From 25ed79d8303afabd873132569d6dc282886ad7d6 Mon Sep 17 00:00:00 2001 From: Chia-I Wu Date: Fri, 1 Oct 2010 00:10:03 +0800 Subject: Revert "egl: Drop broken _EGL_PLATFORM_NO_OS code" This reverts commit 021a68b7e83259faedacea8b3a18e754bed6277a. --- src/egl/main/egldriver.c | 30 ++++++++++++++++++++++++++++++ 1 file changed, 30 insertions(+) diff --git a/src/egl/main/egldriver.c b/src/egl/main/egldriver.c index ff0011c4b15..7790436489e 100644 --- a/src/egl/main/egldriver.c +++ b/src/egl/main/egldriver.c @@ -86,6 +86,30 @@ library_suffix(void) } +#else /* _EGL_PLATFORM_NO_OS */ + + +typedef void *lib_handle; + +static INLINE void * +open_library(const char *filename) +{ + return (void *) filename; +} + +static INLINE void +close_library(void *lib) +{ +} + + +static const char * +library_suffix(void) +{ + return NULL; +} + + #endif @@ -123,6 +147,8 @@ _eglOpenLibrary(const char *driverPath, lib_handle *handle) else { error = dlerror(); } +#else /* _EGL_PLATFORM_NO_OS */ + mainFunc = (_EGLMain_t) _eglMain; #endif if (!lib) { @@ -501,6 +527,10 @@ _eglAddDefaultDrivers(void) "egl_dri2", "egl_glx" }; +#else /* _EGL_PLATFORM_NO_OS */ + const char *DefaultDriverNames[] = { + "" + }; #endif for (i = 0; i < ARRAY_SIZE(DefaultDriverNames); i++) { -- cgit v1.2.3 From 455a7585de034f3f20f7c4a03fb5695cdf345d8d Mon Sep 17 00:00:00 2001 From: Chia-I Wu Date: Mon, 11 Oct 2010 15:59:27 +0800 Subject: targets/egl-gdi: Optional support for DRM screen. --- src/gallium/targets/egl-gdi/egl-static.c | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/src/gallium/targets/egl-gdi/egl-static.c b/src/gallium/targets/egl-gdi/egl-static.c index da6e5ce3396..ff9735c29b2 100644 --- a/src/gallium/targets/egl-gdi/egl-static.c +++ b/src/gallium/targets/egl-gdi/egl-static.c @@ -28,6 +28,7 @@ #include "common/egl_g3d_loader.h" #include "state_tracker/st_gl_api.h" +#include "state_tracker/drm_driver.h" #include "vg_api.h" #include "target-helpers/inline_sw_helper.h" #include "target-helpers/inline_debug_helper.h" @@ -73,7 +74,11 @@ guess_gl_api(enum st_profile_type profile) static struct pipe_screen * create_drm_screen(const char *name, int fd) { +#if FEATURE_DRM + return driver_descriptor.create_screen(fd); +#else return NULL; +#endif } static struct pipe_screen * -- cgit v1.2.3 From 2e9e27c0f723654d32bbbb7c9da8a9e80a71cb9f Mon Sep 17 00:00:00 2001 From: Chia-I Wu Date: Sun, 10 Oct 2010 14:44:09 -0400 Subject: i915: Free with FREE. --- src/gallium/drivers/i915/i915_resource_buffer.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/gallium/drivers/i915/i915_resource_buffer.c b/src/gallium/drivers/i915/i915_resource_buffer.c index 450203d60a9..d3d6a6752ae 100644 --- a/src/gallium/drivers/i915/i915_resource_buffer.c +++ b/src/gallium/drivers/i915/i915_resource_buffer.c @@ -55,7 +55,7 @@ i915_buffer_destroy(struct pipe_screen *screen, { struct i915_buffer *buffer = i915_buffer(resource); if (buffer->free_on_destroy) - align_free(buffer->data); + FREE(buffer->data); FREE(buffer); } -- cgit v1.2.3 From 88e9712a68eb4944924a37b59ced1beeea11b6ed Mon Sep 17 00:00:00 2001 From: Chia-I Wu Date: Tue, 12 Oct 2010 14:22:31 -0400 Subject: tnl: Add support for GL_FIXED. --- src/mesa/tnl/t_draw.c | 10 ++++++++++ 1 file changed, 10 insertions(+) diff --git a/src/mesa/tnl/t_draw.c b/src/mesa/tnl/t_draw.c index 30f1bf323cb..e2aac64ad74 100644 --- a/src/mesa/tnl/t_draw.c +++ b/src/mesa/tnl/t_draw.c @@ -174,6 +174,16 @@ static void _tnl_import_array( struct gl_context *ctx, case GL_HALF_FLOAT: convert_half_to_float(input, ptr, fptr, count, sz); break; + case GL_FIXED: + { + GLuint i, j; + for (i = 0; i < count; i++) { + const GLint *in = (GLint *) (ptr + i * input->StrideB); + for (j = 0; j < sz; j++) + *fptr++ = *in++ / 65536.0f; + } + } + break; default: assert(0); break; -- cgit v1.2.3 From 7aceb74db73e72f13328672733836818e3979052 Mon Sep 17 00:00:00 2001 From: Chia-I Wu Date: Tue, 12 Oct 2010 14:26:52 -0400 Subject: i915c: Add GL_OES_draw_texture support. --- src/mesa/drivers/common/meta.c | 143 ++++++++++++++++++++++ src/mesa/drivers/common/meta.h | 3 + src/mesa/drivers/dri/intel/intel_context.c | 1 + src/mesa/drivers/dri/intel/intel_extensions.h | 3 + src/mesa/drivers/dri/intel/intel_extensions_es2.c | 14 +++ src/mesa/drivers/dri/intel/intel_tex.c | 2 + 6 files changed, 166 insertions(+) diff --git a/src/mesa/drivers/common/meta.c b/src/mesa/drivers/common/meta.c index 95accc1813d..5e0e9a12df2 100644 --- a/src/mesa/drivers/common/meta.c +++ b/src/mesa/drivers/common/meta.c @@ -267,6 +267,16 @@ struct gen_mipmap_state }; +/** + * State for glDrawTex() + */ +struct drawtex_state +{ + GLuint ArrayObj; + GLuint VBO; +}; + + /** * All per-context meta state. */ @@ -282,6 +292,7 @@ struct gl_meta_state struct drawpix_state DrawPix; /**< For _mesa_meta_DrawPixels() */ struct bitmap_state Bitmap; /**< For _mesa_meta_Bitmap() */ struct gen_mipmap_state Mipmap; /**< For _mesa_meta_GenerateMipmap() */ + struct drawtex_state DrawTex; /**< For _mesa_meta_DrawTex() */ }; @@ -2844,3 +2855,135 @@ _mesa_meta_CopyColorSubTable(struct gl_context *ctx,GLenum target, GLsizei start free(buf); } + + +#if FEATURE_OES_draw_texture + + +/** + * Meta implementation of ctx->Driver.DrawTex() in terms + * of polygon rendering. + */ +void +_mesa_meta_DrawTex(struct gl_context *ctx, GLfloat x, GLfloat y, GLfloat z, + GLfloat width, GLfloat height) +{ + struct drawtex_state *drawtex = &ctx->Meta->DrawTex; + struct vertex { + GLfloat x, y, z, st[MAX_TEXTURE_UNITS][2]; + }; + struct vertex verts[4]; + GLuint i; + + _mesa_meta_begin(ctx, (META_RASTERIZATION | + META_SHADER | + META_TRANSFORM | + META_VERTEX | + META_VIEWPORT)); + + if (drawtex->ArrayObj == 0) { + /* one-time setup */ + GLint active_texture; + + /* create vertex array object */ + _mesa_GenVertexArrays(1, &drawtex->ArrayObj); + _mesa_BindVertexArray(drawtex->ArrayObj); + + /* create vertex array buffer */ + _mesa_GenBuffersARB(1, &drawtex->VBO); + _mesa_BindBufferARB(GL_ARRAY_BUFFER_ARB, drawtex->VBO); + _mesa_BufferDataARB(GL_ARRAY_BUFFER_ARB, sizeof(verts), + NULL, GL_DYNAMIC_DRAW_ARB); + + /* client active texture is not part of the array object */ + active_texture = ctx->Array.ActiveTexture; + + /* setup vertex arrays */ + _mesa_VertexPointer(3, GL_FLOAT, sizeof(struct vertex), OFFSET(x)); + _mesa_EnableClientState(GL_VERTEX_ARRAY); + for (i = 0; i < ctx->Const.MaxTextureUnits; i++) { + _mesa_ClientActiveTextureARB(GL_TEXTURE0 + i); + _mesa_TexCoordPointer(2, GL_FLOAT, sizeof(struct vertex), OFFSET(st[i])); + _mesa_EnableClientState(GL_TEXTURE_COORD_ARRAY); + } + + /* restore client active texture */ + _mesa_ClientActiveTextureARB(GL_TEXTURE0 + active_texture); + } + else { + _mesa_BindVertexArray(drawtex->ArrayObj); + _mesa_BindBufferARB(GL_ARRAY_BUFFER_ARB, drawtex->VBO); + } + + /* vertex positions, texcoords */ + { + const GLfloat x1 = x + width; + const GLfloat y1 = y + height; + + z = CLAMP(z, 0.0, 1.0); + z = invert_z(z); + + verts[0].x = x; + verts[0].y = y; + verts[0].z = z; + + verts[1].x = x1; + verts[1].y = y; + verts[1].z = z; + + verts[2].x = x1; + verts[2].y = y1; + verts[2].z = z; + + verts[3].x = x; + verts[3].y = y1; + verts[3].z = z; + + for (i = 0; i < ctx->Const.MaxTextureUnits; i++) { + const struct gl_texture_object *texObj; + const struct gl_texture_image *texImage; + GLfloat s, t, s1, t1; + GLuint tw, th; + + if (!ctx->Texture.Unit[i]._ReallyEnabled) { + GLuint j; + for (j = 0; j < 4; j++) { + verts[j].st[i][0] = 0.0f; + verts[j].st[i][1] = 0.0f; + } + continue; + } + + texObj = ctx->Texture.Unit[i]._Current; + texImage = texObj->Image[0][texObj->BaseLevel]; + tw = texImage->Width2; + th = texImage->Height2; + + s = (GLfloat) texObj->CropRect[0] / tw; + t = (GLfloat) texObj->CropRect[1] / th; + s1 = (GLfloat) (texObj->CropRect[0] + texObj->CropRect[2]) / tw; + t1 = (GLfloat) (texObj->CropRect[1] + texObj->CropRect[3]) / th; + + verts[0].st[i][0] = s; + verts[0].st[i][1] = t; + + verts[1].st[i][0] = s1; + verts[1].st[i][1] = t; + + verts[2].st[i][0] = s1; + verts[2].st[i][1] = t1; + + verts[3].st[i][0] = s; + verts[3].st[i][1] = t1; + } + + _mesa_BufferSubDataARB(GL_ARRAY_BUFFER_ARB, 0, sizeof(verts), verts); + } + + _mesa_DrawArrays(GL_TRIANGLE_FAN, 0, 4); + + _mesa_meta_end(ctx); +} + + +#endif /* FEATURE_OES_draw_texture */ diff --git a/src/mesa/drivers/common/meta.h b/src/mesa/drivers/common/meta.h index b0797d3d91a..889606186b9 100644 --- a/src/mesa/drivers/common/meta.h +++ b/src/mesa/drivers/common/meta.h @@ -114,5 +114,8 @@ _mesa_meta_CopyConvolutionFilter2D(struct gl_context *ctx, GLenum target, GLenum internalFormat, GLint x, GLint y, GLsizei width, GLsizei height); +extern void +_mesa_meta_DrawTex(struct gl_context *ctx, GLfloat x, GLfloat y, GLfloat z, + GLfloat width, GLfloat height); #endif /* META_H */ diff --git a/src/mesa/drivers/dri/intel/intel_context.c b/src/mesa/drivers/dri/intel/intel_context.c index 9c222c7b485..de8a2ce1e94 100644 --- a/src/mesa/drivers/dri/intel/intel_context.c +++ b/src/mesa/drivers/dri/intel/intel_context.c @@ -789,6 +789,7 @@ intelInitContext(struct intel_context *intel, intelInitExtensions(ctx); break; case API_OPENGLES: + intelInitExtensionsES1(ctx); break; case API_OPENGLES2: intelInitExtensionsES2(ctx); diff --git a/src/mesa/drivers/dri/intel/intel_extensions.h b/src/mesa/drivers/dri/intel/intel_extensions.h index fb2a846d39f..9991c000108 100644 --- a/src/mesa/drivers/dri/intel/intel_extensions.h +++ b/src/mesa/drivers/dri/intel/intel_extensions.h @@ -32,6 +32,9 @@ extern void intelInitExtensions(struct gl_context *ctx); +extern void +intelInitExtensionsES1(struct gl_context *ctx); + extern void intelInitExtensionsES2(struct gl_context *ctx); diff --git a/src/mesa/drivers/dri/intel/intel_extensions_es2.c b/src/mesa/drivers/dri/intel/intel_extensions_es2.c index 71c86339c72..4272ed5d9ca 100644 --- a/src/mesa/drivers/dri/intel/intel_extensions_es2.c +++ b/src/mesa/drivers/dri/intel/intel_extensions_es2.c @@ -78,6 +78,20 @@ static const char *es2_extensions[] = { NULL, }; +void +intelInitExtensionsES1(struct gl_context *ctx) +{ + int i; + + /* Can't use driInitExtensions() since it uses extensions from + * main/remap_helper.h when called the first time. */ + + for (i = 0; es2_extensions[i]; i++) + _mesa_enable_extension(ctx, es2_extensions[i]); + + _mesa_enable_extension(ctx, "GL_OES_draw_texture"); +} + /** * Initializes potential list of extensions if ctx == NULL, or actually enables * extensions for a context. diff --git a/src/mesa/drivers/dri/intel/intel_tex.c b/src/mesa/drivers/dri/intel/intel_tex.c index 2c21ea0576e..646e55bdff9 100644 --- a/src/mesa/drivers/dri/intel/intel_tex.c +++ b/src/mesa/drivers/dri/intel/intel_tex.c @@ -120,4 +120,6 @@ intelInitTextureFuncs(struct dd_function_table *functions) functions->NewTextureImage = intelNewTextureImage; functions->DeleteTexture = intelDeleteTextureObject; functions->FreeTexImageData = intelFreeTextureImageData; + + functions->DrawTex = _mesa_meta_DrawTex; } -- cgit v1.2.3 From 17935c0191b4c5adb68dd59df23282caef869875 Mon Sep 17 00:00:00 2001 From: Chia-I Wu Date: Mon, 27 Sep 2010 00:19:43 +0800 Subject: android: Fix build with bionic. --- src/gallium/auxiliary/os/os_thread.h | 2 +- src/gallium/auxiliary/util/u_math.h | 10 ++++++++++ src/gallium/include/pipe/p_compiler.h | 2 ++ src/gallium/include/pipe/p_config.h | 8 ++++++++ src/glsl/ir_reader.cpp | 2 +- src/glsl/link_functions.cpp | 2 +- src/glsl/linker.cpp | 2 +- src/mesa/main/imports.c | 2 +- src/mesa/main/imports.h | 7 +++++++ src/mesa/main/querymatrix.c | 3 ++- src/talloc/talloc.c | 2 +- 11 files changed, 35 insertions(+), 7 deletions(-) diff --git a/src/gallium/auxiliary/os/os_thread.h b/src/gallium/auxiliary/os/os_thread.h index a084310d4ff..64e3869a748 100644 --- a/src/gallium/auxiliary/os/os_thread.h +++ b/src/gallium/auxiliary/os/os_thread.h @@ -306,7 +306,7 @@ typedef int64_t pipe_condvar; * pipe_barrier */ -#if defined(PIPE_OS_LINUX) || defined(PIPE_OS_BSD) || defined(PIPE_OS_SOLARIS) || defined(PIPE_OS_HAIKU) || defined(PIPE_OS_EMBEDDED) +#if (defined(PIPE_OS_LINUX) || defined(PIPE_OS_BSD) || defined(PIPE_OS_SOLARIS) || defined(PIPE_OS_HAIKU) || defined(PIPE_OS_EMBEDDED)) && !defined(PIPE_OS_ANDROID) typedef pthread_barrier_t pipe_barrier; diff --git a/src/gallium/auxiliary/util/u_math.h b/src/gallium/auxiliary/util/u_math.h index 37294b7203f..cfcb9cd857b 100644 --- a/src/gallium/auxiliary/util/u_math.h +++ b/src/gallium/auxiliary/util/u_math.h @@ -187,6 +187,16 @@ static INLINE double log2( double x ) #endif /* _MSC_VER */ +#ifdef PIPE_OS_ANDROID + +static INLINE +double log2(double d) +{ + return log(d) / M_LN2; +} + +#endif + diff --git a/src/gallium/include/pipe/p_compiler.h b/src/gallium/include/pipe/p_compiler.h index 3d6b5b5c81d..a842d541eb2 100644 --- a/src/gallium/include/pipe/p_compiler.h +++ b/src/gallium/include/pipe/p_compiler.h @@ -67,7 +67,9 @@ extern "C" { #if !defined(__HAIKU__) && !defined(__USE_MISC) +#if !defined(PIPE_OS_ANDROID) typedef unsigned int uint; +#endif typedef unsigned short ushort; #endif typedef unsigned char ubyte; diff --git a/src/gallium/include/pipe/p_config.h b/src/gallium/include/pipe/p_config.h index 74a1fa29781..988430c11d4 100644 --- a/src/gallium/include/pipe/p_config.h +++ b/src/gallium/include/pipe/p_config.h @@ -133,6 +133,14 @@ #define PIPE_OS_UNIX #endif +/* + * Android defines __linux__ so PIPE_OS_LINUX and PIPE_OS_UNIX will also be + * defined. + */ +#if defined(ANDROID) +#define PIPE_OS_ANDROID +#endif + #if defined(__FreeBSD__) #define PIPE_OS_FREEBSD #define PIPE_OS_BSD diff --git a/src/glsl/ir_reader.cpp b/src/glsl/ir_reader.cpp index 5a718d3b756..b9d9d8639f5 100644 --- a/src/glsl/ir_reader.cpp +++ b/src/glsl/ir_reader.cpp @@ -21,9 +21,9 @@ * DEALINGS IN THE SOFTWARE. */ -#include extern "C" { +#include #include } diff --git a/src/glsl/link_functions.cpp b/src/glsl/link_functions.cpp index 05930edb80e..c6339abf237 100644 --- a/src/glsl/link_functions.cpp +++ b/src/glsl/link_functions.cpp @@ -23,9 +23,9 @@ #include #include -#include extern "C" { +#include #include } diff --git a/src/glsl/linker.cpp b/src/glsl/linker.cpp index e62fe6d7e9f..a219ab7e66c 100644 --- a/src/glsl/linker.cpp +++ b/src/glsl/linker.cpp @@ -65,10 +65,10 @@ */ #include #include -#include #include extern "C" { +#include #include } diff --git a/src/mesa/main/imports.c b/src/mesa/main/imports.c index cefbf4d8c98..d662e055b29 100644 --- a/src/mesa/main/imports.c +++ b/src/mesa/main/imports.c @@ -757,7 +757,7 @@ _mesa_strdup( const char *s ) float _mesa_strtof( const char *s, char **end ) { -#if defined(_GNU_SOURCE) && !defined(__CYGWIN__) && !defined(__FreeBSD__) +#if defined(_GNU_SOURCE) && !defined(__CYGWIN__) && !defined(__FreeBSD__) && !defined(ANDROID) static locale_t loc = NULL; if (!loc) { loc = newlocale(LC_CTYPE_MASK, "C", NULL); diff --git a/src/mesa/main/imports.h b/src/mesa/main/imports.h index 5ea647ad8d7..c0686efed28 100644 --- a/src/mesa/main/imports.h +++ b/src/mesa/main/imports.h @@ -116,6 +116,7 @@ typedef union { GLfloat f; GLint i; } fi_type; #endif + /** * \name Work-arounds for platforms that lack C99 math functions */ @@ -134,7 +135,13 @@ typedef union { GLfloat f; GLint i; } fi_type; #define exp2f(f) ((float) exp2(f)) #define floorf(f) ((float) floor(f)) #define logf(f) ((float) log(f)) + +#ifdef ANDROID +#define log2f(f) ((float) (log(f) / M_LN2)) +#else #define log2f(f) ((float) log2(f)) +#endif + #define powf(x,y) ((float) pow(x,y)) #define sinf(f) ((float) sin(f)) #define sinhf(f) ((float) sinh(f)) diff --git a/src/mesa/main/querymatrix.c b/src/mesa/main/querymatrix.c index 944ad435f7a..11c7b0669d0 100644 --- a/src/mesa/main/querymatrix.c +++ b/src/mesa/main/querymatrix.c @@ -73,7 +73,8 @@ fpclassify(double x) #elif defined(__APPLE__) || defined(__CYGWIN__) || defined(__FreeBSD__) || \ defined(__OpenBSD__) || defined(__NetBSD__) || defined(__DragonFly__) || \ (defined(__sun) && defined(__C99FEATURES__)) || defined(__MINGW32__) || \ - (defined(__sun) && defined(__GNUC__)) + (defined(__sun) && defined(__GNUC__)) || \ + defined(ANDROID) /* fpclassify is available. */ diff --git a/src/talloc/talloc.c b/src/talloc/talloc.c index cc01346a7f0..ea77684f7b9 100644 --- a/src/talloc/talloc.c +++ b/src/talloc/talloc.c @@ -56,7 +56,7 @@ static size_t strnlen (const char* s, size_t n) #endif /* Visual C++ 2008 & Xcode/gcc4.0 compatibility */ -#if !defined(_cplusplus) && (defined(WIN32) || defined(__APPLE__)) +#if !defined(_cplusplus) && (defined(WIN32) || defined(__APPLE__) || defined(ANDROID)) typedef int bool; #define false 0 #define true 1 -- cgit v1.2.3 From bf21df37c65a959269180ebc215447e2e6bd38fc Mon Sep 17 00:00:00 2001 From: Chia-I Wu Date: Fri, 8 Oct 2010 23:08:34 -0400 Subject: android: Use __mmap2 in winsys/svga. --- src/gallium/winsys/svga/drm/vmw_screen_ioctl.c | 22 ++++++++++++++++++++-- 1 file changed, 20 insertions(+), 2 deletions(-) diff --git a/src/gallium/winsys/svga/drm/vmw_screen_ioctl.c b/src/gallium/winsys/svga/drm/vmw_screen_ioctl.c index d92ba389d35..847f2c789ba 100644 --- a/src/gallium/winsys/svga/drm/vmw_screen_ioctl.c +++ b/src/gallium/winsys/svga/drm/vmw_screen_ioctl.c @@ -46,6 +46,24 @@ #include #include +#ifdef PIPE_OS_ANDROID +extern void* __mmap2(void*, size_t, int, int, int, size_t); + +#define MMAP2_SHIFT 12 +static INLINE void* vmw_mmap(void *addr, size_t size, int prot, int flags, int fd, unsigned long long offset) +{ + if ( offset & ((1UL << MMAP2_SHIFT)-1) ) { + errno = EINVAL; + return MAP_FAILED; + } + + return __mmap2(addr, size, prot, flags, fd, (size_t)(offset >> MMAP2_SHIFT)); +} + +#else +#define vmw_mmap(addr, size, prot, flags, fd, offset) mmap(addr, size, prot, flags, fd, offset) +#endif + struct vmw_region { SVGAGuestPtr ptr; @@ -106,7 +124,7 @@ vmw_ioctl_fifo_map(struct vmw_winsys_screen *vws, VMW_FUNC; - map = mmap(NULL, getpagesize(), PROT_READ, MAP_SHARED, + map = vmw_mmap(NULL, getpagesize(), PROT_READ, MAP_SHARED, vws->ioctl.drm_fd, fifo_offset); if (map == MAP_FAILED) { @@ -388,7 +406,7 @@ vmw_ioctl_region_map(struct vmw_region *region) region->ptr.gmrId, region->ptr.offset); if (region->data == NULL) { - map = mmap(NULL, region->size, PROT_READ | PROT_WRITE, MAP_SHARED, + map = vmw_mmap(NULL, region->size, PROT_READ | PROT_WRITE, MAP_SHARED, region->drm_fd, region->map_handle); if (map == MAP_FAILED) { debug_printf("%s: Map failed.\n", __FUNCTION__); -- cgit v1.2.3 From 017c563cff3b70a708deeffa3945f51f6a2f1151 Mon Sep 17 00:00:00 2001 From: Chia-I Wu Date: Fri, 1 Oct 2010 16:55:42 -0400 Subject: android: Fix GL_OES_EGL_image with SurfaceFlinger. --- src/gallium/drivers/softpipe/sp_flush.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/gallium/drivers/softpipe/sp_flush.c b/src/gallium/drivers/softpipe/sp_flush.c index 4258395063b..3a09ee8b4f7 100644 --- a/src/gallium/drivers/softpipe/sp_flush.c +++ b/src/gallium/drivers/softpipe/sp_flush.c @@ -50,7 +50,7 @@ softpipe_flush( struct pipe_context *pipe, draw_flush(softpipe->draw); - if (flags & PIPE_FLUSH_TEXTURE_CACHE) { + if (1 || (flags & PIPE_FLUSH_TEXTURE_CACHE)) { for (i = 0; i < softpipe->num_sampler_views; i++) { sp_flush_tex_tile_cache(softpipe->tex_cache[i]); } -- cgit v1.2.3 From 3fe7753b70ab4ee5a85ca482ef50d659a2ae1583 Mon Sep 17 00:00:00 2001 From: Chia-I Wu Date: Tue, 12 Oct 2010 13:39:03 -0400 Subject: android: Fix depth/stencil with i915c. --- src/mesa/drivers/dri/intel/intel_context.c | 26 ++++++++++++++++++++++++++ 1 file changed, 26 insertions(+) diff --git a/src/mesa/drivers/dri/intel/intel_context.c b/src/mesa/drivers/dri/intel/intel_context.c index de8a2ce1e94..968f3c6e466 100644 --- a/src/mesa/drivers/dri/intel/intel_context.c +++ b/src/mesa/drivers/dri/intel/intel_context.c @@ -420,6 +420,32 @@ intel_update_renderbuffers(__DRIcontext *context, __DRIdrawable *drawable) } } +#ifdef ANDROID + depth_rb = intel_get_renderbuffer(fb, BUFFER_DEPTH); + stencil_rb = intel_get_renderbuffer(fb, BUFFER_STENCIL); + rb = NULL; + if (depth_rb && !depth_rb->region) + rb = depth_rb; + else if (stencil_rb && !stencil_rb->region) + rb = stencil_rb; + if (rb) { + uint32_t tiling = I915_TILING_NONE; + + /* Gen6 requires depth must be tiling */ + if (intel->gen >= 6 && rb->Base.Format == MESA_FORMAT_S8_Z24) + tiling = I915_TILING_Y; + + region = intel_region_alloc(intel->intelScreen, tiling, + _mesa_get_format_bytes(rb->Base.Format), + drawable->w, drawable->h, GL_TRUE); + intel_renderbuffer_set_region(intel, rb, region); + intel_region_release(®ion); + } + + if (stencil_rb && !stencil_rb->region) + intel_renderbuffer_set_region(intel, stencil_rb, depth_rb->region); +#endif + driUpdateFramebufferSize(&intel->ctx, drawable); } -- cgit v1.2.3 From 6719d59a85958712425ade241606a8d632f4357d Mon Sep 17 00:00:00 2001 From: Chia-I Wu Date: Wed, 20 Oct 2010 11:44:36 -0400 Subject: android: Enable extensions required by ES1 for i915c. --- src/mesa/drivers/dri/intel/intel_extensions_es2.c | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/src/mesa/drivers/dri/intel/intel_extensions_es2.c b/src/mesa/drivers/dri/intel/intel_extensions_es2.c index 4272ed5d9ca..54b0517deb9 100644 --- a/src/mesa/drivers/dri/intel/intel_extensions_es2.c +++ b/src/mesa/drivers/dri/intel/intel_extensions_es2.c @@ -89,6 +89,11 @@ intelInitExtensionsES1(struct gl_context *ctx) for (i = 0; es2_extensions[i]; i++) _mesa_enable_extension(ctx, es2_extensions[i]); + _mesa_enable_extension(ctx, "GL_ARB_texture_env_add"); + _mesa_enable_extension(ctx, "GL_ARB_texture_env_combine"); + _mesa_enable_extension(ctx, "GL_ARB_texture_env_dot3"); + _mesa_enable_extension(ctx, "GL_ARB_point_parameters"); + _mesa_enable_extension(ctx, "GL_OES_draw_texture"); } -- cgit v1.2.3 From 13375514519e00fc6598b30055d7320553f8b676 Mon Sep 17 00:00:00 2001 From: Chia-I Wu Date: Mon, 11 Oct 2010 16:09:52 +0800 Subject: android: Add _EGL_PLATFORM_ANDROID. --- include/EGL/eglplatform.h | 9 +++++++++ src/egl/main/egldisplay.c | 3 ++- src/egl/main/egldisplay.h | 1 + 3 files changed, 12 insertions(+), 1 deletion(-) diff --git a/include/EGL/eglplatform.h b/include/EGL/eglplatform.h index 33a3e5f8891..22a263f522a 100644 --- a/include/EGL/eglplatform.h +++ b/include/EGL/eglplatform.h @@ -78,6 +78,15 @@ typedef int EGLNativeDisplayType; typedef void *EGLNativeWindowType; typedef void *EGLNativePixmapType; +#elif defined(ANDROID) /* Android */ + +struct android_native_window_t; +struct egl_native_pixmap_t; + +typedef struct android_native_window_t* EGLNativeWindowType; +typedef struct egl_native_pixmap_t* EGLNativePixmapType; +typedef void* EGLNativeDisplayType; + #elif defined(__unix__) || defined(__unix) #ifdef MESA_EGL_NO_X11_HEADERS diff --git a/src/egl/main/egldisplay.c b/src/egl/main/egldisplay.c index 565e44d2d23..cabf1d40fee 100644 --- a/src/egl/main/egldisplay.c +++ b/src/egl/main/egldisplay.c @@ -28,7 +28,8 @@ _eglGetNativePlatformFromEnv(void) { _EGL_PLATFORM_WINDOWS, "gdi" }, { _EGL_PLATFORM_X11, "x11" }, { _EGL_PLATFORM_DRM, "drm" }, - { _EGL_PLATFORM_FBDEV, "fbdev" } + { _EGL_PLATFORM_FBDEV, "fbdev" }, + { _EGL_PLATFORM_ANDROID, "android" } }; _EGLPlatformType plat = _EGL_INVALID_PLATFORM; const char *plat_name; diff --git a/src/egl/main/egldisplay.h b/src/egl/main/egldisplay.h index bcba05480a8..054c138c9ea 100644 --- a/src/egl/main/egldisplay.h +++ b/src/egl/main/egldisplay.h @@ -13,6 +13,7 @@ enum _egl_platform_type { _EGL_PLATFORM_X11, _EGL_PLATFORM_DRM, _EGL_PLATFORM_FBDEV, + _EGL_PLATFORM_ANDROID, _EGL_NUM_PLATFORMS, _EGL_INVALID_PLATFORM = -1 -- cgit v1.2.3 From 0d4dcb25842739d586debb3472ceb90589fe741b Mon Sep 17 00:00:00 2001 From: Chia-I Wu Date: Fri, 1 Oct 2010 15:27:42 -0400 Subject: android: Add Android EGL extensions. --- include/EGL/eglext.h | 22 ++++++++++++++++++++ src/egl/main/eglapi.c | 52 +++++++++++++++++++++++++++++++++++++++++++++++ src/egl/main/eglapi.h | 15 ++++++++++++++ src/egl/main/egldisplay.h | 4 ++++ src/egl/main/eglmisc.c | 4 ++++ 5 files changed, 97 insertions(+) diff --git a/include/EGL/eglext.h b/include/EGL/eglext.h index 04603931b38..891152572d0 100644 --- a/include/EGL/eglext.h +++ b/include/EGL/eglext.h @@ -376,6 +376,28 @@ typedef EGLBoolean (EGLAPIENTRYP PFNEGLSWAPBUFFERSREGIONNOK) (EGLDisplay dpy, EG #define EGL_Y_INVERTED_NOK 0x307F #endif /* EGL_NOK_texture_from_pixmap */ +#ifndef EGL_ANDROID_image_native_buffer +#define EGL_ANDROID_image_native_buffer 1 +struct android_native_buffer_t; +#define EGL_NATIVE_BUFFER_ANDROID 0x3140 /* eglCreateImageKHR target */ +#endif + +#ifndef EGL_ANDROID_get_render_buffer +#define EGL_ANDROID_get_render_buffer 1 +#ifdef EGL_EGLEXT_PROTOTYPES +EGLAPI EGLClientBuffer EGLAPIENTRY eglGetRenderBufferANDROID(EGLDisplay dpy, EGLSurface draw); +#endif +typedef EGLClientBuffer (EGLAPIENTRYP PFNEGLGETRENDERBUFFERANDROIDPROC) (EGLDisplay dpy, EGLSurface draw); +#endif + +#ifndef EGL_ANDROID_swap_rectangle +#define EGL_ANDROID_swap_rectangle 1 +#ifdef EGL_EGLEXT_PROTOTYPES +EGLAPI EGLBoolean EGLAPIENTRY eglSetSwapRectangleANDROID (EGLDisplay dpy, EGLSurface draw, EGLint left, EGLint top, EGLint width, EGLint height); +#endif /* EGL_EGLEXT_PROTOTYPES */ +typedef EGLBoolean (EGLAPIENTRYP PFNEGLSETSWAPRECTANGLEANDROIDPROC) (EGLDisplay dpy, EGLSurface draw, EGLint left, EGLint top, EGLint width, EGLint height); +#endif + #ifdef __cplusplus } diff --git a/src/egl/main/eglapi.c b/src/egl/main/eglapi.c index efa9e97346b..c339e6ebebd 100644 --- a/src/egl/main/eglapi.c +++ b/src/egl/main/eglapi.c @@ -916,6 +916,12 @@ eglGetProcAddress(const char *procname) #ifdef EGL_MESA_drm_image { "eglCreateDRMImageMESA", (_EGLProc) eglCreateDRMImageMESA }, { "eglExportDRMImageMESA", (_EGLProc) eglExportDRMImageMESA }, +#endif +#ifdef EGL_ANDROID_swap_rectangle + { "eglSetSwapRectangleANDROID", (_EGLProc) eglSetSwapRectangleANDROID }, +#endif +#ifdef EGL_ANDROID_get_render_buffer + { "eglGetRenderBufferANDROID", (_EGLProc) eglGetRenderBufferANDROID }, #endif { NULL, NULL } }; @@ -1494,3 +1500,49 @@ eglExportDRMImageMESA(EGLDisplay dpy, EGLImageKHR image, } #endif + +#ifdef EGL_ANDROID_swap_rectangle + +EGLBoolean EGLAPIENTRY +eglSetSwapRectangleANDROID(EGLDisplay dpy, EGLSurface draw, + EGLint left, EGLint top, + EGLint width, EGLint height) +{ + _EGLDisplay *disp = _eglLockDisplay(dpy); + _EGLSurface *surf = _eglLookupSurface(draw, disp); + _EGLDriver *drv; + EGLBoolean ret; + + _EGL_CHECK_SURFACE(disp, surf, EGL_FALSE, drv); + + if (!disp->Extensions.ANDROID_swap_rectangle) + RETURN_EGL_EVAL(disp, EGL_FALSE); + + ret = drv->API.SetSwapRectangleANDROID(drv, disp, surf, left, top, width, height); + + RETURN_EGL_EVAL(disp, ret); +} + +#endif + +#ifdef EGL_ANDROID_get_render_buffer + +EGLClientBuffer EGLAPIENTRY +eglGetRenderBufferANDROID(EGLDisplay dpy, EGLSurface draw) +{ + _EGLDisplay *disp = _eglLockDisplay(dpy); + _EGLSurface *surf = _eglLookupSurface(draw, disp); + _EGLDriver *drv; + EGLClientBuffer ret; + + _EGL_CHECK_SURFACE(disp, surf, NULL, drv); + + if (!disp->Extensions.ANDROID_get_render_buffer) + RETURN_EGL_EVAL(disp, NULL); + + ret = drv->API.GetRenderBufferANDROID(drv, disp, surf); + + RETURN_EGL_EVAL(disp, ret); +} + +#endif diff --git a/src/egl/main/eglapi.h b/src/egl/main/eglapi.h index 127becc9acd..96db72c70f5 100644 --- a/src/egl/main/eglapi.h +++ b/src/egl/main/eglapi.h @@ -95,6 +95,14 @@ typedef _EGLImage *(*CreateDRMImageMESA_t)(_EGLDriver *drv, _EGLDisplay *disp, c typedef EGLBoolean (*ExportDRMImageMESA_t)(_EGLDriver *drv, _EGLDisplay *disp, _EGLImage *img, EGLint *name, EGLint *handle, EGLint *stride); #endif +#ifdef EGL_ANDROID_swap_rectangle +typedef EGLBoolean (*SetSwapRectangleANDROID_t)(_EGLDriver *drv, _EGLDisplay *disp, _EGLSurface *draw, EGLint left, EGLint top, EGLint width, EGLint height); +#endif + +#ifdef EGL_ANDROID_get_render_buffer +typedef EGLClientBuffer (*GetRenderBufferANDROID_t)(_EGLDriver *drv, _EGLDisplay *disp, _EGLSurface *draw); +#endif + /** * The API dispatcher jumps through these functions */ @@ -169,6 +177,13 @@ struct _egl_api CreateDRMImageMESA_t CreateDRMImageMESA; ExportDRMImageMESA_t ExportDRMImageMESA; #endif + +#ifdef EGL_ANDROID_swap_rectangle + SetSwapRectangleANDROID_t SetSwapRectangleANDROID; +#endif +#ifdef EGL_ANDROID_get_render_buffer + GetRenderBufferANDROID_t GetRenderBufferANDROID; +#endif }; #endif /* EGLAPI_INCLUDED */ diff --git a/src/egl/main/egldisplay.h b/src/egl/main/egldisplay.h index 054c138c9ea..b409ade827e 100644 --- a/src/egl/main/egldisplay.h +++ b/src/egl/main/egldisplay.h @@ -76,6 +76,10 @@ struct _egl_extensions EGLBoolean NOK_swap_region; EGLBoolean NOK_texture_from_pixmap; + EGLBoolean ANDROID_image_native_buffer; + EGLBoolean ANDROID_swap_rectangle; + EGLBoolean ANDROID_get_render_buffer; + char String[_EGL_MAX_EXTENSIONS_LEN]; }; diff --git a/src/egl/main/eglmisc.c b/src/egl/main/eglmisc.c index bbb96a908e4..de20d249c3a 100644 --- a/src/egl/main/eglmisc.c +++ b/src/egl/main/eglmisc.c @@ -107,6 +107,10 @@ _eglUpdateExtensionsString(_EGLDisplay *dpy) _EGL_CHECK_EXTENSION(NOK_swap_region); _EGL_CHECK_EXTENSION(NOK_texture_from_pixmap); + + _EGL_CHECK_EXTENSION(ANDROID_image_native_buffer); + _EGL_CHECK_EXTENSION(ANDROID_swap_rectangle); + _EGL_CHECK_EXTENSION(ANDROID_get_render_buffer); #undef _EGL_CHECK_EXTENSION } -- cgit v1.2.3 From 8148db591a7b0e7a51f664930301cc8d774a90a8 Mon Sep 17 00:00:00 2001 From: Chia-I Wu Date: Mon, 11 Oct 2010 16:30:03 +0800 Subject: android: Add android backend for st/egl. --- .../state_trackers/egl/android/native_android.cpp | 679 +++++++++++++++++++++ src/gallium/state_trackers/egl/common/egl_g3d.c | 11 + src/gallium/state_trackers/egl/common/egl_g3d.h | 3 + .../state_trackers/egl/common/egl_g3d_image.c | 83 +++ src/gallium/state_trackers/egl/common/native.h | 3 + .../winsys/sw/android/android_sw_winsys.cpp | 269 ++++++++ src/gallium/winsys/sw/android/android_sw_winsys.h | 49 ++ 7 files changed, 1097 insertions(+) create mode 100644 src/gallium/state_trackers/egl/android/native_android.cpp create mode 100644 src/gallium/winsys/sw/android/android_sw_winsys.cpp create mode 100644 src/gallium/winsys/sw/android/android_sw_winsys.h diff --git a/src/gallium/state_trackers/egl/android/native_android.cpp b/src/gallium/state_trackers/egl/android/native_android.cpp new file mode 100644 index 00000000000..450eae3868c --- /dev/null +++ b/src/gallium/state_trackers/egl/android/native_android.cpp @@ -0,0 +1,679 @@ +/* + * Mesa 3-D graphics library + * Version: 7.9 + * + * Copyright (C) 2010 LunarG Inc. + * + * Permission is hereby granted, free of charge, to any person obtaining a + * copy of this software and associated documentation files (the "Software"), + * to deal in the Software without restriction, including without limitation + * the rights to use, copy, modify, merge, publish, distribute, sublicense, + * and/or sell copies of the Software, and to permit persons to whom the + * Software is furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included + * in all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL + * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING + * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER + * DEALINGS IN THE SOFTWARE. + * + * Authors: + * Chia-I Wu + */ + +#define LOG_TAG "MESA-EGL" +#include +#include +#include +#include + +extern "C" { +#include "egllog.h" +} +#include "util/u_memory.h" +#include "util/u_inlines.h" +#include "util/u_format.h" +#include "common/native.h" +#include "common/native_helper.h" +#include "android/android_sw_winsys.h" +#include "state_tracker/drm_driver.h" + +struct android_config; + +struct android_display { + struct native_display base; + + boolean use_drm; + struct native_event_handler *event_handler; + struct android_config *configs; + int num_configs; +}; + +struct android_surface { + struct native_surface base; + + struct android_display *adpy; + android_native_window_t *win; + + uint stamp; + android_native_buffer_t *buf; + struct pipe_resource *res; + + /* cache the current front and back resources */ + void *cache_handles[2]; + struct pipe_resource *cache_resources[2]; +}; + +struct android_config { + struct native_config base; +}; + +static INLINE struct android_display * +android_display(const struct native_display *ndpy) +{ + return (struct android_display *) ndpy; +} + +static INLINE struct android_surface * +android_surface(const struct native_surface *nsurf) +{ + return (struct android_surface *) nsurf; +} + +static INLINE struct android_config * +android_config(const struct native_config *nconf) +{ + return (struct android_config *) nconf; +} + +namespace android { + +static enum pipe_format +get_pipe_format(int native) +{ + enum pipe_format fmt; + + /* see libpixelflinger/format.cpp */ + switch (native) { + case PIXEL_FORMAT_RGBA_8888: + fmt = PIPE_FORMAT_R8G8B8A8_UNORM; + break; + case PIXEL_FORMAT_RGBX_8888: + fmt = PIPE_FORMAT_R8G8B8X8_UNORM; + break; + case PIXEL_FORMAT_RGB_888: + fmt = PIPE_FORMAT_R8G8B8_UNORM; + break; + case PIXEL_FORMAT_RGB_565: + fmt = PIPE_FORMAT_B5G6R5_UNORM; + break; + case PIXEL_FORMAT_BGRA_8888: + fmt = PIPE_FORMAT_B8G8R8A8_UNORM; + break; + case PIXEL_FORMAT_A_8: + fmt = PIPE_FORMAT_A8_UNORM; + break; + case PIXEL_FORMAT_L_8: + fmt = PIPE_FORMAT_L8_UNORM; + break; + case PIXEL_FORMAT_LA_88: + fmt = PIPE_FORMAT_L8A8_UNORM; + break; + case PIXEL_FORMAT_NONE: + case PIXEL_FORMAT_RGBA_5551: + case PIXEL_FORMAT_RGBA_4444: + case PIXEL_FORMAT_RGB_332: + default: + LOGE("unsupported native format 0x%x", native); + fmt = PIPE_FORMAT_NONE; + break; + } + + return fmt; +} + +#include +static int +get_handle_name(buffer_handle_t handle) +{ + struct drm_bo_t *bo; + + bo = drm_gem_get(handle); + + return (bo) ? bo->name : 0; +} + +static struct pipe_resource * +import_buffer(struct android_display *adpy, const struct pipe_resource *templ, + struct android_native_buffer_t *abuf) +{ + struct pipe_screen *screen = adpy->base.screen; + struct pipe_resource *res; + + if (templ->bind & PIPE_BIND_RENDER_TARGET) { + if (!screen->is_format_supported(screen, templ->format, + templ->target, 0, PIPE_BIND_RENDER_TARGET, 0)) + LOGW("importing unsupported buffer as render target"); + } + if (templ->bind & PIPE_BIND_SAMPLER_VIEW) { + if (!screen->is_format_supported(screen, templ->format, + templ->target, 0, PIPE_BIND_SAMPLER_VIEW, 0)) + LOGW("importing unsupported buffer as sampler view"); + } + + if (adpy->use_drm) { + struct winsys_handle handle; + + memset(&handle, 0, sizeof(handle)); + handle.type = DRM_API_HANDLE_TYPE_SHARED; + handle.handle = get_handle_name(abuf->handle); + if (!handle.handle) { + LOGE("unable to import invalid buffer %p", abuf); + return NULL; + } + + handle.stride = + abuf->stride * util_format_get_blocksize(templ->format); + + res = screen->resource_from_handle(screen, templ, &handle); + } + else { + struct android_winsys_handle handle; + + memset(&handle, 0, sizeof(handle)); + handle.handle = abuf->handle; + handle.stride = + abuf->stride * util_format_get_blocksize(templ->format); + + res = screen->resource_from_handle(screen, + templ, (struct winsys_handle *) &handle); + } + + if (!res) + LOGE("failed to import buffer %p", abuf); + + return res; +} + +static boolean +android_surface_dequeue_buffer(struct native_surface *nsurf) +{ + struct android_surface *asurf = android_surface(nsurf); + void *handle; + int idx; + + if (asurf->win->dequeueBuffer(asurf->win, &asurf->buf) != NO_ERROR) { + LOGE("failed to dequeue window %p", asurf->win); + return FALSE; + } + + asurf->buf->common.incRef(&asurf->buf->common); + asurf->win->lockBuffer(asurf->win, asurf->buf); + + if (asurf->adpy->use_drm) + handle = (void *) get_handle_name(asurf->buf->handle); + else + handle = (void *) asurf->buf->handle; + /* NULL is invalid */ + if (!handle) { + LOGE("window %p returned an invalid buffer", asurf->win); + return TRUE; + } + + /* find the slot to use */ + for (idx = 0; idx < Elements(asurf->cache_handles); idx++) { + if (asurf->cache_handles[idx] == handle || !asurf->cache_handles[idx]) + break; + } + if (idx == Elements(asurf->cache_handles)) { + /* buffer reallocated; clear the cache */ + for (idx = 0; idx < Elements(asurf->cache_handles); idx++) { + asurf->cache_handles[idx] = 0; + pipe_resource_reference(&asurf->cache_resources[idx], NULL); + } + idx = 0; + } + + /* update the cache */ + if (!asurf->cache_handles[idx]) { + struct pipe_resource templ; + + assert(!asurf->cache_resources[idx]); + + memset(&templ, 0, sizeof(templ)); + templ.target = PIPE_TEXTURE_2D; + templ.last_level = 0; + templ.width0 = asurf->buf->width; + templ.height0 = asurf->buf->height; + templ.depth0 = 1; + templ.bind = PIPE_BIND_RENDER_TARGET; + if (!asurf->adpy->use_drm) { + templ.bind |= PIPE_BIND_TRANSFER_WRITE | + PIPE_BIND_TRANSFER_READ; + } + + templ.format = get_pipe_format(asurf->buf->format); + if (templ.format != PIPE_FORMAT_NONE) { + asurf->cache_resources[idx] = + import_buffer(asurf->adpy, &templ, asurf->buf); + } + else { + asurf->cache_resources[idx] = NULL; + } + + asurf->cache_handles[idx] = handle; + } + + pipe_resource_reference(&asurf->res, asurf->cache_resources[idx]); + + return TRUE; +} + +static boolean +android_surface_enqueue_buffer(struct native_surface *nsurf) +{ + struct android_surface *asurf = android_surface(nsurf); + + pipe_resource_reference(&asurf->res, NULL); + + asurf->win->queueBuffer(asurf->win, asurf->buf); + + asurf->buf->common.decRef(&asurf->buf->common); + asurf->buf = NULL; + + return TRUE; +} + +static boolean +android_surface_swap_buffers(struct native_surface *nsurf) +{ + struct android_surface *asurf = android_surface(nsurf); + struct android_display *adpy = asurf->adpy; + + if (!asurf->buf) + return FALSE; + + android_surface_enqueue_buffer(&asurf->base); + + asurf->stamp++; + adpy->event_handler->invalid_surface(&adpy->base, + &asurf->base, asurf->stamp); + + return TRUE; +} + +static boolean +android_surface_present(struct native_surface *nsurf, + enum native_attachment natt, + boolean preserve, + uint swap_interval) +{ + boolean ret; + + if (swap_interval || natt != NATIVE_ATTACHMENT_BACK_LEFT) + return FALSE; + + return android_surface_swap_buffers(nsurf); +} + +static boolean +android_surface_validate(struct native_surface *nsurf, uint attachment_mask, + unsigned int *seq_num, struct pipe_resource **textures, + int *width, int *height) +{ + struct android_surface *asurf = android_surface(nsurf); + struct winsys_handle handle; + + if (!asurf->buf) { + if (!android_surface_dequeue_buffer(&asurf->base)) + return FALSE; + } + + if (textures) { + const enum native_attachment att = NATIVE_ATTACHMENT_BACK_LEFT; + + if (native_attachment_mask_test(attachment_mask, att)) { + textures[att] = NULL; + pipe_resource_reference(&textures[att], asurf->res); + } + } + + if (seq_num) + *seq_num = asurf->stamp; + if (width) + *width = asurf->buf->width; + if (height) + *height = asurf->buf->height; + + return TRUE; +} + +static void +android_surface_wait(struct native_surface *nsurf) +{ +} + +static void +android_surface_destroy(struct native_surface *nsurf) +{ + struct android_surface *asurf = android_surface(nsurf); + int i; + + if (asurf->buf) + android_surface_enqueue_buffer(&asurf->base); + + for (i = 0; i < Elements(asurf->cache_handles); i++) + pipe_resource_reference(&asurf->cache_resources[i], NULL); + + asurf->win->common.decRef(&asurf->win->common); + + FREE(asurf); +} + +static struct native_surface * +android_display_create_window_surface(struct native_display *ndpy, + EGLNativeWindowType win, + const struct native_config *nconf) +{ + struct android_display *adpy = android_display(ndpy); + struct android_config *aconf = android_config(nconf); + struct android_surface *asurf; + enum pipe_format format; + int val; + + if (win->common.magic != ANDROID_NATIVE_WINDOW_MAGIC) { + LOGE("invalid native window with magic 0x%x", win->common.magic); + return NULL; + } + if (win->query(win, NATIVE_WINDOW_FORMAT, &val)) { + LOGE("failed to query native window format"); + return NULL; + } + format = get_pipe_format(val); + if (format != nconf->color_format) { + LOGW("native window format 0x%x != config format 0x%x", + format, nconf->color_format); + if (!adpy->base.screen->is_format_supported(adpy->base.screen, + format, PIPE_TEXTURE_2D, 0, PIPE_BIND_RENDER_TARGET, 0)) { + LOGE("and the native window cannot be used as a render target"); + return NULL; + } + } + + asurf = CALLOC_STRUCT(android_surface); + if (!asurf) + return NULL; + + asurf->adpy = adpy; + asurf->win = win; + + asurf->win->common.incRef(&asurf->win->common); + if (!adpy->use_drm) { + native_window_set_usage(asurf->win, + GRALLOC_USAGE_SW_READ_OFTEN | GRALLOC_USAGE_SW_WRITE_OFTEN); + } + + asurf->base.destroy = android_surface_destroy; + asurf->base.present = android_surface_present; + asurf->base.validate = android_surface_validate; + asurf->base.wait = android_surface_wait; + + return &asurf->base; +} + +static boolean +android_display_init_configs(struct native_display *ndpy) +{ + struct android_display *adpy = android_display(ndpy); + const int native_formats[] = { + PIXEL_FORMAT_RGBA_8888, + PIXEL_FORMAT_RGBX_8888, + PIXEL_FORMAT_RGB_888, + PIXEL_FORMAT_RGB_565, + PIXEL_FORMAT_BGRA_8888, + PIXEL_FORMAT_A_8 + }; + int i; + + adpy->configs = (struct android_config *) + CALLOC(Elements(native_formats), sizeof(*adpy->configs)); + if (!adpy->configs) + return FALSE; + + for (i = 0; i < Elements(native_formats); i++) { + enum pipe_format color_format; + struct android_config *aconf; + + color_format = get_pipe_format(native_formats[i]); + if (color_format == PIPE_FORMAT_NONE || + !adpy->base.screen->is_format_supported(adpy->base.screen, + color_format, PIPE_TEXTURE_2D, 0, PIPE_BIND_RENDER_TARGET, 0)) { + LOGI("skip unsupported native format 0x%x", native_formats[i]); + continue; + } + + aconf = &adpy->configs[adpy->num_configs++]; + aconf->base.buffer_mask = 1 << NATIVE_ATTACHMENT_BACK_LEFT; + aconf->base.color_format = color_format; + aconf->base.window_bit = TRUE; + if (!adpy->use_drm) + aconf->base.slow_config = TRUE; + + aconf->base.native_visual_type = native_formats[i]; + } + + return TRUE; +} + +static boolean +android_display_init(struct native_display *ndpy) +{ + struct android_display *adpy = android_display(ndpy); + const hw_module_t *mod; + int fd, err; + boolean force_sw; + char value[PROPERTY_VALUE_MAX]; + + if (property_get("debug.mesa.software", value, NULL)) + force_sw = (atoi(value) != 0); + else + force_sw = debug_get_bool_option("EGL_SOFTWARE", FALSE); + + /* try DRM first */ + if (!force_sw) { + err = hw_get_module(GRALLOC_HARDWARE_MODULE_ID, &mod); + if (!err) { + const gralloc_module_t *gr = (gralloc_module_t *) mod; + + err = -EINVAL; + if (gr->perform) + err = gr->perform(gr, GRALLOC_MODULE_PERFORM_GET_DRM_FD, &fd); + } + if (!err && fd >= 0) { + adpy->base.screen = + adpy->event_handler->new_drm_screen(&adpy->base, "i915", fd); + if (adpy->base.screen) + adpy->use_drm = TRUE; + } + + if (adpy->base.screen) + LOGI("using DRM screen"); + else + LOGE("failed to create DRM screen"); + } + + /* try SW screen */ + if (!adpy->base.screen) { + struct sw_winsys *ws = android_create_sw_winsys(); + + if (ws) { + adpy->base.screen = + adpy->event_handler->new_sw_screen(&adpy->base, ws); + } + + if (adpy->base.screen) + LOGI("using SW screen"); + else + LOGE("failed to create SW screen"); + } + + if (adpy->base.screen) { + if (!android_display_init_configs(&adpy->base)) { + adpy->base.screen->destroy(adpy->base.screen); + adpy->base.screen = NULL; + } + } + + return (adpy->base.screen != NULL); +} + +static void +android_display_destroy(struct native_display *ndpy) +{ + struct android_display *adpy = android_display(ndpy); + + FREE(adpy->configs); + adpy->base.screen->destroy(adpy->base.screen); + FREE(adpy); +} + +static const struct native_config ** +android_display_get_configs(struct native_display *ndpy, int *num_configs) +{ + struct android_display *adpy = android_display(ndpy); + const struct native_config **configs; + int i; + + configs = (const struct native_config **) + MALLOC(adpy->num_configs * sizeof(*configs)); + if (configs) { + for (i = 0; i < adpy->num_configs; i++) + configs[i] = (const struct native_config *) &adpy->configs[i]; + if (num_configs) + *num_configs = adpy->num_configs; + } + + return configs; +} + +static int +android_display_get_param(struct native_display *ndpy, + enum native_param_type param) +{ + int val; + + switch (param) { + default: + val = 0; + break; + } + + return val; +} + +static struct pipe_resource * +android_display_import_buffer(struct native_display *ndpy, + const struct pipe_resource *templ, + void *buf) +{ + struct android_display *adpy = android_display(ndpy); + struct android_native_buffer_t *abuf = + (struct android_native_buffer_t *) buf; + + return import_buffer(adpy, templ, abuf); +} + +static boolean +android_display_export_buffer(struct native_display *ndpy, + struct pipe_resource *res, + void *buf) +{ + return FALSE; +} + +static struct native_display_buffer android_display_buffer = { + android_display_import_buffer, + android_display_export_buffer +}; + +static struct android_display * +android_display_create(struct native_event_handler *event_handler, + void *user_data) +{ + struct android_display *adpy; + + adpy = CALLOC_STRUCT(android_display); + if (!adpy) + return NULL; + + adpy->event_handler = event_handler; + adpy->base.user_data = user_data; + + if (!android_display_init(&adpy->base)) { + FREE(adpy); + return NULL; + } + + adpy->base.destroy = android_display_destroy; + adpy->base.get_param = android_display_get_param; + adpy->base.get_configs = android_display_get_configs; + adpy->base.create_window_surface = android_display_create_window_surface; + + adpy->base.buffer = &android_display_buffer; + + return adpy; +} + +static struct native_display * +native_create_display(void *dpy, struct native_event_handler *event_handler, + void *user_data) +{ + struct android_display *adpy; + + adpy = android_display_create(event_handler, user_data); + + return (adpy) ? &adpy->base : NULL; +} + +static const struct native_platform android_platform = { + "Android", /* name */ + native_create_display +}; + +}; /* namespace android */ + +using namespace android; + +static void +android_log(EGLint level, const char *msg) +{ + switch (level) { + case _EGL_DEBUG: + LOGD(msg); + break; + case _EGL_INFO: + LOGI(msg); + break; + case _EGL_WARNING: + LOGW(msg); + break; + case _EGL_FATAL: + LOG_FATAL(msg); + break; + default: + break; + } +} + +const struct native_platform * +native_get_android_platform(void) +{ + _eglSetLogProc(android_log); + + return &android_platform; +} diff --git a/src/gallium/state_trackers/egl/common/egl_g3d.c b/src/gallium/state_trackers/egl/common/egl_g3d.c index a3750ac56fb..604091aac0b 100644 --- a/src/gallium/state_trackers/egl/common/egl_g3d.c +++ b/src/gallium/state_trackers/egl/common/egl_g3d.c @@ -73,6 +73,12 @@ egl_g3d_get_platform(_EGLDriver *drv, _EGLPlatformType plat) plat_name = "FBDEV"; #ifdef HAVE_FBDEV_BACKEND nplat = native_get_fbdev_platform(); +#endif + break; + case _EGL_PLATFORM_ANDROID: + plat_name = "Android"; +#ifdef HAVE_ANDROID_BACKEND + nplat = native_get_android_platform(); #endif break; default: @@ -557,6 +563,11 @@ egl_g3d_initialize(_EGLDriver *drv, _EGLDisplay *dpy, dpy->Extensions.MESA_drm_image = EGL_TRUE; } +#ifdef EGL_ANDROID_image_native_buffer + if (dpy->Platform == _EGL_PLATFORM_ANDROID && gdpy->native->buffer) + dpy->Extensions.ANDROID_image_native_buffer = EGL_TRUE; +#endif + if (egl_g3d_add_configs(drv, dpy, 1) == 1) { _eglError(EGL_NOT_INITIALIZED, "eglInitialize(unable to add configs)"); goto fail; diff --git a/src/gallium/state_trackers/egl/common/egl_g3d.h b/src/gallium/state_trackers/egl/common/egl_g3d.h index 9873fee6ec2..a5850635b20 100644 --- a/src/gallium/state_trackers/egl/common/egl_g3d.h +++ b/src/gallium/state_trackers/egl/common/egl_g3d.h @@ -94,6 +94,9 @@ struct egl_g3d_image { struct pipe_resource *texture; unsigned level; unsigned layer; + + EGLenum target; + EGLClientBuffer buffer; }; /* standard typecasts */ diff --git a/src/gallium/state_trackers/egl/common/egl_g3d_image.c b/src/gallium/state_trackers/egl/common/egl_g3d_image.c index b2d6b433c5e..b53b121005b 100644 --- a/src/gallium/state_trackers/egl/common/egl_g3d_image.c +++ b/src/gallium/state_trackers/egl/common/egl_g3d_image.c @@ -41,6 +41,11 @@ /* for struct winsys_handle */ #include "state_tracker/drm_driver.h" +#ifdef EGL_ANDROID_image_native_buffer +#include +#include "android/android_sw_winsys.h" +#endif + /** * Reference and return the front left buffer of the native pixmap. */ @@ -185,6 +190,67 @@ egl_g3d_reference_drm_buffer(_EGLDisplay *dpy, EGLint name, #endif /* EGL_MESA_drm_image */ +#ifdef EGL_ANDROID_image_native_buffer + +static struct pipe_resource * +egl_g3d_reference_android_native_buffer(_EGLDisplay *dpy, + struct android_native_buffer_t *buf) +{ + struct egl_g3d_display *gdpy = egl_g3d_display(dpy); + struct pipe_screen *screen = gdpy->native->screen; + enum pipe_format format; + struct pipe_resource templ, *res; + struct android_winsys_handle handle; + + if (!buf || buf->common.magic != ANDROID_NATIVE_BUFFER_MAGIC || + buf->common.version != sizeof(*buf)) { + _eglError(EGL_BAD_PARAMETER, "eglCreateEGLImageKHR"); + return NULL; + } + + switch (buf->format) { + case HAL_PIXEL_FORMAT_RGBA_8888: + format = PIPE_FORMAT_R8G8B8A8_UNORM; + break; + case HAL_PIXEL_FORMAT_RGBX_8888: + format = PIPE_FORMAT_R8G8B8X8_UNORM; + break; + case HAL_PIXEL_FORMAT_RGB_888: + format = PIPE_FORMAT_R8G8B8_UNORM; + break; + case HAL_PIXEL_FORMAT_RGB_565: + format = PIPE_FORMAT_B5G6R5_UNORM; + break; + case HAL_PIXEL_FORMAT_BGRA_8888: + format = PIPE_FORMAT_B8G8R8A8_UNORM; + break; + case HAL_PIXEL_FORMAT_RGBA_5551: + case HAL_PIXEL_FORMAT_RGBA_4444: + /* unsupported */ + default: + _eglLog(_EGL_WARNING, "unsupported native format 0x%x", buf->format); + return NULL; + break; + } + + memset(&templ, 0, sizeof(templ)); + templ.target = PIPE_TEXTURE_2D; + templ.format = format; + templ.bind = PIPE_BIND_RENDER_TARGET | PIPE_BIND_SAMPLER_VIEW; + templ.width0 = buf->width; + templ.height0 = buf->height; + templ.depth0 = 1; + + res = gdpy->native->buffer->import_buffer(gdpy->native, + &templ, (void *) buf); + if (res) + buf->common.incRef(&buf->common); + + return res; +} + +#endif /* EGL_ANDROID_image_native_buffer */ + _EGLImage * egl_g3d_create_image(_EGLDriver *drv, _EGLDisplay *dpy, _EGLContext *ctx, EGLenum target, EGLClientBuffer buffer, @@ -205,6 +271,8 @@ egl_g3d_create_image(_EGLDriver *drv, _EGLDisplay *dpy, _EGLContext *ctx, return NULL; } + gimg->target = target; + switch (target) { case EGL_NATIVE_PIXMAP_KHR: ptex = egl_g3d_reference_native_pixmap(dpy, @@ -215,6 +283,13 @@ egl_g3d_create_image(_EGLDriver *drv, _EGLDisplay *dpy, _EGLContext *ctx, ptex = egl_g3d_reference_drm_buffer(dpy, (EGLint) buffer, &gimg->base, attribs); break; +#endif +#ifdef EGL_ANDROID_image_native_buffer + case EGL_NATIVE_BUFFER_ANDROID: + gimg->buffer = buffer; + ptex = egl_g3d_reference_android_native_buffer(dpy, + (struct android_native_buffer_t *) buffer); + break; #endif default: ptex = NULL; @@ -252,6 +327,14 @@ egl_g3d_destroy_image(_EGLDriver *drv, _EGLDisplay *dpy, _EGLImage *img) { struct egl_g3d_image *gimg = egl_g3d_image(img); +#ifdef EGL_ANDROID_image_native_buffer + if (gimg->target == EGL_NATIVE_BUFFER_ANDROID) { + struct android_native_buffer_t * buf = + (struct android_native_buffer_t *) gimg->buffer; + buf->common.decRef(&buf->common); + } +#endif + pipe_resource_reference(&gimg->texture, NULL); FREE(gimg); diff --git a/src/gallium/state_trackers/egl/common/native.h b/src/gallium/state_trackers/egl/common/native.h index 3886ca20562..ca8cb97f713 100644 --- a/src/gallium/state_trackers/egl/common/native.h +++ b/src/gallium/state_trackers/egl/common/native.h @@ -243,6 +243,9 @@ native_get_drm_platform(void); const struct native_platform * native_get_fbdev_platform(void); +const struct native_platform * +native_get_android_platform(void); + #ifdef __cplusplus } #endif diff --git a/src/gallium/winsys/sw/android/android_sw_winsys.cpp b/src/gallium/winsys/sw/android/android_sw_winsys.cpp new file mode 100644 index 00000000000..1c3c9f81bec --- /dev/null +++ b/src/gallium/winsys/sw/android/android_sw_winsys.cpp @@ -0,0 +1,269 @@ +/* + * Mesa 3-D graphics library + * Version: 7.9 + * + * Copyright (C) 2010 LunarG Inc. + * + * Permission is hereby granted, free of charge, to any person obtaining a + * copy of this software and associated documentation files (the "Software"), + * to deal in the Software without restriction, including without limitation + * the rights to use, copy, modify, merge, publish, distribute, sublicense, + * and/or sell copies of the Software, and to permit persons to whom the + * Software is furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included + * in all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL + * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING + * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER + * DEALINGS IN THE SOFTWARE. + * + * Authors: + * Chia-I Wu + */ + +#include "pipe/p_compiler.h" +#include "pipe/p_state.h" +#include "util/u_memory.h" +#include "util/u_format.h" +#include "state_tracker/sw_winsys.h" + +#include +#include +#include + +#include "android_sw_winsys.h" + +struct android_sw_winsys +{ + struct sw_winsys base; + + const gralloc_module_t *grmod; +}; + +struct android_sw_displaytarget +{ + buffer_handle_t handle; + int stride; + int width, height, usage; + + void *mapped; +}; + +static INLINE struct android_sw_winsys * +android_sw_winsys(struct sw_winsys *ws) +{ + return (struct android_sw_winsys *) ws; +} + +static INLINE struct android_sw_displaytarget * +android_sw_displaytarget(struct sw_displaytarget *dt) +{ + return (struct android_sw_displaytarget *) dt; +} + +namespace android { + +static void +android_displaytarget_display(struct sw_winsys *ws, + struct sw_displaytarget *dt, + void *context_private) +{ +} + +static struct sw_displaytarget * +android_displaytarget_create(struct sw_winsys *ws, + unsigned tex_usage, + enum pipe_format format, + unsigned width, unsigned height, + unsigned alignment, + unsigned *stride) +{ + return NULL; +} + +static void +android_displaytarget_destroy(struct sw_winsys *ws, + struct sw_displaytarget *dt) +{ + struct android_sw_displaytarget *adt = android_sw_displaytarget(dt); + + assert(!adt->mapped); + FREE(adt); +} + +static void +android_displaytarget_unmap(struct sw_winsys *ws, + struct sw_displaytarget *dt) +{ + struct android_sw_winsys *droid = android_sw_winsys(ws); + struct android_sw_displaytarget *adt = android_sw_displaytarget(dt); + + if (adt->mapped) { + if (sw_gralloc_handle_t::validate(adt->handle) >= 0) { + adt->mapped = NULL; + } + else { + droid->grmod->unlock(droid->grmod, adt->handle); + adt->mapped = NULL; + } + } +} + +static void * +android_displaytarget_map(struct sw_winsys *ws, + struct sw_displaytarget *dt, + unsigned flags) +{ + struct android_sw_winsys *droid = android_sw_winsys(ws); + struct android_sw_displaytarget *adt = android_sw_displaytarget(dt); + + if (!adt->mapped) { + if (sw_gralloc_handle_t::validate(adt->handle) >= 0) { + const sw_gralloc_handle_t *swhandle = + reinterpret_cast(adt->handle); + adt->mapped = reinterpret_cast(swhandle->base); + } + else { + droid->grmod->lock(droid->grmod, adt->handle, + adt->usage, 0, 0, adt->width, adt->height, &adt->mapped); + } + } + + return adt->mapped; +} + +static struct sw_displaytarget * +android_displaytarget_from_handle(struct sw_winsys *ws, + const struct pipe_resource *templ, + struct winsys_handle *whandle, + unsigned *stride) +{ + struct android_winsys_handle *ahandle = + (struct android_winsys_handle *) whandle; + struct android_sw_displaytarget *adt; + + adt = CALLOC_STRUCT(android_sw_displaytarget); + if (!adt) + return NULL; + + adt->handle = ahandle->handle; + adt->stride = ahandle->stride; + adt->width = templ->width0; + adt->height = templ->height0; + + if (templ->usage & PIPE_BIND_RENDER_TARGET) + adt->usage |= GRALLOC_USAGE_HW_RENDER; + if (templ->usage & PIPE_BIND_SAMPLER_VIEW) + adt->usage |= GRALLOC_USAGE_HW_TEXTURE; + if (templ->usage & PIPE_BIND_SCANOUT) + adt->usage |= GRALLOC_USAGE_HW_FB; + + if (templ->usage & PIPE_BIND_TRANSFER_READ) + adt->usage |= GRALLOC_USAGE_SW_READ_OFTEN; + if (templ->usage & PIPE_BIND_TRANSFER_WRITE) + adt->usage |= GRALLOC_USAGE_SW_WRITE_OFTEN; + + if (stride) + *stride = adt->stride; + + return reinterpret_cast(adt); +} + +static boolean +android_displaytarget_get_handle(struct sw_winsys *ws, + struct sw_displaytarget *dt, + struct winsys_handle *whandle) +{ + return FALSE; +} + +static boolean +android_is_displaytarget_format_supported(struct sw_winsys *ws, + unsigned tex_usage, + enum pipe_format format) +{ + struct android_sw_winsys *droid = android_sw_winsys(ws); + int fmt; + + switch (format) { + case PIPE_FORMAT_R8G8B8A8_UNORM: + fmt = PIXEL_FORMAT_RGBA_8888; + break; + case PIPE_FORMAT_R8G8B8X8_UNORM: + fmt = PIXEL_FORMAT_RGBX_8888; + break; + case PIPE_FORMAT_R8G8B8_UNORM: + fmt = PIXEL_FORMAT_RGB_888; + break; + case PIPE_FORMAT_B5G6R5_UNORM: + fmt = PIXEL_FORMAT_RGB_565; + break; + case PIPE_FORMAT_B8G8R8A8_UNORM: + fmt = PIXEL_FORMAT_BGRA_8888; + break; + case PIPE_FORMAT_A8_UNORM: + fmt = PIXEL_FORMAT_A_8; + break; + case PIPE_FORMAT_L8_UNORM: + fmt = PIXEL_FORMAT_L_8; + break; + case PIPE_FORMAT_L8A8_UNORM: + fmt = PIXEL_FORMAT_LA_88; + break; + default: + fmt = PIXEL_FORMAT_NONE; + break; + } + + return (fmt != PIXEL_FORMAT_NONE); +} + +static void +android_destroy(struct sw_winsys *ws) +{ + struct android_sw_winsys *droid = android_sw_winsys(ws); + + FREE(droid); +} + +}; /* namespace android */ + +using namespace android; + +struct sw_winsys * +android_create_sw_winsys(void) +{ + struct android_sw_winsys *droid; + const hw_module_t *mod; + + droid = CALLOC_STRUCT(android_sw_winsys); + if (!droid) + return NULL; + + if (hw_get_module(GRALLOC_HARDWARE_MODULE_ID, &mod)) { + FREE(droid); + return NULL; + } + + droid->grmod = (const gralloc_module_t *) mod; + + droid->base.destroy = android_destroy; + droid->base.is_displaytarget_format_supported = + android_is_displaytarget_format_supported; + + droid->base.displaytarget_create = android_displaytarget_create; + droid->base.displaytarget_destroy = android_displaytarget_destroy; + droid->base.displaytarget_from_handle = android_displaytarget_from_handle; + droid->base.displaytarget_get_handle = android_displaytarget_get_handle; + + droid->base.displaytarget_map = android_displaytarget_map; + droid->base.displaytarget_unmap = android_displaytarget_unmap; + droid->base.displaytarget_display = android_displaytarget_display; + + return &droid->base; +} diff --git a/src/gallium/winsys/sw/android/android_sw_winsys.h b/src/gallium/winsys/sw/android/android_sw_winsys.h new file mode 100644 index 00000000000..8bb1dc91d49 --- /dev/null +++ b/src/gallium/winsys/sw/android/android_sw_winsys.h @@ -0,0 +1,49 @@ +/* + * Mesa 3-D graphics library + * Version: 7.9 + * + * Copyright (C) 2010 LunarG Inc. + * + * Permission is hereby granted, free of charge, to any person obtaining a + * copy of this software and associated documentation files (the "Software"), + * to deal in the Software without restriction, including without limitation + * the rights to use, copy, modify, merge, publish, distribute, sublicense, + * and/or sell copies of the Software, and to permit persons to whom the + * Software is furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included + * in all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL + * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING + * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER + * DEALINGS IN THE SOFTWARE. + * + * Authors: + * Chia-I Wu + */ + +#ifndef ANDROID_SW_WINSYS +#define ANDROID_SW_WINSYS + +#include +#include + +__BEGIN_DECLS + +struct sw_winsys; + +struct android_winsys_handle { + buffer_handle_t handle; + int stride; +}; + +struct sw_winsys * +android_create_sw_winsys(void); + +__END_DECLS + +#endif /* ANDROID_SW_WINSYS */ -- cgit v1.2.3 From 121fc671f48f6fe5b58d44d55ef9ec421f6abde1 Mon Sep 17 00:00:00 2001 From: Chia-I Wu Date: Mon, 11 Oct 2010 17:58:10 +0800 Subject: android: Add new classic EGL driver for Android. --- src/egl/drivers/android/droid.c | 649 ++++++++++++++++++++++++++++++++++ src/egl/drivers/android/droid.h | 126 +++++++ src/egl/drivers/android/droid_core.c | 327 +++++++++++++++++ src/egl/drivers/android/droid_image.c | 132 +++++++ src/egl/drivers/android/egl_android.c | 42 +++ 5 files changed, 1276 insertions(+) create mode 100644 src/egl/drivers/android/droid.c create mode 100644 src/egl/drivers/android/droid.h create mode 100644 src/egl/drivers/android/droid_core.c create mode 100644 src/egl/drivers/android/droid_image.c create mode 100644 src/egl/drivers/android/egl_android.c diff --git a/src/egl/drivers/android/droid.c b/src/egl/drivers/android/droid.c new file mode 100644 index 00000000000..60c100bb131 --- /dev/null +++ b/src/egl/drivers/android/droid.c @@ -0,0 +1,649 @@ +/* + * Copyright © 2010 Intel Corporation + * + * Permission is hereby granted, free of charge, to any person obtaining a + * copy of this software and associated documentation files (the "Software"), + * to deal in the Software without restriction, including without limitation + * the rights to use, copy, modify, merge, publish, distribute, sublicense, + * and/or sell copies of the Software, and to permit persons to whom the + * Software is furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice (including the next + * paragraph) shall be included in all copies or substantial portions of the + * Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, + * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF + * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND + * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT + * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, + * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER + * DEALINGS IN THE SOFTWARE. + * + * Authors: + * Kristian Høgsberg + */ + +#define LOG_TAG "MESA-EGL" + +#include + +#include "glapi/glapi.h" +#include "droid.h" + +static const __DRIuseInvalidateExtension use_invalidate = { + { __DRI_USE_INVALIDATE, 1 } +}; + +static __DRIimage * +droid_lookup_egl_image(__DRIscreen *screen, void *image, void *data) +{ + _EGLDisplay *disp = data; + struct droid_egl_image *dimg; + _EGLImage *img; + + (void) screen; + + img = _eglLookupImage(image, disp); + if (img == NULL) { + _eglError(EGL_BAD_PARAMETER, "droid_lookup_egl_image"); + return NULL; + } + + dimg = droid_egl_image(image); + + return dimg->dri_image; +} + +static const __DRIimageLookupExtension image_lookup_extension = { + { __DRI_IMAGE_LOOKUP, 1 }, + droid_lookup_egl_image +}; + +static int +get_format_bpp(int native) +{ + int bpp; + + /* see libpixelflinger/format.cpp */ + switch (native) { + case GGL_PIXEL_FORMAT_RGBA_8888: + case GGL_PIXEL_FORMAT_RGBX_8888: + case GGL_PIXEL_FORMAT_BGRA_8888: + bpp = 4; + break; + case GGL_PIXEL_FORMAT_RGB_888: + bpp = 3; + break; + case GGL_PIXEL_FORMAT_RGB_565: + case GGL_PIXEL_FORMAT_RGBA_5551: + case GGL_PIXEL_FORMAT_RGBA_4444: + case GGL_PIXEL_FORMAT_LA_88: + bpp = 2; + break; + case GGL_PIXEL_FORMAT_RGB_332: + case GGL_PIXEL_FORMAT_A_8: + case GGL_PIXEL_FORMAT_L_8: + bpp = 1; + break; + default: + bpp = 0; + break; + } + + return bpp; +} + +#include +int +get_native_buffer_name(struct android_native_buffer_t *buf) +{ + struct drm_bo_t *bo; + + bo = drm_gem_get(buf->handle); + + return (bo) ? bo->name : 0; +} + +EGLBoolean +droid_dequeue_buffer(struct droid_egl_surface *dsurf) +{ + __DRIbuffer *buf = &dsurf->dri_buffer; + + if (dsurf->window->dequeueBuffer(dsurf->window, &dsurf->buffer)) + return EGL_FALSE; + + dsurf->buffer->common.incRef(&dsurf->buffer->common); + dsurf->window->lockBuffer(dsurf->window, dsurf->buffer); + + buf->attachment = __DRI_BUFFER_FAKE_FRONT_LEFT; + buf->name = get_native_buffer_name(dsurf->buffer); + buf->cpp = get_format_bpp(dsurf->buffer->format); + buf->pitch = dsurf->buffer->stride * buf->cpp; + buf->flags = 0; + + return EGL_TRUE; +} + +EGLBoolean +droid_enqueue_buffer(struct droid_egl_surface *dsurf) +{ + dsurf->window->queueBuffer(dsurf->window, dsurf->buffer); + + dsurf->buffer->common.decRef(&dsurf->buffer->common); + dsurf->buffer = NULL; + + return EGL_TRUE; +} + +static void +droid_flush_front_buffer(__DRIdrawable * driDrawable, void *loaderPrivate) +{ +} + +static __DRIbuffer * +droid_get_buffers_with_format(__DRIdrawable * driDrawable, + int *width, int *height, + unsigned int *attachments, int count, + int *out_count, void *loaderPrivate) +{ + struct droid_egl_surface *dsurf = loaderPrivate; + struct droid_egl_display *ddpy = + droid_egl_display(dsurf->base.Resource.Display); + + if (!dsurf->buffer) { + if (!droid_dequeue_buffer(dsurf)) + return NULL; + } + + if (width) + *width = dsurf->buffer->width; + if (height) + *height = dsurf->buffer->height; + + *out_count = 1; + + return &dsurf->dri_buffer; +} + +static const EGLint droid_to_egl_attribute_map[] = { + 0, + EGL_BUFFER_SIZE, /* __DRI_ATTRIB_BUFFER_SIZE */ + EGL_LEVEL, /* __DRI_ATTRIB_LEVEL */ + EGL_RED_SIZE, /* __DRI_ATTRIB_RED_SIZE */ + EGL_GREEN_SIZE, /* __DRI_ATTRIB_GREEN_SIZE */ + EGL_BLUE_SIZE, /* __DRI_ATTRIB_BLUE_SIZE */ + EGL_LUMINANCE_SIZE, /* __DRI_ATTRIB_LUMINANCE_SIZE */ + EGL_ALPHA_SIZE, /* __DRI_ATTRIB_ALPHA_SIZE */ + 0, /* __DRI_ATTRIB_ALPHA_MASK_SIZE */ + EGL_DEPTH_SIZE, /* __DRI_ATTRIB_DEPTH_SIZE */ + EGL_STENCIL_SIZE, /* __DRI_ATTRIB_STENCIL_SIZE */ + 0, /* __DRI_ATTRIB_ACCUM_RED_SIZE */ + 0, /* __DRI_ATTRIB_ACCUM_GREEN_SIZE */ + 0, /* __DRI_ATTRIB_ACCUM_BLUE_SIZE */ + 0, /* __DRI_ATTRIB_ACCUM_ALPHA_SIZE */ + EGL_SAMPLE_BUFFERS, /* __DRI_ATTRIB_SAMPLE_BUFFERS */ + EGL_SAMPLES, /* __DRI_ATTRIB_SAMPLES */ + 0, /* __DRI_ATTRIB_RENDER_TYPE, */ + 0, /* __DRI_ATTRIB_CONFIG_CAVEAT */ + 0, /* __DRI_ATTRIB_CONFORMANT */ + 0, /* __DRI_ATTRIB_DOUBLE_BUFFER */ + 0, /* __DRI_ATTRIB_STEREO */ + 0, /* __DRI_ATTRIB_AUX_BUFFERS */ + 0, /* __DRI_ATTRIB_TRANSPARENT_TYPE */ + 0, /* __DRI_ATTRIB_TRANSPARENT_INDEX_VALUE */ + 0, /* __DRI_ATTRIB_TRANSPARENT_RED_VALUE */ + 0, /* __DRI_ATTRIB_TRANSPARENT_GREEN_VALUE */ + 0, /* __DRI_ATTRIB_TRANSPARENT_BLUE_VALUE */ + 0, /* __DRI_ATTRIB_TRANSPARENT_ALPHA_VALUE */ + 0, /* __DRI_ATTRIB_FLOAT_MODE */ + 0, /* __DRI_ATTRIB_RED_MASK */ + 0, /* __DRI_ATTRIB_GREEN_MASK */ + 0, /* __DRI_ATTRIB_BLUE_MASK */ + 0, /* __DRI_ATTRIB_ALPHA_MASK */ + EGL_MAX_PBUFFER_WIDTH, /* __DRI_ATTRIB_MAX_PBUFFER_WIDTH */ + EGL_MAX_PBUFFER_HEIGHT, /* __DRI_ATTRIB_MAX_PBUFFER_HEIGHT */ + EGL_MAX_PBUFFER_PIXELS, /* __DRI_ATTRIB_MAX_PBUFFER_PIXELS */ + 0, /* __DRI_ATTRIB_OPTIMAL_PBUFFER_WIDTH */ + 0, /* __DRI_ATTRIB_OPTIMAL_PBUFFER_HEIGHT */ + 0, /* __DRI_ATTRIB_VISUAL_SELECT_GROUP */ + 0, /* __DRI_ATTRIB_SWAP_METHOD */ + EGL_MAX_SWAP_INTERVAL, /* __DRI_ATTRIB_MAX_SWAP_INTERVAL */ + EGL_MIN_SWAP_INTERVAL, /* __DRI_ATTRIB_MIN_SWAP_INTERVAL */ + 0, /* __DRI_ATTRIB_BIND_TO_TEXTURE_RGB */ + 0, /* __DRI_ATTRIB_BIND_TO_TEXTURE_RGBA */ + 0, /* __DRI_ATTRIB_BIND_TO_MIPMAP_TEXTURE */ + 0, /* __DRI_ATTRIB_BIND_TO_TEXTURE_TARGETS */ + EGL_Y_INVERTED_NOK, /* __DRI_ATTRIB_YINVERTED */ +}; + +static struct droid_egl_config * +droid_add_config(_EGLDisplay *dpy, const __DRIconfig *dri_config, int id, + int depth, EGLint surface_type, int rgba_masks[4]) +{ + struct droid_egl_config *conf; + struct droid_egl_display *ddpy; + _EGLConfig base; + unsigned int attrib, value, double_buffer; + EGLint key, bind_to_texture_rgb, bind_to_texture_rgba; + int dri_masks[4] = { 0, 0, 0, 0 }; + int i; + + ddpy = dpy->DriverData; + _eglInitConfig(&base, dpy, id); + + i = 0; + double_buffer = 0; + bind_to_texture_rgb = 0; + bind_to_texture_rgba = 0; + + while (ddpy->core->indexConfigAttrib(dri_config, i++, &attrib, &value)) { + switch (attrib) { + case __DRI_ATTRIB_RENDER_TYPE: + if (value & __DRI_ATTRIB_RGBA_BIT) + value = EGL_RGB_BUFFER; + else if (value & __DRI_ATTRIB_LUMINANCE_BIT) + value = EGL_LUMINANCE_BUFFER; + else + assert(0); + _eglSetConfigKey(&base, EGL_COLOR_BUFFER_TYPE, value); + break; + + case __DRI_ATTRIB_CONFIG_CAVEAT: + if (value & __DRI_ATTRIB_NON_CONFORMANT_CONFIG) + value = EGL_NON_CONFORMANT_CONFIG; + else if (value & __DRI_ATTRIB_SLOW_BIT) + value = EGL_SLOW_CONFIG; + else + value = EGL_NONE; + _eglSetConfigKey(&base, EGL_CONFIG_CAVEAT, value); + break; + + case __DRI_ATTRIB_BIND_TO_TEXTURE_RGB: + bind_to_texture_rgb = value; + break; + + case __DRI_ATTRIB_BIND_TO_TEXTURE_RGBA: + bind_to_texture_rgba = value; + break; + + case __DRI_ATTRIB_DOUBLE_BUFFER: + double_buffer = value; + break; + + case __DRI_ATTRIB_RED_MASK: + dri_masks[0] = value; + break; + + case __DRI_ATTRIB_GREEN_MASK: + dri_masks[1] = value; + break; + + case __DRI_ATTRIB_BLUE_MASK: + dri_masks[2] = value; + break; + + case __DRI_ATTRIB_ALPHA_MASK: + dri_masks[3] = value; + break; + + default: + key = droid_to_egl_attribute_map[attrib]; + if (key != 0) + _eglSetConfigKey(&base, key, value); + break; + } + } + + /* In EGL, double buffer or not isn't a config attribute. Pixmaps + * surfaces are always single buffered, pbuffer surfaces are always + * back buffers and windows can be either, selected by passing an + * attribute at window surface construction time. To support this + * we ignore all double buffer configs and manipulate the buffer we + * return in the getBuffer callback to get the behaviour we want. */ + + if (double_buffer) + return NULL; + + if (depth > 0 && depth != _eglGetConfigKey(&base, EGL_BUFFER_SIZE)) + return NULL; + + if (memcmp(dri_masks, rgba_masks, sizeof(rgba_masks))) + return NULL; + + _eglSetConfigKey(&base, EGL_NATIVE_RENDERABLE, EGL_TRUE); + + _eglSetConfigKey(&base, EGL_SURFACE_TYPE, surface_type); + if (surface_type & (EGL_PIXMAP_BIT | EGL_PBUFFER_BIT)) { + _eglSetConfigKey(&base, EGL_BIND_TO_TEXTURE_RGB, bind_to_texture_rgb); + if (_eglGetConfigKey(&base, EGL_ALPHA_SIZE) > 0) + _eglSetConfigKey(&base, + EGL_BIND_TO_TEXTURE_RGBA, bind_to_texture_rgba); + } + + _eglSetConfigKey(&base, EGL_RENDERABLE_TYPE, dpy->ClientAPIsMask); + _eglSetConfigKey(&base, EGL_CONFORMANT, dpy->ClientAPIsMask); + + if (!_eglValidateConfig(&base, EGL_FALSE)) { + _eglLog(_EGL_DEBUG, "DRI2: failed to validate config %d", id); + return NULL; + } + + conf = calloc(1, sizeof(*conf)); + if (conf != NULL) { + memcpy(&conf->base, &base, sizeof(base)); + conf->dri_config = dri_config; + _eglLinkConfig(&conf->base); + } + + return conf; +} + +static EGLBoolean +droid_add_configs_for_visuals(_EGLDriver *drv, _EGLDisplay *dpy) +{ + struct droid_egl_display *ddpy = droid_egl_display(dpy); + const struct { + int format; + int size; + int rgba_masks[4]; + } visuals[] = { + { GGL_PIXEL_FORMAT_RGBA_8888, 32, { 0xff, 0xff00, 0xff0000, 0xff000000 } }, + { GGL_PIXEL_FORMAT_RGBX_8888, 32, { 0xff, 0xff00, 0xff0000, 0x0 } }, + { GGL_PIXEL_FORMAT_RGB_888, 24, { 0xff, 0xff00, 0xff0000, 0x0 } }, + { GGL_PIXEL_FORMAT_RGB_565, 16, { 0xf800, 0x7e0, 0x1f, 0x0 } }, + { GGL_PIXEL_FORMAT_BGRA_8888, 32, { 0xff0000, 0xff00, 0xff, 0xff000000 } }, + { GGL_PIXEL_FORMAT_A_8, 8, { 0xf800, 0x7e0, 0x1f, 0x0 } }, + { 0, 0, { 0, 0, 0, 0 } } + }; + int count, i, j; + + count = 0; + for (i = 0; visuals[i].format; i++) { + int format_count = 0; + + for (j = 0; ddpy->dri_configs[j]; j++) { + struct droid_egl_config *dconf; + + dconf = droid_add_config(dpy, ddpy->dri_configs[j], count + 1, + visuals[i].size, EGL_WINDOW_BIT, visuals[i].rgba_masks); + if (dconf) { + _eglSetConfigKey(&dconf->base, + EGL_NATIVE_VISUAL_TYPE, visuals[i].format); + count++; + format_count++; + } + } + + if (!format_count) { + _eglLog(_EGL_DEBUG, "No DRI config supports native format 0x%x", + visuals[i].format); + } + } + + return (count != 0); +} + +struct droid_extension_match { + const char *name; + int version; + int offset; +}; + +static struct droid_extension_match droid_driver_extensions[] = { + { __DRI_CORE, 1, offsetof(struct droid_egl_display, core) }, + { __DRI_DRI2, 1, offsetof(struct droid_egl_display, dri2) }, + { NULL, 0, 0 } +}; + +static struct droid_extension_match droid_core_extensions[] = { + { __DRI2_FLUSH, 1, offsetof(struct droid_egl_display, flush) }, + { __DRI_IMAGE, 1, offsetof(struct droid_egl_display, image) }, + { NULL, 0, 0 } +}; + +extern const __DRIextension *__driDriverExtensions[]; + +static EGLBoolean +droid_bind_extensions(struct droid_egl_display *ddpy, + struct droid_extension_match *matches, + const __DRIextension **extensions) +{ + int i, j, ret = EGL_TRUE; + void *field; + + for (i = 0; extensions[i]; i++) { + _eglLog(_EGL_DEBUG, "DRI2: found extension `%s'", extensions[i]->name); + for (j = 0; matches[j].name; j++) { + if (strcmp(extensions[i]->name, matches[j].name) == 0 && + extensions[i]->version >= matches[j].version) { + field = ((char *) ddpy + matches[j].offset); + *(const __DRIextension **) field = extensions[i]; + _eglLog(_EGL_INFO, "DRI2: found extension %s version %d", + extensions[i]->name, extensions[i]->version); + } + } + } + + for (j = 0; matches[j].name; j++) { + field = ((char *) ddpy + matches[j].offset); + if (*(const __DRIextension **) field == NULL) { + _eglLog(_EGL_FATAL, "DRI2: did not find extension %s version %d", + matches[j].name, matches[j].version); + ret = EGL_FALSE; + } + } + + return ret; +} + +static EGLBoolean +droid_create_screen(_EGLDisplay *dpy) +{ + struct droid_egl_display *ddpy = droid_egl_display(dpy); + const __DRIextension **extensions; + unsigned int api_mask; + + ddpy->dri_screen = + ddpy->dri2->createNewScreen(0, ddpy->fd, ddpy->extensions, + &ddpy->dri_configs, dpy); + if (ddpy->dri_screen == NULL) { + _eglLog(_EGL_WARNING, "failed to create dri screen"); + return EGL_FALSE; + } + + extensions = ddpy->core->getExtensions(ddpy->dri_screen); + if (!droid_bind_extensions(ddpy, droid_core_extensions, extensions)) { + ddpy->core->destroyScreen(ddpy->dri_screen); + return EGL_FALSE; + } + + if (ddpy->dri2->base.version >= 2) + api_mask = ddpy->dri2->getAPIMask(ddpy->dri_screen); + else + api_mask = __DRI_API_OPENGL; + + dpy->ClientAPIsMask = 0; + if (api_mask & (1 <<__DRI_API_OPENGL)) + dpy->ClientAPIsMask |= EGL_OPENGL_BIT; + if (api_mask & (1 <<__DRI_API_GLES)) + dpy->ClientAPIsMask |= EGL_OPENGL_ES_BIT; + if (api_mask & (1 << __DRI_API_GLES2)) + dpy->ClientAPIsMask |= EGL_OPENGL_ES2_BIT; + + if (ddpy->dri2->base.version >= 2) { + dpy->Extensions.KHR_surfaceless_gles1 = EGL_TRUE; + dpy->Extensions.KHR_surfaceless_gles2 = EGL_TRUE; + dpy->Extensions.KHR_surfaceless_opengl = EGL_TRUE; + } + + return EGL_TRUE; +} + +static EGLBoolean +droid_load_driver(_EGLDisplay *disp) +{ + struct droid_egl_display *ddpy = disp->DriverData; + const __DRIextension **extensions; + + extensions = __driDriverExtensions; + + if (!droid_bind_extensions(ddpy, droid_driver_extensions, extensions)) + return EGL_FALSE; + + return EGL_TRUE; +} + +static EGLBoolean +droid_initialize_android(_EGLDriver *drv, _EGLDisplay *dpy, + EGLint *major, EGLint *minor) +{ + struct droid_egl_display *ddpy; + int fd = -1, err, i; + const hw_module_t *mod; + + err = hw_get_module(GRALLOC_HARDWARE_MODULE_ID, &mod); + if (!err) { + const gralloc_module_t *gr = (gralloc_module_t *) mod; + + err = -EINVAL; + if (gr->perform) + err = gr->perform(gr, GRALLOC_MODULE_PERFORM_GET_DRM_FD, &fd); + } + if (err || fd < 0) { + _eglLog(_EGL_WARNING, "fail to get drm fd"); + return EGL_FALSE; + } + + ddpy = calloc(1, sizeof(*ddpy)); + if (!ddpy) + return _eglError(EGL_BAD_ALLOC, "eglInitialize"); + + dpy->DriverData = (void *) ddpy; + + ddpy->fd = fd; + if (!droid_load_driver(dpy)) + return EGL_FALSE; + + ddpy->loader_extension.base.name = __DRI_DRI2_LOADER; + ddpy->loader_extension.base.version = 3; + ddpy->loader_extension.getBuffers = NULL; + ddpy->loader_extension.flushFrontBuffer = droid_flush_front_buffer; + ddpy->loader_extension.getBuffersWithFormat = + droid_get_buffers_with_format; + + ddpy->extensions[0] = &ddpy->loader_extension.base; + ddpy->extensions[1] = &image_lookup_extension.base; + ddpy->extensions[2] = &use_invalidate.base; + ddpy->extensions[3] = NULL; + + if (!droid_create_screen(dpy)) { + free(ddpy); + return EGL_FALSE; + } + + if (!droid_add_configs_for_visuals(drv, dpy)) { + ddpy->core->destroyScreen(ddpy->dri_screen); + free(ddpy); + } + + dpy->Extensions.ANDROID_image_native_buffer = EGL_TRUE; + dpy->Extensions.KHR_image_base = EGL_TRUE; + + /* we're supporting EGL 1.4 */ + *major = 1; + *minor = 4; + + return EGL_TRUE; +} + +static EGLBoolean +droid_terminate(_EGLDriver *drv, _EGLDisplay *dpy) +{ + struct droid_egl_display *ddpy = droid_egl_display(dpy); + + _eglReleaseDisplayResources(drv, dpy); + _eglCleanupDisplay(dpy); + + ddpy->core->destroyScreen(ddpy->dri_screen); + free(ddpy); + dpy->DriverData = NULL; + + return EGL_TRUE; +} + +static EGLBoolean +droid_initialize(_EGLDriver *drv, _EGLDisplay *dpy, + EGLint *major, EGLint *minor) +{ + switch (dpy->Platform) { + case _EGL_PLATFORM_ANDROID: + return droid_initialize_android(drv, dpy, major, minor); + default: + return EGL_FALSE; + } +} + +static _EGLProc +droid_get_proc_address(_EGLDriver *drv, const char *procname) +{ + return (_EGLProc) _glapi_get_proc_address(procname); +} + + +static void +droid_unload(_EGLDriver *drv) +{ + struct droid_egl_driver *ddrv = droid_egl_driver(drv); + + free(ddrv); +} + +static void +droid_log(EGLint level, const char *msg) +{ + switch (level) { + case _EGL_DEBUG: + LOGD(msg); + break; + case _EGL_INFO: + LOGI(msg); + break; + case _EGL_WARNING: + LOGW(msg); + break; + case _EGL_FATAL: + LOG_FATAL(msg); + break; + default: + break; + } +} + +_EGLDriver * +droid_create_driver(void) +{ + struct droid_egl_driver *ddrv; + + ddrv = calloc(1, sizeof(*ddrv)); + if (!ddrv) + return NULL; + + _eglSetLogProc(droid_log); + + ddrv->base.Name = "Droid"; + ddrv->base.Unload = droid_unload; + + _eglInitDriverFallbacks(&ddrv->base); + ddrv->base.API.Initialize = droid_initialize; + ddrv->base.API.Terminate = droid_terminate; + ddrv->base.API.GetProcAddress = droid_get_proc_address; + + ddrv->glFlush = + (void (*)(void)) droid_get_proc_address(&ddrv->base, "glFlush"); + ddrv->glFinish = + (void (*)(void)) droid_get_proc_address(&ddrv->base, "glFinish"); + + return &ddrv->base; +} diff --git a/src/egl/drivers/android/droid.h b/src/egl/drivers/android/droid.h new file mode 100644 index 00000000000..20e32a65885 --- /dev/null +++ b/src/egl/drivers/android/droid.h @@ -0,0 +1,126 @@ +/* + * Copyright © 2010 Intel Corporation + * + * Permission is hereby granted, free of charge, to any person obtaining a + * copy of this software and associated documentation files (the "Software"), + * to deal in the Software without restriction, including without limitation + * the rights to use, copy, modify, merge, publish, distribute, sublicense, + * and/or sell copies of the Software, and to permit persons to whom the + * Software is furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice (including the next + * paragraph) shall be included in all copies or substantial portions of the + * Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, + * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF + * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND + * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT + * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, + * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER + * DEALINGS IN THE SOFTWARE. + * + * Authors: + * Kristian Høgsberg + */ + +#ifndef _DROID_H_ +#define _DROID_H_ + +#include + +#include +#include +#include + +#include +#include + +#include "egldriver.h" +#include "egldisplay.h" +#include "eglcontext.h" +#include "eglsurface.h" +#include "eglconfig.h" +#include "eglimage.h" +#include "eglcurrent.h" +#include "egllog.h" + +struct droid_egl_driver +{ + _EGLDriver base; + + void (*glFlush)(void); + void (*glFinish)(void); +}; + +struct droid_egl_display +{ + int fd; + + __DRIscreen *dri_screen; + const __DRIconfig **dri_configs; + __DRIcoreExtension *core; + __DRIdri2Extension *dri2; + __DRI2flushExtension *flush; + __DRIimageExtension *image; + + __DRIdri2LoaderExtension loader_extension; + const __DRIextension *extensions[8]; +}; + +struct droid_egl_context +{ + _EGLContext base; + + __DRIcontext *dri_context; +}; + +struct droid_egl_surface +{ + _EGLSurface base; + + __DRIdrawable *dri_drawable; + __DRIbuffer dri_buffer; + + android_native_window_t *window; + android_native_buffer_t *buffer; +}; + +struct droid_egl_config +{ + _EGLConfig base; + + const __DRIconfig *dri_config; +}; + +struct droid_egl_image +{ + _EGLImage base; + + __DRIimage *dri_image; +}; + +/* standard typecasts */ +_EGL_DRIVER_STANDARD_TYPECASTS(droid_egl) +_EGL_DRIVER_TYPECAST(droid_egl_image, _EGLImage, obj) + +_EGLDriver * +droid_create_driver(void); + +void +droid_init_core_functions(_EGLDriver *drv); + +void +droid_init_image_functions(_EGLDriver *drv); + +EGLBoolean +droid_dequeue_buffer(struct droid_egl_surface *dsurf); + +EGLBoolean +droid_enqueue_buffer(struct droid_egl_surface *dsurf); + +int +get_native_buffer_name(struct android_native_buffer_t *buf); + +#endif /* _DROID_H_ */ diff --git a/src/egl/drivers/android/droid_core.c b/src/egl/drivers/android/droid_core.c new file mode 100644 index 00000000000..82c21d4aa94 --- /dev/null +++ b/src/egl/drivers/android/droid_core.c @@ -0,0 +1,327 @@ +/* + * Copyright © 2010 Intel Corporation + * + * Permission is hereby granted, free of charge, to any person obtaining a + * copy of this software and associated documentation files (the "Software"), + * to deal in the Software without restriction, including without limitation + * the rights to use, copy, modify, merge, publish, distribute, sublicense, + * and/or sell copies of the Software, and to permit persons to whom the + * Software is furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice (including the next + * paragraph) shall be included in all copies or substantial portions of the + * Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, + * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF + * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND + * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT + * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, + * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER + * DEALINGS IN THE SOFTWARE. + * + * Authors: + * Kristian Høgsberg + */ + +#include "droid.h" + +static _EGLContext * +droid_create_context(_EGLDriver *drv, _EGLDisplay *disp, _EGLConfig *conf, + _EGLContext *share_list, const EGLint *attrib_list) +{ + struct droid_egl_context *dctx; + struct droid_egl_display *ddpy = droid_egl_display(disp); + struct droid_egl_context *dctx_shared = droid_egl_context(share_list); + struct droid_egl_config *dconf = droid_egl_config(conf); + const __DRIconfig *dri_config; + int api; + + (void) drv; + + dctx = calloc(1, sizeof *dctx); + if (!dctx) { + _eglError(EGL_BAD_ALLOC, "eglCreateContext"); + return NULL; + } + + if (!_eglInitContext(&dctx->base, disp, conf, attrib_list)) + goto cleanup; + + switch (dctx->base.ClientAPI) { + case EGL_OPENGL_ES_API: + switch (dctx->base.ClientVersion) { + case 1: + api = __DRI_API_GLES; + break; + case 2: + api = __DRI_API_GLES2; + break; + default: + _eglError(EGL_BAD_PARAMETER, "eglCreateContext"); + return NULL; + } + break; + case EGL_OPENGL_API: + api = __DRI_API_OPENGL; + break; + default: + _eglError(EGL_BAD_PARAMETER, "eglCreateContext"); + return NULL; + } + + if (conf != NULL) + dri_config = dconf->dri_config; + else + dri_config = NULL; + + if (ddpy->dri2->base.version >= 2) { + dctx->dri_context = + ddpy->dri2->createNewContextForAPI(ddpy->dri_screen, + api, + dri_config, + dctx_shared ? + dctx_shared->dri_context : NULL, + dctx); + } else if (api == __DRI_API_OPENGL) { + dctx->dri_context = + ddpy->dri2->createNewContext(ddpy->dri_screen, + dconf->dri_config, + dctx_shared ? + dctx_shared->dri_context : NULL, + dctx); + } else { + /* fail */ + } + + if (!dctx->dri_context) + goto cleanup; + + return &dctx->base; + + cleanup: + free(dctx); + return NULL; +} + +static _EGLSurface * +droid_create_surface(_EGLDriver *drv, _EGLDisplay *disp, EGLint type, + _EGLConfig *conf, EGLNativeWindowType window, + const EGLint *attrib_list) +{ + struct droid_egl_display *ddpy = droid_egl_display(disp); + struct droid_egl_config *dconf = droid_egl_config(conf); + struct droid_egl_surface *dsurf; + int format, vis_type; + + (void) drv; + + if (!window || window->common.magic != ANDROID_NATIVE_WINDOW_MAGIC) { + _eglError(EGL_BAD_NATIVE_WINDOW, "droid_create_surface"); + return NULL; + } + if (window->query(window, NATIVE_WINDOW_FORMAT, &format)) { + _eglError(EGL_BAD_NATIVE_WINDOW, "droid_create_surface"); + return NULL; + } + + vis_type = _eglGetConfigKey(&dconf->base, EGL_NATIVE_VISUAL_TYPE); + if (format != vis_type) { + _eglLog(_EGL_WARNING, "Native format mismatch: 0x%x != 0x%x", + format, vis_type); + } + + dsurf = calloc(1, sizeof *dsurf); + if (!dsurf) { + _eglError(EGL_BAD_ALLOC, "droid_create_surface"); + return NULL; + } + + if (!_eglInitSurface(&dsurf->base, disp, type, conf, attrib_list)) + goto cleanup_surf; + + dsurf->dri_drawable = + (*ddpy->dri2->createNewDrawable) (ddpy->dri_screen, + dconf->dri_config, dsurf); + if (dsurf->dri_drawable == NULL) { + _eglError(EGL_BAD_ALLOC, "dri2->createNewDrawable"); + goto cleanup_pixmap; + } + + window->common.incRef(&window->common); + window->query(window, NATIVE_WINDOW_WIDTH, &dsurf->base.Width); + window->query(window, NATIVE_WINDOW_HEIGHT, &dsurf->base.Height); + + dsurf->window = window; + + return &dsurf->base; + + cleanup_dri_drawable: + ddpy->core->destroyDrawable(dsurf->dri_drawable); + cleanup_pixmap: + cleanup_surf: + free(dsurf); + + return NULL; +} + +static _EGLSurface * +droid_create_window_surface(_EGLDriver *drv, _EGLDisplay *disp, + _EGLConfig *conf, EGLNativeWindowType window, + const EGLint *attrib_list) +{ + return droid_create_surface(drv, disp, EGL_WINDOW_BIT, conf, + window, attrib_list); +} + +static _EGLSurface * +droid_create_pixmap_surface(_EGLDriver *drv, _EGLDisplay *disp, + _EGLConfig *conf, EGLNativePixmapType pixmap, + const EGLint *attrib_list) +{ + return NULL; +} + +static _EGLSurface * +droid_create_pbuffer_surface(_EGLDriver *drv, _EGLDisplay *disp, + _EGLConfig *conf, const EGLint *attrib_list) +{ + return NULL; +} + +static EGLBoolean +droid_destroy_surface(_EGLDriver *drv, _EGLDisplay *disp, _EGLSurface *surf) +{ + struct droid_egl_display *ddpy = droid_egl_display(disp); + struct droid_egl_surface *dsurf = droid_egl_surface(surf); + + (void) drv; + + if (!_eglPutSurface(surf)) + return EGL_TRUE; + + (*ddpy->core->destroyDrawable)(dsurf->dri_drawable); + + droid_enqueue_buffer(dsurf); + dsurf->window->common.decRef(&dsurf->window->common); + + free(surf); + + return EGL_TRUE; +} + +static EGLBoolean +droid_make_current(_EGLDriver *drv, _EGLDisplay *disp, _EGLSurface *dsurf, + _EGLSurface *rsurf, _EGLContext *ctx) +{ + struct droid_egl_driver *ddrv = droid_egl_driver(drv); + struct droid_egl_display *ddpy = droid_egl_display(disp); + struct droid_egl_surface *droid_dsurf = droid_egl_surface(dsurf); + struct droid_egl_surface *droid_rsurf = droid_egl_surface(rsurf); + struct droid_egl_context *dctx = droid_egl_context(ctx); + _EGLContext *old_ctx; + _EGLSurface *old_dsurf, *old_rsurf; + __DRIdrawable *ddraw, *rdraw; + __DRIcontext *cctx; + + /* make new bindings */ + if (!_eglBindContext(ctx, dsurf, rsurf, &old_ctx, &old_dsurf, &old_rsurf)) + return EGL_FALSE; + + /* flush before context switch */ + if (old_ctx && ddrv->glFlush) + ddrv->glFlush(); + + ddraw = (droid_dsurf) ? droid_dsurf->dri_drawable : NULL; + rdraw = (droid_rsurf) ? droid_rsurf->dri_drawable : NULL; + cctx = (dctx) ? dctx->dri_context : NULL; + + if ((cctx == NULL && ddraw == NULL && rdraw == NULL) || + ddpy->core->bindContext(cctx, ddraw, rdraw)) { + droid_destroy_surface(drv, disp, old_dsurf); + droid_destroy_surface(drv, disp, old_rsurf); + if (old_ctx) { + /* unbind the old context only when there is no new context bound */ + if (!ctx) { + __DRIcontext *old_cctx = droid_egl_context(old_ctx)->dri_context; + ddpy->core->unbindContext(old_cctx); + } + /* no destroy? */ + _eglPutContext(old_ctx); + } + + return EGL_TRUE; + } else { + /* undo the previous _eglBindContext */ + _eglBindContext(old_ctx, old_dsurf, old_rsurf, &ctx, &dsurf, &rsurf); + assert(&dctx->base == ctx && + &droid_dsurf->base == dsurf && + &droid_rsurf->base == rsurf); + + _eglPutSurface(dsurf); + _eglPutSurface(rsurf); + _eglPutContext(ctx); + + _eglPutSurface(old_dsurf); + _eglPutSurface(old_rsurf); + _eglPutContext(old_ctx); + + return EGL_FALSE; + } +} + +static EGLBoolean +droid_swap_buffers(_EGLDriver *drv, _EGLDisplay *disp, _EGLSurface *draw) +{ + struct droid_egl_driver *ddrv = droid_egl_driver(drv); + struct droid_egl_display *ddpy = droid_egl_display(disp); + struct droid_egl_surface *dsurf = droid_egl_surface(draw); + _EGLContext *ctx; + + if (ddrv->glFlush) { + ctx = _eglGetCurrentContext(); + if (ctx && ctx->DrawSurface == &dsurf->base) + ddrv->glFlush(); + } + + (*ddpy->flush->flush)(dsurf->dri_drawable); + + if (dsurf->buffer) + droid_enqueue_buffer(dsurf); + + (*ddpy->flush->invalidate)(dsurf->dri_drawable); + + return EGL_TRUE; +} + +static EGLBoolean +droid_wait_client(_EGLDriver *drv, _EGLDisplay *disp, _EGLContext *ctx) +{ + struct droid_egl_driver *ddrv = droid_egl_driver(drv); + struct droid_egl_display *ddpy = droid_egl_display(disp); + struct droid_egl_surface *dsurf = droid_egl_surface(ctx->DrawSurface); + + if (ddrv->glFinish) + ddrv->glFinish(); + + if (dsurf) + (*ddpy->flush->flush)(dsurf->dri_drawable); + + return EGL_TRUE; +} + +void +droid_init_core_functions(_EGLDriver *drv) +{ + struct droid_egl_driver *ddrv = droid_egl_driver(drv); + + ddrv->base.API.CreateContext = droid_create_context; + ddrv->base.API.CreateWindowSurface = droid_create_window_surface; + ddrv->base.API.CreatePixmapSurface = droid_create_pixmap_surface; + ddrv->base.API.CreatePbufferSurface = droid_create_pbuffer_surface; + ddrv->base.API.DestroySurface = droid_destroy_surface; + ddrv->base.API.MakeCurrent = droid_make_current; + ddrv->base.API.SwapBuffers = droid_swap_buffers; + ddrv->base.API.WaitClient = droid_wait_client; +} diff --git a/src/egl/drivers/android/droid_image.c b/src/egl/drivers/android/droid_image.c new file mode 100644 index 00000000000..509335bce68 --- /dev/null +++ b/src/egl/drivers/android/droid_image.c @@ -0,0 +1,132 @@ +/* + * Copyright © 2010 Intel Corporation + * + * Permission is hereby granted, free of charge, to any person obtaining a + * copy of this software and associated documentation files (the "Software"), + * to deal in the Software without restriction, including without limitation + * the rights to use, copy, modify, merge, publish, distribute, sublicense, + * and/or sell copies of the Software, and to permit persons to whom the + * Software is furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice (including the next + * paragraph) shall be included in all copies or substantial portions of the + * Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, + * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF + * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND + * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT + * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, + * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER + * DEALINGS IN THE SOFTWARE. + * + * Authors: + * Kristian Høgsberg + */ + +#include "droid.h" + +static _EGLImage * +droid_create_image_android_native_buffer(_EGLDisplay *disp, + EGLClientBuffer buffer) +{ + struct droid_egl_display *ddpy = droid_egl_display(disp); + struct android_native_buffer_t *buf = + (struct android_native_buffer_t *) buffer; + struct droid_egl_image *dimg; + EGLint format, name; + + if (!buf || buf->common.magic != ANDROID_NATIVE_BUFFER_MAGIC || + buf->common.version != sizeof(*buf)) { + _eglError(EGL_BAD_PARAMETER, "eglCreateEGLImageKHR"); + return NULL; + } + + name = get_native_buffer_name(buf); + if (!name) { + _eglError(EGL_BAD_PARAMETER, "eglCreateEGLImageKHR"); + return NULL; + } + + switch (buf->format) { + case HAL_PIXEL_FORMAT_BGRA_8888: + format = __DRI_IMAGE_FORMAT_ARGB8888; + break; + case HAL_PIXEL_FORMAT_RGB_565: + format = __DRI_IMAGE_FORMAT_RGB565; + break; + case HAL_PIXEL_FORMAT_RGBA_8888: + case HAL_PIXEL_FORMAT_RGBX_8888: + case HAL_PIXEL_FORMAT_RGB_888: + case HAL_PIXEL_FORMAT_RGBA_5551: + case HAL_PIXEL_FORMAT_RGBA_4444: + /* unsupported */ + default: + _eglLog(_EGL_WARNING, "unsupported native buffer format 0x%x", buf->format); + return NULL; + break; + } + + dimg = calloc(1, sizeof(*dimg)); + if (!dimg) { + _eglError(EGL_BAD_ALLOC, "droid_create_image_mesa_drm"); + return NULL; + } + + if (!_eglInitImage(&dimg->base, disp)) { + free(dimg); + return NULL; + } + + dimg->dri_image = + ddpy->image->createImageFromName(ddpy->dri_screen, + buf->width, + buf->height, + format, + name, + buf->stride, + dimg); + if (!dimg->dri_image) { + free(dimg); + _eglError(EGL_BAD_ALLOC, "droid_create_image_mesa_drm"); + return NULL; + } + + return &dimg->base; +} + +static _EGLImage * +droid_create_image_khr(_EGLDriver *drv, _EGLDisplay *disp, + _EGLContext *ctx, EGLenum target, + EGLClientBuffer buffer, const EGLint *attr_list) +{ + switch (target) { + case EGL_NATIVE_BUFFER_ANDROID: + return droid_create_image_android_native_buffer(disp, buffer); + default: + _eglError(EGL_BAD_PARAMETER, "droid_create_image_khr"); + return EGL_NO_IMAGE_KHR; + } +} + +static EGLBoolean +droid_destroy_image_khr(_EGLDriver *drv, _EGLDisplay *disp, _EGLImage *image) +{ + struct droid_egl_display *ddpy = droid_egl_display(disp); + struct droid_egl_image *dimg = droid_egl_image(image); + + ddpy->image->destroyImage(dimg->dri_image); + free(dimg); + + return EGL_TRUE; +} + +void +droid_init_image_functions(_EGLDriver *drv) +{ + struct droid_egl_driver *ddrv = droid_egl_driver(drv); + + ddrv->base.API.CreateImageKHR = droid_create_image_khr; + ddrv->base.API.DestroyImageKHR = droid_destroy_image_khr; +} diff --git a/src/egl/drivers/android/egl_android.c b/src/egl/drivers/android/egl_android.c new file mode 100644 index 00000000000..3f1cb36b788 --- /dev/null +++ b/src/egl/drivers/android/egl_android.c @@ -0,0 +1,42 @@ +/* + * Copyright © 2010 Intel Corporation + * + * Permission is hereby granted, free of charge, to any person obtaining a + * copy of this software and associated documentation files (the "Software"), + * to deal in the Software without restriction, including without limitation + * the rights to use, copy, modify, merge, publish, distribute, sublicense, + * and/or sell copies of the Software, and to permit persons to whom the + * Software is furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice (including the next + * paragraph) shall be included in all copies or substantial portions of the + * Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, + * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF + * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND + * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT + * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, + * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER + * DEALINGS IN THE SOFTWARE. + * + * Authors: + * Kristian Høgsberg + */ + +#include "droid.h" + +_EGLDriver * +_eglMain(const char *args) +{ + _EGLDriver *drv; + + drv = droid_create_driver(); + if (drv) { + droid_init_core_functions(drv); + droid_init_image_functions(drv); + } + + return drv; +} -- cgit v1.2.3 From b0a79b3512dd3e142bc5d2fcd5fac7438997c49f Mon Sep 17 00:00:00 2001 From: Chia-I Wu Date: Mon, 11 Oct 2010 16:06:47 +0800 Subject: android: Add DRM-based gralloc. --- src/gralloc/gralloc_gem.c | 119 +++++++++++++++ src/gralloc/gralloc_gem.h | 77 ++++++++++ src/gralloc/gralloc_gem_i915.c | 211 ++++++++++++++++++++++++++ src/gralloc/gralloc_gem_pipe.c | 333 +++++++++++++++++++++++++++++++++++++++++ src/gralloc/gralloc_kms.c | 241 +++++++++++++++++++++++++++++ src/gralloc/gralloc_kms.h | 19 +++ src/gralloc/gralloc_mod.c | 328 ++++++++++++++++++++++++++++++++++++++++ src/gralloc/gralloc_mod.h | 65 ++++++++ 8 files changed, 1393 insertions(+) create mode 100644 src/gralloc/gralloc_gem.c create mode 100644 src/gralloc/gralloc_gem.h create mode 100644 src/gralloc/gralloc_gem_i915.c create mode 100644 src/gralloc/gralloc_gem_pipe.c create mode 100644 src/gralloc/gralloc_kms.c create mode 100644 src/gralloc/gralloc_kms.h create mode 100644 src/gralloc/gralloc_mod.c create mode 100644 src/gralloc/gralloc_mod.h diff --git a/src/gralloc/gralloc_gem.c b/src/gralloc/gralloc_gem.c new file mode 100644 index 00000000000..a3df97f89bb --- /dev/null +++ b/src/gralloc/gralloc_gem.c @@ -0,0 +1,119 @@ +#define LOG_TAG "GRALLOC-GEM" + +#include +#include +#include +#include +#include +#include +#include + +#include "gralloc_mod.h" +#include "gralloc_gem.h" + +#define unlikely(x) __builtin_expect(!!(x), 0) + +#define DRM_PATH "/dev/dri/card0" + +static int32_t drm_gem_pid = 0; + +static int +drm_gem_get_pid(void) +{ + if (unlikely(!drm_gem_pid)) + android_atomic_write((int32_t) getpid(), &drm_gem_pid); + return drm_gem_pid; +} + +static int +drm_gem_init_locked(struct drm_module_t *drm) +{ + int ret; + + if (drm->fd >= 0) + return 0; + + drm->fd = open(DRM_PATH, O_RDWR); + if (drm->fd < 0) { + LOGE("failed to open %s", DRM_PATH); + return -EINVAL; + } + + return 0; +} + +int +drm_gem_init(struct drm_module_t *drm) +{ + int ret; + + pthread_mutex_lock(&drm->mutex); + ret = drm_gem_init_locked(drm); + pthread_mutex_unlock(&drm->mutex); + + return ret; +} + +int +drm_gem_get_magic(struct drm_module_t *drm, int32_t *magic) +{ + int ret; + + ret = drm_gem_init(drm); + if (ret) + return ret; + + return drmGetMagic(drm->fd, (drm_magic_t *) magic); +} + +int +drm_gem_auth_magic(struct drm_module_t *drm, int32_t magic) +{ + int ret; + + ret = drm_gem_init(drm); + if (ret) + return ret; + + return drmAuthMagic(drm->fd, (drm_magic_t) magic); +} + +struct drm_bo_t * +drm_gem_create_bo(int width, int height, int format, int usage) +{ + struct drm_bo_t *bo; + + bo = calloc(1, sizeof(*bo)); + if (!bo) + return NULL; + + bo->base.version = sizeof(bo->base); + bo->base.numInts = DRM_HANDLE_NUM_INTS; + bo->base.numFds = DRM_HANDLE_NUM_FDS; + + bo->magic = DRM_HANDLE_MAGIC; + + bo->width = width; + bo->height = height; + bo->format = format; + bo->usage = usage; + + bo->pid = drm_gem_get_pid(); + + return bo; +} + +struct drm_bo_t * +drm_gem_validate(buffer_handle_t handle) +{ + struct drm_bo_t *bo = drm_gem_get(handle); + + if (bo && unlikely(bo->pid != drm_gem_pid)) { + bo->pid = drm_gem_get_pid(); + bo->fb_handle = 0; + bo->fb_id = 0; + bo->data = 0; + } + + return bo; +} diff --git a/src/gralloc/gralloc_gem.h b/src/gralloc/gralloc_gem.h new file mode 100644 index 00000000000..e6ef176efa2 --- /dev/null +++ b/src/gralloc/gralloc_gem.h @@ -0,0 +1,77 @@ +#ifndef _GRALLOC_GEM_H_ +#define _GRALLOC_GEM_H_ + +#include +#include "gralloc_mod.h" + +struct drm_bo_t { + native_handle_t base; + +#define DRM_HANDLE_MAGIC 0x12345678 +#define DRM_HANDLE_NUM_INTS 11 +#define DRM_HANDLE_NUM_FDS 0 + int magic; + + int width; + int height; + int format; + int usage; + + int name; + int stride; + + /* these fields are undefined until validated */ + int pid; + int fb_handle; + int fb_id; + int data; /* pointer as int? 32-bit only! */ +}; + +int +drm_gem_init(struct drm_module_t *drm); + +int +drm_gem_get_magic(struct drm_module_t *drm, int32_t *magic); + +int +drm_gem_auth_magic(struct drm_module_t *drm, int32_t magic); + +static inline struct drm_bo_t * +drm_gem_get(buffer_handle_t handle) +{ + struct drm_bo_t *bo = (struct drm_bo_t *) handle; + + if (bo->base.version != sizeof(bo->base) || + bo->base.numInts != DRM_HANDLE_NUM_INTS || + bo->base.numFds != DRM_HANDLE_NUM_FDS || + bo->magic != DRM_HANDLE_MAGIC) + bo = NULL; + + return bo; +} + +struct drm_bo_t * +drm_gem_validate(buffer_handle_t handle); + +struct drm_bo_t * +drm_gem_create_bo(int width, int height, int format, int usage); + + +int +drm_gem_drv_init(struct drm_module_t *drm); + +struct drm_bo_t * +drm_gem_drv_alloc(struct drm_module_t *drm, int width, int height, + int format, int usage, int *stride); + +void +drm_gem_drv_free(struct drm_module_t *drm, struct drm_bo_t *bo); + +int +drm_gem_drv_map(struct drm_module_t *drm, struct drm_bo_t *bo, + int x, int y, int w, int h, int enable_write, void **addr); + +void +drm_gem_drv_unmap(struct drm_module_t *drm, struct drm_bo_t *bo); + +#endif /* _GRALLOC_GEM_H_ */ diff --git a/src/gralloc/gralloc_gem_i915.c b/src/gralloc/gralloc_gem_i915.c new file mode 100644 index 00000000000..2822fe5c127 --- /dev/null +++ b/src/gralloc/gralloc_gem_i915.c @@ -0,0 +1,211 @@ +#define LOG_TAG "GRALLOC-I915" + +#include +#include +#include +#include +#include +#include + +#include "gralloc_mod.h" +#include "gralloc_gem.h" + +static void +drm_gem_drv_init_features_locked(struct drm_module_t *drm) +{ + struct drm_i915_getparam gp; + + drm_intel_bufmgr *bufmgr = (drm_intel_bufmgr *) drm->gem; + + drm->mode_dirty_fb = 0; + + memset(&gp, 0, sizeof(gp)); + gp.param = I915_PARAM_HAS_PAGEFLIPPING; + gp.value = &drm->mode_page_flip; + if (!drmCommandWriteRead(drm->fd, DRM_I915_GETPARAM, &gp, sizeof(gp))) + drm->mode_page_flip = *gp.value; + else + drm->mode_page_flip = 0; + + if (drm->resources) { + int pipe; + + pipe = drm_intel_get_pipe_from_crtc_id(bufmgr, drm->crtc_id); + drm->swap_interval = (pipe >= 0) ? 1 : 0; + drm->vblank_secondary = (pipe > 0); + } + else { + drm->swap_interval = 0; + } + + /* XXX there is a bug in the kernel module */ + drm->mode_page_flip = 0; + +} + +static int +drm_gem_drv_init_locked(struct drm_module_t *drm) +{ + if (drm->gem) + return 0; + + drm->gem = (void *) drm_intel_bufmgr_gem_init(drm->fd, 16 * 1024); + if (!drm->gem) { + LOGE("failed to create buffer manager"); + return -ENOMEM; + } + + drm_gem_drv_init_features_locked(drm); + + return 0; +} + +int +drm_gem_drv_init(struct drm_module_t *drm) +{ + int ret; + + pthread_mutex_lock(&drm->mutex); + ret = drm_gem_drv_init_locked(drm); + pthread_mutex_unlock(&drm->mutex); + + return ret; +} + +static uint32_t +drm_gem_get_tiling(struct drm_bo_t *bo) +{ + uint32_t tiling = I915_TILING_NONE; + + if (bo->usage & GRALLOC_USAGE_SW_READ_OFTEN) + return tiling; + + if (bo->usage & GRALLOC_USAGE_HW_FB || + bo->usage & GRALLOC_USAGE_HW_TEXTURE) { + if (bo->width >= 64) + tiling = I915_TILING_X; + } + + return tiling; +} + +struct drm_bo_t * +drm_gem_drv_alloc(struct drm_module_t *drm, int width, int height, + int format, int usage, int *stride) +{ + drm_intel_bufmgr *bufmgr = (drm_intel_bufmgr *) drm->gem; + struct drm_bo_t *bo; + drm_intel_bo *ibo; + int aligned_width, aligned_height, cpp; + unsigned long pitch, flags; + uint32_t tiling; + const char *name; + + bo = drm_gem_create_bo(width, height, format, usage); + if (!bo) + return NULL; + + cpp = drm_mod_get_bpp(format); + if (!cpp) { + LOGE("unrecognized format 0x%x", format); + free(bo); + return NULL; + } + + if (usage & GRALLOC_USAGE_HW_FB) { + name = "gralloc-fb"; + aligned_width = (width + 63) & ~63; + } + if (usage & GRALLOC_USAGE_HW_TEXTURE) { + name = "gralloc-texture"; + aligned_width = (width + 3) & ~3; + aligned_height = (height + 1) & ~1; + } + else { + name = "gralloc-buf"; + aligned_width = width; + aligned_height = height; + } + + tiling = drm_gem_get_tiling(bo); + + flags = 0x0; + if (bo->usage & (GRALLOC_USAGE_HW_RENDER | GRALLOC_USAGE_HW_FB)) + flags |= BO_ALLOC_FOR_RENDER; + + ibo = drm_intel_bo_alloc_tiled(bufmgr, name, + aligned_width, aligned_height, cpp, &tiling, &pitch, flags); + if (!ibo) { + LOGE("failed to allocate ibo %dx%dx%d", width, height, cpp); + free(bo); + return NULL; + } + + if (bo->usage & GRALLOC_USAGE_HW_FB) { + drm_intel_bo_disable_reuse(ibo); + bo->stride = pitch; + bo->fb_handle = ibo->handle; + } + + if (drm_intel_bo_flink(ibo, (uint32_t *) &bo->name)) { + LOGE("failed to flink ibo"); + drm_intel_bo_unreference(ibo); + free(bo); + return NULL; + } + + bo->data = (int) ibo; + + *stride = pitch; + + return bo; +} + +void +drm_gem_drv_free(struct drm_module_t *drm, struct drm_bo_t *bo) +{ + drm_intel_bo_unreference((drm_intel_bo *) bo->data); + free(bo); +} + +int +drm_gem_drv_map(struct drm_module_t *drm, struct drm_bo_t *bo, + int x, int y, int w, int h, int enable_write, void **addr) +{ + drm_intel_bo *ibo = (drm_intel_bo *) bo->data; + int err; + + if (!ibo) { + drm_intel_bufmgr *bufmgr = (drm_intel_bufmgr *) drm->gem; + + ibo = drm_intel_bo_gem_create_from_name(bufmgr, "gralloc-r", bo->name); + if (!ibo) { + LOGE("failed to create ibo from name %u", bo->name); + return -EINVAL; + } + + bo->data = (int) ibo; + } + + if ((bo->usage & GRALLOC_USAGE_HW_FB) || + drm_gem_get_tiling(bo) != I915_TILING_NONE) + err = drm_intel_gem_bo_map_gtt(ibo); + else + err = drm_intel_bo_map(ibo, enable_write); + if (!err) + *addr = ibo->virtual; + + return err; +} + +void +drm_gem_drv_unmap(struct drm_module_t *drm, struct drm_bo_t *bo) +{ + drm_intel_bo *ibo = (drm_intel_bo *) bo->data; + + if ((bo->usage & GRALLOC_USAGE_HW_FB) || + drm_gem_get_tiling(bo) != I915_TILING_NONE) + drm_intel_gem_bo_unmap_gtt(ibo); + else + drm_intel_bo_unmap(ibo); +} diff --git a/src/gralloc/gralloc_gem_pipe.c b/src/gralloc/gralloc_gem_pipe.c new file mode 100644 index 00000000000..99a84616273 --- /dev/null +++ b/src/gralloc/gralloc_gem_pipe.c @@ -0,0 +1,333 @@ +#define LOG_TAG "GRALLOC-PIPE" + +#include +#include + +#include "pipe/p_screen.h" +#include "pipe/p_context.h" +#include "state_tracker/drm_driver.h" +#include "util/u_inlines.h" +#include "util/u_memory.h" + +#include "gralloc_mod.h" +#include "gralloc_gem.h" + +struct drm_pipe_manager { + pthread_mutex_t mutex; + struct pipe_screen *screen; + struct pipe_context *context; +}; + +struct drm_pipe_buffer { + struct winsys_handle winsys; + uint32_t fb_handle; + struct pipe_resource *resource; + struct pipe_transfer *transfer; +}; + +static void +drm_gem_drv_init_features_locked(struct drm_module_t *drm) +{ + drm->mode_dirty_fb = 0; + drm->mode_page_flip = 0; + + if (strcmp(driver_descriptor.driver_name, "vmwgfx") == 0) + drm->mode_dirty_fb = 1; + + drm->swap_interval = 0; +} + +static int +drm_gem_drv_init_locked(struct drm_module_t *drm) +{ + struct drm_pipe_manager *pm; + + if (drm->gem) + return 0; + + pm = CALLOC(1, sizeof(*pm)); + if (!pm) + return -ENOMEM; + + pthread_mutex_init(&pm->mutex, NULL); + + pm->screen = driver_descriptor.create_screen(drm->fd); + if (!pm->screen) { + LOGE("failed to create pipe screen"); + FREE(pm); + return -EINVAL; + } + + drm->gem = (void *) pm; + + drm_gem_drv_init_features_locked(drm); + + return 0; +} + +int +drm_gem_drv_init(struct drm_module_t *drm) +{ + int ret; + + pthread_mutex_lock(&drm->mutex); + ret = drm_gem_drv_init_locked(drm); + pthread_mutex_unlock(&drm->mutex); + + return ret; +} + +static enum pipe_format +get_pipe_format(int format) +{ + enum pipe_format fmt; + + switch (format) { + case HAL_PIXEL_FORMAT_RGBA_8888: + fmt = PIPE_FORMAT_R8G8B8A8_UNORM; + break; + case HAL_PIXEL_FORMAT_RGBX_8888: + fmt = PIPE_FORMAT_R8G8B8X8_UNORM; + break; + case HAL_PIXEL_FORMAT_RGB_888: + fmt = PIPE_FORMAT_R8G8B8_UNORM; + break; + case HAL_PIXEL_FORMAT_RGB_565: + fmt = PIPE_FORMAT_B5G6R5_UNORM; + break; + case HAL_PIXEL_FORMAT_BGRA_8888: + fmt = PIPE_FORMAT_B8G8R8A8_UNORM; + break; + case HAL_PIXEL_FORMAT_RGBA_5551: + case HAL_PIXEL_FORMAT_RGBA_4444: + default: + fmt = PIPE_FORMAT_NONE; + break; + } + + return fmt; +} + +static unsigned +get_pipe_bind(int usage) +{ + unsigned bind = PIPE_BIND_SHARED; + + if (usage & GRALLOC_USAGE_SW_READ_MASK) + bind |= PIPE_BIND_TRANSFER_READ; + if (usage & GRALLOC_USAGE_SW_WRITE_MASK) + bind |= PIPE_BIND_TRANSFER_WRITE; + + if (usage & GRALLOC_USAGE_HW_TEXTURE) + bind |= PIPE_BIND_SAMPLER_VIEW; + if (usage & GRALLOC_USAGE_HW_RENDER) + bind |= PIPE_BIND_RENDER_TARGET; + if (usage & GRALLOC_USAGE_HW_FB) { + bind |= PIPE_BIND_RENDER_TARGET; + bind |= PIPE_BIND_SCANOUT; + } + + return bind; +} + +static struct drm_pipe_buffer * +get_pipe_buffer(struct drm_pipe_manager *pm, int width, int height, + int format, int usage, struct winsys_handle *winsys) +{ + struct drm_pipe_buffer *buf; + struct pipe_resource templ; + + memset(&templ, 0, sizeof(templ)); + templ.format = get_pipe_format(format); + templ.bind = get_pipe_bind(usage); + templ.target = PIPE_TEXTURE_2D; + + if (templ.format == PIPE_FORMAT_NONE || + !pm->screen->is_format_supported(pm->screen, templ.format, + templ.target, 0, templ.bind, 0)) { + LOGE("unsupported format 0x%x", format); + return NULL; + } + + buf = CALLOC(1, sizeof(*buf)); + if (!buf) + return NULL; + + templ.width0 = width; + templ.height0 = height; + templ.depth0 = 1; + + if (winsys) { + buf->resource = pm->screen->resource_from_handle(pm->screen, + &templ, winsys); + if (!buf->resource) + goto fail; + + buf->winsys = *winsys; + } + else { + buf->resource = pm->screen->resource_create(pm->screen, &templ); + if (!buf->resource) + goto fail; + + buf->winsys.type = DRM_API_HANDLE_TYPE_SHARED; + if (!pm->screen->resource_get_handle(pm->screen, buf->resource, &buf->winsys)) + goto fail; + } + + /* need the gem handle for fb */ + if (usage & GRALLOC_USAGE_HW_FB) { + struct winsys_handle tmp; + + memset(&tmp, 0, sizeof(tmp)); + tmp.type = DRM_API_HANDLE_TYPE_KMS; + if (!pm->screen->resource_get_handle(pm->screen, buf->resource, &tmp)) + goto fail; + + buf->fb_handle = tmp.handle; + } + + return buf; + +fail: + LOGE("failed to allocate pipe buffer"); + if (buf->resource) + pipe_resource_reference(&buf->resource, NULL); + FREE(buf); + + return NULL; +} + +struct drm_bo_t * +drm_gem_drv_alloc(struct drm_module_t *drm, int width, int height, + int format, int usage, int *stride) +{ + struct drm_pipe_manager *pm = (struct drm_pipe_manager *) drm->gem; + struct drm_pipe_buffer *buf; + struct drm_bo_t *bo; + struct pipe_resource templ; + + bo = drm_gem_create_bo(width, height, format, usage); + if (!bo) + return NULL; + + pthread_mutex_lock(&pm->mutex); + buf = get_pipe_buffer(pm, width, height, format, usage, NULL); + pthread_mutex_unlock(&pm->mutex); + + if (buf) { + bo->name = (int) buf->winsys.handle; + bo->stride = (int) buf->winsys.stride; + + bo->fb_handle = buf->fb_handle; + bo->data = (int) buf; + + *stride = bo->stride; + } + else { + free(bo); + bo = NULL; + } + + return bo; +} + +void +drm_gem_drv_free(struct drm_module_t *drm, struct drm_bo_t *bo) +{ + struct drm_pipe_manager *pm = (struct drm_pipe_manager *) drm->gem; + struct drm_pipe_buffer *buf = (struct drm_pipe_buffer *) bo->data; + + pthread_mutex_lock(&pm->mutex); + + if (buf->transfer) + pipe_transfer_destroy(pm->context, buf->transfer); + pipe_resource_reference(&buf->resource, NULL); + + pthread_mutex_unlock(&pm->mutex); + + FREE(buf); + free(bo); +} + +int +drm_gem_drv_map(struct drm_module_t *drm, struct drm_bo_t *bo, + int x, int y, int w, int h, int enable_write, void **addr) +{ + struct drm_pipe_manager *pm = (struct drm_pipe_manager *) drm->gem; + struct drm_pipe_buffer *buf = (struct drm_pipe_buffer *) bo->data; + enum pipe_transfer_usage usage = 0; + int ret = 0; + + pthread_mutex_lock(&pm->mutex); + + /* need a context to get transfer */ + if (!pm->context) { + pm->context = pm->screen->context_create(pm->screen, NULL); + if (!pm->context) { + LOGE("failed to create pipe context"); + ret = -ENOMEM; + } + } + + /* the bo was allocated by another process */ + if (!buf && !ret) { + struct winsys_handle winsys; + + memset(&winsys, 0, sizeof(winsys)); + winsys.type = DRM_API_HANDLE_TYPE_SHARED; + winsys.handle = bo->name; + winsys.stride = bo->stride; + + buf = get_pipe_buffer(pm, bo->width, bo->height, + bo->format, bo->usage, &winsys); + if (!buf) { + LOGE("failed to create pipe buffer from name %u", bo->name); + ret = -ENOMEM; + } + + bo->data = (int) buf; + } + + if (buf) { + usage = PIPE_TRANSFER_READ; + if (enable_write) + usage |= PIPE_TRANSFER_WRITE; + + assert(!buf->transfer); + + /* + * ignore x, y, w and h so that returned addr points at the start of the + * buffer + */ + buf->transfer = pipe_get_transfer(pm->context, buf->resource, + 0, 0, usage, 0, 0, bo->width, bo->height); + if (buf->transfer) + *addr = pipe_transfer_map(pm->context, buf->transfer); + else + ret = -ENOMEM; + } + + pthread_mutex_unlock(&pm->mutex); + + return ret; +} + +void +drm_gem_drv_unmap(struct drm_module_t *drm, struct drm_bo_t *bo) +{ + struct drm_pipe_manager *pm = (struct drm_pipe_manager *) drm->gem; + struct drm_pipe_buffer *buf = (struct drm_pipe_buffer *) bo->data; + + pthread_mutex_lock(&pm->mutex); + + assert(buf && buf->transfer); + + pipe_transfer_unmap(pm->context, buf->transfer); + pipe_transfer_destroy(pm->context, buf->transfer); + buf->transfer = NULL; + + pm->context->flush(pm->context, PIPE_FLUSH_RENDER_CACHE, NULL); + + pthread_mutex_unlock(&pm->mutex); +} diff --git a/src/gralloc/gralloc_kms.c b/src/gralloc/gralloc_kms.c new file mode 100644 index 00000000000..6ae9446244d --- /dev/null +++ b/src/gralloc/gralloc_kms.c @@ -0,0 +1,241 @@ +#define LOG_TAG "GRALLOC-KMS" + +#include +#include +#include +#include "gralloc_kms.h" + +int +drm_kms_add_fb(struct drm_module_t *drm, struct drm_bo_t *bo) +{ + uint8_t bpp; + + bpp = drm_mod_get_bpp(bo->format) * 8; + + return drmModeAddFB(drm->fd, bo->width, bo->height, bpp, bpp, + bo->stride, bo->fb_handle, (uint32_t *) &bo->fb_id); +} + +void +drm_kms_rm_fb(struct drm_module_t *drm, struct drm_bo_t *bo) +{ + drmModeRmFB(drm->fd, bo->fb_id); + bo->fb_id = 0; +} + +static void +drm_kms_wait_vblank(struct drm_module_t *drm, int num) +{ + drmVBlank vbl; + int ret; + + memset(&vbl, 0, sizeof(vbl)); + vbl.request.type = DRM_VBLANK_RELATIVE; + if (drm->vblank_secondary) + vbl.request.type |= DRM_VBLANK_SECONDARY; + vbl.request.sequence = num; + + ret = drmWaitVBlank(drm->fd, &vbl); + if (ret) + LOGW("failed to wait vblank"); +} + +static int +drm_kms_set_crtc(struct drm_module_t *drm, struct drm_bo_t *bo) +{ + int ret; + + if (drm->swap_interval) + drm_kms_wait_vblank(drm, drm->swap_interval); + + ret = drmModeSetCrtc(drm->fd, drm->crtc_id, bo->fb_id, + 0, 0, &drm->connector_id, 1, &drm->mode); + if (ret) { + LOGE("failed to set crtc"); + return ret; + } + +#ifdef DRM_MODE_FEATURE_DIRTYFB + if (drm->mode_dirty_fb) + ret = drmModeDirtyFB(drm->fd, bo->fb_id, &drm->clip, 1); +#endif + + return ret; +} + +static int +drm_kms_page_flip(struct drm_module_t *drm, struct drm_bo_t *bo) +{ + int waits = 3, ret; + + if (drm->swap_interval > 1) + drm_kms_wait_vblank(drm, drm->swap_interval - 1); + + while (waits) { + ret = drmModePageFlip(drm->fd, drm->crtc_id, bo->fb_id, 0x0, NULL); + if (ret && errno == -EBUSY) { + if (drm->swap_interval) + drm_kms_wait_vblank(drm, 1); + else + usleep(5000); + waits--; + } + else { + break; + } + } + + if (ret) + LOGE("failed to perform page flip"); + + return ret; +} + +int +drm_kms_post(struct drm_module_t *drm, struct drm_bo_t *bo) +{ + int ret; + + if (!bo->fb_id) { + LOGE("unable to post bo %p without fb", bo); + return -EINVAL; + } + + /* TODO spawn a thread to avoid waiting */ + + if (drm->first_post) { + pthread_mutex_lock(&drm->mutex); + if (drm->first_post) { + ret = drm_kms_set_crtc(drm, bo); + if (!ret) + drm->first_post = 0; + pthread_mutex_unlock(&drm->mutex); + + return ret; + } + pthread_mutex_unlock(&drm->mutex); + } + + if (drm->mode_page_flip && drm->swap_interval) + ret = drm_kms_page_flip(drm, bo); + else + ret = drm_kms_set_crtc(drm, bo); + + return ret; +} + +static int +drm_kms_init_with_connector_locked(struct drm_module_t *drm, + drmModeConnectorPtr connector) +{ + drmModeEncoderPtr encoder; + drmModeModeInfoPtr mode; + int i; + + if (!connector->count_modes) + return -EINVAL; + + encoder = drmModeGetEncoder(drm->fd, connector->encoders[0]); + if (!encoder) + return -EINVAL; + + for (i = 0; i < drm->resources->count_crtcs; i++) { + if (encoder->possible_crtcs & (1 << i)) + break; + } + drmModeFreeEncoder(encoder); + if (i == drm->resources->count_crtcs) + return -EINVAL; + + drm->crtc_id = drm->resources->crtcs[i]; + drm->connector_id = connector->connector_id; + + /* find the first preferred mode */ + mode = NULL; + for (i = 0; i < connector->count_modes; i++) { + drmModeModeInfoPtr m = &connector->modes[i]; + if (m->type & DRM_MODE_TYPE_PREFERRED) { + mode = m; + break; + } + } + /* no preference; use the first */ + if (!mode) + mode = &connector->modes[0]; + + drm->mode = *mode; + + if (connector->mmWidth && connector->mmHeight) { + drm->xdpi = (drm->mode.hdisplay * 25.4 / connector->mmWidth); + drm->ydpi = (drm->mode.vdisplay * 25.4 / connector->mmHeight); + } + else { + drm->xdpi = 75; + drm->ydpi = 75; + } + + /* select between 32/16 bits */ +#if 1 + drm->format = HAL_PIXEL_FORMAT_BGRA_8888; +#else + drm->format = HAL_PIXEL_FORMAT_RGB_565; +#endif + +#ifdef DRM_MODE_FEATURE_DIRTYFB + drm->clip.x1 = 0; + drm->clip.y1 = 0; + drm->clip.x2 = drm->mode.hdisplay; + drm->clip.y2 = drm->mode.vdisplay; +#endif + + drm->first_post = 1; + + return 0; +} + +static int +drm_kms_init_locked(struct drm_module_t *drm) +{ + int i, ret; + + if (drm->resources) + return 0; + + drm->resources = drmModeGetResources(drm->fd); + if (!drm->resources) + return -EINVAL; + + for (i = 0; i < drm->resources->count_connectors; i++) { + drmModeConnectorPtr connector; + + connector = drmModeGetConnector(drm->fd, drm->resources->connectors[i]); + if (connector) { + if (connector->connection == DRM_MODE_CONNECTED) { + if (!drm_kms_init_with_connector_locked(drm, connector)) + break; + } + + drmModeFreeConnector(connector); + } + } + if (i == drm->resources->count_connectors) { + drmModeFreeResources(drm->resources); + drm->resources = NULL; + + return -EINVAL; + } + + return 0; +} + +int +drm_kms_init(struct drm_module_t *drm) +{ + int ret; + + pthread_mutex_lock(&drm->mutex); + ret = drm_kms_init_locked(drm); + pthread_mutex_unlock(&drm->mutex); + + return ret; +} diff --git a/src/gralloc/gralloc_kms.h b/src/gralloc/gralloc_kms.h new file mode 100644 index 00000000000..44708e00344 --- /dev/null +++ b/src/gralloc/gralloc_kms.h @@ -0,0 +1,19 @@ +#ifndef _DRM_KMS_H_ +#define _DRM_KMS_H_ + +#include "gralloc_mod.h" +#include "gralloc_gem.h" + +int +drm_kms_init(struct drm_module_t *drm); + +int +drm_kms_add_fb(struct drm_module_t *drm, struct drm_bo_t *bo); + +void +drm_kms_rm_fb(struct drm_module_t *drm, struct drm_bo_t *bo); + +int +drm_kms_post(struct drm_module_t *drm, struct drm_bo_t *bo); + +#endif /* _DRM_KMS_H_ */ diff --git a/src/gralloc/gralloc_mod.c b/src/gralloc/gralloc_mod.c new file mode 100644 index 00000000000..1296d2af042 --- /dev/null +++ b/src/gralloc/gralloc_mod.c @@ -0,0 +1,328 @@ +#define LOG_TAG "GRALLOC-MOD" + +#include +#include +#include +#include + +#include "gralloc_mod.h" +#include "gralloc_gem.h" +#include "gralloc_kms.h" + +static int +drm_mod_perform(const struct gralloc_module_t *mod, int op, ...) +{ + struct drm_module_t *drm = (struct drm_module_t *) mod; + va_list args; + int ret; + + va_start(args, op); + switch (op) { + case GRALLOC_MODULE_PERFORM_GET_DRM_FD: + { + int *fd = va_arg(args, int *); + + ret = drm_gem_init(drm); + if (!ret) + *fd = drm->fd; + } + break; + case GRALLOC_MODULE_PERFORM_GET_DRM_MAGIC: + { + int32_t *magic = va_arg(args, int32_t *); + + ret = drm_gem_init(drm); + if (!ret) + ret = drm_gem_get_magic(drm, magic); + } + break; + case GRALLOC_MODULE_PERFORM_AUTH_DRM_MAGIC: + { + int32_t magic = va_arg(args, int32_t); + + ret = drm_gem_init(drm); + if (!ret) + ret = drm_gem_auth_magic(drm, magic); + } + break; + default: + ret = -EINVAL; + break; + } + va_end(args); + + return ret; +} + +static int +drm_mod_register_buffer(const gralloc_module_t *mod, buffer_handle_t handle) +{ + return (drm_gem_get(handle)) ? 0 : -EINVAL; +} + +static int +drm_mod_unregister_buffer(const gralloc_module_t *mod, buffer_handle_t handle) +{ + return (drm_gem_get(handle)) ? 0 : -EINVAL; +} + +static int +drm_mod_lock(const gralloc_module_t *mod, buffer_handle_t handle, + int usage, int x, int y, int w, int h, void **ptr) +{ + struct drm_module_t *drm = (struct drm_module_t *) mod; + struct drm_bo_t *bo; + int ret; + + ret = drm_gem_init(drm); + if (!ret) + ret = drm_gem_drv_init(drm); + if (ret) + return ret; + + bo = drm_gem_validate(handle); + if (!bo) + return -EINVAL; + + return drm_gem_drv_map(drm, bo, x, y, w, h, 1, ptr); +} + +static int +drm_mod_unlock(const gralloc_module_t *mod, buffer_handle_t handle) +{ + struct drm_module_t *drm = (struct drm_module_t *) mod; + struct drm_bo_t *bo; + + bo = drm_gem_validate(handle); + if (!bo) + return -EINVAL; + + drm_gem_drv_unmap(drm, bo); + + return 0; +} + +static int +drm_mod_close_gpu0(struct hw_device_t *dev) +{ + struct alloc_device_t *alloc = (struct alloc_device_t *) dev; + + free(alloc); + + return 0; +} + +static int +drm_mod_free_gpu0(alloc_device_t *dev, buffer_handle_t handle) +{ + struct drm_module_t *drm = (struct drm_module_t *) dev->common.module; + struct drm_bo_t *bo; + + bo = drm_gem_validate(handle); + if (!bo) + return -EINVAL; + + if (bo->usage & GRALLOC_USAGE_HW_FB) + drm_kms_rm_fb(drm, bo); + + drm_gem_drv_free(drm, bo); + + return 0; +} + +static int +drm_mod_alloc_gpu0(alloc_device_t *dev, int w, int h, int format, int usage, + buffer_handle_t *handle, int *stride) +{ + struct drm_module_t *drm = (struct drm_module_t *) dev->common.module; + struct drm_bo_t *bo; + int size, bpp, ret; + + ret = drm_gem_drv_init(drm); + if (ret) + return ret; + + bpp = drm_mod_get_bpp(format); + if (!bpp) + return -EINVAL; + + bo = drm_gem_drv_alloc(drm, w, h, format, usage, stride); + if (!bo) + return -EINVAL; + if (bo->usage & GRALLOC_USAGE_HW_FB) { + ret = drm_kms_add_fb(drm, bo); + if (ret) { + LOGE("failed to add fb"); + drm_gem_drv_free(drm, bo); + return ret; + } + } + + *stride /= bpp; + *handle = &bo->base; + + return 0; +} + +static int +drm_mod_open_gpu0(struct drm_module_t *drm, hw_device_t **dev) +{ + struct alloc_device_t *alloc; + int ret; + + ret = drm_gem_init(drm); + if (ret) + return ret; + + alloc = calloc(1, sizeof(*alloc)); + if (!alloc) + return -EINVAL; + + alloc->common.tag = HARDWARE_DEVICE_TAG; + alloc->common.version = 0; + alloc->common.module = (hw_module_t *) drm; + alloc->common.close = drm_mod_close_gpu0; + + alloc->alloc = drm_mod_alloc_gpu0; + alloc->free = drm_mod_free_gpu0; + + *dev = &alloc->common; + + return 0; +} + +static int +drm_mod_close_fb0(struct hw_device_t *dev) +{ + struct framebuffer_device_t *fb = (struct framebuffer_device_t *) dev; + + free(fb); + + return 0; +} + +static int +drm_mod_set_swap_interval_fb0(struct framebuffer_device_t *fb, int interval) +{ + if (interval < fb->minSwapInterval || interval > fb->maxSwapInterval) + return -EINVAL; + return 0; +} + +static int +drm_mod_post_fb0(struct framebuffer_device_t *fb, buffer_handle_t handle) +{ + struct drm_module_t *drm = (struct drm_module_t *) fb->common.module; + struct drm_bo_t *bo; + + bo = drm_gem_validate(handle); + if (!bo) + return -EINVAL; + + return drm_kms_post(drm, bo); +} + +#include +static int +drm_mod_composition_complete_fb0(struct framebuffer_device_t *fb) +{ + eglWaitClient(); + return 0; +} + +static int +drm_mod_open_fb0(struct drm_module_t *drm, struct hw_device_t **dev) +{ + struct framebuffer_device_t *fb; + int ret; + + fb = calloc(1, sizeof(*fb)); + if (!fb) + return -ENOMEM; + + ret = drm_gem_init(drm); + if (!ret) + ret = drm_kms_init(drm); + if (ret) { + free(fb); + return ret; + } + + fb->common.tag = HARDWARE_DEVICE_TAG; + fb->common.version = 0; + fb->common.module = (hw_module_t *) drm; + fb->common.close = drm_mod_close_fb0; + + fb->setSwapInterval = drm_mod_set_swap_interval_fb0; + fb->post = drm_mod_post_fb0; + fb->compositionComplete = drm_mod_composition_complete_fb0; + + *((uint32_t *) &fb->flags) = 0x0; + *((uint32_t *) &fb->width) = drm->mode.hdisplay; + *((uint32_t *) &fb->height) = drm->mode.vdisplay; + *((int *) &fb->stride) = drm->mode.hdisplay; + *((float *) &fb->fps) = drm->mode.vrefresh; + + *((int *) &fb->format) = drm->format; + *((float *) &fb->xdpi) = drm->xdpi; + *((float *) &fb->ydpi) = drm->ydpi; + *((int *) &fb->minSwapInterval) = drm->swap_interval; + *((int *) &fb->maxSwapInterval) = drm->swap_interval; + + *dev = &fb->common; + + LOGI("mode.hdisplay %d\n" + "mode.vdisplay %d\n" + "mode.vrefresh %d\n" + "format 0x%x\n" + "xdpi %d\n" + "ydpi %d\n", + drm->mode.hdisplay, + drm->mode.vdisplay, + drm->mode.vrefresh, + drm->format, + drm->xdpi, drm->ydpi); + + return 0; +} + +static int +drm_mod_open(const struct hw_module_t *mod, const char *name, struct hw_device_t **dev) +{ + struct drm_module_t *drm = (struct drm_module_t *) mod; + int ret; + + if (strcmp(name, GRALLOC_HARDWARE_GPU0) == 0) + ret = drm_mod_open_gpu0(drm, dev); + else if (strcmp(name, GRALLOC_HARDWARE_FB0) == 0) + ret = drm_mod_open_fb0(drm, dev); + else + ret = -EINVAL; + + return ret; +} + +static struct hw_module_methods_t drm_mod_methods = { + .open = drm_mod_open +}; + +struct drm_module_t HAL_MODULE_INFO_SYM = { + .base = { + .common = { + .tag = HARDWARE_MODULE_TAG, + .version_major = 1, + .version_minor = 0, + .id = GRALLOC_HARDWARE_MODULE_ID, + .name = "DRM Memory Allocator", + .author = "Chia-I Wu", + .methods = &drm_mod_methods + }, + .registerBuffer = drm_mod_register_buffer, + .unregisterBuffer = drm_mod_unregister_buffer, + .lock = drm_mod_lock, + .unlock = drm_mod_unlock, + .perform = drm_mod_perform + }, + .mutex = PTHREAD_MUTEX_INITIALIZER, + .fd = -1 +}; diff --git a/src/gralloc/gralloc_mod.h b/src/gralloc/gralloc_mod.h new file mode 100644 index 00000000000..e06ec864ad8 --- /dev/null +++ b/src/gralloc/gralloc_mod.h @@ -0,0 +1,65 @@ +#ifndef _GRALLOC_DRM_H +#define _GRALLOC_DRM_H + +#include +#include +#include +#include + +struct drm_module_t { + gralloc_module_t base; + + pthread_mutex_t mutex; + + /* initialized by drm_gem_init */ + int fd; + + /* initialized by drm_kms_init */ + drmModeResPtr resources; + uint32_t crtc_id; + uint32_t connector_id; + drmModeModeInfo mode; + int xdpi, ydpi; + int format; +#ifdef DRM_MODE_FEATURE_DIRTYFB + drmModeClip clip; +#endif + + /* initialized by drm_gem_drv_init */ + void *gem; + int mode_dirty_fb; + int mode_page_flip; + int swap_interval; + int vblank_secondary; + + int first_post; +}; + +static inline int +drm_mod_get_bpp(int format) +{ + int bpp; + + switch (format) { + case HAL_PIXEL_FORMAT_RGBA_8888: + case HAL_PIXEL_FORMAT_RGBX_8888: + case HAL_PIXEL_FORMAT_BGRA_8888: + bpp = 4; + break; + case HAL_PIXEL_FORMAT_RGB_888: + bpp = 3; + break; + case HAL_PIXEL_FORMAT_RGB_565: + case HAL_PIXEL_FORMAT_RGBA_5551: + case HAL_PIXEL_FORMAT_RGBA_4444: + bpp = 2; + break; + default: + bpp = 0; + break; + } + + return bpp; +} + +#endif /* _GRALLOC_DRM_H */ -- cgit v1.2.3 From 07a8209c3f9aad96a71a258b9fa029f286cee74e Mon Sep 17 00:00:00 2001 From: Chia-I Wu Date: Wed, 13 Oct 2010 10:16:36 -0400 Subject: android: Add __DRI_IMAGE_FORMAT_RGBA8888_REV. --- include/GL/internal/dri_interface.h | 1 + src/egl/drivers/android/droid_image.c | 2 ++ src/mesa/drivers/dri/i915/i915_texstate.c | 2 ++ src/mesa/drivers/dri/intel/intel_screen.c | 10 ++++++++++ 4 files changed, 15 insertions(+) diff --git a/include/GL/internal/dri_interface.h b/include/GL/internal/dri_interface.h index 9ee039bd90b..2c4d9069813 100644 --- a/include/GL/internal/dri_interface.h +++ b/include/GL/internal/dri_interface.h @@ -788,6 +788,7 @@ struct __DRIdri2ExtensionRec { #define __DRI_IMAGE_FORMAT_RGB565 0x1001 #define __DRI_IMAGE_FORMAT_XRGB8888 0x1002 #define __DRI_IMAGE_FORMAT_ARGB8888 0x1003 +#define __DRI_IMAGE_FORMAT_RGBA8888_REV 0x1004 #define __DRI_IMAGE_USE_SHARE 0x0001 #define __DRI_IMAGE_USE_SCANOUT 0x0002 diff --git a/src/egl/drivers/android/droid_image.c b/src/egl/drivers/android/droid_image.c index 509335bce68..0e69340b7b9 100644 --- a/src/egl/drivers/android/droid_image.c +++ b/src/egl/drivers/android/droid_image.c @@ -57,6 +57,8 @@ droid_create_image_android_native_buffer(_EGLDisplay *disp, format = __DRI_IMAGE_FORMAT_RGB565; break; case HAL_PIXEL_FORMAT_RGBA_8888: + format = __DRI_IMAGE_FORMAT_RGBA8888_REV; + break; case HAL_PIXEL_FORMAT_RGBX_8888: case HAL_PIXEL_FORMAT_RGB_888: case HAL_PIXEL_FORMAT_RGBA_5551: diff --git a/src/mesa/drivers/dri/i915/i915_texstate.c b/src/mesa/drivers/dri/i915/i915_texstate.c index c724a214967..bc05a5687c7 100644 --- a/src/mesa/drivers/dri/i915/i915_texstate.c +++ b/src/mesa/drivers/dri/i915/i915_texstate.c @@ -60,6 +60,8 @@ translate_texture_format(gl_format mesa_format, GLuint internal_format, return MAPSURF_32BIT | MT_32BIT_ARGB8888; case MESA_FORMAT_XRGB8888: return MAPSURF_32BIT | MT_32BIT_XRGB8888; + case MESA_FORMAT_RGBA8888_REV: + return MAPSURF_32BIT | MT_32BIT_ABGR8888; case MESA_FORMAT_YCBCR_REV: return (MAPSURF_422 | MT_422_YCRCB_NORMAL); case MESA_FORMAT_YCBCR: diff --git a/src/mesa/drivers/dri/intel/intel_screen.c b/src/mesa/drivers/dri/intel/intel_screen.c index 3f13589a214..e5b6c9f0e4a 100644 --- a/src/mesa/drivers/dri/intel/intel_screen.c +++ b/src/mesa/drivers/dri/intel/intel_screen.c @@ -151,6 +151,11 @@ intel_create_image_from_name(__DRIscreen *screen, image->internal_format = GL_RGBA; image->data_type = GL_UNSIGNED_BYTE; break; + case __DRI_IMAGE_FORMAT_RGBA8888_REV: + image->format = MESA_FORMAT_RGBA8888_REV; + image->internal_format = GL_RGBA; + image->data_type = GL_UNSIGNED_BYTE; + break; default: free(image); return NULL; @@ -237,6 +242,11 @@ intel_create_image(__DRIscreen *screen, image->internal_format = GL_RGBA; image->data_type = GL_UNSIGNED_BYTE; break; + case __DRI_IMAGE_FORMAT_RGBA8888_REV: + image->format = MESA_FORMAT_RGBA8888_REV; + image->internal_format = GL_RGBA; + image->data_type = GL_UNSIGNED_BYTE; + break; default: free(image); return NULL; -- cgit v1.2.3 From 4128957d3057728cada936f32bf470214e37d952 Mon Sep 17 00:00:00 2001 From: Chia-I Wu Date: Thu, 30 Sep 2010 14:09:54 +0800 Subject: android: Add pre-generated files. --- src/mapi/es1api/glapi/glapi_sparc.S | 1080 ++ src/mapi/es1api/glapi/glapi_x86-64.S | 19246 ++++++++++++++++++++++++++++++++ src/mapi/es1api/glapi/glapi_x86.S | 1043 ++ src/mapi/es1api/glapi/glapitable.h | 551 + src/mapi/es1api/glapi/glapitemp.h | 4528 ++++++++ src/mapi/es1api/glapi/glprocs.h | 1977 ++++ src/mapi/es1api/main/glapidispatch.h | 2524 +++++ src/mapi/es1api/main/remap_helper.h | 2335 ++++ src/mapi/es2api/glapi/glapi_sparc.S | 1084 ++ src/mapi/es2api/glapi/glapi_x86-64.S | 19796 +++++++++++++++++++++++++++++++++ src/mapi/es2api/glapi/glapi_x86.S | 1053 ++ src/mapi/es2api/glapi/glapitable.h | 563 + src/mapi/es2api/glapi/glapitemp.h | 4170 +++++++ src/mapi/es2api/glapi/glprocs.h | 1877 ++++ src/mapi/es2api/main/glapidispatch.h | 2392 ++++ src/mapi/es2api/main/remap_helper.h | 2269 ++++ src/mesa/main/.gitignore | 2 - src/mesa/main/api_exec_es1.c | 4860 ++++++++ src/mesa/main/api_exec_es2.c | 2519 +++++ 19 files changed, 73867 insertions(+), 2 deletions(-) create mode 100644 src/mapi/es1api/glapi/glapi_sparc.S create mode 100644 src/mapi/es1api/glapi/glapi_x86-64.S create mode 100644 src/mapi/es1api/glapi/glapi_x86.S create mode 100644 src/mapi/es1api/glapi/glapitable.h create mode 100644 src/mapi/es1api/glapi/glapitemp.h create mode 100644 src/mapi/es1api/glapi/glprocs.h create mode 100644 src/mapi/es1api/main/glapidispatch.h create mode 100644 src/mapi/es1api/main/remap_helper.h create mode 100644 src/mapi/es2api/glapi/glapi_sparc.S create mode 100644 src/mapi/es2api/glapi/glapi_x86-64.S create mode 100644 src/mapi/es2api/glapi/glapi_x86.S create mode 100644 src/mapi/es2api/glapi/glapitable.h create mode 100644 src/mapi/es2api/glapi/glapitemp.h create mode 100644 src/mapi/es2api/glapi/glprocs.h create mode 100644 src/mapi/es2api/main/glapidispatch.h create mode 100644 src/mapi/es2api/main/remap_helper.h create mode 100644 src/mesa/main/api_exec_es1.c create mode 100644 src/mesa/main/api_exec_es2.c diff --git a/src/mapi/es1api/glapi/glapi_sparc.S b/src/mapi/es1api/glapi/glapi_sparc.S new file mode 100644 index 00000000000..331f85a8caa --- /dev/null +++ b/src/mapi/es1api/glapi/glapi_sparc.S @@ -0,0 +1,1080 @@ +/* DO NOT EDIT - This file generated automatically by gl_SPARC_asm.py (from Mesa) script */ + +/* + * Copyright (C) 1999-2003 Brian Paul All Rights Reserved. + * (C) Copyright IBM Corporation 2004 + * All Rights Reserved. + * + * Permission is hereby granted, free of charge, to any person obtaining a + * copy of this software and associated documentation files (the "Software"), + * to deal in the Software without restriction, including without limitation + * the rights to use, copy, modify, merge, publish, distribute, sub license, + * and/or sell copies of the Software, and to permit persons to whom the + * Software is furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice (including the next + * paragraph) shall be included in all copies or substantial portions of the + * Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL + * BRIAN PAUL, IBM, + * AND/OR THEIR SUPPLIERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, + * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF + * OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE + * SOFTWARE. + */ + +#ifdef __arch64__ +#define GL_OFF(N) ((N) * 8) +#define GL_LL ldx +#define GL_TIE_LD(SYM) %tie_ldx(SYM) +#define GL_STACK_SIZE 128 +#else +#define GL_OFF(N) ((N) * 4) +#define GL_LL ld +#define GL_TIE_LD(SYM) %tie_ld(SYM) +#define GL_STACK_SIZE 64 +#endif + +#define GLOBL_FN(x) .globl x ; .type x, @function +#define HIDDEN(x) .hidden x + + .register %g2, #scratch + .register %g3, #scratch + + .text + + GLOBL_FN(__glapi_sparc_icache_flush) + HIDDEN(__glapi_sparc_icache_flush) + .type __glapi_sparc_icache_flush, @function +__glapi_sparc_icache_flush: /* %o0 = insn_addr */ + flush %o0 + retl + nop + + .align 32 + + .type __glapi_sparc_get_pc, @function +__glapi_sparc_get_pc: + retl + add %o7, %g2, %g2 + .size __glapi_sparc_get_pc, .-__glapi_sparc_get_pc + +#ifdef GLX_USE_TLS + + GLOBL_FN(__glapi_sparc_get_dispatch) + HIDDEN(__glapi_sparc_get_dispatch) +__glapi_sparc_get_dispatch: + mov %o7, %g1 + sethi %hi(_GLOBAL_OFFSET_TABLE_-4), %g2 + call __glapi_sparc_get_pc + add %g2, %lo(_GLOBAL_OFFSET_TABLE_+4), %g2 + mov %g1, %o7 + sethi %tie_hi22(_glapi_tls_Dispatch), %g1 + add %g1, %tie_lo10(_glapi_tls_Dispatch), %g1 + GL_LL [%g2 + %g1], %g2, GL_TIE_LD(_glapi_tls_Dispatch) + retl + mov %g2, %o0 + + .data + .align 32 + + /* --> sethi %hi(_glapi_tls_Dispatch), %g1 */ + /* --> or %g1, %lo(_glapi_tls_Dispatch), %g1 */ + GLOBL_FN(__glapi_sparc_tls_stub) + HIDDEN(__glapi_sparc_tls_stub) +__glapi_sparc_tls_stub: /* Call offset in %g3 */ + mov %o7, %g1 + sethi %hi(_GLOBAL_OFFSET_TABLE_-4), %g2 + call __glapi_sparc_get_pc + add %g2, %lo(_GLOBAL_OFFSET_TABLE_+4), %g2 + mov %g1, %o7 + srl %g3, 10, %g3 + sethi %tie_hi22(_glapi_tls_Dispatch), %g1 + add %g1, %tie_lo10(_glapi_tls_Dispatch), %g1 + GL_LL [%g2 + %g1], %g2, GL_TIE_LD(_glapi_tls_Dispatch) + GL_LL [%g7+%g2], %g1 + GL_LL [%g1 + %g3], %g1 + jmp %g1 + nop + .size __glapi_sparc_tls_stub, .-__glapi_sparc_tls_stub + +#define GL_STUB(fn, off) \ + GLOBL_FN(fn); \ +fn: ba __glapi_sparc_tls_stub; \ + sethi GL_OFF(off), %g3; \ + .size fn,.-fn; + +#elif defined(PTHREADS) + + /* 64-bit 0x00 --> sethi %hh(_glapi_Dispatch), %g1 */ + /* 64-bit 0x04 --> sethi %lm(_glapi_Dispatch), %g2 */ + /* 64-bit 0x08 --> or %g1, %hm(_glapi_Dispatch), %g1 */ + /* 64-bit 0x0c --> sllx %g1, 32, %g1 */ + /* 64-bit 0x10 --> add %g1, %g2, %g1 */ + /* 64-bit 0x14 --> ldx [%g1 + %lo(_glapi_Dispatch)], %g1 */ + + /* 32-bit 0x00 --> sethi %hi(_glapi_Dispatch), %g1 */ + /* 32-bit 0x04 --> ld [%g1 + %lo(_glapi_Dispatch)], %g1 */ + + .data + .align 32 + + GLOBL_FN(__glapi_sparc_pthread_stub) + HIDDEN(__glapi_sparc_pthread_stub) +__glapi_sparc_pthread_stub: /* Call offset in %g3 */ + mov %o7, %g1 + sethi %hi(_GLOBAL_OFFSET_TABLE_-4), %g2 + call __glapi_sparc_get_pc + add %g2, %lo(_GLOBAL_OFFSET_TABLE_+4), %g2 + mov %g1, %o7 + sethi %hi(_glapi_Dispatch), %g1 + or %g1, %lo(_glapi_Dispatch), %g1 + srl %g3, 10, %g3 + GL_LL [%g2+%g1], %g2 + GL_LL [%g2], %g1 + cmp %g1, 0 + be 2f + nop +1: GL_LL [%g1 + %g3], %g1 + jmp %g1 + nop +2: save %sp, GL_STACK_SIZE, %sp + mov %g3, %l0 + call _glapi_get_dispatch + nop + mov %o0, %g1 + mov %l0, %g3 + ba 1b + restore %g0, %g0, %g0 + .size __glapi_sparc_pthread_stub, .-__glapi_sparc_pthread_stub + +#define GL_STUB(fn, off) \ + GLOBL_FN(fn); \ +fn: ba __glapi_sparc_pthread_stub; \ + sethi GL_OFF(off), %g3; \ + .size fn,.-fn; + +#else /* Non-threaded version. */ + + .type __glapi_sparc_nothread_stub, @function +__glapi_sparc_nothread_stub: /* Call offset in %g3 */ + mov %o7, %g1 + sethi %hi(_GLOBAL_OFFSET_TABLE_-4), %g2 + call __glapi_sparc_get_pc + add %g2, %lo(_GLOBAL_OFFSET_TABLE_+4), %g2 + mov %g1, %o7 + srl %g3, 10, %g3 + sethi %hi(_glapi_Dispatch), %g1 + or %g1, %lo(_glapi_Dispatch), %g1 + GL_LL [%g2+%g1], %g2 + GL_LL [%g2], %g1 + GL_LL [%g1 + %g3], %g1 + jmp %g1 + nop + .size __glapi_sparc_nothread_stub, .-__glapi_sparc_nothread_stub + +#define GL_STUB(fn, off) \ + GLOBL_FN(fn); \ +fn: ba __glapi_sparc_nothread_stub; \ + sethi GL_OFF(off), %g3; \ + .size fn,.-fn; + +#endif + +#define GL_STUB_ALIAS(fn, alias) \ + .globl fn; \ + .set fn, alias + + .text + .align 32 + + .globl gl_dispatch_functions_start + HIDDEN(gl_dispatch_functions_start) +gl_dispatch_functions_start: + + GL_STUB(gl_dispatch_stub_0, 0) + HIDDEN(gl_dispatch_stub_0) + GL_STUB(gl_dispatch_stub_1, 1) + HIDDEN(gl_dispatch_stub_1) + GL_STUB(gl_dispatch_stub_2, 2) + HIDDEN(gl_dispatch_stub_2) + GL_STUB(gl_dispatch_stub_3, 3) + HIDDEN(gl_dispatch_stub_3) + GL_STUB(gl_dispatch_stub_4, 4) + HIDDEN(gl_dispatch_stub_4) + GL_STUB(gl_dispatch_stub_5, 5) + HIDDEN(gl_dispatch_stub_5) + GL_STUB(gl_dispatch_stub_6, 6) + HIDDEN(gl_dispatch_stub_6) + GL_STUB(gl_dispatch_stub_7, 7) + HIDDEN(gl_dispatch_stub_7) + GL_STUB(gl_dispatch_stub_8, 8) + HIDDEN(gl_dispatch_stub_8) + GL_STUB(gl_dispatch_stub_9, 9) + HIDDEN(gl_dispatch_stub_9) + GL_STUB(gl_dispatch_stub_10, 10) + HIDDEN(gl_dispatch_stub_10) + GL_STUB(gl_dispatch_stub_11, 11) + HIDDEN(gl_dispatch_stub_11) + GL_STUB(gl_dispatch_stub_12, 12) + HIDDEN(gl_dispatch_stub_12) + GL_STUB(gl_dispatch_stub_13, 13) + HIDDEN(gl_dispatch_stub_13) + GL_STUB(gl_dispatch_stub_14, 14) + HIDDEN(gl_dispatch_stub_14) + GL_STUB(gl_dispatch_stub_15, 15) + HIDDEN(gl_dispatch_stub_15) + GL_STUB(gl_dispatch_stub_16, 16) + HIDDEN(gl_dispatch_stub_16) + GL_STUB(gl_dispatch_stub_17, 17) + HIDDEN(gl_dispatch_stub_17) + GL_STUB(gl_dispatch_stub_18, 18) + HIDDEN(gl_dispatch_stub_18) + GL_STUB(gl_dispatch_stub_19, 19) + HIDDEN(gl_dispatch_stub_19) + GL_STUB(gl_dispatch_stub_20, 20) + HIDDEN(gl_dispatch_stub_20) + GL_STUB(gl_dispatch_stub_21, 21) + HIDDEN(gl_dispatch_stub_21) + GL_STUB(gl_dispatch_stub_22, 22) + HIDDEN(gl_dispatch_stub_22) + GL_STUB(gl_dispatch_stub_23, 23) + HIDDEN(gl_dispatch_stub_23) + GL_STUB(gl_dispatch_stub_24, 24) + HIDDEN(gl_dispatch_stub_24) + GL_STUB(gl_dispatch_stub_25, 25) + HIDDEN(gl_dispatch_stub_25) + GL_STUB(gl_dispatch_stub_26, 26) + HIDDEN(gl_dispatch_stub_26) + GL_STUB(gl_dispatch_stub_27, 27) + HIDDEN(gl_dispatch_stub_27) + GL_STUB(gl_dispatch_stub_28, 28) + HIDDEN(gl_dispatch_stub_28) + GL_STUB(glColor4f, 29) + GL_STUB(gl_dispatch_stub_30, 30) + HIDDEN(gl_dispatch_stub_30) + GL_STUB(gl_dispatch_stub_31, 31) + HIDDEN(gl_dispatch_stub_31) + GL_STUB(gl_dispatch_stub_32, 32) + HIDDEN(gl_dispatch_stub_32) + GL_STUB(gl_dispatch_stub_33, 33) + HIDDEN(gl_dispatch_stub_33) + GL_STUB(gl_dispatch_stub_34, 34) + HIDDEN(gl_dispatch_stub_34) + GL_STUB(glColor4ub, 35) + GL_STUB(gl_dispatch_stub_36, 36) + HIDDEN(gl_dispatch_stub_36) + GL_STUB(gl_dispatch_stub_37, 37) + HIDDEN(gl_dispatch_stub_37) + GL_STUB(gl_dispatch_stub_38, 38) + HIDDEN(gl_dispatch_stub_38) + GL_STUB(gl_dispatch_stub_39, 39) + HIDDEN(gl_dispatch_stub_39) + GL_STUB(gl_dispatch_stub_40, 40) + HIDDEN(gl_dispatch_stub_40) + GL_STUB(gl_dispatch_stub_41, 41) + HIDDEN(gl_dispatch_stub_41) + GL_STUB(gl_dispatch_stub_42, 42) + HIDDEN(gl_dispatch_stub_42) + GL_STUB(gl_dispatch_stub_43, 43) + HIDDEN(gl_dispatch_stub_43) + GL_STUB(gl_dispatch_stub_44, 44) + HIDDEN(gl_dispatch_stub_44) + GL_STUB(gl_dispatch_stub_45, 45) + HIDDEN(gl_dispatch_stub_45) + GL_STUB(gl_dispatch_stub_46, 46) + HIDDEN(gl_dispatch_stub_46) + GL_STUB(gl_dispatch_stub_47, 47) + HIDDEN(gl_dispatch_stub_47) + GL_STUB(gl_dispatch_stub_48, 48) + HIDDEN(gl_dispatch_stub_48) + GL_STUB(gl_dispatch_stub_49, 49) + HIDDEN(gl_dispatch_stub_49) + GL_STUB(gl_dispatch_stub_50, 50) + HIDDEN(gl_dispatch_stub_50) + GL_STUB(gl_dispatch_stub_51, 51) + HIDDEN(gl_dispatch_stub_51) + GL_STUB(gl_dispatch_stub_52, 52) + HIDDEN(gl_dispatch_stub_52) + GL_STUB(gl_dispatch_stub_53, 53) + HIDDEN(gl_dispatch_stub_53) + GL_STUB(gl_dispatch_stub_54, 54) + HIDDEN(gl_dispatch_stub_54) + GL_STUB(gl_dispatch_stub_55, 55) + HIDDEN(gl_dispatch_stub_55) + GL_STUB(glNormal3f, 56) + GL_STUB(gl_dispatch_stub_57, 57) + HIDDEN(gl_dispatch_stub_57) + GL_STUB(gl_dispatch_stub_58, 58) + HIDDEN(gl_dispatch_stub_58) + GL_STUB(gl_dispatch_stub_59, 59) + HIDDEN(gl_dispatch_stub_59) + GL_STUB(gl_dispatch_stub_60, 60) + HIDDEN(gl_dispatch_stub_60) + GL_STUB(gl_dispatch_stub_61, 61) + HIDDEN(gl_dispatch_stub_61) + GL_STUB(gl_dispatch_stub_62, 62) + HIDDEN(gl_dispatch_stub_62) + GL_STUB(gl_dispatch_stub_63, 63) + HIDDEN(gl_dispatch_stub_63) + GL_STUB(gl_dispatch_stub_64, 64) + HIDDEN(gl_dispatch_stub_64) + GL_STUB(gl_dispatch_stub_65, 65) + HIDDEN(gl_dispatch_stub_65) + GL_STUB(gl_dispatch_stub_66, 66) + HIDDEN(gl_dispatch_stub_66) + GL_STUB(gl_dispatch_stub_67, 67) + HIDDEN(gl_dispatch_stub_67) + GL_STUB(gl_dispatch_stub_68, 68) + HIDDEN(gl_dispatch_stub_68) + GL_STUB(gl_dispatch_stub_69, 69) + HIDDEN(gl_dispatch_stub_69) + GL_STUB(gl_dispatch_stub_70, 70) + HIDDEN(gl_dispatch_stub_70) + GL_STUB(gl_dispatch_stub_71, 71) + HIDDEN(gl_dispatch_stub_71) + GL_STUB(gl_dispatch_stub_72, 72) + HIDDEN(gl_dispatch_stub_72) + GL_STUB(gl_dispatch_stub_73, 73) + HIDDEN(gl_dispatch_stub_73) + GL_STUB(gl_dispatch_stub_74, 74) + HIDDEN(gl_dispatch_stub_74) + GL_STUB(gl_dispatch_stub_75, 75) + HIDDEN(gl_dispatch_stub_75) + GL_STUB(gl_dispatch_stub_76, 76) + HIDDEN(gl_dispatch_stub_76) + GL_STUB(gl_dispatch_stub_77, 77) + HIDDEN(gl_dispatch_stub_77) + GL_STUB(gl_dispatch_stub_78, 78) + HIDDEN(gl_dispatch_stub_78) + GL_STUB(gl_dispatch_stub_79, 79) + HIDDEN(gl_dispatch_stub_79) + GL_STUB(gl_dispatch_stub_80, 80) + HIDDEN(gl_dispatch_stub_80) + GL_STUB(gl_dispatch_stub_81, 81) + HIDDEN(gl_dispatch_stub_81) + GL_STUB(gl_dispatch_stub_82, 82) + HIDDEN(gl_dispatch_stub_82) + GL_STUB(gl_dispatch_stub_83, 83) + HIDDEN(gl_dispatch_stub_83) + GL_STUB(gl_dispatch_stub_84, 84) + HIDDEN(gl_dispatch_stub_84) + GL_STUB(gl_dispatch_stub_85, 85) + HIDDEN(gl_dispatch_stub_85) + GL_STUB(gl_dispatch_stub_86, 86) + HIDDEN(gl_dispatch_stub_86) + GL_STUB(gl_dispatch_stub_87, 87) + HIDDEN(gl_dispatch_stub_87) + GL_STUB(gl_dispatch_stub_88, 88) + HIDDEN(gl_dispatch_stub_88) + GL_STUB(gl_dispatch_stub_89, 89) + HIDDEN(gl_dispatch_stub_89) + GL_STUB(gl_dispatch_stub_90, 90) + HIDDEN(gl_dispatch_stub_90) + GL_STUB(gl_dispatch_stub_91, 91) + HIDDEN(gl_dispatch_stub_91) + GL_STUB(gl_dispatch_stub_92, 92) + HIDDEN(gl_dispatch_stub_92) + GL_STUB(gl_dispatch_stub_93, 93) + HIDDEN(gl_dispatch_stub_93) + GL_STUB(gl_dispatch_stub_94, 94) + HIDDEN(gl_dispatch_stub_94) + GL_STUB(gl_dispatch_stub_95, 95) + HIDDEN(gl_dispatch_stub_95) + GL_STUB(gl_dispatch_stub_96, 96) + HIDDEN(gl_dispatch_stub_96) + GL_STUB(gl_dispatch_stub_97, 97) + HIDDEN(gl_dispatch_stub_97) + GL_STUB(gl_dispatch_stub_98, 98) + HIDDEN(gl_dispatch_stub_98) + GL_STUB(gl_dispatch_stub_99, 99) + HIDDEN(gl_dispatch_stub_99) + GL_STUB(gl_dispatch_stub_100, 100) + HIDDEN(gl_dispatch_stub_100) + GL_STUB(gl_dispatch_stub_101, 101) + HIDDEN(gl_dispatch_stub_101) + GL_STUB(gl_dispatch_stub_102, 102) + HIDDEN(gl_dispatch_stub_102) + GL_STUB(gl_dispatch_stub_103, 103) + HIDDEN(gl_dispatch_stub_103) + GL_STUB(gl_dispatch_stub_104, 104) + HIDDEN(gl_dispatch_stub_104) + GL_STUB(gl_dispatch_stub_105, 105) + HIDDEN(gl_dispatch_stub_105) + GL_STUB(gl_dispatch_stub_106, 106) + HIDDEN(gl_dispatch_stub_106) + GL_STUB(gl_dispatch_stub_107, 107) + HIDDEN(gl_dispatch_stub_107) + GL_STUB(gl_dispatch_stub_108, 108) + HIDDEN(gl_dispatch_stub_108) + GL_STUB(gl_dispatch_stub_109, 109) + HIDDEN(gl_dispatch_stub_109) + GL_STUB(gl_dispatch_stub_110, 110) + HIDDEN(gl_dispatch_stub_110) + GL_STUB(gl_dispatch_stub_111, 111) + HIDDEN(gl_dispatch_stub_111) + GL_STUB(gl_dispatch_stub_112, 112) + HIDDEN(gl_dispatch_stub_112) + GL_STUB(gl_dispatch_stub_113, 113) + HIDDEN(gl_dispatch_stub_113) + GL_STUB(gl_dispatch_stub_114, 114) + HIDDEN(gl_dispatch_stub_114) + GL_STUB(gl_dispatch_stub_115, 115) + HIDDEN(gl_dispatch_stub_115) + GL_STUB(gl_dispatch_stub_116, 116) + HIDDEN(gl_dispatch_stub_116) + GL_STUB(gl_dispatch_stub_117, 117) + HIDDEN(gl_dispatch_stub_117) + GL_STUB(gl_dispatch_stub_118, 118) + HIDDEN(gl_dispatch_stub_118) + GL_STUB(gl_dispatch_stub_119, 119) + HIDDEN(gl_dispatch_stub_119) + GL_STUB(gl_dispatch_stub_120, 120) + HIDDEN(gl_dispatch_stub_120) + GL_STUB(gl_dispatch_stub_121, 121) + HIDDEN(gl_dispatch_stub_121) + GL_STUB(gl_dispatch_stub_122, 122) + HIDDEN(gl_dispatch_stub_122) + GL_STUB(gl_dispatch_stub_123, 123) + HIDDEN(gl_dispatch_stub_123) + GL_STUB(gl_dispatch_stub_124, 124) + HIDDEN(gl_dispatch_stub_124) + GL_STUB(gl_dispatch_stub_125, 125) + HIDDEN(gl_dispatch_stub_125) + GL_STUB(gl_dispatch_stub_126, 126) + HIDDEN(gl_dispatch_stub_126) + GL_STUB(gl_dispatch_stub_127, 127) + HIDDEN(gl_dispatch_stub_127) + GL_STUB(gl_dispatch_stub_128, 128) + HIDDEN(gl_dispatch_stub_128) + GL_STUB(gl_dispatch_stub_129, 129) + HIDDEN(gl_dispatch_stub_129) + GL_STUB(gl_dispatch_stub_130, 130) + HIDDEN(gl_dispatch_stub_130) + GL_STUB(gl_dispatch_stub_131, 131) + HIDDEN(gl_dispatch_stub_131) + GL_STUB(gl_dispatch_stub_132, 132) + HIDDEN(gl_dispatch_stub_132) + GL_STUB(gl_dispatch_stub_133, 133) + HIDDEN(gl_dispatch_stub_133) + GL_STUB(gl_dispatch_stub_134, 134) + HIDDEN(gl_dispatch_stub_134) + GL_STUB(gl_dispatch_stub_135, 135) + HIDDEN(gl_dispatch_stub_135) + GL_STUB(gl_dispatch_stub_136, 136) + HIDDEN(gl_dispatch_stub_136) + GL_STUB(gl_dispatch_stub_137, 137) + HIDDEN(gl_dispatch_stub_137) + GL_STUB(gl_dispatch_stub_138, 138) + HIDDEN(gl_dispatch_stub_138) + GL_STUB(gl_dispatch_stub_139, 139) + HIDDEN(gl_dispatch_stub_139) + GL_STUB(gl_dispatch_stub_140, 140) + HIDDEN(gl_dispatch_stub_140) + GL_STUB(gl_dispatch_stub_141, 141) + HIDDEN(gl_dispatch_stub_141) + GL_STUB(gl_dispatch_stub_142, 142) + HIDDEN(gl_dispatch_stub_142) + GL_STUB(gl_dispatch_stub_143, 143) + HIDDEN(gl_dispatch_stub_143) + GL_STUB(gl_dispatch_stub_144, 144) + HIDDEN(gl_dispatch_stub_144) + GL_STUB(gl_dispatch_stub_145, 145) + HIDDEN(gl_dispatch_stub_145) + GL_STUB(gl_dispatch_stub_146, 146) + HIDDEN(gl_dispatch_stub_146) + GL_STUB(gl_dispatch_stub_147, 147) + HIDDEN(gl_dispatch_stub_147) + GL_STUB(gl_dispatch_stub_148, 148) + HIDDEN(gl_dispatch_stub_148) + GL_STUB(gl_dispatch_stub_149, 149) + HIDDEN(gl_dispatch_stub_149) + GL_STUB(gl_dispatch_stub_150, 150) + HIDDEN(gl_dispatch_stub_150) + GL_STUB(gl_dispatch_stub_151, 151) + HIDDEN(gl_dispatch_stub_151) + GL_STUB(glCullFace, 152) + GL_STUB(glFogf, 153) + GL_STUB(glFogfv, 154) + GL_STUB(gl_dispatch_stub_155, 155) + HIDDEN(gl_dispatch_stub_155) + GL_STUB(gl_dispatch_stub_156, 156) + HIDDEN(gl_dispatch_stub_156) + GL_STUB(glFrontFace, 157) + GL_STUB(glHint, 158) + GL_STUB(glLightf, 159) + GL_STUB(glLightfv, 160) + GL_STUB(gl_dispatch_stub_161, 161) + HIDDEN(gl_dispatch_stub_161) + GL_STUB(gl_dispatch_stub_162, 162) + HIDDEN(gl_dispatch_stub_162) + GL_STUB(glLightModelf, 163) + GL_STUB(glLightModelfv, 164) + GL_STUB(gl_dispatch_stub_165, 165) + HIDDEN(gl_dispatch_stub_165) + GL_STUB(gl_dispatch_stub_166, 166) + HIDDEN(gl_dispatch_stub_166) + GL_STUB(gl_dispatch_stub_167, 167) + HIDDEN(gl_dispatch_stub_167) + GL_STUB(glLineWidth, 168) + GL_STUB(glMaterialf, 169) + GL_STUB(glMaterialfv, 170) + GL_STUB(gl_dispatch_stub_171, 171) + HIDDEN(gl_dispatch_stub_171) + GL_STUB(gl_dispatch_stub_172, 172) + HIDDEN(gl_dispatch_stub_172) + GL_STUB(glPointSize, 173) + GL_STUB(gl_dispatch_stub_174, 174) + HIDDEN(gl_dispatch_stub_174) + GL_STUB(gl_dispatch_stub_175, 175) + HIDDEN(gl_dispatch_stub_175) + GL_STUB(glScissor, 176) + GL_STUB(glShadeModel, 177) + GL_STUB(glTexParameterf, 178) + GL_STUB(glTexParameterfv, 179) + GL_STUB(glTexParameteri, 180) + GL_STUB(glTexParameteriv, 181) + GL_STUB(gl_dispatch_stub_182, 182) + HIDDEN(gl_dispatch_stub_182) + GL_STUB(glTexImage2D, 183) + GL_STUB(glTexEnvf, 184) + GL_STUB(glTexEnvfv, 185) + GL_STUB(glTexEnvi, 186) + GL_STUB(glTexEnviv, 187) + GL_STUB(gl_dispatch_stub_188, 188) + HIDDEN(gl_dispatch_stub_188) + GL_STUB(gl_dispatch_stub_189, 189) + HIDDEN(gl_dispatch_stub_189) + GL_STUB(glTexGenfOES, 190) + GL_STUB(glTexGenfvOES, 191) + GL_STUB(glTexGeniOES, 192) + GL_STUB(glTexGenivOES, 193) + GL_STUB(gl_dispatch_stub_194, 194) + HIDDEN(gl_dispatch_stub_194) + GL_STUB(gl_dispatch_stub_195, 195) + HIDDEN(gl_dispatch_stub_195) + GL_STUB(gl_dispatch_stub_196, 196) + HIDDEN(gl_dispatch_stub_196) + GL_STUB(gl_dispatch_stub_197, 197) + HIDDEN(gl_dispatch_stub_197) + GL_STUB(gl_dispatch_stub_198, 198) + HIDDEN(gl_dispatch_stub_198) + GL_STUB(gl_dispatch_stub_199, 199) + HIDDEN(gl_dispatch_stub_199) + GL_STUB(gl_dispatch_stub_200, 200) + HIDDEN(gl_dispatch_stub_200) + GL_STUB(gl_dispatch_stub_201, 201) + HIDDEN(gl_dispatch_stub_201) + GL_STUB(gl_dispatch_stub_202, 202) + HIDDEN(gl_dispatch_stub_202) + GL_STUB(glClear, 203) + GL_STUB(gl_dispatch_stub_204, 204) + HIDDEN(gl_dispatch_stub_204) + GL_STUB(gl_dispatch_stub_205, 205) + HIDDEN(gl_dispatch_stub_205) + GL_STUB(glClearColor, 206) + GL_STUB(glClearStencil, 207) + GL_STUB(gl_dispatch_stub_208, 208) + HIDDEN(gl_dispatch_stub_208) + GL_STUB(glStencilMask, 209) + GL_STUB(glColorMask, 210) + GL_STUB(glDepthMask, 211) + GL_STUB(gl_dispatch_stub_212, 212) + HIDDEN(gl_dispatch_stub_212) + GL_STUB(gl_dispatch_stub_213, 213) + HIDDEN(gl_dispatch_stub_213) + GL_STUB(glDisable, 214) + GL_STUB(glEnable, 215) + GL_STUB(glFinish, 216) + GL_STUB(glFlush, 217) + GL_STUB(gl_dispatch_stub_218, 218) + HIDDEN(gl_dispatch_stub_218) + GL_STUB(gl_dispatch_stub_219, 219) + HIDDEN(gl_dispatch_stub_219) + GL_STUB(gl_dispatch_stub_220, 220) + HIDDEN(gl_dispatch_stub_220) + GL_STUB(gl_dispatch_stub_221, 221) + HIDDEN(gl_dispatch_stub_221) + GL_STUB(gl_dispatch_stub_222, 222) + HIDDEN(gl_dispatch_stub_222) + GL_STUB(gl_dispatch_stub_223, 223) + HIDDEN(gl_dispatch_stub_223) + GL_STUB(gl_dispatch_stub_224, 224) + HIDDEN(gl_dispatch_stub_224) + GL_STUB(gl_dispatch_stub_225, 225) + HIDDEN(gl_dispatch_stub_225) + GL_STUB(gl_dispatch_stub_226, 226) + HIDDEN(gl_dispatch_stub_226) + GL_STUB(gl_dispatch_stub_227, 227) + HIDDEN(gl_dispatch_stub_227) + GL_STUB(gl_dispatch_stub_228, 228) + HIDDEN(gl_dispatch_stub_228) + GL_STUB(gl_dispatch_stub_229, 229) + HIDDEN(gl_dispatch_stub_229) + GL_STUB(gl_dispatch_stub_230, 230) + HIDDEN(gl_dispatch_stub_230) + GL_STUB(gl_dispatch_stub_231, 231) + HIDDEN(gl_dispatch_stub_231) + GL_STUB(gl_dispatch_stub_232, 232) + HIDDEN(gl_dispatch_stub_232) + GL_STUB(gl_dispatch_stub_233, 233) + HIDDEN(gl_dispatch_stub_233) + GL_STUB(gl_dispatch_stub_234, 234) + HIDDEN(gl_dispatch_stub_234) + GL_STUB(gl_dispatch_stub_235, 235) + HIDDEN(gl_dispatch_stub_235) + GL_STUB(gl_dispatch_stub_236, 236) + HIDDEN(gl_dispatch_stub_236) + GL_STUB(gl_dispatch_stub_237, 237) + HIDDEN(gl_dispatch_stub_237) + GL_STUB(gl_dispatch_stub_238, 238) + HIDDEN(gl_dispatch_stub_238) + GL_STUB(gl_dispatch_stub_239, 239) + HIDDEN(gl_dispatch_stub_239) + GL_STUB(glAlphaFunc, 240) + GL_STUB(glBlendFunc, 241) + GL_STUB(glLogicOp, 242) + GL_STUB(glStencilFunc, 243) + GL_STUB(glStencilOp, 244) + GL_STUB(glDepthFunc, 245) + GL_STUB(gl_dispatch_stub_246, 246) + HIDDEN(gl_dispatch_stub_246) + GL_STUB(gl_dispatch_stub_247, 247) + HIDDEN(gl_dispatch_stub_247) + GL_STUB(gl_dispatch_stub_248, 248) + HIDDEN(gl_dispatch_stub_248) + GL_STUB(gl_dispatch_stub_249, 249) + HIDDEN(gl_dispatch_stub_249) + GL_STUB(glPixelStorei, 250) + GL_STUB(gl_dispatch_stub_251, 251) + HIDDEN(gl_dispatch_stub_251) + GL_STUB(gl_dispatch_stub_252, 252) + HIDDEN(gl_dispatch_stub_252) + GL_STUB(gl_dispatch_stub_253, 253) + HIDDEN(gl_dispatch_stub_253) + GL_STUB(gl_dispatch_stub_254, 254) + HIDDEN(gl_dispatch_stub_254) + GL_STUB(gl_dispatch_stub_255, 255) + HIDDEN(gl_dispatch_stub_255) + GL_STUB(glReadPixels, 256) + GL_STUB(gl_dispatch_stub_257, 257) + HIDDEN(gl_dispatch_stub_257) + GL_STUB(glGetBooleanv, 258) + GL_STUB(gl_dispatch_stub_259, 259) + HIDDEN(gl_dispatch_stub_259) + GL_STUB(gl_dispatch_stub_260, 260) + HIDDEN(gl_dispatch_stub_260) + GL_STUB(glGetError, 261) + GL_STUB(glGetFloatv, 262) + GL_STUB(glGetIntegerv, 263) + GL_STUB(glGetLightfv, 264) + GL_STUB(gl_dispatch_stub_265, 265) + HIDDEN(gl_dispatch_stub_265) + GL_STUB(gl_dispatch_stub_266, 266) + HIDDEN(gl_dispatch_stub_266) + GL_STUB(gl_dispatch_stub_267, 267) + HIDDEN(gl_dispatch_stub_267) + GL_STUB(gl_dispatch_stub_268, 268) + HIDDEN(gl_dispatch_stub_268) + GL_STUB(glGetMaterialfv, 269) + GL_STUB(gl_dispatch_stub_270, 270) + HIDDEN(gl_dispatch_stub_270) + GL_STUB(gl_dispatch_stub_271, 271) + HIDDEN(gl_dispatch_stub_271) + GL_STUB(gl_dispatch_stub_272, 272) + HIDDEN(gl_dispatch_stub_272) + GL_STUB(gl_dispatch_stub_273, 273) + HIDDEN(gl_dispatch_stub_273) + GL_STUB(gl_dispatch_stub_274, 274) + HIDDEN(gl_dispatch_stub_274) + GL_STUB(glGetString, 275) + GL_STUB(glGetTexEnvfv, 276) + GL_STUB(glGetTexEnviv, 277) + GL_STUB(gl_dispatch_stub_278, 278) + HIDDEN(gl_dispatch_stub_278) + GL_STUB(glGetTexGenfvOES, 279) + GL_STUB(glGetTexGenivOES, 280) + GL_STUB(gl_dispatch_stub_281, 281) + HIDDEN(gl_dispatch_stub_281) + GL_STUB(glGetTexParameterfv, 282) + GL_STUB(glGetTexParameteriv, 283) + GL_STUB(gl_dispatch_stub_284, 284) + HIDDEN(gl_dispatch_stub_284) + GL_STUB(gl_dispatch_stub_285, 285) + HIDDEN(gl_dispatch_stub_285) + GL_STUB(glIsEnabled, 286) + GL_STUB(gl_dispatch_stub_287, 287) + HIDDEN(gl_dispatch_stub_287) + GL_STUB(gl_dispatch_stub_288, 288) + HIDDEN(gl_dispatch_stub_288) + GL_STUB(gl_dispatch_stub_289, 289) + HIDDEN(gl_dispatch_stub_289) + GL_STUB(glLoadIdentity, 290) + GL_STUB(glLoadMatrixf, 291) + GL_STUB(gl_dispatch_stub_292, 292) + HIDDEN(gl_dispatch_stub_292) + GL_STUB(glMatrixMode, 293) + GL_STUB(glMultMatrixf, 294) + GL_STUB(gl_dispatch_stub_295, 295) + HIDDEN(gl_dispatch_stub_295) + GL_STUB(gl_dispatch_stub_296, 296) + HIDDEN(gl_dispatch_stub_296) + GL_STUB(glPopMatrix, 297) + GL_STUB(glPushMatrix, 298) + GL_STUB(gl_dispatch_stub_299, 299) + HIDDEN(gl_dispatch_stub_299) + GL_STUB(glRotatef, 300) + GL_STUB(gl_dispatch_stub_301, 301) + HIDDEN(gl_dispatch_stub_301) + GL_STUB(glScalef, 302) + GL_STUB(gl_dispatch_stub_303, 303) + HIDDEN(gl_dispatch_stub_303) + GL_STUB(glTranslatef, 304) + GL_STUB(glViewport, 305) + GL_STUB(gl_dispatch_stub_306, 306) + HIDDEN(gl_dispatch_stub_306) + GL_STUB(glBindTexture, 307) + GL_STUB(glColorPointer, 308) + GL_STUB(glDisableClientState, 309) + GL_STUB(glDrawArrays, 310) + GL_STUB(glDrawElements, 311) + GL_STUB(gl_dispatch_stub_312, 312) + HIDDEN(gl_dispatch_stub_312) + GL_STUB(glEnableClientState, 313) + GL_STUB(gl_dispatch_stub_314, 314) + HIDDEN(gl_dispatch_stub_314) + GL_STUB(gl_dispatch_stub_315, 315) + HIDDEN(gl_dispatch_stub_315) + GL_STUB(gl_dispatch_stub_316, 316) + HIDDEN(gl_dispatch_stub_316) + GL_STUB(gl_dispatch_stub_317, 317) + HIDDEN(gl_dispatch_stub_317) + GL_STUB(glNormalPointer, 318) + GL_STUB(glPolygonOffset, 319) + GL_STUB(glTexCoordPointer, 320) + GL_STUB(glVertexPointer, 321) + GL_STUB(gl_dispatch_stub_322, 322) + HIDDEN(gl_dispatch_stub_322) + GL_STUB(gl_dispatch_stub_323, 323) + HIDDEN(gl_dispatch_stub_323) + GL_STUB(glCopyTexImage2D, 324) + GL_STUB(gl_dispatch_stub_325, 325) + HIDDEN(gl_dispatch_stub_325) + GL_STUB(glCopyTexSubImage2D, 326) + GL_STUB(glDeleteTextures, 327) + GL_STUB(glGenTextures, 328) + GL_STUB(glGetPointerv, 329) + GL_STUB(glIsTexture, 330) + GL_STUB(gl_dispatch_stub_331, 331) + HIDDEN(gl_dispatch_stub_331) + GL_STUB(gl_dispatch_stub_332, 332) + HIDDEN(gl_dispatch_stub_332) + GL_STUB(glTexSubImage2D, 333) + GL_STUB(gl_dispatch_stub_334, 334) + HIDDEN(gl_dispatch_stub_334) + GL_STUB(gl_dispatch_stub_335, 335) + HIDDEN(gl_dispatch_stub_335) + GL_STUB(gl_dispatch_stub_336, 336) + HIDDEN(gl_dispatch_stub_336) + GL_STUB(glBlendEquationOES, 337) + GL_STUB(gl_dispatch_stub_338, 338) + HIDDEN(gl_dispatch_stub_338) + GL_STUB(gl_dispatch_stub_339, 339) + HIDDEN(gl_dispatch_stub_339) + GL_STUB(gl_dispatch_stub_340, 340) + HIDDEN(gl_dispatch_stub_340) + GL_STUB(gl_dispatch_stub_341, 341) + HIDDEN(gl_dispatch_stub_341) + GL_STUB(gl_dispatch_stub_342, 342) + HIDDEN(gl_dispatch_stub_342) + GL_STUB(gl_dispatch_stub_343, 343) + HIDDEN(gl_dispatch_stub_343) + GL_STUB(gl_dispatch_stub_344, 344) + HIDDEN(gl_dispatch_stub_344) + GL_STUB(gl_dispatch_stub_345, 345) + HIDDEN(gl_dispatch_stub_345) + GL_STUB(gl_dispatch_stub_346, 346) + HIDDEN(gl_dispatch_stub_346) + GL_STUB(gl_dispatch_stub_347, 347) + HIDDEN(gl_dispatch_stub_347) + GL_STUB(gl_dispatch_stub_348, 348) + HIDDEN(gl_dispatch_stub_348) + GL_STUB(gl_dispatch_stub_349, 349) + HIDDEN(gl_dispatch_stub_349) + GL_STUB(gl_dispatch_stub_350, 350) + HIDDEN(gl_dispatch_stub_350) + GL_STUB(gl_dispatch_stub_351, 351) + HIDDEN(gl_dispatch_stub_351) + GL_STUB(gl_dispatch_stub_352, 352) + HIDDEN(gl_dispatch_stub_352) + GL_STUB(gl_dispatch_stub_353, 353) + HIDDEN(gl_dispatch_stub_353) + GL_STUB(gl_dispatch_stub_354, 354) + HIDDEN(gl_dispatch_stub_354) + GL_STUB(gl_dispatch_stub_355, 355) + HIDDEN(gl_dispatch_stub_355) + GL_STUB(gl_dispatch_stub_356, 356) + HIDDEN(gl_dispatch_stub_356) + GL_STUB(gl_dispatch_stub_357, 357) + HIDDEN(gl_dispatch_stub_357) + GL_STUB(gl_dispatch_stub_358, 358) + HIDDEN(gl_dispatch_stub_358) + GL_STUB(gl_dispatch_stub_359, 359) + HIDDEN(gl_dispatch_stub_359) + GL_STUB(gl_dispatch_stub_360, 360) + HIDDEN(gl_dispatch_stub_360) + GL_STUB(gl_dispatch_stub_361, 361) + HIDDEN(gl_dispatch_stub_361) + GL_STUB(gl_dispatch_stub_362, 362) + HIDDEN(gl_dispatch_stub_362) + GL_STUB(gl_dispatch_stub_363, 363) + HIDDEN(gl_dispatch_stub_363) + GL_STUB(gl_dispatch_stub_364, 364) + HIDDEN(gl_dispatch_stub_364) + GL_STUB(gl_dispatch_stub_365, 365) + HIDDEN(gl_dispatch_stub_365) + GL_STUB(gl_dispatch_stub_366, 366) + HIDDEN(gl_dispatch_stub_366) + GL_STUB(gl_dispatch_stub_367, 367) + HIDDEN(gl_dispatch_stub_367) + GL_STUB(gl_dispatch_stub_368, 368) + HIDDEN(gl_dispatch_stub_368) + GL_STUB(gl_dispatch_stub_369, 369) + HIDDEN(gl_dispatch_stub_369) + GL_STUB(gl_dispatch_stub_370, 370) + HIDDEN(gl_dispatch_stub_370) + GL_STUB(gl_dispatch_stub_371, 371) + HIDDEN(gl_dispatch_stub_371) + GL_STUB(gl_dispatch_stub_372, 372) + HIDDEN(gl_dispatch_stub_372) + GL_STUB(gl_dispatch_stub_373, 373) + HIDDEN(gl_dispatch_stub_373) + GL_STUB(glActiveTexture, 374) + GL_STUB(glClientActiveTexture, 375) + GL_STUB(gl_dispatch_stub_376, 376) + HIDDEN(gl_dispatch_stub_376) + GL_STUB(gl_dispatch_stub_377, 377) + HIDDEN(gl_dispatch_stub_377) + GL_STUB(gl_dispatch_stub_378, 378) + HIDDEN(gl_dispatch_stub_378) + GL_STUB(gl_dispatch_stub_379, 379) + HIDDEN(gl_dispatch_stub_379) + GL_STUB(gl_dispatch_stub_380, 380) + HIDDEN(gl_dispatch_stub_380) + GL_STUB(gl_dispatch_stub_381, 381) + HIDDEN(gl_dispatch_stub_381) + GL_STUB(gl_dispatch_stub_382, 382) + HIDDEN(gl_dispatch_stub_382) + GL_STUB(gl_dispatch_stub_383, 383) + HIDDEN(gl_dispatch_stub_383) + GL_STUB(gl_dispatch_stub_384, 384) + HIDDEN(gl_dispatch_stub_384) + GL_STUB(gl_dispatch_stub_385, 385) + HIDDEN(gl_dispatch_stub_385) + GL_STUB(gl_dispatch_stub_386, 386) + HIDDEN(gl_dispatch_stub_386) + GL_STUB(gl_dispatch_stub_387, 387) + HIDDEN(gl_dispatch_stub_387) + GL_STUB(gl_dispatch_stub_388, 388) + HIDDEN(gl_dispatch_stub_388) + GL_STUB(gl_dispatch_stub_389, 389) + HIDDEN(gl_dispatch_stub_389) + GL_STUB(gl_dispatch_stub_390, 390) + HIDDEN(gl_dispatch_stub_390) + GL_STUB(gl_dispatch_stub_391, 391) + HIDDEN(gl_dispatch_stub_391) + GL_STUB(gl_dispatch_stub_392, 392) + HIDDEN(gl_dispatch_stub_392) + GL_STUB(gl_dispatch_stub_393, 393) + HIDDEN(gl_dispatch_stub_393) + GL_STUB(gl_dispatch_stub_394, 394) + HIDDEN(gl_dispatch_stub_394) + GL_STUB(gl_dispatch_stub_395, 395) + HIDDEN(gl_dispatch_stub_395) + GL_STUB(gl_dispatch_stub_396, 396) + HIDDEN(gl_dispatch_stub_396) + GL_STUB(gl_dispatch_stub_397, 397) + HIDDEN(gl_dispatch_stub_397) + GL_STUB(gl_dispatch_stub_398, 398) + HIDDEN(gl_dispatch_stub_398) + GL_STUB(gl_dispatch_stub_399, 399) + HIDDEN(gl_dispatch_stub_399) + GL_STUB(gl_dispatch_stub_400, 400) + HIDDEN(gl_dispatch_stub_400) + GL_STUB(gl_dispatch_stub_401, 401) + HIDDEN(gl_dispatch_stub_401) + GL_STUB(glMultiTexCoord4f, 402) + GL_STUB(gl_dispatch_stub_403, 403) + HIDDEN(gl_dispatch_stub_403) + GL_STUB(gl_dispatch_stub_404, 404) + HIDDEN(gl_dispatch_stub_404) + GL_STUB(gl_dispatch_stub_405, 405) + HIDDEN(gl_dispatch_stub_405) + GL_STUB(gl_dispatch_stub_406, 406) + HIDDEN(gl_dispatch_stub_406) + GL_STUB(gl_dispatch_stub_407, 407) + HIDDEN(gl_dispatch_stub_407) + GL_STUB(glBlendEquationSeparateOES, 408) + GL_STUB(glBlendFuncSeparateOES, 409) + GL_STUB(glDrawTexfOES, 410) + GL_STUB(glDrawTexfvOES, 411) + GL_STUB(glDrawTexiOES, 412) + GL_STUB(glDrawTexivOES, 413) + GL_STUB(glDrawTexsOES, 414) + GL_STUB(glDrawTexsvOES, 415) + GL_STUB(glDrawTexxOES, 416) + GL_STUB(glDrawTexxvOES, 417) + GL_STUB(glBindFramebufferOES, 418) + GL_STUB(glBindRenderbufferOES, 419) + GL_STUB(glCheckFramebufferStatusOES, 420) + GL_STUB(glDeleteFramebuffersOES, 421) + GL_STUB(glDeleteRenderbuffersOES, 422) + GL_STUB(glFramebufferRenderbufferOES, 423) + GL_STUB(glFramebufferTexture2DOES, 424) + GL_STUB(glGenFramebuffersOES, 425) + GL_STUB(glGenRenderbuffersOES, 426) + GL_STUB(glGenerateMipmapOES, 427) + GL_STUB(glGetFramebufferAttachmentParameterivOES, 428) + GL_STUB(glGetRenderbufferParameterivOES, 429) + GL_STUB(glIsFramebufferOES, 430) + GL_STUB(glIsRenderbufferOES, 431) + GL_STUB(glRenderbufferStorageOES, 432) + GL_STUB(glPointSizePointerOES, 433) + GL_STUB(glQueryMatrixxOES, 434) + GL_STUB(glGetTexGenxvOES, 435) + GL_STUB(glTexGenxOES, 436) + GL_STUB(glTexGenxvOES, 437) + GL_STUB(glGetBufferPointervOES, 438) + GL_STUB(glMapBufferOES, 439) + GL_STUB(glUnmapBufferOES, 440) + GL_STUB(glMultiDrawArraysEXT, 441) + GL_STUB(glMultiDrawElementsEXT, 442) + GL_STUB(gl_dispatch_stub_443, 443) + HIDDEN(gl_dispatch_stub_443) + GL_STUB(gl_dispatch_stub_444, 444) + HIDDEN(gl_dispatch_stub_444) + GL_STUB(gl_dispatch_stub_445, 445) + HIDDEN(gl_dispatch_stub_445) + GL_STUB(gl_dispatch_stub_446, 446) + HIDDEN(gl_dispatch_stub_446) + GL_STUB(glEGLImageTargetRenderbufferStorageOES, 447) + GL_STUB(glEGLImageTargetTexture2DOES, 448) + GL_STUB(glCompressedTexImage2D, 449) + GL_STUB(glCompressedTexSubImage2D, 450) + GL_STUB(glSampleCoverage, 451) + GL_STUB(glBindBuffer, 452) + GL_STUB(glBufferData, 453) + GL_STUB(glBufferSubData, 454) + GL_STUB(glDeleteBuffers, 455) + GL_STUB(glGenBuffers, 456) + GL_STUB(glGetBufferParameteriv, 457) + GL_STUB(glIsBuffer, 458) + GL_STUB(glPointParameterf, 459) + GL_STUB(glPointParameterfv, 460) + GL_STUB(glAlphaFuncx, 461) + GL_STUB(glClearColorx, 462) + GL_STUB(glClearDepthf, 463) + GL_STUB(glClearDepthx, 464) + GL_STUB(glColor4x, 465) + GL_STUB(glDepthRangef, 466) + GL_STUB(glDepthRangex, 467) + GL_STUB(glFogx, 468) + GL_STUB(glFogxv, 469) + GL_STUB(glFrustumf, 470) + GL_STUB(glFrustumx, 471) + GL_STUB(glLightModelx, 472) + GL_STUB(glLightModelxv, 473) + GL_STUB(glLightx, 474) + GL_STUB(glLightxv, 475) + GL_STUB(glLineWidthx, 476) + GL_STUB(glLoadMatrixx, 477) + GL_STUB(glMaterialx, 478) + GL_STUB(glMaterialxv, 479) + GL_STUB(glMultMatrixx, 480) + GL_STUB(glMultiTexCoord4x, 481) + GL_STUB(glNormal3x, 482) + GL_STUB(glOrthof, 483) + GL_STUB(glOrthox, 484) + GL_STUB(glPointSizex, 485) + GL_STUB(glPolygonOffsetx, 486) + GL_STUB(glRotatex, 487) + GL_STUB(glSampleCoveragex, 488) + GL_STUB(glScalex, 489) + GL_STUB(glTexEnvx, 490) + GL_STUB(glTexEnvxv, 491) + GL_STUB(glTexParameterx, 492) + GL_STUB(glTranslatex, 493) + GL_STUB(glClipPlanef, 494) + GL_STUB(glClipPlanex, 495) + GL_STUB(glGetClipPlanef, 496) + GL_STUB(glGetClipPlanex, 497) + GL_STUB(glGetFixedv, 498) + GL_STUB(glGetLightxv, 499) + GL_STUB(glGetMaterialxv, 500) + GL_STUB(glGetTexEnvxv, 501) + GL_STUB(glGetTexParameterxv, 502) + GL_STUB(glPointParameterx, 503) + GL_STUB(glPointParameterxv, 504) + GL_STUB(glTexParameterxv, 505) + GL_STUB_ALIAS(glTexGenf, glTexGenfOES) + GL_STUB_ALIAS(glTexGenfv, glTexGenfvOES) + GL_STUB_ALIAS(glTexGeni, glTexGeniOES) + GL_STUB_ALIAS(glTexGeniv, glTexGenivOES) + GL_STUB_ALIAS(glGetTexGenfv, glGetTexGenfvOES) + GL_STUB_ALIAS(glGetTexGeniv, glGetTexGenivOES) + GL_STUB_ALIAS(glBlendEquation, glBlendEquationOES) + GL_STUB_ALIAS(glActiveTextureARB, glActiveTexture) + GL_STUB_ALIAS(glClientActiveTextureARB, glClientActiveTexture) + GL_STUB_ALIAS(glMultiTexCoord4fARB, glMultiTexCoord4f) + GL_STUB_ALIAS(glAlphaFuncxOES, glAlphaFuncx) + GL_STUB_ALIAS(glClearColorxOES, glClearColorx) + GL_STUB_ALIAS(glClearDepthfOES, glClearDepthf) + GL_STUB_ALIAS(glClearDepthxOES, glClearDepthx) + GL_STUB_ALIAS(glColor4xOES, glColor4x) + GL_STUB_ALIAS(glDepthRangefOES, glDepthRangef) + GL_STUB_ALIAS(glDepthRangexOES, glDepthRangex) + GL_STUB_ALIAS(glFogxOES, glFogx) + GL_STUB_ALIAS(glFogxvOES, glFogxv) + GL_STUB_ALIAS(glFrustumfOES, glFrustumf) + GL_STUB_ALIAS(glFrustumxOES, glFrustumx) + GL_STUB_ALIAS(glLightModelxOES, glLightModelx) + GL_STUB_ALIAS(glLightModelxvOES, glLightModelxv) + GL_STUB_ALIAS(glLightxOES, glLightx) + GL_STUB_ALIAS(glLightxvOES, glLightxv) + GL_STUB_ALIAS(glLineWidthxOES, glLineWidthx) + GL_STUB_ALIAS(glLoadMatrixxOES, glLoadMatrixx) + GL_STUB_ALIAS(glMaterialxOES, glMaterialx) + GL_STUB_ALIAS(glMaterialxvOES, glMaterialxv) + GL_STUB_ALIAS(glMultMatrixxOES, glMultMatrixx) + GL_STUB_ALIAS(glMultiTexCoord4xOES, glMultiTexCoord4x) + GL_STUB_ALIAS(glNormal3xOES, glNormal3x) + GL_STUB_ALIAS(glOrthofOES, glOrthof) + GL_STUB_ALIAS(glOrthoxOES, glOrthox) + GL_STUB_ALIAS(glPointSizexOES, glPointSizex) + GL_STUB_ALIAS(glPolygonOffsetxOES, glPolygonOffsetx) + GL_STUB_ALIAS(glRotatexOES, glRotatex) + GL_STUB_ALIAS(glSampleCoveragexOES, glSampleCoveragex) + GL_STUB_ALIAS(glScalexOES, glScalex) + GL_STUB_ALIAS(glTexEnvxOES, glTexEnvx) + GL_STUB_ALIAS(glTexEnvxvOES, glTexEnvxv) + GL_STUB_ALIAS(glTexParameterxOES, glTexParameterx) + GL_STUB_ALIAS(glTranslatexOES, glTranslatex) + GL_STUB_ALIAS(glClipPlanefOES, glClipPlanef) + GL_STUB_ALIAS(glClipPlanexOES, glClipPlanex) + GL_STUB_ALIAS(glGetClipPlanefOES, glGetClipPlanef) + GL_STUB_ALIAS(glGetClipPlanexOES, glGetClipPlanex) + GL_STUB_ALIAS(glGetFixedvOES, glGetFixedv) + GL_STUB_ALIAS(glGetLightxvOES, glGetLightxv) + GL_STUB_ALIAS(glGetMaterialxvOES, glGetMaterialxv) + GL_STUB_ALIAS(glGetTexEnvxvOES, glGetTexEnvxv) + GL_STUB_ALIAS(glGetTexParameterxvOES, glGetTexParameterxv) + GL_STUB_ALIAS(glPointParameterxOES, glPointParameterx) + GL_STUB_ALIAS(glPointParameterxvOES, glPointParameterxv) + GL_STUB_ALIAS(glTexParameterxvOES, glTexParameterxv) + + .globl gl_dispatch_functions_end + HIDDEN(gl_dispatch_functions_end) +gl_dispatch_functions_end: diff --git a/src/mapi/es1api/glapi/glapi_x86-64.S b/src/mapi/es1api/glapi/glapi_x86-64.S new file mode 100644 index 00000000000..7fe97e53a1b --- /dev/null +++ b/src/mapi/es1api/glapi/glapi_x86-64.S @@ -0,0 +1,19246 @@ +/* DO NOT EDIT - This file generated automatically by gl_x86-64_asm.py (from Mesa) script */ + +/* + * (C) Copyright IBM Corporation 2005 + * All Rights Reserved. + * + * Permission is hereby granted, free of charge, to any person obtaining a + * copy of this software and associated documentation files (the "Software"), + * to deal in the Software without restriction, including without limitation + * the rights to use, copy, modify, merge, publish, distribute, sub license, + * and/or sell copies of the Software, and to permit persons to whom the + * Software is furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice (including the next + * paragraph) shall be included in all copies or substantial portions of the + * Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL + * IBM, + * AND/OR THEIR SUPPLIERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, + * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF + * OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE + * SOFTWARE. + */ + +/* If we build with gcc's -fvisibility=hidden flag, we'll need to change + * the symbol visibility mode to 'default'. + */ + +#include "x86/assyntax.h" + +#ifdef __GNUC__ +# pragma GCC visibility push(default) +# define HIDDEN(x) .hidden x +#else +# define HIDDEN(x) +#endif + +# if defined(USE_MGL_NAMESPACE) +# define GL_PREFIX(n) GLNAME(CONCAT(mgl,n)) +# define _glapi_Dispatch _mglapi_Dispatch +# else +# define GL_PREFIX(n) GLNAME(CONCAT(gl,n)) +# endif + +#if defined(PTHREADS) || defined(WIN32) || defined(BEOS_THREADS) +# define THREADS +#endif + + .text + +#ifdef GLX_USE_TLS + + .globl _x86_64_get_get_dispatch; HIDDEN(_x86_64_get_get_dispatch) +_x86_64_get_get_dispatch: + lea _x86_64_get_dispatch(%rip), %rax + ret + + .p2align 4,,15 +_x86_64_get_dispatch: + movq _glapi_tls_Dispatch@GOTTPOFF(%rip), %rax + movq %fs:(%rax), %rax + ret + .size _x86_64_get_dispatch, .-_x86_64_get_dispatch + +#elif defined(PTHREADS) + + .extern _glapi_Dispatch + .extern _gl_DispatchTSD + .extern pthread_getspecific + + .p2align 4,,15 +_x86_64_get_dispatch: + movq _gl_DispatchTSD(%rip), %rdi + jmp pthread_getspecific@PLT + +#elif defined(THREADS) + + .extern _glapi_get_dispatch + +#endif + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_0) + .type GL_PREFIX(_dispatch_stub_0), @function + HIDDEN(GL_PREFIX(_dispatch_stub_0)) +GL_PREFIX(_dispatch_stub_0): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 0(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rbp + call _x86_64_get_dispatch@PLT + popq %rbp + popq %rsi + popq %rdi + movq (%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 0(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rbp + call _glapi_get_dispatch + popq %rbp + popq %rsi + popq %rdi + movq 0(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_0), .-GL_PREFIX(_dispatch_stub_0) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_1) + .type GL_PREFIX(_dispatch_stub_1), @function + HIDDEN(GL_PREFIX(_dispatch_stub_1)) +GL_PREFIX(_dispatch_stub_1): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 8(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rbp + call _x86_64_get_dispatch@PLT + popq %rbp + movq 8(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 8(%rax), %r11 + jmp *%r11 +1: + pushq %rbp + call _glapi_get_dispatch + popq %rbp + movq 8(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_1), .-GL_PREFIX(_dispatch_stub_1) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_2) + .type GL_PREFIX(_dispatch_stub_2), @function + HIDDEN(GL_PREFIX(_dispatch_stub_2)) +GL_PREFIX(_dispatch_stub_2): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 16(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + call _x86_64_get_dispatch@PLT + popq %rdi + movq 16(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 16(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + call _glapi_get_dispatch + popq %rdi + movq 16(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_2), .-GL_PREFIX(_dispatch_stub_2) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_3) + .type GL_PREFIX(_dispatch_stub_3), @function + HIDDEN(GL_PREFIX(_dispatch_stub_3)) +GL_PREFIX(_dispatch_stub_3): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 24(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rdx + call _x86_64_get_dispatch@PLT + popq %rdx + popq %rsi + popq %rdi + movq 24(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 24(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rdx + call _glapi_get_dispatch + popq %rdx + popq %rsi + popq %rdi + movq 24(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_3), .-GL_PREFIX(_dispatch_stub_3) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_4) + .type GL_PREFIX(_dispatch_stub_4), @function + HIDDEN(GL_PREFIX(_dispatch_stub_4)) +GL_PREFIX(_dispatch_stub_4): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 32(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rbp + call _x86_64_get_dispatch@PLT + popq %rbp + popq %rsi + popq %rdi + movq 32(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 32(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rbp + call _glapi_get_dispatch + popq %rbp + popq %rsi + popq %rdi + movq 32(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_4), .-GL_PREFIX(_dispatch_stub_4) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_5) + .type GL_PREFIX(_dispatch_stub_5), @function + HIDDEN(GL_PREFIX(_dispatch_stub_5)) +GL_PREFIX(_dispatch_stub_5): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 40(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + call _x86_64_get_dispatch@PLT + popq %rdi + movq 40(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 40(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + call _glapi_get_dispatch + popq %rdi + movq 40(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_5), .-GL_PREFIX(_dispatch_stub_5) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_6) + .type GL_PREFIX(_dispatch_stub_6), @function + HIDDEN(GL_PREFIX(_dispatch_stub_6)) +GL_PREFIX(_dispatch_stub_6): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 48(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + call _x86_64_get_dispatch@PLT + popq %rdi + movq 48(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 48(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + call _glapi_get_dispatch + popq %rdi + movq 48(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_6), .-GL_PREFIX(_dispatch_stub_6) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_7) + .type GL_PREFIX(_dispatch_stub_7), @function + HIDDEN(GL_PREFIX(_dispatch_stub_7)) +GL_PREFIX(_dispatch_stub_7): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 56(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + call _x86_64_get_dispatch@PLT + popq %rdi + movq 56(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 56(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + call _glapi_get_dispatch + popq %rdi + movq 56(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_7), .-GL_PREFIX(_dispatch_stub_7) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_8) + .type GL_PREFIX(_dispatch_stub_8), @function + HIDDEN(GL_PREFIX(_dispatch_stub_8)) +GL_PREFIX(_dispatch_stub_8): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 64(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + subq $56, %rsp + movq %rdi, (%rsp) + movq %rsi, 8(%rsp) + movq %xmm0, 16(%rsp) + movq %xmm1, 24(%rsp) + movq %xmm2, 32(%rsp) + movq %xmm3, 40(%rsp) + movq %rdx, 48(%rsp) + call _x86_64_get_dispatch@PLT + movq 48(%rsp), %rdx + movq 40(%rsp), %xmm3 + movq 32(%rsp), %xmm2 + movq 24(%rsp), %xmm1 + movq 16(%rsp), %xmm0 + movq 8(%rsp), %rsi + movq (%rsp), %rdi + addq $56, %rsp + movq 64(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 64(%rax), %r11 + jmp *%r11 +1: + subq $56, %rsp + movq %rdi, (%rsp) + movq %rsi, 8(%rsp) + movq %xmm0, 16(%rsp) + movq %xmm1, 24(%rsp) + movq %xmm2, 32(%rsp) + movq %xmm3, 40(%rsp) + movq %rdx, 48(%rsp) + call _glapi_get_dispatch + movq 48(%rsp), %rdx + movq 40(%rsp), %xmm3 + movq 32(%rsp), %xmm2 + movq 24(%rsp), %xmm1 + movq 16(%rsp), %xmm0 + movq 8(%rsp), %rsi + movq (%rsp), %rdi + addq $56, %rsp + movq 64(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_8), .-GL_PREFIX(_dispatch_stub_8) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_9) + .type GL_PREFIX(_dispatch_stub_9), @function + HIDDEN(GL_PREFIX(_dispatch_stub_9)) +GL_PREFIX(_dispatch_stub_9): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 72(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rdx + call _x86_64_get_dispatch@PLT + popq %rdx + popq %rsi + popq %rdi + movq 72(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 72(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rdx + call _glapi_get_dispatch + popq %rdx + popq %rsi + popq %rdi + movq 72(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_9), .-GL_PREFIX(_dispatch_stub_9) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_10) + .type GL_PREFIX(_dispatch_stub_10), @function + HIDDEN(GL_PREFIX(_dispatch_stub_10)) +GL_PREFIX(_dispatch_stub_10): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 80(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + call _x86_64_get_dispatch@PLT + popq %rdi + movq 80(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 80(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + call _glapi_get_dispatch + popq %rdi + movq 80(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_10), .-GL_PREFIX(_dispatch_stub_10) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_11) + .type GL_PREFIX(_dispatch_stub_11), @function + HIDDEN(GL_PREFIX(_dispatch_stub_11)) +GL_PREFIX(_dispatch_stub_11): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 88(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + subq $24, %rsp + movq %xmm0, (%rsp) + movq %xmm1, 8(%rsp) + movq %xmm2, 16(%rsp) + call _x86_64_get_dispatch@PLT + movq 16(%rsp), %xmm2 + movq 8(%rsp), %xmm1 + movq (%rsp), %xmm0 + addq $24, %rsp + movq 88(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 88(%rax), %r11 + jmp *%r11 +1: + subq $24, %rsp + movq %xmm0, (%rsp) + movq %xmm1, 8(%rsp) + movq %xmm2, 16(%rsp) + call _glapi_get_dispatch + movq 16(%rsp), %xmm2 + movq 8(%rsp), %xmm1 + movq (%rsp), %xmm0 + addq $24, %rsp + movq 88(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_11), .-GL_PREFIX(_dispatch_stub_11) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_12) + .type GL_PREFIX(_dispatch_stub_12), @function + HIDDEN(GL_PREFIX(_dispatch_stub_12)) +GL_PREFIX(_dispatch_stub_12): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 96(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + call _x86_64_get_dispatch@PLT + popq %rdi + movq 96(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 96(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + call _glapi_get_dispatch + popq %rdi + movq 96(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_12), .-GL_PREFIX(_dispatch_stub_12) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_13) + .type GL_PREFIX(_dispatch_stub_13), @function + HIDDEN(GL_PREFIX(_dispatch_stub_13)) +GL_PREFIX(_dispatch_stub_13): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 104(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + subq $24, %rsp + movq %xmm0, (%rsp) + movq %xmm1, 8(%rsp) + movq %xmm2, 16(%rsp) + call _x86_64_get_dispatch@PLT + movq 16(%rsp), %xmm2 + movq 8(%rsp), %xmm1 + movq (%rsp), %xmm0 + addq $24, %rsp + movq 104(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 104(%rax), %r11 + jmp *%r11 +1: + subq $24, %rsp + movq %xmm0, (%rsp) + movq %xmm1, 8(%rsp) + movq %xmm2, 16(%rsp) + call _glapi_get_dispatch + movq 16(%rsp), %xmm2 + movq 8(%rsp), %xmm1 + movq (%rsp), %xmm0 + addq $24, %rsp + movq 104(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_13), .-GL_PREFIX(_dispatch_stub_13) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_14) + .type GL_PREFIX(_dispatch_stub_14), @function + HIDDEN(GL_PREFIX(_dispatch_stub_14)) +GL_PREFIX(_dispatch_stub_14): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 112(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + call _x86_64_get_dispatch@PLT + popq %rdi + movq 112(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 112(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + call _glapi_get_dispatch + popq %rdi + movq 112(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_14), .-GL_PREFIX(_dispatch_stub_14) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_15) + .type GL_PREFIX(_dispatch_stub_15), @function + HIDDEN(GL_PREFIX(_dispatch_stub_15)) +GL_PREFIX(_dispatch_stub_15): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 120(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rdx + call _x86_64_get_dispatch@PLT + popq %rdx + popq %rsi + popq %rdi + movq 120(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 120(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rdx + call _glapi_get_dispatch + popq %rdx + popq %rsi + popq %rdi + movq 120(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_15), .-GL_PREFIX(_dispatch_stub_15) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_16) + .type GL_PREFIX(_dispatch_stub_16), @function + HIDDEN(GL_PREFIX(_dispatch_stub_16)) +GL_PREFIX(_dispatch_stub_16): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 128(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + call _x86_64_get_dispatch@PLT + popq %rdi + movq 128(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 128(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + call _glapi_get_dispatch + popq %rdi + movq 128(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_16), .-GL_PREFIX(_dispatch_stub_16) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_17) + .type GL_PREFIX(_dispatch_stub_17), @function + HIDDEN(GL_PREFIX(_dispatch_stub_17)) +GL_PREFIX(_dispatch_stub_17): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 136(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rdx + call _x86_64_get_dispatch@PLT + popq %rdx + popq %rsi + popq %rdi + movq 136(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 136(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rdx + call _glapi_get_dispatch + popq %rdx + popq %rsi + popq %rdi + movq 136(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_17), .-GL_PREFIX(_dispatch_stub_17) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_18) + .type GL_PREFIX(_dispatch_stub_18), @function + HIDDEN(GL_PREFIX(_dispatch_stub_18)) +GL_PREFIX(_dispatch_stub_18): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 144(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + call _x86_64_get_dispatch@PLT + popq %rdi + movq 144(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 144(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + call _glapi_get_dispatch + popq %rdi + movq 144(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_18), .-GL_PREFIX(_dispatch_stub_18) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_19) + .type GL_PREFIX(_dispatch_stub_19), @function + HIDDEN(GL_PREFIX(_dispatch_stub_19)) +GL_PREFIX(_dispatch_stub_19): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 152(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rdx + call _x86_64_get_dispatch@PLT + popq %rdx + popq %rsi + popq %rdi + movq 152(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 152(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rdx + call _glapi_get_dispatch + popq %rdx + popq %rsi + popq %rdi + movq 152(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_19), .-GL_PREFIX(_dispatch_stub_19) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_20) + .type GL_PREFIX(_dispatch_stub_20), @function + HIDDEN(GL_PREFIX(_dispatch_stub_20)) +GL_PREFIX(_dispatch_stub_20): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 160(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + call _x86_64_get_dispatch@PLT + popq %rdi + movq 160(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 160(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + call _glapi_get_dispatch + popq %rdi + movq 160(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_20), .-GL_PREFIX(_dispatch_stub_20) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_21) + .type GL_PREFIX(_dispatch_stub_21), @function + HIDDEN(GL_PREFIX(_dispatch_stub_21)) +GL_PREFIX(_dispatch_stub_21): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 168(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rdx + call _x86_64_get_dispatch@PLT + popq %rdx + popq %rsi + popq %rdi + movq 168(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 168(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rdx + call _glapi_get_dispatch + popq %rdx + popq %rsi + popq %rdi + movq 168(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_21), .-GL_PREFIX(_dispatch_stub_21) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_22) + .type GL_PREFIX(_dispatch_stub_22), @function + HIDDEN(GL_PREFIX(_dispatch_stub_22)) +GL_PREFIX(_dispatch_stub_22): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 176(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + call _x86_64_get_dispatch@PLT + popq %rdi + movq 176(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 176(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + call _glapi_get_dispatch + popq %rdi + movq 176(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_22), .-GL_PREFIX(_dispatch_stub_22) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_23) + .type GL_PREFIX(_dispatch_stub_23), @function + HIDDEN(GL_PREFIX(_dispatch_stub_23)) +GL_PREFIX(_dispatch_stub_23): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 184(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rdx + call _x86_64_get_dispatch@PLT + popq %rdx + popq %rsi + popq %rdi + movq 184(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 184(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rdx + call _glapi_get_dispatch + popq %rdx + popq %rsi + popq %rdi + movq 184(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_23), .-GL_PREFIX(_dispatch_stub_23) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_24) + .type GL_PREFIX(_dispatch_stub_24), @function + HIDDEN(GL_PREFIX(_dispatch_stub_24)) +GL_PREFIX(_dispatch_stub_24): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 192(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + call _x86_64_get_dispatch@PLT + popq %rdi + movq 192(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 192(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + call _glapi_get_dispatch + popq %rdi + movq 192(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_24), .-GL_PREFIX(_dispatch_stub_24) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_25) + .type GL_PREFIX(_dispatch_stub_25), @function + HIDDEN(GL_PREFIX(_dispatch_stub_25)) +GL_PREFIX(_dispatch_stub_25): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 200(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rdx + pushq %rcx + pushq %rbp + call _x86_64_get_dispatch@PLT + popq %rbp + popq %rcx + popq %rdx + popq %rsi + popq %rdi + movq 200(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 200(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rdx + pushq %rcx + pushq %rbp + call _glapi_get_dispatch + popq %rbp + popq %rcx + popq %rdx + popq %rsi + popq %rdi + movq 200(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_25), .-GL_PREFIX(_dispatch_stub_25) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_26) + .type GL_PREFIX(_dispatch_stub_26), @function + HIDDEN(GL_PREFIX(_dispatch_stub_26)) +GL_PREFIX(_dispatch_stub_26): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 208(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + call _x86_64_get_dispatch@PLT + popq %rdi + movq 208(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 208(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + call _glapi_get_dispatch + popq %rdi + movq 208(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_26), .-GL_PREFIX(_dispatch_stub_26) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_27) + .type GL_PREFIX(_dispatch_stub_27), @function + HIDDEN(GL_PREFIX(_dispatch_stub_27)) +GL_PREFIX(_dispatch_stub_27): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 216(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + subq $40, %rsp + movq %xmm0, (%rsp) + movq %xmm1, 8(%rsp) + movq %xmm2, 16(%rsp) + movq %xmm3, 24(%rsp) + call _x86_64_get_dispatch@PLT + movq 24(%rsp), %xmm3 + movq 16(%rsp), %xmm2 + movq 8(%rsp), %xmm1 + movq (%rsp), %xmm0 + addq $40, %rsp + movq 216(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 216(%rax), %r11 + jmp *%r11 +1: + subq $40, %rsp + movq %xmm0, (%rsp) + movq %xmm1, 8(%rsp) + movq %xmm2, 16(%rsp) + movq %xmm3, 24(%rsp) + call _glapi_get_dispatch + movq 24(%rsp), %xmm3 + movq 16(%rsp), %xmm2 + movq 8(%rsp), %xmm1 + movq (%rsp), %xmm0 + addq $40, %rsp + movq 216(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_27), .-GL_PREFIX(_dispatch_stub_27) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_28) + .type GL_PREFIX(_dispatch_stub_28), @function + HIDDEN(GL_PREFIX(_dispatch_stub_28)) +GL_PREFIX(_dispatch_stub_28): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 224(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + call _x86_64_get_dispatch@PLT + popq %rdi + movq 224(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 224(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + call _glapi_get_dispatch + popq %rdi + movq 224(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_28), .-GL_PREFIX(_dispatch_stub_28) + + .p2align 4,,15 + .globl GL_PREFIX(Color4f) + .type GL_PREFIX(Color4f), @function +GL_PREFIX(Color4f): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 232(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + subq $40, %rsp + movq %xmm0, (%rsp) + movq %xmm1, 8(%rsp) + movq %xmm2, 16(%rsp) + movq %xmm3, 24(%rsp) + call _x86_64_get_dispatch@PLT + movq 24(%rsp), %xmm3 + movq 16(%rsp), %xmm2 + movq 8(%rsp), %xmm1 + movq (%rsp), %xmm0 + addq $40, %rsp + movq 232(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 232(%rax), %r11 + jmp *%r11 +1: + subq $40, %rsp + movq %xmm0, (%rsp) + movq %xmm1, 8(%rsp) + movq %xmm2, 16(%rsp) + movq %xmm3, 24(%rsp) + call _glapi_get_dispatch + movq 24(%rsp), %xmm3 + movq 16(%rsp), %xmm2 + movq 8(%rsp), %xmm1 + movq (%rsp), %xmm0 + addq $40, %rsp + movq 232(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(Color4f), .-GL_PREFIX(Color4f) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_30) + .type GL_PREFIX(_dispatch_stub_30), @function + HIDDEN(GL_PREFIX(_dispatch_stub_30)) +GL_PREFIX(_dispatch_stub_30): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 240(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + call _x86_64_get_dispatch@PLT + popq %rdi + movq 240(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 240(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + call _glapi_get_dispatch + popq %rdi + movq 240(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_30), .-GL_PREFIX(_dispatch_stub_30) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_31) + .type GL_PREFIX(_dispatch_stub_31), @function + HIDDEN(GL_PREFIX(_dispatch_stub_31)) +GL_PREFIX(_dispatch_stub_31): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 248(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rdx + pushq %rcx + pushq %rbp + call _x86_64_get_dispatch@PLT + popq %rbp + popq %rcx + popq %rdx + popq %rsi + popq %rdi + movq 248(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 248(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rdx + pushq %rcx + pushq %rbp + call _glapi_get_dispatch + popq %rbp + popq %rcx + popq %rdx + popq %rsi + popq %rdi + movq 248(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_31), .-GL_PREFIX(_dispatch_stub_31) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_32) + .type GL_PREFIX(_dispatch_stub_32), @function + HIDDEN(GL_PREFIX(_dispatch_stub_32)) +GL_PREFIX(_dispatch_stub_32): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 256(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + call _x86_64_get_dispatch@PLT + popq %rdi + movq 256(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 256(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + call _glapi_get_dispatch + popq %rdi + movq 256(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_32), .-GL_PREFIX(_dispatch_stub_32) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_33) + .type GL_PREFIX(_dispatch_stub_33), @function + HIDDEN(GL_PREFIX(_dispatch_stub_33)) +GL_PREFIX(_dispatch_stub_33): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 264(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rdx + pushq %rcx + pushq %rbp + call _x86_64_get_dispatch@PLT + popq %rbp + popq %rcx + popq %rdx + popq %rsi + popq %rdi + movq 264(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 264(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rdx + pushq %rcx + pushq %rbp + call _glapi_get_dispatch + popq %rbp + popq %rcx + popq %rdx + popq %rsi + popq %rdi + movq 264(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_33), .-GL_PREFIX(_dispatch_stub_33) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_34) + .type GL_PREFIX(_dispatch_stub_34), @function + HIDDEN(GL_PREFIX(_dispatch_stub_34)) +GL_PREFIX(_dispatch_stub_34): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 272(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + call _x86_64_get_dispatch@PLT + popq %rdi + movq 272(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 272(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + call _glapi_get_dispatch + popq %rdi + movq 272(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_34), .-GL_PREFIX(_dispatch_stub_34) + + .p2align 4,,15 + .globl GL_PREFIX(Color4ub) + .type GL_PREFIX(Color4ub), @function +GL_PREFIX(Color4ub): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 280(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rdx + pushq %rcx + pushq %rbp + call _x86_64_get_dispatch@PLT + popq %rbp + popq %rcx + popq %rdx + popq %rsi + popq %rdi + movq 280(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 280(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rdx + pushq %rcx + pushq %rbp + call _glapi_get_dispatch + popq %rbp + popq %rcx + popq %rdx + popq %rsi + popq %rdi + movq 280(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(Color4ub), .-GL_PREFIX(Color4ub) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_36) + .type GL_PREFIX(_dispatch_stub_36), @function + HIDDEN(GL_PREFIX(_dispatch_stub_36)) +GL_PREFIX(_dispatch_stub_36): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 288(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + call _x86_64_get_dispatch@PLT + popq %rdi + movq 288(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 288(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + call _glapi_get_dispatch + popq %rdi + movq 288(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_36), .-GL_PREFIX(_dispatch_stub_36) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_37) + .type GL_PREFIX(_dispatch_stub_37), @function + HIDDEN(GL_PREFIX(_dispatch_stub_37)) +GL_PREFIX(_dispatch_stub_37): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 296(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rdx + pushq %rcx + pushq %rbp + call _x86_64_get_dispatch@PLT + popq %rbp + popq %rcx + popq %rdx + popq %rsi + popq %rdi + movq 296(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 296(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rdx + pushq %rcx + pushq %rbp + call _glapi_get_dispatch + popq %rbp + popq %rcx + popq %rdx + popq %rsi + popq %rdi + movq 296(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_37), .-GL_PREFIX(_dispatch_stub_37) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_38) + .type GL_PREFIX(_dispatch_stub_38), @function + HIDDEN(GL_PREFIX(_dispatch_stub_38)) +GL_PREFIX(_dispatch_stub_38): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 304(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + call _x86_64_get_dispatch@PLT + popq %rdi + movq 304(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 304(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + call _glapi_get_dispatch + popq %rdi + movq 304(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_38), .-GL_PREFIX(_dispatch_stub_38) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_39) + .type GL_PREFIX(_dispatch_stub_39), @function + HIDDEN(GL_PREFIX(_dispatch_stub_39)) +GL_PREFIX(_dispatch_stub_39): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 312(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rdx + pushq %rcx + pushq %rbp + call _x86_64_get_dispatch@PLT + popq %rbp + popq %rcx + popq %rdx + popq %rsi + popq %rdi + movq 312(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 312(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rdx + pushq %rcx + pushq %rbp + call _glapi_get_dispatch + popq %rbp + popq %rcx + popq %rdx + popq %rsi + popq %rdi + movq 312(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_39), .-GL_PREFIX(_dispatch_stub_39) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_40) + .type GL_PREFIX(_dispatch_stub_40), @function + HIDDEN(GL_PREFIX(_dispatch_stub_40)) +GL_PREFIX(_dispatch_stub_40): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 320(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + call _x86_64_get_dispatch@PLT + popq %rdi + movq 320(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 320(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + call _glapi_get_dispatch + popq %rdi + movq 320(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_40), .-GL_PREFIX(_dispatch_stub_40) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_41) + .type GL_PREFIX(_dispatch_stub_41), @function + HIDDEN(GL_PREFIX(_dispatch_stub_41)) +GL_PREFIX(_dispatch_stub_41): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 328(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + call _x86_64_get_dispatch@PLT + popq %rdi + movq 328(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 328(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + call _glapi_get_dispatch + popq %rdi + movq 328(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_41), .-GL_PREFIX(_dispatch_stub_41) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_42) + .type GL_PREFIX(_dispatch_stub_42), @function + HIDDEN(GL_PREFIX(_dispatch_stub_42)) +GL_PREFIX(_dispatch_stub_42): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 336(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + call _x86_64_get_dispatch@PLT + popq %rdi + movq 336(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 336(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + call _glapi_get_dispatch + popq %rdi + movq 336(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_42), .-GL_PREFIX(_dispatch_stub_42) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_43) + .type GL_PREFIX(_dispatch_stub_43), @function + HIDDEN(GL_PREFIX(_dispatch_stub_43)) +GL_PREFIX(_dispatch_stub_43): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 344(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rbp + call _x86_64_get_dispatch@PLT + popq %rbp + movq 344(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 344(%rax), %r11 + jmp *%r11 +1: + pushq %rbp + call _glapi_get_dispatch + popq %rbp + movq 344(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_43), .-GL_PREFIX(_dispatch_stub_43) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_44) + .type GL_PREFIX(_dispatch_stub_44), @function + HIDDEN(GL_PREFIX(_dispatch_stub_44)) +GL_PREFIX(_dispatch_stub_44): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 352(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + subq $8, %rsp + movq %xmm0, (%rsp) + call _x86_64_get_dispatch@PLT + movq (%rsp), %xmm0 + addq $8, %rsp + movq 352(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 352(%rax), %r11 + jmp *%r11 +1: + subq $8, %rsp + movq %xmm0, (%rsp) + call _glapi_get_dispatch + movq (%rsp), %xmm0 + addq $8, %rsp + movq 352(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_44), .-GL_PREFIX(_dispatch_stub_44) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_45) + .type GL_PREFIX(_dispatch_stub_45), @function + HIDDEN(GL_PREFIX(_dispatch_stub_45)) +GL_PREFIX(_dispatch_stub_45): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 360(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + call _x86_64_get_dispatch@PLT + popq %rdi + movq 360(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 360(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + call _glapi_get_dispatch + popq %rdi + movq 360(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_45), .-GL_PREFIX(_dispatch_stub_45) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_46) + .type GL_PREFIX(_dispatch_stub_46), @function + HIDDEN(GL_PREFIX(_dispatch_stub_46)) +GL_PREFIX(_dispatch_stub_46): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 368(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + subq $8, %rsp + movq %xmm0, (%rsp) + call _x86_64_get_dispatch@PLT + movq (%rsp), %xmm0 + addq $8, %rsp + movq 368(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 368(%rax), %r11 + jmp *%r11 +1: + subq $8, %rsp + movq %xmm0, (%rsp) + call _glapi_get_dispatch + movq (%rsp), %xmm0 + addq $8, %rsp + movq 368(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_46), .-GL_PREFIX(_dispatch_stub_46) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_47) + .type GL_PREFIX(_dispatch_stub_47), @function + HIDDEN(GL_PREFIX(_dispatch_stub_47)) +GL_PREFIX(_dispatch_stub_47): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 376(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + call _x86_64_get_dispatch@PLT + popq %rdi + movq 376(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 376(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + call _glapi_get_dispatch + popq %rdi + movq 376(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_47), .-GL_PREFIX(_dispatch_stub_47) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_48) + .type GL_PREFIX(_dispatch_stub_48), @function + HIDDEN(GL_PREFIX(_dispatch_stub_48)) +GL_PREFIX(_dispatch_stub_48): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 384(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + call _x86_64_get_dispatch@PLT + popq %rdi + movq 384(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 384(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + call _glapi_get_dispatch + popq %rdi + movq 384(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_48), .-GL_PREFIX(_dispatch_stub_48) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_49) + .type GL_PREFIX(_dispatch_stub_49), @function + HIDDEN(GL_PREFIX(_dispatch_stub_49)) +GL_PREFIX(_dispatch_stub_49): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 392(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + call _x86_64_get_dispatch@PLT + popq %rdi + movq 392(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 392(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + call _glapi_get_dispatch + popq %rdi + movq 392(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_49), .-GL_PREFIX(_dispatch_stub_49) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_50) + .type GL_PREFIX(_dispatch_stub_50), @function + HIDDEN(GL_PREFIX(_dispatch_stub_50)) +GL_PREFIX(_dispatch_stub_50): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 400(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + call _x86_64_get_dispatch@PLT + popq %rdi + movq 400(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 400(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + call _glapi_get_dispatch + popq %rdi + movq 400(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_50), .-GL_PREFIX(_dispatch_stub_50) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_51) + .type GL_PREFIX(_dispatch_stub_51), @function + HIDDEN(GL_PREFIX(_dispatch_stub_51)) +GL_PREFIX(_dispatch_stub_51): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 408(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + call _x86_64_get_dispatch@PLT + popq %rdi + movq 408(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 408(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + call _glapi_get_dispatch + popq %rdi + movq 408(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_51), .-GL_PREFIX(_dispatch_stub_51) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_52) + .type GL_PREFIX(_dispatch_stub_52), @function + HIDDEN(GL_PREFIX(_dispatch_stub_52)) +GL_PREFIX(_dispatch_stub_52): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 416(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rdx + call _x86_64_get_dispatch@PLT + popq %rdx + popq %rsi + popq %rdi + movq 416(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 416(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rdx + call _glapi_get_dispatch + popq %rdx + popq %rsi + popq %rdi + movq 416(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_52), .-GL_PREFIX(_dispatch_stub_52) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_53) + .type GL_PREFIX(_dispatch_stub_53), @function + HIDDEN(GL_PREFIX(_dispatch_stub_53)) +GL_PREFIX(_dispatch_stub_53): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 424(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + call _x86_64_get_dispatch@PLT + popq %rdi + movq 424(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 424(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + call _glapi_get_dispatch + popq %rdi + movq 424(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_53), .-GL_PREFIX(_dispatch_stub_53) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_54) + .type GL_PREFIX(_dispatch_stub_54), @function + HIDDEN(GL_PREFIX(_dispatch_stub_54)) +GL_PREFIX(_dispatch_stub_54): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 432(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + subq $24, %rsp + movq %xmm0, (%rsp) + movq %xmm1, 8(%rsp) + movq %xmm2, 16(%rsp) + call _x86_64_get_dispatch@PLT + movq 16(%rsp), %xmm2 + movq 8(%rsp), %xmm1 + movq (%rsp), %xmm0 + addq $24, %rsp + movq 432(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 432(%rax), %r11 + jmp *%r11 +1: + subq $24, %rsp + movq %xmm0, (%rsp) + movq %xmm1, 8(%rsp) + movq %xmm2, 16(%rsp) + call _glapi_get_dispatch + movq 16(%rsp), %xmm2 + movq 8(%rsp), %xmm1 + movq (%rsp), %xmm0 + addq $24, %rsp + movq 432(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_54), .-GL_PREFIX(_dispatch_stub_54) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_55) + .type GL_PREFIX(_dispatch_stub_55), @function + HIDDEN(GL_PREFIX(_dispatch_stub_55)) +GL_PREFIX(_dispatch_stub_55): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 440(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + call _x86_64_get_dispatch@PLT + popq %rdi + movq 440(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 440(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + call _glapi_get_dispatch + popq %rdi + movq 440(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_55), .-GL_PREFIX(_dispatch_stub_55) + + .p2align 4,,15 + .globl GL_PREFIX(Normal3f) + .type GL_PREFIX(Normal3f), @function +GL_PREFIX(Normal3f): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 448(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + subq $24, %rsp + movq %xmm0, (%rsp) + movq %xmm1, 8(%rsp) + movq %xmm2, 16(%rsp) + call _x86_64_get_dispatch@PLT + movq 16(%rsp), %xmm2 + movq 8(%rsp), %xmm1 + movq (%rsp), %xmm0 + addq $24, %rsp + movq 448(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 448(%rax), %r11 + jmp *%r11 +1: + subq $24, %rsp + movq %xmm0, (%rsp) + movq %xmm1, 8(%rsp) + movq %xmm2, 16(%rsp) + call _glapi_get_dispatch + movq 16(%rsp), %xmm2 + movq 8(%rsp), %xmm1 + movq (%rsp), %xmm0 + addq $24, %rsp + movq 448(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(Normal3f), .-GL_PREFIX(Normal3f) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_57) + .type GL_PREFIX(_dispatch_stub_57), @function + HIDDEN(GL_PREFIX(_dispatch_stub_57)) +GL_PREFIX(_dispatch_stub_57): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 456(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + call _x86_64_get_dispatch@PLT + popq %rdi + movq 456(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 456(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + call _glapi_get_dispatch + popq %rdi + movq 456(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_57), .-GL_PREFIX(_dispatch_stub_57) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_58) + .type GL_PREFIX(_dispatch_stub_58), @function + HIDDEN(GL_PREFIX(_dispatch_stub_58)) +GL_PREFIX(_dispatch_stub_58): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 464(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rdx + call _x86_64_get_dispatch@PLT + popq %rdx + popq %rsi + popq %rdi + movq 464(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 464(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rdx + call _glapi_get_dispatch + popq %rdx + popq %rsi + popq %rdi + movq 464(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_58), .-GL_PREFIX(_dispatch_stub_58) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_59) + .type GL_PREFIX(_dispatch_stub_59), @function + HIDDEN(GL_PREFIX(_dispatch_stub_59)) +GL_PREFIX(_dispatch_stub_59): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 472(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + call _x86_64_get_dispatch@PLT + popq %rdi + movq 472(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 472(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + call _glapi_get_dispatch + popq %rdi + movq 472(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_59), .-GL_PREFIX(_dispatch_stub_59) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_60) + .type GL_PREFIX(_dispatch_stub_60), @function + HIDDEN(GL_PREFIX(_dispatch_stub_60)) +GL_PREFIX(_dispatch_stub_60): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 480(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rdx + call _x86_64_get_dispatch@PLT + popq %rdx + popq %rsi + popq %rdi + movq 480(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 480(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rdx + call _glapi_get_dispatch + popq %rdx + popq %rsi + popq %rdi + movq 480(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_60), .-GL_PREFIX(_dispatch_stub_60) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_61) + .type GL_PREFIX(_dispatch_stub_61), @function + HIDDEN(GL_PREFIX(_dispatch_stub_61)) +GL_PREFIX(_dispatch_stub_61): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 488(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + call _x86_64_get_dispatch@PLT + popq %rdi + movq 488(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 488(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + call _glapi_get_dispatch + popq %rdi + movq 488(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_61), .-GL_PREFIX(_dispatch_stub_61) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_62) + .type GL_PREFIX(_dispatch_stub_62), @function + HIDDEN(GL_PREFIX(_dispatch_stub_62)) +GL_PREFIX(_dispatch_stub_62): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 496(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + subq $24, %rsp + movq %xmm0, (%rsp) + movq %xmm1, 8(%rsp) + call _x86_64_get_dispatch@PLT + movq 8(%rsp), %xmm1 + movq (%rsp), %xmm0 + addq $24, %rsp + movq 496(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 496(%rax), %r11 + jmp *%r11 +1: + subq $24, %rsp + movq %xmm0, (%rsp) + movq %xmm1, 8(%rsp) + call _glapi_get_dispatch + movq 8(%rsp), %xmm1 + movq (%rsp), %xmm0 + addq $24, %rsp + movq 496(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_62), .-GL_PREFIX(_dispatch_stub_62) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_63) + .type GL_PREFIX(_dispatch_stub_63), @function + HIDDEN(GL_PREFIX(_dispatch_stub_63)) +GL_PREFIX(_dispatch_stub_63): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 504(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + call _x86_64_get_dispatch@PLT + popq %rdi + movq 504(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 504(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + call _glapi_get_dispatch + popq %rdi + movq 504(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_63), .-GL_PREFIX(_dispatch_stub_63) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_64) + .type GL_PREFIX(_dispatch_stub_64), @function + HIDDEN(GL_PREFIX(_dispatch_stub_64)) +GL_PREFIX(_dispatch_stub_64): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 512(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + subq $24, %rsp + movq %xmm0, (%rsp) + movq %xmm1, 8(%rsp) + call _x86_64_get_dispatch@PLT + movq 8(%rsp), %xmm1 + movq (%rsp), %xmm0 + addq $24, %rsp + movq 512(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 512(%rax), %r11 + jmp *%r11 +1: + subq $24, %rsp + movq %xmm0, (%rsp) + movq %xmm1, 8(%rsp) + call _glapi_get_dispatch + movq 8(%rsp), %xmm1 + movq (%rsp), %xmm0 + addq $24, %rsp + movq 512(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_64), .-GL_PREFIX(_dispatch_stub_64) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_65) + .type GL_PREFIX(_dispatch_stub_65), @function + HIDDEN(GL_PREFIX(_dispatch_stub_65)) +GL_PREFIX(_dispatch_stub_65): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 520(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + call _x86_64_get_dispatch@PLT + popq %rdi + movq 520(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 520(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + call _glapi_get_dispatch + popq %rdi + movq 520(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_65), .-GL_PREFIX(_dispatch_stub_65) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_66) + .type GL_PREFIX(_dispatch_stub_66), @function + HIDDEN(GL_PREFIX(_dispatch_stub_66)) +GL_PREFIX(_dispatch_stub_66): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 528(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rbp + call _x86_64_get_dispatch@PLT + popq %rbp + popq %rsi + popq %rdi + movq 528(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 528(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rbp + call _glapi_get_dispatch + popq %rbp + popq %rsi + popq %rdi + movq 528(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_66), .-GL_PREFIX(_dispatch_stub_66) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_67) + .type GL_PREFIX(_dispatch_stub_67), @function + HIDDEN(GL_PREFIX(_dispatch_stub_67)) +GL_PREFIX(_dispatch_stub_67): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 536(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + call _x86_64_get_dispatch@PLT + popq %rdi + movq 536(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 536(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + call _glapi_get_dispatch + popq %rdi + movq 536(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_67), .-GL_PREFIX(_dispatch_stub_67) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_68) + .type GL_PREFIX(_dispatch_stub_68), @function + HIDDEN(GL_PREFIX(_dispatch_stub_68)) +GL_PREFIX(_dispatch_stub_68): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 544(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rbp + call _x86_64_get_dispatch@PLT + popq %rbp + popq %rsi + popq %rdi + movq 544(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 544(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rbp + call _glapi_get_dispatch + popq %rbp + popq %rsi + popq %rdi + movq 544(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_68), .-GL_PREFIX(_dispatch_stub_68) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_69) + .type GL_PREFIX(_dispatch_stub_69), @function + HIDDEN(GL_PREFIX(_dispatch_stub_69)) +GL_PREFIX(_dispatch_stub_69): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 552(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + call _x86_64_get_dispatch@PLT + popq %rdi + movq 552(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 552(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + call _glapi_get_dispatch + popq %rdi + movq 552(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_69), .-GL_PREFIX(_dispatch_stub_69) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_70) + .type GL_PREFIX(_dispatch_stub_70), @function + HIDDEN(GL_PREFIX(_dispatch_stub_70)) +GL_PREFIX(_dispatch_stub_70): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 560(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + subq $24, %rsp + movq %xmm0, (%rsp) + movq %xmm1, 8(%rsp) + movq %xmm2, 16(%rsp) + call _x86_64_get_dispatch@PLT + movq 16(%rsp), %xmm2 + movq 8(%rsp), %xmm1 + movq (%rsp), %xmm0 + addq $24, %rsp + movq 560(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 560(%rax), %r11 + jmp *%r11 +1: + subq $24, %rsp + movq %xmm0, (%rsp) + movq %xmm1, 8(%rsp) + movq %xmm2, 16(%rsp) + call _glapi_get_dispatch + movq 16(%rsp), %xmm2 + movq 8(%rsp), %xmm1 + movq (%rsp), %xmm0 + addq $24, %rsp + movq 560(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_70), .-GL_PREFIX(_dispatch_stub_70) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_71) + .type GL_PREFIX(_dispatch_stub_71), @function + HIDDEN(GL_PREFIX(_dispatch_stub_71)) +GL_PREFIX(_dispatch_stub_71): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 568(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + call _x86_64_get_dispatch@PLT + popq %rdi + movq 568(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 568(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + call _glapi_get_dispatch + popq %rdi + movq 568(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_71), .-GL_PREFIX(_dispatch_stub_71) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_72) + .type GL_PREFIX(_dispatch_stub_72), @function + HIDDEN(GL_PREFIX(_dispatch_stub_72)) +GL_PREFIX(_dispatch_stub_72): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 576(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + subq $24, %rsp + movq %xmm0, (%rsp) + movq %xmm1, 8(%rsp) + movq %xmm2, 16(%rsp) + call _x86_64_get_dispatch@PLT + movq 16(%rsp), %xmm2 + movq 8(%rsp), %xmm1 + movq (%rsp), %xmm0 + addq $24, %rsp + movq 576(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 576(%rax), %r11 + jmp *%r11 +1: + subq $24, %rsp + movq %xmm0, (%rsp) + movq %xmm1, 8(%rsp) + movq %xmm2, 16(%rsp) + call _glapi_get_dispatch + movq 16(%rsp), %xmm2 + movq 8(%rsp), %xmm1 + movq (%rsp), %xmm0 + addq $24, %rsp + movq 576(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_72), .-GL_PREFIX(_dispatch_stub_72) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_73) + .type GL_PREFIX(_dispatch_stub_73), @function + HIDDEN(GL_PREFIX(_dispatch_stub_73)) +GL_PREFIX(_dispatch_stub_73): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 584(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + call _x86_64_get_dispatch@PLT + popq %rdi + movq 584(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 584(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + call _glapi_get_dispatch + popq %rdi + movq 584(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_73), .-GL_PREFIX(_dispatch_stub_73) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_74) + .type GL_PREFIX(_dispatch_stub_74), @function + HIDDEN(GL_PREFIX(_dispatch_stub_74)) +GL_PREFIX(_dispatch_stub_74): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 592(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rdx + call _x86_64_get_dispatch@PLT + popq %rdx + popq %rsi + popq %rdi + movq 592(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 592(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rdx + call _glapi_get_dispatch + popq %rdx + popq %rsi + popq %rdi + movq 592(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_74), .-GL_PREFIX(_dispatch_stub_74) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_75) + .type GL_PREFIX(_dispatch_stub_75), @function + HIDDEN(GL_PREFIX(_dispatch_stub_75)) +GL_PREFIX(_dispatch_stub_75): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 600(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + call _x86_64_get_dispatch@PLT + popq %rdi + movq 600(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 600(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + call _glapi_get_dispatch + popq %rdi + movq 600(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_75), .-GL_PREFIX(_dispatch_stub_75) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_76) + .type GL_PREFIX(_dispatch_stub_76), @function + HIDDEN(GL_PREFIX(_dispatch_stub_76)) +GL_PREFIX(_dispatch_stub_76): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 608(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rdx + call _x86_64_get_dispatch@PLT + popq %rdx + popq %rsi + popq %rdi + movq 608(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 608(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rdx + call _glapi_get_dispatch + popq %rdx + popq %rsi + popq %rdi + movq 608(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_76), .-GL_PREFIX(_dispatch_stub_76) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_77) + .type GL_PREFIX(_dispatch_stub_77), @function + HIDDEN(GL_PREFIX(_dispatch_stub_77)) +GL_PREFIX(_dispatch_stub_77): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 616(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + call _x86_64_get_dispatch@PLT + popq %rdi + movq 616(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 616(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + call _glapi_get_dispatch + popq %rdi + movq 616(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_77), .-GL_PREFIX(_dispatch_stub_77) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_78) + .type GL_PREFIX(_dispatch_stub_78), @function + HIDDEN(GL_PREFIX(_dispatch_stub_78)) +GL_PREFIX(_dispatch_stub_78): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 624(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + subq $40, %rsp + movq %xmm0, (%rsp) + movq %xmm1, 8(%rsp) + movq %xmm2, 16(%rsp) + movq %xmm3, 24(%rsp) + call _x86_64_get_dispatch@PLT + movq 24(%rsp), %xmm3 + movq 16(%rsp), %xmm2 + movq 8(%rsp), %xmm1 + movq (%rsp), %xmm0 + addq $40, %rsp + movq 624(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 624(%rax), %r11 + jmp *%r11 +1: + subq $40, %rsp + movq %xmm0, (%rsp) + movq %xmm1, 8(%rsp) + movq %xmm2, 16(%rsp) + movq %xmm3, 24(%rsp) + call _glapi_get_dispatch + movq 24(%rsp), %xmm3 + movq 16(%rsp), %xmm2 + movq 8(%rsp), %xmm1 + movq (%rsp), %xmm0 + addq $40, %rsp + movq 624(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_78), .-GL_PREFIX(_dispatch_stub_78) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_79) + .type GL_PREFIX(_dispatch_stub_79), @function + HIDDEN(GL_PREFIX(_dispatch_stub_79)) +GL_PREFIX(_dispatch_stub_79): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 632(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + call _x86_64_get_dispatch@PLT + popq %rdi + movq 632(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 632(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + call _glapi_get_dispatch + popq %rdi + movq 632(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_79), .-GL_PREFIX(_dispatch_stub_79) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_80) + .type GL_PREFIX(_dispatch_stub_80), @function + HIDDEN(GL_PREFIX(_dispatch_stub_80)) +GL_PREFIX(_dispatch_stub_80): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 640(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + subq $40, %rsp + movq %xmm0, (%rsp) + movq %xmm1, 8(%rsp) + movq %xmm2, 16(%rsp) + movq %xmm3, 24(%rsp) + call _x86_64_get_dispatch@PLT + movq 24(%rsp), %xmm3 + movq 16(%rsp), %xmm2 + movq 8(%rsp), %xmm1 + movq (%rsp), %xmm0 + addq $40, %rsp + movq 640(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 640(%rax), %r11 + jmp *%r11 +1: + subq $40, %rsp + movq %xmm0, (%rsp) + movq %xmm1, 8(%rsp) + movq %xmm2, 16(%rsp) + movq %xmm3, 24(%rsp) + call _glapi_get_dispatch + movq 24(%rsp), %xmm3 + movq 16(%rsp), %xmm2 + movq 8(%rsp), %xmm1 + movq (%rsp), %xmm0 + addq $40, %rsp + movq 640(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_80), .-GL_PREFIX(_dispatch_stub_80) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_81) + .type GL_PREFIX(_dispatch_stub_81), @function + HIDDEN(GL_PREFIX(_dispatch_stub_81)) +GL_PREFIX(_dispatch_stub_81): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 648(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + call _x86_64_get_dispatch@PLT + popq %rdi + movq 648(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 648(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + call _glapi_get_dispatch + popq %rdi + movq 648(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_81), .-GL_PREFIX(_dispatch_stub_81) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_82) + .type GL_PREFIX(_dispatch_stub_82), @function + HIDDEN(GL_PREFIX(_dispatch_stub_82)) +GL_PREFIX(_dispatch_stub_82): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 656(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rdx + pushq %rcx + pushq %rbp + call _x86_64_get_dispatch@PLT + popq %rbp + popq %rcx + popq %rdx + popq %rsi + popq %rdi + movq 656(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 656(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rdx + pushq %rcx + pushq %rbp + call _glapi_get_dispatch + popq %rbp + popq %rcx + popq %rdx + popq %rsi + popq %rdi + movq 656(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_82), .-GL_PREFIX(_dispatch_stub_82) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_83) + .type GL_PREFIX(_dispatch_stub_83), @function + HIDDEN(GL_PREFIX(_dispatch_stub_83)) +GL_PREFIX(_dispatch_stub_83): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 664(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + call _x86_64_get_dispatch@PLT + popq %rdi + movq 664(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 664(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + call _glapi_get_dispatch + popq %rdi + movq 664(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_83), .-GL_PREFIX(_dispatch_stub_83) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_84) + .type GL_PREFIX(_dispatch_stub_84), @function + HIDDEN(GL_PREFIX(_dispatch_stub_84)) +GL_PREFIX(_dispatch_stub_84): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 672(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rdx + pushq %rcx + pushq %rbp + call _x86_64_get_dispatch@PLT + popq %rbp + popq %rcx + popq %rdx + popq %rsi + popq %rdi + movq 672(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 672(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rdx + pushq %rcx + pushq %rbp + call _glapi_get_dispatch + popq %rbp + popq %rcx + popq %rdx + popq %rsi + popq %rdi + movq 672(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_84), .-GL_PREFIX(_dispatch_stub_84) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_85) + .type GL_PREFIX(_dispatch_stub_85), @function + HIDDEN(GL_PREFIX(_dispatch_stub_85)) +GL_PREFIX(_dispatch_stub_85): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 680(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + call _x86_64_get_dispatch@PLT + popq %rdi + movq 680(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 680(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + call _glapi_get_dispatch + popq %rdi + movq 680(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_85), .-GL_PREFIX(_dispatch_stub_85) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_86) + .type GL_PREFIX(_dispatch_stub_86), @function + HIDDEN(GL_PREFIX(_dispatch_stub_86)) +GL_PREFIX(_dispatch_stub_86): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 688(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + subq $40, %rsp + movq %xmm0, (%rsp) + movq %xmm1, 8(%rsp) + movq %xmm2, 16(%rsp) + movq %xmm3, 24(%rsp) + call _x86_64_get_dispatch@PLT + movq 24(%rsp), %xmm3 + movq 16(%rsp), %xmm2 + movq 8(%rsp), %xmm1 + movq (%rsp), %xmm0 + addq $40, %rsp + movq 688(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 688(%rax), %r11 + jmp *%r11 +1: + subq $40, %rsp + movq %xmm0, (%rsp) + movq %xmm1, 8(%rsp) + movq %xmm2, 16(%rsp) + movq %xmm3, 24(%rsp) + call _glapi_get_dispatch + movq 24(%rsp), %xmm3 + movq 16(%rsp), %xmm2 + movq 8(%rsp), %xmm1 + movq (%rsp), %xmm0 + addq $40, %rsp + movq 688(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_86), .-GL_PREFIX(_dispatch_stub_86) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_87) + .type GL_PREFIX(_dispatch_stub_87), @function + HIDDEN(GL_PREFIX(_dispatch_stub_87)) +GL_PREFIX(_dispatch_stub_87): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 696(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rbp + call _x86_64_get_dispatch@PLT + popq %rbp + popq %rsi + popq %rdi + movq 696(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 696(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rbp + call _glapi_get_dispatch + popq %rbp + popq %rsi + popq %rdi + movq 696(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_87), .-GL_PREFIX(_dispatch_stub_87) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_88) + .type GL_PREFIX(_dispatch_stub_88), @function + HIDDEN(GL_PREFIX(_dispatch_stub_88)) +GL_PREFIX(_dispatch_stub_88): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 704(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + subq $40, %rsp + movq %xmm0, (%rsp) + movq %xmm1, 8(%rsp) + movq %xmm2, 16(%rsp) + movq %xmm3, 24(%rsp) + call _x86_64_get_dispatch@PLT + movq 24(%rsp), %xmm3 + movq 16(%rsp), %xmm2 + movq 8(%rsp), %xmm1 + movq (%rsp), %xmm0 + addq $40, %rsp + movq 704(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 704(%rax), %r11 + jmp *%r11 +1: + subq $40, %rsp + movq %xmm0, (%rsp) + movq %xmm1, 8(%rsp) + movq %xmm2, 16(%rsp) + movq %xmm3, 24(%rsp) + call _glapi_get_dispatch + movq 24(%rsp), %xmm3 + movq 16(%rsp), %xmm2 + movq 8(%rsp), %xmm1 + movq (%rsp), %xmm0 + addq $40, %rsp + movq 704(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_88), .-GL_PREFIX(_dispatch_stub_88) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_89) + .type GL_PREFIX(_dispatch_stub_89), @function + HIDDEN(GL_PREFIX(_dispatch_stub_89)) +GL_PREFIX(_dispatch_stub_89): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 712(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rbp + call _x86_64_get_dispatch@PLT + popq %rbp + popq %rsi + popq %rdi + movq 712(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 712(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rbp + call _glapi_get_dispatch + popq %rbp + popq %rsi + popq %rdi + movq 712(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_89), .-GL_PREFIX(_dispatch_stub_89) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_90) + .type GL_PREFIX(_dispatch_stub_90), @function + HIDDEN(GL_PREFIX(_dispatch_stub_90)) +GL_PREFIX(_dispatch_stub_90): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 720(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rdx + pushq %rcx + pushq %rbp + call _x86_64_get_dispatch@PLT + popq %rbp + popq %rcx + popq %rdx + popq %rsi + popq %rdi + movq 720(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 720(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rdx + pushq %rcx + pushq %rbp + call _glapi_get_dispatch + popq %rbp + popq %rcx + popq %rdx + popq %rsi + popq %rdi + movq 720(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_90), .-GL_PREFIX(_dispatch_stub_90) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_91) + .type GL_PREFIX(_dispatch_stub_91), @function + HIDDEN(GL_PREFIX(_dispatch_stub_91)) +GL_PREFIX(_dispatch_stub_91): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 728(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rbp + call _x86_64_get_dispatch@PLT + popq %rbp + popq %rsi + popq %rdi + movq 728(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 728(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rbp + call _glapi_get_dispatch + popq %rbp + popq %rsi + popq %rdi + movq 728(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_91), .-GL_PREFIX(_dispatch_stub_91) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_92) + .type GL_PREFIX(_dispatch_stub_92), @function + HIDDEN(GL_PREFIX(_dispatch_stub_92)) +GL_PREFIX(_dispatch_stub_92): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 736(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rdx + pushq %rcx + pushq %rbp + call _x86_64_get_dispatch@PLT + popq %rbp + popq %rcx + popq %rdx + popq %rsi + popq %rdi + movq 736(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 736(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rdx + pushq %rcx + pushq %rbp + call _glapi_get_dispatch + popq %rbp + popq %rcx + popq %rdx + popq %rsi + popq %rdi + movq 736(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_92), .-GL_PREFIX(_dispatch_stub_92) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_93) + .type GL_PREFIX(_dispatch_stub_93), @function + HIDDEN(GL_PREFIX(_dispatch_stub_93)) +GL_PREFIX(_dispatch_stub_93): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 744(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rbp + call _x86_64_get_dispatch@PLT + popq %rbp + popq %rsi + popq %rdi + movq 744(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 744(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rbp + call _glapi_get_dispatch + popq %rbp + popq %rsi + popq %rdi + movq 744(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_93), .-GL_PREFIX(_dispatch_stub_93) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_94) + .type GL_PREFIX(_dispatch_stub_94), @function + HIDDEN(GL_PREFIX(_dispatch_stub_94)) +GL_PREFIX(_dispatch_stub_94): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 752(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + subq $8, %rsp + movq %xmm0, (%rsp) + call _x86_64_get_dispatch@PLT + movq (%rsp), %xmm0 + addq $8, %rsp + movq 752(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 752(%rax), %r11 + jmp *%r11 +1: + subq $8, %rsp + movq %xmm0, (%rsp) + call _glapi_get_dispatch + movq (%rsp), %xmm0 + addq $8, %rsp + movq 752(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_94), .-GL_PREFIX(_dispatch_stub_94) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_95) + .type GL_PREFIX(_dispatch_stub_95), @function + HIDDEN(GL_PREFIX(_dispatch_stub_95)) +GL_PREFIX(_dispatch_stub_95): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 760(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + call _x86_64_get_dispatch@PLT + popq %rdi + movq 760(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 760(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + call _glapi_get_dispatch + popq %rdi + movq 760(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_95), .-GL_PREFIX(_dispatch_stub_95) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_96) + .type GL_PREFIX(_dispatch_stub_96), @function + HIDDEN(GL_PREFIX(_dispatch_stub_96)) +GL_PREFIX(_dispatch_stub_96): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 768(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + subq $8, %rsp + movq %xmm0, (%rsp) + call _x86_64_get_dispatch@PLT + movq (%rsp), %xmm0 + addq $8, %rsp + movq 768(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 768(%rax), %r11 + jmp *%r11 +1: + subq $8, %rsp + movq %xmm0, (%rsp) + call _glapi_get_dispatch + movq (%rsp), %xmm0 + addq $8, %rsp + movq 768(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_96), .-GL_PREFIX(_dispatch_stub_96) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_97) + .type GL_PREFIX(_dispatch_stub_97), @function + HIDDEN(GL_PREFIX(_dispatch_stub_97)) +GL_PREFIX(_dispatch_stub_97): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 776(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + call _x86_64_get_dispatch@PLT + popq %rdi + movq 776(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 776(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + call _glapi_get_dispatch + popq %rdi + movq 776(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_97), .-GL_PREFIX(_dispatch_stub_97) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_98) + .type GL_PREFIX(_dispatch_stub_98), @function + HIDDEN(GL_PREFIX(_dispatch_stub_98)) +GL_PREFIX(_dispatch_stub_98): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 784(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + call _x86_64_get_dispatch@PLT + popq %rdi + movq 784(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 784(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + call _glapi_get_dispatch + popq %rdi + movq 784(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_98), .-GL_PREFIX(_dispatch_stub_98) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_99) + .type GL_PREFIX(_dispatch_stub_99), @function + HIDDEN(GL_PREFIX(_dispatch_stub_99)) +GL_PREFIX(_dispatch_stub_99): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 792(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + call _x86_64_get_dispatch@PLT + popq %rdi + movq 792(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 792(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + call _glapi_get_dispatch + popq %rdi + movq 792(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_99), .-GL_PREFIX(_dispatch_stub_99) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_100) + .type GL_PREFIX(_dispatch_stub_100), @function + HIDDEN(GL_PREFIX(_dispatch_stub_100)) +GL_PREFIX(_dispatch_stub_100): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 800(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + call _x86_64_get_dispatch@PLT + popq %rdi + movq 800(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 800(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + call _glapi_get_dispatch + popq %rdi + movq 800(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_100), .-GL_PREFIX(_dispatch_stub_100) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_101) + .type GL_PREFIX(_dispatch_stub_101), @function + HIDDEN(GL_PREFIX(_dispatch_stub_101)) +GL_PREFIX(_dispatch_stub_101): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 808(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + call _x86_64_get_dispatch@PLT + popq %rdi + movq 808(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 808(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + call _glapi_get_dispatch + popq %rdi + movq 808(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_101), .-GL_PREFIX(_dispatch_stub_101) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_102) + .type GL_PREFIX(_dispatch_stub_102), @function + HIDDEN(GL_PREFIX(_dispatch_stub_102)) +GL_PREFIX(_dispatch_stub_102): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 816(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + subq $24, %rsp + movq %xmm0, (%rsp) + movq %xmm1, 8(%rsp) + call _x86_64_get_dispatch@PLT + movq 8(%rsp), %xmm1 + movq (%rsp), %xmm0 + addq $24, %rsp + movq 816(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 816(%rax), %r11 + jmp *%r11 +1: + subq $24, %rsp + movq %xmm0, (%rsp) + movq %xmm1, 8(%rsp) + call _glapi_get_dispatch + movq 8(%rsp), %xmm1 + movq (%rsp), %xmm0 + addq $24, %rsp + movq 816(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_102), .-GL_PREFIX(_dispatch_stub_102) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_103) + .type GL_PREFIX(_dispatch_stub_103), @function + HIDDEN(GL_PREFIX(_dispatch_stub_103)) +GL_PREFIX(_dispatch_stub_103): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 824(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + call _x86_64_get_dispatch@PLT + popq %rdi + movq 824(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 824(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + call _glapi_get_dispatch + popq %rdi + movq 824(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_103), .-GL_PREFIX(_dispatch_stub_103) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_104) + .type GL_PREFIX(_dispatch_stub_104), @function + HIDDEN(GL_PREFIX(_dispatch_stub_104)) +GL_PREFIX(_dispatch_stub_104): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 832(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + subq $24, %rsp + movq %xmm0, (%rsp) + movq %xmm1, 8(%rsp) + call _x86_64_get_dispatch@PLT + movq 8(%rsp), %xmm1 + movq (%rsp), %xmm0 + addq $24, %rsp + movq 832(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 832(%rax), %r11 + jmp *%r11 +1: + subq $24, %rsp + movq %xmm0, (%rsp) + movq %xmm1, 8(%rsp) + call _glapi_get_dispatch + movq 8(%rsp), %xmm1 + movq (%rsp), %xmm0 + addq $24, %rsp + movq 832(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_104), .-GL_PREFIX(_dispatch_stub_104) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_105) + .type GL_PREFIX(_dispatch_stub_105), @function + HIDDEN(GL_PREFIX(_dispatch_stub_105)) +GL_PREFIX(_dispatch_stub_105): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 840(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + call _x86_64_get_dispatch@PLT + popq %rdi + movq 840(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 840(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + call _glapi_get_dispatch + popq %rdi + movq 840(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_105), .-GL_PREFIX(_dispatch_stub_105) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_106) + .type GL_PREFIX(_dispatch_stub_106), @function + HIDDEN(GL_PREFIX(_dispatch_stub_106)) +GL_PREFIX(_dispatch_stub_106): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 848(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rbp + call _x86_64_get_dispatch@PLT + popq %rbp + popq %rsi + popq %rdi + movq 848(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 848(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rbp + call _glapi_get_dispatch + popq %rbp + popq %rsi + popq %rdi + movq 848(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_106), .-GL_PREFIX(_dispatch_stub_106) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_107) + .type GL_PREFIX(_dispatch_stub_107), @function + HIDDEN(GL_PREFIX(_dispatch_stub_107)) +GL_PREFIX(_dispatch_stub_107): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 856(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + call _x86_64_get_dispatch@PLT + popq %rdi + movq 856(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 856(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + call _glapi_get_dispatch + popq %rdi + movq 856(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_107), .-GL_PREFIX(_dispatch_stub_107) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_108) + .type GL_PREFIX(_dispatch_stub_108), @function + HIDDEN(GL_PREFIX(_dispatch_stub_108)) +GL_PREFIX(_dispatch_stub_108): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 864(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rbp + call _x86_64_get_dispatch@PLT + popq %rbp + popq %rsi + popq %rdi + movq 864(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 864(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rbp + call _glapi_get_dispatch + popq %rbp + popq %rsi + popq %rdi + movq 864(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_108), .-GL_PREFIX(_dispatch_stub_108) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_109) + .type GL_PREFIX(_dispatch_stub_109), @function + HIDDEN(GL_PREFIX(_dispatch_stub_109)) +GL_PREFIX(_dispatch_stub_109): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 872(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + call _x86_64_get_dispatch@PLT + popq %rdi + movq 872(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 872(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + call _glapi_get_dispatch + popq %rdi + movq 872(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_109), .-GL_PREFIX(_dispatch_stub_109) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_110) + .type GL_PREFIX(_dispatch_stub_110), @function + HIDDEN(GL_PREFIX(_dispatch_stub_110)) +GL_PREFIX(_dispatch_stub_110): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 880(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + subq $24, %rsp + movq %xmm0, (%rsp) + movq %xmm1, 8(%rsp) + movq %xmm2, 16(%rsp) + call _x86_64_get_dispatch@PLT + movq 16(%rsp), %xmm2 + movq 8(%rsp), %xmm1 + movq (%rsp), %xmm0 + addq $24, %rsp + movq 880(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 880(%rax), %r11 + jmp *%r11 +1: + subq $24, %rsp + movq %xmm0, (%rsp) + movq %xmm1, 8(%rsp) + movq %xmm2, 16(%rsp) + call _glapi_get_dispatch + movq 16(%rsp), %xmm2 + movq 8(%rsp), %xmm1 + movq (%rsp), %xmm0 + addq $24, %rsp + movq 880(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_110), .-GL_PREFIX(_dispatch_stub_110) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_111) + .type GL_PREFIX(_dispatch_stub_111), @function + HIDDEN(GL_PREFIX(_dispatch_stub_111)) +GL_PREFIX(_dispatch_stub_111): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 888(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + call _x86_64_get_dispatch@PLT + popq %rdi + movq 888(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 888(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + call _glapi_get_dispatch + popq %rdi + movq 888(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_111), .-GL_PREFIX(_dispatch_stub_111) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_112) + .type GL_PREFIX(_dispatch_stub_112), @function + HIDDEN(GL_PREFIX(_dispatch_stub_112)) +GL_PREFIX(_dispatch_stub_112): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 896(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + subq $24, %rsp + movq %xmm0, (%rsp) + movq %xmm1, 8(%rsp) + movq %xmm2, 16(%rsp) + call _x86_64_get_dispatch@PLT + movq 16(%rsp), %xmm2 + movq 8(%rsp), %xmm1 + movq (%rsp), %xmm0 + addq $24, %rsp + movq 896(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 896(%rax), %r11 + jmp *%r11 +1: + subq $24, %rsp + movq %xmm0, (%rsp) + movq %xmm1, 8(%rsp) + movq %xmm2, 16(%rsp) + call _glapi_get_dispatch + movq 16(%rsp), %xmm2 + movq 8(%rsp), %xmm1 + movq (%rsp), %xmm0 + addq $24, %rsp + movq 896(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_112), .-GL_PREFIX(_dispatch_stub_112) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_113) + .type GL_PREFIX(_dispatch_stub_113), @function + HIDDEN(GL_PREFIX(_dispatch_stub_113)) +GL_PREFIX(_dispatch_stub_113): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 904(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + call _x86_64_get_dispatch@PLT + popq %rdi + movq 904(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 904(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + call _glapi_get_dispatch + popq %rdi + movq 904(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_113), .-GL_PREFIX(_dispatch_stub_113) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_114) + .type GL_PREFIX(_dispatch_stub_114), @function + HIDDEN(GL_PREFIX(_dispatch_stub_114)) +GL_PREFIX(_dispatch_stub_114): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 912(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rdx + call _x86_64_get_dispatch@PLT + popq %rdx + popq %rsi + popq %rdi + movq 912(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 912(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rdx + call _glapi_get_dispatch + popq %rdx + popq %rsi + popq %rdi + movq 912(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_114), .-GL_PREFIX(_dispatch_stub_114) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_115) + .type GL_PREFIX(_dispatch_stub_115), @function + HIDDEN(GL_PREFIX(_dispatch_stub_115)) +GL_PREFIX(_dispatch_stub_115): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 920(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + call _x86_64_get_dispatch@PLT + popq %rdi + movq 920(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 920(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + call _glapi_get_dispatch + popq %rdi + movq 920(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_115), .-GL_PREFIX(_dispatch_stub_115) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_116) + .type GL_PREFIX(_dispatch_stub_116), @function + HIDDEN(GL_PREFIX(_dispatch_stub_116)) +GL_PREFIX(_dispatch_stub_116): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 928(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rdx + call _x86_64_get_dispatch@PLT + popq %rdx + popq %rsi + popq %rdi + movq 928(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 928(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rdx + call _glapi_get_dispatch + popq %rdx + popq %rsi + popq %rdi + movq 928(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_116), .-GL_PREFIX(_dispatch_stub_116) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_117) + .type GL_PREFIX(_dispatch_stub_117), @function + HIDDEN(GL_PREFIX(_dispatch_stub_117)) +GL_PREFIX(_dispatch_stub_117): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 936(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + call _x86_64_get_dispatch@PLT + popq %rdi + movq 936(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 936(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + call _glapi_get_dispatch + popq %rdi + movq 936(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_117), .-GL_PREFIX(_dispatch_stub_117) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_118) + .type GL_PREFIX(_dispatch_stub_118), @function + HIDDEN(GL_PREFIX(_dispatch_stub_118)) +GL_PREFIX(_dispatch_stub_118): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 944(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + subq $40, %rsp + movq %xmm0, (%rsp) + movq %xmm1, 8(%rsp) + movq %xmm2, 16(%rsp) + movq %xmm3, 24(%rsp) + call _x86_64_get_dispatch@PLT + movq 24(%rsp), %xmm3 + movq 16(%rsp), %xmm2 + movq 8(%rsp), %xmm1 + movq (%rsp), %xmm0 + addq $40, %rsp + movq 944(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 944(%rax), %r11 + jmp *%r11 +1: + subq $40, %rsp + movq %xmm0, (%rsp) + movq %xmm1, 8(%rsp) + movq %xmm2, 16(%rsp) + movq %xmm3, 24(%rsp) + call _glapi_get_dispatch + movq 24(%rsp), %xmm3 + movq 16(%rsp), %xmm2 + movq 8(%rsp), %xmm1 + movq (%rsp), %xmm0 + addq $40, %rsp + movq 944(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_118), .-GL_PREFIX(_dispatch_stub_118) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_119) + .type GL_PREFIX(_dispatch_stub_119), @function + HIDDEN(GL_PREFIX(_dispatch_stub_119)) +GL_PREFIX(_dispatch_stub_119): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 952(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + call _x86_64_get_dispatch@PLT + popq %rdi + movq 952(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 952(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + call _glapi_get_dispatch + popq %rdi + movq 952(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_119), .-GL_PREFIX(_dispatch_stub_119) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_120) + .type GL_PREFIX(_dispatch_stub_120), @function + HIDDEN(GL_PREFIX(_dispatch_stub_120)) +GL_PREFIX(_dispatch_stub_120): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 960(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + subq $40, %rsp + movq %xmm0, (%rsp) + movq %xmm1, 8(%rsp) + movq %xmm2, 16(%rsp) + movq %xmm3, 24(%rsp) + call _x86_64_get_dispatch@PLT + movq 24(%rsp), %xmm3 + movq 16(%rsp), %xmm2 + movq 8(%rsp), %xmm1 + movq (%rsp), %xmm0 + addq $40, %rsp + movq 960(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 960(%rax), %r11 + jmp *%r11 +1: + subq $40, %rsp + movq %xmm0, (%rsp) + movq %xmm1, 8(%rsp) + movq %xmm2, 16(%rsp) + movq %xmm3, 24(%rsp) + call _glapi_get_dispatch + movq 24(%rsp), %xmm3 + movq 16(%rsp), %xmm2 + movq 8(%rsp), %xmm1 + movq (%rsp), %xmm0 + addq $40, %rsp + movq 960(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_120), .-GL_PREFIX(_dispatch_stub_120) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_121) + .type GL_PREFIX(_dispatch_stub_121), @function + HIDDEN(GL_PREFIX(_dispatch_stub_121)) +GL_PREFIX(_dispatch_stub_121): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 968(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + call _x86_64_get_dispatch@PLT + popq %rdi + movq 968(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 968(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + call _glapi_get_dispatch + popq %rdi + movq 968(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_121), .-GL_PREFIX(_dispatch_stub_121) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_122) + .type GL_PREFIX(_dispatch_stub_122), @function + HIDDEN(GL_PREFIX(_dispatch_stub_122)) +GL_PREFIX(_dispatch_stub_122): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 976(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rdx + pushq %rcx + pushq %rbp + call _x86_64_get_dispatch@PLT + popq %rbp + popq %rcx + popq %rdx + popq %rsi + popq %rdi + movq 976(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 976(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rdx + pushq %rcx + pushq %rbp + call _glapi_get_dispatch + popq %rbp + popq %rcx + popq %rdx + popq %rsi + popq %rdi + movq 976(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_122), .-GL_PREFIX(_dispatch_stub_122) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_123) + .type GL_PREFIX(_dispatch_stub_123), @function + HIDDEN(GL_PREFIX(_dispatch_stub_123)) +GL_PREFIX(_dispatch_stub_123): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 984(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + call _x86_64_get_dispatch@PLT + popq %rdi + movq 984(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 984(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + call _glapi_get_dispatch + popq %rdi + movq 984(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_123), .-GL_PREFIX(_dispatch_stub_123) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_124) + .type GL_PREFIX(_dispatch_stub_124), @function + HIDDEN(GL_PREFIX(_dispatch_stub_124)) +GL_PREFIX(_dispatch_stub_124): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 992(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rdx + pushq %rcx + pushq %rbp + call _x86_64_get_dispatch@PLT + popq %rbp + popq %rcx + popq %rdx + popq %rsi + popq %rdi + movq 992(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 992(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rdx + pushq %rcx + pushq %rbp + call _glapi_get_dispatch + popq %rbp + popq %rcx + popq %rdx + popq %rsi + popq %rdi + movq 992(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_124), .-GL_PREFIX(_dispatch_stub_124) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_125) + .type GL_PREFIX(_dispatch_stub_125), @function + HIDDEN(GL_PREFIX(_dispatch_stub_125)) +GL_PREFIX(_dispatch_stub_125): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 1000(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + call _x86_64_get_dispatch@PLT + popq %rdi + movq 1000(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 1000(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + call _glapi_get_dispatch + popq %rdi + movq 1000(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_125), .-GL_PREFIX(_dispatch_stub_125) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_126) + .type GL_PREFIX(_dispatch_stub_126), @function + HIDDEN(GL_PREFIX(_dispatch_stub_126)) +GL_PREFIX(_dispatch_stub_126): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 1008(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + subq $24, %rsp + movq %xmm0, (%rsp) + movq %xmm1, 8(%rsp) + call _x86_64_get_dispatch@PLT + movq 8(%rsp), %xmm1 + movq (%rsp), %xmm0 + addq $24, %rsp + movq 1008(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 1008(%rax), %r11 + jmp *%r11 +1: + subq $24, %rsp + movq %xmm0, (%rsp) + movq %xmm1, 8(%rsp) + call _glapi_get_dispatch + movq 8(%rsp), %xmm1 + movq (%rsp), %xmm0 + addq $24, %rsp + movq 1008(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_126), .-GL_PREFIX(_dispatch_stub_126) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_127) + .type GL_PREFIX(_dispatch_stub_127), @function + HIDDEN(GL_PREFIX(_dispatch_stub_127)) +GL_PREFIX(_dispatch_stub_127): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 1016(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + call _x86_64_get_dispatch@PLT + popq %rdi + movq 1016(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 1016(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + call _glapi_get_dispatch + popq %rdi + movq 1016(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_127), .-GL_PREFIX(_dispatch_stub_127) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_128) + .type GL_PREFIX(_dispatch_stub_128), @function + HIDDEN(GL_PREFIX(_dispatch_stub_128)) +GL_PREFIX(_dispatch_stub_128): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 1024(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + subq $24, %rsp + movq %xmm0, (%rsp) + movq %xmm1, 8(%rsp) + call _x86_64_get_dispatch@PLT + movq 8(%rsp), %xmm1 + movq (%rsp), %xmm0 + addq $24, %rsp + movq 1024(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 1024(%rax), %r11 + jmp *%r11 +1: + subq $24, %rsp + movq %xmm0, (%rsp) + movq %xmm1, 8(%rsp) + call _glapi_get_dispatch + movq 8(%rsp), %xmm1 + movq (%rsp), %xmm0 + addq $24, %rsp + movq 1024(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_128), .-GL_PREFIX(_dispatch_stub_128) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_129) + .type GL_PREFIX(_dispatch_stub_129), @function + HIDDEN(GL_PREFIX(_dispatch_stub_129)) +GL_PREFIX(_dispatch_stub_129): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 1032(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + call _x86_64_get_dispatch@PLT + popq %rdi + movq 1032(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 1032(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + call _glapi_get_dispatch + popq %rdi + movq 1032(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_129), .-GL_PREFIX(_dispatch_stub_129) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_130) + .type GL_PREFIX(_dispatch_stub_130), @function + HIDDEN(GL_PREFIX(_dispatch_stub_130)) +GL_PREFIX(_dispatch_stub_130): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 1040(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rbp + call _x86_64_get_dispatch@PLT + popq %rbp + popq %rsi + popq %rdi + movq 1040(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 1040(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rbp + call _glapi_get_dispatch + popq %rbp + popq %rsi + popq %rdi + movq 1040(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_130), .-GL_PREFIX(_dispatch_stub_130) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_131) + .type GL_PREFIX(_dispatch_stub_131), @function + HIDDEN(GL_PREFIX(_dispatch_stub_131)) +GL_PREFIX(_dispatch_stub_131): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 1048(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + call _x86_64_get_dispatch@PLT + popq %rdi + movq 1048(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 1048(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + call _glapi_get_dispatch + popq %rdi + movq 1048(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_131), .-GL_PREFIX(_dispatch_stub_131) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_132) + .type GL_PREFIX(_dispatch_stub_132), @function + HIDDEN(GL_PREFIX(_dispatch_stub_132)) +GL_PREFIX(_dispatch_stub_132): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 1056(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rbp + call _x86_64_get_dispatch@PLT + popq %rbp + popq %rsi + popq %rdi + movq 1056(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 1056(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rbp + call _glapi_get_dispatch + popq %rbp + popq %rsi + popq %rdi + movq 1056(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_132), .-GL_PREFIX(_dispatch_stub_132) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_133) + .type GL_PREFIX(_dispatch_stub_133), @function + HIDDEN(GL_PREFIX(_dispatch_stub_133)) +GL_PREFIX(_dispatch_stub_133): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 1064(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + call _x86_64_get_dispatch@PLT + popq %rdi + movq 1064(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 1064(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + call _glapi_get_dispatch + popq %rdi + movq 1064(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_133), .-GL_PREFIX(_dispatch_stub_133) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_134) + .type GL_PREFIX(_dispatch_stub_134), @function + HIDDEN(GL_PREFIX(_dispatch_stub_134)) +GL_PREFIX(_dispatch_stub_134): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 1072(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + subq $24, %rsp + movq %xmm0, (%rsp) + movq %xmm1, 8(%rsp) + movq %xmm2, 16(%rsp) + call _x86_64_get_dispatch@PLT + movq 16(%rsp), %xmm2 + movq 8(%rsp), %xmm1 + movq (%rsp), %xmm0 + addq $24, %rsp + movq 1072(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 1072(%rax), %r11 + jmp *%r11 +1: + subq $24, %rsp + movq %xmm0, (%rsp) + movq %xmm1, 8(%rsp) + movq %xmm2, 16(%rsp) + call _glapi_get_dispatch + movq 16(%rsp), %xmm2 + movq 8(%rsp), %xmm1 + movq (%rsp), %xmm0 + addq $24, %rsp + movq 1072(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_134), .-GL_PREFIX(_dispatch_stub_134) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_135) + .type GL_PREFIX(_dispatch_stub_135), @function + HIDDEN(GL_PREFIX(_dispatch_stub_135)) +GL_PREFIX(_dispatch_stub_135): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 1080(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + call _x86_64_get_dispatch@PLT + popq %rdi + movq 1080(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 1080(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + call _glapi_get_dispatch + popq %rdi + movq 1080(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_135), .-GL_PREFIX(_dispatch_stub_135) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_136) + .type GL_PREFIX(_dispatch_stub_136), @function + HIDDEN(GL_PREFIX(_dispatch_stub_136)) +GL_PREFIX(_dispatch_stub_136): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 1088(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + subq $24, %rsp + movq %xmm0, (%rsp) + movq %xmm1, 8(%rsp) + movq %xmm2, 16(%rsp) + call _x86_64_get_dispatch@PLT + movq 16(%rsp), %xmm2 + movq 8(%rsp), %xmm1 + movq (%rsp), %xmm0 + addq $24, %rsp + movq 1088(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 1088(%rax), %r11 + jmp *%r11 +1: + subq $24, %rsp + movq %xmm0, (%rsp) + movq %xmm1, 8(%rsp) + movq %xmm2, 16(%rsp) + call _glapi_get_dispatch + movq 16(%rsp), %xmm2 + movq 8(%rsp), %xmm1 + movq (%rsp), %xmm0 + addq $24, %rsp + movq 1088(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_136), .-GL_PREFIX(_dispatch_stub_136) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_137) + .type GL_PREFIX(_dispatch_stub_137), @function + HIDDEN(GL_PREFIX(_dispatch_stub_137)) +GL_PREFIX(_dispatch_stub_137): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 1096(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + call _x86_64_get_dispatch@PLT + popq %rdi + movq 1096(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 1096(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + call _glapi_get_dispatch + popq %rdi + movq 1096(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_137), .-GL_PREFIX(_dispatch_stub_137) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_138) + .type GL_PREFIX(_dispatch_stub_138), @function + HIDDEN(GL_PREFIX(_dispatch_stub_138)) +GL_PREFIX(_dispatch_stub_138): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 1104(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rdx + call _x86_64_get_dispatch@PLT + popq %rdx + popq %rsi + popq %rdi + movq 1104(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 1104(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rdx + call _glapi_get_dispatch + popq %rdx + popq %rsi + popq %rdi + movq 1104(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_138), .-GL_PREFIX(_dispatch_stub_138) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_139) + .type GL_PREFIX(_dispatch_stub_139), @function + HIDDEN(GL_PREFIX(_dispatch_stub_139)) +GL_PREFIX(_dispatch_stub_139): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 1112(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + call _x86_64_get_dispatch@PLT + popq %rdi + movq 1112(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 1112(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + call _glapi_get_dispatch + popq %rdi + movq 1112(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_139), .-GL_PREFIX(_dispatch_stub_139) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_140) + .type GL_PREFIX(_dispatch_stub_140), @function + HIDDEN(GL_PREFIX(_dispatch_stub_140)) +GL_PREFIX(_dispatch_stub_140): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 1120(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rdx + call _x86_64_get_dispatch@PLT + popq %rdx + popq %rsi + popq %rdi + movq 1120(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 1120(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rdx + call _glapi_get_dispatch + popq %rdx + popq %rsi + popq %rdi + movq 1120(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_140), .-GL_PREFIX(_dispatch_stub_140) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_141) + .type GL_PREFIX(_dispatch_stub_141), @function + HIDDEN(GL_PREFIX(_dispatch_stub_141)) +GL_PREFIX(_dispatch_stub_141): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 1128(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + call _x86_64_get_dispatch@PLT + popq %rdi + movq 1128(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 1128(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + call _glapi_get_dispatch + popq %rdi + movq 1128(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_141), .-GL_PREFIX(_dispatch_stub_141) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_142) + .type GL_PREFIX(_dispatch_stub_142), @function + HIDDEN(GL_PREFIX(_dispatch_stub_142)) +GL_PREFIX(_dispatch_stub_142): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 1136(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + subq $40, %rsp + movq %xmm0, (%rsp) + movq %xmm1, 8(%rsp) + movq %xmm2, 16(%rsp) + movq %xmm3, 24(%rsp) + call _x86_64_get_dispatch@PLT + movq 24(%rsp), %xmm3 + movq 16(%rsp), %xmm2 + movq 8(%rsp), %xmm1 + movq (%rsp), %xmm0 + addq $40, %rsp + movq 1136(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 1136(%rax), %r11 + jmp *%r11 +1: + subq $40, %rsp + movq %xmm0, (%rsp) + movq %xmm1, 8(%rsp) + movq %xmm2, 16(%rsp) + movq %xmm3, 24(%rsp) + call _glapi_get_dispatch + movq 24(%rsp), %xmm3 + movq 16(%rsp), %xmm2 + movq 8(%rsp), %xmm1 + movq (%rsp), %xmm0 + addq $40, %rsp + movq 1136(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_142), .-GL_PREFIX(_dispatch_stub_142) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_143) + .type GL_PREFIX(_dispatch_stub_143), @function + HIDDEN(GL_PREFIX(_dispatch_stub_143)) +GL_PREFIX(_dispatch_stub_143): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 1144(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + call _x86_64_get_dispatch@PLT + popq %rdi + movq 1144(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 1144(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + call _glapi_get_dispatch + popq %rdi + movq 1144(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_143), .-GL_PREFIX(_dispatch_stub_143) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_144) + .type GL_PREFIX(_dispatch_stub_144), @function + HIDDEN(GL_PREFIX(_dispatch_stub_144)) +GL_PREFIX(_dispatch_stub_144): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 1152(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + subq $40, %rsp + movq %xmm0, (%rsp) + movq %xmm1, 8(%rsp) + movq %xmm2, 16(%rsp) + movq %xmm3, 24(%rsp) + call _x86_64_get_dispatch@PLT + movq 24(%rsp), %xmm3 + movq 16(%rsp), %xmm2 + movq 8(%rsp), %xmm1 + movq (%rsp), %xmm0 + addq $40, %rsp + movq 1152(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 1152(%rax), %r11 + jmp *%r11 +1: + subq $40, %rsp + movq %xmm0, (%rsp) + movq %xmm1, 8(%rsp) + movq %xmm2, 16(%rsp) + movq %xmm3, 24(%rsp) + call _glapi_get_dispatch + movq 24(%rsp), %xmm3 + movq 16(%rsp), %xmm2 + movq 8(%rsp), %xmm1 + movq (%rsp), %xmm0 + addq $40, %rsp + movq 1152(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_144), .-GL_PREFIX(_dispatch_stub_144) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_145) + .type GL_PREFIX(_dispatch_stub_145), @function + HIDDEN(GL_PREFIX(_dispatch_stub_145)) +GL_PREFIX(_dispatch_stub_145): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 1160(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + call _x86_64_get_dispatch@PLT + popq %rdi + movq 1160(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 1160(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + call _glapi_get_dispatch + popq %rdi + movq 1160(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_145), .-GL_PREFIX(_dispatch_stub_145) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_146) + .type GL_PREFIX(_dispatch_stub_146), @function + HIDDEN(GL_PREFIX(_dispatch_stub_146)) +GL_PREFIX(_dispatch_stub_146): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 1168(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rdx + pushq %rcx + pushq %rbp + call _x86_64_get_dispatch@PLT + popq %rbp + popq %rcx + popq %rdx + popq %rsi + popq %rdi + movq 1168(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 1168(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rdx + pushq %rcx + pushq %rbp + call _glapi_get_dispatch + popq %rbp + popq %rcx + popq %rdx + popq %rsi + popq %rdi + movq 1168(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_146), .-GL_PREFIX(_dispatch_stub_146) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_147) + .type GL_PREFIX(_dispatch_stub_147), @function + HIDDEN(GL_PREFIX(_dispatch_stub_147)) +GL_PREFIX(_dispatch_stub_147): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 1176(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + call _x86_64_get_dispatch@PLT + popq %rdi + movq 1176(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 1176(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + call _glapi_get_dispatch + popq %rdi + movq 1176(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_147), .-GL_PREFIX(_dispatch_stub_147) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_148) + .type GL_PREFIX(_dispatch_stub_148), @function + HIDDEN(GL_PREFIX(_dispatch_stub_148)) +GL_PREFIX(_dispatch_stub_148): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 1184(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rdx + pushq %rcx + pushq %rbp + call _x86_64_get_dispatch@PLT + popq %rbp + popq %rcx + popq %rdx + popq %rsi + popq %rdi + movq 1184(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 1184(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rdx + pushq %rcx + pushq %rbp + call _glapi_get_dispatch + popq %rbp + popq %rcx + popq %rdx + popq %rsi + popq %rdi + movq 1184(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_148), .-GL_PREFIX(_dispatch_stub_148) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_149) + .type GL_PREFIX(_dispatch_stub_149), @function + HIDDEN(GL_PREFIX(_dispatch_stub_149)) +GL_PREFIX(_dispatch_stub_149): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 1192(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + call _x86_64_get_dispatch@PLT + popq %rdi + movq 1192(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 1192(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + call _glapi_get_dispatch + popq %rdi + movq 1192(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_149), .-GL_PREFIX(_dispatch_stub_149) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_150) + .type GL_PREFIX(_dispatch_stub_150), @function + HIDDEN(GL_PREFIX(_dispatch_stub_150)) +GL_PREFIX(_dispatch_stub_150): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 1200(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rbp + call _x86_64_get_dispatch@PLT + popq %rbp + popq %rsi + popq %rdi + movq 1200(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 1200(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rbp + call _glapi_get_dispatch + popq %rbp + popq %rsi + popq %rdi + movq 1200(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_150), .-GL_PREFIX(_dispatch_stub_150) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_151) + .type GL_PREFIX(_dispatch_stub_151), @function + HIDDEN(GL_PREFIX(_dispatch_stub_151)) +GL_PREFIX(_dispatch_stub_151): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 1208(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rbp + call _x86_64_get_dispatch@PLT + popq %rbp + popq %rsi + popq %rdi + movq 1208(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 1208(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rbp + call _glapi_get_dispatch + popq %rbp + popq %rsi + popq %rdi + movq 1208(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_151), .-GL_PREFIX(_dispatch_stub_151) + + .p2align 4,,15 + .globl GL_PREFIX(CullFace) + .type GL_PREFIX(CullFace), @function +GL_PREFIX(CullFace): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 1216(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + call _x86_64_get_dispatch@PLT + popq %rdi + movq 1216(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 1216(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + call _glapi_get_dispatch + popq %rdi + movq 1216(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(CullFace), .-GL_PREFIX(CullFace) + + .p2align 4,,15 + .globl GL_PREFIX(Fogf) + .type GL_PREFIX(Fogf), @function +GL_PREFIX(Fogf): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 1224(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + subq $24, %rsp + movq %rdi, (%rsp) + movq %xmm0, 8(%rsp) + call _x86_64_get_dispatch@PLT + movq 8(%rsp), %xmm0 + movq (%rsp), %rdi + addq $24, %rsp + movq 1224(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 1224(%rax), %r11 + jmp *%r11 +1: + subq $24, %rsp + movq %rdi, (%rsp) + movq %xmm0, 8(%rsp) + call _glapi_get_dispatch + movq 8(%rsp), %xmm0 + movq (%rsp), %rdi + addq $24, %rsp + movq 1224(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(Fogf), .-GL_PREFIX(Fogf) + + .p2align 4,,15 + .globl GL_PREFIX(Fogfv) + .type GL_PREFIX(Fogfv), @function +GL_PREFIX(Fogfv): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 1232(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rbp + call _x86_64_get_dispatch@PLT + popq %rbp + popq %rsi + popq %rdi + movq 1232(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 1232(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rbp + call _glapi_get_dispatch + popq %rbp + popq %rsi + popq %rdi + movq 1232(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(Fogfv), .-GL_PREFIX(Fogfv) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_155) + .type GL_PREFIX(_dispatch_stub_155), @function + HIDDEN(GL_PREFIX(_dispatch_stub_155)) +GL_PREFIX(_dispatch_stub_155): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 1240(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rbp + call _x86_64_get_dispatch@PLT + popq %rbp + popq %rsi + popq %rdi + movq 1240(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 1240(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rbp + call _glapi_get_dispatch + popq %rbp + popq %rsi + popq %rdi + movq 1240(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_155), .-GL_PREFIX(_dispatch_stub_155) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_156) + .type GL_PREFIX(_dispatch_stub_156), @function + HIDDEN(GL_PREFIX(_dispatch_stub_156)) +GL_PREFIX(_dispatch_stub_156): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 1248(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rbp + call _x86_64_get_dispatch@PLT + popq %rbp + popq %rsi + popq %rdi + movq 1248(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 1248(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rbp + call _glapi_get_dispatch + popq %rbp + popq %rsi + popq %rdi + movq 1248(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_156), .-GL_PREFIX(_dispatch_stub_156) + + .p2align 4,,15 + .globl GL_PREFIX(FrontFace) + .type GL_PREFIX(FrontFace), @function +GL_PREFIX(FrontFace): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 1256(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + call _x86_64_get_dispatch@PLT + popq %rdi + movq 1256(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 1256(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + call _glapi_get_dispatch + popq %rdi + movq 1256(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(FrontFace), .-GL_PREFIX(FrontFace) + + .p2align 4,,15 + .globl GL_PREFIX(Hint) + .type GL_PREFIX(Hint), @function +GL_PREFIX(Hint): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 1264(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rbp + call _x86_64_get_dispatch@PLT + popq %rbp + popq %rsi + popq %rdi + movq 1264(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 1264(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rbp + call _glapi_get_dispatch + popq %rbp + popq %rsi + popq %rdi + movq 1264(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(Hint), .-GL_PREFIX(Hint) + + .p2align 4,,15 + .globl GL_PREFIX(Lightf) + .type GL_PREFIX(Lightf), @function +GL_PREFIX(Lightf): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 1272(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + subq $24, %rsp + movq %rdi, (%rsp) + movq %rsi, 8(%rsp) + movq %xmm0, 16(%rsp) + call _x86_64_get_dispatch@PLT + movq 16(%rsp), %xmm0 + movq 8(%rsp), %rsi + movq (%rsp), %rdi + addq $24, %rsp + movq 1272(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 1272(%rax), %r11 + jmp *%r11 +1: + subq $24, %rsp + movq %rdi, (%rsp) + movq %rsi, 8(%rsp) + movq %xmm0, 16(%rsp) + call _glapi_get_dispatch + movq 16(%rsp), %xmm0 + movq 8(%rsp), %rsi + movq (%rsp), %rdi + addq $24, %rsp + movq 1272(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(Lightf), .-GL_PREFIX(Lightf) + + .p2align 4,,15 + .globl GL_PREFIX(Lightfv) + .type GL_PREFIX(Lightfv), @function +GL_PREFIX(Lightfv): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 1280(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rdx + call _x86_64_get_dispatch@PLT + popq %rdx + popq %rsi + popq %rdi + movq 1280(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 1280(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rdx + call _glapi_get_dispatch + popq %rdx + popq %rsi + popq %rdi + movq 1280(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(Lightfv), .-GL_PREFIX(Lightfv) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_161) + .type GL_PREFIX(_dispatch_stub_161), @function + HIDDEN(GL_PREFIX(_dispatch_stub_161)) +GL_PREFIX(_dispatch_stub_161): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 1288(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rdx + call _x86_64_get_dispatch@PLT + popq %rdx + popq %rsi + popq %rdi + movq 1288(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 1288(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rdx + call _glapi_get_dispatch + popq %rdx + popq %rsi + popq %rdi + movq 1288(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_161), .-GL_PREFIX(_dispatch_stub_161) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_162) + .type GL_PREFIX(_dispatch_stub_162), @function + HIDDEN(GL_PREFIX(_dispatch_stub_162)) +GL_PREFIX(_dispatch_stub_162): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 1296(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rdx + call _x86_64_get_dispatch@PLT + popq %rdx + popq %rsi + popq %rdi + movq 1296(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 1296(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rdx + call _glapi_get_dispatch + popq %rdx + popq %rsi + popq %rdi + movq 1296(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_162), .-GL_PREFIX(_dispatch_stub_162) + + .p2align 4,,15 + .globl GL_PREFIX(LightModelf) + .type GL_PREFIX(LightModelf), @function +GL_PREFIX(LightModelf): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 1304(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + subq $24, %rsp + movq %rdi, (%rsp) + movq %xmm0, 8(%rsp) + call _x86_64_get_dispatch@PLT + movq 8(%rsp), %xmm0 + movq (%rsp), %rdi + addq $24, %rsp + movq 1304(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 1304(%rax), %r11 + jmp *%r11 +1: + subq $24, %rsp + movq %rdi, (%rsp) + movq %xmm0, 8(%rsp) + call _glapi_get_dispatch + movq 8(%rsp), %xmm0 + movq (%rsp), %rdi + addq $24, %rsp + movq 1304(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(LightModelf), .-GL_PREFIX(LightModelf) + + .p2align 4,,15 + .globl GL_PREFIX(LightModelfv) + .type GL_PREFIX(LightModelfv), @function +GL_PREFIX(LightModelfv): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 1312(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rbp + call _x86_64_get_dispatch@PLT + popq %rbp + popq %rsi + popq %rdi + movq 1312(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 1312(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rbp + call _glapi_get_dispatch + popq %rbp + popq %rsi + popq %rdi + movq 1312(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(LightModelfv), .-GL_PREFIX(LightModelfv) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_165) + .type GL_PREFIX(_dispatch_stub_165), @function + HIDDEN(GL_PREFIX(_dispatch_stub_165)) +GL_PREFIX(_dispatch_stub_165): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 1320(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rbp + call _x86_64_get_dispatch@PLT + popq %rbp + popq %rsi + popq %rdi + movq 1320(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 1320(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rbp + call _glapi_get_dispatch + popq %rbp + popq %rsi + popq %rdi + movq 1320(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_165), .-GL_PREFIX(_dispatch_stub_165) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_166) + .type GL_PREFIX(_dispatch_stub_166), @function + HIDDEN(GL_PREFIX(_dispatch_stub_166)) +GL_PREFIX(_dispatch_stub_166): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 1328(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rbp + call _x86_64_get_dispatch@PLT + popq %rbp + popq %rsi + popq %rdi + movq 1328(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 1328(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rbp + call _glapi_get_dispatch + popq %rbp + popq %rsi + popq %rdi + movq 1328(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_166), .-GL_PREFIX(_dispatch_stub_166) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_167) + .type GL_PREFIX(_dispatch_stub_167), @function + HIDDEN(GL_PREFIX(_dispatch_stub_167)) +GL_PREFIX(_dispatch_stub_167): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 1336(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rbp + call _x86_64_get_dispatch@PLT + popq %rbp + popq %rsi + popq %rdi + movq 1336(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 1336(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rbp + call _glapi_get_dispatch + popq %rbp + popq %rsi + popq %rdi + movq 1336(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_167), .-GL_PREFIX(_dispatch_stub_167) + + .p2align 4,,15 + .globl GL_PREFIX(LineWidth) + .type GL_PREFIX(LineWidth), @function +GL_PREFIX(LineWidth): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 1344(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + subq $8, %rsp + movq %xmm0, (%rsp) + call _x86_64_get_dispatch@PLT + movq (%rsp), %xmm0 + addq $8, %rsp + movq 1344(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 1344(%rax), %r11 + jmp *%r11 +1: + subq $8, %rsp + movq %xmm0, (%rsp) + call _glapi_get_dispatch + movq (%rsp), %xmm0 + addq $8, %rsp + movq 1344(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(LineWidth), .-GL_PREFIX(LineWidth) + + .p2align 4,,15 + .globl GL_PREFIX(Materialf) + .type GL_PREFIX(Materialf), @function +GL_PREFIX(Materialf): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 1352(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + subq $24, %rsp + movq %rdi, (%rsp) + movq %rsi, 8(%rsp) + movq %xmm0, 16(%rsp) + call _x86_64_get_dispatch@PLT + movq 16(%rsp), %xmm0 + movq 8(%rsp), %rsi + movq (%rsp), %rdi + addq $24, %rsp + movq 1352(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 1352(%rax), %r11 + jmp *%r11 +1: + subq $24, %rsp + movq %rdi, (%rsp) + movq %rsi, 8(%rsp) + movq %xmm0, 16(%rsp) + call _glapi_get_dispatch + movq 16(%rsp), %xmm0 + movq 8(%rsp), %rsi + movq (%rsp), %rdi + addq $24, %rsp + movq 1352(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(Materialf), .-GL_PREFIX(Materialf) + + .p2align 4,,15 + .globl GL_PREFIX(Materialfv) + .type GL_PREFIX(Materialfv), @function +GL_PREFIX(Materialfv): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 1360(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rdx + call _x86_64_get_dispatch@PLT + popq %rdx + popq %rsi + popq %rdi + movq 1360(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 1360(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rdx + call _glapi_get_dispatch + popq %rdx + popq %rsi + popq %rdi + movq 1360(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(Materialfv), .-GL_PREFIX(Materialfv) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_171) + .type GL_PREFIX(_dispatch_stub_171), @function + HIDDEN(GL_PREFIX(_dispatch_stub_171)) +GL_PREFIX(_dispatch_stub_171): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 1368(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rdx + call _x86_64_get_dispatch@PLT + popq %rdx + popq %rsi + popq %rdi + movq 1368(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 1368(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rdx + call _glapi_get_dispatch + popq %rdx + popq %rsi + popq %rdi + movq 1368(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_171), .-GL_PREFIX(_dispatch_stub_171) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_172) + .type GL_PREFIX(_dispatch_stub_172), @function + HIDDEN(GL_PREFIX(_dispatch_stub_172)) +GL_PREFIX(_dispatch_stub_172): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 1376(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rdx + call _x86_64_get_dispatch@PLT + popq %rdx + popq %rsi + popq %rdi + movq 1376(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 1376(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rdx + call _glapi_get_dispatch + popq %rdx + popq %rsi + popq %rdi + movq 1376(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_172), .-GL_PREFIX(_dispatch_stub_172) + + .p2align 4,,15 + .globl GL_PREFIX(PointSize) + .type GL_PREFIX(PointSize), @function +GL_PREFIX(PointSize): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 1384(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + subq $8, %rsp + movq %xmm0, (%rsp) + call _x86_64_get_dispatch@PLT + movq (%rsp), %xmm0 + addq $8, %rsp + movq 1384(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 1384(%rax), %r11 + jmp *%r11 +1: + subq $8, %rsp + movq %xmm0, (%rsp) + call _glapi_get_dispatch + movq (%rsp), %xmm0 + addq $8, %rsp + movq 1384(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(PointSize), .-GL_PREFIX(PointSize) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_174) + .type GL_PREFIX(_dispatch_stub_174), @function + HIDDEN(GL_PREFIX(_dispatch_stub_174)) +GL_PREFIX(_dispatch_stub_174): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 1392(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rbp + call _x86_64_get_dispatch@PLT + popq %rbp + popq %rsi + popq %rdi + movq 1392(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 1392(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rbp + call _glapi_get_dispatch + popq %rbp + popq %rsi + popq %rdi + movq 1392(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_174), .-GL_PREFIX(_dispatch_stub_174) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_175) + .type GL_PREFIX(_dispatch_stub_175), @function + HIDDEN(GL_PREFIX(_dispatch_stub_175)) +GL_PREFIX(_dispatch_stub_175): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 1400(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + call _x86_64_get_dispatch@PLT + popq %rdi + movq 1400(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 1400(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + call _glapi_get_dispatch + popq %rdi + movq 1400(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_175), .-GL_PREFIX(_dispatch_stub_175) + + .p2align 4,,15 + .globl GL_PREFIX(Scissor) + .type GL_PREFIX(Scissor), @function +GL_PREFIX(Scissor): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 1408(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rdx + pushq %rcx + pushq %rbp + call _x86_64_get_dispatch@PLT + popq %rbp + popq %rcx + popq %rdx + popq %rsi + popq %rdi + movq 1408(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 1408(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rdx + pushq %rcx + pushq %rbp + call _glapi_get_dispatch + popq %rbp + popq %rcx + popq %rdx + popq %rsi + popq %rdi + movq 1408(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(Scissor), .-GL_PREFIX(Scissor) + + .p2align 4,,15 + .globl GL_PREFIX(ShadeModel) + .type GL_PREFIX(ShadeModel), @function +GL_PREFIX(ShadeModel): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 1416(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + call _x86_64_get_dispatch@PLT + popq %rdi + movq 1416(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 1416(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + call _glapi_get_dispatch + popq %rdi + movq 1416(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(ShadeModel), .-GL_PREFIX(ShadeModel) + + .p2align 4,,15 + .globl GL_PREFIX(TexParameterf) + .type GL_PREFIX(TexParameterf), @function +GL_PREFIX(TexParameterf): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 1424(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + subq $24, %rsp + movq %rdi, (%rsp) + movq %rsi, 8(%rsp) + movq %xmm0, 16(%rsp) + call _x86_64_get_dispatch@PLT + movq 16(%rsp), %xmm0 + movq 8(%rsp), %rsi + movq (%rsp), %rdi + addq $24, %rsp + movq 1424(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 1424(%rax), %r11 + jmp *%r11 +1: + subq $24, %rsp + movq %rdi, (%rsp) + movq %rsi, 8(%rsp) + movq %xmm0, 16(%rsp) + call _glapi_get_dispatch + movq 16(%rsp), %xmm0 + movq 8(%rsp), %rsi + movq (%rsp), %rdi + addq $24, %rsp + movq 1424(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(TexParameterf), .-GL_PREFIX(TexParameterf) + + .p2align 4,,15 + .globl GL_PREFIX(TexParameterfv) + .type GL_PREFIX(TexParameterfv), @function +GL_PREFIX(TexParameterfv): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 1432(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rdx + call _x86_64_get_dispatch@PLT + popq %rdx + popq %rsi + popq %rdi + movq 1432(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 1432(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rdx + call _glapi_get_dispatch + popq %rdx + popq %rsi + popq %rdi + movq 1432(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(TexParameterfv), .-GL_PREFIX(TexParameterfv) + + .p2align 4,,15 + .globl GL_PREFIX(TexParameteri) + .type GL_PREFIX(TexParameteri), @function +GL_PREFIX(TexParameteri): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 1440(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rdx + call _x86_64_get_dispatch@PLT + popq %rdx + popq %rsi + popq %rdi + movq 1440(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 1440(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rdx + call _glapi_get_dispatch + popq %rdx + popq %rsi + popq %rdi + movq 1440(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(TexParameteri), .-GL_PREFIX(TexParameteri) + + .p2align 4,,15 + .globl GL_PREFIX(TexParameteriv) + .type GL_PREFIX(TexParameteriv), @function +GL_PREFIX(TexParameteriv): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 1448(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rdx + call _x86_64_get_dispatch@PLT + popq %rdx + popq %rsi + popq %rdi + movq 1448(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 1448(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rdx + call _glapi_get_dispatch + popq %rdx + popq %rsi + popq %rdi + movq 1448(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(TexParameteriv), .-GL_PREFIX(TexParameteriv) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_182) + .type GL_PREFIX(_dispatch_stub_182), @function + HIDDEN(GL_PREFIX(_dispatch_stub_182)) +GL_PREFIX(_dispatch_stub_182): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 1456(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rdx + pushq %rcx + pushq %r8 + pushq %r9 + pushq %rbp + call _x86_64_get_dispatch@PLT + popq %rbp + popq %r9 + popq %r8 + popq %rcx + popq %rdx + popq %rsi + popq %rdi + movq 1456(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 1456(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rdx + pushq %rcx + pushq %r8 + pushq %r9 + pushq %rbp + call _glapi_get_dispatch + popq %rbp + popq %r9 + popq %r8 + popq %rcx + popq %rdx + popq %rsi + popq %rdi + movq 1456(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_182), .-GL_PREFIX(_dispatch_stub_182) + + .p2align 4,,15 + .globl GL_PREFIX(TexImage2D) + .type GL_PREFIX(TexImage2D), @function +GL_PREFIX(TexImage2D): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 1464(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rdx + pushq %rcx + pushq %r8 + pushq %r9 + pushq %rbp + call _x86_64_get_dispatch@PLT + popq %rbp + popq %r9 + popq %r8 + popq %rcx + popq %rdx + popq %rsi + popq %rdi + movq 1464(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 1464(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rdx + pushq %rcx + pushq %r8 + pushq %r9 + pushq %rbp + call _glapi_get_dispatch + popq %rbp + popq %r9 + popq %r8 + popq %rcx + popq %rdx + popq %rsi + popq %rdi + movq 1464(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(TexImage2D), .-GL_PREFIX(TexImage2D) + + .p2align 4,,15 + .globl GL_PREFIX(TexEnvf) + .type GL_PREFIX(TexEnvf), @function +GL_PREFIX(TexEnvf): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 1472(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + subq $24, %rsp + movq %rdi, (%rsp) + movq %rsi, 8(%rsp) + movq %xmm0, 16(%rsp) + call _x86_64_get_dispatch@PLT + movq 16(%rsp), %xmm0 + movq 8(%rsp), %rsi + movq (%rsp), %rdi + addq $24, %rsp + movq 1472(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 1472(%rax), %r11 + jmp *%r11 +1: + subq $24, %rsp + movq %rdi, (%rsp) + movq %rsi, 8(%rsp) + movq %xmm0, 16(%rsp) + call _glapi_get_dispatch + movq 16(%rsp), %xmm0 + movq 8(%rsp), %rsi + movq (%rsp), %rdi + addq $24, %rsp + movq 1472(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(TexEnvf), .-GL_PREFIX(TexEnvf) + + .p2align 4,,15 + .globl GL_PREFIX(TexEnvfv) + .type GL_PREFIX(TexEnvfv), @function +GL_PREFIX(TexEnvfv): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 1480(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rdx + call _x86_64_get_dispatch@PLT + popq %rdx + popq %rsi + popq %rdi + movq 1480(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 1480(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rdx + call _glapi_get_dispatch + popq %rdx + popq %rsi + popq %rdi + movq 1480(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(TexEnvfv), .-GL_PREFIX(TexEnvfv) + + .p2align 4,,15 + .globl GL_PREFIX(TexEnvi) + .type GL_PREFIX(TexEnvi), @function +GL_PREFIX(TexEnvi): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 1488(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rdx + call _x86_64_get_dispatch@PLT + popq %rdx + popq %rsi + popq %rdi + movq 1488(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 1488(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rdx + call _glapi_get_dispatch + popq %rdx + popq %rsi + popq %rdi + movq 1488(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(TexEnvi), .-GL_PREFIX(TexEnvi) + + .p2align 4,,15 + .globl GL_PREFIX(TexEnviv) + .type GL_PREFIX(TexEnviv), @function +GL_PREFIX(TexEnviv): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 1496(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rdx + call _x86_64_get_dispatch@PLT + popq %rdx + popq %rsi + popq %rdi + movq 1496(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 1496(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rdx + call _glapi_get_dispatch + popq %rdx + popq %rsi + popq %rdi + movq 1496(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(TexEnviv), .-GL_PREFIX(TexEnviv) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_188) + .type GL_PREFIX(_dispatch_stub_188), @function + HIDDEN(GL_PREFIX(_dispatch_stub_188)) +GL_PREFIX(_dispatch_stub_188): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 1504(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + subq $24, %rsp + movq %rdi, (%rsp) + movq %rsi, 8(%rsp) + movq %xmm0, 16(%rsp) + call _x86_64_get_dispatch@PLT + movq 16(%rsp), %xmm0 + movq 8(%rsp), %rsi + movq (%rsp), %rdi + addq $24, %rsp + movq 1504(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 1504(%rax), %r11 + jmp *%r11 +1: + subq $24, %rsp + movq %rdi, (%rsp) + movq %rsi, 8(%rsp) + movq %xmm0, 16(%rsp) + call _glapi_get_dispatch + movq 16(%rsp), %xmm0 + movq 8(%rsp), %rsi + movq (%rsp), %rdi + addq $24, %rsp + movq 1504(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_188), .-GL_PREFIX(_dispatch_stub_188) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_189) + .type GL_PREFIX(_dispatch_stub_189), @function + HIDDEN(GL_PREFIX(_dispatch_stub_189)) +GL_PREFIX(_dispatch_stub_189): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 1512(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rdx + call _x86_64_get_dispatch@PLT + popq %rdx + popq %rsi + popq %rdi + movq 1512(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 1512(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rdx + call _glapi_get_dispatch + popq %rdx + popq %rsi + popq %rdi + movq 1512(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_189), .-GL_PREFIX(_dispatch_stub_189) + + .p2align 4,,15 + .globl GL_PREFIX(TexGenfOES) + .type GL_PREFIX(TexGenfOES), @function +GL_PREFIX(TexGenfOES): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 1520(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + subq $24, %rsp + movq %rdi, (%rsp) + movq %rsi, 8(%rsp) + movq %xmm0, 16(%rsp) + call _x86_64_get_dispatch@PLT + movq 16(%rsp), %xmm0 + movq 8(%rsp), %rsi + movq (%rsp), %rdi + addq $24, %rsp + movq 1520(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 1520(%rax), %r11 + jmp *%r11 +1: + subq $24, %rsp + movq %rdi, (%rsp) + movq %rsi, 8(%rsp) + movq %xmm0, 16(%rsp) + call _glapi_get_dispatch + movq 16(%rsp), %xmm0 + movq 8(%rsp), %rsi + movq (%rsp), %rdi + addq $24, %rsp + movq 1520(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(TexGenfOES), .-GL_PREFIX(TexGenfOES) + + .p2align 4,,15 + .globl GL_PREFIX(TexGenfvOES) + .type GL_PREFIX(TexGenfvOES), @function +GL_PREFIX(TexGenfvOES): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 1528(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rdx + call _x86_64_get_dispatch@PLT + popq %rdx + popq %rsi + popq %rdi + movq 1528(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 1528(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rdx + call _glapi_get_dispatch + popq %rdx + popq %rsi + popq %rdi + movq 1528(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(TexGenfvOES), .-GL_PREFIX(TexGenfvOES) + + .p2align 4,,15 + .globl GL_PREFIX(TexGeniOES) + .type GL_PREFIX(TexGeniOES), @function +GL_PREFIX(TexGeniOES): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 1536(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rdx + call _x86_64_get_dispatch@PLT + popq %rdx + popq %rsi + popq %rdi + movq 1536(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 1536(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rdx + call _glapi_get_dispatch + popq %rdx + popq %rsi + popq %rdi + movq 1536(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(TexGeniOES), .-GL_PREFIX(TexGeniOES) + + .p2align 4,,15 + .globl GL_PREFIX(TexGenivOES) + .type GL_PREFIX(TexGenivOES), @function +GL_PREFIX(TexGenivOES): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 1544(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rdx + call _x86_64_get_dispatch@PLT + popq %rdx + popq %rsi + popq %rdi + movq 1544(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 1544(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rdx + call _glapi_get_dispatch + popq %rdx + popq %rsi + popq %rdi + movq 1544(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(TexGenivOES), .-GL_PREFIX(TexGenivOES) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_194) + .type GL_PREFIX(_dispatch_stub_194), @function + HIDDEN(GL_PREFIX(_dispatch_stub_194)) +GL_PREFIX(_dispatch_stub_194): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 1552(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rdx + call _x86_64_get_dispatch@PLT + popq %rdx + popq %rsi + popq %rdi + movq 1552(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 1552(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rdx + call _glapi_get_dispatch + popq %rdx + popq %rsi + popq %rdi + movq 1552(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_194), .-GL_PREFIX(_dispatch_stub_194) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_195) + .type GL_PREFIX(_dispatch_stub_195), @function + HIDDEN(GL_PREFIX(_dispatch_stub_195)) +GL_PREFIX(_dispatch_stub_195): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 1560(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rbp + call _x86_64_get_dispatch@PLT + popq %rbp + popq %rsi + popq %rdi + movq 1560(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 1560(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rbp + call _glapi_get_dispatch + popq %rbp + popq %rsi + popq %rdi + movq 1560(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_195), .-GL_PREFIX(_dispatch_stub_195) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_196) + .type GL_PREFIX(_dispatch_stub_196), @function + HIDDEN(GL_PREFIX(_dispatch_stub_196)) +GL_PREFIX(_dispatch_stub_196): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 1568(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + call _x86_64_get_dispatch@PLT + popq %rdi + movq 1568(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 1568(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + call _glapi_get_dispatch + popq %rdi + movq 1568(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_196), .-GL_PREFIX(_dispatch_stub_196) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_197) + .type GL_PREFIX(_dispatch_stub_197), @function + HIDDEN(GL_PREFIX(_dispatch_stub_197)) +GL_PREFIX(_dispatch_stub_197): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 1576(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rbp + call _x86_64_get_dispatch@PLT + popq %rbp + movq 1576(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 1576(%rax), %r11 + jmp *%r11 +1: + pushq %rbp + call _glapi_get_dispatch + popq %rbp + movq 1576(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_197), .-GL_PREFIX(_dispatch_stub_197) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_198) + .type GL_PREFIX(_dispatch_stub_198), @function + HIDDEN(GL_PREFIX(_dispatch_stub_198)) +GL_PREFIX(_dispatch_stub_198): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 1584(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + call _x86_64_get_dispatch@PLT + popq %rdi + movq 1584(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 1584(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + call _glapi_get_dispatch + popq %rdi + movq 1584(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_198), .-GL_PREFIX(_dispatch_stub_198) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_199) + .type GL_PREFIX(_dispatch_stub_199), @function + HIDDEN(GL_PREFIX(_dispatch_stub_199)) +GL_PREFIX(_dispatch_stub_199): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 1592(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + subq $8, %rsp + movq %xmm0, (%rsp) + call _x86_64_get_dispatch@PLT + movq (%rsp), %xmm0 + addq $8, %rsp + movq 1592(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 1592(%rax), %r11 + jmp *%r11 +1: + subq $8, %rsp + movq %xmm0, (%rsp) + call _glapi_get_dispatch + movq (%rsp), %xmm0 + addq $8, %rsp + movq 1592(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_199), .-GL_PREFIX(_dispatch_stub_199) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_200) + .type GL_PREFIX(_dispatch_stub_200), @function + HIDDEN(GL_PREFIX(_dispatch_stub_200)) +GL_PREFIX(_dispatch_stub_200): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 1600(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rbp + call _x86_64_get_dispatch@PLT + popq %rbp + movq 1600(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 1600(%rax), %r11 + jmp *%r11 +1: + pushq %rbp + call _glapi_get_dispatch + popq %rbp + movq 1600(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_200), .-GL_PREFIX(_dispatch_stub_200) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_201) + .type GL_PREFIX(_dispatch_stub_201), @function + HIDDEN(GL_PREFIX(_dispatch_stub_201)) +GL_PREFIX(_dispatch_stub_201): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 1608(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + call _x86_64_get_dispatch@PLT + popq %rdi + movq 1608(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 1608(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + call _glapi_get_dispatch + popq %rdi + movq 1608(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_201), .-GL_PREFIX(_dispatch_stub_201) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_202) + .type GL_PREFIX(_dispatch_stub_202), @function + HIDDEN(GL_PREFIX(_dispatch_stub_202)) +GL_PREFIX(_dispatch_stub_202): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 1616(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + call _x86_64_get_dispatch@PLT + popq %rdi + movq 1616(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 1616(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + call _glapi_get_dispatch + popq %rdi + movq 1616(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_202), .-GL_PREFIX(_dispatch_stub_202) + + .p2align 4,,15 + .globl GL_PREFIX(Clear) + .type GL_PREFIX(Clear), @function +GL_PREFIX(Clear): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 1624(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + call _x86_64_get_dispatch@PLT + popq %rdi + movq 1624(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 1624(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + call _glapi_get_dispatch + popq %rdi + movq 1624(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(Clear), .-GL_PREFIX(Clear) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_204) + .type GL_PREFIX(_dispatch_stub_204), @function + HIDDEN(GL_PREFIX(_dispatch_stub_204)) +GL_PREFIX(_dispatch_stub_204): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 1632(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + subq $40, %rsp + movq %xmm0, (%rsp) + movq %xmm1, 8(%rsp) + movq %xmm2, 16(%rsp) + movq %xmm3, 24(%rsp) + call _x86_64_get_dispatch@PLT + movq 24(%rsp), %xmm3 + movq 16(%rsp), %xmm2 + movq 8(%rsp), %xmm1 + movq (%rsp), %xmm0 + addq $40, %rsp + movq 1632(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 1632(%rax), %r11 + jmp *%r11 +1: + subq $40, %rsp + movq %xmm0, (%rsp) + movq %xmm1, 8(%rsp) + movq %xmm2, 16(%rsp) + movq %xmm3, 24(%rsp) + call _glapi_get_dispatch + movq 24(%rsp), %xmm3 + movq 16(%rsp), %xmm2 + movq 8(%rsp), %xmm1 + movq (%rsp), %xmm0 + addq $40, %rsp + movq 1632(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_204), .-GL_PREFIX(_dispatch_stub_204) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_205) + .type GL_PREFIX(_dispatch_stub_205), @function + HIDDEN(GL_PREFIX(_dispatch_stub_205)) +GL_PREFIX(_dispatch_stub_205): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 1640(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + subq $8, %rsp + movq %xmm0, (%rsp) + call _x86_64_get_dispatch@PLT + movq (%rsp), %xmm0 + addq $8, %rsp + movq 1640(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 1640(%rax), %r11 + jmp *%r11 +1: + subq $8, %rsp + movq %xmm0, (%rsp) + call _glapi_get_dispatch + movq (%rsp), %xmm0 + addq $8, %rsp + movq 1640(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_205), .-GL_PREFIX(_dispatch_stub_205) + + .p2align 4,,15 + .globl GL_PREFIX(ClearColor) + .type GL_PREFIX(ClearColor), @function +GL_PREFIX(ClearColor): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 1648(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rdx + pushq %rcx + pushq %rbp + call _x86_64_get_dispatch@PLT + popq %rbp + popq %rcx + popq %rdx + popq %rsi + popq %rdi + movq 1648(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 1648(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rdx + pushq %rcx + pushq %rbp + call _glapi_get_dispatch + popq %rbp + popq %rcx + popq %rdx + popq %rsi + popq %rdi + movq 1648(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(ClearColor), .-GL_PREFIX(ClearColor) + + .p2align 4,,15 + .globl GL_PREFIX(ClearStencil) + .type GL_PREFIX(ClearStencil), @function +GL_PREFIX(ClearStencil): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 1656(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + call _x86_64_get_dispatch@PLT + popq %rdi + movq 1656(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 1656(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + call _glapi_get_dispatch + popq %rdi + movq 1656(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(ClearStencil), .-GL_PREFIX(ClearStencil) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_208) + .type GL_PREFIX(_dispatch_stub_208), @function + HIDDEN(GL_PREFIX(_dispatch_stub_208)) +GL_PREFIX(_dispatch_stub_208): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 1664(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + call _x86_64_get_dispatch@PLT + popq %rdi + movq 1664(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 1664(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + call _glapi_get_dispatch + popq %rdi + movq 1664(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_208), .-GL_PREFIX(_dispatch_stub_208) + + .p2align 4,,15 + .globl GL_PREFIX(StencilMask) + .type GL_PREFIX(StencilMask), @function +GL_PREFIX(StencilMask): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 1672(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + call _x86_64_get_dispatch@PLT + popq %rdi + movq 1672(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 1672(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + call _glapi_get_dispatch + popq %rdi + movq 1672(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(StencilMask), .-GL_PREFIX(StencilMask) + + .p2align 4,,15 + .globl GL_PREFIX(ColorMask) + .type GL_PREFIX(ColorMask), @function +GL_PREFIX(ColorMask): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 1680(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rdx + pushq %rcx + pushq %rbp + call _x86_64_get_dispatch@PLT + popq %rbp + popq %rcx + popq %rdx + popq %rsi + popq %rdi + movq 1680(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 1680(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rdx + pushq %rcx + pushq %rbp + call _glapi_get_dispatch + popq %rbp + popq %rcx + popq %rdx + popq %rsi + popq %rdi + movq 1680(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(ColorMask), .-GL_PREFIX(ColorMask) + + .p2align 4,,15 + .globl GL_PREFIX(DepthMask) + .type GL_PREFIX(DepthMask), @function +GL_PREFIX(DepthMask): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 1688(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + call _x86_64_get_dispatch@PLT + popq %rdi + movq 1688(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 1688(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + call _glapi_get_dispatch + popq %rdi + movq 1688(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(DepthMask), .-GL_PREFIX(DepthMask) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_212) + .type GL_PREFIX(_dispatch_stub_212), @function + HIDDEN(GL_PREFIX(_dispatch_stub_212)) +GL_PREFIX(_dispatch_stub_212): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 1696(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + call _x86_64_get_dispatch@PLT + popq %rdi + movq 1696(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 1696(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + call _glapi_get_dispatch + popq %rdi + movq 1696(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_212), .-GL_PREFIX(_dispatch_stub_212) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_213) + .type GL_PREFIX(_dispatch_stub_213), @function + HIDDEN(GL_PREFIX(_dispatch_stub_213)) +GL_PREFIX(_dispatch_stub_213): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 1704(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + subq $24, %rsp + movq %rdi, (%rsp) + movq %xmm0, 8(%rsp) + call _x86_64_get_dispatch@PLT + movq 8(%rsp), %xmm0 + movq (%rsp), %rdi + addq $24, %rsp + movq 1704(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 1704(%rax), %r11 + jmp *%r11 +1: + subq $24, %rsp + movq %rdi, (%rsp) + movq %xmm0, 8(%rsp) + call _glapi_get_dispatch + movq 8(%rsp), %xmm0 + movq (%rsp), %rdi + addq $24, %rsp + movq 1704(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_213), .-GL_PREFIX(_dispatch_stub_213) + + .p2align 4,,15 + .globl GL_PREFIX(Disable) + .type GL_PREFIX(Disable), @function +GL_PREFIX(Disable): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 1712(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + call _x86_64_get_dispatch@PLT + popq %rdi + movq 1712(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 1712(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + call _glapi_get_dispatch + popq %rdi + movq 1712(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(Disable), .-GL_PREFIX(Disable) + + .p2align 4,,15 + .globl GL_PREFIX(Enable) + .type GL_PREFIX(Enable), @function +GL_PREFIX(Enable): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 1720(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + call _x86_64_get_dispatch@PLT + popq %rdi + movq 1720(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 1720(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + call _glapi_get_dispatch + popq %rdi + movq 1720(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(Enable), .-GL_PREFIX(Enable) + + .p2align 4,,15 + .globl GL_PREFIX(Finish) + .type GL_PREFIX(Finish), @function +GL_PREFIX(Finish): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 1728(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rbp + call _x86_64_get_dispatch@PLT + popq %rbp + movq 1728(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 1728(%rax), %r11 + jmp *%r11 +1: + pushq %rbp + call _glapi_get_dispatch + popq %rbp + movq 1728(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(Finish), .-GL_PREFIX(Finish) + + .p2align 4,,15 + .globl GL_PREFIX(Flush) + .type GL_PREFIX(Flush), @function +GL_PREFIX(Flush): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 1736(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rbp + call _x86_64_get_dispatch@PLT + popq %rbp + movq 1736(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 1736(%rax), %r11 + jmp *%r11 +1: + pushq %rbp + call _glapi_get_dispatch + popq %rbp + movq 1736(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(Flush), .-GL_PREFIX(Flush) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_218) + .type GL_PREFIX(_dispatch_stub_218), @function + HIDDEN(GL_PREFIX(_dispatch_stub_218)) +GL_PREFIX(_dispatch_stub_218): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 1744(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rbp + call _x86_64_get_dispatch@PLT + popq %rbp + movq 1744(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 1744(%rax), %r11 + jmp *%r11 +1: + pushq %rbp + call _glapi_get_dispatch + popq %rbp + movq 1744(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_218), .-GL_PREFIX(_dispatch_stub_218) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_219) + .type GL_PREFIX(_dispatch_stub_219), @function + HIDDEN(GL_PREFIX(_dispatch_stub_219)) +GL_PREFIX(_dispatch_stub_219): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 1752(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + call _x86_64_get_dispatch@PLT + popq %rdi + movq 1752(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 1752(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + call _glapi_get_dispatch + popq %rdi + movq 1752(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_219), .-GL_PREFIX(_dispatch_stub_219) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_220) + .type GL_PREFIX(_dispatch_stub_220), @function + HIDDEN(GL_PREFIX(_dispatch_stub_220)) +GL_PREFIX(_dispatch_stub_220): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 1760(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + subq $56, %rsp + movq %rdi, (%rsp) + movq %xmm0, 8(%rsp) + movq %xmm1, 16(%rsp) + movq %rsi, 24(%rsp) + movq %rdx, 32(%rsp) + movq %rcx, 40(%rsp) + call _x86_64_get_dispatch@PLT + movq 40(%rsp), %rcx + movq 32(%rsp), %rdx + movq 24(%rsp), %rsi + movq 16(%rsp), %xmm1 + movq 8(%rsp), %xmm0 + movq (%rsp), %rdi + addq $56, %rsp + movq 1760(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 1760(%rax), %r11 + jmp *%r11 +1: + subq $56, %rsp + movq %rdi, (%rsp) + movq %xmm0, 8(%rsp) + movq %xmm1, 16(%rsp) + movq %rsi, 24(%rsp) + movq %rdx, 32(%rsp) + movq %rcx, 40(%rsp) + call _glapi_get_dispatch + movq 40(%rsp), %rcx + movq 32(%rsp), %rdx + movq 24(%rsp), %rsi + movq 16(%rsp), %xmm1 + movq 8(%rsp), %xmm0 + movq (%rsp), %rdi + addq $56, %rsp + movq 1760(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_220), .-GL_PREFIX(_dispatch_stub_220) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_221) + .type GL_PREFIX(_dispatch_stub_221), @function + HIDDEN(GL_PREFIX(_dispatch_stub_221)) +GL_PREFIX(_dispatch_stub_221): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 1768(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + subq $56, %rsp + movq %rdi, (%rsp) + movq %xmm0, 8(%rsp) + movq %xmm1, 16(%rsp) + movq %rsi, 24(%rsp) + movq %rdx, 32(%rsp) + movq %rcx, 40(%rsp) + call _x86_64_get_dispatch@PLT + movq 40(%rsp), %rcx + movq 32(%rsp), %rdx + movq 24(%rsp), %rsi + movq 16(%rsp), %xmm1 + movq 8(%rsp), %xmm0 + movq (%rsp), %rdi + addq $56, %rsp + movq 1768(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 1768(%rax), %r11 + jmp *%r11 +1: + subq $56, %rsp + movq %rdi, (%rsp) + movq %xmm0, 8(%rsp) + movq %xmm1, 16(%rsp) + movq %rsi, 24(%rsp) + movq %rdx, 32(%rsp) + movq %rcx, 40(%rsp) + call _glapi_get_dispatch + movq 40(%rsp), %rcx + movq 32(%rsp), %rdx + movq 24(%rsp), %rsi + movq 16(%rsp), %xmm1 + movq 8(%rsp), %xmm0 + movq (%rsp), %rdi + addq $56, %rsp + movq 1768(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_221), .-GL_PREFIX(_dispatch_stub_221) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_222) + .type GL_PREFIX(_dispatch_stub_222), @function + HIDDEN(GL_PREFIX(_dispatch_stub_222)) +GL_PREFIX(_dispatch_stub_222): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 1776(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + subq $88, %rsp + movq %rdi, (%rsp) + movq %xmm0, 8(%rsp) + movq %xmm1, 16(%rsp) + movq %rsi, 24(%rsp) + movq %rdx, 32(%rsp) + movq %xmm2, 40(%rsp) + movq %xmm3, 48(%rsp) + movq %rcx, 56(%rsp) + movq %r8, 64(%rsp) + movq %r9, 72(%rsp) + call _x86_64_get_dispatch@PLT + movq 72(%rsp), %r9 + movq 64(%rsp), %r8 + movq 56(%rsp), %rcx + movq 48(%rsp), %xmm3 + movq 40(%rsp), %xmm2 + movq 32(%rsp), %rdx + movq 24(%rsp), %rsi + movq 16(%rsp), %xmm1 + movq 8(%rsp), %xmm0 + movq (%rsp), %rdi + addq $88, %rsp + movq 1776(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 1776(%rax), %r11 + jmp *%r11 +1: + subq $88, %rsp + movq %rdi, (%rsp) + movq %xmm0, 8(%rsp) + movq %xmm1, 16(%rsp) + movq %rsi, 24(%rsp) + movq %rdx, 32(%rsp) + movq %xmm2, 40(%rsp) + movq %xmm3, 48(%rsp) + movq %rcx, 56(%rsp) + movq %r8, 64(%rsp) + movq %r9, 72(%rsp) + call _glapi_get_dispatch + movq 72(%rsp), %r9 + movq 64(%rsp), %r8 + movq 56(%rsp), %rcx + movq 48(%rsp), %xmm3 + movq 40(%rsp), %xmm2 + movq 32(%rsp), %rdx + movq 24(%rsp), %rsi + movq 16(%rsp), %xmm1 + movq 8(%rsp), %xmm0 + movq (%rsp), %rdi + addq $88, %rsp + movq 1776(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_222), .-GL_PREFIX(_dispatch_stub_222) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_223) + .type GL_PREFIX(_dispatch_stub_223), @function + HIDDEN(GL_PREFIX(_dispatch_stub_223)) +GL_PREFIX(_dispatch_stub_223): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 1784(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + subq $88, %rsp + movq %rdi, (%rsp) + movq %xmm0, 8(%rsp) + movq %xmm1, 16(%rsp) + movq %rsi, 24(%rsp) + movq %rdx, 32(%rsp) + movq %xmm2, 40(%rsp) + movq %xmm3, 48(%rsp) + movq %rcx, 56(%rsp) + movq %r8, 64(%rsp) + movq %r9, 72(%rsp) + call _x86_64_get_dispatch@PLT + movq 72(%rsp), %r9 + movq 64(%rsp), %r8 + movq 56(%rsp), %rcx + movq 48(%rsp), %xmm3 + movq 40(%rsp), %xmm2 + movq 32(%rsp), %rdx + movq 24(%rsp), %rsi + movq 16(%rsp), %xmm1 + movq 8(%rsp), %xmm0 + movq (%rsp), %rdi + addq $88, %rsp + movq 1784(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 1784(%rax), %r11 + jmp *%r11 +1: + subq $88, %rsp + movq %rdi, (%rsp) + movq %xmm0, 8(%rsp) + movq %xmm1, 16(%rsp) + movq %rsi, 24(%rsp) + movq %rdx, 32(%rsp) + movq %xmm2, 40(%rsp) + movq %xmm3, 48(%rsp) + movq %rcx, 56(%rsp) + movq %r8, 64(%rsp) + movq %r9, 72(%rsp) + call _glapi_get_dispatch + movq 72(%rsp), %r9 + movq 64(%rsp), %r8 + movq 56(%rsp), %rcx + movq 48(%rsp), %xmm3 + movq 40(%rsp), %xmm2 + movq 32(%rsp), %rdx + movq 24(%rsp), %rsi + movq 16(%rsp), %xmm1 + movq 8(%rsp), %xmm0 + movq (%rsp), %rdi + addq $88, %rsp + movq 1784(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_223), .-GL_PREFIX(_dispatch_stub_223) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_224) + .type GL_PREFIX(_dispatch_stub_224), @function + HIDDEN(GL_PREFIX(_dispatch_stub_224)) +GL_PREFIX(_dispatch_stub_224): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 1792(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + subq $24, %rsp + movq %rdi, (%rsp) + movq %xmm0, 8(%rsp) + movq %xmm1, 16(%rsp) + call _x86_64_get_dispatch@PLT + movq 16(%rsp), %xmm1 + movq 8(%rsp), %xmm0 + movq (%rsp), %rdi + addq $24, %rsp + movq 1792(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 1792(%rax), %r11 + jmp *%r11 +1: + subq $24, %rsp + movq %rdi, (%rsp) + movq %xmm0, 8(%rsp) + movq %xmm1, 16(%rsp) + call _glapi_get_dispatch + movq 16(%rsp), %xmm1 + movq 8(%rsp), %xmm0 + movq (%rsp), %rdi + addq $24, %rsp + movq 1792(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_224), .-GL_PREFIX(_dispatch_stub_224) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_225) + .type GL_PREFIX(_dispatch_stub_225), @function + HIDDEN(GL_PREFIX(_dispatch_stub_225)) +GL_PREFIX(_dispatch_stub_225): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 1800(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + subq $24, %rsp + movq %rdi, (%rsp) + movq %xmm0, 8(%rsp) + movq %xmm1, 16(%rsp) + call _x86_64_get_dispatch@PLT + movq 16(%rsp), %xmm1 + movq 8(%rsp), %xmm0 + movq (%rsp), %rdi + addq $24, %rsp + movq 1800(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 1800(%rax), %r11 + jmp *%r11 +1: + subq $24, %rsp + movq %rdi, (%rsp) + movq %xmm0, 8(%rsp) + movq %xmm1, 16(%rsp) + call _glapi_get_dispatch + movq 16(%rsp), %xmm1 + movq 8(%rsp), %xmm0 + movq (%rsp), %rdi + addq $24, %rsp + movq 1800(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_225), .-GL_PREFIX(_dispatch_stub_225) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_226) + .type GL_PREFIX(_dispatch_stub_226), @function + HIDDEN(GL_PREFIX(_dispatch_stub_226)) +GL_PREFIX(_dispatch_stub_226): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 1808(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + subq $56, %rsp + movq %rdi, (%rsp) + movq %xmm0, 8(%rsp) + movq %xmm1, 16(%rsp) + movq %rsi, 24(%rsp) + movq %xmm2, 32(%rsp) + movq %xmm3, 40(%rsp) + call _x86_64_get_dispatch@PLT + movq 40(%rsp), %xmm3 + movq 32(%rsp), %xmm2 + movq 24(%rsp), %rsi + movq 16(%rsp), %xmm1 + movq 8(%rsp), %xmm0 + movq (%rsp), %rdi + addq $56, %rsp + movq 1808(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 1808(%rax), %r11 + jmp *%r11 +1: + subq $56, %rsp + movq %rdi, (%rsp) + movq %xmm0, 8(%rsp) + movq %xmm1, 16(%rsp) + movq %rsi, 24(%rsp) + movq %xmm2, 32(%rsp) + movq %xmm3, 40(%rsp) + call _glapi_get_dispatch + movq 40(%rsp), %xmm3 + movq 32(%rsp), %xmm2 + movq 24(%rsp), %rsi + movq 16(%rsp), %xmm1 + movq 8(%rsp), %xmm0 + movq (%rsp), %rdi + addq $56, %rsp + movq 1808(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_226), .-GL_PREFIX(_dispatch_stub_226) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_227) + .type GL_PREFIX(_dispatch_stub_227), @function + HIDDEN(GL_PREFIX(_dispatch_stub_227)) +GL_PREFIX(_dispatch_stub_227): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 1816(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + subq $56, %rsp + movq %rdi, (%rsp) + movq %xmm0, 8(%rsp) + movq %xmm1, 16(%rsp) + movq %rsi, 24(%rsp) + movq %xmm2, 32(%rsp) + movq %xmm3, 40(%rsp) + call _x86_64_get_dispatch@PLT + movq 40(%rsp), %xmm3 + movq 32(%rsp), %xmm2 + movq 24(%rsp), %rsi + movq 16(%rsp), %xmm1 + movq 8(%rsp), %xmm0 + movq (%rsp), %rdi + addq $56, %rsp + movq 1816(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 1816(%rax), %r11 + jmp *%r11 +1: + subq $56, %rsp + movq %rdi, (%rsp) + movq %xmm0, 8(%rsp) + movq %xmm1, 16(%rsp) + movq %rsi, 24(%rsp) + movq %xmm2, 32(%rsp) + movq %xmm3, 40(%rsp) + call _glapi_get_dispatch + movq 40(%rsp), %xmm3 + movq 32(%rsp), %xmm2 + movq 24(%rsp), %rsi + movq 16(%rsp), %xmm1 + movq 8(%rsp), %xmm0 + movq (%rsp), %rdi + addq $56, %rsp + movq 1816(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_227), .-GL_PREFIX(_dispatch_stub_227) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_228) + .type GL_PREFIX(_dispatch_stub_228), @function + HIDDEN(GL_PREFIX(_dispatch_stub_228)) +GL_PREFIX(_dispatch_stub_228): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 1824(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + subq $8, %rsp + movq %xmm0, (%rsp) + call _x86_64_get_dispatch@PLT + movq (%rsp), %xmm0 + addq $8, %rsp + movq 1824(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 1824(%rax), %r11 + jmp *%r11 +1: + subq $8, %rsp + movq %xmm0, (%rsp) + call _glapi_get_dispatch + movq (%rsp), %xmm0 + addq $8, %rsp + movq 1824(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_228), .-GL_PREFIX(_dispatch_stub_228) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_229) + .type GL_PREFIX(_dispatch_stub_229), @function + HIDDEN(GL_PREFIX(_dispatch_stub_229)) +GL_PREFIX(_dispatch_stub_229): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 1832(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + call _x86_64_get_dispatch@PLT + popq %rdi + movq 1832(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 1832(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + call _glapi_get_dispatch + popq %rdi + movq 1832(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_229), .-GL_PREFIX(_dispatch_stub_229) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_230) + .type GL_PREFIX(_dispatch_stub_230), @function + HIDDEN(GL_PREFIX(_dispatch_stub_230)) +GL_PREFIX(_dispatch_stub_230): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 1840(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + subq $8, %rsp + movq %xmm0, (%rsp) + call _x86_64_get_dispatch@PLT + movq (%rsp), %xmm0 + addq $8, %rsp + movq 1840(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 1840(%rax), %r11 + jmp *%r11 +1: + subq $8, %rsp + movq %xmm0, (%rsp) + call _glapi_get_dispatch + movq (%rsp), %xmm0 + addq $8, %rsp + movq 1840(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_230), .-GL_PREFIX(_dispatch_stub_230) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_231) + .type GL_PREFIX(_dispatch_stub_231), @function + HIDDEN(GL_PREFIX(_dispatch_stub_231)) +GL_PREFIX(_dispatch_stub_231): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 1848(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + call _x86_64_get_dispatch@PLT + popq %rdi + movq 1848(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 1848(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + call _glapi_get_dispatch + popq %rdi + movq 1848(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_231), .-GL_PREFIX(_dispatch_stub_231) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_232) + .type GL_PREFIX(_dispatch_stub_232), @function + HIDDEN(GL_PREFIX(_dispatch_stub_232)) +GL_PREFIX(_dispatch_stub_232): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 1856(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + subq $24, %rsp + movq %xmm0, (%rsp) + movq %xmm1, 8(%rsp) + call _x86_64_get_dispatch@PLT + movq 8(%rsp), %xmm1 + movq (%rsp), %xmm0 + addq $24, %rsp + movq 1856(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 1856(%rax), %r11 + jmp *%r11 +1: + subq $24, %rsp + movq %xmm0, (%rsp) + movq %xmm1, 8(%rsp) + call _glapi_get_dispatch + movq 8(%rsp), %xmm1 + movq (%rsp), %xmm0 + addq $24, %rsp + movq 1856(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_232), .-GL_PREFIX(_dispatch_stub_232) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_233) + .type GL_PREFIX(_dispatch_stub_233), @function + HIDDEN(GL_PREFIX(_dispatch_stub_233)) +GL_PREFIX(_dispatch_stub_233): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 1864(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + call _x86_64_get_dispatch@PLT + popq %rdi + movq 1864(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 1864(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + call _glapi_get_dispatch + popq %rdi + movq 1864(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_233), .-GL_PREFIX(_dispatch_stub_233) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_234) + .type GL_PREFIX(_dispatch_stub_234), @function + HIDDEN(GL_PREFIX(_dispatch_stub_234)) +GL_PREFIX(_dispatch_stub_234): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 1872(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + subq $24, %rsp + movq %xmm0, (%rsp) + movq %xmm1, 8(%rsp) + call _x86_64_get_dispatch@PLT + movq 8(%rsp), %xmm1 + movq (%rsp), %xmm0 + addq $24, %rsp + movq 1872(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 1872(%rax), %r11 + jmp *%r11 +1: + subq $24, %rsp + movq %xmm0, (%rsp) + movq %xmm1, 8(%rsp) + call _glapi_get_dispatch + movq 8(%rsp), %xmm1 + movq (%rsp), %xmm0 + addq $24, %rsp + movq 1872(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_234), .-GL_PREFIX(_dispatch_stub_234) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_235) + .type GL_PREFIX(_dispatch_stub_235), @function + HIDDEN(GL_PREFIX(_dispatch_stub_235)) +GL_PREFIX(_dispatch_stub_235): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 1880(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + call _x86_64_get_dispatch@PLT + popq %rdi + movq 1880(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 1880(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + call _glapi_get_dispatch + popq %rdi + movq 1880(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_235), .-GL_PREFIX(_dispatch_stub_235) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_236) + .type GL_PREFIX(_dispatch_stub_236), @function + HIDDEN(GL_PREFIX(_dispatch_stub_236)) +GL_PREFIX(_dispatch_stub_236): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 1888(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rdx + call _x86_64_get_dispatch@PLT + popq %rdx + popq %rsi + popq %rdi + movq 1888(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 1888(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rdx + call _glapi_get_dispatch + popq %rdx + popq %rsi + popq %rdi + movq 1888(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_236), .-GL_PREFIX(_dispatch_stub_236) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_237) + .type GL_PREFIX(_dispatch_stub_237), @function + HIDDEN(GL_PREFIX(_dispatch_stub_237)) +GL_PREFIX(_dispatch_stub_237): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 1896(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + call _x86_64_get_dispatch@PLT + popq %rdi + movq 1896(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 1896(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + call _glapi_get_dispatch + popq %rdi + movq 1896(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_237), .-GL_PREFIX(_dispatch_stub_237) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_238) + .type GL_PREFIX(_dispatch_stub_238), @function + HIDDEN(GL_PREFIX(_dispatch_stub_238)) +GL_PREFIX(_dispatch_stub_238): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 1904(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rdx + pushq %rcx + pushq %r8 + call _x86_64_get_dispatch@PLT + popq %r8 + popq %rcx + popq %rdx + popq %rsi + popq %rdi + movq 1904(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 1904(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rdx + pushq %rcx + pushq %r8 + call _glapi_get_dispatch + popq %r8 + popq %rcx + popq %rdx + popq %rsi + popq %rdi + movq 1904(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_238), .-GL_PREFIX(_dispatch_stub_238) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_239) + .type GL_PREFIX(_dispatch_stub_239), @function + HIDDEN(GL_PREFIX(_dispatch_stub_239)) +GL_PREFIX(_dispatch_stub_239): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 1912(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rbp + call _x86_64_get_dispatch@PLT + popq %rbp + popq %rsi + popq %rdi + movq 1912(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 1912(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rbp + call _glapi_get_dispatch + popq %rbp + popq %rsi + popq %rdi + movq 1912(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_239), .-GL_PREFIX(_dispatch_stub_239) + + .p2align 4,,15 + .globl GL_PREFIX(AlphaFunc) + .type GL_PREFIX(AlphaFunc), @function +GL_PREFIX(AlphaFunc): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 1920(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rbp + call _x86_64_get_dispatch@PLT + popq %rbp + popq %rsi + popq %rdi + movq 1920(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 1920(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rbp + call _glapi_get_dispatch + popq %rbp + popq %rsi + popq %rdi + movq 1920(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(AlphaFunc), .-GL_PREFIX(AlphaFunc) + + .p2align 4,,15 + .globl GL_PREFIX(BlendFunc) + .type GL_PREFIX(BlendFunc), @function +GL_PREFIX(BlendFunc): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 1928(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rbp + call _x86_64_get_dispatch@PLT + popq %rbp + popq %rsi + popq %rdi + movq 1928(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 1928(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rbp + call _glapi_get_dispatch + popq %rbp + popq %rsi + popq %rdi + movq 1928(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(BlendFunc), .-GL_PREFIX(BlendFunc) + + .p2align 4,,15 + .globl GL_PREFIX(LogicOp) + .type GL_PREFIX(LogicOp), @function +GL_PREFIX(LogicOp): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 1936(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + call _x86_64_get_dispatch@PLT + popq %rdi + movq 1936(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 1936(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + call _glapi_get_dispatch + popq %rdi + movq 1936(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(LogicOp), .-GL_PREFIX(LogicOp) + + .p2align 4,,15 + .globl GL_PREFIX(StencilFunc) + .type GL_PREFIX(StencilFunc), @function +GL_PREFIX(StencilFunc): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 1944(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rdx + call _x86_64_get_dispatch@PLT + popq %rdx + popq %rsi + popq %rdi + movq 1944(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 1944(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rdx + call _glapi_get_dispatch + popq %rdx + popq %rsi + popq %rdi + movq 1944(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(StencilFunc), .-GL_PREFIX(StencilFunc) + + .p2align 4,,15 + .globl GL_PREFIX(StencilOp) + .type GL_PREFIX(StencilOp), @function +GL_PREFIX(StencilOp): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 1952(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rdx + call _x86_64_get_dispatch@PLT + popq %rdx + popq %rsi + popq %rdi + movq 1952(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 1952(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rdx + call _glapi_get_dispatch + popq %rdx + popq %rsi + popq %rdi + movq 1952(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(StencilOp), .-GL_PREFIX(StencilOp) + + .p2align 4,,15 + .globl GL_PREFIX(DepthFunc) + .type GL_PREFIX(DepthFunc), @function +GL_PREFIX(DepthFunc): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 1960(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + call _x86_64_get_dispatch@PLT + popq %rdi + movq 1960(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 1960(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + call _glapi_get_dispatch + popq %rdi + movq 1960(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(DepthFunc), .-GL_PREFIX(DepthFunc) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_246) + .type GL_PREFIX(_dispatch_stub_246), @function + HIDDEN(GL_PREFIX(_dispatch_stub_246)) +GL_PREFIX(_dispatch_stub_246): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 1968(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + subq $24, %rsp + movq %xmm0, (%rsp) + movq %xmm1, 8(%rsp) + call _x86_64_get_dispatch@PLT + movq 8(%rsp), %xmm1 + movq (%rsp), %xmm0 + addq $24, %rsp + movq 1968(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 1968(%rax), %r11 + jmp *%r11 +1: + subq $24, %rsp + movq %xmm0, (%rsp) + movq %xmm1, 8(%rsp) + call _glapi_get_dispatch + movq 8(%rsp), %xmm1 + movq (%rsp), %xmm0 + addq $24, %rsp + movq 1968(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_246), .-GL_PREFIX(_dispatch_stub_246) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_247) + .type GL_PREFIX(_dispatch_stub_247), @function + HIDDEN(GL_PREFIX(_dispatch_stub_247)) +GL_PREFIX(_dispatch_stub_247): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 1976(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + subq $24, %rsp + movq %rdi, (%rsp) + movq %xmm0, 8(%rsp) + call _x86_64_get_dispatch@PLT + movq 8(%rsp), %xmm0 + movq (%rsp), %rdi + addq $24, %rsp + movq 1976(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 1976(%rax), %r11 + jmp *%r11 +1: + subq $24, %rsp + movq %rdi, (%rsp) + movq %xmm0, 8(%rsp) + call _glapi_get_dispatch + movq 8(%rsp), %xmm0 + movq (%rsp), %rdi + addq $24, %rsp + movq 1976(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_247), .-GL_PREFIX(_dispatch_stub_247) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_248) + .type GL_PREFIX(_dispatch_stub_248), @function + HIDDEN(GL_PREFIX(_dispatch_stub_248)) +GL_PREFIX(_dispatch_stub_248): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 1984(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rbp + call _x86_64_get_dispatch@PLT + popq %rbp + popq %rsi + popq %rdi + movq 1984(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 1984(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rbp + call _glapi_get_dispatch + popq %rbp + popq %rsi + popq %rdi + movq 1984(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_248), .-GL_PREFIX(_dispatch_stub_248) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_249) + .type GL_PREFIX(_dispatch_stub_249), @function + HIDDEN(GL_PREFIX(_dispatch_stub_249)) +GL_PREFIX(_dispatch_stub_249): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 1992(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + subq $24, %rsp + movq %rdi, (%rsp) + movq %xmm0, 8(%rsp) + call _x86_64_get_dispatch@PLT + movq 8(%rsp), %xmm0 + movq (%rsp), %rdi + addq $24, %rsp + movq 1992(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 1992(%rax), %r11 + jmp *%r11 +1: + subq $24, %rsp + movq %rdi, (%rsp) + movq %xmm0, 8(%rsp) + call _glapi_get_dispatch + movq 8(%rsp), %xmm0 + movq (%rsp), %rdi + addq $24, %rsp + movq 1992(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_249), .-GL_PREFIX(_dispatch_stub_249) + + .p2align 4,,15 + .globl GL_PREFIX(PixelStorei) + .type GL_PREFIX(PixelStorei), @function +GL_PREFIX(PixelStorei): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 2000(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rbp + call _x86_64_get_dispatch@PLT + popq %rbp + popq %rsi + popq %rdi + movq 2000(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 2000(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rbp + call _glapi_get_dispatch + popq %rbp + popq %rsi + popq %rdi + movq 2000(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(PixelStorei), .-GL_PREFIX(PixelStorei) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_251) + .type GL_PREFIX(_dispatch_stub_251), @function + HIDDEN(GL_PREFIX(_dispatch_stub_251)) +GL_PREFIX(_dispatch_stub_251): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 2008(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rdx + call _x86_64_get_dispatch@PLT + popq %rdx + popq %rsi + popq %rdi + movq 2008(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 2008(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rdx + call _glapi_get_dispatch + popq %rdx + popq %rsi + popq %rdi + movq 2008(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_251), .-GL_PREFIX(_dispatch_stub_251) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_252) + .type GL_PREFIX(_dispatch_stub_252), @function + HIDDEN(GL_PREFIX(_dispatch_stub_252)) +GL_PREFIX(_dispatch_stub_252): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 2016(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rdx + call _x86_64_get_dispatch@PLT + popq %rdx + popq %rsi + popq %rdi + movq 2016(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 2016(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rdx + call _glapi_get_dispatch + popq %rdx + popq %rsi + popq %rdi + movq 2016(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_252), .-GL_PREFIX(_dispatch_stub_252) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_253) + .type GL_PREFIX(_dispatch_stub_253), @function + HIDDEN(GL_PREFIX(_dispatch_stub_253)) +GL_PREFIX(_dispatch_stub_253): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 2024(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rdx + call _x86_64_get_dispatch@PLT + popq %rdx + popq %rsi + popq %rdi + movq 2024(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 2024(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rdx + call _glapi_get_dispatch + popq %rdx + popq %rsi + popq %rdi + movq 2024(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_253), .-GL_PREFIX(_dispatch_stub_253) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_254) + .type GL_PREFIX(_dispatch_stub_254), @function + HIDDEN(GL_PREFIX(_dispatch_stub_254)) +GL_PREFIX(_dispatch_stub_254): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 2032(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + call _x86_64_get_dispatch@PLT + popq %rdi + movq 2032(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 2032(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + call _glapi_get_dispatch + popq %rdi + movq 2032(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_254), .-GL_PREFIX(_dispatch_stub_254) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_255) + .type GL_PREFIX(_dispatch_stub_255), @function + HIDDEN(GL_PREFIX(_dispatch_stub_255)) +GL_PREFIX(_dispatch_stub_255): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 2040(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rdx + pushq %rcx + pushq %r8 + call _x86_64_get_dispatch@PLT + popq %r8 + popq %rcx + popq %rdx + popq %rsi + popq %rdi + movq 2040(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 2040(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rdx + pushq %rcx + pushq %r8 + call _glapi_get_dispatch + popq %r8 + popq %rcx + popq %rdx + popq %rsi + popq %rdi + movq 2040(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_255), .-GL_PREFIX(_dispatch_stub_255) + + .p2align 4,,15 + .globl GL_PREFIX(ReadPixels) + .type GL_PREFIX(ReadPixels), @function +GL_PREFIX(ReadPixels): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 2048(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rdx + pushq %rcx + pushq %r8 + pushq %r9 + pushq %rbp + call _x86_64_get_dispatch@PLT + popq %rbp + popq %r9 + popq %r8 + popq %rcx + popq %rdx + popq %rsi + popq %rdi + movq 2048(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 2048(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rdx + pushq %rcx + pushq %r8 + pushq %r9 + pushq %rbp + call _glapi_get_dispatch + popq %rbp + popq %r9 + popq %r8 + popq %rcx + popq %rdx + popq %rsi + popq %rdi + movq 2048(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(ReadPixels), .-GL_PREFIX(ReadPixels) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_257) + .type GL_PREFIX(_dispatch_stub_257), @function + HIDDEN(GL_PREFIX(_dispatch_stub_257)) +GL_PREFIX(_dispatch_stub_257): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 2056(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rdx + pushq %rcx + pushq %r8 + call _x86_64_get_dispatch@PLT + popq %r8 + popq %rcx + popq %rdx + popq %rsi + popq %rdi + movq 2056(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 2056(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rdx + pushq %rcx + pushq %r8 + call _glapi_get_dispatch + popq %r8 + popq %rcx + popq %rdx + popq %rsi + popq %rdi + movq 2056(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_257), .-GL_PREFIX(_dispatch_stub_257) + + .p2align 4,,15 + .globl GL_PREFIX(GetBooleanv) + .type GL_PREFIX(GetBooleanv), @function +GL_PREFIX(GetBooleanv): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 2064(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rbp + call _x86_64_get_dispatch@PLT + popq %rbp + popq %rsi + popq %rdi + movq 2064(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 2064(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rbp + call _glapi_get_dispatch + popq %rbp + popq %rsi + popq %rdi + movq 2064(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(GetBooleanv), .-GL_PREFIX(GetBooleanv) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_259) + .type GL_PREFIX(_dispatch_stub_259), @function + HIDDEN(GL_PREFIX(_dispatch_stub_259)) +GL_PREFIX(_dispatch_stub_259): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 2072(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rbp + call _x86_64_get_dispatch@PLT + popq %rbp + popq %rsi + popq %rdi + movq 2072(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 2072(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rbp + call _glapi_get_dispatch + popq %rbp + popq %rsi + popq %rdi + movq 2072(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_259), .-GL_PREFIX(_dispatch_stub_259) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_260) + .type GL_PREFIX(_dispatch_stub_260), @function + HIDDEN(GL_PREFIX(_dispatch_stub_260)) +GL_PREFIX(_dispatch_stub_260): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 2080(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rbp + call _x86_64_get_dispatch@PLT + popq %rbp + popq %rsi + popq %rdi + movq 2080(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 2080(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rbp + call _glapi_get_dispatch + popq %rbp + popq %rsi + popq %rdi + movq 2080(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_260), .-GL_PREFIX(_dispatch_stub_260) + + .p2align 4,,15 + .globl GL_PREFIX(GetError) + .type GL_PREFIX(GetError), @function +GL_PREFIX(GetError): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 2088(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rbp + call _x86_64_get_dispatch@PLT + popq %rbp + movq 2088(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 2088(%rax), %r11 + jmp *%r11 +1: + pushq %rbp + call _glapi_get_dispatch + popq %rbp + movq 2088(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(GetError), .-GL_PREFIX(GetError) + + .p2align 4,,15 + .globl GL_PREFIX(GetFloatv) + .type GL_PREFIX(GetFloatv), @function +GL_PREFIX(GetFloatv): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 2096(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rbp + call _x86_64_get_dispatch@PLT + popq %rbp + popq %rsi + popq %rdi + movq 2096(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 2096(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rbp + call _glapi_get_dispatch + popq %rbp + popq %rsi + popq %rdi + movq 2096(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(GetFloatv), .-GL_PREFIX(GetFloatv) + + .p2align 4,,15 + .globl GL_PREFIX(GetIntegerv) + .type GL_PREFIX(GetIntegerv), @function +GL_PREFIX(GetIntegerv): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 2104(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rbp + call _x86_64_get_dispatch@PLT + popq %rbp + popq %rsi + popq %rdi + movq 2104(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 2104(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rbp + call _glapi_get_dispatch + popq %rbp + popq %rsi + popq %rdi + movq 2104(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(GetIntegerv), .-GL_PREFIX(GetIntegerv) + + .p2align 4,,15 + .globl GL_PREFIX(GetLightfv) + .type GL_PREFIX(GetLightfv), @function +GL_PREFIX(GetLightfv): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 2112(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rdx + call _x86_64_get_dispatch@PLT + popq %rdx + popq %rsi + popq %rdi + movq 2112(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 2112(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rdx + call _glapi_get_dispatch + popq %rdx + popq %rsi + popq %rdi + movq 2112(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(GetLightfv), .-GL_PREFIX(GetLightfv) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_265) + .type GL_PREFIX(_dispatch_stub_265), @function + HIDDEN(GL_PREFIX(_dispatch_stub_265)) +GL_PREFIX(_dispatch_stub_265): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 2120(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rdx + call _x86_64_get_dispatch@PLT + popq %rdx + popq %rsi + popq %rdi + movq 2120(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 2120(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rdx + call _glapi_get_dispatch + popq %rdx + popq %rsi + popq %rdi + movq 2120(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_265), .-GL_PREFIX(_dispatch_stub_265) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_266) + .type GL_PREFIX(_dispatch_stub_266), @function + HIDDEN(GL_PREFIX(_dispatch_stub_266)) +GL_PREFIX(_dispatch_stub_266): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 2128(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rdx + call _x86_64_get_dispatch@PLT + popq %rdx + popq %rsi + popq %rdi + movq 2128(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 2128(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rdx + call _glapi_get_dispatch + popq %rdx + popq %rsi + popq %rdi + movq 2128(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_266), .-GL_PREFIX(_dispatch_stub_266) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_267) + .type GL_PREFIX(_dispatch_stub_267), @function + HIDDEN(GL_PREFIX(_dispatch_stub_267)) +GL_PREFIX(_dispatch_stub_267): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 2136(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rdx + call _x86_64_get_dispatch@PLT + popq %rdx + popq %rsi + popq %rdi + movq 2136(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 2136(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rdx + call _glapi_get_dispatch + popq %rdx + popq %rsi + popq %rdi + movq 2136(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_267), .-GL_PREFIX(_dispatch_stub_267) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_268) + .type GL_PREFIX(_dispatch_stub_268), @function + HIDDEN(GL_PREFIX(_dispatch_stub_268)) +GL_PREFIX(_dispatch_stub_268): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 2144(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rdx + call _x86_64_get_dispatch@PLT + popq %rdx + popq %rsi + popq %rdi + movq 2144(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 2144(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rdx + call _glapi_get_dispatch + popq %rdx + popq %rsi + popq %rdi + movq 2144(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_268), .-GL_PREFIX(_dispatch_stub_268) + + .p2align 4,,15 + .globl GL_PREFIX(GetMaterialfv) + .type GL_PREFIX(GetMaterialfv), @function +GL_PREFIX(GetMaterialfv): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 2152(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rdx + call _x86_64_get_dispatch@PLT + popq %rdx + popq %rsi + popq %rdi + movq 2152(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 2152(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rdx + call _glapi_get_dispatch + popq %rdx + popq %rsi + popq %rdi + movq 2152(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(GetMaterialfv), .-GL_PREFIX(GetMaterialfv) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_270) + .type GL_PREFIX(_dispatch_stub_270), @function + HIDDEN(GL_PREFIX(_dispatch_stub_270)) +GL_PREFIX(_dispatch_stub_270): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 2160(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rdx + call _x86_64_get_dispatch@PLT + popq %rdx + popq %rsi + popq %rdi + movq 2160(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 2160(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rdx + call _glapi_get_dispatch + popq %rdx + popq %rsi + popq %rdi + movq 2160(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_270), .-GL_PREFIX(_dispatch_stub_270) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_271) + .type GL_PREFIX(_dispatch_stub_271), @function + HIDDEN(GL_PREFIX(_dispatch_stub_271)) +GL_PREFIX(_dispatch_stub_271): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 2168(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rbp + call _x86_64_get_dispatch@PLT + popq %rbp + popq %rsi + popq %rdi + movq 2168(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 2168(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rbp + call _glapi_get_dispatch + popq %rbp + popq %rsi + popq %rdi + movq 2168(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_271), .-GL_PREFIX(_dispatch_stub_271) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_272) + .type GL_PREFIX(_dispatch_stub_272), @function + HIDDEN(GL_PREFIX(_dispatch_stub_272)) +GL_PREFIX(_dispatch_stub_272): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 2176(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rbp + call _x86_64_get_dispatch@PLT + popq %rbp + popq %rsi + popq %rdi + movq 2176(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 2176(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rbp + call _glapi_get_dispatch + popq %rbp + popq %rsi + popq %rdi + movq 2176(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_272), .-GL_PREFIX(_dispatch_stub_272) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_273) + .type GL_PREFIX(_dispatch_stub_273), @function + HIDDEN(GL_PREFIX(_dispatch_stub_273)) +GL_PREFIX(_dispatch_stub_273): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 2184(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rbp + call _x86_64_get_dispatch@PLT + popq %rbp + popq %rsi + popq %rdi + movq 2184(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 2184(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rbp + call _glapi_get_dispatch + popq %rbp + popq %rsi + popq %rdi + movq 2184(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_273), .-GL_PREFIX(_dispatch_stub_273) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_274) + .type GL_PREFIX(_dispatch_stub_274), @function + HIDDEN(GL_PREFIX(_dispatch_stub_274)) +GL_PREFIX(_dispatch_stub_274): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 2192(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + call _x86_64_get_dispatch@PLT + popq %rdi + movq 2192(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 2192(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + call _glapi_get_dispatch + popq %rdi + movq 2192(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_274), .-GL_PREFIX(_dispatch_stub_274) + + .p2align 4,,15 + .globl GL_PREFIX(GetString) + .type GL_PREFIX(GetString), @function +GL_PREFIX(GetString): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 2200(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + call _x86_64_get_dispatch@PLT + popq %rdi + movq 2200(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 2200(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + call _glapi_get_dispatch + popq %rdi + movq 2200(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(GetString), .-GL_PREFIX(GetString) + + .p2align 4,,15 + .globl GL_PREFIX(GetTexEnvfv) + .type GL_PREFIX(GetTexEnvfv), @function +GL_PREFIX(GetTexEnvfv): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 2208(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rdx + call _x86_64_get_dispatch@PLT + popq %rdx + popq %rsi + popq %rdi + movq 2208(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 2208(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rdx + call _glapi_get_dispatch + popq %rdx + popq %rsi + popq %rdi + movq 2208(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(GetTexEnvfv), .-GL_PREFIX(GetTexEnvfv) + + .p2align 4,,15 + .globl GL_PREFIX(GetTexEnviv) + .type GL_PREFIX(GetTexEnviv), @function +GL_PREFIX(GetTexEnviv): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 2216(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rdx + call _x86_64_get_dispatch@PLT + popq %rdx + popq %rsi + popq %rdi + movq 2216(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 2216(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rdx + call _glapi_get_dispatch + popq %rdx + popq %rsi + popq %rdi + movq 2216(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(GetTexEnviv), .-GL_PREFIX(GetTexEnviv) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_278) + .type GL_PREFIX(_dispatch_stub_278), @function + HIDDEN(GL_PREFIX(_dispatch_stub_278)) +GL_PREFIX(_dispatch_stub_278): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 2224(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rdx + call _x86_64_get_dispatch@PLT + popq %rdx + popq %rsi + popq %rdi + movq 2224(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 2224(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rdx + call _glapi_get_dispatch + popq %rdx + popq %rsi + popq %rdi + movq 2224(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_278), .-GL_PREFIX(_dispatch_stub_278) + + .p2align 4,,15 + .globl GL_PREFIX(GetTexGenfvOES) + .type GL_PREFIX(GetTexGenfvOES), @function +GL_PREFIX(GetTexGenfvOES): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 2232(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rdx + call _x86_64_get_dispatch@PLT + popq %rdx + popq %rsi + popq %rdi + movq 2232(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 2232(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rdx + call _glapi_get_dispatch + popq %rdx + popq %rsi + popq %rdi + movq 2232(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(GetTexGenfvOES), .-GL_PREFIX(GetTexGenfvOES) + + .p2align 4,,15 + .globl GL_PREFIX(GetTexGenivOES) + .type GL_PREFIX(GetTexGenivOES), @function +GL_PREFIX(GetTexGenivOES): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 2240(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rdx + call _x86_64_get_dispatch@PLT + popq %rdx + popq %rsi + popq %rdi + movq 2240(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 2240(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rdx + call _glapi_get_dispatch + popq %rdx + popq %rsi + popq %rdi + movq 2240(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(GetTexGenivOES), .-GL_PREFIX(GetTexGenivOES) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_281) + .type GL_PREFIX(_dispatch_stub_281), @function + HIDDEN(GL_PREFIX(_dispatch_stub_281)) +GL_PREFIX(_dispatch_stub_281): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 2248(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rdx + pushq %rcx + pushq %r8 + call _x86_64_get_dispatch@PLT + popq %r8 + popq %rcx + popq %rdx + popq %rsi + popq %rdi + movq 2248(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 2248(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rdx + pushq %rcx + pushq %r8 + call _glapi_get_dispatch + popq %r8 + popq %rcx + popq %rdx + popq %rsi + popq %rdi + movq 2248(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_281), .-GL_PREFIX(_dispatch_stub_281) + + .p2align 4,,15 + .globl GL_PREFIX(GetTexParameterfv) + .type GL_PREFIX(GetTexParameterfv), @function +GL_PREFIX(GetTexParameterfv): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 2256(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rdx + call _x86_64_get_dispatch@PLT + popq %rdx + popq %rsi + popq %rdi + movq 2256(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 2256(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rdx + call _glapi_get_dispatch + popq %rdx + popq %rsi + popq %rdi + movq 2256(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(GetTexParameterfv), .-GL_PREFIX(GetTexParameterfv) + + .p2align 4,,15 + .globl GL_PREFIX(GetTexParameteriv) + .type GL_PREFIX(GetTexParameteriv), @function +GL_PREFIX(GetTexParameteriv): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 2264(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rdx + call _x86_64_get_dispatch@PLT + popq %rdx + popq %rsi + popq %rdi + movq 2264(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 2264(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rdx + call _glapi_get_dispatch + popq %rdx + popq %rsi + popq %rdi + movq 2264(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(GetTexParameteriv), .-GL_PREFIX(GetTexParameteriv) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_284) + .type GL_PREFIX(_dispatch_stub_284), @function + HIDDEN(GL_PREFIX(_dispatch_stub_284)) +GL_PREFIX(_dispatch_stub_284): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 2272(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rdx + pushq %rcx + pushq %rbp + call _x86_64_get_dispatch@PLT + popq %rbp + popq %rcx + popq %rdx + popq %rsi + popq %rdi + movq 2272(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 2272(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rdx + pushq %rcx + pushq %rbp + call _glapi_get_dispatch + popq %rbp + popq %rcx + popq %rdx + popq %rsi + popq %rdi + movq 2272(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_284), .-GL_PREFIX(_dispatch_stub_284) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_285) + .type GL_PREFIX(_dispatch_stub_285), @function + HIDDEN(GL_PREFIX(_dispatch_stub_285)) +GL_PREFIX(_dispatch_stub_285): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 2280(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rdx + pushq %rcx + pushq %rbp + call _x86_64_get_dispatch@PLT + popq %rbp + popq %rcx + popq %rdx + popq %rsi + popq %rdi + movq 2280(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 2280(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rdx + pushq %rcx + pushq %rbp + call _glapi_get_dispatch + popq %rbp + popq %rcx + popq %rdx + popq %rsi + popq %rdi + movq 2280(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_285), .-GL_PREFIX(_dispatch_stub_285) + + .p2align 4,,15 + .globl GL_PREFIX(IsEnabled) + .type GL_PREFIX(IsEnabled), @function +GL_PREFIX(IsEnabled): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 2288(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + call _x86_64_get_dispatch@PLT + popq %rdi + movq 2288(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 2288(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + call _glapi_get_dispatch + popq %rdi + movq 2288(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(IsEnabled), .-GL_PREFIX(IsEnabled) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_287) + .type GL_PREFIX(_dispatch_stub_287), @function + HIDDEN(GL_PREFIX(_dispatch_stub_287)) +GL_PREFIX(_dispatch_stub_287): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 2296(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + call _x86_64_get_dispatch@PLT + popq %rdi + movq 2296(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 2296(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + call _glapi_get_dispatch + popq %rdi + movq 2296(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_287), .-GL_PREFIX(_dispatch_stub_287) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_288) + .type GL_PREFIX(_dispatch_stub_288), @function + HIDDEN(GL_PREFIX(_dispatch_stub_288)) +GL_PREFIX(_dispatch_stub_288): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 2304(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rbp + call _x86_64_get_dispatch@PLT + popq %rbp + popq %rsi + popq %rdi + movq 2304(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 2304(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rbp + call _glapi_get_dispatch + popq %rbp + popq %rsi + popq %rdi + movq 2304(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_288), .-GL_PREFIX(_dispatch_stub_288) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_289) + .type GL_PREFIX(_dispatch_stub_289), @function + HIDDEN(GL_PREFIX(_dispatch_stub_289)) +GL_PREFIX(_dispatch_stub_289): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 2312(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + subq $56, %rsp + movq %xmm0, (%rsp) + movq %xmm1, 8(%rsp) + movq %xmm2, 16(%rsp) + movq %xmm3, 24(%rsp) + movq %xmm4, 32(%rsp) + movq %xmm5, 40(%rsp) + call _x86_64_get_dispatch@PLT + movq 40(%rsp), %xmm5 + movq 32(%rsp), %xmm4 + movq 24(%rsp), %xmm3 + movq 16(%rsp), %xmm2 + movq 8(%rsp), %xmm1 + movq (%rsp), %xmm0 + addq $56, %rsp + movq 2312(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 2312(%rax), %r11 + jmp *%r11 +1: + subq $56, %rsp + movq %xmm0, (%rsp) + movq %xmm1, 8(%rsp) + movq %xmm2, 16(%rsp) + movq %xmm3, 24(%rsp) + movq %xmm4, 32(%rsp) + movq %xmm5, 40(%rsp) + call _glapi_get_dispatch + movq 40(%rsp), %xmm5 + movq 32(%rsp), %xmm4 + movq 24(%rsp), %xmm3 + movq 16(%rsp), %xmm2 + movq 8(%rsp), %xmm1 + movq (%rsp), %xmm0 + addq $56, %rsp + movq 2312(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_289), .-GL_PREFIX(_dispatch_stub_289) + + .p2align 4,,15 + .globl GL_PREFIX(LoadIdentity) + .type GL_PREFIX(LoadIdentity), @function +GL_PREFIX(LoadIdentity): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 2320(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rbp + call _x86_64_get_dispatch@PLT + popq %rbp + movq 2320(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 2320(%rax), %r11 + jmp *%r11 +1: + pushq %rbp + call _glapi_get_dispatch + popq %rbp + movq 2320(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(LoadIdentity), .-GL_PREFIX(LoadIdentity) + + .p2align 4,,15 + .globl GL_PREFIX(LoadMatrixf) + .type GL_PREFIX(LoadMatrixf), @function +GL_PREFIX(LoadMatrixf): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 2328(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + call _x86_64_get_dispatch@PLT + popq %rdi + movq 2328(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 2328(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + call _glapi_get_dispatch + popq %rdi + movq 2328(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(LoadMatrixf), .-GL_PREFIX(LoadMatrixf) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_292) + .type GL_PREFIX(_dispatch_stub_292), @function + HIDDEN(GL_PREFIX(_dispatch_stub_292)) +GL_PREFIX(_dispatch_stub_292): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 2336(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + call _x86_64_get_dispatch@PLT + popq %rdi + movq 2336(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 2336(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + call _glapi_get_dispatch + popq %rdi + movq 2336(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_292), .-GL_PREFIX(_dispatch_stub_292) + + .p2align 4,,15 + .globl GL_PREFIX(MatrixMode) + .type GL_PREFIX(MatrixMode), @function +GL_PREFIX(MatrixMode): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 2344(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + call _x86_64_get_dispatch@PLT + popq %rdi + movq 2344(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 2344(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + call _glapi_get_dispatch + popq %rdi + movq 2344(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(MatrixMode), .-GL_PREFIX(MatrixMode) + + .p2align 4,,15 + .globl GL_PREFIX(MultMatrixf) + .type GL_PREFIX(MultMatrixf), @function +GL_PREFIX(MultMatrixf): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 2352(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + call _x86_64_get_dispatch@PLT + popq %rdi + movq 2352(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 2352(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + call _glapi_get_dispatch + popq %rdi + movq 2352(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(MultMatrixf), .-GL_PREFIX(MultMatrixf) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_295) + .type GL_PREFIX(_dispatch_stub_295), @function + HIDDEN(GL_PREFIX(_dispatch_stub_295)) +GL_PREFIX(_dispatch_stub_295): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 2360(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + call _x86_64_get_dispatch@PLT + popq %rdi + movq 2360(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 2360(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + call _glapi_get_dispatch + popq %rdi + movq 2360(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_295), .-GL_PREFIX(_dispatch_stub_295) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_296) + .type GL_PREFIX(_dispatch_stub_296), @function + HIDDEN(GL_PREFIX(_dispatch_stub_296)) +GL_PREFIX(_dispatch_stub_296): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 2368(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + subq $56, %rsp + movq %xmm0, (%rsp) + movq %xmm1, 8(%rsp) + movq %xmm2, 16(%rsp) + movq %xmm3, 24(%rsp) + movq %xmm4, 32(%rsp) + movq %xmm5, 40(%rsp) + call _x86_64_get_dispatch@PLT + movq 40(%rsp), %xmm5 + movq 32(%rsp), %xmm4 + movq 24(%rsp), %xmm3 + movq 16(%rsp), %xmm2 + movq 8(%rsp), %xmm1 + movq (%rsp), %xmm0 + addq $56, %rsp + movq 2368(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 2368(%rax), %r11 + jmp *%r11 +1: + subq $56, %rsp + movq %xmm0, (%rsp) + movq %xmm1, 8(%rsp) + movq %xmm2, 16(%rsp) + movq %xmm3, 24(%rsp) + movq %xmm4, 32(%rsp) + movq %xmm5, 40(%rsp) + call _glapi_get_dispatch + movq 40(%rsp), %xmm5 + movq 32(%rsp), %xmm4 + movq 24(%rsp), %xmm3 + movq 16(%rsp), %xmm2 + movq 8(%rsp), %xmm1 + movq (%rsp), %xmm0 + addq $56, %rsp + movq 2368(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_296), .-GL_PREFIX(_dispatch_stub_296) + + .p2align 4,,15 + .globl GL_PREFIX(PopMatrix) + .type GL_PREFIX(PopMatrix), @function +GL_PREFIX(PopMatrix): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 2376(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rbp + call _x86_64_get_dispatch@PLT + popq %rbp + movq 2376(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 2376(%rax), %r11 + jmp *%r11 +1: + pushq %rbp + call _glapi_get_dispatch + popq %rbp + movq 2376(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(PopMatrix), .-GL_PREFIX(PopMatrix) + + .p2align 4,,15 + .globl GL_PREFIX(PushMatrix) + .type GL_PREFIX(PushMatrix), @function +GL_PREFIX(PushMatrix): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 2384(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rbp + call _x86_64_get_dispatch@PLT + popq %rbp + movq 2384(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 2384(%rax), %r11 + jmp *%r11 +1: + pushq %rbp + call _glapi_get_dispatch + popq %rbp + movq 2384(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(PushMatrix), .-GL_PREFIX(PushMatrix) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_299) + .type GL_PREFIX(_dispatch_stub_299), @function + HIDDEN(GL_PREFIX(_dispatch_stub_299)) +GL_PREFIX(_dispatch_stub_299): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 2392(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + subq $40, %rsp + movq %xmm0, (%rsp) + movq %xmm1, 8(%rsp) + movq %xmm2, 16(%rsp) + movq %xmm3, 24(%rsp) + call _x86_64_get_dispatch@PLT + movq 24(%rsp), %xmm3 + movq 16(%rsp), %xmm2 + movq 8(%rsp), %xmm1 + movq (%rsp), %xmm0 + addq $40, %rsp + movq 2392(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 2392(%rax), %r11 + jmp *%r11 +1: + subq $40, %rsp + movq %xmm0, (%rsp) + movq %xmm1, 8(%rsp) + movq %xmm2, 16(%rsp) + movq %xmm3, 24(%rsp) + call _glapi_get_dispatch + movq 24(%rsp), %xmm3 + movq 16(%rsp), %xmm2 + movq 8(%rsp), %xmm1 + movq (%rsp), %xmm0 + addq $40, %rsp + movq 2392(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_299), .-GL_PREFIX(_dispatch_stub_299) + + .p2align 4,,15 + .globl GL_PREFIX(Rotatef) + .type GL_PREFIX(Rotatef), @function +GL_PREFIX(Rotatef): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 2400(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + subq $40, %rsp + movq %xmm0, (%rsp) + movq %xmm1, 8(%rsp) + movq %xmm2, 16(%rsp) + movq %xmm3, 24(%rsp) + call _x86_64_get_dispatch@PLT + movq 24(%rsp), %xmm3 + movq 16(%rsp), %xmm2 + movq 8(%rsp), %xmm1 + movq (%rsp), %xmm0 + addq $40, %rsp + movq 2400(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 2400(%rax), %r11 + jmp *%r11 +1: + subq $40, %rsp + movq %xmm0, (%rsp) + movq %xmm1, 8(%rsp) + movq %xmm2, 16(%rsp) + movq %xmm3, 24(%rsp) + call _glapi_get_dispatch + movq 24(%rsp), %xmm3 + movq 16(%rsp), %xmm2 + movq 8(%rsp), %xmm1 + movq (%rsp), %xmm0 + addq $40, %rsp + movq 2400(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(Rotatef), .-GL_PREFIX(Rotatef) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_301) + .type GL_PREFIX(_dispatch_stub_301), @function + HIDDEN(GL_PREFIX(_dispatch_stub_301)) +GL_PREFIX(_dispatch_stub_301): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 2408(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + subq $24, %rsp + movq %xmm0, (%rsp) + movq %xmm1, 8(%rsp) + movq %xmm2, 16(%rsp) + call _x86_64_get_dispatch@PLT + movq 16(%rsp), %xmm2 + movq 8(%rsp), %xmm1 + movq (%rsp), %xmm0 + addq $24, %rsp + movq 2408(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 2408(%rax), %r11 + jmp *%r11 +1: + subq $24, %rsp + movq %xmm0, (%rsp) + movq %xmm1, 8(%rsp) + movq %xmm2, 16(%rsp) + call _glapi_get_dispatch + movq 16(%rsp), %xmm2 + movq 8(%rsp), %xmm1 + movq (%rsp), %xmm0 + addq $24, %rsp + movq 2408(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_301), .-GL_PREFIX(_dispatch_stub_301) + + .p2align 4,,15 + .globl GL_PREFIX(Scalef) + .type GL_PREFIX(Scalef), @function +GL_PREFIX(Scalef): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 2416(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + subq $24, %rsp + movq %xmm0, (%rsp) + movq %xmm1, 8(%rsp) + movq %xmm2, 16(%rsp) + call _x86_64_get_dispatch@PLT + movq 16(%rsp), %xmm2 + movq 8(%rsp), %xmm1 + movq (%rsp), %xmm0 + addq $24, %rsp + movq 2416(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 2416(%rax), %r11 + jmp *%r11 +1: + subq $24, %rsp + movq %xmm0, (%rsp) + movq %xmm1, 8(%rsp) + movq %xmm2, 16(%rsp) + call _glapi_get_dispatch + movq 16(%rsp), %xmm2 + movq 8(%rsp), %xmm1 + movq (%rsp), %xmm0 + addq $24, %rsp + movq 2416(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(Scalef), .-GL_PREFIX(Scalef) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_303) + .type GL_PREFIX(_dispatch_stub_303), @function + HIDDEN(GL_PREFIX(_dispatch_stub_303)) +GL_PREFIX(_dispatch_stub_303): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 2424(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + subq $24, %rsp + movq %xmm0, (%rsp) + movq %xmm1, 8(%rsp) + movq %xmm2, 16(%rsp) + call _x86_64_get_dispatch@PLT + movq 16(%rsp), %xmm2 + movq 8(%rsp), %xmm1 + movq (%rsp), %xmm0 + addq $24, %rsp + movq 2424(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 2424(%rax), %r11 + jmp *%r11 +1: + subq $24, %rsp + movq %xmm0, (%rsp) + movq %xmm1, 8(%rsp) + movq %xmm2, 16(%rsp) + call _glapi_get_dispatch + movq 16(%rsp), %xmm2 + movq 8(%rsp), %xmm1 + movq (%rsp), %xmm0 + addq $24, %rsp + movq 2424(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_303), .-GL_PREFIX(_dispatch_stub_303) + + .p2align 4,,15 + .globl GL_PREFIX(Translatef) + .type GL_PREFIX(Translatef), @function +GL_PREFIX(Translatef): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 2432(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + subq $24, %rsp + movq %xmm0, (%rsp) + movq %xmm1, 8(%rsp) + movq %xmm2, 16(%rsp) + call _x86_64_get_dispatch@PLT + movq 16(%rsp), %xmm2 + movq 8(%rsp), %xmm1 + movq (%rsp), %xmm0 + addq $24, %rsp + movq 2432(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 2432(%rax), %r11 + jmp *%r11 +1: + subq $24, %rsp + movq %xmm0, (%rsp) + movq %xmm1, 8(%rsp) + movq %xmm2, 16(%rsp) + call _glapi_get_dispatch + movq 16(%rsp), %xmm2 + movq 8(%rsp), %xmm1 + movq (%rsp), %xmm0 + addq $24, %rsp + movq 2432(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(Translatef), .-GL_PREFIX(Translatef) + + .p2align 4,,15 + .globl GL_PREFIX(Viewport) + .type GL_PREFIX(Viewport), @function +GL_PREFIX(Viewport): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 2440(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rdx + pushq %rcx + pushq %rbp + call _x86_64_get_dispatch@PLT + popq %rbp + popq %rcx + popq %rdx + popq %rsi + popq %rdi + movq 2440(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 2440(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rdx + pushq %rcx + pushq %rbp + call _glapi_get_dispatch + popq %rbp + popq %rcx + popq %rdx + popq %rsi + popq %rdi + movq 2440(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(Viewport), .-GL_PREFIX(Viewport) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_306) + .type GL_PREFIX(_dispatch_stub_306), @function + HIDDEN(GL_PREFIX(_dispatch_stub_306)) +GL_PREFIX(_dispatch_stub_306): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 2448(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + call _x86_64_get_dispatch@PLT + popq %rdi + movq 2448(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 2448(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + call _glapi_get_dispatch + popq %rdi + movq 2448(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_306), .-GL_PREFIX(_dispatch_stub_306) + + .p2align 4,,15 + .globl GL_PREFIX(BindTexture) + .type GL_PREFIX(BindTexture), @function +GL_PREFIX(BindTexture): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 2456(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rbp + call _x86_64_get_dispatch@PLT + popq %rbp + popq %rsi + popq %rdi + movq 2456(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 2456(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rbp + call _glapi_get_dispatch + popq %rbp + popq %rsi + popq %rdi + movq 2456(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(BindTexture), .-GL_PREFIX(BindTexture) + + .p2align 4,,15 + .globl GL_PREFIX(ColorPointer) + .type GL_PREFIX(ColorPointer), @function +GL_PREFIX(ColorPointer): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 2464(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rdx + pushq %rcx + pushq %rbp + call _x86_64_get_dispatch@PLT + popq %rbp + popq %rcx + popq %rdx + popq %rsi + popq %rdi + movq 2464(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 2464(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rdx + pushq %rcx + pushq %rbp + call _glapi_get_dispatch + popq %rbp + popq %rcx + popq %rdx + popq %rsi + popq %rdi + movq 2464(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(ColorPointer), .-GL_PREFIX(ColorPointer) + + .p2align 4,,15 + .globl GL_PREFIX(DisableClientState) + .type GL_PREFIX(DisableClientState), @function +GL_PREFIX(DisableClientState): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 2472(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + call _x86_64_get_dispatch@PLT + popq %rdi + movq 2472(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 2472(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + call _glapi_get_dispatch + popq %rdi + movq 2472(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(DisableClientState), .-GL_PREFIX(DisableClientState) + + .p2align 4,,15 + .globl GL_PREFIX(DrawArrays) + .type GL_PREFIX(DrawArrays), @function +GL_PREFIX(DrawArrays): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 2480(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rdx + call _x86_64_get_dispatch@PLT + popq %rdx + popq %rsi + popq %rdi + movq 2480(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 2480(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rdx + call _glapi_get_dispatch + popq %rdx + popq %rsi + popq %rdi + movq 2480(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(DrawArrays), .-GL_PREFIX(DrawArrays) + + .p2align 4,,15 + .globl GL_PREFIX(DrawElements) + .type GL_PREFIX(DrawElements), @function +GL_PREFIX(DrawElements): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 2488(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rdx + pushq %rcx + pushq %rbp + call _x86_64_get_dispatch@PLT + popq %rbp + popq %rcx + popq %rdx + popq %rsi + popq %rdi + movq 2488(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 2488(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rdx + pushq %rcx + pushq %rbp + call _glapi_get_dispatch + popq %rbp + popq %rcx + popq %rdx + popq %rsi + popq %rdi + movq 2488(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(DrawElements), .-GL_PREFIX(DrawElements) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_312) + .type GL_PREFIX(_dispatch_stub_312), @function + HIDDEN(GL_PREFIX(_dispatch_stub_312)) +GL_PREFIX(_dispatch_stub_312): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 2496(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rbp + call _x86_64_get_dispatch@PLT + popq %rbp + popq %rsi + popq %rdi + movq 2496(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 2496(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rbp + call _glapi_get_dispatch + popq %rbp + popq %rsi + popq %rdi + movq 2496(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_312), .-GL_PREFIX(_dispatch_stub_312) + + .p2align 4,,15 + .globl GL_PREFIX(EnableClientState) + .type GL_PREFIX(EnableClientState), @function +GL_PREFIX(EnableClientState): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 2504(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + call _x86_64_get_dispatch@PLT + popq %rdi + movq 2504(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 2504(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + call _glapi_get_dispatch + popq %rdi + movq 2504(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(EnableClientState), .-GL_PREFIX(EnableClientState) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_314) + .type GL_PREFIX(_dispatch_stub_314), @function + HIDDEN(GL_PREFIX(_dispatch_stub_314)) +GL_PREFIX(_dispatch_stub_314): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 2512(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rdx + call _x86_64_get_dispatch@PLT + popq %rdx + popq %rsi + popq %rdi + movq 2512(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 2512(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rdx + call _glapi_get_dispatch + popq %rdx + popq %rsi + popq %rdi + movq 2512(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_314), .-GL_PREFIX(_dispatch_stub_314) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_315) + .type GL_PREFIX(_dispatch_stub_315), @function + HIDDEN(GL_PREFIX(_dispatch_stub_315)) +GL_PREFIX(_dispatch_stub_315): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 2520(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + call _x86_64_get_dispatch@PLT + popq %rdi + movq 2520(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 2520(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + call _glapi_get_dispatch + popq %rdi + movq 2520(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_315), .-GL_PREFIX(_dispatch_stub_315) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_316) + .type GL_PREFIX(_dispatch_stub_316), @function + HIDDEN(GL_PREFIX(_dispatch_stub_316)) +GL_PREFIX(_dispatch_stub_316): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 2528(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + call _x86_64_get_dispatch@PLT + popq %rdi + movq 2528(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 2528(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + call _glapi_get_dispatch + popq %rdi + movq 2528(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_316), .-GL_PREFIX(_dispatch_stub_316) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_317) + .type GL_PREFIX(_dispatch_stub_317), @function + HIDDEN(GL_PREFIX(_dispatch_stub_317)) +GL_PREFIX(_dispatch_stub_317): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 2536(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rdx + call _x86_64_get_dispatch@PLT + popq %rdx + popq %rsi + popq %rdi + movq 2536(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 2536(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rdx + call _glapi_get_dispatch + popq %rdx + popq %rsi + popq %rdi + movq 2536(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_317), .-GL_PREFIX(_dispatch_stub_317) + + .p2align 4,,15 + .globl GL_PREFIX(NormalPointer) + .type GL_PREFIX(NormalPointer), @function +GL_PREFIX(NormalPointer): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 2544(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rdx + call _x86_64_get_dispatch@PLT + popq %rdx + popq %rsi + popq %rdi + movq 2544(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 2544(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rdx + call _glapi_get_dispatch + popq %rdx + popq %rsi + popq %rdi + movq 2544(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(NormalPointer), .-GL_PREFIX(NormalPointer) + + .p2align 4,,15 + .globl GL_PREFIX(PolygonOffset) + .type GL_PREFIX(PolygonOffset), @function +GL_PREFIX(PolygonOffset): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 2552(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + subq $24, %rsp + movq %xmm0, (%rsp) + movq %xmm1, 8(%rsp) + call _x86_64_get_dispatch@PLT + movq 8(%rsp), %xmm1 + movq (%rsp), %xmm0 + addq $24, %rsp + movq 2552(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 2552(%rax), %r11 + jmp *%r11 +1: + subq $24, %rsp + movq %xmm0, (%rsp) + movq %xmm1, 8(%rsp) + call _glapi_get_dispatch + movq 8(%rsp), %xmm1 + movq (%rsp), %xmm0 + addq $24, %rsp + movq 2552(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(PolygonOffset), .-GL_PREFIX(PolygonOffset) + + .p2align 4,,15 + .globl GL_PREFIX(TexCoordPointer) + .type GL_PREFIX(TexCoordPointer), @function +GL_PREFIX(TexCoordPointer): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 2560(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rdx + pushq %rcx + pushq %rbp + call _x86_64_get_dispatch@PLT + popq %rbp + popq %rcx + popq %rdx + popq %rsi + popq %rdi + movq 2560(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 2560(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rdx + pushq %rcx + pushq %rbp + call _glapi_get_dispatch + popq %rbp + popq %rcx + popq %rdx + popq %rsi + popq %rdi + movq 2560(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(TexCoordPointer), .-GL_PREFIX(TexCoordPointer) + + .p2align 4,,15 + .globl GL_PREFIX(VertexPointer) + .type GL_PREFIX(VertexPointer), @function +GL_PREFIX(VertexPointer): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 2568(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rdx + pushq %rcx + pushq %rbp + call _x86_64_get_dispatch@PLT + popq %rbp + popq %rcx + popq %rdx + popq %rsi + popq %rdi + movq 2568(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 2568(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rdx + pushq %rcx + pushq %rbp + call _glapi_get_dispatch + popq %rbp + popq %rcx + popq %rdx + popq %rsi + popq %rdi + movq 2568(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(VertexPointer), .-GL_PREFIX(VertexPointer) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_322) + .type GL_PREFIX(_dispatch_stub_322), @function + HIDDEN(GL_PREFIX(_dispatch_stub_322)) +GL_PREFIX(_dispatch_stub_322): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 2576(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rdx + call _x86_64_get_dispatch@PLT + popq %rdx + popq %rsi + popq %rdi + movq 2576(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 2576(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rdx + call _glapi_get_dispatch + popq %rdx + popq %rsi + popq %rdi + movq 2576(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_322), .-GL_PREFIX(_dispatch_stub_322) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_323) + .type GL_PREFIX(_dispatch_stub_323), @function + HIDDEN(GL_PREFIX(_dispatch_stub_323)) +GL_PREFIX(_dispatch_stub_323): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 2584(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rdx + pushq %rcx + pushq %r8 + pushq %r9 + pushq %rbp + call _x86_64_get_dispatch@PLT + popq %rbp + popq %r9 + popq %r8 + popq %rcx + popq %rdx + popq %rsi + popq %rdi + movq 2584(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 2584(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rdx + pushq %rcx + pushq %r8 + pushq %r9 + pushq %rbp + call _glapi_get_dispatch + popq %rbp + popq %r9 + popq %r8 + popq %rcx + popq %rdx + popq %rsi + popq %rdi + movq 2584(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_323), .-GL_PREFIX(_dispatch_stub_323) + + .p2align 4,,15 + .globl GL_PREFIX(CopyTexImage2D) + .type GL_PREFIX(CopyTexImage2D), @function +GL_PREFIX(CopyTexImage2D): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 2592(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rdx + pushq %rcx + pushq %r8 + pushq %r9 + pushq %rbp + call _x86_64_get_dispatch@PLT + popq %rbp + popq %r9 + popq %r8 + popq %rcx + popq %rdx + popq %rsi + popq %rdi + movq 2592(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 2592(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rdx + pushq %rcx + pushq %r8 + pushq %r9 + pushq %rbp + call _glapi_get_dispatch + popq %rbp + popq %r9 + popq %r8 + popq %rcx + popq %rdx + popq %rsi + popq %rdi + movq 2592(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(CopyTexImage2D), .-GL_PREFIX(CopyTexImage2D) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_325) + .type GL_PREFIX(_dispatch_stub_325), @function + HIDDEN(GL_PREFIX(_dispatch_stub_325)) +GL_PREFIX(_dispatch_stub_325): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 2600(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rdx + pushq %rcx + pushq %r8 + pushq %r9 + pushq %rbp + call _x86_64_get_dispatch@PLT + popq %rbp + popq %r9 + popq %r8 + popq %rcx + popq %rdx + popq %rsi + popq %rdi + movq 2600(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 2600(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rdx + pushq %rcx + pushq %r8 + pushq %r9 + pushq %rbp + call _glapi_get_dispatch + popq %rbp + popq %r9 + popq %r8 + popq %rcx + popq %rdx + popq %rsi + popq %rdi + movq 2600(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_325), .-GL_PREFIX(_dispatch_stub_325) + + .p2align 4,,15 + .globl GL_PREFIX(CopyTexSubImage2D) + .type GL_PREFIX(CopyTexSubImage2D), @function +GL_PREFIX(CopyTexSubImage2D): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 2608(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rdx + pushq %rcx + pushq %r8 + pushq %r9 + pushq %rbp + call _x86_64_get_dispatch@PLT + popq %rbp + popq %r9 + popq %r8 + popq %rcx + popq %rdx + popq %rsi + popq %rdi + movq 2608(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 2608(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rdx + pushq %rcx + pushq %r8 + pushq %r9 + pushq %rbp + call _glapi_get_dispatch + popq %rbp + popq %r9 + popq %r8 + popq %rcx + popq %rdx + popq %rsi + popq %rdi + movq 2608(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(CopyTexSubImage2D), .-GL_PREFIX(CopyTexSubImage2D) + + .p2align 4,,15 + .globl GL_PREFIX(DeleteTextures) + .type GL_PREFIX(DeleteTextures), @function +GL_PREFIX(DeleteTextures): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 2616(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rbp + call _x86_64_get_dispatch@PLT + popq %rbp + popq %rsi + popq %rdi + movq 2616(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 2616(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rbp + call _glapi_get_dispatch + popq %rbp + popq %rsi + popq %rdi + movq 2616(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(DeleteTextures), .-GL_PREFIX(DeleteTextures) + + .p2align 4,,15 + .globl GL_PREFIX(GenTextures) + .type GL_PREFIX(GenTextures), @function +GL_PREFIX(GenTextures): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 2624(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rbp + call _x86_64_get_dispatch@PLT + popq %rbp + popq %rsi + popq %rdi + movq 2624(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 2624(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rbp + call _glapi_get_dispatch + popq %rbp + popq %rsi + popq %rdi + movq 2624(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(GenTextures), .-GL_PREFIX(GenTextures) + + .p2align 4,,15 + .globl GL_PREFIX(GetPointerv) + .type GL_PREFIX(GetPointerv), @function +GL_PREFIX(GetPointerv): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 2632(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rbp + call _x86_64_get_dispatch@PLT + popq %rbp + popq %rsi + popq %rdi + movq 2632(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 2632(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rbp + call _glapi_get_dispatch + popq %rbp + popq %rsi + popq %rdi + movq 2632(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(GetPointerv), .-GL_PREFIX(GetPointerv) + + .p2align 4,,15 + .globl GL_PREFIX(IsTexture) + .type GL_PREFIX(IsTexture), @function +GL_PREFIX(IsTexture): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 2640(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + call _x86_64_get_dispatch@PLT + popq %rdi + movq 2640(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 2640(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + call _glapi_get_dispatch + popq %rdi + movq 2640(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(IsTexture), .-GL_PREFIX(IsTexture) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_331) + .type GL_PREFIX(_dispatch_stub_331), @function + HIDDEN(GL_PREFIX(_dispatch_stub_331)) +GL_PREFIX(_dispatch_stub_331): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 2648(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rdx + call _x86_64_get_dispatch@PLT + popq %rdx + popq %rsi + popq %rdi + movq 2648(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 2648(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rdx + call _glapi_get_dispatch + popq %rdx + popq %rsi + popq %rdi + movq 2648(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_331), .-GL_PREFIX(_dispatch_stub_331) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_332) + .type GL_PREFIX(_dispatch_stub_332), @function + HIDDEN(GL_PREFIX(_dispatch_stub_332)) +GL_PREFIX(_dispatch_stub_332): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 2656(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rdx + pushq %rcx + pushq %r8 + pushq %r9 + pushq %rbp + call _x86_64_get_dispatch@PLT + popq %rbp + popq %r9 + popq %r8 + popq %rcx + popq %rdx + popq %rsi + popq %rdi + movq 2656(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 2656(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rdx + pushq %rcx + pushq %r8 + pushq %r9 + pushq %rbp + call _glapi_get_dispatch + popq %rbp + popq %r9 + popq %r8 + popq %rcx + popq %rdx + popq %rsi + popq %rdi + movq 2656(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_332), .-GL_PREFIX(_dispatch_stub_332) + + .p2align 4,,15 + .globl GL_PREFIX(TexSubImage2D) + .type GL_PREFIX(TexSubImage2D), @function +GL_PREFIX(TexSubImage2D): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 2664(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rdx + pushq %rcx + pushq %r8 + pushq %r9 + pushq %rbp + call _x86_64_get_dispatch@PLT + popq %rbp + popq %r9 + popq %r8 + popq %rcx + popq %rdx + popq %rsi + popq %rdi + movq 2664(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 2664(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rdx + pushq %rcx + pushq %r8 + pushq %r9 + pushq %rbp + call _glapi_get_dispatch + popq %rbp + popq %r9 + popq %r8 + popq %rcx + popq %rdx + popq %rsi + popq %rdi + movq 2664(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(TexSubImage2D), .-GL_PREFIX(TexSubImage2D) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_334) + .type GL_PREFIX(_dispatch_stub_334), @function + HIDDEN(GL_PREFIX(_dispatch_stub_334)) +GL_PREFIX(_dispatch_stub_334): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 2672(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rbp + call _x86_64_get_dispatch@PLT + popq %rbp + movq 2672(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 2672(%rax), %r11 + jmp *%r11 +1: + pushq %rbp + call _glapi_get_dispatch + popq %rbp + movq 2672(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_334), .-GL_PREFIX(_dispatch_stub_334) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_335) + .type GL_PREFIX(_dispatch_stub_335), @function + HIDDEN(GL_PREFIX(_dispatch_stub_335)) +GL_PREFIX(_dispatch_stub_335): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 2680(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + call _x86_64_get_dispatch@PLT + popq %rdi + movq 2680(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 2680(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + call _glapi_get_dispatch + popq %rdi + movq 2680(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_335), .-GL_PREFIX(_dispatch_stub_335) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_336) + .type GL_PREFIX(_dispatch_stub_336), @function + HIDDEN(GL_PREFIX(_dispatch_stub_336)) +GL_PREFIX(_dispatch_stub_336): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 2688(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rdx + pushq %rcx + pushq %rbp + call _x86_64_get_dispatch@PLT + popq %rbp + popq %rcx + popq %rdx + popq %rsi + popq %rdi + movq 2688(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 2688(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rdx + pushq %rcx + pushq %rbp + call _glapi_get_dispatch + popq %rbp + popq %rcx + popq %rdx + popq %rsi + popq %rdi + movq 2688(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_336), .-GL_PREFIX(_dispatch_stub_336) + + .p2align 4,,15 + .globl GL_PREFIX(BlendEquationOES) + .type GL_PREFIX(BlendEquationOES), @function +GL_PREFIX(BlendEquationOES): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 2696(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + call _x86_64_get_dispatch@PLT + popq %rdi + movq 2696(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 2696(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + call _glapi_get_dispatch + popq %rdi + movq 2696(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(BlendEquationOES), .-GL_PREFIX(BlendEquationOES) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_338) + .type GL_PREFIX(_dispatch_stub_338), @function + HIDDEN(GL_PREFIX(_dispatch_stub_338)) +GL_PREFIX(_dispatch_stub_338): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 2704(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rdx + pushq %rcx + pushq %r8 + pushq %r9 + pushq %rbp + call _x86_64_get_dispatch@PLT + popq %rbp + popq %r9 + popq %r8 + popq %rcx + popq %rdx + popq %rsi + popq %rdi + movq 2704(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 2704(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rdx + pushq %rcx + pushq %r8 + pushq %r9 + pushq %rbp + call _glapi_get_dispatch + popq %rbp + popq %r9 + popq %r8 + popq %rcx + popq %rdx + popq %rsi + popq %rdi + movq 2704(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_338), .-GL_PREFIX(_dispatch_stub_338) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_339) + .type GL_PREFIX(_dispatch_stub_339), @function + HIDDEN(GL_PREFIX(_dispatch_stub_339)) +GL_PREFIX(_dispatch_stub_339): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 2712(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rdx + pushq %rcx + pushq %r8 + pushq %r9 + pushq %rbp + call _x86_64_get_dispatch@PLT + popq %rbp + popq %r9 + popq %r8 + popq %rcx + popq %rdx + popq %rsi + popq %rdi + movq 2712(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 2712(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rdx + pushq %rcx + pushq %r8 + pushq %r9 + pushq %rbp + call _glapi_get_dispatch + popq %rbp + popq %r9 + popq %r8 + popq %rcx + popq %rdx + popq %rsi + popq %rdi + movq 2712(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_339), .-GL_PREFIX(_dispatch_stub_339) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_340) + .type GL_PREFIX(_dispatch_stub_340), @function + HIDDEN(GL_PREFIX(_dispatch_stub_340)) +GL_PREFIX(_dispatch_stub_340): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 2720(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rdx + call _x86_64_get_dispatch@PLT + popq %rdx + popq %rsi + popq %rdi + movq 2720(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 2720(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rdx + call _glapi_get_dispatch + popq %rdx + popq %rsi + popq %rdi + movq 2720(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_340), .-GL_PREFIX(_dispatch_stub_340) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_341) + .type GL_PREFIX(_dispatch_stub_341), @function + HIDDEN(GL_PREFIX(_dispatch_stub_341)) +GL_PREFIX(_dispatch_stub_341): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 2728(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rdx + call _x86_64_get_dispatch@PLT + popq %rdx + popq %rsi + popq %rdi + movq 2728(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 2728(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rdx + call _glapi_get_dispatch + popq %rdx + popq %rsi + popq %rdi + movq 2728(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_341), .-GL_PREFIX(_dispatch_stub_341) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_342) + .type GL_PREFIX(_dispatch_stub_342), @function + HIDDEN(GL_PREFIX(_dispatch_stub_342)) +GL_PREFIX(_dispatch_stub_342): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 2736(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rdx + pushq %rcx + pushq %r8 + call _x86_64_get_dispatch@PLT + popq %r8 + popq %rcx + popq %rdx + popq %rsi + popq %rdi + movq 2736(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 2736(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rdx + pushq %rcx + pushq %r8 + call _glapi_get_dispatch + popq %r8 + popq %rcx + popq %rdx + popq %rsi + popq %rdi + movq 2736(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_342), .-GL_PREFIX(_dispatch_stub_342) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_343) + .type GL_PREFIX(_dispatch_stub_343), @function + HIDDEN(GL_PREFIX(_dispatch_stub_343)) +GL_PREFIX(_dispatch_stub_343): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 2744(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rdx + pushq %rcx + pushq %rbp + call _x86_64_get_dispatch@PLT + popq %rbp + popq %rcx + popq %rdx + popq %rsi + popq %rdi + movq 2744(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 2744(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rdx + pushq %rcx + pushq %rbp + call _glapi_get_dispatch + popq %rbp + popq %rcx + popq %rdx + popq %rsi + popq %rdi + movq 2744(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_343), .-GL_PREFIX(_dispatch_stub_343) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_344) + .type GL_PREFIX(_dispatch_stub_344), @function + HIDDEN(GL_PREFIX(_dispatch_stub_344)) +GL_PREFIX(_dispatch_stub_344): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 2752(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rdx + call _x86_64_get_dispatch@PLT + popq %rdx + popq %rsi + popq %rdi + movq 2752(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 2752(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rdx + call _glapi_get_dispatch + popq %rdx + popq %rsi + popq %rdi + movq 2752(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_344), .-GL_PREFIX(_dispatch_stub_344) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_345) + .type GL_PREFIX(_dispatch_stub_345), @function + HIDDEN(GL_PREFIX(_dispatch_stub_345)) +GL_PREFIX(_dispatch_stub_345): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 2760(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rdx + call _x86_64_get_dispatch@PLT + popq %rdx + popq %rsi + popq %rdi + movq 2760(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 2760(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rdx + call _glapi_get_dispatch + popq %rdx + popq %rsi + popq %rdi + movq 2760(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_345), .-GL_PREFIX(_dispatch_stub_345) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_346) + .type GL_PREFIX(_dispatch_stub_346), @function + HIDDEN(GL_PREFIX(_dispatch_stub_346)) +GL_PREFIX(_dispatch_stub_346): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 2768(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rdx + pushq %rcx + pushq %r8 + pushq %r9 + pushq %rbp + call _x86_64_get_dispatch@PLT + popq %rbp + popq %r9 + popq %r8 + popq %rcx + popq %rdx + popq %rsi + popq %rdi + movq 2768(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 2768(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rdx + pushq %rcx + pushq %r8 + pushq %r9 + pushq %rbp + call _glapi_get_dispatch + popq %rbp + popq %r9 + popq %r8 + popq %rcx + popq %rdx + popq %rsi + popq %rdi + movq 2768(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_346), .-GL_PREFIX(_dispatch_stub_346) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_347) + .type GL_PREFIX(_dispatch_stub_347), @function + HIDDEN(GL_PREFIX(_dispatch_stub_347)) +GL_PREFIX(_dispatch_stub_347): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 2776(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rdx + pushq %rcx + pushq %r8 + call _x86_64_get_dispatch@PLT + popq %r8 + popq %rcx + popq %rdx + popq %rsi + popq %rdi + movq 2776(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 2776(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rdx + pushq %rcx + pushq %r8 + call _glapi_get_dispatch + popq %r8 + popq %rcx + popq %rdx + popq %rsi + popq %rdi + movq 2776(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_347), .-GL_PREFIX(_dispatch_stub_347) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_348) + .type GL_PREFIX(_dispatch_stub_348), @function + HIDDEN(GL_PREFIX(_dispatch_stub_348)) +GL_PREFIX(_dispatch_stub_348): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 2784(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rdx + pushq %rcx + pushq %r8 + pushq %r9 + pushq %rbp + call _x86_64_get_dispatch@PLT + popq %rbp + popq %r9 + popq %r8 + popq %rcx + popq %rdx + popq %rsi + popq %rdi + movq 2784(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 2784(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rdx + pushq %rcx + pushq %r8 + pushq %r9 + pushq %rbp + call _glapi_get_dispatch + popq %rbp + popq %r9 + popq %r8 + popq %rcx + popq %rdx + popq %rsi + popq %rdi + movq 2784(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_348), .-GL_PREFIX(_dispatch_stub_348) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_349) + .type GL_PREFIX(_dispatch_stub_349), @function + HIDDEN(GL_PREFIX(_dispatch_stub_349)) +GL_PREFIX(_dispatch_stub_349): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 2792(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rdx + pushq %rcx + pushq %r8 + pushq %r9 + pushq %rbp + call _x86_64_get_dispatch@PLT + popq %rbp + popq %r9 + popq %r8 + popq %rcx + popq %rdx + popq %rsi + popq %rdi + movq 2792(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 2792(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rdx + pushq %rcx + pushq %r8 + pushq %r9 + pushq %rbp + call _glapi_get_dispatch + popq %rbp + popq %r9 + popq %r8 + popq %rcx + popq %rdx + popq %rsi + popq %rdi + movq 2792(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_349), .-GL_PREFIX(_dispatch_stub_349) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_350) + .type GL_PREFIX(_dispatch_stub_350), @function + HIDDEN(GL_PREFIX(_dispatch_stub_350)) +GL_PREFIX(_dispatch_stub_350): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 2800(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + subq $24, %rsp + movq %rdi, (%rsp) + movq %rsi, 8(%rsp) + movq %xmm0, 16(%rsp) + call _x86_64_get_dispatch@PLT + movq 16(%rsp), %xmm0 + movq 8(%rsp), %rsi + movq (%rsp), %rdi + addq $24, %rsp + movq 2800(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 2800(%rax), %r11 + jmp *%r11 +1: + subq $24, %rsp + movq %rdi, (%rsp) + movq %rsi, 8(%rsp) + movq %xmm0, 16(%rsp) + call _glapi_get_dispatch + movq 16(%rsp), %xmm0 + movq 8(%rsp), %rsi + movq (%rsp), %rdi + addq $24, %rsp + movq 2800(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_350), .-GL_PREFIX(_dispatch_stub_350) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_351) + .type GL_PREFIX(_dispatch_stub_351), @function + HIDDEN(GL_PREFIX(_dispatch_stub_351)) +GL_PREFIX(_dispatch_stub_351): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 2808(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rdx + call _x86_64_get_dispatch@PLT + popq %rdx + popq %rsi + popq %rdi + movq 2808(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 2808(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rdx + call _glapi_get_dispatch + popq %rdx + popq %rsi + popq %rdi + movq 2808(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_351), .-GL_PREFIX(_dispatch_stub_351) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_352) + .type GL_PREFIX(_dispatch_stub_352), @function + HIDDEN(GL_PREFIX(_dispatch_stub_352)) +GL_PREFIX(_dispatch_stub_352): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 2816(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rdx + call _x86_64_get_dispatch@PLT + popq %rdx + popq %rsi + popq %rdi + movq 2816(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 2816(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rdx + call _glapi_get_dispatch + popq %rdx + popq %rsi + popq %rdi + movq 2816(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_352), .-GL_PREFIX(_dispatch_stub_352) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_353) + .type GL_PREFIX(_dispatch_stub_353), @function + HIDDEN(GL_PREFIX(_dispatch_stub_353)) +GL_PREFIX(_dispatch_stub_353): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 2824(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rdx + call _x86_64_get_dispatch@PLT + popq %rdx + popq %rsi + popq %rdi + movq 2824(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 2824(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rdx + call _glapi_get_dispatch + popq %rdx + popq %rsi + popq %rdi + movq 2824(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_353), .-GL_PREFIX(_dispatch_stub_353) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_354) + .type GL_PREFIX(_dispatch_stub_354), @function + HIDDEN(GL_PREFIX(_dispatch_stub_354)) +GL_PREFIX(_dispatch_stub_354): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 2832(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rdx + pushq %rcx + pushq %r8 + call _x86_64_get_dispatch@PLT + popq %r8 + popq %rcx + popq %rdx + popq %rsi + popq %rdi + movq 2832(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 2832(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rdx + pushq %rcx + pushq %r8 + call _glapi_get_dispatch + popq %r8 + popq %rcx + popq %rdx + popq %rsi + popq %rdi + movq 2832(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_354), .-GL_PREFIX(_dispatch_stub_354) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_355) + .type GL_PREFIX(_dispatch_stub_355), @function + HIDDEN(GL_PREFIX(_dispatch_stub_355)) +GL_PREFIX(_dispatch_stub_355): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 2840(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rdx + pushq %rcx + pushq %r8 + pushq %r9 + pushq %rbp + call _x86_64_get_dispatch@PLT + popq %rbp + popq %r9 + popq %r8 + popq %rcx + popq %rdx + popq %rsi + popq %rdi + movq 2840(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 2840(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rdx + pushq %rcx + pushq %r8 + pushq %r9 + pushq %rbp + call _glapi_get_dispatch + popq %rbp + popq %r9 + popq %r8 + popq %rcx + popq %rdx + popq %rsi + popq %rdi + movq 2840(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_355), .-GL_PREFIX(_dispatch_stub_355) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_356) + .type GL_PREFIX(_dispatch_stub_356), @function + HIDDEN(GL_PREFIX(_dispatch_stub_356)) +GL_PREFIX(_dispatch_stub_356): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 2848(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rdx + pushq %rcx + pushq %rbp + call _x86_64_get_dispatch@PLT + popq %rbp + popq %rcx + popq %rdx + popq %rsi + popq %rdi + movq 2848(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 2848(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rdx + pushq %rcx + pushq %rbp + call _glapi_get_dispatch + popq %rbp + popq %rcx + popq %rdx + popq %rsi + popq %rdi + movq 2848(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_356), .-GL_PREFIX(_dispatch_stub_356) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_357) + .type GL_PREFIX(_dispatch_stub_357), @function + HIDDEN(GL_PREFIX(_dispatch_stub_357)) +GL_PREFIX(_dispatch_stub_357): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 2856(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rdx + call _x86_64_get_dispatch@PLT + popq %rdx + popq %rsi + popq %rdi + movq 2856(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 2856(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rdx + call _glapi_get_dispatch + popq %rdx + popq %rsi + popq %rdi + movq 2856(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_357), .-GL_PREFIX(_dispatch_stub_357) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_358) + .type GL_PREFIX(_dispatch_stub_358), @function + HIDDEN(GL_PREFIX(_dispatch_stub_358)) +GL_PREFIX(_dispatch_stub_358): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 2864(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rdx + call _x86_64_get_dispatch@PLT + popq %rdx + popq %rsi + popq %rdi + movq 2864(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 2864(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rdx + call _glapi_get_dispatch + popq %rdx + popq %rsi + popq %rdi + movq 2864(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_358), .-GL_PREFIX(_dispatch_stub_358) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_359) + .type GL_PREFIX(_dispatch_stub_359), @function + HIDDEN(GL_PREFIX(_dispatch_stub_359)) +GL_PREFIX(_dispatch_stub_359): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 2872(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rdx + pushq %rcx + pushq %r8 + pushq %r9 + pushq %rbp + call _x86_64_get_dispatch@PLT + popq %rbp + popq %r9 + popq %r8 + popq %rcx + popq %rdx + popq %rsi + popq %rdi + movq 2872(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 2872(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rdx + pushq %rcx + pushq %r8 + pushq %r9 + pushq %rbp + call _glapi_get_dispatch + popq %rbp + popq %r9 + popq %r8 + popq %rcx + popq %rdx + popq %rsi + popq %rdi + movq 2872(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_359), .-GL_PREFIX(_dispatch_stub_359) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_360) + .type GL_PREFIX(_dispatch_stub_360), @function + HIDDEN(GL_PREFIX(_dispatch_stub_360)) +GL_PREFIX(_dispatch_stub_360): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 2880(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rdx + pushq %rcx + pushq %r8 + pushq %r9 + pushq %rbp + call _x86_64_get_dispatch@PLT + popq %rbp + popq %r9 + popq %r8 + popq %rcx + popq %rdx + popq %rsi + popq %rdi + movq 2880(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 2880(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rdx + pushq %rcx + pushq %r8 + pushq %r9 + pushq %rbp + call _glapi_get_dispatch + popq %rbp + popq %r9 + popq %r8 + popq %rcx + popq %rdx + popq %rsi + popq %rdi + movq 2880(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_360), .-GL_PREFIX(_dispatch_stub_360) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_361) + .type GL_PREFIX(_dispatch_stub_361), @function + HIDDEN(GL_PREFIX(_dispatch_stub_361)) +GL_PREFIX(_dispatch_stub_361): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 2888(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rdx + pushq %rcx + pushq %r8 + call _x86_64_get_dispatch@PLT + popq %r8 + popq %rcx + popq %rdx + popq %rsi + popq %rdi + movq 2888(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 2888(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rdx + pushq %rcx + pushq %r8 + call _glapi_get_dispatch + popq %r8 + popq %rcx + popq %rdx + popq %rsi + popq %rdi + movq 2888(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_361), .-GL_PREFIX(_dispatch_stub_361) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_362) + .type GL_PREFIX(_dispatch_stub_362), @function + HIDDEN(GL_PREFIX(_dispatch_stub_362)) +GL_PREFIX(_dispatch_stub_362): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 2896(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rdx + call _x86_64_get_dispatch@PLT + popq %rdx + popq %rsi + popq %rdi + movq 2896(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 2896(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rdx + call _glapi_get_dispatch + popq %rdx + popq %rsi + popq %rdi + movq 2896(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_362), .-GL_PREFIX(_dispatch_stub_362) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_363) + .type GL_PREFIX(_dispatch_stub_363), @function + HIDDEN(GL_PREFIX(_dispatch_stub_363)) +GL_PREFIX(_dispatch_stub_363): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 2904(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rdx + call _x86_64_get_dispatch@PLT + popq %rdx + popq %rsi + popq %rdi + movq 2904(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 2904(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rdx + call _glapi_get_dispatch + popq %rdx + popq %rsi + popq %rdi + movq 2904(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_363), .-GL_PREFIX(_dispatch_stub_363) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_364) + .type GL_PREFIX(_dispatch_stub_364), @function + HIDDEN(GL_PREFIX(_dispatch_stub_364)) +GL_PREFIX(_dispatch_stub_364): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 2912(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rdx + pushq %rcx + pushq %r8 + call _x86_64_get_dispatch@PLT + popq %r8 + popq %rcx + popq %rdx + popq %rsi + popq %rdi + movq 2912(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 2912(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rdx + pushq %rcx + pushq %r8 + call _glapi_get_dispatch + popq %r8 + popq %rcx + popq %rdx + popq %rsi + popq %rdi + movq 2912(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_364), .-GL_PREFIX(_dispatch_stub_364) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_365) + .type GL_PREFIX(_dispatch_stub_365), @function + HIDDEN(GL_PREFIX(_dispatch_stub_365)) +GL_PREFIX(_dispatch_stub_365): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 2920(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rdx + call _x86_64_get_dispatch@PLT + popq %rdx + popq %rsi + popq %rdi + movq 2920(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 2920(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rdx + call _glapi_get_dispatch + popq %rdx + popq %rsi + popq %rdi + movq 2920(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_365), .-GL_PREFIX(_dispatch_stub_365) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_366) + .type GL_PREFIX(_dispatch_stub_366), @function + HIDDEN(GL_PREFIX(_dispatch_stub_366)) +GL_PREFIX(_dispatch_stub_366): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 2928(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rdx + call _x86_64_get_dispatch@PLT + popq %rdx + popq %rsi + popq %rdi + movq 2928(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 2928(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rdx + call _glapi_get_dispatch + popq %rdx + popq %rsi + popq %rdi + movq 2928(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_366), .-GL_PREFIX(_dispatch_stub_366) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_367) + .type GL_PREFIX(_dispatch_stub_367), @function + HIDDEN(GL_PREFIX(_dispatch_stub_367)) +GL_PREFIX(_dispatch_stub_367): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 2936(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rdx + pushq %rcx + pushq %rbp + call _x86_64_get_dispatch@PLT + popq %rbp + popq %rcx + popq %rdx + popq %rsi + popq %rdi + movq 2936(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 2936(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rdx + pushq %rcx + pushq %rbp + call _glapi_get_dispatch + popq %rbp + popq %rcx + popq %rdx + popq %rsi + popq %rdi + movq 2936(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_367), .-GL_PREFIX(_dispatch_stub_367) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_368) + .type GL_PREFIX(_dispatch_stub_368), @function + HIDDEN(GL_PREFIX(_dispatch_stub_368)) +GL_PREFIX(_dispatch_stub_368): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 2944(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rdx + call _x86_64_get_dispatch@PLT + popq %rdx + popq %rsi + popq %rdi + movq 2944(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 2944(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rdx + call _glapi_get_dispatch + popq %rdx + popq %rsi + popq %rdi + movq 2944(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_368), .-GL_PREFIX(_dispatch_stub_368) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_369) + .type GL_PREFIX(_dispatch_stub_369), @function + HIDDEN(GL_PREFIX(_dispatch_stub_369)) +GL_PREFIX(_dispatch_stub_369): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 2952(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + call _x86_64_get_dispatch@PLT + popq %rdi + movq 2952(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 2952(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + call _glapi_get_dispatch + popq %rdi + movq 2952(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_369), .-GL_PREFIX(_dispatch_stub_369) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_370) + .type GL_PREFIX(_dispatch_stub_370), @function + HIDDEN(GL_PREFIX(_dispatch_stub_370)) +GL_PREFIX(_dispatch_stub_370): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 2960(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + call _x86_64_get_dispatch@PLT + popq %rdi + movq 2960(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 2960(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + call _glapi_get_dispatch + popq %rdi + movq 2960(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_370), .-GL_PREFIX(_dispatch_stub_370) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_371) + .type GL_PREFIX(_dispatch_stub_371), @function + HIDDEN(GL_PREFIX(_dispatch_stub_371)) +GL_PREFIX(_dispatch_stub_371): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 2968(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rdx + pushq %rcx + pushq %r8 + pushq %r9 + pushq %rbp + call _x86_64_get_dispatch@PLT + popq %rbp + popq %r9 + popq %r8 + popq %rcx + popq %rdx + popq %rsi + popq %rdi + movq 2968(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 2968(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rdx + pushq %rcx + pushq %r8 + pushq %r9 + pushq %rbp + call _glapi_get_dispatch + popq %rbp + popq %r9 + popq %r8 + popq %rcx + popq %rdx + popq %rsi + popq %rdi + movq 2968(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_371), .-GL_PREFIX(_dispatch_stub_371) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_372) + .type GL_PREFIX(_dispatch_stub_372), @function + HIDDEN(GL_PREFIX(_dispatch_stub_372)) +GL_PREFIX(_dispatch_stub_372): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 2976(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rdx + pushq %rcx + pushq %r8 + pushq %r9 + pushq %rbp + call _x86_64_get_dispatch@PLT + popq %rbp + popq %r9 + popq %r8 + popq %rcx + popq %rdx + popq %rsi + popq %rdi + movq 2976(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 2976(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rdx + pushq %rcx + pushq %r8 + pushq %r9 + pushq %rbp + call _glapi_get_dispatch + popq %rbp + popq %r9 + popq %r8 + popq %rcx + popq %rdx + popq %rsi + popq %rdi + movq 2976(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_372), .-GL_PREFIX(_dispatch_stub_372) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_373) + .type GL_PREFIX(_dispatch_stub_373), @function + HIDDEN(GL_PREFIX(_dispatch_stub_373)) +GL_PREFIX(_dispatch_stub_373): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 2984(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rdx + pushq %rcx + pushq %r8 + pushq %r9 + pushq %rbp + call _x86_64_get_dispatch@PLT + popq %rbp + popq %r9 + popq %r8 + popq %rcx + popq %rdx + popq %rsi + popq %rdi + movq 2984(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 2984(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rdx + pushq %rcx + pushq %r8 + pushq %r9 + pushq %rbp + call _glapi_get_dispatch + popq %rbp + popq %r9 + popq %r8 + popq %rcx + popq %rdx + popq %rsi + popq %rdi + movq 2984(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_373), .-GL_PREFIX(_dispatch_stub_373) + + .p2align 4,,15 + .globl GL_PREFIX(ActiveTexture) + .type GL_PREFIX(ActiveTexture), @function +GL_PREFIX(ActiveTexture): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 2992(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + call _x86_64_get_dispatch@PLT + popq %rdi + movq 2992(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 2992(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + call _glapi_get_dispatch + popq %rdi + movq 2992(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(ActiveTexture), .-GL_PREFIX(ActiveTexture) + + .p2align 4,,15 + .globl GL_PREFIX(ClientActiveTexture) + .type GL_PREFIX(ClientActiveTexture), @function +GL_PREFIX(ClientActiveTexture): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 3000(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + call _x86_64_get_dispatch@PLT + popq %rdi + movq 3000(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 3000(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + call _glapi_get_dispatch + popq %rdi + movq 3000(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(ClientActiveTexture), .-GL_PREFIX(ClientActiveTexture) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_376) + .type GL_PREFIX(_dispatch_stub_376), @function + HIDDEN(GL_PREFIX(_dispatch_stub_376)) +GL_PREFIX(_dispatch_stub_376): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 3008(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + subq $24, %rsp + movq %rdi, (%rsp) + movq %xmm0, 8(%rsp) + call _x86_64_get_dispatch@PLT + movq 8(%rsp), %xmm0 + movq (%rsp), %rdi + addq $24, %rsp + movq 3008(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 3008(%rax), %r11 + jmp *%r11 +1: + subq $24, %rsp + movq %rdi, (%rsp) + movq %xmm0, 8(%rsp) + call _glapi_get_dispatch + movq 8(%rsp), %xmm0 + movq (%rsp), %rdi + addq $24, %rsp + movq 3008(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_376), .-GL_PREFIX(_dispatch_stub_376) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_377) + .type GL_PREFIX(_dispatch_stub_377), @function + HIDDEN(GL_PREFIX(_dispatch_stub_377)) +GL_PREFIX(_dispatch_stub_377): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 3016(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rbp + call _x86_64_get_dispatch@PLT + popq %rbp + popq %rsi + popq %rdi + movq 3016(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 3016(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rbp + call _glapi_get_dispatch + popq %rbp + popq %rsi + popq %rdi + movq 3016(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_377), .-GL_PREFIX(_dispatch_stub_377) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_378) + .type GL_PREFIX(_dispatch_stub_378), @function + HIDDEN(GL_PREFIX(_dispatch_stub_378)) +GL_PREFIX(_dispatch_stub_378): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 3024(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + subq $24, %rsp + movq %rdi, (%rsp) + movq %xmm0, 8(%rsp) + call _x86_64_get_dispatch@PLT + movq 8(%rsp), %xmm0 + movq (%rsp), %rdi + addq $24, %rsp + movq 3024(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 3024(%rax), %r11 + jmp *%r11 +1: + subq $24, %rsp + movq %rdi, (%rsp) + movq %xmm0, 8(%rsp) + call _glapi_get_dispatch + movq 8(%rsp), %xmm0 + movq (%rsp), %rdi + addq $24, %rsp + movq 3024(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_378), .-GL_PREFIX(_dispatch_stub_378) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_379) + .type GL_PREFIX(_dispatch_stub_379), @function + HIDDEN(GL_PREFIX(_dispatch_stub_379)) +GL_PREFIX(_dispatch_stub_379): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 3032(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rbp + call _x86_64_get_dispatch@PLT + popq %rbp + popq %rsi + popq %rdi + movq 3032(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 3032(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rbp + call _glapi_get_dispatch + popq %rbp + popq %rsi + popq %rdi + movq 3032(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_379), .-GL_PREFIX(_dispatch_stub_379) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_380) + .type GL_PREFIX(_dispatch_stub_380), @function + HIDDEN(GL_PREFIX(_dispatch_stub_380)) +GL_PREFIX(_dispatch_stub_380): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 3040(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rbp + call _x86_64_get_dispatch@PLT + popq %rbp + popq %rsi + popq %rdi + movq 3040(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 3040(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rbp + call _glapi_get_dispatch + popq %rbp + popq %rsi + popq %rdi + movq 3040(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_380), .-GL_PREFIX(_dispatch_stub_380) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_381) + .type GL_PREFIX(_dispatch_stub_381), @function + HIDDEN(GL_PREFIX(_dispatch_stub_381)) +GL_PREFIX(_dispatch_stub_381): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 3048(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rbp + call _x86_64_get_dispatch@PLT + popq %rbp + popq %rsi + popq %rdi + movq 3048(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 3048(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rbp + call _glapi_get_dispatch + popq %rbp + popq %rsi + popq %rdi + movq 3048(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_381), .-GL_PREFIX(_dispatch_stub_381) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_382) + .type GL_PREFIX(_dispatch_stub_382), @function + HIDDEN(GL_PREFIX(_dispatch_stub_382)) +GL_PREFIX(_dispatch_stub_382): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 3056(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rbp + call _x86_64_get_dispatch@PLT + popq %rbp + popq %rsi + popq %rdi + movq 3056(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 3056(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rbp + call _glapi_get_dispatch + popq %rbp + popq %rsi + popq %rdi + movq 3056(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_382), .-GL_PREFIX(_dispatch_stub_382) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_383) + .type GL_PREFIX(_dispatch_stub_383), @function + HIDDEN(GL_PREFIX(_dispatch_stub_383)) +GL_PREFIX(_dispatch_stub_383): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 3064(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rbp + call _x86_64_get_dispatch@PLT + popq %rbp + popq %rsi + popq %rdi + movq 3064(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 3064(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rbp + call _glapi_get_dispatch + popq %rbp + popq %rsi + popq %rdi + movq 3064(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_383), .-GL_PREFIX(_dispatch_stub_383) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_384) + .type GL_PREFIX(_dispatch_stub_384), @function + HIDDEN(GL_PREFIX(_dispatch_stub_384)) +GL_PREFIX(_dispatch_stub_384): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 3072(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + subq $24, %rsp + movq %rdi, (%rsp) + movq %xmm0, 8(%rsp) + movq %xmm1, 16(%rsp) + call _x86_64_get_dispatch@PLT + movq 16(%rsp), %xmm1 + movq 8(%rsp), %xmm0 + movq (%rsp), %rdi + addq $24, %rsp + movq 3072(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 3072(%rax), %r11 + jmp *%r11 +1: + subq $24, %rsp + movq %rdi, (%rsp) + movq %xmm0, 8(%rsp) + movq %xmm1, 16(%rsp) + call _glapi_get_dispatch + movq 16(%rsp), %xmm1 + movq 8(%rsp), %xmm0 + movq (%rsp), %rdi + addq $24, %rsp + movq 3072(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_384), .-GL_PREFIX(_dispatch_stub_384) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_385) + .type GL_PREFIX(_dispatch_stub_385), @function + HIDDEN(GL_PREFIX(_dispatch_stub_385)) +GL_PREFIX(_dispatch_stub_385): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 3080(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rbp + call _x86_64_get_dispatch@PLT + popq %rbp + popq %rsi + popq %rdi + movq 3080(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 3080(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rbp + call _glapi_get_dispatch + popq %rbp + popq %rsi + popq %rdi + movq 3080(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_385), .-GL_PREFIX(_dispatch_stub_385) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_386) + .type GL_PREFIX(_dispatch_stub_386), @function + HIDDEN(GL_PREFIX(_dispatch_stub_386)) +GL_PREFIX(_dispatch_stub_386): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 3088(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + subq $24, %rsp + movq %rdi, (%rsp) + movq %xmm0, 8(%rsp) + movq %xmm1, 16(%rsp) + call _x86_64_get_dispatch@PLT + movq 16(%rsp), %xmm1 + movq 8(%rsp), %xmm0 + movq (%rsp), %rdi + addq $24, %rsp + movq 3088(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 3088(%rax), %r11 + jmp *%r11 +1: + subq $24, %rsp + movq %rdi, (%rsp) + movq %xmm0, 8(%rsp) + movq %xmm1, 16(%rsp) + call _glapi_get_dispatch + movq 16(%rsp), %xmm1 + movq 8(%rsp), %xmm0 + movq (%rsp), %rdi + addq $24, %rsp + movq 3088(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_386), .-GL_PREFIX(_dispatch_stub_386) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_387) + .type GL_PREFIX(_dispatch_stub_387), @function + HIDDEN(GL_PREFIX(_dispatch_stub_387)) +GL_PREFIX(_dispatch_stub_387): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 3096(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rbp + call _x86_64_get_dispatch@PLT + popq %rbp + popq %rsi + popq %rdi + movq 3096(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 3096(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rbp + call _glapi_get_dispatch + popq %rbp + popq %rsi + popq %rdi + movq 3096(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_387), .-GL_PREFIX(_dispatch_stub_387) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_388) + .type GL_PREFIX(_dispatch_stub_388), @function + HIDDEN(GL_PREFIX(_dispatch_stub_388)) +GL_PREFIX(_dispatch_stub_388): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 3104(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rdx + call _x86_64_get_dispatch@PLT + popq %rdx + popq %rsi + popq %rdi + movq 3104(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 3104(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rdx + call _glapi_get_dispatch + popq %rdx + popq %rsi + popq %rdi + movq 3104(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_388), .-GL_PREFIX(_dispatch_stub_388) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_389) + .type GL_PREFIX(_dispatch_stub_389), @function + HIDDEN(GL_PREFIX(_dispatch_stub_389)) +GL_PREFIX(_dispatch_stub_389): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 3112(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rbp + call _x86_64_get_dispatch@PLT + popq %rbp + popq %rsi + popq %rdi + movq 3112(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 3112(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rbp + call _glapi_get_dispatch + popq %rbp + popq %rsi + popq %rdi + movq 3112(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_389), .-GL_PREFIX(_dispatch_stub_389) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_390) + .type GL_PREFIX(_dispatch_stub_390), @function + HIDDEN(GL_PREFIX(_dispatch_stub_390)) +GL_PREFIX(_dispatch_stub_390): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 3120(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rdx + call _x86_64_get_dispatch@PLT + popq %rdx + popq %rsi + popq %rdi + movq 3120(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 3120(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rdx + call _glapi_get_dispatch + popq %rdx + popq %rsi + popq %rdi + movq 3120(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_390), .-GL_PREFIX(_dispatch_stub_390) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_391) + .type GL_PREFIX(_dispatch_stub_391), @function + HIDDEN(GL_PREFIX(_dispatch_stub_391)) +GL_PREFIX(_dispatch_stub_391): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 3128(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rbp + call _x86_64_get_dispatch@PLT + popq %rbp + popq %rsi + popq %rdi + movq 3128(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 3128(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rbp + call _glapi_get_dispatch + popq %rbp + popq %rsi + popq %rdi + movq 3128(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_391), .-GL_PREFIX(_dispatch_stub_391) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_392) + .type GL_PREFIX(_dispatch_stub_392), @function + HIDDEN(GL_PREFIX(_dispatch_stub_392)) +GL_PREFIX(_dispatch_stub_392): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 3136(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + subq $40, %rsp + movq %rdi, (%rsp) + movq %xmm0, 8(%rsp) + movq %xmm1, 16(%rsp) + movq %xmm2, 24(%rsp) + call _x86_64_get_dispatch@PLT + movq 24(%rsp), %xmm2 + movq 16(%rsp), %xmm1 + movq 8(%rsp), %xmm0 + movq (%rsp), %rdi + addq $40, %rsp + movq 3136(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 3136(%rax), %r11 + jmp *%r11 +1: + subq $40, %rsp + movq %rdi, (%rsp) + movq %xmm0, 8(%rsp) + movq %xmm1, 16(%rsp) + movq %xmm2, 24(%rsp) + call _glapi_get_dispatch + movq 24(%rsp), %xmm2 + movq 16(%rsp), %xmm1 + movq 8(%rsp), %xmm0 + movq (%rsp), %rdi + addq $40, %rsp + movq 3136(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_392), .-GL_PREFIX(_dispatch_stub_392) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_393) + .type GL_PREFIX(_dispatch_stub_393), @function + HIDDEN(GL_PREFIX(_dispatch_stub_393)) +GL_PREFIX(_dispatch_stub_393): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 3144(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rbp + call _x86_64_get_dispatch@PLT + popq %rbp + popq %rsi + popq %rdi + movq 3144(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 3144(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rbp + call _glapi_get_dispatch + popq %rbp + popq %rsi + popq %rdi + movq 3144(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_393), .-GL_PREFIX(_dispatch_stub_393) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_394) + .type GL_PREFIX(_dispatch_stub_394), @function + HIDDEN(GL_PREFIX(_dispatch_stub_394)) +GL_PREFIX(_dispatch_stub_394): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 3152(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + subq $40, %rsp + movq %rdi, (%rsp) + movq %xmm0, 8(%rsp) + movq %xmm1, 16(%rsp) + movq %xmm2, 24(%rsp) + call _x86_64_get_dispatch@PLT + movq 24(%rsp), %xmm2 + movq 16(%rsp), %xmm1 + movq 8(%rsp), %xmm0 + movq (%rsp), %rdi + addq $40, %rsp + movq 3152(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 3152(%rax), %r11 + jmp *%r11 +1: + subq $40, %rsp + movq %rdi, (%rsp) + movq %xmm0, 8(%rsp) + movq %xmm1, 16(%rsp) + movq %xmm2, 24(%rsp) + call _glapi_get_dispatch + movq 24(%rsp), %xmm2 + movq 16(%rsp), %xmm1 + movq 8(%rsp), %xmm0 + movq (%rsp), %rdi + addq $40, %rsp + movq 3152(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_394), .-GL_PREFIX(_dispatch_stub_394) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_395) + .type GL_PREFIX(_dispatch_stub_395), @function + HIDDEN(GL_PREFIX(_dispatch_stub_395)) +GL_PREFIX(_dispatch_stub_395): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 3160(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rbp + call _x86_64_get_dispatch@PLT + popq %rbp + popq %rsi + popq %rdi + movq 3160(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 3160(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rbp + call _glapi_get_dispatch + popq %rbp + popq %rsi + popq %rdi + movq 3160(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_395), .-GL_PREFIX(_dispatch_stub_395) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_396) + .type GL_PREFIX(_dispatch_stub_396), @function + HIDDEN(GL_PREFIX(_dispatch_stub_396)) +GL_PREFIX(_dispatch_stub_396): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 3168(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rdx + pushq %rcx + pushq %rbp + call _x86_64_get_dispatch@PLT + popq %rbp + popq %rcx + popq %rdx + popq %rsi + popq %rdi + movq 3168(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 3168(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rdx + pushq %rcx + pushq %rbp + call _glapi_get_dispatch + popq %rbp + popq %rcx + popq %rdx + popq %rsi + popq %rdi + movq 3168(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_396), .-GL_PREFIX(_dispatch_stub_396) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_397) + .type GL_PREFIX(_dispatch_stub_397), @function + HIDDEN(GL_PREFIX(_dispatch_stub_397)) +GL_PREFIX(_dispatch_stub_397): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 3176(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rbp + call _x86_64_get_dispatch@PLT + popq %rbp + popq %rsi + popq %rdi + movq 3176(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 3176(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rbp + call _glapi_get_dispatch + popq %rbp + popq %rsi + popq %rdi + movq 3176(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_397), .-GL_PREFIX(_dispatch_stub_397) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_398) + .type GL_PREFIX(_dispatch_stub_398), @function + HIDDEN(GL_PREFIX(_dispatch_stub_398)) +GL_PREFIX(_dispatch_stub_398): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 3184(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rdx + pushq %rcx + pushq %rbp + call _x86_64_get_dispatch@PLT + popq %rbp + popq %rcx + popq %rdx + popq %rsi + popq %rdi + movq 3184(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 3184(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rdx + pushq %rcx + pushq %rbp + call _glapi_get_dispatch + popq %rbp + popq %rcx + popq %rdx + popq %rsi + popq %rdi + movq 3184(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_398), .-GL_PREFIX(_dispatch_stub_398) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_399) + .type GL_PREFIX(_dispatch_stub_399), @function + HIDDEN(GL_PREFIX(_dispatch_stub_399)) +GL_PREFIX(_dispatch_stub_399): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 3192(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rbp + call _x86_64_get_dispatch@PLT + popq %rbp + popq %rsi + popq %rdi + movq 3192(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 3192(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rbp + call _glapi_get_dispatch + popq %rbp + popq %rsi + popq %rdi + movq 3192(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_399), .-GL_PREFIX(_dispatch_stub_399) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_400) + .type GL_PREFIX(_dispatch_stub_400), @function + HIDDEN(GL_PREFIX(_dispatch_stub_400)) +GL_PREFIX(_dispatch_stub_400): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 3200(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + subq $40, %rsp + movq %rdi, (%rsp) + movq %xmm0, 8(%rsp) + movq %xmm1, 16(%rsp) + movq %xmm2, 24(%rsp) + movq %xmm3, 32(%rsp) + call _x86_64_get_dispatch@PLT + movq 32(%rsp), %xmm3 + movq 24(%rsp), %xmm2 + movq 16(%rsp), %xmm1 + movq 8(%rsp), %xmm0 + movq (%rsp), %rdi + addq $40, %rsp + movq 3200(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 3200(%rax), %r11 + jmp *%r11 +1: + subq $40, %rsp + movq %rdi, (%rsp) + movq %xmm0, 8(%rsp) + movq %xmm1, 16(%rsp) + movq %xmm2, 24(%rsp) + movq %xmm3, 32(%rsp) + call _glapi_get_dispatch + movq 32(%rsp), %xmm3 + movq 24(%rsp), %xmm2 + movq 16(%rsp), %xmm1 + movq 8(%rsp), %xmm0 + movq (%rsp), %rdi + addq $40, %rsp + movq 3200(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_400), .-GL_PREFIX(_dispatch_stub_400) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_401) + .type GL_PREFIX(_dispatch_stub_401), @function + HIDDEN(GL_PREFIX(_dispatch_stub_401)) +GL_PREFIX(_dispatch_stub_401): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 3208(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rbp + call _x86_64_get_dispatch@PLT + popq %rbp + popq %rsi + popq %rdi + movq 3208(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 3208(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rbp + call _glapi_get_dispatch + popq %rbp + popq %rsi + popq %rdi + movq 3208(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_401), .-GL_PREFIX(_dispatch_stub_401) + + .p2align 4,,15 + .globl GL_PREFIX(MultiTexCoord4f) + .type GL_PREFIX(MultiTexCoord4f), @function +GL_PREFIX(MultiTexCoord4f): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 3216(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + subq $40, %rsp + movq %rdi, (%rsp) + movq %xmm0, 8(%rsp) + movq %xmm1, 16(%rsp) + movq %xmm2, 24(%rsp) + movq %xmm3, 32(%rsp) + call _x86_64_get_dispatch@PLT + movq 32(%rsp), %xmm3 + movq 24(%rsp), %xmm2 + movq 16(%rsp), %xmm1 + movq 8(%rsp), %xmm0 + movq (%rsp), %rdi + addq $40, %rsp + movq 3216(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 3216(%rax), %r11 + jmp *%r11 +1: + subq $40, %rsp + movq %rdi, (%rsp) + movq %xmm0, 8(%rsp) + movq %xmm1, 16(%rsp) + movq %xmm2, 24(%rsp) + movq %xmm3, 32(%rsp) + call _glapi_get_dispatch + movq 32(%rsp), %xmm3 + movq 24(%rsp), %xmm2 + movq 16(%rsp), %xmm1 + movq 8(%rsp), %xmm0 + movq (%rsp), %rdi + addq $40, %rsp + movq 3216(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(MultiTexCoord4f), .-GL_PREFIX(MultiTexCoord4f) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_403) + .type GL_PREFIX(_dispatch_stub_403), @function + HIDDEN(GL_PREFIX(_dispatch_stub_403)) +GL_PREFIX(_dispatch_stub_403): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 3224(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rbp + call _x86_64_get_dispatch@PLT + popq %rbp + popq %rsi + popq %rdi + movq 3224(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 3224(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rbp + call _glapi_get_dispatch + popq %rbp + popq %rsi + popq %rdi + movq 3224(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_403), .-GL_PREFIX(_dispatch_stub_403) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_404) + .type GL_PREFIX(_dispatch_stub_404), @function + HIDDEN(GL_PREFIX(_dispatch_stub_404)) +GL_PREFIX(_dispatch_stub_404): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 3232(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rdx + pushq %rcx + pushq %r8 + call _x86_64_get_dispatch@PLT + popq %r8 + popq %rcx + popq %rdx + popq %rsi + popq %rdi + movq 3232(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 3232(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rdx + pushq %rcx + pushq %r8 + call _glapi_get_dispatch + popq %r8 + popq %rcx + popq %rdx + popq %rsi + popq %rdi + movq 3232(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_404), .-GL_PREFIX(_dispatch_stub_404) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_405) + .type GL_PREFIX(_dispatch_stub_405), @function + HIDDEN(GL_PREFIX(_dispatch_stub_405)) +GL_PREFIX(_dispatch_stub_405): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 3240(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rbp + call _x86_64_get_dispatch@PLT + popq %rbp + popq %rsi + popq %rdi + movq 3240(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 3240(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rbp + call _glapi_get_dispatch + popq %rbp + popq %rsi + popq %rdi + movq 3240(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_405), .-GL_PREFIX(_dispatch_stub_405) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_406) + .type GL_PREFIX(_dispatch_stub_406), @function + HIDDEN(GL_PREFIX(_dispatch_stub_406)) +GL_PREFIX(_dispatch_stub_406): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 3248(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rdx + pushq %rcx + pushq %r8 + call _x86_64_get_dispatch@PLT + popq %r8 + popq %rcx + popq %rdx + popq %rsi + popq %rdi + movq 3248(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 3248(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rdx + pushq %rcx + pushq %r8 + call _glapi_get_dispatch + popq %r8 + popq %rcx + popq %rdx + popq %rsi + popq %rdi + movq 3248(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_406), .-GL_PREFIX(_dispatch_stub_406) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_407) + .type GL_PREFIX(_dispatch_stub_407), @function + HIDDEN(GL_PREFIX(_dispatch_stub_407)) +GL_PREFIX(_dispatch_stub_407): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 3256(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rbp + call _x86_64_get_dispatch@PLT + popq %rbp + popq %rsi + popq %rdi + movq 3256(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 3256(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rbp + call _glapi_get_dispatch + popq %rbp + popq %rsi + popq %rdi + movq 3256(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_407), .-GL_PREFIX(_dispatch_stub_407) + + .p2align 4,,15 + .globl GL_PREFIX(BlendEquationSeparateOES) + .type GL_PREFIX(BlendEquationSeparateOES), @function +GL_PREFIX(BlendEquationSeparateOES): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 3264(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rbp + call _x86_64_get_dispatch@PLT + popq %rbp + popq %rsi + popq %rdi + movq 3264(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 3264(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rbp + call _glapi_get_dispatch + popq %rbp + popq %rsi + popq %rdi + movq 3264(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(BlendEquationSeparateOES), .-GL_PREFIX(BlendEquationSeparateOES) + + .p2align 4,,15 + .globl GL_PREFIX(BlendFuncSeparateOES) + .type GL_PREFIX(BlendFuncSeparateOES), @function +GL_PREFIX(BlendFuncSeparateOES): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 3272(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rdx + pushq %rcx + pushq %rbp + call _x86_64_get_dispatch@PLT + popq %rbp + popq %rcx + popq %rdx + popq %rsi + popq %rdi + movq 3272(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 3272(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rdx + pushq %rcx + pushq %rbp + call _glapi_get_dispatch + popq %rbp + popq %rcx + popq %rdx + popq %rsi + popq %rdi + movq 3272(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(BlendFuncSeparateOES), .-GL_PREFIX(BlendFuncSeparateOES) + + .p2align 4,,15 + .globl GL_PREFIX(DrawTexfOES) + .type GL_PREFIX(DrawTexfOES), @function +GL_PREFIX(DrawTexfOES): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 3280(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + subq $40, %rsp + movq %xmm0, (%rsp) + movq %xmm1, 8(%rsp) + movq %xmm2, 16(%rsp) + movq %xmm3, 24(%rsp) + movq %xmm4, 32(%rsp) + call _x86_64_get_dispatch@PLT + movq 32(%rsp), %xmm4 + movq 24(%rsp), %xmm3 + movq 16(%rsp), %xmm2 + movq 8(%rsp), %xmm1 + movq (%rsp), %xmm0 + addq $40, %rsp + movq 3280(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 3280(%rax), %r11 + jmp *%r11 +1: + subq $40, %rsp + movq %xmm0, (%rsp) + movq %xmm1, 8(%rsp) + movq %xmm2, 16(%rsp) + movq %xmm3, 24(%rsp) + movq %xmm4, 32(%rsp) + call _glapi_get_dispatch + movq 32(%rsp), %xmm4 + movq 24(%rsp), %xmm3 + movq 16(%rsp), %xmm2 + movq 8(%rsp), %xmm1 + movq (%rsp), %xmm0 + addq $40, %rsp + movq 3280(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(DrawTexfOES), .-GL_PREFIX(DrawTexfOES) + + .p2align 4,,15 + .globl GL_PREFIX(DrawTexfvOES) + .type GL_PREFIX(DrawTexfvOES), @function +GL_PREFIX(DrawTexfvOES): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 3288(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + call _x86_64_get_dispatch@PLT + popq %rdi + movq 3288(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 3288(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + call _glapi_get_dispatch + popq %rdi + movq 3288(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(DrawTexfvOES), .-GL_PREFIX(DrawTexfvOES) + + .p2align 4,,15 + .globl GL_PREFIX(DrawTexiOES) + .type GL_PREFIX(DrawTexiOES), @function +GL_PREFIX(DrawTexiOES): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 3296(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rdx + pushq %rcx + pushq %r8 + call _x86_64_get_dispatch@PLT + popq %r8 + popq %rcx + popq %rdx + popq %rsi + popq %rdi + movq 3296(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 3296(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rdx + pushq %rcx + pushq %r8 + call _glapi_get_dispatch + popq %r8 + popq %rcx + popq %rdx + popq %rsi + popq %rdi + movq 3296(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(DrawTexiOES), .-GL_PREFIX(DrawTexiOES) + + .p2align 4,,15 + .globl GL_PREFIX(DrawTexivOES) + .type GL_PREFIX(DrawTexivOES), @function +GL_PREFIX(DrawTexivOES): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 3304(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + call _x86_64_get_dispatch@PLT + popq %rdi + movq 3304(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 3304(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + call _glapi_get_dispatch + popq %rdi + movq 3304(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(DrawTexivOES), .-GL_PREFIX(DrawTexivOES) + + .p2align 4,,15 + .globl GL_PREFIX(DrawTexsOES) + .type GL_PREFIX(DrawTexsOES), @function +GL_PREFIX(DrawTexsOES): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 3312(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rdx + pushq %rcx + pushq %r8 + call _x86_64_get_dispatch@PLT + popq %r8 + popq %rcx + popq %rdx + popq %rsi + popq %rdi + movq 3312(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 3312(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rdx + pushq %rcx + pushq %r8 + call _glapi_get_dispatch + popq %r8 + popq %rcx + popq %rdx + popq %rsi + popq %rdi + movq 3312(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(DrawTexsOES), .-GL_PREFIX(DrawTexsOES) + + .p2align 4,,15 + .globl GL_PREFIX(DrawTexsvOES) + .type GL_PREFIX(DrawTexsvOES), @function +GL_PREFIX(DrawTexsvOES): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 3320(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + call _x86_64_get_dispatch@PLT + popq %rdi + movq 3320(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 3320(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + call _glapi_get_dispatch + popq %rdi + movq 3320(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(DrawTexsvOES), .-GL_PREFIX(DrawTexsvOES) + + .p2align 4,,15 + .globl GL_PREFIX(DrawTexxOES) + .type GL_PREFIX(DrawTexxOES), @function +GL_PREFIX(DrawTexxOES): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 3328(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rdx + pushq %rcx + pushq %r8 + call _x86_64_get_dispatch@PLT + popq %r8 + popq %rcx + popq %rdx + popq %rsi + popq %rdi + movq 3328(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 3328(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rdx + pushq %rcx + pushq %r8 + call _glapi_get_dispatch + popq %r8 + popq %rcx + popq %rdx + popq %rsi + popq %rdi + movq 3328(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(DrawTexxOES), .-GL_PREFIX(DrawTexxOES) + + .p2align 4,,15 + .globl GL_PREFIX(DrawTexxvOES) + .type GL_PREFIX(DrawTexxvOES), @function +GL_PREFIX(DrawTexxvOES): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 3336(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + call _x86_64_get_dispatch@PLT + popq %rdi + movq 3336(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 3336(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + call _glapi_get_dispatch + popq %rdi + movq 3336(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(DrawTexxvOES), .-GL_PREFIX(DrawTexxvOES) + + .p2align 4,,15 + .globl GL_PREFIX(BindFramebufferOES) + .type GL_PREFIX(BindFramebufferOES), @function +GL_PREFIX(BindFramebufferOES): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 3344(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rbp + call _x86_64_get_dispatch@PLT + popq %rbp + popq %rsi + popq %rdi + movq 3344(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 3344(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rbp + call _glapi_get_dispatch + popq %rbp + popq %rsi + popq %rdi + movq 3344(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(BindFramebufferOES), .-GL_PREFIX(BindFramebufferOES) + + .p2align 4,,15 + .globl GL_PREFIX(BindRenderbufferOES) + .type GL_PREFIX(BindRenderbufferOES), @function +GL_PREFIX(BindRenderbufferOES): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 3352(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rbp + call _x86_64_get_dispatch@PLT + popq %rbp + popq %rsi + popq %rdi + movq 3352(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 3352(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rbp + call _glapi_get_dispatch + popq %rbp + popq %rsi + popq %rdi + movq 3352(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(BindRenderbufferOES), .-GL_PREFIX(BindRenderbufferOES) + + .p2align 4,,15 + .globl GL_PREFIX(CheckFramebufferStatusOES) + .type GL_PREFIX(CheckFramebufferStatusOES), @function +GL_PREFIX(CheckFramebufferStatusOES): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 3360(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + call _x86_64_get_dispatch@PLT + popq %rdi + movq 3360(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 3360(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + call _glapi_get_dispatch + popq %rdi + movq 3360(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(CheckFramebufferStatusOES), .-GL_PREFIX(CheckFramebufferStatusOES) + + .p2align 4,,15 + .globl GL_PREFIX(DeleteFramebuffersOES) + .type GL_PREFIX(DeleteFramebuffersOES), @function +GL_PREFIX(DeleteFramebuffersOES): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 3368(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rbp + call _x86_64_get_dispatch@PLT + popq %rbp + popq %rsi + popq %rdi + movq 3368(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 3368(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rbp + call _glapi_get_dispatch + popq %rbp + popq %rsi + popq %rdi + movq 3368(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(DeleteFramebuffersOES), .-GL_PREFIX(DeleteFramebuffersOES) + + .p2align 4,,15 + .globl GL_PREFIX(DeleteRenderbuffersOES) + .type GL_PREFIX(DeleteRenderbuffersOES), @function +GL_PREFIX(DeleteRenderbuffersOES): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 3376(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rbp + call _x86_64_get_dispatch@PLT + popq %rbp + popq %rsi + popq %rdi + movq 3376(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 3376(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rbp + call _glapi_get_dispatch + popq %rbp + popq %rsi + popq %rdi + movq 3376(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(DeleteRenderbuffersOES), .-GL_PREFIX(DeleteRenderbuffersOES) + + .p2align 4,,15 + .globl GL_PREFIX(FramebufferRenderbufferOES) + .type GL_PREFIX(FramebufferRenderbufferOES), @function +GL_PREFIX(FramebufferRenderbufferOES): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 3384(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rdx + pushq %rcx + pushq %rbp + call _x86_64_get_dispatch@PLT + popq %rbp + popq %rcx + popq %rdx + popq %rsi + popq %rdi + movq 3384(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 3384(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rdx + pushq %rcx + pushq %rbp + call _glapi_get_dispatch + popq %rbp + popq %rcx + popq %rdx + popq %rsi + popq %rdi + movq 3384(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(FramebufferRenderbufferOES), .-GL_PREFIX(FramebufferRenderbufferOES) + + .p2align 4,,15 + .globl GL_PREFIX(FramebufferTexture2DOES) + .type GL_PREFIX(FramebufferTexture2DOES), @function +GL_PREFIX(FramebufferTexture2DOES): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 3392(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rdx + pushq %rcx + pushq %r8 + call _x86_64_get_dispatch@PLT + popq %r8 + popq %rcx + popq %rdx + popq %rsi + popq %rdi + movq 3392(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 3392(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rdx + pushq %rcx + pushq %r8 + call _glapi_get_dispatch + popq %r8 + popq %rcx + popq %rdx + popq %rsi + popq %rdi + movq 3392(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(FramebufferTexture2DOES), .-GL_PREFIX(FramebufferTexture2DOES) + + .p2align 4,,15 + .globl GL_PREFIX(GenFramebuffersOES) + .type GL_PREFIX(GenFramebuffersOES), @function +GL_PREFIX(GenFramebuffersOES): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 3400(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rbp + call _x86_64_get_dispatch@PLT + popq %rbp + popq %rsi + popq %rdi + movq 3400(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 3400(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rbp + call _glapi_get_dispatch + popq %rbp + popq %rsi + popq %rdi + movq 3400(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(GenFramebuffersOES), .-GL_PREFIX(GenFramebuffersOES) + + .p2align 4,,15 + .globl GL_PREFIX(GenRenderbuffersOES) + .type GL_PREFIX(GenRenderbuffersOES), @function +GL_PREFIX(GenRenderbuffersOES): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 3408(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rbp + call _x86_64_get_dispatch@PLT + popq %rbp + popq %rsi + popq %rdi + movq 3408(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 3408(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rbp + call _glapi_get_dispatch + popq %rbp + popq %rsi + popq %rdi + movq 3408(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(GenRenderbuffersOES), .-GL_PREFIX(GenRenderbuffersOES) + + .p2align 4,,15 + .globl GL_PREFIX(GenerateMipmapOES) + .type GL_PREFIX(GenerateMipmapOES), @function +GL_PREFIX(GenerateMipmapOES): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 3416(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + call _x86_64_get_dispatch@PLT + popq %rdi + movq 3416(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 3416(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + call _glapi_get_dispatch + popq %rdi + movq 3416(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(GenerateMipmapOES), .-GL_PREFIX(GenerateMipmapOES) + + .p2align 4,,15 + .globl GL_PREFIX(GetFramebufferAttachmentParameterivOES) + .type GL_PREFIX(GetFramebufferAttachmentParameterivOES), @function +GL_PREFIX(GetFramebufferAttachmentParameterivOES): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 3424(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rdx + pushq %rcx + pushq %rbp + call _x86_64_get_dispatch@PLT + popq %rbp + popq %rcx + popq %rdx + popq %rsi + popq %rdi + movq 3424(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 3424(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rdx + pushq %rcx + pushq %rbp + call _glapi_get_dispatch + popq %rbp + popq %rcx + popq %rdx + popq %rsi + popq %rdi + movq 3424(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(GetFramebufferAttachmentParameterivOES), .-GL_PREFIX(GetFramebufferAttachmentParameterivOES) + + .p2align 4,,15 + .globl GL_PREFIX(GetRenderbufferParameterivOES) + .type GL_PREFIX(GetRenderbufferParameterivOES), @function +GL_PREFIX(GetRenderbufferParameterivOES): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 3432(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rdx + call _x86_64_get_dispatch@PLT + popq %rdx + popq %rsi + popq %rdi + movq 3432(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 3432(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rdx + call _glapi_get_dispatch + popq %rdx + popq %rsi + popq %rdi + movq 3432(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(GetRenderbufferParameterivOES), .-GL_PREFIX(GetRenderbufferParameterivOES) + + .p2align 4,,15 + .globl GL_PREFIX(IsFramebufferOES) + .type GL_PREFIX(IsFramebufferOES), @function +GL_PREFIX(IsFramebufferOES): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 3440(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + call _x86_64_get_dispatch@PLT + popq %rdi + movq 3440(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 3440(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + call _glapi_get_dispatch + popq %rdi + movq 3440(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(IsFramebufferOES), .-GL_PREFIX(IsFramebufferOES) + + .p2align 4,,15 + .globl GL_PREFIX(IsRenderbufferOES) + .type GL_PREFIX(IsRenderbufferOES), @function +GL_PREFIX(IsRenderbufferOES): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 3448(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + call _x86_64_get_dispatch@PLT + popq %rdi + movq 3448(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 3448(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + call _glapi_get_dispatch + popq %rdi + movq 3448(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(IsRenderbufferOES), .-GL_PREFIX(IsRenderbufferOES) + + .p2align 4,,15 + .globl GL_PREFIX(RenderbufferStorageOES) + .type GL_PREFIX(RenderbufferStorageOES), @function +GL_PREFIX(RenderbufferStorageOES): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 3456(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rdx + pushq %rcx + pushq %rbp + call _x86_64_get_dispatch@PLT + popq %rbp + popq %rcx + popq %rdx + popq %rsi + popq %rdi + movq 3456(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 3456(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rdx + pushq %rcx + pushq %rbp + call _glapi_get_dispatch + popq %rbp + popq %rcx + popq %rdx + popq %rsi + popq %rdi + movq 3456(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(RenderbufferStorageOES), .-GL_PREFIX(RenderbufferStorageOES) + + .p2align 4,,15 + .globl GL_PREFIX(PointSizePointerOES) + .type GL_PREFIX(PointSizePointerOES), @function +GL_PREFIX(PointSizePointerOES): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 3464(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rdx + call _x86_64_get_dispatch@PLT + popq %rdx + popq %rsi + popq %rdi + movq 3464(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 3464(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rdx + call _glapi_get_dispatch + popq %rdx + popq %rsi + popq %rdi + movq 3464(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(PointSizePointerOES), .-GL_PREFIX(PointSizePointerOES) + + .p2align 4,,15 + .globl GL_PREFIX(QueryMatrixxOES) + .type GL_PREFIX(QueryMatrixxOES), @function +GL_PREFIX(QueryMatrixxOES): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 3472(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rbp + call _x86_64_get_dispatch@PLT + popq %rbp + popq %rsi + popq %rdi + movq 3472(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 3472(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rbp + call _glapi_get_dispatch + popq %rbp + popq %rsi + popq %rdi + movq 3472(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(QueryMatrixxOES), .-GL_PREFIX(QueryMatrixxOES) + + .p2align 4,,15 + .globl GL_PREFIX(GetTexGenxvOES) + .type GL_PREFIX(GetTexGenxvOES), @function +GL_PREFIX(GetTexGenxvOES): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 3480(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rdx + call _x86_64_get_dispatch@PLT + popq %rdx + popq %rsi + popq %rdi + movq 3480(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 3480(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rdx + call _glapi_get_dispatch + popq %rdx + popq %rsi + popq %rdi + movq 3480(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(GetTexGenxvOES), .-GL_PREFIX(GetTexGenxvOES) + + .p2align 4,,15 + .globl GL_PREFIX(TexGenxOES) + .type GL_PREFIX(TexGenxOES), @function +GL_PREFIX(TexGenxOES): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 3488(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rdx + call _x86_64_get_dispatch@PLT + popq %rdx + popq %rsi + popq %rdi + movq 3488(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 3488(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rdx + call _glapi_get_dispatch + popq %rdx + popq %rsi + popq %rdi + movq 3488(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(TexGenxOES), .-GL_PREFIX(TexGenxOES) + + .p2align 4,,15 + .globl GL_PREFIX(TexGenxvOES) + .type GL_PREFIX(TexGenxvOES), @function +GL_PREFIX(TexGenxvOES): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 3496(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rdx + call _x86_64_get_dispatch@PLT + popq %rdx + popq %rsi + popq %rdi + movq 3496(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 3496(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rdx + call _glapi_get_dispatch + popq %rdx + popq %rsi + popq %rdi + movq 3496(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(TexGenxvOES), .-GL_PREFIX(TexGenxvOES) + + .p2align 4,,15 + .globl GL_PREFIX(GetBufferPointervOES) + .type GL_PREFIX(GetBufferPointervOES), @function +GL_PREFIX(GetBufferPointervOES): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 3504(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rdx + call _x86_64_get_dispatch@PLT + popq %rdx + popq %rsi + popq %rdi + movq 3504(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 3504(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rdx + call _glapi_get_dispatch + popq %rdx + popq %rsi + popq %rdi + movq 3504(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(GetBufferPointervOES), .-GL_PREFIX(GetBufferPointervOES) + + .p2align 4,,15 + .globl GL_PREFIX(MapBufferOES) + .type GL_PREFIX(MapBufferOES), @function +GL_PREFIX(MapBufferOES): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 3512(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rbp + call _x86_64_get_dispatch@PLT + popq %rbp + popq %rsi + popq %rdi + movq 3512(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 3512(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rbp + call _glapi_get_dispatch + popq %rbp + popq %rsi + popq %rdi + movq 3512(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(MapBufferOES), .-GL_PREFIX(MapBufferOES) + + .p2align 4,,15 + .globl GL_PREFIX(UnmapBufferOES) + .type GL_PREFIX(UnmapBufferOES), @function +GL_PREFIX(UnmapBufferOES): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 3520(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + call _x86_64_get_dispatch@PLT + popq %rdi + movq 3520(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 3520(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + call _glapi_get_dispatch + popq %rdi + movq 3520(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(UnmapBufferOES), .-GL_PREFIX(UnmapBufferOES) + + .p2align 4,,15 + .globl GL_PREFIX(MultiDrawArraysEXT) + .type GL_PREFIX(MultiDrawArraysEXT), @function +GL_PREFIX(MultiDrawArraysEXT): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 3528(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rdx + pushq %rcx + pushq %rbp + call _x86_64_get_dispatch@PLT + popq %rbp + popq %rcx + popq %rdx + popq %rsi + popq %rdi + movq 3528(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 3528(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rdx + pushq %rcx + pushq %rbp + call _glapi_get_dispatch + popq %rbp + popq %rcx + popq %rdx + popq %rsi + popq %rdi + movq 3528(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(MultiDrawArraysEXT), .-GL_PREFIX(MultiDrawArraysEXT) + + .p2align 4,,15 + .globl GL_PREFIX(MultiDrawElementsEXT) + .type GL_PREFIX(MultiDrawElementsEXT), @function +GL_PREFIX(MultiDrawElementsEXT): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 3536(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rdx + pushq %rcx + pushq %r8 + call _x86_64_get_dispatch@PLT + popq %r8 + popq %rcx + popq %rdx + popq %rsi + popq %rdi + movq 3536(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 3536(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rdx + pushq %rcx + pushq %r8 + call _glapi_get_dispatch + popq %r8 + popq %rcx + popq %rdx + popq %rsi + popq %rdi + movq 3536(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(MultiDrawElementsEXT), .-GL_PREFIX(MultiDrawElementsEXT) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_443) + .type GL_PREFIX(_dispatch_stub_443), @function + HIDDEN(GL_PREFIX(_dispatch_stub_443)) +GL_PREFIX(_dispatch_stub_443): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 3544(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + call _x86_64_get_dispatch@PLT + popq %rdi + movq 3544(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 3544(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + call _glapi_get_dispatch + popq %rdi + movq 3544(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_443), .-GL_PREFIX(_dispatch_stub_443) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_444) + .type GL_PREFIX(_dispatch_stub_444), @function + HIDDEN(GL_PREFIX(_dispatch_stub_444)) +GL_PREFIX(_dispatch_stub_444): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 3552(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rbp + call _x86_64_get_dispatch@PLT + popq %rbp + popq %rsi + popq %rdi + movq 3552(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 3552(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rbp + call _glapi_get_dispatch + popq %rbp + popq %rsi + popq %rdi + movq 3552(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_444), .-GL_PREFIX(_dispatch_stub_444) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_445) + .type GL_PREFIX(_dispatch_stub_445), @function + HIDDEN(GL_PREFIX(_dispatch_stub_445)) +GL_PREFIX(_dispatch_stub_445): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 3560(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rbp + call _x86_64_get_dispatch@PLT + popq %rbp + popq %rsi + popq %rdi + movq 3560(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 3560(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rbp + call _glapi_get_dispatch + popq %rbp + popq %rsi + popq %rdi + movq 3560(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_445), .-GL_PREFIX(_dispatch_stub_445) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_446) + .type GL_PREFIX(_dispatch_stub_446), @function + HIDDEN(GL_PREFIX(_dispatch_stub_446)) +GL_PREFIX(_dispatch_stub_446): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 3568(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + call _x86_64_get_dispatch@PLT + popq %rdi + movq 3568(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 3568(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + call _glapi_get_dispatch + popq %rdi + movq 3568(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_446), .-GL_PREFIX(_dispatch_stub_446) + + .p2align 4,,15 + .globl GL_PREFIX(EGLImageTargetRenderbufferStorageOES) + .type GL_PREFIX(EGLImageTargetRenderbufferStorageOES), @function +GL_PREFIX(EGLImageTargetRenderbufferStorageOES): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 3576(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rbp + call _x86_64_get_dispatch@PLT + popq %rbp + popq %rsi + popq %rdi + movq 3576(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 3576(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rbp + call _glapi_get_dispatch + popq %rbp + popq %rsi + popq %rdi + movq 3576(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(EGLImageTargetRenderbufferStorageOES), .-GL_PREFIX(EGLImageTargetRenderbufferStorageOES) + + .p2align 4,,15 + .globl GL_PREFIX(EGLImageTargetTexture2DOES) + .type GL_PREFIX(EGLImageTargetTexture2DOES), @function +GL_PREFIX(EGLImageTargetTexture2DOES): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 3584(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rbp + call _x86_64_get_dispatch@PLT + popq %rbp + popq %rsi + popq %rdi + movq 3584(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 3584(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rbp + call _glapi_get_dispatch + popq %rbp + popq %rsi + popq %rdi + movq 3584(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(EGLImageTargetTexture2DOES), .-GL_PREFIX(EGLImageTargetTexture2DOES) + + .p2align 4,,15 + .globl GL_PREFIX(CompressedTexImage2D) + .type GL_PREFIX(CompressedTexImage2D), @function +GL_PREFIX(CompressedTexImage2D): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 3592(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rdx + pushq %rcx + pushq %r8 + pushq %r9 + pushq %rbp + call _x86_64_get_dispatch@PLT + popq %rbp + popq %r9 + popq %r8 + popq %rcx + popq %rdx + popq %rsi + popq %rdi + movq 3592(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 3592(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rdx + pushq %rcx + pushq %r8 + pushq %r9 + pushq %rbp + call _glapi_get_dispatch + popq %rbp + popq %r9 + popq %r8 + popq %rcx + popq %rdx + popq %rsi + popq %rdi + movq 3592(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(CompressedTexImage2D), .-GL_PREFIX(CompressedTexImage2D) + + .p2align 4,,15 + .globl GL_PREFIX(CompressedTexSubImage2D) + .type GL_PREFIX(CompressedTexSubImage2D), @function +GL_PREFIX(CompressedTexSubImage2D): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 3600(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rdx + pushq %rcx + pushq %r8 + pushq %r9 + pushq %rbp + call _x86_64_get_dispatch@PLT + popq %rbp + popq %r9 + popq %r8 + popq %rcx + popq %rdx + popq %rsi + popq %rdi + movq 3600(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 3600(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rdx + pushq %rcx + pushq %r8 + pushq %r9 + pushq %rbp + call _glapi_get_dispatch + popq %rbp + popq %r9 + popq %r8 + popq %rcx + popq %rdx + popq %rsi + popq %rdi + movq 3600(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(CompressedTexSubImage2D), .-GL_PREFIX(CompressedTexSubImage2D) + + .p2align 4,,15 + .globl GL_PREFIX(SampleCoverage) + .type GL_PREFIX(SampleCoverage), @function +GL_PREFIX(SampleCoverage): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 3608(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rbp + call _x86_64_get_dispatch@PLT + popq %rbp + popq %rsi + popq %rdi + movq 3608(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 3608(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rbp + call _glapi_get_dispatch + popq %rbp + popq %rsi + popq %rdi + movq 3608(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(SampleCoverage), .-GL_PREFIX(SampleCoverage) + + .p2align 4,,15 + .globl GL_PREFIX(BindBuffer) + .type GL_PREFIX(BindBuffer), @function +GL_PREFIX(BindBuffer): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 3616(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rbp + call _x86_64_get_dispatch@PLT + popq %rbp + popq %rsi + popq %rdi + movq 3616(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 3616(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rbp + call _glapi_get_dispatch + popq %rbp + popq %rsi + popq %rdi + movq 3616(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(BindBuffer), .-GL_PREFIX(BindBuffer) + + .p2align 4,,15 + .globl GL_PREFIX(BufferData) + .type GL_PREFIX(BufferData), @function +GL_PREFIX(BufferData): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 3624(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rdx + pushq %rcx + pushq %rbp + call _x86_64_get_dispatch@PLT + popq %rbp + popq %rcx + popq %rdx + popq %rsi + popq %rdi + movq 3624(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 3624(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rdx + pushq %rcx + pushq %rbp + call _glapi_get_dispatch + popq %rbp + popq %rcx + popq %rdx + popq %rsi + popq %rdi + movq 3624(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(BufferData), .-GL_PREFIX(BufferData) + + .p2align 4,,15 + .globl GL_PREFIX(BufferSubData) + .type GL_PREFIX(BufferSubData), @function +GL_PREFIX(BufferSubData): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 3632(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rdx + pushq %rcx + pushq %rbp + call _x86_64_get_dispatch@PLT + popq %rbp + popq %rcx + popq %rdx + popq %rsi + popq %rdi + movq 3632(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 3632(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rdx + pushq %rcx + pushq %rbp + call _glapi_get_dispatch + popq %rbp + popq %rcx + popq %rdx + popq %rsi + popq %rdi + movq 3632(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(BufferSubData), .-GL_PREFIX(BufferSubData) + + .p2align 4,,15 + .globl GL_PREFIX(DeleteBuffers) + .type GL_PREFIX(DeleteBuffers), @function +GL_PREFIX(DeleteBuffers): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 3640(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rbp + call _x86_64_get_dispatch@PLT + popq %rbp + popq %rsi + popq %rdi + movq 3640(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 3640(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rbp + call _glapi_get_dispatch + popq %rbp + popq %rsi + popq %rdi + movq 3640(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(DeleteBuffers), .-GL_PREFIX(DeleteBuffers) + + .p2align 4,,15 + .globl GL_PREFIX(GenBuffers) + .type GL_PREFIX(GenBuffers), @function +GL_PREFIX(GenBuffers): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 3648(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rbp + call _x86_64_get_dispatch@PLT + popq %rbp + popq %rsi + popq %rdi + movq 3648(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 3648(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rbp + call _glapi_get_dispatch + popq %rbp + popq %rsi + popq %rdi + movq 3648(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(GenBuffers), .-GL_PREFIX(GenBuffers) + + .p2align 4,,15 + .globl GL_PREFIX(GetBufferParameteriv) + .type GL_PREFIX(GetBufferParameteriv), @function +GL_PREFIX(GetBufferParameteriv): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 3656(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rdx + call _x86_64_get_dispatch@PLT + popq %rdx + popq %rsi + popq %rdi + movq 3656(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 3656(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rdx + call _glapi_get_dispatch + popq %rdx + popq %rsi + popq %rdi + movq 3656(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(GetBufferParameteriv), .-GL_PREFIX(GetBufferParameteriv) + + .p2align 4,,15 + .globl GL_PREFIX(IsBuffer) + .type GL_PREFIX(IsBuffer), @function +GL_PREFIX(IsBuffer): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 3664(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + call _x86_64_get_dispatch@PLT + popq %rdi + movq 3664(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 3664(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + call _glapi_get_dispatch + popq %rdi + movq 3664(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(IsBuffer), .-GL_PREFIX(IsBuffer) + + .p2align 4,,15 + .globl GL_PREFIX(PointParameterf) + .type GL_PREFIX(PointParameterf), @function +GL_PREFIX(PointParameterf): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 3672(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + subq $24, %rsp + movq %rdi, (%rsp) + movq %xmm0, 8(%rsp) + call _x86_64_get_dispatch@PLT + movq 8(%rsp), %xmm0 + movq (%rsp), %rdi + addq $24, %rsp + movq 3672(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 3672(%rax), %r11 + jmp *%r11 +1: + subq $24, %rsp + movq %rdi, (%rsp) + movq %xmm0, 8(%rsp) + call _glapi_get_dispatch + movq 8(%rsp), %xmm0 + movq (%rsp), %rdi + addq $24, %rsp + movq 3672(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(PointParameterf), .-GL_PREFIX(PointParameterf) + + .p2align 4,,15 + .globl GL_PREFIX(PointParameterfv) + .type GL_PREFIX(PointParameterfv), @function +GL_PREFIX(PointParameterfv): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 3680(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rbp + call _x86_64_get_dispatch@PLT + popq %rbp + popq %rsi + popq %rdi + movq 3680(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 3680(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rbp + call _glapi_get_dispatch + popq %rbp + popq %rsi + popq %rdi + movq 3680(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(PointParameterfv), .-GL_PREFIX(PointParameterfv) + + .p2align 4,,15 + .globl GL_PREFIX(AlphaFuncx) + .type GL_PREFIX(AlphaFuncx), @function +GL_PREFIX(AlphaFuncx): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 3688(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rbp + call _x86_64_get_dispatch@PLT + popq %rbp + popq %rsi + popq %rdi + movq 3688(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 3688(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rbp + call _glapi_get_dispatch + popq %rbp + popq %rsi + popq %rdi + movq 3688(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(AlphaFuncx), .-GL_PREFIX(AlphaFuncx) + + .p2align 4,,15 + .globl GL_PREFIX(ClearColorx) + .type GL_PREFIX(ClearColorx), @function +GL_PREFIX(ClearColorx): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 3696(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rdx + pushq %rcx + pushq %rbp + call _x86_64_get_dispatch@PLT + popq %rbp + popq %rcx + popq %rdx + popq %rsi + popq %rdi + movq 3696(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 3696(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rdx + pushq %rcx + pushq %rbp + call _glapi_get_dispatch + popq %rbp + popq %rcx + popq %rdx + popq %rsi + popq %rdi + movq 3696(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(ClearColorx), .-GL_PREFIX(ClearColorx) + + .p2align 4,,15 + .globl GL_PREFIX(ClearDepthf) + .type GL_PREFIX(ClearDepthf), @function +GL_PREFIX(ClearDepthf): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 3704(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + call _x86_64_get_dispatch@PLT + popq %rdi + movq 3704(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 3704(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + call _glapi_get_dispatch + popq %rdi + movq 3704(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(ClearDepthf), .-GL_PREFIX(ClearDepthf) + + .p2align 4,,15 + .globl GL_PREFIX(ClearDepthx) + .type GL_PREFIX(ClearDepthx), @function +GL_PREFIX(ClearDepthx): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 3712(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + call _x86_64_get_dispatch@PLT + popq %rdi + movq 3712(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 3712(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + call _glapi_get_dispatch + popq %rdi + movq 3712(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(ClearDepthx), .-GL_PREFIX(ClearDepthx) + + .p2align 4,,15 + .globl GL_PREFIX(Color4x) + .type GL_PREFIX(Color4x), @function +GL_PREFIX(Color4x): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 3720(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rdx + pushq %rcx + pushq %rbp + call _x86_64_get_dispatch@PLT + popq %rbp + popq %rcx + popq %rdx + popq %rsi + popq %rdi + movq 3720(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 3720(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rdx + pushq %rcx + pushq %rbp + call _glapi_get_dispatch + popq %rbp + popq %rcx + popq %rdx + popq %rsi + popq %rdi + movq 3720(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(Color4x), .-GL_PREFIX(Color4x) + + .p2align 4,,15 + .globl GL_PREFIX(DepthRangef) + .type GL_PREFIX(DepthRangef), @function +GL_PREFIX(DepthRangef): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 3728(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rbp + call _x86_64_get_dispatch@PLT + popq %rbp + popq %rsi + popq %rdi + movq 3728(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 3728(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rbp + call _glapi_get_dispatch + popq %rbp + popq %rsi + popq %rdi + movq 3728(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(DepthRangef), .-GL_PREFIX(DepthRangef) + + .p2align 4,,15 + .globl GL_PREFIX(DepthRangex) + .type GL_PREFIX(DepthRangex), @function +GL_PREFIX(DepthRangex): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 3736(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rbp + call _x86_64_get_dispatch@PLT + popq %rbp + popq %rsi + popq %rdi + movq 3736(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 3736(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rbp + call _glapi_get_dispatch + popq %rbp + popq %rsi + popq %rdi + movq 3736(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(DepthRangex), .-GL_PREFIX(DepthRangex) + + .p2align 4,,15 + .globl GL_PREFIX(Fogx) + .type GL_PREFIX(Fogx), @function +GL_PREFIX(Fogx): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 3744(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rbp + call _x86_64_get_dispatch@PLT + popq %rbp + popq %rsi + popq %rdi + movq 3744(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 3744(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rbp + call _glapi_get_dispatch + popq %rbp + popq %rsi + popq %rdi + movq 3744(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(Fogx), .-GL_PREFIX(Fogx) + + .p2align 4,,15 + .globl GL_PREFIX(Fogxv) + .type GL_PREFIX(Fogxv), @function +GL_PREFIX(Fogxv): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 3752(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rbp + call _x86_64_get_dispatch@PLT + popq %rbp + popq %rsi + popq %rdi + movq 3752(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 3752(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rbp + call _glapi_get_dispatch + popq %rbp + popq %rsi + popq %rdi + movq 3752(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(Fogxv), .-GL_PREFIX(Fogxv) + + .p2align 4,,15 + .globl GL_PREFIX(Frustumf) + .type GL_PREFIX(Frustumf), @function +GL_PREFIX(Frustumf): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 3760(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + subq $56, %rsp + movq %xmm0, (%rsp) + movq %xmm1, 8(%rsp) + movq %xmm2, 16(%rsp) + movq %xmm3, 24(%rsp) + movq %xmm4, 32(%rsp) + movq %xmm5, 40(%rsp) + call _x86_64_get_dispatch@PLT + movq 40(%rsp), %xmm5 + movq 32(%rsp), %xmm4 + movq 24(%rsp), %xmm3 + movq 16(%rsp), %xmm2 + movq 8(%rsp), %xmm1 + movq (%rsp), %xmm0 + addq $56, %rsp + movq 3760(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 3760(%rax), %r11 + jmp *%r11 +1: + subq $56, %rsp + movq %xmm0, (%rsp) + movq %xmm1, 8(%rsp) + movq %xmm2, 16(%rsp) + movq %xmm3, 24(%rsp) + movq %xmm4, 32(%rsp) + movq %xmm5, 40(%rsp) + call _glapi_get_dispatch + movq 40(%rsp), %xmm5 + movq 32(%rsp), %xmm4 + movq 24(%rsp), %xmm3 + movq 16(%rsp), %xmm2 + movq 8(%rsp), %xmm1 + movq (%rsp), %xmm0 + addq $56, %rsp + movq 3760(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(Frustumf), .-GL_PREFIX(Frustumf) + + .p2align 4,,15 + .globl GL_PREFIX(Frustumx) + .type GL_PREFIX(Frustumx), @function +GL_PREFIX(Frustumx): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 3768(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rdx + pushq %rcx + pushq %r8 + pushq %r9 + pushq %rbp + call _x86_64_get_dispatch@PLT + popq %rbp + popq %r9 + popq %r8 + popq %rcx + popq %rdx + popq %rsi + popq %rdi + movq 3768(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 3768(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rdx + pushq %rcx + pushq %r8 + pushq %r9 + pushq %rbp + call _glapi_get_dispatch + popq %rbp + popq %r9 + popq %r8 + popq %rcx + popq %rdx + popq %rsi + popq %rdi + movq 3768(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(Frustumx), .-GL_PREFIX(Frustumx) + + .p2align 4,,15 + .globl GL_PREFIX(LightModelx) + .type GL_PREFIX(LightModelx), @function +GL_PREFIX(LightModelx): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 3776(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rbp + call _x86_64_get_dispatch@PLT + popq %rbp + popq %rsi + popq %rdi + movq 3776(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 3776(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rbp + call _glapi_get_dispatch + popq %rbp + popq %rsi + popq %rdi + movq 3776(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(LightModelx), .-GL_PREFIX(LightModelx) + + .p2align 4,,15 + .globl GL_PREFIX(LightModelxv) + .type GL_PREFIX(LightModelxv), @function +GL_PREFIX(LightModelxv): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 3784(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rbp + call _x86_64_get_dispatch@PLT + popq %rbp + popq %rsi + popq %rdi + movq 3784(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 3784(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rbp + call _glapi_get_dispatch + popq %rbp + popq %rsi + popq %rdi + movq 3784(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(LightModelxv), .-GL_PREFIX(LightModelxv) + + .p2align 4,,15 + .globl GL_PREFIX(Lightx) + .type GL_PREFIX(Lightx), @function +GL_PREFIX(Lightx): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 3792(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rdx + call _x86_64_get_dispatch@PLT + popq %rdx + popq %rsi + popq %rdi + movq 3792(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 3792(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rdx + call _glapi_get_dispatch + popq %rdx + popq %rsi + popq %rdi + movq 3792(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(Lightx), .-GL_PREFIX(Lightx) + + .p2align 4,,15 + .globl GL_PREFIX(Lightxv) + .type GL_PREFIX(Lightxv), @function +GL_PREFIX(Lightxv): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 3800(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rdx + call _x86_64_get_dispatch@PLT + popq %rdx + popq %rsi + popq %rdi + movq 3800(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 3800(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rdx + call _glapi_get_dispatch + popq %rdx + popq %rsi + popq %rdi + movq 3800(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(Lightxv), .-GL_PREFIX(Lightxv) + + .p2align 4,,15 + .globl GL_PREFIX(LineWidthx) + .type GL_PREFIX(LineWidthx), @function +GL_PREFIX(LineWidthx): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 3808(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + call _x86_64_get_dispatch@PLT + popq %rdi + movq 3808(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 3808(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + call _glapi_get_dispatch + popq %rdi + movq 3808(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(LineWidthx), .-GL_PREFIX(LineWidthx) + + .p2align 4,,15 + .globl GL_PREFIX(LoadMatrixx) + .type GL_PREFIX(LoadMatrixx), @function +GL_PREFIX(LoadMatrixx): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 3816(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + call _x86_64_get_dispatch@PLT + popq %rdi + movq 3816(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 3816(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + call _glapi_get_dispatch + popq %rdi + movq 3816(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(LoadMatrixx), .-GL_PREFIX(LoadMatrixx) + + .p2align 4,,15 + .globl GL_PREFIX(Materialx) + .type GL_PREFIX(Materialx), @function +GL_PREFIX(Materialx): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 3824(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rdx + call _x86_64_get_dispatch@PLT + popq %rdx + popq %rsi + popq %rdi + movq 3824(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 3824(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rdx + call _glapi_get_dispatch + popq %rdx + popq %rsi + popq %rdi + movq 3824(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(Materialx), .-GL_PREFIX(Materialx) + + .p2align 4,,15 + .globl GL_PREFIX(Materialxv) + .type GL_PREFIX(Materialxv), @function +GL_PREFIX(Materialxv): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 3832(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rdx + call _x86_64_get_dispatch@PLT + popq %rdx + popq %rsi + popq %rdi + movq 3832(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 3832(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rdx + call _glapi_get_dispatch + popq %rdx + popq %rsi + popq %rdi + movq 3832(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(Materialxv), .-GL_PREFIX(Materialxv) + + .p2align 4,,15 + .globl GL_PREFIX(MultMatrixx) + .type GL_PREFIX(MultMatrixx), @function +GL_PREFIX(MultMatrixx): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 3840(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + call _x86_64_get_dispatch@PLT + popq %rdi + movq 3840(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 3840(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + call _glapi_get_dispatch + popq %rdi + movq 3840(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(MultMatrixx), .-GL_PREFIX(MultMatrixx) + + .p2align 4,,15 + .globl GL_PREFIX(MultiTexCoord4x) + .type GL_PREFIX(MultiTexCoord4x), @function +GL_PREFIX(MultiTexCoord4x): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 3848(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rdx + pushq %rcx + pushq %r8 + call _x86_64_get_dispatch@PLT + popq %r8 + popq %rcx + popq %rdx + popq %rsi + popq %rdi + movq 3848(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 3848(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rdx + pushq %rcx + pushq %r8 + call _glapi_get_dispatch + popq %r8 + popq %rcx + popq %rdx + popq %rsi + popq %rdi + movq 3848(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(MultiTexCoord4x), .-GL_PREFIX(MultiTexCoord4x) + + .p2align 4,,15 + .globl GL_PREFIX(Normal3x) + .type GL_PREFIX(Normal3x), @function +GL_PREFIX(Normal3x): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 3856(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rdx + call _x86_64_get_dispatch@PLT + popq %rdx + popq %rsi + popq %rdi + movq 3856(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 3856(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rdx + call _glapi_get_dispatch + popq %rdx + popq %rsi + popq %rdi + movq 3856(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(Normal3x), .-GL_PREFIX(Normal3x) + + .p2align 4,,15 + .globl GL_PREFIX(Orthof) + .type GL_PREFIX(Orthof), @function +GL_PREFIX(Orthof): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 3864(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + subq $56, %rsp + movq %xmm0, (%rsp) + movq %xmm1, 8(%rsp) + movq %xmm2, 16(%rsp) + movq %xmm3, 24(%rsp) + movq %xmm4, 32(%rsp) + movq %xmm5, 40(%rsp) + call _x86_64_get_dispatch@PLT + movq 40(%rsp), %xmm5 + movq 32(%rsp), %xmm4 + movq 24(%rsp), %xmm3 + movq 16(%rsp), %xmm2 + movq 8(%rsp), %xmm1 + movq (%rsp), %xmm0 + addq $56, %rsp + movq 3864(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 3864(%rax), %r11 + jmp *%r11 +1: + subq $56, %rsp + movq %xmm0, (%rsp) + movq %xmm1, 8(%rsp) + movq %xmm2, 16(%rsp) + movq %xmm3, 24(%rsp) + movq %xmm4, 32(%rsp) + movq %xmm5, 40(%rsp) + call _glapi_get_dispatch + movq 40(%rsp), %xmm5 + movq 32(%rsp), %xmm4 + movq 24(%rsp), %xmm3 + movq 16(%rsp), %xmm2 + movq 8(%rsp), %xmm1 + movq (%rsp), %xmm0 + addq $56, %rsp + movq 3864(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(Orthof), .-GL_PREFIX(Orthof) + + .p2align 4,,15 + .globl GL_PREFIX(Orthox) + .type GL_PREFIX(Orthox), @function +GL_PREFIX(Orthox): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 3872(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rdx + pushq %rcx + pushq %r8 + pushq %r9 + pushq %rbp + call _x86_64_get_dispatch@PLT + popq %rbp + popq %r9 + popq %r8 + popq %rcx + popq %rdx + popq %rsi + popq %rdi + movq 3872(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 3872(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rdx + pushq %rcx + pushq %r8 + pushq %r9 + pushq %rbp + call _glapi_get_dispatch + popq %rbp + popq %r9 + popq %r8 + popq %rcx + popq %rdx + popq %rsi + popq %rdi + movq 3872(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(Orthox), .-GL_PREFIX(Orthox) + + .p2align 4,,15 + .globl GL_PREFIX(PointSizex) + .type GL_PREFIX(PointSizex), @function +GL_PREFIX(PointSizex): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 3880(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + call _x86_64_get_dispatch@PLT + popq %rdi + movq 3880(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 3880(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + call _glapi_get_dispatch + popq %rdi + movq 3880(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(PointSizex), .-GL_PREFIX(PointSizex) + + .p2align 4,,15 + .globl GL_PREFIX(PolygonOffsetx) + .type GL_PREFIX(PolygonOffsetx), @function +GL_PREFIX(PolygonOffsetx): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 3888(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rbp + call _x86_64_get_dispatch@PLT + popq %rbp + popq %rsi + popq %rdi + movq 3888(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 3888(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rbp + call _glapi_get_dispatch + popq %rbp + popq %rsi + popq %rdi + movq 3888(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(PolygonOffsetx), .-GL_PREFIX(PolygonOffsetx) + + .p2align 4,,15 + .globl GL_PREFIX(Rotatex) + .type GL_PREFIX(Rotatex), @function +GL_PREFIX(Rotatex): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 3896(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rdx + pushq %rcx + pushq %rbp + call _x86_64_get_dispatch@PLT + popq %rbp + popq %rcx + popq %rdx + popq %rsi + popq %rdi + movq 3896(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 3896(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rdx + pushq %rcx + pushq %rbp + call _glapi_get_dispatch + popq %rbp + popq %rcx + popq %rdx + popq %rsi + popq %rdi + movq 3896(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(Rotatex), .-GL_PREFIX(Rotatex) + + .p2align 4,,15 + .globl GL_PREFIX(SampleCoveragex) + .type GL_PREFIX(SampleCoveragex), @function +GL_PREFIX(SampleCoveragex): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 3904(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rbp + call _x86_64_get_dispatch@PLT + popq %rbp + popq %rsi + popq %rdi + movq 3904(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 3904(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rbp + call _glapi_get_dispatch + popq %rbp + popq %rsi + popq %rdi + movq 3904(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(SampleCoveragex), .-GL_PREFIX(SampleCoveragex) + + .p2align 4,,15 + .globl GL_PREFIX(Scalex) + .type GL_PREFIX(Scalex), @function +GL_PREFIX(Scalex): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 3912(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rdx + call _x86_64_get_dispatch@PLT + popq %rdx + popq %rsi + popq %rdi + movq 3912(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 3912(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rdx + call _glapi_get_dispatch + popq %rdx + popq %rsi + popq %rdi + movq 3912(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(Scalex), .-GL_PREFIX(Scalex) + + .p2align 4,,15 + .globl GL_PREFIX(TexEnvx) + .type GL_PREFIX(TexEnvx), @function +GL_PREFIX(TexEnvx): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 3920(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rdx + call _x86_64_get_dispatch@PLT + popq %rdx + popq %rsi + popq %rdi + movq 3920(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 3920(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rdx + call _glapi_get_dispatch + popq %rdx + popq %rsi + popq %rdi + movq 3920(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(TexEnvx), .-GL_PREFIX(TexEnvx) + + .p2align 4,,15 + .globl GL_PREFIX(TexEnvxv) + .type GL_PREFIX(TexEnvxv), @function +GL_PREFIX(TexEnvxv): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 3928(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rdx + call _x86_64_get_dispatch@PLT + popq %rdx + popq %rsi + popq %rdi + movq 3928(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 3928(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rdx + call _glapi_get_dispatch + popq %rdx + popq %rsi + popq %rdi + movq 3928(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(TexEnvxv), .-GL_PREFIX(TexEnvxv) + + .p2align 4,,15 + .globl GL_PREFIX(TexParameterx) + .type GL_PREFIX(TexParameterx), @function +GL_PREFIX(TexParameterx): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 3936(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rdx + call _x86_64_get_dispatch@PLT + popq %rdx + popq %rsi + popq %rdi + movq 3936(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 3936(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rdx + call _glapi_get_dispatch + popq %rdx + popq %rsi + popq %rdi + movq 3936(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(TexParameterx), .-GL_PREFIX(TexParameterx) + + .p2align 4,,15 + .globl GL_PREFIX(Translatex) + .type GL_PREFIX(Translatex), @function +GL_PREFIX(Translatex): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 3944(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rdx + call _x86_64_get_dispatch@PLT + popq %rdx + popq %rsi + popq %rdi + movq 3944(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 3944(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rdx + call _glapi_get_dispatch + popq %rdx + popq %rsi + popq %rdi + movq 3944(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(Translatex), .-GL_PREFIX(Translatex) + + .p2align 4,,15 + .globl GL_PREFIX(ClipPlanef) + .type GL_PREFIX(ClipPlanef), @function +GL_PREFIX(ClipPlanef): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 3952(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rbp + call _x86_64_get_dispatch@PLT + popq %rbp + popq %rsi + popq %rdi + movq 3952(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 3952(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rbp + call _glapi_get_dispatch + popq %rbp + popq %rsi + popq %rdi + movq 3952(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(ClipPlanef), .-GL_PREFIX(ClipPlanef) + + .p2align 4,,15 + .globl GL_PREFIX(ClipPlanex) + .type GL_PREFIX(ClipPlanex), @function +GL_PREFIX(ClipPlanex): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 3960(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rbp + call _x86_64_get_dispatch@PLT + popq %rbp + popq %rsi + popq %rdi + movq 3960(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 3960(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rbp + call _glapi_get_dispatch + popq %rbp + popq %rsi + popq %rdi + movq 3960(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(ClipPlanex), .-GL_PREFIX(ClipPlanex) + + .p2align 4,,15 + .globl GL_PREFIX(GetClipPlanef) + .type GL_PREFIX(GetClipPlanef), @function +GL_PREFIX(GetClipPlanef): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 3968(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rbp + call _x86_64_get_dispatch@PLT + popq %rbp + popq %rsi + popq %rdi + movq 3968(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 3968(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rbp + call _glapi_get_dispatch + popq %rbp + popq %rsi + popq %rdi + movq 3968(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(GetClipPlanef), .-GL_PREFIX(GetClipPlanef) + + .p2align 4,,15 + .globl GL_PREFIX(GetClipPlanex) + .type GL_PREFIX(GetClipPlanex), @function +GL_PREFIX(GetClipPlanex): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 3976(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rbp + call _x86_64_get_dispatch@PLT + popq %rbp + popq %rsi + popq %rdi + movq 3976(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 3976(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rbp + call _glapi_get_dispatch + popq %rbp + popq %rsi + popq %rdi + movq 3976(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(GetClipPlanex), .-GL_PREFIX(GetClipPlanex) + + .p2align 4,,15 + .globl GL_PREFIX(GetFixedv) + .type GL_PREFIX(GetFixedv), @function +GL_PREFIX(GetFixedv): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 3984(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rbp + call _x86_64_get_dispatch@PLT + popq %rbp + popq %rsi + popq %rdi + movq 3984(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 3984(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rbp + call _glapi_get_dispatch + popq %rbp + popq %rsi + popq %rdi + movq 3984(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(GetFixedv), .-GL_PREFIX(GetFixedv) + + .p2align 4,,15 + .globl GL_PREFIX(GetLightxv) + .type GL_PREFIX(GetLightxv), @function +GL_PREFIX(GetLightxv): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 3992(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rdx + call _x86_64_get_dispatch@PLT + popq %rdx + popq %rsi + popq %rdi + movq 3992(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 3992(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rdx + call _glapi_get_dispatch + popq %rdx + popq %rsi + popq %rdi + movq 3992(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(GetLightxv), .-GL_PREFIX(GetLightxv) + + .p2align 4,,15 + .globl GL_PREFIX(GetMaterialxv) + .type GL_PREFIX(GetMaterialxv), @function +GL_PREFIX(GetMaterialxv): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 4000(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rdx + call _x86_64_get_dispatch@PLT + popq %rdx + popq %rsi + popq %rdi + movq 4000(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 4000(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rdx + call _glapi_get_dispatch + popq %rdx + popq %rsi + popq %rdi + movq 4000(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(GetMaterialxv), .-GL_PREFIX(GetMaterialxv) + + .p2align 4,,15 + .globl GL_PREFIX(GetTexEnvxv) + .type GL_PREFIX(GetTexEnvxv), @function +GL_PREFIX(GetTexEnvxv): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 4008(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rdx + call _x86_64_get_dispatch@PLT + popq %rdx + popq %rsi + popq %rdi + movq 4008(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 4008(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rdx + call _glapi_get_dispatch + popq %rdx + popq %rsi + popq %rdi + movq 4008(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(GetTexEnvxv), .-GL_PREFIX(GetTexEnvxv) + + .p2align 4,,15 + .globl GL_PREFIX(GetTexParameterxv) + .type GL_PREFIX(GetTexParameterxv), @function +GL_PREFIX(GetTexParameterxv): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 4016(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rdx + call _x86_64_get_dispatch@PLT + popq %rdx + popq %rsi + popq %rdi + movq 4016(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 4016(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rdx + call _glapi_get_dispatch + popq %rdx + popq %rsi + popq %rdi + movq 4016(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(GetTexParameterxv), .-GL_PREFIX(GetTexParameterxv) + + .p2align 4,,15 + .globl GL_PREFIX(PointParameterx) + .type GL_PREFIX(PointParameterx), @function +GL_PREFIX(PointParameterx): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 4024(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rbp + call _x86_64_get_dispatch@PLT + popq %rbp + popq %rsi + popq %rdi + movq 4024(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 4024(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rbp + call _glapi_get_dispatch + popq %rbp + popq %rsi + popq %rdi + movq 4024(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(PointParameterx), .-GL_PREFIX(PointParameterx) + + .p2align 4,,15 + .globl GL_PREFIX(PointParameterxv) + .type GL_PREFIX(PointParameterxv), @function +GL_PREFIX(PointParameterxv): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 4032(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rbp + call _x86_64_get_dispatch@PLT + popq %rbp + popq %rsi + popq %rdi + movq 4032(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 4032(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rbp + call _glapi_get_dispatch + popq %rbp + popq %rsi + popq %rdi + movq 4032(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(PointParameterxv), .-GL_PREFIX(PointParameterxv) + + .p2align 4,,15 + .globl GL_PREFIX(TexParameterxv) + .type GL_PREFIX(TexParameterxv), @function +GL_PREFIX(TexParameterxv): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 4040(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rdx + call _x86_64_get_dispatch@PLT + popq %rdx + popq %rsi + popq %rdi + movq 4040(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 4040(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rdx + call _glapi_get_dispatch + popq %rdx + popq %rsi + popq %rdi + movq 4040(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(TexParameterxv), .-GL_PREFIX(TexParameterxv) + + .globl GL_PREFIX(AlphaFuncxOES) ; .set GL_PREFIX(AlphaFuncxOES), GL_PREFIX(AlphaFuncx) + .globl GL_PREFIX(ClearColorxOES) ; .set GL_PREFIX(ClearColorxOES), GL_PREFIX(ClearColorx) + .globl GL_PREFIX(ClearDepthfOES) ; .set GL_PREFIX(ClearDepthfOES), GL_PREFIX(ClearDepthf) + .globl GL_PREFIX(ClearDepthxOES) ; .set GL_PREFIX(ClearDepthxOES), GL_PREFIX(ClearDepthx) + .globl GL_PREFIX(Color4xOES) ; .set GL_PREFIX(Color4xOES), GL_PREFIX(Color4x) + .globl GL_PREFIX(DepthRangefOES) ; .set GL_PREFIX(DepthRangefOES), GL_PREFIX(DepthRangef) + .globl GL_PREFIX(DepthRangexOES) ; .set GL_PREFIX(DepthRangexOES), GL_PREFIX(DepthRangex) + .globl GL_PREFIX(FogxOES) ; .set GL_PREFIX(FogxOES), GL_PREFIX(Fogx) + .globl GL_PREFIX(FogxvOES) ; .set GL_PREFIX(FogxvOES), GL_PREFIX(Fogxv) + .globl GL_PREFIX(FrustumfOES) ; .set GL_PREFIX(FrustumfOES), GL_PREFIX(Frustumf) + .globl GL_PREFIX(FrustumxOES) ; .set GL_PREFIX(FrustumxOES), GL_PREFIX(Frustumx) + .globl GL_PREFIX(LightModelxOES) ; .set GL_PREFIX(LightModelxOES), GL_PREFIX(LightModelx) + .globl GL_PREFIX(LightModelxvOES) ; .set GL_PREFIX(LightModelxvOES), GL_PREFIX(LightModelxv) + .globl GL_PREFIX(LightxOES) ; .set GL_PREFIX(LightxOES), GL_PREFIX(Lightx) + .globl GL_PREFIX(LightxvOES) ; .set GL_PREFIX(LightxvOES), GL_PREFIX(Lightxv) + .globl GL_PREFIX(LineWidthxOES) ; .set GL_PREFIX(LineWidthxOES), GL_PREFIX(LineWidthx) + .globl GL_PREFIX(LoadMatrixxOES) ; .set GL_PREFIX(LoadMatrixxOES), GL_PREFIX(LoadMatrixx) + .globl GL_PREFIX(MaterialxOES) ; .set GL_PREFIX(MaterialxOES), GL_PREFIX(Materialx) + .globl GL_PREFIX(MaterialxvOES) ; .set GL_PREFIX(MaterialxvOES), GL_PREFIX(Materialxv) + .globl GL_PREFIX(MultMatrixxOES) ; .set GL_PREFIX(MultMatrixxOES), GL_PREFIX(MultMatrixx) + .globl GL_PREFIX(MultiTexCoord4xOES) ; .set GL_PREFIX(MultiTexCoord4xOES), GL_PREFIX(MultiTexCoord4x) + .globl GL_PREFIX(Normal3xOES) ; .set GL_PREFIX(Normal3xOES), GL_PREFIX(Normal3x) + .globl GL_PREFIX(OrthofOES) ; .set GL_PREFIX(OrthofOES), GL_PREFIX(Orthof) + .globl GL_PREFIX(OrthoxOES) ; .set GL_PREFIX(OrthoxOES), GL_PREFIX(Orthox) + .globl GL_PREFIX(PointSizexOES) ; .set GL_PREFIX(PointSizexOES), GL_PREFIX(PointSizex) + .globl GL_PREFIX(PolygonOffsetxOES) ; .set GL_PREFIX(PolygonOffsetxOES), GL_PREFIX(PolygonOffsetx) + .globl GL_PREFIX(RotatexOES) ; .set GL_PREFIX(RotatexOES), GL_PREFIX(Rotatex) + .globl GL_PREFIX(SampleCoveragexOES) ; .set GL_PREFIX(SampleCoveragexOES), GL_PREFIX(SampleCoveragex) + .globl GL_PREFIX(ScalexOES) ; .set GL_PREFIX(ScalexOES), GL_PREFIX(Scalex) + .globl GL_PREFIX(TexEnvxOES) ; .set GL_PREFIX(TexEnvxOES), GL_PREFIX(TexEnvx) + .globl GL_PREFIX(TexEnvxvOES) ; .set GL_PREFIX(TexEnvxvOES), GL_PREFIX(TexEnvxv) + .globl GL_PREFIX(TexParameterxOES) ; .set GL_PREFIX(TexParameterxOES), GL_PREFIX(TexParameterx) + .globl GL_PREFIX(TranslatexOES) ; .set GL_PREFIX(TranslatexOES), GL_PREFIX(Translatex) + .globl GL_PREFIX(ClipPlanefOES) ; .set GL_PREFIX(ClipPlanefOES), GL_PREFIX(ClipPlanef) + .globl GL_PREFIX(ClipPlanexOES) ; .set GL_PREFIX(ClipPlanexOES), GL_PREFIX(ClipPlanex) + .globl GL_PREFIX(GetClipPlanefOES) ; .set GL_PREFIX(GetClipPlanefOES), GL_PREFIX(GetClipPlanef) + .globl GL_PREFIX(GetClipPlanexOES) ; .set GL_PREFIX(GetClipPlanexOES), GL_PREFIX(GetClipPlanex) + .globl GL_PREFIX(GetFixedvOES) ; .set GL_PREFIX(GetFixedvOES), GL_PREFIX(GetFixedv) + .globl GL_PREFIX(GetLightxvOES) ; .set GL_PREFIX(GetLightxvOES), GL_PREFIX(GetLightxv) + .globl GL_PREFIX(GetMaterialxvOES) ; .set GL_PREFIX(GetMaterialxvOES), GL_PREFIX(GetMaterialxv) + .globl GL_PREFIX(GetTexEnvxvOES) ; .set GL_PREFIX(GetTexEnvxvOES), GL_PREFIX(GetTexEnvxv) + .globl GL_PREFIX(GetTexParameterxvOES) ; .set GL_PREFIX(GetTexParameterxvOES), GL_PREFIX(GetTexParameterxv) + .globl GL_PREFIX(PointParameterxOES) ; .set GL_PREFIX(PointParameterxOES), GL_PREFIX(PointParameterx) + .globl GL_PREFIX(PointParameterxvOES) ; .set GL_PREFIX(PointParameterxvOES), GL_PREFIX(PointParameterxv) + .globl GL_PREFIX(TexParameterxvOES) ; .set GL_PREFIX(TexParameterxvOES), GL_PREFIX(TexParameterxv) + +#if defined(GLX_USE_TLS) && defined(__linux__) + .section ".note.ABI-tag", "a" + .p2align 2 + .long 1f - 0f /* name length */ + .long 3f - 2f /* data length */ + .long 1 /* note length */ +0: .asciz "GNU" /* vendor name */ +1: .p2align 2 +2: .long 0 /* note data: the ABI tag */ + .long 2,4,20 /* Minimum kernel version w/TLS */ +3: .p2align 2 /* pad out section */ +#endif /* GLX_USE_TLS */ + +#if defined (__ELF__) && defined (__linux__) + .section .note.GNU-stack,"",%progbits +#endif diff --git a/src/mapi/es1api/glapi/glapi_x86.S b/src/mapi/es1api/glapi/glapi_x86.S new file mode 100644 index 00000000000..f2dca68925a --- /dev/null +++ b/src/mapi/es1api/glapi/glapi_x86.S @@ -0,0 +1,1043 @@ +/* DO NOT EDIT - This file generated automatically by gl_x86_asm.py (from Mesa) script */ + +/* + * Copyright (C) 1999-2001 Brian Paul All Rights Reserved. + * (C) Copyright IBM Corporation 2004, 2005 + * All Rights Reserved. + * + * Permission is hereby granted, free of charge, to any person obtaining a + * copy of this software and associated documentation files (the "Software"), + * to deal in the Software without restriction, including without limitation + * the rights to use, copy, modify, merge, publish, distribute, sub license, + * and/or sell copies of the Software, and to permit persons to whom the + * Software is furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice (including the next + * paragraph) shall be included in all copies or substantial portions of the + * Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL + * BRIAN PAUL, IBM, + * AND/OR THEIR SUPPLIERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, + * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF + * OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE + * SOFTWARE. + */ + +#include "x86/assyntax.h" + +#if defined(STDCALL_API) +# if defined(USE_MGL_NAMESPACE) +# define GL_PREFIX(n,n2) GLNAME(CONCAT(mgl,n2)) +# else +# define GL_PREFIX(n,n2) GLNAME(CONCAT(gl,n2)) +# endif +#else +# if defined(USE_MGL_NAMESPACE) +# define GL_PREFIX(n,n2) GLNAME(CONCAT(mgl,n)) +# define _glapi_Dispatch _mglapi_Dispatch +# else +# define GL_PREFIX(n,n2) GLNAME(CONCAT(gl,n)) +# endif +#endif + +#define GL_OFFSET(x) CODEPTR(REGOFF(4 * x, EAX)) + +#if defined(GNU_ASSEMBLER) && !defined(__DJGPP__) && !defined(__MINGW32__) && !defined(__APPLE__) +#define GLOBL_FN(x) GLOBL x ; .type x, function +#else +#define GLOBL_FN(x) GLOBL x +#endif + +#if defined(PTHREADS) || defined(WIN32) || defined(BEOS_THREADS) +# define THREADS +#endif + +#ifdef GLX_USE_TLS + +#ifdef GLX_X86_READONLY_TEXT +# define CTX_INSNS MOV_L(GS:(EAX), EAX) +#else +# define CTX_INSNS NOP /* Pad for init_glapi_relocs() */ +#endif + +# define GL_STUB(fn,off,fn_alt) \ +ALIGNTEXT16; \ +GLOBL_FN(GL_PREFIX(fn, fn_alt)); \ +GL_PREFIX(fn, fn_alt): \ + CALL(_x86_get_dispatch) ; \ + CTX_INSNS ; \ + JMP(GL_OFFSET(off)) + +#elif defined(PTHREADS) +# define GL_STUB(fn,off,fn_alt) \ +ALIGNTEXT16; \ +GLOBL_FN(GL_PREFIX(fn, fn_alt)); \ +GL_PREFIX(fn, fn_alt): \ + MOV_L(CONTENT(GLNAME(_glapi_Dispatch)), EAX) ; \ + TEST_L(EAX, EAX) ; \ + JE(1f) ; \ + JMP(GL_OFFSET(off)) ; \ +1: CALL(_x86_get_dispatch) ; \ + JMP(GL_OFFSET(off)) +#elif defined(THREADS) +# define GL_STUB(fn,off,fn_alt) \ +ALIGNTEXT16; \ +GLOBL_FN(GL_PREFIX(fn, fn_alt)); \ +GL_PREFIX(fn, fn_alt): \ + MOV_L(CONTENT(GLNAME(_glapi_Dispatch)), EAX) ; \ + TEST_L(EAX, EAX) ; \ + JE(1f) ; \ + JMP(GL_OFFSET(off)) ; \ +1: CALL(_glapi_get_dispatch) ; \ + JMP(GL_OFFSET(off)) +#else /* Non-threaded version. */ +# define GL_STUB(fn,off,fn_alt) \ +ALIGNTEXT16; \ +GLOBL_FN(GL_PREFIX(fn, fn_alt)); \ +GL_PREFIX(fn, fn_alt): \ + MOV_L(CONTENT(GLNAME(_glapi_Dispatch)), EAX) ; \ + JMP(GL_OFFSET(off)) +#endif + +#ifdef HAVE_ALIAS +# define GL_STUB_ALIAS(fn,off,fn_alt,alias,alias_alt) \ + .globl GL_PREFIX(fn, fn_alt) ; \ + .set GL_PREFIX(fn, fn_alt), GL_PREFIX(alias, alias_alt) +#else +# define GL_STUB_ALIAS(fn,off,fn_alt,alias,alias_alt) \ + GL_STUB(fn, off, fn_alt) +#endif + +SEG_TEXT + +#ifdef GLX_USE_TLS + + GLOBL GLNAME(_x86_get_dispatch) + HIDDEN(GLNAME(_x86_get_dispatch)) +ALIGNTEXT16 +GLNAME(_x86_get_dispatch): + call 1f +1: popl %eax + addl $_GLOBAL_OFFSET_TABLE_+[.-1b], %eax + movl _glapi_tls_Dispatch@GOTNTPOFF(%eax), %eax + ret + +#elif defined(PTHREADS) +EXTERN GLNAME(_glapi_Dispatch) +EXTERN GLNAME(_gl_DispatchTSD) +EXTERN GLNAME(pthread_getspecific) + +ALIGNTEXT16 +GLNAME(_x86_get_dispatch): + SUB_L(CONST(24), ESP) + PUSH_L(GLNAME(_gl_DispatchTSD)) + CALL(GLNAME(pthread_getspecific)) + ADD_L(CONST(28), ESP) + RET +#elif defined(THREADS) +EXTERN GLNAME(_glapi_get_dispatch) +#endif + +#if defined( GLX_USE_TLS ) && !defined( GLX_X86_READONLY_TEXT ) + .section wtext, "awx", @progbits +#endif /* defined( GLX_USE_TLS ) */ + + ALIGNTEXT16 + GLOBL GLNAME(gl_dispatch_functions_start) + HIDDEN(GLNAME(gl_dispatch_functions_start)) +GLNAME(gl_dispatch_functions_start): + + GL_STUB(_dispatch_stub_0, 0, _dispatch_stub_0@8) + HIDDEN(GL_PREFIX(_dispatch_stub_0, _dispatch_stub_0@8)) + GL_STUB(_dispatch_stub_1, 1, _dispatch_stub_1@0) + HIDDEN(GL_PREFIX(_dispatch_stub_1, _dispatch_stub_1@0)) + GL_STUB(_dispatch_stub_2, 2, _dispatch_stub_2@4) + HIDDEN(GL_PREFIX(_dispatch_stub_2, _dispatch_stub_2@4)) + GL_STUB(_dispatch_stub_3, 3, _dispatch_stub_3@12) + HIDDEN(GL_PREFIX(_dispatch_stub_3, _dispatch_stub_3@12)) + GL_STUB(_dispatch_stub_4, 4, _dispatch_stub_4@8) + HIDDEN(GL_PREFIX(_dispatch_stub_4, _dispatch_stub_4@8)) + GL_STUB(_dispatch_stub_5, 5, _dispatch_stub_5@4) + HIDDEN(GL_PREFIX(_dispatch_stub_5, _dispatch_stub_5@4)) + GL_STUB(_dispatch_stub_6, 6, _dispatch_stub_6@4) + HIDDEN(GL_PREFIX(_dispatch_stub_6, _dispatch_stub_6@4)) + GL_STUB(_dispatch_stub_7, 7, _dispatch_stub_7@4) + HIDDEN(GL_PREFIX(_dispatch_stub_7, _dispatch_stub_7@4)) + GL_STUB(_dispatch_stub_8, 8, _dispatch_stub_8@28) + HIDDEN(GL_PREFIX(_dispatch_stub_8, _dispatch_stub_8@28)) + GL_STUB(_dispatch_stub_9, 9, _dispatch_stub_9@12) + HIDDEN(GL_PREFIX(_dispatch_stub_9, _dispatch_stub_9@12)) + GL_STUB(_dispatch_stub_10, 10, _dispatch_stub_10@4) + HIDDEN(GL_PREFIX(_dispatch_stub_10, _dispatch_stub_10@4)) + GL_STUB(_dispatch_stub_11, 11, _dispatch_stub_11@24) + HIDDEN(GL_PREFIX(_dispatch_stub_11, _dispatch_stub_11@24)) + GL_STUB(_dispatch_stub_12, 12, _dispatch_stub_12@4) + HIDDEN(GL_PREFIX(_dispatch_stub_12, _dispatch_stub_12@4)) + GL_STUB(_dispatch_stub_13, 13, _dispatch_stub_13@12) + HIDDEN(GL_PREFIX(_dispatch_stub_13, _dispatch_stub_13@12)) + GL_STUB(_dispatch_stub_14, 14, _dispatch_stub_14@4) + HIDDEN(GL_PREFIX(_dispatch_stub_14, _dispatch_stub_14@4)) + GL_STUB(_dispatch_stub_15, 15, _dispatch_stub_15@12) + HIDDEN(GL_PREFIX(_dispatch_stub_15, _dispatch_stub_15@12)) + GL_STUB(_dispatch_stub_16, 16, _dispatch_stub_16@4) + HIDDEN(GL_PREFIX(_dispatch_stub_16, _dispatch_stub_16@4)) + GL_STUB(_dispatch_stub_17, 17, _dispatch_stub_17@12) + HIDDEN(GL_PREFIX(_dispatch_stub_17, _dispatch_stub_17@12)) + GL_STUB(_dispatch_stub_18, 18, _dispatch_stub_18@4) + HIDDEN(GL_PREFIX(_dispatch_stub_18, _dispatch_stub_18@4)) + GL_STUB(_dispatch_stub_19, 19, _dispatch_stub_19@12) + HIDDEN(GL_PREFIX(_dispatch_stub_19, _dispatch_stub_19@12)) + GL_STUB(_dispatch_stub_20, 20, _dispatch_stub_20@4) + HIDDEN(GL_PREFIX(_dispatch_stub_20, _dispatch_stub_20@4)) + GL_STUB(_dispatch_stub_21, 21, _dispatch_stub_21@12) + HIDDEN(GL_PREFIX(_dispatch_stub_21, _dispatch_stub_21@12)) + GL_STUB(_dispatch_stub_22, 22, _dispatch_stub_22@4) + HIDDEN(GL_PREFIX(_dispatch_stub_22, _dispatch_stub_22@4)) + GL_STUB(_dispatch_stub_23, 23, _dispatch_stub_23@12) + HIDDEN(GL_PREFIX(_dispatch_stub_23, _dispatch_stub_23@12)) + GL_STUB(_dispatch_stub_24, 24, _dispatch_stub_24@4) + HIDDEN(GL_PREFIX(_dispatch_stub_24, _dispatch_stub_24@4)) + GL_STUB(_dispatch_stub_25, 25, _dispatch_stub_25@16) + HIDDEN(GL_PREFIX(_dispatch_stub_25, _dispatch_stub_25@16)) + GL_STUB(_dispatch_stub_26, 26, _dispatch_stub_26@4) + HIDDEN(GL_PREFIX(_dispatch_stub_26, _dispatch_stub_26@4)) + GL_STUB(_dispatch_stub_27, 27, _dispatch_stub_27@32) + HIDDEN(GL_PREFIX(_dispatch_stub_27, _dispatch_stub_27@32)) + GL_STUB(_dispatch_stub_28, 28, _dispatch_stub_28@4) + HIDDEN(GL_PREFIX(_dispatch_stub_28, _dispatch_stub_28@4)) + GL_STUB(Color4f, 29, Color4f@16) + GL_STUB(_dispatch_stub_30, 30, _dispatch_stub_30@4) + HIDDEN(GL_PREFIX(_dispatch_stub_30, _dispatch_stub_30@4)) + GL_STUB(_dispatch_stub_31, 31, _dispatch_stub_31@16) + HIDDEN(GL_PREFIX(_dispatch_stub_31, _dispatch_stub_31@16)) + GL_STUB(_dispatch_stub_32, 32, _dispatch_stub_32@4) + HIDDEN(GL_PREFIX(_dispatch_stub_32, _dispatch_stub_32@4)) + GL_STUB(_dispatch_stub_33, 33, _dispatch_stub_33@16) + HIDDEN(GL_PREFIX(_dispatch_stub_33, _dispatch_stub_33@16)) + GL_STUB(_dispatch_stub_34, 34, _dispatch_stub_34@4) + HIDDEN(GL_PREFIX(_dispatch_stub_34, _dispatch_stub_34@4)) + GL_STUB(Color4ub, 35, Color4ub@16) + GL_STUB(_dispatch_stub_36, 36, _dispatch_stub_36@4) + HIDDEN(GL_PREFIX(_dispatch_stub_36, _dispatch_stub_36@4)) + GL_STUB(_dispatch_stub_37, 37, _dispatch_stub_37@16) + HIDDEN(GL_PREFIX(_dispatch_stub_37, _dispatch_stub_37@16)) + GL_STUB(_dispatch_stub_38, 38, _dispatch_stub_38@4) + HIDDEN(GL_PREFIX(_dispatch_stub_38, _dispatch_stub_38@4)) + GL_STUB(_dispatch_stub_39, 39, _dispatch_stub_39@16) + HIDDEN(GL_PREFIX(_dispatch_stub_39, _dispatch_stub_39@16)) + GL_STUB(_dispatch_stub_40, 40, _dispatch_stub_40@4) + HIDDEN(GL_PREFIX(_dispatch_stub_40, _dispatch_stub_40@4)) + GL_STUB(_dispatch_stub_41, 41, _dispatch_stub_41@4) + HIDDEN(GL_PREFIX(_dispatch_stub_41, _dispatch_stub_41@4)) + GL_STUB(_dispatch_stub_42, 42, _dispatch_stub_42@4) + HIDDEN(GL_PREFIX(_dispatch_stub_42, _dispatch_stub_42@4)) + GL_STUB(_dispatch_stub_43, 43, _dispatch_stub_43@0) + HIDDEN(GL_PREFIX(_dispatch_stub_43, _dispatch_stub_43@0)) + GL_STUB(_dispatch_stub_44, 44, _dispatch_stub_44@8) + HIDDEN(GL_PREFIX(_dispatch_stub_44, _dispatch_stub_44@8)) + GL_STUB(_dispatch_stub_45, 45, _dispatch_stub_45@4) + HIDDEN(GL_PREFIX(_dispatch_stub_45, _dispatch_stub_45@4)) + GL_STUB(_dispatch_stub_46, 46, _dispatch_stub_46@4) + HIDDEN(GL_PREFIX(_dispatch_stub_46, _dispatch_stub_46@4)) + GL_STUB(_dispatch_stub_47, 47, _dispatch_stub_47@4) + HIDDEN(GL_PREFIX(_dispatch_stub_47, _dispatch_stub_47@4)) + GL_STUB(_dispatch_stub_48, 48, _dispatch_stub_48@4) + HIDDEN(GL_PREFIX(_dispatch_stub_48, _dispatch_stub_48@4)) + GL_STUB(_dispatch_stub_49, 49, _dispatch_stub_49@4) + HIDDEN(GL_PREFIX(_dispatch_stub_49, _dispatch_stub_49@4)) + GL_STUB(_dispatch_stub_50, 50, _dispatch_stub_50@4) + HIDDEN(GL_PREFIX(_dispatch_stub_50, _dispatch_stub_50@4)) + GL_STUB(_dispatch_stub_51, 51, _dispatch_stub_51@4) + HIDDEN(GL_PREFIX(_dispatch_stub_51, _dispatch_stub_51@4)) + GL_STUB(_dispatch_stub_52, 52, _dispatch_stub_52@12) + HIDDEN(GL_PREFIX(_dispatch_stub_52, _dispatch_stub_52@12)) + GL_STUB(_dispatch_stub_53, 53, _dispatch_stub_53@4) + HIDDEN(GL_PREFIX(_dispatch_stub_53, _dispatch_stub_53@4)) + GL_STUB(_dispatch_stub_54, 54, _dispatch_stub_54@24) + HIDDEN(GL_PREFIX(_dispatch_stub_54, _dispatch_stub_54@24)) + GL_STUB(_dispatch_stub_55, 55, _dispatch_stub_55@4) + HIDDEN(GL_PREFIX(_dispatch_stub_55, _dispatch_stub_55@4)) + GL_STUB(Normal3f, 56, Normal3f@12) + GL_STUB(_dispatch_stub_57, 57, _dispatch_stub_57@4) + HIDDEN(GL_PREFIX(_dispatch_stub_57, _dispatch_stub_57@4)) + GL_STUB(_dispatch_stub_58, 58, _dispatch_stub_58@12) + HIDDEN(GL_PREFIX(_dispatch_stub_58, _dispatch_stub_58@12)) + GL_STUB(_dispatch_stub_59, 59, _dispatch_stub_59@4) + HIDDEN(GL_PREFIX(_dispatch_stub_59, _dispatch_stub_59@4)) + GL_STUB(_dispatch_stub_60, 60, _dispatch_stub_60@12) + HIDDEN(GL_PREFIX(_dispatch_stub_60, _dispatch_stub_60@12)) + GL_STUB(_dispatch_stub_61, 61, _dispatch_stub_61@4) + HIDDEN(GL_PREFIX(_dispatch_stub_61, _dispatch_stub_61@4)) + GL_STUB(_dispatch_stub_62, 62, _dispatch_stub_62@16) + HIDDEN(GL_PREFIX(_dispatch_stub_62, _dispatch_stub_62@16)) + GL_STUB(_dispatch_stub_63, 63, _dispatch_stub_63@4) + HIDDEN(GL_PREFIX(_dispatch_stub_63, _dispatch_stub_63@4)) + GL_STUB(_dispatch_stub_64, 64, _dispatch_stub_64@8) + HIDDEN(GL_PREFIX(_dispatch_stub_64, _dispatch_stub_64@8)) + GL_STUB(_dispatch_stub_65, 65, _dispatch_stub_65@4) + HIDDEN(GL_PREFIX(_dispatch_stub_65, _dispatch_stub_65@4)) + GL_STUB(_dispatch_stub_66, 66, _dispatch_stub_66@8) + HIDDEN(GL_PREFIX(_dispatch_stub_66, _dispatch_stub_66@8)) + GL_STUB(_dispatch_stub_67, 67, _dispatch_stub_67@4) + HIDDEN(GL_PREFIX(_dispatch_stub_67, _dispatch_stub_67@4)) + GL_STUB(_dispatch_stub_68, 68, _dispatch_stub_68@8) + HIDDEN(GL_PREFIX(_dispatch_stub_68, _dispatch_stub_68@8)) + GL_STUB(_dispatch_stub_69, 69, _dispatch_stub_69@4) + HIDDEN(GL_PREFIX(_dispatch_stub_69, _dispatch_stub_69@4)) + GL_STUB(_dispatch_stub_70, 70, _dispatch_stub_70@24) + HIDDEN(GL_PREFIX(_dispatch_stub_70, _dispatch_stub_70@24)) + GL_STUB(_dispatch_stub_71, 71, _dispatch_stub_71@4) + HIDDEN(GL_PREFIX(_dispatch_stub_71, _dispatch_stub_71@4)) + GL_STUB(_dispatch_stub_72, 72, _dispatch_stub_72@12) + HIDDEN(GL_PREFIX(_dispatch_stub_72, _dispatch_stub_72@12)) + GL_STUB(_dispatch_stub_73, 73, _dispatch_stub_73@4) + HIDDEN(GL_PREFIX(_dispatch_stub_73, _dispatch_stub_73@4)) + GL_STUB(_dispatch_stub_74, 74, _dispatch_stub_74@12) + HIDDEN(GL_PREFIX(_dispatch_stub_74, _dispatch_stub_74@12)) + GL_STUB(_dispatch_stub_75, 75, _dispatch_stub_75@4) + HIDDEN(GL_PREFIX(_dispatch_stub_75, _dispatch_stub_75@4)) + GL_STUB(_dispatch_stub_76, 76, _dispatch_stub_76@12) + HIDDEN(GL_PREFIX(_dispatch_stub_76, _dispatch_stub_76@12)) + GL_STUB(_dispatch_stub_77, 77, _dispatch_stub_77@4) + HIDDEN(GL_PREFIX(_dispatch_stub_77, _dispatch_stub_77@4)) + GL_STUB(_dispatch_stub_78, 78, _dispatch_stub_78@32) + HIDDEN(GL_PREFIX(_dispatch_stub_78, _dispatch_stub_78@32)) + GL_STUB(_dispatch_stub_79, 79, _dispatch_stub_79@4) + HIDDEN(GL_PREFIX(_dispatch_stub_79, _dispatch_stub_79@4)) + GL_STUB(_dispatch_stub_80, 80, _dispatch_stub_80@16) + HIDDEN(GL_PREFIX(_dispatch_stub_80, _dispatch_stub_80@16)) + GL_STUB(_dispatch_stub_81, 81, _dispatch_stub_81@4) + HIDDEN(GL_PREFIX(_dispatch_stub_81, _dispatch_stub_81@4)) + GL_STUB(_dispatch_stub_82, 82, _dispatch_stub_82@16) + HIDDEN(GL_PREFIX(_dispatch_stub_82, _dispatch_stub_82@16)) + GL_STUB(_dispatch_stub_83, 83, _dispatch_stub_83@4) + HIDDEN(GL_PREFIX(_dispatch_stub_83, _dispatch_stub_83@4)) + GL_STUB(_dispatch_stub_84, 84, _dispatch_stub_84@16) + HIDDEN(GL_PREFIX(_dispatch_stub_84, _dispatch_stub_84@16)) + GL_STUB(_dispatch_stub_85, 85, _dispatch_stub_85@4) + HIDDEN(GL_PREFIX(_dispatch_stub_85, _dispatch_stub_85@4)) + GL_STUB(_dispatch_stub_86, 86, _dispatch_stub_86@32) + HIDDEN(GL_PREFIX(_dispatch_stub_86, _dispatch_stub_86@32)) + GL_STUB(_dispatch_stub_87, 87, _dispatch_stub_87@8) + HIDDEN(GL_PREFIX(_dispatch_stub_87, _dispatch_stub_87@8)) + GL_STUB(_dispatch_stub_88, 88, _dispatch_stub_88@16) + HIDDEN(GL_PREFIX(_dispatch_stub_88, _dispatch_stub_88@16)) + GL_STUB(_dispatch_stub_89, 89, _dispatch_stub_89@8) + HIDDEN(GL_PREFIX(_dispatch_stub_89, _dispatch_stub_89@8)) + GL_STUB(_dispatch_stub_90, 90, _dispatch_stub_90@16) + HIDDEN(GL_PREFIX(_dispatch_stub_90, _dispatch_stub_90@16)) + GL_STUB(_dispatch_stub_91, 91, _dispatch_stub_91@8) + HIDDEN(GL_PREFIX(_dispatch_stub_91, _dispatch_stub_91@8)) + GL_STUB(_dispatch_stub_92, 92, _dispatch_stub_92@16) + HIDDEN(GL_PREFIX(_dispatch_stub_92, _dispatch_stub_92@16)) + GL_STUB(_dispatch_stub_93, 93, _dispatch_stub_93@8) + HIDDEN(GL_PREFIX(_dispatch_stub_93, _dispatch_stub_93@8)) + GL_STUB(_dispatch_stub_94, 94, _dispatch_stub_94@8) + HIDDEN(GL_PREFIX(_dispatch_stub_94, _dispatch_stub_94@8)) + GL_STUB(_dispatch_stub_95, 95, _dispatch_stub_95@4) + HIDDEN(GL_PREFIX(_dispatch_stub_95, _dispatch_stub_95@4)) + GL_STUB(_dispatch_stub_96, 96, _dispatch_stub_96@4) + HIDDEN(GL_PREFIX(_dispatch_stub_96, _dispatch_stub_96@4)) + GL_STUB(_dispatch_stub_97, 97, _dispatch_stub_97@4) + HIDDEN(GL_PREFIX(_dispatch_stub_97, _dispatch_stub_97@4)) + GL_STUB(_dispatch_stub_98, 98, _dispatch_stub_98@4) + HIDDEN(GL_PREFIX(_dispatch_stub_98, _dispatch_stub_98@4)) + GL_STUB(_dispatch_stub_99, 99, _dispatch_stub_99@4) + HIDDEN(GL_PREFIX(_dispatch_stub_99, _dispatch_stub_99@4)) + GL_STUB(_dispatch_stub_100, 100, _dispatch_stub_100@4) + HIDDEN(GL_PREFIX(_dispatch_stub_100, _dispatch_stub_100@4)) + GL_STUB(_dispatch_stub_101, 101, _dispatch_stub_101@4) + HIDDEN(GL_PREFIX(_dispatch_stub_101, _dispatch_stub_101@4)) + GL_STUB(_dispatch_stub_102, 102, _dispatch_stub_102@16) + HIDDEN(GL_PREFIX(_dispatch_stub_102, _dispatch_stub_102@16)) + GL_STUB(_dispatch_stub_103, 103, _dispatch_stub_103@4) + HIDDEN(GL_PREFIX(_dispatch_stub_103, _dispatch_stub_103@4)) + GL_STUB(_dispatch_stub_104, 104, _dispatch_stub_104@8) + HIDDEN(GL_PREFIX(_dispatch_stub_104, _dispatch_stub_104@8)) + GL_STUB(_dispatch_stub_105, 105, _dispatch_stub_105@4) + HIDDEN(GL_PREFIX(_dispatch_stub_105, _dispatch_stub_105@4)) + GL_STUB(_dispatch_stub_106, 106, _dispatch_stub_106@8) + HIDDEN(GL_PREFIX(_dispatch_stub_106, _dispatch_stub_106@8)) + GL_STUB(_dispatch_stub_107, 107, _dispatch_stub_107@4) + HIDDEN(GL_PREFIX(_dispatch_stub_107, _dispatch_stub_107@4)) + GL_STUB(_dispatch_stub_108, 108, _dispatch_stub_108@8) + HIDDEN(GL_PREFIX(_dispatch_stub_108, _dispatch_stub_108@8)) + GL_STUB(_dispatch_stub_109, 109, _dispatch_stub_109@4) + HIDDEN(GL_PREFIX(_dispatch_stub_109, _dispatch_stub_109@4)) + GL_STUB(_dispatch_stub_110, 110, _dispatch_stub_110@24) + HIDDEN(GL_PREFIX(_dispatch_stub_110, _dispatch_stub_110@24)) + GL_STUB(_dispatch_stub_111, 111, _dispatch_stub_111@4) + HIDDEN(GL_PREFIX(_dispatch_stub_111, _dispatch_stub_111@4)) + GL_STUB(_dispatch_stub_112, 112, _dispatch_stub_112@12) + HIDDEN(GL_PREFIX(_dispatch_stub_112, _dispatch_stub_112@12)) + GL_STUB(_dispatch_stub_113, 113, _dispatch_stub_113@4) + HIDDEN(GL_PREFIX(_dispatch_stub_113, _dispatch_stub_113@4)) + GL_STUB(_dispatch_stub_114, 114, _dispatch_stub_114@12) + HIDDEN(GL_PREFIX(_dispatch_stub_114, _dispatch_stub_114@12)) + GL_STUB(_dispatch_stub_115, 115, _dispatch_stub_115@4) + HIDDEN(GL_PREFIX(_dispatch_stub_115, _dispatch_stub_115@4)) + GL_STUB(_dispatch_stub_116, 116, _dispatch_stub_116@12) + HIDDEN(GL_PREFIX(_dispatch_stub_116, _dispatch_stub_116@12)) + GL_STUB(_dispatch_stub_117, 117, _dispatch_stub_117@4) + HIDDEN(GL_PREFIX(_dispatch_stub_117, _dispatch_stub_117@4)) + GL_STUB(_dispatch_stub_118, 118, _dispatch_stub_118@32) + HIDDEN(GL_PREFIX(_dispatch_stub_118, _dispatch_stub_118@32)) + GL_STUB(_dispatch_stub_119, 119, _dispatch_stub_119@4) + HIDDEN(GL_PREFIX(_dispatch_stub_119, _dispatch_stub_119@4)) + GL_STUB(_dispatch_stub_120, 120, _dispatch_stub_120@16) + HIDDEN(GL_PREFIX(_dispatch_stub_120, _dispatch_stub_120@16)) + GL_STUB(_dispatch_stub_121, 121, _dispatch_stub_121@4) + HIDDEN(GL_PREFIX(_dispatch_stub_121, _dispatch_stub_121@4)) + GL_STUB(_dispatch_stub_122, 122, _dispatch_stub_122@16) + HIDDEN(GL_PREFIX(_dispatch_stub_122, _dispatch_stub_122@16)) + GL_STUB(_dispatch_stub_123, 123, _dispatch_stub_123@4) + HIDDEN(GL_PREFIX(_dispatch_stub_123, _dispatch_stub_123@4)) + GL_STUB(_dispatch_stub_124, 124, _dispatch_stub_124@16) + HIDDEN(GL_PREFIX(_dispatch_stub_124, _dispatch_stub_124@16)) + GL_STUB(_dispatch_stub_125, 125, _dispatch_stub_125@4) + HIDDEN(GL_PREFIX(_dispatch_stub_125, _dispatch_stub_125@4)) + GL_STUB(_dispatch_stub_126, 126, _dispatch_stub_126@16) + HIDDEN(GL_PREFIX(_dispatch_stub_126, _dispatch_stub_126@16)) + GL_STUB(_dispatch_stub_127, 127, _dispatch_stub_127@4) + HIDDEN(GL_PREFIX(_dispatch_stub_127, _dispatch_stub_127@4)) + GL_STUB(_dispatch_stub_128, 128, _dispatch_stub_128@8) + HIDDEN(GL_PREFIX(_dispatch_stub_128, _dispatch_stub_128@8)) + GL_STUB(_dispatch_stub_129, 129, _dispatch_stub_129@4) + HIDDEN(GL_PREFIX(_dispatch_stub_129, _dispatch_stub_129@4)) + GL_STUB(_dispatch_stub_130, 130, _dispatch_stub_130@8) + HIDDEN(GL_PREFIX(_dispatch_stub_130, _dispatch_stub_130@8)) + GL_STUB(_dispatch_stub_131, 131, _dispatch_stub_131@4) + HIDDEN(GL_PREFIX(_dispatch_stub_131, _dispatch_stub_131@4)) + GL_STUB(_dispatch_stub_132, 132, _dispatch_stub_132@8) + HIDDEN(GL_PREFIX(_dispatch_stub_132, _dispatch_stub_132@8)) + GL_STUB(_dispatch_stub_133, 133, _dispatch_stub_133@4) + HIDDEN(GL_PREFIX(_dispatch_stub_133, _dispatch_stub_133@4)) + GL_STUB(_dispatch_stub_134, 134, _dispatch_stub_134@24) + HIDDEN(GL_PREFIX(_dispatch_stub_134, _dispatch_stub_134@24)) + GL_STUB(_dispatch_stub_135, 135, _dispatch_stub_135@4) + HIDDEN(GL_PREFIX(_dispatch_stub_135, _dispatch_stub_135@4)) + GL_STUB(_dispatch_stub_136, 136, _dispatch_stub_136@12) + HIDDEN(GL_PREFIX(_dispatch_stub_136, _dispatch_stub_136@12)) + GL_STUB(_dispatch_stub_137, 137, _dispatch_stub_137@4) + HIDDEN(GL_PREFIX(_dispatch_stub_137, _dispatch_stub_137@4)) + GL_STUB(_dispatch_stub_138, 138, _dispatch_stub_138@12) + HIDDEN(GL_PREFIX(_dispatch_stub_138, _dispatch_stub_138@12)) + GL_STUB(_dispatch_stub_139, 139, _dispatch_stub_139@4) + HIDDEN(GL_PREFIX(_dispatch_stub_139, _dispatch_stub_139@4)) + GL_STUB(_dispatch_stub_140, 140, _dispatch_stub_140@12) + HIDDEN(GL_PREFIX(_dispatch_stub_140, _dispatch_stub_140@12)) + GL_STUB(_dispatch_stub_141, 141, _dispatch_stub_141@4) + HIDDEN(GL_PREFIX(_dispatch_stub_141, _dispatch_stub_141@4)) + GL_STUB(_dispatch_stub_142, 142, _dispatch_stub_142@32) + HIDDEN(GL_PREFIX(_dispatch_stub_142, _dispatch_stub_142@32)) + GL_STUB(_dispatch_stub_143, 143, _dispatch_stub_143@4) + HIDDEN(GL_PREFIX(_dispatch_stub_143, _dispatch_stub_143@4)) + GL_STUB(_dispatch_stub_144, 144, _dispatch_stub_144@16) + HIDDEN(GL_PREFIX(_dispatch_stub_144, _dispatch_stub_144@16)) + GL_STUB(_dispatch_stub_145, 145, _dispatch_stub_145@4) + HIDDEN(GL_PREFIX(_dispatch_stub_145, _dispatch_stub_145@4)) + GL_STUB(_dispatch_stub_146, 146, _dispatch_stub_146@16) + HIDDEN(GL_PREFIX(_dispatch_stub_146, _dispatch_stub_146@16)) + GL_STUB(_dispatch_stub_147, 147, _dispatch_stub_147@4) + HIDDEN(GL_PREFIX(_dispatch_stub_147, _dispatch_stub_147@4)) + GL_STUB(_dispatch_stub_148, 148, _dispatch_stub_148@16) + HIDDEN(GL_PREFIX(_dispatch_stub_148, _dispatch_stub_148@16)) + GL_STUB(_dispatch_stub_149, 149, _dispatch_stub_149@4) + HIDDEN(GL_PREFIX(_dispatch_stub_149, _dispatch_stub_149@4)) + GL_STUB(_dispatch_stub_150, 150, _dispatch_stub_150@8) + HIDDEN(GL_PREFIX(_dispatch_stub_150, _dispatch_stub_150@8)) + GL_STUB(_dispatch_stub_151, 151, _dispatch_stub_151@8) + HIDDEN(GL_PREFIX(_dispatch_stub_151, _dispatch_stub_151@8)) + GL_STUB(CullFace, 152, CullFace@4) + GL_STUB(Fogf, 153, Fogf@8) + GL_STUB(Fogfv, 154, Fogfv@8) + GL_STUB(_dispatch_stub_155, 155, _dispatch_stub_155@8) + HIDDEN(GL_PREFIX(_dispatch_stub_155, _dispatch_stub_155@8)) + GL_STUB(_dispatch_stub_156, 156, _dispatch_stub_156@8) + HIDDEN(GL_PREFIX(_dispatch_stub_156, _dispatch_stub_156@8)) + GL_STUB(FrontFace, 157, FrontFace@4) + GL_STUB(Hint, 158, Hint@8) + GL_STUB(Lightf, 159, Lightf@12) + GL_STUB(Lightfv, 160, Lightfv@12) + GL_STUB(_dispatch_stub_161, 161, _dispatch_stub_161@12) + HIDDEN(GL_PREFIX(_dispatch_stub_161, _dispatch_stub_161@12)) + GL_STUB(_dispatch_stub_162, 162, _dispatch_stub_162@12) + HIDDEN(GL_PREFIX(_dispatch_stub_162, _dispatch_stub_162@12)) + GL_STUB(LightModelf, 163, LightModelf@8) + GL_STUB(LightModelfv, 164, LightModelfv@8) + GL_STUB(_dispatch_stub_165, 165, _dispatch_stub_165@8) + HIDDEN(GL_PREFIX(_dispatch_stub_165, _dispatch_stub_165@8)) + GL_STUB(_dispatch_stub_166, 166, _dispatch_stub_166@8) + HIDDEN(GL_PREFIX(_dispatch_stub_166, _dispatch_stub_166@8)) + GL_STUB(_dispatch_stub_167, 167, _dispatch_stub_167@8) + HIDDEN(GL_PREFIX(_dispatch_stub_167, _dispatch_stub_167@8)) + GL_STUB(LineWidth, 168, LineWidth@4) + GL_STUB(Materialf, 169, Materialf@12) + GL_STUB(Materialfv, 170, Materialfv@12) + GL_STUB(_dispatch_stub_171, 171, _dispatch_stub_171@12) + HIDDEN(GL_PREFIX(_dispatch_stub_171, _dispatch_stub_171@12)) + GL_STUB(_dispatch_stub_172, 172, _dispatch_stub_172@12) + HIDDEN(GL_PREFIX(_dispatch_stub_172, _dispatch_stub_172@12)) + GL_STUB(PointSize, 173, PointSize@4) + GL_STUB(_dispatch_stub_174, 174, _dispatch_stub_174@8) + HIDDEN(GL_PREFIX(_dispatch_stub_174, _dispatch_stub_174@8)) + GL_STUB(_dispatch_stub_175, 175, _dispatch_stub_175@4) + HIDDEN(GL_PREFIX(_dispatch_stub_175, _dispatch_stub_175@4)) + GL_STUB(Scissor, 176, Scissor@16) + GL_STUB(ShadeModel, 177, ShadeModel@4) + GL_STUB(TexParameterf, 178, TexParameterf@12) + GL_STUB(TexParameterfv, 179, TexParameterfv@12) + GL_STUB(TexParameteri, 180, TexParameteri@12) + GL_STUB(TexParameteriv, 181, TexParameteriv@12) + GL_STUB(_dispatch_stub_182, 182, _dispatch_stub_182@32) + HIDDEN(GL_PREFIX(_dispatch_stub_182, _dispatch_stub_182@32)) + GL_STUB(TexImage2D, 183, TexImage2D@36) + GL_STUB(TexEnvf, 184, TexEnvf@12) + GL_STUB(TexEnvfv, 185, TexEnvfv@12) + GL_STUB(TexEnvi, 186, TexEnvi@12) + GL_STUB(TexEnviv, 187, TexEnviv@12) + GL_STUB(_dispatch_stub_188, 188, _dispatch_stub_188@16) + HIDDEN(GL_PREFIX(_dispatch_stub_188, _dispatch_stub_188@16)) + GL_STUB(_dispatch_stub_189, 189, _dispatch_stub_189@12) + HIDDEN(GL_PREFIX(_dispatch_stub_189, _dispatch_stub_189@12)) + GL_STUB(TexGenfOES, 190, TexGenfOES@12) + GL_STUB(TexGenfvOES, 191, TexGenfvOES@12) + GL_STUB(TexGeniOES, 192, TexGeniOES@12) + GL_STUB(TexGenivOES, 193, TexGenivOES@12) + GL_STUB(_dispatch_stub_194, 194, _dispatch_stub_194@12) + HIDDEN(GL_PREFIX(_dispatch_stub_194, _dispatch_stub_194@12)) + GL_STUB(_dispatch_stub_195, 195, _dispatch_stub_195@8) + HIDDEN(GL_PREFIX(_dispatch_stub_195, _dispatch_stub_195@8)) + GL_STUB(_dispatch_stub_196, 196, _dispatch_stub_196@4) + HIDDEN(GL_PREFIX(_dispatch_stub_196, _dispatch_stub_196@4)) + GL_STUB(_dispatch_stub_197, 197, _dispatch_stub_197@0) + HIDDEN(GL_PREFIX(_dispatch_stub_197, _dispatch_stub_197@0)) + GL_STUB(_dispatch_stub_198, 198, _dispatch_stub_198@4) + HIDDEN(GL_PREFIX(_dispatch_stub_198, _dispatch_stub_198@4)) + GL_STUB(_dispatch_stub_199, 199, _dispatch_stub_199@4) + HIDDEN(GL_PREFIX(_dispatch_stub_199, _dispatch_stub_199@4)) + GL_STUB(_dispatch_stub_200, 200, _dispatch_stub_200@0) + HIDDEN(GL_PREFIX(_dispatch_stub_200, _dispatch_stub_200@0)) + GL_STUB(_dispatch_stub_201, 201, _dispatch_stub_201@4) + HIDDEN(GL_PREFIX(_dispatch_stub_201, _dispatch_stub_201@4)) + GL_STUB(_dispatch_stub_202, 202, _dispatch_stub_202@4) + HIDDEN(GL_PREFIX(_dispatch_stub_202, _dispatch_stub_202@4)) + GL_STUB(Clear, 203, Clear@4) + GL_STUB(_dispatch_stub_204, 204, _dispatch_stub_204@16) + HIDDEN(GL_PREFIX(_dispatch_stub_204, _dispatch_stub_204@16)) + GL_STUB(_dispatch_stub_205, 205, _dispatch_stub_205@4) + HIDDEN(GL_PREFIX(_dispatch_stub_205, _dispatch_stub_205@4)) + GL_STUB(ClearColor, 206, ClearColor@16) + GL_STUB(ClearStencil, 207, ClearStencil@4) + GL_STUB(_dispatch_stub_208, 208, _dispatch_stub_208@8) + HIDDEN(GL_PREFIX(_dispatch_stub_208, _dispatch_stub_208@8)) + GL_STUB(StencilMask, 209, StencilMask@4) + GL_STUB(ColorMask, 210, ColorMask@16) + GL_STUB(DepthMask, 211, DepthMask@4) + GL_STUB(_dispatch_stub_212, 212, _dispatch_stub_212@4) + HIDDEN(GL_PREFIX(_dispatch_stub_212, _dispatch_stub_212@4)) + GL_STUB(_dispatch_stub_213, 213, _dispatch_stub_213@8) + HIDDEN(GL_PREFIX(_dispatch_stub_213, _dispatch_stub_213@8)) + GL_STUB(Disable, 214, Disable@4) + GL_STUB(Enable, 215, Enable@4) + GL_STUB(Finish, 216, Finish@0) + GL_STUB(Flush, 217, Flush@0) + GL_STUB(_dispatch_stub_218, 218, _dispatch_stub_218@0) + HIDDEN(GL_PREFIX(_dispatch_stub_218, _dispatch_stub_218@0)) + GL_STUB(_dispatch_stub_219, 219, _dispatch_stub_219@4) + HIDDEN(GL_PREFIX(_dispatch_stub_219, _dispatch_stub_219@4)) + GL_STUB(_dispatch_stub_220, 220, _dispatch_stub_220@32) + HIDDEN(GL_PREFIX(_dispatch_stub_220, _dispatch_stub_220@32)) + GL_STUB(_dispatch_stub_221, 221, _dispatch_stub_221@24) + HIDDEN(GL_PREFIX(_dispatch_stub_221, _dispatch_stub_221@24)) + GL_STUB(_dispatch_stub_222, 222, _dispatch_stub_222@56) + HIDDEN(GL_PREFIX(_dispatch_stub_222, _dispatch_stub_222@56)) + GL_STUB(_dispatch_stub_223, 223, _dispatch_stub_223@40) + HIDDEN(GL_PREFIX(_dispatch_stub_223, _dispatch_stub_223@40)) + GL_STUB(_dispatch_stub_224, 224, _dispatch_stub_224@20) + HIDDEN(GL_PREFIX(_dispatch_stub_224, _dispatch_stub_224@20)) + GL_STUB(_dispatch_stub_225, 225, _dispatch_stub_225@12) + HIDDEN(GL_PREFIX(_dispatch_stub_225, _dispatch_stub_225@12)) + GL_STUB(_dispatch_stub_226, 226, _dispatch_stub_226@40) + HIDDEN(GL_PREFIX(_dispatch_stub_226, _dispatch_stub_226@40)) + GL_STUB(_dispatch_stub_227, 227, _dispatch_stub_227@24) + HIDDEN(GL_PREFIX(_dispatch_stub_227, _dispatch_stub_227@24)) + GL_STUB(_dispatch_stub_228, 228, _dispatch_stub_228@8) + HIDDEN(GL_PREFIX(_dispatch_stub_228, _dispatch_stub_228@8)) + GL_STUB(_dispatch_stub_229, 229, _dispatch_stub_229@4) + HIDDEN(GL_PREFIX(_dispatch_stub_229, _dispatch_stub_229@4)) + GL_STUB(_dispatch_stub_230, 230, _dispatch_stub_230@4) + HIDDEN(GL_PREFIX(_dispatch_stub_230, _dispatch_stub_230@4)) + GL_STUB(_dispatch_stub_231, 231, _dispatch_stub_231@4) + HIDDEN(GL_PREFIX(_dispatch_stub_231, _dispatch_stub_231@4)) + GL_STUB(_dispatch_stub_232, 232, _dispatch_stub_232@16) + HIDDEN(GL_PREFIX(_dispatch_stub_232, _dispatch_stub_232@16)) + GL_STUB(_dispatch_stub_233, 233, _dispatch_stub_233@4) + HIDDEN(GL_PREFIX(_dispatch_stub_233, _dispatch_stub_233@4)) + GL_STUB(_dispatch_stub_234, 234, _dispatch_stub_234@8) + HIDDEN(GL_PREFIX(_dispatch_stub_234, _dispatch_stub_234@8)) + GL_STUB(_dispatch_stub_235, 235, _dispatch_stub_235@4) + HIDDEN(GL_PREFIX(_dispatch_stub_235, _dispatch_stub_235@4)) + GL_STUB(_dispatch_stub_236, 236, _dispatch_stub_236@12) + HIDDEN(GL_PREFIX(_dispatch_stub_236, _dispatch_stub_236@12)) + GL_STUB(_dispatch_stub_237, 237, _dispatch_stub_237@4) + HIDDEN(GL_PREFIX(_dispatch_stub_237, _dispatch_stub_237@4)) + GL_STUB(_dispatch_stub_238, 238, _dispatch_stub_238@20) + HIDDEN(GL_PREFIX(_dispatch_stub_238, _dispatch_stub_238@20)) + GL_STUB(_dispatch_stub_239, 239, _dispatch_stub_239@8) + HIDDEN(GL_PREFIX(_dispatch_stub_239, _dispatch_stub_239@8)) + GL_STUB(AlphaFunc, 240, AlphaFunc@8) + GL_STUB(BlendFunc, 241, BlendFunc@8) + GL_STUB(LogicOp, 242, LogicOp@4) + GL_STUB(StencilFunc, 243, StencilFunc@12) + GL_STUB(StencilOp, 244, StencilOp@12) + GL_STUB(DepthFunc, 245, DepthFunc@4) + GL_STUB(_dispatch_stub_246, 246, _dispatch_stub_246@8) + HIDDEN(GL_PREFIX(_dispatch_stub_246, _dispatch_stub_246@8)) + GL_STUB(_dispatch_stub_247, 247, _dispatch_stub_247@8) + HIDDEN(GL_PREFIX(_dispatch_stub_247, _dispatch_stub_247@8)) + GL_STUB(_dispatch_stub_248, 248, _dispatch_stub_248@8) + HIDDEN(GL_PREFIX(_dispatch_stub_248, _dispatch_stub_248@8)) + GL_STUB(_dispatch_stub_249, 249, _dispatch_stub_249@8) + HIDDEN(GL_PREFIX(_dispatch_stub_249, _dispatch_stub_249@8)) + GL_STUB(PixelStorei, 250, PixelStorei@8) + GL_STUB(_dispatch_stub_251, 251, _dispatch_stub_251@12) + HIDDEN(GL_PREFIX(_dispatch_stub_251, _dispatch_stub_251@12)) + GL_STUB(_dispatch_stub_252, 252, _dispatch_stub_252@12) + HIDDEN(GL_PREFIX(_dispatch_stub_252, _dispatch_stub_252@12)) + GL_STUB(_dispatch_stub_253, 253, _dispatch_stub_253@12) + HIDDEN(GL_PREFIX(_dispatch_stub_253, _dispatch_stub_253@12)) + GL_STUB(_dispatch_stub_254, 254, _dispatch_stub_254@4) + HIDDEN(GL_PREFIX(_dispatch_stub_254, _dispatch_stub_254@4)) + GL_STUB(_dispatch_stub_255, 255, _dispatch_stub_255@20) + HIDDEN(GL_PREFIX(_dispatch_stub_255, _dispatch_stub_255@20)) + GL_STUB(ReadPixels, 256, ReadPixels@28) + GL_STUB(_dispatch_stub_257, 257, _dispatch_stub_257@20) + HIDDEN(GL_PREFIX(_dispatch_stub_257, _dispatch_stub_257@20)) + GL_STUB(GetBooleanv, 258, GetBooleanv@8) + GL_STUB(_dispatch_stub_259, 259, _dispatch_stub_259@8) + HIDDEN(GL_PREFIX(_dispatch_stub_259, _dispatch_stub_259@8)) + GL_STUB(_dispatch_stub_260, 260, _dispatch_stub_260@8) + HIDDEN(GL_PREFIX(_dispatch_stub_260, _dispatch_stub_260@8)) + GL_STUB(GetError, 261, GetError@0) + GL_STUB(GetFloatv, 262, GetFloatv@8) + GL_STUB(GetIntegerv, 263, GetIntegerv@8) + GL_STUB(GetLightfv, 264, GetLightfv@12) + GL_STUB(_dispatch_stub_265, 265, _dispatch_stub_265@12) + HIDDEN(GL_PREFIX(_dispatch_stub_265, _dispatch_stub_265@12)) + GL_STUB(_dispatch_stub_266, 266, _dispatch_stub_266@12) + HIDDEN(GL_PREFIX(_dispatch_stub_266, _dispatch_stub_266@12)) + GL_STUB(_dispatch_stub_267, 267, _dispatch_stub_267@12) + HIDDEN(GL_PREFIX(_dispatch_stub_267, _dispatch_stub_267@12)) + GL_STUB(_dispatch_stub_268, 268, _dispatch_stub_268@12) + HIDDEN(GL_PREFIX(_dispatch_stub_268, _dispatch_stub_268@12)) + GL_STUB(GetMaterialfv, 269, GetMaterialfv@12) + GL_STUB(_dispatch_stub_270, 270, _dispatch_stub_270@12) + HIDDEN(GL_PREFIX(_dispatch_stub_270, _dispatch_stub_270@12)) + GL_STUB(_dispatch_stub_271, 271, _dispatch_stub_271@8) + HIDDEN(GL_PREFIX(_dispatch_stub_271, _dispatch_stub_271@8)) + GL_STUB(_dispatch_stub_272, 272, _dispatch_stub_272@8) + HIDDEN(GL_PREFIX(_dispatch_stub_272, _dispatch_stub_272@8)) + GL_STUB(_dispatch_stub_273, 273, _dispatch_stub_273@8) + HIDDEN(GL_PREFIX(_dispatch_stub_273, _dispatch_stub_273@8)) + GL_STUB(_dispatch_stub_274, 274, _dispatch_stub_274@4) + HIDDEN(GL_PREFIX(_dispatch_stub_274, _dispatch_stub_274@4)) + GL_STUB(GetString, 275, GetString@4) + GL_STUB(GetTexEnvfv, 276, GetTexEnvfv@12) + GL_STUB(GetTexEnviv, 277, GetTexEnviv@12) + GL_STUB(_dispatch_stub_278, 278, _dispatch_stub_278@12) + HIDDEN(GL_PREFIX(_dispatch_stub_278, _dispatch_stub_278@12)) + GL_STUB(GetTexGenfvOES, 279, GetTexGenfvOES@12) + GL_STUB(GetTexGenivOES, 280, GetTexGenivOES@12) + GL_STUB(_dispatch_stub_281, 281, _dispatch_stub_281@20) + HIDDEN(GL_PREFIX(_dispatch_stub_281, _dispatch_stub_281@20)) + GL_STUB(GetTexParameterfv, 282, GetTexParameterfv@12) + GL_STUB(GetTexParameteriv, 283, GetTexParameteriv@12) + GL_STUB(_dispatch_stub_284, 284, _dispatch_stub_284@16) + HIDDEN(GL_PREFIX(_dispatch_stub_284, _dispatch_stub_284@16)) + GL_STUB(_dispatch_stub_285, 285, _dispatch_stub_285@16) + HIDDEN(GL_PREFIX(_dispatch_stub_285, _dispatch_stub_285@16)) + GL_STUB(IsEnabled, 286, IsEnabled@4) + GL_STUB(_dispatch_stub_287, 287, _dispatch_stub_287@4) + HIDDEN(GL_PREFIX(_dispatch_stub_287, _dispatch_stub_287@4)) + GL_STUB(_dispatch_stub_288, 288, _dispatch_stub_288@16) + HIDDEN(GL_PREFIX(_dispatch_stub_288, _dispatch_stub_288@16)) + GL_STUB(_dispatch_stub_289, 289, _dispatch_stub_289@48) + HIDDEN(GL_PREFIX(_dispatch_stub_289, _dispatch_stub_289@48)) + GL_STUB(LoadIdentity, 290, LoadIdentity@0) + GL_STUB(LoadMatrixf, 291, LoadMatrixf@4) + GL_STUB(_dispatch_stub_292, 292, _dispatch_stub_292@4) + HIDDEN(GL_PREFIX(_dispatch_stub_292, _dispatch_stub_292@4)) + GL_STUB(MatrixMode, 293, MatrixMode@4) + GL_STUB(MultMatrixf, 294, MultMatrixf@4) + GL_STUB(_dispatch_stub_295, 295, _dispatch_stub_295@4) + HIDDEN(GL_PREFIX(_dispatch_stub_295, _dispatch_stub_295@4)) + GL_STUB(_dispatch_stub_296, 296, _dispatch_stub_296@48) + HIDDEN(GL_PREFIX(_dispatch_stub_296, _dispatch_stub_296@48)) + GL_STUB(PopMatrix, 297, PopMatrix@0) + GL_STUB(PushMatrix, 298, PushMatrix@0) + GL_STUB(_dispatch_stub_299, 299, _dispatch_stub_299@32) + HIDDEN(GL_PREFIX(_dispatch_stub_299, _dispatch_stub_299@32)) + GL_STUB(Rotatef, 300, Rotatef@16) + GL_STUB(_dispatch_stub_301, 301, _dispatch_stub_301@24) + HIDDEN(GL_PREFIX(_dispatch_stub_301, _dispatch_stub_301@24)) + GL_STUB(Scalef, 302, Scalef@12) + GL_STUB(_dispatch_stub_303, 303, _dispatch_stub_303@24) + HIDDEN(GL_PREFIX(_dispatch_stub_303, _dispatch_stub_303@24)) + GL_STUB(Translatef, 304, Translatef@12) + GL_STUB(Viewport, 305, Viewport@16) + GL_STUB(_dispatch_stub_306, 306, _dispatch_stub_306@4) + HIDDEN(GL_PREFIX(_dispatch_stub_306, _dispatch_stub_306@4)) + GL_STUB(BindTexture, 307, BindTexture@8) + GL_STUB(ColorPointer, 308, ColorPointer@16) + GL_STUB(DisableClientState, 309, DisableClientState@4) + GL_STUB(DrawArrays, 310, DrawArrays@12) + GL_STUB(DrawElements, 311, DrawElements@16) + GL_STUB(_dispatch_stub_312, 312, _dispatch_stub_312@8) + HIDDEN(GL_PREFIX(_dispatch_stub_312, _dispatch_stub_312@8)) + GL_STUB(EnableClientState, 313, EnableClientState@4) + GL_STUB(_dispatch_stub_314, 314, _dispatch_stub_314@12) + HIDDEN(GL_PREFIX(_dispatch_stub_314, _dispatch_stub_314@12)) + GL_STUB(_dispatch_stub_315, 315, _dispatch_stub_315@4) + HIDDEN(GL_PREFIX(_dispatch_stub_315, _dispatch_stub_315@4)) + GL_STUB(_dispatch_stub_316, 316, _dispatch_stub_316@4) + HIDDEN(GL_PREFIX(_dispatch_stub_316, _dispatch_stub_316@4)) + GL_STUB(_dispatch_stub_317, 317, _dispatch_stub_317@12) + HIDDEN(GL_PREFIX(_dispatch_stub_317, _dispatch_stub_317@12)) + GL_STUB(NormalPointer, 318, NormalPointer@12) + GL_STUB(PolygonOffset, 319, PolygonOffset@8) + GL_STUB(TexCoordPointer, 320, TexCoordPointer@16) + GL_STUB(VertexPointer, 321, VertexPointer@16) + GL_STUB(_dispatch_stub_322, 322, _dispatch_stub_322@12) + HIDDEN(GL_PREFIX(_dispatch_stub_322, _dispatch_stub_322@12)) + GL_STUB(_dispatch_stub_323, 323, _dispatch_stub_323@28) + HIDDEN(GL_PREFIX(_dispatch_stub_323, _dispatch_stub_323@28)) + GL_STUB(CopyTexImage2D, 324, CopyTexImage2D@32) + GL_STUB(_dispatch_stub_325, 325, _dispatch_stub_325@24) + HIDDEN(GL_PREFIX(_dispatch_stub_325, _dispatch_stub_325@24)) + GL_STUB(CopyTexSubImage2D, 326, CopyTexSubImage2D@32) + GL_STUB(DeleteTextures, 327, DeleteTextures@8) + GL_STUB(GenTextures, 328, GenTextures@8) + GL_STUB(GetPointerv, 329, GetPointerv@8) + GL_STUB(IsTexture, 330, IsTexture@4) + GL_STUB(_dispatch_stub_331, 331, _dispatch_stub_331@12) + HIDDEN(GL_PREFIX(_dispatch_stub_331, _dispatch_stub_331@12)) + GL_STUB(_dispatch_stub_332, 332, _dispatch_stub_332@28) + HIDDEN(GL_PREFIX(_dispatch_stub_332, _dispatch_stub_332@28)) + GL_STUB(TexSubImage2D, 333, TexSubImage2D@36) + GL_STUB(_dispatch_stub_334, 334, _dispatch_stub_334@0) + HIDDEN(GL_PREFIX(_dispatch_stub_334, _dispatch_stub_334@0)) + GL_STUB(_dispatch_stub_335, 335, _dispatch_stub_335@4) + HIDDEN(GL_PREFIX(_dispatch_stub_335, _dispatch_stub_335@4)) + GL_STUB(_dispatch_stub_336, 336, _dispatch_stub_336@16) + HIDDEN(GL_PREFIX(_dispatch_stub_336, _dispatch_stub_336@16)) + GL_STUB(BlendEquationOES, 337, BlendEquationOES@4) + GL_STUB(_dispatch_stub_338, 338, _dispatch_stub_338@24) + HIDDEN(GL_PREFIX(_dispatch_stub_338, _dispatch_stub_338@24)) + GL_STUB(_dispatch_stub_339, 339, _dispatch_stub_339@24) + HIDDEN(GL_PREFIX(_dispatch_stub_339, _dispatch_stub_339@24)) + GL_STUB(_dispatch_stub_340, 340, _dispatch_stub_340@12) + HIDDEN(GL_PREFIX(_dispatch_stub_340, _dispatch_stub_340@12)) + GL_STUB(_dispatch_stub_341, 341, _dispatch_stub_341@12) + HIDDEN(GL_PREFIX(_dispatch_stub_341, _dispatch_stub_341@12)) + GL_STUB(_dispatch_stub_342, 342, _dispatch_stub_342@20) + HIDDEN(GL_PREFIX(_dispatch_stub_342, _dispatch_stub_342@20)) + GL_STUB(_dispatch_stub_343, 343, _dispatch_stub_343@16) + HIDDEN(GL_PREFIX(_dispatch_stub_343, _dispatch_stub_343@16)) + GL_STUB(_dispatch_stub_344, 344, _dispatch_stub_344@12) + HIDDEN(GL_PREFIX(_dispatch_stub_344, _dispatch_stub_344@12)) + GL_STUB(_dispatch_stub_345, 345, _dispatch_stub_345@12) + HIDDEN(GL_PREFIX(_dispatch_stub_345, _dispatch_stub_345@12)) + GL_STUB(_dispatch_stub_346, 346, _dispatch_stub_346@24) + HIDDEN(GL_PREFIX(_dispatch_stub_346, _dispatch_stub_346@24)) + GL_STUB(_dispatch_stub_347, 347, _dispatch_stub_347@20) + HIDDEN(GL_PREFIX(_dispatch_stub_347, _dispatch_stub_347@20)) + GL_STUB(_dispatch_stub_348, 348, _dispatch_stub_348@24) + HIDDEN(GL_PREFIX(_dispatch_stub_348, _dispatch_stub_348@24)) + GL_STUB(_dispatch_stub_349, 349, _dispatch_stub_349@28) + HIDDEN(GL_PREFIX(_dispatch_stub_349, _dispatch_stub_349@28)) + GL_STUB(_dispatch_stub_350, 350, _dispatch_stub_350@12) + HIDDEN(GL_PREFIX(_dispatch_stub_350, _dispatch_stub_350@12)) + GL_STUB(_dispatch_stub_351, 351, _dispatch_stub_351@12) + HIDDEN(GL_PREFIX(_dispatch_stub_351, _dispatch_stub_351@12)) + GL_STUB(_dispatch_stub_352, 352, _dispatch_stub_352@12) + HIDDEN(GL_PREFIX(_dispatch_stub_352, _dispatch_stub_352@12)) + GL_STUB(_dispatch_stub_353, 353, _dispatch_stub_353@12) + HIDDEN(GL_PREFIX(_dispatch_stub_353, _dispatch_stub_353@12)) + GL_STUB(_dispatch_stub_354, 354, _dispatch_stub_354@20) + HIDDEN(GL_PREFIX(_dispatch_stub_354, _dispatch_stub_354@20)) + GL_STUB(_dispatch_stub_355, 355, _dispatch_stub_355@24) + HIDDEN(GL_PREFIX(_dispatch_stub_355, _dispatch_stub_355@24)) + GL_STUB(_dispatch_stub_356, 356, _dispatch_stub_356@16) + HIDDEN(GL_PREFIX(_dispatch_stub_356, _dispatch_stub_356@16)) + GL_STUB(_dispatch_stub_357, 357, _dispatch_stub_357@12) + HIDDEN(GL_PREFIX(_dispatch_stub_357, _dispatch_stub_357@12)) + GL_STUB(_dispatch_stub_358, 358, _dispatch_stub_358@12) + HIDDEN(GL_PREFIX(_dispatch_stub_358, _dispatch_stub_358@12)) + GL_STUB(_dispatch_stub_359, 359, _dispatch_stub_359@24) + HIDDEN(GL_PREFIX(_dispatch_stub_359, _dispatch_stub_359@24)) + GL_STUB(_dispatch_stub_360, 360, _dispatch_stub_360@32) + HIDDEN(GL_PREFIX(_dispatch_stub_360, _dispatch_stub_360@32)) + GL_STUB(_dispatch_stub_361, 361, _dispatch_stub_361@20) + HIDDEN(GL_PREFIX(_dispatch_stub_361, _dispatch_stub_361@20)) + GL_STUB(_dispatch_stub_362, 362, _dispatch_stub_362@12) + HIDDEN(GL_PREFIX(_dispatch_stub_362, _dispatch_stub_362@12)) + GL_STUB(_dispatch_stub_363, 363, _dispatch_stub_363@12) + HIDDEN(GL_PREFIX(_dispatch_stub_363, _dispatch_stub_363@12)) + GL_STUB(_dispatch_stub_364, 364, _dispatch_stub_364@20) + HIDDEN(GL_PREFIX(_dispatch_stub_364, _dispatch_stub_364@20)) + GL_STUB(_dispatch_stub_365, 365, _dispatch_stub_365@12) + HIDDEN(GL_PREFIX(_dispatch_stub_365, _dispatch_stub_365@12)) + GL_STUB(_dispatch_stub_366, 366, _dispatch_stub_366@12) + HIDDEN(GL_PREFIX(_dispatch_stub_366, _dispatch_stub_366@12)) + GL_STUB(_dispatch_stub_367, 367, _dispatch_stub_367@16) + HIDDEN(GL_PREFIX(_dispatch_stub_367, _dispatch_stub_367@16)) + GL_STUB(_dispatch_stub_368, 368, _dispatch_stub_368@12) + HIDDEN(GL_PREFIX(_dispatch_stub_368, _dispatch_stub_368@12)) + GL_STUB(_dispatch_stub_369, 369, _dispatch_stub_369@4) + HIDDEN(GL_PREFIX(_dispatch_stub_369, _dispatch_stub_369@4)) + GL_STUB(_dispatch_stub_370, 370, _dispatch_stub_370@4) + HIDDEN(GL_PREFIX(_dispatch_stub_370, _dispatch_stub_370@4)) + GL_STUB(_dispatch_stub_371, 371, _dispatch_stub_371@40) + HIDDEN(GL_PREFIX(_dispatch_stub_371, _dispatch_stub_371@40)) + GL_STUB(_dispatch_stub_372, 372, _dispatch_stub_372@44) + HIDDEN(GL_PREFIX(_dispatch_stub_372, _dispatch_stub_372@44)) + GL_STUB(_dispatch_stub_373, 373, _dispatch_stub_373@36) + HIDDEN(GL_PREFIX(_dispatch_stub_373, _dispatch_stub_373@36)) + GL_STUB(ActiveTexture, 374, ActiveTexture@4) + GL_STUB(ClientActiveTexture, 375, ClientActiveTexture@4) + GL_STUB(_dispatch_stub_376, 376, _dispatch_stub_376@12) + HIDDEN(GL_PREFIX(_dispatch_stub_376, _dispatch_stub_376@12)) + GL_STUB(_dispatch_stub_377, 377, _dispatch_stub_377@8) + HIDDEN(GL_PREFIX(_dispatch_stub_377, _dispatch_stub_377@8)) + GL_STUB(_dispatch_stub_378, 378, _dispatch_stub_378@8) + HIDDEN(GL_PREFIX(_dispatch_stub_378, _dispatch_stub_378@8)) + GL_STUB(_dispatch_stub_379, 379, _dispatch_stub_379@8) + HIDDEN(GL_PREFIX(_dispatch_stub_379, _dispatch_stub_379@8)) + GL_STUB(_dispatch_stub_380, 380, _dispatch_stub_380@8) + HIDDEN(GL_PREFIX(_dispatch_stub_380, _dispatch_stub_380@8)) + GL_STUB(_dispatch_stub_381, 381, _dispatch_stub_381@8) + HIDDEN(GL_PREFIX(_dispatch_stub_381, _dispatch_stub_381@8)) + GL_STUB(_dispatch_stub_382, 382, _dispatch_stub_382@8) + HIDDEN(GL_PREFIX(_dispatch_stub_382, _dispatch_stub_382@8)) + GL_STUB(_dispatch_stub_383, 383, _dispatch_stub_383@8) + HIDDEN(GL_PREFIX(_dispatch_stub_383, _dispatch_stub_383@8)) + GL_STUB(_dispatch_stub_384, 384, _dispatch_stub_384@20) + HIDDEN(GL_PREFIX(_dispatch_stub_384, _dispatch_stub_384@20)) + GL_STUB(_dispatch_stub_385, 385, _dispatch_stub_385@8) + HIDDEN(GL_PREFIX(_dispatch_stub_385, _dispatch_stub_385@8)) + GL_STUB(_dispatch_stub_386, 386, _dispatch_stub_386@12) + HIDDEN(GL_PREFIX(_dispatch_stub_386, _dispatch_stub_386@12)) + GL_STUB(_dispatch_stub_387, 387, _dispatch_stub_387@8) + HIDDEN(GL_PREFIX(_dispatch_stub_387, _dispatch_stub_387@8)) + GL_STUB(_dispatch_stub_388, 388, _dispatch_stub_388@12) + HIDDEN(GL_PREFIX(_dispatch_stub_388, _dispatch_stub_388@12)) + GL_STUB(_dispatch_stub_389, 389, _dispatch_stub_389@8) + HIDDEN(GL_PREFIX(_dispatch_stub_389, _dispatch_stub_389@8)) + GL_STUB(_dispatch_stub_390, 390, _dispatch_stub_390@12) + HIDDEN(GL_PREFIX(_dispatch_stub_390, _dispatch_stub_390@12)) + GL_STUB(_dispatch_stub_391, 391, _dispatch_stub_391@8) + HIDDEN(GL_PREFIX(_dispatch_stub_391, _dispatch_stub_391@8)) + GL_STUB(_dispatch_stub_392, 392, _dispatch_stub_392@28) + HIDDEN(GL_PREFIX(_dispatch_stub_392, _dispatch_stub_392@28)) + GL_STUB(_dispatch_stub_393, 393, _dispatch_stub_393@8) + HIDDEN(GL_PREFIX(_dispatch_stub_393, _dispatch_stub_393@8)) + GL_STUB(_dispatch_stub_394, 394, _dispatch_stub_394@16) + HIDDEN(GL_PREFIX(_dispatch_stub_394, _dispatch_stub_394@16)) + GL_STUB(_dispatch_stub_395, 395, _dispatch_stub_395@8) + HIDDEN(GL_PREFIX(_dispatch_stub_395, _dispatch_stub_395@8)) + GL_STUB(_dispatch_stub_396, 396, _dispatch_stub_396@16) + HIDDEN(GL_PREFIX(_dispatch_stub_396, _dispatch_stub_396@16)) + GL_STUB(_dispatch_stub_397, 397, _dispatch_stub_397@8) + HIDDEN(GL_PREFIX(_dispatch_stub_397, _dispatch_stub_397@8)) + GL_STUB(_dispatch_stub_398, 398, _dispatch_stub_398@16) + HIDDEN(GL_PREFIX(_dispatch_stub_398, _dispatch_stub_398@16)) + GL_STUB(_dispatch_stub_399, 399, _dispatch_stub_399@8) + HIDDEN(GL_PREFIX(_dispatch_stub_399, _dispatch_stub_399@8)) + GL_STUB(_dispatch_stub_400, 400, _dispatch_stub_400@36) + HIDDEN(GL_PREFIX(_dispatch_stub_400, _dispatch_stub_400@36)) + GL_STUB(_dispatch_stub_401, 401, _dispatch_stub_401@8) + HIDDEN(GL_PREFIX(_dispatch_stub_401, _dispatch_stub_401@8)) + GL_STUB(MultiTexCoord4f, 402, MultiTexCoord4f@20) + GL_STUB(_dispatch_stub_403, 403, _dispatch_stub_403@8) + HIDDEN(GL_PREFIX(_dispatch_stub_403, _dispatch_stub_403@8)) + GL_STUB(_dispatch_stub_404, 404, _dispatch_stub_404@20) + HIDDEN(GL_PREFIX(_dispatch_stub_404, _dispatch_stub_404@20)) + GL_STUB(_dispatch_stub_405, 405, _dispatch_stub_405@8) + HIDDEN(GL_PREFIX(_dispatch_stub_405, _dispatch_stub_405@8)) + GL_STUB(_dispatch_stub_406, 406, _dispatch_stub_406@20) + HIDDEN(GL_PREFIX(_dispatch_stub_406, _dispatch_stub_406@20)) + GL_STUB(_dispatch_stub_407, 407, _dispatch_stub_407@8) + HIDDEN(GL_PREFIX(_dispatch_stub_407, _dispatch_stub_407@8)) + GL_STUB(BlendEquationSeparateOES, 408, BlendEquationSeparateOES@8) + GL_STUB(BlendFuncSeparateOES, 409, BlendFuncSeparateOES@16) + GL_STUB(DrawTexfOES, 410, DrawTexfOES@20) + GL_STUB(DrawTexfvOES, 411, DrawTexfvOES@4) + GL_STUB(DrawTexiOES, 412, DrawTexiOES@20) + GL_STUB(DrawTexivOES, 413, DrawTexivOES@4) + GL_STUB(DrawTexsOES, 414, DrawTexsOES@20) + GL_STUB(DrawTexsvOES, 415, DrawTexsvOES@4) + GL_STUB(DrawTexxOES, 416, DrawTexxOES@20) + GL_STUB(DrawTexxvOES, 417, DrawTexxvOES@4) + GL_STUB(BindFramebufferOES, 418, BindFramebufferOES@8) + GL_STUB(BindRenderbufferOES, 419, BindRenderbufferOES@8) + GL_STUB(CheckFramebufferStatusOES, 420, CheckFramebufferStatusOES@4) + GL_STUB(DeleteFramebuffersOES, 421, DeleteFramebuffersOES@8) + GL_STUB(DeleteRenderbuffersOES, 422, DeleteRenderbuffersOES@8) + GL_STUB(FramebufferRenderbufferOES, 423, FramebufferRenderbufferOES@16) + GL_STUB(FramebufferTexture2DOES, 424, FramebufferTexture2DOES@20) + GL_STUB(GenFramebuffersOES, 425, GenFramebuffersOES@8) + GL_STUB(GenRenderbuffersOES, 426, GenRenderbuffersOES@8) + GL_STUB(GenerateMipmapOES, 427, GenerateMipmapOES@4) + GL_STUB(GetFramebufferAttachmentParameterivOES, 428, GetFramebufferAttachmentParameterivOES@16) + GL_STUB(GetRenderbufferParameterivOES, 429, GetRenderbufferParameterivOES@12) + GL_STUB(IsFramebufferOES, 430, IsFramebufferOES@4) + GL_STUB(IsRenderbufferOES, 431, IsRenderbufferOES@4) + GL_STUB(RenderbufferStorageOES, 432, RenderbufferStorageOES@16) + GL_STUB(PointSizePointerOES, 433, PointSizePointerOES@12) + GL_STUB(QueryMatrixxOES, 434, QueryMatrixxOES@8) + GL_STUB(GetTexGenxvOES, 435, GetTexGenxvOES@12) + GL_STUB(TexGenxOES, 436, TexGenxOES@12) + GL_STUB(TexGenxvOES, 437, TexGenxvOES@12) + GL_STUB(GetBufferPointervOES, 438, GetBufferPointervOES@12) + GL_STUB(MapBufferOES, 439, MapBufferOES@8) + GL_STUB(UnmapBufferOES, 440, UnmapBufferOES@4) + GL_STUB(MultiDrawArraysEXT, 441, MultiDrawArraysEXT@16) + GL_STUB(MultiDrawElementsEXT, 442, MultiDrawElementsEXT@20) + GL_STUB(_dispatch_stub_443, 443, _dispatch_stub_443@4) + HIDDEN(GL_PREFIX(_dispatch_stub_443, _dispatch_stub_443@4)) + GL_STUB(_dispatch_stub_444, 444, _dispatch_stub_444@8) + HIDDEN(GL_PREFIX(_dispatch_stub_444, _dispatch_stub_444@8)) + GL_STUB(_dispatch_stub_445, 445, _dispatch_stub_445@8) + HIDDEN(GL_PREFIX(_dispatch_stub_445, _dispatch_stub_445@8)) + GL_STUB(_dispatch_stub_446, 446, _dispatch_stub_446@4) + HIDDEN(GL_PREFIX(_dispatch_stub_446, _dispatch_stub_446@4)) + GL_STUB(EGLImageTargetRenderbufferStorageOES, 447, EGLImageTargetRenderbufferStorageOES@8) + GL_STUB(EGLImageTargetTexture2DOES, 448, EGLImageTargetTexture2DOES@8) + GL_STUB(CompressedTexImage2D, 449, CompressedTexImage2D@32) + GL_STUB(CompressedTexSubImage2D, 450, CompressedTexSubImage2D@36) + GL_STUB(SampleCoverage, 451, SampleCoverage@8) + GL_STUB(BindBuffer, 452, BindBuffer@8) + GL_STUB(BufferData, 453, BufferData@16) + GL_STUB(BufferSubData, 454, BufferSubData@16) + GL_STUB(DeleteBuffers, 455, DeleteBuffers@8) + GL_STUB(GenBuffers, 456, GenBuffers@8) + GL_STUB(GetBufferParameteriv, 457, GetBufferParameteriv@12) + GL_STUB(IsBuffer, 458, IsBuffer@4) + GL_STUB(PointParameterf, 459, PointParameterf@8) + GL_STUB(PointParameterfv, 460, PointParameterfv@8) + GL_STUB(AlphaFuncx, 461, AlphaFuncx@8) + GL_STUB(ClearColorx, 462, ClearColorx@16) + GL_STUB(ClearDepthf, 463, ClearDepthf@4) + GL_STUB(ClearDepthx, 464, ClearDepthx@4) + GL_STUB(Color4x, 465, Color4x@16) + GL_STUB(DepthRangef, 466, DepthRangef@8) + GL_STUB(DepthRangex, 467, DepthRangex@8) + GL_STUB(Fogx, 468, Fogx@8) + GL_STUB(Fogxv, 469, Fogxv@8) + GL_STUB(Frustumf, 470, Frustumf@24) + GL_STUB(Frustumx, 471, Frustumx@24) + GL_STUB(LightModelx, 472, LightModelx@8) + GL_STUB(LightModelxv, 473, LightModelxv@8) + GL_STUB(Lightx, 474, Lightx@12) + GL_STUB(Lightxv, 475, Lightxv@12) + GL_STUB(LineWidthx, 476, LineWidthx@4) + GL_STUB(LoadMatrixx, 477, LoadMatrixx@4) + GL_STUB(Materialx, 478, Materialx@12) + GL_STUB(Materialxv, 479, Materialxv@12) + GL_STUB(MultMatrixx, 480, MultMatrixx@4) + GL_STUB(MultiTexCoord4x, 481, MultiTexCoord4x@20) + GL_STUB(Normal3x, 482, Normal3x@12) + GL_STUB(Orthof, 483, Orthof@24) + GL_STUB(Orthox, 484, Orthox@24) + GL_STUB(PointSizex, 485, PointSizex@4) + GL_STUB(PolygonOffsetx, 486, PolygonOffsetx@8) + GL_STUB(Rotatex, 487, Rotatex@16) + GL_STUB(SampleCoveragex, 488, SampleCoveragex@8) + GL_STUB(Scalex, 489, Scalex@12) + GL_STUB(TexEnvx, 490, TexEnvx@12) + GL_STUB(TexEnvxv, 491, TexEnvxv@12) + GL_STUB(TexParameterx, 492, TexParameterx@12) + GL_STUB(Translatex, 493, Translatex@12) + GL_STUB(ClipPlanef, 494, ClipPlanef@8) + GL_STUB(ClipPlanex, 495, ClipPlanex@8) + GL_STUB(GetClipPlanef, 496, GetClipPlanef@8) + GL_STUB(GetClipPlanex, 497, GetClipPlanex@8) + GL_STUB(GetFixedv, 498, GetFixedv@8) + GL_STUB(GetLightxv, 499, GetLightxv@12) + GL_STUB(GetMaterialxv, 500, GetMaterialxv@12) + GL_STUB(GetTexEnvxv, 501, GetTexEnvxv@12) + GL_STUB(GetTexParameterxv, 502, GetTexParameterxv@12) + GL_STUB(PointParameterx, 503, PointParameterx@8) + GL_STUB(PointParameterxv, 504, PointParameterxv@8) + GL_STUB(TexParameterxv, 505, TexParameterxv@12) + GL_STUB_ALIAS(AlphaFuncxOES, 461, AlphaFuncxOES@8, AlphaFuncx, AlphaFuncx@8) + GL_STUB_ALIAS(ClearColorxOES, 462, ClearColorxOES@16, ClearColorx, ClearColorx@16) + GL_STUB_ALIAS(ClearDepthfOES, 463, ClearDepthfOES@4, ClearDepthf, ClearDepthf@4) + GL_STUB_ALIAS(ClearDepthxOES, 464, ClearDepthxOES@4, ClearDepthx, ClearDepthx@4) + GL_STUB_ALIAS(Color4xOES, 465, Color4xOES@16, Color4x, Color4x@16) + GL_STUB_ALIAS(DepthRangefOES, 466, DepthRangefOES@8, DepthRangef, DepthRangef@8) + GL_STUB_ALIAS(DepthRangexOES, 467, DepthRangexOES@8, DepthRangex, DepthRangex@8) + GL_STUB_ALIAS(FogxOES, 468, FogxOES@8, Fogx, Fogx@8) + GL_STUB_ALIAS(FogxvOES, 469, FogxvOES@8, Fogxv, Fogxv@8) + GL_STUB_ALIAS(FrustumfOES, 470, FrustumfOES@24, Frustumf, Frustumf@24) + GL_STUB_ALIAS(FrustumxOES, 471, FrustumxOES@24, Frustumx, Frustumx@24) + GL_STUB_ALIAS(LightModelxOES, 472, LightModelxOES@8, LightModelx, LightModelx@8) + GL_STUB_ALIAS(LightModelxvOES, 473, LightModelxvOES@8, LightModelxv, LightModelxv@8) + GL_STUB_ALIAS(LightxOES, 474, LightxOES@12, Lightx, Lightx@12) + GL_STUB_ALIAS(LightxvOES, 475, LightxvOES@12, Lightxv, Lightxv@12) + GL_STUB_ALIAS(LineWidthxOES, 476, LineWidthxOES@4, LineWidthx, LineWidthx@4) + GL_STUB_ALIAS(LoadMatrixxOES, 477, LoadMatrixxOES@4, LoadMatrixx, LoadMatrixx@4) + GL_STUB_ALIAS(MaterialxOES, 478, MaterialxOES@12, Materialx, Materialx@12) + GL_STUB_ALIAS(MaterialxvOES, 479, MaterialxvOES@12, Materialxv, Materialxv@12) + GL_STUB_ALIAS(MultMatrixxOES, 480, MultMatrixxOES@4, MultMatrixx, MultMatrixx@4) + GL_STUB_ALIAS(MultiTexCoord4xOES, 481, MultiTexCoord4xOES@20, MultiTexCoord4x, MultiTexCoord4x@20) + GL_STUB_ALIAS(Normal3xOES, 482, Normal3xOES@12, Normal3x, Normal3x@12) + GL_STUB_ALIAS(OrthofOES, 483, OrthofOES@24, Orthof, Orthof@24) + GL_STUB_ALIAS(OrthoxOES, 484, OrthoxOES@24, Orthox, Orthox@24) + GL_STUB_ALIAS(PointSizexOES, 485, PointSizexOES@4, PointSizex, PointSizex@4) + GL_STUB_ALIAS(PolygonOffsetxOES, 486, PolygonOffsetxOES@8, PolygonOffsetx, PolygonOffsetx@8) + GL_STUB_ALIAS(RotatexOES, 487, RotatexOES@16, Rotatex, Rotatex@16) + GL_STUB_ALIAS(SampleCoveragexOES, 488, SampleCoveragexOES@8, SampleCoveragex, SampleCoveragex@8) + GL_STUB_ALIAS(ScalexOES, 489, ScalexOES@12, Scalex, Scalex@12) + GL_STUB_ALIAS(TexEnvxOES, 490, TexEnvxOES@12, TexEnvx, TexEnvx@12) + GL_STUB_ALIAS(TexEnvxvOES, 491, TexEnvxvOES@12, TexEnvxv, TexEnvxv@12) + GL_STUB_ALIAS(TexParameterxOES, 492, TexParameterxOES@12, TexParameterx, TexParameterx@12) + GL_STUB_ALIAS(TranslatexOES, 493, TranslatexOES@12, Translatex, Translatex@12) + GL_STUB_ALIAS(ClipPlanefOES, 494, ClipPlanefOES@8, ClipPlanef, ClipPlanef@8) + GL_STUB_ALIAS(ClipPlanexOES, 495, ClipPlanexOES@8, ClipPlanex, ClipPlanex@8) + GL_STUB_ALIAS(GetClipPlanefOES, 496, GetClipPlanefOES@8, GetClipPlanef, GetClipPlanef@8) + GL_STUB_ALIAS(GetClipPlanexOES, 497, GetClipPlanexOES@8, GetClipPlanex, GetClipPlanex@8) + GL_STUB_ALIAS(GetFixedvOES, 498, GetFixedvOES@8, GetFixedv, GetFixedv@8) + GL_STUB_ALIAS(GetLightxvOES, 499, GetLightxvOES@12, GetLightxv, GetLightxv@12) + GL_STUB_ALIAS(GetMaterialxvOES, 500, GetMaterialxvOES@12, GetMaterialxv, GetMaterialxv@12) + GL_STUB_ALIAS(GetTexEnvxvOES, 501, GetTexEnvxvOES@12, GetTexEnvxv, GetTexEnvxv@12) + GL_STUB_ALIAS(GetTexParameterxvOES, 502, GetTexParameterxvOES@12, GetTexParameterxv, GetTexParameterxv@12) + GL_STUB_ALIAS(PointParameterxOES, 503, PointParameterxOES@8, PointParameterx, PointParameterx@8) + GL_STUB_ALIAS(PointParameterxvOES, 504, PointParameterxvOES@8, PointParameterxv, PointParameterxv@8) + GL_STUB_ALIAS(TexParameterxvOES, 505, TexParameterxvOES@12, TexParameterxv, TexParameterxv@12) + + GLOBL GLNAME(gl_dispatch_functions_end) + HIDDEN(GLNAME(gl_dispatch_functions_end)) + ALIGNTEXT16 +GLNAME(gl_dispatch_functions_end): + +#if defined(GLX_USE_TLS) && defined(__linux__) + .section ".note.ABI-tag", "a" + .p2align 2 + .long 1f - 0f /* name length */ + .long 3f - 2f /* data length */ + .long 1 /* note length */ +0: .asciz "GNU" /* vendor name */ +1: .p2align 2 +2: .long 0 /* note data: the ABI tag */ + .long 2,4,20 /* Minimum kernel version w/TLS */ +3: .p2align 2 /* pad out section */ +#endif /* GLX_USE_TLS */ + +#if defined (__ELF__) && defined (__linux__) + .section .note.GNU-stack,"",%progbits +#endif diff --git a/src/mapi/es1api/glapi/glapitable.h b/src/mapi/es1api/glapi/glapitable.h new file mode 100644 index 00000000000..ea3f519484c --- /dev/null +++ b/src/mapi/es1api/glapi/glapitable.h @@ -0,0 +1,551 @@ +/* DO NOT EDIT - This file generated automatically by gl_table.py (from Mesa) script */ + +/* + * Copyright (C) 1999-2003 Brian Paul All Rights Reserved. + * (C) Copyright IBM Corporation 2004 + * All Rights Reserved. + * + * Permission is hereby granted, free of charge, to any person obtaining a + * copy of this software and associated documentation files (the "Software"), + * to deal in the Software without restriction, including without limitation + * the rights to use, copy, modify, merge, publish, distribute, sub license, + * and/or sell copies of the Software, and to permit persons to whom the + * Software is furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice (including the next + * paragraph) shall be included in all copies or substantial portions of the + * Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL + * BRIAN PAUL, IBM, + * AND/OR THEIR SUPPLIERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, + * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF + * OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE + * SOFTWARE. + */ + +#if !defined( _GLAPI_TABLE_H_ ) +# define _GLAPI_TABLE_H_ + +#ifndef GLAPIENTRYP +# ifndef GLAPIENTRY +# define GLAPIENTRY +# endif + +# define GLAPIENTRYP GLAPIENTRY * +#endif + + +struct _glapi_table +{ + void (GLAPIENTRYP NewList)(GLuint list, GLenum mode); /* 0 */ + void (GLAPIENTRYP EndList)(void); /* 1 */ + void (GLAPIENTRYP CallList)(GLuint list); /* 2 */ + void (GLAPIENTRYP CallLists)(GLsizei n, GLenum type, const GLvoid * lists); /* 3 */ + void (GLAPIENTRYP DeleteLists)(GLuint list, GLsizei range); /* 4 */ + GLuint (GLAPIENTRYP GenLists)(GLsizei range); /* 5 */ + void (GLAPIENTRYP ListBase)(GLuint base); /* 6 */ + void (GLAPIENTRYP Begin)(GLenum mode); /* 7 */ + void (GLAPIENTRYP Bitmap)(GLsizei width, GLsizei height, GLfloat xorig, GLfloat yorig, GLfloat xmove, GLfloat ymove, const GLubyte * bitmap); /* 8 */ + void (GLAPIENTRYP Color3b)(GLbyte red, GLbyte green, GLbyte blue); /* 9 */ + void (GLAPIENTRYP Color3bv)(const GLbyte * v); /* 10 */ + void (GLAPIENTRYP Color3d)(GLdouble red, GLdouble green, GLdouble blue); /* 11 */ + void (GLAPIENTRYP Color3dv)(const GLdouble * v); /* 12 */ + void (GLAPIENTRYP Color3f)(GLfloat red, GLfloat green, GLfloat blue); /* 13 */ + void (GLAPIENTRYP Color3fv)(const GLfloat * v); /* 14 */ + void (GLAPIENTRYP Color3i)(GLint red, GLint green, GLint blue); /* 15 */ + void (GLAPIENTRYP Color3iv)(const GLint * v); /* 16 */ + void (GLAPIENTRYP Color3s)(GLshort red, GLshort green, GLshort blue); /* 17 */ + void (GLAPIENTRYP Color3sv)(const GLshort * v); /* 18 */ + void (GLAPIENTRYP Color3ub)(GLubyte red, GLubyte green, GLubyte blue); /* 19 */ + void (GLAPIENTRYP Color3ubv)(const GLubyte * v); /* 20 */ + void (GLAPIENTRYP Color3ui)(GLuint red, GLuint green, GLuint blue); /* 21 */ + void (GLAPIENTRYP Color3uiv)(const GLuint * v); /* 22 */ + void (GLAPIENTRYP Color3us)(GLushort red, GLushort green, GLushort blue); /* 23 */ + void (GLAPIENTRYP Color3usv)(const GLushort * v); /* 24 */ + void (GLAPIENTRYP Color4b)(GLbyte red, GLbyte green, GLbyte blue, GLbyte alpha); /* 25 */ + void (GLAPIENTRYP Color4bv)(const GLbyte * v); /* 26 */ + void (GLAPIENTRYP Color4d)(GLdouble red, GLdouble green, GLdouble blue, GLdouble alpha); /* 27 */ + void (GLAPIENTRYP Color4dv)(const GLdouble * v); /* 28 */ + void (GLAPIENTRYP Color4f)(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha); /* 29 */ + void (GLAPIENTRYP Color4fv)(const GLfloat * v); /* 30 */ + void (GLAPIENTRYP Color4i)(GLint red, GLint green, GLint blue, GLint alpha); /* 31 */ + void (GLAPIENTRYP Color4iv)(const GLint * v); /* 32 */ + void (GLAPIENTRYP Color4s)(GLshort red, GLshort green, GLshort blue, GLshort alpha); /* 33 */ + void (GLAPIENTRYP Color4sv)(const GLshort * v); /* 34 */ + void (GLAPIENTRYP Color4ub)(GLubyte red, GLubyte green, GLubyte blue, GLubyte alpha); /* 35 */ + void (GLAPIENTRYP Color4ubv)(const GLubyte * v); /* 36 */ + void (GLAPIENTRYP Color4ui)(GLuint red, GLuint green, GLuint blue, GLuint alpha); /* 37 */ + void (GLAPIENTRYP Color4uiv)(const GLuint * v); /* 38 */ + void (GLAPIENTRYP Color4us)(GLushort red, GLushort green, GLushort blue, GLushort alpha); /* 39 */ + void (GLAPIENTRYP Color4usv)(const GLushort * v); /* 40 */ + void (GLAPIENTRYP EdgeFlag)(GLboolean flag); /* 41 */ + void (GLAPIENTRYP EdgeFlagv)(const GLboolean * flag); /* 42 */ + void (GLAPIENTRYP End)(void); /* 43 */ + void (GLAPIENTRYP Indexd)(GLdouble c); /* 44 */ + void (GLAPIENTRYP Indexdv)(const GLdouble * c); /* 45 */ + void (GLAPIENTRYP Indexf)(GLfloat c); /* 46 */ + void (GLAPIENTRYP Indexfv)(const GLfloat * c); /* 47 */ + void (GLAPIENTRYP Indexi)(GLint c); /* 48 */ + void (GLAPIENTRYP Indexiv)(const GLint * c); /* 49 */ + void (GLAPIENTRYP Indexs)(GLshort c); /* 50 */ + void (GLAPIENTRYP Indexsv)(const GLshort * c); /* 51 */ + void (GLAPIENTRYP Normal3b)(GLbyte nx, GLbyte ny, GLbyte nz); /* 52 */ + void (GLAPIENTRYP Normal3bv)(const GLbyte * v); /* 53 */ + void (GLAPIENTRYP Normal3d)(GLdouble nx, GLdouble ny, GLdouble nz); /* 54 */ + void (GLAPIENTRYP Normal3dv)(const GLdouble * v); /* 55 */ + void (GLAPIENTRYP Normal3f)(GLfloat nx, GLfloat ny, GLfloat nz); /* 56 */ + void (GLAPIENTRYP Normal3fv)(const GLfloat * v); /* 57 */ + void (GLAPIENTRYP Normal3i)(GLint nx, GLint ny, GLint nz); /* 58 */ + void (GLAPIENTRYP Normal3iv)(const GLint * v); /* 59 */ + void (GLAPIENTRYP Normal3s)(GLshort nx, GLshort ny, GLshort nz); /* 60 */ + void (GLAPIENTRYP Normal3sv)(const GLshort * v); /* 61 */ + void (GLAPIENTRYP RasterPos2d)(GLdouble x, GLdouble y); /* 62 */ + void (GLAPIENTRYP RasterPos2dv)(const GLdouble * v); /* 63 */ + void (GLAPIENTRYP RasterPos2f)(GLfloat x, GLfloat y); /* 64 */ + void (GLAPIENTRYP RasterPos2fv)(const GLfloat * v); /* 65 */ + void (GLAPIENTRYP RasterPos2i)(GLint x, GLint y); /* 66 */ + void (GLAPIENTRYP RasterPos2iv)(const GLint * v); /* 67 */ + void (GLAPIENTRYP RasterPos2s)(GLshort x, GLshort y); /* 68 */ + void (GLAPIENTRYP RasterPos2sv)(const GLshort * v); /* 69 */ + void (GLAPIENTRYP RasterPos3d)(GLdouble x, GLdouble y, GLdouble z); /* 70 */ + void (GLAPIENTRYP RasterPos3dv)(const GLdouble * v); /* 71 */ + void (GLAPIENTRYP RasterPos3f)(GLfloat x, GLfloat y, GLfloat z); /* 72 */ + void (GLAPIENTRYP RasterPos3fv)(const GLfloat * v); /* 73 */ + void (GLAPIENTRYP RasterPos3i)(GLint x, GLint y, GLint z); /* 74 */ + void (GLAPIENTRYP RasterPos3iv)(const GLint * v); /* 75 */ + void (GLAPIENTRYP RasterPos3s)(GLshort x, GLshort y, GLshort z); /* 76 */ + void (GLAPIENTRYP RasterPos3sv)(const GLshort * v); /* 77 */ + void (GLAPIENTRYP RasterPos4d)(GLdouble x, GLdouble y, GLdouble z, GLdouble w); /* 78 */ + void (GLAPIENTRYP RasterPos4dv)(const GLdouble * v); /* 79 */ + void (GLAPIENTRYP RasterPos4f)(GLfloat x, GLfloat y, GLfloat z, GLfloat w); /* 80 */ + void (GLAPIENTRYP RasterPos4fv)(const GLfloat * v); /* 81 */ + void (GLAPIENTRYP RasterPos4i)(GLint x, GLint y, GLint z, GLint w); /* 82 */ + void (GLAPIENTRYP RasterPos4iv)(const GLint * v); /* 83 */ + void (GLAPIENTRYP RasterPos4s)(GLshort x, GLshort y, GLshort z, GLshort w); /* 84 */ + void (GLAPIENTRYP RasterPos4sv)(const GLshort * v); /* 85 */ + void (GLAPIENTRYP Rectd)(GLdouble x1, GLdouble y1, GLdouble x2, GLdouble y2); /* 86 */ + void (GLAPIENTRYP Rectdv)(const GLdouble * v1, const GLdouble * v2); /* 87 */ + void (GLAPIENTRYP Rectf)(GLfloat x1, GLfloat y1, GLfloat x2, GLfloat y2); /* 88 */ + void (GLAPIENTRYP Rectfv)(const GLfloat * v1, const GLfloat * v2); /* 89 */ + void (GLAPIENTRYP Recti)(GLint x1, GLint y1, GLint x2, GLint y2); /* 90 */ + void (GLAPIENTRYP Rectiv)(const GLint * v1, const GLint * v2); /* 91 */ + void (GLAPIENTRYP Rects)(GLshort x1, GLshort y1, GLshort x2, GLshort y2); /* 92 */ + void (GLAPIENTRYP Rectsv)(const GLshort * v1, const GLshort * v2); /* 93 */ + void (GLAPIENTRYP TexCoord1d)(GLdouble s); /* 94 */ + void (GLAPIENTRYP TexCoord1dv)(const GLdouble * v); /* 95 */ + void (GLAPIENTRYP TexCoord1f)(GLfloat s); /* 96 */ + void (GLAPIENTRYP TexCoord1fv)(const GLfloat * v); /* 97 */ + void (GLAPIENTRYP TexCoord1i)(GLint s); /* 98 */ + void (GLAPIENTRYP TexCoord1iv)(const GLint * v); /* 99 */ + void (GLAPIENTRYP TexCoord1s)(GLshort s); /* 100 */ + void (GLAPIENTRYP TexCoord1sv)(const GLshort * v); /* 101 */ + void (GLAPIENTRYP TexCoord2d)(GLdouble s, GLdouble t); /* 102 */ + void (GLAPIENTRYP TexCoord2dv)(const GLdouble * v); /* 103 */ + void (GLAPIENTRYP TexCoord2f)(GLfloat s, GLfloat t); /* 104 */ + void (GLAPIENTRYP TexCoord2fv)(const GLfloat * v); /* 105 */ + void (GLAPIENTRYP TexCoord2i)(GLint s, GLint t); /* 106 */ + void (GLAPIENTRYP TexCoord2iv)(const GLint * v); /* 107 */ + void (GLAPIENTRYP TexCoord2s)(GLshort s, GLshort t); /* 108 */ + void (GLAPIENTRYP TexCoord2sv)(const GLshort * v); /* 109 */ + void (GLAPIENTRYP TexCoord3d)(GLdouble s, GLdouble t, GLdouble r); /* 110 */ + void (GLAPIENTRYP TexCoord3dv)(const GLdouble * v); /* 111 */ + void (GLAPIENTRYP TexCoord3f)(GLfloat s, GLfloat t, GLfloat r); /* 112 */ + void (GLAPIENTRYP TexCoord3fv)(const GLfloat * v); /* 113 */ + void (GLAPIENTRYP TexCoord3i)(GLint s, GLint t, GLint r); /* 114 */ + void (GLAPIENTRYP TexCoord3iv)(const GLint * v); /* 115 */ + void (GLAPIENTRYP TexCoord3s)(GLshort s, GLshort t, GLshort r); /* 116 */ + void (GLAPIENTRYP TexCoord3sv)(const GLshort * v); /* 117 */ + void (GLAPIENTRYP TexCoord4d)(GLdouble s, GLdouble t, GLdouble r, GLdouble q); /* 118 */ + void (GLAPIENTRYP TexCoord4dv)(const GLdouble * v); /* 119 */ + void (GLAPIENTRYP TexCoord4f)(GLfloat s, GLfloat t, GLfloat r, GLfloat q); /* 120 */ + void (GLAPIENTRYP TexCoord4fv)(const GLfloat * v); /* 121 */ + void (GLAPIENTRYP TexCoord4i)(GLint s, GLint t, GLint r, GLint q); /* 122 */ + void (GLAPIENTRYP TexCoord4iv)(const GLint * v); /* 123 */ + void (GLAPIENTRYP TexCoord4s)(GLshort s, GLshort t, GLshort r, GLshort q); /* 124 */ + void (GLAPIENTRYP TexCoord4sv)(const GLshort * v); /* 125 */ + void (GLAPIENTRYP Vertex2d)(GLdouble x, GLdouble y); /* 126 */ + void (GLAPIENTRYP Vertex2dv)(const GLdouble * v); /* 127 */ + void (GLAPIENTRYP Vertex2f)(GLfloat x, GLfloat y); /* 128 */ + void (GLAPIENTRYP Vertex2fv)(const GLfloat * v); /* 129 */ + void (GLAPIENTRYP Vertex2i)(GLint x, GLint y); /* 130 */ + void (GLAPIENTRYP Vertex2iv)(const GLint * v); /* 131 */ + void (GLAPIENTRYP Vertex2s)(GLshort x, GLshort y); /* 132 */ + void (GLAPIENTRYP Vertex2sv)(const GLshort * v); /* 133 */ + void (GLAPIENTRYP Vertex3d)(GLdouble x, GLdouble y, GLdouble z); /* 134 */ + void (GLAPIENTRYP Vertex3dv)(const GLdouble * v); /* 135 */ + void (GLAPIENTRYP Vertex3f)(GLfloat x, GLfloat y, GLfloat z); /* 136 */ + void (GLAPIENTRYP Vertex3fv)(const GLfloat * v); /* 137 */ + void (GLAPIENTRYP Vertex3i)(GLint x, GLint y, GLint z); /* 138 */ + void (GLAPIENTRYP Vertex3iv)(const GLint * v); /* 139 */ + void (GLAPIENTRYP Vertex3s)(GLshort x, GLshort y, GLshort z); /* 140 */ + void (GLAPIENTRYP Vertex3sv)(const GLshort * v); /* 141 */ + void (GLAPIENTRYP Vertex4d)(GLdouble x, GLdouble y, GLdouble z, GLdouble w); /* 142 */ + void (GLAPIENTRYP Vertex4dv)(const GLdouble * v); /* 143 */ + void (GLAPIENTRYP Vertex4f)(GLfloat x, GLfloat y, GLfloat z, GLfloat w); /* 144 */ + void (GLAPIENTRYP Vertex4fv)(const GLfloat * v); /* 145 */ + void (GLAPIENTRYP Vertex4i)(GLint x, GLint y, GLint z, GLint w); /* 146 */ + void (GLAPIENTRYP Vertex4iv)(const GLint * v); /* 147 */ + void (GLAPIENTRYP Vertex4s)(GLshort x, GLshort y, GLshort z, GLshort w); /* 148 */ + void (GLAPIENTRYP Vertex4sv)(const GLshort * v); /* 149 */ + void (GLAPIENTRYP ClipPlane)(GLenum plane, const GLdouble * equation); /* 150 */ + void (GLAPIENTRYP ColorMaterial)(GLenum face, GLenum mode); /* 151 */ + void (GLAPIENTRYP CullFace)(GLenum mode); /* 152 */ + void (GLAPIENTRYP Fogf)(GLenum pname, GLfloat param); /* 153 */ + void (GLAPIENTRYP Fogfv)(GLenum pname, const GLfloat * params); /* 154 */ + void (GLAPIENTRYP Fogi)(GLenum pname, GLint param); /* 155 */ + void (GLAPIENTRYP Fogiv)(GLenum pname, const GLint * params); /* 156 */ + void (GLAPIENTRYP FrontFace)(GLenum mode); /* 157 */ + void (GLAPIENTRYP Hint)(GLenum target, GLenum mode); /* 158 */ + void (GLAPIENTRYP Lightf)(GLenum light, GLenum pname, GLfloat param); /* 159 */ + void (GLAPIENTRYP Lightfv)(GLenum light, GLenum pname, const GLfloat * params); /* 160 */ + void (GLAPIENTRYP Lighti)(GLenum light, GLenum pname, GLint param); /* 161 */ + void (GLAPIENTRYP Lightiv)(GLenum light, GLenum pname, const GLint * params); /* 162 */ + void (GLAPIENTRYP LightModelf)(GLenum pname, GLfloat param); /* 163 */ + void (GLAPIENTRYP LightModelfv)(GLenum pname, const GLfloat * params); /* 164 */ + void (GLAPIENTRYP LightModeli)(GLenum pname, GLint param); /* 165 */ + void (GLAPIENTRYP LightModeliv)(GLenum pname, const GLint * params); /* 166 */ + void (GLAPIENTRYP LineStipple)(GLint factor, GLushort pattern); /* 167 */ + void (GLAPIENTRYP LineWidth)(GLfloat width); /* 168 */ + void (GLAPIENTRYP Materialf)(GLenum face, GLenum pname, GLfloat param); /* 169 */ + void (GLAPIENTRYP Materialfv)(GLenum face, GLenum pname, const GLfloat * params); /* 170 */ + void (GLAPIENTRYP Materiali)(GLenum face, GLenum pname, GLint param); /* 171 */ + void (GLAPIENTRYP Materialiv)(GLenum face, GLenum pname, const GLint * params); /* 172 */ + void (GLAPIENTRYP PointSize)(GLfloat size); /* 173 */ + void (GLAPIENTRYP PolygonMode)(GLenum face, GLenum mode); /* 174 */ + void (GLAPIENTRYP PolygonStipple)(const GLubyte * mask); /* 175 */ + void (GLAPIENTRYP Scissor)(GLint x, GLint y, GLsizei width, GLsizei height); /* 176 */ + void (GLAPIENTRYP ShadeModel)(GLenum mode); /* 177 */ + void (GLAPIENTRYP TexParameterf)(GLenum target, GLenum pname, GLfloat param); /* 178 */ + void (GLAPIENTRYP TexParameterfv)(GLenum target, GLenum pname, const GLfloat * params); /* 179 */ + void (GLAPIENTRYP TexParameteri)(GLenum target, GLenum pname, GLint param); /* 180 */ + void (GLAPIENTRYP TexParameteriv)(GLenum target, GLenum pname, const GLint * params); /* 181 */ + void (GLAPIENTRYP TexImage1D)(GLenum target, GLint level, GLint internalformat, GLsizei width, GLint border, GLenum format, GLenum type, const GLvoid * pixels); /* 182 */ + void (GLAPIENTRYP TexImage2D)(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const GLvoid * pixels); /* 183 */ + void (GLAPIENTRYP TexEnvf)(GLenum target, GLenum pname, GLfloat param); /* 184 */ + void (GLAPIENTRYP TexEnvfv)(GLenum target, GLenum pname, const GLfloat * params); /* 185 */ + void (GLAPIENTRYP TexEnvi)(GLenum target, GLenum pname, GLint param); /* 186 */ + void (GLAPIENTRYP TexEnviv)(GLenum target, GLenum pname, const GLint * params); /* 187 */ + void (GLAPIENTRYP TexGend)(GLenum coord, GLenum pname, GLdouble param); /* 188 */ + void (GLAPIENTRYP TexGendv)(GLenum coord, GLenum pname, const GLdouble * params); /* 189 */ + void (GLAPIENTRYP TexGenfOES)(GLenum coord, GLenum pname, GLfloat param); /* 190 */ + void (GLAPIENTRYP TexGenfvOES)(GLenum coord, GLenum pname, const GLfloat * params); /* 191 */ + void (GLAPIENTRYP TexGeniOES)(GLenum coord, GLenum pname, GLint param); /* 192 */ + void (GLAPIENTRYP TexGenivOES)(GLenum coord, GLenum pname, const GLint * params); /* 193 */ + void (GLAPIENTRYP FeedbackBuffer)(GLsizei size, GLenum type, GLfloat * buffer); /* 194 */ + void (GLAPIENTRYP SelectBuffer)(GLsizei size, GLuint * buffer); /* 195 */ + GLint (GLAPIENTRYP RenderMode)(GLenum mode); /* 196 */ + void (GLAPIENTRYP InitNames)(void); /* 197 */ + void (GLAPIENTRYP LoadName)(GLuint name); /* 198 */ + void (GLAPIENTRYP PassThrough)(GLfloat token); /* 199 */ + void (GLAPIENTRYP PopName)(void); /* 200 */ + void (GLAPIENTRYP PushName)(GLuint name); /* 201 */ + void (GLAPIENTRYP DrawBuffer)(GLenum mode); /* 202 */ + void (GLAPIENTRYP Clear)(GLbitfield mask); /* 203 */ + void (GLAPIENTRYP ClearAccum)(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha); /* 204 */ + void (GLAPIENTRYP ClearIndex)(GLfloat c); /* 205 */ + void (GLAPIENTRYP ClearColor)(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha); /* 206 */ + void (GLAPIENTRYP ClearStencil)(GLint s); /* 207 */ + void (GLAPIENTRYP ClearDepth)(GLclampd depth); /* 208 */ + void (GLAPIENTRYP StencilMask)(GLuint mask); /* 209 */ + void (GLAPIENTRYP ColorMask)(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha); /* 210 */ + void (GLAPIENTRYP DepthMask)(GLboolean flag); /* 211 */ + void (GLAPIENTRYP IndexMask)(GLuint mask); /* 212 */ + void (GLAPIENTRYP Accum)(GLenum op, GLfloat value); /* 213 */ + void (GLAPIENTRYP Disable)(GLenum cap); /* 214 */ + void (GLAPIENTRYP Enable)(GLenum cap); /* 215 */ + void (GLAPIENTRYP Finish)(void); /* 216 */ + void (GLAPIENTRYP Flush)(void); /* 217 */ + void (GLAPIENTRYP PopAttrib)(void); /* 218 */ + void (GLAPIENTRYP PushAttrib)(GLbitfield mask); /* 219 */ + void (GLAPIENTRYP Map1d)(GLenum target, GLdouble u1, GLdouble u2, GLint stride, GLint order, const GLdouble * points); /* 220 */ + void (GLAPIENTRYP Map1f)(GLenum target, GLfloat u1, GLfloat u2, GLint stride, GLint order, const GLfloat * points); /* 221 */ + void (GLAPIENTRYP Map2d)(GLenum target, GLdouble u1, GLdouble u2, GLint ustride, GLint uorder, GLdouble v1, GLdouble v2, GLint vstride, GLint vorder, const GLdouble * points); /* 222 */ + void (GLAPIENTRYP Map2f)(GLenum target, GLfloat u1, GLfloat u2, GLint ustride, GLint uorder, GLfloat v1, GLfloat v2, GLint vstride, GLint vorder, const GLfloat * points); /* 223 */ + void (GLAPIENTRYP MapGrid1d)(GLint un, GLdouble u1, GLdouble u2); /* 224 */ + void (GLAPIENTRYP MapGrid1f)(GLint un, GLfloat u1, GLfloat u2); /* 225 */ + void (GLAPIENTRYP MapGrid2d)(GLint un, GLdouble u1, GLdouble u2, GLint vn, GLdouble v1, GLdouble v2); /* 226 */ + void (GLAPIENTRYP MapGrid2f)(GLint un, GLfloat u1, GLfloat u2, GLint vn, GLfloat v1, GLfloat v2); /* 227 */ + void (GLAPIENTRYP EvalCoord1d)(GLdouble u); /* 228 */ + void (GLAPIENTRYP EvalCoord1dv)(const GLdouble * u); /* 229 */ + void (GLAPIENTRYP EvalCoord1f)(GLfloat u); /* 230 */ + void (GLAPIENTRYP EvalCoord1fv)(const GLfloat * u); /* 231 */ + void (GLAPIENTRYP EvalCoord2d)(GLdouble u, GLdouble v); /* 232 */ + void (GLAPIENTRYP EvalCoord2dv)(const GLdouble * u); /* 233 */ + void (GLAPIENTRYP EvalCoord2f)(GLfloat u, GLfloat v); /* 234 */ + void (GLAPIENTRYP EvalCoord2fv)(const GLfloat * u); /* 235 */ + void (GLAPIENTRYP EvalMesh1)(GLenum mode, GLint i1, GLint i2); /* 236 */ + void (GLAPIENTRYP EvalPoint1)(GLint i); /* 237 */ + void (GLAPIENTRYP EvalMesh2)(GLenum mode, GLint i1, GLint i2, GLint j1, GLint j2); /* 238 */ + void (GLAPIENTRYP EvalPoint2)(GLint i, GLint j); /* 239 */ + void (GLAPIENTRYP AlphaFunc)(GLenum func, GLclampf ref); /* 240 */ + void (GLAPIENTRYP BlendFunc)(GLenum sfactor, GLenum dfactor); /* 241 */ + void (GLAPIENTRYP LogicOp)(GLenum opcode); /* 242 */ + void (GLAPIENTRYP StencilFunc)(GLenum func, GLint ref, GLuint mask); /* 243 */ + void (GLAPIENTRYP StencilOp)(GLenum fail, GLenum zfail, GLenum zpass); /* 244 */ + void (GLAPIENTRYP DepthFunc)(GLenum func); /* 245 */ + void (GLAPIENTRYP PixelZoom)(GLfloat xfactor, GLfloat yfactor); /* 246 */ + void (GLAPIENTRYP PixelTransferf)(GLenum pname, GLfloat param); /* 247 */ + void (GLAPIENTRYP PixelTransferi)(GLenum pname, GLint param); /* 248 */ + void (GLAPIENTRYP PixelStoref)(GLenum pname, GLfloat param); /* 249 */ + void (GLAPIENTRYP PixelStorei)(GLenum pname, GLint param); /* 250 */ + void (GLAPIENTRYP PixelMapfv)(GLenum map, GLsizei mapsize, const GLfloat * values); /* 251 */ + void (GLAPIENTRYP PixelMapuiv)(GLenum map, GLsizei mapsize, const GLuint * values); /* 252 */ + void (GLAPIENTRYP PixelMapusv)(GLenum map, GLsizei mapsize, const GLushort * values); /* 253 */ + void (GLAPIENTRYP ReadBuffer)(GLenum mode); /* 254 */ + void (GLAPIENTRYP CopyPixels)(GLint x, GLint y, GLsizei width, GLsizei height, GLenum type); /* 255 */ + void (GLAPIENTRYP ReadPixels)(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLvoid * pixels); /* 256 */ + void (GLAPIENTRYP DrawPixels)(GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid * pixels); /* 257 */ + void (GLAPIENTRYP GetBooleanv)(GLenum pname, GLboolean * params); /* 258 */ + void (GLAPIENTRYP GetClipPlane)(GLenum plane, GLdouble * equation); /* 259 */ + void (GLAPIENTRYP GetDoublev)(GLenum pname, GLdouble * params); /* 260 */ + GLenum (GLAPIENTRYP GetError)(void); /* 261 */ + void (GLAPIENTRYP GetFloatv)(GLenum pname, GLfloat * params); /* 262 */ + void (GLAPIENTRYP GetIntegerv)(GLenum pname, GLint * params); /* 263 */ + void (GLAPIENTRYP GetLightfv)(GLenum light, GLenum pname, GLfloat * params); /* 264 */ + void (GLAPIENTRYP GetLightiv)(GLenum light, GLenum pname, GLint * params); /* 265 */ + void (GLAPIENTRYP GetMapdv)(GLenum target, GLenum query, GLdouble * v); /* 266 */ + void (GLAPIENTRYP GetMapfv)(GLenum target, GLenum query, GLfloat * v); /* 267 */ + void (GLAPIENTRYP GetMapiv)(GLenum target, GLenum query, GLint * v); /* 268 */ + void (GLAPIENTRYP GetMaterialfv)(GLenum face, GLenum pname, GLfloat * params); /* 269 */ + void (GLAPIENTRYP GetMaterialiv)(GLenum face, GLenum pname, GLint * params); /* 270 */ + void (GLAPIENTRYP GetPixelMapfv)(GLenum map, GLfloat * values); /* 271 */ + void (GLAPIENTRYP GetPixelMapuiv)(GLenum map, GLuint * values); /* 272 */ + void (GLAPIENTRYP GetPixelMapusv)(GLenum map, GLushort * values); /* 273 */ + void (GLAPIENTRYP GetPolygonStipple)(GLubyte * mask); /* 274 */ + const GLubyte * (GLAPIENTRYP GetString)(GLenum name); /* 275 */ + void (GLAPIENTRYP GetTexEnvfv)(GLenum target, GLenum pname, GLfloat * params); /* 276 */ + void (GLAPIENTRYP GetTexEnviv)(GLenum target, GLenum pname, GLint * params); /* 277 */ + void (GLAPIENTRYP GetTexGendv)(GLenum coord, GLenum pname, GLdouble * params); /* 278 */ + void (GLAPIENTRYP GetTexGenfvOES)(GLenum coord, GLenum pname, GLfloat * params); /* 279 */ + void (GLAPIENTRYP GetTexGenivOES)(GLenum coord, GLenum pname, GLint * params); /* 280 */ + void (GLAPIENTRYP GetTexImage)(GLenum target, GLint level, GLenum format, GLenum type, GLvoid * pixels); /* 281 */ + void (GLAPIENTRYP GetTexParameterfv)(GLenum target, GLenum pname, GLfloat * params); /* 282 */ + void (GLAPIENTRYP GetTexParameteriv)(GLenum target, GLenum pname, GLint * params); /* 283 */ + void (GLAPIENTRYP GetTexLevelParameterfv)(GLenum target, GLint level, GLenum pname, GLfloat * params); /* 284 */ + void (GLAPIENTRYP GetTexLevelParameteriv)(GLenum target, GLint level, GLenum pname, GLint * params); /* 285 */ + GLboolean (GLAPIENTRYP IsEnabled)(GLenum cap); /* 286 */ + GLboolean (GLAPIENTRYP IsList)(GLuint list); /* 287 */ + void (GLAPIENTRYP DepthRange)(GLclampd zNear, GLclampd zFar); /* 288 */ + void (GLAPIENTRYP Frustum)(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar); /* 289 */ + void (GLAPIENTRYP LoadIdentity)(void); /* 290 */ + void (GLAPIENTRYP LoadMatrixf)(const GLfloat * m); /* 291 */ + void (GLAPIENTRYP LoadMatrixd)(const GLdouble * m); /* 292 */ + void (GLAPIENTRYP MatrixMode)(GLenum mode); /* 293 */ + void (GLAPIENTRYP MultMatrixf)(const GLfloat * m); /* 294 */ + void (GLAPIENTRYP MultMatrixd)(const GLdouble * m); /* 295 */ + void (GLAPIENTRYP Ortho)(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar); /* 296 */ + void (GLAPIENTRYP PopMatrix)(void); /* 297 */ + void (GLAPIENTRYP PushMatrix)(void); /* 298 */ + void (GLAPIENTRYP Rotated)(GLdouble angle, GLdouble x, GLdouble y, GLdouble z); /* 299 */ + void (GLAPIENTRYP Rotatef)(GLfloat angle, GLfloat x, GLfloat y, GLfloat z); /* 300 */ + void (GLAPIENTRYP Scaled)(GLdouble x, GLdouble y, GLdouble z); /* 301 */ + void (GLAPIENTRYP Scalef)(GLfloat x, GLfloat y, GLfloat z); /* 302 */ + void (GLAPIENTRYP Translated)(GLdouble x, GLdouble y, GLdouble z); /* 303 */ + void (GLAPIENTRYP Translatef)(GLfloat x, GLfloat y, GLfloat z); /* 304 */ + void (GLAPIENTRYP Viewport)(GLint x, GLint y, GLsizei width, GLsizei height); /* 305 */ + void (GLAPIENTRYP ArrayElement)(GLint i); /* 306 */ + void (GLAPIENTRYP BindTexture)(GLenum target, GLuint texture); /* 307 */ + void (GLAPIENTRYP ColorPointer)(GLint size, GLenum type, GLsizei stride, const GLvoid * pointer); /* 308 */ + void (GLAPIENTRYP DisableClientState)(GLenum array); /* 309 */ + void (GLAPIENTRYP DrawArrays)(GLenum mode, GLint first, GLsizei count); /* 310 */ + void (GLAPIENTRYP DrawElements)(GLenum mode, GLsizei count, GLenum type, const GLvoid * indices); /* 311 */ + void (GLAPIENTRYP EdgeFlagPointer)(GLsizei stride, const GLvoid * pointer); /* 312 */ + void (GLAPIENTRYP EnableClientState)(GLenum array); /* 313 */ + void (GLAPIENTRYP IndexPointer)(GLenum type, GLsizei stride, const GLvoid * pointer); /* 314 */ + void (GLAPIENTRYP Indexub)(GLubyte c); /* 315 */ + void (GLAPIENTRYP Indexubv)(const GLubyte * c); /* 316 */ + void (GLAPIENTRYP InterleavedArrays)(GLenum format, GLsizei stride, const GLvoid * pointer); /* 317 */ + void (GLAPIENTRYP NormalPointer)(GLenum type, GLsizei stride, const GLvoid * pointer); /* 318 */ + void (GLAPIENTRYP PolygonOffset)(GLfloat factor, GLfloat units); /* 319 */ + void (GLAPIENTRYP TexCoordPointer)(GLint size, GLenum type, GLsizei stride, const GLvoid * pointer); /* 320 */ + void (GLAPIENTRYP VertexPointer)(GLint size, GLenum type, GLsizei stride, const GLvoid * pointer); /* 321 */ + GLboolean (GLAPIENTRYP AreTexturesResident)(GLsizei n, const GLuint * textures, GLboolean * residences); /* 322 */ + void (GLAPIENTRYP CopyTexImage1D)(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLint border); /* 323 */ + void (GLAPIENTRYP CopyTexImage2D)(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border); /* 324 */ + void (GLAPIENTRYP CopyTexSubImage1D)(GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width); /* 325 */ + void (GLAPIENTRYP CopyTexSubImage2D)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height); /* 326 */ + void (GLAPIENTRYP DeleteTextures)(GLsizei n, const GLuint * textures); /* 327 */ + void (GLAPIENTRYP GenTextures)(GLsizei n, GLuint * textures); /* 328 */ + void (GLAPIENTRYP GetPointerv)(GLenum pname, GLvoid ** params); /* 329 */ + GLboolean (GLAPIENTRYP IsTexture)(GLuint texture); /* 330 */ + void (GLAPIENTRYP PrioritizeTextures)(GLsizei n, const GLuint * textures, const GLclampf * priorities); /* 331 */ + void (GLAPIENTRYP TexSubImage1D)(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const GLvoid * pixels); /* 332 */ + void (GLAPIENTRYP TexSubImage2D)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid * pixels); /* 333 */ + void (GLAPIENTRYP PopClientAttrib)(void); /* 334 */ + void (GLAPIENTRYP PushClientAttrib)(GLbitfield mask); /* 335 */ + void (GLAPIENTRYP BlendColor)(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha); /* 336 */ + void (GLAPIENTRYP BlendEquationOES)(GLenum mode); /* 337 */ + void (GLAPIENTRYP DrawRangeElements)(GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const GLvoid * indices); /* 338 */ + void (GLAPIENTRYP ColorTable)(GLenum target, GLenum internalformat, GLsizei width, GLenum format, GLenum type, const GLvoid * table); /* 339 */ + void (GLAPIENTRYP ColorTableParameterfv)(GLenum target, GLenum pname, const GLfloat * params); /* 340 */ + void (GLAPIENTRYP ColorTableParameteriv)(GLenum target, GLenum pname, const GLint * params); /* 341 */ + void (GLAPIENTRYP CopyColorTable)(GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width); /* 342 */ + void (GLAPIENTRYP GetColorTable)(GLenum target, GLenum format, GLenum type, GLvoid * table); /* 343 */ + void (GLAPIENTRYP GetColorTableParameterfv)(GLenum target, GLenum pname, GLfloat * params); /* 344 */ + void (GLAPIENTRYP GetColorTableParameteriv)(GLenum target, GLenum pname, GLint * params); /* 345 */ + void (GLAPIENTRYP ColorSubTable)(GLenum target, GLsizei start, GLsizei count, GLenum format, GLenum type, const GLvoid * data); /* 346 */ + void (GLAPIENTRYP CopyColorSubTable)(GLenum target, GLsizei start, GLint x, GLint y, GLsizei width); /* 347 */ + void (GLAPIENTRYP ConvolutionFilter1D)(GLenum target, GLenum internalformat, GLsizei width, GLenum format, GLenum type, const GLvoid * image); /* 348 */ + void (GLAPIENTRYP ConvolutionFilter2D)(GLenum target, GLenum internalformat, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid * image); /* 349 */ + void (GLAPIENTRYP ConvolutionParameterf)(GLenum target, GLenum pname, GLfloat params); /* 350 */ + void (GLAPIENTRYP ConvolutionParameterfv)(GLenum target, GLenum pname, const GLfloat * params); /* 351 */ + void (GLAPIENTRYP ConvolutionParameteri)(GLenum target, GLenum pname, GLint params); /* 352 */ + void (GLAPIENTRYP ConvolutionParameteriv)(GLenum target, GLenum pname, const GLint * params); /* 353 */ + void (GLAPIENTRYP CopyConvolutionFilter1D)(GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width); /* 354 */ + void (GLAPIENTRYP CopyConvolutionFilter2D)(GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height); /* 355 */ + void (GLAPIENTRYP GetConvolutionFilter)(GLenum target, GLenum format, GLenum type, GLvoid * image); /* 356 */ + void (GLAPIENTRYP GetConvolutionParameterfv)(GLenum target, GLenum pname, GLfloat * params); /* 357 */ + void (GLAPIENTRYP GetConvolutionParameteriv)(GLenum target, GLenum pname, GLint * params); /* 358 */ + void (GLAPIENTRYP GetSeparableFilter)(GLenum target, GLenum format, GLenum type, GLvoid * row, GLvoid * column, GLvoid * span); /* 359 */ + void (GLAPIENTRYP SeparableFilter2D)(GLenum target, GLenum internalformat, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid * row, const GLvoid * column); /* 360 */ + void (GLAPIENTRYP GetHistogram)(GLenum target, GLboolean reset, GLenum format, GLenum type, GLvoid * values); /* 361 */ + void (GLAPIENTRYP GetHistogramParameterfv)(GLenum target, GLenum pname, GLfloat * params); /* 362 */ + void (GLAPIENTRYP GetHistogramParameteriv)(GLenum target, GLenum pname, GLint * params); /* 363 */ + void (GLAPIENTRYP GetMinmax)(GLenum target, GLboolean reset, GLenum format, GLenum type, GLvoid * values); /* 364 */ + void (GLAPIENTRYP GetMinmaxParameterfv)(GLenum target, GLenum pname, GLfloat * params); /* 365 */ + void (GLAPIENTRYP GetMinmaxParameteriv)(GLenum target, GLenum pname, GLint * params); /* 366 */ + void (GLAPIENTRYP Histogram)(GLenum target, GLsizei width, GLenum internalformat, GLboolean sink); /* 367 */ + void (GLAPIENTRYP Minmax)(GLenum target, GLenum internalformat, GLboolean sink); /* 368 */ + void (GLAPIENTRYP ResetHistogram)(GLenum target); /* 369 */ + void (GLAPIENTRYP ResetMinmax)(GLenum target); /* 370 */ + void (GLAPIENTRYP TexImage3D)(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const GLvoid * pixels); /* 371 */ + void (GLAPIENTRYP TexSubImage3D)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const GLvoid * pixels); /* 372 */ + void (GLAPIENTRYP CopyTexSubImage3D)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height); /* 373 */ + void (GLAPIENTRYP ActiveTexture)(GLenum texture); /* 374 */ + void (GLAPIENTRYP ClientActiveTexture)(GLenum texture); /* 375 */ + void (GLAPIENTRYP MultiTexCoord1dARB)(GLenum target, GLdouble s); /* 376 */ + void (GLAPIENTRYP MultiTexCoord1dvARB)(GLenum target, const GLdouble * v); /* 377 */ + void (GLAPIENTRYP MultiTexCoord1fARB)(GLenum target, GLfloat s); /* 378 */ + void (GLAPIENTRYP MultiTexCoord1fvARB)(GLenum target, const GLfloat * v); /* 379 */ + void (GLAPIENTRYP MultiTexCoord1iARB)(GLenum target, GLint s); /* 380 */ + void (GLAPIENTRYP MultiTexCoord1ivARB)(GLenum target, const GLint * v); /* 381 */ + void (GLAPIENTRYP MultiTexCoord1sARB)(GLenum target, GLshort s); /* 382 */ + void (GLAPIENTRYP MultiTexCoord1svARB)(GLenum target, const GLshort * v); /* 383 */ + void (GLAPIENTRYP MultiTexCoord2dARB)(GLenum target, GLdouble s, GLdouble t); /* 384 */ + void (GLAPIENTRYP MultiTexCoord2dvARB)(GLenum target, const GLdouble * v); /* 385 */ + void (GLAPIENTRYP MultiTexCoord2fARB)(GLenum target, GLfloat s, GLfloat t); /* 386 */ + void (GLAPIENTRYP MultiTexCoord2fvARB)(GLenum target, const GLfloat * v); /* 387 */ + void (GLAPIENTRYP MultiTexCoord2iARB)(GLenum target, GLint s, GLint t); /* 388 */ + void (GLAPIENTRYP MultiTexCoord2ivARB)(GLenum target, const GLint * v); /* 389 */ + void (GLAPIENTRYP MultiTexCoord2sARB)(GLenum target, GLshort s, GLshort t); /* 390 */ + void (GLAPIENTRYP MultiTexCoord2svARB)(GLenum target, const GLshort * v); /* 391 */ + void (GLAPIENTRYP MultiTexCoord3dARB)(GLenum target, GLdouble s, GLdouble t, GLdouble r); /* 392 */ + void (GLAPIENTRYP MultiTexCoord3dvARB)(GLenum target, const GLdouble * v); /* 393 */ + void (GLAPIENTRYP MultiTexCoord3fARB)(GLenum target, GLfloat s, GLfloat t, GLfloat r); /* 394 */ + void (GLAPIENTRYP MultiTexCoord3fvARB)(GLenum target, const GLfloat * v); /* 395 */ + void (GLAPIENTRYP MultiTexCoord3iARB)(GLenum target, GLint s, GLint t, GLint r); /* 396 */ + void (GLAPIENTRYP MultiTexCoord3ivARB)(GLenum target, const GLint * v); /* 397 */ + void (GLAPIENTRYP MultiTexCoord3sARB)(GLenum target, GLshort s, GLshort t, GLshort r); /* 398 */ + void (GLAPIENTRYP MultiTexCoord3svARB)(GLenum target, const GLshort * v); /* 399 */ + void (GLAPIENTRYP MultiTexCoord4dARB)(GLenum target, GLdouble s, GLdouble t, GLdouble r, GLdouble q); /* 400 */ + void (GLAPIENTRYP MultiTexCoord4dvARB)(GLenum target, const GLdouble * v); /* 401 */ + void (GLAPIENTRYP MultiTexCoord4f)(GLenum target, GLfloat s, GLfloat t, GLfloat r, GLfloat q); /* 402 */ + void (GLAPIENTRYP MultiTexCoord4fvARB)(GLenum target, const GLfloat * v); /* 403 */ + void (GLAPIENTRYP MultiTexCoord4iARB)(GLenum target, GLint s, GLint t, GLint r, GLint q); /* 404 */ + void (GLAPIENTRYP MultiTexCoord4ivARB)(GLenum target, const GLint * v); /* 405 */ + void (GLAPIENTRYP MultiTexCoord4sARB)(GLenum target, GLshort s, GLshort t, GLshort r, GLshort q); /* 406 */ + void (GLAPIENTRYP MultiTexCoord4svARB)(GLenum target, const GLshort * v); /* 407 */ + void (GLAPIENTRYP BlendEquationSeparateOES)(GLenum modeRGB, GLenum modeA); /* 408 */ + void (GLAPIENTRYP BlendFuncSeparateOES)(GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha); /* 409 */ + void (GLAPIENTRYP DrawTexfOES)(GLfloat x, GLfloat y, GLfloat z, GLfloat width, GLfloat height); /* 410 */ + void (GLAPIENTRYP DrawTexfvOES)(const GLfloat * coords); /* 411 */ + void (GLAPIENTRYP DrawTexiOES)(GLint x, GLint y, GLint z, GLint width, GLint height); /* 412 */ + void (GLAPIENTRYP DrawTexivOES)(const GLint * coords); /* 413 */ + void (GLAPIENTRYP DrawTexsOES)(GLshort x, GLshort y, GLshort z, GLshort width, GLshort height); /* 414 */ + void (GLAPIENTRYP DrawTexsvOES)(const GLshort * coords); /* 415 */ + void (GLAPIENTRYP DrawTexxOES)(GLfixed x, GLfixed y, GLfixed z, GLfixed width, GLfixed height); /* 416 */ + void (GLAPIENTRYP DrawTexxvOES)(const GLfixed * coords); /* 417 */ + void (GLAPIENTRYP BindFramebufferOES)(GLenum target, GLuint framebuffer); /* 418 */ + void (GLAPIENTRYP BindRenderbufferOES)(GLenum target, GLuint renderbuffer); /* 419 */ + GLenum (GLAPIENTRYP CheckFramebufferStatusOES)(GLenum target); /* 420 */ + void (GLAPIENTRYP DeleteFramebuffersOES)(GLsizei n, const GLuint * framebuffers); /* 421 */ + void (GLAPIENTRYP DeleteRenderbuffersOES)(GLsizei n, const GLuint * renderbuffers); /* 422 */ + void (GLAPIENTRYP FramebufferRenderbufferOES)(GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer); /* 423 */ + void (GLAPIENTRYP FramebufferTexture2DOES)(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level); /* 424 */ + void (GLAPIENTRYP GenFramebuffersOES)(GLsizei n, GLuint * framebuffers); /* 425 */ + void (GLAPIENTRYP GenRenderbuffersOES)(GLsizei n, GLuint * renderbuffers); /* 426 */ + void (GLAPIENTRYP GenerateMipmapOES)(GLenum target); /* 427 */ + void (GLAPIENTRYP GetFramebufferAttachmentParameterivOES)(GLenum target, GLenum attachment, GLenum pname, GLint * params); /* 428 */ + void (GLAPIENTRYP GetRenderbufferParameterivOES)(GLenum target, GLenum pname, GLint * params); /* 429 */ + GLboolean (GLAPIENTRYP IsFramebufferOES)(GLuint framebuffer); /* 430 */ + GLboolean (GLAPIENTRYP IsRenderbufferOES)(GLuint renderbuffer); /* 431 */ + void (GLAPIENTRYP RenderbufferStorageOES)(GLenum target, GLenum internalformat, GLsizei width, GLsizei height); /* 432 */ + void (GLAPIENTRYP PointSizePointerOES)(GLenum type, GLsizei stride, const GLvoid * pointer); /* 433 */ + GLbitfield (GLAPIENTRYP QueryMatrixxOES)(GLfixed * mantissa, GLint * exponent); /* 434 */ + void (GLAPIENTRYP GetTexGenxvOES)(GLenum coord, GLenum pname, GLfixed * params); /* 435 */ + void (GLAPIENTRYP TexGenxOES)(GLenum coord, GLenum pname, GLint param); /* 436 */ + void (GLAPIENTRYP TexGenxvOES)(GLenum coord, GLenum pname, const GLfixed * params); /* 437 */ + void (GLAPIENTRYP GetBufferPointervOES)(GLenum target, GLenum pname, GLvoid ** params); /* 438 */ + GLvoid * (GLAPIENTRYP MapBufferOES)(GLenum target, GLenum access); /* 439 */ + GLboolean (GLAPIENTRYP UnmapBufferOES)(GLenum target); /* 440 */ + void (GLAPIENTRYP MultiDrawArraysEXT)(GLenum mode, const GLint * first, const GLsizei * count, GLsizei primcount); /* 441 */ + void (GLAPIENTRYP MultiDrawElementsEXT)(GLenum mode, const GLsizei * count, GLenum type, const GLvoid ** indices, GLsizei primcount); /* 442 */ + void (GLAPIENTRYP BindVertexArrayAPPLE)(GLuint array); /* 443 */ + void (GLAPIENTRYP DeleteVertexArraysAPPLE)(GLsizei n, const GLuint * arrays); /* 444 */ + void (GLAPIENTRYP GenVertexArraysAPPLE)(GLsizei n, GLuint * arrays); /* 445 */ + GLboolean (GLAPIENTRYP IsVertexArrayAPPLE)(GLuint array); /* 446 */ + void (GLAPIENTRYP EGLImageTargetRenderbufferStorageOES)(GLenum target, GLvoid * writeOffset); /* 447 */ + void (GLAPIENTRYP EGLImageTargetTexture2DOES)(GLenum target, GLvoid * writeOffset); /* 448 */ + void (GLAPIENTRYP CompressedTexImage2D)(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const GLvoid * data); /* 449 */ + void (GLAPIENTRYP CompressedTexSubImage2D)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const GLvoid * data); /* 450 */ + void (GLAPIENTRYP SampleCoverage)(GLclampf value, GLboolean invert); /* 451 */ + void (GLAPIENTRYP BindBuffer)(GLenum target, GLuint buffer); /* 452 */ + void (GLAPIENTRYP BufferData)(GLenum target, GLsizeiptr size, const GLvoid * data, GLenum usage); /* 453 */ + void (GLAPIENTRYP BufferSubData)(GLenum target, GLintptr offset, GLsizeiptr size, const GLvoid * data); /* 454 */ + void (GLAPIENTRYP DeleteBuffers)(GLsizei n, const GLuint * buffer); /* 455 */ + void (GLAPIENTRYP GenBuffers)(GLsizei n, GLuint * buffer); /* 456 */ + void (GLAPIENTRYP GetBufferParameteriv)(GLenum target, GLenum pname, GLint * params); /* 457 */ + GLboolean (GLAPIENTRYP IsBuffer)(GLuint buffer); /* 458 */ + void (GLAPIENTRYP PointParameterf)(GLenum pname, GLfloat param); /* 459 */ + void (GLAPIENTRYP PointParameterfv)(GLenum pname, const GLfloat * params); /* 460 */ + void (GLAPIENTRYP AlphaFuncx)(GLenum func, GLclampx ref); /* 461 */ + void (GLAPIENTRYP ClearColorx)(GLclampx red, GLclampx green, GLclampx blue, GLclampx alpha); /* 462 */ + void (GLAPIENTRYP ClearDepthf)(GLclampf depth); /* 463 */ + void (GLAPIENTRYP ClearDepthx)(GLclampx depth); /* 464 */ + void (GLAPIENTRYP Color4x)(GLfixed red, GLfixed green, GLfixed blue, GLfixed alpha); /* 465 */ + void (GLAPIENTRYP DepthRangef)(GLclampf zNear, GLclampf zFar); /* 466 */ + void (GLAPIENTRYP DepthRangex)(GLclampx zNear, GLclampx zFar); /* 467 */ + void (GLAPIENTRYP Fogx)(GLenum pname, GLfixed param); /* 468 */ + void (GLAPIENTRYP Fogxv)(GLenum pname, const GLfixed * params); /* 469 */ + void (GLAPIENTRYP Frustumf)(GLfloat left, GLfloat right, GLfloat bottom, GLfloat top, GLfloat zNear, GLfloat zFar); /* 470 */ + void (GLAPIENTRYP Frustumx)(GLfixed left, GLfixed right, GLfixed bottom, GLfixed top, GLfixed zNear, GLfixed zFar); /* 471 */ + void (GLAPIENTRYP LightModelx)(GLenum pname, GLfixed param); /* 472 */ + void (GLAPIENTRYP LightModelxv)(GLenum pname, const GLfixed * params); /* 473 */ + void (GLAPIENTRYP Lightx)(GLenum light, GLenum pname, GLfixed param); /* 474 */ + void (GLAPIENTRYP Lightxv)(GLenum light, GLenum pname, const GLfixed * params); /* 475 */ + void (GLAPIENTRYP LineWidthx)(GLfixed width); /* 476 */ + void (GLAPIENTRYP LoadMatrixx)(const GLfixed * m); /* 477 */ + void (GLAPIENTRYP Materialx)(GLenum face, GLenum pname, GLfixed param); /* 478 */ + void (GLAPIENTRYP Materialxv)(GLenum face, GLenum pname, const GLfixed * params); /* 479 */ + void (GLAPIENTRYP MultMatrixx)(const GLfixed * m); /* 480 */ + void (GLAPIENTRYP MultiTexCoord4x)(GLenum target, GLfixed s, GLfixed t, GLfixed r, GLfixed q); /* 481 */ + void (GLAPIENTRYP Normal3x)(GLfixed nx, GLfixed ny, GLfixed nz); /* 482 */ + void (GLAPIENTRYP Orthof)(GLfloat left, GLfloat right, GLfloat bottom, GLfloat top, GLfloat zNear, GLfloat zFar); /* 483 */ + void (GLAPIENTRYP Orthox)(GLfixed left, GLfixed right, GLfixed bottom, GLfixed top, GLfixed zNear, GLfixed zFar); /* 484 */ + void (GLAPIENTRYP PointSizex)(GLfixed size); /* 485 */ + void (GLAPIENTRYP PolygonOffsetx)(GLfixed factor, GLfixed units); /* 486 */ + void (GLAPIENTRYP Rotatex)(GLfixed angle, GLfixed x, GLfixed y, GLfixed z); /* 487 */ + void (GLAPIENTRYP SampleCoveragex)(GLclampx value, GLboolean invert); /* 488 */ + void (GLAPIENTRYP Scalex)(GLfixed x, GLfixed y, GLfixed z); /* 489 */ + void (GLAPIENTRYP TexEnvx)(GLenum target, GLenum pname, GLfixed param); /* 490 */ + void (GLAPIENTRYP TexEnvxv)(GLenum target, GLenum pname, const GLfixed * params); /* 491 */ + void (GLAPIENTRYP TexParameterx)(GLenum target, GLenum pname, GLfixed param); /* 492 */ + void (GLAPIENTRYP Translatex)(GLfixed x, GLfixed y, GLfixed z); /* 493 */ + void (GLAPIENTRYP ClipPlanef)(GLenum plane, const GLfloat * equation); /* 494 */ + void (GLAPIENTRYP ClipPlanex)(GLenum plane, const GLfixed * equation); /* 495 */ + void (GLAPIENTRYP GetClipPlanef)(GLenum plane, GLfloat * equation); /* 496 */ + void (GLAPIENTRYP GetClipPlanex)(GLenum plane, GLfixed * equation); /* 497 */ + void (GLAPIENTRYP GetFixedv)(GLenum pname, GLfixed * params); /* 498 */ + void (GLAPIENTRYP GetLightxv)(GLenum light, GLenum pname, GLfixed * params); /* 499 */ + void (GLAPIENTRYP GetMaterialxv)(GLenum face, GLenum pname, GLfixed * params); /* 500 */ + void (GLAPIENTRYP GetTexEnvxv)(GLenum target, GLenum pname, GLfixed * params); /* 501 */ + void (GLAPIENTRYP GetTexParameterxv)(GLenum target, GLenum pname, GLfixed * params); /* 502 */ + void (GLAPIENTRYP PointParameterx)(GLenum pname, GLfixed param); /* 503 */ + void (GLAPIENTRYP PointParameterxv)(GLenum pname, const GLfixed * params); /* 504 */ + void (GLAPIENTRYP TexParameterxv)(GLenum target, GLenum pname, const GLfixed * params); /* 505 */ +}; + +#endif /* !defined( _GLAPI_TABLE_H_ ) */ diff --git a/src/mapi/es1api/glapi/glapitemp.h b/src/mapi/es1api/glapi/glapitemp.h new file mode 100644 index 00000000000..69995716d31 --- /dev/null +++ b/src/mapi/es1api/glapi/glapitemp.h @@ -0,0 +1,4528 @@ +/* DO NOT EDIT - This file generated automatically by gl_apitemp.py (from Mesa) script */ + +/* + * Copyright (C) 1999-2001 Brian Paul All Rights Reserved. + * (C) Copyright IBM Corporation 2004 + * All Rights Reserved. + * + * Permission is hereby granted, free of charge, to any person obtaining a + * copy of this software and associated documentation files (the "Software"), + * to deal in the Software without restriction, including without limitation + * the rights to use, copy, modify, merge, publish, distribute, sub license, + * and/or sell copies of the Software, and to permit persons to whom the + * Software is furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice (including the next + * paragraph) shall be included in all copies or substantial portions of the + * Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL + * BRIAN PAUL, IBM, + * AND/OR THEIR SUPPLIERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, + * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF + * OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE + * SOFTWARE. + */ + + +# if defined(__GNUC__) || (defined(__SUNPRO_C) && (__SUNPRO_C >= 0x590)) && defined(__ELF__) +# define HIDDEN __attribute__((visibility("hidden"))) +# else +# define HIDDEN +# endif + +/* + * This file is a template which generates the OpenGL API entry point + * functions. It should be included by a .c file which first defines + * the following macros: + * KEYWORD1 - usually nothing, but might be __declspec(dllexport) on Win32 + * KEYWORD2 - usually nothing, but might be __stdcall on Win32 + * NAME(n) - builds the final function name (usually add "gl" prefix) + * DISPATCH(func, args, msg) - code to do dispatch of named function. + * msg is a printf-style debug message. + * RETURN_DISPATCH(func, args, msg) - code to do dispatch with a return value + * + * Here is an example which generates the usual OpenGL functions: + * #define KEYWORD1 + * #define KEYWORD2 + * #define NAME(func) gl##func + * #define DISPATCH(func, args, msg) \ + * struct _glapi_table *dispatch = CurrentDispatch; \ + * (*dispatch->func) args + * #define RETURN DISPATCH(func, args, msg) \ + * struct _glapi_table *dispatch = CurrentDispatch; \ + * return (*dispatch->func) args + * + */ + + +#if defined( NAME ) +#ifndef KEYWORD1 +#define KEYWORD1 +#endif + +#ifndef KEYWORD1_ALT +#define KEYWORD1_ALT HIDDEN +#endif + +#ifndef KEYWORD2 +#define KEYWORD2 +#endif + +#ifndef DISPATCH +#error DISPATCH must be defined +#endif + +#ifndef RETURN_DISPATCH +#error RETURN_DISPATCH must be defined +#endif + + +#ifndef _GLAPI_SKIP_NORMAL_ENTRY_POINTS + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_0)(GLuint list, GLenum mode); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_0)(GLuint list, GLenum mode) +{ + DISPATCH(NewList, (list, mode), (F, "glNewList(%d, 0x%x);\n", list, mode)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_1)(void); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_1)(void) +{ + DISPATCH(EndList, (), (F, "glEndList();\n")); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_2)(GLuint list); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_2)(GLuint list) +{ + DISPATCH(CallList, (list), (F, "glCallList(%d);\n", list)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_3)(GLsizei n, GLenum type, const GLvoid * lists); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_3)(GLsizei n, GLenum type, const GLvoid * lists) +{ + DISPATCH(CallLists, (n, type, lists), (F, "glCallLists(%d, 0x%x, %p);\n", n, type, (const void *) lists)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_4)(GLuint list, GLsizei range); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_4)(GLuint list, GLsizei range) +{ + DISPATCH(DeleteLists, (list, range), (F, "glDeleteLists(%d, %d);\n", list, range)); +} + +KEYWORD1_ALT GLuint KEYWORD2 NAME(_dispatch_stub_5)(GLsizei range); + +KEYWORD1_ALT GLuint KEYWORD2 NAME(_dispatch_stub_5)(GLsizei range) +{ + RETURN_DISPATCH(GenLists, (range), (F, "glGenLists(%d);\n", range)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_6)(GLuint base); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_6)(GLuint base) +{ + DISPATCH(ListBase, (base), (F, "glListBase(%d);\n", base)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_7)(GLenum mode); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_7)(GLenum mode) +{ + DISPATCH(Begin, (mode), (F, "glBegin(0x%x);\n", mode)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_8)(GLsizei width, GLsizei height, GLfloat xorig, GLfloat yorig, GLfloat xmove, GLfloat ymove, const GLubyte * bitmap); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_8)(GLsizei width, GLsizei height, GLfloat xorig, GLfloat yorig, GLfloat xmove, GLfloat ymove, const GLubyte * bitmap) +{ + DISPATCH(Bitmap, (width, height, xorig, yorig, xmove, ymove, bitmap), (F, "glBitmap(%d, %d, %f, %f, %f, %f, %p);\n", width, height, xorig, yorig, xmove, ymove, (const void *) bitmap)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_9)(GLbyte red, GLbyte green, GLbyte blue); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_9)(GLbyte red, GLbyte green, GLbyte blue) +{ + DISPATCH(Color3b, (red, green, blue), (F, "glColor3b(%d, %d, %d);\n", red, green, blue)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_10)(const GLbyte * v); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_10)(const GLbyte * v) +{ + DISPATCH(Color3bv, (v), (F, "glColor3bv(%p);\n", (const void *) v)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_11)(GLdouble red, GLdouble green, GLdouble blue); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_11)(GLdouble red, GLdouble green, GLdouble blue) +{ + DISPATCH(Color3d, (red, green, blue), (F, "glColor3d(%f, %f, %f);\n", red, green, blue)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_12)(const GLdouble * v); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_12)(const GLdouble * v) +{ + DISPATCH(Color3dv, (v), (F, "glColor3dv(%p);\n", (const void *) v)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_13)(GLfloat red, GLfloat green, GLfloat blue); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_13)(GLfloat red, GLfloat green, GLfloat blue) +{ + DISPATCH(Color3f, (red, green, blue), (F, "glColor3f(%f, %f, %f);\n", red, green, blue)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_14)(const GLfloat * v); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_14)(const GLfloat * v) +{ + DISPATCH(Color3fv, (v), (F, "glColor3fv(%p);\n", (const void *) v)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_15)(GLint red, GLint green, GLint blue); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_15)(GLint red, GLint green, GLint blue) +{ + DISPATCH(Color3i, (red, green, blue), (F, "glColor3i(%d, %d, %d);\n", red, green, blue)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_16)(const GLint * v); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_16)(const GLint * v) +{ + DISPATCH(Color3iv, (v), (F, "glColor3iv(%p);\n", (const void *) v)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_17)(GLshort red, GLshort green, GLshort blue); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_17)(GLshort red, GLshort green, GLshort blue) +{ + DISPATCH(Color3s, (red, green, blue), (F, "glColor3s(%d, %d, %d);\n", red, green, blue)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_18)(const GLshort * v); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_18)(const GLshort * v) +{ + DISPATCH(Color3sv, (v), (F, "glColor3sv(%p);\n", (const void *) v)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_19)(GLubyte red, GLubyte green, GLubyte blue); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_19)(GLubyte red, GLubyte green, GLubyte blue) +{ + DISPATCH(Color3ub, (red, green, blue), (F, "glColor3ub(%d, %d, %d);\n", red, green, blue)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_20)(const GLubyte * v); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_20)(const GLubyte * v) +{ + DISPATCH(Color3ubv, (v), (F, "glColor3ubv(%p);\n", (const void *) v)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_21)(GLuint red, GLuint green, GLuint blue); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_21)(GLuint red, GLuint green, GLuint blue) +{ + DISPATCH(Color3ui, (red, green, blue), (F, "glColor3ui(%d, %d, %d);\n", red, green, blue)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_22)(const GLuint * v); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_22)(const GLuint * v) +{ + DISPATCH(Color3uiv, (v), (F, "glColor3uiv(%p);\n", (const void *) v)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_23)(GLushort red, GLushort green, GLushort blue); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_23)(GLushort red, GLushort green, GLushort blue) +{ + DISPATCH(Color3us, (red, green, blue), (F, "glColor3us(%d, %d, %d);\n", red, green, blue)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_24)(const GLushort * v); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_24)(const GLushort * v) +{ + DISPATCH(Color3usv, (v), (F, "glColor3usv(%p);\n", (const void *) v)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_25)(GLbyte red, GLbyte green, GLbyte blue, GLbyte alpha); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_25)(GLbyte red, GLbyte green, GLbyte blue, GLbyte alpha) +{ + DISPATCH(Color4b, (red, green, blue, alpha), (F, "glColor4b(%d, %d, %d, %d);\n", red, green, blue, alpha)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_26)(const GLbyte * v); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_26)(const GLbyte * v) +{ + DISPATCH(Color4bv, (v), (F, "glColor4bv(%p);\n", (const void *) v)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_27)(GLdouble red, GLdouble green, GLdouble blue, GLdouble alpha); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_27)(GLdouble red, GLdouble green, GLdouble blue, GLdouble alpha) +{ + DISPATCH(Color4d, (red, green, blue, alpha), (F, "glColor4d(%f, %f, %f, %f);\n", red, green, blue, alpha)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_28)(const GLdouble * v); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_28)(const GLdouble * v) +{ + DISPATCH(Color4dv, (v), (F, "glColor4dv(%p);\n", (const void *) v)); +} + +KEYWORD1 void KEYWORD2 NAME(Color4f)(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha) +{ + DISPATCH(Color4f, (red, green, blue, alpha), (F, "glColor4f(%f, %f, %f, %f);\n", red, green, blue, alpha)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_30)(const GLfloat * v); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_30)(const GLfloat * v) +{ + DISPATCH(Color4fv, (v), (F, "glColor4fv(%p);\n", (const void *) v)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_31)(GLint red, GLint green, GLint blue, GLint alpha); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_31)(GLint red, GLint green, GLint blue, GLint alpha) +{ + DISPATCH(Color4i, (red, green, blue, alpha), (F, "glColor4i(%d, %d, %d, %d);\n", red, green, blue, alpha)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_32)(const GLint * v); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_32)(const GLint * v) +{ + DISPATCH(Color4iv, (v), (F, "glColor4iv(%p);\n", (const void *) v)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_33)(GLshort red, GLshort green, GLshort blue, GLshort alpha); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_33)(GLshort red, GLshort green, GLshort blue, GLshort alpha) +{ + DISPATCH(Color4s, (red, green, blue, alpha), (F, "glColor4s(%d, %d, %d, %d);\n", red, green, blue, alpha)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_34)(const GLshort * v); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_34)(const GLshort * v) +{ + DISPATCH(Color4sv, (v), (F, "glColor4sv(%p);\n", (const void *) v)); +} + +KEYWORD1 void KEYWORD2 NAME(Color4ub)(GLubyte red, GLubyte green, GLubyte blue, GLubyte alpha) +{ + DISPATCH(Color4ub, (red, green, blue, alpha), (F, "glColor4ub(%d, %d, %d, %d);\n", red, green, blue, alpha)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_36)(const GLubyte * v); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_36)(const GLubyte * v) +{ + DISPATCH(Color4ubv, (v), (F, "glColor4ubv(%p);\n", (const void *) v)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_37)(GLuint red, GLuint green, GLuint blue, GLuint alpha); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_37)(GLuint red, GLuint green, GLuint blue, GLuint alpha) +{ + DISPATCH(Color4ui, (red, green, blue, alpha), (F, "glColor4ui(%d, %d, %d, %d);\n", red, green, blue, alpha)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_38)(const GLuint * v); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_38)(const GLuint * v) +{ + DISPATCH(Color4uiv, (v), (F, "glColor4uiv(%p);\n", (const void *) v)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_39)(GLushort red, GLushort green, GLushort blue, GLushort alpha); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_39)(GLushort red, GLushort green, GLushort blue, GLushort alpha) +{ + DISPATCH(Color4us, (red, green, blue, alpha), (F, "glColor4us(%d, %d, %d, %d);\n", red, green, blue, alpha)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_40)(const GLushort * v); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_40)(const GLushort * v) +{ + DISPATCH(Color4usv, (v), (F, "glColor4usv(%p);\n", (const void *) v)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_41)(GLboolean flag); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_41)(GLboolean flag) +{ + DISPATCH(EdgeFlag, (flag), (F, "glEdgeFlag(%d);\n", flag)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_42)(const GLboolean * flag); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_42)(const GLboolean * flag) +{ + DISPATCH(EdgeFlagv, (flag), (F, "glEdgeFlagv(%p);\n", (const void *) flag)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_43)(void); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_43)(void) +{ + DISPATCH(End, (), (F, "glEnd();\n")); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_44)(GLdouble c); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_44)(GLdouble c) +{ + DISPATCH(Indexd, (c), (F, "glIndexd(%f);\n", c)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_45)(const GLdouble * c); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_45)(const GLdouble * c) +{ + DISPATCH(Indexdv, (c), (F, "glIndexdv(%p);\n", (const void *) c)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_46)(GLfloat c); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_46)(GLfloat c) +{ + DISPATCH(Indexf, (c), (F, "glIndexf(%f);\n", c)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_47)(const GLfloat * c); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_47)(const GLfloat * c) +{ + DISPATCH(Indexfv, (c), (F, "glIndexfv(%p);\n", (const void *) c)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_48)(GLint c); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_48)(GLint c) +{ + DISPATCH(Indexi, (c), (F, "glIndexi(%d);\n", c)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_49)(const GLint * c); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_49)(const GLint * c) +{ + DISPATCH(Indexiv, (c), (F, "glIndexiv(%p);\n", (const void *) c)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_50)(GLshort c); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_50)(GLshort c) +{ + DISPATCH(Indexs, (c), (F, "glIndexs(%d);\n", c)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_51)(const GLshort * c); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_51)(const GLshort * c) +{ + DISPATCH(Indexsv, (c), (F, "glIndexsv(%p);\n", (const void *) c)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_52)(GLbyte nx, GLbyte ny, GLbyte nz); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_52)(GLbyte nx, GLbyte ny, GLbyte nz) +{ + DISPATCH(Normal3b, (nx, ny, nz), (F, "glNormal3b(%d, %d, %d);\n", nx, ny, nz)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_53)(const GLbyte * v); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_53)(const GLbyte * v) +{ + DISPATCH(Normal3bv, (v), (F, "glNormal3bv(%p);\n", (const void *) v)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_54)(GLdouble nx, GLdouble ny, GLdouble nz); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_54)(GLdouble nx, GLdouble ny, GLdouble nz) +{ + DISPATCH(Normal3d, (nx, ny, nz), (F, "glNormal3d(%f, %f, %f);\n", nx, ny, nz)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_55)(const GLdouble * v); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_55)(const GLdouble * v) +{ + DISPATCH(Normal3dv, (v), (F, "glNormal3dv(%p);\n", (const void *) v)); +} + +KEYWORD1 void KEYWORD2 NAME(Normal3f)(GLfloat nx, GLfloat ny, GLfloat nz) +{ + DISPATCH(Normal3f, (nx, ny, nz), (F, "glNormal3f(%f, %f, %f);\n", nx, ny, nz)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_57)(const GLfloat * v); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_57)(const GLfloat * v) +{ + DISPATCH(Normal3fv, (v), (F, "glNormal3fv(%p);\n", (const void *) v)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_58)(GLint nx, GLint ny, GLint nz); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_58)(GLint nx, GLint ny, GLint nz) +{ + DISPATCH(Normal3i, (nx, ny, nz), (F, "glNormal3i(%d, %d, %d);\n", nx, ny, nz)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_59)(const GLint * v); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_59)(const GLint * v) +{ + DISPATCH(Normal3iv, (v), (F, "glNormal3iv(%p);\n", (const void *) v)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_60)(GLshort nx, GLshort ny, GLshort nz); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_60)(GLshort nx, GLshort ny, GLshort nz) +{ + DISPATCH(Normal3s, (nx, ny, nz), (F, "glNormal3s(%d, %d, %d);\n", nx, ny, nz)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_61)(const GLshort * v); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_61)(const GLshort * v) +{ + DISPATCH(Normal3sv, (v), (F, "glNormal3sv(%p);\n", (const void *) v)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_62)(GLdouble x, GLdouble y); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_62)(GLdouble x, GLdouble y) +{ + DISPATCH(RasterPos2d, (x, y), (F, "glRasterPos2d(%f, %f);\n", x, y)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_63)(const GLdouble * v); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_63)(const GLdouble * v) +{ + DISPATCH(RasterPos2dv, (v), (F, "glRasterPos2dv(%p);\n", (const void *) v)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_64)(GLfloat x, GLfloat y); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_64)(GLfloat x, GLfloat y) +{ + DISPATCH(RasterPos2f, (x, y), (F, "glRasterPos2f(%f, %f);\n", x, y)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_65)(const GLfloat * v); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_65)(const GLfloat * v) +{ + DISPATCH(RasterPos2fv, (v), (F, "glRasterPos2fv(%p);\n", (const void *) v)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_66)(GLint x, GLint y); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_66)(GLint x, GLint y) +{ + DISPATCH(RasterPos2i, (x, y), (F, "glRasterPos2i(%d, %d);\n", x, y)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_67)(const GLint * v); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_67)(const GLint * v) +{ + DISPATCH(RasterPos2iv, (v), (F, "glRasterPos2iv(%p);\n", (const void *) v)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_68)(GLshort x, GLshort y); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_68)(GLshort x, GLshort y) +{ + DISPATCH(RasterPos2s, (x, y), (F, "glRasterPos2s(%d, %d);\n", x, y)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_69)(const GLshort * v); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_69)(const GLshort * v) +{ + DISPATCH(RasterPos2sv, (v), (F, "glRasterPos2sv(%p);\n", (const void *) v)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_70)(GLdouble x, GLdouble y, GLdouble z); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_70)(GLdouble x, GLdouble y, GLdouble z) +{ + DISPATCH(RasterPos3d, (x, y, z), (F, "glRasterPos3d(%f, %f, %f);\n", x, y, z)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_71)(const GLdouble * v); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_71)(const GLdouble * v) +{ + DISPATCH(RasterPos3dv, (v), (F, "glRasterPos3dv(%p);\n", (const void *) v)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_72)(GLfloat x, GLfloat y, GLfloat z); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_72)(GLfloat x, GLfloat y, GLfloat z) +{ + DISPATCH(RasterPos3f, (x, y, z), (F, "glRasterPos3f(%f, %f, %f);\n", x, y, z)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_73)(const GLfloat * v); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_73)(const GLfloat * v) +{ + DISPATCH(RasterPos3fv, (v), (F, "glRasterPos3fv(%p);\n", (const void *) v)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_74)(GLint x, GLint y, GLint z); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_74)(GLint x, GLint y, GLint z) +{ + DISPATCH(RasterPos3i, (x, y, z), (F, "glRasterPos3i(%d, %d, %d);\n", x, y, z)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_75)(const GLint * v); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_75)(const GLint * v) +{ + DISPATCH(RasterPos3iv, (v), (F, "glRasterPos3iv(%p);\n", (const void *) v)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_76)(GLshort x, GLshort y, GLshort z); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_76)(GLshort x, GLshort y, GLshort z) +{ + DISPATCH(RasterPos3s, (x, y, z), (F, "glRasterPos3s(%d, %d, %d);\n", x, y, z)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_77)(const GLshort * v); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_77)(const GLshort * v) +{ + DISPATCH(RasterPos3sv, (v), (F, "glRasterPos3sv(%p);\n", (const void *) v)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_78)(GLdouble x, GLdouble y, GLdouble z, GLdouble w); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_78)(GLdouble x, GLdouble y, GLdouble z, GLdouble w) +{ + DISPATCH(RasterPos4d, (x, y, z, w), (F, "glRasterPos4d(%f, %f, %f, %f);\n", x, y, z, w)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_79)(const GLdouble * v); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_79)(const GLdouble * v) +{ + DISPATCH(RasterPos4dv, (v), (F, "glRasterPos4dv(%p);\n", (const void *) v)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_80)(GLfloat x, GLfloat y, GLfloat z, GLfloat w); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_80)(GLfloat x, GLfloat y, GLfloat z, GLfloat w) +{ + DISPATCH(RasterPos4f, (x, y, z, w), (F, "glRasterPos4f(%f, %f, %f, %f);\n", x, y, z, w)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_81)(const GLfloat * v); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_81)(const GLfloat * v) +{ + DISPATCH(RasterPos4fv, (v), (F, "glRasterPos4fv(%p);\n", (const void *) v)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_82)(GLint x, GLint y, GLint z, GLint w); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_82)(GLint x, GLint y, GLint z, GLint w) +{ + DISPATCH(RasterPos4i, (x, y, z, w), (F, "glRasterPos4i(%d, %d, %d, %d);\n", x, y, z, w)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_83)(const GLint * v); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_83)(const GLint * v) +{ + DISPATCH(RasterPos4iv, (v), (F, "glRasterPos4iv(%p);\n", (const void *) v)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_84)(GLshort x, GLshort y, GLshort z, GLshort w); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_84)(GLshort x, GLshort y, GLshort z, GLshort w) +{ + DISPATCH(RasterPos4s, (x, y, z, w), (F, "glRasterPos4s(%d, %d, %d, %d);\n", x, y, z, w)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_85)(const GLshort * v); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_85)(const GLshort * v) +{ + DISPATCH(RasterPos4sv, (v), (F, "glRasterPos4sv(%p);\n", (const void *) v)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_86)(GLdouble x1, GLdouble y1, GLdouble x2, GLdouble y2); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_86)(GLdouble x1, GLdouble y1, GLdouble x2, GLdouble y2) +{ + DISPATCH(Rectd, (x1, y1, x2, y2), (F, "glRectd(%f, %f, %f, %f);\n", x1, y1, x2, y2)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_87)(const GLdouble * v1, const GLdouble * v2); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_87)(const GLdouble * v1, const GLdouble * v2) +{ + DISPATCH(Rectdv, (v1, v2), (F, "glRectdv(%p, %p);\n", (const void *) v1, (const void *) v2)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_88)(GLfloat x1, GLfloat y1, GLfloat x2, GLfloat y2); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_88)(GLfloat x1, GLfloat y1, GLfloat x2, GLfloat y2) +{ + DISPATCH(Rectf, (x1, y1, x2, y2), (F, "glRectf(%f, %f, %f, %f);\n", x1, y1, x2, y2)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_89)(const GLfloat * v1, const GLfloat * v2); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_89)(const GLfloat * v1, const GLfloat * v2) +{ + DISPATCH(Rectfv, (v1, v2), (F, "glRectfv(%p, %p);\n", (const void *) v1, (const void *) v2)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_90)(GLint x1, GLint y1, GLint x2, GLint y2); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_90)(GLint x1, GLint y1, GLint x2, GLint y2) +{ + DISPATCH(Recti, (x1, y1, x2, y2), (F, "glRecti(%d, %d, %d, %d);\n", x1, y1, x2, y2)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_91)(const GLint * v1, const GLint * v2); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_91)(const GLint * v1, const GLint * v2) +{ + DISPATCH(Rectiv, (v1, v2), (F, "glRectiv(%p, %p);\n", (const void *) v1, (const void *) v2)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_92)(GLshort x1, GLshort y1, GLshort x2, GLshort y2); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_92)(GLshort x1, GLshort y1, GLshort x2, GLshort y2) +{ + DISPATCH(Rects, (x1, y1, x2, y2), (F, "glRects(%d, %d, %d, %d);\n", x1, y1, x2, y2)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_93)(const GLshort * v1, const GLshort * v2); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_93)(const GLshort * v1, const GLshort * v2) +{ + DISPATCH(Rectsv, (v1, v2), (F, "glRectsv(%p, %p);\n", (const void *) v1, (const void *) v2)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_94)(GLdouble s); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_94)(GLdouble s) +{ + DISPATCH(TexCoord1d, (s), (F, "glTexCoord1d(%f);\n", s)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_95)(const GLdouble * v); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_95)(const GLdouble * v) +{ + DISPATCH(TexCoord1dv, (v), (F, "glTexCoord1dv(%p);\n", (const void *) v)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_96)(GLfloat s); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_96)(GLfloat s) +{ + DISPATCH(TexCoord1f, (s), (F, "glTexCoord1f(%f);\n", s)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_97)(const GLfloat * v); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_97)(const GLfloat * v) +{ + DISPATCH(TexCoord1fv, (v), (F, "glTexCoord1fv(%p);\n", (const void *) v)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_98)(GLint s); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_98)(GLint s) +{ + DISPATCH(TexCoord1i, (s), (F, "glTexCoord1i(%d);\n", s)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_99)(const GLint * v); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_99)(const GLint * v) +{ + DISPATCH(TexCoord1iv, (v), (F, "glTexCoord1iv(%p);\n", (const void *) v)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_100)(GLshort s); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_100)(GLshort s) +{ + DISPATCH(TexCoord1s, (s), (F, "glTexCoord1s(%d);\n", s)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_101)(const GLshort * v); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_101)(const GLshort * v) +{ + DISPATCH(TexCoord1sv, (v), (F, "glTexCoord1sv(%p);\n", (const void *) v)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_102)(GLdouble s, GLdouble t); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_102)(GLdouble s, GLdouble t) +{ + DISPATCH(TexCoord2d, (s, t), (F, "glTexCoord2d(%f, %f);\n", s, t)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_103)(const GLdouble * v); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_103)(const GLdouble * v) +{ + DISPATCH(TexCoord2dv, (v), (F, "glTexCoord2dv(%p);\n", (const void *) v)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_104)(GLfloat s, GLfloat t); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_104)(GLfloat s, GLfloat t) +{ + DISPATCH(TexCoord2f, (s, t), (F, "glTexCoord2f(%f, %f);\n", s, t)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_105)(const GLfloat * v); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_105)(const GLfloat * v) +{ + DISPATCH(TexCoord2fv, (v), (F, "glTexCoord2fv(%p);\n", (const void *) v)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_106)(GLint s, GLint t); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_106)(GLint s, GLint t) +{ + DISPATCH(TexCoord2i, (s, t), (F, "glTexCoord2i(%d, %d);\n", s, t)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_107)(const GLint * v); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_107)(const GLint * v) +{ + DISPATCH(TexCoord2iv, (v), (F, "glTexCoord2iv(%p);\n", (const void *) v)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_108)(GLshort s, GLshort t); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_108)(GLshort s, GLshort t) +{ + DISPATCH(TexCoord2s, (s, t), (F, "glTexCoord2s(%d, %d);\n", s, t)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_109)(const GLshort * v); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_109)(const GLshort * v) +{ + DISPATCH(TexCoord2sv, (v), (F, "glTexCoord2sv(%p);\n", (const void *) v)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_110)(GLdouble s, GLdouble t, GLdouble r); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_110)(GLdouble s, GLdouble t, GLdouble r) +{ + DISPATCH(TexCoord3d, (s, t, r), (F, "glTexCoord3d(%f, %f, %f);\n", s, t, r)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_111)(const GLdouble * v); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_111)(const GLdouble * v) +{ + DISPATCH(TexCoord3dv, (v), (F, "glTexCoord3dv(%p);\n", (const void *) v)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_112)(GLfloat s, GLfloat t, GLfloat r); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_112)(GLfloat s, GLfloat t, GLfloat r) +{ + DISPATCH(TexCoord3f, (s, t, r), (F, "glTexCoord3f(%f, %f, %f);\n", s, t, r)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_113)(const GLfloat * v); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_113)(const GLfloat * v) +{ + DISPATCH(TexCoord3fv, (v), (F, "glTexCoord3fv(%p);\n", (const void *) v)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_114)(GLint s, GLint t, GLint r); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_114)(GLint s, GLint t, GLint r) +{ + DISPATCH(TexCoord3i, (s, t, r), (F, "glTexCoord3i(%d, %d, %d);\n", s, t, r)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_115)(const GLint * v); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_115)(const GLint * v) +{ + DISPATCH(TexCoord3iv, (v), (F, "glTexCoord3iv(%p);\n", (const void *) v)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_116)(GLshort s, GLshort t, GLshort r); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_116)(GLshort s, GLshort t, GLshort r) +{ + DISPATCH(TexCoord3s, (s, t, r), (F, "glTexCoord3s(%d, %d, %d);\n", s, t, r)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_117)(const GLshort * v); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_117)(const GLshort * v) +{ + DISPATCH(TexCoord3sv, (v), (F, "glTexCoord3sv(%p);\n", (const void *) v)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_118)(GLdouble s, GLdouble t, GLdouble r, GLdouble q); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_118)(GLdouble s, GLdouble t, GLdouble r, GLdouble q) +{ + DISPATCH(TexCoord4d, (s, t, r, q), (F, "glTexCoord4d(%f, %f, %f, %f);\n", s, t, r, q)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_119)(const GLdouble * v); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_119)(const GLdouble * v) +{ + DISPATCH(TexCoord4dv, (v), (F, "glTexCoord4dv(%p);\n", (const void *) v)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_120)(GLfloat s, GLfloat t, GLfloat r, GLfloat q); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_120)(GLfloat s, GLfloat t, GLfloat r, GLfloat q) +{ + DISPATCH(TexCoord4f, (s, t, r, q), (F, "glTexCoord4f(%f, %f, %f, %f);\n", s, t, r, q)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_121)(const GLfloat * v); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_121)(const GLfloat * v) +{ + DISPATCH(TexCoord4fv, (v), (F, "glTexCoord4fv(%p);\n", (const void *) v)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_122)(GLint s, GLint t, GLint r, GLint q); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_122)(GLint s, GLint t, GLint r, GLint q) +{ + DISPATCH(TexCoord4i, (s, t, r, q), (F, "glTexCoord4i(%d, %d, %d, %d);\n", s, t, r, q)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_123)(const GLint * v); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_123)(const GLint * v) +{ + DISPATCH(TexCoord4iv, (v), (F, "glTexCoord4iv(%p);\n", (const void *) v)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_124)(GLshort s, GLshort t, GLshort r, GLshort q); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_124)(GLshort s, GLshort t, GLshort r, GLshort q) +{ + DISPATCH(TexCoord4s, (s, t, r, q), (F, "glTexCoord4s(%d, %d, %d, %d);\n", s, t, r, q)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_125)(const GLshort * v); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_125)(const GLshort * v) +{ + DISPATCH(TexCoord4sv, (v), (F, "glTexCoord4sv(%p);\n", (const void *) v)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_126)(GLdouble x, GLdouble y); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_126)(GLdouble x, GLdouble y) +{ + DISPATCH(Vertex2d, (x, y), (F, "glVertex2d(%f, %f);\n", x, y)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_127)(const GLdouble * v); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_127)(const GLdouble * v) +{ + DISPATCH(Vertex2dv, (v), (F, "glVertex2dv(%p);\n", (const void *) v)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_128)(GLfloat x, GLfloat y); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_128)(GLfloat x, GLfloat y) +{ + DISPATCH(Vertex2f, (x, y), (F, "glVertex2f(%f, %f);\n", x, y)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_129)(const GLfloat * v); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_129)(const GLfloat * v) +{ + DISPATCH(Vertex2fv, (v), (F, "glVertex2fv(%p);\n", (const void *) v)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_130)(GLint x, GLint y); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_130)(GLint x, GLint y) +{ + DISPATCH(Vertex2i, (x, y), (F, "glVertex2i(%d, %d);\n", x, y)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_131)(const GLint * v); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_131)(const GLint * v) +{ + DISPATCH(Vertex2iv, (v), (F, "glVertex2iv(%p);\n", (const void *) v)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_132)(GLshort x, GLshort y); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_132)(GLshort x, GLshort y) +{ + DISPATCH(Vertex2s, (x, y), (F, "glVertex2s(%d, %d);\n", x, y)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_133)(const GLshort * v); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_133)(const GLshort * v) +{ + DISPATCH(Vertex2sv, (v), (F, "glVertex2sv(%p);\n", (const void *) v)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_134)(GLdouble x, GLdouble y, GLdouble z); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_134)(GLdouble x, GLdouble y, GLdouble z) +{ + DISPATCH(Vertex3d, (x, y, z), (F, "glVertex3d(%f, %f, %f);\n", x, y, z)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_135)(const GLdouble * v); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_135)(const GLdouble * v) +{ + DISPATCH(Vertex3dv, (v), (F, "glVertex3dv(%p);\n", (const void *) v)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_136)(GLfloat x, GLfloat y, GLfloat z); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_136)(GLfloat x, GLfloat y, GLfloat z) +{ + DISPATCH(Vertex3f, (x, y, z), (F, "glVertex3f(%f, %f, %f);\n", x, y, z)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_137)(const GLfloat * v); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_137)(const GLfloat * v) +{ + DISPATCH(Vertex3fv, (v), (F, "glVertex3fv(%p);\n", (const void *) v)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_138)(GLint x, GLint y, GLint z); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_138)(GLint x, GLint y, GLint z) +{ + DISPATCH(Vertex3i, (x, y, z), (F, "glVertex3i(%d, %d, %d);\n", x, y, z)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_139)(const GLint * v); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_139)(const GLint * v) +{ + DISPATCH(Vertex3iv, (v), (F, "glVertex3iv(%p);\n", (const void *) v)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_140)(GLshort x, GLshort y, GLshort z); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_140)(GLshort x, GLshort y, GLshort z) +{ + DISPATCH(Vertex3s, (x, y, z), (F, "glVertex3s(%d, %d, %d);\n", x, y, z)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_141)(const GLshort * v); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_141)(const GLshort * v) +{ + DISPATCH(Vertex3sv, (v), (F, "glVertex3sv(%p);\n", (const void *) v)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_142)(GLdouble x, GLdouble y, GLdouble z, GLdouble w); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_142)(GLdouble x, GLdouble y, GLdouble z, GLdouble w) +{ + DISPATCH(Vertex4d, (x, y, z, w), (F, "glVertex4d(%f, %f, %f, %f);\n", x, y, z, w)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_143)(const GLdouble * v); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_143)(const GLdouble * v) +{ + DISPATCH(Vertex4dv, (v), (F, "glVertex4dv(%p);\n", (const void *) v)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_144)(GLfloat x, GLfloat y, GLfloat z, GLfloat w); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_144)(GLfloat x, GLfloat y, GLfloat z, GLfloat w) +{ + DISPATCH(Vertex4f, (x, y, z, w), (F, "glVertex4f(%f, %f, %f, %f);\n", x, y, z, w)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_145)(const GLfloat * v); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_145)(const GLfloat * v) +{ + DISPATCH(Vertex4fv, (v), (F, "glVertex4fv(%p);\n", (const void *) v)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_146)(GLint x, GLint y, GLint z, GLint w); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_146)(GLint x, GLint y, GLint z, GLint w) +{ + DISPATCH(Vertex4i, (x, y, z, w), (F, "glVertex4i(%d, %d, %d, %d);\n", x, y, z, w)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_147)(const GLint * v); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_147)(const GLint * v) +{ + DISPATCH(Vertex4iv, (v), (F, "glVertex4iv(%p);\n", (const void *) v)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_148)(GLshort x, GLshort y, GLshort z, GLshort w); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_148)(GLshort x, GLshort y, GLshort z, GLshort w) +{ + DISPATCH(Vertex4s, (x, y, z, w), (F, "glVertex4s(%d, %d, %d, %d);\n", x, y, z, w)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_149)(const GLshort * v); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_149)(const GLshort * v) +{ + DISPATCH(Vertex4sv, (v), (F, "glVertex4sv(%p);\n", (const void *) v)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_150)(GLenum plane, const GLdouble * equation); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_150)(GLenum plane, const GLdouble * equation) +{ + DISPATCH(ClipPlane, (plane, equation), (F, "glClipPlane(0x%x, %p);\n", plane, (const void *) equation)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_151)(GLenum face, GLenum mode); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_151)(GLenum face, GLenum mode) +{ + DISPATCH(ColorMaterial, (face, mode), (F, "glColorMaterial(0x%x, 0x%x);\n", face, mode)); +} + +KEYWORD1 void KEYWORD2 NAME(CullFace)(GLenum mode) +{ + DISPATCH(CullFace, (mode), (F, "glCullFace(0x%x);\n", mode)); +} + +KEYWORD1 void KEYWORD2 NAME(Fogf)(GLenum pname, GLfloat param) +{ + DISPATCH(Fogf, (pname, param), (F, "glFogf(0x%x, %f);\n", pname, param)); +} + +KEYWORD1 void KEYWORD2 NAME(Fogfv)(GLenum pname, const GLfloat * params) +{ + DISPATCH(Fogfv, (pname, params), (F, "glFogfv(0x%x, %p);\n", pname, (const void *) params)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_155)(GLenum pname, GLint param); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_155)(GLenum pname, GLint param) +{ + DISPATCH(Fogi, (pname, param), (F, "glFogi(0x%x, %d);\n", pname, param)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_156)(GLenum pname, const GLint * params); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_156)(GLenum pname, const GLint * params) +{ + DISPATCH(Fogiv, (pname, params), (F, "glFogiv(0x%x, %p);\n", pname, (const void *) params)); +} + +KEYWORD1 void KEYWORD2 NAME(FrontFace)(GLenum mode) +{ + DISPATCH(FrontFace, (mode), (F, "glFrontFace(0x%x);\n", mode)); +} + +KEYWORD1 void KEYWORD2 NAME(Hint)(GLenum target, GLenum mode) +{ + DISPATCH(Hint, (target, mode), (F, "glHint(0x%x, 0x%x);\n", target, mode)); +} + +KEYWORD1 void KEYWORD2 NAME(Lightf)(GLenum light, GLenum pname, GLfloat param) +{ + DISPATCH(Lightf, (light, pname, param), (F, "glLightf(0x%x, 0x%x, %f);\n", light, pname, param)); +} + +KEYWORD1 void KEYWORD2 NAME(Lightfv)(GLenum light, GLenum pname, const GLfloat * params) +{ + DISPATCH(Lightfv, (light, pname, params), (F, "glLightfv(0x%x, 0x%x, %p);\n", light, pname, (const void *) params)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_161)(GLenum light, GLenum pname, GLint param); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_161)(GLenum light, GLenum pname, GLint param) +{ + DISPATCH(Lighti, (light, pname, param), (F, "glLighti(0x%x, 0x%x, %d);\n", light, pname, param)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_162)(GLenum light, GLenum pname, const GLint * params); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_162)(GLenum light, GLenum pname, const GLint * params) +{ + DISPATCH(Lightiv, (light, pname, params), (F, "glLightiv(0x%x, 0x%x, %p);\n", light, pname, (const void *) params)); +} + +KEYWORD1 void KEYWORD2 NAME(LightModelf)(GLenum pname, GLfloat param) +{ + DISPATCH(LightModelf, (pname, param), (F, "glLightModelf(0x%x, %f);\n", pname, param)); +} + +KEYWORD1 void KEYWORD2 NAME(LightModelfv)(GLenum pname, const GLfloat * params) +{ + DISPATCH(LightModelfv, (pname, params), (F, "glLightModelfv(0x%x, %p);\n", pname, (const void *) params)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_165)(GLenum pname, GLint param); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_165)(GLenum pname, GLint param) +{ + DISPATCH(LightModeli, (pname, param), (F, "glLightModeli(0x%x, %d);\n", pname, param)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_166)(GLenum pname, const GLint * params); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_166)(GLenum pname, const GLint * params) +{ + DISPATCH(LightModeliv, (pname, params), (F, "glLightModeliv(0x%x, %p);\n", pname, (const void *) params)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_167)(GLint factor, GLushort pattern); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_167)(GLint factor, GLushort pattern) +{ + DISPATCH(LineStipple, (factor, pattern), (F, "glLineStipple(%d, %d);\n", factor, pattern)); +} + +KEYWORD1 void KEYWORD2 NAME(LineWidth)(GLfloat width) +{ + DISPATCH(LineWidth, (width), (F, "glLineWidth(%f);\n", width)); +} + +KEYWORD1 void KEYWORD2 NAME(Materialf)(GLenum face, GLenum pname, GLfloat param) +{ + DISPATCH(Materialf, (face, pname, param), (F, "glMaterialf(0x%x, 0x%x, %f);\n", face, pname, param)); +} + +KEYWORD1 void KEYWORD2 NAME(Materialfv)(GLenum face, GLenum pname, const GLfloat * params) +{ + DISPATCH(Materialfv, (face, pname, params), (F, "glMaterialfv(0x%x, 0x%x, %p);\n", face, pname, (const void *) params)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_171)(GLenum face, GLenum pname, GLint param); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_171)(GLenum face, GLenum pname, GLint param) +{ + DISPATCH(Materiali, (face, pname, param), (F, "glMateriali(0x%x, 0x%x, %d);\n", face, pname, param)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_172)(GLenum face, GLenum pname, const GLint * params); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_172)(GLenum face, GLenum pname, const GLint * params) +{ + DISPATCH(Materialiv, (face, pname, params), (F, "glMaterialiv(0x%x, 0x%x, %p);\n", face, pname, (const void *) params)); +} + +KEYWORD1 void KEYWORD2 NAME(PointSize)(GLfloat size) +{ + DISPATCH(PointSize, (size), (F, "glPointSize(%f);\n", size)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_174)(GLenum face, GLenum mode); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_174)(GLenum face, GLenum mode) +{ + DISPATCH(PolygonMode, (face, mode), (F, "glPolygonMode(0x%x, 0x%x);\n", face, mode)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_175)(const GLubyte * mask); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_175)(const GLubyte * mask) +{ + DISPATCH(PolygonStipple, (mask), (F, "glPolygonStipple(%p);\n", (const void *) mask)); +} + +KEYWORD1 void KEYWORD2 NAME(Scissor)(GLint x, GLint y, GLsizei width, GLsizei height) +{ + DISPATCH(Scissor, (x, y, width, height), (F, "glScissor(%d, %d, %d, %d);\n", x, y, width, height)); +} + +KEYWORD1 void KEYWORD2 NAME(ShadeModel)(GLenum mode) +{ + DISPATCH(ShadeModel, (mode), (F, "glShadeModel(0x%x);\n", mode)); +} + +KEYWORD1 void KEYWORD2 NAME(TexParameterf)(GLenum target, GLenum pname, GLfloat param) +{ + DISPATCH(TexParameterf, (target, pname, param), (F, "glTexParameterf(0x%x, 0x%x, %f);\n", target, pname, param)); +} + +KEYWORD1 void KEYWORD2 NAME(TexParameterfv)(GLenum target, GLenum pname, const GLfloat * params) +{ + DISPATCH(TexParameterfv, (target, pname, params), (F, "glTexParameterfv(0x%x, 0x%x, %p);\n", target, pname, (const void *) params)); +} + +KEYWORD1 void KEYWORD2 NAME(TexParameteri)(GLenum target, GLenum pname, GLint param) +{ + DISPATCH(TexParameteri, (target, pname, param), (F, "glTexParameteri(0x%x, 0x%x, %d);\n", target, pname, param)); +} + +KEYWORD1 void KEYWORD2 NAME(TexParameteriv)(GLenum target, GLenum pname, const GLint * params) +{ + DISPATCH(TexParameteriv, (target, pname, params), (F, "glTexParameteriv(0x%x, 0x%x, %p);\n", target, pname, (const void *) params)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_182)(GLenum target, GLint level, GLint internalformat, GLsizei width, GLint border, GLenum format, GLenum type, const GLvoid * pixels); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_182)(GLenum target, GLint level, GLint internalformat, GLsizei width, GLint border, GLenum format, GLenum type, const GLvoid * pixels) +{ + DISPATCH(TexImage1D, (target, level, internalformat, width, border, format, type, pixels), (F, "glTexImage1D(0x%x, %d, %d, %d, %d, 0x%x, 0x%x, %p);\n", target, level, internalformat, width, border, format, type, (const void *) pixels)); +} + +KEYWORD1 void KEYWORD2 NAME(TexImage2D)(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const GLvoid * pixels) +{ + DISPATCH(TexImage2D, (target, level, internalformat, width, height, border, format, type, pixels), (F, "glTexImage2D(0x%x, %d, %d, %d, %d, %d, 0x%x, 0x%x, %p);\n", target, level, internalformat, width, height, border, format, type, (const void *) pixels)); +} + +KEYWORD1 void KEYWORD2 NAME(TexEnvf)(GLenum target, GLenum pname, GLfloat param) +{ + DISPATCH(TexEnvf, (target, pname, param), (F, "glTexEnvf(0x%x, 0x%x, %f);\n", target, pname, param)); +} + +KEYWORD1 void KEYWORD2 NAME(TexEnvfv)(GLenum target, GLenum pname, const GLfloat * params) +{ + DISPATCH(TexEnvfv, (target, pname, params), (F, "glTexEnvfv(0x%x, 0x%x, %p);\n", target, pname, (const void *) params)); +} + +KEYWORD1 void KEYWORD2 NAME(TexEnvi)(GLenum target, GLenum pname, GLint param) +{ + DISPATCH(TexEnvi, (target, pname, param), (F, "glTexEnvi(0x%x, 0x%x, %d);\n", target, pname, param)); +} + +KEYWORD1 void KEYWORD2 NAME(TexEnviv)(GLenum target, GLenum pname, const GLint * params) +{ + DISPATCH(TexEnviv, (target, pname, params), (F, "glTexEnviv(0x%x, 0x%x, %p);\n", target, pname, (const void *) params)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_188)(GLenum coord, GLenum pname, GLdouble param); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_188)(GLenum coord, GLenum pname, GLdouble param) +{ + DISPATCH(TexGend, (coord, pname, param), (F, "glTexGend(0x%x, 0x%x, %f);\n", coord, pname, param)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_189)(GLenum coord, GLenum pname, const GLdouble * params); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_189)(GLenum coord, GLenum pname, const GLdouble * params) +{ + DISPATCH(TexGendv, (coord, pname, params), (F, "glTexGendv(0x%x, 0x%x, %p);\n", coord, pname, (const void *) params)); +} + +KEYWORD1 void KEYWORD2 NAME(TexGenfOES)(GLenum coord, GLenum pname, GLfloat param); + +KEYWORD1 void KEYWORD2 NAME(TexGenfOES)(GLenum coord, GLenum pname, GLfloat param) +{ + DISPATCH(TexGenfOES, (coord, pname, param), (F, "glTexGenfOES(0x%x, 0x%x, %f);\n", coord, pname, param)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_190)(GLenum coord, GLenum pname, GLfloat param); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_190)(GLenum coord, GLenum pname, GLfloat param) +{ + DISPATCH(TexGenfOES, (coord, pname, param), (F, "glTexGenf(0x%x, 0x%x, %f);\n", coord, pname, param)); +} + +KEYWORD1 void KEYWORD2 NAME(TexGenfvOES)(GLenum coord, GLenum pname, const GLfloat * params); + +KEYWORD1 void KEYWORD2 NAME(TexGenfvOES)(GLenum coord, GLenum pname, const GLfloat * params) +{ + DISPATCH(TexGenfvOES, (coord, pname, params), (F, "glTexGenfvOES(0x%x, 0x%x, %p);\n", coord, pname, (const void *) params)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_191)(GLenum coord, GLenum pname, const GLfloat * params); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_191)(GLenum coord, GLenum pname, const GLfloat * params) +{ + DISPATCH(TexGenfvOES, (coord, pname, params), (F, "glTexGenfv(0x%x, 0x%x, %p);\n", coord, pname, (const void *) params)); +} + +KEYWORD1 void KEYWORD2 NAME(TexGeniOES)(GLenum coord, GLenum pname, GLint param); + +KEYWORD1 void KEYWORD2 NAME(TexGeniOES)(GLenum coord, GLenum pname, GLint param) +{ + DISPATCH(TexGeniOES, (coord, pname, param), (F, "glTexGeniOES(0x%x, 0x%x, %d);\n", coord, pname, param)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_192)(GLenum coord, GLenum pname, GLint param); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_192)(GLenum coord, GLenum pname, GLint param) +{ + DISPATCH(TexGeniOES, (coord, pname, param), (F, "glTexGeni(0x%x, 0x%x, %d);\n", coord, pname, param)); +} + +KEYWORD1 void KEYWORD2 NAME(TexGenivOES)(GLenum coord, GLenum pname, const GLint * params); + +KEYWORD1 void KEYWORD2 NAME(TexGenivOES)(GLenum coord, GLenum pname, const GLint * params) +{ + DISPATCH(TexGenivOES, (coord, pname, params), (F, "glTexGenivOES(0x%x, 0x%x, %p);\n", coord, pname, (const void *) params)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_193)(GLenum coord, GLenum pname, const GLint * params); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_193)(GLenum coord, GLenum pname, const GLint * params) +{ + DISPATCH(TexGenivOES, (coord, pname, params), (F, "glTexGeniv(0x%x, 0x%x, %p);\n", coord, pname, (const void *) params)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_194)(GLsizei size, GLenum type, GLfloat * buffer); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_194)(GLsizei size, GLenum type, GLfloat * buffer) +{ + DISPATCH(FeedbackBuffer, (size, type, buffer), (F, "glFeedbackBuffer(%d, 0x%x, %p);\n", size, type, (const void *) buffer)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_195)(GLsizei size, GLuint * buffer); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_195)(GLsizei size, GLuint * buffer) +{ + DISPATCH(SelectBuffer, (size, buffer), (F, "glSelectBuffer(%d, %p);\n", size, (const void *) buffer)); +} + +KEYWORD1_ALT GLint KEYWORD2 NAME(_dispatch_stub_196)(GLenum mode); + +KEYWORD1_ALT GLint KEYWORD2 NAME(_dispatch_stub_196)(GLenum mode) +{ + RETURN_DISPATCH(RenderMode, (mode), (F, "glRenderMode(0x%x);\n", mode)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_197)(void); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_197)(void) +{ + DISPATCH(InitNames, (), (F, "glInitNames();\n")); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_198)(GLuint name); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_198)(GLuint name) +{ + DISPATCH(LoadName, (name), (F, "glLoadName(%d);\n", name)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_199)(GLfloat token); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_199)(GLfloat token) +{ + DISPATCH(PassThrough, (token), (F, "glPassThrough(%f);\n", token)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_200)(void); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_200)(void) +{ + DISPATCH(PopName, (), (F, "glPopName();\n")); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_201)(GLuint name); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_201)(GLuint name) +{ + DISPATCH(PushName, (name), (F, "glPushName(%d);\n", name)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_202)(GLenum mode); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_202)(GLenum mode) +{ + DISPATCH(DrawBuffer, (mode), (F, "glDrawBuffer(0x%x);\n", mode)); +} + +KEYWORD1 void KEYWORD2 NAME(Clear)(GLbitfield mask) +{ + DISPATCH(Clear, (mask), (F, "glClear(%d);\n", mask)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_204)(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_204)(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha) +{ + DISPATCH(ClearAccum, (red, green, blue, alpha), (F, "glClearAccum(%f, %f, %f, %f);\n", red, green, blue, alpha)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_205)(GLfloat c); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_205)(GLfloat c) +{ + DISPATCH(ClearIndex, (c), (F, "glClearIndex(%f);\n", c)); +} + +KEYWORD1 void KEYWORD2 NAME(ClearColor)(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha) +{ + DISPATCH(ClearColor, (red, green, blue, alpha), (F, "glClearColor(%f, %f, %f, %f);\n", red, green, blue, alpha)); +} + +KEYWORD1 void KEYWORD2 NAME(ClearStencil)(GLint s) +{ + DISPATCH(ClearStencil, (s), (F, "glClearStencil(%d);\n", s)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_208)(GLclampd depth); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_208)(GLclampd depth) +{ + DISPATCH(ClearDepth, (depth), (F, "glClearDepth(%f);\n", depth)); +} + +KEYWORD1 void KEYWORD2 NAME(StencilMask)(GLuint mask) +{ + DISPATCH(StencilMask, (mask), (F, "glStencilMask(%d);\n", mask)); +} + +KEYWORD1 void KEYWORD2 NAME(ColorMask)(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha) +{ + DISPATCH(ColorMask, (red, green, blue, alpha), (F, "glColorMask(%d, %d, %d, %d);\n", red, green, blue, alpha)); +} + +KEYWORD1 void KEYWORD2 NAME(DepthMask)(GLboolean flag) +{ + DISPATCH(DepthMask, (flag), (F, "glDepthMask(%d);\n", flag)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_212)(GLuint mask); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_212)(GLuint mask) +{ + DISPATCH(IndexMask, (mask), (F, "glIndexMask(%d);\n", mask)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_213)(GLenum op, GLfloat value); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_213)(GLenum op, GLfloat value) +{ + DISPATCH(Accum, (op, value), (F, "glAccum(0x%x, %f);\n", op, value)); +} + +KEYWORD1 void KEYWORD2 NAME(Disable)(GLenum cap) +{ + DISPATCH(Disable, (cap), (F, "glDisable(0x%x);\n", cap)); +} + +KEYWORD1 void KEYWORD2 NAME(Enable)(GLenum cap) +{ + DISPATCH(Enable, (cap), (F, "glEnable(0x%x);\n", cap)); +} + +KEYWORD1 void KEYWORD2 NAME(Finish)(void) +{ + DISPATCH(Finish, (), (F, "glFinish();\n")); +} + +KEYWORD1 void KEYWORD2 NAME(Flush)(void) +{ + DISPATCH(Flush, (), (F, "glFlush();\n")); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_218)(void); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_218)(void) +{ + DISPATCH(PopAttrib, (), (F, "glPopAttrib();\n")); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_219)(GLbitfield mask); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_219)(GLbitfield mask) +{ + DISPATCH(PushAttrib, (mask), (F, "glPushAttrib(%d);\n", mask)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_220)(GLenum target, GLdouble u1, GLdouble u2, GLint stride, GLint order, const GLdouble * points); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_220)(GLenum target, GLdouble u1, GLdouble u2, GLint stride, GLint order, const GLdouble * points) +{ + DISPATCH(Map1d, (target, u1, u2, stride, order, points), (F, "glMap1d(0x%x, %f, %f, %d, %d, %p);\n", target, u1, u2, stride, order, (const void *) points)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_221)(GLenum target, GLfloat u1, GLfloat u2, GLint stride, GLint order, const GLfloat * points); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_221)(GLenum target, GLfloat u1, GLfloat u2, GLint stride, GLint order, const GLfloat * points) +{ + DISPATCH(Map1f, (target, u1, u2, stride, order, points), (F, "glMap1f(0x%x, %f, %f, %d, %d, %p);\n", target, u1, u2, stride, order, (const void *) points)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_222)(GLenum target, GLdouble u1, GLdouble u2, GLint ustride, GLint uorder, GLdouble v1, GLdouble v2, GLint vstride, GLint vorder, const GLdouble * points); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_222)(GLenum target, GLdouble u1, GLdouble u2, GLint ustride, GLint uorder, GLdouble v1, GLdouble v2, GLint vstride, GLint vorder, const GLdouble * points) +{ + DISPATCH(Map2d, (target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, points), (F, "glMap2d(0x%x, %f, %f, %d, %d, %f, %f, %d, %d, %p);\n", target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, (const void *) points)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_223)(GLenum target, GLfloat u1, GLfloat u2, GLint ustride, GLint uorder, GLfloat v1, GLfloat v2, GLint vstride, GLint vorder, const GLfloat * points); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_223)(GLenum target, GLfloat u1, GLfloat u2, GLint ustride, GLint uorder, GLfloat v1, GLfloat v2, GLint vstride, GLint vorder, const GLfloat * points) +{ + DISPATCH(Map2f, (target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, points), (F, "glMap2f(0x%x, %f, %f, %d, %d, %f, %f, %d, %d, %p);\n", target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, (const void *) points)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_224)(GLint un, GLdouble u1, GLdouble u2); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_224)(GLint un, GLdouble u1, GLdouble u2) +{ + DISPATCH(MapGrid1d, (un, u1, u2), (F, "glMapGrid1d(%d, %f, %f);\n", un, u1, u2)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_225)(GLint un, GLfloat u1, GLfloat u2); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_225)(GLint un, GLfloat u1, GLfloat u2) +{ + DISPATCH(MapGrid1f, (un, u1, u2), (F, "glMapGrid1f(%d, %f, %f);\n", un, u1, u2)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_226)(GLint un, GLdouble u1, GLdouble u2, GLint vn, GLdouble v1, GLdouble v2); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_226)(GLint un, GLdouble u1, GLdouble u2, GLint vn, GLdouble v1, GLdouble v2) +{ + DISPATCH(MapGrid2d, (un, u1, u2, vn, v1, v2), (F, "glMapGrid2d(%d, %f, %f, %d, %f, %f);\n", un, u1, u2, vn, v1, v2)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_227)(GLint un, GLfloat u1, GLfloat u2, GLint vn, GLfloat v1, GLfloat v2); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_227)(GLint un, GLfloat u1, GLfloat u2, GLint vn, GLfloat v1, GLfloat v2) +{ + DISPATCH(MapGrid2f, (un, u1, u2, vn, v1, v2), (F, "glMapGrid2f(%d, %f, %f, %d, %f, %f);\n", un, u1, u2, vn, v1, v2)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_228)(GLdouble u); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_228)(GLdouble u) +{ + DISPATCH(EvalCoord1d, (u), (F, "glEvalCoord1d(%f);\n", u)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_229)(const GLdouble * u); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_229)(const GLdouble * u) +{ + DISPATCH(EvalCoord1dv, (u), (F, "glEvalCoord1dv(%p);\n", (const void *) u)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_230)(GLfloat u); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_230)(GLfloat u) +{ + DISPATCH(EvalCoord1f, (u), (F, "glEvalCoord1f(%f);\n", u)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_231)(const GLfloat * u); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_231)(const GLfloat * u) +{ + DISPATCH(EvalCoord1fv, (u), (F, "glEvalCoord1fv(%p);\n", (const void *) u)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_232)(GLdouble u, GLdouble v); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_232)(GLdouble u, GLdouble v) +{ + DISPATCH(EvalCoord2d, (u, v), (F, "glEvalCoord2d(%f, %f);\n", u, v)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_233)(const GLdouble * u); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_233)(const GLdouble * u) +{ + DISPATCH(EvalCoord2dv, (u), (F, "glEvalCoord2dv(%p);\n", (const void *) u)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_234)(GLfloat u, GLfloat v); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_234)(GLfloat u, GLfloat v) +{ + DISPATCH(EvalCoord2f, (u, v), (F, "glEvalCoord2f(%f, %f);\n", u, v)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_235)(const GLfloat * u); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_235)(const GLfloat * u) +{ + DISPATCH(EvalCoord2fv, (u), (F, "glEvalCoord2fv(%p);\n", (const void *) u)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_236)(GLenum mode, GLint i1, GLint i2); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_236)(GLenum mode, GLint i1, GLint i2) +{ + DISPATCH(EvalMesh1, (mode, i1, i2), (F, "glEvalMesh1(0x%x, %d, %d);\n", mode, i1, i2)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_237)(GLint i); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_237)(GLint i) +{ + DISPATCH(EvalPoint1, (i), (F, "glEvalPoint1(%d);\n", i)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_238)(GLenum mode, GLint i1, GLint i2, GLint j1, GLint j2); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_238)(GLenum mode, GLint i1, GLint i2, GLint j1, GLint j2) +{ + DISPATCH(EvalMesh2, (mode, i1, i2, j1, j2), (F, "glEvalMesh2(0x%x, %d, %d, %d, %d);\n", mode, i1, i2, j1, j2)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_239)(GLint i, GLint j); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_239)(GLint i, GLint j) +{ + DISPATCH(EvalPoint2, (i, j), (F, "glEvalPoint2(%d, %d);\n", i, j)); +} + +KEYWORD1 void KEYWORD2 NAME(AlphaFunc)(GLenum func, GLclampf ref) +{ + DISPATCH(AlphaFunc, (func, ref), (F, "glAlphaFunc(0x%x, %f);\n", func, ref)); +} + +KEYWORD1 void KEYWORD2 NAME(BlendFunc)(GLenum sfactor, GLenum dfactor) +{ + DISPATCH(BlendFunc, (sfactor, dfactor), (F, "glBlendFunc(0x%x, 0x%x);\n", sfactor, dfactor)); +} + +KEYWORD1 void KEYWORD2 NAME(LogicOp)(GLenum opcode) +{ + DISPATCH(LogicOp, (opcode), (F, "glLogicOp(0x%x);\n", opcode)); +} + +KEYWORD1 void KEYWORD2 NAME(StencilFunc)(GLenum func, GLint ref, GLuint mask) +{ + DISPATCH(StencilFunc, (func, ref, mask), (F, "glStencilFunc(0x%x, %d, %d);\n", func, ref, mask)); +} + +KEYWORD1 void KEYWORD2 NAME(StencilOp)(GLenum fail, GLenum zfail, GLenum zpass) +{ + DISPATCH(StencilOp, (fail, zfail, zpass), (F, "glStencilOp(0x%x, 0x%x, 0x%x);\n", fail, zfail, zpass)); +} + +KEYWORD1 void KEYWORD2 NAME(DepthFunc)(GLenum func) +{ + DISPATCH(DepthFunc, (func), (F, "glDepthFunc(0x%x);\n", func)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_246)(GLfloat xfactor, GLfloat yfactor); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_246)(GLfloat xfactor, GLfloat yfactor) +{ + DISPATCH(PixelZoom, (xfactor, yfactor), (F, "glPixelZoom(%f, %f);\n", xfactor, yfactor)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_247)(GLenum pname, GLfloat param); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_247)(GLenum pname, GLfloat param) +{ + DISPATCH(PixelTransferf, (pname, param), (F, "glPixelTransferf(0x%x, %f);\n", pname, param)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_248)(GLenum pname, GLint param); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_248)(GLenum pname, GLint param) +{ + DISPATCH(PixelTransferi, (pname, param), (F, "glPixelTransferi(0x%x, %d);\n", pname, param)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_249)(GLenum pname, GLfloat param); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_249)(GLenum pname, GLfloat param) +{ + DISPATCH(PixelStoref, (pname, param), (F, "glPixelStoref(0x%x, %f);\n", pname, param)); +} + +KEYWORD1 void KEYWORD2 NAME(PixelStorei)(GLenum pname, GLint param) +{ + DISPATCH(PixelStorei, (pname, param), (F, "glPixelStorei(0x%x, %d);\n", pname, param)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_251)(GLenum map, GLsizei mapsize, const GLfloat * values); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_251)(GLenum map, GLsizei mapsize, const GLfloat * values) +{ + DISPATCH(PixelMapfv, (map, mapsize, values), (F, "glPixelMapfv(0x%x, %d, %p);\n", map, mapsize, (const void *) values)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_252)(GLenum map, GLsizei mapsize, const GLuint * values); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_252)(GLenum map, GLsizei mapsize, const GLuint * values) +{ + DISPATCH(PixelMapuiv, (map, mapsize, values), (F, "glPixelMapuiv(0x%x, %d, %p);\n", map, mapsize, (const void *) values)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_253)(GLenum map, GLsizei mapsize, const GLushort * values); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_253)(GLenum map, GLsizei mapsize, const GLushort * values) +{ + DISPATCH(PixelMapusv, (map, mapsize, values), (F, "glPixelMapusv(0x%x, %d, %p);\n", map, mapsize, (const void *) values)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_254)(GLenum mode); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_254)(GLenum mode) +{ + DISPATCH(ReadBuffer, (mode), (F, "glReadBuffer(0x%x);\n", mode)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_255)(GLint x, GLint y, GLsizei width, GLsizei height, GLenum type); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_255)(GLint x, GLint y, GLsizei width, GLsizei height, GLenum type) +{ + DISPATCH(CopyPixels, (x, y, width, height, type), (F, "glCopyPixels(%d, %d, %d, %d, 0x%x);\n", x, y, width, height, type)); +} + +KEYWORD1 void KEYWORD2 NAME(ReadPixels)(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLvoid * pixels) +{ + DISPATCH(ReadPixels, (x, y, width, height, format, type, pixels), (F, "glReadPixels(%d, %d, %d, %d, 0x%x, 0x%x, %p);\n", x, y, width, height, format, type, (const void *) pixels)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_257)(GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid * pixels); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_257)(GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid * pixels) +{ + DISPATCH(DrawPixels, (width, height, format, type, pixels), (F, "glDrawPixels(%d, %d, 0x%x, 0x%x, %p);\n", width, height, format, type, (const void *) pixels)); +} + +KEYWORD1 void KEYWORD2 NAME(GetBooleanv)(GLenum pname, GLboolean * params) +{ + DISPATCH(GetBooleanv, (pname, params), (F, "glGetBooleanv(0x%x, %p);\n", pname, (const void *) params)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_259)(GLenum plane, GLdouble * equation); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_259)(GLenum plane, GLdouble * equation) +{ + DISPATCH(GetClipPlane, (plane, equation), (F, "glGetClipPlane(0x%x, %p);\n", plane, (const void *) equation)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_260)(GLenum pname, GLdouble * params); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_260)(GLenum pname, GLdouble * params) +{ + DISPATCH(GetDoublev, (pname, params), (F, "glGetDoublev(0x%x, %p);\n", pname, (const void *) params)); +} + +KEYWORD1 GLenum KEYWORD2 NAME(GetError)(void) +{ + RETURN_DISPATCH(GetError, (), (F, "glGetError();\n")); +} + +KEYWORD1 void KEYWORD2 NAME(GetFloatv)(GLenum pname, GLfloat * params) +{ + DISPATCH(GetFloatv, (pname, params), (F, "glGetFloatv(0x%x, %p);\n", pname, (const void *) params)); +} + +KEYWORD1 void KEYWORD2 NAME(GetIntegerv)(GLenum pname, GLint * params) +{ + DISPATCH(GetIntegerv, (pname, params), (F, "glGetIntegerv(0x%x, %p);\n", pname, (const void *) params)); +} + +KEYWORD1 void KEYWORD2 NAME(GetLightfv)(GLenum light, GLenum pname, GLfloat * params) +{ + DISPATCH(GetLightfv, (light, pname, params), (F, "glGetLightfv(0x%x, 0x%x, %p);\n", light, pname, (const void *) params)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_265)(GLenum light, GLenum pname, GLint * params); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_265)(GLenum light, GLenum pname, GLint * params) +{ + DISPATCH(GetLightiv, (light, pname, params), (F, "glGetLightiv(0x%x, 0x%x, %p);\n", light, pname, (const void *) params)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_266)(GLenum target, GLenum query, GLdouble * v); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_266)(GLenum target, GLenum query, GLdouble * v) +{ + DISPATCH(GetMapdv, (target, query, v), (F, "glGetMapdv(0x%x, 0x%x, %p);\n", target, query, (const void *) v)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_267)(GLenum target, GLenum query, GLfloat * v); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_267)(GLenum target, GLenum query, GLfloat * v) +{ + DISPATCH(GetMapfv, (target, query, v), (F, "glGetMapfv(0x%x, 0x%x, %p);\n", target, query, (const void *) v)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_268)(GLenum target, GLenum query, GLint * v); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_268)(GLenum target, GLenum query, GLint * v) +{ + DISPATCH(GetMapiv, (target, query, v), (F, "glGetMapiv(0x%x, 0x%x, %p);\n", target, query, (const void *) v)); +} + +KEYWORD1 void KEYWORD2 NAME(GetMaterialfv)(GLenum face, GLenum pname, GLfloat * params) +{ + DISPATCH(GetMaterialfv, (face, pname, params), (F, "glGetMaterialfv(0x%x, 0x%x, %p);\n", face, pname, (const void *) params)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_270)(GLenum face, GLenum pname, GLint * params); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_270)(GLenum face, GLenum pname, GLint * params) +{ + DISPATCH(GetMaterialiv, (face, pname, params), (F, "glGetMaterialiv(0x%x, 0x%x, %p);\n", face, pname, (const void *) params)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_271)(GLenum map, GLfloat * values); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_271)(GLenum map, GLfloat * values) +{ + DISPATCH(GetPixelMapfv, (map, values), (F, "glGetPixelMapfv(0x%x, %p);\n", map, (const void *) values)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_272)(GLenum map, GLuint * values); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_272)(GLenum map, GLuint * values) +{ + DISPATCH(GetPixelMapuiv, (map, values), (F, "glGetPixelMapuiv(0x%x, %p);\n", map, (const void *) values)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_273)(GLenum map, GLushort * values); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_273)(GLenum map, GLushort * values) +{ + DISPATCH(GetPixelMapusv, (map, values), (F, "glGetPixelMapusv(0x%x, %p);\n", map, (const void *) values)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_274)(GLubyte * mask); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_274)(GLubyte * mask) +{ + DISPATCH(GetPolygonStipple, (mask), (F, "glGetPolygonStipple(%p);\n", (const void *) mask)); +} + +KEYWORD1 const GLubyte * KEYWORD2 NAME(GetString)(GLenum name) +{ + RETURN_DISPATCH(GetString, (name), (F, "glGetString(0x%x);\n", name)); +} + +KEYWORD1 void KEYWORD2 NAME(GetTexEnvfv)(GLenum target, GLenum pname, GLfloat * params) +{ + DISPATCH(GetTexEnvfv, (target, pname, params), (F, "glGetTexEnvfv(0x%x, 0x%x, %p);\n", target, pname, (const void *) params)); +} + +KEYWORD1 void KEYWORD2 NAME(GetTexEnviv)(GLenum target, GLenum pname, GLint * params) +{ + DISPATCH(GetTexEnviv, (target, pname, params), (F, "glGetTexEnviv(0x%x, 0x%x, %p);\n", target, pname, (const void *) params)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_278)(GLenum coord, GLenum pname, GLdouble * params); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_278)(GLenum coord, GLenum pname, GLdouble * params) +{ + DISPATCH(GetTexGendv, (coord, pname, params), (F, "glGetTexGendv(0x%x, 0x%x, %p);\n", coord, pname, (const void *) params)); +} + +KEYWORD1 void KEYWORD2 NAME(GetTexGenfvOES)(GLenum coord, GLenum pname, GLfloat * params); + +KEYWORD1 void KEYWORD2 NAME(GetTexGenfvOES)(GLenum coord, GLenum pname, GLfloat * params) +{ + DISPATCH(GetTexGenfvOES, (coord, pname, params), (F, "glGetTexGenfvOES(0x%x, 0x%x, %p);\n", coord, pname, (const void *) params)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_279)(GLenum coord, GLenum pname, GLfloat * params); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_279)(GLenum coord, GLenum pname, GLfloat * params) +{ + DISPATCH(GetTexGenfvOES, (coord, pname, params), (F, "glGetTexGenfv(0x%x, 0x%x, %p);\n", coord, pname, (const void *) params)); +} + +KEYWORD1 void KEYWORD2 NAME(GetTexGenivOES)(GLenum coord, GLenum pname, GLint * params); + +KEYWORD1 void KEYWORD2 NAME(GetTexGenivOES)(GLenum coord, GLenum pname, GLint * params) +{ + DISPATCH(GetTexGenivOES, (coord, pname, params), (F, "glGetTexGenivOES(0x%x, 0x%x, %p);\n", coord, pname, (const void *) params)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_280)(GLenum coord, GLenum pname, GLint * params); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_280)(GLenum coord, GLenum pname, GLint * params) +{ + DISPATCH(GetTexGenivOES, (coord, pname, params), (F, "glGetTexGeniv(0x%x, 0x%x, %p);\n", coord, pname, (const void *) params)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_281)(GLenum target, GLint level, GLenum format, GLenum type, GLvoid * pixels); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_281)(GLenum target, GLint level, GLenum format, GLenum type, GLvoid * pixels) +{ + DISPATCH(GetTexImage, (target, level, format, type, pixels), (F, "glGetTexImage(0x%x, %d, 0x%x, 0x%x, %p);\n", target, level, format, type, (const void *) pixels)); +} + +KEYWORD1 void KEYWORD2 NAME(GetTexParameterfv)(GLenum target, GLenum pname, GLfloat * params) +{ + DISPATCH(GetTexParameterfv, (target, pname, params), (F, "glGetTexParameterfv(0x%x, 0x%x, %p);\n", target, pname, (const void *) params)); +} + +KEYWORD1 void KEYWORD2 NAME(GetTexParameteriv)(GLenum target, GLenum pname, GLint * params) +{ + DISPATCH(GetTexParameteriv, (target, pname, params), (F, "glGetTexParameteriv(0x%x, 0x%x, %p);\n", target, pname, (const void *) params)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_284)(GLenum target, GLint level, GLenum pname, GLfloat * params); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_284)(GLenum target, GLint level, GLenum pname, GLfloat * params) +{ + DISPATCH(GetTexLevelParameterfv, (target, level, pname, params), (F, "glGetTexLevelParameterfv(0x%x, %d, 0x%x, %p);\n", target, level, pname, (const void *) params)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_285)(GLenum target, GLint level, GLenum pname, GLint * params); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_285)(GLenum target, GLint level, GLenum pname, GLint * params) +{ + DISPATCH(GetTexLevelParameteriv, (target, level, pname, params), (F, "glGetTexLevelParameteriv(0x%x, %d, 0x%x, %p);\n", target, level, pname, (const void *) params)); +} + +KEYWORD1 GLboolean KEYWORD2 NAME(IsEnabled)(GLenum cap) +{ + RETURN_DISPATCH(IsEnabled, (cap), (F, "glIsEnabled(0x%x);\n", cap)); +} + +KEYWORD1_ALT GLboolean KEYWORD2 NAME(_dispatch_stub_287)(GLuint list); + +KEYWORD1_ALT GLboolean KEYWORD2 NAME(_dispatch_stub_287)(GLuint list) +{ + RETURN_DISPATCH(IsList, (list), (F, "glIsList(%d);\n", list)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_288)(GLclampd zNear, GLclampd zFar); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_288)(GLclampd zNear, GLclampd zFar) +{ + DISPATCH(DepthRange, (zNear, zFar), (F, "glDepthRange(%f, %f);\n", zNear, zFar)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_289)(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_289)(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar) +{ + DISPATCH(Frustum, (left, right, bottom, top, zNear, zFar), (F, "glFrustum(%f, %f, %f, %f, %f, %f);\n", left, right, bottom, top, zNear, zFar)); +} + +KEYWORD1 void KEYWORD2 NAME(LoadIdentity)(void) +{ + DISPATCH(LoadIdentity, (), (F, "glLoadIdentity();\n")); +} + +KEYWORD1 void KEYWORD2 NAME(LoadMatrixf)(const GLfloat * m) +{ + DISPATCH(LoadMatrixf, (m), (F, "glLoadMatrixf(%p);\n", (const void *) m)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_292)(const GLdouble * m); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_292)(const GLdouble * m) +{ + DISPATCH(LoadMatrixd, (m), (F, "glLoadMatrixd(%p);\n", (const void *) m)); +} + +KEYWORD1 void KEYWORD2 NAME(MatrixMode)(GLenum mode) +{ + DISPATCH(MatrixMode, (mode), (F, "glMatrixMode(0x%x);\n", mode)); +} + +KEYWORD1 void KEYWORD2 NAME(MultMatrixf)(const GLfloat * m) +{ + DISPATCH(MultMatrixf, (m), (F, "glMultMatrixf(%p);\n", (const void *) m)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_295)(const GLdouble * m); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_295)(const GLdouble * m) +{ + DISPATCH(MultMatrixd, (m), (F, "glMultMatrixd(%p);\n", (const void *) m)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_296)(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_296)(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar) +{ + DISPATCH(Ortho, (left, right, bottom, top, zNear, zFar), (F, "glOrtho(%f, %f, %f, %f, %f, %f);\n", left, right, bottom, top, zNear, zFar)); +} + +KEYWORD1 void KEYWORD2 NAME(PopMatrix)(void) +{ + DISPATCH(PopMatrix, (), (F, "glPopMatrix();\n")); +} + +KEYWORD1 void KEYWORD2 NAME(PushMatrix)(void) +{ + DISPATCH(PushMatrix, (), (F, "glPushMatrix();\n")); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_299)(GLdouble angle, GLdouble x, GLdouble y, GLdouble z); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_299)(GLdouble angle, GLdouble x, GLdouble y, GLdouble z) +{ + DISPATCH(Rotated, (angle, x, y, z), (F, "glRotated(%f, %f, %f, %f);\n", angle, x, y, z)); +} + +KEYWORD1 void KEYWORD2 NAME(Rotatef)(GLfloat angle, GLfloat x, GLfloat y, GLfloat z) +{ + DISPATCH(Rotatef, (angle, x, y, z), (F, "glRotatef(%f, %f, %f, %f);\n", angle, x, y, z)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_301)(GLdouble x, GLdouble y, GLdouble z); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_301)(GLdouble x, GLdouble y, GLdouble z) +{ + DISPATCH(Scaled, (x, y, z), (F, "glScaled(%f, %f, %f);\n", x, y, z)); +} + +KEYWORD1 void KEYWORD2 NAME(Scalef)(GLfloat x, GLfloat y, GLfloat z) +{ + DISPATCH(Scalef, (x, y, z), (F, "glScalef(%f, %f, %f);\n", x, y, z)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_303)(GLdouble x, GLdouble y, GLdouble z); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_303)(GLdouble x, GLdouble y, GLdouble z) +{ + DISPATCH(Translated, (x, y, z), (F, "glTranslated(%f, %f, %f);\n", x, y, z)); +} + +KEYWORD1 void KEYWORD2 NAME(Translatef)(GLfloat x, GLfloat y, GLfloat z) +{ + DISPATCH(Translatef, (x, y, z), (F, "glTranslatef(%f, %f, %f);\n", x, y, z)); +} + +KEYWORD1 void KEYWORD2 NAME(Viewport)(GLint x, GLint y, GLsizei width, GLsizei height) +{ + DISPATCH(Viewport, (x, y, width, height), (F, "glViewport(%d, %d, %d, %d);\n", x, y, width, height)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_306)(GLint i); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_306)(GLint i) +{ + DISPATCH(ArrayElement, (i), (F, "glArrayElement(%d);\n", i)); +} + +KEYWORD1 void KEYWORD2 NAME(BindTexture)(GLenum target, GLuint texture) +{ + DISPATCH(BindTexture, (target, texture), (F, "glBindTexture(0x%x, %d);\n", target, texture)); +} + +KEYWORD1 void KEYWORD2 NAME(ColorPointer)(GLint size, GLenum type, GLsizei stride, const GLvoid * pointer) +{ + DISPATCH(ColorPointer, (size, type, stride, pointer), (F, "glColorPointer(%d, 0x%x, %d, %p);\n", size, type, stride, (const void *) pointer)); +} + +KEYWORD1 void KEYWORD2 NAME(DisableClientState)(GLenum array) +{ + DISPATCH(DisableClientState, (array), (F, "glDisableClientState(0x%x);\n", array)); +} + +KEYWORD1 void KEYWORD2 NAME(DrawArrays)(GLenum mode, GLint first, GLsizei count) +{ + DISPATCH(DrawArrays, (mode, first, count), (F, "glDrawArrays(0x%x, %d, %d);\n", mode, first, count)); +} + +KEYWORD1 void KEYWORD2 NAME(DrawElements)(GLenum mode, GLsizei count, GLenum type, const GLvoid * indices) +{ + DISPATCH(DrawElements, (mode, count, type, indices), (F, "glDrawElements(0x%x, %d, 0x%x, %p);\n", mode, count, type, (const void *) indices)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_312)(GLsizei stride, const GLvoid * pointer); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_312)(GLsizei stride, const GLvoid * pointer) +{ + DISPATCH(EdgeFlagPointer, (stride, pointer), (F, "glEdgeFlagPointer(%d, %p);\n", stride, (const void *) pointer)); +} + +KEYWORD1 void KEYWORD2 NAME(EnableClientState)(GLenum array) +{ + DISPATCH(EnableClientState, (array), (F, "glEnableClientState(0x%x);\n", array)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_314)(GLenum type, GLsizei stride, const GLvoid * pointer); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_314)(GLenum type, GLsizei stride, const GLvoid * pointer) +{ + DISPATCH(IndexPointer, (type, stride, pointer), (F, "glIndexPointer(0x%x, %d, %p);\n", type, stride, (const void *) pointer)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_315)(GLubyte c); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_315)(GLubyte c) +{ + DISPATCH(Indexub, (c), (F, "glIndexub(%d);\n", c)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_316)(const GLubyte * c); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_316)(const GLubyte * c) +{ + DISPATCH(Indexubv, (c), (F, "glIndexubv(%p);\n", (const void *) c)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_317)(GLenum format, GLsizei stride, const GLvoid * pointer); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_317)(GLenum format, GLsizei stride, const GLvoid * pointer) +{ + DISPATCH(InterleavedArrays, (format, stride, pointer), (F, "glInterleavedArrays(0x%x, %d, %p);\n", format, stride, (const void *) pointer)); +} + +KEYWORD1 void KEYWORD2 NAME(NormalPointer)(GLenum type, GLsizei stride, const GLvoid * pointer) +{ + DISPATCH(NormalPointer, (type, stride, pointer), (F, "glNormalPointer(0x%x, %d, %p);\n", type, stride, (const void *) pointer)); +} + +KEYWORD1 void KEYWORD2 NAME(PolygonOffset)(GLfloat factor, GLfloat units) +{ + DISPATCH(PolygonOffset, (factor, units), (F, "glPolygonOffset(%f, %f);\n", factor, units)); +} + +KEYWORD1 void KEYWORD2 NAME(TexCoordPointer)(GLint size, GLenum type, GLsizei stride, const GLvoid * pointer) +{ + DISPATCH(TexCoordPointer, (size, type, stride, pointer), (F, "glTexCoordPointer(%d, 0x%x, %d, %p);\n", size, type, stride, (const void *) pointer)); +} + +KEYWORD1 void KEYWORD2 NAME(VertexPointer)(GLint size, GLenum type, GLsizei stride, const GLvoid * pointer) +{ + DISPATCH(VertexPointer, (size, type, stride, pointer), (F, "glVertexPointer(%d, 0x%x, %d, %p);\n", size, type, stride, (const void *) pointer)); +} + +KEYWORD1_ALT GLboolean KEYWORD2 NAME(_dispatch_stub_322)(GLsizei n, const GLuint * textures, GLboolean * residences); + +KEYWORD1_ALT GLboolean KEYWORD2 NAME(_dispatch_stub_322)(GLsizei n, const GLuint * textures, GLboolean * residences) +{ + RETURN_DISPATCH(AreTexturesResident, (n, textures, residences), (F, "glAreTexturesResident(%d, %p, %p);\n", n, (const void *) textures, (const void *) residences)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_323)(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLint border); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_323)(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLint border) +{ + DISPATCH(CopyTexImage1D, (target, level, internalformat, x, y, width, border), (F, "glCopyTexImage1D(0x%x, %d, 0x%x, %d, %d, %d, %d);\n", target, level, internalformat, x, y, width, border)); +} + +KEYWORD1 void KEYWORD2 NAME(CopyTexImage2D)(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border) +{ + DISPATCH(CopyTexImage2D, (target, level, internalformat, x, y, width, height, border), (F, "glCopyTexImage2D(0x%x, %d, 0x%x, %d, %d, %d, %d, %d);\n", target, level, internalformat, x, y, width, height, border)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_325)(GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_325)(GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width) +{ + DISPATCH(CopyTexSubImage1D, (target, level, xoffset, x, y, width), (F, "glCopyTexSubImage1D(0x%x, %d, %d, %d, %d, %d);\n", target, level, xoffset, x, y, width)); +} + +KEYWORD1 void KEYWORD2 NAME(CopyTexSubImage2D)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height) +{ + DISPATCH(CopyTexSubImage2D, (target, level, xoffset, yoffset, x, y, width, height), (F, "glCopyTexSubImage2D(0x%x, %d, %d, %d, %d, %d, %d, %d);\n", target, level, xoffset, yoffset, x, y, width, height)); +} + +KEYWORD1 void KEYWORD2 NAME(DeleteTextures)(GLsizei n, const GLuint * textures) +{ + DISPATCH(DeleteTextures, (n, textures), (F, "glDeleteTextures(%d, %p);\n", n, (const void *) textures)); +} + +KEYWORD1 void KEYWORD2 NAME(GenTextures)(GLsizei n, GLuint * textures) +{ + DISPATCH(GenTextures, (n, textures), (F, "glGenTextures(%d, %p);\n", n, (const void *) textures)); +} + +KEYWORD1 void KEYWORD2 NAME(GetPointerv)(GLenum pname, GLvoid ** params) +{ + DISPATCH(GetPointerv, (pname, params), (F, "glGetPointerv(0x%x, %p);\n", pname, (const void *) params)); +} + +KEYWORD1 GLboolean KEYWORD2 NAME(IsTexture)(GLuint texture) +{ + RETURN_DISPATCH(IsTexture, (texture), (F, "glIsTexture(%d);\n", texture)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_331)(GLsizei n, const GLuint * textures, const GLclampf * priorities); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_331)(GLsizei n, const GLuint * textures, const GLclampf * priorities) +{ + DISPATCH(PrioritizeTextures, (n, textures, priorities), (F, "glPrioritizeTextures(%d, %p, %p);\n", n, (const void *) textures, (const void *) priorities)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_332)(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const GLvoid * pixels); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_332)(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const GLvoid * pixels) +{ + DISPATCH(TexSubImage1D, (target, level, xoffset, width, format, type, pixels), (F, "glTexSubImage1D(0x%x, %d, %d, %d, 0x%x, 0x%x, %p);\n", target, level, xoffset, width, format, type, (const void *) pixels)); +} + +KEYWORD1 void KEYWORD2 NAME(TexSubImage2D)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid * pixels) +{ + DISPATCH(TexSubImage2D, (target, level, xoffset, yoffset, width, height, format, type, pixels), (F, "glTexSubImage2D(0x%x, %d, %d, %d, %d, %d, 0x%x, 0x%x, %p);\n", target, level, xoffset, yoffset, width, height, format, type, (const void *) pixels)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_334)(void); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_334)(void) +{ + DISPATCH(PopClientAttrib, (), (F, "glPopClientAttrib();\n")); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_335)(GLbitfield mask); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_335)(GLbitfield mask) +{ + DISPATCH(PushClientAttrib, (mask), (F, "glPushClientAttrib(%d);\n", mask)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_336)(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_336)(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha) +{ + DISPATCH(BlendColor, (red, green, blue, alpha), (F, "glBlendColor(%f, %f, %f, %f);\n", red, green, blue, alpha)); +} + +KEYWORD1 void KEYWORD2 NAME(BlendEquationOES)(GLenum mode); + +KEYWORD1 void KEYWORD2 NAME(BlendEquationOES)(GLenum mode) +{ + DISPATCH(BlendEquationOES, (mode), (F, "glBlendEquationOES(0x%x);\n", mode)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_337)(GLenum mode); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_337)(GLenum mode) +{ + DISPATCH(BlendEquationOES, (mode), (F, "glBlendEquation(0x%x);\n", mode)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_338)(GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const GLvoid * indices); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_338)(GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const GLvoid * indices) +{ + DISPATCH(DrawRangeElements, (mode, start, end, count, type, indices), (F, "glDrawRangeElements(0x%x, %d, %d, %d, 0x%x, %p);\n", mode, start, end, count, type, (const void *) indices)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_339)(GLenum target, GLenum internalformat, GLsizei width, GLenum format, GLenum type, const GLvoid * table); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_339)(GLenum target, GLenum internalformat, GLsizei width, GLenum format, GLenum type, const GLvoid * table) +{ + DISPATCH(ColorTable, (target, internalformat, width, format, type, table), (F, "glColorTable(0x%x, 0x%x, %d, 0x%x, 0x%x, %p);\n", target, internalformat, width, format, type, (const void *) table)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_340)(GLenum target, GLenum pname, const GLfloat * params); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_340)(GLenum target, GLenum pname, const GLfloat * params) +{ + DISPATCH(ColorTableParameterfv, (target, pname, params), (F, "glColorTableParameterfv(0x%x, 0x%x, %p);\n", target, pname, (const void *) params)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_341)(GLenum target, GLenum pname, const GLint * params); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_341)(GLenum target, GLenum pname, const GLint * params) +{ + DISPATCH(ColorTableParameteriv, (target, pname, params), (F, "glColorTableParameteriv(0x%x, 0x%x, %p);\n", target, pname, (const void *) params)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_342)(GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_342)(GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width) +{ + DISPATCH(CopyColorTable, (target, internalformat, x, y, width), (F, "glCopyColorTable(0x%x, 0x%x, %d, %d, %d);\n", target, internalformat, x, y, width)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_343)(GLenum target, GLenum format, GLenum type, GLvoid * table); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_343)(GLenum target, GLenum format, GLenum type, GLvoid * table) +{ + DISPATCH(GetColorTable, (target, format, type, table), (F, "glGetColorTable(0x%x, 0x%x, 0x%x, %p);\n", target, format, type, (const void *) table)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_344)(GLenum target, GLenum pname, GLfloat * params); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_344)(GLenum target, GLenum pname, GLfloat * params) +{ + DISPATCH(GetColorTableParameterfv, (target, pname, params), (F, "glGetColorTableParameterfv(0x%x, 0x%x, %p);\n", target, pname, (const void *) params)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_345)(GLenum target, GLenum pname, GLint * params); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_345)(GLenum target, GLenum pname, GLint * params) +{ + DISPATCH(GetColorTableParameteriv, (target, pname, params), (F, "glGetColorTableParameteriv(0x%x, 0x%x, %p);\n", target, pname, (const void *) params)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_346)(GLenum target, GLsizei start, GLsizei count, GLenum format, GLenum type, const GLvoid * data); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_346)(GLenum target, GLsizei start, GLsizei count, GLenum format, GLenum type, const GLvoid * data) +{ + DISPATCH(ColorSubTable, (target, start, count, format, type, data), (F, "glColorSubTable(0x%x, %d, %d, 0x%x, 0x%x, %p);\n", target, start, count, format, type, (const void *) data)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_347)(GLenum target, GLsizei start, GLint x, GLint y, GLsizei width); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_347)(GLenum target, GLsizei start, GLint x, GLint y, GLsizei width) +{ + DISPATCH(CopyColorSubTable, (target, start, x, y, width), (F, "glCopyColorSubTable(0x%x, %d, %d, %d, %d);\n", target, start, x, y, width)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_348)(GLenum target, GLenum internalformat, GLsizei width, GLenum format, GLenum type, const GLvoid * image); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_348)(GLenum target, GLenum internalformat, GLsizei width, GLenum format, GLenum type, const GLvoid * image) +{ + DISPATCH(ConvolutionFilter1D, (target, internalformat, width, format, type, image), (F, "glConvolutionFilter1D(0x%x, 0x%x, %d, 0x%x, 0x%x, %p);\n", target, internalformat, width, format, type, (const void *) image)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_349)(GLenum target, GLenum internalformat, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid * image); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_349)(GLenum target, GLenum internalformat, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid * image) +{ + DISPATCH(ConvolutionFilter2D, (target, internalformat, width, height, format, type, image), (F, "glConvolutionFilter2D(0x%x, 0x%x, %d, %d, 0x%x, 0x%x, %p);\n", target, internalformat, width, height, format, type, (const void *) image)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_350)(GLenum target, GLenum pname, GLfloat params); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_350)(GLenum target, GLenum pname, GLfloat params) +{ + DISPATCH(ConvolutionParameterf, (target, pname, params), (F, "glConvolutionParameterf(0x%x, 0x%x, %f);\n", target, pname, params)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_351)(GLenum target, GLenum pname, const GLfloat * params); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_351)(GLenum target, GLenum pname, const GLfloat * params) +{ + DISPATCH(ConvolutionParameterfv, (target, pname, params), (F, "glConvolutionParameterfv(0x%x, 0x%x, %p);\n", target, pname, (const void *) params)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_352)(GLenum target, GLenum pname, GLint params); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_352)(GLenum target, GLenum pname, GLint params) +{ + DISPATCH(ConvolutionParameteri, (target, pname, params), (F, "glConvolutionParameteri(0x%x, 0x%x, %d);\n", target, pname, params)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_353)(GLenum target, GLenum pname, const GLint * params); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_353)(GLenum target, GLenum pname, const GLint * params) +{ + DISPATCH(ConvolutionParameteriv, (target, pname, params), (F, "glConvolutionParameteriv(0x%x, 0x%x, %p);\n", target, pname, (const void *) params)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_354)(GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_354)(GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width) +{ + DISPATCH(CopyConvolutionFilter1D, (target, internalformat, x, y, width), (F, "glCopyConvolutionFilter1D(0x%x, 0x%x, %d, %d, %d);\n", target, internalformat, x, y, width)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_355)(GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_355)(GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height) +{ + DISPATCH(CopyConvolutionFilter2D, (target, internalformat, x, y, width, height), (F, "glCopyConvolutionFilter2D(0x%x, 0x%x, %d, %d, %d, %d);\n", target, internalformat, x, y, width, height)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_356)(GLenum target, GLenum format, GLenum type, GLvoid * image); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_356)(GLenum target, GLenum format, GLenum type, GLvoid * image) +{ + DISPATCH(GetConvolutionFilter, (target, format, type, image), (F, "glGetConvolutionFilter(0x%x, 0x%x, 0x%x, %p);\n", target, format, type, (const void *) image)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_357)(GLenum target, GLenum pname, GLfloat * params); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_357)(GLenum target, GLenum pname, GLfloat * params) +{ + DISPATCH(GetConvolutionParameterfv, (target, pname, params), (F, "glGetConvolutionParameterfv(0x%x, 0x%x, %p);\n", target, pname, (const void *) params)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_358)(GLenum target, GLenum pname, GLint * params); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_358)(GLenum target, GLenum pname, GLint * params) +{ + DISPATCH(GetConvolutionParameteriv, (target, pname, params), (F, "glGetConvolutionParameteriv(0x%x, 0x%x, %p);\n", target, pname, (const void *) params)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_359)(GLenum target, GLenum format, GLenum type, GLvoid * row, GLvoid * column, GLvoid * span); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_359)(GLenum target, GLenum format, GLenum type, GLvoid * row, GLvoid * column, GLvoid * span) +{ + DISPATCH(GetSeparableFilter, (target, format, type, row, column, span), (F, "glGetSeparableFilter(0x%x, 0x%x, 0x%x, %p, %p, %p);\n", target, format, type, (const void *) row, (const void *) column, (const void *) span)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_360)(GLenum target, GLenum internalformat, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid * row, const GLvoid * column); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_360)(GLenum target, GLenum internalformat, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid * row, const GLvoid * column) +{ + DISPATCH(SeparableFilter2D, (target, internalformat, width, height, format, type, row, column), (F, "glSeparableFilter2D(0x%x, 0x%x, %d, %d, 0x%x, 0x%x, %p, %p);\n", target, internalformat, width, height, format, type, (const void *) row, (const void *) column)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_361)(GLenum target, GLboolean reset, GLenum format, GLenum type, GLvoid * values); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_361)(GLenum target, GLboolean reset, GLenum format, GLenum type, GLvoid * values) +{ + DISPATCH(GetHistogram, (target, reset, format, type, values), (F, "glGetHistogram(0x%x, %d, 0x%x, 0x%x, %p);\n", target, reset, format, type, (const void *) values)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_362)(GLenum target, GLenum pname, GLfloat * params); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_362)(GLenum target, GLenum pname, GLfloat * params) +{ + DISPATCH(GetHistogramParameterfv, (target, pname, params), (F, "glGetHistogramParameterfv(0x%x, 0x%x, %p);\n", target, pname, (const void *) params)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_363)(GLenum target, GLenum pname, GLint * params); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_363)(GLenum target, GLenum pname, GLint * params) +{ + DISPATCH(GetHistogramParameteriv, (target, pname, params), (F, "glGetHistogramParameteriv(0x%x, 0x%x, %p);\n", target, pname, (const void *) params)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_364)(GLenum target, GLboolean reset, GLenum format, GLenum type, GLvoid * values); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_364)(GLenum target, GLboolean reset, GLenum format, GLenum type, GLvoid * values) +{ + DISPATCH(GetMinmax, (target, reset, format, type, values), (F, "glGetMinmax(0x%x, %d, 0x%x, 0x%x, %p);\n", target, reset, format, type, (const void *) values)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_365)(GLenum target, GLenum pname, GLfloat * params); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_365)(GLenum target, GLenum pname, GLfloat * params) +{ + DISPATCH(GetMinmaxParameterfv, (target, pname, params), (F, "glGetMinmaxParameterfv(0x%x, 0x%x, %p);\n", target, pname, (const void *) params)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_366)(GLenum target, GLenum pname, GLint * params); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_366)(GLenum target, GLenum pname, GLint * params) +{ + DISPATCH(GetMinmaxParameteriv, (target, pname, params), (F, "glGetMinmaxParameteriv(0x%x, 0x%x, %p);\n", target, pname, (const void *) params)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_367)(GLenum target, GLsizei width, GLenum internalformat, GLboolean sink); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_367)(GLenum target, GLsizei width, GLenum internalformat, GLboolean sink) +{ + DISPATCH(Histogram, (target, width, internalformat, sink), (F, "glHistogram(0x%x, %d, 0x%x, %d);\n", target, width, internalformat, sink)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_368)(GLenum target, GLenum internalformat, GLboolean sink); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_368)(GLenum target, GLenum internalformat, GLboolean sink) +{ + DISPATCH(Minmax, (target, internalformat, sink), (F, "glMinmax(0x%x, 0x%x, %d);\n", target, internalformat, sink)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_369)(GLenum target); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_369)(GLenum target) +{ + DISPATCH(ResetHistogram, (target), (F, "glResetHistogram(0x%x);\n", target)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_370)(GLenum target); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_370)(GLenum target) +{ + DISPATCH(ResetMinmax, (target), (F, "glResetMinmax(0x%x);\n", target)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_371)(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const GLvoid * pixels); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_371)(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const GLvoid * pixels) +{ + DISPATCH(TexImage3D, (target, level, internalformat, width, height, depth, border, format, type, pixels), (F, "glTexImage3D(0x%x, %d, %d, %d, %d, %d, %d, 0x%x, 0x%x, %p);\n", target, level, internalformat, width, height, depth, border, format, type, (const void *) pixels)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_372)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const GLvoid * pixels); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_372)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const GLvoid * pixels) +{ + DISPATCH(TexSubImage3D, (target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, pixels), (F, "glTexSubImage3D(0x%x, %d, %d, %d, %d, %d, %d, %d, 0x%x, 0x%x, %p);\n", target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, (const void *) pixels)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_373)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_373)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height) +{ + DISPATCH(CopyTexSubImage3D, (target, level, xoffset, yoffset, zoffset, x, y, width, height), (F, "glCopyTexSubImage3D(0x%x, %d, %d, %d, %d, %d, %d, %d, %d);\n", target, level, xoffset, yoffset, zoffset, x, y, width, height)); +} + +KEYWORD1 void KEYWORD2 NAME(ActiveTexture)(GLenum texture) +{ + DISPATCH(ActiveTexture, (texture), (F, "glActiveTexture(0x%x);\n", texture)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_374)(GLenum texture); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_374)(GLenum texture) +{ + DISPATCH(ActiveTexture, (texture), (F, "glActiveTextureARB(0x%x);\n", texture)); +} + +KEYWORD1 void KEYWORD2 NAME(ClientActiveTexture)(GLenum texture) +{ + DISPATCH(ClientActiveTexture, (texture), (F, "glClientActiveTexture(0x%x);\n", texture)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_375)(GLenum texture); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_375)(GLenum texture) +{ + DISPATCH(ClientActiveTexture, (texture), (F, "glClientActiveTextureARB(0x%x);\n", texture)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_376)(GLenum target, GLdouble s); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_376)(GLenum target, GLdouble s) +{ + DISPATCH(MultiTexCoord1dARB, (target, s), (F, "glMultiTexCoord1dARB(0x%x, %f);\n", target, s)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_377)(GLenum target, const GLdouble * v); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_377)(GLenum target, const GLdouble * v) +{ + DISPATCH(MultiTexCoord1dvARB, (target, v), (F, "glMultiTexCoord1dvARB(0x%x, %p);\n", target, (const void *) v)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_378)(GLenum target, GLfloat s); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_378)(GLenum target, GLfloat s) +{ + DISPATCH(MultiTexCoord1fARB, (target, s), (F, "glMultiTexCoord1fARB(0x%x, %f);\n", target, s)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_379)(GLenum target, const GLfloat * v); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_379)(GLenum target, const GLfloat * v) +{ + DISPATCH(MultiTexCoord1fvARB, (target, v), (F, "glMultiTexCoord1fvARB(0x%x, %p);\n", target, (const void *) v)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_380)(GLenum target, GLint s); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_380)(GLenum target, GLint s) +{ + DISPATCH(MultiTexCoord1iARB, (target, s), (F, "glMultiTexCoord1iARB(0x%x, %d);\n", target, s)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_381)(GLenum target, const GLint * v); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_381)(GLenum target, const GLint * v) +{ + DISPATCH(MultiTexCoord1ivARB, (target, v), (F, "glMultiTexCoord1ivARB(0x%x, %p);\n", target, (const void *) v)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_382)(GLenum target, GLshort s); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_382)(GLenum target, GLshort s) +{ + DISPATCH(MultiTexCoord1sARB, (target, s), (F, "glMultiTexCoord1sARB(0x%x, %d);\n", target, s)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_383)(GLenum target, const GLshort * v); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_383)(GLenum target, const GLshort * v) +{ + DISPATCH(MultiTexCoord1svARB, (target, v), (F, "glMultiTexCoord1svARB(0x%x, %p);\n", target, (const void *) v)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_384)(GLenum target, GLdouble s, GLdouble t); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_384)(GLenum target, GLdouble s, GLdouble t) +{ + DISPATCH(MultiTexCoord2dARB, (target, s, t), (F, "glMultiTexCoord2dARB(0x%x, %f, %f);\n", target, s, t)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_385)(GLenum target, const GLdouble * v); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_385)(GLenum target, const GLdouble * v) +{ + DISPATCH(MultiTexCoord2dvARB, (target, v), (F, "glMultiTexCoord2dvARB(0x%x, %p);\n", target, (const void *) v)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_386)(GLenum target, GLfloat s, GLfloat t); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_386)(GLenum target, GLfloat s, GLfloat t) +{ + DISPATCH(MultiTexCoord2fARB, (target, s, t), (F, "glMultiTexCoord2fARB(0x%x, %f, %f);\n", target, s, t)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_387)(GLenum target, const GLfloat * v); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_387)(GLenum target, const GLfloat * v) +{ + DISPATCH(MultiTexCoord2fvARB, (target, v), (F, "glMultiTexCoord2fvARB(0x%x, %p);\n", target, (const void *) v)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_388)(GLenum target, GLint s, GLint t); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_388)(GLenum target, GLint s, GLint t) +{ + DISPATCH(MultiTexCoord2iARB, (target, s, t), (F, "glMultiTexCoord2iARB(0x%x, %d, %d);\n", target, s, t)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_389)(GLenum target, const GLint * v); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_389)(GLenum target, const GLint * v) +{ + DISPATCH(MultiTexCoord2ivARB, (target, v), (F, "glMultiTexCoord2ivARB(0x%x, %p);\n", target, (const void *) v)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_390)(GLenum target, GLshort s, GLshort t); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_390)(GLenum target, GLshort s, GLshort t) +{ + DISPATCH(MultiTexCoord2sARB, (target, s, t), (F, "glMultiTexCoord2sARB(0x%x, %d, %d);\n", target, s, t)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_391)(GLenum target, const GLshort * v); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_391)(GLenum target, const GLshort * v) +{ + DISPATCH(MultiTexCoord2svARB, (target, v), (F, "glMultiTexCoord2svARB(0x%x, %p);\n", target, (const void *) v)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_392)(GLenum target, GLdouble s, GLdouble t, GLdouble r); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_392)(GLenum target, GLdouble s, GLdouble t, GLdouble r) +{ + DISPATCH(MultiTexCoord3dARB, (target, s, t, r), (F, "glMultiTexCoord3dARB(0x%x, %f, %f, %f);\n", target, s, t, r)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_393)(GLenum target, const GLdouble * v); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_393)(GLenum target, const GLdouble * v) +{ + DISPATCH(MultiTexCoord3dvARB, (target, v), (F, "glMultiTexCoord3dvARB(0x%x, %p);\n", target, (const void *) v)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_394)(GLenum target, GLfloat s, GLfloat t, GLfloat r); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_394)(GLenum target, GLfloat s, GLfloat t, GLfloat r) +{ + DISPATCH(MultiTexCoord3fARB, (target, s, t, r), (F, "glMultiTexCoord3fARB(0x%x, %f, %f, %f);\n", target, s, t, r)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_395)(GLenum target, const GLfloat * v); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_395)(GLenum target, const GLfloat * v) +{ + DISPATCH(MultiTexCoord3fvARB, (target, v), (F, "glMultiTexCoord3fvARB(0x%x, %p);\n", target, (const void *) v)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_396)(GLenum target, GLint s, GLint t, GLint r); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_396)(GLenum target, GLint s, GLint t, GLint r) +{ + DISPATCH(MultiTexCoord3iARB, (target, s, t, r), (F, "glMultiTexCoord3iARB(0x%x, %d, %d, %d);\n", target, s, t, r)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_397)(GLenum target, const GLint * v); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_397)(GLenum target, const GLint * v) +{ + DISPATCH(MultiTexCoord3ivARB, (target, v), (F, "glMultiTexCoord3ivARB(0x%x, %p);\n", target, (const void *) v)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_398)(GLenum target, GLshort s, GLshort t, GLshort r); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_398)(GLenum target, GLshort s, GLshort t, GLshort r) +{ + DISPATCH(MultiTexCoord3sARB, (target, s, t, r), (F, "glMultiTexCoord3sARB(0x%x, %d, %d, %d);\n", target, s, t, r)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_399)(GLenum target, const GLshort * v); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_399)(GLenum target, const GLshort * v) +{ + DISPATCH(MultiTexCoord3svARB, (target, v), (F, "glMultiTexCoord3svARB(0x%x, %p);\n", target, (const void *) v)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_400)(GLenum target, GLdouble s, GLdouble t, GLdouble r, GLdouble q); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_400)(GLenum target, GLdouble s, GLdouble t, GLdouble r, GLdouble q) +{ + DISPATCH(MultiTexCoord4dARB, (target, s, t, r, q), (F, "glMultiTexCoord4dARB(0x%x, %f, %f, %f, %f);\n", target, s, t, r, q)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_401)(GLenum target, const GLdouble * v); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_401)(GLenum target, const GLdouble * v) +{ + DISPATCH(MultiTexCoord4dvARB, (target, v), (F, "glMultiTexCoord4dvARB(0x%x, %p);\n", target, (const void *) v)); +} + +KEYWORD1 void KEYWORD2 NAME(MultiTexCoord4f)(GLenum target, GLfloat s, GLfloat t, GLfloat r, GLfloat q) +{ + DISPATCH(MultiTexCoord4f, (target, s, t, r, q), (F, "glMultiTexCoord4f(0x%x, %f, %f, %f, %f);\n", target, s, t, r, q)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_402)(GLenum target, GLfloat s, GLfloat t, GLfloat r, GLfloat q); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_402)(GLenum target, GLfloat s, GLfloat t, GLfloat r, GLfloat q) +{ + DISPATCH(MultiTexCoord4f, (target, s, t, r, q), (F, "glMultiTexCoord4fARB(0x%x, %f, %f, %f, %f);\n", target, s, t, r, q)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_403)(GLenum target, const GLfloat * v); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_403)(GLenum target, const GLfloat * v) +{ + DISPATCH(MultiTexCoord4fvARB, (target, v), (F, "glMultiTexCoord4fvARB(0x%x, %p);\n", target, (const void *) v)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_404)(GLenum target, GLint s, GLint t, GLint r, GLint q); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_404)(GLenum target, GLint s, GLint t, GLint r, GLint q) +{ + DISPATCH(MultiTexCoord4iARB, (target, s, t, r, q), (F, "glMultiTexCoord4iARB(0x%x, %d, %d, %d, %d);\n", target, s, t, r, q)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_405)(GLenum target, const GLint * v); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_405)(GLenum target, const GLint * v) +{ + DISPATCH(MultiTexCoord4ivARB, (target, v), (F, "glMultiTexCoord4ivARB(0x%x, %p);\n", target, (const void *) v)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_406)(GLenum target, GLshort s, GLshort t, GLshort r, GLshort q); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_406)(GLenum target, GLshort s, GLshort t, GLshort r, GLshort q) +{ + DISPATCH(MultiTexCoord4sARB, (target, s, t, r, q), (F, "glMultiTexCoord4sARB(0x%x, %d, %d, %d, %d);\n", target, s, t, r, q)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_407)(GLenum target, const GLshort * v); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_407)(GLenum target, const GLshort * v) +{ + DISPATCH(MultiTexCoord4svARB, (target, v), (F, "glMultiTexCoord4svARB(0x%x, %p);\n", target, (const void *) v)); +} + +KEYWORD1 void KEYWORD2 NAME(BlendEquationSeparateOES)(GLenum modeRGB, GLenum modeA); + +KEYWORD1 void KEYWORD2 NAME(BlendEquationSeparateOES)(GLenum modeRGB, GLenum modeA) +{ + DISPATCH(BlendEquationSeparateOES, (modeRGB, modeA), (F, "glBlendEquationSeparateOES(0x%x, 0x%x);\n", modeRGB, modeA)); +} + +KEYWORD1 void KEYWORD2 NAME(BlendFuncSeparateOES)(GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha); + +KEYWORD1 void KEYWORD2 NAME(BlendFuncSeparateOES)(GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha) +{ + DISPATCH(BlendFuncSeparateOES, (sfactorRGB, dfactorRGB, sfactorAlpha, dfactorAlpha), (F, "glBlendFuncSeparateOES(0x%x, 0x%x, 0x%x, 0x%x);\n", sfactorRGB, dfactorRGB, sfactorAlpha, dfactorAlpha)); +} + +KEYWORD1 void KEYWORD2 NAME(DrawTexfOES)(GLfloat x, GLfloat y, GLfloat z, GLfloat width, GLfloat height); + +KEYWORD1 void KEYWORD2 NAME(DrawTexfOES)(GLfloat x, GLfloat y, GLfloat z, GLfloat width, GLfloat height) +{ + DISPATCH(DrawTexfOES, (x, y, z, width, height), (F, "glDrawTexfOES(%f, %f, %f, %f, %f);\n", x, y, z, width, height)); +} + +KEYWORD1 void KEYWORD2 NAME(DrawTexfvOES)(const GLfloat * coords); + +KEYWORD1 void KEYWORD2 NAME(DrawTexfvOES)(const GLfloat * coords) +{ + DISPATCH(DrawTexfvOES, (coords), (F, "glDrawTexfvOES(%p);\n", (const void *) coords)); +} + +KEYWORD1 void KEYWORD2 NAME(DrawTexiOES)(GLint x, GLint y, GLint z, GLint width, GLint height); + +KEYWORD1 void KEYWORD2 NAME(DrawTexiOES)(GLint x, GLint y, GLint z, GLint width, GLint height) +{ + DISPATCH(DrawTexiOES, (x, y, z, width, height), (F, "glDrawTexiOES(%d, %d, %d, %d, %d);\n", x, y, z, width, height)); +} + +KEYWORD1 void KEYWORD2 NAME(DrawTexivOES)(const GLint * coords); + +KEYWORD1 void KEYWORD2 NAME(DrawTexivOES)(const GLint * coords) +{ + DISPATCH(DrawTexivOES, (coords), (F, "glDrawTexivOES(%p);\n", (const void *) coords)); +} + +KEYWORD1 void KEYWORD2 NAME(DrawTexsOES)(GLshort x, GLshort y, GLshort z, GLshort width, GLshort height); + +KEYWORD1 void KEYWORD2 NAME(DrawTexsOES)(GLshort x, GLshort y, GLshort z, GLshort width, GLshort height) +{ + DISPATCH(DrawTexsOES, (x, y, z, width, height), (F, "glDrawTexsOES(%d, %d, %d, %d, %d);\n", x, y, z, width, height)); +} + +KEYWORD1 void KEYWORD2 NAME(DrawTexsvOES)(const GLshort * coords); + +KEYWORD1 void KEYWORD2 NAME(DrawTexsvOES)(const GLshort * coords) +{ + DISPATCH(DrawTexsvOES, (coords), (F, "glDrawTexsvOES(%p);\n", (const void *) coords)); +} + +KEYWORD1 void KEYWORD2 NAME(DrawTexxOES)(GLfixed x, GLfixed y, GLfixed z, GLfixed width, GLfixed height); + +KEYWORD1 void KEYWORD2 NAME(DrawTexxOES)(GLfixed x, GLfixed y, GLfixed z, GLfixed width, GLfixed height) +{ + DISPATCH(DrawTexxOES, (x, y, z, width, height), (F, "glDrawTexxOES(%d, %d, %d, %d, %d);\n", x, y, z, width, height)); +} + +KEYWORD1 void KEYWORD2 NAME(DrawTexxvOES)(const GLfixed * coords); + +KEYWORD1 void KEYWORD2 NAME(DrawTexxvOES)(const GLfixed * coords) +{ + DISPATCH(DrawTexxvOES, (coords), (F, "glDrawTexxvOES(%p);\n", (const void *) coords)); +} + +KEYWORD1 void KEYWORD2 NAME(BindFramebufferOES)(GLenum target, GLuint framebuffer); + +KEYWORD1 void KEYWORD2 NAME(BindFramebufferOES)(GLenum target, GLuint framebuffer) +{ + DISPATCH(BindFramebufferOES, (target, framebuffer), (F, "glBindFramebufferOES(0x%x, %d);\n", target, framebuffer)); +} + +KEYWORD1 void KEYWORD2 NAME(BindRenderbufferOES)(GLenum target, GLuint renderbuffer); + +KEYWORD1 void KEYWORD2 NAME(BindRenderbufferOES)(GLenum target, GLuint renderbuffer) +{ + DISPATCH(BindRenderbufferOES, (target, renderbuffer), (F, "glBindRenderbufferOES(0x%x, %d);\n", target, renderbuffer)); +} + +KEYWORD1 GLenum KEYWORD2 NAME(CheckFramebufferStatusOES)(GLenum target); + +KEYWORD1 GLenum KEYWORD2 NAME(CheckFramebufferStatusOES)(GLenum target) +{ + RETURN_DISPATCH(CheckFramebufferStatusOES, (target), (F, "glCheckFramebufferStatusOES(0x%x);\n", target)); +} + +KEYWORD1 void KEYWORD2 NAME(DeleteFramebuffersOES)(GLsizei n, const GLuint * framebuffers); + +KEYWORD1 void KEYWORD2 NAME(DeleteFramebuffersOES)(GLsizei n, const GLuint * framebuffers) +{ + DISPATCH(DeleteFramebuffersOES, (n, framebuffers), (F, "glDeleteFramebuffersOES(%d, %p);\n", n, (const void *) framebuffers)); +} + +KEYWORD1 void KEYWORD2 NAME(DeleteRenderbuffersOES)(GLsizei n, const GLuint * renderbuffers); + +KEYWORD1 void KEYWORD2 NAME(DeleteRenderbuffersOES)(GLsizei n, const GLuint * renderbuffers) +{ + DISPATCH(DeleteRenderbuffersOES, (n, renderbuffers), (F, "glDeleteRenderbuffersOES(%d, %p);\n", n, (const void *) renderbuffers)); +} + +KEYWORD1 void KEYWORD2 NAME(FramebufferRenderbufferOES)(GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer); + +KEYWORD1 void KEYWORD2 NAME(FramebufferRenderbufferOES)(GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer) +{ + DISPATCH(FramebufferRenderbufferOES, (target, attachment, renderbuffertarget, renderbuffer), (F, "glFramebufferRenderbufferOES(0x%x, 0x%x, 0x%x, %d);\n", target, attachment, renderbuffertarget, renderbuffer)); +} + +KEYWORD1 void KEYWORD2 NAME(FramebufferTexture2DOES)(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level); + +KEYWORD1 void KEYWORD2 NAME(FramebufferTexture2DOES)(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level) +{ + DISPATCH(FramebufferTexture2DOES, (target, attachment, textarget, texture, level), (F, "glFramebufferTexture2DOES(0x%x, 0x%x, 0x%x, %d, %d);\n", target, attachment, textarget, texture, level)); +} + +KEYWORD1 void KEYWORD2 NAME(GenFramebuffersOES)(GLsizei n, GLuint * framebuffers); + +KEYWORD1 void KEYWORD2 NAME(GenFramebuffersOES)(GLsizei n, GLuint * framebuffers) +{ + DISPATCH(GenFramebuffersOES, (n, framebuffers), (F, "glGenFramebuffersOES(%d, %p);\n", n, (const void *) framebuffers)); +} + +KEYWORD1 void KEYWORD2 NAME(GenRenderbuffersOES)(GLsizei n, GLuint * renderbuffers); + +KEYWORD1 void KEYWORD2 NAME(GenRenderbuffersOES)(GLsizei n, GLuint * renderbuffers) +{ + DISPATCH(GenRenderbuffersOES, (n, renderbuffers), (F, "glGenRenderbuffersOES(%d, %p);\n", n, (const void *) renderbuffers)); +} + +KEYWORD1 void KEYWORD2 NAME(GenerateMipmapOES)(GLenum target); + +KEYWORD1 void KEYWORD2 NAME(GenerateMipmapOES)(GLenum target) +{ + DISPATCH(GenerateMipmapOES, (target), (F, "glGenerateMipmapOES(0x%x);\n", target)); +} + +KEYWORD1 void KEYWORD2 NAME(GetFramebufferAttachmentParameterivOES)(GLenum target, GLenum attachment, GLenum pname, GLint * params); + +KEYWORD1 void KEYWORD2 NAME(GetFramebufferAttachmentParameterivOES)(GLenum target, GLenum attachment, GLenum pname, GLint * params) +{ + DISPATCH(GetFramebufferAttachmentParameterivOES, (target, attachment, pname, params), (F, "glGetFramebufferAttachmentParameterivOES(0x%x, 0x%x, 0x%x, %p);\n", target, attachment, pname, (const void *) params)); +} + +KEYWORD1 void KEYWORD2 NAME(GetRenderbufferParameterivOES)(GLenum target, GLenum pname, GLint * params); + +KEYWORD1 void KEYWORD2 NAME(GetRenderbufferParameterivOES)(GLenum target, GLenum pname, GLint * params) +{ + DISPATCH(GetRenderbufferParameterivOES, (target, pname, params), (F, "glGetRenderbufferParameterivOES(0x%x, 0x%x, %p);\n", target, pname, (const void *) params)); +} + +KEYWORD1 GLboolean KEYWORD2 NAME(IsFramebufferOES)(GLuint framebuffer); + +KEYWORD1 GLboolean KEYWORD2 NAME(IsFramebufferOES)(GLuint framebuffer) +{ + RETURN_DISPATCH(IsFramebufferOES, (framebuffer), (F, "glIsFramebufferOES(%d);\n", framebuffer)); +} + +KEYWORD1 GLboolean KEYWORD2 NAME(IsRenderbufferOES)(GLuint renderbuffer); + +KEYWORD1 GLboolean KEYWORD2 NAME(IsRenderbufferOES)(GLuint renderbuffer) +{ + RETURN_DISPATCH(IsRenderbufferOES, (renderbuffer), (F, "glIsRenderbufferOES(%d);\n", renderbuffer)); +} + +KEYWORD1 void KEYWORD2 NAME(RenderbufferStorageOES)(GLenum target, GLenum internalformat, GLsizei width, GLsizei height); + +KEYWORD1 void KEYWORD2 NAME(RenderbufferStorageOES)(GLenum target, GLenum internalformat, GLsizei width, GLsizei height) +{ + DISPATCH(RenderbufferStorageOES, (target, internalformat, width, height), (F, "glRenderbufferStorageOES(0x%x, 0x%x, %d, %d);\n", target, internalformat, width, height)); +} + +KEYWORD1 void KEYWORD2 NAME(PointSizePointerOES)(GLenum type, GLsizei stride, const GLvoid * pointer); + +KEYWORD1 void KEYWORD2 NAME(PointSizePointerOES)(GLenum type, GLsizei stride, const GLvoid * pointer) +{ + DISPATCH(PointSizePointerOES, (type, stride, pointer), (F, "glPointSizePointerOES(0x%x, %d, %p);\n", type, stride, (const void *) pointer)); +} + +KEYWORD1 GLbitfield KEYWORD2 NAME(QueryMatrixxOES)(GLfixed * mantissa, GLint * exponent); + +KEYWORD1 GLbitfield KEYWORD2 NAME(QueryMatrixxOES)(GLfixed * mantissa, GLint * exponent) +{ + RETURN_DISPATCH(QueryMatrixxOES, (mantissa, exponent), (F, "glQueryMatrixxOES(%p, %p);\n", (const void *) mantissa, (const void *) exponent)); +} + +KEYWORD1 void KEYWORD2 NAME(GetTexGenxvOES)(GLenum coord, GLenum pname, GLfixed * params); + +KEYWORD1 void KEYWORD2 NAME(GetTexGenxvOES)(GLenum coord, GLenum pname, GLfixed * params) +{ + DISPATCH(GetTexGenxvOES, (coord, pname, params), (F, "glGetTexGenxvOES(0x%x, 0x%x, %p);\n", coord, pname, (const void *) params)); +} + +KEYWORD1 void KEYWORD2 NAME(TexGenxOES)(GLenum coord, GLenum pname, GLint param); + +KEYWORD1 void KEYWORD2 NAME(TexGenxOES)(GLenum coord, GLenum pname, GLint param) +{ + DISPATCH(TexGenxOES, (coord, pname, param), (F, "glTexGenxOES(0x%x, 0x%x, %d);\n", coord, pname, param)); +} + +KEYWORD1 void KEYWORD2 NAME(TexGenxvOES)(GLenum coord, GLenum pname, const GLfixed * params); + +KEYWORD1 void KEYWORD2 NAME(TexGenxvOES)(GLenum coord, GLenum pname, const GLfixed * params) +{ + DISPATCH(TexGenxvOES, (coord, pname, params), (F, "glTexGenxvOES(0x%x, 0x%x, %p);\n", coord, pname, (const void *) params)); +} + +KEYWORD1 void KEYWORD2 NAME(GetBufferPointervOES)(GLenum target, GLenum pname, GLvoid ** params); + +KEYWORD1 void KEYWORD2 NAME(GetBufferPointervOES)(GLenum target, GLenum pname, GLvoid ** params) +{ + DISPATCH(GetBufferPointervOES, (target, pname, params), (F, "glGetBufferPointervOES(0x%x, 0x%x, %p);\n", target, pname, (const void *) params)); +} + +KEYWORD1 GLvoid * KEYWORD2 NAME(MapBufferOES)(GLenum target, GLenum access); + +KEYWORD1 GLvoid * KEYWORD2 NAME(MapBufferOES)(GLenum target, GLenum access) +{ + RETURN_DISPATCH(MapBufferOES, (target, access), (F, "glMapBufferOES(0x%x, 0x%x);\n", target, access)); +} + +KEYWORD1 GLboolean KEYWORD2 NAME(UnmapBufferOES)(GLenum target); + +KEYWORD1 GLboolean KEYWORD2 NAME(UnmapBufferOES)(GLenum target) +{ + RETURN_DISPATCH(UnmapBufferOES, (target), (F, "glUnmapBufferOES(0x%x);\n", target)); +} + +KEYWORD1 void KEYWORD2 NAME(MultiDrawArraysEXT)(GLenum mode, const GLint * first, const GLsizei * count, GLsizei primcount) +{ + DISPATCH(MultiDrawArraysEXT, (mode, first, count, primcount), (F, "glMultiDrawArraysEXT(0x%x, %p, %p, %d);\n", mode, (const void *) first, (const void *) count, primcount)); +} + +KEYWORD1 void KEYWORD2 NAME(MultiDrawElementsEXT)(GLenum mode, const GLsizei * count, GLenum type, const GLvoid ** indices, GLsizei primcount) +{ + DISPATCH(MultiDrawElementsEXT, (mode, count, type, indices, primcount), (F, "glMultiDrawElementsEXT(0x%x, %p, 0x%x, %p, %d);\n", mode, (const void *) count, type, (const void *) indices, primcount)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_443)(GLuint array); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_443)(GLuint array) +{ + DISPATCH(BindVertexArrayAPPLE, (array), (F, "glBindVertexArrayAPPLE(%d);\n", array)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_444)(GLsizei n, const GLuint * arrays); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_444)(GLsizei n, const GLuint * arrays) +{ + DISPATCH(DeleteVertexArraysAPPLE, (n, arrays), (F, "glDeleteVertexArraysAPPLE(%d, %p);\n", n, (const void *) arrays)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_445)(GLsizei n, GLuint * arrays); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_445)(GLsizei n, GLuint * arrays) +{ + DISPATCH(GenVertexArraysAPPLE, (n, arrays), (F, "glGenVertexArraysAPPLE(%d, %p);\n", n, (const void *) arrays)); +} + +KEYWORD1_ALT GLboolean KEYWORD2 NAME(_dispatch_stub_446)(GLuint array); + +KEYWORD1_ALT GLboolean KEYWORD2 NAME(_dispatch_stub_446)(GLuint array) +{ + RETURN_DISPATCH(IsVertexArrayAPPLE, (array), (F, "glIsVertexArrayAPPLE(%d);\n", array)); +} + +KEYWORD1 void KEYWORD2 NAME(EGLImageTargetRenderbufferStorageOES)(GLenum target, GLvoid * writeOffset); + +KEYWORD1 void KEYWORD2 NAME(EGLImageTargetRenderbufferStorageOES)(GLenum target, GLvoid * writeOffset) +{ + DISPATCH(EGLImageTargetRenderbufferStorageOES, (target, writeOffset), (F, "glEGLImageTargetRenderbufferStorageOES(0x%x, %p);\n", target, (const void *) writeOffset)); +} + +KEYWORD1 void KEYWORD2 NAME(EGLImageTargetTexture2DOES)(GLenum target, GLvoid * writeOffset); + +KEYWORD1 void KEYWORD2 NAME(EGLImageTargetTexture2DOES)(GLenum target, GLvoid * writeOffset) +{ + DISPATCH(EGLImageTargetTexture2DOES, (target, writeOffset), (F, "glEGLImageTargetTexture2DOES(0x%x, %p);\n", target, (const void *) writeOffset)); +} + +KEYWORD1 void KEYWORD2 NAME(CompressedTexImage2D)(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const GLvoid * data) +{ + DISPATCH(CompressedTexImage2D, (target, level, internalformat, width, height, border, imageSize, data), (F, "glCompressedTexImage2D(0x%x, %d, 0x%x, %d, %d, %d, %d, %p);\n", target, level, internalformat, width, height, border, imageSize, (const void *) data)); +} + +KEYWORD1 void KEYWORD2 NAME(CompressedTexSubImage2D)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const GLvoid * data) +{ + DISPATCH(CompressedTexSubImage2D, (target, level, xoffset, yoffset, width, height, format, imageSize, data), (F, "glCompressedTexSubImage2D(0x%x, %d, %d, %d, %d, %d, 0x%x, %d, %p);\n", target, level, xoffset, yoffset, width, height, format, imageSize, (const void *) data)); +} + +KEYWORD1 void KEYWORD2 NAME(SampleCoverage)(GLclampf value, GLboolean invert) +{ + DISPATCH(SampleCoverage, (value, invert), (F, "glSampleCoverage(%f, %d);\n", value, invert)); +} + +KEYWORD1 void KEYWORD2 NAME(BindBuffer)(GLenum target, GLuint buffer) +{ + DISPATCH(BindBuffer, (target, buffer), (F, "glBindBuffer(0x%x, %d);\n", target, buffer)); +} + +KEYWORD1 void KEYWORD2 NAME(BufferData)(GLenum target, GLsizeiptr size, const GLvoid * data, GLenum usage) +{ + DISPATCH(BufferData, (target, size, data, usage), (F, "glBufferData(0x%x, %d, %p, 0x%x);\n", target, size, (const void *) data, usage)); +} + +KEYWORD1 void KEYWORD2 NAME(BufferSubData)(GLenum target, GLintptr offset, GLsizeiptr size, const GLvoid * data) +{ + DISPATCH(BufferSubData, (target, offset, size, data), (F, "glBufferSubData(0x%x, %d, %d, %p);\n", target, offset, size, (const void *) data)); +} + +KEYWORD1 void KEYWORD2 NAME(DeleteBuffers)(GLsizei n, const GLuint * buffer) +{ + DISPATCH(DeleteBuffers, (n, buffer), (F, "glDeleteBuffers(%d, %p);\n", n, (const void *) buffer)); +} + +KEYWORD1 void KEYWORD2 NAME(GenBuffers)(GLsizei n, GLuint * buffer) +{ + DISPATCH(GenBuffers, (n, buffer), (F, "glGenBuffers(%d, %p);\n", n, (const void *) buffer)); +} + +KEYWORD1 void KEYWORD2 NAME(GetBufferParameteriv)(GLenum target, GLenum pname, GLint * params) +{ + DISPATCH(GetBufferParameteriv, (target, pname, params), (F, "glGetBufferParameteriv(0x%x, 0x%x, %p);\n", target, pname, (const void *) params)); +} + +KEYWORD1 GLboolean KEYWORD2 NAME(IsBuffer)(GLuint buffer) +{ + RETURN_DISPATCH(IsBuffer, (buffer), (F, "glIsBuffer(%d);\n", buffer)); +} + +KEYWORD1 void KEYWORD2 NAME(PointParameterf)(GLenum pname, GLfloat param) +{ + DISPATCH(PointParameterf, (pname, param), (F, "glPointParameterf(0x%x, %f);\n", pname, param)); +} + +KEYWORD1 void KEYWORD2 NAME(PointParameterfv)(GLenum pname, const GLfloat * params) +{ + DISPATCH(PointParameterfv, (pname, params), (F, "glPointParameterfv(0x%x, %p);\n", pname, (const void *) params)); +} + +KEYWORD1 void KEYWORD2 NAME(AlphaFuncx)(GLenum func, GLclampx ref); + +KEYWORD1 void KEYWORD2 NAME(AlphaFuncx)(GLenum func, GLclampx ref) +{ + DISPATCH(AlphaFuncx, (func, ref), (F, "glAlphaFuncx(0x%x, %d);\n", func, ref)); +} + +KEYWORD1 void KEYWORD2 NAME(AlphaFuncxOES)(GLenum func, GLclampx ref); + +KEYWORD1 void KEYWORD2 NAME(AlphaFuncxOES)(GLenum func, GLclampx ref) +{ + DISPATCH(AlphaFuncx, (func, ref), (F, "glAlphaFuncxOES(0x%x, %d);\n", func, ref)); +} + +KEYWORD1 void KEYWORD2 NAME(ClearColorx)(GLclampx red, GLclampx green, GLclampx blue, GLclampx alpha); + +KEYWORD1 void KEYWORD2 NAME(ClearColorx)(GLclampx red, GLclampx green, GLclampx blue, GLclampx alpha) +{ + DISPATCH(ClearColorx, (red, green, blue, alpha), (F, "glClearColorx(%d, %d, %d, %d);\n", red, green, blue, alpha)); +} + +KEYWORD1 void KEYWORD2 NAME(ClearColorxOES)(GLclampx red, GLclampx green, GLclampx blue, GLclampx alpha); + +KEYWORD1 void KEYWORD2 NAME(ClearColorxOES)(GLclampx red, GLclampx green, GLclampx blue, GLclampx alpha) +{ + DISPATCH(ClearColorx, (red, green, blue, alpha), (F, "glClearColorxOES(%d, %d, %d, %d);\n", red, green, blue, alpha)); +} + +KEYWORD1 void KEYWORD2 NAME(ClearDepthf)(GLclampf depth); + +KEYWORD1 void KEYWORD2 NAME(ClearDepthf)(GLclampf depth) +{ + DISPATCH(ClearDepthf, (depth), (F, "glClearDepthf(%f);\n", depth)); +} + +KEYWORD1 void KEYWORD2 NAME(ClearDepthfOES)(GLclampf depth); + +KEYWORD1 void KEYWORD2 NAME(ClearDepthfOES)(GLclampf depth) +{ + DISPATCH(ClearDepthf, (depth), (F, "glClearDepthfOES(%f);\n", depth)); +} + +KEYWORD1 void KEYWORD2 NAME(ClearDepthx)(GLclampx depth); + +KEYWORD1 void KEYWORD2 NAME(ClearDepthx)(GLclampx depth) +{ + DISPATCH(ClearDepthx, (depth), (F, "glClearDepthx(%d);\n", depth)); +} + +KEYWORD1 void KEYWORD2 NAME(ClearDepthxOES)(GLclampx depth); + +KEYWORD1 void KEYWORD2 NAME(ClearDepthxOES)(GLclampx depth) +{ + DISPATCH(ClearDepthx, (depth), (F, "glClearDepthxOES(%d);\n", depth)); +} + +KEYWORD1 void KEYWORD2 NAME(Color4x)(GLfixed red, GLfixed green, GLfixed blue, GLfixed alpha); + +KEYWORD1 void KEYWORD2 NAME(Color4x)(GLfixed red, GLfixed green, GLfixed blue, GLfixed alpha) +{ + DISPATCH(Color4x, (red, green, blue, alpha), (F, "glColor4x(%d, %d, %d, %d);\n", red, green, blue, alpha)); +} + +KEYWORD1 void KEYWORD2 NAME(Color4xOES)(GLfixed red, GLfixed green, GLfixed blue, GLfixed alpha); + +KEYWORD1 void KEYWORD2 NAME(Color4xOES)(GLfixed red, GLfixed green, GLfixed blue, GLfixed alpha) +{ + DISPATCH(Color4x, (red, green, blue, alpha), (F, "glColor4xOES(%d, %d, %d, %d);\n", red, green, blue, alpha)); +} + +KEYWORD1 void KEYWORD2 NAME(DepthRangef)(GLclampf zNear, GLclampf zFar); + +KEYWORD1 void KEYWORD2 NAME(DepthRangef)(GLclampf zNear, GLclampf zFar) +{ + DISPATCH(DepthRangef, (zNear, zFar), (F, "glDepthRangef(%f, %f);\n", zNear, zFar)); +} + +KEYWORD1 void KEYWORD2 NAME(DepthRangefOES)(GLclampf zNear, GLclampf zFar); + +KEYWORD1 void KEYWORD2 NAME(DepthRangefOES)(GLclampf zNear, GLclampf zFar) +{ + DISPATCH(DepthRangef, (zNear, zFar), (F, "glDepthRangefOES(%f, %f);\n", zNear, zFar)); +} + +KEYWORD1 void KEYWORD2 NAME(DepthRangex)(GLclampx zNear, GLclampx zFar); + +KEYWORD1 void KEYWORD2 NAME(DepthRangex)(GLclampx zNear, GLclampx zFar) +{ + DISPATCH(DepthRangex, (zNear, zFar), (F, "glDepthRangex(%d, %d);\n", zNear, zFar)); +} + +KEYWORD1 void KEYWORD2 NAME(DepthRangexOES)(GLclampx zNear, GLclampx zFar); + +KEYWORD1 void KEYWORD2 NAME(DepthRangexOES)(GLclampx zNear, GLclampx zFar) +{ + DISPATCH(DepthRangex, (zNear, zFar), (F, "glDepthRangexOES(%d, %d);\n", zNear, zFar)); +} + +KEYWORD1 void KEYWORD2 NAME(Fogx)(GLenum pname, GLfixed param); + +KEYWORD1 void KEYWORD2 NAME(Fogx)(GLenum pname, GLfixed param) +{ + DISPATCH(Fogx, (pname, param), (F, "glFogx(0x%x, %d);\n", pname, param)); +} + +KEYWORD1 void KEYWORD2 NAME(FogxOES)(GLenum pname, GLfixed param); + +KEYWORD1 void KEYWORD2 NAME(FogxOES)(GLenum pname, GLfixed param) +{ + DISPATCH(Fogx, (pname, param), (F, "glFogxOES(0x%x, %d);\n", pname, param)); +} + +KEYWORD1 void KEYWORD2 NAME(Fogxv)(GLenum pname, const GLfixed * params); + +KEYWORD1 void KEYWORD2 NAME(Fogxv)(GLenum pname, const GLfixed * params) +{ + DISPATCH(Fogxv, (pname, params), (F, "glFogxv(0x%x, %p);\n", pname, (const void *) params)); +} + +KEYWORD1 void KEYWORD2 NAME(FogxvOES)(GLenum pname, const GLfixed * params); + +KEYWORD1 void KEYWORD2 NAME(FogxvOES)(GLenum pname, const GLfixed * params) +{ + DISPATCH(Fogxv, (pname, params), (F, "glFogxvOES(0x%x, %p);\n", pname, (const void *) params)); +} + +KEYWORD1 void KEYWORD2 NAME(Frustumf)(GLfloat left, GLfloat right, GLfloat bottom, GLfloat top, GLfloat zNear, GLfloat zFar); + +KEYWORD1 void KEYWORD2 NAME(Frustumf)(GLfloat left, GLfloat right, GLfloat bottom, GLfloat top, GLfloat zNear, GLfloat zFar) +{ + DISPATCH(Frustumf, (left, right, bottom, top, zNear, zFar), (F, "glFrustumf(%f, %f, %f, %f, %f, %f);\n", left, right, bottom, top, zNear, zFar)); +} + +KEYWORD1 void KEYWORD2 NAME(FrustumfOES)(GLfloat left, GLfloat right, GLfloat bottom, GLfloat top, GLfloat zNear, GLfloat zFar); + +KEYWORD1 void KEYWORD2 NAME(FrustumfOES)(GLfloat left, GLfloat right, GLfloat bottom, GLfloat top, GLfloat zNear, GLfloat zFar) +{ + DISPATCH(Frustumf, (left, right, bottom, top, zNear, zFar), (F, "glFrustumfOES(%f, %f, %f, %f, %f, %f);\n", left, right, bottom, top, zNear, zFar)); +} + +KEYWORD1 void KEYWORD2 NAME(Frustumx)(GLfixed left, GLfixed right, GLfixed bottom, GLfixed top, GLfixed zNear, GLfixed zFar); + +KEYWORD1 void KEYWORD2 NAME(Frustumx)(GLfixed left, GLfixed right, GLfixed bottom, GLfixed top, GLfixed zNear, GLfixed zFar) +{ + DISPATCH(Frustumx, (left, right, bottom, top, zNear, zFar), (F, "glFrustumx(%d, %d, %d, %d, %d, %d);\n", left, right, bottom, top, zNear, zFar)); +} + +KEYWORD1 void KEYWORD2 NAME(FrustumxOES)(GLfixed left, GLfixed right, GLfixed bottom, GLfixed top, GLfixed zNear, GLfixed zFar); + +KEYWORD1 void KEYWORD2 NAME(FrustumxOES)(GLfixed left, GLfixed right, GLfixed bottom, GLfixed top, GLfixed zNear, GLfixed zFar) +{ + DISPATCH(Frustumx, (left, right, bottom, top, zNear, zFar), (F, "glFrustumxOES(%d, %d, %d, %d, %d, %d);\n", left, right, bottom, top, zNear, zFar)); +} + +KEYWORD1 void KEYWORD2 NAME(LightModelx)(GLenum pname, GLfixed param); + +KEYWORD1 void KEYWORD2 NAME(LightModelx)(GLenum pname, GLfixed param) +{ + DISPATCH(LightModelx, (pname, param), (F, "glLightModelx(0x%x, %d);\n", pname, param)); +} + +KEYWORD1 void KEYWORD2 NAME(LightModelxOES)(GLenum pname, GLfixed param); + +KEYWORD1 void KEYWORD2 NAME(LightModelxOES)(GLenum pname, GLfixed param) +{ + DISPATCH(LightModelx, (pname, param), (F, "glLightModelxOES(0x%x, %d);\n", pname, param)); +} + +KEYWORD1 void KEYWORD2 NAME(LightModelxv)(GLenum pname, const GLfixed * params); + +KEYWORD1 void KEYWORD2 NAME(LightModelxv)(GLenum pname, const GLfixed * params) +{ + DISPATCH(LightModelxv, (pname, params), (F, "glLightModelxv(0x%x, %p);\n", pname, (const void *) params)); +} + +KEYWORD1 void KEYWORD2 NAME(LightModelxvOES)(GLenum pname, const GLfixed * params); + +KEYWORD1 void KEYWORD2 NAME(LightModelxvOES)(GLenum pname, const GLfixed * params) +{ + DISPATCH(LightModelxv, (pname, params), (F, "glLightModelxvOES(0x%x, %p);\n", pname, (const void *) params)); +} + +KEYWORD1 void KEYWORD2 NAME(Lightx)(GLenum light, GLenum pname, GLfixed param); + +KEYWORD1 void KEYWORD2 NAME(Lightx)(GLenum light, GLenum pname, GLfixed param) +{ + DISPATCH(Lightx, (light, pname, param), (F, "glLightx(0x%x, 0x%x, %d);\n", light, pname, param)); +} + +KEYWORD1 void KEYWORD2 NAME(LightxOES)(GLenum light, GLenum pname, GLfixed param); + +KEYWORD1 void KEYWORD2 NAME(LightxOES)(GLenum light, GLenum pname, GLfixed param) +{ + DISPATCH(Lightx, (light, pname, param), (F, "glLightxOES(0x%x, 0x%x, %d);\n", light, pname, param)); +} + +KEYWORD1 void KEYWORD2 NAME(Lightxv)(GLenum light, GLenum pname, const GLfixed * params); + +KEYWORD1 void KEYWORD2 NAME(Lightxv)(GLenum light, GLenum pname, const GLfixed * params) +{ + DISPATCH(Lightxv, (light, pname, params), (F, "glLightxv(0x%x, 0x%x, %p);\n", light, pname, (const void *) params)); +} + +KEYWORD1 void KEYWORD2 NAME(LightxvOES)(GLenum light, GLenum pname, const GLfixed * params); + +KEYWORD1 void KEYWORD2 NAME(LightxvOES)(GLenum light, GLenum pname, const GLfixed * params) +{ + DISPATCH(Lightxv, (light, pname, params), (F, "glLightxvOES(0x%x, 0x%x, %p);\n", light, pname, (const void *) params)); +} + +KEYWORD1 void KEYWORD2 NAME(LineWidthx)(GLfixed width); + +KEYWORD1 void KEYWORD2 NAME(LineWidthx)(GLfixed width) +{ + DISPATCH(LineWidthx, (width), (F, "glLineWidthx(%d);\n", width)); +} + +KEYWORD1 void KEYWORD2 NAME(LineWidthxOES)(GLfixed width); + +KEYWORD1 void KEYWORD2 NAME(LineWidthxOES)(GLfixed width) +{ + DISPATCH(LineWidthx, (width), (F, "glLineWidthxOES(%d);\n", width)); +} + +KEYWORD1 void KEYWORD2 NAME(LoadMatrixx)(const GLfixed * m); + +KEYWORD1 void KEYWORD2 NAME(LoadMatrixx)(const GLfixed * m) +{ + DISPATCH(LoadMatrixx, (m), (F, "glLoadMatrixx(%p);\n", (const void *) m)); +} + +KEYWORD1 void KEYWORD2 NAME(LoadMatrixxOES)(const GLfixed * m); + +KEYWORD1 void KEYWORD2 NAME(LoadMatrixxOES)(const GLfixed * m) +{ + DISPATCH(LoadMatrixx, (m), (F, "glLoadMatrixxOES(%p);\n", (const void *) m)); +} + +KEYWORD1 void KEYWORD2 NAME(Materialx)(GLenum face, GLenum pname, GLfixed param); + +KEYWORD1 void KEYWORD2 NAME(Materialx)(GLenum face, GLenum pname, GLfixed param) +{ + DISPATCH(Materialx, (face, pname, param), (F, "glMaterialx(0x%x, 0x%x, %d);\n", face, pname, param)); +} + +KEYWORD1 void KEYWORD2 NAME(MaterialxOES)(GLenum face, GLenum pname, GLfixed param); + +KEYWORD1 void KEYWORD2 NAME(MaterialxOES)(GLenum face, GLenum pname, GLfixed param) +{ + DISPATCH(Materialx, (face, pname, param), (F, "glMaterialxOES(0x%x, 0x%x, %d);\n", face, pname, param)); +} + +KEYWORD1 void KEYWORD2 NAME(Materialxv)(GLenum face, GLenum pname, const GLfixed * params); + +KEYWORD1 void KEYWORD2 NAME(Materialxv)(GLenum face, GLenum pname, const GLfixed * params) +{ + DISPATCH(Materialxv, (face, pname, params), (F, "glMaterialxv(0x%x, 0x%x, %p);\n", face, pname, (const void *) params)); +} + +KEYWORD1 void KEYWORD2 NAME(MaterialxvOES)(GLenum face, GLenum pname, const GLfixed * params); + +KEYWORD1 void KEYWORD2 NAME(MaterialxvOES)(GLenum face, GLenum pname, const GLfixed * params) +{ + DISPATCH(Materialxv, (face, pname, params), (F, "glMaterialxvOES(0x%x, 0x%x, %p);\n", face, pname, (const void *) params)); +} + +KEYWORD1 void KEYWORD2 NAME(MultMatrixx)(const GLfixed * m); + +KEYWORD1 void KEYWORD2 NAME(MultMatrixx)(const GLfixed * m) +{ + DISPATCH(MultMatrixx, (m), (F, "glMultMatrixx(%p);\n", (const void *) m)); +} + +KEYWORD1 void KEYWORD2 NAME(MultMatrixxOES)(const GLfixed * m); + +KEYWORD1 void KEYWORD2 NAME(MultMatrixxOES)(const GLfixed * m) +{ + DISPATCH(MultMatrixx, (m), (F, "glMultMatrixxOES(%p);\n", (const void *) m)); +} + +KEYWORD1 void KEYWORD2 NAME(MultiTexCoord4x)(GLenum target, GLfixed s, GLfixed t, GLfixed r, GLfixed q); + +KEYWORD1 void KEYWORD2 NAME(MultiTexCoord4x)(GLenum target, GLfixed s, GLfixed t, GLfixed r, GLfixed q) +{ + DISPATCH(MultiTexCoord4x, (target, s, t, r, q), (F, "glMultiTexCoord4x(0x%x, %d, %d, %d, %d);\n", target, s, t, r, q)); +} + +KEYWORD1 void KEYWORD2 NAME(MultiTexCoord4xOES)(GLenum target, GLfixed s, GLfixed t, GLfixed r, GLfixed q); + +KEYWORD1 void KEYWORD2 NAME(MultiTexCoord4xOES)(GLenum target, GLfixed s, GLfixed t, GLfixed r, GLfixed q) +{ + DISPATCH(MultiTexCoord4x, (target, s, t, r, q), (F, "glMultiTexCoord4xOES(0x%x, %d, %d, %d, %d);\n", target, s, t, r, q)); +} + +KEYWORD1 void KEYWORD2 NAME(Normal3x)(GLfixed nx, GLfixed ny, GLfixed nz); + +KEYWORD1 void KEYWORD2 NAME(Normal3x)(GLfixed nx, GLfixed ny, GLfixed nz) +{ + DISPATCH(Normal3x, (nx, ny, nz), (F, "glNormal3x(%d, %d, %d);\n", nx, ny, nz)); +} + +KEYWORD1 void KEYWORD2 NAME(Normal3xOES)(GLfixed nx, GLfixed ny, GLfixed nz); + +KEYWORD1 void KEYWORD2 NAME(Normal3xOES)(GLfixed nx, GLfixed ny, GLfixed nz) +{ + DISPATCH(Normal3x, (nx, ny, nz), (F, "glNormal3xOES(%d, %d, %d);\n", nx, ny, nz)); +} + +KEYWORD1 void KEYWORD2 NAME(Orthof)(GLfloat left, GLfloat right, GLfloat bottom, GLfloat top, GLfloat zNear, GLfloat zFar); + +KEYWORD1 void KEYWORD2 NAME(Orthof)(GLfloat left, GLfloat right, GLfloat bottom, GLfloat top, GLfloat zNear, GLfloat zFar) +{ + DISPATCH(Orthof, (left, right, bottom, top, zNear, zFar), (F, "glOrthof(%f, %f, %f, %f, %f, %f);\n", left, right, bottom, top, zNear, zFar)); +} + +KEYWORD1 void KEYWORD2 NAME(OrthofOES)(GLfloat left, GLfloat right, GLfloat bottom, GLfloat top, GLfloat zNear, GLfloat zFar); + +KEYWORD1 void KEYWORD2 NAME(OrthofOES)(GLfloat left, GLfloat right, GLfloat bottom, GLfloat top, GLfloat zNear, GLfloat zFar) +{ + DISPATCH(Orthof, (left, right, bottom, top, zNear, zFar), (F, "glOrthofOES(%f, %f, %f, %f, %f, %f);\n", left, right, bottom, top, zNear, zFar)); +} + +KEYWORD1 void KEYWORD2 NAME(Orthox)(GLfixed left, GLfixed right, GLfixed bottom, GLfixed top, GLfixed zNear, GLfixed zFar); + +KEYWORD1 void KEYWORD2 NAME(Orthox)(GLfixed left, GLfixed right, GLfixed bottom, GLfixed top, GLfixed zNear, GLfixed zFar) +{ + DISPATCH(Orthox, (left, right, bottom, top, zNear, zFar), (F, "glOrthox(%d, %d, %d, %d, %d, %d);\n", left, right, bottom, top, zNear, zFar)); +} + +KEYWORD1 void KEYWORD2 NAME(OrthoxOES)(GLfixed left, GLfixed right, GLfixed bottom, GLfixed top, GLfixed zNear, GLfixed zFar); + +KEYWORD1 void KEYWORD2 NAME(OrthoxOES)(GLfixed left, GLfixed right, GLfixed bottom, GLfixed top, GLfixed zNear, GLfixed zFar) +{ + DISPATCH(Orthox, (left, right, bottom, top, zNear, zFar), (F, "glOrthoxOES(%d, %d, %d, %d, %d, %d);\n", left, right, bottom, top, zNear, zFar)); +} + +KEYWORD1 void KEYWORD2 NAME(PointSizex)(GLfixed size); + +KEYWORD1 void KEYWORD2 NAME(PointSizex)(GLfixed size) +{ + DISPATCH(PointSizex, (size), (F, "glPointSizex(%d);\n", size)); +} + +KEYWORD1 void KEYWORD2 NAME(PointSizexOES)(GLfixed size); + +KEYWORD1 void KEYWORD2 NAME(PointSizexOES)(GLfixed size) +{ + DISPATCH(PointSizex, (size), (F, "glPointSizexOES(%d);\n", size)); +} + +KEYWORD1 void KEYWORD2 NAME(PolygonOffsetx)(GLfixed factor, GLfixed units); + +KEYWORD1 void KEYWORD2 NAME(PolygonOffsetx)(GLfixed factor, GLfixed units) +{ + DISPATCH(PolygonOffsetx, (factor, units), (F, "glPolygonOffsetx(%d, %d);\n", factor, units)); +} + +KEYWORD1 void KEYWORD2 NAME(PolygonOffsetxOES)(GLfixed factor, GLfixed units); + +KEYWORD1 void KEYWORD2 NAME(PolygonOffsetxOES)(GLfixed factor, GLfixed units) +{ + DISPATCH(PolygonOffsetx, (factor, units), (F, "glPolygonOffsetxOES(%d, %d);\n", factor, units)); +} + +KEYWORD1 void KEYWORD2 NAME(Rotatex)(GLfixed angle, GLfixed x, GLfixed y, GLfixed z); + +KEYWORD1 void KEYWORD2 NAME(Rotatex)(GLfixed angle, GLfixed x, GLfixed y, GLfixed z) +{ + DISPATCH(Rotatex, (angle, x, y, z), (F, "glRotatex(%d, %d, %d, %d);\n", angle, x, y, z)); +} + +KEYWORD1 void KEYWORD2 NAME(RotatexOES)(GLfixed angle, GLfixed x, GLfixed y, GLfixed z); + +KEYWORD1 void KEYWORD2 NAME(RotatexOES)(GLfixed angle, GLfixed x, GLfixed y, GLfixed z) +{ + DISPATCH(Rotatex, (angle, x, y, z), (F, "glRotatexOES(%d, %d, %d, %d);\n", angle, x, y, z)); +} + +KEYWORD1 void KEYWORD2 NAME(SampleCoveragex)(GLclampx value, GLboolean invert); + +KEYWORD1 void KEYWORD2 NAME(SampleCoveragex)(GLclampx value, GLboolean invert) +{ + DISPATCH(SampleCoveragex, (value, invert), (F, "glSampleCoveragex(%d, %d);\n", value, invert)); +} + +KEYWORD1 void KEYWORD2 NAME(SampleCoveragexOES)(GLclampx value, GLboolean invert); + +KEYWORD1 void KEYWORD2 NAME(SampleCoveragexOES)(GLclampx value, GLboolean invert) +{ + DISPATCH(SampleCoveragex, (value, invert), (F, "glSampleCoveragexOES(%d, %d);\n", value, invert)); +} + +KEYWORD1 void KEYWORD2 NAME(Scalex)(GLfixed x, GLfixed y, GLfixed z); + +KEYWORD1 void KEYWORD2 NAME(Scalex)(GLfixed x, GLfixed y, GLfixed z) +{ + DISPATCH(Scalex, (x, y, z), (F, "glScalex(%d, %d, %d);\n", x, y, z)); +} + +KEYWORD1 void KEYWORD2 NAME(ScalexOES)(GLfixed x, GLfixed y, GLfixed z); + +KEYWORD1 void KEYWORD2 NAME(ScalexOES)(GLfixed x, GLfixed y, GLfixed z) +{ + DISPATCH(Scalex, (x, y, z), (F, "glScalexOES(%d, %d, %d);\n", x, y, z)); +} + +KEYWORD1 void KEYWORD2 NAME(TexEnvx)(GLenum target, GLenum pname, GLfixed param); + +KEYWORD1 void KEYWORD2 NAME(TexEnvx)(GLenum target, GLenum pname, GLfixed param) +{ + DISPATCH(TexEnvx, (target, pname, param), (F, "glTexEnvx(0x%x, 0x%x, %d);\n", target, pname, param)); +} + +KEYWORD1 void KEYWORD2 NAME(TexEnvxOES)(GLenum target, GLenum pname, GLfixed param); + +KEYWORD1 void KEYWORD2 NAME(TexEnvxOES)(GLenum target, GLenum pname, GLfixed param) +{ + DISPATCH(TexEnvx, (target, pname, param), (F, "glTexEnvxOES(0x%x, 0x%x, %d);\n", target, pname, param)); +} + +KEYWORD1 void KEYWORD2 NAME(TexEnvxv)(GLenum target, GLenum pname, const GLfixed * params); + +KEYWORD1 void KEYWORD2 NAME(TexEnvxv)(GLenum target, GLenum pname, const GLfixed * params) +{ + DISPATCH(TexEnvxv, (target, pname, params), (F, "glTexEnvxv(0x%x, 0x%x, %p);\n", target, pname, (const void *) params)); +} + +KEYWORD1 void KEYWORD2 NAME(TexEnvxvOES)(GLenum target, GLenum pname, const GLfixed * params); + +KEYWORD1 void KEYWORD2 NAME(TexEnvxvOES)(GLenum target, GLenum pname, const GLfixed * params) +{ + DISPATCH(TexEnvxv, (target, pname, params), (F, "glTexEnvxvOES(0x%x, 0x%x, %p);\n", target, pname, (const void *) params)); +} + +KEYWORD1 void KEYWORD2 NAME(TexParameterx)(GLenum target, GLenum pname, GLfixed param); + +KEYWORD1 void KEYWORD2 NAME(TexParameterx)(GLenum target, GLenum pname, GLfixed param) +{ + DISPATCH(TexParameterx, (target, pname, param), (F, "glTexParameterx(0x%x, 0x%x, %d);\n", target, pname, param)); +} + +KEYWORD1 void KEYWORD2 NAME(TexParameterxOES)(GLenum target, GLenum pname, GLfixed param); + +KEYWORD1 void KEYWORD2 NAME(TexParameterxOES)(GLenum target, GLenum pname, GLfixed param) +{ + DISPATCH(TexParameterx, (target, pname, param), (F, "glTexParameterxOES(0x%x, 0x%x, %d);\n", target, pname, param)); +} + +KEYWORD1 void KEYWORD2 NAME(Translatex)(GLfixed x, GLfixed y, GLfixed z); + +KEYWORD1 void KEYWORD2 NAME(Translatex)(GLfixed x, GLfixed y, GLfixed z) +{ + DISPATCH(Translatex, (x, y, z), (F, "glTranslatex(%d, %d, %d);\n", x, y, z)); +} + +KEYWORD1 void KEYWORD2 NAME(TranslatexOES)(GLfixed x, GLfixed y, GLfixed z); + +KEYWORD1 void KEYWORD2 NAME(TranslatexOES)(GLfixed x, GLfixed y, GLfixed z) +{ + DISPATCH(Translatex, (x, y, z), (F, "glTranslatexOES(%d, %d, %d);\n", x, y, z)); +} + +KEYWORD1 void KEYWORD2 NAME(ClipPlanef)(GLenum plane, const GLfloat * equation); + +KEYWORD1 void KEYWORD2 NAME(ClipPlanef)(GLenum plane, const GLfloat * equation) +{ + DISPATCH(ClipPlanef, (plane, equation), (F, "glClipPlanef(0x%x, %p);\n", plane, (const void *) equation)); +} + +KEYWORD1 void KEYWORD2 NAME(ClipPlanefOES)(GLenum plane, const GLfloat * equation); + +KEYWORD1 void KEYWORD2 NAME(ClipPlanefOES)(GLenum plane, const GLfloat * equation) +{ + DISPATCH(ClipPlanef, (plane, equation), (F, "glClipPlanefOES(0x%x, %p);\n", plane, (const void *) equation)); +} + +KEYWORD1 void KEYWORD2 NAME(ClipPlanex)(GLenum plane, const GLfixed * equation); + +KEYWORD1 void KEYWORD2 NAME(ClipPlanex)(GLenum plane, const GLfixed * equation) +{ + DISPATCH(ClipPlanex, (plane, equation), (F, "glClipPlanex(0x%x, %p);\n", plane, (const void *) equation)); +} + +KEYWORD1 void KEYWORD2 NAME(ClipPlanexOES)(GLenum plane, const GLfixed * equation); + +KEYWORD1 void KEYWORD2 NAME(ClipPlanexOES)(GLenum plane, const GLfixed * equation) +{ + DISPATCH(ClipPlanex, (plane, equation), (F, "glClipPlanexOES(0x%x, %p);\n", plane, (const void *) equation)); +} + +KEYWORD1 void KEYWORD2 NAME(GetClipPlanef)(GLenum plane, GLfloat * equation); + +KEYWORD1 void KEYWORD2 NAME(GetClipPlanef)(GLenum plane, GLfloat * equation) +{ + DISPATCH(GetClipPlanef, (plane, equation), (F, "glGetClipPlanef(0x%x, %p);\n", plane, (const void *) equation)); +} + +KEYWORD1 void KEYWORD2 NAME(GetClipPlanefOES)(GLenum plane, GLfloat * equation); + +KEYWORD1 void KEYWORD2 NAME(GetClipPlanefOES)(GLenum plane, GLfloat * equation) +{ + DISPATCH(GetClipPlanef, (plane, equation), (F, "glGetClipPlanefOES(0x%x, %p);\n", plane, (const void *) equation)); +} + +KEYWORD1 void KEYWORD2 NAME(GetClipPlanex)(GLenum plane, GLfixed * equation); + +KEYWORD1 void KEYWORD2 NAME(GetClipPlanex)(GLenum plane, GLfixed * equation) +{ + DISPATCH(GetClipPlanex, (plane, equation), (F, "glGetClipPlanex(0x%x, %p);\n", plane, (const void *) equation)); +} + +KEYWORD1 void KEYWORD2 NAME(GetClipPlanexOES)(GLenum plane, GLfixed * equation); + +KEYWORD1 void KEYWORD2 NAME(GetClipPlanexOES)(GLenum plane, GLfixed * equation) +{ + DISPATCH(GetClipPlanex, (plane, equation), (F, "glGetClipPlanexOES(0x%x, %p);\n", plane, (const void *) equation)); +} + +KEYWORD1 void KEYWORD2 NAME(GetFixedv)(GLenum pname, GLfixed * params); + +KEYWORD1 void KEYWORD2 NAME(GetFixedv)(GLenum pname, GLfixed * params) +{ + DISPATCH(GetFixedv, (pname, params), (F, "glGetFixedv(0x%x, %p);\n", pname, (const void *) params)); +} + +KEYWORD1 void KEYWORD2 NAME(GetFixedvOES)(GLenum pname, GLfixed * params); + +KEYWORD1 void KEYWORD2 NAME(GetFixedvOES)(GLenum pname, GLfixed * params) +{ + DISPATCH(GetFixedv, (pname, params), (F, "glGetFixedvOES(0x%x, %p);\n", pname, (const void *) params)); +} + +KEYWORD1 void KEYWORD2 NAME(GetLightxv)(GLenum light, GLenum pname, GLfixed * params); + +KEYWORD1 void KEYWORD2 NAME(GetLightxv)(GLenum light, GLenum pname, GLfixed * params) +{ + DISPATCH(GetLightxv, (light, pname, params), (F, "glGetLightxv(0x%x, 0x%x, %p);\n", light, pname, (const void *) params)); +} + +KEYWORD1 void KEYWORD2 NAME(GetLightxvOES)(GLenum light, GLenum pname, GLfixed * params); + +KEYWORD1 void KEYWORD2 NAME(GetLightxvOES)(GLenum light, GLenum pname, GLfixed * params) +{ + DISPATCH(GetLightxv, (light, pname, params), (F, "glGetLightxvOES(0x%x, 0x%x, %p);\n", light, pname, (const void *) params)); +} + +KEYWORD1 void KEYWORD2 NAME(GetMaterialxv)(GLenum face, GLenum pname, GLfixed * params); + +KEYWORD1 void KEYWORD2 NAME(GetMaterialxv)(GLenum face, GLenum pname, GLfixed * params) +{ + DISPATCH(GetMaterialxv, (face, pname, params), (F, "glGetMaterialxv(0x%x, 0x%x, %p);\n", face, pname, (const void *) params)); +} + +KEYWORD1 void KEYWORD2 NAME(GetMaterialxvOES)(GLenum face, GLenum pname, GLfixed * params); + +KEYWORD1 void KEYWORD2 NAME(GetMaterialxvOES)(GLenum face, GLenum pname, GLfixed * params) +{ + DISPATCH(GetMaterialxv, (face, pname, params), (F, "glGetMaterialxvOES(0x%x, 0x%x, %p);\n", face, pname, (const void *) params)); +} + +KEYWORD1 void KEYWORD2 NAME(GetTexEnvxv)(GLenum target, GLenum pname, GLfixed * params); + +KEYWORD1 void KEYWORD2 NAME(GetTexEnvxv)(GLenum target, GLenum pname, GLfixed * params) +{ + DISPATCH(GetTexEnvxv, (target, pname, params), (F, "glGetTexEnvxv(0x%x, 0x%x, %p);\n", target, pname, (const void *) params)); +} + +KEYWORD1 void KEYWORD2 NAME(GetTexEnvxvOES)(GLenum target, GLenum pname, GLfixed * params); + +KEYWORD1 void KEYWORD2 NAME(GetTexEnvxvOES)(GLenum target, GLenum pname, GLfixed * params) +{ + DISPATCH(GetTexEnvxv, (target, pname, params), (F, "glGetTexEnvxvOES(0x%x, 0x%x, %p);\n", target, pname, (const void *) params)); +} + +KEYWORD1 void KEYWORD2 NAME(GetTexParameterxv)(GLenum target, GLenum pname, GLfixed * params); + +KEYWORD1 void KEYWORD2 NAME(GetTexParameterxv)(GLenum target, GLenum pname, GLfixed * params) +{ + DISPATCH(GetTexParameterxv, (target, pname, params), (F, "glGetTexParameterxv(0x%x, 0x%x, %p);\n", target, pname, (const void *) params)); +} + +KEYWORD1 void KEYWORD2 NAME(GetTexParameterxvOES)(GLenum target, GLenum pname, GLfixed * params); + +KEYWORD1 void KEYWORD2 NAME(GetTexParameterxvOES)(GLenum target, GLenum pname, GLfixed * params) +{ + DISPATCH(GetTexParameterxv, (target, pname, params), (F, "glGetTexParameterxvOES(0x%x, 0x%x, %p);\n", target, pname, (const void *) params)); +} + +KEYWORD1 void KEYWORD2 NAME(PointParameterx)(GLenum pname, GLfixed param); + +KEYWORD1 void KEYWORD2 NAME(PointParameterx)(GLenum pname, GLfixed param) +{ + DISPATCH(PointParameterx, (pname, param), (F, "glPointParameterx(0x%x, %d);\n", pname, param)); +} + +KEYWORD1 void KEYWORD2 NAME(PointParameterxOES)(GLenum pname, GLfixed param); + +KEYWORD1 void KEYWORD2 NAME(PointParameterxOES)(GLenum pname, GLfixed param) +{ + DISPATCH(PointParameterx, (pname, param), (F, "glPointParameterxOES(0x%x, %d);\n", pname, param)); +} + +KEYWORD1 void KEYWORD2 NAME(PointParameterxv)(GLenum pname, const GLfixed * params); + +KEYWORD1 void KEYWORD2 NAME(PointParameterxv)(GLenum pname, const GLfixed * params) +{ + DISPATCH(PointParameterxv, (pname, params), (F, "glPointParameterxv(0x%x, %p);\n", pname, (const void *) params)); +} + +KEYWORD1 void KEYWORD2 NAME(PointParameterxvOES)(GLenum pname, const GLfixed * params); + +KEYWORD1 void KEYWORD2 NAME(PointParameterxvOES)(GLenum pname, const GLfixed * params) +{ + DISPATCH(PointParameterxv, (pname, params), (F, "glPointParameterxvOES(0x%x, %p);\n", pname, (const void *) params)); +} + +KEYWORD1 void KEYWORD2 NAME(TexParameterxv)(GLenum target, GLenum pname, const GLfixed * params); + +KEYWORD1 void KEYWORD2 NAME(TexParameterxv)(GLenum target, GLenum pname, const GLfixed * params) +{ + DISPATCH(TexParameterxv, (target, pname, params), (F, "glTexParameterxv(0x%x, 0x%x, %p);\n", target, pname, (const void *) params)); +} + +KEYWORD1 void KEYWORD2 NAME(TexParameterxvOES)(GLenum target, GLenum pname, const GLfixed * params); + +KEYWORD1 void KEYWORD2 NAME(TexParameterxvOES)(GLenum target, GLenum pname, const GLfixed * params) +{ + DISPATCH(TexParameterxv, (target, pname, params), (F, "glTexParameterxvOES(0x%x, 0x%x, %p);\n", target, pname, (const void *) params)); +} + + +#endif /* _GLAPI_SKIP_NORMAL_ENTRY_POINTS */ + +/* these entry points might require different protocols */ +#ifndef _GLAPI_SKIP_PROTO_ENTRY_POINTS + + +#endif /* _GLAPI_SKIP_PROTO_ENTRY_POINTS */ + + +#endif /* defined( NAME ) */ + +/* + * This is how a dispatch table can be initialized with all the functions + * we generated above. + */ +#ifdef DISPATCH_TABLE_NAME + +#ifndef TABLE_ENTRY +#error TABLE_ENTRY must be defined +#endif + +#ifdef _GLAPI_SKIP_NORMAL_ENTRY_POINTS +#error _GLAPI_SKIP_NORMAL_ENTRY_POINTS must not be defined +#endif + +_glapi_proc DISPATCH_TABLE_NAME[] = { + TABLE_ENTRY(_dispatch_stub_0), + TABLE_ENTRY(_dispatch_stub_1), + TABLE_ENTRY(_dispatch_stub_2), + TABLE_ENTRY(_dispatch_stub_3), + TABLE_ENTRY(_dispatch_stub_4), + TABLE_ENTRY(_dispatch_stub_5), + TABLE_ENTRY(_dispatch_stub_6), + TABLE_ENTRY(_dispatch_stub_7), + TABLE_ENTRY(_dispatch_stub_8), + TABLE_ENTRY(_dispatch_stub_9), + TABLE_ENTRY(_dispatch_stub_10), + TABLE_ENTRY(_dispatch_stub_11), + TABLE_ENTRY(_dispatch_stub_12), + TABLE_ENTRY(_dispatch_stub_13), + TABLE_ENTRY(_dispatch_stub_14), + TABLE_ENTRY(_dispatch_stub_15), + TABLE_ENTRY(_dispatch_stub_16), + TABLE_ENTRY(_dispatch_stub_17), + TABLE_ENTRY(_dispatch_stub_18), + TABLE_ENTRY(_dispatch_stub_19), + TABLE_ENTRY(_dispatch_stub_20), + TABLE_ENTRY(_dispatch_stub_21), + TABLE_ENTRY(_dispatch_stub_22), + TABLE_ENTRY(_dispatch_stub_23), + TABLE_ENTRY(_dispatch_stub_24), + TABLE_ENTRY(_dispatch_stub_25), + TABLE_ENTRY(_dispatch_stub_26), + TABLE_ENTRY(_dispatch_stub_27), + TABLE_ENTRY(_dispatch_stub_28), + TABLE_ENTRY(Color4f), + TABLE_ENTRY(_dispatch_stub_30), + TABLE_ENTRY(_dispatch_stub_31), + TABLE_ENTRY(_dispatch_stub_32), + TABLE_ENTRY(_dispatch_stub_33), + TABLE_ENTRY(_dispatch_stub_34), + TABLE_ENTRY(Color4ub), + TABLE_ENTRY(_dispatch_stub_36), + TABLE_ENTRY(_dispatch_stub_37), + TABLE_ENTRY(_dispatch_stub_38), + TABLE_ENTRY(_dispatch_stub_39), + TABLE_ENTRY(_dispatch_stub_40), + TABLE_ENTRY(_dispatch_stub_41), + TABLE_ENTRY(_dispatch_stub_42), + TABLE_ENTRY(_dispatch_stub_43), + TABLE_ENTRY(_dispatch_stub_44), + TABLE_ENTRY(_dispatch_stub_45), + TABLE_ENTRY(_dispatch_stub_46), + TABLE_ENTRY(_dispatch_stub_47), + TABLE_ENTRY(_dispatch_stub_48), + TABLE_ENTRY(_dispatch_stub_49), + TABLE_ENTRY(_dispatch_stub_50), + TABLE_ENTRY(_dispatch_stub_51), + TABLE_ENTRY(_dispatch_stub_52), + TABLE_ENTRY(_dispatch_stub_53), + TABLE_ENTRY(_dispatch_stub_54), + TABLE_ENTRY(_dispatch_stub_55), + TABLE_ENTRY(Normal3f), + TABLE_ENTRY(_dispatch_stub_57), + TABLE_ENTRY(_dispatch_stub_58), + TABLE_ENTRY(_dispatch_stub_59), + TABLE_ENTRY(_dispatch_stub_60), + TABLE_ENTRY(_dispatch_stub_61), + TABLE_ENTRY(_dispatch_stub_62), + TABLE_ENTRY(_dispatch_stub_63), + TABLE_ENTRY(_dispatch_stub_64), + TABLE_ENTRY(_dispatch_stub_65), + TABLE_ENTRY(_dispatch_stub_66), + TABLE_ENTRY(_dispatch_stub_67), + TABLE_ENTRY(_dispatch_stub_68), + TABLE_ENTRY(_dispatch_stub_69), + TABLE_ENTRY(_dispatch_stub_70), + TABLE_ENTRY(_dispatch_stub_71), + TABLE_ENTRY(_dispatch_stub_72), + TABLE_ENTRY(_dispatch_stub_73), + TABLE_ENTRY(_dispatch_stub_74), + TABLE_ENTRY(_dispatch_stub_75), + TABLE_ENTRY(_dispatch_stub_76), + TABLE_ENTRY(_dispatch_stub_77), + TABLE_ENTRY(_dispatch_stub_78), + TABLE_ENTRY(_dispatch_stub_79), + TABLE_ENTRY(_dispatch_stub_80), + TABLE_ENTRY(_dispatch_stub_81), + TABLE_ENTRY(_dispatch_stub_82), + TABLE_ENTRY(_dispatch_stub_83), + TABLE_ENTRY(_dispatch_stub_84), + TABLE_ENTRY(_dispatch_stub_85), + TABLE_ENTRY(_dispatch_stub_86), + TABLE_ENTRY(_dispatch_stub_87), + TABLE_ENTRY(_dispatch_stub_88), + TABLE_ENTRY(_dispatch_stub_89), + TABLE_ENTRY(_dispatch_stub_90), + TABLE_ENTRY(_dispatch_stub_91), + TABLE_ENTRY(_dispatch_stub_92), + TABLE_ENTRY(_dispatch_stub_93), + TABLE_ENTRY(_dispatch_stub_94), + TABLE_ENTRY(_dispatch_stub_95), + TABLE_ENTRY(_dispatch_stub_96), + TABLE_ENTRY(_dispatch_stub_97), + TABLE_ENTRY(_dispatch_stub_98), + TABLE_ENTRY(_dispatch_stub_99), + TABLE_ENTRY(_dispatch_stub_100), + TABLE_ENTRY(_dispatch_stub_101), + TABLE_ENTRY(_dispatch_stub_102), + TABLE_ENTRY(_dispatch_stub_103), + TABLE_ENTRY(_dispatch_stub_104), + TABLE_ENTRY(_dispatch_stub_105), + TABLE_ENTRY(_dispatch_stub_106), + TABLE_ENTRY(_dispatch_stub_107), + TABLE_ENTRY(_dispatch_stub_108), + TABLE_ENTRY(_dispatch_stub_109), + TABLE_ENTRY(_dispatch_stub_110), + TABLE_ENTRY(_dispatch_stub_111), + TABLE_ENTRY(_dispatch_stub_112), + TABLE_ENTRY(_dispatch_stub_113), + TABLE_ENTRY(_dispatch_stub_114), + TABLE_ENTRY(_dispatch_stub_115), + TABLE_ENTRY(_dispatch_stub_116), + TABLE_ENTRY(_dispatch_stub_117), + TABLE_ENTRY(_dispatch_stub_118), + TABLE_ENTRY(_dispatch_stub_119), + TABLE_ENTRY(_dispatch_stub_120), + TABLE_ENTRY(_dispatch_stub_121), + TABLE_ENTRY(_dispatch_stub_122), + TABLE_ENTRY(_dispatch_stub_123), + TABLE_ENTRY(_dispatch_stub_124), + TABLE_ENTRY(_dispatch_stub_125), + TABLE_ENTRY(_dispatch_stub_126), + TABLE_ENTRY(_dispatch_stub_127), + TABLE_ENTRY(_dispatch_stub_128), + TABLE_ENTRY(_dispatch_stub_129), + TABLE_ENTRY(_dispatch_stub_130), + TABLE_ENTRY(_dispatch_stub_131), + TABLE_ENTRY(_dispatch_stub_132), + TABLE_ENTRY(_dispatch_stub_133), + TABLE_ENTRY(_dispatch_stub_134), + TABLE_ENTRY(_dispatch_stub_135), + TABLE_ENTRY(_dispatch_stub_136), + TABLE_ENTRY(_dispatch_stub_137), + TABLE_ENTRY(_dispatch_stub_138), + TABLE_ENTRY(_dispatch_stub_139), + TABLE_ENTRY(_dispatch_stub_140), + TABLE_ENTRY(_dispatch_stub_141), + TABLE_ENTRY(_dispatch_stub_142), + TABLE_ENTRY(_dispatch_stub_143), + TABLE_ENTRY(_dispatch_stub_144), + TABLE_ENTRY(_dispatch_stub_145), + TABLE_ENTRY(_dispatch_stub_146), + TABLE_ENTRY(_dispatch_stub_147), + TABLE_ENTRY(_dispatch_stub_148), + TABLE_ENTRY(_dispatch_stub_149), + TABLE_ENTRY(_dispatch_stub_150), + TABLE_ENTRY(_dispatch_stub_151), + TABLE_ENTRY(CullFace), + TABLE_ENTRY(Fogf), + TABLE_ENTRY(Fogfv), + TABLE_ENTRY(_dispatch_stub_155), + TABLE_ENTRY(_dispatch_stub_156), + TABLE_ENTRY(FrontFace), + TABLE_ENTRY(Hint), + TABLE_ENTRY(Lightf), + TABLE_ENTRY(Lightfv), + TABLE_ENTRY(_dispatch_stub_161), + TABLE_ENTRY(_dispatch_stub_162), + TABLE_ENTRY(LightModelf), + TABLE_ENTRY(LightModelfv), + TABLE_ENTRY(_dispatch_stub_165), + TABLE_ENTRY(_dispatch_stub_166), + TABLE_ENTRY(_dispatch_stub_167), + TABLE_ENTRY(LineWidth), + TABLE_ENTRY(Materialf), + TABLE_ENTRY(Materialfv), + TABLE_ENTRY(_dispatch_stub_171), + TABLE_ENTRY(_dispatch_stub_172), + TABLE_ENTRY(PointSize), + TABLE_ENTRY(_dispatch_stub_174), + TABLE_ENTRY(_dispatch_stub_175), + TABLE_ENTRY(Scissor), + TABLE_ENTRY(ShadeModel), + TABLE_ENTRY(TexParameterf), + TABLE_ENTRY(TexParameterfv), + TABLE_ENTRY(TexParameteri), + TABLE_ENTRY(TexParameteriv), + TABLE_ENTRY(_dispatch_stub_182), + TABLE_ENTRY(TexImage2D), + TABLE_ENTRY(TexEnvf), + TABLE_ENTRY(TexEnvfv), + TABLE_ENTRY(TexEnvi), + TABLE_ENTRY(TexEnviv), + TABLE_ENTRY(_dispatch_stub_188), + TABLE_ENTRY(_dispatch_stub_189), + TABLE_ENTRY(TexGenfOES), + TABLE_ENTRY(TexGenfvOES), + TABLE_ENTRY(TexGeniOES), + TABLE_ENTRY(TexGenivOES), + TABLE_ENTRY(_dispatch_stub_194), + TABLE_ENTRY(_dispatch_stub_195), + TABLE_ENTRY(_dispatch_stub_196), + TABLE_ENTRY(_dispatch_stub_197), + TABLE_ENTRY(_dispatch_stub_198), + TABLE_ENTRY(_dispatch_stub_199), + TABLE_ENTRY(_dispatch_stub_200), + TABLE_ENTRY(_dispatch_stub_201), + TABLE_ENTRY(_dispatch_stub_202), + TABLE_ENTRY(Clear), + TABLE_ENTRY(_dispatch_stub_204), + TABLE_ENTRY(_dispatch_stub_205), + TABLE_ENTRY(ClearColor), + TABLE_ENTRY(ClearStencil), + TABLE_ENTRY(_dispatch_stub_208), + TABLE_ENTRY(StencilMask), + TABLE_ENTRY(ColorMask), + TABLE_ENTRY(DepthMask), + TABLE_ENTRY(_dispatch_stub_212), + TABLE_ENTRY(_dispatch_stub_213), + TABLE_ENTRY(Disable), + TABLE_ENTRY(Enable), + TABLE_ENTRY(Finish), + TABLE_ENTRY(Flush), + TABLE_ENTRY(_dispatch_stub_218), + TABLE_ENTRY(_dispatch_stub_219), + TABLE_ENTRY(_dispatch_stub_220), + TABLE_ENTRY(_dispatch_stub_221), + TABLE_ENTRY(_dispatch_stub_222), + TABLE_ENTRY(_dispatch_stub_223), + TABLE_ENTRY(_dispatch_stub_224), + TABLE_ENTRY(_dispatch_stub_225), + TABLE_ENTRY(_dispatch_stub_226), + TABLE_ENTRY(_dispatch_stub_227), + TABLE_ENTRY(_dispatch_stub_228), + TABLE_ENTRY(_dispatch_stub_229), + TABLE_ENTRY(_dispatch_stub_230), + TABLE_ENTRY(_dispatch_stub_231), + TABLE_ENTRY(_dispatch_stub_232), + TABLE_ENTRY(_dispatch_stub_233), + TABLE_ENTRY(_dispatch_stub_234), + TABLE_ENTRY(_dispatch_stub_235), + TABLE_ENTRY(_dispatch_stub_236), + TABLE_ENTRY(_dispatch_stub_237), + TABLE_ENTRY(_dispatch_stub_238), + TABLE_ENTRY(_dispatch_stub_239), + TABLE_ENTRY(AlphaFunc), + TABLE_ENTRY(BlendFunc), + TABLE_ENTRY(LogicOp), + TABLE_ENTRY(StencilFunc), + TABLE_ENTRY(StencilOp), + TABLE_ENTRY(DepthFunc), + TABLE_ENTRY(_dispatch_stub_246), + TABLE_ENTRY(_dispatch_stub_247), + TABLE_ENTRY(_dispatch_stub_248), + TABLE_ENTRY(_dispatch_stub_249), + TABLE_ENTRY(PixelStorei), + TABLE_ENTRY(_dispatch_stub_251), + TABLE_ENTRY(_dispatch_stub_252), + TABLE_ENTRY(_dispatch_stub_253), + TABLE_ENTRY(_dispatch_stub_254), + TABLE_ENTRY(_dispatch_stub_255), + TABLE_ENTRY(ReadPixels), + TABLE_ENTRY(_dispatch_stub_257), + TABLE_ENTRY(GetBooleanv), + TABLE_ENTRY(_dispatch_stub_259), + TABLE_ENTRY(_dispatch_stub_260), + TABLE_ENTRY(GetError), + TABLE_ENTRY(GetFloatv), + TABLE_ENTRY(GetIntegerv), + TABLE_ENTRY(GetLightfv), + TABLE_ENTRY(_dispatch_stub_265), + TABLE_ENTRY(_dispatch_stub_266), + TABLE_ENTRY(_dispatch_stub_267), + TABLE_ENTRY(_dispatch_stub_268), + TABLE_ENTRY(GetMaterialfv), + TABLE_ENTRY(_dispatch_stub_270), + TABLE_ENTRY(_dispatch_stub_271), + TABLE_ENTRY(_dispatch_stub_272), + TABLE_ENTRY(_dispatch_stub_273), + TABLE_ENTRY(_dispatch_stub_274), + TABLE_ENTRY(GetString), + TABLE_ENTRY(GetTexEnvfv), + TABLE_ENTRY(GetTexEnviv), + TABLE_ENTRY(_dispatch_stub_278), + TABLE_ENTRY(GetTexGenfvOES), + TABLE_ENTRY(GetTexGenivOES), + TABLE_ENTRY(_dispatch_stub_281), + TABLE_ENTRY(GetTexParameterfv), + TABLE_ENTRY(GetTexParameteriv), + TABLE_ENTRY(_dispatch_stub_284), + TABLE_ENTRY(_dispatch_stub_285), + TABLE_ENTRY(IsEnabled), + TABLE_ENTRY(_dispatch_stub_287), + TABLE_ENTRY(_dispatch_stub_288), + TABLE_ENTRY(_dispatch_stub_289), + TABLE_ENTRY(LoadIdentity), + TABLE_ENTRY(LoadMatrixf), + TABLE_ENTRY(_dispatch_stub_292), + TABLE_ENTRY(MatrixMode), + TABLE_ENTRY(MultMatrixf), + TABLE_ENTRY(_dispatch_stub_295), + TABLE_ENTRY(_dispatch_stub_296), + TABLE_ENTRY(PopMatrix), + TABLE_ENTRY(PushMatrix), + TABLE_ENTRY(_dispatch_stub_299), + TABLE_ENTRY(Rotatef), + TABLE_ENTRY(_dispatch_stub_301), + TABLE_ENTRY(Scalef), + TABLE_ENTRY(_dispatch_stub_303), + TABLE_ENTRY(Translatef), + TABLE_ENTRY(Viewport), + TABLE_ENTRY(_dispatch_stub_306), + TABLE_ENTRY(BindTexture), + TABLE_ENTRY(ColorPointer), + TABLE_ENTRY(DisableClientState), + TABLE_ENTRY(DrawArrays), + TABLE_ENTRY(DrawElements), + TABLE_ENTRY(_dispatch_stub_312), + TABLE_ENTRY(EnableClientState), + TABLE_ENTRY(_dispatch_stub_314), + TABLE_ENTRY(_dispatch_stub_315), + TABLE_ENTRY(_dispatch_stub_316), + TABLE_ENTRY(_dispatch_stub_317), + TABLE_ENTRY(NormalPointer), + TABLE_ENTRY(PolygonOffset), + TABLE_ENTRY(TexCoordPointer), + TABLE_ENTRY(VertexPointer), + TABLE_ENTRY(_dispatch_stub_322), + TABLE_ENTRY(_dispatch_stub_323), + TABLE_ENTRY(CopyTexImage2D), + TABLE_ENTRY(_dispatch_stub_325), + TABLE_ENTRY(CopyTexSubImage2D), + TABLE_ENTRY(DeleteTextures), + TABLE_ENTRY(GenTextures), + TABLE_ENTRY(GetPointerv), + TABLE_ENTRY(IsTexture), + TABLE_ENTRY(_dispatch_stub_331), + TABLE_ENTRY(_dispatch_stub_332), + TABLE_ENTRY(TexSubImage2D), + TABLE_ENTRY(_dispatch_stub_334), + TABLE_ENTRY(_dispatch_stub_335), + TABLE_ENTRY(_dispatch_stub_336), + TABLE_ENTRY(BlendEquationOES), + TABLE_ENTRY(_dispatch_stub_338), + TABLE_ENTRY(_dispatch_stub_339), + TABLE_ENTRY(_dispatch_stub_340), + TABLE_ENTRY(_dispatch_stub_341), + TABLE_ENTRY(_dispatch_stub_342), + TABLE_ENTRY(_dispatch_stub_343), + TABLE_ENTRY(_dispatch_stub_344), + TABLE_ENTRY(_dispatch_stub_345), + TABLE_ENTRY(_dispatch_stub_346), + TABLE_ENTRY(_dispatch_stub_347), + TABLE_ENTRY(_dispatch_stub_348), + TABLE_ENTRY(_dispatch_stub_349), + TABLE_ENTRY(_dispatch_stub_350), + TABLE_ENTRY(_dispatch_stub_351), + TABLE_ENTRY(_dispatch_stub_352), + TABLE_ENTRY(_dispatch_stub_353), + TABLE_ENTRY(_dispatch_stub_354), + TABLE_ENTRY(_dispatch_stub_355), + TABLE_ENTRY(_dispatch_stub_356), + TABLE_ENTRY(_dispatch_stub_357), + TABLE_ENTRY(_dispatch_stub_358), + TABLE_ENTRY(_dispatch_stub_359), + TABLE_ENTRY(_dispatch_stub_360), + TABLE_ENTRY(_dispatch_stub_361), + TABLE_ENTRY(_dispatch_stub_362), + TABLE_ENTRY(_dispatch_stub_363), + TABLE_ENTRY(_dispatch_stub_364), + TABLE_ENTRY(_dispatch_stub_365), + TABLE_ENTRY(_dispatch_stub_366), + TABLE_ENTRY(_dispatch_stub_367), + TABLE_ENTRY(_dispatch_stub_368), + TABLE_ENTRY(_dispatch_stub_369), + TABLE_ENTRY(_dispatch_stub_370), + TABLE_ENTRY(_dispatch_stub_371), + TABLE_ENTRY(_dispatch_stub_372), + TABLE_ENTRY(_dispatch_stub_373), + TABLE_ENTRY(ActiveTexture), + TABLE_ENTRY(ClientActiveTexture), + TABLE_ENTRY(_dispatch_stub_376), + TABLE_ENTRY(_dispatch_stub_377), + TABLE_ENTRY(_dispatch_stub_378), + TABLE_ENTRY(_dispatch_stub_379), + TABLE_ENTRY(_dispatch_stub_380), + TABLE_ENTRY(_dispatch_stub_381), + TABLE_ENTRY(_dispatch_stub_382), + TABLE_ENTRY(_dispatch_stub_383), + TABLE_ENTRY(_dispatch_stub_384), + TABLE_ENTRY(_dispatch_stub_385), + TABLE_ENTRY(_dispatch_stub_386), + TABLE_ENTRY(_dispatch_stub_387), + TABLE_ENTRY(_dispatch_stub_388), + TABLE_ENTRY(_dispatch_stub_389), + TABLE_ENTRY(_dispatch_stub_390), + TABLE_ENTRY(_dispatch_stub_391), + TABLE_ENTRY(_dispatch_stub_392), + TABLE_ENTRY(_dispatch_stub_393), + TABLE_ENTRY(_dispatch_stub_394), + TABLE_ENTRY(_dispatch_stub_395), + TABLE_ENTRY(_dispatch_stub_396), + TABLE_ENTRY(_dispatch_stub_397), + TABLE_ENTRY(_dispatch_stub_398), + TABLE_ENTRY(_dispatch_stub_399), + TABLE_ENTRY(_dispatch_stub_400), + TABLE_ENTRY(_dispatch_stub_401), + TABLE_ENTRY(MultiTexCoord4f), + TABLE_ENTRY(_dispatch_stub_403), + TABLE_ENTRY(_dispatch_stub_404), + TABLE_ENTRY(_dispatch_stub_405), + TABLE_ENTRY(_dispatch_stub_406), + TABLE_ENTRY(_dispatch_stub_407), + TABLE_ENTRY(BlendEquationSeparateOES), + TABLE_ENTRY(BlendFuncSeparateOES), + TABLE_ENTRY(DrawTexfOES), + TABLE_ENTRY(DrawTexfvOES), + TABLE_ENTRY(DrawTexiOES), + TABLE_ENTRY(DrawTexivOES), + TABLE_ENTRY(DrawTexsOES), + TABLE_ENTRY(DrawTexsvOES), + TABLE_ENTRY(DrawTexxOES), + TABLE_ENTRY(DrawTexxvOES), + TABLE_ENTRY(BindFramebufferOES), + TABLE_ENTRY(BindRenderbufferOES), + TABLE_ENTRY(CheckFramebufferStatusOES), + TABLE_ENTRY(DeleteFramebuffersOES), + TABLE_ENTRY(DeleteRenderbuffersOES), + TABLE_ENTRY(FramebufferRenderbufferOES), + TABLE_ENTRY(FramebufferTexture2DOES), + TABLE_ENTRY(GenFramebuffersOES), + TABLE_ENTRY(GenRenderbuffersOES), + TABLE_ENTRY(GenerateMipmapOES), + TABLE_ENTRY(GetFramebufferAttachmentParameterivOES), + TABLE_ENTRY(GetRenderbufferParameterivOES), + TABLE_ENTRY(IsFramebufferOES), + TABLE_ENTRY(IsRenderbufferOES), + TABLE_ENTRY(RenderbufferStorageOES), + TABLE_ENTRY(PointSizePointerOES), + TABLE_ENTRY(QueryMatrixxOES), + TABLE_ENTRY(GetTexGenxvOES), + TABLE_ENTRY(TexGenxOES), + TABLE_ENTRY(TexGenxvOES), + TABLE_ENTRY(GetBufferPointervOES), + TABLE_ENTRY(MapBufferOES), + TABLE_ENTRY(UnmapBufferOES), + TABLE_ENTRY(MultiDrawArraysEXT), + TABLE_ENTRY(MultiDrawElementsEXT), + TABLE_ENTRY(_dispatch_stub_443), + TABLE_ENTRY(_dispatch_stub_444), + TABLE_ENTRY(_dispatch_stub_445), + TABLE_ENTRY(_dispatch_stub_446), + TABLE_ENTRY(EGLImageTargetRenderbufferStorageOES), + TABLE_ENTRY(EGLImageTargetTexture2DOES), + TABLE_ENTRY(CompressedTexImage2D), + TABLE_ENTRY(CompressedTexSubImage2D), + TABLE_ENTRY(SampleCoverage), + TABLE_ENTRY(BindBuffer), + TABLE_ENTRY(BufferData), + TABLE_ENTRY(BufferSubData), + TABLE_ENTRY(DeleteBuffers), + TABLE_ENTRY(GenBuffers), + TABLE_ENTRY(GetBufferParameteriv), + TABLE_ENTRY(IsBuffer), + TABLE_ENTRY(PointParameterf), + TABLE_ENTRY(PointParameterfv), + TABLE_ENTRY(AlphaFuncx), + TABLE_ENTRY(ClearColorx), + TABLE_ENTRY(ClearDepthf), + TABLE_ENTRY(ClearDepthx), + TABLE_ENTRY(Color4x), + TABLE_ENTRY(DepthRangef), + TABLE_ENTRY(DepthRangex), + TABLE_ENTRY(Fogx), + TABLE_ENTRY(Fogxv), + TABLE_ENTRY(Frustumf), + TABLE_ENTRY(Frustumx), + TABLE_ENTRY(LightModelx), + TABLE_ENTRY(LightModelxv), + TABLE_ENTRY(Lightx), + TABLE_ENTRY(Lightxv), + TABLE_ENTRY(LineWidthx), + TABLE_ENTRY(LoadMatrixx), + TABLE_ENTRY(Materialx), + TABLE_ENTRY(Materialxv), + TABLE_ENTRY(MultMatrixx), + TABLE_ENTRY(MultiTexCoord4x), + TABLE_ENTRY(Normal3x), + TABLE_ENTRY(Orthof), + TABLE_ENTRY(Orthox), + TABLE_ENTRY(PointSizex), + TABLE_ENTRY(PolygonOffsetx), + TABLE_ENTRY(Rotatex), + TABLE_ENTRY(SampleCoveragex), + TABLE_ENTRY(Scalex), + TABLE_ENTRY(TexEnvx), + TABLE_ENTRY(TexEnvxv), + TABLE_ENTRY(TexParameterx), + TABLE_ENTRY(Translatex), + TABLE_ENTRY(ClipPlanef), + TABLE_ENTRY(ClipPlanex), + TABLE_ENTRY(GetClipPlanef), + TABLE_ENTRY(GetClipPlanex), + TABLE_ENTRY(GetFixedv), + TABLE_ENTRY(GetLightxv), + TABLE_ENTRY(GetMaterialxv), + TABLE_ENTRY(GetTexEnvxv), + TABLE_ENTRY(GetTexParameterxv), + TABLE_ENTRY(PointParameterx), + TABLE_ENTRY(PointParameterxv), + TABLE_ENTRY(TexParameterxv), + /* A whole bunch of no-op functions. These might be called + * when someone tries to call a dynamically-registered + * extension function without a current rendering context. + */ + TABLE_ENTRY(Unused), + TABLE_ENTRY(Unused), + TABLE_ENTRY(Unused), + TABLE_ENTRY(Unused), + TABLE_ENTRY(Unused), + TABLE_ENTRY(Unused), + TABLE_ENTRY(Unused), + TABLE_ENTRY(Unused), + TABLE_ENTRY(Unused), + TABLE_ENTRY(Unused), + TABLE_ENTRY(Unused), + TABLE_ENTRY(Unused), + TABLE_ENTRY(Unused), + TABLE_ENTRY(Unused), + TABLE_ENTRY(Unused), + TABLE_ENTRY(Unused), + TABLE_ENTRY(Unused), + TABLE_ENTRY(Unused), + TABLE_ENTRY(Unused), + TABLE_ENTRY(Unused), + TABLE_ENTRY(Unused), + TABLE_ENTRY(Unused), + TABLE_ENTRY(Unused), + TABLE_ENTRY(Unused), + TABLE_ENTRY(Unused), + TABLE_ENTRY(Unused), + TABLE_ENTRY(Unused), + TABLE_ENTRY(Unused), + TABLE_ENTRY(Unused), + TABLE_ENTRY(Unused), + TABLE_ENTRY(Unused), + TABLE_ENTRY(Unused), + TABLE_ENTRY(Unused), + TABLE_ENTRY(Unused), + TABLE_ENTRY(Unused), + TABLE_ENTRY(Unused), + TABLE_ENTRY(Unused), + TABLE_ENTRY(Unused), + TABLE_ENTRY(Unused), + TABLE_ENTRY(Unused), + TABLE_ENTRY(Unused), + TABLE_ENTRY(Unused), + TABLE_ENTRY(Unused), + TABLE_ENTRY(Unused), + TABLE_ENTRY(Unused), + TABLE_ENTRY(Unused), + TABLE_ENTRY(Unused), + TABLE_ENTRY(Unused), + TABLE_ENTRY(Unused), + TABLE_ENTRY(Unused), + TABLE_ENTRY(Unused), + TABLE_ENTRY(Unused), + TABLE_ENTRY(Unused), + TABLE_ENTRY(Unused), + TABLE_ENTRY(Unused), + TABLE_ENTRY(Unused), + TABLE_ENTRY(Unused), + TABLE_ENTRY(Unused), + TABLE_ENTRY(Unused), + TABLE_ENTRY(Unused), + TABLE_ENTRY(Unused), + TABLE_ENTRY(Unused), + TABLE_ENTRY(Unused), + TABLE_ENTRY(Unused), + TABLE_ENTRY(Unused), + TABLE_ENTRY(Unused), + TABLE_ENTRY(Unused), + TABLE_ENTRY(Unused), + TABLE_ENTRY(Unused), + TABLE_ENTRY(Unused), + TABLE_ENTRY(Unused), + TABLE_ENTRY(Unused), + TABLE_ENTRY(Unused), + TABLE_ENTRY(Unused), + TABLE_ENTRY(Unused), + TABLE_ENTRY(Unused), + TABLE_ENTRY(Unused), + TABLE_ENTRY(Unused), + TABLE_ENTRY(Unused), + TABLE_ENTRY(Unused), + TABLE_ENTRY(Unused), + TABLE_ENTRY(Unused), + TABLE_ENTRY(Unused), + TABLE_ENTRY(Unused), + TABLE_ENTRY(Unused), + TABLE_ENTRY(Unused), + TABLE_ENTRY(Unused), + TABLE_ENTRY(Unused), + TABLE_ENTRY(Unused), + TABLE_ENTRY(Unused), + TABLE_ENTRY(Unused), + TABLE_ENTRY(Unused), + TABLE_ENTRY(Unused), + TABLE_ENTRY(Unused), + TABLE_ENTRY(Unused), + TABLE_ENTRY(Unused), + TABLE_ENTRY(Unused), + TABLE_ENTRY(Unused), + TABLE_ENTRY(Unused), +}; +#endif /* DISPATCH_TABLE_NAME */ + + +/* + * This is just used to silence compiler warnings. + * We list the functions which are not otherwise used. + */ +#ifdef UNUSED_TABLE_NAME +_glapi_proc UNUSED_TABLE_NAME[] = { +#ifndef _GLAPI_SKIP_NORMAL_ENTRY_POINTS + TABLE_ENTRY(_dispatch_stub_190), + TABLE_ENTRY(_dispatch_stub_191), + TABLE_ENTRY(_dispatch_stub_192), + TABLE_ENTRY(_dispatch_stub_193), + TABLE_ENTRY(_dispatch_stub_279), + TABLE_ENTRY(_dispatch_stub_280), + TABLE_ENTRY(_dispatch_stub_337), + TABLE_ENTRY(_dispatch_stub_374), + TABLE_ENTRY(_dispatch_stub_375), + TABLE_ENTRY(_dispatch_stub_402), + TABLE_ENTRY(AlphaFuncxOES), + TABLE_ENTRY(ClearColorxOES), + TABLE_ENTRY(ClearDepthfOES), + TABLE_ENTRY(ClearDepthxOES), + TABLE_ENTRY(Color4xOES), + TABLE_ENTRY(DepthRangefOES), + TABLE_ENTRY(DepthRangexOES), + TABLE_ENTRY(FogxOES), + TABLE_ENTRY(FogxvOES), + TABLE_ENTRY(FrustumfOES), + TABLE_ENTRY(FrustumxOES), + TABLE_ENTRY(LightModelxOES), + TABLE_ENTRY(LightModelxvOES), + TABLE_ENTRY(LightxOES), + TABLE_ENTRY(LightxvOES), + TABLE_ENTRY(LineWidthxOES), + TABLE_ENTRY(LoadMatrixxOES), + TABLE_ENTRY(MaterialxOES), + TABLE_ENTRY(MaterialxvOES), + TABLE_ENTRY(MultMatrixxOES), + TABLE_ENTRY(MultiTexCoord4xOES), + TABLE_ENTRY(Normal3xOES), + TABLE_ENTRY(OrthofOES), + TABLE_ENTRY(OrthoxOES), + TABLE_ENTRY(PointSizexOES), + TABLE_ENTRY(PolygonOffsetxOES), + TABLE_ENTRY(RotatexOES), + TABLE_ENTRY(SampleCoveragexOES), + TABLE_ENTRY(ScalexOES), + TABLE_ENTRY(TexEnvxOES), + TABLE_ENTRY(TexEnvxvOES), + TABLE_ENTRY(TexParameterxOES), + TABLE_ENTRY(TranslatexOES), + TABLE_ENTRY(ClipPlanefOES), + TABLE_ENTRY(ClipPlanexOES), + TABLE_ENTRY(GetClipPlanefOES), + TABLE_ENTRY(GetClipPlanexOES), + TABLE_ENTRY(GetFixedvOES), + TABLE_ENTRY(GetLightxvOES), + TABLE_ENTRY(GetMaterialxvOES), + TABLE_ENTRY(GetTexEnvxvOES), + TABLE_ENTRY(GetTexParameterxvOES), + TABLE_ENTRY(PointParameterxOES), + TABLE_ENTRY(PointParameterxvOES), + TABLE_ENTRY(TexParameterxvOES), +#endif /* _GLAPI_SKIP_NORMAL_ENTRY_POINTS */ +#ifndef _GLAPI_SKIP_PROTO_ENTRY_POINTS +#endif /* _GLAPI_SKIP_PROTO_ENTRY_POINTS */ +}; +#endif /*UNUSED_TABLE_NAME*/ + + +# undef KEYWORD1 +# undef KEYWORD1_ALT +# undef KEYWORD2 +# undef NAME +# undef DISPATCH +# undef RETURN_DISPATCH +# undef DISPATCH_TABLE_NAME +# undef UNUSED_TABLE_NAME +# undef TABLE_ENTRY +# undef HIDDEN diff --git a/src/mapi/es1api/glapi/glprocs.h b/src/mapi/es1api/glapi/glprocs.h new file mode 100644 index 00000000000..fe2fecfc932 --- /dev/null +++ b/src/mapi/es1api/glapi/glprocs.h @@ -0,0 +1,1977 @@ +/* DO NOT EDIT - This file generated automatically by gl_procs.py (from Mesa) script */ + +/* + * Copyright (C) 1999-2001 Brian Paul All Rights Reserved. + * (C) Copyright IBM Corporation 2004, 2006 + * All Rights Reserved. + * + * Permission is hereby granted, free of charge, to any person obtaining a + * copy of this software and associated documentation files (the "Software"), + * to deal in the Software without restriction, including without limitation + * the rights to use, copy, modify, merge, publish, distribute, sub license, + * and/or sell copies of the Software, and to permit persons to whom the + * Software is furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice (including the next + * paragraph) shall be included in all copies or substantial portions of the + * Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL + * BRIAN PAUL, IBM, + * AND/OR THEIR SUPPLIERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, + * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF + * OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE + * SOFTWARE. + */ + + +/* This file is only included by glapi.c and is used for + * the GetProcAddress() function + */ + +typedef struct { + GLint Name_offset; +#if defined(NEED_FUNCTION_POINTER) || defined(GLX_INDIRECT_RENDERING) + _glapi_proc Address; +#endif + GLuint Offset; +} glprocs_table_t; + +#if !defined(NEED_FUNCTION_POINTER) && !defined(GLX_INDIRECT_RENDERING) +# define NAME_FUNC_OFFSET(n,f1,f2,f3,o) { n , o } +#elif defined(NEED_FUNCTION_POINTER) && !defined(GLX_INDIRECT_RENDERING) +# define NAME_FUNC_OFFSET(n,f1,f2,f3,o) { n , (_glapi_proc) f1 , o } +#elif defined(NEED_FUNCTION_POINTER) && defined(GLX_INDIRECT_RENDERING) +# define NAME_FUNC_OFFSET(n,f1,f2,f3,o) { n , (_glapi_proc) f2 , o } +#elif !defined(NEED_FUNCTION_POINTER) && defined(GLX_INDIRECT_RENDERING) +# define NAME_FUNC_OFFSET(n,f1,f2,f3,o) { n , (_glapi_proc) f3 , o } +#endif + + + +static const char gl_string_table[] = + "glNewList\0" + "glEndList\0" + "glCallList\0" + "glCallLists\0" + "glDeleteLists\0" + "glGenLists\0" + "glListBase\0" + "glBegin\0" + "glBitmap\0" + "glColor3b\0" + "glColor3bv\0" + "glColor3d\0" + "glColor3dv\0" + "glColor3f\0" + "glColor3fv\0" + "glColor3i\0" + "glColor3iv\0" + "glColor3s\0" + "glColor3sv\0" + "glColor3ub\0" + "glColor3ubv\0" + "glColor3ui\0" + "glColor3uiv\0" + "glColor3us\0" + "glColor3usv\0" + "glColor4b\0" + "glColor4bv\0" + "glColor4d\0" + "glColor4dv\0" + "glColor4f\0" + "glColor4fv\0" + "glColor4i\0" + "glColor4iv\0" + "glColor4s\0" + "glColor4sv\0" + "glColor4ub\0" + "glColor4ubv\0" + "glColor4ui\0" + "glColor4uiv\0" + "glColor4us\0" + "glColor4usv\0" + "glEdgeFlag\0" + "glEdgeFlagv\0" + "glEnd\0" + "glIndexd\0" + "glIndexdv\0" + "glIndexf\0" + "glIndexfv\0" + "glIndexi\0" + "glIndexiv\0" + "glIndexs\0" + "glIndexsv\0" + "glNormal3b\0" + "glNormal3bv\0" + "glNormal3d\0" + "glNormal3dv\0" + "glNormal3f\0" + "glNormal3fv\0" + "glNormal3i\0" + "glNormal3iv\0" + "glNormal3s\0" + "glNormal3sv\0" + "glRasterPos2d\0" + "glRasterPos2dv\0" + "glRasterPos2f\0" + "glRasterPos2fv\0" + "glRasterPos2i\0" + "glRasterPos2iv\0" + "glRasterPos2s\0" + "glRasterPos2sv\0" + "glRasterPos3d\0" + "glRasterPos3dv\0" + "glRasterPos3f\0" + "glRasterPos3fv\0" + "glRasterPos3i\0" + "glRasterPos3iv\0" + "glRasterPos3s\0" + "glRasterPos3sv\0" + "glRasterPos4d\0" + "glRasterPos4dv\0" + "glRasterPos4f\0" + "glRasterPos4fv\0" + "glRasterPos4i\0" + "glRasterPos4iv\0" + "glRasterPos4s\0" + "glRasterPos4sv\0" + "glRectd\0" + "glRectdv\0" + "glRectf\0" + "glRectfv\0" + "glRecti\0" + "glRectiv\0" + "glRects\0" + "glRectsv\0" + "glTexCoord1d\0" + "glTexCoord1dv\0" + "glTexCoord1f\0" + "glTexCoord1fv\0" + "glTexCoord1i\0" + "glTexCoord1iv\0" + "glTexCoord1s\0" + "glTexCoord1sv\0" + "glTexCoord2d\0" + "glTexCoord2dv\0" + "glTexCoord2f\0" + "glTexCoord2fv\0" + "glTexCoord2i\0" + "glTexCoord2iv\0" + "glTexCoord2s\0" + "glTexCoord2sv\0" + "glTexCoord3d\0" + "glTexCoord3dv\0" + "glTexCoord3f\0" + "glTexCoord3fv\0" + "glTexCoord3i\0" + "glTexCoord3iv\0" + "glTexCoord3s\0" + "glTexCoord3sv\0" + "glTexCoord4d\0" + "glTexCoord4dv\0" + "glTexCoord4f\0" + "glTexCoord4fv\0" + "glTexCoord4i\0" + "glTexCoord4iv\0" + "glTexCoord4s\0" + "glTexCoord4sv\0" + "glVertex2d\0" + "glVertex2dv\0" + "glVertex2f\0" + "glVertex2fv\0" + "glVertex2i\0" + "glVertex2iv\0" + "glVertex2s\0" + "glVertex2sv\0" + "glVertex3d\0" + "glVertex3dv\0" + "glVertex3f\0" + "glVertex3fv\0" + "glVertex3i\0" + "glVertex3iv\0" + "glVertex3s\0" + "glVertex3sv\0" + "glVertex4d\0" + "glVertex4dv\0" + "glVertex4f\0" + "glVertex4fv\0" + "glVertex4i\0" + "glVertex4iv\0" + "glVertex4s\0" + "glVertex4sv\0" + "glClipPlane\0" + "glColorMaterial\0" + "glCullFace\0" + "glFogf\0" + "glFogfv\0" + "glFogi\0" + "glFogiv\0" + "glFrontFace\0" + "glHint\0" + "glLightf\0" + "glLightfv\0" + "glLighti\0" + "glLightiv\0" + "glLightModelf\0" + "glLightModelfv\0" + "glLightModeli\0" + "glLightModeliv\0" + "glLineStipple\0" + "glLineWidth\0" + "glMaterialf\0" + "glMaterialfv\0" + "glMateriali\0" + "glMaterialiv\0" + "glPointSize\0" + "glPolygonMode\0" + "glPolygonStipple\0" + "glScissor\0" + "glShadeModel\0" + "glTexParameterf\0" + "glTexParameterfv\0" + "glTexParameteri\0" + "glTexParameteriv\0" + "glTexImage1D\0" + "glTexImage2D\0" + "glTexEnvf\0" + "glTexEnvfv\0" + "glTexEnvi\0" + "glTexEnviv\0" + "glTexGend\0" + "glTexGendv\0" + "glTexGenfOES\0" + "glTexGenfvOES\0" + "glTexGeniOES\0" + "glTexGenivOES\0" + "glFeedbackBuffer\0" + "glSelectBuffer\0" + "glRenderMode\0" + "glInitNames\0" + "glLoadName\0" + "glPassThrough\0" + "glPopName\0" + "glPushName\0" + "glDrawBuffer\0" + "glClear\0" + "glClearAccum\0" + "glClearIndex\0" + "glClearColor\0" + "glClearStencil\0" + "glClearDepth\0" + "glStencilMask\0" + "glColorMask\0" + "glDepthMask\0" + "glIndexMask\0" + "glAccum\0" + "glDisable\0" + "glEnable\0" + "glFinish\0" + "glFlush\0" + "glPopAttrib\0" + "glPushAttrib\0" + "glMap1d\0" + "glMap1f\0" + "glMap2d\0" + "glMap2f\0" + "glMapGrid1d\0" + "glMapGrid1f\0" + "glMapGrid2d\0" + "glMapGrid2f\0" + "glEvalCoord1d\0" + "glEvalCoord1dv\0" + "glEvalCoord1f\0" + "glEvalCoord1fv\0" + "glEvalCoord2d\0" + "glEvalCoord2dv\0" + "glEvalCoord2f\0" + "glEvalCoord2fv\0" + "glEvalMesh1\0" + "glEvalPoint1\0" + "glEvalMesh2\0" + "glEvalPoint2\0" + "glAlphaFunc\0" + "glBlendFunc\0" + "glLogicOp\0" + "glStencilFunc\0" + "glStencilOp\0" + "glDepthFunc\0" + "glPixelZoom\0" + "glPixelTransferf\0" + "glPixelTransferi\0" + "glPixelStoref\0" + "glPixelStorei\0" + "glPixelMapfv\0" + "glPixelMapuiv\0" + "glPixelMapusv\0" + "glReadBuffer\0" + "glCopyPixels\0" + "glReadPixels\0" + "glDrawPixels\0" + "glGetBooleanv\0" + "glGetClipPlane\0" + "glGetDoublev\0" + "glGetError\0" + "glGetFloatv\0" + "glGetIntegerv\0" + "glGetLightfv\0" + "glGetLightiv\0" + "glGetMapdv\0" + "glGetMapfv\0" + "glGetMapiv\0" + "glGetMaterialfv\0" + "glGetMaterialiv\0" + "glGetPixelMapfv\0" + "glGetPixelMapuiv\0" + "glGetPixelMapusv\0" + "glGetPolygonStipple\0" + "glGetString\0" + "glGetTexEnvfv\0" + "glGetTexEnviv\0" + "glGetTexGendv\0" + "glGetTexGenfvOES\0" + "glGetTexGenivOES\0" + "glGetTexImage\0" + "glGetTexParameterfv\0" + "glGetTexParameteriv\0" + "glGetTexLevelParameterfv\0" + "glGetTexLevelParameteriv\0" + "glIsEnabled\0" + "glIsList\0" + "glDepthRange\0" + "glFrustum\0" + "glLoadIdentity\0" + "glLoadMatrixf\0" + "glLoadMatrixd\0" + "glMatrixMode\0" + "glMultMatrixf\0" + "glMultMatrixd\0" + "glOrtho\0" + "glPopMatrix\0" + "glPushMatrix\0" + "glRotated\0" + "glRotatef\0" + "glScaled\0" + "glScalef\0" + "glTranslated\0" + "glTranslatef\0" + "glViewport\0" + "glArrayElement\0" + "glBindTexture\0" + "glColorPointer\0" + "glDisableClientState\0" + "glDrawArrays\0" + "glDrawElements\0" + "glEdgeFlagPointer\0" + "glEnableClientState\0" + "glIndexPointer\0" + "glIndexub\0" + "glIndexubv\0" + "glInterleavedArrays\0" + "glNormalPointer\0" + "glPolygonOffset\0" + "glTexCoordPointer\0" + "glVertexPointer\0" + "glAreTexturesResident\0" + "glCopyTexImage1D\0" + "glCopyTexImage2D\0" + "glCopyTexSubImage1D\0" + "glCopyTexSubImage2D\0" + "glDeleteTextures\0" + "glGenTextures\0" + "glGetPointerv\0" + "glIsTexture\0" + "glPrioritizeTextures\0" + "glTexSubImage1D\0" + "glTexSubImage2D\0" + "glPopClientAttrib\0" + "glPushClientAttrib\0" + "glBlendColor\0" + "glBlendEquationOES\0" + "glDrawRangeElements\0" + "glColorTable\0" + "glColorTableParameterfv\0" + "glColorTableParameteriv\0" + "glCopyColorTable\0" + "glGetColorTable\0" + "glGetColorTableParameterfv\0" + "glGetColorTableParameteriv\0" + "glColorSubTable\0" + "glCopyColorSubTable\0" + "glConvolutionFilter1D\0" + "glConvolutionFilter2D\0" + "glConvolutionParameterf\0" + "glConvolutionParameterfv\0" + "glConvolutionParameteri\0" + "glConvolutionParameteriv\0" + "glCopyConvolutionFilter1D\0" + "glCopyConvolutionFilter2D\0" + "glGetConvolutionFilter\0" + "glGetConvolutionParameterfv\0" + "glGetConvolutionParameteriv\0" + "glGetSeparableFilter\0" + "glSeparableFilter2D\0" + "glGetHistogram\0" + "glGetHistogramParameterfv\0" + "glGetHistogramParameteriv\0" + "glGetMinmax\0" + "glGetMinmaxParameterfv\0" + "glGetMinmaxParameteriv\0" + "glHistogram\0" + "glMinmax\0" + "glResetHistogram\0" + "glResetMinmax\0" + "glTexImage3D\0" + "glTexSubImage3D\0" + "glCopyTexSubImage3D\0" + "glActiveTexture\0" + "glClientActiveTexture\0" + "glMultiTexCoord1dARB\0" + "glMultiTexCoord1dvARB\0" + "glMultiTexCoord1fARB\0" + "glMultiTexCoord1fvARB\0" + "glMultiTexCoord1iARB\0" + "glMultiTexCoord1ivARB\0" + "glMultiTexCoord1sARB\0" + "glMultiTexCoord1svARB\0" + "glMultiTexCoord2dARB\0" + "glMultiTexCoord2dvARB\0" + "glMultiTexCoord2fARB\0" + "glMultiTexCoord2fvARB\0" + "glMultiTexCoord2iARB\0" + "glMultiTexCoord2ivARB\0" + "glMultiTexCoord2sARB\0" + "glMultiTexCoord2svARB\0" + "glMultiTexCoord3dARB\0" + "glMultiTexCoord3dvARB\0" + "glMultiTexCoord3fARB\0" + "glMultiTexCoord3fvARB\0" + "glMultiTexCoord3iARB\0" + "glMultiTexCoord3ivARB\0" + "glMultiTexCoord3sARB\0" + "glMultiTexCoord3svARB\0" + "glMultiTexCoord4dARB\0" + "glMultiTexCoord4dvARB\0" + "glMultiTexCoord4f\0" + "glMultiTexCoord4fvARB\0" + "glMultiTexCoord4iARB\0" + "glMultiTexCoord4ivARB\0" + "glMultiTexCoord4sARB\0" + "glMultiTexCoord4svARB\0" + "glBlendEquationSeparateOES\0" + "glBlendFuncSeparateOES\0" + "glDrawTexfOES\0" + "glDrawTexfvOES\0" + "glDrawTexiOES\0" + "glDrawTexivOES\0" + "glDrawTexsOES\0" + "glDrawTexsvOES\0" + "glDrawTexxOES\0" + "glDrawTexxvOES\0" + "glBindFramebufferOES\0" + "glBindRenderbufferOES\0" + "glCheckFramebufferStatusOES\0" + "glDeleteFramebuffersOES\0" + "glDeleteRenderbuffersOES\0" + "glFramebufferRenderbufferOES\0" + "glFramebufferTexture2DOES\0" + "glGenFramebuffersOES\0" + "glGenRenderbuffersOES\0" + "glGenerateMipmapOES\0" + "glGetFramebufferAttachmentParameterivOES\0" + "glGetRenderbufferParameterivOES\0" + "glIsFramebufferOES\0" + "glIsRenderbufferOES\0" + "glRenderbufferStorageOES\0" + "glPointSizePointerOES\0" + "glQueryMatrixxOES\0" + "glGetTexGenxvOES\0" + "glTexGenxOES\0" + "glTexGenxvOES\0" + "glGetBufferPointervOES\0" + "glMapBufferOES\0" + "glUnmapBufferOES\0" + "glMultiDrawArraysEXT\0" + "glMultiDrawElementsEXT\0" + "glBindVertexArrayAPPLE\0" + "glDeleteVertexArraysAPPLE\0" + "glGenVertexArraysAPPLE\0" + "glIsVertexArrayAPPLE\0" + "glEGLImageTargetRenderbufferStorageOES\0" + "glEGLImageTargetTexture2DOES\0" + "glCompressedTexImage2D\0" + "glCompressedTexSubImage2D\0" + "glSampleCoverage\0" + "glBindBuffer\0" + "glBufferData\0" + "glBufferSubData\0" + "glDeleteBuffers\0" + "glGenBuffers\0" + "glGetBufferParameteriv\0" + "glIsBuffer\0" + "glPointParameterf\0" + "glPointParameterfv\0" + "glAlphaFuncx\0" + "glClearColorx\0" + "glClearDepthf\0" + "glClearDepthx\0" + "glColor4x\0" + "glDepthRangef\0" + "glDepthRangex\0" + "glFogx\0" + "glFogxv\0" + "glFrustumf\0" + "glFrustumx\0" + "glLightModelx\0" + "glLightModelxv\0" + "glLightx\0" + "glLightxv\0" + "glLineWidthx\0" + "glLoadMatrixx\0" + "glMaterialx\0" + "glMaterialxv\0" + "glMultMatrixx\0" + "glMultiTexCoord4x\0" + "glNormal3x\0" + "glOrthof\0" + "glOrthox\0" + "glPointSizex\0" + "glPolygonOffsetx\0" + "glRotatex\0" + "glSampleCoveragex\0" + "glScalex\0" + "glTexEnvx\0" + "glTexEnvxv\0" + "glTexParameterx\0" + "glTranslatex\0" + "glClipPlanef\0" + "glClipPlanex\0" + "glGetClipPlanef\0" + "glGetClipPlanex\0" + "glGetFixedv\0" + "glGetLightxv\0" + "glGetMaterialxv\0" + "glGetTexEnvxv\0" + "glGetTexParameterxv\0" + "glPointParameterx\0" + "glPointParameterxv\0" + "glTexParameterxv\0" + "glTexGenf\0" + "glTexGenfv\0" + "glTexGeni\0" + "glTexGeniv\0" + "glGetTexGenfv\0" + "glGetTexGeniv\0" + "glBlendEquation\0" + "glActiveTextureARB\0" + "glClientActiveTextureARB\0" + "glMultiTexCoord4fARB\0" + "glAlphaFuncxOES\0" + "glClearColorxOES\0" + "glClearDepthfOES\0" + "glClearDepthxOES\0" + "glColor4xOES\0" + "glDepthRangefOES\0" + "glDepthRangexOES\0" + "glFogxOES\0" + "glFogxvOES\0" + "glFrustumfOES\0" + "glFrustumxOES\0" + "glLightModelxOES\0" + "glLightModelxvOES\0" + "glLightxOES\0" + "glLightxvOES\0" + "glLineWidthxOES\0" + "glLoadMatrixxOES\0" + "glMaterialxOES\0" + "glMaterialxvOES\0" + "glMultMatrixxOES\0" + "glMultiTexCoord4xOES\0" + "glNormal3xOES\0" + "glOrthofOES\0" + "glOrthoxOES\0" + "glPointSizexOES\0" + "glPolygonOffsetxOES\0" + "glRotatexOES\0" + "glSampleCoveragexOES\0" + "glScalexOES\0" + "glTexEnvxOES\0" + "glTexEnvxvOES\0" + "glTexParameterxOES\0" + "glTranslatexOES\0" + "glClipPlanefOES\0" + "glClipPlanexOES\0" + "glGetClipPlanefOES\0" + "glGetClipPlanexOES\0" + "glGetFixedvOES\0" + "glGetLightxvOES\0" + "glGetMaterialxvOES\0" + "glGetTexEnvxvOES\0" + "glGetTexParameterxvOES\0" + "glPointParameterxOES\0" + "glPointParameterxvOES\0" + "glTexParameterxvOES\0" + ; + + +#ifdef USE_MGL_NAMESPACE +#define gl_dispatch_stub_0 mgl_dispatch_stub_0 +#define gl_dispatch_stub_1 mgl_dispatch_stub_1 +#define gl_dispatch_stub_2 mgl_dispatch_stub_2 +#define gl_dispatch_stub_3 mgl_dispatch_stub_3 +#define gl_dispatch_stub_4 mgl_dispatch_stub_4 +#define gl_dispatch_stub_5 mgl_dispatch_stub_5 +#define gl_dispatch_stub_6 mgl_dispatch_stub_6 +#define gl_dispatch_stub_7 mgl_dispatch_stub_7 +#define gl_dispatch_stub_8 mgl_dispatch_stub_8 +#define gl_dispatch_stub_9 mgl_dispatch_stub_9 +#define gl_dispatch_stub_10 mgl_dispatch_stub_10 +#define gl_dispatch_stub_11 mgl_dispatch_stub_11 +#define gl_dispatch_stub_12 mgl_dispatch_stub_12 +#define gl_dispatch_stub_13 mgl_dispatch_stub_13 +#define gl_dispatch_stub_14 mgl_dispatch_stub_14 +#define gl_dispatch_stub_15 mgl_dispatch_stub_15 +#define gl_dispatch_stub_16 mgl_dispatch_stub_16 +#define gl_dispatch_stub_17 mgl_dispatch_stub_17 +#define gl_dispatch_stub_18 mgl_dispatch_stub_18 +#define gl_dispatch_stub_19 mgl_dispatch_stub_19 +#define gl_dispatch_stub_20 mgl_dispatch_stub_20 +#define gl_dispatch_stub_21 mgl_dispatch_stub_21 +#define gl_dispatch_stub_22 mgl_dispatch_stub_22 +#define gl_dispatch_stub_23 mgl_dispatch_stub_23 +#define gl_dispatch_stub_24 mgl_dispatch_stub_24 +#define gl_dispatch_stub_25 mgl_dispatch_stub_25 +#define gl_dispatch_stub_26 mgl_dispatch_stub_26 +#define gl_dispatch_stub_27 mgl_dispatch_stub_27 +#define gl_dispatch_stub_28 mgl_dispatch_stub_28 +#define gl_dispatch_stub_30 mgl_dispatch_stub_30 +#define gl_dispatch_stub_31 mgl_dispatch_stub_31 +#define gl_dispatch_stub_32 mgl_dispatch_stub_32 +#define gl_dispatch_stub_33 mgl_dispatch_stub_33 +#define gl_dispatch_stub_34 mgl_dispatch_stub_34 +#define gl_dispatch_stub_36 mgl_dispatch_stub_36 +#define gl_dispatch_stub_37 mgl_dispatch_stub_37 +#define gl_dispatch_stub_38 mgl_dispatch_stub_38 +#define gl_dispatch_stub_39 mgl_dispatch_stub_39 +#define gl_dispatch_stub_40 mgl_dispatch_stub_40 +#define gl_dispatch_stub_41 mgl_dispatch_stub_41 +#define gl_dispatch_stub_42 mgl_dispatch_stub_42 +#define gl_dispatch_stub_43 mgl_dispatch_stub_43 +#define gl_dispatch_stub_44 mgl_dispatch_stub_44 +#define gl_dispatch_stub_45 mgl_dispatch_stub_45 +#define gl_dispatch_stub_46 mgl_dispatch_stub_46 +#define gl_dispatch_stub_47 mgl_dispatch_stub_47 +#define gl_dispatch_stub_48 mgl_dispatch_stub_48 +#define gl_dispatch_stub_49 mgl_dispatch_stub_49 +#define gl_dispatch_stub_50 mgl_dispatch_stub_50 +#define gl_dispatch_stub_51 mgl_dispatch_stub_51 +#define gl_dispatch_stub_52 mgl_dispatch_stub_52 +#define gl_dispatch_stub_53 mgl_dispatch_stub_53 +#define gl_dispatch_stub_54 mgl_dispatch_stub_54 +#define gl_dispatch_stub_55 mgl_dispatch_stub_55 +#define gl_dispatch_stub_57 mgl_dispatch_stub_57 +#define gl_dispatch_stub_58 mgl_dispatch_stub_58 +#define gl_dispatch_stub_59 mgl_dispatch_stub_59 +#define gl_dispatch_stub_60 mgl_dispatch_stub_60 +#define gl_dispatch_stub_61 mgl_dispatch_stub_61 +#define gl_dispatch_stub_62 mgl_dispatch_stub_62 +#define gl_dispatch_stub_63 mgl_dispatch_stub_63 +#define gl_dispatch_stub_64 mgl_dispatch_stub_64 +#define gl_dispatch_stub_65 mgl_dispatch_stub_65 +#define gl_dispatch_stub_66 mgl_dispatch_stub_66 +#define gl_dispatch_stub_67 mgl_dispatch_stub_67 +#define gl_dispatch_stub_68 mgl_dispatch_stub_68 +#define gl_dispatch_stub_69 mgl_dispatch_stub_69 +#define gl_dispatch_stub_70 mgl_dispatch_stub_70 +#define gl_dispatch_stub_71 mgl_dispatch_stub_71 +#define gl_dispatch_stub_72 mgl_dispatch_stub_72 +#define gl_dispatch_stub_73 mgl_dispatch_stub_73 +#define gl_dispatch_stub_74 mgl_dispatch_stub_74 +#define gl_dispatch_stub_75 mgl_dispatch_stub_75 +#define gl_dispatch_stub_76 mgl_dispatch_stub_76 +#define gl_dispatch_stub_77 mgl_dispatch_stub_77 +#define gl_dispatch_stub_78 mgl_dispatch_stub_78 +#define gl_dispatch_stub_79 mgl_dispatch_stub_79 +#define gl_dispatch_stub_80 mgl_dispatch_stub_80 +#define gl_dispatch_stub_81 mgl_dispatch_stub_81 +#define gl_dispatch_stub_82 mgl_dispatch_stub_82 +#define gl_dispatch_stub_83 mgl_dispatch_stub_83 +#define gl_dispatch_stub_84 mgl_dispatch_stub_84 +#define gl_dispatch_stub_85 mgl_dispatch_stub_85 +#define gl_dispatch_stub_86 mgl_dispatch_stub_86 +#define gl_dispatch_stub_87 mgl_dispatch_stub_87 +#define gl_dispatch_stub_88 mgl_dispatch_stub_88 +#define gl_dispatch_stub_89 mgl_dispatch_stub_89 +#define gl_dispatch_stub_90 mgl_dispatch_stub_90 +#define gl_dispatch_stub_91 mgl_dispatch_stub_91 +#define gl_dispatch_stub_92 mgl_dispatch_stub_92 +#define gl_dispatch_stub_93 mgl_dispatch_stub_93 +#define gl_dispatch_stub_94 mgl_dispatch_stub_94 +#define gl_dispatch_stub_95 mgl_dispatch_stub_95 +#define gl_dispatch_stub_96 mgl_dispatch_stub_96 +#define gl_dispatch_stub_97 mgl_dispatch_stub_97 +#define gl_dispatch_stub_98 mgl_dispatch_stub_98 +#define gl_dispatch_stub_99 mgl_dispatch_stub_99 +#define gl_dispatch_stub_100 mgl_dispatch_stub_100 +#define gl_dispatch_stub_101 mgl_dispatch_stub_101 +#define gl_dispatch_stub_102 mgl_dispatch_stub_102 +#define gl_dispatch_stub_103 mgl_dispatch_stub_103 +#define gl_dispatch_stub_104 mgl_dispatch_stub_104 +#define gl_dispatch_stub_105 mgl_dispatch_stub_105 +#define gl_dispatch_stub_106 mgl_dispatch_stub_106 +#define gl_dispatch_stub_107 mgl_dispatch_stub_107 +#define gl_dispatch_stub_108 mgl_dispatch_stub_108 +#define gl_dispatch_stub_109 mgl_dispatch_stub_109 +#define gl_dispatch_stub_110 mgl_dispatch_stub_110 +#define gl_dispatch_stub_111 mgl_dispatch_stub_111 +#define gl_dispatch_stub_112 mgl_dispatch_stub_112 +#define gl_dispatch_stub_113 mgl_dispatch_stub_113 +#define gl_dispatch_stub_114 mgl_dispatch_stub_114 +#define gl_dispatch_stub_115 mgl_dispatch_stub_115 +#define gl_dispatch_stub_116 mgl_dispatch_stub_116 +#define gl_dispatch_stub_117 mgl_dispatch_stub_117 +#define gl_dispatch_stub_118 mgl_dispatch_stub_118 +#define gl_dispatch_stub_119 mgl_dispatch_stub_119 +#define gl_dispatch_stub_120 mgl_dispatch_stub_120 +#define gl_dispatch_stub_121 mgl_dispatch_stub_121 +#define gl_dispatch_stub_122 mgl_dispatch_stub_122 +#define gl_dispatch_stub_123 mgl_dispatch_stub_123 +#define gl_dispatch_stub_124 mgl_dispatch_stub_124 +#define gl_dispatch_stub_125 mgl_dispatch_stub_125 +#define gl_dispatch_stub_126 mgl_dispatch_stub_126 +#define gl_dispatch_stub_127 mgl_dispatch_stub_127 +#define gl_dispatch_stub_128 mgl_dispatch_stub_128 +#define gl_dispatch_stub_129 mgl_dispatch_stub_129 +#define gl_dispatch_stub_130 mgl_dispatch_stub_130 +#define gl_dispatch_stub_131 mgl_dispatch_stub_131 +#define gl_dispatch_stub_132 mgl_dispatch_stub_132 +#define gl_dispatch_stub_133 mgl_dispatch_stub_133 +#define gl_dispatch_stub_134 mgl_dispatch_stub_134 +#define gl_dispatch_stub_135 mgl_dispatch_stub_135 +#define gl_dispatch_stub_136 mgl_dispatch_stub_136 +#define gl_dispatch_stub_137 mgl_dispatch_stub_137 +#define gl_dispatch_stub_138 mgl_dispatch_stub_138 +#define gl_dispatch_stub_139 mgl_dispatch_stub_139 +#define gl_dispatch_stub_140 mgl_dispatch_stub_140 +#define gl_dispatch_stub_141 mgl_dispatch_stub_141 +#define gl_dispatch_stub_142 mgl_dispatch_stub_142 +#define gl_dispatch_stub_143 mgl_dispatch_stub_143 +#define gl_dispatch_stub_144 mgl_dispatch_stub_144 +#define gl_dispatch_stub_145 mgl_dispatch_stub_145 +#define gl_dispatch_stub_146 mgl_dispatch_stub_146 +#define gl_dispatch_stub_147 mgl_dispatch_stub_147 +#define gl_dispatch_stub_148 mgl_dispatch_stub_148 +#define gl_dispatch_stub_149 mgl_dispatch_stub_149 +#define gl_dispatch_stub_150 mgl_dispatch_stub_150 +#define gl_dispatch_stub_151 mgl_dispatch_stub_151 +#define gl_dispatch_stub_155 mgl_dispatch_stub_155 +#define gl_dispatch_stub_156 mgl_dispatch_stub_156 +#define gl_dispatch_stub_161 mgl_dispatch_stub_161 +#define gl_dispatch_stub_162 mgl_dispatch_stub_162 +#define gl_dispatch_stub_165 mgl_dispatch_stub_165 +#define gl_dispatch_stub_166 mgl_dispatch_stub_166 +#define gl_dispatch_stub_167 mgl_dispatch_stub_167 +#define gl_dispatch_stub_171 mgl_dispatch_stub_171 +#define gl_dispatch_stub_172 mgl_dispatch_stub_172 +#define gl_dispatch_stub_174 mgl_dispatch_stub_174 +#define gl_dispatch_stub_175 mgl_dispatch_stub_175 +#define gl_dispatch_stub_182 mgl_dispatch_stub_182 +#define gl_dispatch_stub_188 mgl_dispatch_stub_188 +#define gl_dispatch_stub_189 mgl_dispatch_stub_189 +#define gl_dispatch_stub_194 mgl_dispatch_stub_194 +#define gl_dispatch_stub_195 mgl_dispatch_stub_195 +#define gl_dispatch_stub_196 mgl_dispatch_stub_196 +#define gl_dispatch_stub_197 mgl_dispatch_stub_197 +#define gl_dispatch_stub_198 mgl_dispatch_stub_198 +#define gl_dispatch_stub_199 mgl_dispatch_stub_199 +#define gl_dispatch_stub_200 mgl_dispatch_stub_200 +#define gl_dispatch_stub_201 mgl_dispatch_stub_201 +#define gl_dispatch_stub_202 mgl_dispatch_stub_202 +#define gl_dispatch_stub_204 mgl_dispatch_stub_204 +#define gl_dispatch_stub_205 mgl_dispatch_stub_205 +#define gl_dispatch_stub_208 mgl_dispatch_stub_208 +#define gl_dispatch_stub_212 mgl_dispatch_stub_212 +#define gl_dispatch_stub_213 mgl_dispatch_stub_213 +#define gl_dispatch_stub_218 mgl_dispatch_stub_218 +#define gl_dispatch_stub_219 mgl_dispatch_stub_219 +#define gl_dispatch_stub_220 mgl_dispatch_stub_220 +#define gl_dispatch_stub_221 mgl_dispatch_stub_221 +#define gl_dispatch_stub_222 mgl_dispatch_stub_222 +#define gl_dispatch_stub_223 mgl_dispatch_stub_223 +#define gl_dispatch_stub_224 mgl_dispatch_stub_224 +#define gl_dispatch_stub_225 mgl_dispatch_stub_225 +#define gl_dispatch_stub_226 mgl_dispatch_stub_226 +#define gl_dispatch_stub_227 mgl_dispatch_stub_227 +#define gl_dispatch_stub_228 mgl_dispatch_stub_228 +#define gl_dispatch_stub_229 mgl_dispatch_stub_229 +#define gl_dispatch_stub_230 mgl_dispatch_stub_230 +#define gl_dispatch_stub_231 mgl_dispatch_stub_231 +#define gl_dispatch_stub_232 mgl_dispatch_stub_232 +#define gl_dispatch_stub_233 mgl_dispatch_stub_233 +#define gl_dispatch_stub_234 mgl_dispatch_stub_234 +#define gl_dispatch_stub_235 mgl_dispatch_stub_235 +#define gl_dispatch_stub_236 mgl_dispatch_stub_236 +#define gl_dispatch_stub_237 mgl_dispatch_stub_237 +#define gl_dispatch_stub_238 mgl_dispatch_stub_238 +#define gl_dispatch_stub_239 mgl_dispatch_stub_239 +#define gl_dispatch_stub_246 mgl_dispatch_stub_246 +#define gl_dispatch_stub_247 mgl_dispatch_stub_247 +#define gl_dispatch_stub_248 mgl_dispatch_stub_248 +#define gl_dispatch_stub_249 mgl_dispatch_stub_249 +#define gl_dispatch_stub_251 mgl_dispatch_stub_251 +#define gl_dispatch_stub_252 mgl_dispatch_stub_252 +#define gl_dispatch_stub_253 mgl_dispatch_stub_253 +#define gl_dispatch_stub_254 mgl_dispatch_stub_254 +#define gl_dispatch_stub_255 mgl_dispatch_stub_255 +#define gl_dispatch_stub_257 mgl_dispatch_stub_257 +#define gl_dispatch_stub_259 mgl_dispatch_stub_259 +#define gl_dispatch_stub_260 mgl_dispatch_stub_260 +#define gl_dispatch_stub_265 mgl_dispatch_stub_265 +#define gl_dispatch_stub_266 mgl_dispatch_stub_266 +#define gl_dispatch_stub_267 mgl_dispatch_stub_267 +#define gl_dispatch_stub_268 mgl_dispatch_stub_268 +#define gl_dispatch_stub_270 mgl_dispatch_stub_270 +#define gl_dispatch_stub_271 mgl_dispatch_stub_271 +#define gl_dispatch_stub_272 mgl_dispatch_stub_272 +#define gl_dispatch_stub_273 mgl_dispatch_stub_273 +#define gl_dispatch_stub_274 mgl_dispatch_stub_274 +#define gl_dispatch_stub_278 mgl_dispatch_stub_278 +#define gl_dispatch_stub_281 mgl_dispatch_stub_281 +#define gl_dispatch_stub_284 mgl_dispatch_stub_284 +#define gl_dispatch_stub_285 mgl_dispatch_stub_285 +#define gl_dispatch_stub_287 mgl_dispatch_stub_287 +#define gl_dispatch_stub_288 mgl_dispatch_stub_288 +#define gl_dispatch_stub_289 mgl_dispatch_stub_289 +#define gl_dispatch_stub_292 mgl_dispatch_stub_292 +#define gl_dispatch_stub_295 mgl_dispatch_stub_295 +#define gl_dispatch_stub_296 mgl_dispatch_stub_296 +#define gl_dispatch_stub_299 mgl_dispatch_stub_299 +#define gl_dispatch_stub_301 mgl_dispatch_stub_301 +#define gl_dispatch_stub_303 mgl_dispatch_stub_303 +#define gl_dispatch_stub_306 mgl_dispatch_stub_306 +#define gl_dispatch_stub_312 mgl_dispatch_stub_312 +#define gl_dispatch_stub_314 mgl_dispatch_stub_314 +#define gl_dispatch_stub_315 mgl_dispatch_stub_315 +#define gl_dispatch_stub_316 mgl_dispatch_stub_316 +#define gl_dispatch_stub_317 mgl_dispatch_stub_317 +#define gl_dispatch_stub_322 mgl_dispatch_stub_322 +#define gl_dispatch_stub_323 mgl_dispatch_stub_323 +#define gl_dispatch_stub_325 mgl_dispatch_stub_325 +#define gl_dispatch_stub_331 mgl_dispatch_stub_331 +#define gl_dispatch_stub_332 mgl_dispatch_stub_332 +#define gl_dispatch_stub_334 mgl_dispatch_stub_334 +#define gl_dispatch_stub_335 mgl_dispatch_stub_335 +#define gl_dispatch_stub_336 mgl_dispatch_stub_336 +#define gl_dispatch_stub_338 mgl_dispatch_stub_338 +#define gl_dispatch_stub_339 mgl_dispatch_stub_339 +#define gl_dispatch_stub_340 mgl_dispatch_stub_340 +#define gl_dispatch_stub_341 mgl_dispatch_stub_341 +#define gl_dispatch_stub_342 mgl_dispatch_stub_342 +#define gl_dispatch_stub_343 mgl_dispatch_stub_343 +#define gl_dispatch_stub_344 mgl_dispatch_stub_344 +#define gl_dispatch_stub_345 mgl_dispatch_stub_345 +#define gl_dispatch_stub_346 mgl_dispatch_stub_346 +#define gl_dispatch_stub_347 mgl_dispatch_stub_347 +#define gl_dispatch_stub_348 mgl_dispatch_stub_348 +#define gl_dispatch_stub_349 mgl_dispatch_stub_349 +#define gl_dispatch_stub_350 mgl_dispatch_stub_350 +#define gl_dispatch_stub_351 mgl_dispatch_stub_351 +#define gl_dispatch_stub_352 mgl_dispatch_stub_352 +#define gl_dispatch_stub_353 mgl_dispatch_stub_353 +#define gl_dispatch_stub_354 mgl_dispatch_stub_354 +#define gl_dispatch_stub_355 mgl_dispatch_stub_355 +#define gl_dispatch_stub_356 mgl_dispatch_stub_356 +#define gl_dispatch_stub_357 mgl_dispatch_stub_357 +#define gl_dispatch_stub_358 mgl_dispatch_stub_358 +#define gl_dispatch_stub_359 mgl_dispatch_stub_359 +#define gl_dispatch_stub_360 mgl_dispatch_stub_360 +#define gl_dispatch_stub_361 mgl_dispatch_stub_361 +#define gl_dispatch_stub_362 mgl_dispatch_stub_362 +#define gl_dispatch_stub_363 mgl_dispatch_stub_363 +#define gl_dispatch_stub_364 mgl_dispatch_stub_364 +#define gl_dispatch_stub_365 mgl_dispatch_stub_365 +#define gl_dispatch_stub_366 mgl_dispatch_stub_366 +#define gl_dispatch_stub_367 mgl_dispatch_stub_367 +#define gl_dispatch_stub_368 mgl_dispatch_stub_368 +#define gl_dispatch_stub_369 mgl_dispatch_stub_369 +#define gl_dispatch_stub_370 mgl_dispatch_stub_370 +#define gl_dispatch_stub_371 mgl_dispatch_stub_371 +#define gl_dispatch_stub_372 mgl_dispatch_stub_372 +#define gl_dispatch_stub_373 mgl_dispatch_stub_373 +#define gl_dispatch_stub_376 mgl_dispatch_stub_376 +#define gl_dispatch_stub_377 mgl_dispatch_stub_377 +#define gl_dispatch_stub_378 mgl_dispatch_stub_378 +#define gl_dispatch_stub_379 mgl_dispatch_stub_379 +#define gl_dispatch_stub_380 mgl_dispatch_stub_380 +#define gl_dispatch_stub_381 mgl_dispatch_stub_381 +#define gl_dispatch_stub_382 mgl_dispatch_stub_382 +#define gl_dispatch_stub_383 mgl_dispatch_stub_383 +#define gl_dispatch_stub_384 mgl_dispatch_stub_384 +#define gl_dispatch_stub_385 mgl_dispatch_stub_385 +#define gl_dispatch_stub_386 mgl_dispatch_stub_386 +#define gl_dispatch_stub_387 mgl_dispatch_stub_387 +#define gl_dispatch_stub_388 mgl_dispatch_stub_388 +#define gl_dispatch_stub_389 mgl_dispatch_stub_389 +#define gl_dispatch_stub_390 mgl_dispatch_stub_390 +#define gl_dispatch_stub_391 mgl_dispatch_stub_391 +#define gl_dispatch_stub_392 mgl_dispatch_stub_392 +#define gl_dispatch_stub_393 mgl_dispatch_stub_393 +#define gl_dispatch_stub_394 mgl_dispatch_stub_394 +#define gl_dispatch_stub_395 mgl_dispatch_stub_395 +#define gl_dispatch_stub_396 mgl_dispatch_stub_396 +#define gl_dispatch_stub_397 mgl_dispatch_stub_397 +#define gl_dispatch_stub_398 mgl_dispatch_stub_398 +#define gl_dispatch_stub_399 mgl_dispatch_stub_399 +#define gl_dispatch_stub_400 mgl_dispatch_stub_400 +#define gl_dispatch_stub_401 mgl_dispatch_stub_401 +#define gl_dispatch_stub_403 mgl_dispatch_stub_403 +#define gl_dispatch_stub_404 mgl_dispatch_stub_404 +#define gl_dispatch_stub_405 mgl_dispatch_stub_405 +#define gl_dispatch_stub_406 mgl_dispatch_stub_406 +#define gl_dispatch_stub_407 mgl_dispatch_stub_407 +#define gl_dispatch_stub_443 mgl_dispatch_stub_443 +#define gl_dispatch_stub_444 mgl_dispatch_stub_444 +#define gl_dispatch_stub_445 mgl_dispatch_stub_445 +#define gl_dispatch_stub_446 mgl_dispatch_stub_446 +#endif /* USE_MGL_NAMESPACE */ + + +#if defined(NEED_FUNCTION_POINTER) || defined(GLX_INDIRECT_RENDERING) +void GLAPIENTRY gl_dispatch_stub_0(GLuint list, GLenum mode); +void GLAPIENTRY gl_dispatch_stub_1(void); +void GLAPIENTRY gl_dispatch_stub_2(GLuint list); +void GLAPIENTRY gl_dispatch_stub_3(GLsizei n, GLenum type, const GLvoid * lists); +void GLAPIENTRY gl_dispatch_stub_4(GLuint list, GLsizei range); +GLuint GLAPIENTRY gl_dispatch_stub_5(GLsizei range); +void GLAPIENTRY gl_dispatch_stub_6(GLuint base); +void GLAPIENTRY gl_dispatch_stub_7(GLenum mode); +void GLAPIENTRY gl_dispatch_stub_8(GLsizei width, GLsizei height, GLfloat xorig, GLfloat yorig, GLfloat xmove, GLfloat ymove, const GLubyte * bitmap); +void GLAPIENTRY gl_dispatch_stub_9(GLbyte red, GLbyte green, GLbyte blue); +void GLAPIENTRY gl_dispatch_stub_10(const GLbyte * v); +void GLAPIENTRY gl_dispatch_stub_11(GLdouble red, GLdouble green, GLdouble blue); +void GLAPIENTRY gl_dispatch_stub_12(const GLdouble * v); +void GLAPIENTRY gl_dispatch_stub_13(GLfloat red, GLfloat green, GLfloat blue); +void GLAPIENTRY gl_dispatch_stub_14(const GLfloat * v); +void GLAPIENTRY gl_dispatch_stub_15(GLint red, GLint green, GLint blue); +void GLAPIENTRY gl_dispatch_stub_16(const GLint * v); +void GLAPIENTRY gl_dispatch_stub_17(GLshort red, GLshort green, GLshort blue); +void GLAPIENTRY gl_dispatch_stub_18(const GLshort * v); +void GLAPIENTRY gl_dispatch_stub_19(GLubyte red, GLubyte green, GLubyte blue); +void GLAPIENTRY gl_dispatch_stub_20(const GLubyte * v); +void GLAPIENTRY gl_dispatch_stub_21(GLuint red, GLuint green, GLuint blue); +void GLAPIENTRY gl_dispatch_stub_22(const GLuint * v); +void GLAPIENTRY gl_dispatch_stub_23(GLushort red, GLushort green, GLushort blue); +void GLAPIENTRY gl_dispatch_stub_24(const GLushort * v); +void GLAPIENTRY gl_dispatch_stub_25(GLbyte red, GLbyte green, GLbyte blue, GLbyte alpha); +void GLAPIENTRY gl_dispatch_stub_26(const GLbyte * v); +void GLAPIENTRY gl_dispatch_stub_27(GLdouble red, GLdouble green, GLdouble blue, GLdouble alpha); +void GLAPIENTRY gl_dispatch_stub_28(const GLdouble * v); +void GLAPIENTRY gl_dispatch_stub_30(const GLfloat * v); +void GLAPIENTRY gl_dispatch_stub_31(GLint red, GLint green, GLint blue, GLint alpha); +void GLAPIENTRY gl_dispatch_stub_32(const GLint * v); +void GLAPIENTRY gl_dispatch_stub_33(GLshort red, GLshort green, GLshort blue, GLshort alpha); +void GLAPIENTRY gl_dispatch_stub_34(const GLshort * v); +void GLAPIENTRY gl_dispatch_stub_36(const GLubyte * v); +void GLAPIENTRY gl_dispatch_stub_37(GLuint red, GLuint green, GLuint blue, GLuint alpha); +void GLAPIENTRY gl_dispatch_stub_38(const GLuint * v); +void GLAPIENTRY gl_dispatch_stub_39(GLushort red, GLushort green, GLushort blue, GLushort alpha); +void GLAPIENTRY gl_dispatch_stub_40(const GLushort * v); +void GLAPIENTRY gl_dispatch_stub_41(GLboolean flag); +void GLAPIENTRY gl_dispatch_stub_42(const GLboolean * flag); +void GLAPIENTRY gl_dispatch_stub_43(void); +void GLAPIENTRY gl_dispatch_stub_44(GLdouble c); +void GLAPIENTRY gl_dispatch_stub_45(const GLdouble * c); +void GLAPIENTRY gl_dispatch_stub_46(GLfloat c); +void GLAPIENTRY gl_dispatch_stub_47(const GLfloat * c); +void GLAPIENTRY gl_dispatch_stub_48(GLint c); +void GLAPIENTRY gl_dispatch_stub_49(const GLint * c); +void GLAPIENTRY gl_dispatch_stub_50(GLshort c); +void GLAPIENTRY gl_dispatch_stub_51(const GLshort * c); +void GLAPIENTRY gl_dispatch_stub_52(GLbyte nx, GLbyte ny, GLbyte nz); +void GLAPIENTRY gl_dispatch_stub_53(const GLbyte * v); +void GLAPIENTRY gl_dispatch_stub_54(GLdouble nx, GLdouble ny, GLdouble nz); +void GLAPIENTRY gl_dispatch_stub_55(const GLdouble * v); +void GLAPIENTRY gl_dispatch_stub_57(const GLfloat * v); +void GLAPIENTRY gl_dispatch_stub_58(GLint nx, GLint ny, GLint nz); +void GLAPIENTRY gl_dispatch_stub_59(const GLint * v); +void GLAPIENTRY gl_dispatch_stub_60(GLshort nx, GLshort ny, GLshort nz); +void GLAPIENTRY gl_dispatch_stub_61(const GLshort * v); +void GLAPIENTRY gl_dispatch_stub_62(GLdouble x, GLdouble y); +void GLAPIENTRY gl_dispatch_stub_63(const GLdouble * v); +void GLAPIENTRY gl_dispatch_stub_64(GLfloat x, GLfloat y); +void GLAPIENTRY gl_dispatch_stub_65(const GLfloat * v); +void GLAPIENTRY gl_dispatch_stub_66(GLint x, GLint y); +void GLAPIENTRY gl_dispatch_stub_67(const GLint * v); +void GLAPIENTRY gl_dispatch_stub_68(GLshort x, GLshort y); +void GLAPIENTRY gl_dispatch_stub_69(const GLshort * v); +void GLAPIENTRY gl_dispatch_stub_70(GLdouble x, GLdouble y, GLdouble z); +void GLAPIENTRY gl_dispatch_stub_71(const GLdouble * v); +void GLAPIENTRY gl_dispatch_stub_72(GLfloat x, GLfloat y, GLfloat z); +void GLAPIENTRY gl_dispatch_stub_73(const GLfloat * v); +void GLAPIENTRY gl_dispatch_stub_74(GLint x, GLint y, GLint z); +void GLAPIENTRY gl_dispatch_stub_75(const GLint * v); +void GLAPIENTRY gl_dispatch_stub_76(GLshort x, GLshort y, GLshort z); +void GLAPIENTRY gl_dispatch_stub_77(const GLshort * v); +void GLAPIENTRY gl_dispatch_stub_78(GLdouble x, GLdouble y, GLdouble z, GLdouble w); +void GLAPIENTRY gl_dispatch_stub_79(const GLdouble * v); +void GLAPIENTRY gl_dispatch_stub_80(GLfloat x, GLfloat y, GLfloat z, GLfloat w); +void GLAPIENTRY gl_dispatch_stub_81(const GLfloat * v); +void GLAPIENTRY gl_dispatch_stub_82(GLint x, GLint y, GLint z, GLint w); +void GLAPIENTRY gl_dispatch_stub_83(const GLint * v); +void GLAPIENTRY gl_dispatch_stub_84(GLshort x, GLshort y, GLshort z, GLshort w); +void GLAPIENTRY gl_dispatch_stub_85(const GLshort * v); +void GLAPIENTRY gl_dispatch_stub_86(GLdouble x1, GLdouble y1, GLdouble x2, GLdouble y2); +void GLAPIENTRY gl_dispatch_stub_87(const GLdouble * v1, const GLdouble * v2); +void GLAPIENTRY gl_dispatch_stub_88(GLfloat x1, GLfloat y1, GLfloat x2, GLfloat y2); +void GLAPIENTRY gl_dispatch_stub_89(const GLfloat * v1, const GLfloat * v2); +void GLAPIENTRY gl_dispatch_stub_90(GLint x1, GLint y1, GLint x2, GLint y2); +void GLAPIENTRY gl_dispatch_stub_91(const GLint * v1, const GLint * v2); +void GLAPIENTRY gl_dispatch_stub_92(GLshort x1, GLshort y1, GLshort x2, GLshort y2); +void GLAPIENTRY gl_dispatch_stub_93(const GLshort * v1, const GLshort * v2); +void GLAPIENTRY gl_dispatch_stub_94(GLdouble s); +void GLAPIENTRY gl_dispatch_stub_95(const GLdouble * v); +void GLAPIENTRY gl_dispatch_stub_96(GLfloat s); +void GLAPIENTRY gl_dispatch_stub_97(const GLfloat * v); +void GLAPIENTRY gl_dispatch_stub_98(GLint s); +void GLAPIENTRY gl_dispatch_stub_99(const GLint * v); +void GLAPIENTRY gl_dispatch_stub_100(GLshort s); +void GLAPIENTRY gl_dispatch_stub_101(const GLshort * v); +void GLAPIENTRY gl_dispatch_stub_102(GLdouble s, GLdouble t); +void GLAPIENTRY gl_dispatch_stub_103(const GLdouble * v); +void GLAPIENTRY gl_dispatch_stub_104(GLfloat s, GLfloat t); +void GLAPIENTRY gl_dispatch_stub_105(const GLfloat * v); +void GLAPIENTRY gl_dispatch_stub_106(GLint s, GLint t); +void GLAPIENTRY gl_dispatch_stub_107(const GLint * v); +void GLAPIENTRY gl_dispatch_stub_108(GLshort s, GLshort t); +void GLAPIENTRY gl_dispatch_stub_109(const GLshort * v); +void GLAPIENTRY gl_dispatch_stub_110(GLdouble s, GLdouble t, GLdouble r); +void GLAPIENTRY gl_dispatch_stub_111(const GLdouble * v); +void GLAPIENTRY gl_dispatch_stub_112(GLfloat s, GLfloat t, GLfloat r); +void GLAPIENTRY gl_dispatch_stub_113(const GLfloat * v); +void GLAPIENTRY gl_dispatch_stub_114(GLint s, GLint t, GLint r); +void GLAPIENTRY gl_dispatch_stub_115(const GLint * v); +void GLAPIENTRY gl_dispatch_stub_116(GLshort s, GLshort t, GLshort r); +void GLAPIENTRY gl_dispatch_stub_117(const GLshort * v); +void GLAPIENTRY gl_dispatch_stub_118(GLdouble s, GLdouble t, GLdouble r, GLdouble q); +void GLAPIENTRY gl_dispatch_stub_119(const GLdouble * v); +void GLAPIENTRY gl_dispatch_stub_120(GLfloat s, GLfloat t, GLfloat r, GLfloat q); +void GLAPIENTRY gl_dispatch_stub_121(const GLfloat * v); +void GLAPIENTRY gl_dispatch_stub_122(GLint s, GLint t, GLint r, GLint q); +void GLAPIENTRY gl_dispatch_stub_123(const GLint * v); +void GLAPIENTRY gl_dispatch_stub_124(GLshort s, GLshort t, GLshort r, GLshort q); +void GLAPIENTRY gl_dispatch_stub_125(const GLshort * v); +void GLAPIENTRY gl_dispatch_stub_126(GLdouble x, GLdouble y); +void GLAPIENTRY gl_dispatch_stub_127(const GLdouble * v); +void GLAPIENTRY gl_dispatch_stub_128(GLfloat x, GLfloat y); +void GLAPIENTRY gl_dispatch_stub_129(const GLfloat * v); +void GLAPIENTRY gl_dispatch_stub_130(GLint x, GLint y); +void GLAPIENTRY gl_dispatch_stub_131(const GLint * v); +void GLAPIENTRY gl_dispatch_stub_132(GLshort x, GLshort y); +void GLAPIENTRY gl_dispatch_stub_133(const GLshort * v); +void GLAPIENTRY gl_dispatch_stub_134(GLdouble x, GLdouble y, GLdouble z); +void GLAPIENTRY gl_dispatch_stub_135(const GLdouble * v); +void GLAPIENTRY gl_dispatch_stub_136(GLfloat x, GLfloat y, GLfloat z); +void GLAPIENTRY gl_dispatch_stub_137(const GLfloat * v); +void GLAPIENTRY gl_dispatch_stub_138(GLint x, GLint y, GLint z); +void GLAPIENTRY gl_dispatch_stub_139(const GLint * v); +void GLAPIENTRY gl_dispatch_stub_140(GLshort x, GLshort y, GLshort z); +void GLAPIENTRY gl_dispatch_stub_141(const GLshort * v); +void GLAPIENTRY gl_dispatch_stub_142(GLdouble x, GLdouble y, GLdouble z, GLdouble w); +void GLAPIENTRY gl_dispatch_stub_143(const GLdouble * v); +void GLAPIENTRY gl_dispatch_stub_144(GLfloat x, GLfloat y, GLfloat z, GLfloat w); +void GLAPIENTRY gl_dispatch_stub_145(const GLfloat * v); +void GLAPIENTRY gl_dispatch_stub_146(GLint x, GLint y, GLint z, GLint w); +void GLAPIENTRY gl_dispatch_stub_147(const GLint * v); +void GLAPIENTRY gl_dispatch_stub_148(GLshort x, GLshort y, GLshort z, GLshort w); +void GLAPIENTRY gl_dispatch_stub_149(const GLshort * v); +void GLAPIENTRY gl_dispatch_stub_150(GLenum plane, const GLdouble * equation); +void GLAPIENTRY gl_dispatch_stub_151(GLenum face, GLenum mode); +void GLAPIENTRY gl_dispatch_stub_155(GLenum pname, GLint param); +void GLAPIENTRY gl_dispatch_stub_156(GLenum pname, const GLint * params); +void GLAPIENTRY gl_dispatch_stub_161(GLenum light, GLenum pname, GLint param); +void GLAPIENTRY gl_dispatch_stub_162(GLenum light, GLenum pname, const GLint * params); +void GLAPIENTRY gl_dispatch_stub_165(GLenum pname, GLint param); +void GLAPIENTRY gl_dispatch_stub_166(GLenum pname, const GLint * params); +void GLAPIENTRY gl_dispatch_stub_167(GLint factor, GLushort pattern); +void GLAPIENTRY gl_dispatch_stub_171(GLenum face, GLenum pname, GLint param); +void GLAPIENTRY gl_dispatch_stub_172(GLenum face, GLenum pname, const GLint * params); +void GLAPIENTRY gl_dispatch_stub_174(GLenum face, GLenum mode); +void GLAPIENTRY gl_dispatch_stub_175(const GLubyte * mask); +void GLAPIENTRY gl_dispatch_stub_182(GLenum target, GLint level, GLint internalformat, GLsizei width, GLint border, GLenum format, GLenum type, const GLvoid * pixels); +void GLAPIENTRY gl_dispatch_stub_188(GLenum coord, GLenum pname, GLdouble param); +void GLAPIENTRY gl_dispatch_stub_189(GLenum coord, GLenum pname, const GLdouble * params); +void GLAPIENTRY gl_dispatch_stub_194(GLsizei size, GLenum type, GLfloat * buffer); +void GLAPIENTRY gl_dispatch_stub_195(GLsizei size, GLuint * buffer); +GLint GLAPIENTRY gl_dispatch_stub_196(GLenum mode); +void GLAPIENTRY gl_dispatch_stub_197(void); +void GLAPIENTRY gl_dispatch_stub_198(GLuint name); +void GLAPIENTRY gl_dispatch_stub_199(GLfloat token); +void GLAPIENTRY gl_dispatch_stub_200(void); +void GLAPIENTRY gl_dispatch_stub_201(GLuint name); +void GLAPIENTRY gl_dispatch_stub_202(GLenum mode); +void GLAPIENTRY gl_dispatch_stub_204(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha); +void GLAPIENTRY gl_dispatch_stub_205(GLfloat c); +void GLAPIENTRY gl_dispatch_stub_208(GLclampd depth); +void GLAPIENTRY gl_dispatch_stub_212(GLuint mask); +void GLAPIENTRY gl_dispatch_stub_213(GLenum op, GLfloat value); +void GLAPIENTRY gl_dispatch_stub_218(void); +void GLAPIENTRY gl_dispatch_stub_219(GLbitfield mask); +void GLAPIENTRY gl_dispatch_stub_220(GLenum target, GLdouble u1, GLdouble u2, GLint stride, GLint order, const GLdouble * points); +void GLAPIENTRY gl_dispatch_stub_221(GLenum target, GLfloat u1, GLfloat u2, GLint stride, GLint order, const GLfloat * points); +void GLAPIENTRY gl_dispatch_stub_222(GLenum target, GLdouble u1, GLdouble u2, GLint ustride, GLint uorder, GLdouble v1, GLdouble v2, GLint vstride, GLint vorder, const GLdouble * points); +void GLAPIENTRY gl_dispatch_stub_223(GLenum target, GLfloat u1, GLfloat u2, GLint ustride, GLint uorder, GLfloat v1, GLfloat v2, GLint vstride, GLint vorder, const GLfloat * points); +void GLAPIENTRY gl_dispatch_stub_224(GLint un, GLdouble u1, GLdouble u2); +void GLAPIENTRY gl_dispatch_stub_225(GLint un, GLfloat u1, GLfloat u2); +void GLAPIENTRY gl_dispatch_stub_226(GLint un, GLdouble u1, GLdouble u2, GLint vn, GLdouble v1, GLdouble v2); +void GLAPIENTRY gl_dispatch_stub_227(GLint un, GLfloat u1, GLfloat u2, GLint vn, GLfloat v1, GLfloat v2); +void GLAPIENTRY gl_dispatch_stub_228(GLdouble u); +void GLAPIENTRY gl_dispatch_stub_229(const GLdouble * u); +void GLAPIENTRY gl_dispatch_stub_230(GLfloat u); +void GLAPIENTRY gl_dispatch_stub_231(const GLfloat * u); +void GLAPIENTRY gl_dispatch_stub_232(GLdouble u, GLdouble v); +void GLAPIENTRY gl_dispatch_stub_233(const GLdouble * u); +void GLAPIENTRY gl_dispatch_stub_234(GLfloat u, GLfloat v); +void GLAPIENTRY gl_dispatch_stub_235(const GLfloat * u); +void GLAPIENTRY gl_dispatch_stub_236(GLenum mode, GLint i1, GLint i2); +void GLAPIENTRY gl_dispatch_stub_237(GLint i); +void GLAPIENTRY gl_dispatch_stub_238(GLenum mode, GLint i1, GLint i2, GLint j1, GLint j2); +void GLAPIENTRY gl_dispatch_stub_239(GLint i, GLint j); +void GLAPIENTRY gl_dispatch_stub_246(GLfloat xfactor, GLfloat yfactor); +void GLAPIENTRY gl_dispatch_stub_247(GLenum pname, GLfloat param); +void GLAPIENTRY gl_dispatch_stub_248(GLenum pname, GLint param); +void GLAPIENTRY gl_dispatch_stub_249(GLenum pname, GLfloat param); +void GLAPIENTRY gl_dispatch_stub_251(GLenum map, GLsizei mapsize, const GLfloat * values); +void GLAPIENTRY gl_dispatch_stub_252(GLenum map, GLsizei mapsize, const GLuint * values); +void GLAPIENTRY gl_dispatch_stub_253(GLenum map, GLsizei mapsize, const GLushort * values); +void GLAPIENTRY gl_dispatch_stub_254(GLenum mode); +void GLAPIENTRY gl_dispatch_stub_255(GLint x, GLint y, GLsizei width, GLsizei height, GLenum type); +void GLAPIENTRY gl_dispatch_stub_257(GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid * pixels); +void GLAPIENTRY gl_dispatch_stub_259(GLenum plane, GLdouble * equation); +void GLAPIENTRY gl_dispatch_stub_260(GLenum pname, GLdouble * params); +void GLAPIENTRY gl_dispatch_stub_265(GLenum light, GLenum pname, GLint * params); +void GLAPIENTRY gl_dispatch_stub_266(GLenum target, GLenum query, GLdouble * v); +void GLAPIENTRY gl_dispatch_stub_267(GLenum target, GLenum query, GLfloat * v); +void GLAPIENTRY gl_dispatch_stub_268(GLenum target, GLenum query, GLint * v); +void GLAPIENTRY gl_dispatch_stub_270(GLenum face, GLenum pname, GLint * params); +void GLAPIENTRY gl_dispatch_stub_271(GLenum map, GLfloat * values); +void GLAPIENTRY gl_dispatch_stub_272(GLenum map, GLuint * values); +void GLAPIENTRY gl_dispatch_stub_273(GLenum map, GLushort * values); +void GLAPIENTRY gl_dispatch_stub_274(GLubyte * mask); +void GLAPIENTRY gl_dispatch_stub_278(GLenum coord, GLenum pname, GLdouble * params); +void GLAPIENTRY gl_dispatch_stub_281(GLenum target, GLint level, GLenum format, GLenum type, GLvoid * pixels); +void GLAPIENTRY gl_dispatch_stub_284(GLenum target, GLint level, GLenum pname, GLfloat * params); +void GLAPIENTRY gl_dispatch_stub_285(GLenum target, GLint level, GLenum pname, GLint * params); +GLboolean GLAPIENTRY gl_dispatch_stub_287(GLuint list); +void GLAPIENTRY gl_dispatch_stub_288(GLclampd zNear, GLclampd zFar); +void GLAPIENTRY gl_dispatch_stub_289(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar); +void GLAPIENTRY gl_dispatch_stub_292(const GLdouble * m); +void GLAPIENTRY gl_dispatch_stub_295(const GLdouble * m); +void GLAPIENTRY gl_dispatch_stub_296(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar); +void GLAPIENTRY gl_dispatch_stub_299(GLdouble angle, GLdouble x, GLdouble y, GLdouble z); +void GLAPIENTRY gl_dispatch_stub_301(GLdouble x, GLdouble y, GLdouble z); +void GLAPIENTRY gl_dispatch_stub_303(GLdouble x, GLdouble y, GLdouble z); +void GLAPIENTRY gl_dispatch_stub_306(GLint i); +void GLAPIENTRY gl_dispatch_stub_312(GLsizei stride, const GLvoid * pointer); +void GLAPIENTRY gl_dispatch_stub_314(GLenum type, GLsizei stride, const GLvoid * pointer); +void GLAPIENTRY gl_dispatch_stub_315(GLubyte c); +void GLAPIENTRY gl_dispatch_stub_316(const GLubyte * c); +void GLAPIENTRY gl_dispatch_stub_317(GLenum format, GLsizei stride, const GLvoid * pointer); +GLboolean GLAPIENTRY gl_dispatch_stub_322(GLsizei n, const GLuint * textures, GLboolean * residences); +void GLAPIENTRY gl_dispatch_stub_323(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLint border); +void GLAPIENTRY gl_dispatch_stub_325(GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width); +void GLAPIENTRY gl_dispatch_stub_331(GLsizei n, const GLuint * textures, const GLclampf * priorities); +void GLAPIENTRY gl_dispatch_stub_332(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const GLvoid * pixels); +void GLAPIENTRY gl_dispatch_stub_334(void); +void GLAPIENTRY gl_dispatch_stub_335(GLbitfield mask); +void GLAPIENTRY gl_dispatch_stub_336(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha); +void GLAPIENTRY gl_dispatch_stub_338(GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const GLvoid * indices); +void GLAPIENTRY gl_dispatch_stub_339(GLenum target, GLenum internalformat, GLsizei width, GLenum format, GLenum type, const GLvoid * table); +void GLAPIENTRY gl_dispatch_stub_340(GLenum target, GLenum pname, const GLfloat * params); +void GLAPIENTRY gl_dispatch_stub_341(GLenum target, GLenum pname, const GLint * params); +void GLAPIENTRY gl_dispatch_stub_342(GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width); +void GLAPIENTRY gl_dispatch_stub_343(GLenum target, GLenum format, GLenum type, GLvoid * table); +void GLAPIENTRY gl_dispatch_stub_344(GLenum target, GLenum pname, GLfloat * params); +void GLAPIENTRY gl_dispatch_stub_345(GLenum target, GLenum pname, GLint * params); +void GLAPIENTRY gl_dispatch_stub_346(GLenum target, GLsizei start, GLsizei count, GLenum format, GLenum type, const GLvoid * data); +void GLAPIENTRY gl_dispatch_stub_347(GLenum target, GLsizei start, GLint x, GLint y, GLsizei width); +void GLAPIENTRY gl_dispatch_stub_348(GLenum target, GLenum internalformat, GLsizei width, GLenum format, GLenum type, const GLvoid * image); +void GLAPIENTRY gl_dispatch_stub_349(GLenum target, GLenum internalformat, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid * image); +void GLAPIENTRY gl_dispatch_stub_350(GLenum target, GLenum pname, GLfloat params); +void GLAPIENTRY gl_dispatch_stub_351(GLenum target, GLenum pname, const GLfloat * params); +void GLAPIENTRY gl_dispatch_stub_352(GLenum target, GLenum pname, GLint params); +void GLAPIENTRY gl_dispatch_stub_353(GLenum target, GLenum pname, const GLint * params); +void GLAPIENTRY gl_dispatch_stub_354(GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width); +void GLAPIENTRY gl_dispatch_stub_355(GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height); +void GLAPIENTRY gl_dispatch_stub_356(GLenum target, GLenum format, GLenum type, GLvoid * image); +void GLAPIENTRY gl_dispatch_stub_357(GLenum target, GLenum pname, GLfloat * params); +void GLAPIENTRY gl_dispatch_stub_358(GLenum target, GLenum pname, GLint * params); +void GLAPIENTRY gl_dispatch_stub_359(GLenum target, GLenum format, GLenum type, GLvoid * row, GLvoid * column, GLvoid * span); +void GLAPIENTRY gl_dispatch_stub_360(GLenum target, GLenum internalformat, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid * row, const GLvoid * column); +void GLAPIENTRY gl_dispatch_stub_361(GLenum target, GLboolean reset, GLenum format, GLenum type, GLvoid * values); +void GLAPIENTRY gl_dispatch_stub_362(GLenum target, GLenum pname, GLfloat * params); +void GLAPIENTRY gl_dispatch_stub_363(GLenum target, GLenum pname, GLint * params); +void GLAPIENTRY gl_dispatch_stub_364(GLenum target, GLboolean reset, GLenum format, GLenum type, GLvoid * values); +void GLAPIENTRY gl_dispatch_stub_365(GLenum target, GLenum pname, GLfloat * params); +void GLAPIENTRY gl_dispatch_stub_366(GLenum target, GLenum pname, GLint * params); +void GLAPIENTRY gl_dispatch_stub_367(GLenum target, GLsizei width, GLenum internalformat, GLboolean sink); +void GLAPIENTRY gl_dispatch_stub_368(GLenum target, GLenum internalformat, GLboolean sink); +void GLAPIENTRY gl_dispatch_stub_369(GLenum target); +void GLAPIENTRY gl_dispatch_stub_370(GLenum target); +void GLAPIENTRY gl_dispatch_stub_371(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const GLvoid * pixels); +void GLAPIENTRY gl_dispatch_stub_372(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const GLvoid * pixels); +void GLAPIENTRY gl_dispatch_stub_373(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height); +void GLAPIENTRY gl_dispatch_stub_376(GLenum target, GLdouble s); +void GLAPIENTRY gl_dispatch_stub_377(GLenum target, const GLdouble * v); +void GLAPIENTRY gl_dispatch_stub_378(GLenum target, GLfloat s); +void GLAPIENTRY gl_dispatch_stub_379(GLenum target, const GLfloat * v); +void GLAPIENTRY gl_dispatch_stub_380(GLenum target, GLint s); +void GLAPIENTRY gl_dispatch_stub_381(GLenum target, const GLint * v); +void GLAPIENTRY gl_dispatch_stub_382(GLenum target, GLshort s); +void GLAPIENTRY gl_dispatch_stub_383(GLenum target, const GLshort * v); +void GLAPIENTRY gl_dispatch_stub_384(GLenum target, GLdouble s, GLdouble t); +void GLAPIENTRY gl_dispatch_stub_385(GLenum target, const GLdouble * v); +void GLAPIENTRY gl_dispatch_stub_386(GLenum target, GLfloat s, GLfloat t); +void GLAPIENTRY gl_dispatch_stub_387(GLenum target, const GLfloat * v); +void GLAPIENTRY gl_dispatch_stub_388(GLenum target, GLint s, GLint t); +void GLAPIENTRY gl_dispatch_stub_389(GLenum target, const GLint * v); +void GLAPIENTRY gl_dispatch_stub_390(GLenum target, GLshort s, GLshort t); +void GLAPIENTRY gl_dispatch_stub_391(GLenum target, const GLshort * v); +void GLAPIENTRY gl_dispatch_stub_392(GLenum target, GLdouble s, GLdouble t, GLdouble r); +void GLAPIENTRY gl_dispatch_stub_393(GLenum target, const GLdouble * v); +void GLAPIENTRY gl_dispatch_stub_394(GLenum target, GLfloat s, GLfloat t, GLfloat r); +void GLAPIENTRY gl_dispatch_stub_395(GLenum target, const GLfloat * v); +void GLAPIENTRY gl_dispatch_stub_396(GLenum target, GLint s, GLint t, GLint r); +void GLAPIENTRY gl_dispatch_stub_397(GLenum target, const GLint * v); +void GLAPIENTRY gl_dispatch_stub_398(GLenum target, GLshort s, GLshort t, GLshort r); +void GLAPIENTRY gl_dispatch_stub_399(GLenum target, const GLshort * v); +void GLAPIENTRY gl_dispatch_stub_400(GLenum target, GLdouble s, GLdouble t, GLdouble r, GLdouble q); +void GLAPIENTRY gl_dispatch_stub_401(GLenum target, const GLdouble * v); +void GLAPIENTRY gl_dispatch_stub_403(GLenum target, const GLfloat * v); +void GLAPIENTRY gl_dispatch_stub_404(GLenum target, GLint s, GLint t, GLint r, GLint q); +void GLAPIENTRY gl_dispatch_stub_405(GLenum target, const GLint * v); +void GLAPIENTRY gl_dispatch_stub_406(GLenum target, GLshort s, GLshort t, GLshort r, GLshort q); +void GLAPIENTRY gl_dispatch_stub_407(GLenum target, const GLshort * v); +void GLAPIENTRY gl_dispatch_stub_443(GLuint array); +void GLAPIENTRY gl_dispatch_stub_444(GLsizei n, const GLuint * arrays); +void GLAPIENTRY gl_dispatch_stub_445(GLsizei n, GLuint * arrays); +GLboolean GLAPIENTRY gl_dispatch_stub_446(GLuint array); + +/* OpenGL ES specific prototypes */ + +/* category GL_OES_EGL_image */ +GLAPI void GLAPIENTRY glEGLImageTargetRenderbufferStorageOES(GLenum target, GLvoid * writeOffset); +GLAPI void GLAPIENTRY glEGLImageTargetTexture2DOES(GLenum target, GLvoid * writeOffset); +/* category GL_OES_blend_equation_separate */ +GLAPI void GLAPIENTRY glBlendEquationSeparateOES(GLenum modeRGB, GLenum modeA); +/* category GL_OES_blend_func_separate */ +GLAPI void GLAPIENTRY glBlendFuncSeparateOES(GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha); +/* category GL_OES_blend_subtract */ +GLAPI void GLAPIENTRY glBlendEquationOES(GLenum mode); +/* category GL_OES_draw_texture */ +GLAPI void GLAPIENTRY glDrawTexfOES(GLfloat x, GLfloat y, GLfloat z, GLfloat width, GLfloat height); +GLAPI void GLAPIENTRY glDrawTexfvOES(const GLfloat * coords); +GLAPI void GLAPIENTRY glDrawTexiOES(GLint x, GLint y, GLint z, GLint width, GLint height); +GLAPI void GLAPIENTRY glDrawTexivOES(const GLint * coords); +GLAPI void GLAPIENTRY glDrawTexsOES(GLshort x, GLshort y, GLshort z, GLshort width, GLshort height); +GLAPI void GLAPIENTRY glDrawTexsvOES(const GLshort * coords); +GLAPI void GLAPIENTRY glDrawTexxOES(GLfixed x, GLfixed y, GLfixed z, GLfixed width, GLfixed height); +GLAPI void GLAPIENTRY glDrawTexxvOES(const GLfixed * coords); +/* category GL_OES_fixed_point */ +GLAPI void GLAPIENTRY glAlphaFuncxOES(GLenum func, GLclampx ref); +GLAPI void GLAPIENTRY glClearColorxOES(GLclampx red, GLclampx green, GLclampx blue, GLclampx alpha); +GLAPI void GLAPIENTRY glClearDepthxOES(GLclampx depth); +GLAPI void GLAPIENTRY glColor4xOES(GLfixed red, GLfixed green, GLfixed blue, GLfixed alpha); +GLAPI void GLAPIENTRY glDepthRangexOES(GLclampx zNear, GLclampx zFar); +GLAPI void GLAPIENTRY glFogxOES(GLenum pname, GLfixed param); +GLAPI void GLAPIENTRY glFogxvOES(GLenum pname, const GLfixed * params); +GLAPI void GLAPIENTRY glFrustumxOES(GLfixed left, GLfixed right, GLfixed bottom, GLfixed top, GLfixed zNear, GLfixed zFar); +GLAPI void GLAPIENTRY glLightModelxOES(GLenum pname, GLfixed param); +GLAPI void GLAPIENTRY glLightModelxvOES(GLenum pname, const GLfixed * params); +GLAPI void GLAPIENTRY glLightxOES(GLenum light, GLenum pname, GLfixed param); +GLAPI void GLAPIENTRY glLightxvOES(GLenum light, GLenum pname, const GLfixed * params); +GLAPI void GLAPIENTRY glLineWidthxOES(GLfixed width); +GLAPI void GLAPIENTRY glLoadMatrixxOES(const GLfixed * m); +GLAPI void GLAPIENTRY glMaterialxOES(GLenum face, GLenum pname, GLfixed param); +GLAPI void GLAPIENTRY glMaterialxvOES(GLenum face, GLenum pname, const GLfixed * params); +GLAPI void GLAPIENTRY glMultMatrixxOES(const GLfixed * m); +GLAPI void GLAPIENTRY glMultiTexCoord4xOES(GLenum target, GLfixed s, GLfixed t, GLfixed r, GLfixed q); +GLAPI void GLAPIENTRY glNormal3xOES(GLfixed nx, GLfixed ny, GLfixed nz); +GLAPI void GLAPIENTRY glOrthoxOES(GLfixed left, GLfixed right, GLfixed bottom, GLfixed top, GLfixed zNear, GLfixed zFar); +GLAPI void GLAPIENTRY glPointSizexOES(GLfixed size); +GLAPI void GLAPIENTRY glPolygonOffsetxOES(GLfixed factor, GLfixed units); +GLAPI void GLAPIENTRY glRotatexOES(GLfixed angle, GLfixed x, GLfixed y, GLfixed z); +GLAPI void GLAPIENTRY glSampleCoveragexOES(GLclampx value, GLboolean invert); +GLAPI void GLAPIENTRY glScalexOES(GLfixed x, GLfixed y, GLfixed z); +GLAPI void GLAPIENTRY glTexEnvxOES(GLenum target, GLenum pname, GLfixed param); +GLAPI void GLAPIENTRY glTexEnvxvOES(GLenum target, GLenum pname, const GLfixed * params); +GLAPI void GLAPIENTRY glTexParameterxOES(GLenum target, GLenum pname, GLfixed param); +GLAPI void GLAPIENTRY glTranslatexOES(GLfixed x, GLfixed y, GLfixed z); +GLAPI void GLAPIENTRY glClipPlanexOES(GLenum plane, const GLfixed * equation); +GLAPI void GLAPIENTRY glGetClipPlanexOES(GLenum plane, GLfixed * equation); +GLAPI void GLAPIENTRY glGetFixedvOES(GLenum pname, GLfixed * params); +GLAPI void GLAPIENTRY glGetLightxvOES(GLenum light, GLenum pname, GLfixed * params); +GLAPI void GLAPIENTRY glGetMaterialxvOES(GLenum face, GLenum pname, GLfixed * params); +GLAPI void GLAPIENTRY glGetTexEnvxvOES(GLenum target, GLenum pname, GLfixed * params); +GLAPI void GLAPIENTRY glGetTexParameterxvOES(GLenum target, GLenum pname, GLfixed * params); +GLAPI void GLAPIENTRY glPointParameterxOES(GLenum pname, GLfixed param); +GLAPI void GLAPIENTRY glPointParameterxvOES(GLenum pname, const GLfixed * params); +GLAPI void GLAPIENTRY glTexParameterxvOES(GLenum target, GLenum pname, const GLfixed * params); +/* category GL_OES_framebuffer_object */ +GLAPI void GLAPIENTRY glBindFramebufferOES(GLenum target, GLuint framebuffer); +GLAPI void GLAPIENTRY glBindRenderbufferOES(GLenum target, GLuint renderbuffer); +GLAPI GLenum GLAPIENTRY glCheckFramebufferStatusOES(GLenum target); +GLAPI void GLAPIENTRY glDeleteFramebuffersOES(GLsizei n, const GLuint * framebuffers); +GLAPI void GLAPIENTRY glDeleteRenderbuffersOES(GLsizei n, const GLuint * renderbuffers); +GLAPI void GLAPIENTRY glFramebufferRenderbufferOES(GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer); +GLAPI void GLAPIENTRY glFramebufferTexture2DOES(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level); +GLAPI void GLAPIENTRY glGenFramebuffersOES(GLsizei n, GLuint * framebuffers); +GLAPI void GLAPIENTRY glGenRenderbuffersOES(GLsizei n, GLuint * renderbuffers); +GLAPI void GLAPIENTRY glGenerateMipmapOES(GLenum target); +GLAPI void GLAPIENTRY glGetFramebufferAttachmentParameterivOES(GLenum target, GLenum attachment, GLenum pname, GLint * params); +GLAPI void GLAPIENTRY glGetRenderbufferParameterivOES(GLenum target, GLenum pname, GLint * params); +GLAPI GLboolean GLAPIENTRY glIsFramebufferOES(GLuint framebuffer); +GLAPI GLboolean GLAPIENTRY glIsRenderbufferOES(GLuint renderbuffer); +GLAPI void GLAPIENTRY glRenderbufferStorageOES(GLenum target, GLenum internalformat, GLsizei width, GLsizei height); +/* category GL_OES_mapbuffer */ +GLAPI void GLAPIENTRY glGetBufferPointervOES(GLenum target, GLenum pname, GLvoid ** params); +GLAPI GLvoid * GLAPIENTRY glMapBufferOES(GLenum target, GLenum access); +GLAPI GLboolean GLAPIENTRY glUnmapBufferOES(GLenum target); +/* category GL_OES_point_size_array */ +GLAPI void GLAPIENTRY glPointSizePointerOES(GLenum type, GLsizei stride, const GLvoid * pointer); +/* category GL_OES_query_matrix */ +GLAPI GLbitfield GLAPIENTRY glQueryMatrixxOES(GLfixed * mantissa, GLint * exponent); +/* category GL_OES_single_precision */ +GLAPI void GLAPIENTRY glClearDepthfOES(GLclampf depth); +GLAPI void GLAPIENTRY glDepthRangefOES(GLclampf zNear, GLclampf zFar); +GLAPI void GLAPIENTRY glFrustumfOES(GLfloat left, GLfloat right, GLfloat bottom, GLfloat top, GLfloat zNear, GLfloat zFar); +GLAPI void GLAPIENTRY glOrthofOES(GLfloat left, GLfloat right, GLfloat bottom, GLfloat top, GLfloat zNear, GLfloat zFar); +GLAPI void GLAPIENTRY glClipPlanefOES(GLenum plane, const GLfloat * equation); +GLAPI void GLAPIENTRY glGetClipPlanefOES(GLenum plane, GLfloat * equation); +/* category GL_OES_texture_cube_map */ +GLAPI void GLAPIENTRY glTexGenfOES(GLenum coord, GLenum pname, GLfloat param); +GLAPI void GLAPIENTRY glTexGenfvOES(GLenum coord, GLenum pname, const GLfloat * params); +GLAPI void GLAPIENTRY glTexGeniOES(GLenum coord, GLenum pname, GLint param); +GLAPI void GLAPIENTRY glTexGenivOES(GLenum coord, GLenum pname, const GLint * params); +GLAPI void GLAPIENTRY glGetTexGenfvOES(GLenum coord, GLenum pname, GLfloat * params); +GLAPI void GLAPIENTRY glGetTexGenivOES(GLenum coord, GLenum pname, GLint * params); +GLAPI void GLAPIENTRY glGetTexGenxvOES(GLenum coord, GLenum pname, GLfixed * params); +GLAPI void GLAPIENTRY glTexGenxOES(GLenum coord, GLenum pname, GLint param); +GLAPI void GLAPIENTRY glTexGenxvOES(GLenum coord, GLenum pname, const GLfixed * params); +/* category es1.0 */ +GLAPI void GLAPIENTRY glAlphaFuncx(GLenum func, GLclampx ref); +GLAPI void GLAPIENTRY glClearColorx(GLclampx red, GLclampx green, GLclampx blue, GLclampx alpha); +GLAPI void GLAPIENTRY glClearDepthf(GLclampf depth); +GLAPI void GLAPIENTRY glClearDepthx(GLclampx depth); +GLAPI void GLAPIENTRY glColor4x(GLfixed red, GLfixed green, GLfixed blue, GLfixed alpha); +GLAPI void GLAPIENTRY glDepthRangef(GLclampf zNear, GLclampf zFar); +GLAPI void GLAPIENTRY glDepthRangex(GLclampx zNear, GLclampx zFar); +GLAPI void GLAPIENTRY glFogx(GLenum pname, GLfixed param); +GLAPI void GLAPIENTRY glFogxv(GLenum pname, const GLfixed * params); +GLAPI void GLAPIENTRY glFrustumf(GLfloat left, GLfloat right, GLfloat bottom, GLfloat top, GLfloat zNear, GLfloat zFar); +GLAPI void GLAPIENTRY glFrustumx(GLfixed left, GLfixed right, GLfixed bottom, GLfixed top, GLfixed zNear, GLfixed zFar); +GLAPI void GLAPIENTRY glLightModelx(GLenum pname, GLfixed param); +GLAPI void GLAPIENTRY glLightModelxv(GLenum pname, const GLfixed * params); +GLAPI void GLAPIENTRY glLightx(GLenum light, GLenum pname, GLfixed param); +GLAPI void GLAPIENTRY glLightxv(GLenum light, GLenum pname, const GLfixed * params); +GLAPI void GLAPIENTRY glLineWidthx(GLfixed width); +GLAPI void GLAPIENTRY glLoadMatrixx(const GLfixed * m); +GLAPI void GLAPIENTRY glMaterialx(GLenum face, GLenum pname, GLfixed param); +GLAPI void GLAPIENTRY glMaterialxv(GLenum face, GLenum pname, const GLfixed * params); +GLAPI void GLAPIENTRY glMultMatrixx(const GLfixed * m); +GLAPI void GLAPIENTRY glMultiTexCoord4x(GLenum target, GLfixed s, GLfixed t, GLfixed r, GLfixed q); +GLAPI void GLAPIENTRY glNormal3x(GLfixed nx, GLfixed ny, GLfixed nz); +GLAPI void GLAPIENTRY glOrthof(GLfloat left, GLfloat right, GLfloat bottom, GLfloat top, GLfloat zNear, GLfloat zFar); +GLAPI void GLAPIENTRY glOrthox(GLfixed left, GLfixed right, GLfixed bottom, GLfixed top, GLfixed zNear, GLfixed zFar); +GLAPI void GLAPIENTRY glPointSizex(GLfixed size); +GLAPI void GLAPIENTRY glPolygonOffsetx(GLfixed factor, GLfixed units); +GLAPI void GLAPIENTRY glRotatex(GLfixed angle, GLfixed x, GLfixed y, GLfixed z); +GLAPI void GLAPIENTRY glSampleCoveragex(GLclampx value, GLboolean invert); +GLAPI void GLAPIENTRY glScalex(GLfixed x, GLfixed y, GLfixed z); +GLAPI void GLAPIENTRY glTexEnvx(GLenum target, GLenum pname, GLfixed param); +GLAPI void GLAPIENTRY glTexEnvxv(GLenum target, GLenum pname, const GLfixed * params); +GLAPI void GLAPIENTRY glTexParameterx(GLenum target, GLenum pname, GLfixed param); +GLAPI void GLAPIENTRY glTranslatex(GLfixed x, GLfixed y, GLfixed z); +/* category es1.1 */ +GLAPI void GLAPIENTRY glClipPlanef(GLenum plane, const GLfloat * equation); +GLAPI void GLAPIENTRY glClipPlanex(GLenum plane, const GLfixed * equation); +GLAPI void GLAPIENTRY glGetClipPlanef(GLenum plane, GLfloat * equation); +GLAPI void GLAPIENTRY glGetClipPlanex(GLenum plane, GLfixed * equation); +GLAPI void GLAPIENTRY glGetFixedv(GLenum pname, GLfixed * params); +GLAPI void GLAPIENTRY glGetLightxv(GLenum light, GLenum pname, GLfixed * params); +GLAPI void GLAPIENTRY glGetMaterialxv(GLenum face, GLenum pname, GLfixed * params); +GLAPI void GLAPIENTRY glGetTexEnvxv(GLenum target, GLenum pname, GLfixed * params); +GLAPI void GLAPIENTRY glGetTexParameterxv(GLenum target, GLenum pname, GLfixed * params); +GLAPI void GLAPIENTRY glPointParameterx(GLenum pname, GLfixed param); +GLAPI void GLAPIENTRY glPointParameterxv(GLenum pname, const GLfixed * params); +GLAPI void GLAPIENTRY glTexParameterxv(GLenum target, GLenum pname, const GLfixed * params); + +#endif /* defined(NEED_FUNCTION_POINTER) || defined(GLX_INDIRECT_RENDERING) */ + +static const glprocs_table_t static_functions[] = { + NAME_FUNC_OFFSET( 0, gl_dispatch_stub_0, gl_dispatch_stub_0, NULL, 0), + NAME_FUNC_OFFSET( 10, gl_dispatch_stub_1, gl_dispatch_stub_1, NULL, 1), + NAME_FUNC_OFFSET( 20, gl_dispatch_stub_2, gl_dispatch_stub_2, NULL, 2), + NAME_FUNC_OFFSET( 31, gl_dispatch_stub_3, gl_dispatch_stub_3, NULL, 3), + NAME_FUNC_OFFSET( 43, gl_dispatch_stub_4, gl_dispatch_stub_4, NULL, 4), + NAME_FUNC_OFFSET( 57, gl_dispatch_stub_5, gl_dispatch_stub_5, NULL, 5), + NAME_FUNC_OFFSET( 68, gl_dispatch_stub_6, gl_dispatch_stub_6, NULL, 6), + NAME_FUNC_OFFSET( 79, gl_dispatch_stub_7, gl_dispatch_stub_7, NULL, 7), + NAME_FUNC_OFFSET( 87, gl_dispatch_stub_8, gl_dispatch_stub_8, NULL, 8), + NAME_FUNC_OFFSET( 96, gl_dispatch_stub_9, gl_dispatch_stub_9, NULL, 9), + NAME_FUNC_OFFSET( 106, gl_dispatch_stub_10, gl_dispatch_stub_10, NULL, 10), + NAME_FUNC_OFFSET( 117, gl_dispatch_stub_11, gl_dispatch_stub_11, NULL, 11), + NAME_FUNC_OFFSET( 127, gl_dispatch_stub_12, gl_dispatch_stub_12, NULL, 12), + NAME_FUNC_OFFSET( 138, gl_dispatch_stub_13, gl_dispatch_stub_13, NULL, 13), + NAME_FUNC_OFFSET( 148, gl_dispatch_stub_14, gl_dispatch_stub_14, NULL, 14), + NAME_FUNC_OFFSET( 159, gl_dispatch_stub_15, gl_dispatch_stub_15, NULL, 15), + NAME_FUNC_OFFSET( 169, gl_dispatch_stub_16, gl_dispatch_stub_16, NULL, 16), + NAME_FUNC_OFFSET( 180, gl_dispatch_stub_17, gl_dispatch_stub_17, NULL, 17), + NAME_FUNC_OFFSET( 190, gl_dispatch_stub_18, gl_dispatch_stub_18, NULL, 18), + NAME_FUNC_OFFSET( 201, gl_dispatch_stub_19, gl_dispatch_stub_19, NULL, 19), + NAME_FUNC_OFFSET( 212, gl_dispatch_stub_20, gl_dispatch_stub_20, NULL, 20), + NAME_FUNC_OFFSET( 224, gl_dispatch_stub_21, gl_dispatch_stub_21, NULL, 21), + NAME_FUNC_OFFSET( 235, gl_dispatch_stub_22, gl_dispatch_stub_22, NULL, 22), + NAME_FUNC_OFFSET( 247, gl_dispatch_stub_23, gl_dispatch_stub_23, NULL, 23), + NAME_FUNC_OFFSET( 258, gl_dispatch_stub_24, gl_dispatch_stub_24, NULL, 24), + NAME_FUNC_OFFSET( 270, gl_dispatch_stub_25, gl_dispatch_stub_25, NULL, 25), + NAME_FUNC_OFFSET( 280, gl_dispatch_stub_26, gl_dispatch_stub_26, NULL, 26), + NAME_FUNC_OFFSET( 291, gl_dispatch_stub_27, gl_dispatch_stub_27, NULL, 27), + NAME_FUNC_OFFSET( 301, gl_dispatch_stub_28, gl_dispatch_stub_28, NULL, 28), + NAME_FUNC_OFFSET( 312, glColor4f, glColor4f, NULL, 29), + NAME_FUNC_OFFSET( 322, gl_dispatch_stub_30, gl_dispatch_stub_30, NULL, 30), + NAME_FUNC_OFFSET( 333, gl_dispatch_stub_31, gl_dispatch_stub_31, NULL, 31), + NAME_FUNC_OFFSET( 343, gl_dispatch_stub_32, gl_dispatch_stub_32, NULL, 32), + NAME_FUNC_OFFSET( 354, gl_dispatch_stub_33, gl_dispatch_stub_33, NULL, 33), + NAME_FUNC_OFFSET( 364, gl_dispatch_stub_34, gl_dispatch_stub_34, NULL, 34), + NAME_FUNC_OFFSET( 375, glColor4ub, glColor4ub, NULL, 35), + NAME_FUNC_OFFSET( 386, gl_dispatch_stub_36, gl_dispatch_stub_36, NULL, 36), + NAME_FUNC_OFFSET( 398, gl_dispatch_stub_37, gl_dispatch_stub_37, NULL, 37), + NAME_FUNC_OFFSET( 409, gl_dispatch_stub_38, gl_dispatch_stub_38, NULL, 38), + NAME_FUNC_OFFSET( 421, gl_dispatch_stub_39, gl_dispatch_stub_39, NULL, 39), + NAME_FUNC_OFFSET( 432, gl_dispatch_stub_40, gl_dispatch_stub_40, NULL, 40), + NAME_FUNC_OFFSET( 444, gl_dispatch_stub_41, gl_dispatch_stub_41, NULL, 41), + NAME_FUNC_OFFSET( 455, gl_dispatch_stub_42, gl_dispatch_stub_42, NULL, 42), + NAME_FUNC_OFFSET( 467, gl_dispatch_stub_43, gl_dispatch_stub_43, NULL, 43), + NAME_FUNC_OFFSET( 473, gl_dispatch_stub_44, gl_dispatch_stub_44, NULL, 44), + NAME_FUNC_OFFSET( 482, gl_dispatch_stub_45, gl_dispatch_stub_45, NULL, 45), + NAME_FUNC_OFFSET( 492, gl_dispatch_stub_46, gl_dispatch_stub_46, NULL, 46), + NAME_FUNC_OFFSET( 501, gl_dispatch_stub_47, gl_dispatch_stub_47, NULL, 47), + NAME_FUNC_OFFSET( 511, gl_dispatch_stub_48, gl_dispatch_stub_48, NULL, 48), + NAME_FUNC_OFFSET( 520, gl_dispatch_stub_49, gl_dispatch_stub_49, NULL, 49), + NAME_FUNC_OFFSET( 530, gl_dispatch_stub_50, gl_dispatch_stub_50, NULL, 50), + NAME_FUNC_OFFSET( 539, gl_dispatch_stub_51, gl_dispatch_stub_51, NULL, 51), + NAME_FUNC_OFFSET( 549, gl_dispatch_stub_52, gl_dispatch_stub_52, NULL, 52), + NAME_FUNC_OFFSET( 560, gl_dispatch_stub_53, gl_dispatch_stub_53, NULL, 53), + NAME_FUNC_OFFSET( 572, gl_dispatch_stub_54, gl_dispatch_stub_54, NULL, 54), + NAME_FUNC_OFFSET( 583, gl_dispatch_stub_55, gl_dispatch_stub_55, NULL, 55), + NAME_FUNC_OFFSET( 595, glNormal3f, glNormal3f, NULL, 56), + NAME_FUNC_OFFSET( 606, gl_dispatch_stub_57, gl_dispatch_stub_57, NULL, 57), + NAME_FUNC_OFFSET( 618, gl_dispatch_stub_58, gl_dispatch_stub_58, NULL, 58), + NAME_FUNC_OFFSET( 629, gl_dispatch_stub_59, gl_dispatch_stub_59, NULL, 59), + NAME_FUNC_OFFSET( 641, gl_dispatch_stub_60, gl_dispatch_stub_60, NULL, 60), + NAME_FUNC_OFFSET( 652, gl_dispatch_stub_61, gl_dispatch_stub_61, NULL, 61), + NAME_FUNC_OFFSET( 664, gl_dispatch_stub_62, gl_dispatch_stub_62, NULL, 62), + NAME_FUNC_OFFSET( 678, gl_dispatch_stub_63, gl_dispatch_stub_63, NULL, 63), + NAME_FUNC_OFFSET( 693, gl_dispatch_stub_64, gl_dispatch_stub_64, NULL, 64), + NAME_FUNC_OFFSET( 707, gl_dispatch_stub_65, gl_dispatch_stub_65, NULL, 65), + NAME_FUNC_OFFSET( 722, gl_dispatch_stub_66, gl_dispatch_stub_66, NULL, 66), + NAME_FUNC_OFFSET( 736, gl_dispatch_stub_67, gl_dispatch_stub_67, NULL, 67), + NAME_FUNC_OFFSET( 751, gl_dispatch_stub_68, gl_dispatch_stub_68, NULL, 68), + NAME_FUNC_OFFSET( 765, gl_dispatch_stub_69, gl_dispatch_stub_69, NULL, 69), + NAME_FUNC_OFFSET( 780, gl_dispatch_stub_70, gl_dispatch_stub_70, NULL, 70), + NAME_FUNC_OFFSET( 794, gl_dispatch_stub_71, gl_dispatch_stub_71, NULL, 71), + NAME_FUNC_OFFSET( 809, gl_dispatch_stub_72, gl_dispatch_stub_72, NULL, 72), + NAME_FUNC_OFFSET( 823, gl_dispatch_stub_73, gl_dispatch_stub_73, NULL, 73), + NAME_FUNC_OFFSET( 838, gl_dispatch_stub_74, gl_dispatch_stub_74, NULL, 74), + NAME_FUNC_OFFSET( 852, gl_dispatch_stub_75, gl_dispatch_stub_75, NULL, 75), + NAME_FUNC_OFFSET( 867, gl_dispatch_stub_76, gl_dispatch_stub_76, NULL, 76), + NAME_FUNC_OFFSET( 881, gl_dispatch_stub_77, gl_dispatch_stub_77, NULL, 77), + NAME_FUNC_OFFSET( 896, gl_dispatch_stub_78, gl_dispatch_stub_78, NULL, 78), + NAME_FUNC_OFFSET( 910, gl_dispatch_stub_79, gl_dispatch_stub_79, NULL, 79), + NAME_FUNC_OFFSET( 925, gl_dispatch_stub_80, gl_dispatch_stub_80, NULL, 80), + NAME_FUNC_OFFSET( 939, gl_dispatch_stub_81, gl_dispatch_stub_81, NULL, 81), + NAME_FUNC_OFFSET( 954, gl_dispatch_stub_82, gl_dispatch_stub_82, NULL, 82), + NAME_FUNC_OFFSET( 968, gl_dispatch_stub_83, gl_dispatch_stub_83, NULL, 83), + NAME_FUNC_OFFSET( 983, gl_dispatch_stub_84, gl_dispatch_stub_84, NULL, 84), + NAME_FUNC_OFFSET( 997, gl_dispatch_stub_85, gl_dispatch_stub_85, NULL, 85), + NAME_FUNC_OFFSET( 1012, gl_dispatch_stub_86, gl_dispatch_stub_86, NULL, 86), + NAME_FUNC_OFFSET( 1020, gl_dispatch_stub_87, gl_dispatch_stub_87, NULL, 87), + NAME_FUNC_OFFSET( 1029, gl_dispatch_stub_88, gl_dispatch_stub_88, NULL, 88), + NAME_FUNC_OFFSET( 1037, gl_dispatch_stub_89, gl_dispatch_stub_89, NULL, 89), + NAME_FUNC_OFFSET( 1046, gl_dispatch_stub_90, gl_dispatch_stub_90, NULL, 90), + NAME_FUNC_OFFSET( 1054, gl_dispatch_stub_91, gl_dispatch_stub_91, NULL, 91), + NAME_FUNC_OFFSET( 1063, gl_dispatch_stub_92, gl_dispatch_stub_92, NULL, 92), + NAME_FUNC_OFFSET( 1071, gl_dispatch_stub_93, gl_dispatch_stub_93, NULL, 93), + NAME_FUNC_OFFSET( 1080, gl_dispatch_stub_94, gl_dispatch_stub_94, NULL, 94), + NAME_FUNC_OFFSET( 1093, gl_dispatch_stub_95, gl_dispatch_stub_95, NULL, 95), + NAME_FUNC_OFFSET( 1107, gl_dispatch_stub_96, gl_dispatch_stub_96, NULL, 96), + NAME_FUNC_OFFSET( 1120, gl_dispatch_stub_97, gl_dispatch_stub_97, NULL, 97), + NAME_FUNC_OFFSET( 1134, gl_dispatch_stub_98, gl_dispatch_stub_98, NULL, 98), + NAME_FUNC_OFFSET( 1147, gl_dispatch_stub_99, gl_dispatch_stub_99, NULL, 99), + NAME_FUNC_OFFSET( 1161, gl_dispatch_stub_100, gl_dispatch_stub_100, NULL, 100), + NAME_FUNC_OFFSET( 1174, gl_dispatch_stub_101, gl_dispatch_stub_101, NULL, 101), + NAME_FUNC_OFFSET( 1188, gl_dispatch_stub_102, gl_dispatch_stub_102, NULL, 102), + NAME_FUNC_OFFSET( 1201, gl_dispatch_stub_103, gl_dispatch_stub_103, NULL, 103), + NAME_FUNC_OFFSET( 1215, gl_dispatch_stub_104, gl_dispatch_stub_104, NULL, 104), + NAME_FUNC_OFFSET( 1228, gl_dispatch_stub_105, gl_dispatch_stub_105, NULL, 105), + NAME_FUNC_OFFSET( 1242, gl_dispatch_stub_106, gl_dispatch_stub_106, NULL, 106), + NAME_FUNC_OFFSET( 1255, gl_dispatch_stub_107, gl_dispatch_stub_107, NULL, 107), + NAME_FUNC_OFFSET( 1269, gl_dispatch_stub_108, gl_dispatch_stub_108, NULL, 108), + NAME_FUNC_OFFSET( 1282, gl_dispatch_stub_109, gl_dispatch_stub_109, NULL, 109), + NAME_FUNC_OFFSET( 1296, gl_dispatch_stub_110, gl_dispatch_stub_110, NULL, 110), + NAME_FUNC_OFFSET( 1309, gl_dispatch_stub_111, gl_dispatch_stub_111, NULL, 111), + NAME_FUNC_OFFSET( 1323, gl_dispatch_stub_112, gl_dispatch_stub_112, NULL, 112), + NAME_FUNC_OFFSET( 1336, gl_dispatch_stub_113, gl_dispatch_stub_113, NULL, 113), + NAME_FUNC_OFFSET( 1350, gl_dispatch_stub_114, gl_dispatch_stub_114, NULL, 114), + NAME_FUNC_OFFSET( 1363, gl_dispatch_stub_115, gl_dispatch_stub_115, NULL, 115), + NAME_FUNC_OFFSET( 1377, gl_dispatch_stub_116, gl_dispatch_stub_116, NULL, 116), + NAME_FUNC_OFFSET( 1390, gl_dispatch_stub_117, gl_dispatch_stub_117, NULL, 117), + NAME_FUNC_OFFSET( 1404, gl_dispatch_stub_118, gl_dispatch_stub_118, NULL, 118), + NAME_FUNC_OFFSET( 1417, gl_dispatch_stub_119, gl_dispatch_stub_119, NULL, 119), + NAME_FUNC_OFFSET( 1431, gl_dispatch_stub_120, gl_dispatch_stub_120, NULL, 120), + NAME_FUNC_OFFSET( 1444, gl_dispatch_stub_121, gl_dispatch_stub_121, NULL, 121), + NAME_FUNC_OFFSET( 1458, gl_dispatch_stub_122, gl_dispatch_stub_122, NULL, 122), + NAME_FUNC_OFFSET( 1471, gl_dispatch_stub_123, gl_dispatch_stub_123, NULL, 123), + NAME_FUNC_OFFSET( 1485, gl_dispatch_stub_124, gl_dispatch_stub_124, NULL, 124), + NAME_FUNC_OFFSET( 1498, gl_dispatch_stub_125, gl_dispatch_stub_125, NULL, 125), + NAME_FUNC_OFFSET( 1512, gl_dispatch_stub_126, gl_dispatch_stub_126, NULL, 126), + NAME_FUNC_OFFSET( 1523, gl_dispatch_stub_127, gl_dispatch_stub_127, NULL, 127), + NAME_FUNC_OFFSET( 1535, gl_dispatch_stub_128, gl_dispatch_stub_128, NULL, 128), + NAME_FUNC_OFFSET( 1546, gl_dispatch_stub_129, gl_dispatch_stub_129, NULL, 129), + NAME_FUNC_OFFSET( 1558, gl_dispatch_stub_130, gl_dispatch_stub_130, NULL, 130), + NAME_FUNC_OFFSET( 1569, gl_dispatch_stub_131, gl_dispatch_stub_131, NULL, 131), + NAME_FUNC_OFFSET( 1581, gl_dispatch_stub_132, gl_dispatch_stub_132, NULL, 132), + NAME_FUNC_OFFSET( 1592, gl_dispatch_stub_133, gl_dispatch_stub_133, NULL, 133), + NAME_FUNC_OFFSET( 1604, gl_dispatch_stub_134, gl_dispatch_stub_134, NULL, 134), + NAME_FUNC_OFFSET( 1615, gl_dispatch_stub_135, gl_dispatch_stub_135, NULL, 135), + NAME_FUNC_OFFSET( 1627, gl_dispatch_stub_136, gl_dispatch_stub_136, NULL, 136), + NAME_FUNC_OFFSET( 1638, gl_dispatch_stub_137, gl_dispatch_stub_137, NULL, 137), + NAME_FUNC_OFFSET( 1650, gl_dispatch_stub_138, gl_dispatch_stub_138, NULL, 138), + NAME_FUNC_OFFSET( 1661, gl_dispatch_stub_139, gl_dispatch_stub_139, NULL, 139), + NAME_FUNC_OFFSET( 1673, gl_dispatch_stub_140, gl_dispatch_stub_140, NULL, 140), + NAME_FUNC_OFFSET( 1684, gl_dispatch_stub_141, gl_dispatch_stub_141, NULL, 141), + NAME_FUNC_OFFSET( 1696, gl_dispatch_stub_142, gl_dispatch_stub_142, NULL, 142), + NAME_FUNC_OFFSET( 1707, gl_dispatch_stub_143, gl_dispatch_stub_143, NULL, 143), + NAME_FUNC_OFFSET( 1719, gl_dispatch_stub_144, gl_dispatch_stub_144, NULL, 144), + NAME_FUNC_OFFSET( 1730, gl_dispatch_stub_145, gl_dispatch_stub_145, NULL, 145), + NAME_FUNC_OFFSET( 1742, gl_dispatch_stub_146, gl_dispatch_stub_146, NULL, 146), + NAME_FUNC_OFFSET( 1753, gl_dispatch_stub_147, gl_dispatch_stub_147, NULL, 147), + NAME_FUNC_OFFSET( 1765, gl_dispatch_stub_148, gl_dispatch_stub_148, NULL, 148), + NAME_FUNC_OFFSET( 1776, gl_dispatch_stub_149, gl_dispatch_stub_149, NULL, 149), + NAME_FUNC_OFFSET( 1788, gl_dispatch_stub_150, gl_dispatch_stub_150, NULL, 150), + NAME_FUNC_OFFSET( 1800, gl_dispatch_stub_151, gl_dispatch_stub_151, NULL, 151), + NAME_FUNC_OFFSET( 1816, glCullFace, glCullFace, NULL, 152), + NAME_FUNC_OFFSET( 1827, glFogf, glFogf, NULL, 153), + NAME_FUNC_OFFSET( 1834, glFogfv, glFogfv, NULL, 154), + NAME_FUNC_OFFSET( 1842, gl_dispatch_stub_155, gl_dispatch_stub_155, NULL, 155), + NAME_FUNC_OFFSET( 1849, gl_dispatch_stub_156, gl_dispatch_stub_156, NULL, 156), + NAME_FUNC_OFFSET( 1857, glFrontFace, glFrontFace, NULL, 157), + NAME_FUNC_OFFSET( 1869, glHint, glHint, NULL, 158), + NAME_FUNC_OFFSET( 1876, glLightf, glLightf, NULL, 159), + NAME_FUNC_OFFSET( 1885, glLightfv, glLightfv, NULL, 160), + NAME_FUNC_OFFSET( 1895, gl_dispatch_stub_161, gl_dispatch_stub_161, NULL, 161), + NAME_FUNC_OFFSET( 1904, gl_dispatch_stub_162, gl_dispatch_stub_162, NULL, 162), + NAME_FUNC_OFFSET( 1914, glLightModelf, glLightModelf, NULL, 163), + NAME_FUNC_OFFSET( 1928, glLightModelfv, glLightModelfv, NULL, 164), + NAME_FUNC_OFFSET( 1943, gl_dispatch_stub_165, gl_dispatch_stub_165, NULL, 165), + NAME_FUNC_OFFSET( 1957, gl_dispatch_stub_166, gl_dispatch_stub_166, NULL, 166), + NAME_FUNC_OFFSET( 1972, gl_dispatch_stub_167, gl_dispatch_stub_167, NULL, 167), + NAME_FUNC_OFFSET( 1986, glLineWidth, glLineWidth, NULL, 168), + NAME_FUNC_OFFSET( 1998, glMaterialf, glMaterialf, NULL, 169), + NAME_FUNC_OFFSET( 2010, glMaterialfv, glMaterialfv, NULL, 170), + NAME_FUNC_OFFSET( 2023, gl_dispatch_stub_171, gl_dispatch_stub_171, NULL, 171), + NAME_FUNC_OFFSET( 2035, gl_dispatch_stub_172, gl_dispatch_stub_172, NULL, 172), + NAME_FUNC_OFFSET( 2048, glPointSize, glPointSize, NULL, 173), + NAME_FUNC_OFFSET( 2060, gl_dispatch_stub_174, gl_dispatch_stub_174, NULL, 174), + NAME_FUNC_OFFSET( 2074, gl_dispatch_stub_175, gl_dispatch_stub_175, NULL, 175), + NAME_FUNC_OFFSET( 2091, glScissor, glScissor, NULL, 176), + NAME_FUNC_OFFSET( 2101, glShadeModel, glShadeModel, NULL, 177), + NAME_FUNC_OFFSET( 2114, glTexParameterf, glTexParameterf, NULL, 178), + NAME_FUNC_OFFSET( 2130, glTexParameterfv, glTexParameterfv, NULL, 179), + NAME_FUNC_OFFSET( 2147, glTexParameteri, glTexParameteri, NULL, 180), + NAME_FUNC_OFFSET( 2163, glTexParameteriv, glTexParameteriv, NULL, 181), + NAME_FUNC_OFFSET( 2180, gl_dispatch_stub_182, gl_dispatch_stub_182, NULL, 182), + NAME_FUNC_OFFSET( 2193, glTexImage2D, glTexImage2D, NULL, 183), + NAME_FUNC_OFFSET( 2206, glTexEnvf, glTexEnvf, NULL, 184), + NAME_FUNC_OFFSET( 2216, glTexEnvfv, glTexEnvfv, NULL, 185), + NAME_FUNC_OFFSET( 2227, glTexEnvi, glTexEnvi, NULL, 186), + NAME_FUNC_OFFSET( 2237, glTexEnviv, glTexEnviv, NULL, 187), + NAME_FUNC_OFFSET( 2248, gl_dispatch_stub_188, gl_dispatch_stub_188, NULL, 188), + NAME_FUNC_OFFSET( 2258, gl_dispatch_stub_189, gl_dispatch_stub_189, NULL, 189), + NAME_FUNC_OFFSET( 2269, glTexGenfOES, glTexGenfOES, NULL, 190), + NAME_FUNC_OFFSET( 2282, glTexGenfvOES, glTexGenfvOES, NULL, 191), + NAME_FUNC_OFFSET( 2296, glTexGeniOES, glTexGeniOES, NULL, 192), + NAME_FUNC_OFFSET( 2309, glTexGenivOES, glTexGenivOES, NULL, 193), + NAME_FUNC_OFFSET( 2323, gl_dispatch_stub_194, gl_dispatch_stub_194, NULL, 194), + NAME_FUNC_OFFSET( 2340, gl_dispatch_stub_195, gl_dispatch_stub_195, NULL, 195), + NAME_FUNC_OFFSET( 2355, gl_dispatch_stub_196, gl_dispatch_stub_196, NULL, 196), + NAME_FUNC_OFFSET( 2368, gl_dispatch_stub_197, gl_dispatch_stub_197, NULL, 197), + NAME_FUNC_OFFSET( 2380, gl_dispatch_stub_198, gl_dispatch_stub_198, NULL, 198), + NAME_FUNC_OFFSET( 2391, gl_dispatch_stub_199, gl_dispatch_stub_199, NULL, 199), + NAME_FUNC_OFFSET( 2405, gl_dispatch_stub_200, gl_dispatch_stub_200, NULL, 200), + NAME_FUNC_OFFSET( 2415, gl_dispatch_stub_201, gl_dispatch_stub_201, NULL, 201), + NAME_FUNC_OFFSET( 2426, gl_dispatch_stub_202, gl_dispatch_stub_202, NULL, 202), + NAME_FUNC_OFFSET( 2439, glClear, glClear, NULL, 203), + NAME_FUNC_OFFSET( 2447, gl_dispatch_stub_204, gl_dispatch_stub_204, NULL, 204), + NAME_FUNC_OFFSET( 2460, gl_dispatch_stub_205, gl_dispatch_stub_205, NULL, 205), + NAME_FUNC_OFFSET( 2473, glClearColor, glClearColor, NULL, 206), + NAME_FUNC_OFFSET( 2486, glClearStencil, glClearStencil, NULL, 207), + NAME_FUNC_OFFSET( 2501, gl_dispatch_stub_208, gl_dispatch_stub_208, NULL, 208), + NAME_FUNC_OFFSET( 2514, glStencilMask, glStencilMask, NULL, 209), + NAME_FUNC_OFFSET( 2528, glColorMask, glColorMask, NULL, 210), + NAME_FUNC_OFFSET( 2540, glDepthMask, glDepthMask, NULL, 211), + NAME_FUNC_OFFSET( 2552, gl_dispatch_stub_212, gl_dispatch_stub_212, NULL, 212), + NAME_FUNC_OFFSET( 2564, gl_dispatch_stub_213, gl_dispatch_stub_213, NULL, 213), + NAME_FUNC_OFFSET( 2572, glDisable, glDisable, NULL, 214), + NAME_FUNC_OFFSET( 2582, glEnable, glEnable, NULL, 215), + NAME_FUNC_OFFSET( 2591, glFinish, glFinish, NULL, 216), + NAME_FUNC_OFFSET( 2600, glFlush, glFlush, NULL, 217), + NAME_FUNC_OFFSET( 2608, gl_dispatch_stub_218, gl_dispatch_stub_218, NULL, 218), + NAME_FUNC_OFFSET( 2620, gl_dispatch_stub_219, gl_dispatch_stub_219, NULL, 219), + NAME_FUNC_OFFSET( 2633, gl_dispatch_stub_220, gl_dispatch_stub_220, NULL, 220), + NAME_FUNC_OFFSET( 2641, gl_dispatch_stub_221, gl_dispatch_stub_221, NULL, 221), + NAME_FUNC_OFFSET( 2649, gl_dispatch_stub_222, gl_dispatch_stub_222, NULL, 222), + NAME_FUNC_OFFSET( 2657, gl_dispatch_stub_223, gl_dispatch_stub_223, NULL, 223), + NAME_FUNC_OFFSET( 2665, gl_dispatch_stub_224, gl_dispatch_stub_224, NULL, 224), + NAME_FUNC_OFFSET( 2677, gl_dispatch_stub_225, gl_dispatch_stub_225, NULL, 225), + NAME_FUNC_OFFSET( 2689, gl_dispatch_stub_226, gl_dispatch_stub_226, NULL, 226), + NAME_FUNC_OFFSET( 2701, gl_dispatch_stub_227, gl_dispatch_stub_227, NULL, 227), + NAME_FUNC_OFFSET( 2713, gl_dispatch_stub_228, gl_dispatch_stub_228, NULL, 228), + NAME_FUNC_OFFSET( 2727, gl_dispatch_stub_229, gl_dispatch_stub_229, NULL, 229), + NAME_FUNC_OFFSET( 2742, gl_dispatch_stub_230, gl_dispatch_stub_230, NULL, 230), + NAME_FUNC_OFFSET( 2756, gl_dispatch_stub_231, gl_dispatch_stub_231, NULL, 231), + NAME_FUNC_OFFSET( 2771, gl_dispatch_stub_232, gl_dispatch_stub_232, NULL, 232), + NAME_FUNC_OFFSET( 2785, gl_dispatch_stub_233, gl_dispatch_stub_233, NULL, 233), + NAME_FUNC_OFFSET( 2800, gl_dispatch_stub_234, gl_dispatch_stub_234, NULL, 234), + NAME_FUNC_OFFSET( 2814, gl_dispatch_stub_235, gl_dispatch_stub_235, NULL, 235), + NAME_FUNC_OFFSET( 2829, gl_dispatch_stub_236, gl_dispatch_stub_236, NULL, 236), + NAME_FUNC_OFFSET( 2841, gl_dispatch_stub_237, gl_dispatch_stub_237, NULL, 237), + NAME_FUNC_OFFSET( 2854, gl_dispatch_stub_238, gl_dispatch_stub_238, NULL, 238), + NAME_FUNC_OFFSET( 2866, gl_dispatch_stub_239, gl_dispatch_stub_239, NULL, 239), + NAME_FUNC_OFFSET( 2879, glAlphaFunc, glAlphaFunc, NULL, 240), + NAME_FUNC_OFFSET( 2891, glBlendFunc, glBlendFunc, NULL, 241), + NAME_FUNC_OFFSET( 2903, glLogicOp, glLogicOp, NULL, 242), + NAME_FUNC_OFFSET( 2913, glStencilFunc, glStencilFunc, NULL, 243), + NAME_FUNC_OFFSET( 2927, glStencilOp, glStencilOp, NULL, 244), + NAME_FUNC_OFFSET( 2939, glDepthFunc, glDepthFunc, NULL, 245), + NAME_FUNC_OFFSET( 2951, gl_dispatch_stub_246, gl_dispatch_stub_246, NULL, 246), + NAME_FUNC_OFFSET( 2963, gl_dispatch_stub_247, gl_dispatch_stub_247, NULL, 247), + NAME_FUNC_OFFSET( 2980, gl_dispatch_stub_248, gl_dispatch_stub_248, NULL, 248), + NAME_FUNC_OFFSET( 2997, gl_dispatch_stub_249, gl_dispatch_stub_249, NULL, 249), + NAME_FUNC_OFFSET( 3011, glPixelStorei, glPixelStorei, NULL, 250), + NAME_FUNC_OFFSET( 3025, gl_dispatch_stub_251, gl_dispatch_stub_251, NULL, 251), + NAME_FUNC_OFFSET( 3038, gl_dispatch_stub_252, gl_dispatch_stub_252, NULL, 252), + NAME_FUNC_OFFSET( 3052, gl_dispatch_stub_253, gl_dispatch_stub_253, NULL, 253), + NAME_FUNC_OFFSET( 3066, gl_dispatch_stub_254, gl_dispatch_stub_254, NULL, 254), + NAME_FUNC_OFFSET( 3079, gl_dispatch_stub_255, gl_dispatch_stub_255, NULL, 255), + NAME_FUNC_OFFSET( 3092, glReadPixels, glReadPixels, NULL, 256), + NAME_FUNC_OFFSET( 3105, gl_dispatch_stub_257, gl_dispatch_stub_257, NULL, 257), + NAME_FUNC_OFFSET( 3118, glGetBooleanv, glGetBooleanv, NULL, 258), + NAME_FUNC_OFFSET( 3132, gl_dispatch_stub_259, gl_dispatch_stub_259, NULL, 259), + NAME_FUNC_OFFSET( 3147, gl_dispatch_stub_260, gl_dispatch_stub_260, NULL, 260), + NAME_FUNC_OFFSET( 3160, glGetError, glGetError, NULL, 261), + NAME_FUNC_OFFSET( 3171, glGetFloatv, glGetFloatv, NULL, 262), + NAME_FUNC_OFFSET( 3183, glGetIntegerv, glGetIntegerv, NULL, 263), + NAME_FUNC_OFFSET( 3197, glGetLightfv, glGetLightfv, NULL, 264), + NAME_FUNC_OFFSET( 3210, gl_dispatch_stub_265, gl_dispatch_stub_265, NULL, 265), + NAME_FUNC_OFFSET( 3223, gl_dispatch_stub_266, gl_dispatch_stub_266, NULL, 266), + NAME_FUNC_OFFSET( 3234, gl_dispatch_stub_267, gl_dispatch_stub_267, NULL, 267), + NAME_FUNC_OFFSET( 3245, gl_dispatch_stub_268, gl_dispatch_stub_268, NULL, 268), + NAME_FUNC_OFFSET( 3256, glGetMaterialfv, glGetMaterialfv, NULL, 269), + NAME_FUNC_OFFSET( 3272, gl_dispatch_stub_270, gl_dispatch_stub_270, NULL, 270), + NAME_FUNC_OFFSET( 3288, gl_dispatch_stub_271, gl_dispatch_stub_271, NULL, 271), + NAME_FUNC_OFFSET( 3304, gl_dispatch_stub_272, gl_dispatch_stub_272, NULL, 272), + NAME_FUNC_OFFSET( 3321, gl_dispatch_stub_273, gl_dispatch_stub_273, NULL, 273), + NAME_FUNC_OFFSET( 3338, gl_dispatch_stub_274, gl_dispatch_stub_274, NULL, 274), + NAME_FUNC_OFFSET( 3358, glGetString, glGetString, NULL, 275), + NAME_FUNC_OFFSET( 3370, glGetTexEnvfv, glGetTexEnvfv, NULL, 276), + NAME_FUNC_OFFSET( 3384, glGetTexEnviv, glGetTexEnviv, NULL, 277), + NAME_FUNC_OFFSET( 3398, gl_dispatch_stub_278, gl_dispatch_stub_278, NULL, 278), + NAME_FUNC_OFFSET( 3412, glGetTexGenfvOES, glGetTexGenfvOES, NULL, 279), + NAME_FUNC_OFFSET( 3429, glGetTexGenivOES, glGetTexGenivOES, NULL, 280), + NAME_FUNC_OFFSET( 3446, gl_dispatch_stub_281, gl_dispatch_stub_281, NULL, 281), + NAME_FUNC_OFFSET( 3460, glGetTexParameterfv, glGetTexParameterfv, NULL, 282), + NAME_FUNC_OFFSET( 3480, glGetTexParameteriv, glGetTexParameteriv, NULL, 283), + NAME_FUNC_OFFSET( 3500, gl_dispatch_stub_284, gl_dispatch_stub_284, NULL, 284), + NAME_FUNC_OFFSET( 3525, gl_dispatch_stub_285, gl_dispatch_stub_285, NULL, 285), + NAME_FUNC_OFFSET( 3550, glIsEnabled, glIsEnabled, NULL, 286), + NAME_FUNC_OFFSET( 3562, gl_dispatch_stub_287, gl_dispatch_stub_287, NULL, 287), + NAME_FUNC_OFFSET( 3571, gl_dispatch_stub_288, gl_dispatch_stub_288, NULL, 288), + NAME_FUNC_OFFSET( 3584, gl_dispatch_stub_289, gl_dispatch_stub_289, NULL, 289), + NAME_FUNC_OFFSET( 3594, glLoadIdentity, glLoadIdentity, NULL, 290), + NAME_FUNC_OFFSET( 3609, glLoadMatrixf, glLoadMatrixf, NULL, 291), + NAME_FUNC_OFFSET( 3623, gl_dispatch_stub_292, gl_dispatch_stub_292, NULL, 292), + NAME_FUNC_OFFSET( 3637, glMatrixMode, glMatrixMode, NULL, 293), + NAME_FUNC_OFFSET( 3650, glMultMatrixf, glMultMatrixf, NULL, 294), + NAME_FUNC_OFFSET( 3664, gl_dispatch_stub_295, gl_dispatch_stub_295, NULL, 295), + NAME_FUNC_OFFSET( 3678, gl_dispatch_stub_296, gl_dispatch_stub_296, NULL, 296), + NAME_FUNC_OFFSET( 3686, glPopMatrix, glPopMatrix, NULL, 297), + NAME_FUNC_OFFSET( 3698, glPushMatrix, glPushMatrix, NULL, 298), + NAME_FUNC_OFFSET( 3711, gl_dispatch_stub_299, gl_dispatch_stub_299, NULL, 299), + NAME_FUNC_OFFSET( 3721, glRotatef, glRotatef, NULL, 300), + NAME_FUNC_OFFSET( 3731, gl_dispatch_stub_301, gl_dispatch_stub_301, NULL, 301), + NAME_FUNC_OFFSET( 3740, glScalef, glScalef, NULL, 302), + NAME_FUNC_OFFSET( 3749, gl_dispatch_stub_303, gl_dispatch_stub_303, NULL, 303), + NAME_FUNC_OFFSET( 3762, glTranslatef, glTranslatef, NULL, 304), + NAME_FUNC_OFFSET( 3775, glViewport, glViewport, NULL, 305), + NAME_FUNC_OFFSET( 3786, gl_dispatch_stub_306, gl_dispatch_stub_306, NULL, 306), + NAME_FUNC_OFFSET( 3801, glBindTexture, glBindTexture, NULL, 307), + NAME_FUNC_OFFSET( 3815, glColorPointer, glColorPointer, NULL, 308), + NAME_FUNC_OFFSET( 3830, glDisableClientState, glDisableClientState, NULL, 309), + NAME_FUNC_OFFSET( 3851, glDrawArrays, glDrawArrays, NULL, 310), + NAME_FUNC_OFFSET( 3864, glDrawElements, glDrawElements, NULL, 311), + NAME_FUNC_OFFSET( 3879, gl_dispatch_stub_312, gl_dispatch_stub_312, NULL, 312), + NAME_FUNC_OFFSET( 3897, glEnableClientState, glEnableClientState, NULL, 313), + NAME_FUNC_OFFSET( 3917, gl_dispatch_stub_314, gl_dispatch_stub_314, NULL, 314), + NAME_FUNC_OFFSET( 3932, gl_dispatch_stub_315, gl_dispatch_stub_315, NULL, 315), + NAME_FUNC_OFFSET( 3942, gl_dispatch_stub_316, gl_dispatch_stub_316, NULL, 316), + NAME_FUNC_OFFSET( 3953, gl_dispatch_stub_317, gl_dispatch_stub_317, NULL, 317), + NAME_FUNC_OFFSET( 3973, glNormalPointer, glNormalPointer, NULL, 318), + NAME_FUNC_OFFSET( 3989, glPolygonOffset, glPolygonOffset, NULL, 319), + NAME_FUNC_OFFSET( 4005, glTexCoordPointer, glTexCoordPointer, NULL, 320), + NAME_FUNC_OFFSET( 4023, glVertexPointer, glVertexPointer, NULL, 321), + NAME_FUNC_OFFSET( 4039, gl_dispatch_stub_322, gl_dispatch_stub_322, NULL, 322), + NAME_FUNC_OFFSET( 4061, gl_dispatch_stub_323, gl_dispatch_stub_323, NULL, 323), + NAME_FUNC_OFFSET( 4078, glCopyTexImage2D, glCopyTexImage2D, NULL, 324), + NAME_FUNC_OFFSET( 4095, gl_dispatch_stub_325, gl_dispatch_stub_325, NULL, 325), + NAME_FUNC_OFFSET( 4115, glCopyTexSubImage2D, glCopyTexSubImage2D, NULL, 326), + NAME_FUNC_OFFSET( 4135, glDeleteTextures, glDeleteTextures, NULL, 327), + NAME_FUNC_OFFSET( 4152, glGenTextures, glGenTextures, NULL, 328), + NAME_FUNC_OFFSET( 4166, glGetPointerv, glGetPointerv, NULL, 329), + NAME_FUNC_OFFSET( 4180, glIsTexture, glIsTexture, NULL, 330), + NAME_FUNC_OFFSET( 4192, gl_dispatch_stub_331, gl_dispatch_stub_331, NULL, 331), + NAME_FUNC_OFFSET( 4213, gl_dispatch_stub_332, gl_dispatch_stub_332, NULL, 332), + NAME_FUNC_OFFSET( 4229, glTexSubImage2D, glTexSubImage2D, NULL, 333), + NAME_FUNC_OFFSET( 4245, gl_dispatch_stub_334, gl_dispatch_stub_334, NULL, 334), + NAME_FUNC_OFFSET( 4263, gl_dispatch_stub_335, gl_dispatch_stub_335, NULL, 335), + NAME_FUNC_OFFSET( 4282, gl_dispatch_stub_336, gl_dispatch_stub_336, NULL, 336), + NAME_FUNC_OFFSET( 4295, glBlendEquationOES, glBlendEquationOES, NULL, 337), + NAME_FUNC_OFFSET( 4314, gl_dispatch_stub_338, gl_dispatch_stub_338, NULL, 338), + NAME_FUNC_OFFSET( 4334, gl_dispatch_stub_339, gl_dispatch_stub_339, NULL, 339), + NAME_FUNC_OFFSET( 4347, gl_dispatch_stub_340, gl_dispatch_stub_340, NULL, 340), + NAME_FUNC_OFFSET( 4371, gl_dispatch_stub_341, gl_dispatch_stub_341, NULL, 341), + NAME_FUNC_OFFSET( 4395, gl_dispatch_stub_342, gl_dispatch_stub_342, NULL, 342), + NAME_FUNC_OFFSET( 4412, gl_dispatch_stub_343, gl_dispatch_stub_343, NULL, 343), + NAME_FUNC_OFFSET( 4428, gl_dispatch_stub_344, gl_dispatch_stub_344, NULL, 344), + NAME_FUNC_OFFSET( 4455, gl_dispatch_stub_345, gl_dispatch_stub_345, NULL, 345), + NAME_FUNC_OFFSET( 4482, gl_dispatch_stub_346, gl_dispatch_stub_346, NULL, 346), + NAME_FUNC_OFFSET( 4498, gl_dispatch_stub_347, gl_dispatch_stub_347, NULL, 347), + NAME_FUNC_OFFSET( 4518, gl_dispatch_stub_348, gl_dispatch_stub_348, NULL, 348), + NAME_FUNC_OFFSET( 4540, gl_dispatch_stub_349, gl_dispatch_stub_349, NULL, 349), + NAME_FUNC_OFFSET( 4562, gl_dispatch_stub_350, gl_dispatch_stub_350, NULL, 350), + NAME_FUNC_OFFSET( 4586, gl_dispatch_stub_351, gl_dispatch_stub_351, NULL, 351), + NAME_FUNC_OFFSET( 4611, gl_dispatch_stub_352, gl_dispatch_stub_352, NULL, 352), + NAME_FUNC_OFFSET( 4635, gl_dispatch_stub_353, gl_dispatch_stub_353, NULL, 353), + NAME_FUNC_OFFSET( 4660, gl_dispatch_stub_354, gl_dispatch_stub_354, NULL, 354), + NAME_FUNC_OFFSET( 4686, gl_dispatch_stub_355, gl_dispatch_stub_355, NULL, 355), + NAME_FUNC_OFFSET( 4712, gl_dispatch_stub_356, gl_dispatch_stub_356, NULL, 356), + NAME_FUNC_OFFSET( 4735, gl_dispatch_stub_357, gl_dispatch_stub_357, NULL, 357), + NAME_FUNC_OFFSET( 4763, gl_dispatch_stub_358, gl_dispatch_stub_358, NULL, 358), + NAME_FUNC_OFFSET( 4791, gl_dispatch_stub_359, gl_dispatch_stub_359, NULL, 359), + NAME_FUNC_OFFSET( 4812, gl_dispatch_stub_360, gl_dispatch_stub_360, NULL, 360), + NAME_FUNC_OFFSET( 4832, gl_dispatch_stub_361, gl_dispatch_stub_361, NULL, 361), + NAME_FUNC_OFFSET( 4847, gl_dispatch_stub_362, gl_dispatch_stub_362, NULL, 362), + NAME_FUNC_OFFSET( 4873, gl_dispatch_stub_363, gl_dispatch_stub_363, NULL, 363), + NAME_FUNC_OFFSET( 4899, gl_dispatch_stub_364, gl_dispatch_stub_364, NULL, 364), + NAME_FUNC_OFFSET( 4911, gl_dispatch_stub_365, gl_dispatch_stub_365, NULL, 365), + NAME_FUNC_OFFSET( 4934, gl_dispatch_stub_366, gl_dispatch_stub_366, NULL, 366), + NAME_FUNC_OFFSET( 4957, gl_dispatch_stub_367, gl_dispatch_stub_367, NULL, 367), + NAME_FUNC_OFFSET( 4969, gl_dispatch_stub_368, gl_dispatch_stub_368, NULL, 368), + NAME_FUNC_OFFSET( 4978, gl_dispatch_stub_369, gl_dispatch_stub_369, NULL, 369), + NAME_FUNC_OFFSET( 4995, gl_dispatch_stub_370, gl_dispatch_stub_370, NULL, 370), + NAME_FUNC_OFFSET( 5009, gl_dispatch_stub_371, gl_dispatch_stub_371, NULL, 371), + NAME_FUNC_OFFSET( 5022, gl_dispatch_stub_372, gl_dispatch_stub_372, NULL, 372), + NAME_FUNC_OFFSET( 5038, gl_dispatch_stub_373, gl_dispatch_stub_373, NULL, 373), + NAME_FUNC_OFFSET( 5058, glActiveTexture, glActiveTexture, NULL, 374), + NAME_FUNC_OFFSET( 5074, glClientActiveTexture, glClientActiveTexture, NULL, 375), + NAME_FUNC_OFFSET( 5096, gl_dispatch_stub_376, gl_dispatch_stub_376, NULL, 376), + NAME_FUNC_OFFSET( 5117, gl_dispatch_stub_377, gl_dispatch_stub_377, NULL, 377), + NAME_FUNC_OFFSET( 5139, gl_dispatch_stub_378, gl_dispatch_stub_378, NULL, 378), + NAME_FUNC_OFFSET( 5160, gl_dispatch_stub_379, gl_dispatch_stub_379, NULL, 379), + NAME_FUNC_OFFSET( 5182, gl_dispatch_stub_380, gl_dispatch_stub_380, NULL, 380), + NAME_FUNC_OFFSET( 5203, gl_dispatch_stub_381, gl_dispatch_stub_381, NULL, 381), + NAME_FUNC_OFFSET( 5225, gl_dispatch_stub_382, gl_dispatch_stub_382, NULL, 382), + NAME_FUNC_OFFSET( 5246, gl_dispatch_stub_383, gl_dispatch_stub_383, NULL, 383), + NAME_FUNC_OFFSET( 5268, gl_dispatch_stub_384, gl_dispatch_stub_384, NULL, 384), + NAME_FUNC_OFFSET( 5289, gl_dispatch_stub_385, gl_dispatch_stub_385, NULL, 385), + NAME_FUNC_OFFSET( 5311, gl_dispatch_stub_386, gl_dispatch_stub_386, NULL, 386), + NAME_FUNC_OFFSET( 5332, gl_dispatch_stub_387, gl_dispatch_stub_387, NULL, 387), + NAME_FUNC_OFFSET( 5354, gl_dispatch_stub_388, gl_dispatch_stub_388, NULL, 388), + NAME_FUNC_OFFSET( 5375, gl_dispatch_stub_389, gl_dispatch_stub_389, NULL, 389), + NAME_FUNC_OFFSET( 5397, gl_dispatch_stub_390, gl_dispatch_stub_390, NULL, 390), + NAME_FUNC_OFFSET( 5418, gl_dispatch_stub_391, gl_dispatch_stub_391, NULL, 391), + NAME_FUNC_OFFSET( 5440, gl_dispatch_stub_392, gl_dispatch_stub_392, NULL, 392), + NAME_FUNC_OFFSET( 5461, gl_dispatch_stub_393, gl_dispatch_stub_393, NULL, 393), + NAME_FUNC_OFFSET( 5483, gl_dispatch_stub_394, gl_dispatch_stub_394, NULL, 394), + NAME_FUNC_OFFSET( 5504, gl_dispatch_stub_395, gl_dispatch_stub_395, NULL, 395), + NAME_FUNC_OFFSET( 5526, gl_dispatch_stub_396, gl_dispatch_stub_396, NULL, 396), + NAME_FUNC_OFFSET( 5547, gl_dispatch_stub_397, gl_dispatch_stub_397, NULL, 397), + NAME_FUNC_OFFSET( 5569, gl_dispatch_stub_398, gl_dispatch_stub_398, NULL, 398), + NAME_FUNC_OFFSET( 5590, gl_dispatch_stub_399, gl_dispatch_stub_399, NULL, 399), + NAME_FUNC_OFFSET( 5612, gl_dispatch_stub_400, gl_dispatch_stub_400, NULL, 400), + NAME_FUNC_OFFSET( 5633, gl_dispatch_stub_401, gl_dispatch_stub_401, NULL, 401), + NAME_FUNC_OFFSET( 5655, glMultiTexCoord4f, glMultiTexCoord4f, NULL, 402), + NAME_FUNC_OFFSET( 5673, gl_dispatch_stub_403, gl_dispatch_stub_403, NULL, 403), + NAME_FUNC_OFFSET( 5695, gl_dispatch_stub_404, gl_dispatch_stub_404, NULL, 404), + NAME_FUNC_OFFSET( 5716, gl_dispatch_stub_405, gl_dispatch_stub_405, NULL, 405), + NAME_FUNC_OFFSET( 5738, gl_dispatch_stub_406, gl_dispatch_stub_406, NULL, 406), + NAME_FUNC_OFFSET( 5759, gl_dispatch_stub_407, gl_dispatch_stub_407, NULL, 407), + NAME_FUNC_OFFSET( 5781, glBlendEquationSeparateOES, glBlendEquationSeparateOES, NULL, 408), + NAME_FUNC_OFFSET( 5808, glBlendFuncSeparateOES, glBlendFuncSeparateOES, NULL, 409), + NAME_FUNC_OFFSET( 5831, glDrawTexfOES, glDrawTexfOES, NULL, 410), + NAME_FUNC_OFFSET( 5845, glDrawTexfvOES, glDrawTexfvOES, NULL, 411), + NAME_FUNC_OFFSET( 5860, glDrawTexiOES, glDrawTexiOES, NULL, 412), + NAME_FUNC_OFFSET( 5874, glDrawTexivOES, glDrawTexivOES, NULL, 413), + NAME_FUNC_OFFSET( 5889, glDrawTexsOES, glDrawTexsOES, NULL, 414), + NAME_FUNC_OFFSET( 5903, glDrawTexsvOES, glDrawTexsvOES, NULL, 415), + NAME_FUNC_OFFSET( 5918, glDrawTexxOES, glDrawTexxOES, NULL, 416), + NAME_FUNC_OFFSET( 5932, glDrawTexxvOES, glDrawTexxvOES, NULL, 417), + NAME_FUNC_OFFSET( 5947, glBindFramebufferOES, glBindFramebufferOES, NULL, 418), + NAME_FUNC_OFFSET( 5968, glBindRenderbufferOES, glBindRenderbufferOES, NULL, 419), + NAME_FUNC_OFFSET( 5990, glCheckFramebufferStatusOES, glCheckFramebufferStatusOES, NULL, 420), + NAME_FUNC_OFFSET( 6018, glDeleteFramebuffersOES, glDeleteFramebuffersOES, NULL, 421), + NAME_FUNC_OFFSET( 6042, glDeleteRenderbuffersOES, glDeleteRenderbuffersOES, NULL, 422), + NAME_FUNC_OFFSET( 6067, glFramebufferRenderbufferOES, glFramebufferRenderbufferOES, NULL, 423), + NAME_FUNC_OFFSET( 6096, glFramebufferTexture2DOES, glFramebufferTexture2DOES, NULL, 424), + NAME_FUNC_OFFSET( 6122, glGenFramebuffersOES, glGenFramebuffersOES, NULL, 425), + NAME_FUNC_OFFSET( 6143, glGenRenderbuffersOES, glGenRenderbuffersOES, NULL, 426), + NAME_FUNC_OFFSET( 6165, glGenerateMipmapOES, glGenerateMipmapOES, NULL, 427), + NAME_FUNC_OFFSET( 6185, glGetFramebufferAttachmentParameterivOES, glGetFramebufferAttachmentParameterivOES, NULL, 428), + NAME_FUNC_OFFSET( 6226, glGetRenderbufferParameterivOES, glGetRenderbufferParameterivOES, NULL, 429), + NAME_FUNC_OFFSET( 6258, glIsFramebufferOES, glIsFramebufferOES, NULL, 430), + NAME_FUNC_OFFSET( 6277, glIsRenderbufferOES, glIsRenderbufferOES, NULL, 431), + NAME_FUNC_OFFSET( 6297, glRenderbufferStorageOES, glRenderbufferStorageOES, NULL, 432), + NAME_FUNC_OFFSET( 6322, glPointSizePointerOES, glPointSizePointerOES, NULL, 433), + NAME_FUNC_OFFSET( 6344, glQueryMatrixxOES, glQueryMatrixxOES, NULL, 434), + NAME_FUNC_OFFSET( 6362, glGetTexGenxvOES, glGetTexGenxvOES, NULL, 435), + NAME_FUNC_OFFSET( 6379, glTexGenxOES, glTexGenxOES, NULL, 436), + NAME_FUNC_OFFSET( 6392, glTexGenxvOES, glTexGenxvOES, NULL, 437), + NAME_FUNC_OFFSET( 6406, glGetBufferPointervOES, glGetBufferPointervOES, NULL, 438), + NAME_FUNC_OFFSET( 6429, glMapBufferOES, glMapBufferOES, NULL, 439), + NAME_FUNC_OFFSET( 6444, glUnmapBufferOES, glUnmapBufferOES, NULL, 440), + NAME_FUNC_OFFSET( 6461, glMultiDrawArraysEXT, glMultiDrawArraysEXT, NULL, 441), + NAME_FUNC_OFFSET( 6482, glMultiDrawElementsEXT, glMultiDrawElementsEXT, NULL, 442), + NAME_FUNC_OFFSET( 6505, gl_dispatch_stub_443, gl_dispatch_stub_443, NULL, 443), + NAME_FUNC_OFFSET( 6528, gl_dispatch_stub_444, gl_dispatch_stub_444, NULL, 444), + NAME_FUNC_OFFSET( 6554, gl_dispatch_stub_445, gl_dispatch_stub_445, NULL, 445), + NAME_FUNC_OFFSET( 6577, gl_dispatch_stub_446, gl_dispatch_stub_446, NULL, 446), + NAME_FUNC_OFFSET( 6598, glEGLImageTargetRenderbufferStorageOES, glEGLImageTargetRenderbufferStorageOES, NULL, 447), + NAME_FUNC_OFFSET( 6637, glEGLImageTargetTexture2DOES, glEGLImageTargetTexture2DOES, NULL, 448), + NAME_FUNC_OFFSET( 6666, glCompressedTexImage2D, glCompressedTexImage2D, NULL, 449), + NAME_FUNC_OFFSET( 6689, glCompressedTexSubImage2D, glCompressedTexSubImage2D, NULL, 450), + NAME_FUNC_OFFSET( 6715, glSampleCoverage, glSampleCoverage, NULL, 451), + NAME_FUNC_OFFSET( 6732, glBindBuffer, glBindBuffer, NULL, 452), + NAME_FUNC_OFFSET( 6745, glBufferData, glBufferData, NULL, 453), + NAME_FUNC_OFFSET( 6758, glBufferSubData, glBufferSubData, NULL, 454), + NAME_FUNC_OFFSET( 6774, glDeleteBuffers, glDeleteBuffers, NULL, 455), + NAME_FUNC_OFFSET( 6790, glGenBuffers, glGenBuffers, NULL, 456), + NAME_FUNC_OFFSET( 6803, glGetBufferParameteriv, glGetBufferParameteriv, NULL, 457), + NAME_FUNC_OFFSET( 6826, glIsBuffer, glIsBuffer, NULL, 458), + NAME_FUNC_OFFSET( 6837, glPointParameterf, glPointParameterf, NULL, 459), + NAME_FUNC_OFFSET( 6855, glPointParameterfv, glPointParameterfv, NULL, 460), + NAME_FUNC_OFFSET( 6874, glAlphaFuncx, glAlphaFuncx, NULL, 461), + NAME_FUNC_OFFSET( 6887, glClearColorx, glClearColorx, NULL, 462), + NAME_FUNC_OFFSET( 6901, glClearDepthf, glClearDepthf, NULL, 463), + NAME_FUNC_OFFSET( 6915, glClearDepthx, glClearDepthx, NULL, 464), + NAME_FUNC_OFFSET( 6929, glColor4x, glColor4x, NULL, 465), + NAME_FUNC_OFFSET( 6939, glDepthRangef, glDepthRangef, NULL, 466), + NAME_FUNC_OFFSET( 6953, glDepthRangex, glDepthRangex, NULL, 467), + NAME_FUNC_OFFSET( 6967, glFogx, glFogx, NULL, 468), + NAME_FUNC_OFFSET( 6974, glFogxv, glFogxv, NULL, 469), + NAME_FUNC_OFFSET( 6982, glFrustumf, glFrustumf, NULL, 470), + NAME_FUNC_OFFSET( 6993, glFrustumx, glFrustumx, NULL, 471), + NAME_FUNC_OFFSET( 7004, glLightModelx, glLightModelx, NULL, 472), + NAME_FUNC_OFFSET( 7018, glLightModelxv, glLightModelxv, NULL, 473), + NAME_FUNC_OFFSET( 7033, glLightx, glLightx, NULL, 474), + NAME_FUNC_OFFSET( 7042, glLightxv, glLightxv, NULL, 475), + NAME_FUNC_OFFSET( 7052, glLineWidthx, glLineWidthx, NULL, 476), + NAME_FUNC_OFFSET( 7065, glLoadMatrixx, glLoadMatrixx, NULL, 477), + NAME_FUNC_OFFSET( 7079, glMaterialx, glMaterialx, NULL, 478), + NAME_FUNC_OFFSET( 7091, glMaterialxv, glMaterialxv, NULL, 479), + NAME_FUNC_OFFSET( 7104, glMultMatrixx, glMultMatrixx, NULL, 480), + NAME_FUNC_OFFSET( 7118, glMultiTexCoord4x, glMultiTexCoord4x, NULL, 481), + NAME_FUNC_OFFSET( 7136, glNormal3x, glNormal3x, NULL, 482), + NAME_FUNC_OFFSET( 7147, glOrthof, glOrthof, NULL, 483), + NAME_FUNC_OFFSET( 7156, glOrthox, glOrthox, NULL, 484), + NAME_FUNC_OFFSET( 7165, glPointSizex, glPointSizex, NULL, 485), + NAME_FUNC_OFFSET( 7178, glPolygonOffsetx, glPolygonOffsetx, NULL, 486), + NAME_FUNC_OFFSET( 7195, glRotatex, glRotatex, NULL, 487), + NAME_FUNC_OFFSET( 7205, glSampleCoveragex, glSampleCoveragex, NULL, 488), + NAME_FUNC_OFFSET( 7223, glScalex, glScalex, NULL, 489), + NAME_FUNC_OFFSET( 7232, glTexEnvx, glTexEnvx, NULL, 490), + NAME_FUNC_OFFSET( 7242, glTexEnvxv, glTexEnvxv, NULL, 491), + NAME_FUNC_OFFSET( 7253, glTexParameterx, glTexParameterx, NULL, 492), + NAME_FUNC_OFFSET( 7269, glTranslatex, glTranslatex, NULL, 493), + NAME_FUNC_OFFSET( 7282, glClipPlanef, glClipPlanef, NULL, 494), + NAME_FUNC_OFFSET( 7295, glClipPlanex, glClipPlanex, NULL, 495), + NAME_FUNC_OFFSET( 7308, glGetClipPlanef, glGetClipPlanef, NULL, 496), + NAME_FUNC_OFFSET( 7324, glGetClipPlanex, glGetClipPlanex, NULL, 497), + NAME_FUNC_OFFSET( 7340, glGetFixedv, glGetFixedv, NULL, 498), + NAME_FUNC_OFFSET( 7352, glGetLightxv, glGetLightxv, NULL, 499), + NAME_FUNC_OFFSET( 7365, glGetMaterialxv, glGetMaterialxv, NULL, 500), + NAME_FUNC_OFFSET( 7381, glGetTexEnvxv, glGetTexEnvxv, NULL, 501), + NAME_FUNC_OFFSET( 7395, glGetTexParameterxv, glGetTexParameterxv, NULL, 502), + NAME_FUNC_OFFSET( 7415, glPointParameterx, glPointParameterx, NULL, 503), + NAME_FUNC_OFFSET( 7433, glPointParameterxv, glPointParameterxv, NULL, 504), + NAME_FUNC_OFFSET( 7452, glTexParameterxv, glTexParameterxv, NULL, 505), + NAME_FUNC_OFFSET( 7469, glTexGenfOES, glTexGenfOES, NULL, 190), + NAME_FUNC_OFFSET( 7479, glTexGenfvOES, glTexGenfvOES, NULL, 191), + NAME_FUNC_OFFSET( 7490, glTexGeniOES, glTexGeniOES, NULL, 192), + NAME_FUNC_OFFSET( 7500, glTexGenivOES, glTexGenivOES, NULL, 193), + NAME_FUNC_OFFSET( 7511, glGetTexGenfvOES, glGetTexGenfvOES, NULL, 279), + NAME_FUNC_OFFSET( 7525, glGetTexGenivOES, glGetTexGenivOES, NULL, 280), + NAME_FUNC_OFFSET( 7539, glBlendEquationOES, glBlendEquationOES, NULL, 337), + NAME_FUNC_OFFSET( 7555, glActiveTexture, glActiveTexture, NULL, 374), + NAME_FUNC_OFFSET( 7574, glClientActiveTexture, glClientActiveTexture, NULL, 375), + NAME_FUNC_OFFSET( 7599, glMultiTexCoord4f, glMultiTexCoord4f, NULL, 402), + NAME_FUNC_OFFSET( 7620, glAlphaFuncx, glAlphaFuncx, NULL, 461), + NAME_FUNC_OFFSET( 7636, glClearColorx, glClearColorx, NULL, 462), + NAME_FUNC_OFFSET( 7653, glClearDepthf, glClearDepthf, NULL, 463), + NAME_FUNC_OFFSET( 7670, glClearDepthx, glClearDepthx, NULL, 464), + NAME_FUNC_OFFSET( 7687, glColor4x, glColor4x, NULL, 465), + NAME_FUNC_OFFSET( 7700, glDepthRangef, glDepthRangef, NULL, 466), + NAME_FUNC_OFFSET( 7717, glDepthRangex, glDepthRangex, NULL, 467), + NAME_FUNC_OFFSET( 7734, glFogx, glFogx, NULL, 468), + NAME_FUNC_OFFSET( 7744, glFogxv, glFogxv, NULL, 469), + NAME_FUNC_OFFSET( 7755, glFrustumf, glFrustumf, NULL, 470), + NAME_FUNC_OFFSET( 7769, glFrustumx, glFrustumx, NULL, 471), + NAME_FUNC_OFFSET( 7783, glLightModelx, glLightModelx, NULL, 472), + NAME_FUNC_OFFSET( 7800, glLightModelxv, glLightModelxv, NULL, 473), + NAME_FUNC_OFFSET( 7818, glLightx, glLightx, NULL, 474), + NAME_FUNC_OFFSET( 7830, glLightxv, glLightxv, NULL, 475), + NAME_FUNC_OFFSET( 7843, glLineWidthx, glLineWidthx, NULL, 476), + NAME_FUNC_OFFSET( 7859, glLoadMatrixx, glLoadMatrixx, NULL, 477), + NAME_FUNC_OFFSET( 7876, glMaterialx, glMaterialx, NULL, 478), + NAME_FUNC_OFFSET( 7891, glMaterialxv, glMaterialxv, NULL, 479), + NAME_FUNC_OFFSET( 7907, glMultMatrixx, glMultMatrixx, NULL, 480), + NAME_FUNC_OFFSET( 7924, glMultiTexCoord4x, glMultiTexCoord4x, NULL, 481), + NAME_FUNC_OFFSET( 7945, glNormal3x, glNormal3x, NULL, 482), + NAME_FUNC_OFFSET( 7959, glOrthof, glOrthof, NULL, 483), + NAME_FUNC_OFFSET( 7971, glOrthox, glOrthox, NULL, 484), + NAME_FUNC_OFFSET( 7983, glPointSizex, glPointSizex, NULL, 485), + NAME_FUNC_OFFSET( 7999, glPolygonOffsetx, glPolygonOffsetx, NULL, 486), + NAME_FUNC_OFFSET( 8019, glRotatex, glRotatex, NULL, 487), + NAME_FUNC_OFFSET( 8032, glSampleCoveragex, glSampleCoveragex, NULL, 488), + NAME_FUNC_OFFSET( 8053, glScalex, glScalex, NULL, 489), + NAME_FUNC_OFFSET( 8065, glTexEnvx, glTexEnvx, NULL, 490), + NAME_FUNC_OFFSET( 8078, glTexEnvxv, glTexEnvxv, NULL, 491), + NAME_FUNC_OFFSET( 8092, glTexParameterx, glTexParameterx, NULL, 492), + NAME_FUNC_OFFSET( 8111, glTranslatex, glTranslatex, NULL, 493), + NAME_FUNC_OFFSET( 8127, glClipPlanef, glClipPlanef, NULL, 494), + NAME_FUNC_OFFSET( 8143, glClipPlanex, glClipPlanex, NULL, 495), + NAME_FUNC_OFFSET( 8159, glGetClipPlanef, glGetClipPlanef, NULL, 496), + NAME_FUNC_OFFSET( 8178, glGetClipPlanex, glGetClipPlanex, NULL, 497), + NAME_FUNC_OFFSET( 8197, glGetFixedv, glGetFixedv, NULL, 498), + NAME_FUNC_OFFSET( 8212, glGetLightxv, glGetLightxv, NULL, 499), + NAME_FUNC_OFFSET( 8228, glGetMaterialxv, glGetMaterialxv, NULL, 500), + NAME_FUNC_OFFSET( 8247, glGetTexEnvxv, glGetTexEnvxv, NULL, 501), + NAME_FUNC_OFFSET( 8264, glGetTexParameterxv, glGetTexParameterxv, NULL, 502), + NAME_FUNC_OFFSET( 8287, glPointParameterx, glPointParameterx, NULL, 503), + NAME_FUNC_OFFSET( 8308, glPointParameterxv, glPointParameterxv, NULL, 504), + NAME_FUNC_OFFSET( 8330, glTexParameterxv, glTexParameterxv, NULL, 505), + NAME_FUNC_OFFSET(-1, NULL, NULL, NULL, 0) +}; + +#undef NAME_FUNC_OFFSET diff --git a/src/mapi/es1api/main/glapidispatch.h b/src/mapi/es1api/main/glapidispatch.h new file mode 100644 index 00000000000..59b0a1e7080 --- /dev/null +++ b/src/mapi/es1api/main/glapidispatch.h @@ -0,0 +1,2524 @@ +/* DO NOT EDIT - This file generated automatically by gl_table.py (from Mesa) script */ + +/* + * (C) Copyright IBM Corporation 2005 + * All Rights Reserved. + * + * Permission is hereby granted, free of charge, to any person obtaining a + * copy of this software and associated documentation files (the "Software"), + * to deal in the Software without restriction, including without limitation + * the rights to use, copy, modify, merge, publish, distribute, sub license, + * and/or sell copies of the Software, and to permit persons to whom the + * Software is furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice (including the next + * paragraph) shall be included in all copies or substantial portions of the + * Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL + * IBM, + * AND/OR THEIR SUPPLIERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, + * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF + * OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE + * SOFTWARE. + */ + +#if !defined( _GLAPI_DISPATCH_H_ ) +# define _GLAPI_DISPATCH_H_ + + +/* this file should not be included directly in mesa */ + +/** + * \file glapidispatch.h + * Macros for handling GL dispatch tables. + * + * For each known GL function, there are 3 macros in this file. The first + * macro is named CALL_FuncName and is used to call that GL function using + * the specified dispatch table. The other 2 macros, called GET_FuncName + * can SET_FuncName, are used to get and set the dispatch pointer for the + * named function in the specified dispatch table. + */ + +#define CALL_by_offset(disp, cast, offset, parameters) \ + (*(cast (GET_by_offset(disp, offset)))) parameters +#define GET_by_offset(disp, offset) \ + (offset >= 0) ? (((_glapi_proc *)(disp))[offset]) : NULL +#define SET_by_offset(disp, offset, fn) \ + do { \ + if ( (offset) < 0 ) { \ + /* fprintf( stderr, "[%s:%u] SET_by_offset(%p, %d, %s)!\n", */ \ + /* __func__, __LINE__, disp, offset, # fn); */ \ + /* abort(); */ \ + } \ + else { \ + ( (_glapi_proc *) (disp) )[offset] = (_glapi_proc) fn; \ + } \ + } while(0) + +/* total number of offsets below */ +#define _gloffset_COUNT 506 + +#define _gloffset_NewList 0 +#define _gloffset_EndList 1 +#define _gloffset_CallList 2 +#define _gloffset_CallLists 3 +#define _gloffset_DeleteLists 4 +#define _gloffset_GenLists 5 +#define _gloffset_ListBase 6 +#define _gloffset_Begin 7 +#define _gloffset_Bitmap 8 +#define _gloffset_Color3b 9 +#define _gloffset_Color3bv 10 +#define _gloffset_Color3d 11 +#define _gloffset_Color3dv 12 +#define _gloffset_Color3f 13 +#define _gloffset_Color3fv 14 +#define _gloffset_Color3i 15 +#define _gloffset_Color3iv 16 +#define _gloffset_Color3s 17 +#define _gloffset_Color3sv 18 +#define _gloffset_Color3ub 19 +#define _gloffset_Color3ubv 20 +#define _gloffset_Color3ui 21 +#define _gloffset_Color3uiv 22 +#define _gloffset_Color3us 23 +#define _gloffset_Color3usv 24 +#define _gloffset_Color4b 25 +#define _gloffset_Color4bv 26 +#define _gloffset_Color4d 27 +#define _gloffset_Color4dv 28 +#define _gloffset_Color4f 29 +#define _gloffset_Color4fv 30 +#define _gloffset_Color4i 31 +#define _gloffset_Color4iv 32 +#define _gloffset_Color4s 33 +#define _gloffset_Color4sv 34 +#define _gloffset_Color4ub 35 +#define _gloffset_Color4ubv 36 +#define _gloffset_Color4ui 37 +#define _gloffset_Color4uiv 38 +#define _gloffset_Color4us 39 +#define _gloffset_Color4usv 40 +#define _gloffset_EdgeFlag 41 +#define _gloffset_EdgeFlagv 42 +#define _gloffset_End 43 +#define _gloffset_Indexd 44 +#define _gloffset_Indexdv 45 +#define _gloffset_Indexf 46 +#define _gloffset_Indexfv 47 +#define _gloffset_Indexi 48 +#define _gloffset_Indexiv 49 +#define _gloffset_Indexs 50 +#define _gloffset_Indexsv 51 +#define _gloffset_Normal3b 52 +#define _gloffset_Normal3bv 53 +#define _gloffset_Normal3d 54 +#define _gloffset_Normal3dv 55 +#define _gloffset_Normal3f 56 +#define _gloffset_Normal3fv 57 +#define _gloffset_Normal3i 58 +#define _gloffset_Normal3iv 59 +#define _gloffset_Normal3s 60 +#define _gloffset_Normal3sv 61 +#define _gloffset_RasterPos2d 62 +#define _gloffset_RasterPos2dv 63 +#define _gloffset_RasterPos2f 64 +#define _gloffset_RasterPos2fv 65 +#define _gloffset_RasterPos2i 66 +#define _gloffset_RasterPos2iv 67 +#define _gloffset_RasterPos2s 68 +#define _gloffset_RasterPos2sv 69 +#define _gloffset_RasterPos3d 70 +#define _gloffset_RasterPos3dv 71 +#define _gloffset_RasterPos3f 72 +#define _gloffset_RasterPos3fv 73 +#define _gloffset_RasterPos3i 74 +#define _gloffset_RasterPos3iv 75 +#define _gloffset_RasterPos3s 76 +#define _gloffset_RasterPos3sv 77 +#define _gloffset_RasterPos4d 78 +#define _gloffset_RasterPos4dv 79 +#define _gloffset_RasterPos4f 80 +#define _gloffset_RasterPos4fv 81 +#define _gloffset_RasterPos4i 82 +#define _gloffset_RasterPos4iv 83 +#define _gloffset_RasterPos4s 84 +#define _gloffset_RasterPos4sv 85 +#define _gloffset_Rectd 86 +#define _gloffset_Rectdv 87 +#define _gloffset_Rectf 88 +#define _gloffset_Rectfv 89 +#define _gloffset_Recti 90 +#define _gloffset_Rectiv 91 +#define _gloffset_Rects 92 +#define _gloffset_Rectsv 93 +#define _gloffset_TexCoord1d 94 +#define _gloffset_TexCoord1dv 95 +#define _gloffset_TexCoord1f 96 +#define _gloffset_TexCoord1fv 97 +#define _gloffset_TexCoord1i 98 +#define _gloffset_TexCoord1iv 99 +#define _gloffset_TexCoord1s 100 +#define _gloffset_TexCoord1sv 101 +#define _gloffset_TexCoord2d 102 +#define _gloffset_TexCoord2dv 103 +#define _gloffset_TexCoord2f 104 +#define _gloffset_TexCoord2fv 105 +#define _gloffset_TexCoord2i 106 +#define _gloffset_TexCoord2iv 107 +#define _gloffset_TexCoord2s 108 +#define _gloffset_TexCoord2sv 109 +#define _gloffset_TexCoord3d 110 +#define _gloffset_TexCoord3dv 111 +#define _gloffset_TexCoord3f 112 +#define _gloffset_TexCoord3fv 113 +#define _gloffset_TexCoord3i 114 +#define _gloffset_TexCoord3iv 115 +#define _gloffset_TexCoord3s 116 +#define _gloffset_TexCoord3sv 117 +#define _gloffset_TexCoord4d 118 +#define _gloffset_TexCoord4dv 119 +#define _gloffset_TexCoord4f 120 +#define _gloffset_TexCoord4fv 121 +#define _gloffset_TexCoord4i 122 +#define _gloffset_TexCoord4iv 123 +#define _gloffset_TexCoord4s 124 +#define _gloffset_TexCoord4sv 125 +#define _gloffset_Vertex2d 126 +#define _gloffset_Vertex2dv 127 +#define _gloffset_Vertex2f 128 +#define _gloffset_Vertex2fv 129 +#define _gloffset_Vertex2i 130 +#define _gloffset_Vertex2iv 131 +#define _gloffset_Vertex2s 132 +#define _gloffset_Vertex2sv 133 +#define _gloffset_Vertex3d 134 +#define _gloffset_Vertex3dv 135 +#define _gloffset_Vertex3f 136 +#define _gloffset_Vertex3fv 137 +#define _gloffset_Vertex3i 138 +#define _gloffset_Vertex3iv 139 +#define _gloffset_Vertex3s 140 +#define _gloffset_Vertex3sv 141 +#define _gloffset_Vertex4d 142 +#define _gloffset_Vertex4dv 143 +#define _gloffset_Vertex4f 144 +#define _gloffset_Vertex4fv 145 +#define _gloffset_Vertex4i 146 +#define _gloffset_Vertex4iv 147 +#define _gloffset_Vertex4s 148 +#define _gloffset_Vertex4sv 149 +#define _gloffset_ClipPlane 150 +#define _gloffset_ColorMaterial 151 +#define _gloffset_CullFace 152 +#define _gloffset_Fogf 153 +#define _gloffset_Fogfv 154 +#define _gloffset_Fogi 155 +#define _gloffset_Fogiv 156 +#define _gloffset_FrontFace 157 +#define _gloffset_Hint 158 +#define _gloffset_Lightf 159 +#define _gloffset_Lightfv 160 +#define _gloffset_Lighti 161 +#define _gloffset_Lightiv 162 +#define _gloffset_LightModelf 163 +#define _gloffset_LightModelfv 164 +#define _gloffset_LightModeli 165 +#define _gloffset_LightModeliv 166 +#define _gloffset_LineStipple 167 +#define _gloffset_LineWidth 168 +#define _gloffset_Materialf 169 +#define _gloffset_Materialfv 170 +#define _gloffset_Materiali 171 +#define _gloffset_Materialiv 172 +#define _gloffset_PointSize 173 +#define _gloffset_PolygonMode 174 +#define _gloffset_PolygonStipple 175 +#define _gloffset_Scissor 176 +#define _gloffset_ShadeModel 177 +#define _gloffset_TexParameterf 178 +#define _gloffset_TexParameterfv 179 +#define _gloffset_TexParameteri 180 +#define _gloffset_TexParameteriv 181 +#define _gloffset_TexImage1D 182 +#define _gloffset_TexImage2D 183 +#define _gloffset_TexEnvf 184 +#define _gloffset_TexEnvfv 185 +#define _gloffset_TexEnvi 186 +#define _gloffset_TexEnviv 187 +#define _gloffset_TexGend 188 +#define _gloffset_TexGendv 189 +#define _gloffset_TexGenfOES 190 +#define _gloffset_TexGenfvOES 191 +#define _gloffset_TexGeniOES 192 +#define _gloffset_TexGenivOES 193 +#define _gloffset_FeedbackBuffer 194 +#define _gloffset_SelectBuffer 195 +#define _gloffset_RenderMode 196 +#define _gloffset_InitNames 197 +#define _gloffset_LoadName 198 +#define _gloffset_PassThrough 199 +#define _gloffset_PopName 200 +#define _gloffset_PushName 201 +#define _gloffset_DrawBuffer 202 +#define _gloffset_Clear 203 +#define _gloffset_ClearAccum 204 +#define _gloffset_ClearIndex 205 +#define _gloffset_ClearColor 206 +#define _gloffset_ClearStencil 207 +#define _gloffset_ClearDepth 208 +#define _gloffset_StencilMask 209 +#define _gloffset_ColorMask 210 +#define _gloffset_DepthMask 211 +#define _gloffset_IndexMask 212 +#define _gloffset_Accum 213 +#define _gloffset_Disable 214 +#define _gloffset_Enable 215 +#define _gloffset_Finish 216 +#define _gloffset_Flush 217 +#define _gloffset_PopAttrib 218 +#define _gloffset_PushAttrib 219 +#define _gloffset_Map1d 220 +#define _gloffset_Map1f 221 +#define _gloffset_Map2d 222 +#define _gloffset_Map2f 223 +#define _gloffset_MapGrid1d 224 +#define _gloffset_MapGrid1f 225 +#define _gloffset_MapGrid2d 226 +#define _gloffset_MapGrid2f 227 +#define _gloffset_EvalCoord1d 228 +#define _gloffset_EvalCoord1dv 229 +#define _gloffset_EvalCoord1f 230 +#define _gloffset_EvalCoord1fv 231 +#define _gloffset_EvalCoord2d 232 +#define _gloffset_EvalCoord2dv 233 +#define _gloffset_EvalCoord2f 234 +#define _gloffset_EvalCoord2fv 235 +#define _gloffset_EvalMesh1 236 +#define _gloffset_EvalPoint1 237 +#define _gloffset_EvalMesh2 238 +#define _gloffset_EvalPoint2 239 +#define _gloffset_AlphaFunc 240 +#define _gloffset_BlendFunc 241 +#define _gloffset_LogicOp 242 +#define _gloffset_StencilFunc 243 +#define _gloffset_StencilOp 244 +#define _gloffset_DepthFunc 245 +#define _gloffset_PixelZoom 246 +#define _gloffset_PixelTransferf 247 +#define _gloffset_PixelTransferi 248 +#define _gloffset_PixelStoref 249 +#define _gloffset_PixelStorei 250 +#define _gloffset_PixelMapfv 251 +#define _gloffset_PixelMapuiv 252 +#define _gloffset_PixelMapusv 253 +#define _gloffset_ReadBuffer 254 +#define _gloffset_CopyPixels 255 +#define _gloffset_ReadPixels 256 +#define _gloffset_DrawPixels 257 +#define _gloffset_GetBooleanv 258 +#define _gloffset_GetClipPlane 259 +#define _gloffset_GetDoublev 260 +#define _gloffset_GetError 261 +#define _gloffset_GetFloatv 262 +#define _gloffset_GetIntegerv 263 +#define _gloffset_GetLightfv 264 +#define _gloffset_GetLightiv 265 +#define _gloffset_GetMapdv 266 +#define _gloffset_GetMapfv 267 +#define _gloffset_GetMapiv 268 +#define _gloffset_GetMaterialfv 269 +#define _gloffset_GetMaterialiv 270 +#define _gloffset_GetPixelMapfv 271 +#define _gloffset_GetPixelMapuiv 272 +#define _gloffset_GetPixelMapusv 273 +#define _gloffset_GetPolygonStipple 274 +#define _gloffset_GetString 275 +#define _gloffset_GetTexEnvfv 276 +#define _gloffset_GetTexEnviv 277 +#define _gloffset_GetTexGendv 278 +#define _gloffset_GetTexGenfvOES 279 +#define _gloffset_GetTexGenivOES 280 +#define _gloffset_GetTexImage 281 +#define _gloffset_GetTexParameterfv 282 +#define _gloffset_GetTexParameteriv 283 +#define _gloffset_GetTexLevelParameterfv 284 +#define _gloffset_GetTexLevelParameteriv 285 +#define _gloffset_IsEnabled 286 +#define _gloffset_IsList 287 +#define _gloffset_DepthRange 288 +#define _gloffset_Frustum 289 +#define _gloffset_LoadIdentity 290 +#define _gloffset_LoadMatrixf 291 +#define _gloffset_LoadMatrixd 292 +#define _gloffset_MatrixMode 293 +#define _gloffset_MultMatrixf 294 +#define _gloffset_MultMatrixd 295 +#define _gloffset_Ortho 296 +#define _gloffset_PopMatrix 297 +#define _gloffset_PushMatrix 298 +#define _gloffset_Rotated 299 +#define _gloffset_Rotatef 300 +#define _gloffset_Scaled 301 +#define _gloffset_Scalef 302 +#define _gloffset_Translated 303 +#define _gloffset_Translatef 304 +#define _gloffset_Viewport 305 +#define _gloffset_ArrayElement 306 +#define _gloffset_BindTexture 307 +#define _gloffset_ColorPointer 308 +#define _gloffset_DisableClientState 309 +#define _gloffset_DrawArrays 310 +#define _gloffset_DrawElements 311 +#define _gloffset_EdgeFlagPointer 312 +#define _gloffset_EnableClientState 313 +#define _gloffset_IndexPointer 314 +#define _gloffset_Indexub 315 +#define _gloffset_Indexubv 316 +#define _gloffset_InterleavedArrays 317 +#define _gloffset_NormalPointer 318 +#define _gloffset_PolygonOffset 319 +#define _gloffset_TexCoordPointer 320 +#define _gloffset_VertexPointer 321 +#define _gloffset_AreTexturesResident 322 +#define _gloffset_CopyTexImage1D 323 +#define _gloffset_CopyTexImage2D 324 +#define _gloffset_CopyTexSubImage1D 325 +#define _gloffset_CopyTexSubImage2D 326 +#define _gloffset_DeleteTextures 327 +#define _gloffset_GenTextures 328 +#define _gloffset_GetPointerv 329 +#define _gloffset_IsTexture 330 +#define _gloffset_PrioritizeTextures 331 +#define _gloffset_TexSubImage1D 332 +#define _gloffset_TexSubImage2D 333 +#define _gloffset_PopClientAttrib 334 +#define _gloffset_PushClientAttrib 335 +#define _gloffset_BlendColor 336 +#define _gloffset_BlendEquationOES 337 +#define _gloffset_DrawRangeElements 338 +#define _gloffset_ColorTable 339 +#define _gloffset_ColorTableParameterfv 340 +#define _gloffset_ColorTableParameteriv 341 +#define _gloffset_CopyColorTable 342 +#define _gloffset_GetColorTable 343 +#define _gloffset_GetColorTableParameterfv 344 +#define _gloffset_GetColorTableParameteriv 345 +#define _gloffset_ColorSubTable 346 +#define _gloffset_CopyColorSubTable 347 +#define _gloffset_ConvolutionFilter1D 348 +#define _gloffset_ConvolutionFilter2D 349 +#define _gloffset_ConvolutionParameterf 350 +#define _gloffset_ConvolutionParameterfv 351 +#define _gloffset_ConvolutionParameteri 352 +#define _gloffset_ConvolutionParameteriv 353 +#define _gloffset_CopyConvolutionFilter1D 354 +#define _gloffset_CopyConvolutionFilter2D 355 +#define _gloffset_GetConvolutionFilter 356 +#define _gloffset_GetConvolutionParameterfv 357 +#define _gloffset_GetConvolutionParameteriv 358 +#define _gloffset_GetSeparableFilter 359 +#define _gloffset_SeparableFilter2D 360 +#define _gloffset_GetHistogram 361 +#define _gloffset_GetHistogramParameterfv 362 +#define _gloffset_GetHistogramParameteriv 363 +#define _gloffset_GetMinmax 364 +#define _gloffset_GetMinmaxParameterfv 365 +#define _gloffset_GetMinmaxParameteriv 366 +#define _gloffset_Histogram 367 +#define _gloffset_Minmax 368 +#define _gloffset_ResetHistogram 369 +#define _gloffset_ResetMinmax 370 +#define _gloffset_TexImage3D 371 +#define _gloffset_TexSubImage3D 372 +#define _gloffset_CopyTexSubImage3D 373 +#define _gloffset_ActiveTexture 374 +#define _gloffset_ClientActiveTexture 375 +#define _gloffset_MultiTexCoord1dARB 376 +#define _gloffset_MultiTexCoord1dvARB 377 +#define _gloffset_MultiTexCoord1fARB 378 +#define _gloffset_MultiTexCoord1fvARB 379 +#define _gloffset_MultiTexCoord1iARB 380 +#define _gloffset_MultiTexCoord1ivARB 381 +#define _gloffset_MultiTexCoord1sARB 382 +#define _gloffset_MultiTexCoord1svARB 383 +#define _gloffset_MultiTexCoord2dARB 384 +#define _gloffset_MultiTexCoord2dvARB 385 +#define _gloffset_MultiTexCoord2fARB 386 +#define _gloffset_MultiTexCoord2fvARB 387 +#define _gloffset_MultiTexCoord2iARB 388 +#define _gloffset_MultiTexCoord2ivARB 389 +#define _gloffset_MultiTexCoord2sARB 390 +#define _gloffset_MultiTexCoord2svARB 391 +#define _gloffset_MultiTexCoord3dARB 392 +#define _gloffset_MultiTexCoord3dvARB 393 +#define _gloffset_MultiTexCoord3fARB 394 +#define _gloffset_MultiTexCoord3fvARB 395 +#define _gloffset_MultiTexCoord3iARB 396 +#define _gloffset_MultiTexCoord3ivARB 397 +#define _gloffset_MultiTexCoord3sARB 398 +#define _gloffset_MultiTexCoord3svARB 399 +#define _gloffset_MultiTexCoord4dARB 400 +#define _gloffset_MultiTexCoord4dvARB 401 +#define _gloffset_MultiTexCoord4f 402 +#define _gloffset_MultiTexCoord4fvARB 403 +#define _gloffset_MultiTexCoord4iARB 404 +#define _gloffset_MultiTexCoord4ivARB 405 +#define _gloffset_MultiTexCoord4sARB 406 +#define _gloffset_MultiTexCoord4svARB 407 + +#if !defined(_GLAPI_USE_REMAP_TABLE) + +#define _gloffset_BlendEquationSeparateOES 408 +#define _gloffset_BlendFuncSeparateOES 409 +#define _gloffset_DrawTexfOES 410 +#define _gloffset_DrawTexfvOES 411 +#define _gloffset_DrawTexiOES 412 +#define _gloffset_DrawTexivOES 413 +#define _gloffset_DrawTexsOES 414 +#define _gloffset_DrawTexsvOES 415 +#define _gloffset_DrawTexxOES 416 +#define _gloffset_DrawTexxvOES 417 +#define _gloffset_BindFramebufferOES 418 +#define _gloffset_BindRenderbufferOES 419 +#define _gloffset_CheckFramebufferStatusOES 420 +#define _gloffset_DeleteFramebuffersOES 421 +#define _gloffset_DeleteRenderbuffersOES 422 +#define _gloffset_FramebufferRenderbufferOES 423 +#define _gloffset_FramebufferTexture2DOES 424 +#define _gloffset_GenFramebuffersOES 425 +#define _gloffset_GenRenderbuffersOES 426 +#define _gloffset_GenerateMipmapOES 427 +#define _gloffset_GetFramebufferAttachmentParameterivOES 428 +#define _gloffset_GetRenderbufferParameterivOES 429 +#define _gloffset_IsFramebufferOES 430 +#define _gloffset_IsRenderbufferOES 431 +#define _gloffset_RenderbufferStorageOES 432 +#define _gloffset_PointSizePointerOES 433 +#define _gloffset_QueryMatrixxOES 434 +#define _gloffset_GetTexGenxvOES 435 +#define _gloffset_TexGenxOES 436 +#define _gloffset_TexGenxvOES 437 +#define _gloffset_GetBufferPointervOES 438 +#define _gloffset_MapBufferOES 439 +#define _gloffset_UnmapBufferOES 440 +#define _gloffset_MultiDrawArraysEXT 441 +#define _gloffset_MultiDrawElementsEXT 442 +#define _gloffset_BindVertexArrayAPPLE 443 +#define _gloffset_DeleteVertexArraysAPPLE 444 +#define _gloffset_GenVertexArraysAPPLE 445 +#define _gloffset_IsVertexArrayAPPLE 446 +#define _gloffset_EGLImageTargetRenderbufferStorageOES 447 +#define _gloffset_EGLImageTargetTexture2DOES 448 +#define _gloffset_CompressedTexImage2D 449 +#define _gloffset_CompressedTexSubImage2D 450 +#define _gloffset_SampleCoverage 451 +#define _gloffset_BindBuffer 452 +#define _gloffset_BufferData 453 +#define _gloffset_BufferSubData 454 +#define _gloffset_DeleteBuffers 455 +#define _gloffset_GenBuffers 456 +#define _gloffset_GetBufferParameteriv 457 +#define _gloffset_IsBuffer 458 +#define _gloffset_PointParameterf 459 +#define _gloffset_PointParameterfv 460 +#define _gloffset_AlphaFuncx 461 +#define _gloffset_ClearColorx 462 +#define _gloffset_ClearDepthf 463 +#define _gloffset_ClearDepthx 464 +#define _gloffset_Color4x 465 +#define _gloffset_DepthRangef 466 +#define _gloffset_DepthRangex 467 +#define _gloffset_Fogx 468 +#define _gloffset_Fogxv 469 +#define _gloffset_Frustumf 470 +#define _gloffset_Frustumx 471 +#define _gloffset_LightModelx 472 +#define _gloffset_LightModelxv 473 +#define _gloffset_Lightx 474 +#define _gloffset_Lightxv 475 +#define _gloffset_LineWidthx 476 +#define _gloffset_LoadMatrixx 477 +#define _gloffset_Materialx 478 +#define _gloffset_Materialxv 479 +#define _gloffset_MultMatrixx 480 +#define _gloffset_MultiTexCoord4x 481 +#define _gloffset_Normal3x 482 +#define _gloffset_Orthof 483 +#define _gloffset_Orthox 484 +#define _gloffset_PointSizex 485 +#define _gloffset_PolygonOffsetx 486 +#define _gloffset_Rotatex 487 +#define _gloffset_SampleCoveragex 488 +#define _gloffset_Scalex 489 +#define _gloffset_TexEnvx 490 +#define _gloffset_TexEnvxv 491 +#define _gloffset_TexParameterx 492 +#define _gloffset_Translatex 493 +#define _gloffset_ClipPlanef 494 +#define _gloffset_ClipPlanex 495 +#define _gloffset_GetClipPlanef 496 +#define _gloffset_GetClipPlanex 497 +#define _gloffset_GetFixedv 498 +#define _gloffset_GetLightxv 499 +#define _gloffset_GetMaterialxv 500 +#define _gloffset_GetTexEnvxv 501 +#define _gloffset_GetTexParameterxv 502 +#define _gloffset_PointParameterx 503 +#define _gloffset_PointParameterxv 504 +#define _gloffset_TexParameterxv 505 + +#else /* !_GLAPI_USE_REMAP_TABLE */ + +#define driDispatchRemapTable_size 98 +extern int driDispatchRemapTable[ driDispatchRemapTable_size ]; + +#define BlendEquationSeparateOES_remap_index 0 +#define BlendFuncSeparateOES_remap_index 1 +#define DrawTexfOES_remap_index 2 +#define DrawTexfvOES_remap_index 3 +#define DrawTexiOES_remap_index 4 +#define DrawTexivOES_remap_index 5 +#define DrawTexsOES_remap_index 6 +#define DrawTexsvOES_remap_index 7 +#define DrawTexxOES_remap_index 8 +#define DrawTexxvOES_remap_index 9 +#define BindFramebufferOES_remap_index 10 +#define BindRenderbufferOES_remap_index 11 +#define CheckFramebufferStatusOES_remap_index 12 +#define DeleteFramebuffersOES_remap_index 13 +#define DeleteRenderbuffersOES_remap_index 14 +#define FramebufferRenderbufferOES_remap_index 15 +#define FramebufferTexture2DOES_remap_index 16 +#define GenFramebuffersOES_remap_index 17 +#define GenRenderbuffersOES_remap_index 18 +#define GenerateMipmapOES_remap_index 19 +#define GetFramebufferAttachmentParameterivOES_remap_index 20 +#define GetRenderbufferParameterivOES_remap_index 21 +#define IsFramebufferOES_remap_index 22 +#define IsRenderbufferOES_remap_index 23 +#define RenderbufferStorageOES_remap_index 24 +#define PointSizePointerOES_remap_index 25 +#define QueryMatrixxOES_remap_index 26 +#define GetTexGenxvOES_remap_index 27 +#define TexGenxOES_remap_index 28 +#define TexGenxvOES_remap_index 29 +#define GetBufferPointervOES_remap_index 30 +#define MapBufferOES_remap_index 31 +#define UnmapBufferOES_remap_index 32 +#define MultiDrawArraysEXT_remap_index 33 +#define MultiDrawElementsEXT_remap_index 34 +#define BindVertexArrayAPPLE_remap_index 35 +#define DeleteVertexArraysAPPLE_remap_index 36 +#define GenVertexArraysAPPLE_remap_index 37 +#define IsVertexArrayAPPLE_remap_index 38 +#define EGLImageTargetRenderbufferStorageOES_remap_index 39 +#define EGLImageTargetTexture2DOES_remap_index 40 +#define CompressedTexImage2D_remap_index 41 +#define CompressedTexSubImage2D_remap_index 42 +#define SampleCoverage_remap_index 43 +#define BindBuffer_remap_index 44 +#define BufferData_remap_index 45 +#define BufferSubData_remap_index 46 +#define DeleteBuffers_remap_index 47 +#define GenBuffers_remap_index 48 +#define GetBufferParameteriv_remap_index 49 +#define IsBuffer_remap_index 50 +#define PointParameterf_remap_index 51 +#define PointParameterfv_remap_index 52 +#define AlphaFuncx_remap_index 53 +#define ClearColorx_remap_index 54 +#define ClearDepthf_remap_index 55 +#define ClearDepthx_remap_index 56 +#define Color4x_remap_index 57 +#define DepthRangef_remap_index 58 +#define DepthRangex_remap_index 59 +#define Fogx_remap_index 60 +#define Fogxv_remap_index 61 +#define Frustumf_remap_index 62 +#define Frustumx_remap_index 63 +#define LightModelx_remap_index 64 +#define LightModelxv_remap_index 65 +#define Lightx_remap_index 66 +#define Lightxv_remap_index 67 +#define LineWidthx_remap_index 68 +#define LoadMatrixx_remap_index 69 +#define Materialx_remap_index 70 +#define Materialxv_remap_index 71 +#define MultMatrixx_remap_index 72 +#define MultiTexCoord4x_remap_index 73 +#define Normal3x_remap_index 74 +#define Orthof_remap_index 75 +#define Orthox_remap_index 76 +#define PointSizex_remap_index 77 +#define PolygonOffsetx_remap_index 78 +#define Rotatex_remap_index 79 +#define SampleCoveragex_remap_index 80 +#define Scalex_remap_index 81 +#define TexEnvx_remap_index 82 +#define TexEnvxv_remap_index 83 +#define TexParameterx_remap_index 84 +#define Translatex_remap_index 85 +#define ClipPlanef_remap_index 86 +#define ClipPlanex_remap_index 87 +#define GetClipPlanef_remap_index 88 +#define GetClipPlanex_remap_index 89 +#define GetFixedv_remap_index 90 +#define GetLightxv_remap_index 91 +#define GetMaterialxv_remap_index 92 +#define GetTexEnvxv_remap_index 93 +#define GetTexParameterxv_remap_index 94 +#define PointParameterx_remap_index 95 +#define PointParameterxv_remap_index 96 +#define TexParameterxv_remap_index 97 + +#define _gloffset_BlendEquationSeparateOES driDispatchRemapTable[BlendEquationSeparateOES_remap_index] +#define _gloffset_BlendFuncSeparateOES driDispatchRemapTable[BlendFuncSeparateOES_remap_index] +#define _gloffset_DrawTexfOES driDispatchRemapTable[DrawTexfOES_remap_index] +#define _gloffset_DrawTexfvOES driDispatchRemapTable[DrawTexfvOES_remap_index] +#define _gloffset_DrawTexiOES driDispatchRemapTable[DrawTexiOES_remap_index] +#define _gloffset_DrawTexivOES driDispatchRemapTable[DrawTexivOES_remap_index] +#define _gloffset_DrawTexsOES driDispatchRemapTable[DrawTexsOES_remap_index] +#define _gloffset_DrawTexsvOES driDispatchRemapTable[DrawTexsvOES_remap_index] +#define _gloffset_DrawTexxOES driDispatchRemapTable[DrawTexxOES_remap_index] +#define _gloffset_DrawTexxvOES driDispatchRemapTable[DrawTexxvOES_remap_index] +#define _gloffset_BindFramebufferOES driDispatchRemapTable[BindFramebufferOES_remap_index] +#define _gloffset_BindRenderbufferOES driDispatchRemapTable[BindRenderbufferOES_remap_index] +#define _gloffset_CheckFramebufferStatusOES driDispatchRemapTable[CheckFramebufferStatusOES_remap_index] +#define _gloffset_DeleteFramebuffersOES driDispatchRemapTable[DeleteFramebuffersOES_remap_index] +#define _gloffset_DeleteRenderbuffersOES driDispatchRemapTable[DeleteRenderbuffersOES_remap_index] +#define _gloffset_FramebufferRenderbufferOES driDispatchRemapTable[FramebufferRenderbufferOES_remap_index] +#define _gloffset_FramebufferTexture2DOES driDispatchRemapTable[FramebufferTexture2DOES_remap_index] +#define _gloffset_GenFramebuffersOES driDispatchRemapTable[GenFramebuffersOES_remap_index] +#define _gloffset_GenRenderbuffersOES driDispatchRemapTable[GenRenderbuffersOES_remap_index] +#define _gloffset_GenerateMipmapOES driDispatchRemapTable[GenerateMipmapOES_remap_index] +#define _gloffset_GetFramebufferAttachmentParameterivOES driDispatchRemapTable[GetFramebufferAttachmentParameterivOES_remap_index] +#define _gloffset_GetRenderbufferParameterivOES driDispatchRemapTable[GetRenderbufferParameterivOES_remap_index] +#define _gloffset_IsFramebufferOES driDispatchRemapTable[IsFramebufferOES_remap_index] +#define _gloffset_IsRenderbufferOES driDispatchRemapTable[IsRenderbufferOES_remap_index] +#define _gloffset_RenderbufferStorageOES driDispatchRemapTable[RenderbufferStorageOES_remap_index] +#define _gloffset_PointSizePointerOES driDispatchRemapTable[PointSizePointerOES_remap_index] +#define _gloffset_QueryMatrixxOES driDispatchRemapTable[QueryMatrixxOES_remap_index] +#define _gloffset_GetTexGenxvOES driDispatchRemapTable[GetTexGenxvOES_remap_index] +#define _gloffset_TexGenxOES driDispatchRemapTable[TexGenxOES_remap_index] +#define _gloffset_TexGenxvOES driDispatchRemapTable[TexGenxvOES_remap_index] +#define _gloffset_GetBufferPointervOES driDispatchRemapTable[GetBufferPointervOES_remap_index] +#define _gloffset_MapBufferOES driDispatchRemapTable[MapBufferOES_remap_index] +#define _gloffset_UnmapBufferOES driDispatchRemapTable[UnmapBufferOES_remap_index] +#define _gloffset_MultiDrawArraysEXT driDispatchRemapTable[MultiDrawArraysEXT_remap_index] +#define _gloffset_MultiDrawElementsEXT driDispatchRemapTable[MultiDrawElementsEXT_remap_index] +#define _gloffset_BindVertexArrayAPPLE driDispatchRemapTable[BindVertexArrayAPPLE_remap_index] +#define _gloffset_DeleteVertexArraysAPPLE driDispatchRemapTable[DeleteVertexArraysAPPLE_remap_index] +#define _gloffset_GenVertexArraysAPPLE driDispatchRemapTable[GenVertexArraysAPPLE_remap_index] +#define _gloffset_IsVertexArrayAPPLE driDispatchRemapTable[IsVertexArrayAPPLE_remap_index] +#define _gloffset_EGLImageTargetRenderbufferStorageOES driDispatchRemapTable[EGLImageTargetRenderbufferStorageOES_remap_index] +#define _gloffset_EGLImageTargetTexture2DOES driDispatchRemapTable[EGLImageTargetTexture2DOES_remap_index] +#define _gloffset_CompressedTexImage2D driDispatchRemapTable[CompressedTexImage2D_remap_index] +#define _gloffset_CompressedTexSubImage2D driDispatchRemapTable[CompressedTexSubImage2D_remap_index] +#define _gloffset_SampleCoverage driDispatchRemapTable[SampleCoverage_remap_index] +#define _gloffset_BindBuffer driDispatchRemapTable[BindBuffer_remap_index] +#define _gloffset_BufferData driDispatchRemapTable[BufferData_remap_index] +#define _gloffset_BufferSubData driDispatchRemapTable[BufferSubData_remap_index] +#define _gloffset_DeleteBuffers driDispatchRemapTable[DeleteBuffers_remap_index] +#define _gloffset_GenBuffers driDispatchRemapTable[GenBuffers_remap_index] +#define _gloffset_GetBufferParameteriv driDispatchRemapTable[GetBufferParameteriv_remap_index] +#define _gloffset_IsBuffer driDispatchRemapTable[IsBuffer_remap_index] +#define _gloffset_PointParameterf driDispatchRemapTable[PointParameterf_remap_index] +#define _gloffset_PointParameterfv driDispatchRemapTable[PointParameterfv_remap_index] +#define _gloffset_AlphaFuncx driDispatchRemapTable[AlphaFuncx_remap_index] +#define _gloffset_ClearColorx driDispatchRemapTable[ClearColorx_remap_index] +#define _gloffset_ClearDepthf driDispatchRemapTable[ClearDepthf_remap_index] +#define _gloffset_ClearDepthx driDispatchRemapTable[ClearDepthx_remap_index] +#define _gloffset_Color4x driDispatchRemapTable[Color4x_remap_index] +#define _gloffset_DepthRangef driDispatchRemapTable[DepthRangef_remap_index] +#define _gloffset_DepthRangex driDispatchRemapTable[DepthRangex_remap_index] +#define _gloffset_Fogx driDispatchRemapTable[Fogx_remap_index] +#define _gloffset_Fogxv driDispatchRemapTable[Fogxv_remap_index] +#define _gloffset_Frustumf driDispatchRemapTable[Frustumf_remap_index] +#define _gloffset_Frustumx driDispatchRemapTable[Frustumx_remap_index] +#define _gloffset_LightModelx driDispatchRemapTable[LightModelx_remap_index] +#define _gloffset_LightModelxv driDispatchRemapTable[LightModelxv_remap_index] +#define _gloffset_Lightx driDispatchRemapTable[Lightx_remap_index] +#define _gloffset_Lightxv driDispatchRemapTable[Lightxv_remap_index] +#define _gloffset_LineWidthx driDispatchRemapTable[LineWidthx_remap_index] +#define _gloffset_LoadMatrixx driDispatchRemapTable[LoadMatrixx_remap_index] +#define _gloffset_Materialx driDispatchRemapTable[Materialx_remap_index] +#define _gloffset_Materialxv driDispatchRemapTable[Materialxv_remap_index] +#define _gloffset_MultMatrixx driDispatchRemapTable[MultMatrixx_remap_index] +#define _gloffset_MultiTexCoord4x driDispatchRemapTable[MultiTexCoord4x_remap_index] +#define _gloffset_Normal3x driDispatchRemapTable[Normal3x_remap_index] +#define _gloffset_Orthof driDispatchRemapTable[Orthof_remap_index] +#define _gloffset_Orthox driDispatchRemapTable[Orthox_remap_index] +#define _gloffset_PointSizex driDispatchRemapTable[PointSizex_remap_index] +#define _gloffset_PolygonOffsetx driDispatchRemapTable[PolygonOffsetx_remap_index] +#define _gloffset_Rotatex driDispatchRemapTable[Rotatex_remap_index] +#define _gloffset_SampleCoveragex driDispatchRemapTable[SampleCoveragex_remap_index] +#define _gloffset_Scalex driDispatchRemapTable[Scalex_remap_index] +#define _gloffset_TexEnvx driDispatchRemapTable[TexEnvx_remap_index] +#define _gloffset_TexEnvxv driDispatchRemapTable[TexEnvxv_remap_index] +#define _gloffset_TexParameterx driDispatchRemapTable[TexParameterx_remap_index] +#define _gloffset_Translatex driDispatchRemapTable[Translatex_remap_index] +#define _gloffset_ClipPlanef driDispatchRemapTable[ClipPlanef_remap_index] +#define _gloffset_ClipPlanex driDispatchRemapTable[ClipPlanex_remap_index] +#define _gloffset_GetClipPlanef driDispatchRemapTable[GetClipPlanef_remap_index] +#define _gloffset_GetClipPlanex driDispatchRemapTable[GetClipPlanex_remap_index] +#define _gloffset_GetFixedv driDispatchRemapTable[GetFixedv_remap_index] +#define _gloffset_GetLightxv driDispatchRemapTable[GetLightxv_remap_index] +#define _gloffset_GetMaterialxv driDispatchRemapTable[GetMaterialxv_remap_index] +#define _gloffset_GetTexEnvxv driDispatchRemapTable[GetTexEnvxv_remap_index] +#define _gloffset_GetTexParameterxv driDispatchRemapTable[GetTexParameterxv_remap_index] +#define _gloffset_PointParameterx driDispatchRemapTable[PointParameterx_remap_index] +#define _gloffset_PointParameterxv driDispatchRemapTable[PointParameterxv_remap_index] +#define _gloffset_TexParameterxv driDispatchRemapTable[TexParameterxv_remap_index] + +#endif /* _GLAPI_USE_REMAP_TABLE */ + +#define CALL_NewList(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLuint, GLenum)), _gloffset_NewList, parameters) +#define GET_NewList(disp) GET_by_offset(disp, _gloffset_NewList) +#define SET_NewList(disp, fn) SET_by_offset(disp, _gloffset_NewList, fn) +#define CALL_EndList(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(void)), _gloffset_EndList, parameters) +#define GET_EndList(disp) GET_by_offset(disp, _gloffset_EndList) +#define SET_EndList(disp, fn) SET_by_offset(disp, _gloffset_EndList, fn) +#define CALL_CallList(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLuint)), _gloffset_CallList, parameters) +#define GET_CallList(disp) GET_by_offset(disp, _gloffset_CallList) +#define SET_CallList(disp, fn) SET_by_offset(disp, _gloffset_CallList, fn) +#define CALL_CallLists(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLsizei, GLenum, const GLvoid *)), _gloffset_CallLists, parameters) +#define GET_CallLists(disp) GET_by_offset(disp, _gloffset_CallLists) +#define SET_CallLists(disp, fn) SET_by_offset(disp, _gloffset_CallLists, fn) +#define CALL_DeleteLists(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLuint, GLsizei)), _gloffset_DeleteLists, parameters) +#define GET_DeleteLists(disp) GET_by_offset(disp, _gloffset_DeleteLists) +#define SET_DeleteLists(disp, fn) SET_by_offset(disp, _gloffset_DeleteLists, fn) +#define CALL_GenLists(disp, parameters) CALL_by_offset(disp, (GLuint (GLAPIENTRYP)(GLsizei)), _gloffset_GenLists, parameters) +#define GET_GenLists(disp) GET_by_offset(disp, _gloffset_GenLists) +#define SET_GenLists(disp, fn) SET_by_offset(disp, _gloffset_GenLists, fn) +#define CALL_ListBase(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLuint)), _gloffset_ListBase, parameters) +#define GET_ListBase(disp) GET_by_offset(disp, _gloffset_ListBase) +#define SET_ListBase(disp, fn) SET_by_offset(disp, _gloffset_ListBase, fn) +#define CALL_Begin(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum)), _gloffset_Begin, parameters) +#define GET_Begin(disp) GET_by_offset(disp, _gloffset_Begin) +#define SET_Begin(disp, fn) SET_by_offset(disp, _gloffset_Begin, fn) +#define CALL_Bitmap(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLsizei, GLsizei, GLfloat, GLfloat, GLfloat, GLfloat, const GLubyte *)), _gloffset_Bitmap, parameters) +#define GET_Bitmap(disp) GET_by_offset(disp, _gloffset_Bitmap) +#define SET_Bitmap(disp, fn) SET_by_offset(disp, _gloffset_Bitmap, fn) +#define CALL_Color3b(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLbyte, GLbyte, GLbyte)), _gloffset_Color3b, parameters) +#define GET_Color3b(disp) GET_by_offset(disp, _gloffset_Color3b) +#define SET_Color3b(disp, fn) SET_by_offset(disp, _gloffset_Color3b, fn) +#define CALL_Color3bv(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(const GLbyte *)), _gloffset_Color3bv, parameters) +#define GET_Color3bv(disp) GET_by_offset(disp, _gloffset_Color3bv) +#define SET_Color3bv(disp, fn) SET_by_offset(disp, _gloffset_Color3bv, fn) +#define CALL_Color3d(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLdouble, GLdouble, GLdouble)), _gloffset_Color3d, parameters) +#define GET_Color3d(disp) GET_by_offset(disp, _gloffset_Color3d) +#define SET_Color3d(disp, fn) SET_by_offset(disp, _gloffset_Color3d, fn) +#define CALL_Color3dv(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(const GLdouble *)), _gloffset_Color3dv, parameters) +#define GET_Color3dv(disp) GET_by_offset(disp, _gloffset_Color3dv) +#define SET_Color3dv(disp, fn) SET_by_offset(disp, _gloffset_Color3dv, fn) +#define CALL_Color3f(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLfloat, GLfloat, GLfloat)), _gloffset_Color3f, parameters) +#define GET_Color3f(disp) GET_by_offset(disp, _gloffset_Color3f) +#define SET_Color3f(disp, fn) SET_by_offset(disp, _gloffset_Color3f, fn) +#define CALL_Color3fv(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(const GLfloat *)), _gloffset_Color3fv, parameters) +#define GET_Color3fv(disp) GET_by_offset(disp, _gloffset_Color3fv) +#define SET_Color3fv(disp, fn) SET_by_offset(disp, _gloffset_Color3fv, fn) +#define CALL_Color3i(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLint, GLint, GLint)), _gloffset_Color3i, parameters) +#define GET_Color3i(disp) GET_by_offset(disp, _gloffset_Color3i) +#define SET_Color3i(disp, fn) SET_by_offset(disp, _gloffset_Color3i, fn) +#define CALL_Color3iv(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(const GLint *)), _gloffset_Color3iv, parameters) +#define GET_Color3iv(disp) GET_by_offset(disp, _gloffset_Color3iv) +#define SET_Color3iv(disp, fn) SET_by_offset(disp, _gloffset_Color3iv, fn) +#define CALL_Color3s(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLshort, GLshort, GLshort)), _gloffset_Color3s, parameters) +#define GET_Color3s(disp) GET_by_offset(disp, _gloffset_Color3s) +#define SET_Color3s(disp, fn) SET_by_offset(disp, _gloffset_Color3s, fn) +#define CALL_Color3sv(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(const GLshort *)), _gloffset_Color3sv, parameters) +#define GET_Color3sv(disp) GET_by_offset(disp, _gloffset_Color3sv) +#define SET_Color3sv(disp, fn) SET_by_offset(disp, _gloffset_Color3sv, fn) +#define CALL_Color3ub(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLubyte, GLubyte, GLubyte)), _gloffset_Color3ub, parameters) +#define GET_Color3ub(disp) GET_by_offset(disp, _gloffset_Color3ub) +#define SET_Color3ub(disp, fn) SET_by_offset(disp, _gloffset_Color3ub, fn) +#define CALL_Color3ubv(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(const GLubyte *)), _gloffset_Color3ubv, parameters) +#define GET_Color3ubv(disp) GET_by_offset(disp, _gloffset_Color3ubv) +#define SET_Color3ubv(disp, fn) SET_by_offset(disp, _gloffset_Color3ubv, fn) +#define CALL_Color3ui(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLuint, GLuint, GLuint)), _gloffset_Color3ui, parameters) +#define GET_Color3ui(disp) GET_by_offset(disp, _gloffset_Color3ui) +#define SET_Color3ui(disp, fn) SET_by_offset(disp, _gloffset_Color3ui, fn) +#define CALL_Color3uiv(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(const GLuint *)), _gloffset_Color3uiv, parameters) +#define GET_Color3uiv(disp) GET_by_offset(disp, _gloffset_Color3uiv) +#define SET_Color3uiv(disp, fn) SET_by_offset(disp, _gloffset_Color3uiv, fn) +#define CALL_Color3us(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLushort, GLushort, GLushort)), _gloffset_Color3us, parameters) +#define GET_Color3us(disp) GET_by_offset(disp, _gloffset_Color3us) +#define SET_Color3us(disp, fn) SET_by_offset(disp, _gloffset_Color3us, fn) +#define CALL_Color3usv(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(const GLushort *)), _gloffset_Color3usv, parameters) +#define GET_Color3usv(disp) GET_by_offset(disp, _gloffset_Color3usv) +#define SET_Color3usv(disp, fn) SET_by_offset(disp, _gloffset_Color3usv, fn) +#define CALL_Color4b(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLbyte, GLbyte, GLbyte, GLbyte)), _gloffset_Color4b, parameters) +#define GET_Color4b(disp) GET_by_offset(disp, _gloffset_Color4b) +#define SET_Color4b(disp, fn) SET_by_offset(disp, _gloffset_Color4b, fn) +#define CALL_Color4bv(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(const GLbyte *)), _gloffset_Color4bv, parameters) +#define GET_Color4bv(disp) GET_by_offset(disp, _gloffset_Color4bv) +#define SET_Color4bv(disp, fn) SET_by_offset(disp, _gloffset_Color4bv, fn) +#define CALL_Color4d(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLdouble, GLdouble, GLdouble, GLdouble)), _gloffset_Color4d, parameters) +#define GET_Color4d(disp) GET_by_offset(disp, _gloffset_Color4d) +#define SET_Color4d(disp, fn) SET_by_offset(disp, _gloffset_Color4d, fn) +#define CALL_Color4dv(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(const GLdouble *)), _gloffset_Color4dv, parameters) +#define GET_Color4dv(disp) GET_by_offset(disp, _gloffset_Color4dv) +#define SET_Color4dv(disp, fn) SET_by_offset(disp, _gloffset_Color4dv, fn) +#define CALL_Color4f(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLfloat, GLfloat, GLfloat, GLfloat)), _gloffset_Color4f, parameters) +#define GET_Color4f(disp) GET_by_offset(disp, _gloffset_Color4f) +#define SET_Color4f(disp, fn) SET_by_offset(disp, _gloffset_Color4f, fn) +#define CALL_Color4fv(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(const GLfloat *)), _gloffset_Color4fv, parameters) +#define GET_Color4fv(disp) GET_by_offset(disp, _gloffset_Color4fv) +#define SET_Color4fv(disp, fn) SET_by_offset(disp, _gloffset_Color4fv, fn) +#define CALL_Color4i(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLint, GLint, GLint, GLint)), _gloffset_Color4i, parameters) +#define GET_Color4i(disp) GET_by_offset(disp, _gloffset_Color4i) +#define SET_Color4i(disp, fn) SET_by_offset(disp, _gloffset_Color4i, fn) +#define CALL_Color4iv(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(const GLint *)), _gloffset_Color4iv, parameters) +#define GET_Color4iv(disp) GET_by_offset(disp, _gloffset_Color4iv) +#define SET_Color4iv(disp, fn) SET_by_offset(disp, _gloffset_Color4iv, fn) +#define CALL_Color4s(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLshort, GLshort, GLshort, GLshort)), _gloffset_Color4s, parameters) +#define GET_Color4s(disp) GET_by_offset(disp, _gloffset_Color4s) +#define SET_Color4s(disp, fn) SET_by_offset(disp, _gloffset_Color4s, fn) +#define CALL_Color4sv(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(const GLshort *)), _gloffset_Color4sv, parameters) +#define GET_Color4sv(disp) GET_by_offset(disp, _gloffset_Color4sv) +#define SET_Color4sv(disp, fn) SET_by_offset(disp, _gloffset_Color4sv, fn) +#define CALL_Color4ub(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLubyte, GLubyte, GLubyte, GLubyte)), _gloffset_Color4ub, parameters) +#define GET_Color4ub(disp) GET_by_offset(disp, _gloffset_Color4ub) +#define SET_Color4ub(disp, fn) SET_by_offset(disp, _gloffset_Color4ub, fn) +#define CALL_Color4ubv(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(const GLubyte *)), _gloffset_Color4ubv, parameters) +#define GET_Color4ubv(disp) GET_by_offset(disp, _gloffset_Color4ubv) +#define SET_Color4ubv(disp, fn) SET_by_offset(disp, _gloffset_Color4ubv, fn) +#define CALL_Color4ui(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLuint, GLuint, GLuint, GLuint)), _gloffset_Color4ui, parameters) +#define GET_Color4ui(disp) GET_by_offset(disp, _gloffset_Color4ui) +#define SET_Color4ui(disp, fn) SET_by_offset(disp, _gloffset_Color4ui, fn) +#define CALL_Color4uiv(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(const GLuint *)), _gloffset_Color4uiv, parameters) +#define GET_Color4uiv(disp) GET_by_offset(disp, _gloffset_Color4uiv) +#define SET_Color4uiv(disp, fn) SET_by_offset(disp, _gloffset_Color4uiv, fn) +#define CALL_Color4us(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLushort, GLushort, GLushort, GLushort)), _gloffset_Color4us, parameters) +#define GET_Color4us(disp) GET_by_offset(disp, _gloffset_Color4us) +#define SET_Color4us(disp, fn) SET_by_offset(disp, _gloffset_Color4us, fn) +#define CALL_Color4usv(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(const GLushort *)), _gloffset_Color4usv, parameters) +#define GET_Color4usv(disp) GET_by_offset(disp, _gloffset_Color4usv) +#define SET_Color4usv(disp, fn) SET_by_offset(disp, _gloffset_Color4usv, fn) +#define CALL_EdgeFlag(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLboolean)), _gloffset_EdgeFlag, parameters) +#define GET_EdgeFlag(disp) GET_by_offset(disp, _gloffset_EdgeFlag) +#define SET_EdgeFlag(disp, fn) SET_by_offset(disp, _gloffset_EdgeFlag, fn) +#define CALL_EdgeFlagv(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(const GLboolean *)), _gloffset_EdgeFlagv, parameters) +#define GET_EdgeFlagv(disp) GET_by_offset(disp, _gloffset_EdgeFlagv) +#define SET_EdgeFlagv(disp, fn) SET_by_offset(disp, _gloffset_EdgeFlagv, fn) +#define CALL_End(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(void)), _gloffset_End, parameters) +#define GET_End(disp) GET_by_offset(disp, _gloffset_End) +#define SET_End(disp, fn) SET_by_offset(disp, _gloffset_End, fn) +#define CALL_Indexd(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLdouble)), _gloffset_Indexd, parameters) +#define GET_Indexd(disp) GET_by_offset(disp, _gloffset_Indexd) +#define SET_Indexd(disp, fn) SET_by_offset(disp, _gloffset_Indexd, fn) +#define CALL_Indexdv(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(const GLdouble *)), _gloffset_Indexdv, parameters) +#define GET_Indexdv(disp) GET_by_offset(disp, _gloffset_Indexdv) +#define SET_Indexdv(disp, fn) SET_by_offset(disp, _gloffset_Indexdv, fn) +#define CALL_Indexf(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLfloat)), _gloffset_Indexf, parameters) +#define GET_Indexf(disp) GET_by_offset(disp, _gloffset_Indexf) +#define SET_Indexf(disp, fn) SET_by_offset(disp, _gloffset_Indexf, fn) +#define CALL_Indexfv(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(const GLfloat *)), _gloffset_Indexfv, parameters) +#define GET_Indexfv(disp) GET_by_offset(disp, _gloffset_Indexfv) +#define SET_Indexfv(disp, fn) SET_by_offset(disp, _gloffset_Indexfv, fn) +#define CALL_Indexi(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLint)), _gloffset_Indexi, parameters) +#define GET_Indexi(disp) GET_by_offset(disp, _gloffset_Indexi) +#define SET_Indexi(disp, fn) SET_by_offset(disp, _gloffset_Indexi, fn) +#define CALL_Indexiv(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(const GLint *)), _gloffset_Indexiv, parameters) +#define GET_Indexiv(disp) GET_by_offset(disp, _gloffset_Indexiv) +#define SET_Indexiv(disp, fn) SET_by_offset(disp, _gloffset_Indexiv, fn) +#define CALL_Indexs(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLshort)), _gloffset_Indexs, parameters) +#define GET_Indexs(disp) GET_by_offset(disp, _gloffset_Indexs) +#define SET_Indexs(disp, fn) SET_by_offset(disp, _gloffset_Indexs, fn) +#define CALL_Indexsv(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(const GLshort *)), _gloffset_Indexsv, parameters) +#define GET_Indexsv(disp) GET_by_offset(disp, _gloffset_Indexsv) +#define SET_Indexsv(disp, fn) SET_by_offset(disp, _gloffset_Indexsv, fn) +#define CALL_Normal3b(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLbyte, GLbyte, GLbyte)), _gloffset_Normal3b, parameters) +#define GET_Normal3b(disp) GET_by_offset(disp, _gloffset_Normal3b) +#define SET_Normal3b(disp, fn) SET_by_offset(disp, _gloffset_Normal3b, fn) +#define CALL_Normal3bv(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(const GLbyte *)), _gloffset_Normal3bv, parameters) +#define GET_Normal3bv(disp) GET_by_offset(disp, _gloffset_Normal3bv) +#define SET_Normal3bv(disp, fn) SET_by_offset(disp, _gloffset_Normal3bv, fn) +#define CALL_Normal3d(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLdouble, GLdouble, GLdouble)), _gloffset_Normal3d, parameters) +#define GET_Normal3d(disp) GET_by_offset(disp, _gloffset_Normal3d) +#define SET_Normal3d(disp, fn) SET_by_offset(disp, _gloffset_Normal3d, fn) +#define CALL_Normal3dv(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(const GLdouble *)), _gloffset_Normal3dv, parameters) +#define GET_Normal3dv(disp) GET_by_offset(disp, _gloffset_Normal3dv) +#define SET_Normal3dv(disp, fn) SET_by_offset(disp, _gloffset_Normal3dv, fn) +#define CALL_Normal3f(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLfloat, GLfloat, GLfloat)), _gloffset_Normal3f, parameters) +#define GET_Normal3f(disp) GET_by_offset(disp, _gloffset_Normal3f) +#define SET_Normal3f(disp, fn) SET_by_offset(disp, _gloffset_Normal3f, fn) +#define CALL_Normal3fv(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(const GLfloat *)), _gloffset_Normal3fv, parameters) +#define GET_Normal3fv(disp) GET_by_offset(disp, _gloffset_Normal3fv) +#define SET_Normal3fv(disp, fn) SET_by_offset(disp, _gloffset_Normal3fv, fn) +#define CALL_Normal3i(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLint, GLint, GLint)), _gloffset_Normal3i, parameters) +#define GET_Normal3i(disp) GET_by_offset(disp, _gloffset_Normal3i) +#define SET_Normal3i(disp, fn) SET_by_offset(disp, _gloffset_Normal3i, fn) +#define CALL_Normal3iv(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(const GLint *)), _gloffset_Normal3iv, parameters) +#define GET_Normal3iv(disp) GET_by_offset(disp, _gloffset_Normal3iv) +#define SET_Normal3iv(disp, fn) SET_by_offset(disp, _gloffset_Normal3iv, fn) +#define CALL_Normal3s(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLshort, GLshort, GLshort)), _gloffset_Normal3s, parameters) +#define GET_Normal3s(disp) GET_by_offset(disp, _gloffset_Normal3s) +#define SET_Normal3s(disp, fn) SET_by_offset(disp, _gloffset_Normal3s, fn) +#define CALL_Normal3sv(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(const GLshort *)), _gloffset_Normal3sv, parameters) +#define GET_Normal3sv(disp) GET_by_offset(disp, _gloffset_Normal3sv) +#define SET_Normal3sv(disp, fn) SET_by_offset(disp, _gloffset_Normal3sv, fn) +#define CALL_RasterPos2d(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLdouble, GLdouble)), _gloffset_RasterPos2d, parameters) +#define GET_RasterPos2d(disp) GET_by_offset(disp, _gloffset_RasterPos2d) +#define SET_RasterPos2d(disp, fn) SET_by_offset(disp, _gloffset_RasterPos2d, fn) +#define CALL_RasterPos2dv(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(const GLdouble *)), _gloffset_RasterPos2dv, parameters) +#define GET_RasterPos2dv(disp) GET_by_offset(disp, _gloffset_RasterPos2dv) +#define SET_RasterPos2dv(disp, fn) SET_by_offset(disp, _gloffset_RasterPos2dv, fn) +#define CALL_RasterPos2f(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLfloat, GLfloat)), _gloffset_RasterPos2f, parameters) +#define GET_RasterPos2f(disp) GET_by_offset(disp, _gloffset_RasterPos2f) +#define SET_RasterPos2f(disp, fn) SET_by_offset(disp, _gloffset_RasterPos2f, fn) +#define CALL_RasterPos2fv(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(const GLfloat *)), _gloffset_RasterPos2fv, parameters) +#define GET_RasterPos2fv(disp) GET_by_offset(disp, _gloffset_RasterPos2fv) +#define SET_RasterPos2fv(disp, fn) SET_by_offset(disp, _gloffset_RasterPos2fv, fn) +#define CALL_RasterPos2i(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLint, GLint)), _gloffset_RasterPos2i, parameters) +#define GET_RasterPos2i(disp) GET_by_offset(disp, _gloffset_RasterPos2i) +#define SET_RasterPos2i(disp, fn) SET_by_offset(disp, _gloffset_RasterPos2i, fn) +#define CALL_RasterPos2iv(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(const GLint *)), _gloffset_RasterPos2iv, parameters) +#define GET_RasterPos2iv(disp) GET_by_offset(disp, _gloffset_RasterPos2iv) +#define SET_RasterPos2iv(disp, fn) SET_by_offset(disp, _gloffset_RasterPos2iv, fn) +#define CALL_RasterPos2s(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLshort, GLshort)), _gloffset_RasterPos2s, parameters) +#define GET_RasterPos2s(disp) GET_by_offset(disp, _gloffset_RasterPos2s) +#define SET_RasterPos2s(disp, fn) SET_by_offset(disp, _gloffset_RasterPos2s, fn) +#define CALL_RasterPos2sv(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(const GLshort *)), _gloffset_RasterPos2sv, parameters) +#define GET_RasterPos2sv(disp) GET_by_offset(disp, _gloffset_RasterPos2sv) +#define SET_RasterPos2sv(disp, fn) SET_by_offset(disp, _gloffset_RasterPos2sv, fn) +#define CALL_RasterPos3d(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLdouble, GLdouble, GLdouble)), _gloffset_RasterPos3d, parameters) +#define GET_RasterPos3d(disp) GET_by_offset(disp, _gloffset_RasterPos3d) +#define SET_RasterPos3d(disp, fn) SET_by_offset(disp, _gloffset_RasterPos3d, fn) +#define CALL_RasterPos3dv(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(const GLdouble *)), _gloffset_RasterPos3dv, parameters) +#define GET_RasterPos3dv(disp) GET_by_offset(disp, _gloffset_RasterPos3dv) +#define SET_RasterPos3dv(disp, fn) SET_by_offset(disp, _gloffset_RasterPos3dv, fn) +#define CALL_RasterPos3f(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLfloat, GLfloat, GLfloat)), _gloffset_RasterPos3f, parameters) +#define GET_RasterPos3f(disp) GET_by_offset(disp, _gloffset_RasterPos3f) +#define SET_RasterPos3f(disp, fn) SET_by_offset(disp, _gloffset_RasterPos3f, fn) +#define CALL_RasterPos3fv(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(const GLfloat *)), _gloffset_RasterPos3fv, parameters) +#define GET_RasterPos3fv(disp) GET_by_offset(disp, _gloffset_RasterPos3fv) +#define SET_RasterPos3fv(disp, fn) SET_by_offset(disp, _gloffset_RasterPos3fv, fn) +#define CALL_RasterPos3i(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLint, GLint, GLint)), _gloffset_RasterPos3i, parameters) +#define GET_RasterPos3i(disp) GET_by_offset(disp, _gloffset_RasterPos3i) +#define SET_RasterPos3i(disp, fn) SET_by_offset(disp, _gloffset_RasterPos3i, fn) +#define CALL_RasterPos3iv(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(const GLint *)), _gloffset_RasterPos3iv, parameters) +#define GET_RasterPos3iv(disp) GET_by_offset(disp, _gloffset_RasterPos3iv) +#define SET_RasterPos3iv(disp, fn) SET_by_offset(disp, _gloffset_RasterPos3iv, fn) +#define CALL_RasterPos3s(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLshort, GLshort, GLshort)), _gloffset_RasterPos3s, parameters) +#define GET_RasterPos3s(disp) GET_by_offset(disp, _gloffset_RasterPos3s) +#define SET_RasterPos3s(disp, fn) SET_by_offset(disp, _gloffset_RasterPos3s, fn) +#define CALL_RasterPos3sv(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(const GLshort *)), _gloffset_RasterPos3sv, parameters) +#define GET_RasterPos3sv(disp) GET_by_offset(disp, _gloffset_RasterPos3sv) +#define SET_RasterPos3sv(disp, fn) SET_by_offset(disp, _gloffset_RasterPos3sv, fn) +#define CALL_RasterPos4d(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLdouble, GLdouble, GLdouble, GLdouble)), _gloffset_RasterPos4d, parameters) +#define GET_RasterPos4d(disp) GET_by_offset(disp, _gloffset_RasterPos4d) +#define SET_RasterPos4d(disp, fn) SET_by_offset(disp, _gloffset_RasterPos4d, fn) +#define CALL_RasterPos4dv(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(const GLdouble *)), _gloffset_RasterPos4dv, parameters) +#define GET_RasterPos4dv(disp) GET_by_offset(disp, _gloffset_RasterPos4dv) +#define SET_RasterPos4dv(disp, fn) SET_by_offset(disp, _gloffset_RasterPos4dv, fn) +#define CALL_RasterPos4f(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLfloat, GLfloat, GLfloat, GLfloat)), _gloffset_RasterPos4f, parameters) +#define GET_RasterPos4f(disp) GET_by_offset(disp, _gloffset_RasterPos4f) +#define SET_RasterPos4f(disp, fn) SET_by_offset(disp, _gloffset_RasterPos4f, fn) +#define CALL_RasterPos4fv(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(const GLfloat *)), _gloffset_RasterPos4fv, parameters) +#define GET_RasterPos4fv(disp) GET_by_offset(disp, _gloffset_RasterPos4fv) +#define SET_RasterPos4fv(disp, fn) SET_by_offset(disp, _gloffset_RasterPos4fv, fn) +#define CALL_RasterPos4i(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLint, GLint, GLint, GLint)), _gloffset_RasterPos4i, parameters) +#define GET_RasterPos4i(disp) GET_by_offset(disp, _gloffset_RasterPos4i) +#define SET_RasterPos4i(disp, fn) SET_by_offset(disp, _gloffset_RasterPos4i, fn) +#define CALL_RasterPos4iv(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(const GLint *)), _gloffset_RasterPos4iv, parameters) +#define GET_RasterPos4iv(disp) GET_by_offset(disp, _gloffset_RasterPos4iv) +#define SET_RasterPos4iv(disp, fn) SET_by_offset(disp, _gloffset_RasterPos4iv, fn) +#define CALL_RasterPos4s(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLshort, GLshort, GLshort, GLshort)), _gloffset_RasterPos4s, parameters) +#define GET_RasterPos4s(disp) GET_by_offset(disp, _gloffset_RasterPos4s) +#define SET_RasterPos4s(disp, fn) SET_by_offset(disp, _gloffset_RasterPos4s, fn) +#define CALL_RasterPos4sv(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(const GLshort *)), _gloffset_RasterPos4sv, parameters) +#define GET_RasterPos4sv(disp) GET_by_offset(disp, _gloffset_RasterPos4sv) +#define SET_RasterPos4sv(disp, fn) SET_by_offset(disp, _gloffset_RasterPos4sv, fn) +#define CALL_Rectd(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLdouble, GLdouble, GLdouble, GLdouble)), _gloffset_Rectd, parameters) +#define GET_Rectd(disp) GET_by_offset(disp, _gloffset_Rectd) +#define SET_Rectd(disp, fn) SET_by_offset(disp, _gloffset_Rectd, fn) +#define CALL_Rectdv(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(const GLdouble *, const GLdouble *)), _gloffset_Rectdv, parameters) +#define GET_Rectdv(disp) GET_by_offset(disp, _gloffset_Rectdv) +#define SET_Rectdv(disp, fn) SET_by_offset(disp, _gloffset_Rectdv, fn) +#define CALL_Rectf(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLfloat, GLfloat, GLfloat, GLfloat)), _gloffset_Rectf, parameters) +#define GET_Rectf(disp) GET_by_offset(disp, _gloffset_Rectf) +#define SET_Rectf(disp, fn) SET_by_offset(disp, _gloffset_Rectf, fn) +#define CALL_Rectfv(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(const GLfloat *, const GLfloat *)), _gloffset_Rectfv, parameters) +#define GET_Rectfv(disp) GET_by_offset(disp, _gloffset_Rectfv) +#define SET_Rectfv(disp, fn) SET_by_offset(disp, _gloffset_Rectfv, fn) +#define CALL_Recti(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLint, GLint, GLint, GLint)), _gloffset_Recti, parameters) +#define GET_Recti(disp) GET_by_offset(disp, _gloffset_Recti) +#define SET_Recti(disp, fn) SET_by_offset(disp, _gloffset_Recti, fn) +#define CALL_Rectiv(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(const GLint *, const GLint *)), _gloffset_Rectiv, parameters) +#define GET_Rectiv(disp) GET_by_offset(disp, _gloffset_Rectiv) +#define SET_Rectiv(disp, fn) SET_by_offset(disp, _gloffset_Rectiv, fn) +#define CALL_Rects(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLshort, GLshort, GLshort, GLshort)), _gloffset_Rects, parameters) +#define GET_Rects(disp) GET_by_offset(disp, _gloffset_Rects) +#define SET_Rects(disp, fn) SET_by_offset(disp, _gloffset_Rects, fn) +#define CALL_Rectsv(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(const GLshort *, const GLshort *)), _gloffset_Rectsv, parameters) +#define GET_Rectsv(disp) GET_by_offset(disp, _gloffset_Rectsv) +#define SET_Rectsv(disp, fn) SET_by_offset(disp, _gloffset_Rectsv, fn) +#define CALL_TexCoord1d(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLdouble)), _gloffset_TexCoord1d, parameters) +#define GET_TexCoord1d(disp) GET_by_offset(disp, _gloffset_TexCoord1d) +#define SET_TexCoord1d(disp, fn) SET_by_offset(disp, _gloffset_TexCoord1d, fn) +#define CALL_TexCoord1dv(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(const GLdouble *)), _gloffset_TexCoord1dv, parameters) +#define GET_TexCoord1dv(disp) GET_by_offset(disp, _gloffset_TexCoord1dv) +#define SET_TexCoord1dv(disp, fn) SET_by_offset(disp, _gloffset_TexCoord1dv, fn) +#define CALL_TexCoord1f(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLfloat)), _gloffset_TexCoord1f, parameters) +#define GET_TexCoord1f(disp) GET_by_offset(disp, _gloffset_TexCoord1f) +#define SET_TexCoord1f(disp, fn) SET_by_offset(disp, _gloffset_TexCoord1f, fn) +#define CALL_TexCoord1fv(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(const GLfloat *)), _gloffset_TexCoord1fv, parameters) +#define GET_TexCoord1fv(disp) GET_by_offset(disp, _gloffset_TexCoord1fv) +#define SET_TexCoord1fv(disp, fn) SET_by_offset(disp, _gloffset_TexCoord1fv, fn) +#define CALL_TexCoord1i(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLint)), _gloffset_TexCoord1i, parameters) +#define GET_TexCoord1i(disp) GET_by_offset(disp, _gloffset_TexCoord1i) +#define SET_TexCoord1i(disp, fn) SET_by_offset(disp, _gloffset_TexCoord1i, fn) +#define CALL_TexCoord1iv(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(const GLint *)), _gloffset_TexCoord1iv, parameters) +#define GET_TexCoord1iv(disp) GET_by_offset(disp, _gloffset_TexCoord1iv) +#define SET_TexCoord1iv(disp, fn) SET_by_offset(disp, _gloffset_TexCoord1iv, fn) +#define CALL_TexCoord1s(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLshort)), _gloffset_TexCoord1s, parameters) +#define GET_TexCoord1s(disp) GET_by_offset(disp, _gloffset_TexCoord1s) +#define SET_TexCoord1s(disp, fn) SET_by_offset(disp, _gloffset_TexCoord1s, fn) +#define CALL_TexCoord1sv(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(const GLshort *)), _gloffset_TexCoord1sv, parameters) +#define GET_TexCoord1sv(disp) GET_by_offset(disp, _gloffset_TexCoord1sv) +#define SET_TexCoord1sv(disp, fn) SET_by_offset(disp, _gloffset_TexCoord1sv, fn) +#define CALL_TexCoord2d(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLdouble, GLdouble)), _gloffset_TexCoord2d, parameters) +#define GET_TexCoord2d(disp) GET_by_offset(disp, _gloffset_TexCoord2d) +#define SET_TexCoord2d(disp, fn) SET_by_offset(disp, _gloffset_TexCoord2d, fn) +#define CALL_TexCoord2dv(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(const GLdouble *)), _gloffset_TexCoord2dv, parameters) +#define GET_TexCoord2dv(disp) GET_by_offset(disp, _gloffset_TexCoord2dv) +#define SET_TexCoord2dv(disp, fn) SET_by_offset(disp, _gloffset_TexCoord2dv, fn) +#define CALL_TexCoord2f(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLfloat, GLfloat)), _gloffset_TexCoord2f, parameters) +#define GET_TexCoord2f(disp) GET_by_offset(disp, _gloffset_TexCoord2f) +#define SET_TexCoord2f(disp, fn) SET_by_offset(disp, _gloffset_TexCoord2f, fn) +#define CALL_TexCoord2fv(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(const GLfloat *)), _gloffset_TexCoord2fv, parameters) +#define GET_TexCoord2fv(disp) GET_by_offset(disp, _gloffset_TexCoord2fv) +#define SET_TexCoord2fv(disp, fn) SET_by_offset(disp, _gloffset_TexCoord2fv, fn) +#define CALL_TexCoord2i(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLint, GLint)), _gloffset_TexCoord2i, parameters) +#define GET_TexCoord2i(disp) GET_by_offset(disp, _gloffset_TexCoord2i) +#define SET_TexCoord2i(disp, fn) SET_by_offset(disp, _gloffset_TexCoord2i, fn) +#define CALL_TexCoord2iv(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(const GLint *)), _gloffset_TexCoord2iv, parameters) +#define GET_TexCoord2iv(disp) GET_by_offset(disp, _gloffset_TexCoord2iv) +#define SET_TexCoord2iv(disp, fn) SET_by_offset(disp, _gloffset_TexCoord2iv, fn) +#define CALL_TexCoord2s(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLshort, GLshort)), _gloffset_TexCoord2s, parameters) +#define GET_TexCoord2s(disp) GET_by_offset(disp, _gloffset_TexCoord2s) +#define SET_TexCoord2s(disp, fn) SET_by_offset(disp, _gloffset_TexCoord2s, fn) +#define CALL_TexCoord2sv(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(const GLshort *)), _gloffset_TexCoord2sv, parameters) +#define GET_TexCoord2sv(disp) GET_by_offset(disp, _gloffset_TexCoord2sv) +#define SET_TexCoord2sv(disp, fn) SET_by_offset(disp, _gloffset_TexCoord2sv, fn) +#define CALL_TexCoord3d(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLdouble, GLdouble, GLdouble)), _gloffset_TexCoord3d, parameters) +#define GET_TexCoord3d(disp) GET_by_offset(disp, _gloffset_TexCoord3d) +#define SET_TexCoord3d(disp, fn) SET_by_offset(disp, _gloffset_TexCoord3d, fn) +#define CALL_TexCoord3dv(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(const GLdouble *)), _gloffset_TexCoord3dv, parameters) +#define GET_TexCoord3dv(disp) GET_by_offset(disp, _gloffset_TexCoord3dv) +#define SET_TexCoord3dv(disp, fn) SET_by_offset(disp, _gloffset_TexCoord3dv, fn) +#define CALL_TexCoord3f(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLfloat, GLfloat, GLfloat)), _gloffset_TexCoord3f, parameters) +#define GET_TexCoord3f(disp) GET_by_offset(disp, _gloffset_TexCoord3f) +#define SET_TexCoord3f(disp, fn) SET_by_offset(disp, _gloffset_TexCoord3f, fn) +#define CALL_TexCoord3fv(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(const GLfloat *)), _gloffset_TexCoord3fv, parameters) +#define GET_TexCoord3fv(disp) GET_by_offset(disp, _gloffset_TexCoord3fv) +#define SET_TexCoord3fv(disp, fn) SET_by_offset(disp, _gloffset_TexCoord3fv, fn) +#define CALL_TexCoord3i(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLint, GLint, GLint)), _gloffset_TexCoord3i, parameters) +#define GET_TexCoord3i(disp) GET_by_offset(disp, _gloffset_TexCoord3i) +#define SET_TexCoord3i(disp, fn) SET_by_offset(disp, _gloffset_TexCoord3i, fn) +#define CALL_TexCoord3iv(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(const GLint *)), _gloffset_TexCoord3iv, parameters) +#define GET_TexCoord3iv(disp) GET_by_offset(disp, _gloffset_TexCoord3iv) +#define SET_TexCoord3iv(disp, fn) SET_by_offset(disp, _gloffset_TexCoord3iv, fn) +#define CALL_TexCoord3s(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLshort, GLshort, GLshort)), _gloffset_TexCoord3s, parameters) +#define GET_TexCoord3s(disp) GET_by_offset(disp, _gloffset_TexCoord3s) +#define SET_TexCoord3s(disp, fn) SET_by_offset(disp, _gloffset_TexCoord3s, fn) +#define CALL_TexCoord3sv(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(const GLshort *)), _gloffset_TexCoord3sv, parameters) +#define GET_TexCoord3sv(disp) GET_by_offset(disp, _gloffset_TexCoord3sv) +#define SET_TexCoord3sv(disp, fn) SET_by_offset(disp, _gloffset_TexCoord3sv, fn) +#define CALL_TexCoord4d(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLdouble, GLdouble, GLdouble, GLdouble)), _gloffset_TexCoord4d, parameters) +#define GET_TexCoord4d(disp) GET_by_offset(disp, _gloffset_TexCoord4d) +#define SET_TexCoord4d(disp, fn) SET_by_offset(disp, _gloffset_TexCoord4d, fn) +#define CALL_TexCoord4dv(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(const GLdouble *)), _gloffset_TexCoord4dv, parameters) +#define GET_TexCoord4dv(disp) GET_by_offset(disp, _gloffset_TexCoord4dv) +#define SET_TexCoord4dv(disp, fn) SET_by_offset(disp, _gloffset_TexCoord4dv, fn) +#define CALL_TexCoord4f(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLfloat, GLfloat, GLfloat, GLfloat)), _gloffset_TexCoord4f, parameters) +#define GET_TexCoord4f(disp) GET_by_offset(disp, _gloffset_TexCoord4f) +#define SET_TexCoord4f(disp, fn) SET_by_offset(disp, _gloffset_TexCoord4f, fn) +#define CALL_TexCoord4fv(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(const GLfloat *)), _gloffset_TexCoord4fv, parameters) +#define GET_TexCoord4fv(disp) GET_by_offset(disp, _gloffset_TexCoord4fv) +#define SET_TexCoord4fv(disp, fn) SET_by_offset(disp, _gloffset_TexCoord4fv, fn) +#define CALL_TexCoord4i(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLint, GLint, GLint, GLint)), _gloffset_TexCoord4i, parameters) +#define GET_TexCoord4i(disp) GET_by_offset(disp, _gloffset_TexCoord4i) +#define SET_TexCoord4i(disp, fn) SET_by_offset(disp, _gloffset_TexCoord4i, fn) +#define CALL_TexCoord4iv(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(const GLint *)), _gloffset_TexCoord4iv, parameters) +#define GET_TexCoord4iv(disp) GET_by_offset(disp, _gloffset_TexCoord4iv) +#define SET_TexCoord4iv(disp, fn) SET_by_offset(disp, _gloffset_TexCoord4iv, fn) +#define CALL_TexCoord4s(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLshort, GLshort, GLshort, GLshort)), _gloffset_TexCoord4s, parameters) +#define GET_TexCoord4s(disp) GET_by_offset(disp, _gloffset_TexCoord4s) +#define SET_TexCoord4s(disp, fn) SET_by_offset(disp, _gloffset_TexCoord4s, fn) +#define CALL_TexCoord4sv(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(const GLshort *)), _gloffset_TexCoord4sv, parameters) +#define GET_TexCoord4sv(disp) GET_by_offset(disp, _gloffset_TexCoord4sv) +#define SET_TexCoord4sv(disp, fn) SET_by_offset(disp, _gloffset_TexCoord4sv, fn) +#define CALL_Vertex2d(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLdouble, GLdouble)), _gloffset_Vertex2d, parameters) +#define GET_Vertex2d(disp) GET_by_offset(disp, _gloffset_Vertex2d) +#define SET_Vertex2d(disp, fn) SET_by_offset(disp, _gloffset_Vertex2d, fn) +#define CALL_Vertex2dv(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(const GLdouble *)), _gloffset_Vertex2dv, parameters) +#define GET_Vertex2dv(disp) GET_by_offset(disp, _gloffset_Vertex2dv) +#define SET_Vertex2dv(disp, fn) SET_by_offset(disp, _gloffset_Vertex2dv, fn) +#define CALL_Vertex2f(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLfloat, GLfloat)), _gloffset_Vertex2f, parameters) +#define GET_Vertex2f(disp) GET_by_offset(disp, _gloffset_Vertex2f) +#define SET_Vertex2f(disp, fn) SET_by_offset(disp, _gloffset_Vertex2f, fn) +#define CALL_Vertex2fv(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(const GLfloat *)), _gloffset_Vertex2fv, parameters) +#define GET_Vertex2fv(disp) GET_by_offset(disp, _gloffset_Vertex2fv) +#define SET_Vertex2fv(disp, fn) SET_by_offset(disp, _gloffset_Vertex2fv, fn) +#define CALL_Vertex2i(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLint, GLint)), _gloffset_Vertex2i, parameters) +#define GET_Vertex2i(disp) GET_by_offset(disp, _gloffset_Vertex2i) +#define SET_Vertex2i(disp, fn) SET_by_offset(disp, _gloffset_Vertex2i, fn) +#define CALL_Vertex2iv(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(const GLint *)), _gloffset_Vertex2iv, parameters) +#define GET_Vertex2iv(disp) GET_by_offset(disp, _gloffset_Vertex2iv) +#define SET_Vertex2iv(disp, fn) SET_by_offset(disp, _gloffset_Vertex2iv, fn) +#define CALL_Vertex2s(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLshort, GLshort)), _gloffset_Vertex2s, parameters) +#define GET_Vertex2s(disp) GET_by_offset(disp, _gloffset_Vertex2s) +#define SET_Vertex2s(disp, fn) SET_by_offset(disp, _gloffset_Vertex2s, fn) +#define CALL_Vertex2sv(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(const GLshort *)), _gloffset_Vertex2sv, parameters) +#define GET_Vertex2sv(disp) GET_by_offset(disp, _gloffset_Vertex2sv) +#define SET_Vertex2sv(disp, fn) SET_by_offset(disp, _gloffset_Vertex2sv, fn) +#define CALL_Vertex3d(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLdouble, GLdouble, GLdouble)), _gloffset_Vertex3d, parameters) +#define GET_Vertex3d(disp) GET_by_offset(disp, _gloffset_Vertex3d) +#define SET_Vertex3d(disp, fn) SET_by_offset(disp, _gloffset_Vertex3d, fn) +#define CALL_Vertex3dv(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(const GLdouble *)), _gloffset_Vertex3dv, parameters) +#define GET_Vertex3dv(disp) GET_by_offset(disp, _gloffset_Vertex3dv) +#define SET_Vertex3dv(disp, fn) SET_by_offset(disp, _gloffset_Vertex3dv, fn) +#define CALL_Vertex3f(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLfloat, GLfloat, GLfloat)), _gloffset_Vertex3f, parameters) +#define GET_Vertex3f(disp) GET_by_offset(disp, _gloffset_Vertex3f) +#define SET_Vertex3f(disp, fn) SET_by_offset(disp, _gloffset_Vertex3f, fn) +#define CALL_Vertex3fv(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(const GLfloat *)), _gloffset_Vertex3fv, parameters) +#define GET_Vertex3fv(disp) GET_by_offset(disp, _gloffset_Vertex3fv) +#define SET_Vertex3fv(disp, fn) SET_by_offset(disp, _gloffset_Vertex3fv, fn) +#define CALL_Vertex3i(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLint, GLint, GLint)), _gloffset_Vertex3i, parameters) +#define GET_Vertex3i(disp) GET_by_offset(disp, _gloffset_Vertex3i) +#define SET_Vertex3i(disp, fn) SET_by_offset(disp, _gloffset_Vertex3i, fn) +#define CALL_Vertex3iv(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(const GLint *)), _gloffset_Vertex3iv, parameters) +#define GET_Vertex3iv(disp) GET_by_offset(disp, _gloffset_Vertex3iv) +#define SET_Vertex3iv(disp, fn) SET_by_offset(disp, _gloffset_Vertex3iv, fn) +#define CALL_Vertex3s(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLshort, GLshort, GLshort)), _gloffset_Vertex3s, parameters) +#define GET_Vertex3s(disp) GET_by_offset(disp, _gloffset_Vertex3s) +#define SET_Vertex3s(disp, fn) SET_by_offset(disp, _gloffset_Vertex3s, fn) +#define CALL_Vertex3sv(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(const GLshort *)), _gloffset_Vertex3sv, parameters) +#define GET_Vertex3sv(disp) GET_by_offset(disp, _gloffset_Vertex3sv) +#define SET_Vertex3sv(disp, fn) SET_by_offset(disp, _gloffset_Vertex3sv, fn) +#define CALL_Vertex4d(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLdouble, GLdouble, GLdouble, GLdouble)), _gloffset_Vertex4d, parameters) +#define GET_Vertex4d(disp) GET_by_offset(disp, _gloffset_Vertex4d) +#define SET_Vertex4d(disp, fn) SET_by_offset(disp, _gloffset_Vertex4d, fn) +#define CALL_Vertex4dv(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(const GLdouble *)), _gloffset_Vertex4dv, parameters) +#define GET_Vertex4dv(disp) GET_by_offset(disp, _gloffset_Vertex4dv) +#define SET_Vertex4dv(disp, fn) SET_by_offset(disp, _gloffset_Vertex4dv, fn) +#define CALL_Vertex4f(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLfloat, GLfloat, GLfloat, GLfloat)), _gloffset_Vertex4f, parameters) +#define GET_Vertex4f(disp) GET_by_offset(disp, _gloffset_Vertex4f) +#define SET_Vertex4f(disp, fn) SET_by_offset(disp, _gloffset_Vertex4f, fn) +#define CALL_Vertex4fv(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(const GLfloat *)), _gloffset_Vertex4fv, parameters) +#define GET_Vertex4fv(disp) GET_by_offset(disp, _gloffset_Vertex4fv) +#define SET_Vertex4fv(disp, fn) SET_by_offset(disp, _gloffset_Vertex4fv, fn) +#define CALL_Vertex4i(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLint, GLint, GLint, GLint)), _gloffset_Vertex4i, parameters) +#define GET_Vertex4i(disp) GET_by_offset(disp, _gloffset_Vertex4i) +#define SET_Vertex4i(disp, fn) SET_by_offset(disp, _gloffset_Vertex4i, fn) +#define CALL_Vertex4iv(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(const GLint *)), _gloffset_Vertex4iv, parameters) +#define GET_Vertex4iv(disp) GET_by_offset(disp, _gloffset_Vertex4iv) +#define SET_Vertex4iv(disp, fn) SET_by_offset(disp, _gloffset_Vertex4iv, fn) +#define CALL_Vertex4s(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLshort, GLshort, GLshort, GLshort)), _gloffset_Vertex4s, parameters) +#define GET_Vertex4s(disp) GET_by_offset(disp, _gloffset_Vertex4s) +#define SET_Vertex4s(disp, fn) SET_by_offset(disp, _gloffset_Vertex4s, fn) +#define CALL_Vertex4sv(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(const GLshort *)), _gloffset_Vertex4sv, parameters) +#define GET_Vertex4sv(disp) GET_by_offset(disp, _gloffset_Vertex4sv) +#define SET_Vertex4sv(disp, fn) SET_by_offset(disp, _gloffset_Vertex4sv, fn) +#define CALL_ClipPlane(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, const GLdouble *)), _gloffset_ClipPlane, parameters) +#define GET_ClipPlane(disp) GET_by_offset(disp, _gloffset_ClipPlane) +#define SET_ClipPlane(disp, fn) SET_by_offset(disp, _gloffset_ClipPlane, fn) +#define CALL_ColorMaterial(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLenum)), _gloffset_ColorMaterial, parameters) +#define GET_ColorMaterial(disp) GET_by_offset(disp, _gloffset_ColorMaterial) +#define SET_ColorMaterial(disp, fn) SET_by_offset(disp, _gloffset_ColorMaterial, fn) +#define CALL_CullFace(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum)), _gloffset_CullFace, parameters) +#define GET_CullFace(disp) GET_by_offset(disp, _gloffset_CullFace) +#define SET_CullFace(disp, fn) SET_by_offset(disp, _gloffset_CullFace, fn) +#define CALL_Fogf(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLfloat)), _gloffset_Fogf, parameters) +#define GET_Fogf(disp) GET_by_offset(disp, _gloffset_Fogf) +#define SET_Fogf(disp, fn) SET_by_offset(disp, _gloffset_Fogf, fn) +#define CALL_Fogfv(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, const GLfloat *)), _gloffset_Fogfv, parameters) +#define GET_Fogfv(disp) GET_by_offset(disp, _gloffset_Fogfv) +#define SET_Fogfv(disp, fn) SET_by_offset(disp, _gloffset_Fogfv, fn) +#define CALL_Fogi(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLint)), _gloffset_Fogi, parameters) +#define GET_Fogi(disp) GET_by_offset(disp, _gloffset_Fogi) +#define SET_Fogi(disp, fn) SET_by_offset(disp, _gloffset_Fogi, fn) +#define CALL_Fogiv(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, const GLint *)), _gloffset_Fogiv, parameters) +#define GET_Fogiv(disp) GET_by_offset(disp, _gloffset_Fogiv) +#define SET_Fogiv(disp, fn) SET_by_offset(disp, _gloffset_Fogiv, fn) +#define CALL_FrontFace(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum)), _gloffset_FrontFace, parameters) +#define GET_FrontFace(disp) GET_by_offset(disp, _gloffset_FrontFace) +#define SET_FrontFace(disp, fn) SET_by_offset(disp, _gloffset_FrontFace, fn) +#define CALL_Hint(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLenum)), _gloffset_Hint, parameters) +#define GET_Hint(disp) GET_by_offset(disp, _gloffset_Hint) +#define SET_Hint(disp, fn) SET_by_offset(disp, _gloffset_Hint, fn) +#define CALL_Lightf(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLenum, GLfloat)), _gloffset_Lightf, parameters) +#define GET_Lightf(disp) GET_by_offset(disp, _gloffset_Lightf) +#define SET_Lightf(disp, fn) SET_by_offset(disp, _gloffset_Lightf, fn) +#define CALL_Lightfv(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLenum, const GLfloat *)), _gloffset_Lightfv, parameters) +#define GET_Lightfv(disp) GET_by_offset(disp, _gloffset_Lightfv) +#define SET_Lightfv(disp, fn) SET_by_offset(disp, _gloffset_Lightfv, fn) +#define CALL_Lighti(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLenum, GLint)), _gloffset_Lighti, parameters) +#define GET_Lighti(disp) GET_by_offset(disp, _gloffset_Lighti) +#define SET_Lighti(disp, fn) SET_by_offset(disp, _gloffset_Lighti, fn) +#define CALL_Lightiv(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLenum, const GLint *)), _gloffset_Lightiv, parameters) +#define GET_Lightiv(disp) GET_by_offset(disp, _gloffset_Lightiv) +#define SET_Lightiv(disp, fn) SET_by_offset(disp, _gloffset_Lightiv, fn) +#define CALL_LightModelf(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLfloat)), _gloffset_LightModelf, parameters) +#define GET_LightModelf(disp) GET_by_offset(disp, _gloffset_LightModelf) +#define SET_LightModelf(disp, fn) SET_by_offset(disp, _gloffset_LightModelf, fn) +#define CALL_LightModelfv(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, const GLfloat *)), _gloffset_LightModelfv, parameters) +#define GET_LightModelfv(disp) GET_by_offset(disp, _gloffset_LightModelfv) +#define SET_LightModelfv(disp, fn) SET_by_offset(disp, _gloffset_LightModelfv, fn) +#define CALL_LightModeli(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLint)), _gloffset_LightModeli, parameters) +#define GET_LightModeli(disp) GET_by_offset(disp, _gloffset_LightModeli) +#define SET_LightModeli(disp, fn) SET_by_offset(disp, _gloffset_LightModeli, fn) +#define CALL_LightModeliv(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, const GLint *)), _gloffset_LightModeliv, parameters) +#define GET_LightModeliv(disp) GET_by_offset(disp, _gloffset_LightModeliv) +#define SET_LightModeliv(disp, fn) SET_by_offset(disp, _gloffset_LightModeliv, fn) +#define CALL_LineStipple(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLint, GLushort)), _gloffset_LineStipple, parameters) +#define GET_LineStipple(disp) GET_by_offset(disp, _gloffset_LineStipple) +#define SET_LineStipple(disp, fn) SET_by_offset(disp, _gloffset_LineStipple, fn) +#define CALL_LineWidth(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLfloat)), _gloffset_LineWidth, parameters) +#define GET_LineWidth(disp) GET_by_offset(disp, _gloffset_LineWidth) +#define SET_LineWidth(disp, fn) SET_by_offset(disp, _gloffset_LineWidth, fn) +#define CALL_Materialf(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLenum, GLfloat)), _gloffset_Materialf, parameters) +#define GET_Materialf(disp) GET_by_offset(disp, _gloffset_Materialf) +#define SET_Materialf(disp, fn) SET_by_offset(disp, _gloffset_Materialf, fn) +#define CALL_Materialfv(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLenum, const GLfloat *)), _gloffset_Materialfv, parameters) +#define GET_Materialfv(disp) GET_by_offset(disp, _gloffset_Materialfv) +#define SET_Materialfv(disp, fn) SET_by_offset(disp, _gloffset_Materialfv, fn) +#define CALL_Materiali(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLenum, GLint)), _gloffset_Materiali, parameters) +#define GET_Materiali(disp) GET_by_offset(disp, _gloffset_Materiali) +#define SET_Materiali(disp, fn) SET_by_offset(disp, _gloffset_Materiali, fn) +#define CALL_Materialiv(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLenum, const GLint *)), _gloffset_Materialiv, parameters) +#define GET_Materialiv(disp) GET_by_offset(disp, _gloffset_Materialiv) +#define SET_Materialiv(disp, fn) SET_by_offset(disp, _gloffset_Materialiv, fn) +#define CALL_PointSize(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLfloat)), _gloffset_PointSize, parameters) +#define GET_PointSize(disp) GET_by_offset(disp, _gloffset_PointSize) +#define SET_PointSize(disp, fn) SET_by_offset(disp, _gloffset_PointSize, fn) +#define CALL_PolygonMode(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLenum)), _gloffset_PolygonMode, parameters) +#define GET_PolygonMode(disp) GET_by_offset(disp, _gloffset_PolygonMode) +#define SET_PolygonMode(disp, fn) SET_by_offset(disp, _gloffset_PolygonMode, fn) +#define CALL_PolygonStipple(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(const GLubyte *)), _gloffset_PolygonStipple, parameters) +#define GET_PolygonStipple(disp) GET_by_offset(disp, _gloffset_PolygonStipple) +#define SET_PolygonStipple(disp, fn) SET_by_offset(disp, _gloffset_PolygonStipple, fn) +#define CALL_Scissor(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLint, GLint, GLsizei, GLsizei)), _gloffset_Scissor, parameters) +#define GET_Scissor(disp) GET_by_offset(disp, _gloffset_Scissor) +#define SET_Scissor(disp, fn) SET_by_offset(disp, _gloffset_Scissor, fn) +#define CALL_ShadeModel(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum)), _gloffset_ShadeModel, parameters) +#define GET_ShadeModel(disp) GET_by_offset(disp, _gloffset_ShadeModel) +#define SET_ShadeModel(disp, fn) SET_by_offset(disp, _gloffset_ShadeModel, fn) +#define CALL_TexParameterf(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLenum, GLfloat)), _gloffset_TexParameterf, parameters) +#define GET_TexParameterf(disp) GET_by_offset(disp, _gloffset_TexParameterf) +#define SET_TexParameterf(disp, fn) SET_by_offset(disp, _gloffset_TexParameterf, fn) +#define CALL_TexParameterfv(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLenum, const GLfloat *)), _gloffset_TexParameterfv, parameters) +#define GET_TexParameterfv(disp) GET_by_offset(disp, _gloffset_TexParameterfv) +#define SET_TexParameterfv(disp, fn) SET_by_offset(disp, _gloffset_TexParameterfv, fn) +#define CALL_TexParameteri(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLenum, GLint)), _gloffset_TexParameteri, parameters) +#define GET_TexParameteri(disp) GET_by_offset(disp, _gloffset_TexParameteri) +#define SET_TexParameteri(disp, fn) SET_by_offset(disp, _gloffset_TexParameteri, fn) +#define CALL_TexParameteriv(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLenum, const GLint *)), _gloffset_TexParameteriv, parameters) +#define GET_TexParameteriv(disp) GET_by_offset(disp, _gloffset_TexParameteriv) +#define SET_TexParameteriv(disp, fn) SET_by_offset(disp, _gloffset_TexParameteriv, fn) +#define CALL_TexImage1D(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLint, GLint, GLsizei, GLint, GLenum, GLenum, const GLvoid *)), _gloffset_TexImage1D, parameters) +#define GET_TexImage1D(disp) GET_by_offset(disp, _gloffset_TexImage1D) +#define SET_TexImage1D(disp, fn) SET_by_offset(disp, _gloffset_TexImage1D, fn) +#define CALL_TexImage2D(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLint, GLint, GLsizei, GLsizei, GLint, GLenum, GLenum, const GLvoid *)), _gloffset_TexImage2D, parameters) +#define GET_TexImage2D(disp) GET_by_offset(disp, _gloffset_TexImage2D) +#define SET_TexImage2D(disp, fn) SET_by_offset(disp, _gloffset_TexImage2D, fn) +#define CALL_TexEnvf(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLenum, GLfloat)), _gloffset_TexEnvf, parameters) +#define GET_TexEnvf(disp) GET_by_offset(disp, _gloffset_TexEnvf) +#define SET_TexEnvf(disp, fn) SET_by_offset(disp, _gloffset_TexEnvf, fn) +#define CALL_TexEnvfv(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLenum, const GLfloat *)), _gloffset_TexEnvfv, parameters) +#define GET_TexEnvfv(disp) GET_by_offset(disp, _gloffset_TexEnvfv) +#define SET_TexEnvfv(disp, fn) SET_by_offset(disp, _gloffset_TexEnvfv, fn) +#define CALL_TexEnvi(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLenum, GLint)), _gloffset_TexEnvi, parameters) +#define GET_TexEnvi(disp) GET_by_offset(disp, _gloffset_TexEnvi) +#define SET_TexEnvi(disp, fn) SET_by_offset(disp, _gloffset_TexEnvi, fn) +#define CALL_TexEnviv(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLenum, const GLint *)), _gloffset_TexEnviv, parameters) +#define GET_TexEnviv(disp) GET_by_offset(disp, _gloffset_TexEnviv) +#define SET_TexEnviv(disp, fn) SET_by_offset(disp, _gloffset_TexEnviv, fn) +#define CALL_TexGend(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLenum, GLdouble)), _gloffset_TexGend, parameters) +#define GET_TexGend(disp) GET_by_offset(disp, _gloffset_TexGend) +#define SET_TexGend(disp, fn) SET_by_offset(disp, _gloffset_TexGend, fn) +#define CALL_TexGendv(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLenum, const GLdouble *)), _gloffset_TexGendv, parameters) +#define GET_TexGendv(disp) GET_by_offset(disp, _gloffset_TexGendv) +#define SET_TexGendv(disp, fn) SET_by_offset(disp, _gloffset_TexGendv, fn) +#define CALL_TexGenfOES(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLenum, GLfloat)), _gloffset_TexGenfOES, parameters) +#define GET_TexGenfOES(disp) GET_by_offset(disp, _gloffset_TexGenfOES) +#define SET_TexGenfOES(disp, fn) SET_by_offset(disp, _gloffset_TexGenfOES, fn) +#define CALL_TexGenfvOES(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLenum, const GLfloat *)), _gloffset_TexGenfvOES, parameters) +#define GET_TexGenfvOES(disp) GET_by_offset(disp, _gloffset_TexGenfvOES) +#define SET_TexGenfvOES(disp, fn) SET_by_offset(disp, _gloffset_TexGenfvOES, fn) +#define CALL_TexGeniOES(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLenum, GLint)), _gloffset_TexGeniOES, parameters) +#define GET_TexGeniOES(disp) GET_by_offset(disp, _gloffset_TexGeniOES) +#define SET_TexGeniOES(disp, fn) SET_by_offset(disp, _gloffset_TexGeniOES, fn) +#define CALL_TexGenivOES(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLenum, const GLint *)), _gloffset_TexGenivOES, parameters) +#define GET_TexGenivOES(disp) GET_by_offset(disp, _gloffset_TexGenivOES) +#define SET_TexGenivOES(disp, fn) SET_by_offset(disp, _gloffset_TexGenivOES, fn) +#define CALL_FeedbackBuffer(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLsizei, GLenum, GLfloat *)), _gloffset_FeedbackBuffer, parameters) +#define GET_FeedbackBuffer(disp) GET_by_offset(disp, _gloffset_FeedbackBuffer) +#define SET_FeedbackBuffer(disp, fn) SET_by_offset(disp, _gloffset_FeedbackBuffer, fn) +#define CALL_SelectBuffer(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLsizei, GLuint *)), _gloffset_SelectBuffer, parameters) +#define GET_SelectBuffer(disp) GET_by_offset(disp, _gloffset_SelectBuffer) +#define SET_SelectBuffer(disp, fn) SET_by_offset(disp, _gloffset_SelectBuffer, fn) +#define CALL_RenderMode(disp, parameters) CALL_by_offset(disp, (GLint (GLAPIENTRYP)(GLenum)), _gloffset_RenderMode, parameters) +#define GET_RenderMode(disp) GET_by_offset(disp, _gloffset_RenderMode) +#define SET_RenderMode(disp, fn) SET_by_offset(disp, _gloffset_RenderMode, fn) +#define CALL_InitNames(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(void)), _gloffset_InitNames, parameters) +#define GET_InitNames(disp) GET_by_offset(disp, _gloffset_InitNames) +#define SET_InitNames(disp, fn) SET_by_offset(disp, _gloffset_InitNames, fn) +#define CALL_LoadName(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLuint)), _gloffset_LoadName, parameters) +#define GET_LoadName(disp) GET_by_offset(disp, _gloffset_LoadName) +#define SET_LoadName(disp, fn) SET_by_offset(disp, _gloffset_LoadName, fn) +#define CALL_PassThrough(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLfloat)), _gloffset_PassThrough, parameters) +#define GET_PassThrough(disp) GET_by_offset(disp, _gloffset_PassThrough) +#define SET_PassThrough(disp, fn) SET_by_offset(disp, _gloffset_PassThrough, fn) +#define CALL_PopName(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(void)), _gloffset_PopName, parameters) +#define GET_PopName(disp) GET_by_offset(disp, _gloffset_PopName) +#define SET_PopName(disp, fn) SET_by_offset(disp, _gloffset_PopName, fn) +#define CALL_PushName(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLuint)), _gloffset_PushName, parameters) +#define GET_PushName(disp) GET_by_offset(disp, _gloffset_PushName) +#define SET_PushName(disp, fn) SET_by_offset(disp, _gloffset_PushName, fn) +#define CALL_DrawBuffer(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum)), _gloffset_DrawBuffer, parameters) +#define GET_DrawBuffer(disp) GET_by_offset(disp, _gloffset_DrawBuffer) +#define SET_DrawBuffer(disp, fn) SET_by_offset(disp, _gloffset_DrawBuffer, fn) +#define CALL_Clear(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLbitfield)), _gloffset_Clear, parameters) +#define GET_Clear(disp) GET_by_offset(disp, _gloffset_Clear) +#define SET_Clear(disp, fn) SET_by_offset(disp, _gloffset_Clear, fn) +#define CALL_ClearAccum(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLfloat, GLfloat, GLfloat, GLfloat)), _gloffset_ClearAccum, parameters) +#define GET_ClearAccum(disp) GET_by_offset(disp, _gloffset_ClearAccum) +#define SET_ClearAccum(disp, fn) SET_by_offset(disp, _gloffset_ClearAccum, fn) +#define CALL_ClearIndex(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLfloat)), _gloffset_ClearIndex, parameters) +#define GET_ClearIndex(disp) GET_by_offset(disp, _gloffset_ClearIndex) +#define SET_ClearIndex(disp, fn) SET_by_offset(disp, _gloffset_ClearIndex, fn) +#define CALL_ClearColor(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLclampf, GLclampf, GLclampf, GLclampf)), _gloffset_ClearColor, parameters) +#define GET_ClearColor(disp) GET_by_offset(disp, _gloffset_ClearColor) +#define SET_ClearColor(disp, fn) SET_by_offset(disp, _gloffset_ClearColor, fn) +#define CALL_ClearStencil(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLint)), _gloffset_ClearStencil, parameters) +#define GET_ClearStencil(disp) GET_by_offset(disp, _gloffset_ClearStencil) +#define SET_ClearStencil(disp, fn) SET_by_offset(disp, _gloffset_ClearStencil, fn) +#define CALL_ClearDepth(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLclampd)), _gloffset_ClearDepth, parameters) +#define GET_ClearDepth(disp) GET_by_offset(disp, _gloffset_ClearDepth) +#define SET_ClearDepth(disp, fn) SET_by_offset(disp, _gloffset_ClearDepth, fn) +#define CALL_StencilMask(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLuint)), _gloffset_StencilMask, parameters) +#define GET_StencilMask(disp) GET_by_offset(disp, _gloffset_StencilMask) +#define SET_StencilMask(disp, fn) SET_by_offset(disp, _gloffset_StencilMask, fn) +#define CALL_ColorMask(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLboolean, GLboolean, GLboolean, GLboolean)), _gloffset_ColorMask, parameters) +#define GET_ColorMask(disp) GET_by_offset(disp, _gloffset_ColorMask) +#define SET_ColorMask(disp, fn) SET_by_offset(disp, _gloffset_ColorMask, fn) +#define CALL_DepthMask(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLboolean)), _gloffset_DepthMask, parameters) +#define GET_DepthMask(disp) GET_by_offset(disp, _gloffset_DepthMask) +#define SET_DepthMask(disp, fn) SET_by_offset(disp, _gloffset_DepthMask, fn) +#define CALL_IndexMask(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLuint)), _gloffset_IndexMask, parameters) +#define GET_IndexMask(disp) GET_by_offset(disp, _gloffset_IndexMask) +#define SET_IndexMask(disp, fn) SET_by_offset(disp, _gloffset_IndexMask, fn) +#define CALL_Accum(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLfloat)), _gloffset_Accum, parameters) +#define GET_Accum(disp) GET_by_offset(disp, _gloffset_Accum) +#define SET_Accum(disp, fn) SET_by_offset(disp, _gloffset_Accum, fn) +#define CALL_Disable(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum)), _gloffset_Disable, parameters) +#define GET_Disable(disp) GET_by_offset(disp, _gloffset_Disable) +#define SET_Disable(disp, fn) SET_by_offset(disp, _gloffset_Disable, fn) +#define CALL_Enable(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum)), _gloffset_Enable, parameters) +#define GET_Enable(disp) GET_by_offset(disp, _gloffset_Enable) +#define SET_Enable(disp, fn) SET_by_offset(disp, _gloffset_Enable, fn) +#define CALL_Finish(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(void)), _gloffset_Finish, parameters) +#define GET_Finish(disp) GET_by_offset(disp, _gloffset_Finish) +#define SET_Finish(disp, fn) SET_by_offset(disp, _gloffset_Finish, fn) +#define CALL_Flush(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(void)), _gloffset_Flush, parameters) +#define GET_Flush(disp) GET_by_offset(disp, _gloffset_Flush) +#define SET_Flush(disp, fn) SET_by_offset(disp, _gloffset_Flush, fn) +#define CALL_PopAttrib(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(void)), _gloffset_PopAttrib, parameters) +#define GET_PopAttrib(disp) GET_by_offset(disp, _gloffset_PopAttrib) +#define SET_PopAttrib(disp, fn) SET_by_offset(disp, _gloffset_PopAttrib, fn) +#define CALL_PushAttrib(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLbitfield)), _gloffset_PushAttrib, parameters) +#define GET_PushAttrib(disp) GET_by_offset(disp, _gloffset_PushAttrib) +#define SET_PushAttrib(disp, fn) SET_by_offset(disp, _gloffset_PushAttrib, fn) +#define CALL_Map1d(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLdouble, GLdouble, GLint, GLint, const GLdouble *)), _gloffset_Map1d, parameters) +#define GET_Map1d(disp) GET_by_offset(disp, _gloffset_Map1d) +#define SET_Map1d(disp, fn) SET_by_offset(disp, _gloffset_Map1d, fn) +#define CALL_Map1f(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLfloat, GLfloat, GLint, GLint, const GLfloat *)), _gloffset_Map1f, parameters) +#define GET_Map1f(disp) GET_by_offset(disp, _gloffset_Map1f) +#define SET_Map1f(disp, fn) SET_by_offset(disp, _gloffset_Map1f, fn) +#define CALL_Map2d(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLdouble, GLdouble, GLint, GLint, GLdouble, GLdouble, GLint, GLint, const GLdouble *)), _gloffset_Map2d, parameters) +#define GET_Map2d(disp) GET_by_offset(disp, _gloffset_Map2d) +#define SET_Map2d(disp, fn) SET_by_offset(disp, _gloffset_Map2d, fn) +#define CALL_Map2f(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLfloat, GLfloat, GLint, GLint, GLfloat, GLfloat, GLint, GLint, const GLfloat *)), _gloffset_Map2f, parameters) +#define GET_Map2f(disp) GET_by_offset(disp, _gloffset_Map2f) +#define SET_Map2f(disp, fn) SET_by_offset(disp, _gloffset_Map2f, fn) +#define CALL_MapGrid1d(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLint, GLdouble, GLdouble)), _gloffset_MapGrid1d, parameters) +#define GET_MapGrid1d(disp) GET_by_offset(disp, _gloffset_MapGrid1d) +#define SET_MapGrid1d(disp, fn) SET_by_offset(disp, _gloffset_MapGrid1d, fn) +#define CALL_MapGrid1f(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLint, GLfloat, GLfloat)), _gloffset_MapGrid1f, parameters) +#define GET_MapGrid1f(disp) GET_by_offset(disp, _gloffset_MapGrid1f) +#define SET_MapGrid1f(disp, fn) SET_by_offset(disp, _gloffset_MapGrid1f, fn) +#define CALL_MapGrid2d(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLint, GLdouble, GLdouble, GLint, GLdouble, GLdouble)), _gloffset_MapGrid2d, parameters) +#define GET_MapGrid2d(disp) GET_by_offset(disp, _gloffset_MapGrid2d) +#define SET_MapGrid2d(disp, fn) SET_by_offset(disp, _gloffset_MapGrid2d, fn) +#define CALL_MapGrid2f(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLint, GLfloat, GLfloat, GLint, GLfloat, GLfloat)), _gloffset_MapGrid2f, parameters) +#define GET_MapGrid2f(disp) GET_by_offset(disp, _gloffset_MapGrid2f) +#define SET_MapGrid2f(disp, fn) SET_by_offset(disp, _gloffset_MapGrid2f, fn) +#define CALL_EvalCoord1d(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLdouble)), _gloffset_EvalCoord1d, parameters) +#define GET_EvalCoord1d(disp) GET_by_offset(disp, _gloffset_EvalCoord1d) +#define SET_EvalCoord1d(disp, fn) SET_by_offset(disp, _gloffset_EvalCoord1d, fn) +#define CALL_EvalCoord1dv(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(const GLdouble *)), _gloffset_EvalCoord1dv, parameters) +#define GET_EvalCoord1dv(disp) GET_by_offset(disp, _gloffset_EvalCoord1dv) +#define SET_EvalCoord1dv(disp, fn) SET_by_offset(disp, _gloffset_EvalCoord1dv, fn) +#define CALL_EvalCoord1f(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLfloat)), _gloffset_EvalCoord1f, parameters) +#define GET_EvalCoord1f(disp) GET_by_offset(disp, _gloffset_EvalCoord1f) +#define SET_EvalCoord1f(disp, fn) SET_by_offset(disp, _gloffset_EvalCoord1f, fn) +#define CALL_EvalCoord1fv(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(const GLfloat *)), _gloffset_EvalCoord1fv, parameters) +#define GET_EvalCoord1fv(disp) GET_by_offset(disp, _gloffset_EvalCoord1fv) +#define SET_EvalCoord1fv(disp, fn) SET_by_offset(disp, _gloffset_EvalCoord1fv, fn) +#define CALL_EvalCoord2d(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLdouble, GLdouble)), _gloffset_EvalCoord2d, parameters) +#define GET_EvalCoord2d(disp) GET_by_offset(disp, _gloffset_EvalCoord2d) +#define SET_EvalCoord2d(disp, fn) SET_by_offset(disp, _gloffset_EvalCoord2d, fn) +#define CALL_EvalCoord2dv(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(const GLdouble *)), _gloffset_EvalCoord2dv, parameters) +#define GET_EvalCoord2dv(disp) GET_by_offset(disp, _gloffset_EvalCoord2dv) +#define SET_EvalCoord2dv(disp, fn) SET_by_offset(disp, _gloffset_EvalCoord2dv, fn) +#define CALL_EvalCoord2f(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLfloat, GLfloat)), _gloffset_EvalCoord2f, parameters) +#define GET_EvalCoord2f(disp) GET_by_offset(disp, _gloffset_EvalCoord2f) +#define SET_EvalCoord2f(disp, fn) SET_by_offset(disp, _gloffset_EvalCoord2f, fn) +#define CALL_EvalCoord2fv(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(const GLfloat *)), _gloffset_EvalCoord2fv, parameters) +#define GET_EvalCoord2fv(disp) GET_by_offset(disp, _gloffset_EvalCoord2fv) +#define SET_EvalCoord2fv(disp, fn) SET_by_offset(disp, _gloffset_EvalCoord2fv, fn) +#define CALL_EvalMesh1(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLint, GLint)), _gloffset_EvalMesh1, parameters) +#define GET_EvalMesh1(disp) GET_by_offset(disp, _gloffset_EvalMesh1) +#define SET_EvalMesh1(disp, fn) SET_by_offset(disp, _gloffset_EvalMesh1, fn) +#define CALL_EvalPoint1(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLint)), _gloffset_EvalPoint1, parameters) +#define GET_EvalPoint1(disp) GET_by_offset(disp, _gloffset_EvalPoint1) +#define SET_EvalPoint1(disp, fn) SET_by_offset(disp, _gloffset_EvalPoint1, fn) +#define CALL_EvalMesh2(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLint, GLint, GLint, GLint)), _gloffset_EvalMesh2, parameters) +#define GET_EvalMesh2(disp) GET_by_offset(disp, _gloffset_EvalMesh2) +#define SET_EvalMesh2(disp, fn) SET_by_offset(disp, _gloffset_EvalMesh2, fn) +#define CALL_EvalPoint2(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLint, GLint)), _gloffset_EvalPoint2, parameters) +#define GET_EvalPoint2(disp) GET_by_offset(disp, _gloffset_EvalPoint2) +#define SET_EvalPoint2(disp, fn) SET_by_offset(disp, _gloffset_EvalPoint2, fn) +#define CALL_AlphaFunc(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLclampf)), _gloffset_AlphaFunc, parameters) +#define GET_AlphaFunc(disp) GET_by_offset(disp, _gloffset_AlphaFunc) +#define SET_AlphaFunc(disp, fn) SET_by_offset(disp, _gloffset_AlphaFunc, fn) +#define CALL_BlendFunc(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLenum)), _gloffset_BlendFunc, parameters) +#define GET_BlendFunc(disp) GET_by_offset(disp, _gloffset_BlendFunc) +#define SET_BlendFunc(disp, fn) SET_by_offset(disp, _gloffset_BlendFunc, fn) +#define CALL_LogicOp(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum)), _gloffset_LogicOp, parameters) +#define GET_LogicOp(disp) GET_by_offset(disp, _gloffset_LogicOp) +#define SET_LogicOp(disp, fn) SET_by_offset(disp, _gloffset_LogicOp, fn) +#define CALL_StencilFunc(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLint, GLuint)), _gloffset_StencilFunc, parameters) +#define GET_StencilFunc(disp) GET_by_offset(disp, _gloffset_StencilFunc) +#define SET_StencilFunc(disp, fn) SET_by_offset(disp, _gloffset_StencilFunc, fn) +#define CALL_StencilOp(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLenum, GLenum)), _gloffset_StencilOp, parameters) +#define GET_StencilOp(disp) GET_by_offset(disp, _gloffset_StencilOp) +#define SET_StencilOp(disp, fn) SET_by_offset(disp, _gloffset_StencilOp, fn) +#define CALL_DepthFunc(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum)), _gloffset_DepthFunc, parameters) +#define GET_DepthFunc(disp) GET_by_offset(disp, _gloffset_DepthFunc) +#define SET_DepthFunc(disp, fn) SET_by_offset(disp, _gloffset_DepthFunc, fn) +#define CALL_PixelZoom(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLfloat, GLfloat)), _gloffset_PixelZoom, parameters) +#define GET_PixelZoom(disp) GET_by_offset(disp, _gloffset_PixelZoom) +#define SET_PixelZoom(disp, fn) SET_by_offset(disp, _gloffset_PixelZoom, fn) +#define CALL_PixelTransferf(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLfloat)), _gloffset_PixelTransferf, parameters) +#define GET_PixelTransferf(disp) GET_by_offset(disp, _gloffset_PixelTransferf) +#define SET_PixelTransferf(disp, fn) SET_by_offset(disp, _gloffset_PixelTransferf, fn) +#define CALL_PixelTransferi(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLint)), _gloffset_PixelTransferi, parameters) +#define GET_PixelTransferi(disp) GET_by_offset(disp, _gloffset_PixelTransferi) +#define SET_PixelTransferi(disp, fn) SET_by_offset(disp, _gloffset_PixelTransferi, fn) +#define CALL_PixelStoref(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLfloat)), _gloffset_PixelStoref, parameters) +#define GET_PixelStoref(disp) GET_by_offset(disp, _gloffset_PixelStoref) +#define SET_PixelStoref(disp, fn) SET_by_offset(disp, _gloffset_PixelStoref, fn) +#define CALL_PixelStorei(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLint)), _gloffset_PixelStorei, parameters) +#define GET_PixelStorei(disp) GET_by_offset(disp, _gloffset_PixelStorei) +#define SET_PixelStorei(disp, fn) SET_by_offset(disp, _gloffset_PixelStorei, fn) +#define CALL_PixelMapfv(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLsizei, const GLfloat *)), _gloffset_PixelMapfv, parameters) +#define GET_PixelMapfv(disp) GET_by_offset(disp, _gloffset_PixelMapfv) +#define SET_PixelMapfv(disp, fn) SET_by_offset(disp, _gloffset_PixelMapfv, fn) +#define CALL_PixelMapuiv(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLsizei, const GLuint *)), _gloffset_PixelMapuiv, parameters) +#define GET_PixelMapuiv(disp) GET_by_offset(disp, _gloffset_PixelMapuiv) +#define SET_PixelMapuiv(disp, fn) SET_by_offset(disp, _gloffset_PixelMapuiv, fn) +#define CALL_PixelMapusv(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLsizei, const GLushort *)), _gloffset_PixelMapusv, parameters) +#define GET_PixelMapusv(disp) GET_by_offset(disp, _gloffset_PixelMapusv) +#define SET_PixelMapusv(disp, fn) SET_by_offset(disp, _gloffset_PixelMapusv, fn) +#define CALL_ReadBuffer(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum)), _gloffset_ReadBuffer, parameters) +#define GET_ReadBuffer(disp) GET_by_offset(disp, _gloffset_ReadBuffer) +#define SET_ReadBuffer(disp, fn) SET_by_offset(disp, _gloffset_ReadBuffer, fn) +#define CALL_CopyPixels(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLint, GLint, GLsizei, GLsizei, GLenum)), _gloffset_CopyPixels, parameters) +#define GET_CopyPixels(disp) GET_by_offset(disp, _gloffset_CopyPixels) +#define SET_CopyPixels(disp, fn) SET_by_offset(disp, _gloffset_CopyPixels, fn) +#define CALL_ReadPixels(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLint, GLint, GLsizei, GLsizei, GLenum, GLenum, GLvoid *)), _gloffset_ReadPixels, parameters) +#define GET_ReadPixels(disp) GET_by_offset(disp, _gloffset_ReadPixels) +#define SET_ReadPixels(disp, fn) SET_by_offset(disp, _gloffset_ReadPixels, fn) +#define CALL_DrawPixels(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLsizei, GLsizei, GLenum, GLenum, const GLvoid *)), _gloffset_DrawPixels, parameters) +#define GET_DrawPixels(disp) GET_by_offset(disp, _gloffset_DrawPixels) +#define SET_DrawPixels(disp, fn) SET_by_offset(disp, _gloffset_DrawPixels, fn) +#define CALL_GetBooleanv(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLboolean *)), _gloffset_GetBooleanv, parameters) +#define GET_GetBooleanv(disp) GET_by_offset(disp, _gloffset_GetBooleanv) +#define SET_GetBooleanv(disp, fn) SET_by_offset(disp, _gloffset_GetBooleanv, fn) +#define CALL_GetClipPlane(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLdouble *)), _gloffset_GetClipPlane, parameters) +#define GET_GetClipPlane(disp) GET_by_offset(disp, _gloffset_GetClipPlane) +#define SET_GetClipPlane(disp, fn) SET_by_offset(disp, _gloffset_GetClipPlane, fn) +#define CALL_GetDoublev(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLdouble *)), _gloffset_GetDoublev, parameters) +#define GET_GetDoublev(disp) GET_by_offset(disp, _gloffset_GetDoublev) +#define SET_GetDoublev(disp, fn) SET_by_offset(disp, _gloffset_GetDoublev, fn) +#define CALL_GetError(disp, parameters) CALL_by_offset(disp, (GLenum (GLAPIENTRYP)(void)), _gloffset_GetError, parameters) +#define GET_GetError(disp) GET_by_offset(disp, _gloffset_GetError) +#define SET_GetError(disp, fn) SET_by_offset(disp, _gloffset_GetError, fn) +#define CALL_GetFloatv(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLfloat *)), _gloffset_GetFloatv, parameters) +#define GET_GetFloatv(disp) GET_by_offset(disp, _gloffset_GetFloatv) +#define SET_GetFloatv(disp, fn) SET_by_offset(disp, _gloffset_GetFloatv, fn) +#define CALL_GetIntegerv(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLint *)), _gloffset_GetIntegerv, parameters) +#define GET_GetIntegerv(disp) GET_by_offset(disp, _gloffset_GetIntegerv) +#define SET_GetIntegerv(disp, fn) SET_by_offset(disp, _gloffset_GetIntegerv, fn) +#define CALL_GetLightfv(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLenum, GLfloat *)), _gloffset_GetLightfv, parameters) +#define GET_GetLightfv(disp) GET_by_offset(disp, _gloffset_GetLightfv) +#define SET_GetLightfv(disp, fn) SET_by_offset(disp, _gloffset_GetLightfv, fn) +#define CALL_GetLightiv(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLenum, GLint *)), _gloffset_GetLightiv, parameters) +#define GET_GetLightiv(disp) GET_by_offset(disp, _gloffset_GetLightiv) +#define SET_GetLightiv(disp, fn) SET_by_offset(disp, _gloffset_GetLightiv, fn) +#define CALL_GetMapdv(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLenum, GLdouble *)), _gloffset_GetMapdv, parameters) +#define GET_GetMapdv(disp) GET_by_offset(disp, _gloffset_GetMapdv) +#define SET_GetMapdv(disp, fn) SET_by_offset(disp, _gloffset_GetMapdv, fn) +#define CALL_GetMapfv(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLenum, GLfloat *)), _gloffset_GetMapfv, parameters) +#define GET_GetMapfv(disp) GET_by_offset(disp, _gloffset_GetMapfv) +#define SET_GetMapfv(disp, fn) SET_by_offset(disp, _gloffset_GetMapfv, fn) +#define CALL_GetMapiv(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLenum, GLint *)), _gloffset_GetMapiv, parameters) +#define GET_GetMapiv(disp) GET_by_offset(disp, _gloffset_GetMapiv) +#define SET_GetMapiv(disp, fn) SET_by_offset(disp, _gloffset_GetMapiv, fn) +#define CALL_GetMaterialfv(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLenum, GLfloat *)), _gloffset_GetMaterialfv, parameters) +#define GET_GetMaterialfv(disp) GET_by_offset(disp, _gloffset_GetMaterialfv) +#define SET_GetMaterialfv(disp, fn) SET_by_offset(disp, _gloffset_GetMaterialfv, fn) +#define CALL_GetMaterialiv(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLenum, GLint *)), _gloffset_GetMaterialiv, parameters) +#define GET_GetMaterialiv(disp) GET_by_offset(disp, _gloffset_GetMaterialiv) +#define SET_GetMaterialiv(disp, fn) SET_by_offset(disp, _gloffset_GetMaterialiv, fn) +#define CALL_GetPixelMapfv(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLfloat *)), _gloffset_GetPixelMapfv, parameters) +#define GET_GetPixelMapfv(disp) GET_by_offset(disp, _gloffset_GetPixelMapfv) +#define SET_GetPixelMapfv(disp, fn) SET_by_offset(disp, _gloffset_GetPixelMapfv, fn) +#define CALL_GetPixelMapuiv(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLuint *)), _gloffset_GetPixelMapuiv, parameters) +#define GET_GetPixelMapuiv(disp) GET_by_offset(disp, _gloffset_GetPixelMapuiv) +#define SET_GetPixelMapuiv(disp, fn) SET_by_offset(disp, _gloffset_GetPixelMapuiv, fn) +#define CALL_GetPixelMapusv(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLushort *)), _gloffset_GetPixelMapusv, parameters) +#define GET_GetPixelMapusv(disp) GET_by_offset(disp, _gloffset_GetPixelMapusv) +#define SET_GetPixelMapusv(disp, fn) SET_by_offset(disp, _gloffset_GetPixelMapusv, fn) +#define CALL_GetPolygonStipple(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLubyte *)), _gloffset_GetPolygonStipple, parameters) +#define GET_GetPolygonStipple(disp) GET_by_offset(disp, _gloffset_GetPolygonStipple) +#define SET_GetPolygonStipple(disp, fn) SET_by_offset(disp, _gloffset_GetPolygonStipple, fn) +#define CALL_GetString(disp, parameters) CALL_by_offset(disp, (const GLubyte * (GLAPIENTRYP)(GLenum)), _gloffset_GetString, parameters) +#define GET_GetString(disp) GET_by_offset(disp, _gloffset_GetString) +#define SET_GetString(disp, fn) SET_by_offset(disp, _gloffset_GetString, fn) +#define CALL_GetTexEnvfv(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLenum, GLfloat *)), _gloffset_GetTexEnvfv, parameters) +#define GET_GetTexEnvfv(disp) GET_by_offset(disp, _gloffset_GetTexEnvfv) +#define SET_GetTexEnvfv(disp, fn) SET_by_offset(disp, _gloffset_GetTexEnvfv, fn) +#define CALL_GetTexEnviv(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLenum, GLint *)), _gloffset_GetTexEnviv, parameters) +#define GET_GetTexEnviv(disp) GET_by_offset(disp, _gloffset_GetTexEnviv) +#define SET_GetTexEnviv(disp, fn) SET_by_offset(disp, _gloffset_GetTexEnviv, fn) +#define CALL_GetTexGendv(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLenum, GLdouble *)), _gloffset_GetTexGendv, parameters) +#define GET_GetTexGendv(disp) GET_by_offset(disp, _gloffset_GetTexGendv) +#define SET_GetTexGendv(disp, fn) SET_by_offset(disp, _gloffset_GetTexGendv, fn) +#define CALL_GetTexGenfvOES(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLenum, GLfloat *)), _gloffset_GetTexGenfvOES, parameters) +#define GET_GetTexGenfvOES(disp) GET_by_offset(disp, _gloffset_GetTexGenfvOES) +#define SET_GetTexGenfvOES(disp, fn) SET_by_offset(disp, _gloffset_GetTexGenfvOES, fn) +#define CALL_GetTexGenivOES(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLenum, GLint *)), _gloffset_GetTexGenivOES, parameters) +#define GET_GetTexGenivOES(disp) GET_by_offset(disp, _gloffset_GetTexGenivOES) +#define SET_GetTexGenivOES(disp, fn) SET_by_offset(disp, _gloffset_GetTexGenivOES, fn) +#define CALL_GetTexImage(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLint, GLenum, GLenum, GLvoid *)), _gloffset_GetTexImage, parameters) +#define GET_GetTexImage(disp) GET_by_offset(disp, _gloffset_GetTexImage) +#define SET_GetTexImage(disp, fn) SET_by_offset(disp, _gloffset_GetTexImage, fn) +#define CALL_GetTexParameterfv(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLenum, GLfloat *)), _gloffset_GetTexParameterfv, parameters) +#define GET_GetTexParameterfv(disp) GET_by_offset(disp, _gloffset_GetTexParameterfv) +#define SET_GetTexParameterfv(disp, fn) SET_by_offset(disp, _gloffset_GetTexParameterfv, fn) +#define CALL_GetTexParameteriv(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLenum, GLint *)), _gloffset_GetTexParameteriv, parameters) +#define GET_GetTexParameteriv(disp) GET_by_offset(disp, _gloffset_GetTexParameteriv) +#define SET_GetTexParameteriv(disp, fn) SET_by_offset(disp, _gloffset_GetTexParameteriv, fn) +#define CALL_GetTexLevelParameterfv(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLint, GLenum, GLfloat *)), _gloffset_GetTexLevelParameterfv, parameters) +#define GET_GetTexLevelParameterfv(disp) GET_by_offset(disp, _gloffset_GetTexLevelParameterfv) +#define SET_GetTexLevelParameterfv(disp, fn) SET_by_offset(disp, _gloffset_GetTexLevelParameterfv, fn) +#define CALL_GetTexLevelParameteriv(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLint, GLenum, GLint *)), _gloffset_GetTexLevelParameteriv, parameters) +#define GET_GetTexLevelParameteriv(disp) GET_by_offset(disp, _gloffset_GetTexLevelParameteriv) +#define SET_GetTexLevelParameteriv(disp, fn) SET_by_offset(disp, _gloffset_GetTexLevelParameteriv, fn) +#define CALL_IsEnabled(disp, parameters) CALL_by_offset(disp, (GLboolean (GLAPIENTRYP)(GLenum)), _gloffset_IsEnabled, parameters) +#define GET_IsEnabled(disp) GET_by_offset(disp, _gloffset_IsEnabled) +#define SET_IsEnabled(disp, fn) SET_by_offset(disp, _gloffset_IsEnabled, fn) +#define CALL_IsList(disp, parameters) CALL_by_offset(disp, (GLboolean (GLAPIENTRYP)(GLuint)), _gloffset_IsList, parameters) +#define GET_IsList(disp) GET_by_offset(disp, _gloffset_IsList) +#define SET_IsList(disp, fn) SET_by_offset(disp, _gloffset_IsList, fn) +#define CALL_DepthRange(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLclampd, GLclampd)), _gloffset_DepthRange, parameters) +#define GET_DepthRange(disp) GET_by_offset(disp, _gloffset_DepthRange) +#define SET_DepthRange(disp, fn) SET_by_offset(disp, _gloffset_DepthRange, fn) +#define CALL_Frustum(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLdouble, GLdouble, GLdouble, GLdouble, GLdouble, GLdouble)), _gloffset_Frustum, parameters) +#define GET_Frustum(disp) GET_by_offset(disp, _gloffset_Frustum) +#define SET_Frustum(disp, fn) SET_by_offset(disp, _gloffset_Frustum, fn) +#define CALL_LoadIdentity(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(void)), _gloffset_LoadIdentity, parameters) +#define GET_LoadIdentity(disp) GET_by_offset(disp, _gloffset_LoadIdentity) +#define SET_LoadIdentity(disp, fn) SET_by_offset(disp, _gloffset_LoadIdentity, fn) +#define CALL_LoadMatrixf(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(const GLfloat *)), _gloffset_LoadMatrixf, parameters) +#define GET_LoadMatrixf(disp) GET_by_offset(disp, _gloffset_LoadMatrixf) +#define SET_LoadMatrixf(disp, fn) SET_by_offset(disp, _gloffset_LoadMatrixf, fn) +#define CALL_LoadMatrixd(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(const GLdouble *)), _gloffset_LoadMatrixd, parameters) +#define GET_LoadMatrixd(disp) GET_by_offset(disp, _gloffset_LoadMatrixd) +#define SET_LoadMatrixd(disp, fn) SET_by_offset(disp, _gloffset_LoadMatrixd, fn) +#define CALL_MatrixMode(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum)), _gloffset_MatrixMode, parameters) +#define GET_MatrixMode(disp) GET_by_offset(disp, _gloffset_MatrixMode) +#define SET_MatrixMode(disp, fn) SET_by_offset(disp, _gloffset_MatrixMode, fn) +#define CALL_MultMatrixf(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(const GLfloat *)), _gloffset_MultMatrixf, parameters) +#define GET_MultMatrixf(disp) GET_by_offset(disp, _gloffset_MultMatrixf) +#define SET_MultMatrixf(disp, fn) SET_by_offset(disp, _gloffset_MultMatrixf, fn) +#define CALL_MultMatrixd(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(const GLdouble *)), _gloffset_MultMatrixd, parameters) +#define GET_MultMatrixd(disp) GET_by_offset(disp, _gloffset_MultMatrixd) +#define SET_MultMatrixd(disp, fn) SET_by_offset(disp, _gloffset_MultMatrixd, fn) +#define CALL_Ortho(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLdouble, GLdouble, GLdouble, GLdouble, GLdouble, GLdouble)), _gloffset_Ortho, parameters) +#define GET_Ortho(disp) GET_by_offset(disp, _gloffset_Ortho) +#define SET_Ortho(disp, fn) SET_by_offset(disp, _gloffset_Ortho, fn) +#define CALL_PopMatrix(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(void)), _gloffset_PopMatrix, parameters) +#define GET_PopMatrix(disp) GET_by_offset(disp, _gloffset_PopMatrix) +#define SET_PopMatrix(disp, fn) SET_by_offset(disp, _gloffset_PopMatrix, fn) +#define CALL_PushMatrix(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(void)), _gloffset_PushMatrix, parameters) +#define GET_PushMatrix(disp) GET_by_offset(disp, _gloffset_PushMatrix) +#define SET_PushMatrix(disp, fn) SET_by_offset(disp, _gloffset_PushMatrix, fn) +#define CALL_Rotated(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLdouble, GLdouble, GLdouble, GLdouble)), _gloffset_Rotated, parameters) +#define GET_Rotated(disp) GET_by_offset(disp, _gloffset_Rotated) +#define SET_Rotated(disp, fn) SET_by_offset(disp, _gloffset_Rotated, fn) +#define CALL_Rotatef(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLfloat, GLfloat, GLfloat, GLfloat)), _gloffset_Rotatef, parameters) +#define GET_Rotatef(disp) GET_by_offset(disp, _gloffset_Rotatef) +#define SET_Rotatef(disp, fn) SET_by_offset(disp, _gloffset_Rotatef, fn) +#define CALL_Scaled(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLdouble, GLdouble, GLdouble)), _gloffset_Scaled, parameters) +#define GET_Scaled(disp) GET_by_offset(disp, _gloffset_Scaled) +#define SET_Scaled(disp, fn) SET_by_offset(disp, _gloffset_Scaled, fn) +#define CALL_Scalef(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLfloat, GLfloat, GLfloat)), _gloffset_Scalef, parameters) +#define GET_Scalef(disp) GET_by_offset(disp, _gloffset_Scalef) +#define SET_Scalef(disp, fn) SET_by_offset(disp, _gloffset_Scalef, fn) +#define CALL_Translated(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLdouble, GLdouble, GLdouble)), _gloffset_Translated, parameters) +#define GET_Translated(disp) GET_by_offset(disp, _gloffset_Translated) +#define SET_Translated(disp, fn) SET_by_offset(disp, _gloffset_Translated, fn) +#define CALL_Translatef(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLfloat, GLfloat, GLfloat)), _gloffset_Translatef, parameters) +#define GET_Translatef(disp) GET_by_offset(disp, _gloffset_Translatef) +#define SET_Translatef(disp, fn) SET_by_offset(disp, _gloffset_Translatef, fn) +#define CALL_Viewport(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLint, GLint, GLsizei, GLsizei)), _gloffset_Viewport, parameters) +#define GET_Viewport(disp) GET_by_offset(disp, _gloffset_Viewport) +#define SET_Viewport(disp, fn) SET_by_offset(disp, _gloffset_Viewport, fn) +#define CALL_ArrayElement(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLint)), _gloffset_ArrayElement, parameters) +#define GET_ArrayElement(disp) GET_by_offset(disp, _gloffset_ArrayElement) +#define SET_ArrayElement(disp, fn) SET_by_offset(disp, _gloffset_ArrayElement, fn) +#define CALL_BindTexture(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLuint)), _gloffset_BindTexture, parameters) +#define GET_BindTexture(disp) GET_by_offset(disp, _gloffset_BindTexture) +#define SET_BindTexture(disp, fn) SET_by_offset(disp, _gloffset_BindTexture, fn) +#define CALL_ColorPointer(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLint, GLenum, GLsizei, const GLvoid *)), _gloffset_ColorPointer, parameters) +#define GET_ColorPointer(disp) GET_by_offset(disp, _gloffset_ColorPointer) +#define SET_ColorPointer(disp, fn) SET_by_offset(disp, _gloffset_ColorPointer, fn) +#define CALL_DisableClientState(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum)), _gloffset_DisableClientState, parameters) +#define GET_DisableClientState(disp) GET_by_offset(disp, _gloffset_DisableClientState) +#define SET_DisableClientState(disp, fn) SET_by_offset(disp, _gloffset_DisableClientState, fn) +#define CALL_DrawArrays(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLint, GLsizei)), _gloffset_DrawArrays, parameters) +#define GET_DrawArrays(disp) GET_by_offset(disp, _gloffset_DrawArrays) +#define SET_DrawArrays(disp, fn) SET_by_offset(disp, _gloffset_DrawArrays, fn) +#define CALL_DrawElements(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLsizei, GLenum, const GLvoid *)), _gloffset_DrawElements, parameters) +#define GET_DrawElements(disp) GET_by_offset(disp, _gloffset_DrawElements) +#define SET_DrawElements(disp, fn) SET_by_offset(disp, _gloffset_DrawElements, fn) +#define CALL_EdgeFlagPointer(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLsizei, const GLvoid *)), _gloffset_EdgeFlagPointer, parameters) +#define GET_EdgeFlagPointer(disp) GET_by_offset(disp, _gloffset_EdgeFlagPointer) +#define SET_EdgeFlagPointer(disp, fn) SET_by_offset(disp, _gloffset_EdgeFlagPointer, fn) +#define CALL_EnableClientState(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum)), _gloffset_EnableClientState, parameters) +#define GET_EnableClientState(disp) GET_by_offset(disp, _gloffset_EnableClientState) +#define SET_EnableClientState(disp, fn) SET_by_offset(disp, _gloffset_EnableClientState, fn) +#define CALL_IndexPointer(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLsizei, const GLvoid *)), _gloffset_IndexPointer, parameters) +#define GET_IndexPointer(disp) GET_by_offset(disp, _gloffset_IndexPointer) +#define SET_IndexPointer(disp, fn) SET_by_offset(disp, _gloffset_IndexPointer, fn) +#define CALL_Indexub(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLubyte)), _gloffset_Indexub, parameters) +#define GET_Indexub(disp) GET_by_offset(disp, _gloffset_Indexub) +#define SET_Indexub(disp, fn) SET_by_offset(disp, _gloffset_Indexub, fn) +#define CALL_Indexubv(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(const GLubyte *)), _gloffset_Indexubv, parameters) +#define GET_Indexubv(disp) GET_by_offset(disp, _gloffset_Indexubv) +#define SET_Indexubv(disp, fn) SET_by_offset(disp, _gloffset_Indexubv, fn) +#define CALL_InterleavedArrays(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLsizei, const GLvoid *)), _gloffset_InterleavedArrays, parameters) +#define GET_InterleavedArrays(disp) GET_by_offset(disp, _gloffset_InterleavedArrays) +#define SET_InterleavedArrays(disp, fn) SET_by_offset(disp, _gloffset_InterleavedArrays, fn) +#define CALL_NormalPointer(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLsizei, const GLvoid *)), _gloffset_NormalPointer, parameters) +#define GET_NormalPointer(disp) GET_by_offset(disp, _gloffset_NormalPointer) +#define SET_NormalPointer(disp, fn) SET_by_offset(disp, _gloffset_NormalPointer, fn) +#define CALL_PolygonOffset(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLfloat, GLfloat)), _gloffset_PolygonOffset, parameters) +#define GET_PolygonOffset(disp) GET_by_offset(disp, _gloffset_PolygonOffset) +#define SET_PolygonOffset(disp, fn) SET_by_offset(disp, _gloffset_PolygonOffset, fn) +#define CALL_TexCoordPointer(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLint, GLenum, GLsizei, const GLvoid *)), _gloffset_TexCoordPointer, parameters) +#define GET_TexCoordPointer(disp) GET_by_offset(disp, _gloffset_TexCoordPointer) +#define SET_TexCoordPointer(disp, fn) SET_by_offset(disp, _gloffset_TexCoordPointer, fn) +#define CALL_VertexPointer(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLint, GLenum, GLsizei, const GLvoid *)), _gloffset_VertexPointer, parameters) +#define GET_VertexPointer(disp) GET_by_offset(disp, _gloffset_VertexPointer) +#define SET_VertexPointer(disp, fn) SET_by_offset(disp, _gloffset_VertexPointer, fn) +#define CALL_AreTexturesResident(disp, parameters) CALL_by_offset(disp, (GLboolean (GLAPIENTRYP)(GLsizei, const GLuint *, GLboolean *)), _gloffset_AreTexturesResident, parameters) +#define GET_AreTexturesResident(disp) GET_by_offset(disp, _gloffset_AreTexturesResident) +#define SET_AreTexturesResident(disp, fn) SET_by_offset(disp, _gloffset_AreTexturesResident, fn) +#define CALL_CopyTexImage1D(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLint, GLenum, GLint, GLint, GLsizei, GLint)), _gloffset_CopyTexImage1D, parameters) +#define GET_CopyTexImage1D(disp) GET_by_offset(disp, _gloffset_CopyTexImage1D) +#define SET_CopyTexImage1D(disp, fn) SET_by_offset(disp, _gloffset_CopyTexImage1D, fn) +#define CALL_CopyTexImage2D(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLint, GLenum, GLint, GLint, GLsizei, GLsizei, GLint)), _gloffset_CopyTexImage2D, parameters) +#define GET_CopyTexImage2D(disp) GET_by_offset(disp, _gloffset_CopyTexImage2D) +#define SET_CopyTexImage2D(disp, fn) SET_by_offset(disp, _gloffset_CopyTexImage2D, fn) +#define CALL_CopyTexSubImage1D(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLint, GLint, GLint, GLint, GLsizei)), _gloffset_CopyTexSubImage1D, parameters) +#define GET_CopyTexSubImage1D(disp) GET_by_offset(disp, _gloffset_CopyTexSubImage1D) +#define SET_CopyTexSubImage1D(disp, fn) SET_by_offset(disp, _gloffset_CopyTexSubImage1D, fn) +#define CALL_CopyTexSubImage2D(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLint, GLint, GLint, GLint, GLint, GLsizei, GLsizei)), _gloffset_CopyTexSubImage2D, parameters) +#define GET_CopyTexSubImage2D(disp) GET_by_offset(disp, _gloffset_CopyTexSubImage2D) +#define SET_CopyTexSubImage2D(disp, fn) SET_by_offset(disp, _gloffset_CopyTexSubImage2D, fn) +#define CALL_DeleteTextures(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLsizei, const GLuint *)), _gloffset_DeleteTextures, parameters) +#define GET_DeleteTextures(disp) GET_by_offset(disp, _gloffset_DeleteTextures) +#define SET_DeleteTextures(disp, fn) SET_by_offset(disp, _gloffset_DeleteTextures, fn) +#define CALL_GenTextures(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLsizei, GLuint *)), _gloffset_GenTextures, parameters) +#define GET_GenTextures(disp) GET_by_offset(disp, _gloffset_GenTextures) +#define SET_GenTextures(disp, fn) SET_by_offset(disp, _gloffset_GenTextures, fn) +#define CALL_GetPointerv(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLvoid **)), _gloffset_GetPointerv, parameters) +#define GET_GetPointerv(disp) GET_by_offset(disp, _gloffset_GetPointerv) +#define SET_GetPointerv(disp, fn) SET_by_offset(disp, _gloffset_GetPointerv, fn) +#define CALL_IsTexture(disp, parameters) CALL_by_offset(disp, (GLboolean (GLAPIENTRYP)(GLuint)), _gloffset_IsTexture, parameters) +#define GET_IsTexture(disp) GET_by_offset(disp, _gloffset_IsTexture) +#define SET_IsTexture(disp, fn) SET_by_offset(disp, _gloffset_IsTexture, fn) +#define CALL_PrioritizeTextures(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLsizei, const GLuint *, const GLclampf *)), _gloffset_PrioritizeTextures, parameters) +#define GET_PrioritizeTextures(disp) GET_by_offset(disp, _gloffset_PrioritizeTextures) +#define SET_PrioritizeTextures(disp, fn) SET_by_offset(disp, _gloffset_PrioritizeTextures, fn) +#define CALL_TexSubImage1D(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLint, GLint, GLsizei, GLenum, GLenum, const GLvoid *)), _gloffset_TexSubImage1D, parameters) +#define GET_TexSubImage1D(disp) GET_by_offset(disp, _gloffset_TexSubImage1D) +#define SET_TexSubImage1D(disp, fn) SET_by_offset(disp, _gloffset_TexSubImage1D, fn) +#define CALL_TexSubImage2D(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLint, GLint, GLint, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *)), _gloffset_TexSubImage2D, parameters) +#define GET_TexSubImage2D(disp) GET_by_offset(disp, _gloffset_TexSubImage2D) +#define SET_TexSubImage2D(disp, fn) SET_by_offset(disp, _gloffset_TexSubImage2D, fn) +#define CALL_PopClientAttrib(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(void)), _gloffset_PopClientAttrib, parameters) +#define GET_PopClientAttrib(disp) GET_by_offset(disp, _gloffset_PopClientAttrib) +#define SET_PopClientAttrib(disp, fn) SET_by_offset(disp, _gloffset_PopClientAttrib, fn) +#define CALL_PushClientAttrib(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLbitfield)), _gloffset_PushClientAttrib, parameters) +#define GET_PushClientAttrib(disp) GET_by_offset(disp, _gloffset_PushClientAttrib) +#define SET_PushClientAttrib(disp, fn) SET_by_offset(disp, _gloffset_PushClientAttrib, fn) +#define CALL_BlendColor(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLclampf, GLclampf, GLclampf, GLclampf)), _gloffset_BlendColor, parameters) +#define GET_BlendColor(disp) GET_by_offset(disp, _gloffset_BlendColor) +#define SET_BlendColor(disp, fn) SET_by_offset(disp, _gloffset_BlendColor, fn) +#define CALL_BlendEquationOES(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum)), _gloffset_BlendEquationOES, parameters) +#define GET_BlendEquationOES(disp) GET_by_offset(disp, _gloffset_BlendEquationOES) +#define SET_BlendEquationOES(disp, fn) SET_by_offset(disp, _gloffset_BlendEquationOES, fn) +#define CALL_DrawRangeElements(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLuint, GLuint, GLsizei, GLenum, const GLvoid *)), _gloffset_DrawRangeElements, parameters) +#define GET_DrawRangeElements(disp) GET_by_offset(disp, _gloffset_DrawRangeElements) +#define SET_DrawRangeElements(disp, fn) SET_by_offset(disp, _gloffset_DrawRangeElements, fn) +#define CALL_ColorTable(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLenum, GLsizei, GLenum, GLenum, const GLvoid *)), _gloffset_ColorTable, parameters) +#define GET_ColorTable(disp) GET_by_offset(disp, _gloffset_ColorTable) +#define SET_ColorTable(disp, fn) SET_by_offset(disp, _gloffset_ColorTable, fn) +#define CALL_ColorTableParameterfv(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLenum, const GLfloat *)), _gloffset_ColorTableParameterfv, parameters) +#define GET_ColorTableParameterfv(disp) GET_by_offset(disp, _gloffset_ColorTableParameterfv) +#define SET_ColorTableParameterfv(disp, fn) SET_by_offset(disp, _gloffset_ColorTableParameterfv, fn) +#define CALL_ColorTableParameteriv(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLenum, const GLint *)), _gloffset_ColorTableParameteriv, parameters) +#define GET_ColorTableParameteriv(disp) GET_by_offset(disp, _gloffset_ColorTableParameteriv) +#define SET_ColorTableParameteriv(disp, fn) SET_by_offset(disp, _gloffset_ColorTableParameteriv, fn) +#define CALL_CopyColorTable(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLenum, GLint, GLint, GLsizei)), _gloffset_CopyColorTable, parameters) +#define GET_CopyColorTable(disp) GET_by_offset(disp, _gloffset_CopyColorTable) +#define SET_CopyColorTable(disp, fn) SET_by_offset(disp, _gloffset_CopyColorTable, fn) +#define CALL_GetColorTable(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLenum, GLenum, GLvoid *)), _gloffset_GetColorTable, parameters) +#define GET_GetColorTable(disp) GET_by_offset(disp, _gloffset_GetColorTable) +#define SET_GetColorTable(disp, fn) SET_by_offset(disp, _gloffset_GetColorTable, fn) +#define CALL_GetColorTableParameterfv(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLenum, GLfloat *)), _gloffset_GetColorTableParameterfv, parameters) +#define GET_GetColorTableParameterfv(disp) GET_by_offset(disp, _gloffset_GetColorTableParameterfv) +#define SET_GetColorTableParameterfv(disp, fn) SET_by_offset(disp, _gloffset_GetColorTableParameterfv, fn) +#define CALL_GetColorTableParameteriv(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLenum, GLint *)), _gloffset_GetColorTableParameteriv, parameters) +#define GET_GetColorTableParameteriv(disp) GET_by_offset(disp, _gloffset_GetColorTableParameteriv) +#define SET_GetColorTableParameteriv(disp, fn) SET_by_offset(disp, _gloffset_GetColorTableParameteriv, fn) +#define CALL_ColorSubTable(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *)), _gloffset_ColorSubTable, parameters) +#define GET_ColorSubTable(disp) GET_by_offset(disp, _gloffset_ColorSubTable) +#define SET_ColorSubTable(disp, fn) SET_by_offset(disp, _gloffset_ColorSubTable, fn) +#define CALL_CopyColorSubTable(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLsizei, GLint, GLint, GLsizei)), _gloffset_CopyColorSubTable, parameters) +#define GET_CopyColorSubTable(disp) GET_by_offset(disp, _gloffset_CopyColorSubTable) +#define SET_CopyColorSubTable(disp, fn) SET_by_offset(disp, _gloffset_CopyColorSubTable, fn) +#define CALL_ConvolutionFilter1D(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLenum, GLsizei, GLenum, GLenum, const GLvoid *)), _gloffset_ConvolutionFilter1D, parameters) +#define GET_ConvolutionFilter1D(disp) GET_by_offset(disp, _gloffset_ConvolutionFilter1D) +#define SET_ConvolutionFilter1D(disp, fn) SET_by_offset(disp, _gloffset_ConvolutionFilter1D, fn) +#define CALL_ConvolutionFilter2D(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLenum, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *)), _gloffset_ConvolutionFilter2D, parameters) +#define GET_ConvolutionFilter2D(disp) GET_by_offset(disp, _gloffset_ConvolutionFilter2D) +#define SET_ConvolutionFilter2D(disp, fn) SET_by_offset(disp, _gloffset_ConvolutionFilter2D, fn) +#define CALL_ConvolutionParameterf(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLenum, GLfloat)), _gloffset_ConvolutionParameterf, parameters) +#define GET_ConvolutionParameterf(disp) GET_by_offset(disp, _gloffset_ConvolutionParameterf) +#define SET_ConvolutionParameterf(disp, fn) SET_by_offset(disp, _gloffset_ConvolutionParameterf, fn) +#define CALL_ConvolutionParameterfv(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLenum, const GLfloat *)), _gloffset_ConvolutionParameterfv, parameters) +#define GET_ConvolutionParameterfv(disp) GET_by_offset(disp, _gloffset_ConvolutionParameterfv) +#define SET_ConvolutionParameterfv(disp, fn) SET_by_offset(disp, _gloffset_ConvolutionParameterfv, fn) +#define CALL_ConvolutionParameteri(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLenum, GLint)), _gloffset_ConvolutionParameteri, parameters) +#define GET_ConvolutionParameteri(disp) GET_by_offset(disp, _gloffset_ConvolutionParameteri) +#define SET_ConvolutionParameteri(disp, fn) SET_by_offset(disp, _gloffset_ConvolutionParameteri, fn) +#define CALL_ConvolutionParameteriv(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLenum, const GLint *)), _gloffset_ConvolutionParameteriv, parameters) +#define GET_ConvolutionParameteriv(disp) GET_by_offset(disp, _gloffset_ConvolutionParameteriv) +#define SET_ConvolutionParameteriv(disp, fn) SET_by_offset(disp, _gloffset_ConvolutionParameteriv, fn) +#define CALL_CopyConvolutionFilter1D(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLenum, GLint, GLint, GLsizei)), _gloffset_CopyConvolutionFilter1D, parameters) +#define GET_CopyConvolutionFilter1D(disp) GET_by_offset(disp, _gloffset_CopyConvolutionFilter1D) +#define SET_CopyConvolutionFilter1D(disp, fn) SET_by_offset(disp, _gloffset_CopyConvolutionFilter1D, fn) +#define CALL_CopyConvolutionFilter2D(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLenum, GLint, GLint, GLsizei, GLsizei)), _gloffset_CopyConvolutionFilter2D, parameters) +#define GET_CopyConvolutionFilter2D(disp) GET_by_offset(disp, _gloffset_CopyConvolutionFilter2D) +#define SET_CopyConvolutionFilter2D(disp, fn) SET_by_offset(disp, _gloffset_CopyConvolutionFilter2D, fn) +#define CALL_GetConvolutionFilter(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLenum, GLenum, GLvoid *)), _gloffset_GetConvolutionFilter, parameters) +#define GET_GetConvolutionFilter(disp) GET_by_offset(disp, _gloffset_GetConvolutionFilter) +#define SET_GetConvolutionFilter(disp, fn) SET_by_offset(disp, _gloffset_GetConvolutionFilter, fn) +#define CALL_GetConvolutionParameterfv(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLenum, GLfloat *)), _gloffset_GetConvolutionParameterfv, parameters) +#define GET_GetConvolutionParameterfv(disp) GET_by_offset(disp, _gloffset_GetConvolutionParameterfv) +#define SET_GetConvolutionParameterfv(disp, fn) SET_by_offset(disp, _gloffset_GetConvolutionParameterfv, fn) +#define CALL_GetConvolutionParameteriv(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLenum, GLint *)), _gloffset_GetConvolutionParameteriv, parameters) +#define GET_GetConvolutionParameteriv(disp) GET_by_offset(disp, _gloffset_GetConvolutionParameteriv) +#define SET_GetConvolutionParameteriv(disp, fn) SET_by_offset(disp, _gloffset_GetConvolutionParameteriv, fn) +#define CALL_GetSeparableFilter(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLenum, GLenum, GLvoid *, GLvoid *, GLvoid *)), _gloffset_GetSeparableFilter, parameters) +#define GET_GetSeparableFilter(disp) GET_by_offset(disp, _gloffset_GetSeparableFilter) +#define SET_GetSeparableFilter(disp, fn) SET_by_offset(disp, _gloffset_GetSeparableFilter, fn) +#define CALL_SeparableFilter2D(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLenum, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *, const GLvoid *)), _gloffset_SeparableFilter2D, parameters) +#define GET_SeparableFilter2D(disp) GET_by_offset(disp, _gloffset_SeparableFilter2D) +#define SET_SeparableFilter2D(disp, fn) SET_by_offset(disp, _gloffset_SeparableFilter2D, fn) +#define CALL_GetHistogram(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLboolean, GLenum, GLenum, GLvoid *)), _gloffset_GetHistogram, parameters) +#define GET_GetHistogram(disp) GET_by_offset(disp, _gloffset_GetHistogram) +#define SET_GetHistogram(disp, fn) SET_by_offset(disp, _gloffset_GetHistogram, fn) +#define CALL_GetHistogramParameterfv(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLenum, GLfloat *)), _gloffset_GetHistogramParameterfv, parameters) +#define GET_GetHistogramParameterfv(disp) GET_by_offset(disp, _gloffset_GetHistogramParameterfv) +#define SET_GetHistogramParameterfv(disp, fn) SET_by_offset(disp, _gloffset_GetHistogramParameterfv, fn) +#define CALL_GetHistogramParameteriv(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLenum, GLint *)), _gloffset_GetHistogramParameteriv, parameters) +#define GET_GetHistogramParameteriv(disp) GET_by_offset(disp, _gloffset_GetHistogramParameteriv) +#define SET_GetHistogramParameteriv(disp, fn) SET_by_offset(disp, _gloffset_GetHistogramParameteriv, fn) +#define CALL_GetMinmax(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLboolean, GLenum, GLenum, GLvoid *)), _gloffset_GetMinmax, parameters) +#define GET_GetMinmax(disp) GET_by_offset(disp, _gloffset_GetMinmax) +#define SET_GetMinmax(disp, fn) SET_by_offset(disp, _gloffset_GetMinmax, fn) +#define CALL_GetMinmaxParameterfv(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLenum, GLfloat *)), _gloffset_GetMinmaxParameterfv, parameters) +#define GET_GetMinmaxParameterfv(disp) GET_by_offset(disp, _gloffset_GetMinmaxParameterfv) +#define SET_GetMinmaxParameterfv(disp, fn) SET_by_offset(disp, _gloffset_GetMinmaxParameterfv, fn) +#define CALL_GetMinmaxParameteriv(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLenum, GLint *)), _gloffset_GetMinmaxParameteriv, parameters) +#define GET_GetMinmaxParameteriv(disp) GET_by_offset(disp, _gloffset_GetMinmaxParameteriv) +#define SET_GetMinmaxParameteriv(disp, fn) SET_by_offset(disp, _gloffset_GetMinmaxParameteriv, fn) +#define CALL_Histogram(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLsizei, GLenum, GLboolean)), _gloffset_Histogram, parameters) +#define GET_Histogram(disp) GET_by_offset(disp, _gloffset_Histogram) +#define SET_Histogram(disp, fn) SET_by_offset(disp, _gloffset_Histogram, fn) +#define CALL_Minmax(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLenum, GLboolean)), _gloffset_Minmax, parameters) +#define GET_Minmax(disp) GET_by_offset(disp, _gloffset_Minmax) +#define SET_Minmax(disp, fn) SET_by_offset(disp, _gloffset_Minmax, fn) +#define CALL_ResetHistogram(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum)), _gloffset_ResetHistogram, parameters) +#define GET_ResetHistogram(disp) GET_by_offset(disp, _gloffset_ResetHistogram) +#define SET_ResetHistogram(disp, fn) SET_by_offset(disp, _gloffset_ResetHistogram, fn) +#define CALL_ResetMinmax(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum)), _gloffset_ResetMinmax, parameters) +#define GET_ResetMinmax(disp) GET_by_offset(disp, _gloffset_ResetMinmax) +#define SET_ResetMinmax(disp, fn) SET_by_offset(disp, _gloffset_ResetMinmax, fn) +#define CALL_TexImage3D(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLint, GLint, GLsizei, GLsizei, GLsizei, GLint, GLenum, GLenum, const GLvoid *)), _gloffset_TexImage3D, parameters) +#define GET_TexImage3D(disp) GET_by_offset(disp, _gloffset_TexImage3D) +#define SET_TexImage3D(disp, fn) SET_by_offset(disp, _gloffset_TexImage3D, fn) +#define CALL_TexSubImage3D(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *)), _gloffset_TexSubImage3D, parameters) +#define GET_TexSubImage3D(disp) GET_by_offset(disp, _gloffset_TexSubImage3D) +#define SET_TexSubImage3D(disp, fn) SET_by_offset(disp, _gloffset_TexSubImage3D, fn) +#define CALL_CopyTexSubImage3D(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLint, GLint, GLint, GLint, GLint, GLint, GLsizei, GLsizei)), _gloffset_CopyTexSubImage3D, parameters) +#define GET_CopyTexSubImage3D(disp) GET_by_offset(disp, _gloffset_CopyTexSubImage3D) +#define SET_CopyTexSubImage3D(disp, fn) SET_by_offset(disp, _gloffset_CopyTexSubImage3D, fn) +#define CALL_ActiveTexture(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum)), _gloffset_ActiveTexture, parameters) +#define GET_ActiveTexture(disp) GET_by_offset(disp, _gloffset_ActiveTexture) +#define SET_ActiveTexture(disp, fn) SET_by_offset(disp, _gloffset_ActiveTexture, fn) +#define CALL_ClientActiveTexture(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum)), _gloffset_ClientActiveTexture, parameters) +#define GET_ClientActiveTexture(disp) GET_by_offset(disp, _gloffset_ClientActiveTexture) +#define SET_ClientActiveTexture(disp, fn) SET_by_offset(disp, _gloffset_ClientActiveTexture, fn) +#define CALL_MultiTexCoord1dARB(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLdouble)), _gloffset_MultiTexCoord1dARB, parameters) +#define GET_MultiTexCoord1dARB(disp) GET_by_offset(disp, _gloffset_MultiTexCoord1dARB) +#define SET_MultiTexCoord1dARB(disp, fn) SET_by_offset(disp, _gloffset_MultiTexCoord1dARB, fn) +#define CALL_MultiTexCoord1dvARB(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, const GLdouble *)), _gloffset_MultiTexCoord1dvARB, parameters) +#define GET_MultiTexCoord1dvARB(disp) GET_by_offset(disp, _gloffset_MultiTexCoord1dvARB) +#define SET_MultiTexCoord1dvARB(disp, fn) SET_by_offset(disp, _gloffset_MultiTexCoord1dvARB, fn) +#define CALL_MultiTexCoord1fARB(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLfloat)), _gloffset_MultiTexCoord1fARB, parameters) +#define GET_MultiTexCoord1fARB(disp) GET_by_offset(disp, _gloffset_MultiTexCoord1fARB) +#define SET_MultiTexCoord1fARB(disp, fn) SET_by_offset(disp, _gloffset_MultiTexCoord1fARB, fn) +#define CALL_MultiTexCoord1fvARB(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, const GLfloat *)), _gloffset_MultiTexCoord1fvARB, parameters) +#define GET_MultiTexCoord1fvARB(disp) GET_by_offset(disp, _gloffset_MultiTexCoord1fvARB) +#define SET_MultiTexCoord1fvARB(disp, fn) SET_by_offset(disp, _gloffset_MultiTexCoord1fvARB, fn) +#define CALL_MultiTexCoord1iARB(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLint)), _gloffset_MultiTexCoord1iARB, parameters) +#define GET_MultiTexCoord1iARB(disp) GET_by_offset(disp, _gloffset_MultiTexCoord1iARB) +#define SET_MultiTexCoord1iARB(disp, fn) SET_by_offset(disp, _gloffset_MultiTexCoord1iARB, fn) +#define CALL_MultiTexCoord1ivARB(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, const GLint *)), _gloffset_MultiTexCoord1ivARB, parameters) +#define GET_MultiTexCoord1ivARB(disp) GET_by_offset(disp, _gloffset_MultiTexCoord1ivARB) +#define SET_MultiTexCoord1ivARB(disp, fn) SET_by_offset(disp, _gloffset_MultiTexCoord1ivARB, fn) +#define CALL_MultiTexCoord1sARB(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLshort)), _gloffset_MultiTexCoord1sARB, parameters) +#define GET_MultiTexCoord1sARB(disp) GET_by_offset(disp, _gloffset_MultiTexCoord1sARB) +#define SET_MultiTexCoord1sARB(disp, fn) SET_by_offset(disp, _gloffset_MultiTexCoord1sARB, fn) +#define CALL_MultiTexCoord1svARB(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, const GLshort *)), _gloffset_MultiTexCoord1svARB, parameters) +#define GET_MultiTexCoord1svARB(disp) GET_by_offset(disp, _gloffset_MultiTexCoord1svARB) +#define SET_MultiTexCoord1svARB(disp, fn) SET_by_offset(disp, _gloffset_MultiTexCoord1svARB, fn) +#define CALL_MultiTexCoord2dARB(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLdouble, GLdouble)), _gloffset_MultiTexCoord2dARB, parameters) +#define GET_MultiTexCoord2dARB(disp) GET_by_offset(disp, _gloffset_MultiTexCoord2dARB) +#define SET_MultiTexCoord2dARB(disp, fn) SET_by_offset(disp, _gloffset_MultiTexCoord2dARB, fn) +#define CALL_MultiTexCoord2dvARB(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, const GLdouble *)), _gloffset_MultiTexCoord2dvARB, parameters) +#define GET_MultiTexCoord2dvARB(disp) GET_by_offset(disp, _gloffset_MultiTexCoord2dvARB) +#define SET_MultiTexCoord2dvARB(disp, fn) SET_by_offset(disp, _gloffset_MultiTexCoord2dvARB, fn) +#define CALL_MultiTexCoord2fARB(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLfloat, GLfloat)), _gloffset_MultiTexCoord2fARB, parameters) +#define GET_MultiTexCoord2fARB(disp) GET_by_offset(disp, _gloffset_MultiTexCoord2fARB) +#define SET_MultiTexCoord2fARB(disp, fn) SET_by_offset(disp, _gloffset_MultiTexCoord2fARB, fn) +#define CALL_MultiTexCoord2fvARB(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, const GLfloat *)), _gloffset_MultiTexCoord2fvARB, parameters) +#define GET_MultiTexCoord2fvARB(disp) GET_by_offset(disp, _gloffset_MultiTexCoord2fvARB) +#define SET_MultiTexCoord2fvARB(disp, fn) SET_by_offset(disp, _gloffset_MultiTexCoord2fvARB, fn) +#define CALL_MultiTexCoord2iARB(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLint, GLint)), _gloffset_MultiTexCoord2iARB, parameters) +#define GET_MultiTexCoord2iARB(disp) GET_by_offset(disp, _gloffset_MultiTexCoord2iARB) +#define SET_MultiTexCoord2iARB(disp, fn) SET_by_offset(disp, _gloffset_MultiTexCoord2iARB, fn) +#define CALL_MultiTexCoord2ivARB(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, const GLint *)), _gloffset_MultiTexCoord2ivARB, parameters) +#define GET_MultiTexCoord2ivARB(disp) GET_by_offset(disp, _gloffset_MultiTexCoord2ivARB) +#define SET_MultiTexCoord2ivARB(disp, fn) SET_by_offset(disp, _gloffset_MultiTexCoord2ivARB, fn) +#define CALL_MultiTexCoord2sARB(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLshort, GLshort)), _gloffset_MultiTexCoord2sARB, parameters) +#define GET_MultiTexCoord2sARB(disp) GET_by_offset(disp, _gloffset_MultiTexCoord2sARB) +#define SET_MultiTexCoord2sARB(disp, fn) SET_by_offset(disp, _gloffset_MultiTexCoord2sARB, fn) +#define CALL_MultiTexCoord2svARB(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, const GLshort *)), _gloffset_MultiTexCoord2svARB, parameters) +#define GET_MultiTexCoord2svARB(disp) GET_by_offset(disp, _gloffset_MultiTexCoord2svARB) +#define SET_MultiTexCoord2svARB(disp, fn) SET_by_offset(disp, _gloffset_MultiTexCoord2svARB, fn) +#define CALL_MultiTexCoord3dARB(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLdouble, GLdouble, GLdouble)), _gloffset_MultiTexCoord3dARB, parameters) +#define GET_MultiTexCoord3dARB(disp) GET_by_offset(disp, _gloffset_MultiTexCoord3dARB) +#define SET_MultiTexCoord3dARB(disp, fn) SET_by_offset(disp, _gloffset_MultiTexCoord3dARB, fn) +#define CALL_MultiTexCoord3dvARB(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, const GLdouble *)), _gloffset_MultiTexCoord3dvARB, parameters) +#define GET_MultiTexCoord3dvARB(disp) GET_by_offset(disp, _gloffset_MultiTexCoord3dvARB) +#define SET_MultiTexCoord3dvARB(disp, fn) SET_by_offset(disp, _gloffset_MultiTexCoord3dvARB, fn) +#define CALL_MultiTexCoord3fARB(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLfloat, GLfloat, GLfloat)), _gloffset_MultiTexCoord3fARB, parameters) +#define GET_MultiTexCoord3fARB(disp) GET_by_offset(disp, _gloffset_MultiTexCoord3fARB) +#define SET_MultiTexCoord3fARB(disp, fn) SET_by_offset(disp, _gloffset_MultiTexCoord3fARB, fn) +#define CALL_MultiTexCoord3fvARB(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, const GLfloat *)), _gloffset_MultiTexCoord3fvARB, parameters) +#define GET_MultiTexCoord3fvARB(disp) GET_by_offset(disp, _gloffset_MultiTexCoord3fvARB) +#define SET_MultiTexCoord3fvARB(disp, fn) SET_by_offset(disp, _gloffset_MultiTexCoord3fvARB, fn) +#define CALL_MultiTexCoord3iARB(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLint, GLint, GLint)), _gloffset_MultiTexCoord3iARB, parameters) +#define GET_MultiTexCoord3iARB(disp) GET_by_offset(disp, _gloffset_MultiTexCoord3iARB) +#define SET_MultiTexCoord3iARB(disp, fn) SET_by_offset(disp, _gloffset_MultiTexCoord3iARB, fn) +#define CALL_MultiTexCoord3ivARB(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, const GLint *)), _gloffset_MultiTexCoord3ivARB, parameters) +#define GET_MultiTexCoord3ivARB(disp) GET_by_offset(disp, _gloffset_MultiTexCoord3ivARB) +#define SET_MultiTexCoord3ivARB(disp, fn) SET_by_offset(disp, _gloffset_MultiTexCoord3ivARB, fn) +#define CALL_MultiTexCoord3sARB(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLshort, GLshort, GLshort)), _gloffset_MultiTexCoord3sARB, parameters) +#define GET_MultiTexCoord3sARB(disp) GET_by_offset(disp, _gloffset_MultiTexCoord3sARB) +#define SET_MultiTexCoord3sARB(disp, fn) SET_by_offset(disp, _gloffset_MultiTexCoord3sARB, fn) +#define CALL_MultiTexCoord3svARB(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, const GLshort *)), _gloffset_MultiTexCoord3svARB, parameters) +#define GET_MultiTexCoord3svARB(disp) GET_by_offset(disp, _gloffset_MultiTexCoord3svARB) +#define SET_MultiTexCoord3svARB(disp, fn) SET_by_offset(disp, _gloffset_MultiTexCoord3svARB, fn) +#define CALL_MultiTexCoord4dARB(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLdouble, GLdouble, GLdouble, GLdouble)), _gloffset_MultiTexCoord4dARB, parameters) +#define GET_MultiTexCoord4dARB(disp) GET_by_offset(disp, _gloffset_MultiTexCoord4dARB) +#define SET_MultiTexCoord4dARB(disp, fn) SET_by_offset(disp, _gloffset_MultiTexCoord4dARB, fn) +#define CALL_MultiTexCoord4dvARB(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, const GLdouble *)), _gloffset_MultiTexCoord4dvARB, parameters) +#define GET_MultiTexCoord4dvARB(disp) GET_by_offset(disp, _gloffset_MultiTexCoord4dvARB) +#define SET_MultiTexCoord4dvARB(disp, fn) SET_by_offset(disp, _gloffset_MultiTexCoord4dvARB, fn) +#define CALL_MultiTexCoord4f(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLfloat, GLfloat, GLfloat, GLfloat)), _gloffset_MultiTexCoord4f, parameters) +#define GET_MultiTexCoord4f(disp) GET_by_offset(disp, _gloffset_MultiTexCoord4f) +#define SET_MultiTexCoord4f(disp, fn) SET_by_offset(disp, _gloffset_MultiTexCoord4f, fn) +#define CALL_MultiTexCoord4fvARB(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, const GLfloat *)), _gloffset_MultiTexCoord4fvARB, parameters) +#define GET_MultiTexCoord4fvARB(disp) GET_by_offset(disp, _gloffset_MultiTexCoord4fvARB) +#define SET_MultiTexCoord4fvARB(disp, fn) SET_by_offset(disp, _gloffset_MultiTexCoord4fvARB, fn) +#define CALL_MultiTexCoord4iARB(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLint, GLint, GLint, GLint)), _gloffset_MultiTexCoord4iARB, parameters) +#define GET_MultiTexCoord4iARB(disp) GET_by_offset(disp, _gloffset_MultiTexCoord4iARB) +#define SET_MultiTexCoord4iARB(disp, fn) SET_by_offset(disp, _gloffset_MultiTexCoord4iARB, fn) +#define CALL_MultiTexCoord4ivARB(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, const GLint *)), _gloffset_MultiTexCoord4ivARB, parameters) +#define GET_MultiTexCoord4ivARB(disp) GET_by_offset(disp, _gloffset_MultiTexCoord4ivARB) +#define SET_MultiTexCoord4ivARB(disp, fn) SET_by_offset(disp, _gloffset_MultiTexCoord4ivARB, fn) +#define CALL_MultiTexCoord4sARB(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLshort, GLshort, GLshort, GLshort)), _gloffset_MultiTexCoord4sARB, parameters) +#define GET_MultiTexCoord4sARB(disp) GET_by_offset(disp, _gloffset_MultiTexCoord4sARB) +#define SET_MultiTexCoord4sARB(disp, fn) SET_by_offset(disp, _gloffset_MultiTexCoord4sARB, fn) +#define CALL_MultiTexCoord4svARB(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, const GLshort *)), _gloffset_MultiTexCoord4svARB, parameters) +#define GET_MultiTexCoord4svARB(disp) GET_by_offset(disp, _gloffset_MultiTexCoord4svARB) +#define SET_MultiTexCoord4svARB(disp, fn) SET_by_offset(disp, _gloffset_MultiTexCoord4svARB, fn) +#define CALL_BlendEquationSeparateOES(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLenum)), _gloffset_BlendEquationSeparateOES, parameters) +#define GET_BlendEquationSeparateOES(disp) GET_by_offset(disp, _gloffset_BlendEquationSeparateOES) +#define SET_BlendEquationSeparateOES(disp, fn) SET_by_offset(disp, _gloffset_BlendEquationSeparateOES, fn) +#define CALL_BlendFuncSeparateOES(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLenum, GLenum, GLenum)), _gloffset_BlendFuncSeparateOES, parameters) +#define GET_BlendFuncSeparateOES(disp) GET_by_offset(disp, _gloffset_BlendFuncSeparateOES) +#define SET_BlendFuncSeparateOES(disp, fn) SET_by_offset(disp, _gloffset_BlendFuncSeparateOES, fn) +#define CALL_DrawTexfOES(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLfloat, GLfloat, GLfloat, GLfloat, GLfloat)), _gloffset_DrawTexfOES, parameters) +#define GET_DrawTexfOES(disp) GET_by_offset(disp, _gloffset_DrawTexfOES) +#define SET_DrawTexfOES(disp, fn) SET_by_offset(disp, _gloffset_DrawTexfOES, fn) +#define CALL_DrawTexfvOES(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(const GLfloat *)), _gloffset_DrawTexfvOES, parameters) +#define GET_DrawTexfvOES(disp) GET_by_offset(disp, _gloffset_DrawTexfvOES) +#define SET_DrawTexfvOES(disp, fn) SET_by_offset(disp, _gloffset_DrawTexfvOES, fn) +#define CALL_DrawTexiOES(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLint, GLint, GLint, GLint, GLint)), _gloffset_DrawTexiOES, parameters) +#define GET_DrawTexiOES(disp) GET_by_offset(disp, _gloffset_DrawTexiOES) +#define SET_DrawTexiOES(disp, fn) SET_by_offset(disp, _gloffset_DrawTexiOES, fn) +#define CALL_DrawTexivOES(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(const GLint *)), _gloffset_DrawTexivOES, parameters) +#define GET_DrawTexivOES(disp) GET_by_offset(disp, _gloffset_DrawTexivOES) +#define SET_DrawTexivOES(disp, fn) SET_by_offset(disp, _gloffset_DrawTexivOES, fn) +#define CALL_DrawTexsOES(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLshort, GLshort, GLshort, GLshort, GLshort)), _gloffset_DrawTexsOES, parameters) +#define GET_DrawTexsOES(disp) GET_by_offset(disp, _gloffset_DrawTexsOES) +#define SET_DrawTexsOES(disp, fn) SET_by_offset(disp, _gloffset_DrawTexsOES, fn) +#define CALL_DrawTexsvOES(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(const GLshort *)), _gloffset_DrawTexsvOES, parameters) +#define GET_DrawTexsvOES(disp) GET_by_offset(disp, _gloffset_DrawTexsvOES) +#define SET_DrawTexsvOES(disp, fn) SET_by_offset(disp, _gloffset_DrawTexsvOES, fn) +#define CALL_DrawTexxOES(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLfixed, GLfixed, GLfixed, GLfixed, GLfixed)), _gloffset_DrawTexxOES, parameters) +#define GET_DrawTexxOES(disp) GET_by_offset(disp, _gloffset_DrawTexxOES) +#define SET_DrawTexxOES(disp, fn) SET_by_offset(disp, _gloffset_DrawTexxOES, fn) +#define CALL_DrawTexxvOES(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(const GLfixed *)), _gloffset_DrawTexxvOES, parameters) +#define GET_DrawTexxvOES(disp) GET_by_offset(disp, _gloffset_DrawTexxvOES) +#define SET_DrawTexxvOES(disp, fn) SET_by_offset(disp, _gloffset_DrawTexxvOES, fn) +#define CALL_BindFramebufferOES(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLuint)), _gloffset_BindFramebufferOES, parameters) +#define GET_BindFramebufferOES(disp) GET_by_offset(disp, _gloffset_BindFramebufferOES) +#define SET_BindFramebufferOES(disp, fn) SET_by_offset(disp, _gloffset_BindFramebufferOES, fn) +#define CALL_BindRenderbufferOES(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLuint)), _gloffset_BindRenderbufferOES, parameters) +#define GET_BindRenderbufferOES(disp) GET_by_offset(disp, _gloffset_BindRenderbufferOES) +#define SET_BindRenderbufferOES(disp, fn) SET_by_offset(disp, _gloffset_BindRenderbufferOES, fn) +#define CALL_CheckFramebufferStatusOES(disp, parameters) CALL_by_offset(disp, (GLenum (GLAPIENTRYP)(GLenum)), _gloffset_CheckFramebufferStatusOES, parameters) +#define GET_CheckFramebufferStatusOES(disp) GET_by_offset(disp, _gloffset_CheckFramebufferStatusOES) +#define SET_CheckFramebufferStatusOES(disp, fn) SET_by_offset(disp, _gloffset_CheckFramebufferStatusOES, fn) +#define CALL_DeleteFramebuffersOES(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLsizei, const GLuint *)), _gloffset_DeleteFramebuffersOES, parameters) +#define GET_DeleteFramebuffersOES(disp) GET_by_offset(disp, _gloffset_DeleteFramebuffersOES) +#define SET_DeleteFramebuffersOES(disp, fn) SET_by_offset(disp, _gloffset_DeleteFramebuffersOES, fn) +#define CALL_DeleteRenderbuffersOES(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLsizei, const GLuint *)), _gloffset_DeleteRenderbuffersOES, parameters) +#define GET_DeleteRenderbuffersOES(disp) GET_by_offset(disp, _gloffset_DeleteRenderbuffersOES) +#define SET_DeleteRenderbuffersOES(disp, fn) SET_by_offset(disp, _gloffset_DeleteRenderbuffersOES, fn) +#define CALL_FramebufferRenderbufferOES(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLenum, GLenum, GLuint)), _gloffset_FramebufferRenderbufferOES, parameters) +#define GET_FramebufferRenderbufferOES(disp) GET_by_offset(disp, _gloffset_FramebufferRenderbufferOES) +#define SET_FramebufferRenderbufferOES(disp, fn) SET_by_offset(disp, _gloffset_FramebufferRenderbufferOES, fn) +#define CALL_FramebufferTexture2DOES(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLenum, GLenum, GLuint, GLint)), _gloffset_FramebufferTexture2DOES, parameters) +#define GET_FramebufferTexture2DOES(disp) GET_by_offset(disp, _gloffset_FramebufferTexture2DOES) +#define SET_FramebufferTexture2DOES(disp, fn) SET_by_offset(disp, _gloffset_FramebufferTexture2DOES, fn) +#define CALL_GenFramebuffersOES(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLsizei, GLuint *)), _gloffset_GenFramebuffersOES, parameters) +#define GET_GenFramebuffersOES(disp) GET_by_offset(disp, _gloffset_GenFramebuffersOES) +#define SET_GenFramebuffersOES(disp, fn) SET_by_offset(disp, _gloffset_GenFramebuffersOES, fn) +#define CALL_GenRenderbuffersOES(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLsizei, GLuint *)), _gloffset_GenRenderbuffersOES, parameters) +#define GET_GenRenderbuffersOES(disp) GET_by_offset(disp, _gloffset_GenRenderbuffersOES) +#define SET_GenRenderbuffersOES(disp, fn) SET_by_offset(disp, _gloffset_GenRenderbuffersOES, fn) +#define CALL_GenerateMipmapOES(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum)), _gloffset_GenerateMipmapOES, parameters) +#define GET_GenerateMipmapOES(disp) GET_by_offset(disp, _gloffset_GenerateMipmapOES) +#define SET_GenerateMipmapOES(disp, fn) SET_by_offset(disp, _gloffset_GenerateMipmapOES, fn) +#define CALL_GetFramebufferAttachmentParameterivOES(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLenum, GLenum, GLint *)), _gloffset_GetFramebufferAttachmentParameterivOES, parameters) +#define GET_GetFramebufferAttachmentParameterivOES(disp) GET_by_offset(disp, _gloffset_GetFramebufferAttachmentParameterivOES) +#define SET_GetFramebufferAttachmentParameterivOES(disp, fn) SET_by_offset(disp, _gloffset_GetFramebufferAttachmentParameterivOES, fn) +#define CALL_GetRenderbufferParameterivOES(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLenum, GLint *)), _gloffset_GetRenderbufferParameterivOES, parameters) +#define GET_GetRenderbufferParameterivOES(disp) GET_by_offset(disp, _gloffset_GetRenderbufferParameterivOES) +#define SET_GetRenderbufferParameterivOES(disp, fn) SET_by_offset(disp, _gloffset_GetRenderbufferParameterivOES, fn) +#define CALL_IsFramebufferOES(disp, parameters) CALL_by_offset(disp, (GLboolean (GLAPIENTRYP)(GLuint)), _gloffset_IsFramebufferOES, parameters) +#define GET_IsFramebufferOES(disp) GET_by_offset(disp, _gloffset_IsFramebufferOES) +#define SET_IsFramebufferOES(disp, fn) SET_by_offset(disp, _gloffset_IsFramebufferOES, fn) +#define CALL_IsRenderbufferOES(disp, parameters) CALL_by_offset(disp, (GLboolean (GLAPIENTRYP)(GLuint)), _gloffset_IsRenderbufferOES, parameters) +#define GET_IsRenderbufferOES(disp) GET_by_offset(disp, _gloffset_IsRenderbufferOES) +#define SET_IsRenderbufferOES(disp, fn) SET_by_offset(disp, _gloffset_IsRenderbufferOES, fn) +#define CALL_RenderbufferStorageOES(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLenum, GLsizei, GLsizei)), _gloffset_RenderbufferStorageOES, parameters) +#define GET_RenderbufferStorageOES(disp) GET_by_offset(disp, _gloffset_RenderbufferStorageOES) +#define SET_RenderbufferStorageOES(disp, fn) SET_by_offset(disp, _gloffset_RenderbufferStorageOES, fn) +#define CALL_PointSizePointerOES(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLsizei, const GLvoid *)), _gloffset_PointSizePointerOES, parameters) +#define GET_PointSizePointerOES(disp) GET_by_offset(disp, _gloffset_PointSizePointerOES) +#define SET_PointSizePointerOES(disp, fn) SET_by_offset(disp, _gloffset_PointSizePointerOES, fn) +#define CALL_QueryMatrixxOES(disp, parameters) CALL_by_offset(disp, (GLbitfield (GLAPIENTRYP)(GLfixed *, GLint *)), _gloffset_QueryMatrixxOES, parameters) +#define GET_QueryMatrixxOES(disp) GET_by_offset(disp, _gloffset_QueryMatrixxOES) +#define SET_QueryMatrixxOES(disp, fn) SET_by_offset(disp, _gloffset_QueryMatrixxOES, fn) +#define CALL_GetTexGenxvOES(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLenum, GLfixed *)), _gloffset_GetTexGenxvOES, parameters) +#define GET_GetTexGenxvOES(disp) GET_by_offset(disp, _gloffset_GetTexGenxvOES) +#define SET_GetTexGenxvOES(disp, fn) SET_by_offset(disp, _gloffset_GetTexGenxvOES, fn) +#define CALL_TexGenxOES(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLenum, GLint)), _gloffset_TexGenxOES, parameters) +#define GET_TexGenxOES(disp) GET_by_offset(disp, _gloffset_TexGenxOES) +#define SET_TexGenxOES(disp, fn) SET_by_offset(disp, _gloffset_TexGenxOES, fn) +#define CALL_TexGenxvOES(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLenum, const GLfixed *)), _gloffset_TexGenxvOES, parameters) +#define GET_TexGenxvOES(disp) GET_by_offset(disp, _gloffset_TexGenxvOES) +#define SET_TexGenxvOES(disp, fn) SET_by_offset(disp, _gloffset_TexGenxvOES, fn) +#define CALL_GetBufferPointervOES(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLenum, GLvoid **)), _gloffset_GetBufferPointervOES, parameters) +#define GET_GetBufferPointervOES(disp) GET_by_offset(disp, _gloffset_GetBufferPointervOES) +#define SET_GetBufferPointervOES(disp, fn) SET_by_offset(disp, _gloffset_GetBufferPointervOES, fn) +#define CALL_MapBufferOES(disp, parameters) CALL_by_offset(disp, (GLvoid * (GLAPIENTRYP)(GLenum, GLenum)), _gloffset_MapBufferOES, parameters) +#define GET_MapBufferOES(disp) GET_by_offset(disp, _gloffset_MapBufferOES) +#define SET_MapBufferOES(disp, fn) SET_by_offset(disp, _gloffset_MapBufferOES, fn) +#define CALL_UnmapBufferOES(disp, parameters) CALL_by_offset(disp, (GLboolean (GLAPIENTRYP)(GLenum)), _gloffset_UnmapBufferOES, parameters) +#define GET_UnmapBufferOES(disp) GET_by_offset(disp, _gloffset_UnmapBufferOES) +#define SET_UnmapBufferOES(disp, fn) SET_by_offset(disp, _gloffset_UnmapBufferOES, fn) +#define CALL_MultiDrawArraysEXT(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, const GLint *, const GLsizei *, GLsizei)), _gloffset_MultiDrawArraysEXT, parameters) +#define GET_MultiDrawArraysEXT(disp) GET_by_offset(disp, _gloffset_MultiDrawArraysEXT) +#define SET_MultiDrawArraysEXT(disp, fn) SET_by_offset(disp, _gloffset_MultiDrawArraysEXT, fn) +#define CALL_MultiDrawElementsEXT(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, const GLsizei *, GLenum, const GLvoid **, GLsizei)), _gloffset_MultiDrawElementsEXT, parameters) +#define GET_MultiDrawElementsEXT(disp) GET_by_offset(disp, _gloffset_MultiDrawElementsEXT) +#define SET_MultiDrawElementsEXT(disp, fn) SET_by_offset(disp, _gloffset_MultiDrawElementsEXT, fn) +#define CALL_BindVertexArrayAPPLE(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLuint)), _gloffset_BindVertexArrayAPPLE, parameters) +#define GET_BindVertexArrayAPPLE(disp) GET_by_offset(disp, _gloffset_BindVertexArrayAPPLE) +#define SET_BindVertexArrayAPPLE(disp, fn) SET_by_offset(disp, _gloffset_BindVertexArrayAPPLE, fn) +#define CALL_DeleteVertexArraysAPPLE(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLsizei, const GLuint *)), _gloffset_DeleteVertexArraysAPPLE, parameters) +#define GET_DeleteVertexArraysAPPLE(disp) GET_by_offset(disp, _gloffset_DeleteVertexArraysAPPLE) +#define SET_DeleteVertexArraysAPPLE(disp, fn) SET_by_offset(disp, _gloffset_DeleteVertexArraysAPPLE, fn) +#define CALL_GenVertexArraysAPPLE(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLsizei, GLuint *)), _gloffset_GenVertexArraysAPPLE, parameters) +#define GET_GenVertexArraysAPPLE(disp) GET_by_offset(disp, _gloffset_GenVertexArraysAPPLE) +#define SET_GenVertexArraysAPPLE(disp, fn) SET_by_offset(disp, _gloffset_GenVertexArraysAPPLE, fn) +#define CALL_IsVertexArrayAPPLE(disp, parameters) CALL_by_offset(disp, (GLboolean (GLAPIENTRYP)(GLuint)), _gloffset_IsVertexArrayAPPLE, parameters) +#define GET_IsVertexArrayAPPLE(disp) GET_by_offset(disp, _gloffset_IsVertexArrayAPPLE) +#define SET_IsVertexArrayAPPLE(disp, fn) SET_by_offset(disp, _gloffset_IsVertexArrayAPPLE, fn) +#define CALL_EGLImageTargetRenderbufferStorageOES(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLvoid *)), _gloffset_EGLImageTargetRenderbufferStorageOES, parameters) +#define GET_EGLImageTargetRenderbufferStorageOES(disp) GET_by_offset(disp, _gloffset_EGLImageTargetRenderbufferStorageOES) +#define SET_EGLImageTargetRenderbufferStorageOES(disp, fn) SET_by_offset(disp, _gloffset_EGLImageTargetRenderbufferStorageOES, fn) +#define CALL_EGLImageTargetTexture2DOES(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLvoid *)), _gloffset_EGLImageTargetTexture2DOES, parameters) +#define GET_EGLImageTargetTexture2DOES(disp) GET_by_offset(disp, _gloffset_EGLImageTargetTexture2DOES) +#define SET_EGLImageTargetTexture2DOES(disp, fn) SET_by_offset(disp, _gloffset_EGLImageTargetTexture2DOES, fn) +#define CALL_CompressedTexImage2D(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLint, GLenum, GLsizei, GLsizei, GLint, GLsizei, const GLvoid *)), _gloffset_CompressedTexImage2D, parameters) +#define GET_CompressedTexImage2D(disp) GET_by_offset(disp, _gloffset_CompressedTexImage2D) +#define SET_CompressedTexImage2D(disp, fn) SET_by_offset(disp, _gloffset_CompressedTexImage2D, fn) +#define CALL_CompressedTexSubImage2D(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLint, GLint, GLint, GLsizei, GLsizei, GLenum, GLsizei, const GLvoid *)), _gloffset_CompressedTexSubImage2D, parameters) +#define GET_CompressedTexSubImage2D(disp) GET_by_offset(disp, _gloffset_CompressedTexSubImage2D) +#define SET_CompressedTexSubImage2D(disp, fn) SET_by_offset(disp, _gloffset_CompressedTexSubImage2D, fn) +#define CALL_SampleCoverage(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLclampf, GLboolean)), _gloffset_SampleCoverage, parameters) +#define GET_SampleCoverage(disp) GET_by_offset(disp, _gloffset_SampleCoverage) +#define SET_SampleCoverage(disp, fn) SET_by_offset(disp, _gloffset_SampleCoverage, fn) +#define CALL_BindBuffer(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLuint)), _gloffset_BindBuffer, parameters) +#define GET_BindBuffer(disp) GET_by_offset(disp, _gloffset_BindBuffer) +#define SET_BindBuffer(disp, fn) SET_by_offset(disp, _gloffset_BindBuffer, fn) +#define CALL_BufferData(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLsizeiptr, const GLvoid *, GLenum)), _gloffset_BufferData, parameters) +#define GET_BufferData(disp) GET_by_offset(disp, _gloffset_BufferData) +#define SET_BufferData(disp, fn) SET_by_offset(disp, _gloffset_BufferData, fn) +#define CALL_BufferSubData(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLintptr, GLsizeiptr, const GLvoid *)), _gloffset_BufferSubData, parameters) +#define GET_BufferSubData(disp) GET_by_offset(disp, _gloffset_BufferSubData) +#define SET_BufferSubData(disp, fn) SET_by_offset(disp, _gloffset_BufferSubData, fn) +#define CALL_DeleteBuffers(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLsizei, const GLuint *)), _gloffset_DeleteBuffers, parameters) +#define GET_DeleteBuffers(disp) GET_by_offset(disp, _gloffset_DeleteBuffers) +#define SET_DeleteBuffers(disp, fn) SET_by_offset(disp, _gloffset_DeleteBuffers, fn) +#define CALL_GenBuffers(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLsizei, GLuint *)), _gloffset_GenBuffers, parameters) +#define GET_GenBuffers(disp) GET_by_offset(disp, _gloffset_GenBuffers) +#define SET_GenBuffers(disp, fn) SET_by_offset(disp, _gloffset_GenBuffers, fn) +#define CALL_GetBufferParameteriv(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLenum, GLint *)), _gloffset_GetBufferParameteriv, parameters) +#define GET_GetBufferParameteriv(disp) GET_by_offset(disp, _gloffset_GetBufferParameteriv) +#define SET_GetBufferParameteriv(disp, fn) SET_by_offset(disp, _gloffset_GetBufferParameteriv, fn) +#define CALL_IsBuffer(disp, parameters) CALL_by_offset(disp, (GLboolean (GLAPIENTRYP)(GLuint)), _gloffset_IsBuffer, parameters) +#define GET_IsBuffer(disp) GET_by_offset(disp, _gloffset_IsBuffer) +#define SET_IsBuffer(disp, fn) SET_by_offset(disp, _gloffset_IsBuffer, fn) +#define CALL_PointParameterf(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLfloat)), _gloffset_PointParameterf, parameters) +#define GET_PointParameterf(disp) GET_by_offset(disp, _gloffset_PointParameterf) +#define SET_PointParameterf(disp, fn) SET_by_offset(disp, _gloffset_PointParameterf, fn) +#define CALL_PointParameterfv(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, const GLfloat *)), _gloffset_PointParameterfv, parameters) +#define GET_PointParameterfv(disp) GET_by_offset(disp, _gloffset_PointParameterfv) +#define SET_PointParameterfv(disp, fn) SET_by_offset(disp, _gloffset_PointParameterfv, fn) +#define CALL_AlphaFuncx(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLclampx)), _gloffset_AlphaFuncx, parameters) +#define GET_AlphaFuncx(disp) GET_by_offset(disp, _gloffset_AlphaFuncx) +#define SET_AlphaFuncx(disp, fn) SET_by_offset(disp, _gloffset_AlphaFuncx, fn) +#define CALL_ClearColorx(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLclampx, GLclampx, GLclampx, GLclampx)), _gloffset_ClearColorx, parameters) +#define GET_ClearColorx(disp) GET_by_offset(disp, _gloffset_ClearColorx) +#define SET_ClearColorx(disp, fn) SET_by_offset(disp, _gloffset_ClearColorx, fn) +#define CALL_ClearDepthf(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLclampf)), _gloffset_ClearDepthf, parameters) +#define GET_ClearDepthf(disp) GET_by_offset(disp, _gloffset_ClearDepthf) +#define SET_ClearDepthf(disp, fn) SET_by_offset(disp, _gloffset_ClearDepthf, fn) +#define CALL_ClearDepthx(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLclampx)), _gloffset_ClearDepthx, parameters) +#define GET_ClearDepthx(disp) GET_by_offset(disp, _gloffset_ClearDepthx) +#define SET_ClearDepthx(disp, fn) SET_by_offset(disp, _gloffset_ClearDepthx, fn) +#define CALL_Color4x(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLfixed, GLfixed, GLfixed, GLfixed)), _gloffset_Color4x, parameters) +#define GET_Color4x(disp) GET_by_offset(disp, _gloffset_Color4x) +#define SET_Color4x(disp, fn) SET_by_offset(disp, _gloffset_Color4x, fn) +#define CALL_DepthRangef(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLclampf, GLclampf)), _gloffset_DepthRangef, parameters) +#define GET_DepthRangef(disp) GET_by_offset(disp, _gloffset_DepthRangef) +#define SET_DepthRangef(disp, fn) SET_by_offset(disp, _gloffset_DepthRangef, fn) +#define CALL_DepthRangex(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLclampx, GLclampx)), _gloffset_DepthRangex, parameters) +#define GET_DepthRangex(disp) GET_by_offset(disp, _gloffset_DepthRangex) +#define SET_DepthRangex(disp, fn) SET_by_offset(disp, _gloffset_DepthRangex, fn) +#define CALL_Fogx(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLfixed)), _gloffset_Fogx, parameters) +#define GET_Fogx(disp) GET_by_offset(disp, _gloffset_Fogx) +#define SET_Fogx(disp, fn) SET_by_offset(disp, _gloffset_Fogx, fn) +#define CALL_Fogxv(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, const GLfixed *)), _gloffset_Fogxv, parameters) +#define GET_Fogxv(disp) GET_by_offset(disp, _gloffset_Fogxv) +#define SET_Fogxv(disp, fn) SET_by_offset(disp, _gloffset_Fogxv, fn) +#define CALL_Frustumf(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat)), _gloffset_Frustumf, parameters) +#define GET_Frustumf(disp) GET_by_offset(disp, _gloffset_Frustumf) +#define SET_Frustumf(disp, fn) SET_by_offset(disp, _gloffset_Frustumf, fn) +#define CALL_Frustumx(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLfixed, GLfixed, GLfixed, GLfixed, GLfixed, GLfixed)), _gloffset_Frustumx, parameters) +#define GET_Frustumx(disp) GET_by_offset(disp, _gloffset_Frustumx) +#define SET_Frustumx(disp, fn) SET_by_offset(disp, _gloffset_Frustumx, fn) +#define CALL_LightModelx(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLfixed)), _gloffset_LightModelx, parameters) +#define GET_LightModelx(disp) GET_by_offset(disp, _gloffset_LightModelx) +#define SET_LightModelx(disp, fn) SET_by_offset(disp, _gloffset_LightModelx, fn) +#define CALL_LightModelxv(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, const GLfixed *)), _gloffset_LightModelxv, parameters) +#define GET_LightModelxv(disp) GET_by_offset(disp, _gloffset_LightModelxv) +#define SET_LightModelxv(disp, fn) SET_by_offset(disp, _gloffset_LightModelxv, fn) +#define CALL_Lightx(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLenum, GLfixed)), _gloffset_Lightx, parameters) +#define GET_Lightx(disp) GET_by_offset(disp, _gloffset_Lightx) +#define SET_Lightx(disp, fn) SET_by_offset(disp, _gloffset_Lightx, fn) +#define CALL_Lightxv(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLenum, const GLfixed *)), _gloffset_Lightxv, parameters) +#define GET_Lightxv(disp) GET_by_offset(disp, _gloffset_Lightxv) +#define SET_Lightxv(disp, fn) SET_by_offset(disp, _gloffset_Lightxv, fn) +#define CALL_LineWidthx(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLfixed)), _gloffset_LineWidthx, parameters) +#define GET_LineWidthx(disp) GET_by_offset(disp, _gloffset_LineWidthx) +#define SET_LineWidthx(disp, fn) SET_by_offset(disp, _gloffset_LineWidthx, fn) +#define CALL_LoadMatrixx(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(const GLfixed *)), _gloffset_LoadMatrixx, parameters) +#define GET_LoadMatrixx(disp) GET_by_offset(disp, _gloffset_LoadMatrixx) +#define SET_LoadMatrixx(disp, fn) SET_by_offset(disp, _gloffset_LoadMatrixx, fn) +#define CALL_Materialx(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLenum, GLfixed)), _gloffset_Materialx, parameters) +#define GET_Materialx(disp) GET_by_offset(disp, _gloffset_Materialx) +#define SET_Materialx(disp, fn) SET_by_offset(disp, _gloffset_Materialx, fn) +#define CALL_Materialxv(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLenum, const GLfixed *)), _gloffset_Materialxv, parameters) +#define GET_Materialxv(disp) GET_by_offset(disp, _gloffset_Materialxv) +#define SET_Materialxv(disp, fn) SET_by_offset(disp, _gloffset_Materialxv, fn) +#define CALL_MultMatrixx(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(const GLfixed *)), _gloffset_MultMatrixx, parameters) +#define GET_MultMatrixx(disp) GET_by_offset(disp, _gloffset_MultMatrixx) +#define SET_MultMatrixx(disp, fn) SET_by_offset(disp, _gloffset_MultMatrixx, fn) +#define CALL_MultiTexCoord4x(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLfixed, GLfixed, GLfixed, GLfixed)), _gloffset_MultiTexCoord4x, parameters) +#define GET_MultiTexCoord4x(disp) GET_by_offset(disp, _gloffset_MultiTexCoord4x) +#define SET_MultiTexCoord4x(disp, fn) SET_by_offset(disp, _gloffset_MultiTexCoord4x, fn) +#define CALL_Normal3x(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLfixed, GLfixed, GLfixed)), _gloffset_Normal3x, parameters) +#define GET_Normal3x(disp) GET_by_offset(disp, _gloffset_Normal3x) +#define SET_Normal3x(disp, fn) SET_by_offset(disp, _gloffset_Normal3x, fn) +#define CALL_Orthof(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat)), _gloffset_Orthof, parameters) +#define GET_Orthof(disp) GET_by_offset(disp, _gloffset_Orthof) +#define SET_Orthof(disp, fn) SET_by_offset(disp, _gloffset_Orthof, fn) +#define CALL_Orthox(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLfixed, GLfixed, GLfixed, GLfixed, GLfixed, GLfixed)), _gloffset_Orthox, parameters) +#define GET_Orthox(disp) GET_by_offset(disp, _gloffset_Orthox) +#define SET_Orthox(disp, fn) SET_by_offset(disp, _gloffset_Orthox, fn) +#define CALL_PointSizex(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLfixed)), _gloffset_PointSizex, parameters) +#define GET_PointSizex(disp) GET_by_offset(disp, _gloffset_PointSizex) +#define SET_PointSizex(disp, fn) SET_by_offset(disp, _gloffset_PointSizex, fn) +#define CALL_PolygonOffsetx(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLfixed, GLfixed)), _gloffset_PolygonOffsetx, parameters) +#define GET_PolygonOffsetx(disp) GET_by_offset(disp, _gloffset_PolygonOffsetx) +#define SET_PolygonOffsetx(disp, fn) SET_by_offset(disp, _gloffset_PolygonOffsetx, fn) +#define CALL_Rotatex(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLfixed, GLfixed, GLfixed, GLfixed)), _gloffset_Rotatex, parameters) +#define GET_Rotatex(disp) GET_by_offset(disp, _gloffset_Rotatex) +#define SET_Rotatex(disp, fn) SET_by_offset(disp, _gloffset_Rotatex, fn) +#define CALL_SampleCoveragex(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLclampx, GLboolean)), _gloffset_SampleCoveragex, parameters) +#define GET_SampleCoveragex(disp) GET_by_offset(disp, _gloffset_SampleCoveragex) +#define SET_SampleCoveragex(disp, fn) SET_by_offset(disp, _gloffset_SampleCoveragex, fn) +#define CALL_Scalex(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLfixed, GLfixed, GLfixed)), _gloffset_Scalex, parameters) +#define GET_Scalex(disp) GET_by_offset(disp, _gloffset_Scalex) +#define SET_Scalex(disp, fn) SET_by_offset(disp, _gloffset_Scalex, fn) +#define CALL_TexEnvx(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLenum, GLfixed)), _gloffset_TexEnvx, parameters) +#define GET_TexEnvx(disp) GET_by_offset(disp, _gloffset_TexEnvx) +#define SET_TexEnvx(disp, fn) SET_by_offset(disp, _gloffset_TexEnvx, fn) +#define CALL_TexEnvxv(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLenum, const GLfixed *)), _gloffset_TexEnvxv, parameters) +#define GET_TexEnvxv(disp) GET_by_offset(disp, _gloffset_TexEnvxv) +#define SET_TexEnvxv(disp, fn) SET_by_offset(disp, _gloffset_TexEnvxv, fn) +#define CALL_TexParameterx(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLenum, GLfixed)), _gloffset_TexParameterx, parameters) +#define GET_TexParameterx(disp) GET_by_offset(disp, _gloffset_TexParameterx) +#define SET_TexParameterx(disp, fn) SET_by_offset(disp, _gloffset_TexParameterx, fn) +#define CALL_Translatex(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLfixed, GLfixed, GLfixed)), _gloffset_Translatex, parameters) +#define GET_Translatex(disp) GET_by_offset(disp, _gloffset_Translatex) +#define SET_Translatex(disp, fn) SET_by_offset(disp, _gloffset_Translatex, fn) +#define CALL_ClipPlanef(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, const GLfloat *)), _gloffset_ClipPlanef, parameters) +#define GET_ClipPlanef(disp) GET_by_offset(disp, _gloffset_ClipPlanef) +#define SET_ClipPlanef(disp, fn) SET_by_offset(disp, _gloffset_ClipPlanef, fn) +#define CALL_ClipPlanex(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, const GLfixed *)), _gloffset_ClipPlanex, parameters) +#define GET_ClipPlanex(disp) GET_by_offset(disp, _gloffset_ClipPlanex) +#define SET_ClipPlanex(disp, fn) SET_by_offset(disp, _gloffset_ClipPlanex, fn) +#define CALL_GetClipPlanef(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLfloat *)), _gloffset_GetClipPlanef, parameters) +#define GET_GetClipPlanef(disp) GET_by_offset(disp, _gloffset_GetClipPlanef) +#define SET_GetClipPlanef(disp, fn) SET_by_offset(disp, _gloffset_GetClipPlanef, fn) +#define CALL_GetClipPlanex(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLfixed *)), _gloffset_GetClipPlanex, parameters) +#define GET_GetClipPlanex(disp) GET_by_offset(disp, _gloffset_GetClipPlanex) +#define SET_GetClipPlanex(disp, fn) SET_by_offset(disp, _gloffset_GetClipPlanex, fn) +#define CALL_GetFixedv(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLfixed *)), _gloffset_GetFixedv, parameters) +#define GET_GetFixedv(disp) GET_by_offset(disp, _gloffset_GetFixedv) +#define SET_GetFixedv(disp, fn) SET_by_offset(disp, _gloffset_GetFixedv, fn) +#define CALL_GetLightxv(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLenum, GLfixed *)), _gloffset_GetLightxv, parameters) +#define GET_GetLightxv(disp) GET_by_offset(disp, _gloffset_GetLightxv) +#define SET_GetLightxv(disp, fn) SET_by_offset(disp, _gloffset_GetLightxv, fn) +#define CALL_GetMaterialxv(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLenum, GLfixed *)), _gloffset_GetMaterialxv, parameters) +#define GET_GetMaterialxv(disp) GET_by_offset(disp, _gloffset_GetMaterialxv) +#define SET_GetMaterialxv(disp, fn) SET_by_offset(disp, _gloffset_GetMaterialxv, fn) +#define CALL_GetTexEnvxv(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLenum, GLfixed *)), _gloffset_GetTexEnvxv, parameters) +#define GET_GetTexEnvxv(disp) GET_by_offset(disp, _gloffset_GetTexEnvxv) +#define SET_GetTexEnvxv(disp, fn) SET_by_offset(disp, _gloffset_GetTexEnvxv, fn) +#define CALL_GetTexParameterxv(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLenum, GLfixed *)), _gloffset_GetTexParameterxv, parameters) +#define GET_GetTexParameterxv(disp) GET_by_offset(disp, _gloffset_GetTexParameterxv) +#define SET_GetTexParameterxv(disp, fn) SET_by_offset(disp, _gloffset_GetTexParameterxv, fn) +#define CALL_PointParameterx(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLfixed)), _gloffset_PointParameterx, parameters) +#define GET_PointParameterx(disp) GET_by_offset(disp, _gloffset_PointParameterx) +#define SET_PointParameterx(disp, fn) SET_by_offset(disp, _gloffset_PointParameterx, fn) +#define CALL_PointParameterxv(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, const GLfixed *)), _gloffset_PointParameterxv, parameters) +#define GET_PointParameterxv(disp) GET_by_offset(disp, _gloffset_PointParameterxv) +#define SET_PointParameterxv(disp, fn) SET_by_offset(disp, _gloffset_PointParameterxv, fn) +#define CALL_TexParameterxv(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLenum, const GLfixed *)), _gloffset_TexParameterxv, parameters) +#define GET_TexParameterxv(disp) GET_by_offset(disp, _gloffset_TexParameterxv) +#define SET_TexParameterxv(disp, fn) SET_by_offset(disp, _gloffset_TexParameterxv, fn) + +/* define aliases for compatibility */ +#define CALL_TexGenf(disp, parameters) CALL_TexGenfOES(disp, parameters) +#define GET_TexGenf(disp) GET_TexGenfOES(disp) +#define SET_TexGenf(disp, fn) SET_TexGenfOES(disp, fn) +#define CALL_TexGenfv(disp, parameters) CALL_TexGenfvOES(disp, parameters) +#define GET_TexGenfv(disp) GET_TexGenfvOES(disp) +#define SET_TexGenfv(disp, fn) SET_TexGenfvOES(disp, fn) +#define CALL_TexGeni(disp, parameters) CALL_TexGeniOES(disp, parameters) +#define GET_TexGeni(disp) GET_TexGeniOES(disp) +#define SET_TexGeni(disp, fn) SET_TexGeniOES(disp, fn) +#define CALL_TexGeniv(disp, parameters) CALL_TexGenivOES(disp, parameters) +#define GET_TexGeniv(disp) GET_TexGenivOES(disp) +#define SET_TexGeniv(disp, fn) SET_TexGenivOES(disp, fn) +#define CALL_GetTexGenfv(disp, parameters) CALL_GetTexGenfvOES(disp, parameters) +#define GET_GetTexGenfv(disp) GET_GetTexGenfvOES(disp) +#define SET_GetTexGenfv(disp, fn) SET_GetTexGenfvOES(disp, fn) +#define CALL_GetTexGeniv(disp, parameters) CALL_GetTexGenivOES(disp, parameters) +#define GET_GetTexGeniv(disp) GET_GetTexGenivOES(disp) +#define SET_GetTexGeniv(disp, fn) SET_GetTexGenivOES(disp, fn) +#define CALL_BlendEquation(disp, parameters) CALL_BlendEquationOES(disp, parameters) +#define GET_BlendEquation(disp) GET_BlendEquationOES(disp) +#define SET_BlendEquation(disp, fn) SET_BlendEquationOES(disp, fn) +#define CALL_ActiveTextureARB(disp, parameters) CALL_ActiveTexture(disp, parameters) +#define GET_ActiveTextureARB(disp) GET_ActiveTexture(disp) +#define SET_ActiveTextureARB(disp, fn) SET_ActiveTexture(disp, fn) +#define CALL_ClientActiveTextureARB(disp, parameters) CALL_ClientActiveTexture(disp, parameters) +#define GET_ClientActiveTextureARB(disp) GET_ClientActiveTexture(disp) +#define SET_ClientActiveTextureARB(disp, fn) SET_ClientActiveTexture(disp, fn) +#define CALL_MultiTexCoord4fARB(disp, parameters) CALL_MultiTexCoord4f(disp, parameters) +#define GET_MultiTexCoord4fARB(disp) GET_MultiTexCoord4f(disp) +#define SET_MultiTexCoord4fARB(disp, fn) SET_MultiTexCoord4f(disp, fn) +#define CALL_AlphaFuncxOES(disp, parameters) CALL_AlphaFuncx(disp, parameters) +#define GET_AlphaFuncxOES(disp) GET_AlphaFuncx(disp) +#define SET_AlphaFuncxOES(disp, fn) SET_AlphaFuncx(disp, fn) +#define CALL_ClearColorxOES(disp, parameters) CALL_ClearColorx(disp, parameters) +#define GET_ClearColorxOES(disp) GET_ClearColorx(disp) +#define SET_ClearColorxOES(disp, fn) SET_ClearColorx(disp, fn) +#define CALL_ClearDepthfOES(disp, parameters) CALL_ClearDepthf(disp, parameters) +#define GET_ClearDepthfOES(disp) GET_ClearDepthf(disp) +#define SET_ClearDepthfOES(disp, fn) SET_ClearDepthf(disp, fn) +#define CALL_ClearDepthxOES(disp, parameters) CALL_ClearDepthx(disp, parameters) +#define GET_ClearDepthxOES(disp) GET_ClearDepthx(disp) +#define SET_ClearDepthxOES(disp, fn) SET_ClearDepthx(disp, fn) +#define CALL_Color4xOES(disp, parameters) CALL_Color4x(disp, parameters) +#define GET_Color4xOES(disp) GET_Color4x(disp) +#define SET_Color4xOES(disp, fn) SET_Color4x(disp, fn) +#define CALL_DepthRangefOES(disp, parameters) CALL_DepthRangef(disp, parameters) +#define GET_DepthRangefOES(disp) GET_DepthRangef(disp) +#define SET_DepthRangefOES(disp, fn) SET_DepthRangef(disp, fn) +#define CALL_DepthRangexOES(disp, parameters) CALL_DepthRangex(disp, parameters) +#define GET_DepthRangexOES(disp) GET_DepthRangex(disp) +#define SET_DepthRangexOES(disp, fn) SET_DepthRangex(disp, fn) +#define CALL_FogxOES(disp, parameters) CALL_Fogx(disp, parameters) +#define GET_FogxOES(disp) GET_Fogx(disp) +#define SET_FogxOES(disp, fn) SET_Fogx(disp, fn) +#define CALL_FogxvOES(disp, parameters) CALL_Fogxv(disp, parameters) +#define GET_FogxvOES(disp) GET_Fogxv(disp) +#define SET_FogxvOES(disp, fn) SET_Fogxv(disp, fn) +#define CALL_FrustumfOES(disp, parameters) CALL_Frustumf(disp, parameters) +#define GET_FrustumfOES(disp) GET_Frustumf(disp) +#define SET_FrustumfOES(disp, fn) SET_Frustumf(disp, fn) +#define CALL_FrustumxOES(disp, parameters) CALL_Frustumx(disp, parameters) +#define GET_FrustumxOES(disp) GET_Frustumx(disp) +#define SET_FrustumxOES(disp, fn) SET_Frustumx(disp, fn) +#define CALL_LightModelxOES(disp, parameters) CALL_LightModelx(disp, parameters) +#define GET_LightModelxOES(disp) GET_LightModelx(disp) +#define SET_LightModelxOES(disp, fn) SET_LightModelx(disp, fn) +#define CALL_LightModelxvOES(disp, parameters) CALL_LightModelxv(disp, parameters) +#define GET_LightModelxvOES(disp) GET_LightModelxv(disp) +#define SET_LightModelxvOES(disp, fn) SET_LightModelxv(disp, fn) +#define CALL_LightxOES(disp, parameters) CALL_Lightx(disp, parameters) +#define GET_LightxOES(disp) GET_Lightx(disp) +#define SET_LightxOES(disp, fn) SET_Lightx(disp, fn) +#define CALL_LightxvOES(disp, parameters) CALL_Lightxv(disp, parameters) +#define GET_LightxvOES(disp) GET_Lightxv(disp) +#define SET_LightxvOES(disp, fn) SET_Lightxv(disp, fn) +#define CALL_LineWidthxOES(disp, parameters) CALL_LineWidthx(disp, parameters) +#define GET_LineWidthxOES(disp) GET_LineWidthx(disp) +#define SET_LineWidthxOES(disp, fn) SET_LineWidthx(disp, fn) +#define CALL_LoadMatrixxOES(disp, parameters) CALL_LoadMatrixx(disp, parameters) +#define GET_LoadMatrixxOES(disp) GET_LoadMatrixx(disp) +#define SET_LoadMatrixxOES(disp, fn) SET_LoadMatrixx(disp, fn) +#define CALL_MaterialxOES(disp, parameters) CALL_Materialx(disp, parameters) +#define GET_MaterialxOES(disp) GET_Materialx(disp) +#define SET_MaterialxOES(disp, fn) SET_Materialx(disp, fn) +#define CALL_MaterialxvOES(disp, parameters) CALL_Materialxv(disp, parameters) +#define GET_MaterialxvOES(disp) GET_Materialxv(disp) +#define SET_MaterialxvOES(disp, fn) SET_Materialxv(disp, fn) +#define CALL_MultMatrixxOES(disp, parameters) CALL_MultMatrixx(disp, parameters) +#define GET_MultMatrixxOES(disp) GET_MultMatrixx(disp) +#define SET_MultMatrixxOES(disp, fn) SET_MultMatrixx(disp, fn) +#define CALL_MultiTexCoord4xOES(disp, parameters) CALL_MultiTexCoord4x(disp, parameters) +#define GET_MultiTexCoord4xOES(disp) GET_MultiTexCoord4x(disp) +#define SET_MultiTexCoord4xOES(disp, fn) SET_MultiTexCoord4x(disp, fn) +#define CALL_Normal3xOES(disp, parameters) CALL_Normal3x(disp, parameters) +#define GET_Normal3xOES(disp) GET_Normal3x(disp) +#define SET_Normal3xOES(disp, fn) SET_Normal3x(disp, fn) +#define CALL_OrthofOES(disp, parameters) CALL_Orthof(disp, parameters) +#define GET_OrthofOES(disp) GET_Orthof(disp) +#define SET_OrthofOES(disp, fn) SET_Orthof(disp, fn) +#define CALL_OrthoxOES(disp, parameters) CALL_Orthox(disp, parameters) +#define GET_OrthoxOES(disp) GET_Orthox(disp) +#define SET_OrthoxOES(disp, fn) SET_Orthox(disp, fn) +#define CALL_PointSizexOES(disp, parameters) CALL_PointSizex(disp, parameters) +#define GET_PointSizexOES(disp) GET_PointSizex(disp) +#define SET_PointSizexOES(disp, fn) SET_PointSizex(disp, fn) +#define CALL_PolygonOffsetxOES(disp, parameters) CALL_PolygonOffsetx(disp, parameters) +#define GET_PolygonOffsetxOES(disp) GET_PolygonOffsetx(disp) +#define SET_PolygonOffsetxOES(disp, fn) SET_PolygonOffsetx(disp, fn) +#define CALL_RotatexOES(disp, parameters) CALL_Rotatex(disp, parameters) +#define GET_RotatexOES(disp) GET_Rotatex(disp) +#define SET_RotatexOES(disp, fn) SET_Rotatex(disp, fn) +#define CALL_SampleCoveragexOES(disp, parameters) CALL_SampleCoveragex(disp, parameters) +#define GET_SampleCoveragexOES(disp) GET_SampleCoveragex(disp) +#define SET_SampleCoveragexOES(disp, fn) SET_SampleCoveragex(disp, fn) +#define CALL_ScalexOES(disp, parameters) CALL_Scalex(disp, parameters) +#define GET_ScalexOES(disp) GET_Scalex(disp) +#define SET_ScalexOES(disp, fn) SET_Scalex(disp, fn) +#define CALL_TexEnvxOES(disp, parameters) CALL_TexEnvx(disp, parameters) +#define GET_TexEnvxOES(disp) GET_TexEnvx(disp) +#define SET_TexEnvxOES(disp, fn) SET_TexEnvx(disp, fn) +#define CALL_TexEnvxvOES(disp, parameters) CALL_TexEnvxv(disp, parameters) +#define GET_TexEnvxvOES(disp) GET_TexEnvxv(disp) +#define SET_TexEnvxvOES(disp, fn) SET_TexEnvxv(disp, fn) +#define CALL_TexParameterxOES(disp, parameters) CALL_TexParameterx(disp, parameters) +#define GET_TexParameterxOES(disp) GET_TexParameterx(disp) +#define SET_TexParameterxOES(disp, fn) SET_TexParameterx(disp, fn) +#define CALL_TranslatexOES(disp, parameters) CALL_Translatex(disp, parameters) +#define GET_TranslatexOES(disp) GET_Translatex(disp) +#define SET_TranslatexOES(disp, fn) SET_Translatex(disp, fn) +#define CALL_ClipPlanefOES(disp, parameters) CALL_ClipPlanef(disp, parameters) +#define GET_ClipPlanefOES(disp) GET_ClipPlanef(disp) +#define SET_ClipPlanefOES(disp, fn) SET_ClipPlanef(disp, fn) +#define CALL_ClipPlanexOES(disp, parameters) CALL_ClipPlanex(disp, parameters) +#define GET_ClipPlanexOES(disp) GET_ClipPlanex(disp) +#define SET_ClipPlanexOES(disp, fn) SET_ClipPlanex(disp, fn) +#define CALL_GetClipPlanefOES(disp, parameters) CALL_GetClipPlanef(disp, parameters) +#define GET_GetClipPlanefOES(disp) GET_GetClipPlanef(disp) +#define SET_GetClipPlanefOES(disp, fn) SET_GetClipPlanef(disp, fn) +#define CALL_GetClipPlanexOES(disp, parameters) CALL_GetClipPlanex(disp, parameters) +#define GET_GetClipPlanexOES(disp) GET_GetClipPlanex(disp) +#define SET_GetClipPlanexOES(disp, fn) SET_GetClipPlanex(disp, fn) +#define CALL_GetFixedvOES(disp, parameters) CALL_GetFixedv(disp, parameters) +#define GET_GetFixedvOES(disp) GET_GetFixedv(disp) +#define SET_GetFixedvOES(disp, fn) SET_GetFixedv(disp, fn) +#define CALL_GetLightxvOES(disp, parameters) CALL_GetLightxv(disp, parameters) +#define GET_GetLightxvOES(disp) GET_GetLightxv(disp) +#define SET_GetLightxvOES(disp, fn) SET_GetLightxv(disp, fn) +#define CALL_GetMaterialxvOES(disp, parameters) CALL_GetMaterialxv(disp, parameters) +#define GET_GetMaterialxvOES(disp) GET_GetMaterialxv(disp) +#define SET_GetMaterialxvOES(disp, fn) SET_GetMaterialxv(disp, fn) +#define CALL_GetTexEnvxvOES(disp, parameters) CALL_GetTexEnvxv(disp, parameters) +#define GET_GetTexEnvxvOES(disp) GET_GetTexEnvxv(disp) +#define SET_GetTexEnvxvOES(disp, fn) SET_GetTexEnvxv(disp, fn) +#define CALL_GetTexParameterxvOES(disp, parameters) CALL_GetTexParameterxv(disp, parameters) +#define GET_GetTexParameterxvOES(disp) GET_GetTexParameterxv(disp) +#define SET_GetTexParameterxvOES(disp, fn) SET_GetTexParameterxv(disp, fn) +#define CALL_PointParameterxOES(disp, parameters) CALL_PointParameterx(disp, parameters) +#define GET_PointParameterxOES(disp) GET_PointParameterx(disp) +#define SET_PointParameterxOES(disp, fn) SET_PointParameterx(disp, fn) +#define CALL_PointParameterxvOES(disp, parameters) CALL_PointParameterxv(disp, parameters) +#define GET_PointParameterxvOES(disp) GET_PointParameterxv(disp) +#define SET_PointParameterxvOES(disp, fn) SET_PointParameterxv(disp, fn) +#define CALL_TexParameterxvOES(disp, parameters) CALL_TexParameterxv(disp, parameters) +#define GET_TexParameterxvOES(disp) GET_TexParameterxv(disp) +#define SET_TexParameterxvOES(disp, fn) SET_TexParameterxv(disp, fn) + +#if defined(_GLAPI_USE_REMAP_TABLE) +#define TexGenf_remap_index TexGenfOES_remap_index +#define TexGenfv_remap_index TexGenfvOES_remap_index +#define TexGeni_remap_index TexGeniOES_remap_index +#define TexGeniv_remap_index TexGenivOES_remap_index +#define GetTexGenfv_remap_index GetTexGenfvOES_remap_index +#define GetTexGeniv_remap_index GetTexGenivOES_remap_index +#define BlendEquation_remap_index BlendEquationOES_remap_index +#define ActiveTextureARB_remap_index ActiveTexture_remap_index +#define ClientActiveTextureARB_remap_index ClientActiveTexture_remap_index +#define MultiTexCoord4fARB_remap_index MultiTexCoord4f_remap_index +#define AlphaFuncxOES_remap_index AlphaFuncx_remap_index +#define ClearColorxOES_remap_index ClearColorx_remap_index +#define ClearDepthfOES_remap_index ClearDepthf_remap_index +#define ClearDepthxOES_remap_index ClearDepthx_remap_index +#define Color4xOES_remap_index Color4x_remap_index +#define DepthRangefOES_remap_index DepthRangef_remap_index +#define DepthRangexOES_remap_index DepthRangex_remap_index +#define FogxOES_remap_index Fogx_remap_index +#define FogxvOES_remap_index Fogxv_remap_index +#define FrustumfOES_remap_index Frustumf_remap_index +#define FrustumxOES_remap_index Frustumx_remap_index +#define LightModelxOES_remap_index LightModelx_remap_index +#define LightModelxvOES_remap_index LightModelxv_remap_index +#define LightxOES_remap_index Lightx_remap_index +#define LightxvOES_remap_index Lightxv_remap_index +#define LineWidthxOES_remap_index LineWidthx_remap_index +#define LoadMatrixxOES_remap_index LoadMatrixx_remap_index +#define MaterialxOES_remap_index Materialx_remap_index +#define MaterialxvOES_remap_index Materialxv_remap_index +#define MultMatrixxOES_remap_index MultMatrixx_remap_index +#define MultiTexCoord4xOES_remap_index MultiTexCoord4x_remap_index +#define Normal3xOES_remap_index Normal3x_remap_index +#define OrthofOES_remap_index Orthof_remap_index +#define OrthoxOES_remap_index Orthox_remap_index +#define PointSizexOES_remap_index PointSizex_remap_index +#define PolygonOffsetxOES_remap_index PolygonOffsetx_remap_index +#define RotatexOES_remap_index Rotatex_remap_index +#define SampleCoveragexOES_remap_index SampleCoveragex_remap_index +#define ScalexOES_remap_index Scalex_remap_index +#define TexEnvxOES_remap_index TexEnvx_remap_index +#define TexEnvxvOES_remap_index TexEnvxv_remap_index +#define TexParameterxOES_remap_index TexParameterx_remap_index +#define TranslatexOES_remap_index Translatex_remap_index +#define ClipPlanefOES_remap_index ClipPlanef_remap_index +#define ClipPlanexOES_remap_index ClipPlanex_remap_index +#define GetClipPlanefOES_remap_index GetClipPlanef_remap_index +#define GetClipPlanexOES_remap_index GetClipPlanex_remap_index +#define GetFixedvOES_remap_index GetFixedv_remap_index +#define GetLightxvOES_remap_index GetLightxv_remap_index +#define GetMaterialxvOES_remap_index GetMaterialxv_remap_index +#define GetTexEnvxvOES_remap_index GetTexEnvxv_remap_index +#define GetTexParameterxvOES_remap_index GetTexParameterxv_remap_index +#define PointParameterxOES_remap_index PointParameterx_remap_index +#define PointParameterxvOES_remap_index PointParameterxv_remap_index +#define TexParameterxvOES_remap_index TexParameterxv_remap_index +#endif /* defined(_GLAPI_USE_REMAP_TABLE) */ + + +#endif /* !defined( _GLAPI_DISPATCH_H_ ) */ diff --git a/src/mapi/es1api/main/remap_helper.h b/src/mapi/es1api/main/remap_helper.h new file mode 100644 index 00000000000..0f47c520f34 --- /dev/null +++ b/src/mapi/es1api/main/remap_helper.h @@ -0,0 +1,2335 @@ +/* DO NOT EDIT - This file generated automatically by remap_helper.py (from Mesa) script */ + +/* + * Copyright (C) 2009 Chia-I Wu + * All Rights Reserved. + * + * Permission is hereby granted, free of charge, to any person obtaining a + * copy of this software and associated documentation files (the "Software"), + * to deal in the Software without restriction, including without limitation + * the rights to use, copy, modify, merge, publish, distribute, sub license, + * and/or sell copies of the Software, and to permit persons to whom the + * Software is furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice (including the next + * paragraph) shall be included in all copies or substantial portions of the + * Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL + * Chia-I Wu, + * AND/OR THEIR SUPPLIERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, + * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF + * OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE + * SOFTWARE. + */ + +#include "main/dispatch.h" +#include "main/remap.h" + +/* this is internal to remap.c */ +#ifdef need_MESA_remap_table + +static const char _mesa_function_pool[] = + /* _mesa_function_pool[0]: MapGrid1d (offset 224) */ + "idd\0" + "glMapGrid1d\0" + "\0" + /* _mesa_function_pool[17]: MapGrid1f (offset 225) */ + "iff\0" + "glMapGrid1f\0" + "\0" + /* _mesa_function_pool[34]: RasterPos4i (offset 82) */ + "iiii\0" + "glRasterPos4i\0" + "\0" + /* _mesa_function_pool[54]: RasterPos4d (offset 78) */ + "dddd\0" + "glRasterPos4d\0" + "\0" + /* _mesa_function_pool[74]: NewList (dynamic) */ + "ii\0" + "glNewList\0" + "\0" + /* _mesa_function_pool[88]: RasterPos4f (offset 80) */ + "ffff\0" + "glRasterPos4f\0" + "\0" + /* _mesa_function_pool[108]: LoadIdentity (offset 290) */ + "\0" + "glLoadIdentity\0" + "\0" + /* _mesa_function_pool[125]: ConvolutionFilter1D (offset 348) */ + "iiiiip\0" + "glConvolutionFilter1D\0" + "\0" + /* _mesa_function_pool[155]: RasterPos3dv (offset 71) */ + "p\0" + "glRasterPos3dv\0" + "\0" + /* _mesa_function_pool[173]: TexCoord1iv (offset 99) */ + "p\0" + "glTexCoord1iv\0" + "\0" + /* _mesa_function_pool[190]: TexCoord4sv (offset 125) */ + "p\0" + "glTexCoord4sv\0" + "\0" + /* _mesa_function_pool[207]: RasterPos4s (offset 84) */ + "iiii\0" + "glRasterPos4s\0" + "\0" + /* _mesa_function_pool[227]: TexCoord1f (offset 96) */ + "f\0" + "glTexCoord1f\0" + "\0" + /* _mesa_function_pool[243]: PolygonOffsetx (will be remapped) */ + "ii\0" + "glPolygonOffsetx\0" + "glPolygonOffsetxOES\0" + "\0" + /* _mesa_function_pool[284]: TexCoord1i (offset 98) */ + "i\0" + "glTexCoord1i\0" + "\0" + /* _mesa_function_pool[300]: Histogram (offset 367) */ + "iiii\0" + "glHistogram\0" + "\0" + /* _mesa_function_pool[318]: TexCoord1s (offset 100) */ + "i\0" + "glTexCoord1s\0" + "\0" + /* _mesa_function_pool[334]: GetMapfv (offset 267) */ + "iip\0" + "glGetMapfv\0" + "\0" + /* _mesa_function_pool[350]: EvalCoord1f (offset 230) */ + "f\0" + "glEvalCoord1f\0" + "\0" + /* _mesa_function_pool[367]: ConvolutionFilter2D (offset 349) */ + "iiiiiip\0" + "glConvolutionFilter2D\0" + "\0" + /* _mesa_function_pool[398]: PolygonStipple (offset 175) */ + "p\0" + "glPolygonStipple\0" + "\0" + /* _mesa_function_pool[418]: GetPixelMapfv (offset 271) */ + "ip\0" + "glGetPixelMapfv\0" + "\0" + /* _mesa_function_pool[438]: Color3uiv (offset 22) */ + "p\0" + "glColor3uiv\0" + "\0" + /* _mesa_function_pool[453]: IsEnabled (offset 286) */ + "i\0" + "glIsEnabled\0" + "\0" + /* _mesa_function_pool[468]: EvalCoord2fv (offset 235) */ + "p\0" + "glEvalCoord2fv\0" + "\0" + /* _mesa_function_pool[486]: GenerateMipmapOES (will be remapped) */ + "i\0" + "glGenerateMipmapOES\0" + "\0" + /* _mesa_function_pool[509]: GetMapiv (offset 268) */ + "iip\0" + "glGetMapiv\0" + "\0" + /* _mesa_function_pool[525]: Indexubv (offset 316) */ + "p\0" + "glIndexubv\0" + "\0" + /* _mesa_function_pool[539]: TexImage3D (offset 371) */ + "iiiiiiiiip\0" + "glTexImage3D\0" + "\0" + /* _mesa_function_pool[564]: EdgeFlagPointer (offset 312) */ + "ip\0" + "glEdgeFlagPointer\0" + "\0" + /* _mesa_function_pool[586]: Color3ubv (offset 20) */ + "p\0" + "glColor3ubv\0" + "\0" + /* _mesa_function_pool[601]: Vertex3dv (offset 135) */ + "p\0" + "glVertex3dv\0" + "\0" + /* _mesa_function_pool[616]: Disable (offset 214) */ + "i\0" + "glDisable\0" + "\0" + /* _mesa_function_pool[629]: LightModeliv (offset 166) */ + "ip\0" + "glLightModeliv\0" + "\0" + /* _mesa_function_pool[648]: GetClipPlanex (will be remapped) */ + "ip\0" + "glGetClipPlanex\0" + "glGetClipPlanexOES\0" + "\0" + /* _mesa_function_pool[687]: Vertex3iv (offset 139) */ + "p\0" + "glVertex3iv\0" + "\0" + /* _mesa_function_pool[702]: GetClipPlanef (will be remapped) */ + "ip\0" + "glGetClipPlanef\0" + "glGetClipPlanefOES\0" + "\0" + /* _mesa_function_pool[741]: BlendColor (offset 336) */ + "ffff\0" + "glBlendColor\0" + "\0" + /* _mesa_function_pool[760]: MultiTexCoord3fARB (offset 394) */ + "ifff\0" + "glMultiTexCoord3fARB\0" + "\0" + /* _mesa_function_pool[787]: DeleteVertexArraysAPPLE (will be remapped) */ + "ip\0" + "glDeleteVertexArraysAPPLE\0" + "\0" + /* _mesa_function_pool[817]: Scalef (offset 302) */ + "fff\0" + "glScalef\0" + "\0" + /* _mesa_function_pool[831]: Normal3iv (offset 59) */ + "p\0" + "glNormal3iv\0" + "\0" + /* _mesa_function_pool[846]: PointSizex (will be remapped) */ + "i\0" + "glPointSizex\0" + "glPointSizexOES\0" + "\0" + /* _mesa_function_pool[878]: DrawTexiOES (will be remapped) */ + "iiiii\0" + "glDrawTexiOES\0" + "\0" + /* _mesa_function_pool[899]: PassThrough (offset 199) */ + "f\0" + "glPassThrough\0" + "\0" + /* _mesa_function_pool[916]: Viewport (offset 305) */ + "iiii\0" + "glViewport\0" + "\0" + /* _mesa_function_pool[933]: DepthRange (offset 288) */ + "dd\0" + "glDepthRange\0" + "\0" + /* _mesa_function_pool[950]: ResetHistogram (offset 369) */ + "i\0" + "glResetHistogram\0" + "\0" + /* _mesa_function_pool[970]: CompressedTexSubImage2D (will be remapped) */ + "iiiiiiiip\0" + "glCompressedTexSubImage2D\0" + "\0" + /* _mesa_function_pool[1007]: MultiTexCoord2dvARB (offset 385) */ + "ip\0" + "glMultiTexCoord2dvARB\0" + "\0" + /* _mesa_function_pool[1033]: GetMaterialxv (will be remapped) */ + "iip\0" + "glGetMaterialxv\0" + "glGetMaterialxvOES\0" + "\0" + /* _mesa_function_pool[1073]: TexCoord2sv (offset 109) */ + "p\0" + "glTexCoord2sv\0" + "\0" + /* _mesa_function_pool[1090]: TexCoord2dv (offset 103) */ + "p\0" + "glTexCoord2dv\0" + "\0" + /* _mesa_function_pool[1107]: TexCoord1d (offset 94) */ + "d\0" + "glTexCoord1d\0" + "\0" + /* _mesa_function_pool[1123]: Color3sv (offset 18) */ + "p\0" + "glColor3sv\0" + "\0" + /* _mesa_function_pool[1137]: GetLightxv (will be remapped) */ + "iip\0" + "glGetLightxv\0" + "glGetLightxvOES\0" + "\0" + /* _mesa_function_pool[1171]: GetConvolutionParameteriv (offset 358) */ + "iip\0" + "glGetConvolutionParameteriv\0" + "\0" + /* _mesa_function_pool[1204]: AlphaFunc (offset 240) */ + "if\0" + "glAlphaFunc\0" + "\0" + /* _mesa_function_pool[1220]: DrawTexsOES (will be remapped) */ + "iiiii\0" + "glDrawTexsOES\0" + "\0" + /* _mesa_function_pool[1241]: MultiTexCoord1fvARB (offset 379) */ + "ip\0" + "glMultiTexCoord1fvARB\0" + "\0" + /* _mesa_function_pool[1267]: TexCoord3iv (offset 115) */ + "p\0" + "glTexCoord3iv\0" + "\0" + /* _mesa_function_pool[1284]: Color3fv (offset 14) */ + "p\0" + "glColor3fv\0" + "\0" + /* _mesa_function_pool[1298]: Translated (offset 303) */ + "ddd\0" + "glTranslated\0" + "\0" + /* _mesa_function_pool[1316]: PointSize (offset 173) */ + "f\0" + "glPointSize\0" + "\0" + /* _mesa_function_pool[1331]: PopName (offset 200) */ + "\0" + "glPopName\0" + "\0" + /* _mesa_function_pool[1343]: Vertex4sv (offset 149) */ + "p\0" + "glVertex4sv\0" + "\0" + /* _mesa_function_pool[1358]: GetTexEnvfv (offset 276) */ + "iip\0" + "glGetTexEnvfv\0" + "\0" + /* _mesa_function_pool[1377]: ColorTableParameteriv (offset 341) */ + "iip\0" + "glColorTableParameteriv\0" + "\0" + /* _mesa_function_pool[1406]: LineStipple (offset 167) */ + "ii\0" + "glLineStipple\0" + "\0" + /* _mesa_function_pool[1424]: TexEnvi (offset 186) */ + "iii\0" + "glTexEnvi\0" + "\0" + /* _mesa_function_pool[1439]: GetClipPlane (offset 259) */ + "ip\0" + "glGetClipPlane\0" + "\0" + /* _mesa_function_pool[1458]: Scalex (will be remapped) */ + "iii\0" + "glScalex\0" + "glScalexOES\0" + "\0" + /* _mesa_function_pool[1484]: Scaled (offset 301) */ + "ddd\0" + "glScaled\0" + "\0" + /* _mesa_function_pool[1498]: CallLists (offset 3) */ + "iip\0" + "glCallLists\0" + "\0" + /* _mesa_function_pool[1515]: Vertex2dv (offset 127) */ + "p\0" + "glVertex2dv\0" + "\0" + /* _mesa_function_pool[1530]: EdgeFlag (offset 41) */ + "i\0" + "glEdgeFlag\0" + "\0" + /* _mesa_function_pool[1544]: TexCoord2iv (offset 107) */ + "p\0" + "glTexCoord2iv\0" + "\0" + /* _mesa_function_pool[1561]: BlendEquationSeparateOES (will be remapped) */ + "ii\0" + "glBlendEquationSeparateOES\0" + "\0" + /* _mesa_function_pool[1592]: TexParameterx (will be remapped) */ + "iii\0" + "glTexParameterx\0" + "glTexParameterxOES\0" + "\0" + /* _mesa_function_pool[1632]: ReadPixels (offset 256) */ + "iiiiiip\0" + "glReadPixels\0" + "\0" + /* _mesa_function_pool[1654]: TexParameteri (offset 180) */ + "iii\0" + "glTexParameteri\0" + "\0" + /* _mesa_function_pool[1675]: Color4iv (offset 32) */ + "p\0" + "glColor4iv\0" + "\0" + /* _mesa_function_pool[1689]: TexParameterf (offset 178) */ + "iif\0" + "glTexParameterf\0" + "\0" + /* _mesa_function_pool[1710]: EdgeFlagv (offset 42) */ + "p\0" + "glEdgeFlagv\0" + "\0" + /* _mesa_function_pool[1725]: MultiTexCoord3dARB (offset 392) */ + "iddd\0" + "glMultiTexCoord3dARB\0" + "\0" + /* _mesa_function_pool[1752]: MultiTexCoord2iARB (offset 388) */ + "iii\0" + "glMultiTexCoord2iARB\0" + "\0" + /* _mesa_function_pool[1778]: DrawPixels (offset 257) */ + "iiiip\0" + "glDrawPixels\0" + "\0" + /* _mesa_function_pool[1798]: DepthRangex (will be remapped) */ + "ii\0" + "glDepthRangex\0" + "glDepthRangexOES\0" + "\0" + /* _mesa_function_pool[1833]: GenLists (offset 5) */ + "i\0" + "glGenLists\0" + "\0" + /* _mesa_function_pool[1847]: DepthRangef (will be remapped) */ + "ff\0" + "glDepthRangef\0" + "glDepthRangefOES\0" + "\0" + /* _mesa_function_pool[1882]: MapGrid2d (offset 226) */ + "iddidd\0" + "glMapGrid2d\0" + "\0" + /* _mesa_function_pool[1902]: MapGrid2f (offset 227) */ + "iffiff\0" + "glMapGrid2f\0" + "\0" + /* _mesa_function_pool[1922]: Fogx (will be remapped) */ + "ii\0" + "glFogx\0" + "glFogxOES\0" + "\0" + /* _mesa_function_pool[1943]: GetTexGenivOES (offset 280) */ + "iip\0" + "glGetTexGenivOES\0" + "glGetTexGeniv\0" + "\0" + /* _mesa_function_pool[1979]: Scissor (offset 176) */ + "iiii\0" + "glScissor\0" + "\0" + /* _mesa_function_pool[1995]: Fogf (offset 153) */ + "if\0" + "glFogf\0" + "\0" + /* _mesa_function_pool[2006]: TexSubImage1D (offset 332) */ + "iiiiiip\0" + "glTexSubImage1D\0" + "\0" + /* _mesa_function_pool[2031]: Color4usv (offset 40) */ + "p\0" + "glColor4usv\0" + "\0" + /* _mesa_function_pool[2046]: Fogi (offset 155) */ + "ii\0" + "glFogi\0" + "\0" + /* _mesa_function_pool[2057]: MultiTexCoord3sARB (offset 398) */ + "iiii\0" + "glMultiTexCoord3sARB\0" + "\0" + /* _mesa_function_pool[2084]: RasterPos3iv (offset 75) */ + "p\0" + "glRasterPos3iv\0" + "\0" + /* _mesa_function_pool[2102]: FramebufferRenderbufferOES (will be remapped) */ + "iiii\0" + "glFramebufferRenderbufferOES\0" + "\0" + /* _mesa_function_pool[2137]: TexCoord2i (offset 106) */ + "ii\0" + "glTexCoord2i\0" + "\0" + /* _mesa_function_pool[2154]: DepthFunc (offset 245) */ + "i\0" + "glDepthFunc\0" + "\0" + /* _mesa_function_pool[2169]: Color4ui (offset 37) */ + "iiii\0" + "glColor4ui\0" + "\0" + /* _mesa_function_pool[2186]: RasterPos3s (offset 76) */ + "iii\0" + "glRasterPos3s\0" + "\0" + /* _mesa_function_pool[2205]: Color3usv (offset 24) */ + "p\0" + "glColor3usv\0" + "\0" + /* _mesa_function_pool[2220]: TexCoord2f (offset 104) */ + "ff\0" + "glTexCoord2f\0" + "\0" + /* _mesa_function_pool[2237]: TexCoord2d (offset 102) */ + "dd\0" + "glTexCoord2d\0" + "\0" + /* _mesa_function_pool[2254]: RasterPos3d (offset 70) */ + "ddd\0" + "glRasterPos3d\0" + "\0" + /* _mesa_function_pool[2273]: RasterPos3f (offset 72) */ + "fff\0" + "glRasterPos3f\0" + "\0" + /* _mesa_function_pool[2292]: AreTexturesResident (offset 322) */ + "ipp\0" + "glAreTexturesResident\0" + "\0" + /* _mesa_function_pool[2319]: TexCoord2s (offset 108) */ + "ii\0" + "glTexCoord2s\0" + "\0" + /* _mesa_function_pool[2336]: RasterPos3i (offset 74) */ + "iii\0" + "glRasterPos3i\0" + "\0" + /* _mesa_function_pool[2355]: Color4us (offset 39) */ + "iiii\0" + "glColor4us\0" + "\0" + /* _mesa_function_pool[2372]: GetTexParameteriv (offset 283) */ + "iip\0" + "glGetTexParameteriv\0" + "\0" + /* _mesa_function_pool[2397]: MapBufferOES (will be remapped) */ + "ii\0" + "glMapBufferOES\0" + "\0" + /* _mesa_function_pool[2416]: DrawTexfOES (will be remapped) */ + "fffff\0" + "glDrawTexfOES\0" + "\0" + /* _mesa_function_pool[2437]: MultiTexCoord2fARB (offset 386) */ + "iff\0" + "glMultiTexCoord2fARB\0" + "\0" + /* _mesa_function_pool[2463]: ColorTable (offset 339) */ + "iiiiip\0" + "glColorTable\0" + "\0" + /* _mesa_function_pool[2484]: IndexPointer (offset 314) */ + "iip\0" + "glIndexPointer\0" + "\0" + /* _mesa_function_pool[2504]: Accum (offset 213) */ + "if\0" + "glAccum\0" + "\0" + /* _mesa_function_pool[2516]: GetTexImage (offset 281) */ + "iiiip\0" + "glGetTexImage\0" + "\0" + /* _mesa_function_pool[2537]: LoadName (offset 198) */ + "i\0" + "glLoadName\0" + "\0" + /* _mesa_function_pool[2551]: Finish (offset 216) */ + "\0" + "glFinish\0" + "\0" + /* _mesa_function_pool[2562]: ClearStencil (offset 207) */ + "i\0" + "glClearStencil\0" + "\0" + /* _mesa_function_pool[2580]: Color4x (will be remapped) */ + "iiii\0" + "glColor4x\0" + "glColor4xOES\0" + "\0" + /* _mesa_function_pool[2609]: ConvolutionParameteriv (offset 353) */ + "iip\0" + "glConvolutionParameteriv\0" + "\0" + /* _mesa_function_pool[2639]: GenBuffers (will be remapped) */ + "ip\0" + "glGenBuffers\0" + "\0" + /* _mesa_function_pool[2656]: InterleavedArrays (offset 317) */ + "iip\0" + "glInterleavedArrays\0" + "\0" + /* _mesa_function_pool[2681]: RasterPos2fv (offset 65) */ + "p\0" + "glRasterPos2fv\0" + "\0" + /* _mesa_function_pool[2699]: TexCoord1fv (offset 97) */ + "p\0" + "glTexCoord1fv\0" + "\0" + /* _mesa_function_pool[2716]: Vertex2d (offset 126) */ + "dd\0" + "glVertex2d\0" + "\0" + /* _mesa_function_pool[2731]: PixelTransferf (offset 247) */ + "if\0" + "glPixelTransferf\0" + "\0" + /* _mesa_function_pool[2752]: Color4i (offset 31) */ + "iiii\0" + "glColor4i\0" + "\0" + /* _mesa_function_pool[2768]: Color4f (offset 29) */ + "ffff\0" + "glColor4f\0" + "\0" + /* _mesa_function_pool[2784]: RasterPos4fv (offset 81) */ + "p\0" + "glRasterPos4fv\0" + "\0" + /* _mesa_function_pool[2802]: Color4d (offset 27) */ + "dddd\0" + "glColor4d\0" + "\0" + /* _mesa_function_pool[2818]: ClearIndex (offset 205) */ + "f\0" + "glClearIndex\0" + "\0" + /* _mesa_function_pool[2834]: Color4b (offset 25) */ + "iiii\0" + "glColor4b\0" + "\0" + /* _mesa_function_pool[2850]: LoadMatrixd (offset 292) */ + "p\0" + "glLoadMatrixd\0" + "\0" + /* _mesa_function_pool[2867]: PushMatrix (offset 298) */ + "\0" + "glPushMatrix\0" + "\0" + /* _mesa_function_pool[2882]: ConvolutionParameterfv (offset 351) */ + "iip\0" + "glConvolutionParameterfv\0" + "\0" + /* _mesa_function_pool[2912]: BlendFuncSeparateOES (will be remapped) */ + "iiii\0" + "glBlendFuncSeparateOES\0" + "\0" + /* _mesa_function_pool[2941]: GetTexGendv (offset 278) */ + "iip\0" + "glGetTexGendv\0" + "\0" + /* _mesa_function_pool[2960]: EndList (offset 1) */ + "\0" + "glEndList\0" + "\0" + /* _mesa_function_pool[2972]: Fogiv (offset 156) */ + "ip\0" + "glFogiv\0" + "\0" + /* _mesa_function_pool[2984]: EvalCoord1fv (offset 231) */ + "p\0" + "glEvalCoord1fv\0" + "\0" + /* _mesa_function_pool[3002]: DrawRangeElements (offset 338) */ + "iiiiip\0" + "glDrawRangeElements\0" + "\0" + /* _mesa_function_pool[3030]: EvalMesh2 (offset 238) */ + "iiiii\0" + "glEvalMesh2\0" + "\0" + /* _mesa_function_pool[3049]: GetTexGenxvOES (will be remapped) */ + "iip\0" + "glGetTexGenxvOES\0" + "\0" + /* _mesa_function_pool[3071]: Vertex4fv (offset 145) */ + "p\0" + "glVertex4fv\0" + "\0" + /* _mesa_function_pool[3086]: VertexPointer (offset 321) */ + "iiip\0" + "glVertexPointer\0" + "\0" + /* _mesa_function_pool[3108]: GetMinmax (offset 364) */ + "iiiip\0" + "glGetMinmax\0" + "\0" + /* _mesa_function_pool[3127]: Normal3fv (offset 57) */ + "p\0" + "glNormal3fv\0" + "\0" + /* _mesa_function_pool[3142]: Color3us (offset 23) */ + "iii\0" + "glColor3us\0" + "\0" + /* _mesa_function_pool[3158]: End (offset 43) */ + "\0" + "glEnd\0" + "\0" + /* _mesa_function_pool[3166]: MultiTexCoord3fvARB (offset 395) */ + "ip\0" + "glMultiTexCoord3fvARB\0" + "\0" + /* _mesa_function_pool[3192]: Color3ub (offset 19) */ + "iii\0" + "glColor3ub\0" + "\0" + /* _mesa_function_pool[3208]: BufferData (will be remapped) */ + "iipi\0" + "glBufferData\0" + "\0" + /* _mesa_function_pool[3227]: BlendEquationOES (offset 337) */ + "i\0" + "glBlendEquationOES\0" + "glBlendEquation\0" + "\0" + /* _mesa_function_pool[3265]: Color3ui (offset 21) */ + "iii\0" + "glColor3ui\0" + "\0" + /* _mesa_function_pool[3281]: TexSubImage2D (offset 333) */ + "iiiiiiiip\0" + "glTexSubImage2D\0" + "\0" + /* _mesa_function_pool[3308]: Enable (offset 215) */ + "i\0" + "glEnable\0" + "\0" + /* _mesa_function_pool[3320]: MultiTexCoord4sARB (offset 406) */ + "iiiii\0" + "glMultiTexCoord4sARB\0" + "\0" + /* _mesa_function_pool[3348]: Normal3x (will be remapped) */ + "iii\0" + "glNormal3x\0" + "glNormal3xOES\0" + "\0" + /* _mesa_function_pool[3378]: LineWidthx (will be remapped) */ + "i\0" + "glLineWidthx\0" + "glLineWidthxOES\0" + "\0" + /* _mesa_function_pool[3410]: GetError (offset 261) */ + "\0" + "glGetError\0" + "\0" + /* _mesa_function_pool[3423]: TexCoord3dv (offset 111) */ + "p\0" + "glTexCoord3dv\0" + "\0" + /* _mesa_function_pool[3440]: Indexdv (offset 45) */ + "p\0" + "glIndexdv\0" + "\0" + /* _mesa_function_pool[3453]: Normal3s (offset 60) */ + "iii\0" + "glNormal3s\0" + "\0" + /* _mesa_function_pool[3469]: PushName (offset 201) */ + "i\0" + "glPushName\0" + "\0" + /* _mesa_function_pool[3483]: Materialxv (will be remapped) */ + "iip\0" + "glMaterialxv\0" + "glMaterialxvOES\0" + "\0" + /* _mesa_function_pool[3517]: Normal3i (offset 58) */ + "iii\0" + "glNormal3i\0" + "\0" + /* _mesa_function_pool[3533]: Normal3b (offset 52) */ + "iii\0" + "glNormal3b\0" + "\0" + /* _mesa_function_pool[3549]: Normal3d (offset 54) */ + "ddd\0" + "glNormal3d\0" + "\0" + /* _mesa_function_pool[3565]: Normal3f (offset 56) */ + "fff\0" + "glNormal3f\0" + "\0" + /* _mesa_function_pool[3581]: MultiTexCoord1svARB (offset 383) */ + "ip\0" + "glMultiTexCoord1svARB\0" + "\0" + /* _mesa_function_pool[3607]: Indexi (offset 48) */ + "i\0" + "glIndexi\0" + "\0" + /* _mesa_function_pool[3619]: EGLImageTargetTexture2DOES (will be remapped) */ + "ip\0" + "glEGLImageTargetTexture2DOES\0" + "\0" + /* _mesa_function_pool[3652]: DepthMask (offset 211) */ + "i\0" + "glDepthMask\0" + "\0" + /* _mesa_function_pool[3667]: Indexf (offset 46) */ + "f\0" + "glIndexf\0" + "\0" + /* _mesa_function_pool[3679]: Indexd (offset 44) */ + "d\0" + "glIndexd\0" + "\0" + /* _mesa_function_pool[3691]: GetMaterialiv (offset 270) */ + "iip\0" + "glGetMaterialiv\0" + "\0" + /* _mesa_function_pool[3712]: StencilOp (offset 244) */ + "iii\0" + "glStencilOp\0" + "\0" + /* _mesa_function_pool[3729]: MultiTexCoord3svARB (offset 399) */ + "ip\0" + "glMultiTexCoord3svARB\0" + "\0" + /* _mesa_function_pool[3755]: TexEnvfv (offset 185) */ + "iip\0" + "glTexEnvfv\0" + "\0" + /* _mesa_function_pool[3771]: MultiTexCoord4iARB (offset 404) */ + "iiiii\0" + "glMultiTexCoord4iARB\0" + "\0" + /* _mesa_function_pool[3799]: Indexs (offset 50) */ + "i\0" + "glIndexs\0" + "\0" + /* _mesa_function_pool[3811]: BindFramebufferOES (will be remapped) */ + "ii\0" + "glBindFramebufferOES\0" + "\0" + /* _mesa_function_pool[3836]: Fogxv (will be remapped) */ + "ip\0" + "glFogxv\0" + "glFogxvOES\0" + "\0" + /* _mesa_function_pool[3859]: EGLImageTargetRenderbufferStorageOES (will be remapped) */ + "ip\0" + "glEGLImageTargetRenderbufferStorageOES\0" + "\0" + /* _mesa_function_pool[3902]: Vertex2i (offset 130) */ + "ii\0" + "glVertex2i\0" + "\0" + /* _mesa_function_pool[3917]: LoadMatrixf (offset 291) */ + "p\0" + "glLoadMatrixf\0" + "\0" + /* _mesa_function_pool[3934]: Vertex2f (offset 128) */ + "ff\0" + "glVertex2f\0" + "\0" + /* _mesa_function_pool[3949]: Color4bv (offset 26) */ + "p\0" + "glColor4bv\0" + "\0" + /* _mesa_function_pool[3963]: DrawTexfvOES (will be remapped) */ + "p\0" + "glDrawTexfvOES\0" + "\0" + /* _mesa_function_pool[3981]: LoadMatrixx (will be remapped) */ + "p\0" + "glLoadMatrixx\0" + "glLoadMatrixxOES\0" + "\0" + /* _mesa_function_pool[4015]: DeleteLists (offset 4) */ + "ii\0" + "glDeleteLists\0" + "\0" + /* _mesa_function_pool[4033]: LogicOp (offset 242) */ + "i\0" + "glLogicOp\0" + "\0" + /* _mesa_function_pool[4046]: Vertex2s (offset 132) */ + "ii\0" + "glVertex2s\0" + "\0" + /* _mesa_function_pool[4061]: TexCoord4fv (offset 121) */ + "p\0" + "glTexCoord4fv\0" + "\0" + /* _mesa_function_pool[4078]: ActiveTexture (offset 374) */ + "i\0" + "glActiveTexture\0" + "glActiveTextureARB\0" + "\0" + /* _mesa_function_pool[4116]: MultiTexCoord3iARB (offset 396) */ + "iiii\0" + "glMultiTexCoord3iARB\0" + "\0" + /* _mesa_function_pool[4143]: GenRenderbuffersOES (will be remapped) */ + "ip\0" + "glGenRenderbuffersOES\0" + "\0" + /* _mesa_function_pool[4169]: DrawTexxOES (will be remapped) */ + "iiiii\0" + "glDrawTexxOES\0" + "\0" + /* _mesa_function_pool[4190]: GenTextures (offset 328) */ + "ip\0" + "glGenTextures\0" + "\0" + /* _mesa_function_pool[4208]: Normal3bv (offset 53) */ + "p\0" + "glNormal3bv\0" + "\0" + /* _mesa_function_pool[4223]: DrawTexxvOES (will be remapped) */ + "p\0" + "glDrawTexxvOES\0" + "\0" + /* _mesa_function_pool[4241]: TexCoord4iv (offset 123) */ + "p\0" + "glTexCoord4iv\0" + "\0" + /* _mesa_function_pool[4258]: Color4ubv (offset 36) */ + "p\0" + "glColor4ubv\0" + "\0" + /* _mesa_function_pool[4273]: DrawBuffer (offset 202) */ + "i\0" + "glDrawBuffer\0" + "\0" + /* _mesa_function_pool[4289]: TexCoord2fv (offset 105) */ + "p\0" + "glTexCoord2fv\0" + "\0" + /* _mesa_function_pool[4306]: TexCoord1sv (offset 101) */ + "p\0" + "glTexCoord1sv\0" + "\0" + /* _mesa_function_pool[4323]: PixelMapfv (offset 251) */ + "iip\0" + "glPixelMapfv\0" + "\0" + /* _mesa_function_pool[4341]: GenFramebuffersOES (will be remapped) */ + "ip\0" + "glGenFramebuffersOES\0" + "\0" + /* _mesa_function_pool[4366]: MultiTexCoord1dARB (offset 376) */ + "id\0" + "glMultiTexCoord1dARB\0" + "\0" + /* _mesa_function_pool[4391]: Orthof (will be remapped) */ + "ffffff\0" + "glOrthof\0" + "glOrthofOES\0" + "\0" + /* _mesa_function_pool[4420]: CompressedTexImage2D (will be remapped) */ + "iiiiiiip\0" + "glCompressedTexImage2D\0" + "\0" + /* _mesa_function_pool[4453]: MultiTexCoord3dvARB (offset 393) */ + "ip\0" + "glMultiTexCoord3dvARB\0" + "\0" + /* _mesa_function_pool[4479]: Flush (offset 217) */ + "\0" + "glFlush\0" + "\0" + /* _mesa_function_pool[4489]: Color4uiv (offset 38) */ + "p\0" + "glColor4uiv\0" + "\0" + /* _mesa_function_pool[4504]: Orthox (will be remapped) */ + "iiiiii\0" + "glOrthox\0" + "glOrthoxOES\0" + "\0" + /* _mesa_function_pool[4533]: RasterPos3sv (offset 77) */ + "p\0" + "glRasterPos3sv\0" + "\0" + /* _mesa_function_pool[4551]: PushAttrib (offset 219) */ + "i\0" + "glPushAttrib\0" + "\0" + /* _mesa_function_pool[4567]: RasterPos2i (offset 66) */ + "ii\0" + "glRasterPos2i\0" + "\0" + /* _mesa_function_pool[4585]: TexParameteriv (offset 181) */ + "iip\0" + "glTexParameteriv\0" + "\0" + /* _mesa_function_pool[4607]: RasterPos2f (offset 64) */ + "ff\0" + "glRasterPos2f\0" + "\0" + /* _mesa_function_pool[4625]: RasterPos2d (offset 62) */ + "dd\0" + "glRasterPos2d\0" + "\0" + /* _mesa_function_pool[4643]: RasterPos3fv (offset 73) */ + "p\0" + "glRasterPos3fv\0" + "\0" + /* _mesa_function_pool[4661]: CopyTexSubImage3D (offset 373) */ + "iiiiiiiii\0" + "glCopyTexSubImage3D\0" + "\0" + /* _mesa_function_pool[4692]: Color4ub (offset 35) */ + "iiii\0" + "glColor4ub\0" + "\0" + /* _mesa_function_pool[4709]: RasterPos2s (offset 68) */ + "ii\0" + "glRasterPos2s\0" + "\0" + /* _mesa_function_pool[4727]: GetColorTable (offset 343) */ + "iiip\0" + "glGetColorTable\0" + "\0" + /* _mesa_function_pool[4749]: SelectBuffer (offset 195) */ + "ip\0" + "glSelectBuffer\0" + "\0" + /* _mesa_function_pool[4768]: Indexiv (offset 49) */ + "p\0" + "glIndexiv\0" + "\0" + /* _mesa_function_pool[4781]: TexCoord3i (offset 114) */ + "iii\0" + "glTexCoord3i\0" + "\0" + /* _mesa_function_pool[4799]: CopyColorTable (offset 342) */ + "iiiii\0" + "glCopyColorTable\0" + "\0" + /* _mesa_function_pool[4823]: PointParameterfv (will be remapped) */ + "ip\0" + "glPointParameterfv\0" + "\0" + /* _mesa_function_pool[4846]: GetHistogramParameterfv (offset 362) */ + "iip\0" + "glGetHistogramParameterfv\0" + "\0" + /* _mesa_function_pool[4877]: Frustum (offset 289) */ + "dddddd\0" + "glFrustum\0" + "\0" + /* _mesa_function_pool[4895]: GetString (offset 275) */ + "i\0" + "glGetString\0" + "\0" + /* _mesa_function_pool[4910]: TexEnvf (offset 184) */ + "iif\0" + "glTexEnvf\0" + "\0" + /* _mesa_function_pool[4925]: TexCoord3d (offset 110) */ + "ddd\0" + "glTexCoord3d\0" + "\0" + /* _mesa_function_pool[4943]: TexCoord3f (offset 112) */ + "fff\0" + "glTexCoord3f\0" + "\0" + /* _mesa_function_pool[4961]: MultiTexCoord3ivARB (offset 397) */ + "ip\0" + "glMultiTexCoord3ivARB\0" + "\0" + /* _mesa_function_pool[4987]: MultiTexCoord2sARB (offset 390) */ + "iii\0" + "glMultiTexCoord2sARB\0" + "\0" + /* _mesa_function_pool[5013]: TexEnvx (will be remapped) */ + "iii\0" + "glTexEnvx\0" + "glTexEnvxOES\0" + "\0" + /* _mesa_function_pool[5041]: TexCoord3s (offset 116) */ + "iii\0" + "glTexCoord3s\0" + "\0" + /* _mesa_function_pool[5059]: GetTexLevelParameteriv (offset 285) */ + "iiip\0" + "glGetTexLevelParameteriv\0" + "\0" + /* _mesa_function_pool[5090]: ClearAccum (offset 204) */ + "ffff\0" + "glClearAccum\0" + "\0" + /* _mesa_function_pool[5109]: RasterPos2sv (offset 69) */ + "p\0" + "glRasterPos2sv\0" + "\0" + /* _mesa_function_pool[5127]: PolygonOffset (offset 319) */ + "ff\0" + "glPolygonOffset\0" + "\0" + /* _mesa_function_pool[5147]: GetBufferParameteriv (will be remapped) */ + "iip\0" + "glGetBufferParameteriv\0" + "\0" + /* _mesa_function_pool[5175]: Rectd (offset 86) */ + "dddd\0" + "glRectd\0" + "\0" + /* _mesa_function_pool[5189]: PointSizePointerOES (will be remapped) */ + "iip\0" + "glPointSizePointerOES\0" + "\0" + /* _mesa_function_pool[5216]: CopyTexImage2D (offset 324) */ + "iiiiiiii\0" + "glCopyTexImage2D\0" + "\0" + /* _mesa_function_pool[5243]: GenVertexArraysAPPLE (will be remapped) */ + "ip\0" + "glGenVertexArraysAPPLE\0" + "\0" + /* _mesa_function_pool[5270]: Lightfv (offset 160) */ + "iip\0" + "glLightfv\0" + "\0" + /* _mesa_function_pool[5285]: Vertex3fv (offset 137) */ + "p\0" + "glVertex3fv\0" + "\0" + /* _mesa_function_pool[5300]: ColorSubTable (offset 346) */ + "iiiiip\0" + "glColorSubTable\0" + "\0" + /* _mesa_function_pool[5324]: Color4fv (offset 30) */ + "p\0" + "glColor4fv\0" + "\0" + /* _mesa_function_pool[5338]: MultiTexCoord4ivARB (offset 405) */ + "ip\0" + "glMultiTexCoord4ivARB\0" + "\0" + /* _mesa_function_pool[5364]: LoadPaletteFromModelViewMatrixOES (dynamic) */ + "\0" + "glLoadPaletteFromModelViewMatrixOES\0" + "\0" + /* _mesa_function_pool[5402]: ColorPointer (offset 308) */ + "iiip\0" + "glColorPointer\0" + "\0" + /* _mesa_function_pool[5423]: Rects (offset 92) */ + "iiii\0" + "glRects\0" + "\0" + /* _mesa_function_pool[5437]: Lightiv (offset 162) */ + "iip\0" + "glLightiv\0" + "\0" + /* _mesa_function_pool[5452]: IsFramebufferOES (will be remapped) */ + "i\0" + "glIsFramebufferOES\0" + "\0" + /* _mesa_function_pool[5474]: Color3bv (offset 10) */ + "p\0" + "glColor3bv\0" + "\0" + /* _mesa_function_pool[5488]: GetBufferPointervOES (will be remapped) */ + "iip\0" + "glGetBufferPointervOES\0" + "\0" + /* _mesa_function_pool[5516]: PixelMapusv (offset 253) */ + "iip\0" + "glPixelMapusv\0" + "\0" + /* _mesa_function_pool[5535]: GetTexGenfvOES (offset 279) */ + "iip\0" + "glGetTexGenfvOES\0" + "glGetTexGenfv\0" + "\0" + /* _mesa_function_pool[5571]: Rectdv (offset 87) */ + "pp\0" + "glRectdv\0" + "\0" + /* _mesa_function_pool[5584]: GetTexParameterxv (will be remapped) */ + "iip\0" + "glGetTexParameterxv\0" + "glGetTexParameterxvOES\0" + "\0" + /* _mesa_function_pool[5632]: Materialiv (offset 172) */ + "iip\0" + "glMaterialiv\0" + "\0" + /* _mesa_function_pool[5650]: PushClientAttrib (offset 335) */ + "i\0" + "glPushClientAttrib\0" + "\0" + /* _mesa_function_pool[5672]: TexGenfOES (offset 190) */ + "iif\0" + "glTexGenfOES\0" + "glTexGenf\0" + "\0" + /* _mesa_function_pool[5700]: MatrixIndexPointerOES (dynamic) */ + "iiip\0" + "glMatrixIndexPointerOES\0" + "\0" + /* _mesa_function_pool[5730]: PolygonMode (offset 174) */ + "ii\0" + "glPolygonMode\0" + "\0" + /* _mesa_function_pool[5748]: BlendFunc (offset 241) */ + "ii\0" + "glBlendFunc\0" + "\0" + /* _mesa_function_pool[5764]: DisableClientState (offset 309) */ + "i\0" + "glDisableClientState\0" + "\0" + /* _mesa_function_pool[5788]: TexGend (offset 188) */ + "iid\0" + "glTexGend\0" + "\0" + /* _mesa_function_pool[5803]: GetPolygonStipple (offset 274) */ + "p\0" + "glGetPolygonStipple\0" + "\0" + /* _mesa_function_pool[5826]: TexGenxOES (will be remapped) */ + "iii\0" + "glTexGenxOES\0" + "\0" + /* _mesa_function_pool[5844]: PointParameterxv (will be remapped) */ + "ip\0" + "glPointParameterxv\0" + "glPointParameterxvOES\0" + "\0" + /* _mesa_function_pool[5889]: Color4sv (offset 34) */ + "p\0" + "glColor4sv\0" + "\0" + /* _mesa_function_pool[5903]: PixelZoom (offset 246) */ + "ff\0" + "glPixelZoom\0" + "\0" + /* _mesa_function_pool[5919]: ColorTableParameterfv (offset 340) */ + "iip\0" + "glColorTableParameterfv\0" + "\0" + /* _mesa_function_pool[5948]: PixelMapuiv (offset 252) */ + "iip\0" + "glPixelMapuiv\0" + "\0" + /* _mesa_function_pool[5967]: Color3dv (offset 12) */ + "p\0" + "glColor3dv\0" + "\0" + /* _mesa_function_pool[5981]: IsTexture (offset 330) */ + "i\0" + "glIsTexture\0" + "\0" + /* _mesa_function_pool[5996]: DeleteFramebuffersOES (will be remapped) */ + "ip\0" + "glDeleteFramebuffersOES\0" + "\0" + /* _mesa_function_pool[6024]: WeightPointerOES (dynamic) */ + "iiip\0" + "glWeightPointerOES\0" + "\0" + /* _mesa_function_pool[6049]: CurrentPaletteMatrixOES (dynamic) */ + "i\0" + "glCurrentPaletteMatrixOES\0" + "\0" + /* _mesa_function_pool[6078]: TexCoord4i (offset 122) */ + "iiii\0" + "glTexCoord4i\0" + "\0" + /* _mesa_function_pool[6097]: GetMapdv (offset 266) */ + "iip\0" + "glGetMapdv\0" + "\0" + /* _mesa_function_pool[6113]: PixelStoref (offset 249) */ + "if\0" + "glPixelStoref\0" + "\0" + /* _mesa_function_pool[6131]: PrioritizeTextures (offset 331) */ + "ipp\0" + "glPrioritizeTextures\0" + "\0" + /* _mesa_function_pool[6157]: PixelStorei (offset 250) */ + "ii\0" + "glPixelStorei\0" + "\0" + /* _mesa_function_pool[6175]: IsBuffer (will be remapped) */ + "i\0" + "glIsBuffer\0" + "\0" + /* _mesa_function_pool[6189]: EvalCoord2dv (offset 233) */ + "p\0" + "glEvalCoord2dv\0" + "\0" + /* _mesa_function_pool[6207]: GetFixedv (will be remapped) */ + "ip\0" + "glGetFixedv\0" + "glGetFixedvOES\0" + "\0" + /* _mesa_function_pool[6238]: RenderbufferStorageOES (will be remapped) */ + "iiii\0" + "glRenderbufferStorageOES\0" + "\0" + /* _mesa_function_pool[6269]: ColorMaterial (offset 151) */ + "ii\0" + "glColorMaterial\0" + "\0" + /* _mesa_function_pool[6289]: Minmax (offset 368) */ + "iii\0" + "glMinmax\0" + "\0" + /* _mesa_function_pool[6303]: GetSeparableFilter (offset 359) */ + "iiippp\0" + "glGetSeparableFilter\0" + "\0" + /* _mesa_function_pool[6332]: FeedbackBuffer (offset 194) */ + "iip\0" + "glFeedbackBuffer\0" + "\0" + /* _mesa_function_pool[6354]: RasterPos2iv (offset 67) */ + "p\0" + "glRasterPos2iv\0" + "\0" + /* _mesa_function_pool[6372]: TexImage1D (offset 182) */ + "iiiiiiip\0" + "glTexImage1D\0" + "\0" + /* _mesa_function_pool[6395]: MultiDrawElementsEXT (will be remapped) */ + "ipipi\0" + "glMultiDrawElementsEXT\0" + "\0" + /* _mesa_function_pool[6425]: Color3s (offset 17) */ + "iii\0" + "glColor3s\0" + "\0" + /* _mesa_function_pool[6440]: TexCoordPointer (offset 320) */ + "iiip\0" + "glTexCoordPointer\0" + "\0" + /* _mesa_function_pool[6464]: GetRenderbufferParameterivOES (will be remapped) */ + "iip\0" + "glGetRenderbufferParameterivOES\0" + "\0" + /* _mesa_function_pool[6501]: Color3i (offset 15) */ + "iii\0" + "glColor3i\0" + "\0" + /* _mesa_function_pool[6516]: FrontFace (offset 157) */ + "i\0" + "glFrontFace\0" + "\0" + /* _mesa_function_pool[6531]: EvalCoord2d (offset 232) */ + "dd\0" + "glEvalCoord2d\0" + "\0" + /* _mesa_function_pool[6549]: EvalCoord2f (offset 234) */ + "ff\0" + "glEvalCoord2f\0" + "\0" + /* _mesa_function_pool[6567]: Color3b (offset 9) */ + "iii\0" + "glColor3b\0" + "\0" + /* _mesa_function_pool[6582]: MultiTexCoord2dARB (offset 384) */ + "idd\0" + "glMultiTexCoord2dARB\0" + "\0" + /* _mesa_function_pool[6608]: Color3f (offset 13) */ + "fff\0" + "glColor3f\0" + "\0" + /* _mesa_function_pool[6623]: Color3d (offset 11) */ + "ddd\0" + "glColor3d\0" + "\0" + /* _mesa_function_pool[6638]: Normal3dv (offset 55) */ + "p\0" + "glNormal3dv\0" + "\0" + /* _mesa_function_pool[6653]: Lightf (offset 159) */ + "iif\0" + "glLightf\0" + "\0" + /* _mesa_function_pool[6667]: MatrixMode (offset 293) */ + "i\0" + "glMatrixMode\0" + "\0" + /* _mesa_function_pool[6683]: GetPixelMapusv (offset 273) */ + "ip\0" + "glGetPixelMapusv\0" + "\0" + /* _mesa_function_pool[6704]: Lighti (offset 161) */ + "iii\0" + "glLighti\0" + "\0" + /* _mesa_function_pool[6718]: Color4s (offset 33) */ + "iiii\0" + "glColor4s\0" + "\0" + /* _mesa_function_pool[6734]: ClearDepthx (will be remapped) */ + "i\0" + "glClearDepthx\0" + "glClearDepthxOES\0" + "\0" + /* _mesa_function_pool[6768]: MultiTexCoord4dvARB (offset 401) */ + "ip\0" + "glMultiTexCoord4dvARB\0" + "\0" + /* _mesa_function_pool[6794]: Lightx (will be remapped) */ + "iii\0" + "glLightx\0" + "glLightxOES\0" + "\0" + /* _mesa_function_pool[6820]: GetDoublev (offset 260) */ + "ip\0" + "glGetDoublev\0" + "\0" + /* _mesa_function_pool[6837]: MultMatrixd (offset 295) */ + "p\0" + "glMultMatrixd\0" + "\0" + /* _mesa_function_pool[6854]: MultMatrixf (offset 294) */ + "p\0" + "glMultMatrixf\0" + "\0" + /* _mesa_function_pool[6871]: GetFramebufferAttachmentParameterivOES (will be remapped) */ + "iiip\0" + "glGetFramebufferAttachmentParameterivOES\0" + "\0" + /* _mesa_function_pool[6918]: MultiTexCoord4fvARB (offset 403) */ + "ip\0" + "glMultiTexCoord4fvARB\0" + "\0" + /* _mesa_function_pool[6944]: MultMatrixx (will be remapped) */ + "p\0" + "glMultMatrixx\0" + "glMultMatrixxOES\0" + "\0" + /* _mesa_function_pool[6978]: PointParameterx (will be remapped) */ + "ii\0" + "glPointParameterx\0" + "glPointParameterxOES\0" + "\0" + /* _mesa_function_pool[7021]: DrawArrays (offset 310) */ + "iii\0" + "glDrawArrays\0" + "\0" + /* _mesa_function_pool[7039]: PointParameterf (will be remapped) */ + "if\0" + "glPointParameterf\0" + "\0" + /* _mesa_function_pool[7061]: TexEnviv (offset 187) */ + "iip\0" + "glTexEnviv\0" + "\0" + /* _mesa_function_pool[7077]: TexSubImage3D (offset 372) */ + "iiiiiiiiiip\0" + "glTexSubImage3D\0" + "\0" + /* _mesa_function_pool[7106]: GetColorTableParameterfv (offset 344) */ + "iip\0" + "glGetColorTableParameterfv\0" + "\0" + /* _mesa_function_pool[7138]: Bitmap (offset 8) */ + "iiffffp\0" + "glBitmap\0" + "\0" + /* _mesa_function_pool[7156]: TexGeniOES (offset 192) */ + "iii\0" + "glTexGeniOES\0" + "glTexGeni\0" + "\0" + /* _mesa_function_pool[7184]: GetTexLevelParameterfv (offset 284) */ + "iiip\0" + "glGetTexLevelParameterfv\0" + "\0" + /* _mesa_function_pool[7215]: QueryMatrixxOES (will be remapped) */ + "pp\0" + "glQueryMatrixxOES\0" + "\0" + /* _mesa_function_pool[7237]: Vertex2sv (offset 133) */ + "p\0" + "glVertex2sv\0" + "\0" + /* _mesa_function_pool[7252]: GetIntegerv (offset 263) */ + "ip\0" + "glGetIntegerv\0" + "\0" + /* _mesa_function_pool[7270]: Rotated (offset 299) */ + "dddd\0" + "glRotated\0" + "\0" + /* _mesa_function_pool[7286]: DeleteBuffers (will be remapped) */ + "ip\0" + "glDeleteBuffers\0" + "\0" + /* _mesa_function_pool[7306]: AlphaFuncx (will be remapped) */ + "ii\0" + "glAlphaFuncx\0" + "glAlphaFuncxOES\0" + "\0" + /* _mesa_function_pool[7339]: GetTexEnviv (offset 277) */ + "iip\0" + "glGetTexEnviv\0" + "\0" + /* _mesa_function_pool[7358]: PopClientAttrib (offset 334) */ + "\0" + "glPopClientAttrib\0" + "\0" + /* _mesa_function_pool[7378]: SeparableFilter2D (offset 360) */ + "iiiiiipp\0" + "glSeparableFilter2D\0" + "\0" + /* _mesa_function_pool[7408]: Map1d (offset 220) */ + "iddiip\0" + "glMap1d\0" + "\0" + /* _mesa_function_pool[7424]: Map1f (offset 221) */ + "iffiip\0" + "glMap1f\0" + "\0" + /* _mesa_function_pool[7440]: ArrayElement (offset 306) */ + "i\0" + "glArrayElement\0" + "\0" + /* _mesa_function_pool[7458]: TexImage2D (offset 183) */ + "iiiiiiiip\0" + "glTexImage2D\0" + "\0" + /* _mesa_function_pool[7482]: GetMinmaxParameteriv (offset 366) */ + "iip\0" + "glGetMinmaxParameteriv\0" + "\0" + /* _mesa_function_pool[7510]: DrawTexivOES (will be remapped) */ + "p\0" + "glDrawTexivOES\0" + "\0" + /* _mesa_function_pool[7528]: CopyTexImage1D (offset 323) */ + "iiiiiii\0" + "glCopyTexImage1D\0" + "\0" + /* _mesa_function_pool[7554]: RasterPos2dv (offset 63) */ + "p\0" + "glRasterPos2dv\0" + "\0" + /* _mesa_function_pool[7572]: SampleCoveragex (will be remapped) */ + "ii\0" + "glSampleCoveragex\0" + "glSampleCoveragexOES\0" + "\0" + /* _mesa_function_pool[7615]: TexCoord1dv (offset 95) */ + "p\0" + "glTexCoord1dv\0" + "\0" + /* _mesa_function_pool[7632]: PixelTransferi (offset 248) */ + "ii\0" + "glPixelTransferi\0" + "\0" + /* _mesa_function_pool[7653]: Rotatef (offset 300) */ + "ffff\0" + "glRotatef\0" + "\0" + /* _mesa_function_pool[7669]: Vertex3i (offset 138) */ + "iii\0" + "glVertex3i\0" + "\0" + /* _mesa_function_pool[7685]: Vertex3f (offset 136) */ + "fff\0" + "glVertex3f\0" + "\0" + /* _mesa_function_pool[7701]: Clear (offset 203) */ + "i\0" + "glClear\0" + "\0" + /* _mesa_function_pool[7712]: Vertex3d (offset 134) */ + "ddd\0" + "glVertex3d\0" + "\0" + /* _mesa_function_pool[7728]: ReadBuffer (offset 254) */ + "i\0" + "glReadBuffer\0" + "\0" + /* _mesa_function_pool[7744]: ConvolutionParameteri (offset 352) */ + "iii\0" + "glConvolutionParameteri\0" + "\0" + /* _mesa_function_pool[7773]: Ortho (offset 296) */ + "dddddd\0" + "glOrtho\0" + "\0" + /* _mesa_function_pool[7789]: ListBase (offset 6) */ + "i\0" + "glListBase\0" + "\0" + /* _mesa_function_pool[7803]: Vertex3s (offset 140) */ + "iii\0" + "glVertex3s\0" + "\0" + /* _mesa_function_pool[7819]: ConvolutionParameterf (offset 350) */ + "iif\0" + "glConvolutionParameterf\0" + "\0" + /* _mesa_function_pool[7848]: GetColorTableParameteriv (offset 345) */ + "iip\0" + "glGetColorTableParameteriv\0" + "\0" + /* _mesa_function_pool[7880]: CallList (offset 2) */ + "i\0" + "glCallList\0" + "\0" + /* _mesa_function_pool[7894]: Rectiv (offset 91) */ + "pp\0" + "glRectiv\0" + "\0" + /* _mesa_function_pool[7907]: TexGenivOES (offset 193) */ + "iip\0" + "glTexGenivOES\0" + "glTexGeniv\0" + "\0" + /* _mesa_function_pool[7937]: TexParameterxv (will be remapped) */ + "iip\0" + "glTexParameterxv\0" + "glTexParameterxvOES\0" + "\0" + /* _mesa_function_pool[7979]: Vertex2fv (offset 129) */ + "p\0" + "glVertex2fv\0" + "\0" + /* _mesa_function_pool[7994]: MultiDrawArraysEXT (will be remapped) */ + "ippi\0" + "glMultiDrawArraysEXT\0" + "\0" + /* _mesa_function_pool[8021]: MultiTexCoord4dARB (offset 400) */ + "idddd\0" + "glMultiTexCoord4dARB\0" + "\0" + /* _mesa_function_pool[8049]: Rotatex (will be remapped) */ + "iiii\0" + "glRotatex\0" + "glRotatexOES\0" + "\0" + /* _mesa_function_pool[8078]: Vertex3sv (offset 141) */ + "p\0" + "glVertex3sv\0" + "\0" + /* _mesa_function_pool[8093]: EvalMesh1 (offset 236) */ + "iii\0" + "glEvalMesh1\0" + "\0" + /* _mesa_function_pool[8110]: BindRenderbufferOES (will be remapped) */ + "ii\0" + "glBindRenderbufferOES\0" + "\0" + /* _mesa_function_pool[8136]: MultiTexCoord1sARB (offset 382) */ + "ii\0" + "glMultiTexCoord1sARB\0" + "\0" + /* _mesa_function_pool[8161]: GetTexParameterfv (offset 282) */ + "iip\0" + "glGetTexParameterfv\0" + "\0" + /* _mesa_function_pool[8186]: MultiTexCoord1dvARB (offset 377) */ + "ip\0" + "glMultiTexCoord1dvARB\0" + "\0" + /* _mesa_function_pool[8212]: Vertex2iv (offset 131) */ + "p\0" + "glVertex2iv\0" + "\0" + /* _mesa_function_pool[8227]: LineWidth (offset 168) */ + "f\0" + "glLineWidth\0" + "\0" + /* _mesa_function_pool[8242]: FramebufferTexture2DOES (will be remapped) */ + "iiiii\0" + "glFramebufferTexture2DOES\0" + "\0" + /* _mesa_function_pool[8275]: Lightxv (will be remapped) */ + "iip\0" + "glLightxv\0" + "glLightxvOES\0" + "\0" + /* _mesa_function_pool[8303]: TexGendv (offset 189) */ + "iip\0" + "glTexGendv\0" + "\0" + /* _mesa_function_pool[8319]: CheckFramebufferStatusOES (will be remapped) */ + "i\0" + "glCheckFramebufferStatusOES\0" + "\0" + /* _mesa_function_pool[8350]: ResetMinmax (offset 370) */ + "i\0" + "glResetMinmax\0" + "\0" + /* _mesa_function_pool[8367]: EnableClientState (offset 313) */ + "i\0" + "glEnableClientState\0" + "\0" + /* _mesa_function_pool[8390]: GetConvolutionParameterfv (offset 357) */ + "iip\0" + "glGetConvolutionParameterfv\0" + "\0" + /* _mesa_function_pool[8423]: GetMaterialfv (offset 269) */ + "iip\0" + "glGetMaterialfv\0" + "\0" + /* _mesa_function_pool[8444]: DeleteTextures (offset 327) */ + "ip\0" + "glDeleteTextures\0" + "\0" + /* _mesa_function_pool[8465]: ShadeModel (offset 177) */ + "i\0" + "glShadeModel\0" + "\0" + /* _mesa_function_pool[8481]: Materialfv (offset 170) */ + "iip\0" + "glMaterialfv\0" + "\0" + /* _mesa_function_pool[8499]: TexCoord3fv (offset 113) */ + "p\0" + "glTexCoord3fv\0" + "\0" + /* _mesa_function_pool[8516]: CopyConvolutionFilter1D (offset 354) */ + "iiiii\0" + "glCopyConvolutionFilter1D\0" + "\0" + /* _mesa_function_pool[8549]: TexGenfvOES (offset 191) */ + "iip\0" + "glTexGenfvOES\0" + "glTexGenfv\0" + "\0" + /* _mesa_function_pool[8579]: MultiTexCoord1ivARB (offset 381) */ + "ip\0" + "glMultiTexCoord1ivARB\0" + "\0" + /* _mesa_function_pool[8605]: MultiTexCoord2ivARB (offset 389) */ + "ip\0" + "glMultiTexCoord2ivARB\0" + "\0" + /* _mesa_function_pool[8631]: ClearDepthf (will be remapped) */ + "f\0" + "glClearDepthf\0" + "glClearDepthfOES\0" + "\0" + /* _mesa_function_pool[8665]: CopyTexSubImage2D (offset 326) */ + "iiiiiiii\0" + "glCopyTexSubImage2D\0" + "\0" + /* _mesa_function_pool[8695]: SampleCoverage (will be remapped) */ + "fi\0" + "glSampleCoverage\0" + "\0" + /* _mesa_function_pool[8716]: Color3iv (offset 16) */ + "p\0" + "glColor3iv\0" + "\0" + /* _mesa_function_pool[8730]: DrawElements (offset 311) */ + "iiip\0" + "glDrawElements\0" + "\0" + /* _mesa_function_pool[8751]: BindVertexArrayAPPLE (will be remapped) */ + "i\0" + "glBindVertexArrayAPPLE\0" + "\0" + /* _mesa_function_pool[8777]: GetHistogramParameteriv (offset 363) */ + "iip\0" + "glGetHistogramParameteriv\0" + "\0" + /* _mesa_function_pool[8808]: MultiTexCoord1iARB (offset 380) */ + "ii\0" + "glMultiTexCoord1iARB\0" + "\0" + /* _mesa_function_pool[8833]: GetConvolutionFilter (offset 356) */ + "iiip\0" + "glGetConvolutionFilter\0" + "\0" + /* _mesa_function_pool[8862]: EvalPoint2 (offset 239) */ + "ii\0" + "glEvalPoint2\0" + "\0" + /* _mesa_function_pool[8879]: EvalPoint1 (offset 237) */ + "i\0" + "glEvalPoint1\0" + "\0" + /* _mesa_function_pool[8895]: TexGenxvOES (will be remapped) */ + "iip\0" + "glTexGenxvOES\0" + "\0" + /* _mesa_function_pool[8914]: Map2d (offset 222) */ + "iddiiddiip\0" + "glMap2d\0" + "\0" + /* _mesa_function_pool[8934]: Map2f (offset 223) */ + "iffiiffiip\0" + "glMap2f\0" + "\0" + /* _mesa_function_pool[8954]: MultiTexCoord4x (will be remapped) */ + "iiiii\0" + "glMultiTexCoord4x\0" + "glMultiTexCoord4xOES\0" + "\0" + /* _mesa_function_pool[9000]: Vertex4s (offset 148) */ + "iiii\0" + "glVertex4s\0" + "\0" + /* _mesa_function_pool[9017]: Vertex4f (offset 144) */ + "ffff\0" + "glVertex4f\0" + "\0" + /* _mesa_function_pool[9034]: EvalCoord1d (offset 228) */ + "d\0" + "glEvalCoord1d\0" + "\0" + /* _mesa_function_pool[9051]: Vertex4d (offset 142) */ + "dddd\0" + "glVertex4d\0" + "\0" + /* _mesa_function_pool[9068]: RasterPos4dv (offset 79) */ + "p\0" + "glRasterPos4dv\0" + "\0" + /* _mesa_function_pool[9086]: MultiTexCoord4f (offset 402) */ + "iffff\0" + "glMultiTexCoord4f\0" + "glMultiTexCoord4fARB\0" + "\0" + /* _mesa_function_pool[9132]: Vertex4i (offset 146) */ + "iiii\0" + "glVertex4i\0" + "\0" + /* _mesa_function_pool[9149]: GetHistogram (offset 361) */ + "iiiip\0" + "glGetHistogram\0" + "\0" + /* _mesa_function_pool[9171]: Translatex (will be remapped) */ + "iii\0" + "glTranslatex\0" + "glTranslatexOES\0" + "\0" + /* _mesa_function_pool[9205]: Materialf (offset 169) */ + "iif\0" + "glMaterialf\0" + "\0" + /* _mesa_function_pool[9222]: Materiali (offset 171) */ + "iii\0" + "glMateriali\0" + "\0" + /* _mesa_function_pool[9239]: Indexsv (offset 51) */ + "p\0" + "glIndexsv\0" + "\0" + /* _mesa_function_pool[9252]: MultiTexCoord4svARB (offset 407) */ + "ip\0" + "glMultiTexCoord4svARB\0" + "\0" + /* _mesa_function_pool[9278]: LightModelfv (offset 164) */ + "ip\0" + "glLightModelfv\0" + "\0" + /* _mesa_function_pool[9297]: Vertex4dv (offset 143) */ + "p\0" + "glVertex4dv\0" + "\0" + /* _mesa_function_pool[9312]: EvalCoord1dv (offset 229) */ + "p\0" + "glEvalCoord1dv\0" + "\0" + /* _mesa_function_pool[9330]: Materialx (will be remapped) */ + "iii\0" + "glMaterialx\0" + "glMaterialxOES\0" + "\0" + /* _mesa_function_pool[9362]: Translatef (offset 304) */ + "fff\0" + "glTranslatef\0" + "\0" + /* _mesa_function_pool[9380]: StencilMask (offset 209) */ + "i\0" + "glStencilMask\0" + "\0" + /* _mesa_function_pool[9397]: GetLightiv (offset 265) */ + "iip\0" + "glGetLightiv\0" + "\0" + /* _mesa_function_pool[9415]: IsList (offset 287) */ + "i\0" + "glIsList\0" + "\0" + /* _mesa_function_pool[9427]: RenderMode (offset 196) */ + "i\0" + "glRenderMode\0" + "\0" + /* _mesa_function_pool[9443]: MultiTexCoord1fARB (offset 378) */ + "if\0" + "glMultiTexCoord1fARB\0" + "\0" + /* _mesa_function_pool[9468]: BindBuffer (will be remapped) */ + "ii\0" + "glBindBuffer\0" + "\0" + /* _mesa_function_pool[9485]: Frustumf (will be remapped) */ + "ffffff\0" + "glFrustumf\0" + "glFrustumfOES\0" + "\0" + /* _mesa_function_pool[9518]: LightModelxv (will be remapped) */ + "ip\0" + "glLightModelxv\0" + "glLightModelxvOES\0" + "\0" + /* _mesa_function_pool[9555]: IsRenderbufferOES (will be remapped) */ + "i\0" + "glIsRenderbufferOES\0" + "\0" + /* _mesa_function_pool[9578]: CopyTexSubImage1D (offset 325) */ + "iiiiii\0" + "glCopyTexSubImage1D\0" + "\0" + /* _mesa_function_pool[9606]: Frustumx (will be remapped) */ + "iiiiii\0" + "glFrustumx\0" + "glFrustumxOES\0" + "\0" + /* _mesa_function_pool[9639]: CullFace (offset 152) */ + "i\0" + "glCullFace\0" + "\0" + /* _mesa_function_pool[9653]: BindTexture (offset 307) */ + "ii\0" + "glBindTexture\0" + "\0" + /* _mesa_function_pool[9671]: StencilFunc (offset 243) */ + "iii\0" + "glStencilFunc\0" + "\0" + /* _mesa_function_pool[9690]: CopyPixels (offset 255) */ + "iiiii\0" + "glCopyPixels\0" + "\0" + /* _mesa_function_pool[9710]: Rectsv (offset 93) */ + "pp\0" + "glRectsv\0" + "\0" + /* _mesa_function_pool[9723]: PopMatrix (offset 297) */ + "\0" + "glPopMatrix\0" + "\0" + /* _mesa_function_pool[9737]: CopyConvolutionFilter2D (offset 355) */ + "iiiiii\0" + "glCopyConvolutionFilter2D\0" + "\0" + /* _mesa_function_pool[9771]: DeleteRenderbuffersOES (will be remapped) */ + "ip\0" + "glDeleteRenderbuffersOES\0" + "\0" + /* _mesa_function_pool[9800]: NormalPointer (offset 318) */ + "iip\0" + "glNormalPointer\0" + "\0" + /* _mesa_function_pool[9821]: TexParameterfv (offset 179) */ + "iip\0" + "glTexParameterfv\0" + "\0" + /* _mesa_function_pool[9843]: ClipPlane (offset 150) */ + "ip\0" + "glClipPlane\0" + "\0" + /* _mesa_function_pool[9859]: Recti (offset 90) */ + "iiii\0" + "glRecti\0" + "\0" + /* _mesa_function_pool[9873]: GetPixelMapuiv (offset 272) */ + "ip\0" + "glGetPixelMapuiv\0" + "\0" + /* _mesa_function_pool[9894]: Rectf (offset 88) */ + "ffff\0" + "glRectf\0" + "\0" + /* _mesa_function_pool[9908]: Indexfv (offset 47) */ + "p\0" + "glIndexfv\0" + "\0" + /* _mesa_function_pool[9921]: GetPointerv (offset 329) */ + "ip\0" + "glGetPointerv\0" + "\0" + /* _mesa_function_pool[9939]: IndexMask (offset 212) */ + "i\0" + "glIndexMask\0" + "\0" + /* _mesa_function_pool[9954]: GetFloatv (offset 262) */ + "ip\0" + "glGetFloatv\0" + "\0" + /* _mesa_function_pool[9970]: TexCoord4s (offset 124) */ + "iiii\0" + "glTexCoord4s\0" + "\0" + /* _mesa_function_pool[9989]: TexCoord3sv (offset 117) */ + "p\0" + "glTexCoord3sv\0" + "\0" + /* _mesa_function_pool[10006]: TexEnvxv (will be remapped) */ + "iip\0" + "glTexEnvxv\0" + "glTexEnvxvOES\0" + "\0" + /* _mesa_function_pool[10036]: PopAttrib (offset 218) */ + "\0" + "glPopAttrib\0" + "\0" + /* _mesa_function_pool[10050]: Fogfv (offset 154) */ + "ip\0" + "glFogfv\0" + "\0" + /* _mesa_function_pool[10062]: InitNames (offset 197) */ + "\0" + "glInitNames\0" + "\0" + /* _mesa_function_pool[10076]: Normal3sv (offset 61) */ + "p\0" + "glNormal3sv\0" + "\0" + /* _mesa_function_pool[10091]: UnmapBufferOES (will be remapped) */ + "i\0" + "glUnmapBufferOES\0" + "\0" + /* _mesa_function_pool[10111]: TexCoord4d (offset 118) */ + "dddd\0" + "glTexCoord4d\0" + "\0" + /* _mesa_function_pool[10130]: TexCoord4f (offset 120) */ + "ffff\0" + "glTexCoord4f\0" + "\0" + /* _mesa_function_pool[10149]: GetBooleanv (offset 258) */ + "ip\0" + "glGetBooleanv\0" + "\0" + /* _mesa_function_pool[10167]: Hint (offset 158) */ + "ii\0" + "glHint\0" + "\0" + /* _mesa_function_pool[10178]: Color4dv (offset 28) */ + "p\0" + "glColor4dv\0" + "\0" + /* _mesa_function_pool[10192]: CopyColorSubTable (offset 347) */ + "iiiii\0" + "glCopyColorSubTable\0" + "\0" + /* _mesa_function_pool[10219]: IsVertexArrayAPPLE (will be remapped) */ + "i\0" + "glIsVertexArrayAPPLE\0" + "\0" + /* _mesa_function_pool[10243]: Vertex4iv (offset 147) */ + "p\0" + "glVertex4iv\0" + "\0" + /* _mesa_function_pool[10258]: BufferSubData (will be remapped) */ + "iiip\0" + "glBufferSubData\0" + "\0" + /* _mesa_function_pool[10280]: TexCoord4dv (offset 119) */ + "p\0" + "glTexCoord4dv\0" + "\0" + /* _mesa_function_pool[10297]: GetTexEnvxv (will be remapped) */ + "iip\0" + "glGetTexEnvxv\0" + "glGetTexEnvxvOES\0" + "\0" + /* _mesa_function_pool[10333]: Begin (offset 7) */ + "i\0" + "glBegin\0" + "\0" + /* _mesa_function_pool[10344]: LightModeli (offset 165) */ + "ii\0" + "glLightModeli\0" + "\0" + /* _mesa_function_pool[10362]: RasterPos4sv (offset 85) */ + "p\0" + "glRasterPos4sv\0" + "\0" + /* _mesa_function_pool[10380]: Rectfv (offset 89) */ + "pp\0" + "glRectfv\0" + "\0" + /* _mesa_function_pool[10393]: ClipPlanex (will be remapped) */ + "ip\0" + "glClipPlanex\0" + "glClipPlanexOES\0" + "\0" + /* _mesa_function_pool[10426]: LightModelf (offset 163) */ + "if\0" + "glLightModelf\0" + "\0" + /* _mesa_function_pool[10444]: DrawTexsvOES (will be remapped) */ + "p\0" + "glDrawTexsvOES\0" + "\0" + /* _mesa_function_pool[10462]: GetLightfv (offset 264) */ + "iip\0" + "glGetLightfv\0" + "\0" + /* _mesa_function_pool[10480]: LightModelx (will be remapped) */ + "ii\0" + "glLightModelx\0" + "glLightModelxOES\0" + "\0" + /* _mesa_function_pool[10515]: ClearColorx (will be remapped) */ + "iiii\0" + "glClearColorx\0" + "glClearColorxOES\0" + "\0" + /* _mesa_function_pool[10552]: ClipPlanef (will be remapped) */ + "ip\0" + "glClipPlanef\0" + "glClipPlanefOES\0" + "\0" + /* _mesa_function_pool[10585]: MultiTexCoord2fvARB (offset 387) */ + "ip\0" + "glMultiTexCoord2fvARB\0" + "\0" + /* _mesa_function_pool[10611]: ClearColor (offset 206) */ + "ffff\0" + "glClearColor\0" + "\0" + /* _mesa_function_pool[10630]: ColorMask (offset 210) */ + "iiii\0" + "glColorMask\0" + "\0" + /* _mesa_function_pool[10648]: RasterPos4iv (offset 83) */ + "p\0" + "glRasterPos4iv\0" + "\0" + /* _mesa_function_pool[10666]: Indexub (offset 315) */ + "i\0" + "glIndexub\0" + "\0" + /* _mesa_function_pool[10679]: GetMinmaxParameterfv (offset 365) */ + "iip\0" + "glGetMinmaxParameterfv\0" + "\0" + /* _mesa_function_pool[10707]: ClientActiveTexture (offset 375) */ + "i\0" + "glClientActiveTexture\0" + "glClientActiveTextureARB\0" + "\0" + /* _mesa_function_pool[10757]: ClearDepth (offset 208) */ + "d\0" + "glClearDepth\0" + "\0" + /* _mesa_function_pool[10773]: MultiTexCoord2svARB (offset 391) */ + "ip\0" + "glMultiTexCoord2svARB\0" + "\0" + ; + +/* these functions need to be remapped */ +static const struct gl_function_pool_remap MESA_remap_table_functions[] = { + { 1561, BlendEquationSeparateOES_remap_index }, + { 2912, BlendFuncSeparateOES_remap_index }, + { 2416, DrawTexfOES_remap_index }, + { 3963, DrawTexfvOES_remap_index }, + { 878, DrawTexiOES_remap_index }, + { 7510, DrawTexivOES_remap_index }, + { 1220, DrawTexsOES_remap_index }, + { 10444, DrawTexsvOES_remap_index }, + { 4169, DrawTexxOES_remap_index }, + { 4223, DrawTexxvOES_remap_index }, + { 3811, BindFramebufferOES_remap_index }, + { 8110, BindRenderbufferOES_remap_index }, + { 8319, CheckFramebufferStatusOES_remap_index }, + { 5996, DeleteFramebuffersOES_remap_index }, + { 9771, DeleteRenderbuffersOES_remap_index }, + { 2102, FramebufferRenderbufferOES_remap_index }, + { 8242, FramebufferTexture2DOES_remap_index }, + { 4341, GenFramebuffersOES_remap_index }, + { 4143, GenRenderbuffersOES_remap_index }, + { 486, GenerateMipmapOES_remap_index }, + { 6871, GetFramebufferAttachmentParameterivOES_remap_index }, + { 6464, GetRenderbufferParameterivOES_remap_index }, + { 5452, IsFramebufferOES_remap_index }, + { 9555, IsRenderbufferOES_remap_index }, + { 6238, RenderbufferStorageOES_remap_index }, + { 5189, PointSizePointerOES_remap_index }, + { 7215, QueryMatrixxOES_remap_index }, + { 3049, GetTexGenxvOES_remap_index }, + { 5826, TexGenxOES_remap_index }, + { 8895, TexGenxvOES_remap_index }, + { 5488, GetBufferPointervOES_remap_index }, + { 2397, MapBufferOES_remap_index }, + { 10091, UnmapBufferOES_remap_index }, + { 7994, MultiDrawArraysEXT_remap_index }, + { 6395, MultiDrawElementsEXT_remap_index }, + { 8751, BindVertexArrayAPPLE_remap_index }, + { 787, DeleteVertexArraysAPPLE_remap_index }, + { 5243, GenVertexArraysAPPLE_remap_index }, + { 10219, IsVertexArrayAPPLE_remap_index }, + { 3859, EGLImageTargetRenderbufferStorageOES_remap_index }, + { 3619, EGLImageTargetTexture2DOES_remap_index }, + { 4420, CompressedTexImage2D_remap_index }, + { 970, CompressedTexSubImage2D_remap_index }, + { 8695, SampleCoverage_remap_index }, + { 9468, BindBuffer_remap_index }, + { 3208, BufferData_remap_index }, + { 10258, BufferSubData_remap_index }, + { 7286, DeleteBuffers_remap_index }, + { 2639, GenBuffers_remap_index }, + { 5147, GetBufferParameteriv_remap_index }, + { 6175, IsBuffer_remap_index }, + { 7039, PointParameterf_remap_index }, + { 4823, PointParameterfv_remap_index }, + { 7306, AlphaFuncx_remap_index }, + { 10515, ClearColorx_remap_index }, + { 8631, ClearDepthf_remap_index }, + { 6734, ClearDepthx_remap_index }, + { 2580, Color4x_remap_index }, + { 1847, DepthRangef_remap_index }, + { 1798, DepthRangex_remap_index }, + { 1922, Fogx_remap_index }, + { 3836, Fogxv_remap_index }, + { 9485, Frustumf_remap_index }, + { 9606, Frustumx_remap_index }, + { 10480, LightModelx_remap_index }, + { 9518, LightModelxv_remap_index }, + { 6794, Lightx_remap_index }, + { 8275, Lightxv_remap_index }, + { 3378, LineWidthx_remap_index }, + { 3981, LoadMatrixx_remap_index }, + { 9330, Materialx_remap_index }, + { 3483, Materialxv_remap_index }, + { 6944, MultMatrixx_remap_index }, + { 8954, MultiTexCoord4x_remap_index }, + { 3348, Normal3x_remap_index }, + { 4391, Orthof_remap_index }, + { 4504, Orthox_remap_index }, + { 846, PointSizex_remap_index }, + { 243, PolygonOffsetx_remap_index }, + { 8049, Rotatex_remap_index }, + { 7572, SampleCoveragex_remap_index }, + { 1458, Scalex_remap_index }, + { 5013, TexEnvx_remap_index }, + { 10006, TexEnvxv_remap_index }, + { 1592, TexParameterx_remap_index }, + { 9171, Translatex_remap_index }, + { 10552, ClipPlanef_remap_index }, + { 10393, ClipPlanex_remap_index }, + { 702, GetClipPlanef_remap_index }, + { 648, GetClipPlanex_remap_index }, + { 6207, GetFixedv_remap_index }, + { 1137, GetLightxv_remap_index }, + { 1033, GetMaterialxv_remap_index }, + { 10297, GetTexEnvxv_remap_index }, + { 5584, GetTexParameterxv_remap_index }, + { 6978, PointParameterx_remap_index }, + { 5844, PointParameterxv_remap_index }, + { 7937, TexParameterxv_remap_index }, + { -1, -1 } +}; + +/* these functions are in the ABI, but have alternative names */ +static const struct gl_function_remap MESA_alt_functions[] = { + { -1, -1 } +}; + +#endif /* need_MESA_remap_table */ + +#if defined(need_GL_APPLE_vertex_array_object) +/* functions defined in MESA_remap_table_functions are excluded */ +static const struct gl_function_remap GL_APPLE_vertex_array_object_functions[] = { + { -1, -1 } +}; +#endif + +#if defined(need_GL_EXT_multi_draw_arrays) +/* functions defined in MESA_remap_table_functions are excluded */ +static const struct gl_function_remap GL_EXT_multi_draw_arrays_functions[] = { + { -1, -1 } +}; +#endif + +#if defined(need_GL_OES_EGL_image) +/* functions defined in MESA_remap_table_functions are excluded */ +static const struct gl_function_remap GL_OES_EGL_image_functions[] = { + { -1, -1 } +}; +#endif + +#if defined(need_GL_OES_blend_equation_separate) +/* functions defined in MESA_remap_table_functions are excluded */ +static const struct gl_function_remap GL_OES_blend_equation_separate_functions[] = { + { -1, -1 } +}; +#endif + +#if defined(need_GL_OES_blend_func_separate) +/* functions defined in MESA_remap_table_functions are excluded */ +static const struct gl_function_remap GL_OES_blend_func_separate_functions[] = { + { -1, -1 } +}; +#endif + +#if defined(need_GL_OES_draw_texture) +/* functions defined in MESA_remap_table_functions are excluded */ +static const struct gl_function_remap GL_OES_draw_texture_functions[] = { + { -1, -1 } +}; +#endif + +#if defined(need_GL_OES_fixed_point) +/* functions defined in MESA_remap_table_functions are excluded */ +static const struct gl_function_remap GL_OES_fixed_point_functions[] = { + { -1, -1 } +}; +#endif + +#if defined(need_GL_OES_framebuffer_object) +/* functions defined in MESA_remap_table_functions are excluded */ +static const struct gl_function_remap GL_OES_framebuffer_object_functions[] = { + { -1, -1 } +}; +#endif + +#if defined(need_GL_OES_mapbuffer) +/* functions defined in MESA_remap_table_functions are excluded */ +static const struct gl_function_remap GL_OES_mapbuffer_functions[] = { + { -1, -1 } +}; +#endif + +#if defined(need_GL_OES_matrix_palette) +static const struct gl_function_remap GL_OES_matrix_palette_functions[] = { + { 5364, -1 }, /* LoadPaletteFromModelViewMatrixOES */ + { 5700, -1 }, /* MatrixIndexPointerOES */ + { 6024, -1 }, /* WeightPointerOES */ + { 6049, -1 }, /* CurrentPaletteMatrixOES */ + { -1, -1 } +}; +#endif + +#if defined(need_GL_OES_point_size_array) +/* functions defined in MESA_remap_table_functions are excluded */ +static const struct gl_function_remap GL_OES_point_size_array_functions[] = { + { -1, -1 } +}; +#endif + +#if defined(need_GL_OES_query_matrix) +/* functions defined in MESA_remap_table_functions are excluded */ +static const struct gl_function_remap GL_OES_query_matrix_functions[] = { + { -1, -1 } +}; +#endif + +#if defined(need_GL_OES_single_precision) +/* functions defined in MESA_remap_table_functions are excluded */ +static const struct gl_function_remap GL_OES_single_precision_functions[] = { + { -1, -1 } +}; +#endif + diff --git a/src/mapi/es2api/glapi/glapi_sparc.S b/src/mapi/es2api/glapi/glapi_sparc.S new file mode 100644 index 00000000000..ce1e3aeb53b --- /dev/null +++ b/src/mapi/es2api/glapi/glapi_sparc.S @@ -0,0 +1,1084 @@ +/* DO NOT EDIT - This file generated automatically by gl_SPARC_asm.py (from Mesa) script */ + +/* + * Copyright (C) 1999-2003 Brian Paul All Rights Reserved. + * (C) Copyright IBM Corporation 2004 + * All Rights Reserved. + * + * Permission is hereby granted, free of charge, to any person obtaining a + * copy of this software and associated documentation files (the "Software"), + * to deal in the Software without restriction, including without limitation + * the rights to use, copy, modify, merge, publish, distribute, sub license, + * and/or sell copies of the Software, and to permit persons to whom the + * Software is furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice (including the next + * paragraph) shall be included in all copies or substantial portions of the + * Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL + * BRIAN PAUL, IBM, + * AND/OR THEIR SUPPLIERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, + * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF + * OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE + * SOFTWARE. + */ + +#ifdef __arch64__ +#define GL_OFF(N) ((N) * 8) +#define GL_LL ldx +#define GL_TIE_LD(SYM) %tie_ldx(SYM) +#define GL_STACK_SIZE 128 +#else +#define GL_OFF(N) ((N) * 4) +#define GL_LL ld +#define GL_TIE_LD(SYM) %tie_ld(SYM) +#define GL_STACK_SIZE 64 +#endif + +#define GLOBL_FN(x) .globl x ; .type x, @function +#define HIDDEN(x) .hidden x + + .register %g2, #scratch + .register %g3, #scratch + + .text + + GLOBL_FN(__glapi_sparc_icache_flush) + HIDDEN(__glapi_sparc_icache_flush) + .type __glapi_sparc_icache_flush, @function +__glapi_sparc_icache_flush: /* %o0 = insn_addr */ + flush %o0 + retl + nop + + .align 32 + + .type __glapi_sparc_get_pc, @function +__glapi_sparc_get_pc: + retl + add %o7, %g2, %g2 + .size __glapi_sparc_get_pc, .-__glapi_sparc_get_pc + +#ifdef GLX_USE_TLS + + GLOBL_FN(__glapi_sparc_get_dispatch) + HIDDEN(__glapi_sparc_get_dispatch) +__glapi_sparc_get_dispatch: + mov %o7, %g1 + sethi %hi(_GLOBAL_OFFSET_TABLE_-4), %g2 + call __glapi_sparc_get_pc + add %g2, %lo(_GLOBAL_OFFSET_TABLE_+4), %g2 + mov %g1, %o7 + sethi %tie_hi22(_glapi_tls_Dispatch), %g1 + add %g1, %tie_lo10(_glapi_tls_Dispatch), %g1 + GL_LL [%g2 + %g1], %g2, GL_TIE_LD(_glapi_tls_Dispatch) + retl + mov %g2, %o0 + + .data + .align 32 + + /* --> sethi %hi(_glapi_tls_Dispatch), %g1 */ + /* --> or %g1, %lo(_glapi_tls_Dispatch), %g1 */ + GLOBL_FN(__glapi_sparc_tls_stub) + HIDDEN(__glapi_sparc_tls_stub) +__glapi_sparc_tls_stub: /* Call offset in %g3 */ + mov %o7, %g1 + sethi %hi(_GLOBAL_OFFSET_TABLE_-4), %g2 + call __glapi_sparc_get_pc + add %g2, %lo(_GLOBAL_OFFSET_TABLE_+4), %g2 + mov %g1, %o7 + srl %g3, 10, %g3 + sethi %tie_hi22(_glapi_tls_Dispatch), %g1 + add %g1, %tie_lo10(_glapi_tls_Dispatch), %g1 + GL_LL [%g2 + %g1], %g2, GL_TIE_LD(_glapi_tls_Dispatch) + GL_LL [%g7+%g2], %g1 + GL_LL [%g1 + %g3], %g1 + jmp %g1 + nop + .size __glapi_sparc_tls_stub, .-__glapi_sparc_tls_stub + +#define GL_STUB(fn, off) \ + GLOBL_FN(fn); \ +fn: ba __glapi_sparc_tls_stub; \ + sethi GL_OFF(off), %g3; \ + .size fn,.-fn; + +#elif defined(PTHREADS) + + /* 64-bit 0x00 --> sethi %hh(_glapi_Dispatch), %g1 */ + /* 64-bit 0x04 --> sethi %lm(_glapi_Dispatch), %g2 */ + /* 64-bit 0x08 --> or %g1, %hm(_glapi_Dispatch), %g1 */ + /* 64-bit 0x0c --> sllx %g1, 32, %g1 */ + /* 64-bit 0x10 --> add %g1, %g2, %g1 */ + /* 64-bit 0x14 --> ldx [%g1 + %lo(_glapi_Dispatch)], %g1 */ + + /* 32-bit 0x00 --> sethi %hi(_glapi_Dispatch), %g1 */ + /* 32-bit 0x04 --> ld [%g1 + %lo(_glapi_Dispatch)], %g1 */ + + .data + .align 32 + + GLOBL_FN(__glapi_sparc_pthread_stub) + HIDDEN(__glapi_sparc_pthread_stub) +__glapi_sparc_pthread_stub: /* Call offset in %g3 */ + mov %o7, %g1 + sethi %hi(_GLOBAL_OFFSET_TABLE_-4), %g2 + call __glapi_sparc_get_pc + add %g2, %lo(_GLOBAL_OFFSET_TABLE_+4), %g2 + mov %g1, %o7 + sethi %hi(_glapi_Dispatch), %g1 + or %g1, %lo(_glapi_Dispatch), %g1 + srl %g3, 10, %g3 + GL_LL [%g2+%g1], %g2 + GL_LL [%g2], %g1 + cmp %g1, 0 + be 2f + nop +1: GL_LL [%g1 + %g3], %g1 + jmp %g1 + nop +2: save %sp, GL_STACK_SIZE, %sp + mov %g3, %l0 + call _glapi_get_dispatch + nop + mov %o0, %g1 + mov %l0, %g3 + ba 1b + restore %g0, %g0, %g0 + .size __glapi_sparc_pthread_stub, .-__glapi_sparc_pthread_stub + +#define GL_STUB(fn, off) \ + GLOBL_FN(fn); \ +fn: ba __glapi_sparc_pthread_stub; \ + sethi GL_OFF(off), %g3; \ + .size fn,.-fn; + +#else /* Non-threaded version. */ + + .type __glapi_sparc_nothread_stub, @function +__glapi_sparc_nothread_stub: /* Call offset in %g3 */ + mov %o7, %g1 + sethi %hi(_GLOBAL_OFFSET_TABLE_-4), %g2 + call __glapi_sparc_get_pc + add %g2, %lo(_GLOBAL_OFFSET_TABLE_+4), %g2 + mov %g1, %o7 + srl %g3, 10, %g3 + sethi %hi(_glapi_Dispatch), %g1 + or %g1, %lo(_glapi_Dispatch), %g1 + GL_LL [%g2+%g1], %g2 + GL_LL [%g2], %g1 + GL_LL [%g1 + %g3], %g1 + jmp %g1 + nop + .size __glapi_sparc_nothread_stub, .-__glapi_sparc_nothread_stub + +#define GL_STUB(fn, off) \ + GLOBL_FN(fn); \ +fn: ba __glapi_sparc_nothread_stub; \ + sethi GL_OFF(off), %g3; \ + .size fn,.-fn; + +#endif + +#define GL_STUB_ALIAS(fn, alias) \ + .globl fn; \ + .set fn, alias + + .text + .align 32 + + .globl gl_dispatch_functions_start + HIDDEN(gl_dispatch_functions_start) +gl_dispatch_functions_start: + + GL_STUB(gl_dispatch_stub_0, 0) + HIDDEN(gl_dispatch_stub_0) + GL_STUB(gl_dispatch_stub_1, 1) + HIDDEN(gl_dispatch_stub_1) + GL_STUB(gl_dispatch_stub_2, 2) + HIDDEN(gl_dispatch_stub_2) + GL_STUB(gl_dispatch_stub_3, 3) + HIDDEN(gl_dispatch_stub_3) + GL_STUB(gl_dispatch_stub_4, 4) + HIDDEN(gl_dispatch_stub_4) + GL_STUB(gl_dispatch_stub_5, 5) + HIDDEN(gl_dispatch_stub_5) + GL_STUB(gl_dispatch_stub_6, 6) + HIDDEN(gl_dispatch_stub_6) + GL_STUB(gl_dispatch_stub_7, 7) + HIDDEN(gl_dispatch_stub_7) + GL_STUB(gl_dispatch_stub_8, 8) + HIDDEN(gl_dispatch_stub_8) + GL_STUB(gl_dispatch_stub_9, 9) + HIDDEN(gl_dispatch_stub_9) + GL_STUB(gl_dispatch_stub_10, 10) + HIDDEN(gl_dispatch_stub_10) + GL_STUB(gl_dispatch_stub_11, 11) + HIDDEN(gl_dispatch_stub_11) + GL_STUB(gl_dispatch_stub_12, 12) + HIDDEN(gl_dispatch_stub_12) + GL_STUB(gl_dispatch_stub_13, 13) + HIDDEN(gl_dispatch_stub_13) + GL_STUB(gl_dispatch_stub_14, 14) + HIDDEN(gl_dispatch_stub_14) + GL_STUB(gl_dispatch_stub_15, 15) + HIDDEN(gl_dispatch_stub_15) + GL_STUB(gl_dispatch_stub_16, 16) + HIDDEN(gl_dispatch_stub_16) + GL_STUB(gl_dispatch_stub_17, 17) + HIDDEN(gl_dispatch_stub_17) + GL_STUB(gl_dispatch_stub_18, 18) + HIDDEN(gl_dispatch_stub_18) + GL_STUB(gl_dispatch_stub_19, 19) + HIDDEN(gl_dispatch_stub_19) + GL_STUB(gl_dispatch_stub_20, 20) + HIDDEN(gl_dispatch_stub_20) + GL_STUB(gl_dispatch_stub_21, 21) + HIDDEN(gl_dispatch_stub_21) + GL_STUB(gl_dispatch_stub_22, 22) + HIDDEN(gl_dispatch_stub_22) + GL_STUB(gl_dispatch_stub_23, 23) + HIDDEN(gl_dispatch_stub_23) + GL_STUB(gl_dispatch_stub_24, 24) + HIDDEN(gl_dispatch_stub_24) + GL_STUB(gl_dispatch_stub_25, 25) + HIDDEN(gl_dispatch_stub_25) + GL_STUB(gl_dispatch_stub_26, 26) + HIDDEN(gl_dispatch_stub_26) + GL_STUB(gl_dispatch_stub_27, 27) + HIDDEN(gl_dispatch_stub_27) + GL_STUB(gl_dispatch_stub_28, 28) + HIDDEN(gl_dispatch_stub_28) + GL_STUB(gl_dispatch_stub_29, 29) + HIDDEN(gl_dispatch_stub_29) + GL_STUB(gl_dispatch_stub_30, 30) + HIDDEN(gl_dispatch_stub_30) + GL_STUB(gl_dispatch_stub_31, 31) + HIDDEN(gl_dispatch_stub_31) + GL_STUB(gl_dispatch_stub_32, 32) + HIDDEN(gl_dispatch_stub_32) + GL_STUB(gl_dispatch_stub_33, 33) + HIDDEN(gl_dispatch_stub_33) + GL_STUB(gl_dispatch_stub_34, 34) + HIDDEN(gl_dispatch_stub_34) + GL_STUB(gl_dispatch_stub_35, 35) + HIDDEN(gl_dispatch_stub_35) + GL_STUB(gl_dispatch_stub_36, 36) + HIDDEN(gl_dispatch_stub_36) + GL_STUB(gl_dispatch_stub_37, 37) + HIDDEN(gl_dispatch_stub_37) + GL_STUB(gl_dispatch_stub_38, 38) + HIDDEN(gl_dispatch_stub_38) + GL_STUB(gl_dispatch_stub_39, 39) + HIDDEN(gl_dispatch_stub_39) + GL_STUB(gl_dispatch_stub_40, 40) + HIDDEN(gl_dispatch_stub_40) + GL_STUB(gl_dispatch_stub_41, 41) + HIDDEN(gl_dispatch_stub_41) + GL_STUB(gl_dispatch_stub_42, 42) + HIDDEN(gl_dispatch_stub_42) + GL_STUB(gl_dispatch_stub_43, 43) + HIDDEN(gl_dispatch_stub_43) + GL_STUB(gl_dispatch_stub_44, 44) + HIDDEN(gl_dispatch_stub_44) + GL_STUB(gl_dispatch_stub_45, 45) + HIDDEN(gl_dispatch_stub_45) + GL_STUB(gl_dispatch_stub_46, 46) + HIDDEN(gl_dispatch_stub_46) + GL_STUB(gl_dispatch_stub_47, 47) + HIDDEN(gl_dispatch_stub_47) + GL_STUB(gl_dispatch_stub_48, 48) + HIDDEN(gl_dispatch_stub_48) + GL_STUB(gl_dispatch_stub_49, 49) + HIDDEN(gl_dispatch_stub_49) + GL_STUB(gl_dispatch_stub_50, 50) + HIDDEN(gl_dispatch_stub_50) + GL_STUB(gl_dispatch_stub_51, 51) + HIDDEN(gl_dispatch_stub_51) + GL_STUB(gl_dispatch_stub_52, 52) + HIDDEN(gl_dispatch_stub_52) + GL_STUB(gl_dispatch_stub_53, 53) + HIDDEN(gl_dispatch_stub_53) + GL_STUB(gl_dispatch_stub_54, 54) + HIDDEN(gl_dispatch_stub_54) + GL_STUB(gl_dispatch_stub_55, 55) + HIDDEN(gl_dispatch_stub_55) + GL_STUB(gl_dispatch_stub_56, 56) + HIDDEN(gl_dispatch_stub_56) + GL_STUB(gl_dispatch_stub_57, 57) + HIDDEN(gl_dispatch_stub_57) + GL_STUB(gl_dispatch_stub_58, 58) + HIDDEN(gl_dispatch_stub_58) + GL_STUB(gl_dispatch_stub_59, 59) + HIDDEN(gl_dispatch_stub_59) + GL_STUB(gl_dispatch_stub_60, 60) + HIDDEN(gl_dispatch_stub_60) + GL_STUB(gl_dispatch_stub_61, 61) + HIDDEN(gl_dispatch_stub_61) + GL_STUB(gl_dispatch_stub_62, 62) + HIDDEN(gl_dispatch_stub_62) + GL_STUB(gl_dispatch_stub_63, 63) + HIDDEN(gl_dispatch_stub_63) + GL_STUB(gl_dispatch_stub_64, 64) + HIDDEN(gl_dispatch_stub_64) + GL_STUB(gl_dispatch_stub_65, 65) + HIDDEN(gl_dispatch_stub_65) + GL_STUB(gl_dispatch_stub_66, 66) + HIDDEN(gl_dispatch_stub_66) + GL_STUB(gl_dispatch_stub_67, 67) + HIDDEN(gl_dispatch_stub_67) + GL_STUB(gl_dispatch_stub_68, 68) + HIDDEN(gl_dispatch_stub_68) + GL_STUB(gl_dispatch_stub_69, 69) + HIDDEN(gl_dispatch_stub_69) + GL_STUB(gl_dispatch_stub_70, 70) + HIDDEN(gl_dispatch_stub_70) + GL_STUB(gl_dispatch_stub_71, 71) + HIDDEN(gl_dispatch_stub_71) + GL_STUB(gl_dispatch_stub_72, 72) + HIDDEN(gl_dispatch_stub_72) + GL_STUB(gl_dispatch_stub_73, 73) + HIDDEN(gl_dispatch_stub_73) + GL_STUB(gl_dispatch_stub_74, 74) + HIDDEN(gl_dispatch_stub_74) + GL_STUB(gl_dispatch_stub_75, 75) + HIDDEN(gl_dispatch_stub_75) + GL_STUB(gl_dispatch_stub_76, 76) + HIDDEN(gl_dispatch_stub_76) + GL_STUB(gl_dispatch_stub_77, 77) + HIDDEN(gl_dispatch_stub_77) + GL_STUB(gl_dispatch_stub_78, 78) + HIDDEN(gl_dispatch_stub_78) + GL_STUB(gl_dispatch_stub_79, 79) + HIDDEN(gl_dispatch_stub_79) + GL_STUB(gl_dispatch_stub_80, 80) + HIDDEN(gl_dispatch_stub_80) + GL_STUB(gl_dispatch_stub_81, 81) + HIDDEN(gl_dispatch_stub_81) + GL_STUB(gl_dispatch_stub_82, 82) + HIDDEN(gl_dispatch_stub_82) + GL_STUB(gl_dispatch_stub_83, 83) + HIDDEN(gl_dispatch_stub_83) + GL_STUB(gl_dispatch_stub_84, 84) + HIDDEN(gl_dispatch_stub_84) + GL_STUB(gl_dispatch_stub_85, 85) + HIDDEN(gl_dispatch_stub_85) + GL_STUB(gl_dispatch_stub_86, 86) + HIDDEN(gl_dispatch_stub_86) + GL_STUB(gl_dispatch_stub_87, 87) + HIDDEN(gl_dispatch_stub_87) + GL_STUB(gl_dispatch_stub_88, 88) + HIDDEN(gl_dispatch_stub_88) + GL_STUB(gl_dispatch_stub_89, 89) + HIDDEN(gl_dispatch_stub_89) + GL_STUB(gl_dispatch_stub_90, 90) + HIDDEN(gl_dispatch_stub_90) + GL_STUB(gl_dispatch_stub_91, 91) + HIDDEN(gl_dispatch_stub_91) + GL_STUB(gl_dispatch_stub_92, 92) + HIDDEN(gl_dispatch_stub_92) + GL_STUB(gl_dispatch_stub_93, 93) + HIDDEN(gl_dispatch_stub_93) + GL_STUB(gl_dispatch_stub_94, 94) + HIDDEN(gl_dispatch_stub_94) + GL_STUB(gl_dispatch_stub_95, 95) + HIDDEN(gl_dispatch_stub_95) + GL_STUB(gl_dispatch_stub_96, 96) + HIDDEN(gl_dispatch_stub_96) + GL_STUB(gl_dispatch_stub_97, 97) + HIDDEN(gl_dispatch_stub_97) + GL_STUB(gl_dispatch_stub_98, 98) + HIDDEN(gl_dispatch_stub_98) + GL_STUB(gl_dispatch_stub_99, 99) + HIDDEN(gl_dispatch_stub_99) + GL_STUB(gl_dispatch_stub_100, 100) + HIDDEN(gl_dispatch_stub_100) + GL_STUB(gl_dispatch_stub_101, 101) + HIDDEN(gl_dispatch_stub_101) + GL_STUB(gl_dispatch_stub_102, 102) + HIDDEN(gl_dispatch_stub_102) + GL_STUB(gl_dispatch_stub_103, 103) + HIDDEN(gl_dispatch_stub_103) + GL_STUB(gl_dispatch_stub_104, 104) + HIDDEN(gl_dispatch_stub_104) + GL_STUB(gl_dispatch_stub_105, 105) + HIDDEN(gl_dispatch_stub_105) + GL_STUB(gl_dispatch_stub_106, 106) + HIDDEN(gl_dispatch_stub_106) + GL_STUB(gl_dispatch_stub_107, 107) + HIDDEN(gl_dispatch_stub_107) + GL_STUB(gl_dispatch_stub_108, 108) + HIDDEN(gl_dispatch_stub_108) + GL_STUB(gl_dispatch_stub_109, 109) + HIDDEN(gl_dispatch_stub_109) + GL_STUB(gl_dispatch_stub_110, 110) + HIDDEN(gl_dispatch_stub_110) + GL_STUB(gl_dispatch_stub_111, 111) + HIDDEN(gl_dispatch_stub_111) + GL_STUB(gl_dispatch_stub_112, 112) + HIDDEN(gl_dispatch_stub_112) + GL_STUB(gl_dispatch_stub_113, 113) + HIDDEN(gl_dispatch_stub_113) + GL_STUB(gl_dispatch_stub_114, 114) + HIDDEN(gl_dispatch_stub_114) + GL_STUB(gl_dispatch_stub_115, 115) + HIDDEN(gl_dispatch_stub_115) + GL_STUB(gl_dispatch_stub_116, 116) + HIDDEN(gl_dispatch_stub_116) + GL_STUB(gl_dispatch_stub_117, 117) + HIDDEN(gl_dispatch_stub_117) + GL_STUB(gl_dispatch_stub_118, 118) + HIDDEN(gl_dispatch_stub_118) + GL_STUB(gl_dispatch_stub_119, 119) + HIDDEN(gl_dispatch_stub_119) + GL_STUB(gl_dispatch_stub_120, 120) + HIDDEN(gl_dispatch_stub_120) + GL_STUB(gl_dispatch_stub_121, 121) + HIDDEN(gl_dispatch_stub_121) + GL_STUB(gl_dispatch_stub_122, 122) + HIDDEN(gl_dispatch_stub_122) + GL_STUB(gl_dispatch_stub_123, 123) + HIDDEN(gl_dispatch_stub_123) + GL_STUB(gl_dispatch_stub_124, 124) + HIDDEN(gl_dispatch_stub_124) + GL_STUB(gl_dispatch_stub_125, 125) + HIDDEN(gl_dispatch_stub_125) + GL_STUB(gl_dispatch_stub_126, 126) + HIDDEN(gl_dispatch_stub_126) + GL_STUB(gl_dispatch_stub_127, 127) + HIDDEN(gl_dispatch_stub_127) + GL_STUB(gl_dispatch_stub_128, 128) + HIDDEN(gl_dispatch_stub_128) + GL_STUB(gl_dispatch_stub_129, 129) + HIDDEN(gl_dispatch_stub_129) + GL_STUB(gl_dispatch_stub_130, 130) + HIDDEN(gl_dispatch_stub_130) + GL_STUB(gl_dispatch_stub_131, 131) + HIDDEN(gl_dispatch_stub_131) + GL_STUB(gl_dispatch_stub_132, 132) + HIDDEN(gl_dispatch_stub_132) + GL_STUB(gl_dispatch_stub_133, 133) + HIDDEN(gl_dispatch_stub_133) + GL_STUB(gl_dispatch_stub_134, 134) + HIDDEN(gl_dispatch_stub_134) + GL_STUB(gl_dispatch_stub_135, 135) + HIDDEN(gl_dispatch_stub_135) + GL_STUB(gl_dispatch_stub_136, 136) + HIDDEN(gl_dispatch_stub_136) + GL_STUB(gl_dispatch_stub_137, 137) + HIDDEN(gl_dispatch_stub_137) + GL_STUB(gl_dispatch_stub_138, 138) + HIDDEN(gl_dispatch_stub_138) + GL_STUB(gl_dispatch_stub_139, 139) + HIDDEN(gl_dispatch_stub_139) + GL_STUB(gl_dispatch_stub_140, 140) + HIDDEN(gl_dispatch_stub_140) + GL_STUB(gl_dispatch_stub_141, 141) + HIDDEN(gl_dispatch_stub_141) + GL_STUB(gl_dispatch_stub_142, 142) + HIDDEN(gl_dispatch_stub_142) + GL_STUB(gl_dispatch_stub_143, 143) + HIDDEN(gl_dispatch_stub_143) + GL_STUB(gl_dispatch_stub_144, 144) + HIDDEN(gl_dispatch_stub_144) + GL_STUB(gl_dispatch_stub_145, 145) + HIDDEN(gl_dispatch_stub_145) + GL_STUB(gl_dispatch_stub_146, 146) + HIDDEN(gl_dispatch_stub_146) + GL_STUB(gl_dispatch_stub_147, 147) + HIDDEN(gl_dispatch_stub_147) + GL_STUB(gl_dispatch_stub_148, 148) + HIDDEN(gl_dispatch_stub_148) + GL_STUB(gl_dispatch_stub_149, 149) + HIDDEN(gl_dispatch_stub_149) + GL_STUB(gl_dispatch_stub_150, 150) + HIDDEN(gl_dispatch_stub_150) + GL_STUB(gl_dispatch_stub_151, 151) + HIDDEN(gl_dispatch_stub_151) + GL_STUB(glCullFace, 152) + GL_STUB(gl_dispatch_stub_153, 153) + HIDDEN(gl_dispatch_stub_153) + GL_STUB(gl_dispatch_stub_154, 154) + HIDDEN(gl_dispatch_stub_154) + GL_STUB(gl_dispatch_stub_155, 155) + HIDDEN(gl_dispatch_stub_155) + GL_STUB(gl_dispatch_stub_156, 156) + HIDDEN(gl_dispatch_stub_156) + GL_STUB(glFrontFace, 157) + GL_STUB(glHint, 158) + GL_STUB(gl_dispatch_stub_159, 159) + HIDDEN(gl_dispatch_stub_159) + GL_STUB(gl_dispatch_stub_160, 160) + HIDDEN(gl_dispatch_stub_160) + GL_STUB(gl_dispatch_stub_161, 161) + HIDDEN(gl_dispatch_stub_161) + GL_STUB(gl_dispatch_stub_162, 162) + HIDDEN(gl_dispatch_stub_162) + GL_STUB(gl_dispatch_stub_163, 163) + HIDDEN(gl_dispatch_stub_163) + GL_STUB(gl_dispatch_stub_164, 164) + HIDDEN(gl_dispatch_stub_164) + GL_STUB(gl_dispatch_stub_165, 165) + HIDDEN(gl_dispatch_stub_165) + GL_STUB(gl_dispatch_stub_166, 166) + HIDDEN(gl_dispatch_stub_166) + GL_STUB(gl_dispatch_stub_167, 167) + HIDDEN(gl_dispatch_stub_167) + GL_STUB(glLineWidth, 168) + GL_STUB(gl_dispatch_stub_169, 169) + HIDDEN(gl_dispatch_stub_169) + GL_STUB(gl_dispatch_stub_170, 170) + HIDDEN(gl_dispatch_stub_170) + GL_STUB(gl_dispatch_stub_171, 171) + HIDDEN(gl_dispatch_stub_171) + GL_STUB(gl_dispatch_stub_172, 172) + HIDDEN(gl_dispatch_stub_172) + GL_STUB(gl_dispatch_stub_173, 173) + HIDDEN(gl_dispatch_stub_173) + GL_STUB(gl_dispatch_stub_174, 174) + HIDDEN(gl_dispatch_stub_174) + GL_STUB(gl_dispatch_stub_175, 175) + HIDDEN(gl_dispatch_stub_175) + GL_STUB(glScissor, 176) + GL_STUB(gl_dispatch_stub_177, 177) + HIDDEN(gl_dispatch_stub_177) + GL_STUB(glTexParameterf, 178) + GL_STUB(glTexParameterfv, 179) + GL_STUB(glTexParameteri, 180) + GL_STUB(glTexParameteriv, 181) + GL_STUB(gl_dispatch_stub_182, 182) + HIDDEN(gl_dispatch_stub_182) + GL_STUB(glTexImage2D, 183) + GL_STUB(gl_dispatch_stub_184, 184) + HIDDEN(gl_dispatch_stub_184) + GL_STUB(gl_dispatch_stub_185, 185) + HIDDEN(gl_dispatch_stub_185) + GL_STUB(gl_dispatch_stub_186, 186) + HIDDEN(gl_dispatch_stub_186) + GL_STUB(gl_dispatch_stub_187, 187) + HIDDEN(gl_dispatch_stub_187) + GL_STUB(gl_dispatch_stub_188, 188) + HIDDEN(gl_dispatch_stub_188) + GL_STUB(gl_dispatch_stub_189, 189) + HIDDEN(gl_dispatch_stub_189) + GL_STUB(gl_dispatch_stub_190, 190) + HIDDEN(gl_dispatch_stub_190) + GL_STUB(gl_dispatch_stub_191, 191) + HIDDEN(gl_dispatch_stub_191) + GL_STUB(gl_dispatch_stub_192, 192) + HIDDEN(gl_dispatch_stub_192) + GL_STUB(gl_dispatch_stub_193, 193) + HIDDEN(gl_dispatch_stub_193) + GL_STUB(gl_dispatch_stub_194, 194) + HIDDEN(gl_dispatch_stub_194) + GL_STUB(gl_dispatch_stub_195, 195) + HIDDEN(gl_dispatch_stub_195) + GL_STUB(gl_dispatch_stub_196, 196) + HIDDEN(gl_dispatch_stub_196) + GL_STUB(gl_dispatch_stub_197, 197) + HIDDEN(gl_dispatch_stub_197) + GL_STUB(gl_dispatch_stub_198, 198) + HIDDEN(gl_dispatch_stub_198) + GL_STUB(gl_dispatch_stub_199, 199) + HIDDEN(gl_dispatch_stub_199) + GL_STUB(gl_dispatch_stub_200, 200) + HIDDEN(gl_dispatch_stub_200) + GL_STUB(gl_dispatch_stub_201, 201) + HIDDEN(gl_dispatch_stub_201) + GL_STUB(gl_dispatch_stub_202, 202) + HIDDEN(gl_dispatch_stub_202) + GL_STUB(glClear, 203) + GL_STUB(gl_dispatch_stub_204, 204) + HIDDEN(gl_dispatch_stub_204) + GL_STUB(gl_dispatch_stub_205, 205) + HIDDEN(gl_dispatch_stub_205) + GL_STUB(glClearColor, 206) + GL_STUB(glClearStencil, 207) + GL_STUB(gl_dispatch_stub_208, 208) + HIDDEN(gl_dispatch_stub_208) + GL_STUB(glStencilMask, 209) + GL_STUB(glColorMask, 210) + GL_STUB(glDepthMask, 211) + GL_STUB(gl_dispatch_stub_212, 212) + HIDDEN(gl_dispatch_stub_212) + GL_STUB(gl_dispatch_stub_213, 213) + HIDDEN(gl_dispatch_stub_213) + GL_STUB(glDisable, 214) + GL_STUB(glEnable, 215) + GL_STUB(glFinish, 216) + GL_STUB(glFlush, 217) + GL_STUB(gl_dispatch_stub_218, 218) + HIDDEN(gl_dispatch_stub_218) + GL_STUB(gl_dispatch_stub_219, 219) + HIDDEN(gl_dispatch_stub_219) + GL_STUB(gl_dispatch_stub_220, 220) + HIDDEN(gl_dispatch_stub_220) + GL_STUB(gl_dispatch_stub_221, 221) + HIDDEN(gl_dispatch_stub_221) + GL_STUB(gl_dispatch_stub_222, 222) + HIDDEN(gl_dispatch_stub_222) + GL_STUB(gl_dispatch_stub_223, 223) + HIDDEN(gl_dispatch_stub_223) + GL_STUB(gl_dispatch_stub_224, 224) + HIDDEN(gl_dispatch_stub_224) + GL_STUB(gl_dispatch_stub_225, 225) + HIDDEN(gl_dispatch_stub_225) + GL_STUB(gl_dispatch_stub_226, 226) + HIDDEN(gl_dispatch_stub_226) + GL_STUB(gl_dispatch_stub_227, 227) + HIDDEN(gl_dispatch_stub_227) + GL_STUB(gl_dispatch_stub_228, 228) + HIDDEN(gl_dispatch_stub_228) + GL_STUB(gl_dispatch_stub_229, 229) + HIDDEN(gl_dispatch_stub_229) + GL_STUB(gl_dispatch_stub_230, 230) + HIDDEN(gl_dispatch_stub_230) + GL_STUB(gl_dispatch_stub_231, 231) + HIDDEN(gl_dispatch_stub_231) + GL_STUB(gl_dispatch_stub_232, 232) + HIDDEN(gl_dispatch_stub_232) + GL_STUB(gl_dispatch_stub_233, 233) + HIDDEN(gl_dispatch_stub_233) + GL_STUB(gl_dispatch_stub_234, 234) + HIDDEN(gl_dispatch_stub_234) + GL_STUB(gl_dispatch_stub_235, 235) + HIDDEN(gl_dispatch_stub_235) + GL_STUB(gl_dispatch_stub_236, 236) + HIDDEN(gl_dispatch_stub_236) + GL_STUB(gl_dispatch_stub_237, 237) + HIDDEN(gl_dispatch_stub_237) + GL_STUB(gl_dispatch_stub_238, 238) + HIDDEN(gl_dispatch_stub_238) + GL_STUB(gl_dispatch_stub_239, 239) + HIDDEN(gl_dispatch_stub_239) + GL_STUB(gl_dispatch_stub_240, 240) + HIDDEN(gl_dispatch_stub_240) + GL_STUB(glBlendFunc, 241) + GL_STUB(gl_dispatch_stub_242, 242) + HIDDEN(gl_dispatch_stub_242) + GL_STUB(glStencilFunc, 243) + GL_STUB(glStencilOp, 244) + GL_STUB(glDepthFunc, 245) + GL_STUB(gl_dispatch_stub_246, 246) + HIDDEN(gl_dispatch_stub_246) + GL_STUB(gl_dispatch_stub_247, 247) + HIDDEN(gl_dispatch_stub_247) + GL_STUB(gl_dispatch_stub_248, 248) + HIDDEN(gl_dispatch_stub_248) + GL_STUB(gl_dispatch_stub_249, 249) + HIDDEN(gl_dispatch_stub_249) + GL_STUB(glPixelStorei, 250) + GL_STUB(gl_dispatch_stub_251, 251) + HIDDEN(gl_dispatch_stub_251) + GL_STUB(gl_dispatch_stub_252, 252) + HIDDEN(gl_dispatch_stub_252) + GL_STUB(gl_dispatch_stub_253, 253) + HIDDEN(gl_dispatch_stub_253) + GL_STUB(gl_dispatch_stub_254, 254) + HIDDEN(gl_dispatch_stub_254) + GL_STUB(gl_dispatch_stub_255, 255) + HIDDEN(gl_dispatch_stub_255) + GL_STUB(glReadPixels, 256) + GL_STUB(gl_dispatch_stub_257, 257) + HIDDEN(gl_dispatch_stub_257) + GL_STUB(glGetBooleanv, 258) + GL_STUB(gl_dispatch_stub_259, 259) + HIDDEN(gl_dispatch_stub_259) + GL_STUB(gl_dispatch_stub_260, 260) + HIDDEN(gl_dispatch_stub_260) + GL_STUB(glGetError, 261) + GL_STUB(glGetFloatv, 262) + GL_STUB(glGetIntegerv, 263) + GL_STUB(gl_dispatch_stub_264, 264) + HIDDEN(gl_dispatch_stub_264) + GL_STUB(gl_dispatch_stub_265, 265) + HIDDEN(gl_dispatch_stub_265) + GL_STUB(gl_dispatch_stub_266, 266) + HIDDEN(gl_dispatch_stub_266) + GL_STUB(gl_dispatch_stub_267, 267) + HIDDEN(gl_dispatch_stub_267) + GL_STUB(gl_dispatch_stub_268, 268) + HIDDEN(gl_dispatch_stub_268) + GL_STUB(gl_dispatch_stub_269, 269) + HIDDEN(gl_dispatch_stub_269) + GL_STUB(gl_dispatch_stub_270, 270) + HIDDEN(gl_dispatch_stub_270) + GL_STUB(gl_dispatch_stub_271, 271) + HIDDEN(gl_dispatch_stub_271) + GL_STUB(gl_dispatch_stub_272, 272) + HIDDEN(gl_dispatch_stub_272) + GL_STUB(gl_dispatch_stub_273, 273) + HIDDEN(gl_dispatch_stub_273) + GL_STUB(gl_dispatch_stub_274, 274) + HIDDEN(gl_dispatch_stub_274) + GL_STUB(glGetString, 275) + GL_STUB(gl_dispatch_stub_276, 276) + HIDDEN(gl_dispatch_stub_276) + GL_STUB(gl_dispatch_stub_277, 277) + HIDDEN(gl_dispatch_stub_277) + GL_STUB(gl_dispatch_stub_278, 278) + HIDDEN(gl_dispatch_stub_278) + GL_STUB(gl_dispatch_stub_279, 279) + HIDDEN(gl_dispatch_stub_279) + GL_STUB(gl_dispatch_stub_280, 280) + HIDDEN(gl_dispatch_stub_280) + GL_STUB(gl_dispatch_stub_281, 281) + HIDDEN(gl_dispatch_stub_281) + GL_STUB(glGetTexParameterfv, 282) + GL_STUB(glGetTexParameteriv, 283) + GL_STUB(gl_dispatch_stub_284, 284) + HIDDEN(gl_dispatch_stub_284) + GL_STUB(gl_dispatch_stub_285, 285) + HIDDEN(gl_dispatch_stub_285) + GL_STUB(glIsEnabled, 286) + GL_STUB(gl_dispatch_stub_287, 287) + HIDDEN(gl_dispatch_stub_287) + GL_STUB(gl_dispatch_stub_288, 288) + HIDDEN(gl_dispatch_stub_288) + GL_STUB(gl_dispatch_stub_289, 289) + HIDDEN(gl_dispatch_stub_289) + GL_STUB(gl_dispatch_stub_290, 290) + HIDDEN(gl_dispatch_stub_290) + GL_STUB(gl_dispatch_stub_291, 291) + HIDDEN(gl_dispatch_stub_291) + GL_STUB(gl_dispatch_stub_292, 292) + HIDDEN(gl_dispatch_stub_292) + GL_STUB(gl_dispatch_stub_293, 293) + HIDDEN(gl_dispatch_stub_293) + GL_STUB(gl_dispatch_stub_294, 294) + HIDDEN(gl_dispatch_stub_294) + GL_STUB(gl_dispatch_stub_295, 295) + HIDDEN(gl_dispatch_stub_295) + GL_STUB(gl_dispatch_stub_296, 296) + HIDDEN(gl_dispatch_stub_296) + GL_STUB(gl_dispatch_stub_297, 297) + HIDDEN(gl_dispatch_stub_297) + GL_STUB(gl_dispatch_stub_298, 298) + HIDDEN(gl_dispatch_stub_298) + GL_STUB(gl_dispatch_stub_299, 299) + HIDDEN(gl_dispatch_stub_299) + GL_STUB(gl_dispatch_stub_300, 300) + HIDDEN(gl_dispatch_stub_300) + GL_STUB(gl_dispatch_stub_301, 301) + HIDDEN(gl_dispatch_stub_301) + GL_STUB(gl_dispatch_stub_302, 302) + HIDDEN(gl_dispatch_stub_302) + GL_STUB(gl_dispatch_stub_303, 303) + HIDDEN(gl_dispatch_stub_303) + GL_STUB(gl_dispatch_stub_304, 304) + HIDDEN(gl_dispatch_stub_304) + GL_STUB(glViewport, 305) + GL_STUB(gl_dispatch_stub_306, 306) + HIDDEN(gl_dispatch_stub_306) + GL_STUB(glBindTexture, 307) + GL_STUB(gl_dispatch_stub_308, 308) + HIDDEN(gl_dispatch_stub_308) + GL_STUB(gl_dispatch_stub_309, 309) + HIDDEN(gl_dispatch_stub_309) + GL_STUB(glDrawArrays, 310) + GL_STUB(glDrawElements, 311) + GL_STUB(gl_dispatch_stub_312, 312) + HIDDEN(gl_dispatch_stub_312) + GL_STUB(gl_dispatch_stub_313, 313) + HIDDEN(gl_dispatch_stub_313) + GL_STUB(gl_dispatch_stub_314, 314) + HIDDEN(gl_dispatch_stub_314) + GL_STUB(gl_dispatch_stub_315, 315) + HIDDEN(gl_dispatch_stub_315) + GL_STUB(gl_dispatch_stub_316, 316) + HIDDEN(gl_dispatch_stub_316) + GL_STUB(gl_dispatch_stub_317, 317) + HIDDEN(gl_dispatch_stub_317) + GL_STUB(gl_dispatch_stub_318, 318) + HIDDEN(gl_dispatch_stub_318) + GL_STUB(glPolygonOffset, 319) + GL_STUB(gl_dispatch_stub_320, 320) + HIDDEN(gl_dispatch_stub_320) + GL_STUB(gl_dispatch_stub_321, 321) + HIDDEN(gl_dispatch_stub_321) + GL_STUB(gl_dispatch_stub_322, 322) + HIDDEN(gl_dispatch_stub_322) + GL_STUB(gl_dispatch_stub_323, 323) + HIDDEN(gl_dispatch_stub_323) + GL_STUB(glCopyTexImage2D, 324) + GL_STUB(gl_dispatch_stub_325, 325) + HIDDEN(gl_dispatch_stub_325) + GL_STUB(glCopyTexSubImage2D, 326) + GL_STUB(glDeleteTextures, 327) + GL_STUB(glGenTextures, 328) + GL_STUB(gl_dispatch_stub_329, 329) + HIDDEN(gl_dispatch_stub_329) + GL_STUB(glIsTexture, 330) + GL_STUB(gl_dispatch_stub_331, 331) + HIDDEN(gl_dispatch_stub_331) + GL_STUB(gl_dispatch_stub_332, 332) + HIDDEN(gl_dispatch_stub_332) + GL_STUB(glTexSubImage2D, 333) + GL_STUB(gl_dispatch_stub_334, 334) + HIDDEN(gl_dispatch_stub_334) + GL_STUB(gl_dispatch_stub_335, 335) + HIDDEN(gl_dispatch_stub_335) + GL_STUB(glBlendColor, 336) + GL_STUB(glBlendEquation, 337) + GL_STUB(gl_dispatch_stub_338, 338) + HIDDEN(gl_dispatch_stub_338) + GL_STUB(gl_dispatch_stub_339, 339) + HIDDEN(gl_dispatch_stub_339) + GL_STUB(gl_dispatch_stub_340, 340) + HIDDEN(gl_dispatch_stub_340) + GL_STUB(gl_dispatch_stub_341, 341) + HIDDEN(gl_dispatch_stub_341) + GL_STUB(gl_dispatch_stub_342, 342) + HIDDEN(gl_dispatch_stub_342) + GL_STUB(gl_dispatch_stub_343, 343) + HIDDEN(gl_dispatch_stub_343) + GL_STUB(gl_dispatch_stub_344, 344) + HIDDEN(gl_dispatch_stub_344) + GL_STUB(gl_dispatch_stub_345, 345) + HIDDEN(gl_dispatch_stub_345) + GL_STUB(gl_dispatch_stub_346, 346) + HIDDEN(gl_dispatch_stub_346) + GL_STUB(gl_dispatch_stub_347, 347) + HIDDEN(gl_dispatch_stub_347) + GL_STUB(gl_dispatch_stub_348, 348) + HIDDEN(gl_dispatch_stub_348) + GL_STUB(gl_dispatch_stub_349, 349) + HIDDEN(gl_dispatch_stub_349) + GL_STUB(gl_dispatch_stub_350, 350) + HIDDEN(gl_dispatch_stub_350) + GL_STUB(gl_dispatch_stub_351, 351) + HIDDEN(gl_dispatch_stub_351) + GL_STUB(gl_dispatch_stub_352, 352) + HIDDEN(gl_dispatch_stub_352) + GL_STUB(gl_dispatch_stub_353, 353) + HIDDEN(gl_dispatch_stub_353) + GL_STUB(gl_dispatch_stub_354, 354) + HIDDEN(gl_dispatch_stub_354) + GL_STUB(gl_dispatch_stub_355, 355) + HIDDEN(gl_dispatch_stub_355) + GL_STUB(gl_dispatch_stub_356, 356) + HIDDEN(gl_dispatch_stub_356) + GL_STUB(gl_dispatch_stub_357, 357) + HIDDEN(gl_dispatch_stub_357) + GL_STUB(gl_dispatch_stub_358, 358) + HIDDEN(gl_dispatch_stub_358) + GL_STUB(gl_dispatch_stub_359, 359) + HIDDEN(gl_dispatch_stub_359) + GL_STUB(gl_dispatch_stub_360, 360) + HIDDEN(gl_dispatch_stub_360) + GL_STUB(gl_dispatch_stub_361, 361) + HIDDEN(gl_dispatch_stub_361) + GL_STUB(gl_dispatch_stub_362, 362) + HIDDEN(gl_dispatch_stub_362) + GL_STUB(gl_dispatch_stub_363, 363) + HIDDEN(gl_dispatch_stub_363) + GL_STUB(gl_dispatch_stub_364, 364) + HIDDEN(gl_dispatch_stub_364) + GL_STUB(gl_dispatch_stub_365, 365) + HIDDEN(gl_dispatch_stub_365) + GL_STUB(gl_dispatch_stub_366, 366) + HIDDEN(gl_dispatch_stub_366) + GL_STUB(gl_dispatch_stub_367, 367) + HIDDEN(gl_dispatch_stub_367) + GL_STUB(gl_dispatch_stub_368, 368) + HIDDEN(gl_dispatch_stub_368) + GL_STUB(gl_dispatch_stub_369, 369) + HIDDEN(gl_dispatch_stub_369) + GL_STUB(gl_dispatch_stub_370, 370) + HIDDEN(gl_dispatch_stub_370) + GL_STUB(glTexImage3DOES, 371) + GL_STUB(glTexSubImage3DOES, 372) + GL_STUB(glCopyTexSubImage3DOES, 373) + GL_STUB(glActiveTexture, 374) + GL_STUB(gl_dispatch_stub_375, 375) + HIDDEN(gl_dispatch_stub_375) + GL_STUB(gl_dispatch_stub_376, 376) + HIDDEN(gl_dispatch_stub_376) + GL_STUB(gl_dispatch_stub_377, 377) + HIDDEN(gl_dispatch_stub_377) + GL_STUB(gl_dispatch_stub_378, 378) + HIDDEN(gl_dispatch_stub_378) + GL_STUB(gl_dispatch_stub_379, 379) + HIDDEN(gl_dispatch_stub_379) + GL_STUB(gl_dispatch_stub_380, 380) + HIDDEN(gl_dispatch_stub_380) + GL_STUB(gl_dispatch_stub_381, 381) + HIDDEN(gl_dispatch_stub_381) + GL_STUB(gl_dispatch_stub_382, 382) + HIDDEN(gl_dispatch_stub_382) + GL_STUB(gl_dispatch_stub_383, 383) + HIDDEN(gl_dispatch_stub_383) + GL_STUB(gl_dispatch_stub_384, 384) + HIDDEN(gl_dispatch_stub_384) + GL_STUB(gl_dispatch_stub_385, 385) + HIDDEN(gl_dispatch_stub_385) + GL_STUB(gl_dispatch_stub_386, 386) + HIDDEN(gl_dispatch_stub_386) + GL_STUB(gl_dispatch_stub_387, 387) + HIDDEN(gl_dispatch_stub_387) + GL_STUB(gl_dispatch_stub_388, 388) + HIDDEN(gl_dispatch_stub_388) + GL_STUB(gl_dispatch_stub_389, 389) + HIDDEN(gl_dispatch_stub_389) + GL_STUB(gl_dispatch_stub_390, 390) + HIDDEN(gl_dispatch_stub_390) + GL_STUB(gl_dispatch_stub_391, 391) + HIDDEN(gl_dispatch_stub_391) + GL_STUB(gl_dispatch_stub_392, 392) + HIDDEN(gl_dispatch_stub_392) + GL_STUB(gl_dispatch_stub_393, 393) + HIDDEN(gl_dispatch_stub_393) + GL_STUB(gl_dispatch_stub_394, 394) + HIDDEN(gl_dispatch_stub_394) + GL_STUB(gl_dispatch_stub_395, 395) + HIDDEN(gl_dispatch_stub_395) + GL_STUB(gl_dispatch_stub_396, 396) + HIDDEN(gl_dispatch_stub_396) + GL_STUB(gl_dispatch_stub_397, 397) + HIDDEN(gl_dispatch_stub_397) + GL_STUB(gl_dispatch_stub_398, 398) + HIDDEN(gl_dispatch_stub_398) + GL_STUB(gl_dispatch_stub_399, 399) + HIDDEN(gl_dispatch_stub_399) + GL_STUB(gl_dispatch_stub_400, 400) + HIDDEN(gl_dispatch_stub_400) + GL_STUB(gl_dispatch_stub_401, 401) + HIDDEN(gl_dispatch_stub_401) + GL_STUB(gl_dispatch_stub_402, 402) + HIDDEN(gl_dispatch_stub_402) + GL_STUB(gl_dispatch_stub_403, 403) + HIDDEN(gl_dispatch_stub_403) + GL_STUB(gl_dispatch_stub_404, 404) + HIDDEN(gl_dispatch_stub_404) + GL_STUB(gl_dispatch_stub_405, 405) + HIDDEN(gl_dispatch_stub_405) + GL_STUB(gl_dispatch_stub_406, 406) + HIDDEN(gl_dispatch_stub_406) + GL_STUB(gl_dispatch_stub_407, 407) + HIDDEN(gl_dispatch_stub_407) + GL_STUB(glGetBufferPointervOES, 408) + GL_STUB(glMapBufferOES, 409) + GL_STUB(glUnmapBufferOES, 410) + GL_STUB(glCompressedTexImage3DOES, 411) + GL_STUB(glCompressedTexSubImage3DOES, 412) + GL_STUB(glFramebufferTexture3DOES, 413) + GL_STUB(glGetProgramBinaryOES, 414) + GL_STUB(glProgramBinaryOES, 415) + GL_STUB(glMultiDrawArraysEXT, 416) + GL_STUB(glMultiDrawElementsEXT, 417) + GL_STUB(gl_dispatch_stub_418, 418) + HIDDEN(gl_dispatch_stub_418) + GL_STUB(gl_dispatch_stub_419, 419) + HIDDEN(gl_dispatch_stub_419) + GL_STUB(gl_dispatch_stub_420, 420) + HIDDEN(gl_dispatch_stub_420) + GL_STUB(gl_dispatch_stub_421, 421) + HIDDEN(gl_dispatch_stub_421) + GL_STUB(glEGLImageTargetRenderbufferStorageOES, 422) + GL_STUB(glEGLImageTargetTexture2DOES, 423) + GL_STUB(glCompressedTexImage2D, 424) + GL_STUB(glCompressedTexSubImage2D, 425) + GL_STUB(glSampleCoverage, 426) + GL_STUB(glBindBuffer, 427) + GL_STUB(glBufferData, 428) + GL_STUB(glBufferSubData, 429) + GL_STUB(glDeleteBuffers, 430) + GL_STUB(glGenBuffers, 431) + GL_STUB(glGetBufferParameteriv, 432) + GL_STUB(glIsBuffer, 433) + GL_STUB(glAttachShader, 434) + GL_STUB(glBindAttribLocation, 435) + GL_STUB(glBlendEquationSeparate, 436) + GL_STUB(glCompileShader, 437) + GL_STUB(glCreateProgram, 438) + GL_STUB(glCreateShader, 439) + GL_STUB(glDeleteProgram, 440) + GL_STUB(glDeleteShader, 441) + GL_STUB(glDetachShader, 442) + GL_STUB(glDisableVertexAttribArray, 443) + GL_STUB(glEnableVertexAttribArray, 444) + GL_STUB(glGetActiveAttrib, 445) + GL_STUB(glGetActiveUniform, 446) + GL_STUB(glGetAttachedShaders, 447) + GL_STUB(glGetAttribLocation, 448) + GL_STUB(glGetProgramInfoLog, 449) + GL_STUB(glGetProgramiv, 450) + GL_STUB(glGetShaderInfoLog, 451) + GL_STUB(glGetShaderSource, 452) + GL_STUB(glGetShaderiv, 453) + GL_STUB(glGetUniformLocation, 454) + GL_STUB(glGetUniformfv, 455) + GL_STUB(glGetUniformiv, 456) + GL_STUB(glGetVertexAttribPointerv, 457) + GL_STUB(glGetVertexAttribfv, 458) + GL_STUB(glGetVertexAttribiv, 459) + GL_STUB(glIsProgram, 460) + GL_STUB(glIsShader, 461) + GL_STUB(glLinkProgram, 462) + GL_STUB(glShaderSource, 463) + GL_STUB(glStencilFuncSeparate, 464) + GL_STUB(glStencilMaskSeparate, 465) + GL_STUB(glStencilOpSeparate, 466) + GL_STUB(glUniform1f, 467) + GL_STUB(glUniform1fv, 468) + GL_STUB(glUniform1i, 469) + GL_STUB(glUniform1iv, 470) + GL_STUB(glUniform2f, 471) + GL_STUB(glUniform2fv, 472) + GL_STUB(glUniform2i, 473) + GL_STUB(glUniform2iv, 474) + GL_STUB(glUniform3f, 475) + GL_STUB(glUniform3fv, 476) + GL_STUB(glUniform3i, 477) + GL_STUB(glUniform3iv, 478) + GL_STUB(glUniform4f, 479) + GL_STUB(glUniform4fv, 480) + GL_STUB(glUniform4i, 481) + GL_STUB(glUniform4iv, 482) + GL_STUB(glUniformMatrix2fv, 483) + GL_STUB(glUniformMatrix3fv, 484) + GL_STUB(glUniformMatrix4fv, 485) + GL_STUB(glUseProgram, 486) + GL_STUB(glValidateProgram, 487) + GL_STUB(glVertexAttrib1f, 488) + GL_STUB(glVertexAttrib1fv, 489) + GL_STUB(glVertexAttrib2f, 490) + GL_STUB(glVertexAttrib2fv, 491) + GL_STUB(glVertexAttrib3f, 492) + GL_STUB(glVertexAttrib3fv, 493) + GL_STUB(glVertexAttrib4f, 494) + GL_STUB(glVertexAttrib4fv, 495) + GL_STUB(glVertexAttribPointer, 496) + GL_STUB(glBlendFuncSeparate, 497) + GL_STUB(glBindFramebuffer, 498) + GL_STUB(glBindRenderbuffer, 499) + GL_STUB(glCheckFramebufferStatus, 500) + GL_STUB(glClearDepthf, 501) + GL_STUB(glDeleteFramebuffers, 502) + GL_STUB(glDeleteRenderbuffers, 503) + GL_STUB(glDepthRangef, 504) + GL_STUB(glFramebufferRenderbuffer, 505) + GL_STUB(glFramebufferTexture2D, 506) + GL_STUB(glGenFramebuffers, 507) + GL_STUB(glGenRenderbuffers, 508) + GL_STUB(glGenerateMipmap, 509) + GL_STUB(glGetFramebufferAttachmentParameteriv, 510) + GL_STUB(glGetRenderbufferParameteriv, 511) + GL_STUB(glGetShaderPrecisionFormat, 512) + GL_STUB(glIsFramebuffer, 513) + GL_STUB(glIsRenderbuffer, 514) + GL_STUB(glReleaseShaderCompiler, 515) + GL_STUB(glRenderbufferStorage, 516) + GL_STUB(glShaderBinary, 517) + GL_STUB_ALIAS(glTexImage3D, glTexImage3DOES) + GL_STUB_ALIAS(glTexSubImage3D, glTexSubImage3DOES) + GL_STUB_ALIAS(glCopyTexSubImage3D, glCopyTexSubImage3DOES) + GL_STUB_ALIAS(glActiveTextureARB, glActiveTexture) + + .globl gl_dispatch_functions_end + HIDDEN(gl_dispatch_functions_end) +gl_dispatch_functions_end: diff --git a/src/mapi/es2api/glapi/glapi_x86-64.S b/src/mapi/es2api/glapi/glapi_x86-64.S new file mode 100644 index 00000000000..23202a26573 --- /dev/null +++ b/src/mapi/es2api/glapi/glapi_x86-64.S @@ -0,0 +1,19796 @@ +/* DO NOT EDIT - This file generated automatically by gl_x86-64_asm.py (from Mesa) script */ + +/* + * (C) Copyright IBM Corporation 2005 + * All Rights Reserved. + * + * Permission is hereby granted, free of charge, to any person obtaining a + * copy of this software and associated documentation files (the "Software"), + * to deal in the Software without restriction, including without limitation + * the rights to use, copy, modify, merge, publish, distribute, sub license, + * and/or sell copies of the Software, and to permit persons to whom the + * Software is furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice (including the next + * paragraph) shall be included in all copies or substantial portions of the + * Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL + * IBM, + * AND/OR THEIR SUPPLIERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, + * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF + * OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE + * SOFTWARE. + */ + +/* If we build with gcc's -fvisibility=hidden flag, we'll need to change + * the symbol visibility mode to 'default'. + */ + +#include "x86/assyntax.h" + +#ifdef __GNUC__ +# pragma GCC visibility push(default) +# define HIDDEN(x) .hidden x +#else +# define HIDDEN(x) +#endif + +# if defined(USE_MGL_NAMESPACE) +# define GL_PREFIX(n) GLNAME(CONCAT(mgl,n)) +# define _glapi_Dispatch _mglapi_Dispatch +# else +# define GL_PREFIX(n) GLNAME(CONCAT(gl,n)) +# endif + +#if defined(PTHREADS) || defined(WIN32) || defined(BEOS_THREADS) +# define THREADS +#endif + + .text + +#ifdef GLX_USE_TLS + + .globl _x86_64_get_get_dispatch; HIDDEN(_x86_64_get_get_dispatch) +_x86_64_get_get_dispatch: + lea _x86_64_get_dispatch(%rip), %rax + ret + + .p2align 4,,15 +_x86_64_get_dispatch: + movq _glapi_tls_Dispatch@GOTTPOFF(%rip), %rax + movq %fs:(%rax), %rax + ret + .size _x86_64_get_dispatch, .-_x86_64_get_dispatch + +#elif defined(PTHREADS) + + .extern _glapi_Dispatch + .extern _gl_DispatchTSD + .extern pthread_getspecific + + .p2align 4,,15 +_x86_64_get_dispatch: + movq _gl_DispatchTSD(%rip), %rdi + jmp pthread_getspecific@PLT + +#elif defined(THREADS) + + .extern _glapi_get_dispatch + +#endif + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_0) + .type GL_PREFIX(_dispatch_stub_0), @function + HIDDEN(GL_PREFIX(_dispatch_stub_0)) +GL_PREFIX(_dispatch_stub_0): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 0(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rbp + call _x86_64_get_dispatch@PLT + popq %rbp + popq %rsi + popq %rdi + movq (%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 0(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rbp + call _glapi_get_dispatch + popq %rbp + popq %rsi + popq %rdi + movq 0(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_0), .-GL_PREFIX(_dispatch_stub_0) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_1) + .type GL_PREFIX(_dispatch_stub_1), @function + HIDDEN(GL_PREFIX(_dispatch_stub_1)) +GL_PREFIX(_dispatch_stub_1): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 8(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rbp + call _x86_64_get_dispatch@PLT + popq %rbp + movq 8(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 8(%rax), %r11 + jmp *%r11 +1: + pushq %rbp + call _glapi_get_dispatch + popq %rbp + movq 8(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_1), .-GL_PREFIX(_dispatch_stub_1) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_2) + .type GL_PREFIX(_dispatch_stub_2), @function + HIDDEN(GL_PREFIX(_dispatch_stub_2)) +GL_PREFIX(_dispatch_stub_2): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 16(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + call _x86_64_get_dispatch@PLT + popq %rdi + movq 16(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 16(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + call _glapi_get_dispatch + popq %rdi + movq 16(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_2), .-GL_PREFIX(_dispatch_stub_2) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_3) + .type GL_PREFIX(_dispatch_stub_3), @function + HIDDEN(GL_PREFIX(_dispatch_stub_3)) +GL_PREFIX(_dispatch_stub_3): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 24(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rdx + call _x86_64_get_dispatch@PLT + popq %rdx + popq %rsi + popq %rdi + movq 24(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 24(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rdx + call _glapi_get_dispatch + popq %rdx + popq %rsi + popq %rdi + movq 24(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_3), .-GL_PREFIX(_dispatch_stub_3) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_4) + .type GL_PREFIX(_dispatch_stub_4), @function + HIDDEN(GL_PREFIX(_dispatch_stub_4)) +GL_PREFIX(_dispatch_stub_4): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 32(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rbp + call _x86_64_get_dispatch@PLT + popq %rbp + popq %rsi + popq %rdi + movq 32(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 32(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rbp + call _glapi_get_dispatch + popq %rbp + popq %rsi + popq %rdi + movq 32(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_4), .-GL_PREFIX(_dispatch_stub_4) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_5) + .type GL_PREFIX(_dispatch_stub_5), @function + HIDDEN(GL_PREFIX(_dispatch_stub_5)) +GL_PREFIX(_dispatch_stub_5): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 40(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + call _x86_64_get_dispatch@PLT + popq %rdi + movq 40(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 40(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + call _glapi_get_dispatch + popq %rdi + movq 40(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_5), .-GL_PREFIX(_dispatch_stub_5) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_6) + .type GL_PREFIX(_dispatch_stub_6), @function + HIDDEN(GL_PREFIX(_dispatch_stub_6)) +GL_PREFIX(_dispatch_stub_6): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 48(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + call _x86_64_get_dispatch@PLT + popq %rdi + movq 48(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 48(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + call _glapi_get_dispatch + popq %rdi + movq 48(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_6), .-GL_PREFIX(_dispatch_stub_6) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_7) + .type GL_PREFIX(_dispatch_stub_7), @function + HIDDEN(GL_PREFIX(_dispatch_stub_7)) +GL_PREFIX(_dispatch_stub_7): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 56(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + call _x86_64_get_dispatch@PLT + popq %rdi + movq 56(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 56(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + call _glapi_get_dispatch + popq %rdi + movq 56(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_7), .-GL_PREFIX(_dispatch_stub_7) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_8) + .type GL_PREFIX(_dispatch_stub_8), @function + HIDDEN(GL_PREFIX(_dispatch_stub_8)) +GL_PREFIX(_dispatch_stub_8): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 64(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + subq $56, %rsp + movq %rdi, (%rsp) + movq %rsi, 8(%rsp) + movq %xmm0, 16(%rsp) + movq %xmm1, 24(%rsp) + movq %xmm2, 32(%rsp) + movq %xmm3, 40(%rsp) + movq %rdx, 48(%rsp) + call _x86_64_get_dispatch@PLT + movq 48(%rsp), %rdx + movq 40(%rsp), %xmm3 + movq 32(%rsp), %xmm2 + movq 24(%rsp), %xmm1 + movq 16(%rsp), %xmm0 + movq 8(%rsp), %rsi + movq (%rsp), %rdi + addq $56, %rsp + movq 64(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 64(%rax), %r11 + jmp *%r11 +1: + subq $56, %rsp + movq %rdi, (%rsp) + movq %rsi, 8(%rsp) + movq %xmm0, 16(%rsp) + movq %xmm1, 24(%rsp) + movq %xmm2, 32(%rsp) + movq %xmm3, 40(%rsp) + movq %rdx, 48(%rsp) + call _glapi_get_dispatch + movq 48(%rsp), %rdx + movq 40(%rsp), %xmm3 + movq 32(%rsp), %xmm2 + movq 24(%rsp), %xmm1 + movq 16(%rsp), %xmm0 + movq 8(%rsp), %rsi + movq (%rsp), %rdi + addq $56, %rsp + movq 64(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_8), .-GL_PREFIX(_dispatch_stub_8) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_9) + .type GL_PREFIX(_dispatch_stub_9), @function + HIDDEN(GL_PREFIX(_dispatch_stub_9)) +GL_PREFIX(_dispatch_stub_9): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 72(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rdx + call _x86_64_get_dispatch@PLT + popq %rdx + popq %rsi + popq %rdi + movq 72(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 72(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rdx + call _glapi_get_dispatch + popq %rdx + popq %rsi + popq %rdi + movq 72(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_9), .-GL_PREFIX(_dispatch_stub_9) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_10) + .type GL_PREFIX(_dispatch_stub_10), @function + HIDDEN(GL_PREFIX(_dispatch_stub_10)) +GL_PREFIX(_dispatch_stub_10): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 80(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + call _x86_64_get_dispatch@PLT + popq %rdi + movq 80(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 80(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + call _glapi_get_dispatch + popq %rdi + movq 80(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_10), .-GL_PREFIX(_dispatch_stub_10) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_11) + .type GL_PREFIX(_dispatch_stub_11), @function + HIDDEN(GL_PREFIX(_dispatch_stub_11)) +GL_PREFIX(_dispatch_stub_11): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 88(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + subq $24, %rsp + movq %xmm0, (%rsp) + movq %xmm1, 8(%rsp) + movq %xmm2, 16(%rsp) + call _x86_64_get_dispatch@PLT + movq 16(%rsp), %xmm2 + movq 8(%rsp), %xmm1 + movq (%rsp), %xmm0 + addq $24, %rsp + movq 88(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 88(%rax), %r11 + jmp *%r11 +1: + subq $24, %rsp + movq %xmm0, (%rsp) + movq %xmm1, 8(%rsp) + movq %xmm2, 16(%rsp) + call _glapi_get_dispatch + movq 16(%rsp), %xmm2 + movq 8(%rsp), %xmm1 + movq (%rsp), %xmm0 + addq $24, %rsp + movq 88(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_11), .-GL_PREFIX(_dispatch_stub_11) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_12) + .type GL_PREFIX(_dispatch_stub_12), @function + HIDDEN(GL_PREFIX(_dispatch_stub_12)) +GL_PREFIX(_dispatch_stub_12): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 96(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + call _x86_64_get_dispatch@PLT + popq %rdi + movq 96(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 96(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + call _glapi_get_dispatch + popq %rdi + movq 96(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_12), .-GL_PREFIX(_dispatch_stub_12) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_13) + .type GL_PREFIX(_dispatch_stub_13), @function + HIDDEN(GL_PREFIX(_dispatch_stub_13)) +GL_PREFIX(_dispatch_stub_13): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 104(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + subq $24, %rsp + movq %xmm0, (%rsp) + movq %xmm1, 8(%rsp) + movq %xmm2, 16(%rsp) + call _x86_64_get_dispatch@PLT + movq 16(%rsp), %xmm2 + movq 8(%rsp), %xmm1 + movq (%rsp), %xmm0 + addq $24, %rsp + movq 104(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 104(%rax), %r11 + jmp *%r11 +1: + subq $24, %rsp + movq %xmm0, (%rsp) + movq %xmm1, 8(%rsp) + movq %xmm2, 16(%rsp) + call _glapi_get_dispatch + movq 16(%rsp), %xmm2 + movq 8(%rsp), %xmm1 + movq (%rsp), %xmm0 + addq $24, %rsp + movq 104(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_13), .-GL_PREFIX(_dispatch_stub_13) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_14) + .type GL_PREFIX(_dispatch_stub_14), @function + HIDDEN(GL_PREFIX(_dispatch_stub_14)) +GL_PREFIX(_dispatch_stub_14): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 112(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + call _x86_64_get_dispatch@PLT + popq %rdi + movq 112(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 112(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + call _glapi_get_dispatch + popq %rdi + movq 112(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_14), .-GL_PREFIX(_dispatch_stub_14) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_15) + .type GL_PREFIX(_dispatch_stub_15), @function + HIDDEN(GL_PREFIX(_dispatch_stub_15)) +GL_PREFIX(_dispatch_stub_15): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 120(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rdx + call _x86_64_get_dispatch@PLT + popq %rdx + popq %rsi + popq %rdi + movq 120(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 120(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rdx + call _glapi_get_dispatch + popq %rdx + popq %rsi + popq %rdi + movq 120(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_15), .-GL_PREFIX(_dispatch_stub_15) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_16) + .type GL_PREFIX(_dispatch_stub_16), @function + HIDDEN(GL_PREFIX(_dispatch_stub_16)) +GL_PREFIX(_dispatch_stub_16): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 128(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + call _x86_64_get_dispatch@PLT + popq %rdi + movq 128(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 128(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + call _glapi_get_dispatch + popq %rdi + movq 128(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_16), .-GL_PREFIX(_dispatch_stub_16) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_17) + .type GL_PREFIX(_dispatch_stub_17), @function + HIDDEN(GL_PREFIX(_dispatch_stub_17)) +GL_PREFIX(_dispatch_stub_17): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 136(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rdx + call _x86_64_get_dispatch@PLT + popq %rdx + popq %rsi + popq %rdi + movq 136(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 136(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rdx + call _glapi_get_dispatch + popq %rdx + popq %rsi + popq %rdi + movq 136(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_17), .-GL_PREFIX(_dispatch_stub_17) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_18) + .type GL_PREFIX(_dispatch_stub_18), @function + HIDDEN(GL_PREFIX(_dispatch_stub_18)) +GL_PREFIX(_dispatch_stub_18): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 144(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + call _x86_64_get_dispatch@PLT + popq %rdi + movq 144(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 144(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + call _glapi_get_dispatch + popq %rdi + movq 144(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_18), .-GL_PREFIX(_dispatch_stub_18) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_19) + .type GL_PREFIX(_dispatch_stub_19), @function + HIDDEN(GL_PREFIX(_dispatch_stub_19)) +GL_PREFIX(_dispatch_stub_19): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 152(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rdx + call _x86_64_get_dispatch@PLT + popq %rdx + popq %rsi + popq %rdi + movq 152(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 152(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rdx + call _glapi_get_dispatch + popq %rdx + popq %rsi + popq %rdi + movq 152(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_19), .-GL_PREFIX(_dispatch_stub_19) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_20) + .type GL_PREFIX(_dispatch_stub_20), @function + HIDDEN(GL_PREFIX(_dispatch_stub_20)) +GL_PREFIX(_dispatch_stub_20): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 160(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + call _x86_64_get_dispatch@PLT + popq %rdi + movq 160(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 160(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + call _glapi_get_dispatch + popq %rdi + movq 160(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_20), .-GL_PREFIX(_dispatch_stub_20) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_21) + .type GL_PREFIX(_dispatch_stub_21), @function + HIDDEN(GL_PREFIX(_dispatch_stub_21)) +GL_PREFIX(_dispatch_stub_21): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 168(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rdx + call _x86_64_get_dispatch@PLT + popq %rdx + popq %rsi + popq %rdi + movq 168(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 168(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rdx + call _glapi_get_dispatch + popq %rdx + popq %rsi + popq %rdi + movq 168(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_21), .-GL_PREFIX(_dispatch_stub_21) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_22) + .type GL_PREFIX(_dispatch_stub_22), @function + HIDDEN(GL_PREFIX(_dispatch_stub_22)) +GL_PREFIX(_dispatch_stub_22): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 176(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + call _x86_64_get_dispatch@PLT + popq %rdi + movq 176(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 176(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + call _glapi_get_dispatch + popq %rdi + movq 176(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_22), .-GL_PREFIX(_dispatch_stub_22) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_23) + .type GL_PREFIX(_dispatch_stub_23), @function + HIDDEN(GL_PREFIX(_dispatch_stub_23)) +GL_PREFIX(_dispatch_stub_23): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 184(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rdx + call _x86_64_get_dispatch@PLT + popq %rdx + popq %rsi + popq %rdi + movq 184(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 184(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rdx + call _glapi_get_dispatch + popq %rdx + popq %rsi + popq %rdi + movq 184(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_23), .-GL_PREFIX(_dispatch_stub_23) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_24) + .type GL_PREFIX(_dispatch_stub_24), @function + HIDDEN(GL_PREFIX(_dispatch_stub_24)) +GL_PREFIX(_dispatch_stub_24): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 192(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + call _x86_64_get_dispatch@PLT + popq %rdi + movq 192(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 192(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + call _glapi_get_dispatch + popq %rdi + movq 192(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_24), .-GL_PREFIX(_dispatch_stub_24) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_25) + .type GL_PREFIX(_dispatch_stub_25), @function + HIDDEN(GL_PREFIX(_dispatch_stub_25)) +GL_PREFIX(_dispatch_stub_25): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 200(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rdx + pushq %rcx + pushq %rbp + call _x86_64_get_dispatch@PLT + popq %rbp + popq %rcx + popq %rdx + popq %rsi + popq %rdi + movq 200(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 200(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rdx + pushq %rcx + pushq %rbp + call _glapi_get_dispatch + popq %rbp + popq %rcx + popq %rdx + popq %rsi + popq %rdi + movq 200(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_25), .-GL_PREFIX(_dispatch_stub_25) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_26) + .type GL_PREFIX(_dispatch_stub_26), @function + HIDDEN(GL_PREFIX(_dispatch_stub_26)) +GL_PREFIX(_dispatch_stub_26): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 208(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + call _x86_64_get_dispatch@PLT + popq %rdi + movq 208(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 208(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + call _glapi_get_dispatch + popq %rdi + movq 208(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_26), .-GL_PREFIX(_dispatch_stub_26) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_27) + .type GL_PREFIX(_dispatch_stub_27), @function + HIDDEN(GL_PREFIX(_dispatch_stub_27)) +GL_PREFIX(_dispatch_stub_27): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 216(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + subq $40, %rsp + movq %xmm0, (%rsp) + movq %xmm1, 8(%rsp) + movq %xmm2, 16(%rsp) + movq %xmm3, 24(%rsp) + call _x86_64_get_dispatch@PLT + movq 24(%rsp), %xmm3 + movq 16(%rsp), %xmm2 + movq 8(%rsp), %xmm1 + movq (%rsp), %xmm0 + addq $40, %rsp + movq 216(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 216(%rax), %r11 + jmp *%r11 +1: + subq $40, %rsp + movq %xmm0, (%rsp) + movq %xmm1, 8(%rsp) + movq %xmm2, 16(%rsp) + movq %xmm3, 24(%rsp) + call _glapi_get_dispatch + movq 24(%rsp), %xmm3 + movq 16(%rsp), %xmm2 + movq 8(%rsp), %xmm1 + movq (%rsp), %xmm0 + addq $40, %rsp + movq 216(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_27), .-GL_PREFIX(_dispatch_stub_27) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_28) + .type GL_PREFIX(_dispatch_stub_28), @function + HIDDEN(GL_PREFIX(_dispatch_stub_28)) +GL_PREFIX(_dispatch_stub_28): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 224(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + call _x86_64_get_dispatch@PLT + popq %rdi + movq 224(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 224(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + call _glapi_get_dispatch + popq %rdi + movq 224(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_28), .-GL_PREFIX(_dispatch_stub_28) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_29) + .type GL_PREFIX(_dispatch_stub_29), @function + HIDDEN(GL_PREFIX(_dispatch_stub_29)) +GL_PREFIX(_dispatch_stub_29): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 232(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + subq $40, %rsp + movq %xmm0, (%rsp) + movq %xmm1, 8(%rsp) + movq %xmm2, 16(%rsp) + movq %xmm3, 24(%rsp) + call _x86_64_get_dispatch@PLT + movq 24(%rsp), %xmm3 + movq 16(%rsp), %xmm2 + movq 8(%rsp), %xmm1 + movq (%rsp), %xmm0 + addq $40, %rsp + movq 232(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 232(%rax), %r11 + jmp *%r11 +1: + subq $40, %rsp + movq %xmm0, (%rsp) + movq %xmm1, 8(%rsp) + movq %xmm2, 16(%rsp) + movq %xmm3, 24(%rsp) + call _glapi_get_dispatch + movq 24(%rsp), %xmm3 + movq 16(%rsp), %xmm2 + movq 8(%rsp), %xmm1 + movq (%rsp), %xmm0 + addq $40, %rsp + movq 232(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_29), .-GL_PREFIX(_dispatch_stub_29) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_30) + .type GL_PREFIX(_dispatch_stub_30), @function + HIDDEN(GL_PREFIX(_dispatch_stub_30)) +GL_PREFIX(_dispatch_stub_30): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 240(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + call _x86_64_get_dispatch@PLT + popq %rdi + movq 240(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 240(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + call _glapi_get_dispatch + popq %rdi + movq 240(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_30), .-GL_PREFIX(_dispatch_stub_30) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_31) + .type GL_PREFIX(_dispatch_stub_31), @function + HIDDEN(GL_PREFIX(_dispatch_stub_31)) +GL_PREFIX(_dispatch_stub_31): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 248(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rdx + pushq %rcx + pushq %rbp + call _x86_64_get_dispatch@PLT + popq %rbp + popq %rcx + popq %rdx + popq %rsi + popq %rdi + movq 248(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 248(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rdx + pushq %rcx + pushq %rbp + call _glapi_get_dispatch + popq %rbp + popq %rcx + popq %rdx + popq %rsi + popq %rdi + movq 248(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_31), .-GL_PREFIX(_dispatch_stub_31) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_32) + .type GL_PREFIX(_dispatch_stub_32), @function + HIDDEN(GL_PREFIX(_dispatch_stub_32)) +GL_PREFIX(_dispatch_stub_32): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 256(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + call _x86_64_get_dispatch@PLT + popq %rdi + movq 256(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 256(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + call _glapi_get_dispatch + popq %rdi + movq 256(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_32), .-GL_PREFIX(_dispatch_stub_32) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_33) + .type GL_PREFIX(_dispatch_stub_33), @function + HIDDEN(GL_PREFIX(_dispatch_stub_33)) +GL_PREFIX(_dispatch_stub_33): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 264(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rdx + pushq %rcx + pushq %rbp + call _x86_64_get_dispatch@PLT + popq %rbp + popq %rcx + popq %rdx + popq %rsi + popq %rdi + movq 264(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 264(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rdx + pushq %rcx + pushq %rbp + call _glapi_get_dispatch + popq %rbp + popq %rcx + popq %rdx + popq %rsi + popq %rdi + movq 264(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_33), .-GL_PREFIX(_dispatch_stub_33) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_34) + .type GL_PREFIX(_dispatch_stub_34), @function + HIDDEN(GL_PREFIX(_dispatch_stub_34)) +GL_PREFIX(_dispatch_stub_34): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 272(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + call _x86_64_get_dispatch@PLT + popq %rdi + movq 272(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 272(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + call _glapi_get_dispatch + popq %rdi + movq 272(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_34), .-GL_PREFIX(_dispatch_stub_34) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_35) + .type GL_PREFIX(_dispatch_stub_35), @function + HIDDEN(GL_PREFIX(_dispatch_stub_35)) +GL_PREFIX(_dispatch_stub_35): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 280(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rdx + pushq %rcx + pushq %rbp + call _x86_64_get_dispatch@PLT + popq %rbp + popq %rcx + popq %rdx + popq %rsi + popq %rdi + movq 280(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 280(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rdx + pushq %rcx + pushq %rbp + call _glapi_get_dispatch + popq %rbp + popq %rcx + popq %rdx + popq %rsi + popq %rdi + movq 280(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_35), .-GL_PREFIX(_dispatch_stub_35) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_36) + .type GL_PREFIX(_dispatch_stub_36), @function + HIDDEN(GL_PREFIX(_dispatch_stub_36)) +GL_PREFIX(_dispatch_stub_36): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 288(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + call _x86_64_get_dispatch@PLT + popq %rdi + movq 288(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 288(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + call _glapi_get_dispatch + popq %rdi + movq 288(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_36), .-GL_PREFIX(_dispatch_stub_36) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_37) + .type GL_PREFIX(_dispatch_stub_37), @function + HIDDEN(GL_PREFIX(_dispatch_stub_37)) +GL_PREFIX(_dispatch_stub_37): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 296(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rdx + pushq %rcx + pushq %rbp + call _x86_64_get_dispatch@PLT + popq %rbp + popq %rcx + popq %rdx + popq %rsi + popq %rdi + movq 296(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 296(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rdx + pushq %rcx + pushq %rbp + call _glapi_get_dispatch + popq %rbp + popq %rcx + popq %rdx + popq %rsi + popq %rdi + movq 296(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_37), .-GL_PREFIX(_dispatch_stub_37) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_38) + .type GL_PREFIX(_dispatch_stub_38), @function + HIDDEN(GL_PREFIX(_dispatch_stub_38)) +GL_PREFIX(_dispatch_stub_38): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 304(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + call _x86_64_get_dispatch@PLT + popq %rdi + movq 304(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 304(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + call _glapi_get_dispatch + popq %rdi + movq 304(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_38), .-GL_PREFIX(_dispatch_stub_38) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_39) + .type GL_PREFIX(_dispatch_stub_39), @function + HIDDEN(GL_PREFIX(_dispatch_stub_39)) +GL_PREFIX(_dispatch_stub_39): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 312(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rdx + pushq %rcx + pushq %rbp + call _x86_64_get_dispatch@PLT + popq %rbp + popq %rcx + popq %rdx + popq %rsi + popq %rdi + movq 312(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 312(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rdx + pushq %rcx + pushq %rbp + call _glapi_get_dispatch + popq %rbp + popq %rcx + popq %rdx + popq %rsi + popq %rdi + movq 312(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_39), .-GL_PREFIX(_dispatch_stub_39) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_40) + .type GL_PREFIX(_dispatch_stub_40), @function + HIDDEN(GL_PREFIX(_dispatch_stub_40)) +GL_PREFIX(_dispatch_stub_40): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 320(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + call _x86_64_get_dispatch@PLT + popq %rdi + movq 320(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 320(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + call _glapi_get_dispatch + popq %rdi + movq 320(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_40), .-GL_PREFIX(_dispatch_stub_40) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_41) + .type GL_PREFIX(_dispatch_stub_41), @function + HIDDEN(GL_PREFIX(_dispatch_stub_41)) +GL_PREFIX(_dispatch_stub_41): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 328(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + call _x86_64_get_dispatch@PLT + popq %rdi + movq 328(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 328(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + call _glapi_get_dispatch + popq %rdi + movq 328(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_41), .-GL_PREFIX(_dispatch_stub_41) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_42) + .type GL_PREFIX(_dispatch_stub_42), @function + HIDDEN(GL_PREFIX(_dispatch_stub_42)) +GL_PREFIX(_dispatch_stub_42): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 336(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + call _x86_64_get_dispatch@PLT + popq %rdi + movq 336(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 336(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + call _glapi_get_dispatch + popq %rdi + movq 336(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_42), .-GL_PREFIX(_dispatch_stub_42) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_43) + .type GL_PREFIX(_dispatch_stub_43), @function + HIDDEN(GL_PREFIX(_dispatch_stub_43)) +GL_PREFIX(_dispatch_stub_43): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 344(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rbp + call _x86_64_get_dispatch@PLT + popq %rbp + movq 344(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 344(%rax), %r11 + jmp *%r11 +1: + pushq %rbp + call _glapi_get_dispatch + popq %rbp + movq 344(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_43), .-GL_PREFIX(_dispatch_stub_43) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_44) + .type GL_PREFIX(_dispatch_stub_44), @function + HIDDEN(GL_PREFIX(_dispatch_stub_44)) +GL_PREFIX(_dispatch_stub_44): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 352(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + subq $8, %rsp + movq %xmm0, (%rsp) + call _x86_64_get_dispatch@PLT + movq (%rsp), %xmm0 + addq $8, %rsp + movq 352(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 352(%rax), %r11 + jmp *%r11 +1: + subq $8, %rsp + movq %xmm0, (%rsp) + call _glapi_get_dispatch + movq (%rsp), %xmm0 + addq $8, %rsp + movq 352(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_44), .-GL_PREFIX(_dispatch_stub_44) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_45) + .type GL_PREFIX(_dispatch_stub_45), @function + HIDDEN(GL_PREFIX(_dispatch_stub_45)) +GL_PREFIX(_dispatch_stub_45): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 360(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + call _x86_64_get_dispatch@PLT + popq %rdi + movq 360(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 360(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + call _glapi_get_dispatch + popq %rdi + movq 360(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_45), .-GL_PREFIX(_dispatch_stub_45) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_46) + .type GL_PREFIX(_dispatch_stub_46), @function + HIDDEN(GL_PREFIX(_dispatch_stub_46)) +GL_PREFIX(_dispatch_stub_46): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 368(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + subq $8, %rsp + movq %xmm0, (%rsp) + call _x86_64_get_dispatch@PLT + movq (%rsp), %xmm0 + addq $8, %rsp + movq 368(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 368(%rax), %r11 + jmp *%r11 +1: + subq $8, %rsp + movq %xmm0, (%rsp) + call _glapi_get_dispatch + movq (%rsp), %xmm0 + addq $8, %rsp + movq 368(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_46), .-GL_PREFIX(_dispatch_stub_46) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_47) + .type GL_PREFIX(_dispatch_stub_47), @function + HIDDEN(GL_PREFIX(_dispatch_stub_47)) +GL_PREFIX(_dispatch_stub_47): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 376(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + call _x86_64_get_dispatch@PLT + popq %rdi + movq 376(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 376(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + call _glapi_get_dispatch + popq %rdi + movq 376(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_47), .-GL_PREFIX(_dispatch_stub_47) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_48) + .type GL_PREFIX(_dispatch_stub_48), @function + HIDDEN(GL_PREFIX(_dispatch_stub_48)) +GL_PREFIX(_dispatch_stub_48): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 384(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + call _x86_64_get_dispatch@PLT + popq %rdi + movq 384(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 384(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + call _glapi_get_dispatch + popq %rdi + movq 384(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_48), .-GL_PREFIX(_dispatch_stub_48) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_49) + .type GL_PREFIX(_dispatch_stub_49), @function + HIDDEN(GL_PREFIX(_dispatch_stub_49)) +GL_PREFIX(_dispatch_stub_49): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 392(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + call _x86_64_get_dispatch@PLT + popq %rdi + movq 392(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 392(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + call _glapi_get_dispatch + popq %rdi + movq 392(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_49), .-GL_PREFIX(_dispatch_stub_49) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_50) + .type GL_PREFIX(_dispatch_stub_50), @function + HIDDEN(GL_PREFIX(_dispatch_stub_50)) +GL_PREFIX(_dispatch_stub_50): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 400(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + call _x86_64_get_dispatch@PLT + popq %rdi + movq 400(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 400(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + call _glapi_get_dispatch + popq %rdi + movq 400(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_50), .-GL_PREFIX(_dispatch_stub_50) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_51) + .type GL_PREFIX(_dispatch_stub_51), @function + HIDDEN(GL_PREFIX(_dispatch_stub_51)) +GL_PREFIX(_dispatch_stub_51): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 408(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + call _x86_64_get_dispatch@PLT + popq %rdi + movq 408(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 408(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + call _glapi_get_dispatch + popq %rdi + movq 408(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_51), .-GL_PREFIX(_dispatch_stub_51) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_52) + .type GL_PREFIX(_dispatch_stub_52), @function + HIDDEN(GL_PREFIX(_dispatch_stub_52)) +GL_PREFIX(_dispatch_stub_52): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 416(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rdx + call _x86_64_get_dispatch@PLT + popq %rdx + popq %rsi + popq %rdi + movq 416(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 416(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rdx + call _glapi_get_dispatch + popq %rdx + popq %rsi + popq %rdi + movq 416(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_52), .-GL_PREFIX(_dispatch_stub_52) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_53) + .type GL_PREFIX(_dispatch_stub_53), @function + HIDDEN(GL_PREFIX(_dispatch_stub_53)) +GL_PREFIX(_dispatch_stub_53): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 424(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + call _x86_64_get_dispatch@PLT + popq %rdi + movq 424(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 424(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + call _glapi_get_dispatch + popq %rdi + movq 424(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_53), .-GL_PREFIX(_dispatch_stub_53) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_54) + .type GL_PREFIX(_dispatch_stub_54), @function + HIDDEN(GL_PREFIX(_dispatch_stub_54)) +GL_PREFIX(_dispatch_stub_54): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 432(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + subq $24, %rsp + movq %xmm0, (%rsp) + movq %xmm1, 8(%rsp) + movq %xmm2, 16(%rsp) + call _x86_64_get_dispatch@PLT + movq 16(%rsp), %xmm2 + movq 8(%rsp), %xmm1 + movq (%rsp), %xmm0 + addq $24, %rsp + movq 432(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 432(%rax), %r11 + jmp *%r11 +1: + subq $24, %rsp + movq %xmm0, (%rsp) + movq %xmm1, 8(%rsp) + movq %xmm2, 16(%rsp) + call _glapi_get_dispatch + movq 16(%rsp), %xmm2 + movq 8(%rsp), %xmm1 + movq (%rsp), %xmm0 + addq $24, %rsp + movq 432(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_54), .-GL_PREFIX(_dispatch_stub_54) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_55) + .type GL_PREFIX(_dispatch_stub_55), @function + HIDDEN(GL_PREFIX(_dispatch_stub_55)) +GL_PREFIX(_dispatch_stub_55): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 440(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + call _x86_64_get_dispatch@PLT + popq %rdi + movq 440(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 440(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + call _glapi_get_dispatch + popq %rdi + movq 440(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_55), .-GL_PREFIX(_dispatch_stub_55) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_56) + .type GL_PREFIX(_dispatch_stub_56), @function + HIDDEN(GL_PREFIX(_dispatch_stub_56)) +GL_PREFIX(_dispatch_stub_56): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 448(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + subq $24, %rsp + movq %xmm0, (%rsp) + movq %xmm1, 8(%rsp) + movq %xmm2, 16(%rsp) + call _x86_64_get_dispatch@PLT + movq 16(%rsp), %xmm2 + movq 8(%rsp), %xmm1 + movq (%rsp), %xmm0 + addq $24, %rsp + movq 448(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 448(%rax), %r11 + jmp *%r11 +1: + subq $24, %rsp + movq %xmm0, (%rsp) + movq %xmm1, 8(%rsp) + movq %xmm2, 16(%rsp) + call _glapi_get_dispatch + movq 16(%rsp), %xmm2 + movq 8(%rsp), %xmm1 + movq (%rsp), %xmm0 + addq $24, %rsp + movq 448(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_56), .-GL_PREFIX(_dispatch_stub_56) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_57) + .type GL_PREFIX(_dispatch_stub_57), @function + HIDDEN(GL_PREFIX(_dispatch_stub_57)) +GL_PREFIX(_dispatch_stub_57): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 456(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + call _x86_64_get_dispatch@PLT + popq %rdi + movq 456(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 456(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + call _glapi_get_dispatch + popq %rdi + movq 456(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_57), .-GL_PREFIX(_dispatch_stub_57) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_58) + .type GL_PREFIX(_dispatch_stub_58), @function + HIDDEN(GL_PREFIX(_dispatch_stub_58)) +GL_PREFIX(_dispatch_stub_58): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 464(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rdx + call _x86_64_get_dispatch@PLT + popq %rdx + popq %rsi + popq %rdi + movq 464(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 464(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rdx + call _glapi_get_dispatch + popq %rdx + popq %rsi + popq %rdi + movq 464(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_58), .-GL_PREFIX(_dispatch_stub_58) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_59) + .type GL_PREFIX(_dispatch_stub_59), @function + HIDDEN(GL_PREFIX(_dispatch_stub_59)) +GL_PREFIX(_dispatch_stub_59): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 472(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + call _x86_64_get_dispatch@PLT + popq %rdi + movq 472(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 472(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + call _glapi_get_dispatch + popq %rdi + movq 472(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_59), .-GL_PREFIX(_dispatch_stub_59) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_60) + .type GL_PREFIX(_dispatch_stub_60), @function + HIDDEN(GL_PREFIX(_dispatch_stub_60)) +GL_PREFIX(_dispatch_stub_60): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 480(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rdx + call _x86_64_get_dispatch@PLT + popq %rdx + popq %rsi + popq %rdi + movq 480(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 480(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rdx + call _glapi_get_dispatch + popq %rdx + popq %rsi + popq %rdi + movq 480(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_60), .-GL_PREFIX(_dispatch_stub_60) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_61) + .type GL_PREFIX(_dispatch_stub_61), @function + HIDDEN(GL_PREFIX(_dispatch_stub_61)) +GL_PREFIX(_dispatch_stub_61): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 488(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + call _x86_64_get_dispatch@PLT + popq %rdi + movq 488(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 488(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + call _glapi_get_dispatch + popq %rdi + movq 488(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_61), .-GL_PREFIX(_dispatch_stub_61) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_62) + .type GL_PREFIX(_dispatch_stub_62), @function + HIDDEN(GL_PREFIX(_dispatch_stub_62)) +GL_PREFIX(_dispatch_stub_62): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 496(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + subq $24, %rsp + movq %xmm0, (%rsp) + movq %xmm1, 8(%rsp) + call _x86_64_get_dispatch@PLT + movq 8(%rsp), %xmm1 + movq (%rsp), %xmm0 + addq $24, %rsp + movq 496(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 496(%rax), %r11 + jmp *%r11 +1: + subq $24, %rsp + movq %xmm0, (%rsp) + movq %xmm1, 8(%rsp) + call _glapi_get_dispatch + movq 8(%rsp), %xmm1 + movq (%rsp), %xmm0 + addq $24, %rsp + movq 496(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_62), .-GL_PREFIX(_dispatch_stub_62) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_63) + .type GL_PREFIX(_dispatch_stub_63), @function + HIDDEN(GL_PREFIX(_dispatch_stub_63)) +GL_PREFIX(_dispatch_stub_63): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 504(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + call _x86_64_get_dispatch@PLT + popq %rdi + movq 504(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 504(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + call _glapi_get_dispatch + popq %rdi + movq 504(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_63), .-GL_PREFIX(_dispatch_stub_63) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_64) + .type GL_PREFIX(_dispatch_stub_64), @function + HIDDEN(GL_PREFIX(_dispatch_stub_64)) +GL_PREFIX(_dispatch_stub_64): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 512(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + subq $24, %rsp + movq %xmm0, (%rsp) + movq %xmm1, 8(%rsp) + call _x86_64_get_dispatch@PLT + movq 8(%rsp), %xmm1 + movq (%rsp), %xmm0 + addq $24, %rsp + movq 512(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 512(%rax), %r11 + jmp *%r11 +1: + subq $24, %rsp + movq %xmm0, (%rsp) + movq %xmm1, 8(%rsp) + call _glapi_get_dispatch + movq 8(%rsp), %xmm1 + movq (%rsp), %xmm0 + addq $24, %rsp + movq 512(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_64), .-GL_PREFIX(_dispatch_stub_64) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_65) + .type GL_PREFIX(_dispatch_stub_65), @function + HIDDEN(GL_PREFIX(_dispatch_stub_65)) +GL_PREFIX(_dispatch_stub_65): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 520(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + call _x86_64_get_dispatch@PLT + popq %rdi + movq 520(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 520(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + call _glapi_get_dispatch + popq %rdi + movq 520(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_65), .-GL_PREFIX(_dispatch_stub_65) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_66) + .type GL_PREFIX(_dispatch_stub_66), @function + HIDDEN(GL_PREFIX(_dispatch_stub_66)) +GL_PREFIX(_dispatch_stub_66): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 528(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rbp + call _x86_64_get_dispatch@PLT + popq %rbp + popq %rsi + popq %rdi + movq 528(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 528(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rbp + call _glapi_get_dispatch + popq %rbp + popq %rsi + popq %rdi + movq 528(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_66), .-GL_PREFIX(_dispatch_stub_66) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_67) + .type GL_PREFIX(_dispatch_stub_67), @function + HIDDEN(GL_PREFIX(_dispatch_stub_67)) +GL_PREFIX(_dispatch_stub_67): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 536(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + call _x86_64_get_dispatch@PLT + popq %rdi + movq 536(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 536(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + call _glapi_get_dispatch + popq %rdi + movq 536(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_67), .-GL_PREFIX(_dispatch_stub_67) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_68) + .type GL_PREFIX(_dispatch_stub_68), @function + HIDDEN(GL_PREFIX(_dispatch_stub_68)) +GL_PREFIX(_dispatch_stub_68): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 544(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rbp + call _x86_64_get_dispatch@PLT + popq %rbp + popq %rsi + popq %rdi + movq 544(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 544(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rbp + call _glapi_get_dispatch + popq %rbp + popq %rsi + popq %rdi + movq 544(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_68), .-GL_PREFIX(_dispatch_stub_68) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_69) + .type GL_PREFIX(_dispatch_stub_69), @function + HIDDEN(GL_PREFIX(_dispatch_stub_69)) +GL_PREFIX(_dispatch_stub_69): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 552(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + call _x86_64_get_dispatch@PLT + popq %rdi + movq 552(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 552(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + call _glapi_get_dispatch + popq %rdi + movq 552(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_69), .-GL_PREFIX(_dispatch_stub_69) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_70) + .type GL_PREFIX(_dispatch_stub_70), @function + HIDDEN(GL_PREFIX(_dispatch_stub_70)) +GL_PREFIX(_dispatch_stub_70): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 560(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + subq $24, %rsp + movq %xmm0, (%rsp) + movq %xmm1, 8(%rsp) + movq %xmm2, 16(%rsp) + call _x86_64_get_dispatch@PLT + movq 16(%rsp), %xmm2 + movq 8(%rsp), %xmm1 + movq (%rsp), %xmm0 + addq $24, %rsp + movq 560(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 560(%rax), %r11 + jmp *%r11 +1: + subq $24, %rsp + movq %xmm0, (%rsp) + movq %xmm1, 8(%rsp) + movq %xmm2, 16(%rsp) + call _glapi_get_dispatch + movq 16(%rsp), %xmm2 + movq 8(%rsp), %xmm1 + movq (%rsp), %xmm0 + addq $24, %rsp + movq 560(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_70), .-GL_PREFIX(_dispatch_stub_70) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_71) + .type GL_PREFIX(_dispatch_stub_71), @function + HIDDEN(GL_PREFIX(_dispatch_stub_71)) +GL_PREFIX(_dispatch_stub_71): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 568(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + call _x86_64_get_dispatch@PLT + popq %rdi + movq 568(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 568(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + call _glapi_get_dispatch + popq %rdi + movq 568(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_71), .-GL_PREFIX(_dispatch_stub_71) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_72) + .type GL_PREFIX(_dispatch_stub_72), @function + HIDDEN(GL_PREFIX(_dispatch_stub_72)) +GL_PREFIX(_dispatch_stub_72): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 576(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + subq $24, %rsp + movq %xmm0, (%rsp) + movq %xmm1, 8(%rsp) + movq %xmm2, 16(%rsp) + call _x86_64_get_dispatch@PLT + movq 16(%rsp), %xmm2 + movq 8(%rsp), %xmm1 + movq (%rsp), %xmm0 + addq $24, %rsp + movq 576(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 576(%rax), %r11 + jmp *%r11 +1: + subq $24, %rsp + movq %xmm0, (%rsp) + movq %xmm1, 8(%rsp) + movq %xmm2, 16(%rsp) + call _glapi_get_dispatch + movq 16(%rsp), %xmm2 + movq 8(%rsp), %xmm1 + movq (%rsp), %xmm0 + addq $24, %rsp + movq 576(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_72), .-GL_PREFIX(_dispatch_stub_72) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_73) + .type GL_PREFIX(_dispatch_stub_73), @function + HIDDEN(GL_PREFIX(_dispatch_stub_73)) +GL_PREFIX(_dispatch_stub_73): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 584(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + call _x86_64_get_dispatch@PLT + popq %rdi + movq 584(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 584(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + call _glapi_get_dispatch + popq %rdi + movq 584(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_73), .-GL_PREFIX(_dispatch_stub_73) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_74) + .type GL_PREFIX(_dispatch_stub_74), @function + HIDDEN(GL_PREFIX(_dispatch_stub_74)) +GL_PREFIX(_dispatch_stub_74): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 592(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rdx + call _x86_64_get_dispatch@PLT + popq %rdx + popq %rsi + popq %rdi + movq 592(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 592(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rdx + call _glapi_get_dispatch + popq %rdx + popq %rsi + popq %rdi + movq 592(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_74), .-GL_PREFIX(_dispatch_stub_74) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_75) + .type GL_PREFIX(_dispatch_stub_75), @function + HIDDEN(GL_PREFIX(_dispatch_stub_75)) +GL_PREFIX(_dispatch_stub_75): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 600(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + call _x86_64_get_dispatch@PLT + popq %rdi + movq 600(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 600(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + call _glapi_get_dispatch + popq %rdi + movq 600(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_75), .-GL_PREFIX(_dispatch_stub_75) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_76) + .type GL_PREFIX(_dispatch_stub_76), @function + HIDDEN(GL_PREFIX(_dispatch_stub_76)) +GL_PREFIX(_dispatch_stub_76): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 608(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rdx + call _x86_64_get_dispatch@PLT + popq %rdx + popq %rsi + popq %rdi + movq 608(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 608(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rdx + call _glapi_get_dispatch + popq %rdx + popq %rsi + popq %rdi + movq 608(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_76), .-GL_PREFIX(_dispatch_stub_76) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_77) + .type GL_PREFIX(_dispatch_stub_77), @function + HIDDEN(GL_PREFIX(_dispatch_stub_77)) +GL_PREFIX(_dispatch_stub_77): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 616(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + call _x86_64_get_dispatch@PLT + popq %rdi + movq 616(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 616(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + call _glapi_get_dispatch + popq %rdi + movq 616(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_77), .-GL_PREFIX(_dispatch_stub_77) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_78) + .type GL_PREFIX(_dispatch_stub_78), @function + HIDDEN(GL_PREFIX(_dispatch_stub_78)) +GL_PREFIX(_dispatch_stub_78): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 624(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + subq $40, %rsp + movq %xmm0, (%rsp) + movq %xmm1, 8(%rsp) + movq %xmm2, 16(%rsp) + movq %xmm3, 24(%rsp) + call _x86_64_get_dispatch@PLT + movq 24(%rsp), %xmm3 + movq 16(%rsp), %xmm2 + movq 8(%rsp), %xmm1 + movq (%rsp), %xmm0 + addq $40, %rsp + movq 624(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 624(%rax), %r11 + jmp *%r11 +1: + subq $40, %rsp + movq %xmm0, (%rsp) + movq %xmm1, 8(%rsp) + movq %xmm2, 16(%rsp) + movq %xmm3, 24(%rsp) + call _glapi_get_dispatch + movq 24(%rsp), %xmm3 + movq 16(%rsp), %xmm2 + movq 8(%rsp), %xmm1 + movq (%rsp), %xmm0 + addq $40, %rsp + movq 624(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_78), .-GL_PREFIX(_dispatch_stub_78) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_79) + .type GL_PREFIX(_dispatch_stub_79), @function + HIDDEN(GL_PREFIX(_dispatch_stub_79)) +GL_PREFIX(_dispatch_stub_79): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 632(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + call _x86_64_get_dispatch@PLT + popq %rdi + movq 632(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 632(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + call _glapi_get_dispatch + popq %rdi + movq 632(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_79), .-GL_PREFIX(_dispatch_stub_79) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_80) + .type GL_PREFIX(_dispatch_stub_80), @function + HIDDEN(GL_PREFIX(_dispatch_stub_80)) +GL_PREFIX(_dispatch_stub_80): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 640(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + subq $40, %rsp + movq %xmm0, (%rsp) + movq %xmm1, 8(%rsp) + movq %xmm2, 16(%rsp) + movq %xmm3, 24(%rsp) + call _x86_64_get_dispatch@PLT + movq 24(%rsp), %xmm3 + movq 16(%rsp), %xmm2 + movq 8(%rsp), %xmm1 + movq (%rsp), %xmm0 + addq $40, %rsp + movq 640(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 640(%rax), %r11 + jmp *%r11 +1: + subq $40, %rsp + movq %xmm0, (%rsp) + movq %xmm1, 8(%rsp) + movq %xmm2, 16(%rsp) + movq %xmm3, 24(%rsp) + call _glapi_get_dispatch + movq 24(%rsp), %xmm3 + movq 16(%rsp), %xmm2 + movq 8(%rsp), %xmm1 + movq (%rsp), %xmm0 + addq $40, %rsp + movq 640(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_80), .-GL_PREFIX(_dispatch_stub_80) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_81) + .type GL_PREFIX(_dispatch_stub_81), @function + HIDDEN(GL_PREFIX(_dispatch_stub_81)) +GL_PREFIX(_dispatch_stub_81): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 648(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + call _x86_64_get_dispatch@PLT + popq %rdi + movq 648(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 648(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + call _glapi_get_dispatch + popq %rdi + movq 648(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_81), .-GL_PREFIX(_dispatch_stub_81) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_82) + .type GL_PREFIX(_dispatch_stub_82), @function + HIDDEN(GL_PREFIX(_dispatch_stub_82)) +GL_PREFIX(_dispatch_stub_82): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 656(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rdx + pushq %rcx + pushq %rbp + call _x86_64_get_dispatch@PLT + popq %rbp + popq %rcx + popq %rdx + popq %rsi + popq %rdi + movq 656(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 656(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rdx + pushq %rcx + pushq %rbp + call _glapi_get_dispatch + popq %rbp + popq %rcx + popq %rdx + popq %rsi + popq %rdi + movq 656(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_82), .-GL_PREFIX(_dispatch_stub_82) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_83) + .type GL_PREFIX(_dispatch_stub_83), @function + HIDDEN(GL_PREFIX(_dispatch_stub_83)) +GL_PREFIX(_dispatch_stub_83): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 664(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + call _x86_64_get_dispatch@PLT + popq %rdi + movq 664(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 664(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + call _glapi_get_dispatch + popq %rdi + movq 664(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_83), .-GL_PREFIX(_dispatch_stub_83) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_84) + .type GL_PREFIX(_dispatch_stub_84), @function + HIDDEN(GL_PREFIX(_dispatch_stub_84)) +GL_PREFIX(_dispatch_stub_84): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 672(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rdx + pushq %rcx + pushq %rbp + call _x86_64_get_dispatch@PLT + popq %rbp + popq %rcx + popq %rdx + popq %rsi + popq %rdi + movq 672(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 672(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rdx + pushq %rcx + pushq %rbp + call _glapi_get_dispatch + popq %rbp + popq %rcx + popq %rdx + popq %rsi + popq %rdi + movq 672(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_84), .-GL_PREFIX(_dispatch_stub_84) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_85) + .type GL_PREFIX(_dispatch_stub_85), @function + HIDDEN(GL_PREFIX(_dispatch_stub_85)) +GL_PREFIX(_dispatch_stub_85): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 680(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + call _x86_64_get_dispatch@PLT + popq %rdi + movq 680(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 680(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + call _glapi_get_dispatch + popq %rdi + movq 680(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_85), .-GL_PREFIX(_dispatch_stub_85) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_86) + .type GL_PREFIX(_dispatch_stub_86), @function + HIDDEN(GL_PREFIX(_dispatch_stub_86)) +GL_PREFIX(_dispatch_stub_86): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 688(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + subq $40, %rsp + movq %xmm0, (%rsp) + movq %xmm1, 8(%rsp) + movq %xmm2, 16(%rsp) + movq %xmm3, 24(%rsp) + call _x86_64_get_dispatch@PLT + movq 24(%rsp), %xmm3 + movq 16(%rsp), %xmm2 + movq 8(%rsp), %xmm1 + movq (%rsp), %xmm0 + addq $40, %rsp + movq 688(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 688(%rax), %r11 + jmp *%r11 +1: + subq $40, %rsp + movq %xmm0, (%rsp) + movq %xmm1, 8(%rsp) + movq %xmm2, 16(%rsp) + movq %xmm3, 24(%rsp) + call _glapi_get_dispatch + movq 24(%rsp), %xmm3 + movq 16(%rsp), %xmm2 + movq 8(%rsp), %xmm1 + movq (%rsp), %xmm0 + addq $40, %rsp + movq 688(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_86), .-GL_PREFIX(_dispatch_stub_86) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_87) + .type GL_PREFIX(_dispatch_stub_87), @function + HIDDEN(GL_PREFIX(_dispatch_stub_87)) +GL_PREFIX(_dispatch_stub_87): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 696(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rbp + call _x86_64_get_dispatch@PLT + popq %rbp + popq %rsi + popq %rdi + movq 696(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 696(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rbp + call _glapi_get_dispatch + popq %rbp + popq %rsi + popq %rdi + movq 696(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_87), .-GL_PREFIX(_dispatch_stub_87) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_88) + .type GL_PREFIX(_dispatch_stub_88), @function + HIDDEN(GL_PREFIX(_dispatch_stub_88)) +GL_PREFIX(_dispatch_stub_88): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 704(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + subq $40, %rsp + movq %xmm0, (%rsp) + movq %xmm1, 8(%rsp) + movq %xmm2, 16(%rsp) + movq %xmm3, 24(%rsp) + call _x86_64_get_dispatch@PLT + movq 24(%rsp), %xmm3 + movq 16(%rsp), %xmm2 + movq 8(%rsp), %xmm1 + movq (%rsp), %xmm0 + addq $40, %rsp + movq 704(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 704(%rax), %r11 + jmp *%r11 +1: + subq $40, %rsp + movq %xmm0, (%rsp) + movq %xmm1, 8(%rsp) + movq %xmm2, 16(%rsp) + movq %xmm3, 24(%rsp) + call _glapi_get_dispatch + movq 24(%rsp), %xmm3 + movq 16(%rsp), %xmm2 + movq 8(%rsp), %xmm1 + movq (%rsp), %xmm0 + addq $40, %rsp + movq 704(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_88), .-GL_PREFIX(_dispatch_stub_88) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_89) + .type GL_PREFIX(_dispatch_stub_89), @function + HIDDEN(GL_PREFIX(_dispatch_stub_89)) +GL_PREFIX(_dispatch_stub_89): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 712(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rbp + call _x86_64_get_dispatch@PLT + popq %rbp + popq %rsi + popq %rdi + movq 712(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 712(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rbp + call _glapi_get_dispatch + popq %rbp + popq %rsi + popq %rdi + movq 712(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_89), .-GL_PREFIX(_dispatch_stub_89) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_90) + .type GL_PREFIX(_dispatch_stub_90), @function + HIDDEN(GL_PREFIX(_dispatch_stub_90)) +GL_PREFIX(_dispatch_stub_90): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 720(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rdx + pushq %rcx + pushq %rbp + call _x86_64_get_dispatch@PLT + popq %rbp + popq %rcx + popq %rdx + popq %rsi + popq %rdi + movq 720(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 720(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rdx + pushq %rcx + pushq %rbp + call _glapi_get_dispatch + popq %rbp + popq %rcx + popq %rdx + popq %rsi + popq %rdi + movq 720(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_90), .-GL_PREFIX(_dispatch_stub_90) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_91) + .type GL_PREFIX(_dispatch_stub_91), @function + HIDDEN(GL_PREFIX(_dispatch_stub_91)) +GL_PREFIX(_dispatch_stub_91): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 728(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rbp + call _x86_64_get_dispatch@PLT + popq %rbp + popq %rsi + popq %rdi + movq 728(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 728(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rbp + call _glapi_get_dispatch + popq %rbp + popq %rsi + popq %rdi + movq 728(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_91), .-GL_PREFIX(_dispatch_stub_91) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_92) + .type GL_PREFIX(_dispatch_stub_92), @function + HIDDEN(GL_PREFIX(_dispatch_stub_92)) +GL_PREFIX(_dispatch_stub_92): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 736(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rdx + pushq %rcx + pushq %rbp + call _x86_64_get_dispatch@PLT + popq %rbp + popq %rcx + popq %rdx + popq %rsi + popq %rdi + movq 736(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 736(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rdx + pushq %rcx + pushq %rbp + call _glapi_get_dispatch + popq %rbp + popq %rcx + popq %rdx + popq %rsi + popq %rdi + movq 736(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_92), .-GL_PREFIX(_dispatch_stub_92) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_93) + .type GL_PREFIX(_dispatch_stub_93), @function + HIDDEN(GL_PREFIX(_dispatch_stub_93)) +GL_PREFIX(_dispatch_stub_93): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 744(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rbp + call _x86_64_get_dispatch@PLT + popq %rbp + popq %rsi + popq %rdi + movq 744(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 744(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rbp + call _glapi_get_dispatch + popq %rbp + popq %rsi + popq %rdi + movq 744(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_93), .-GL_PREFIX(_dispatch_stub_93) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_94) + .type GL_PREFIX(_dispatch_stub_94), @function + HIDDEN(GL_PREFIX(_dispatch_stub_94)) +GL_PREFIX(_dispatch_stub_94): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 752(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + subq $8, %rsp + movq %xmm0, (%rsp) + call _x86_64_get_dispatch@PLT + movq (%rsp), %xmm0 + addq $8, %rsp + movq 752(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 752(%rax), %r11 + jmp *%r11 +1: + subq $8, %rsp + movq %xmm0, (%rsp) + call _glapi_get_dispatch + movq (%rsp), %xmm0 + addq $8, %rsp + movq 752(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_94), .-GL_PREFIX(_dispatch_stub_94) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_95) + .type GL_PREFIX(_dispatch_stub_95), @function + HIDDEN(GL_PREFIX(_dispatch_stub_95)) +GL_PREFIX(_dispatch_stub_95): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 760(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + call _x86_64_get_dispatch@PLT + popq %rdi + movq 760(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 760(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + call _glapi_get_dispatch + popq %rdi + movq 760(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_95), .-GL_PREFIX(_dispatch_stub_95) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_96) + .type GL_PREFIX(_dispatch_stub_96), @function + HIDDEN(GL_PREFIX(_dispatch_stub_96)) +GL_PREFIX(_dispatch_stub_96): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 768(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + subq $8, %rsp + movq %xmm0, (%rsp) + call _x86_64_get_dispatch@PLT + movq (%rsp), %xmm0 + addq $8, %rsp + movq 768(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 768(%rax), %r11 + jmp *%r11 +1: + subq $8, %rsp + movq %xmm0, (%rsp) + call _glapi_get_dispatch + movq (%rsp), %xmm0 + addq $8, %rsp + movq 768(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_96), .-GL_PREFIX(_dispatch_stub_96) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_97) + .type GL_PREFIX(_dispatch_stub_97), @function + HIDDEN(GL_PREFIX(_dispatch_stub_97)) +GL_PREFIX(_dispatch_stub_97): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 776(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + call _x86_64_get_dispatch@PLT + popq %rdi + movq 776(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 776(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + call _glapi_get_dispatch + popq %rdi + movq 776(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_97), .-GL_PREFIX(_dispatch_stub_97) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_98) + .type GL_PREFIX(_dispatch_stub_98), @function + HIDDEN(GL_PREFIX(_dispatch_stub_98)) +GL_PREFIX(_dispatch_stub_98): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 784(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + call _x86_64_get_dispatch@PLT + popq %rdi + movq 784(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 784(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + call _glapi_get_dispatch + popq %rdi + movq 784(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_98), .-GL_PREFIX(_dispatch_stub_98) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_99) + .type GL_PREFIX(_dispatch_stub_99), @function + HIDDEN(GL_PREFIX(_dispatch_stub_99)) +GL_PREFIX(_dispatch_stub_99): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 792(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + call _x86_64_get_dispatch@PLT + popq %rdi + movq 792(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 792(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + call _glapi_get_dispatch + popq %rdi + movq 792(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_99), .-GL_PREFIX(_dispatch_stub_99) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_100) + .type GL_PREFIX(_dispatch_stub_100), @function + HIDDEN(GL_PREFIX(_dispatch_stub_100)) +GL_PREFIX(_dispatch_stub_100): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 800(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + call _x86_64_get_dispatch@PLT + popq %rdi + movq 800(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 800(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + call _glapi_get_dispatch + popq %rdi + movq 800(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_100), .-GL_PREFIX(_dispatch_stub_100) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_101) + .type GL_PREFIX(_dispatch_stub_101), @function + HIDDEN(GL_PREFIX(_dispatch_stub_101)) +GL_PREFIX(_dispatch_stub_101): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 808(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + call _x86_64_get_dispatch@PLT + popq %rdi + movq 808(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 808(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + call _glapi_get_dispatch + popq %rdi + movq 808(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_101), .-GL_PREFIX(_dispatch_stub_101) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_102) + .type GL_PREFIX(_dispatch_stub_102), @function + HIDDEN(GL_PREFIX(_dispatch_stub_102)) +GL_PREFIX(_dispatch_stub_102): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 816(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + subq $24, %rsp + movq %xmm0, (%rsp) + movq %xmm1, 8(%rsp) + call _x86_64_get_dispatch@PLT + movq 8(%rsp), %xmm1 + movq (%rsp), %xmm0 + addq $24, %rsp + movq 816(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 816(%rax), %r11 + jmp *%r11 +1: + subq $24, %rsp + movq %xmm0, (%rsp) + movq %xmm1, 8(%rsp) + call _glapi_get_dispatch + movq 8(%rsp), %xmm1 + movq (%rsp), %xmm0 + addq $24, %rsp + movq 816(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_102), .-GL_PREFIX(_dispatch_stub_102) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_103) + .type GL_PREFIX(_dispatch_stub_103), @function + HIDDEN(GL_PREFIX(_dispatch_stub_103)) +GL_PREFIX(_dispatch_stub_103): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 824(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + call _x86_64_get_dispatch@PLT + popq %rdi + movq 824(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 824(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + call _glapi_get_dispatch + popq %rdi + movq 824(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_103), .-GL_PREFIX(_dispatch_stub_103) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_104) + .type GL_PREFIX(_dispatch_stub_104), @function + HIDDEN(GL_PREFIX(_dispatch_stub_104)) +GL_PREFIX(_dispatch_stub_104): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 832(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + subq $24, %rsp + movq %xmm0, (%rsp) + movq %xmm1, 8(%rsp) + call _x86_64_get_dispatch@PLT + movq 8(%rsp), %xmm1 + movq (%rsp), %xmm0 + addq $24, %rsp + movq 832(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 832(%rax), %r11 + jmp *%r11 +1: + subq $24, %rsp + movq %xmm0, (%rsp) + movq %xmm1, 8(%rsp) + call _glapi_get_dispatch + movq 8(%rsp), %xmm1 + movq (%rsp), %xmm0 + addq $24, %rsp + movq 832(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_104), .-GL_PREFIX(_dispatch_stub_104) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_105) + .type GL_PREFIX(_dispatch_stub_105), @function + HIDDEN(GL_PREFIX(_dispatch_stub_105)) +GL_PREFIX(_dispatch_stub_105): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 840(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + call _x86_64_get_dispatch@PLT + popq %rdi + movq 840(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 840(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + call _glapi_get_dispatch + popq %rdi + movq 840(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_105), .-GL_PREFIX(_dispatch_stub_105) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_106) + .type GL_PREFIX(_dispatch_stub_106), @function + HIDDEN(GL_PREFIX(_dispatch_stub_106)) +GL_PREFIX(_dispatch_stub_106): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 848(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rbp + call _x86_64_get_dispatch@PLT + popq %rbp + popq %rsi + popq %rdi + movq 848(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 848(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rbp + call _glapi_get_dispatch + popq %rbp + popq %rsi + popq %rdi + movq 848(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_106), .-GL_PREFIX(_dispatch_stub_106) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_107) + .type GL_PREFIX(_dispatch_stub_107), @function + HIDDEN(GL_PREFIX(_dispatch_stub_107)) +GL_PREFIX(_dispatch_stub_107): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 856(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + call _x86_64_get_dispatch@PLT + popq %rdi + movq 856(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 856(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + call _glapi_get_dispatch + popq %rdi + movq 856(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_107), .-GL_PREFIX(_dispatch_stub_107) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_108) + .type GL_PREFIX(_dispatch_stub_108), @function + HIDDEN(GL_PREFIX(_dispatch_stub_108)) +GL_PREFIX(_dispatch_stub_108): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 864(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rbp + call _x86_64_get_dispatch@PLT + popq %rbp + popq %rsi + popq %rdi + movq 864(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 864(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rbp + call _glapi_get_dispatch + popq %rbp + popq %rsi + popq %rdi + movq 864(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_108), .-GL_PREFIX(_dispatch_stub_108) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_109) + .type GL_PREFIX(_dispatch_stub_109), @function + HIDDEN(GL_PREFIX(_dispatch_stub_109)) +GL_PREFIX(_dispatch_stub_109): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 872(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + call _x86_64_get_dispatch@PLT + popq %rdi + movq 872(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 872(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + call _glapi_get_dispatch + popq %rdi + movq 872(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_109), .-GL_PREFIX(_dispatch_stub_109) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_110) + .type GL_PREFIX(_dispatch_stub_110), @function + HIDDEN(GL_PREFIX(_dispatch_stub_110)) +GL_PREFIX(_dispatch_stub_110): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 880(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + subq $24, %rsp + movq %xmm0, (%rsp) + movq %xmm1, 8(%rsp) + movq %xmm2, 16(%rsp) + call _x86_64_get_dispatch@PLT + movq 16(%rsp), %xmm2 + movq 8(%rsp), %xmm1 + movq (%rsp), %xmm0 + addq $24, %rsp + movq 880(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 880(%rax), %r11 + jmp *%r11 +1: + subq $24, %rsp + movq %xmm0, (%rsp) + movq %xmm1, 8(%rsp) + movq %xmm2, 16(%rsp) + call _glapi_get_dispatch + movq 16(%rsp), %xmm2 + movq 8(%rsp), %xmm1 + movq (%rsp), %xmm0 + addq $24, %rsp + movq 880(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_110), .-GL_PREFIX(_dispatch_stub_110) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_111) + .type GL_PREFIX(_dispatch_stub_111), @function + HIDDEN(GL_PREFIX(_dispatch_stub_111)) +GL_PREFIX(_dispatch_stub_111): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 888(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + call _x86_64_get_dispatch@PLT + popq %rdi + movq 888(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 888(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + call _glapi_get_dispatch + popq %rdi + movq 888(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_111), .-GL_PREFIX(_dispatch_stub_111) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_112) + .type GL_PREFIX(_dispatch_stub_112), @function + HIDDEN(GL_PREFIX(_dispatch_stub_112)) +GL_PREFIX(_dispatch_stub_112): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 896(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + subq $24, %rsp + movq %xmm0, (%rsp) + movq %xmm1, 8(%rsp) + movq %xmm2, 16(%rsp) + call _x86_64_get_dispatch@PLT + movq 16(%rsp), %xmm2 + movq 8(%rsp), %xmm1 + movq (%rsp), %xmm0 + addq $24, %rsp + movq 896(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 896(%rax), %r11 + jmp *%r11 +1: + subq $24, %rsp + movq %xmm0, (%rsp) + movq %xmm1, 8(%rsp) + movq %xmm2, 16(%rsp) + call _glapi_get_dispatch + movq 16(%rsp), %xmm2 + movq 8(%rsp), %xmm1 + movq (%rsp), %xmm0 + addq $24, %rsp + movq 896(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_112), .-GL_PREFIX(_dispatch_stub_112) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_113) + .type GL_PREFIX(_dispatch_stub_113), @function + HIDDEN(GL_PREFIX(_dispatch_stub_113)) +GL_PREFIX(_dispatch_stub_113): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 904(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + call _x86_64_get_dispatch@PLT + popq %rdi + movq 904(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 904(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + call _glapi_get_dispatch + popq %rdi + movq 904(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_113), .-GL_PREFIX(_dispatch_stub_113) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_114) + .type GL_PREFIX(_dispatch_stub_114), @function + HIDDEN(GL_PREFIX(_dispatch_stub_114)) +GL_PREFIX(_dispatch_stub_114): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 912(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rdx + call _x86_64_get_dispatch@PLT + popq %rdx + popq %rsi + popq %rdi + movq 912(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 912(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rdx + call _glapi_get_dispatch + popq %rdx + popq %rsi + popq %rdi + movq 912(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_114), .-GL_PREFIX(_dispatch_stub_114) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_115) + .type GL_PREFIX(_dispatch_stub_115), @function + HIDDEN(GL_PREFIX(_dispatch_stub_115)) +GL_PREFIX(_dispatch_stub_115): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 920(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + call _x86_64_get_dispatch@PLT + popq %rdi + movq 920(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 920(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + call _glapi_get_dispatch + popq %rdi + movq 920(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_115), .-GL_PREFIX(_dispatch_stub_115) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_116) + .type GL_PREFIX(_dispatch_stub_116), @function + HIDDEN(GL_PREFIX(_dispatch_stub_116)) +GL_PREFIX(_dispatch_stub_116): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 928(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rdx + call _x86_64_get_dispatch@PLT + popq %rdx + popq %rsi + popq %rdi + movq 928(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 928(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rdx + call _glapi_get_dispatch + popq %rdx + popq %rsi + popq %rdi + movq 928(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_116), .-GL_PREFIX(_dispatch_stub_116) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_117) + .type GL_PREFIX(_dispatch_stub_117), @function + HIDDEN(GL_PREFIX(_dispatch_stub_117)) +GL_PREFIX(_dispatch_stub_117): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 936(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + call _x86_64_get_dispatch@PLT + popq %rdi + movq 936(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 936(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + call _glapi_get_dispatch + popq %rdi + movq 936(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_117), .-GL_PREFIX(_dispatch_stub_117) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_118) + .type GL_PREFIX(_dispatch_stub_118), @function + HIDDEN(GL_PREFIX(_dispatch_stub_118)) +GL_PREFIX(_dispatch_stub_118): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 944(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + subq $40, %rsp + movq %xmm0, (%rsp) + movq %xmm1, 8(%rsp) + movq %xmm2, 16(%rsp) + movq %xmm3, 24(%rsp) + call _x86_64_get_dispatch@PLT + movq 24(%rsp), %xmm3 + movq 16(%rsp), %xmm2 + movq 8(%rsp), %xmm1 + movq (%rsp), %xmm0 + addq $40, %rsp + movq 944(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 944(%rax), %r11 + jmp *%r11 +1: + subq $40, %rsp + movq %xmm0, (%rsp) + movq %xmm1, 8(%rsp) + movq %xmm2, 16(%rsp) + movq %xmm3, 24(%rsp) + call _glapi_get_dispatch + movq 24(%rsp), %xmm3 + movq 16(%rsp), %xmm2 + movq 8(%rsp), %xmm1 + movq (%rsp), %xmm0 + addq $40, %rsp + movq 944(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_118), .-GL_PREFIX(_dispatch_stub_118) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_119) + .type GL_PREFIX(_dispatch_stub_119), @function + HIDDEN(GL_PREFIX(_dispatch_stub_119)) +GL_PREFIX(_dispatch_stub_119): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 952(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + call _x86_64_get_dispatch@PLT + popq %rdi + movq 952(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 952(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + call _glapi_get_dispatch + popq %rdi + movq 952(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_119), .-GL_PREFIX(_dispatch_stub_119) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_120) + .type GL_PREFIX(_dispatch_stub_120), @function + HIDDEN(GL_PREFIX(_dispatch_stub_120)) +GL_PREFIX(_dispatch_stub_120): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 960(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + subq $40, %rsp + movq %xmm0, (%rsp) + movq %xmm1, 8(%rsp) + movq %xmm2, 16(%rsp) + movq %xmm3, 24(%rsp) + call _x86_64_get_dispatch@PLT + movq 24(%rsp), %xmm3 + movq 16(%rsp), %xmm2 + movq 8(%rsp), %xmm1 + movq (%rsp), %xmm0 + addq $40, %rsp + movq 960(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 960(%rax), %r11 + jmp *%r11 +1: + subq $40, %rsp + movq %xmm0, (%rsp) + movq %xmm1, 8(%rsp) + movq %xmm2, 16(%rsp) + movq %xmm3, 24(%rsp) + call _glapi_get_dispatch + movq 24(%rsp), %xmm3 + movq 16(%rsp), %xmm2 + movq 8(%rsp), %xmm1 + movq (%rsp), %xmm0 + addq $40, %rsp + movq 960(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_120), .-GL_PREFIX(_dispatch_stub_120) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_121) + .type GL_PREFIX(_dispatch_stub_121), @function + HIDDEN(GL_PREFIX(_dispatch_stub_121)) +GL_PREFIX(_dispatch_stub_121): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 968(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + call _x86_64_get_dispatch@PLT + popq %rdi + movq 968(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 968(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + call _glapi_get_dispatch + popq %rdi + movq 968(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_121), .-GL_PREFIX(_dispatch_stub_121) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_122) + .type GL_PREFIX(_dispatch_stub_122), @function + HIDDEN(GL_PREFIX(_dispatch_stub_122)) +GL_PREFIX(_dispatch_stub_122): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 976(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rdx + pushq %rcx + pushq %rbp + call _x86_64_get_dispatch@PLT + popq %rbp + popq %rcx + popq %rdx + popq %rsi + popq %rdi + movq 976(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 976(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rdx + pushq %rcx + pushq %rbp + call _glapi_get_dispatch + popq %rbp + popq %rcx + popq %rdx + popq %rsi + popq %rdi + movq 976(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_122), .-GL_PREFIX(_dispatch_stub_122) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_123) + .type GL_PREFIX(_dispatch_stub_123), @function + HIDDEN(GL_PREFIX(_dispatch_stub_123)) +GL_PREFIX(_dispatch_stub_123): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 984(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + call _x86_64_get_dispatch@PLT + popq %rdi + movq 984(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 984(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + call _glapi_get_dispatch + popq %rdi + movq 984(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_123), .-GL_PREFIX(_dispatch_stub_123) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_124) + .type GL_PREFIX(_dispatch_stub_124), @function + HIDDEN(GL_PREFIX(_dispatch_stub_124)) +GL_PREFIX(_dispatch_stub_124): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 992(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rdx + pushq %rcx + pushq %rbp + call _x86_64_get_dispatch@PLT + popq %rbp + popq %rcx + popq %rdx + popq %rsi + popq %rdi + movq 992(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 992(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rdx + pushq %rcx + pushq %rbp + call _glapi_get_dispatch + popq %rbp + popq %rcx + popq %rdx + popq %rsi + popq %rdi + movq 992(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_124), .-GL_PREFIX(_dispatch_stub_124) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_125) + .type GL_PREFIX(_dispatch_stub_125), @function + HIDDEN(GL_PREFIX(_dispatch_stub_125)) +GL_PREFIX(_dispatch_stub_125): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 1000(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + call _x86_64_get_dispatch@PLT + popq %rdi + movq 1000(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 1000(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + call _glapi_get_dispatch + popq %rdi + movq 1000(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_125), .-GL_PREFIX(_dispatch_stub_125) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_126) + .type GL_PREFIX(_dispatch_stub_126), @function + HIDDEN(GL_PREFIX(_dispatch_stub_126)) +GL_PREFIX(_dispatch_stub_126): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 1008(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + subq $24, %rsp + movq %xmm0, (%rsp) + movq %xmm1, 8(%rsp) + call _x86_64_get_dispatch@PLT + movq 8(%rsp), %xmm1 + movq (%rsp), %xmm0 + addq $24, %rsp + movq 1008(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 1008(%rax), %r11 + jmp *%r11 +1: + subq $24, %rsp + movq %xmm0, (%rsp) + movq %xmm1, 8(%rsp) + call _glapi_get_dispatch + movq 8(%rsp), %xmm1 + movq (%rsp), %xmm0 + addq $24, %rsp + movq 1008(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_126), .-GL_PREFIX(_dispatch_stub_126) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_127) + .type GL_PREFIX(_dispatch_stub_127), @function + HIDDEN(GL_PREFIX(_dispatch_stub_127)) +GL_PREFIX(_dispatch_stub_127): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 1016(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + call _x86_64_get_dispatch@PLT + popq %rdi + movq 1016(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 1016(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + call _glapi_get_dispatch + popq %rdi + movq 1016(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_127), .-GL_PREFIX(_dispatch_stub_127) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_128) + .type GL_PREFIX(_dispatch_stub_128), @function + HIDDEN(GL_PREFIX(_dispatch_stub_128)) +GL_PREFIX(_dispatch_stub_128): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 1024(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + subq $24, %rsp + movq %xmm0, (%rsp) + movq %xmm1, 8(%rsp) + call _x86_64_get_dispatch@PLT + movq 8(%rsp), %xmm1 + movq (%rsp), %xmm0 + addq $24, %rsp + movq 1024(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 1024(%rax), %r11 + jmp *%r11 +1: + subq $24, %rsp + movq %xmm0, (%rsp) + movq %xmm1, 8(%rsp) + call _glapi_get_dispatch + movq 8(%rsp), %xmm1 + movq (%rsp), %xmm0 + addq $24, %rsp + movq 1024(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_128), .-GL_PREFIX(_dispatch_stub_128) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_129) + .type GL_PREFIX(_dispatch_stub_129), @function + HIDDEN(GL_PREFIX(_dispatch_stub_129)) +GL_PREFIX(_dispatch_stub_129): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 1032(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + call _x86_64_get_dispatch@PLT + popq %rdi + movq 1032(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 1032(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + call _glapi_get_dispatch + popq %rdi + movq 1032(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_129), .-GL_PREFIX(_dispatch_stub_129) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_130) + .type GL_PREFIX(_dispatch_stub_130), @function + HIDDEN(GL_PREFIX(_dispatch_stub_130)) +GL_PREFIX(_dispatch_stub_130): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 1040(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rbp + call _x86_64_get_dispatch@PLT + popq %rbp + popq %rsi + popq %rdi + movq 1040(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 1040(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rbp + call _glapi_get_dispatch + popq %rbp + popq %rsi + popq %rdi + movq 1040(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_130), .-GL_PREFIX(_dispatch_stub_130) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_131) + .type GL_PREFIX(_dispatch_stub_131), @function + HIDDEN(GL_PREFIX(_dispatch_stub_131)) +GL_PREFIX(_dispatch_stub_131): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 1048(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + call _x86_64_get_dispatch@PLT + popq %rdi + movq 1048(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 1048(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + call _glapi_get_dispatch + popq %rdi + movq 1048(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_131), .-GL_PREFIX(_dispatch_stub_131) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_132) + .type GL_PREFIX(_dispatch_stub_132), @function + HIDDEN(GL_PREFIX(_dispatch_stub_132)) +GL_PREFIX(_dispatch_stub_132): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 1056(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rbp + call _x86_64_get_dispatch@PLT + popq %rbp + popq %rsi + popq %rdi + movq 1056(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 1056(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rbp + call _glapi_get_dispatch + popq %rbp + popq %rsi + popq %rdi + movq 1056(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_132), .-GL_PREFIX(_dispatch_stub_132) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_133) + .type GL_PREFIX(_dispatch_stub_133), @function + HIDDEN(GL_PREFIX(_dispatch_stub_133)) +GL_PREFIX(_dispatch_stub_133): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 1064(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + call _x86_64_get_dispatch@PLT + popq %rdi + movq 1064(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 1064(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + call _glapi_get_dispatch + popq %rdi + movq 1064(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_133), .-GL_PREFIX(_dispatch_stub_133) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_134) + .type GL_PREFIX(_dispatch_stub_134), @function + HIDDEN(GL_PREFIX(_dispatch_stub_134)) +GL_PREFIX(_dispatch_stub_134): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 1072(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + subq $24, %rsp + movq %xmm0, (%rsp) + movq %xmm1, 8(%rsp) + movq %xmm2, 16(%rsp) + call _x86_64_get_dispatch@PLT + movq 16(%rsp), %xmm2 + movq 8(%rsp), %xmm1 + movq (%rsp), %xmm0 + addq $24, %rsp + movq 1072(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 1072(%rax), %r11 + jmp *%r11 +1: + subq $24, %rsp + movq %xmm0, (%rsp) + movq %xmm1, 8(%rsp) + movq %xmm2, 16(%rsp) + call _glapi_get_dispatch + movq 16(%rsp), %xmm2 + movq 8(%rsp), %xmm1 + movq (%rsp), %xmm0 + addq $24, %rsp + movq 1072(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_134), .-GL_PREFIX(_dispatch_stub_134) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_135) + .type GL_PREFIX(_dispatch_stub_135), @function + HIDDEN(GL_PREFIX(_dispatch_stub_135)) +GL_PREFIX(_dispatch_stub_135): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 1080(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + call _x86_64_get_dispatch@PLT + popq %rdi + movq 1080(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 1080(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + call _glapi_get_dispatch + popq %rdi + movq 1080(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_135), .-GL_PREFIX(_dispatch_stub_135) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_136) + .type GL_PREFIX(_dispatch_stub_136), @function + HIDDEN(GL_PREFIX(_dispatch_stub_136)) +GL_PREFIX(_dispatch_stub_136): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 1088(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + subq $24, %rsp + movq %xmm0, (%rsp) + movq %xmm1, 8(%rsp) + movq %xmm2, 16(%rsp) + call _x86_64_get_dispatch@PLT + movq 16(%rsp), %xmm2 + movq 8(%rsp), %xmm1 + movq (%rsp), %xmm0 + addq $24, %rsp + movq 1088(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 1088(%rax), %r11 + jmp *%r11 +1: + subq $24, %rsp + movq %xmm0, (%rsp) + movq %xmm1, 8(%rsp) + movq %xmm2, 16(%rsp) + call _glapi_get_dispatch + movq 16(%rsp), %xmm2 + movq 8(%rsp), %xmm1 + movq (%rsp), %xmm0 + addq $24, %rsp + movq 1088(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_136), .-GL_PREFIX(_dispatch_stub_136) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_137) + .type GL_PREFIX(_dispatch_stub_137), @function + HIDDEN(GL_PREFIX(_dispatch_stub_137)) +GL_PREFIX(_dispatch_stub_137): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 1096(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + call _x86_64_get_dispatch@PLT + popq %rdi + movq 1096(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 1096(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + call _glapi_get_dispatch + popq %rdi + movq 1096(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_137), .-GL_PREFIX(_dispatch_stub_137) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_138) + .type GL_PREFIX(_dispatch_stub_138), @function + HIDDEN(GL_PREFIX(_dispatch_stub_138)) +GL_PREFIX(_dispatch_stub_138): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 1104(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rdx + call _x86_64_get_dispatch@PLT + popq %rdx + popq %rsi + popq %rdi + movq 1104(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 1104(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rdx + call _glapi_get_dispatch + popq %rdx + popq %rsi + popq %rdi + movq 1104(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_138), .-GL_PREFIX(_dispatch_stub_138) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_139) + .type GL_PREFIX(_dispatch_stub_139), @function + HIDDEN(GL_PREFIX(_dispatch_stub_139)) +GL_PREFIX(_dispatch_stub_139): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 1112(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + call _x86_64_get_dispatch@PLT + popq %rdi + movq 1112(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 1112(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + call _glapi_get_dispatch + popq %rdi + movq 1112(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_139), .-GL_PREFIX(_dispatch_stub_139) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_140) + .type GL_PREFIX(_dispatch_stub_140), @function + HIDDEN(GL_PREFIX(_dispatch_stub_140)) +GL_PREFIX(_dispatch_stub_140): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 1120(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rdx + call _x86_64_get_dispatch@PLT + popq %rdx + popq %rsi + popq %rdi + movq 1120(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 1120(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rdx + call _glapi_get_dispatch + popq %rdx + popq %rsi + popq %rdi + movq 1120(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_140), .-GL_PREFIX(_dispatch_stub_140) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_141) + .type GL_PREFIX(_dispatch_stub_141), @function + HIDDEN(GL_PREFIX(_dispatch_stub_141)) +GL_PREFIX(_dispatch_stub_141): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 1128(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + call _x86_64_get_dispatch@PLT + popq %rdi + movq 1128(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 1128(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + call _glapi_get_dispatch + popq %rdi + movq 1128(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_141), .-GL_PREFIX(_dispatch_stub_141) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_142) + .type GL_PREFIX(_dispatch_stub_142), @function + HIDDEN(GL_PREFIX(_dispatch_stub_142)) +GL_PREFIX(_dispatch_stub_142): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 1136(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + subq $40, %rsp + movq %xmm0, (%rsp) + movq %xmm1, 8(%rsp) + movq %xmm2, 16(%rsp) + movq %xmm3, 24(%rsp) + call _x86_64_get_dispatch@PLT + movq 24(%rsp), %xmm3 + movq 16(%rsp), %xmm2 + movq 8(%rsp), %xmm1 + movq (%rsp), %xmm0 + addq $40, %rsp + movq 1136(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 1136(%rax), %r11 + jmp *%r11 +1: + subq $40, %rsp + movq %xmm0, (%rsp) + movq %xmm1, 8(%rsp) + movq %xmm2, 16(%rsp) + movq %xmm3, 24(%rsp) + call _glapi_get_dispatch + movq 24(%rsp), %xmm3 + movq 16(%rsp), %xmm2 + movq 8(%rsp), %xmm1 + movq (%rsp), %xmm0 + addq $40, %rsp + movq 1136(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_142), .-GL_PREFIX(_dispatch_stub_142) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_143) + .type GL_PREFIX(_dispatch_stub_143), @function + HIDDEN(GL_PREFIX(_dispatch_stub_143)) +GL_PREFIX(_dispatch_stub_143): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 1144(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + call _x86_64_get_dispatch@PLT + popq %rdi + movq 1144(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 1144(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + call _glapi_get_dispatch + popq %rdi + movq 1144(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_143), .-GL_PREFIX(_dispatch_stub_143) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_144) + .type GL_PREFIX(_dispatch_stub_144), @function + HIDDEN(GL_PREFIX(_dispatch_stub_144)) +GL_PREFIX(_dispatch_stub_144): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 1152(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + subq $40, %rsp + movq %xmm0, (%rsp) + movq %xmm1, 8(%rsp) + movq %xmm2, 16(%rsp) + movq %xmm3, 24(%rsp) + call _x86_64_get_dispatch@PLT + movq 24(%rsp), %xmm3 + movq 16(%rsp), %xmm2 + movq 8(%rsp), %xmm1 + movq (%rsp), %xmm0 + addq $40, %rsp + movq 1152(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 1152(%rax), %r11 + jmp *%r11 +1: + subq $40, %rsp + movq %xmm0, (%rsp) + movq %xmm1, 8(%rsp) + movq %xmm2, 16(%rsp) + movq %xmm3, 24(%rsp) + call _glapi_get_dispatch + movq 24(%rsp), %xmm3 + movq 16(%rsp), %xmm2 + movq 8(%rsp), %xmm1 + movq (%rsp), %xmm0 + addq $40, %rsp + movq 1152(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_144), .-GL_PREFIX(_dispatch_stub_144) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_145) + .type GL_PREFIX(_dispatch_stub_145), @function + HIDDEN(GL_PREFIX(_dispatch_stub_145)) +GL_PREFIX(_dispatch_stub_145): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 1160(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + call _x86_64_get_dispatch@PLT + popq %rdi + movq 1160(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 1160(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + call _glapi_get_dispatch + popq %rdi + movq 1160(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_145), .-GL_PREFIX(_dispatch_stub_145) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_146) + .type GL_PREFIX(_dispatch_stub_146), @function + HIDDEN(GL_PREFIX(_dispatch_stub_146)) +GL_PREFIX(_dispatch_stub_146): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 1168(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rdx + pushq %rcx + pushq %rbp + call _x86_64_get_dispatch@PLT + popq %rbp + popq %rcx + popq %rdx + popq %rsi + popq %rdi + movq 1168(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 1168(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rdx + pushq %rcx + pushq %rbp + call _glapi_get_dispatch + popq %rbp + popq %rcx + popq %rdx + popq %rsi + popq %rdi + movq 1168(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_146), .-GL_PREFIX(_dispatch_stub_146) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_147) + .type GL_PREFIX(_dispatch_stub_147), @function + HIDDEN(GL_PREFIX(_dispatch_stub_147)) +GL_PREFIX(_dispatch_stub_147): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 1176(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + call _x86_64_get_dispatch@PLT + popq %rdi + movq 1176(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 1176(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + call _glapi_get_dispatch + popq %rdi + movq 1176(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_147), .-GL_PREFIX(_dispatch_stub_147) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_148) + .type GL_PREFIX(_dispatch_stub_148), @function + HIDDEN(GL_PREFIX(_dispatch_stub_148)) +GL_PREFIX(_dispatch_stub_148): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 1184(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rdx + pushq %rcx + pushq %rbp + call _x86_64_get_dispatch@PLT + popq %rbp + popq %rcx + popq %rdx + popq %rsi + popq %rdi + movq 1184(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 1184(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rdx + pushq %rcx + pushq %rbp + call _glapi_get_dispatch + popq %rbp + popq %rcx + popq %rdx + popq %rsi + popq %rdi + movq 1184(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_148), .-GL_PREFIX(_dispatch_stub_148) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_149) + .type GL_PREFIX(_dispatch_stub_149), @function + HIDDEN(GL_PREFIX(_dispatch_stub_149)) +GL_PREFIX(_dispatch_stub_149): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 1192(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + call _x86_64_get_dispatch@PLT + popq %rdi + movq 1192(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 1192(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + call _glapi_get_dispatch + popq %rdi + movq 1192(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_149), .-GL_PREFIX(_dispatch_stub_149) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_150) + .type GL_PREFIX(_dispatch_stub_150), @function + HIDDEN(GL_PREFIX(_dispatch_stub_150)) +GL_PREFIX(_dispatch_stub_150): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 1200(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rbp + call _x86_64_get_dispatch@PLT + popq %rbp + popq %rsi + popq %rdi + movq 1200(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 1200(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rbp + call _glapi_get_dispatch + popq %rbp + popq %rsi + popq %rdi + movq 1200(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_150), .-GL_PREFIX(_dispatch_stub_150) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_151) + .type GL_PREFIX(_dispatch_stub_151), @function + HIDDEN(GL_PREFIX(_dispatch_stub_151)) +GL_PREFIX(_dispatch_stub_151): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 1208(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rbp + call _x86_64_get_dispatch@PLT + popq %rbp + popq %rsi + popq %rdi + movq 1208(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 1208(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rbp + call _glapi_get_dispatch + popq %rbp + popq %rsi + popq %rdi + movq 1208(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_151), .-GL_PREFIX(_dispatch_stub_151) + + .p2align 4,,15 + .globl GL_PREFIX(CullFace) + .type GL_PREFIX(CullFace), @function +GL_PREFIX(CullFace): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 1216(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + call _x86_64_get_dispatch@PLT + popq %rdi + movq 1216(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 1216(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + call _glapi_get_dispatch + popq %rdi + movq 1216(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(CullFace), .-GL_PREFIX(CullFace) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_153) + .type GL_PREFIX(_dispatch_stub_153), @function + HIDDEN(GL_PREFIX(_dispatch_stub_153)) +GL_PREFIX(_dispatch_stub_153): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 1224(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + subq $24, %rsp + movq %rdi, (%rsp) + movq %xmm0, 8(%rsp) + call _x86_64_get_dispatch@PLT + movq 8(%rsp), %xmm0 + movq (%rsp), %rdi + addq $24, %rsp + movq 1224(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 1224(%rax), %r11 + jmp *%r11 +1: + subq $24, %rsp + movq %rdi, (%rsp) + movq %xmm0, 8(%rsp) + call _glapi_get_dispatch + movq 8(%rsp), %xmm0 + movq (%rsp), %rdi + addq $24, %rsp + movq 1224(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_153), .-GL_PREFIX(_dispatch_stub_153) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_154) + .type GL_PREFIX(_dispatch_stub_154), @function + HIDDEN(GL_PREFIX(_dispatch_stub_154)) +GL_PREFIX(_dispatch_stub_154): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 1232(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rbp + call _x86_64_get_dispatch@PLT + popq %rbp + popq %rsi + popq %rdi + movq 1232(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 1232(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rbp + call _glapi_get_dispatch + popq %rbp + popq %rsi + popq %rdi + movq 1232(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_154), .-GL_PREFIX(_dispatch_stub_154) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_155) + .type GL_PREFIX(_dispatch_stub_155), @function + HIDDEN(GL_PREFIX(_dispatch_stub_155)) +GL_PREFIX(_dispatch_stub_155): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 1240(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rbp + call _x86_64_get_dispatch@PLT + popq %rbp + popq %rsi + popq %rdi + movq 1240(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 1240(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rbp + call _glapi_get_dispatch + popq %rbp + popq %rsi + popq %rdi + movq 1240(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_155), .-GL_PREFIX(_dispatch_stub_155) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_156) + .type GL_PREFIX(_dispatch_stub_156), @function + HIDDEN(GL_PREFIX(_dispatch_stub_156)) +GL_PREFIX(_dispatch_stub_156): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 1248(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rbp + call _x86_64_get_dispatch@PLT + popq %rbp + popq %rsi + popq %rdi + movq 1248(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 1248(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rbp + call _glapi_get_dispatch + popq %rbp + popq %rsi + popq %rdi + movq 1248(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_156), .-GL_PREFIX(_dispatch_stub_156) + + .p2align 4,,15 + .globl GL_PREFIX(FrontFace) + .type GL_PREFIX(FrontFace), @function +GL_PREFIX(FrontFace): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 1256(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + call _x86_64_get_dispatch@PLT + popq %rdi + movq 1256(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 1256(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + call _glapi_get_dispatch + popq %rdi + movq 1256(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(FrontFace), .-GL_PREFIX(FrontFace) + + .p2align 4,,15 + .globl GL_PREFIX(Hint) + .type GL_PREFIX(Hint), @function +GL_PREFIX(Hint): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 1264(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rbp + call _x86_64_get_dispatch@PLT + popq %rbp + popq %rsi + popq %rdi + movq 1264(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 1264(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rbp + call _glapi_get_dispatch + popq %rbp + popq %rsi + popq %rdi + movq 1264(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(Hint), .-GL_PREFIX(Hint) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_159) + .type GL_PREFIX(_dispatch_stub_159), @function + HIDDEN(GL_PREFIX(_dispatch_stub_159)) +GL_PREFIX(_dispatch_stub_159): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 1272(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + subq $24, %rsp + movq %rdi, (%rsp) + movq %rsi, 8(%rsp) + movq %xmm0, 16(%rsp) + call _x86_64_get_dispatch@PLT + movq 16(%rsp), %xmm0 + movq 8(%rsp), %rsi + movq (%rsp), %rdi + addq $24, %rsp + movq 1272(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 1272(%rax), %r11 + jmp *%r11 +1: + subq $24, %rsp + movq %rdi, (%rsp) + movq %rsi, 8(%rsp) + movq %xmm0, 16(%rsp) + call _glapi_get_dispatch + movq 16(%rsp), %xmm0 + movq 8(%rsp), %rsi + movq (%rsp), %rdi + addq $24, %rsp + movq 1272(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_159), .-GL_PREFIX(_dispatch_stub_159) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_160) + .type GL_PREFIX(_dispatch_stub_160), @function + HIDDEN(GL_PREFIX(_dispatch_stub_160)) +GL_PREFIX(_dispatch_stub_160): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 1280(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rdx + call _x86_64_get_dispatch@PLT + popq %rdx + popq %rsi + popq %rdi + movq 1280(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 1280(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rdx + call _glapi_get_dispatch + popq %rdx + popq %rsi + popq %rdi + movq 1280(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_160), .-GL_PREFIX(_dispatch_stub_160) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_161) + .type GL_PREFIX(_dispatch_stub_161), @function + HIDDEN(GL_PREFIX(_dispatch_stub_161)) +GL_PREFIX(_dispatch_stub_161): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 1288(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rdx + call _x86_64_get_dispatch@PLT + popq %rdx + popq %rsi + popq %rdi + movq 1288(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 1288(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rdx + call _glapi_get_dispatch + popq %rdx + popq %rsi + popq %rdi + movq 1288(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_161), .-GL_PREFIX(_dispatch_stub_161) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_162) + .type GL_PREFIX(_dispatch_stub_162), @function + HIDDEN(GL_PREFIX(_dispatch_stub_162)) +GL_PREFIX(_dispatch_stub_162): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 1296(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rdx + call _x86_64_get_dispatch@PLT + popq %rdx + popq %rsi + popq %rdi + movq 1296(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 1296(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rdx + call _glapi_get_dispatch + popq %rdx + popq %rsi + popq %rdi + movq 1296(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_162), .-GL_PREFIX(_dispatch_stub_162) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_163) + .type GL_PREFIX(_dispatch_stub_163), @function + HIDDEN(GL_PREFIX(_dispatch_stub_163)) +GL_PREFIX(_dispatch_stub_163): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 1304(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + subq $24, %rsp + movq %rdi, (%rsp) + movq %xmm0, 8(%rsp) + call _x86_64_get_dispatch@PLT + movq 8(%rsp), %xmm0 + movq (%rsp), %rdi + addq $24, %rsp + movq 1304(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 1304(%rax), %r11 + jmp *%r11 +1: + subq $24, %rsp + movq %rdi, (%rsp) + movq %xmm0, 8(%rsp) + call _glapi_get_dispatch + movq 8(%rsp), %xmm0 + movq (%rsp), %rdi + addq $24, %rsp + movq 1304(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_163), .-GL_PREFIX(_dispatch_stub_163) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_164) + .type GL_PREFIX(_dispatch_stub_164), @function + HIDDEN(GL_PREFIX(_dispatch_stub_164)) +GL_PREFIX(_dispatch_stub_164): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 1312(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rbp + call _x86_64_get_dispatch@PLT + popq %rbp + popq %rsi + popq %rdi + movq 1312(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 1312(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rbp + call _glapi_get_dispatch + popq %rbp + popq %rsi + popq %rdi + movq 1312(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_164), .-GL_PREFIX(_dispatch_stub_164) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_165) + .type GL_PREFIX(_dispatch_stub_165), @function + HIDDEN(GL_PREFIX(_dispatch_stub_165)) +GL_PREFIX(_dispatch_stub_165): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 1320(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rbp + call _x86_64_get_dispatch@PLT + popq %rbp + popq %rsi + popq %rdi + movq 1320(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 1320(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rbp + call _glapi_get_dispatch + popq %rbp + popq %rsi + popq %rdi + movq 1320(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_165), .-GL_PREFIX(_dispatch_stub_165) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_166) + .type GL_PREFIX(_dispatch_stub_166), @function + HIDDEN(GL_PREFIX(_dispatch_stub_166)) +GL_PREFIX(_dispatch_stub_166): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 1328(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rbp + call _x86_64_get_dispatch@PLT + popq %rbp + popq %rsi + popq %rdi + movq 1328(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 1328(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rbp + call _glapi_get_dispatch + popq %rbp + popq %rsi + popq %rdi + movq 1328(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_166), .-GL_PREFIX(_dispatch_stub_166) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_167) + .type GL_PREFIX(_dispatch_stub_167), @function + HIDDEN(GL_PREFIX(_dispatch_stub_167)) +GL_PREFIX(_dispatch_stub_167): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 1336(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rbp + call _x86_64_get_dispatch@PLT + popq %rbp + popq %rsi + popq %rdi + movq 1336(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 1336(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rbp + call _glapi_get_dispatch + popq %rbp + popq %rsi + popq %rdi + movq 1336(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_167), .-GL_PREFIX(_dispatch_stub_167) + + .p2align 4,,15 + .globl GL_PREFIX(LineWidth) + .type GL_PREFIX(LineWidth), @function +GL_PREFIX(LineWidth): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 1344(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + subq $8, %rsp + movq %xmm0, (%rsp) + call _x86_64_get_dispatch@PLT + movq (%rsp), %xmm0 + addq $8, %rsp + movq 1344(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 1344(%rax), %r11 + jmp *%r11 +1: + subq $8, %rsp + movq %xmm0, (%rsp) + call _glapi_get_dispatch + movq (%rsp), %xmm0 + addq $8, %rsp + movq 1344(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(LineWidth), .-GL_PREFIX(LineWidth) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_169) + .type GL_PREFIX(_dispatch_stub_169), @function + HIDDEN(GL_PREFIX(_dispatch_stub_169)) +GL_PREFIX(_dispatch_stub_169): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 1352(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + subq $24, %rsp + movq %rdi, (%rsp) + movq %rsi, 8(%rsp) + movq %xmm0, 16(%rsp) + call _x86_64_get_dispatch@PLT + movq 16(%rsp), %xmm0 + movq 8(%rsp), %rsi + movq (%rsp), %rdi + addq $24, %rsp + movq 1352(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 1352(%rax), %r11 + jmp *%r11 +1: + subq $24, %rsp + movq %rdi, (%rsp) + movq %rsi, 8(%rsp) + movq %xmm0, 16(%rsp) + call _glapi_get_dispatch + movq 16(%rsp), %xmm0 + movq 8(%rsp), %rsi + movq (%rsp), %rdi + addq $24, %rsp + movq 1352(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_169), .-GL_PREFIX(_dispatch_stub_169) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_170) + .type GL_PREFIX(_dispatch_stub_170), @function + HIDDEN(GL_PREFIX(_dispatch_stub_170)) +GL_PREFIX(_dispatch_stub_170): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 1360(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rdx + call _x86_64_get_dispatch@PLT + popq %rdx + popq %rsi + popq %rdi + movq 1360(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 1360(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rdx + call _glapi_get_dispatch + popq %rdx + popq %rsi + popq %rdi + movq 1360(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_170), .-GL_PREFIX(_dispatch_stub_170) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_171) + .type GL_PREFIX(_dispatch_stub_171), @function + HIDDEN(GL_PREFIX(_dispatch_stub_171)) +GL_PREFIX(_dispatch_stub_171): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 1368(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rdx + call _x86_64_get_dispatch@PLT + popq %rdx + popq %rsi + popq %rdi + movq 1368(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 1368(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rdx + call _glapi_get_dispatch + popq %rdx + popq %rsi + popq %rdi + movq 1368(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_171), .-GL_PREFIX(_dispatch_stub_171) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_172) + .type GL_PREFIX(_dispatch_stub_172), @function + HIDDEN(GL_PREFIX(_dispatch_stub_172)) +GL_PREFIX(_dispatch_stub_172): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 1376(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rdx + call _x86_64_get_dispatch@PLT + popq %rdx + popq %rsi + popq %rdi + movq 1376(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 1376(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rdx + call _glapi_get_dispatch + popq %rdx + popq %rsi + popq %rdi + movq 1376(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_172), .-GL_PREFIX(_dispatch_stub_172) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_173) + .type GL_PREFIX(_dispatch_stub_173), @function + HIDDEN(GL_PREFIX(_dispatch_stub_173)) +GL_PREFIX(_dispatch_stub_173): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 1384(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + subq $8, %rsp + movq %xmm0, (%rsp) + call _x86_64_get_dispatch@PLT + movq (%rsp), %xmm0 + addq $8, %rsp + movq 1384(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 1384(%rax), %r11 + jmp *%r11 +1: + subq $8, %rsp + movq %xmm0, (%rsp) + call _glapi_get_dispatch + movq (%rsp), %xmm0 + addq $8, %rsp + movq 1384(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_173), .-GL_PREFIX(_dispatch_stub_173) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_174) + .type GL_PREFIX(_dispatch_stub_174), @function + HIDDEN(GL_PREFIX(_dispatch_stub_174)) +GL_PREFIX(_dispatch_stub_174): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 1392(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rbp + call _x86_64_get_dispatch@PLT + popq %rbp + popq %rsi + popq %rdi + movq 1392(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 1392(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rbp + call _glapi_get_dispatch + popq %rbp + popq %rsi + popq %rdi + movq 1392(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_174), .-GL_PREFIX(_dispatch_stub_174) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_175) + .type GL_PREFIX(_dispatch_stub_175), @function + HIDDEN(GL_PREFIX(_dispatch_stub_175)) +GL_PREFIX(_dispatch_stub_175): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 1400(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + call _x86_64_get_dispatch@PLT + popq %rdi + movq 1400(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 1400(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + call _glapi_get_dispatch + popq %rdi + movq 1400(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_175), .-GL_PREFIX(_dispatch_stub_175) + + .p2align 4,,15 + .globl GL_PREFIX(Scissor) + .type GL_PREFIX(Scissor), @function +GL_PREFIX(Scissor): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 1408(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rdx + pushq %rcx + pushq %rbp + call _x86_64_get_dispatch@PLT + popq %rbp + popq %rcx + popq %rdx + popq %rsi + popq %rdi + movq 1408(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 1408(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rdx + pushq %rcx + pushq %rbp + call _glapi_get_dispatch + popq %rbp + popq %rcx + popq %rdx + popq %rsi + popq %rdi + movq 1408(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(Scissor), .-GL_PREFIX(Scissor) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_177) + .type GL_PREFIX(_dispatch_stub_177), @function + HIDDEN(GL_PREFIX(_dispatch_stub_177)) +GL_PREFIX(_dispatch_stub_177): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 1416(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + call _x86_64_get_dispatch@PLT + popq %rdi + movq 1416(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 1416(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + call _glapi_get_dispatch + popq %rdi + movq 1416(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_177), .-GL_PREFIX(_dispatch_stub_177) + + .p2align 4,,15 + .globl GL_PREFIX(TexParameterf) + .type GL_PREFIX(TexParameterf), @function +GL_PREFIX(TexParameterf): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 1424(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + subq $24, %rsp + movq %rdi, (%rsp) + movq %rsi, 8(%rsp) + movq %xmm0, 16(%rsp) + call _x86_64_get_dispatch@PLT + movq 16(%rsp), %xmm0 + movq 8(%rsp), %rsi + movq (%rsp), %rdi + addq $24, %rsp + movq 1424(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 1424(%rax), %r11 + jmp *%r11 +1: + subq $24, %rsp + movq %rdi, (%rsp) + movq %rsi, 8(%rsp) + movq %xmm0, 16(%rsp) + call _glapi_get_dispatch + movq 16(%rsp), %xmm0 + movq 8(%rsp), %rsi + movq (%rsp), %rdi + addq $24, %rsp + movq 1424(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(TexParameterf), .-GL_PREFIX(TexParameterf) + + .p2align 4,,15 + .globl GL_PREFIX(TexParameterfv) + .type GL_PREFIX(TexParameterfv), @function +GL_PREFIX(TexParameterfv): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 1432(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rdx + call _x86_64_get_dispatch@PLT + popq %rdx + popq %rsi + popq %rdi + movq 1432(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 1432(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rdx + call _glapi_get_dispatch + popq %rdx + popq %rsi + popq %rdi + movq 1432(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(TexParameterfv), .-GL_PREFIX(TexParameterfv) + + .p2align 4,,15 + .globl GL_PREFIX(TexParameteri) + .type GL_PREFIX(TexParameteri), @function +GL_PREFIX(TexParameteri): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 1440(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rdx + call _x86_64_get_dispatch@PLT + popq %rdx + popq %rsi + popq %rdi + movq 1440(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 1440(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rdx + call _glapi_get_dispatch + popq %rdx + popq %rsi + popq %rdi + movq 1440(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(TexParameteri), .-GL_PREFIX(TexParameteri) + + .p2align 4,,15 + .globl GL_PREFIX(TexParameteriv) + .type GL_PREFIX(TexParameteriv), @function +GL_PREFIX(TexParameteriv): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 1448(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rdx + call _x86_64_get_dispatch@PLT + popq %rdx + popq %rsi + popq %rdi + movq 1448(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 1448(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rdx + call _glapi_get_dispatch + popq %rdx + popq %rsi + popq %rdi + movq 1448(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(TexParameteriv), .-GL_PREFIX(TexParameteriv) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_182) + .type GL_PREFIX(_dispatch_stub_182), @function + HIDDEN(GL_PREFIX(_dispatch_stub_182)) +GL_PREFIX(_dispatch_stub_182): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 1456(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rdx + pushq %rcx + pushq %r8 + pushq %r9 + pushq %rbp + call _x86_64_get_dispatch@PLT + popq %rbp + popq %r9 + popq %r8 + popq %rcx + popq %rdx + popq %rsi + popq %rdi + movq 1456(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 1456(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rdx + pushq %rcx + pushq %r8 + pushq %r9 + pushq %rbp + call _glapi_get_dispatch + popq %rbp + popq %r9 + popq %r8 + popq %rcx + popq %rdx + popq %rsi + popq %rdi + movq 1456(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_182), .-GL_PREFIX(_dispatch_stub_182) + + .p2align 4,,15 + .globl GL_PREFIX(TexImage2D) + .type GL_PREFIX(TexImage2D), @function +GL_PREFIX(TexImage2D): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 1464(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rdx + pushq %rcx + pushq %r8 + pushq %r9 + pushq %rbp + call _x86_64_get_dispatch@PLT + popq %rbp + popq %r9 + popq %r8 + popq %rcx + popq %rdx + popq %rsi + popq %rdi + movq 1464(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 1464(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rdx + pushq %rcx + pushq %r8 + pushq %r9 + pushq %rbp + call _glapi_get_dispatch + popq %rbp + popq %r9 + popq %r8 + popq %rcx + popq %rdx + popq %rsi + popq %rdi + movq 1464(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(TexImage2D), .-GL_PREFIX(TexImage2D) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_184) + .type GL_PREFIX(_dispatch_stub_184), @function + HIDDEN(GL_PREFIX(_dispatch_stub_184)) +GL_PREFIX(_dispatch_stub_184): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 1472(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + subq $24, %rsp + movq %rdi, (%rsp) + movq %rsi, 8(%rsp) + movq %xmm0, 16(%rsp) + call _x86_64_get_dispatch@PLT + movq 16(%rsp), %xmm0 + movq 8(%rsp), %rsi + movq (%rsp), %rdi + addq $24, %rsp + movq 1472(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 1472(%rax), %r11 + jmp *%r11 +1: + subq $24, %rsp + movq %rdi, (%rsp) + movq %rsi, 8(%rsp) + movq %xmm0, 16(%rsp) + call _glapi_get_dispatch + movq 16(%rsp), %xmm0 + movq 8(%rsp), %rsi + movq (%rsp), %rdi + addq $24, %rsp + movq 1472(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_184), .-GL_PREFIX(_dispatch_stub_184) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_185) + .type GL_PREFIX(_dispatch_stub_185), @function + HIDDEN(GL_PREFIX(_dispatch_stub_185)) +GL_PREFIX(_dispatch_stub_185): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 1480(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rdx + call _x86_64_get_dispatch@PLT + popq %rdx + popq %rsi + popq %rdi + movq 1480(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 1480(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rdx + call _glapi_get_dispatch + popq %rdx + popq %rsi + popq %rdi + movq 1480(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_185), .-GL_PREFIX(_dispatch_stub_185) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_186) + .type GL_PREFIX(_dispatch_stub_186), @function + HIDDEN(GL_PREFIX(_dispatch_stub_186)) +GL_PREFIX(_dispatch_stub_186): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 1488(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rdx + call _x86_64_get_dispatch@PLT + popq %rdx + popq %rsi + popq %rdi + movq 1488(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 1488(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rdx + call _glapi_get_dispatch + popq %rdx + popq %rsi + popq %rdi + movq 1488(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_186), .-GL_PREFIX(_dispatch_stub_186) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_187) + .type GL_PREFIX(_dispatch_stub_187), @function + HIDDEN(GL_PREFIX(_dispatch_stub_187)) +GL_PREFIX(_dispatch_stub_187): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 1496(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rdx + call _x86_64_get_dispatch@PLT + popq %rdx + popq %rsi + popq %rdi + movq 1496(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 1496(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rdx + call _glapi_get_dispatch + popq %rdx + popq %rsi + popq %rdi + movq 1496(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_187), .-GL_PREFIX(_dispatch_stub_187) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_188) + .type GL_PREFIX(_dispatch_stub_188), @function + HIDDEN(GL_PREFIX(_dispatch_stub_188)) +GL_PREFIX(_dispatch_stub_188): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 1504(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + subq $24, %rsp + movq %rdi, (%rsp) + movq %rsi, 8(%rsp) + movq %xmm0, 16(%rsp) + call _x86_64_get_dispatch@PLT + movq 16(%rsp), %xmm0 + movq 8(%rsp), %rsi + movq (%rsp), %rdi + addq $24, %rsp + movq 1504(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 1504(%rax), %r11 + jmp *%r11 +1: + subq $24, %rsp + movq %rdi, (%rsp) + movq %rsi, 8(%rsp) + movq %xmm0, 16(%rsp) + call _glapi_get_dispatch + movq 16(%rsp), %xmm0 + movq 8(%rsp), %rsi + movq (%rsp), %rdi + addq $24, %rsp + movq 1504(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_188), .-GL_PREFIX(_dispatch_stub_188) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_189) + .type GL_PREFIX(_dispatch_stub_189), @function + HIDDEN(GL_PREFIX(_dispatch_stub_189)) +GL_PREFIX(_dispatch_stub_189): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 1512(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rdx + call _x86_64_get_dispatch@PLT + popq %rdx + popq %rsi + popq %rdi + movq 1512(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 1512(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rdx + call _glapi_get_dispatch + popq %rdx + popq %rsi + popq %rdi + movq 1512(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_189), .-GL_PREFIX(_dispatch_stub_189) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_190) + .type GL_PREFIX(_dispatch_stub_190), @function + HIDDEN(GL_PREFIX(_dispatch_stub_190)) +GL_PREFIX(_dispatch_stub_190): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 1520(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + subq $24, %rsp + movq %rdi, (%rsp) + movq %rsi, 8(%rsp) + movq %xmm0, 16(%rsp) + call _x86_64_get_dispatch@PLT + movq 16(%rsp), %xmm0 + movq 8(%rsp), %rsi + movq (%rsp), %rdi + addq $24, %rsp + movq 1520(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 1520(%rax), %r11 + jmp *%r11 +1: + subq $24, %rsp + movq %rdi, (%rsp) + movq %rsi, 8(%rsp) + movq %xmm0, 16(%rsp) + call _glapi_get_dispatch + movq 16(%rsp), %xmm0 + movq 8(%rsp), %rsi + movq (%rsp), %rdi + addq $24, %rsp + movq 1520(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_190), .-GL_PREFIX(_dispatch_stub_190) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_191) + .type GL_PREFIX(_dispatch_stub_191), @function + HIDDEN(GL_PREFIX(_dispatch_stub_191)) +GL_PREFIX(_dispatch_stub_191): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 1528(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rdx + call _x86_64_get_dispatch@PLT + popq %rdx + popq %rsi + popq %rdi + movq 1528(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 1528(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rdx + call _glapi_get_dispatch + popq %rdx + popq %rsi + popq %rdi + movq 1528(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_191), .-GL_PREFIX(_dispatch_stub_191) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_192) + .type GL_PREFIX(_dispatch_stub_192), @function + HIDDEN(GL_PREFIX(_dispatch_stub_192)) +GL_PREFIX(_dispatch_stub_192): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 1536(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rdx + call _x86_64_get_dispatch@PLT + popq %rdx + popq %rsi + popq %rdi + movq 1536(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 1536(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rdx + call _glapi_get_dispatch + popq %rdx + popq %rsi + popq %rdi + movq 1536(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_192), .-GL_PREFIX(_dispatch_stub_192) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_193) + .type GL_PREFIX(_dispatch_stub_193), @function + HIDDEN(GL_PREFIX(_dispatch_stub_193)) +GL_PREFIX(_dispatch_stub_193): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 1544(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rdx + call _x86_64_get_dispatch@PLT + popq %rdx + popq %rsi + popq %rdi + movq 1544(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 1544(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rdx + call _glapi_get_dispatch + popq %rdx + popq %rsi + popq %rdi + movq 1544(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_193), .-GL_PREFIX(_dispatch_stub_193) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_194) + .type GL_PREFIX(_dispatch_stub_194), @function + HIDDEN(GL_PREFIX(_dispatch_stub_194)) +GL_PREFIX(_dispatch_stub_194): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 1552(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rdx + call _x86_64_get_dispatch@PLT + popq %rdx + popq %rsi + popq %rdi + movq 1552(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 1552(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rdx + call _glapi_get_dispatch + popq %rdx + popq %rsi + popq %rdi + movq 1552(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_194), .-GL_PREFIX(_dispatch_stub_194) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_195) + .type GL_PREFIX(_dispatch_stub_195), @function + HIDDEN(GL_PREFIX(_dispatch_stub_195)) +GL_PREFIX(_dispatch_stub_195): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 1560(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rbp + call _x86_64_get_dispatch@PLT + popq %rbp + popq %rsi + popq %rdi + movq 1560(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 1560(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rbp + call _glapi_get_dispatch + popq %rbp + popq %rsi + popq %rdi + movq 1560(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_195), .-GL_PREFIX(_dispatch_stub_195) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_196) + .type GL_PREFIX(_dispatch_stub_196), @function + HIDDEN(GL_PREFIX(_dispatch_stub_196)) +GL_PREFIX(_dispatch_stub_196): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 1568(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + call _x86_64_get_dispatch@PLT + popq %rdi + movq 1568(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 1568(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + call _glapi_get_dispatch + popq %rdi + movq 1568(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_196), .-GL_PREFIX(_dispatch_stub_196) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_197) + .type GL_PREFIX(_dispatch_stub_197), @function + HIDDEN(GL_PREFIX(_dispatch_stub_197)) +GL_PREFIX(_dispatch_stub_197): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 1576(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rbp + call _x86_64_get_dispatch@PLT + popq %rbp + movq 1576(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 1576(%rax), %r11 + jmp *%r11 +1: + pushq %rbp + call _glapi_get_dispatch + popq %rbp + movq 1576(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_197), .-GL_PREFIX(_dispatch_stub_197) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_198) + .type GL_PREFIX(_dispatch_stub_198), @function + HIDDEN(GL_PREFIX(_dispatch_stub_198)) +GL_PREFIX(_dispatch_stub_198): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 1584(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + call _x86_64_get_dispatch@PLT + popq %rdi + movq 1584(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 1584(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + call _glapi_get_dispatch + popq %rdi + movq 1584(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_198), .-GL_PREFIX(_dispatch_stub_198) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_199) + .type GL_PREFIX(_dispatch_stub_199), @function + HIDDEN(GL_PREFIX(_dispatch_stub_199)) +GL_PREFIX(_dispatch_stub_199): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 1592(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + subq $8, %rsp + movq %xmm0, (%rsp) + call _x86_64_get_dispatch@PLT + movq (%rsp), %xmm0 + addq $8, %rsp + movq 1592(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 1592(%rax), %r11 + jmp *%r11 +1: + subq $8, %rsp + movq %xmm0, (%rsp) + call _glapi_get_dispatch + movq (%rsp), %xmm0 + addq $8, %rsp + movq 1592(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_199), .-GL_PREFIX(_dispatch_stub_199) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_200) + .type GL_PREFIX(_dispatch_stub_200), @function + HIDDEN(GL_PREFIX(_dispatch_stub_200)) +GL_PREFIX(_dispatch_stub_200): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 1600(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rbp + call _x86_64_get_dispatch@PLT + popq %rbp + movq 1600(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 1600(%rax), %r11 + jmp *%r11 +1: + pushq %rbp + call _glapi_get_dispatch + popq %rbp + movq 1600(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_200), .-GL_PREFIX(_dispatch_stub_200) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_201) + .type GL_PREFIX(_dispatch_stub_201), @function + HIDDEN(GL_PREFIX(_dispatch_stub_201)) +GL_PREFIX(_dispatch_stub_201): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 1608(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + call _x86_64_get_dispatch@PLT + popq %rdi + movq 1608(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 1608(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + call _glapi_get_dispatch + popq %rdi + movq 1608(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_201), .-GL_PREFIX(_dispatch_stub_201) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_202) + .type GL_PREFIX(_dispatch_stub_202), @function + HIDDEN(GL_PREFIX(_dispatch_stub_202)) +GL_PREFIX(_dispatch_stub_202): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 1616(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + call _x86_64_get_dispatch@PLT + popq %rdi + movq 1616(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 1616(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + call _glapi_get_dispatch + popq %rdi + movq 1616(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_202), .-GL_PREFIX(_dispatch_stub_202) + + .p2align 4,,15 + .globl GL_PREFIX(Clear) + .type GL_PREFIX(Clear), @function +GL_PREFIX(Clear): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 1624(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + call _x86_64_get_dispatch@PLT + popq %rdi + movq 1624(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 1624(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + call _glapi_get_dispatch + popq %rdi + movq 1624(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(Clear), .-GL_PREFIX(Clear) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_204) + .type GL_PREFIX(_dispatch_stub_204), @function + HIDDEN(GL_PREFIX(_dispatch_stub_204)) +GL_PREFIX(_dispatch_stub_204): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 1632(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + subq $40, %rsp + movq %xmm0, (%rsp) + movq %xmm1, 8(%rsp) + movq %xmm2, 16(%rsp) + movq %xmm3, 24(%rsp) + call _x86_64_get_dispatch@PLT + movq 24(%rsp), %xmm3 + movq 16(%rsp), %xmm2 + movq 8(%rsp), %xmm1 + movq (%rsp), %xmm0 + addq $40, %rsp + movq 1632(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 1632(%rax), %r11 + jmp *%r11 +1: + subq $40, %rsp + movq %xmm0, (%rsp) + movq %xmm1, 8(%rsp) + movq %xmm2, 16(%rsp) + movq %xmm3, 24(%rsp) + call _glapi_get_dispatch + movq 24(%rsp), %xmm3 + movq 16(%rsp), %xmm2 + movq 8(%rsp), %xmm1 + movq (%rsp), %xmm0 + addq $40, %rsp + movq 1632(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_204), .-GL_PREFIX(_dispatch_stub_204) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_205) + .type GL_PREFIX(_dispatch_stub_205), @function + HIDDEN(GL_PREFIX(_dispatch_stub_205)) +GL_PREFIX(_dispatch_stub_205): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 1640(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + subq $8, %rsp + movq %xmm0, (%rsp) + call _x86_64_get_dispatch@PLT + movq (%rsp), %xmm0 + addq $8, %rsp + movq 1640(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 1640(%rax), %r11 + jmp *%r11 +1: + subq $8, %rsp + movq %xmm0, (%rsp) + call _glapi_get_dispatch + movq (%rsp), %xmm0 + addq $8, %rsp + movq 1640(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_205), .-GL_PREFIX(_dispatch_stub_205) + + .p2align 4,,15 + .globl GL_PREFIX(ClearColor) + .type GL_PREFIX(ClearColor), @function +GL_PREFIX(ClearColor): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 1648(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rdx + pushq %rcx + pushq %rbp + call _x86_64_get_dispatch@PLT + popq %rbp + popq %rcx + popq %rdx + popq %rsi + popq %rdi + movq 1648(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 1648(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rdx + pushq %rcx + pushq %rbp + call _glapi_get_dispatch + popq %rbp + popq %rcx + popq %rdx + popq %rsi + popq %rdi + movq 1648(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(ClearColor), .-GL_PREFIX(ClearColor) + + .p2align 4,,15 + .globl GL_PREFIX(ClearStencil) + .type GL_PREFIX(ClearStencil), @function +GL_PREFIX(ClearStencil): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 1656(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + call _x86_64_get_dispatch@PLT + popq %rdi + movq 1656(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 1656(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + call _glapi_get_dispatch + popq %rdi + movq 1656(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(ClearStencil), .-GL_PREFIX(ClearStencil) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_208) + .type GL_PREFIX(_dispatch_stub_208), @function + HIDDEN(GL_PREFIX(_dispatch_stub_208)) +GL_PREFIX(_dispatch_stub_208): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 1664(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + call _x86_64_get_dispatch@PLT + popq %rdi + movq 1664(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 1664(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + call _glapi_get_dispatch + popq %rdi + movq 1664(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_208), .-GL_PREFIX(_dispatch_stub_208) + + .p2align 4,,15 + .globl GL_PREFIX(StencilMask) + .type GL_PREFIX(StencilMask), @function +GL_PREFIX(StencilMask): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 1672(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + call _x86_64_get_dispatch@PLT + popq %rdi + movq 1672(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 1672(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + call _glapi_get_dispatch + popq %rdi + movq 1672(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(StencilMask), .-GL_PREFIX(StencilMask) + + .p2align 4,,15 + .globl GL_PREFIX(ColorMask) + .type GL_PREFIX(ColorMask), @function +GL_PREFIX(ColorMask): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 1680(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rdx + pushq %rcx + pushq %rbp + call _x86_64_get_dispatch@PLT + popq %rbp + popq %rcx + popq %rdx + popq %rsi + popq %rdi + movq 1680(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 1680(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rdx + pushq %rcx + pushq %rbp + call _glapi_get_dispatch + popq %rbp + popq %rcx + popq %rdx + popq %rsi + popq %rdi + movq 1680(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(ColorMask), .-GL_PREFIX(ColorMask) + + .p2align 4,,15 + .globl GL_PREFIX(DepthMask) + .type GL_PREFIX(DepthMask), @function +GL_PREFIX(DepthMask): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 1688(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + call _x86_64_get_dispatch@PLT + popq %rdi + movq 1688(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 1688(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + call _glapi_get_dispatch + popq %rdi + movq 1688(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(DepthMask), .-GL_PREFIX(DepthMask) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_212) + .type GL_PREFIX(_dispatch_stub_212), @function + HIDDEN(GL_PREFIX(_dispatch_stub_212)) +GL_PREFIX(_dispatch_stub_212): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 1696(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + call _x86_64_get_dispatch@PLT + popq %rdi + movq 1696(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 1696(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + call _glapi_get_dispatch + popq %rdi + movq 1696(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_212), .-GL_PREFIX(_dispatch_stub_212) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_213) + .type GL_PREFIX(_dispatch_stub_213), @function + HIDDEN(GL_PREFIX(_dispatch_stub_213)) +GL_PREFIX(_dispatch_stub_213): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 1704(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + subq $24, %rsp + movq %rdi, (%rsp) + movq %xmm0, 8(%rsp) + call _x86_64_get_dispatch@PLT + movq 8(%rsp), %xmm0 + movq (%rsp), %rdi + addq $24, %rsp + movq 1704(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 1704(%rax), %r11 + jmp *%r11 +1: + subq $24, %rsp + movq %rdi, (%rsp) + movq %xmm0, 8(%rsp) + call _glapi_get_dispatch + movq 8(%rsp), %xmm0 + movq (%rsp), %rdi + addq $24, %rsp + movq 1704(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_213), .-GL_PREFIX(_dispatch_stub_213) + + .p2align 4,,15 + .globl GL_PREFIX(Disable) + .type GL_PREFIX(Disable), @function +GL_PREFIX(Disable): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 1712(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + call _x86_64_get_dispatch@PLT + popq %rdi + movq 1712(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 1712(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + call _glapi_get_dispatch + popq %rdi + movq 1712(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(Disable), .-GL_PREFIX(Disable) + + .p2align 4,,15 + .globl GL_PREFIX(Enable) + .type GL_PREFIX(Enable), @function +GL_PREFIX(Enable): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 1720(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + call _x86_64_get_dispatch@PLT + popq %rdi + movq 1720(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 1720(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + call _glapi_get_dispatch + popq %rdi + movq 1720(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(Enable), .-GL_PREFIX(Enable) + + .p2align 4,,15 + .globl GL_PREFIX(Finish) + .type GL_PREFIX(Finish), @function +GL_PREFIX(Finish): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 1728(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rbp + call _x86_64_get_dispatch@PLT + popq %rbp + movq 1728(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 1728(%rax), %r11 + jmp *%r11 +1: + pushq %rbp + call _glapi_get_dispatch + popq %rbp + movq 1728(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(Finish), .-GL_PREFIX(Finish) + + .p2align 4,,15 + .globl GL_PREFIX(Flush) + .type GL_PREFIX(Flush), @function +GL_PREFIX(Flush): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 1736(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rbp + call _x86_64_get_dispatch@PLT + popq %rbp + movq 1736(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 1736(%rax), %r11 + jmp *%r11 +1: + pushq %rbp + call _glapi_get_dispatch + popq %rbp + movq 1736(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(Flush), .-GL_PREFIX(Flush) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_218) + .type GL_PREFIX(_dispatch_stub_218), @function + HIDDEN(GL_PREFIX(_dispatch_stub_218)) +GL_PREFIX(_dispatch_stub_218): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 1744(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rbp + call _x86_64_get_dispatch@PLT + popq %rbp + movq 1744(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 1744(%rax), %r11 + jmp *%r11 +1: + pushq %rbp + call _glapi_get_dispatch + popq %rbp + movq 1744(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_218), .-GL_PREFIX(_dispatch_stub_218) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_219) + .type GL_PREFIX(_dispatch_stub_219), @function + HIDDEN(GL_PREFIX(_dispatch_stub_219)) +GL_PREFIX(_dispatch_stub_219): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 1752(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + call _x86_64_get_dispatch@PLT + popq %rdi + movq 1752(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 1752(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + call _glapi_get_dispatch + popq %rdi + movq 1752(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_219), .-GL_PREFIX(_dispatch_stub_219) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_220) + .type GL_PREFIX(_dispatch_stub_220), @function + HIDDEN(GL_PREFIX(_dispatch_stub_220)) +GL_PREFIX(_dispatch_stub_220): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 1760(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + subq $56, %rsp + movq %rdi, (%rsp) + movq %xmm0, 8(%rsp) + movq %xmm1, 16(%rsp) + movq %rsi, 24(%rsp) + movq %rdx, 32(%rsp) + movq %rcx, 40(%rsp) + call _x86_64_get_dispatch@PLT + movq 40(%rsp), %rcx + movq 32(%rsp), %rdx + movq 24(%rsp), %rsi + movq 16(%rsp), %xmm1 + movq 8(%rsp), %xmm0 + movq (%rsp), %rdi + addq $56, %rsp + movq 1760(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 1760(%rax), %r11 + jmp *%r11 +1: + subq $56, %rsp + movq %rdi, (%rsp) + movq %xmm0, 8(%rsp) + movq %xmm1, 16(%rsp) + movq %rsi, 24(%rsp) + movq %rdx, 32(%rsp) + movq %rcx, 40(%rsp) + call _glapi_get_dispatch + movq 40(%rsp), %rcx + movq 32(%rsp), %rdx + movq 24(%rsp), %rsi + movq 16(%rsp), %xmm1 + movq 8(%rsp), %xmm0 + movq (%rsp), %rdi + addq $56, %rsp + movq 1760(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_220), .-GL_PREFIX(_dispatch_stub_220) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_221) + .type GL_PREFIX(_dispatch_stub_221), @function + HIDDEN(GL_PREFIX(_dispatch_stub_221)) +GL_PREFIX(_dispatch_stub_221): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 1768(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + subq $56, %rsp + movq %rdi, (%rsp) + movq %xmm0, 8(%rsp) + movq %xmm1, 16(%rsp) + movq %rsi, 24(%rsp) + movq %rdx, 32(%rsp) + movq %rcx, 40(%rsp) + call _x86_64_get_dispatch@PLT + movq 40(%rsp), %rcx + movq 32(%rsp), %rdx + movq 24(%rsp), %rsi + movq 16(%rsp), %xmm1 + movq 8(%rsp), %xmm0 + movq (%rsp), %rdi + addq $56, %rsp + movq 1768(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 1768(%rax), %r11 + jmp *%r11 +1: + subq $56, %rsp + movq %rdi, (%rsp) + movq %xmm0, 8(%rsp) + movq %xmm1, 16(%rsp) + movq %rsi, 24(%rsp) + movq %rdx, 32(%rsp) + movq %rcx, 40(%rsp) + call _glapi_get_dispatch + movq 40(%rsp), %rcx + movq 32(%rsp), %rdx + movq 24(%rsp), %rsi + movq 16(%rsp), %xmm1 + movq 8(%rsp), %xmm0 + movq (%rsp), %rdi + addq $56, %rsp + movq 1768(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_221), .-GL_PREFIX(_dispatch_stub_221) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_222) + .type GL_PREFIX(_dispatch_stub_222), @function + HIDDEN(GL_PREFIX(_dispatch_stub_222)) +GL_PREFIX(_dispatch_stub_222): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 1776(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + subq $88, %rsp + movq %rdi, (%rsp) + movq %xmm0, 8(%rsp) + movq %xmm1, 16(%rsp) + movq %rsi, 24(%rsp) + movq %rdx, 32(%rsp) + movq %xmm2, 40(%rsp) + movq %xmm3, 48(%rsp) + movq %rcx, 56(%rsp) + movq %r8, 64(%rsp) + movq %r9, 72(%rsp) + call _x86_64_get_dispatch@PLT + movq 72(%rsp), %r9 + movq 64(%rsp), %r8 + movq 56(%rsp), %rcx + movq 48(%rsp), %xmm3 + movq 40(%rsp), %xmm2 + movq 32(%rsp), %rdx + movq 24(%rsp), %rsi + movq 16(%rsp), %xmm1 + movq 8(%rsp), %xmm0 + movq (%rsp), %rdi + addq $88, %rsp + movq 1776(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 1776(%rax), %r11 + jmp *%r11 +1: + subq $88, %rsp + movq %rdi, (%rsp) + movq %xmm0, 8(%rsp) + movq %xmm1, 16(%rsp) + movq %rsi, 24(%rsp) + movq %rdx, 32(%rsp) + movq %xmm2, 40(%rsp) + movq %xmm3, 48(%rsp) + movq %rcx, 56(%rsp) + movq %r8, 64(%rsp) + movq %r9, 72(%rsp) + call _glapi_get_dispatch + movq 72(%rsp), %r9 + movq 64(%rsp), %r8 + movq 56(%rsp), %rcx + movq 48(%rsp), %xmm3 + movq 40(%rsp), %xmm2 + movq 32(%rsp), %rdx + movq 24(%rsp), %rsi + movq 16(%rsp), %xmm1 + movq 8(%rsp), %xmm0 + movq (%rsp), %rdi + addq $88, %rsp + movq 1776(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_222), .-GL_PREFIX(_dispatch_stub_222) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_223) + .type GL_PREFIX(_dispatch_stub_223), @function + HIDDEN(GL_PREFIX(_dispatch_stub_223)) +GL_PREFIX(_dispatch_stub_223): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 1784(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + subq $88, %rsp + movq %rdi, (%rsp) + movq %xmm0, 8(%rsp) + movq %xmm1, 16(%rsp) + movq %rsi, 24(%rsp) + movq %rdx, 32(%rsp) + movq %xmm2, 40(%rsp) + movq %xmm3, 48(%rsp) + movq %rcx, 56(%rsp) + movq %r8, 64(%rsp) + movq %r9, 72(%rsp) + call _x86_64_get_dispatch@PLT + movq 72(%rsp), %r9 + movq 64(%rsp), %r8 + movq 56(%rsp), %rcx + movq 48(%rsp), %xmm3 + movq 40(%rsp), %xmm2 + movq 32(%rsp), %rdx + movq 24(%rsp), %rsi + movq 16(%rsp), %xmm1 + movq 8(%rsp), %xmm0 + movq (%rsp), %rdi + addq $88, %rsp + movq 1784(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 1784(%rax), %r11 + jmp *%r11 +1: + subq $88, %rsp + movq %rdi, (%rsp) + movq %xmm0, 8(%rsp) + movq %xmm1, 16(%rsp) + movq %rsi, 24(%rsp) + movq %rdx, 32(%rsp) + movq %xmm2, 40(%rsp) + movq %xmm3, 48(%rsp) + movq %rcx, 56(%rsp) + movq %r8, 64(%rsp) + movq %r9, 72(%rsp) + call _glapi_get_dispatch + movq 72(%rsp), %r9 + movq 64(%rsp), %r8 + movq 56(%rsp), %rcx + movq 48(%rsp), %xmm3 + movq 40(%rsp), %xmm2 + movq 32(%rsp), %rdx + movq 24(%rsp), %rsi + movq 16(%rsp), %xmm1 + movq 8(%rsp), %xmm0 + movq (%rsp), %rdi + addq $88, %rsp + movq 1784(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_223), .-GL_PREFIX(_dispatch_stub_223) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_224) + .type GL_PREFIX(_dispatch_stub_224), @function + HIDDEN(GL_PREFIX(_dispatch_stub_224)) +GL_PREFIX(_dispatch_stub_224): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 1792(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + subq $24, %rsp + movq %rdi, (%rsp) + movq %xmm0, 8(%rsp) + movq %xmm1, 16(%rsp) + call _x86_64_get_dispatch@PLT + movq 16(%rsp), %xmm1 + movq 8(%rsp), %xmm0 + movq (%rsp), %rdi + addq $24, %rsp + movq 1792(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 1792(%rax), %r11 + jmp *%r11 +1: + subq $24, %rsp + movq %rdi, (%rsp) + movq %xmm0, 8(%rsp) + movq %xmm1, 16(%rsp) + call _glapi_get_dispatch + movq 16(%rsp), %xmm1 + movq 8(%rsp), %xmm0 + movq (%rsp), %rdi + addq $24, %rsp + movq 1792(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_224), .-GL_PREFIX(_dispatch_stub_224) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_225) + .type GL_PREFIX(_dispatch_stub_225), @function + HIDDEN(GL_PREFIX(_dispatch_stub_225)) +GL_PREFIX(_dispatch_stub_225): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 1800(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + subq $24, %rsp + movq %rdi, (%rsp) + movq %xmm0, 8(%rsp) + movq %xmm1, 16(%rsp) + call _x86_64_get_dispatch@PLT + movq 16(%rsp), %xmm1 + movq 8(%rsp), %xmm0 + movq (%rsp), %rdi + addq $24, %rsp + movq 1800(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 1800(%rax), %r11 + jmp *%r11 +1: + subq $24, %rsp + movq %rdi, (%rsp) + movq %xmm0, 8(%rsp) + movq %xmm1, 16(%rsp) + call _glapi_get_dispatch + movq 16(%rsp), %xmm1 + movq 8(%rsp), %xmm0 + movq (%rsp), %rdi + addq $24, %rsp + movq 1800(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_225), .-GL_PREFIX(_dispatch_stub_225) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_226) + .type GL_PREFIX(_dispatch_stub_226), @function + HIDDEN(GL_PREFIX(_dispatch_stub_226)) +GL_PREFIX(_dispatch_stub_226): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 1808(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + subq $56, %rsp + movq %rdi, (%rsp) + movq %xmm0, 8(%rsp) + movq %xmm1, 16(%rsp) + movq %rsi, 24(%rsp) + movq %xmm2, 32(%rsp) + movq %xmm3, 40(%rsp) + call _x86_64_get_dispatch@PLT + movq 40(%rsp), %xmm3 + movq 32(%rsp), %xmm2 + movq 24(%rsp), %rsi + movq 16(%rsp), %xmm1 + movq 8(%rsp), %xmm0 + movq (%rsp), %rdi + addq $56, %rsp + movq 1808(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 1808(%rax), %r11 + jmp *%r11 +1: + subq $56, %rsp + movq %rdi, (%rsp) + movq %xmm0, 8(%rsp) + movq %xmm1, 16(%rsp) + movq %rsi, 24(%rsp) + movq %xmm2, 32(%rsp) + movq %xmm3, 40(%rsp) + call _glapi_get_dispatch + movq 40(%rsp), %xmm3 + movq 32(%rsp), %xmm2 + movq 24(%rsp), %rsi + movq 16(%rsp), %xmm1 + movq 8(%rsp), %xmm0 + movq (%rsp), %rdi + addq $56, %rsp + movq 1808(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_226), .-GL_PREFIX(_dispatch_stub_226) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_227) + .type GL_PREFIX(_dispatch_stub_227), @function + HIDDEN(GL_PREFIX(_dispatch_stub_227)) +GL_PREFIX(_dispatch_stub_227): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 1816(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + subq $56, %rsp + movq %rdi, (%rsp) + movq %xmm0, 8(%rsp) + movq %xmm1, 16(%rsp) + movq %rsi, 24(%rsp) + movq %xmm2, 32(%rsp) + movq %xmm3, 40(%rsp) + call _x86_64_get_dispatch@PLT + movq 40(%rsp), %xmm3 + movq 32(%rsp), %xmm2 + movq 24(%rsp), %rsi + movq 16(%rsp), %xmm1 + movq 8(%rsp), %xmm0 + movq (%rsp), %rdi + addq $56, %rsp + movq 1816(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 1816(%rax), %r11 + jmp *%r11 +1: + subq $56, %rsp + movq %rdi, (%rsp) + movq %xmm0, 8(%rsp) + movq %xmm1, 16(%rsp) + movq %rsi, 24(%rsp) + movq %xmm2, 32(%rsp) + movq %xmm3, 40(%rsp) + call _glapi_get_dispatch + movq 40(%rsp), %xmm3 + movq 32(%rsp), %xmm2 + movq 24(%rsp), %rsi + movq 16(%rsp), %xmm1 + movq 8(%rsp), %xmm0 + movq (%rsp), %rdi + addq $56, %rsp + movq 1816(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_227), .-GL_PREFIX(_dispatch_stub_227) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_228) + .type GL_PREFIX(_dispatch_stub_228), @function + HIDDEN(GL_PREFIX(_dispatch_stub_228)) +GL_PREFIX(_dispatch_stub_228): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 1824(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + subq $8, %rsp + movq %xmm0, (%rsp) + call _x86_64_get_dispatch@PLT + movq (%rsp), %xmm0 + addq $8, %rsp + movq 1824(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 1824(%rax), %r11 + jmp *%r11 +1: + subq $8, %rsp + movq %xmm0, (%rsp) + call _glapi_get_dispatch + movq (%rsp), %xmm0 + addq $8, %rsp + movq 1824(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_228), .-GL_PREFIX(_dispatch_stub_228) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_229) + .type GL_PREFIX(_dispatch_stub_229), @function + HIDDEN(GL_PREFIX(_dispatch_stub_229)) +GL_PREFIX(_dispatch_stub_229): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 1832(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + call _x86_64_get_dispatch@PLT + popq %rdi + movq 1832(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 1832(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + call _glapi_get_dispatch + popq %rdi + movq 1832(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_229), .-GL_PREFIX(_dispatch_stub_229) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_230) + .type GL_PREFIX(_dispatch_stub_230), @function + HIDDEN(GL_PREFIX(_dispatch_stub_230)) +GL_PREFIX(_dispatch_stub_230): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 1840(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + subq $8, %rsp + movq %xmm0, (%rsp) + call _x86_64_get_dispatch@PLT + movq (%rsp), %xmm0 + addq $8, %rsp + movq 1840(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 1840(%rax), %r11 + jmp *%r11 +1: + subq $8, %rsp + movq %xmm0, (%rsp) + call _glapi_get_dispatch + movq (%rsp), %xmm0 + addq $8, %rsp + movq 1840(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_230), .-GL_PREFIX(_dispatch_stub_230) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_231) + .type GL_PREFIX(_dispatch_stub_231), @function + HIDDEN(GL_PREFIX(_dispatch_stub_231)) +GL_PREFIX(_dispatch_stub_231): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 1848(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + call _x86_64_get_dispatch@PLT + popq %rdi + movq 1848(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 1848(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + call _glapi_get_dispatch + popq %rdi + movq 1848(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_231), .-GL_PREFIX(_dispatch_stub_231) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_232) + .type GL_PREFIX(_dispatch_stub_232), @function + HIDDEN(GL_PREFIX(_dispatch_stub_232)) +GL_PREFIX(_dispatch_stub_232): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 1856(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + subq $24, %rsp + movq %xmm0, (%rsp) + movq %xmm1, 8(%rsp) + call _x86_64_get_dispatch@PLT + movq 8(%rsp), %xmm1 + movq (%rsp), %xmm0 + addq $24, %rsp + movq 1856(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 1856(%rax), %r11 + jmp *%r11 +1: + subq $24, %rsp + movq %xmm0, (%rsp) + movq %xmm1, 8(%rsp) + call _glapi_get_dispatch + movq 8(%rsp), %xmm1 + movq (%rsp), %xmm0 + addq $24, %rsp + movq 1856(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_232), .-GL_PREFIX(_dispatch_stub_232) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_233) + .type GL_PREFIX(_dispatch_stub_233), @function + HIDDEN(GL_PREFIX(_dispatch_stub_233)) +GL_PREFIX(_dispatch_stub_233): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 1864(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + call _x86_64_get_dispatch@PLT + popq %rdi + movq 1864(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 1864(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + call _glapi_get_dispatch + popq %rdi + movq 1864(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_233), .-GL_PREFIX(_dispatch_stub_233) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_234) + .type GL_PREFIX(_dispatch_stub_234), @function + HIDDEN(GL_PREFIX(_dispatch_stub_234)) +GL_PREFIX(_dispatch_stub_234): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 1872(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + subq $24, %rsp + movq %xmm0, (%rsp) + movq %xmm1, 8(%rsp) + call _x86_64_get_dispatch@PLT + movq 8(%rsp), %xmm1 + movq (%rsp), %xmm0 + addq $24, %rsp + movq 1872(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 1872(%rax), %r11 + jmp *%r11 +1: + subq $24, %rsp + movq %xmm0, (%rsp) + movq %xmm1, 8(%rsp) + call _glapi_get_dispatch + movq 8(%rsp), %xmm1 + movq (%rsp), %xmm0 + addq $24, %rsp + movq 1872(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_234), .-GL_PREFIX(_dispatch_stub_234) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_235) + .type GL_PREFIX(_dispatch_stub_235), @function + HIDDEN(GL_PREFIX(_dispatch_stub_235)) +GL_PREFIX(_dispatch_stub_235): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 1880(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + call _x86_64_get_dispatch@PLT + popq %rdi + movq 1880(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 1880(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + call _glapi_get_dispatch + popq %rdi + movq 1880(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_235), .-GL_PREFIX(_dispatch_stub_235) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_236) + .type GL_PREFIX(_dispatch_stub_236), @function + HIDDEN(GL_PREFIX(_dispatch_stub_236)) +GL_PREFIX(_dispatch_stub_236): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 1888(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rdx + call _x86_64_get_dispatch@PLT + popq %rdx + popq %rsi + popq %rdi + movq 1888(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 1888(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rdx + call _glapi_get_dispatch + popq %rdx + popq %rsi + popq %rdi + movq 1888(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_236), .-GL_PREFIX(_dispatch_stub_236) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_237) + .type GL_PREFIX(_dispatch_stub_237), @function + HIDDEN(GL_PREFIX(_dispatch_stub_237)) +GL_PREFIX(_dispatch_stub_237): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 1896(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + call _x86_64_get_dispatch@PLT + popq %rdi + movq 1896(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 1896(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + call _glapi_get_dispatch + popq %rdi + movq 1896(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_237), .-GL_PREFIX(_dispatch_stub_237) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_238) + .type GL_PREFIX(_dispatch_stub_238), @function + HIDDEN(GL_PREFIX(_dispatch_stub_238)) +GL_PREFIX(_dispatch_stub_238): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 1904(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rdx + pushq %rcx + pushq %r8 + call _x86_64_get_dispatch@PLT + popq %r8 + popq %rcx + popq %rdx + popq %rsi + popq %rdi + movq 1904(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 1904(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rdx + pushq %rcx + pushq %r8 + call _glapi_get_dispatch + popq %r8 + popq %rcx + popq %rdx + popq %rsi + popq %rdi + movq 1904(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_238), .-GL_PREFIX(_dispatch_stub_238) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_239) + .type GL_PREFIX(_dispatch_stub_239), @function + HIDDEN(GL_PREFIX(_dispatch_stub_239)) +GL_PREFIX(_dispatch_stub_239): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 1912(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rbp + call _x86_64_get_dispatch@PLT + popq %rbp + popq %rsi + popq %rdi + movq 1912(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 1912(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rbp + call _glapi_get_dispatch + popq %rbp + popq %rsi + popq %rdi + movq 1912(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_239), .-GL_PREFIX(_dispatch_stub_239) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_240) + .type GL_PREFIX(_dispatch_stub_240), @function + HIDDEN(GL_PREFIX(_dispatch_stub_240)) +GL_PREFIX(_dispatch_stub_240): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 1920(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rbp + call _x86_64_get_dispatch@PLT + popq %rbp + popq %rsi + popq %rdi + movq 1920(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 1920(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rbp + call _glapi_get_dispatch + popq %rbp + popq %rsi + popq %rdi + movq 1920(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_240), .-GL_PREFIX(_dispatch_stub_240) + + .p2align 4,,15 + .globl GL_PREFIX(BlendFunc) + .type GL_PREFIX(BlendFunc), @function +GL_PREFIX(BlendFunc): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 1928(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rbp + call _x86_64_get_dispatch@PLT + popq %rbp + popq %rsi + popq %rdi + movq 1928(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 1928(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rbp + call _glapi_get_dispatch + popq %rbp + popq %rsi + popq %rdi + movq 1928(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(BlendFunc), .-GL_PREFIX(BlendFunc) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_242) + .type GL_PREFIX(_dispatch_stub_242), @function + HIDDEN(GL_PREFIX(_dispatch_stub_242)) +GL_PREFIX(_dispatch_stub_242): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 1936(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + call _x86_64_get_dispatch@PLT + popq %rdi + movq 1936(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 1936(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + call _glapi_get_dispatch + popq %rdi + movq 1936(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_242), .-GL_PREFIX(_dispatch_stub_242) + + .p2align 4,,15 + .globl GL_PREFIX(StencilFunc) + .type GL_PREFIX(StencilFunc), @function +GL_PREFIX(StencilFunc): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 1944(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rdx + call _x86_64_get_dispatch@PLT + popq %rdx + popq %rsi + popq %rdi + movq 1944(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 1944(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rdx + call _glapi_get_dispatch + popq %rdx + popq %rsi + popq %rdi + movq 1944(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(StencilFunc), .-GL_PREFIX(StencilFunc) + + .p2align 4,,15 + .globl GL_PREFIX(StencilOp) + .type GL_PREFIX(StencilOp), @function +GL_PREFIX(StencilOp): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 1952(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rdx + call _x86_64_get_dispatch@PLT + popq %rdx + popq %rsi + popq %rdi + movq 1952(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 1952(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rdx + call _glapi_get_dispatch + popq %rdx + popq %rsi + popq %rdi + movq 1952(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(StencilOp), .-GL_PREFIX(StencilOp) + + .p2align 4,,15 + .globl GL_PREFIX(DepthFunc) + .type GL_PREFIX(DepthFunc), @function +GL_PREFIX(DepthFunc): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 1960(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + call _x86_64_get_dispatch@PLT + popq %rdi + movq 1960(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 1960(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + call _glapi_get_dispatch + popq %rdi + movq 1960(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(DepthFunc), .-GL_PREFIX(DepthFunc) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_246) + .type GL_PREFIX(_dispatch_stub_246), @function + HIDDEN(GL_PREFIX(_dispatch_stub_246)) +GL_PREFIX(_dispatch_stub_246): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 1968(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + subq $24, %rsp + movq %xmm0, (%rsp) + movq %xmm1, 8(%rsp) + call _x86_64_get_dispatch@PLT + movq 8(%rsp), %xmm1 + movq (%rsp), %xmm0 + addq $24, %rsp + movq 1968(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 1968(%rax), %r11 + jmp *%r11 +1: + subq $24, %rsp + movq %xmm0, (%rsp) + movq %xmm1, 8(%rsp) + call _glapi_get_dispatch + movq 8(%rsp), %xmm1 + movq (%rsp), %xmm0 + addq $24, %rsp + movq 1968(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_246), .-GL_PREFIX(_dispatch_stub_246) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_247) + .type GL_PREFIX(_dispatch_stub_247), @function + HIDDEN(GL_PREFIX(_dispatch_stub_247)) +GL_PREFIX(_dispatch_stub_247): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 1976(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + subq $24, %rsp + movq %rdi, (%rsp) + movq %xmm0, 8(%rsp) + call _x86_64_get_dispatch@PLT + movq 8(%rsp), %xmm0 + movq (%rsp), %rdi + addq $24, %rsp + movq 1976(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 1976(%rax), %r11 + jmp *%r11 +1: + subq $24, %rsp + movq %rdi, (%rsp) + movq %xmm0, 8(%rsp) + call _glapi_get_dispatch + movq 8(%rsp), %xmm0 + movq (%rsp), %rdi + addq $24, %rsp + movq 1976(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_247), .-GL_PREFIX(_dispatch_stub_247) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_248) + .type GL_PREFIX(_dispatch_stub_248), @function + HIDDEN(GL_PREFIX(_dispatch_stub_248)) +GL_PREFIX(_dispatch_stub_248): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 1984(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rbp + call _x86_64_get_dispatch@PLT + popq %rbp + popq %rsi + popq %rdi + movq 1984(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 1984(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rbp + call _glapi_get_dispatch + popq %rbp + popq %rsi + popq %rdi + movq 1984(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_248), .-GL_PREFIX(_dispatch_stub_248) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_249) + .type GL_PREFIX(_dispatch_stub_249), @function + HIDDEN(GL_PREFIX(_dispatch_stub_249)) +GL_PREFIX(_dispatch_stub_249): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 1992(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + subq $24, %rsp + movq %rdi, (%rsp) + movq %xmm0, 8(%rsp) + call _x86_64_get_dispatch@PLT + movq 8(%rsp), %xmm0 + movq (%rsp), %rdi + addq $24, %rsp + movq 1992(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 1992(%rax), %r11 + jmp *%r11 +1: + subq $24, %rsp + movq %rdi, (%rsp) + movq %xmm0, 8(%rsp) + call _glapi_get_dispatch + movq 8(%rsp), %xmm0 + movq (%rsp), %rdi + addq $24, %rsp + movq 1992(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_249), .-GL_PREFIX(_dispatch_stub_249) + + .p2align 4,,15 + .globl GL_PREFIX(PixelStorei) + .type GL_PREFIX(PixelStorei), @function +GL_PREFIX(PixelStorei): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 2000(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rbp + call _x86_64_get_dispatch@PLT + popq %rbp + popq %rsi + popq %rdi + movq 2000(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 2000(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rbp + call _glapi_get_dispatch + popq %rbp + popq %rsi + popq %rdi + movq 2000(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(PixelStorei), .-GL_PREFIX(PixelStorei) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_251) + .type GL_PREFIX(_dispatch_stub_251), @function + HIDDEN(GL_PREFIX(_dispatch_stub_251)) +GL_PREFIX(_dispatch_stub_251): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 2008(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rdx + call _x86_64_get_dispatch@PLT + popq %rdx + popq %rsi + popq %rdi + movq 2008(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 2008(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rdx + call _glapi_get_dispatch + popq %rdx + popq %rsi + popq %rdi + movq 2008(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_251), .-GL_PREFIX(_dispatch_stub_251) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_252) + .type GL_PREFIX(_dispatch_stub_252), @function + HIDDEN(GL_PREFIX(_dispatch_stub_252)) +GL_PREFIX(_dispatch_stub_252): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 2016(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rdx + call _x86_64_get_dispatch@PLT + popq %rdx + popq %rsi + popq %rdi + movq 2016(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 2016(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rdx + call _glapi_get_dispatch + popq %rdx + popq %rsi + popq %rdi + movq 2016(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_252), .-GL_PREFIX(_dispatch_stub_252) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_253) + .type GL_PREFIX(_dispatch_stub_253), @function + HIDDEN(GL_PREFIX(_dispatch_stub_253)) +GL_PREFIX(_dispatch_stub_253): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 2024(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rdx + call _x86_64_get_dispatch@PLT + popq %rdx + popq %rsi + popq %rdi + movq 2024(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 2024(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rdx + call _glapi_get_dispatch + popq %rdx + popq %rsi + popq %rdi + movq 2024(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_253), .-GL_PREFIX(_dispatch_stub_253) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_254) + .type GL_PREFIX(_dispatch_stub_254), @function + HIDDEN(GL_PREFIX(_dispatch_stub_254)) +GL_PREFIX(_dispatch_stub_254): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 2032(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + call _x86_64_get_dispatch@PLT + popq %rdi + movq 2032(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 2032(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + call _glapi_get_dispatch + popq %rdi + movq 2032(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_254), .-GL_PREFIX(_dispatch_stub_254) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_255) + .type GL_PREFIX(_dispatch_stub_255), @function + HIDDEN(GL_PREFIX(_dispatch_stub_255)) +GL_PREFIX(_dispatch_stub_255): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 2040(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rdx + pushq %rcx + pushq %r8 + call _x86_64_get_dispatch@PLT + popq %r8 + popq %rcx + popq %rdx + popq %rsi + popq %rdi + movq 2040(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 2040(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rdx + pushq %rcx + pushq %r8 + call _glapi_get_dispatch + popq %r8 + popq %rcx + popq %rdx + popq %rsi + popq %rdi + movq 2040(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_255), .-GL_PREFIX(_dispatch_stub_255) + + .p2align 4,,15 + .globl GL_PREFIX(ReadPixels) + .type GL_PREFIX(ReadPixels), @function +GL_PREFIX(ReadPixels): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 2048(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rdx + pushq %rcx + pushq %r8 + pushq %r9 + pushq %rbp + call _x86_64_get_dispatch@PLT + popq %rbp + popq %r9 + popq %r8 + popq %rcx + popq %rdx + popq %rsi + popq %rdi + movq 2048(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 2048(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rdx + pushq %rcx + pushq %r8 + pushq %r9 + pushq %rbp + call _glapi_get_dispatch + popq %rbp + popq %r9 + popq %r8 + popq %rcx + popq %rdx + popq %rsi + popq %rdi + movq 2048(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(ReadPixels), .-GL_PREFIX(ReadPixels) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_257) + .type GL_PREFIX(_dispatch_stub_257), @function + HIDDEN(GL_PREFIX(_dispatch_stub_257)) +GL_PREFIX(_dispatch_stub_257): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 2056(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rdx + pushq %rcx + pushq %r8 + call _x86_64_get_dispatch@PLT + popq %r8 + popq %rcx + popq %rdx + popq %rsi + popq %rdi + movq 2056(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 2056(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rdx + pushq %rcx + pushq %r8 + call _glapi_get_dispatch + popq %r8 + popq %rcx + popq %rdx + popq %rsi + popq %rdi + movq 2056(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_257), .-GL_PREFIX(_dispatch_stub_257) + + .p2align 4,,15 + .globl GL_PREFIX(GetBooleanv) + .type GL_PREFIX(GetBooleanv), @function +GL_PREFIX(GetBooleanv): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 2064(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rbp + call _x86_64_get_dispatch@PLT + popq %rbp + popq %rsi + popq %rdi + movq 2064(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 2064(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rbp + call _glapi_get_dispatch + popq %rbp + popq %rsi + popq %rdi + movq 2064(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(GetBooleanv), .-GL_PREFIX(GetBooleanv) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_259) + .type GL_PREFIX(_dispatch_stub_259), @function + HIDDEN(GL_PREFIX(_dispatch_stub_259)) +GL_PREFIX(_dispatch_stub_259): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 2072(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rbp + call _x86_64_get_dispatch@PLT + popq %rbp + popq %rsi + popq %rdi + movq 2072(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 2072(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rbp + call _glapi_get_dispatch + popq %rbp + popq %rsi + popq %rdi + movq 2072(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_259), .-GL_PREFIX(_dispatch_stub_259) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_260) + .type GL_PREFIX(_dispatch_stub_260), @function + HIDDEN(GL_PREFIX(_dispatch_stub_260)) +GL_PREFIX(_dispatch_stub_260): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 2080(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rbp + call _x86_64_get_dispatch@PLT + popq %rbp + popq %rsi + popq %rdi + movq 2080(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 2080(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rbp + call _glapi_get_dispatch + popq %rbp + popq %rsi + popq %rdi + movq 2080(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_260), .-GL_PREFIX(_dispatch_stub_260) + + .p2align 4,,15 + .globl GL_PREFIX(GetError) + .type GL_PREFIX(GetError), @function +GL_PREFIX(GetError): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 2088(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rbp + call _x86_64_get_dispatch@PLT + popq %rbp + movq 2088(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 2088(%rax), %r11 + jmp *%r11 +1: + pushq %rbp + call _glapi_get_dispatch + popq %rbp + movq 2088(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(GetError), .-GL_PREFIX(GetError) + + .p2align 4,,15 + .globl GL_PREFIX(GetFloatv) + .type GL_PREFIX(GetFloatv), @function +GL_PREFIX(GetFloatv): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 2096(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rbp + call _x86_64_get_dispatch@PLT + popq %rbp + popq %rsi + popq %rdi + movq 2096(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 2096(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rbp + call _glapi_get_dispatch + popq %rbp + popq %rsi + popq %rdi + movq 2096(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(GetFloatv), .-GL_PREFIX(GetFloatv) + + .p2align 4,,15 + .globl GL_PREFIX(GetIntegerv) + .type GL_PREFIX(GetIntegerv), @function +GL_PREFIX(GetIntegerv): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 2104(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rbp + call _x86_64_get_dispatch@PLT + popq %rbp + popq %rsi + popq %rdi + movq 2104(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 2104(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rbp + call _glapi_get_dispatch + popq %rbp + popq %rsi + popq %rdi + movq 2104(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(GetIntegerv), .-GL_PREFIX(GetIntegerv) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_264) + .type GL_PREFIX(_dispatch_stub_264), @function + HIDDEN(GL_PREFIX(_dispatch_stub_264)) +GL_PREFIX(_dispatch_stub_264): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 2112(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rdx + call _x86_64_get_dispatch@PLT + popq %rdx + popq %rsi + popq %rdi + movq 2112(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 2112(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rdx + call _glapi_get_dispatch + popq %rdx + popq %rsi + popq %rdi + movq 2112(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_264), .-GL_PREFIX(_dispatch_stub_264) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_265) + .type GL_PREFIX(_dispatch_stub_265), @function + HIDDEN(GL_PREFIX(_dispatch_stub_265)) +GL_PREFIX(_dispatch_stub_265): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 2120(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rdx + call _x86_64_get_dispatch@PLT + popq %rdx + popq %rsi + popq %rdi + movq 2120(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 2120(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rdx + call _glapi_get_dispatch + popq %rdx + popq %rsi + popq %rdi + movq 2120(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_265), .-GL_PREFIX(_dispatch_stub_265) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_266) + .type GL_PREFIX(_dispatch_stub_266), @function + HIDDEN(GL_PREFIX(_dispatch_stub_266)) +GL_PREFIX(_dispatch_stub_266): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 2128(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rdx + call _x86_64_get_dispatch@PLT + popq %rdx + popq %rsi + popq %rdi + movq 2128(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 2128(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rdx + call _glapi_get_dispatch + popq %rdx + popq %rsi + popq %rdi + movq 2128(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_266), .-GL_PREFIX(_dispatch_stub_266) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_267) + .type GL_PREFIX(_dispatch_stub_267), @function + HIDDEN(GL_PREFIX(_dispatch_stub_267)) +GL_PREFIX(_dispatch_stub_267): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 2136(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rdx + call _x86_64_get_dispatch@PLT + popq %rdx + popq %rsi + popq %rdi + movq 2136(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 2136(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rdx + call _glapi_get_dispatch + popq %rdx + popq %rsi + popq %rdi + movq 2136(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_267), .-GL_PREFIX(_dispatch_stub_267) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_268) + .type GL_PREFIX(_dispatch_stub_268), @function + HIDDEN(GL_PREFIX(_dispatch_stub_268)) +GL_PREFIX(_dispatch_stub_268): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 2144(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rdx + call _x86_64_get_dispatch@PLT + popq %rdx + popq %rsi + popq %rdi + movq 2144(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 2144(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rdx + call _glapi_get_dispatch + popq %rdx + popq %rsi + popq %rdi + movq 2144(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_268), .-GL_PREFIX(_dispatch_stub_268) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_269) + .type GL_PREFIX(_dispatch_stub_269), @function + HIDDEN(GL_PREFIX(_dispatch_stub_269)) +GL_PREFIX(_dispatch_stub_269): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 2152(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rdx + call _x86_64_get_dispatch@PLT + popq %rdx + popq %rsi + popq %rdi + movq 2152(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 2152(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rdx + call _glapi_get_dispatch + popq %rdx + popq %rsi + popq %rdi + movq 2152(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_269), .-GL_PREFIX(_dispatch_stub_269) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_270) + .type GL_PREFIX(_dispatch_stub_270), @function + HIDDEN(GL_PREFIX(_dispatch_stub_270)) +GL_PREFIX(_dispatch_stub_270): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 2160(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rdx + call _x86_64_get_dispatch@PLT + popq %rdx + popq %rsi + popq %rdi + movq 2160(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 2160(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rdx + call _glapi_get_dispatch + popq %rdx + popq %rsi + popq %rdi + movq 2160(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_270), .-GL_PREFIX(_dispatch_stub_270) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_271) + .type GL_PREFIX(_dispatch_stub_271), @function + HIDDEN(GL_PREFIX(_dispatch_stub_271)) +GL_PREFIX(_dispatch_stub_271): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 2168(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rbp + call _x86_64_get_dispatch@PLT + popq %rbp + popq %rsi + popq %rdi + movq 2168(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 2168(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rbp + call _glapi_get_dispatch + popq %rbp + popq %rsi + popq %rdi + movq 2168(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_271), .-GL_PREFIX(_dispatch_stub_271) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_272) + .type GL_PREFIX(_dispatch_stub_272), @function + HIDDEN(GL_PREFIX(_dispatch_stub_272)) +GL_PREFIX(_dispatch_stub_272): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 2176(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rbp + call _x86_64_get_dispatch@PLT + popq %rbp + popq %rsi + popq %rdi + movq 2176(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 2176(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rbp + call _glapi_get_dispatch + popq %rbp + popq %rsi + popq %rdi + movq 2176(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_272), .-GL_PREFIX(_dispatch_stub_272) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_273) + .type GL_PREFIX(_dispatch_stub_273), @function + HIDDEN(GL_PREFIX(_dispatch_stub_273)) +GL_PREFIX(_dispatch_stub_273): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 2184(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rbp + call _x86_64_get_dispatch@PLT + popq %rbp + popq %rsi + popq %rdi + movq 2184(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 2184(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rbp + call _glapi_get_dispatch + popq %rbp + popq %rsi + popq %rdi + movq 2184(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_273), .-GL_PREFIX(_dispatch_stub_273) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_274) + .type GL_PREFIX(_dispatch_stub_274), @function + HIDDEN(GL_PREFIX(_dispatch_stub_274)) +GL_PREFIX(_dispatch_stub_274): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 2192(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + call _x86_64_get_dispatch@PLT + popq %rdi + movq 2192(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 2192(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + call _glapi_get_dispatch + popq %rdi + movq 2192(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_274), .-GL_PREFIX(_dispatch_stub_274) + + .p2align 4,,15 + .globl GL_PREFIX(GetString) + .type GL_PREFIX(GetString), @function +GL_PREFIX(GetString): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 2200(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + call _x86_64_get_dispatch@PLT + popq %rdi + movq 2200(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 2200(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + call _glapi_get_dispatch + popq %rdi + movq 2200(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(GetString), .-GL_PREFIX(GetString) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_276) + .type GL_PREFIX(_dispatch_stub_276), @function + HIDDEN(GL_PREFIX(_dispatch_stub_276)) +GL_PREFIX(_dispatch_stub_276): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 2208(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rdx + call _x86_64_get_dispatch@PLT + popq %rdx + popq %rsi + popq %rdi + movq 2208(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 2208(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rdx + call _glapi_get_dispatch + popq %rdx + popq %rsi + popq %rdi + movq 2208(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_276), .-GL_PREFIX(_dispatch_stub_276) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_277) + .type GL_PREFIX(_dispatch_stub_277), @function + HIDDEN(GL_PREFIX(_dispatch_stub_277)) +GL_PREFIX(_dispatch_stub_277): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 2216(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rdx + call _x86_64_get_dispatch@PLT + popq %rdx + popq %rsi + popq %rdi + movq 2216(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 2216(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rdx + call _glapi_get_dispatch + popq %rdx + popq %rsi + popq %rdi + movq 2216(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_277), .-GL_PREFIX(_dispatch_stub_277) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_278) + .type GL_PREFIX(_dispatch_stub_278), @function + HIDDEN(GL_PREFIX(_dispatch_stub_278)) +GL_PREFIX(_dispatch_stub_278): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 2224(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rdx + call _x86_64_get_dispatch@PLT + popq %rdx + popq %rsi + popq %rdi + movq 2224(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 2224(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rdx + call _glapi_get_dispatch + popq %rdx + popq %rsi + popq %rdi + movq 2224(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_278), .-GL_PREFIX(_dispatch_stub_278) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_279) + .type GL_PREFIX(_dispatch_stub_279), @function + HIDDEN(GL_PREFIX(_dispatch_stub_279)) +GL_PREFIX(_dispatch_stub_279): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 2232(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rdx + call _x86_64_get_dispatch@PLT + popq %rdx + popq %rsi + popq %rdi + movq 2232(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 2232(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rdx + call _glapi_get_dispatch + popq %rdx + popq %rsi + popq %rdi + movq 2232(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_279), .-GL_PREFIX(_dispatch_stub_279) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_280) + .type GL_PREFIX(_dispatch_stub_280), @function + HIDDEN(GL_PREFIX(_dispatch_stub_280)) +GL_PREFIX(_dispatch_stub_280): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 2240(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rdx + call _x86_64_get_dispatch@PLT + popq %rdx + popq %rsi + popq %rdi + movq 2240(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 2240(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rdx + call _glapi_get_dispatch + popq %rdx + popq %rsi + popq %rdi + movq 2240(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_280), .-GL_PREFIX(_dispatch_stub_280) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_281) + .type GL_PREFIX(_dispatch_stub_281), @function + HIDDEN(GL_PREFIX(_dispatch_stub_281)) +GL_PREFIX(_dispatch_stub_281): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 2248(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rdx + pushq %rcx + pushq %r8 + call _x86_64_get_dispatch@PLT + popq %r8 + popq %rcx + popq %rdx + popq %rsi + popq %rdi + movq 2248(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 2248(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rdx + pushq %rcx + pushq %r8 + call _glapi_get_dispatch + popq %r8 + popq %rcx + popq %rdx + popq %rsi + popq %rdi + movq 2248(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_281), .-GL_PREFIX(_dispatch_stub_281) + + .p2align 4,,15 + .globl GL_PREFIX(GetTexParameterfv) + .type GL_PREFIX(GetTexParameterfv), @function +GL_PREFIX(GetTexParameterfv): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 2256(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rdx + call _x86_64_get_dispatch@PLT + popq %rdx + popq %rsi + popq %rdi + movq 2256(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 2256(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rdx + call _glapi_get_dispatch + popq %rdx + popq %rsi + popq %rdi + movq 2256(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(GetTexParameterfv), .-GL_PREFIX(GetTexParameterfv) + + .p2align 4,,15 + .globl GL_PREFIX(GetTexParameteriv) + .type GL_PREFIX(GetTexParameteriv), @function +GL_PREFIX(GetTexParameteriv): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 2264(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rdx + call _x86_64_get_dispatch@PLT + popq %rdx + popq %rsi + popq %rdi + movq 2264(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 2264(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rdx + call _glapi_get_dispatch + popq %rdx + popq %rsi + popq %rdi + movq 2264(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(GetTexParameteriv), .-GL_PREFIX(GetTexParameteriv) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_284) + .type GL_PREFIX(_dispatch_stub_284), @function + HIDDEN(GL_PREFIX(_dispatch_stub_284)) +GL_PREFIX(_dispatch_stub_284): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 2272(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rdx + pushq %rcx + pushq %rbp + call _x86_64_get_dispatch@PLT + popq %rbp + popq %rcx + popq %rdx + popq %rsi + popq %rdi + movq 2272(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 2272(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rdx + pushq %rcx + pushq %rbp + call _glapi_get_dispatch + popq %rbp + popq %rcx + popq %rdx + popq %rsi + popq %rdi + movq 2272(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_284), .-GL_PREFIX(_dispatch_stub_284) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_285) + .type GL_PREFIX(_dispatch_stub_285), @function + HIDDEN(GL_PREFIX(_dispatch_stub_285)) +GL_PREFIX(_dispatch_stub_285): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 2280(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rdx + pushq %rcx + pushq %rbp + call _x86_64_get_dispatch@PLT + popq %rbp + popq %rcx + popq %rdx + popq %rsi + popq %rdi + movq 2280(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 2280(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rdx + pushq %rcx + pushq %rbp + call _glapi_get_dispatch + popq %rbp + popq %rcx + popq %rdx + popq %rsi + popq %rdi + movq 2280(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_285), .-GL_PREFIX(_dispatch_stub_285) + + .p2align 4,,15 + .globl GL_PREFIX(IsEnabled) + .type GL_PREFIX(IsEnabled), @function +GL_PREFIX(IsEnabled): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 2288(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + call _x86_64_get_dispatch@PLT + popq %rdi + movq 2288(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 2288(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + call _glapi_get_dispatch + popq %rdi + movq 2288(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(IsEnabled), .-GL_PREFIX(IsEnabled) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_287) + .type GL_PREFIX(_dispatch_stub_287), @function + HIDDEN(GL_PREFIX(_dispatch_stub_287)) +GL_PREFIX(_dispatch_stub_287): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 2296(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + call _x86_64_get_dispatch@PLT + popq %rdi + movq 2296(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 2296(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + call _glapi_get_dispatch + popq %rdi + movq 2296(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_287), .-GL_PREFIX(_dispatch_stub_287) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_288) + .type GL_PREFIX(_dispatch_stub_288), @function + HIDDEN(GL_PREFIX(_dispatch_stub_288)) +GL_PREFIX(_dispatch_stub_288): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 2304(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rbp + call _x86_64_get_dispatch@PLT + popq %rbp + popq %rsi + popq %rdi + movq 2304(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 2304(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rbp + call _glapi_get_dispatch + popq %rbp + popq %rsi + popq %rdi + movq 2304(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_288), .-GL_PREFIX(_dispatch_stub_288) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_289) + .type GL_PREFIX(_dispatch_stub_289), @function + HIDDEN(GL_PREFIX(_dispatch_stub_289)) +GL_PREFIX(_dispatch_stub_289): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 2312(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + subq $56, %rsp + movq %xmm0, (%rsp) + movq %xmm1, 8(%rsp) + movq %xmm2, 16(%rsp) + movq %xmm3, 24(%rsp) + movq %xmm4, 32(%rsp) + movq %xmm5, 40(%rsp) + call _x86_64_get_dispatch@PLT + movq 40(%rsp), %xmm5 + movq 32(%rsp), %xmm4 + movq 24(%rsp), %xmm3 + movq 16(%rsp), %xmm2 + movq 8(%rsp), %xmm1 + movq (%rsp), %xmm0 + addq $56, %rsp + movq 2312(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 2312(%rax), %r11 + jmp *%r11 +1: + subq $56, %rsp + movq %xmm0, (%rsp) + movq %xmm1, 8(%rsp) + movq %xmm2, 16(%rsp) + movq %xmm3, 24(%rsp) + movq %xmm4, 32(%rsp) + movq %xmm5, 40(%rsp) + call _glapi_get_dispatch + movq 40(%rsp), %xmm5 + movq 32(%rsp), %xmm4 + movq 24(%rsp), %xmm3 + movq 16(%rsp), %xmm2 + movq 8(%rsp), %xmm1 + movq (%rsp), %xmm0 + addq $56, %rsp + movq 2312(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_289), .-GL_PREFIX(_dispatch_stub_289) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_290) + .type GL_PREFIX(_dispatch_stub_290), @function + HIDDEN(GL_PREFIX(_dispatch_stub_290)) +GL_PREFIX(_dispatch_stub_290): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 2320(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rbp + call _x86_64_get_dispatch@PLT + popq %rbp + movq 2320(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 2320(%rax), %r11 + jmp *%r11 +1: + pushq %rbp + call _glapi_get_dispatch + popq %rbp + movq 2320(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_290), .-GL_PREFIX(_dispatch_stub_290) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_291) + .type GL_PREFIX(_dispatch_stub_291), @function + HIDDEN(GL_PREFIX(_dispatch_stub_291)) +GL_PREFIX(_dispatch_stub_291): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 2328(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + call _x86_64_get_dispatch@PLT + popq %rdi + movq 2328(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 2328(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + call _glapi_get_dispatch + popq %rdi + movq 2328(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_291), .-GL_PREFIX(_dispatch_stub_291) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_292) + .type GL_PREFIX(_dispatch_stub_292), @function + HIDDEN(GL_PREFIX(_dispatch_stub_292)) +GL_PREFIX(_dispatch_stub_292): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 2336(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + call _x86_64_get_dispatch@PLT + popq %rdi + movq 2336(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 2336(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + call _glapi_get_dispatch + popq %rdi + movq 2336(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_292), .-GL_PREFIX(_dispatch_stub_292) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_293) + .type GL_PREFIX(_dispatch_stub_293), @function + HIDDEN(GL_PREFIX(_dispatch_stub_293)) +GL_PREFIX(_dispatch_stub_293): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 2344(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + call _x86_64_get_dispatch@PLT + popq %rdi + movq 2344(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 2344(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + call _glapi_get_dispatch + popq %rdi + movq 2344(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_293), .-GL_PREFIX(_dispatch_stub_293) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_294) + .type GL_PREFIX(_dispatch_stub_294), @function + HIDDEN(GL_PREFIX(_dispatch_stub_294)) +GL_PREFIX(_dispatch_stub_294): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 2352(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + call _x86_64_get_dispatch@PLT + popq %rdi + movq 2352(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 2352(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + call _glapi_get_dispatch + popq %rdi + movq 2352(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_294), .-GL_PREFIX(_dispatch_stub_294) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_295) + .type GL_PREFIX(_dispatch_stub_295), @function + HIDDEN(GL_PREFIX(_dispatch_stub_295)) +GL_PREFIX(_dispatch_stub_295): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 2360(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + call _x86_64_get_dispatch@PLT + popq %rdi + movq 2360(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 2360(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + call _glapi_get_dispatch + popq %rdi + movq 2360(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_295), .-GL_PREFIX(_dispatch_stub_295) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_296) + .type GL_PREFIX(_dispatch_stub_296), @function + HIDDEN(GL_PREFIX(_dispatch_stub_296)) +GL_PREFIX(_dispatch_stub_296): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 2368(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + subq $56, %rsp + movq %xmm0, (%rsp) + movq %xmm1, 8(%rsp) + movq %xmm2, 16(%rsp) + movq %xmm3, 24(%rsp) + movq %xmm4, 32(%rsp) + movq %xmm5, 40(%rsp) + call _x86_64_get_dispatch@PLT + movq 40(%rsp), %xmm5 + movq 32(%rsp), %xmm4 + movq 24(%rsp), %xmm3 + movq 16(%rsp), %xmm2 + movq 8(%rsp), %xmm1 + movq (%rsp), %xmm0 + addq $56, %rsp + movq 2368(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 2368(%rax), %r11 + jmp *%r11 +1: + subq $56, %rsp + movq %xmm0, (%rsp) + movq %xmm1, 8(%rsp) + movq %xmm2, 16(%rsp) + movq %xmm3, 24(%rsp) + movq %xmm4, 32(%rsp) + movq %xmm5, 40(%rsp) + call _glapi_get_dispatch + movq 40(%rsp), %xmm5 + movq 32(%rsp), %xmm4 + movq 24(%rsp), %xmm3 + movq 16(%rsp), %xmm2 + movq 8(%rsp), %xmm1 + movq (%rsp), %xmm0 + addq $56, %rsp + movq 2368(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_296), .-GL_PREFIX(_dispatch_stub_296) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_297) + .type GL_PREFIX(_dispatch_stub_297), @function + HIDDEN(GL_PREFIX(_dispatch_stub_297)) +GL_PREFIX(_dispatch_stub_297): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 2376(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rbp + call _x86_64_get_dispatch@PLT + popq %rbp + movq 2376(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 2376(%rax), %r11 + jmp *%r11 +1: + pushq %rbp + call _glapi_get_dispatch + popq %rbp + movq 2376(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_297), .-GL_PREFIX(_dispatch_stub_297) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_298) + .type GL_PREFIX(_dispatch_stub_298), @function + HIDDEN(GL_PREFIX(_dispatch_stub_298)) +GL_PREFIX(_dispatch_stub_298): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 2384(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rbp + call _x86_64_get_dispatch@PLT + popq %rbp + movq 2384(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 2384(%rax), %r11 + jmp *%r11 +1: + pushq %rbp + call _glapi_get_dispatch + popq %rbp + movq 2384(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_298), .-GL_PREFIX(_dispatch_stub_298) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_299) + .type GL_PREFIX(_dispatch_stub_299), @function + HIDDEN(GL_PREFIX(_dispatch_stub_299)) +GL_PREFIX(_dispatch_stub_299): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 2392(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + subq $40, %rsp + movq %xmm0, (%rsp) + movq %xmm1, 8(%rsp) + movq %xmm2, 16(%rsp) + movq %xmm3, 24(%rsp) + call _x86_64_get_dispatch@PLT + movq 24(%rsp), %xmm3 + movq 16(%rsp), %xmm2 + movq 8(%rsp), %xmm1 + movq (%rsp), %xmm0 + addq $40, %rsp + movq 2392(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 2392(%rax), %r11 + jmp *%r11 +1: + subq $40, %rsp + movq %xmm0, (%rsp) + movq %xmm1, 8(%rsp) + movq %xmm2, 16(%rsp) + movq %xmm3, 24(%rsp) + call _glapi_get_dispatch + movq 24(%rsp), %xmm3 + movq 16(%rsp), %xmm2 + movq 8(%rsp), %xmm1 + movq (%rsp), %xmm0 + addq $40, %rsp + movq 2392(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_299), .-GL_PREFIX(_dispatch_stub_299) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_300) + .type GL_PREFIX(_dispatch_stub_300), @function + HIDDEN(GL_PREFIX(_dispatch_stub_300)) +GL_PREFIX(_dispatch_stub_300): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 2400(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + subq $40, %rsp + movq %xmm0, (%rsp) + movq %xmm1, 8(%rsp) + movq %xmm2, 16(%rsp) + movq %xmm3, 24(%rsp) + call _x86_64_get_dispatch@PLT + movq 24(%rsp), %xmm3 + movq 16(%rsp), %xmm2 + movq 8(%rsp), %xmm1 + movq (%rsp), %xmm0 + addq $40, %rsp + movq 2400(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 2400(%rax), %r11 + jmp *%r11 +1: + subq $40, %rsp + movq %xmm0, (%rsp) + movq %xmm1, 8(%rsp) + movq %xmm2, 16(%rsp) + movq %xmm3, 24(%rsp) + call _glapi_get_dispatch + movq 24(%rsp), %xmm3 + movq 16(%rsp), %xmm2 + movq 8(%rsp), %xmm1 + movq (%rsp), %xmm0 + addq $40, %rsp + movq 2400(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_300), .-GL_PREFIX(_dispatch_stub_300) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_301) + .type GL_PREFIX(_dispatch_stub_301), @function + HIDDEN(GL_PREFIX(_dispatch_stub_301)) +GL_PREFIX(_dispatch_stub_301): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 2408(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + subq $24, %rsp + movq %xmm0, (%rsp) + movq %xmm1, 8(%rsp) + movq %xmm2, 16(%rsp) + call _x86_64_get_dispatch@PLT + movq 16(%rsp), %xmm2 + movq 8(%rsp), %xmm1 + movq (%rsp), %xmm0 + addq $24, %rsp + movq 2408(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 2408(%rax), %r11 + jmp *%r11 +1: + subq $24, %rsp + movq %xmm0, (%rsp) + movq %xmm1, 8(%rsp) + movq %xmm2, 16(%rsp) + call _glapi_get_dispatch + movq 16(%rsp), %xmm2 + movq 8(%rsp), %xmm1 + movq (%rsp), %xmm0 + addq $24, %rsp + movq 2408(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_301), .-GL_PREFIX(_dispatch_stub_301) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_302) + .type GL_PREFIX(_dispatch_stub_302), @function + HIDDEN(GL_PREFIX(_dispatch_stub_302)) +GL_PREFIX(_dispatch_stub_302): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 2416(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + subq $24, %rsp + movq %xmm0, (%rsp) + movq %xmm1, 8(%rsp) + movq %xmm2, 16(%rsp) + call _x86_64_get_dispatch@PLT + movq 16(%rsp), %xmm2 + movq 8(%rsp), %xmm1 + movq (%rsp), %xmm0 + addq $24, %rsp + movq 2416(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 2416(%rax), %r11 + jmp *%r11 +1: + subq $24, %rsp + movq %xmm0, (%rsp) + movq %xmm1, 8(%rsp) + movq %xmm2, 16(%rsp) + call _glapi_get_dispatch + movq 16(%rsp), %xmm2 + movq 8(%rsp), %xmm1 + movq (%rsp), %xmm0 + addq $24, %rsp + movq 2416(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_302), .-GL_PREFIX(_dispatch_stub_302) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_303) + .type GL_PREFIX(_dispatch_stub_303), @function + HIDDEN(GL_PREFIX(_dispatch_stub_303)) +GL_PREFIX(_dispatch_stub_303): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 2424(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + subq $24, %rsp + movq %xmm0, (%rsp) + movq %xmm1, 8(%rsp) + movq %xmm2, 16(%rsp) + call _x86_64_get_dispatch@PLT + movq 16(%rsp), %xmm2 + movq 8(%rsp), %xmm1 + movq (%rsp), %xmm0 + addq $24, %rsp + movq 2424(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 2424(%rax), %r11 + jmp *%r11 +1: + subq $24, %rsp + movq %xmm0, (%rsp) + movq %xmm1, 8(%rsp) + movq %xmm2, 16(%rsp) + call _glapi_get_dispatch + movq 16(%rsp), %xmm2 + movq 8(%rsp), %xmm1 + movq (%rsp), %xmm0 + addq $24, %rsp + movq 2424(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_303), .-GL_PREFIX(_dispatch_stub_303) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_304) + .type GL_PREFIX(_dispatch_stub_304), @function + HIDDEN(GL_PREFIX(_dispatch_stub_304)) +GL_PREFIX(_dispatch_stub_304): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 2432(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + subq $24, %rsp + movq %xmm0, (%rsp) + movq %xmm1, 8(%rsp) + movq %xmm2, 16(%rsp) + call _x86_64_get_dispatch@PLT + movq 16(%rsp), %xmm2 + movq 8(%rsp), %xmm1 + movq (%rsp), %xmm0 + addq $24, %rsp + movq 2432(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 2432(%rax), %r11 + jmp *%r11 +1: + subq $24, %rsp + movq %xmm0, (%rsp) + movq %xmm1, 8(%rsp) + movq %xmm2, 16(%rsp) + call _glapi_get_dispatch + movq 16(%rsp), %xmm2 + movq 8(%rsp), %xmm1 + movq (%rsp), %xmm0 + addq $24, %rsp + movq 2432(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_304), .-GL_PREFIX(_dispatch_stub_304) + + .p2align 4,,15 + .globl GL_PREFIX(Viewport) + .type GL_PREFIX(Viewport), @function +GL_PREFIX(Viewport): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 2440(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rdx + pushq %rcx + pushq %rbp + call _x86_64_get_dispatch@PLT + popq %rbp + popq %rcx + popq %rdx + popq %rsi + popq %rdi + movq 2440(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 2440(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rdx + pushq %rcx + pushq %rbp + call _glapi_get_dispatch + popq %rbp + popq %rcx + popq %rdx + popq %rsi + popq %rdi + movq 2440(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(Viewport), .-GL_PREFIX(Viewport) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_306) + .type GL_PREFIX(_dispatch_stub_306), @function + HIDDEN(GL_PREFIX(_dispatch_stub_306)) +GL_PREFIX(_dispatch_stub_306): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 2448(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + call _x86_64_get_dispatch@PLT + popq %rdi + movq 2448(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 2448(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + call _glapi_get_dispatch + popq %rdi + movq 2448(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_306), .-GL_PREFIX(_dispatch_stub_306) + + .p2align 4,,15 + .globl GL_PREFIX(BindTexture) + .type GL_PREFIX(BindTexture), @function +GL_PREFIX(BindTexture): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 2456(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rbp + call _x86_64_get_dispatch@PLT + popq %rbp + popq %rsi + popq %rdi + movq 2456(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 2456(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rbp + call _glapi_get_dispatch + popq %rbp + popq %rsi + popq %rdi + movq 2456(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(BindTexture), .-GL_PREFIX(BindTexture) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_308) + .type GL_PREFIX(_dispatch_stub_308), @function + HIDDEN(GL_PREFIX(_dispatch_stub_308)) +GL_PREFIX(_dispatch_stub_308): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 2464(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rdx + pushq %rcx + pushq %rbp + call _x86_64_get_dispatch@PLT + popq %rbp + popq %rcx + popq %rdx + popq %rsi + popq %rdi + movq 2464(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 2464(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rdx + pushq %rcx + pushq %rbp + call _glapi_get_dispatch + popq %rbp + popq %rcx + popq %rdx + popq %rsi + popq %rdi + movq 2464(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_308), .-GL_PREFIX(_dispatch_stub_308) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_309) + .type GL_PREFIX(_dispatch_stub_309), @function + HIDDEN(GL_PREFIX(_dispatch_stub_309)) +GL_PREFIX(_dispatch_stub_309): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 2472(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + call _x86_64_get_dispatch@PLT + popq %rdi + movq 2472(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 2472(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + call _glapi_get_dispatch + popq %rdi + movq 2472(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_309), .-GL_PREFIX(_dispatch_stub_309) + + .p2align 4,,15 + .globl GL_PREFIX(DrawArrays) + .type GL_PREFIX(DrawArrays), @function +GL_PREFIX(DrawArrays): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 2480(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rdx + call _x86_64_get_dispatch@PLT + popq %rdx + popq %rsi + popq %rdi + movq 2480(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 2480(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rdx + call _glapi_get_dispatch + popq %rdx + popq %rsi + popq %rdi + movq 2480(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(DrawArrays), .-GL_PREFIX(DrawArrays) + + .p2align 4,,15 + .globl GL_PREFIX(DrawElements) + .type GL_PREFIX(DrawElements), @function +GL_PREFIX(DrawElements): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 2488(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rdx + pushq %rcx + pushq %rbp + call _x86_64_get_dispatch@PLT + popq %rbp + popq %rcx + popq %rdx + popq %rsi + popq %rdi + movq 2488(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 2488(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rdx + pushq %rcx + pushq %rbp + call _glapi_get_dispatch + popq %rbp + popq %rcx + popq %rdx + popq %rsi + popq %rdi + movq 2488(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(DrawElements), .-GL_PREFIX(DrawElements) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_312) + .type GL_PREFIX(_dispatch_stub_312), @function + HIDDEN(GL_PREFIX(_dispatch_stub_312)) +GL_PREFIX(_dispatch_stub_312): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 2496(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rbp + call _x86_64_get_dispatch@PLT + popq %rbp + popq %rsi + popq %rdi + movq 2496(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 2496(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rbp + call _glapi_get_dispatch + popq %rbp + popq %rsi + popq %rdi + movq 2496(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_312), .-GL_PREFIX(_dispatch_stub_312) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_313) + .type GL_PREFIX(_dispatch_stub_313), @function + HIDDEN(GL_PREFIX(_dispatch_stub_313)) +GL_PREFIX(_dispatch_stub_313): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 2504(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + call _x86_64_get_dispatch@PLT + popq %rdi + movq 2504(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 2504(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + call _glapi_get_dispatch + popq %rdi + movq 2504(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_313), .-GL_PREFIX(_dispatch_stub_313) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_314) + .type GL_PREFIX(_dispatch_stub_314), @function + HIDDEN(GL_PREFIX(_dispatch_stub_314)) +GL_PREFIX(_dispatch_stub_314): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 2512(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rdx + call _x86_64_get_dispatch@PLT + popq %rdx + popq %rsi + popq %rdi + movq 2512(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 2512(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rdx + call _glapi_get_dispatch + popq %rdx + popq %rsi + popq %rdi + movq 2512(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_314), .-GL_PREFIX(_dispatch_stub_314) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_315) + .type GL_PREFIX(_dispatch_stub_315), @function + HIDDEN(GL_PREFIX(_dispatch_stub_315)) +GL_PREFIX(_dispatch_stub_315): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 2520(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + call _x86_64_get_dispatch@PLT + popq %rdi + movq 2520(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 2520(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + call _glapi_get_dispatch + popq %rdi + movq 2520(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_315), .-GL_PREFIX(_dispatch_stub_315) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_316) + .type GL_PREFIX(_dispatch_stub_316), @function + HIDDEN(GL_PREFIX(_dispatch_stub_316)) +GL_PREFIX(_dispatch_stub_316): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 2528(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + call _x86_64_get_dispatch@PLT + popq %rdi + movq 2528(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 2528(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + call _glapi_get_dispatch + popq %rdi + movq 2528(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_316), .-GL_PREFIX(_dispatch_stub_316) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_317) + .type GL_PREFIX(_dispatch_stub_317), @function + HIDDEN(GL_PREFIX(_dispatch_stub_317)) +GL_PREFIX(_dispatch_stub_317): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 2536(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rdx + call _x86_64_get_dispatch@PLT + popq %rdx + popq %rsi + popq %rdi + movq 2536(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 2536(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rdx + call _glapi_get_dispatch + popq %rdx + popq %rsi + popq %rdi + movq 2536(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_317), .-GL_PREFIX(_dispatch_stub_317) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_318) + .type GL_PREFIX(_dispatch_stub_318), @function + HIDDEN(GL_PREFIX(_dispatch_stub_318)) +GL_PREFIX(_dispatch_stub_318): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 2544(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rdx + call _x86_64_get_dispatch@PLT + popq %rdx + popq %rsi + popq %rdi + movq 2544(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 2544(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rdx + call _glapi_get_dispatch + popq %rdx + popq %rsi + popq %rdi + movq 2544(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_318), .-GL_PREFIX(_dispatch_stub_318) + + .p2align 4,,15 + .globl GL_PREFIX(PolygonOffset) + .type GL_PREFIX(PolygonOffset), @function +GL_PREFIX(PolygonOffset): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 2552(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + subq $24, %rsp + movq %xmm0, (%rsp) + movq %xmm1, 8(%rsp) + call _x86_64_get_dispatch@PLT + movq 8(%rsp), %xmm1 + movq (%rsp), %xmm0 + addq $24, %rsp + movq 2552(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 2552(%rax), %r11 + jmp *%r11 +1: + subq $24, %rsp + movq %xmm0, (%rsp) + movq %xmm1, 8(%rsp) + call _glapi_get_dispatch + movq 8(%rsp), %xmm1 + movq (%rsp), %xmm0 + addq $24, %rsp + movq 2552(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(PolygonOffset), .-GL_PREFIX(PolygonOffset) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_320) + .type GL_PREFIX(_dispatch_stub_320), @function + HIDDEN(GL_PREFIX(_dispatch_stub_320)) +GL_PREFIX(_dispatch_stub_320): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 2560(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rdx + pushq %rcx + pushq %rbp + call _x86_64_get_dispatch@PLT + popq %rbp + popq %rcx + popq %rdx + popq %rsi + popq %rdi + movq 2560(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 2560(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rdx + pushq %rcx + pushq %rbp + call _glapi_get_dispatch + popq %rbp + popq %rcx + popq %rdx + popq %rsi + popq %rdi + movq 2560(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_320), .-GL_PREFIX(_dispatch_stub_320) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_321) + .type GL_PREFIX(_dispatch_stub_321), @function + HIDDEN(GL_PREFIX(_dispatch_stub_321)) +GL_PREFIX(_dispatch_stub_321): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 2568(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rdx + pushq %rcx + pushq %rbp + call _x86_64_get_dispatch@PLT + popq %rbp + popq %rcx + popq %rdx + popq %rsi + popq %rdi + movq 2568(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 2568(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rdx + pushq %rcx + pushq %rbp + call _glapi_get_dispatch + popq %rbp + popq %rcx + popq %rdx + popq %rsi + popq %rdi + movq 2568(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_321), .-GL_PREFIX(_dispatch_stub_321) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_322) + .type GL_PREFIX(_dispatch_stub_322), @function + HIDDEN(GL_PREFIX(_dispatch_stub_322)) +GL_PREFIX(_dispatch_stub_322): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 2576(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rdx + call _x86_64_get_dispatch@PLT + popq %rdx + popq %rsi + popq %rdi + movq 2576(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 2576(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rdx + call _glapi_get_dispatch + popq %rdx + popq %rsi + popq %rdi + movq 2576(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_322), .-GL_PREFIX(_dispatch_stub_322) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_323) + .type GL_PREFIX(_dispatch_stub_323), @function + HIDDEN(GL_PREFIX(_dispatch_stub_323)) +GL_PREFIX(_dispatch_stub_323): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 2584(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rdx + pushq %rcx + pushq %r8 + pushq %r9 + pushq %rbp + call _x86_64_get_dispatch@PLT + popq %rbp + popq %r9 + popq %r8 + popq %rcx + popq %rdx + popq %rsi + popq %rdi + movq 2584(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 2584(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rdx + pushq %rcx + pushq %r8 + pushq %r9 + pushq %rbp + call _glapi_get_dispatch + popq %rbp + popq %r9 + popq %r8 + popq %rcx + popq %rdx + popq %rsi + popq %rdi + movq 2584(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_323), .-GL_PREFIX(_dispatch_stub_323) + + .p2align 4,,15 + .globl GL_PREFIX(CopyTexImage2D) + .type GL_PREFIX(CopyTexImage2D), @function +GL_PREFIX(CopyTexImage2D): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 2592(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rdx + pushq %rcx + pushq %r8 + pushq %r9 + pushq %rbp + call _x86_64_get_dispatch@PLT + popq %rbp + popq %r9 + popq %r8 + popq %rcx + popq %rdx + popq %rsi + popq %rdi + movq 2592(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 2592(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rdx + pushq %rcx + pushq %r8 + pushq %r9 + pushq %rbp + call _glapi_get_dispatch + popq %rbp + popq %r9 + popq %r8 + popq %rcx + popq %rdx + popq %rsi + popq %rdi + movq 2592(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(CopyTexImage2D), .-GL_PREFIX(CopyTexImage2D) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_325) + .type GL_PREFIX(_dispatch_stub_325), @function + HIDDEN(GL_PREFIX(_dispatch_stub_325)) +GL_PREFIX(_dispatch_stub_325): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 2600(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rdx + pushq %rcx + pushq %r8 + pushq %r9 + pushq %rbp + call _x86_64_get_dispatch@PLT + popq %rbp + popq %r9 + popq %r8 + popq %rcx + popq %rdx + popq %rsi + popq %rdi + movq 2600(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 2600(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rdx + pushq %rcx + pushq %r8 + pushq %r9 + pushq %rbp + call _glapi_get_dispatch + popq %rbp + popq %r9 + popq %r8 + popq %rcx + popq %rdx + popq %rsi + popq %rdi + movq 2600(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_325), .-GL_PREFIX(_dispatch_stub_325) + + .p2align 4,,15 + .globl GL_PREFIX(CopyTexSubImage2D) + .type GL_PREFIX(CopyTexSubImage2D), @function +GL_PREFIX(CopyTexSubImage2D): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 2608(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rdx + pushq %rcx + pushq %r8 + pushq %r9 + pushq %rbp + call _x86_64_get_dispatch@PLT + popq %rbp + popq %r9 + popq %r8 + popq %rcx + popq %rdx + popq %rsi + popq %rdi + movq 2608(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 2608(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rdx + pushq %rcx + pushq %r8 + pushq %r9 + pushq %rbp + call _glapi_get_dispatch + popq %rbp + popq %r9 + popq %r8 + popq %rcx + popq %rdx + popq %rsi + popq %rdi + movq 2608(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(CopyTexSubImage2D), .-GL_PREFIX(CopyTexSubImage2D) + + .p2align 4,,15 + .globl GL_PREFIX(DeleteTextures) + .type GL_PREFIX(DeleteTextures), @function +GL_PREFIX(DeleteTextures): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 2616(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rbp + call _x86_64_get_dispatch@PLT + popq %rbp + popq %rsi + popq %rdi + movq 2616(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 2616(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rbp + call _glapi_get_dispatch + popq %rbp + popq %rsi + popq %rdi + movq 2616(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(DeleteTextures), .-GL_PREFIX(DeleteTextures) + + .p2align 4,,15 + .globl GL_PREFIX(GenTextures) + .type GL_PREFIX(GenTextures), @function +GL_PREFIX(GenTextures): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 2624(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rbp + call _x86_64_get_dispatch@PLT + popq %rbp + popq %rsi + popq %rdi + movq 2624(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 2624(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rbp + call _glapi_get_dispatch + popq %rbp + popq %rsi + popq %rdi + movq 2624(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(GenTextures), .-GL_PREFIX(GenTextures) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_329) + .type GL_PREFIX(_dispatch_stub_329), @function + HIDDEN(GL_PREFIX(_dispatch_stub_329)) +GL_PREFIX(_dispatch_stub_329): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 2632(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rbp + call _x86_64_get_dispatch@PLT + popq %rbp + popq %rsi + popq %rdi + movq 2632(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 2632(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rbp + call _glapi_get_dispatch + popq %rbp + popq %rsi + popq %rdi + movq 2632(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_329), .-GL_PREFIX(_dispatch_stub_329) + + .p2align 4,,15 + .globl GL_PREFIX(IsTexture) + .type GL_PREFIX(IsTexture), @function +GL_PREFIX(IsTexture): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 2640(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + call _x86_64_get_dispatch@PLT + popq %rdi + movq 2640(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 2640(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + call _glapi_get_dispatch + popq %rdi + movq 2640(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(IsTexture), .-GL_PREFIX(IsTexture) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_331) + .type GL_PREFIX(_dispatch_stub_331), @function + HIDDEN(GL_PREFIX(_dispatch_stub_331)) +GL_PREFIX(_dispatch_stub_331): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 2648(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rdx + call _x86_64_get_dispatch@PLT + popq %rdx + popq %rsi + popq %rdi + movq 2648(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 2648(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rdx + call _glapi_get_dispatch + popq %rdx + popq %rsi + popq %rdi + movq 2648(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_331), .-GL_PREFIX(_dispatch_stub_331) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_332) + .type GL_PREFIX(_dispatch_stub_332), @function + HIDDEN(GL_PREFIX(_dispatch_stub_332)) +GL_PREFIX(_dispatch_stub_332): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 2656(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rdx + pushq %rcx + pushq %r8 + pushq %r9 + pushq %rbp + call _x86_64_get_dispatch@PLT + popq %rbp + popq %r9 + popq %r8 + popq %rcx + popq %rdx + popq %rsi + popq %rdi + movq 2656(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 2656(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rdx + pushq %rcx + pushq %r8 + pushq %r9 + pushq %rbp + call _glapi_get_dispatch + popq %rbp + popq %r9 + popq %r8 + popq %rcx + popq %rdx + popq %rsi + popq %rdi + movq 2656(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_332), .-GL_PREFIX(_dispatch_stub_332) + + .p2align 4,,15 + .globl GL_PREFIX(TexSubImage2D) + .type GL_PREFIX(TexSubImage2D), @function +GL_PREFIX(TexSubImage2D): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 2664(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rdx + pushq %rcx + pushq %r8 + pushq %r9 + pushq %rbp + call _x86_64_get_dispatch@PLT + popq %rbp + popq %r9 + popq %r8 + popq %rcx + popq %rdx + popq %rsi + popq %rdi + movq 2664(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 2664(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rdx + pushq %rcx + pushq %r8 + pushq %r9 + pushq %rbp + call _glapi_get_dispatch + popq %rbp + popq %r9 + popq %r8 + popq %rcx + popq %rdx + popq %rsi + popq %rdi + movq 2664(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(TexSubImage2D), .-GL_PREFIX(TexSubImage2D) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_334) + .type GL_PREFIX(_dispatch_stub_334), @function + HIDDEN(GL_PREFIX(_dispatch_stub_334)) +GL_PREFIX(_dispatch_stub_334): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 2672(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rbp + call _x86_64_get_dispatch@PLT + popq %rbp + movq 2672(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 2672(%rax), %r11 + jmp *%r11 +1: + pushq %rbp + call _glapi_get_dispatch + popq %rbp + movq 2672(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_334), .-GL_PREFIX(_dispatch_stub_334) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_335) + .type GL_PREFIX(_dispatch_stub_335), @function + HIDDEN(GL_PREFIX(_dispatch_stub_335)) +GL_PREFIX(_dispatch_stub_335): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 2680(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + call _x86_64_get_dispatch@PLT + popq %rdi + movq 2680(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 2680(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + call _glapi_get_dispatch + popq %rdi + movq 2680(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_335), .-GL_PREFIX(_dispatch_stub_335) + + .p2align 4,,15 + .globl GL_PREFIX(BlendColor) + .type GL_PREFIX(BlendColor), @function +GL_PREFIX(BlendColor): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 2688(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rdx + pushq %rcx + pushq %rbp + call _x86_64_get_dispatch@PLT + popq %rbp + popq %rcx + popq %rdx + popq %rsi + popq %rdi + movq 2688(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 2688(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rdx + pushq %rcx + pushq %rbp + call _glapi_get_dispatch + popq %rbp + popq %rcx + popq %rdx + popq %rsi + popq %rdi + movq 2688(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(BlendColor), .-GL_PREFIX(BlendColor) + + .p2align 4,,15 + .globl GL_PREFIX(BlendEquation) + .type GL_PREFIX(BlendEquation), @function +GL_PREFIX(BlendEquation): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 2696(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + call _x86_64_get_dispatch@PLT + popq %rdi + movq 2696(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 2696(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + call _glapi_get_dispatch + popq %rdi + movq 2696(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(BlendEquation), .-GL_PREFIX(BlendEquation) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_338) + .type GL_PREFIX(_dispatch_stub_338), @function + HIDDEN(GL_PREFIX(_dispatch_stub_338)) +GL_PREFIX(_dispatch_stub_338): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 2704(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rdx + pushq %rcx + pushq %r8 + pushq %r9 + pushq %rbp + call _x86_64_get_dispatch@PLT + popq %rbp + popq %r9 + popq %r8 + popq %rcx + popq %rdx + popq %rsi + popq %rdi + movq 2704(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 2704(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rdx + pushq %rcx + pushq %r8 + pushq %r9 + pushq %rbp + call _glapi_get_dispatch + popq %rbp + popq %r9 + popq %r8 + popq %rcx + popq %rdx + popq %rsi + popq %rdi + movq 2704(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_338), .-GL_PREFIX(_dispatch_stub_338) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_339) + .type GL_PREFIX(_dispatch_stub_339), @function + HIDDEN(GL_PREFIX(_dispatch_stub_339)) +GL_PREFIX(_dispatch_stub_339): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 2712(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rdx + pushq %rcx + pushq %r8 + pushq %r9 + pushq %rbp + call _x86_64_get_dispatch@PLT + popq %rbp + popq %r9 + popq %r8 + popq %rcx + popq %rdx + popq %rsi + popq %rdi + movq 2712(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 2712(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rdx + pushq %rcx + pushq %r8 + pushq %r9 + pushq %rbp + call _glapi_get_dispatch + popq %rbp + popq %r9 + popq %r8 + popq %rcx + popq %rdx + popq %rsi + popq %rdi + movq 2712(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_339), .-GL_PREFIX(_dispatch_stub_339) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_340) + .type GL_PREFIX(_dispatch_stub_340), @function + HIDDEN(GL_PREFIX(_dispatch_stub_340)) +GL_PREFIX(_dispatch_stub_340): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 2720(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rdx + call _x86_64_get_dispatch@PLT + popq %rdx + popq %rsi + popq %rdi + movq 2720(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 2720(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rdx + call _glapi_get_dispatch + popq %rdx + popq %rsi + popq %rdi + movq 2720(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_340), .-GL_PREFIX(_dispatch_stub_340) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_341) + .type GL_PREFIX(_dispatch_stub_341), @function + HIDDEN(GL_PREFIX(_dispatch_stub_341)) +GL_PREFIX(_dispatch_stub_341): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 2728(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rdx + call _x86_64_get_dispatch@PLT + popq %rdx + popq %rsi + popq %rdi + movq 2728(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 2728(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rdx + call _glapi_get_dispatch + popq %rdx + popq %rsi + popq %rdi + movq 2728(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_341), .-GL_PREFIX(_dispatch_stub_341) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_342) + .type GL_PREFIX(_dispatch_stub_342), @function + HIDDEN(GL_PREFIX(_dispatch_stub_342)) +GL_PREFIX(_dispatch_stub_342): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 2736(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rdx + pushq %rcx + pushq %r8 + call _x86_64_get_dispatch@PLT + popq %r8 + popq %rcx + popq %rdx + popq %rsi + popq %rdi + movq 2736(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 2736(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rdx + pushq %rcx + pushq %r8 + call _glapi_get_dispatch + popq %r8 + popq %rcx + popq %rdx + popq %rsi + popq %rdi + movq 2736(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_342), .-GL_PREFIX(_dispatch_stub_342) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_343) + .type GL_PREFIX(_dispatch_stub_343), @function + HIDDEN(GL_PREFIX(_dispatch_stub_343)) +GL_PREFIX(_dispatch_stub_343): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 2744(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rdx + pushq %rcx + pushq %rbp + call _x86_64_get_dispatch@PLT + popq %rbp + popq %rcx + popq %rdx + popq %rsi + popq %rdi + movq 2744(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 2744(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rdx + pushq %rcx + pushq %rbp + call _glapi_get_dispatch + popq %rbp + popq %rcx + popq %rdx + popq %rsi + popq %rdi + movq 2744(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_343), .-GL_PREFIX(_dispatch_stub_343) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_344) + .type GL_PREFIX(_dispatch_stub_344), @function + HIDDEN(GL_PREFIX(_dispatch_stub_344)) +GL_PREFIX(_dispatch_stub_344): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 2752(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rdx + call _x86_64_get_dispatch@PLT + popq %rdx + popq %rsi + popq %rdi + movq 2752(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 2752(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rdx + call _glapi_get_dispatch + popq %rdx + popq %rsi + popq %rdi + movq 2752(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_344), .-GL_PREFIX(_dispatch_stub_344) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_345) + .type GL_PREFIX(_dispatch_stub_345), @function + HIDDEN(GL_PREFIX(_dispatch_stub_345)) +GL_PREFIX(_dispatch_stub_345): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 2760(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rdx + call _x86_64_get_dispatch@PLT + popq %rdx + popq %rsi + popq %rdi + movq 2760(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 2760(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rdx + call _glapi_get_dispatch + popq %rdx + popq %rsi + popq %rdi + movq 2760(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_345), .-GL_PREFIX(_dispatch_stub_345) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_346) + .type GL_PREFIX(_dispatch_stub_346), @function + HIDDEN(GL_PREFIX(_dispatch_stub_346)) +GL_PREFIX(_dispatch_stub_346): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 2768(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rdx + pushq %rcx + pushq %r8 + pushq %r9 + pushq %rbp + call _x86_64_get_dispatch@PLT + popq %rbp + popq %r9 + popq %r8 + popq %rcx + popq %rdx + popq %rsi + popq %rdi + movq 2768(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 2768(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rdx + pushq %rcx + pushq %r8 + pushq %r9 + pushq %rbp + call _glapi_get_dispatch + popq %rbp + popq %r9 + popq %r8 + popq %rcx + popq %rdx + popq %rsi + popq %rdi + movq 2768(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_346), .-GL_PREFIX(_dispatch_stub_346) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_347) + .type GL_PREFIX(_dispatch_stub_347), @function + HIDDEN(GL_PREFIX(_dispatch_stub_347)) +GL_PREFIX(_dispatch_stub_347): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 2776(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rdx + pushq %rcx + pushq %r8 + call _x86_64_get_dispatch@PLT + popq %r8 + popq %rcx + popq %rdx + popq %rsi + popq %rdi + movq 2776(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 2776(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rdx + pushq %rcx + pushq %r8 + call _glapi_get_dispatch + popq %r8 + popq %rcx + popq %rdx + popq %rsi + popq %rdi + movq 2776(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_347), .-GL_PREFIX(_dispatch_stub_347) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_348) + .type GL_PREFIX(_dispatch_stub_348), @function + HIDDEN(GL_PREFIX(_dispatch_stub_348)) +GL_PREFIX(_dispatch_stub_348): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 2784(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rdx + pushq %rcx + pushq %r8 + pushq %r9 + pushq %rbp + call _x86_64_get_dispatch@PLT + popq %rbp + popq %r9 + popq %r8 + popq %rcx + popq %rdx + popq %rsi + popq %rdi + movq 2784(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 2784(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rdx + pushq %rcx + pushq %r8 + pushq %r9 + pushq %rbp + call _glapi_get_dispatch + popq %rbp + popq %r9 + popq %r8 + popq %rcx + popq %rdx + popq %rsi + popq %rdi + movq 2784(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_348), .-GL_PREFIX(_dispatch_stub_348) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_349) + .type GL_PREFIX(_dispatch_stub_349), @function + HIDDEN(GL_PREFIX(_dispatch_stub_349)) +GL_PREFIX(_dispatch_stub_349): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 2792(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rdx + pushq %rcx + pushq %r8 + pushq %r9 + pushq %rbp + call _x86_64_get_dispatch@PLT + popq %rbp + popq %r9 + popq %r8 + popq %rcx + popq %rdx + popq %rsi + popq %rdi + movq 2792(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 2792(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rdx + pushq %rcx + pushq %r8 + pushq %r9 + pushq %rbp + call _glapi_get_dispatch + popq %rbp + popq %r9 + popq %r8 + popq %rcx + popq %rdx + popq %rsi + popq %rdi + movq 2792(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_349), .-GL_PREFIX(_dispatch_stub_349) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_350) + .type GL_PREFIX(_dispatch_stub_350), @function + HIDDEN(GL_PREFIX(_dispatch_stub_350)) +GL_PREFIX(_dispatch_stub_350): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 2800(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + subq $24, %rsp + movq %rdi, (%rsp) + movq %rsi, 8(%rsp) + movq %xmm0, 16(%rsp) + call _x86_64_get_dispatch@PLT + movq 16(%rsp), %xmm0 + movq 8(%rsp), %rsi + movq (%rsp), %rdi + addq $24, %rsp + movq 2800(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 2800(%rax), %r11 + jmp *%r11 +1: + subq $24, %rsp + movq %rdi, (%rsp) + movq %rsi, 8(%rsp) + movq %xmm0, 16(%rsp) + call _glapi_get_dispatch + movq 16(%rsp), %xmm0 + movq 8(%rsp), %rsi + movq (%rsp), %rdi + addq $24, %rsp + movq 2800(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_350), .-GL_PREFIX(_dispatch_stub_350) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_351) + .type GL_PREFIX(_dispatch_stub_351), @function + HIDDEN(GL_PREFIX(_dispatch_stub_351)) +GL_PREFIX(_dispatch_stub_351): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 2808(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rdx + call _x86_64_get_dispatch@PLT + popq %rdx + popq %rsi + popq %rdi + movq 2808(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 2808(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rdx + call _glapi_get_dispatch + popq %rdx + popq %rsi + popq %rdi + movq 2808(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_351), .-GL_PREFIX(_dispatch_stub_351) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_352) + .type GL_PREFIX(_dispatch_stub_352), @function + HIDDEN(GL_PREFIX(_dispatch_stub_352)) +GL_PREFIX(_dispatch_stub_352): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 2816(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rdx + call _x86_64_get_dispatch@PLT + popq %rdx + popq %rsi + popq %rdi + movq 2816(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 2816(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rdx + call _glapi_get_dispatch + popq %rdx + popq %rsi + popq %rdi + movq 2816(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_352), .-GL_PREFIX(_dispatch_stub_352) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_353) + .type GL_PREFIX(_dispatch_stub_353), @function + HIDDEN(GL_PREFIX(_dispatch_stub_353)) +GL_PREFIX(_dispatch_stub_353): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 2824(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rdx + call _x86_64_get_dispatch@PLT + popq %rdx + popq %rsi + popq %rdi + movq 2824(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 2824(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rdx + call _glapi_get_dispatch + popq %rdx + popq %rsi + popq %rdi + movq 2824(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_353), .-GL_PREFIX(_dispatch_stub_353) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_354) + .type GL_PREFIX(_dispatch_stub_354), @function + HIDDEN(GL_PREFIX(_dispatch_stub_354)) +GL_PREFIX(_dispatch_stub_354): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 2832(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rdx + pushq %rcx + pushq %r8 + call _x86_64_get_dispatch@PLT + popq %r8 + popq %rcx + popq %rdx + popq %rsi + popq %rdi + movq 2832(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 2832(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rdx + pushq %rcx + pushq %r8 + call _glapi_get_dispatch + popq %r8 + popq %rcx + popq %rdx + popq %rsi + popq %rdi + movq 2832(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_354), .-GL_PREFIX(_dispatch_stub_354) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_355) + .type GL_PREFIX(_dispatch_stub_355), @function + HIDDEN(GL_PREFIX(_dispatch_stub_355)) +GL_PREFIX(_dispatch_stub_355): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 2840(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rdx + pushq %rcx + pushq %r8 + pushq %r9 + pushq %rbp + call _x86_64_get_dispatch@PLT + popq %rbp + popq %r9 + popq %r8 + popq %rcx + popq %rdx + popq %rsi + popq %rdi + movq 2840(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 2840(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rdx + pushq %rcx + pushq %r8 + pushq %r9 + pushq %rbp + call _glapi_get_dispatch + popq %rbp + popq %r9 + popq %r8 + popq %rcx + popq %rdx + popq %rsi + popq %rdi + movq 2840(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_355), .-GL_PREFIX(_dispatch_stub_355) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_356) + .type GL_PREFIX(_dispatch_stub_356), @function + HIDDEN(GL_PREFIX(_dispatch_stub_356)) +GL_PREFIX(_dispatch_stub_356): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 2848(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rdx + pushq %rcx + pushq %rbp + call _x86_64_get_dispatch@PLT + popq %rbp + popq %rcx + popq %rdx + popq %rsi + popq %rdi + movq 2848(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 2848(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rdx + pushq %rcx + pushq %rbp + call _glapi_get_dispatch + popq %rbp + popq %rcx + popq %rdx + popq %rsi + popq %rdi + movq 2848(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_356), .-GL_PREFIX(_dispatch_stub_356) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_357) + .type GL_PREFIX(_dispatch_stub_357), @function + HIDDEN(GL_PREFIX(_dispatch_stub_357)) +GL_PREFIX(_dispatch_stub_357): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 2856(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rdx + call _x86_64_get_dispatch@PLT + popq %rdx + popq %rsi + popq %rdi + movq 2856(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 2856(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rdx + call _glapi_get_dispatch + popq %rdx + popq %rsi + popq %rdi + movq 2856(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_357), .-GL_PREFIX(_dispatch_stub_357) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_358) + .type GL_PREFIX(_dispatch_stub_358), @function + HIDDEN(GL_PREFIX(_dispatch_stub_358)) +GL_PREFIX(_dispatch_stub_358): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 2864(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rdx + call _x86_64_get_dispatch@PLT + popq %rdx + popq %rsi + popq %rdi + movq 2864(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 2864(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rdx + call _glapi_get_dispatch + popq %rdx + popq %rsi + popq %rdi + movq 2864(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_358), .-GL_PREFIX(_dispatch_stub_358) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_359) + .type GL_PREFIX(_dispatch_stub_359), @function + HIDDEN(GL_PREFIX(_dispatch_stub_359)) +GL_PREFIX(_dispatch_stub_359): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 2872(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rdx + pushq %rcx + pushq %r8 + pushq %r9 + pushq %rbp + call _x86_64_get_dispatch@PLT + popq %rbp + popq %r9 + popq %r8 + popq %rcx + popq %rdx + popq %rsi + popq %rdi + movq 2872(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 2872(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rdx + pushq %rcx + pushq %r8 + pushq %r9 + pushq %rbp + call _glapi_get_dispatch + popq %rbp + popq %r9 + popq %r8 + popq %rcx + popq %rdx + popq %rsi + popq %rdi + movq 2872(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_359), .-GL_PREFIX(_dispatch_stub_359) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_360) + .type GL_PREFIX(_dispatch_stub_360), @function + HIDDEN(GL_PREFIX(_dispatch_stub_360)) +GL_PREFIX(_dispatch_stub_360): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 2880(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rdx + pushq %rcx + pushq %r8 + pushq %r9 + pushq %rbp + call _x86_64_get_dispatch@PLT + popq %rbp + popq %r9 + popq %r8 + popq %rcx + popq %rdx + popq %rsi + popq %rdi + movq 2880(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 2880(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rdx + pushq %rcx + pushq %r8 + pushq %r9 + pushq %rbp + call _glapi_get_dispatch + popq %rbp + popq %r9 + popq %r8 + popq %rcx + popq %rdx + popq %rsi + popq %rdi + movq 2880(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_360), .-GL_PREFIX(_dispatch_stub_360) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_361) + .type GL_PREFIX(_dispatch_stub_361), @function + HIDDEN(GL_PREFIX(_dispatch_stub_361)) +GL_PREFIX(_dispatch_stub_361): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 2888(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rdx + pushq %rcx + pushq %r8 + call _x86_64_get_dispatch@PLT + popq %r8 + popq %rcx + popq %rdx + popq %rsi + popq %rdi + movq 2888(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 2888(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rdx + pushq %rcx + pushq %r8 + call _glapi_get_dispatch + popq %r8 + popq %rcx + popq %rdx + popq %rsi + popq %rdi + movq 2888(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_361), .-GL_PREFIX(_dispatch_stub_361) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_362) + .type GL_PREFIX(_dispatch_stub_362), @function + HIDDEN(GL_PREFIX(_dispatch_stub_362)) +GL_PREFIX(_dispatch_stub_362): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 2896(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rdx + call _x86_64_get_dispatch@PLT + popq %rdx + popq %rsi + popq %rdi + movq 2896(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 2896(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rdx + call _glapi_get_dispatch + popq %rdx + popq %rsi + popq %rdi + movq 2896(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_362), .-GL_PREFIX(_dispatch_stub_362) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_363) + .type GL_PREFIX(_dispatch_stub_363), @function + HIDDEN(GL_PREFIX(_dispatch_stub_363)) +GL_PREFIX(_dispatch_stub_363): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 2904(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rdx + call _x86_64_get_dispatch@PLT + popq %rdx + popq %rsi + popq %rdi + movq 2904(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 2904(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rdx + call _glapi_get_dispatch + popq %rdx + popq %rsi + popq %rdi + movq 2904(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_363), .-GL_PREFIX(_dispatch_stub_363) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_364) + .type GL_PREFIX(_dispatch_stub_364), @function + HIDDEN(GL_PREFIX(_dispatch_stub_364)) +GL_PREFIX(_dispatch_stub_364): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 2912(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rdx + pushq %rcx + pushq %r8 + call _x86_64_get_dispatch@PLT + popq %r8 + popq %rcx + popq %rdx + popq %rsi + popq %rdi + movq 2912(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 2912(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rdx + pushq %rcx + pushq %r8 + call _glapi_get_dispatch + popq %r8 + popq %rcx + popq %rdx + popq %rsi + popq %rdi + movq 2912(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_364), .-GL_PREFIX(_dispatch_stub_364) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_365) + .type GL_PREFIX(_dispatch_stub_365), @function + HIDDEN(GL_PREFIX(_dispatch_stub_365)) +GL_PREFIX(_dispatch_stub_365): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 2920(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rdx + call _x86_64_get_dispatch@PLT + popq %rdx + popq %rsi + popq %rdi + movq 2920(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 2920(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rdx + call _glapi_get_dispatch + popq %rdx + popq %rsi + popq %rdi + movq 2920(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_365), .-GL_PREFIX(_dispatch_stub_365) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_366) + .type GL_PREFIX(_dispatch_stub_366), @function + HIDDEN(GL_PREFIX(_dispatch_stub_366)) +GL_PREFIX(_dispatch_stub_366): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 2928(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rdx + call _x86_64_get_dispatch@PLT + popq %rdx + popq %rsi + popq %rdi + movq 2928(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 2928(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rdx + call _glapi_get_dispatch + popq %rdx + popq %rsi + popq %rdi + movq 2928(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_366), .-GL_PREFIX(_dispatch_stub_366) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_367) + .type GL_PREFIX(_dispatch_stub_367), @function + HIDDEN(GL_PREFIX(_dispatch_stub_367)) +GL_PREFIX(_dispatch_stub_367): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 2936(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rdx + pushq %rcx + pushq %rbp + call _x86_64_get_dispatch@PLT + popq %rbp + popq %rcx + popq %rdx + popq %rsi + popq %rdi + movq 2936(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 2936(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rdx + pushq %rcx + pushq %rbp + call _glapi_get_dispatch + popq %rbp + popq %rcx + popq %rdx + popq %rsi + popq %rdi + movq 2936(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_367), .-GL_PREFIX(_dispatch_stub_367) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_368) + .type GL_PREFIX(_dispatch_stub_368), @function + HIDDEN(GL_PREFIX(_dispatch_stub_368)) +GL_PREFIX(_dispatch_stub_368): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 2944(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rdx + call _x86_64_get_dispatch@PLT + popq %rdx + popq %rsi + popq %rdi + movq 2944(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 2944(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rdx + call _glapi_get_dispatch + popq %rdx + popq %rsi + popq %rdi + movq 2944(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_368), .-GL_PREFIX(_dispatch_stub_368) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_369) + .type GL_PREFIX(_dispatch_stub_369), @function + HIDDEN(GL_PREFIX(_dispatch_stub_369)) +GL_PREFIX(_dispatch_stub_369): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 2952(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + call _x86_64_get_dispatch@PLT + popq %rdi + movq 2952(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 2952(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + call _glapi_get_dispatch + popq %rdi + movq 2952(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_369), .-GL_PREFIX(_dispatch_stub_369) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_370) + .type GL_PREFIX(_dispatch_stub_370), @function + HIDDEN(GL_PREFIX(_dispatch_stub_370)) +GL_PREFIX(_dispatch_stub_370): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 2960(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + call _x86_64_get_dispatch@PLT + popq %rdi + movq 2960(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 2960(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + call _glapi_get_dispatch + popq %rdi + movq 2960(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_370), .-GL_PREFIX(_dispatch_stub_370) + + .p2align 4,,15 + .globl GL_PREFIX(TexImage3DOES) + .type GL_PREFIX(TexImage3DOES), @function +GL_PREFIX(TexImage3DOES): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 2968(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rdx + pushq %rcx + pushq %r8 + pushq %r9 + pushq %rbp + call _x86_64_get_dispatch@PLT + popq %rbp + popq %r9 + popq %r8 + popq %rcx + popq %rdx + popq %rsi + popq %rdi + movq 2968(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 2968(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rdx + pushq %rcx + pushq %r8 + pushq %r9 + pushq %rbp + call _glapi_get_dispatch + popq %rbp + popq %r9 + popq %r8 + popq %rcx + popq %rdx + popq %rsi + popq %rdi + movq 2968(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(TexImage3DOES), .-GL_PREFIX(TexImage3DOES) + + .p2align 4,,15 + .globl GL_PREFIX(TexSubImage3DOES) + .type GL_PREFIX(TexSubImage3DOES), @function +GL_PREFIX(TexSubImage3DOES): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 2976(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rdx + pushq %rcx + pushq %r8 + pushq %r9 + pushq %rbp + call _x86_64_get_dispatch@PLT + popq %rbp + popq %r9 + popq %r8 + popq %rcx + popq %rdx + popq %rsi + popq %rdi + movq 2976(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 2976(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rdx + pushq %rcx + pushq %r8 + pushq %r9 + pushq %rbp + call _glapi_get_dispatch + popq %rbp + popq %r9 + popq %r8 + popq %rcx + popq %rdx + popq %rsi + popq %rdi + movq 2976(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(TexSubImage3DOES), .-GL_PREFIX(TexSubImage3DOES) + + .p2align 4,,15 + .globl GL_PREFIX(CopyTexSubImage3DOES) + .type GL_PREFIX(CopyTexSubImage3DOES), @function +GL_PREFIX(CopyTexSubImage3DOES): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 2984(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rdx + pushq %rcx + pushq %r8 + pushq %r9 + pushq %rbp + call _x86_64_get_dispatch@PLT + popq %rbp + popq %r9 + popq %r8 + popq %rcx + popq %rdx + popq %rsi + popq %rdi + movq 2984(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 2984(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rdx + pushq %rcx + pushq %r8 + pushq %r9 + pushq %rbp + call _glapi_get_dispatch + popq %rbp + popq %r9 + popq %r8 + popq %rcx + popq %rdx + popq %rsi + popq %rdi + movq 2984(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(CopyTexSubImage3DOES), .-GL_PREFIX(CopyTexSubImage3DOES) + + .p2align 4,,15 + .globl GL_PREFIX(ActiveTexture) + .type GL_PREFIX(ActiveTexture), @function +GL_PREFIX(ActiveTexture): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 2992(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + call _x86_64_get_dispatch@PLT + popq %rdi + movq 2992(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 2992(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + call _glapi_get_dispatch + popq %rdi + movq 2992(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(ActiveTexture), .-GL_PREFIX(ActiveTexture) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_375) + .type GL_PREFIX(_dispatch_stub_375), @function + HIDDEN(GL_PREFIX(_dispatch_stub_375)) +GL_PREFIX(_dispatch_stub_375): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 3000(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + call _x86_64_get_dispatch@PLT + popq %rdi + movq 3000(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 3000(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + call _glapi_get_dispatch + popq %rdi + movq 3000(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_375), .-GL_PREFIX(_dispatch_stub_375) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_376) + .type GL_PREFIX(_dispatch_stub_376), @function + HIDDEN(GL_PREFIX(_dispatch_stub_376)) +GL_PREFIX(_dispatch_stub_376): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 3008(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + subq $24, %rsp + movq %rdi, (%rsp) + movq %xmm0, 8(%rsp) + call _x86_64_get_dispatch@PLT + movq 8(%rsp), %xmm0 + movq (%rsp), %rdi + addq $24, %rsp + movq 3008(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 3008(%rax), %r11 + jmp *%r11 +1: + subq $24, %rsp + movq %rdi, (%rsp) + movq %xmm0, 8(%rsp) + call _glapi_get_dispatch + movq 8(%rsp), %xmm0 + movq (%rsp), %rdi + addq $24, %rsp + movq 3008(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_376), .-GL_PREFIX(_dispatch_stub_376) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_377) + .type GL_PREFIX(_dispatch_stub_377), @function + HIDDEN(GL_PREFIX(_dispatch_stub_377)) +GL_PREFIX(_dispatch_stub_377): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 3016(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rbp + call _x86_64_get_dispatch@PLT + popq %rbp + popq %rsi + popq %rdi + movq 3016(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 3016(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rbp + call _glapi_get_dispatch + popq %rbp + popq %rsi + popq %rdi + movq 3016(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_377), .-GL_PREFIX(_dispatch_stub_377) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_378) + .type GL_PREFIX(_dispatch_stub_378), @function + HIDDEN(GL_PREFIX(_dispatch_stub_378)) +GL_PREFIX(_dispatch_stub_378): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 3024(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + subq $24, %rsp + movq %rdi, (%rsp) + movq %xmm0, 8(%rsp) + call _x86_64_get_dispatch@PLT + movq 8(%rsp), %xmm0 + movq (%rsp), %rdi + addq $24, %rsp + movq 3024(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 3024(%rax), %r11 + jmp *%r11 +1: + subq $24, %rsp + movq %rdi, (%rsp) + movq %xmm0, 8(%rsp) + call _glapi_get_dispatch + movq 8(%rsp), %xmm0 + movq (%rsp), %rdi + addq $24, %rsp + movq 3024(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_378), .-GL_PREFIX(_dispatch_stub_378) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_379) + .type GL_PREFIX(_dispatch_stub_379), @function + HIDDEN(GL_PREFIX(_dispatch_stub_379)) +GL_PREFIX(_dispatch_stub_379): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 3032(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rbp + call _x86_64_get_dispatch@PLT + popq %rbp + popq %rsi + popq %rdi + movq 3032(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 3032(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rbp + call _glapi_get_dispatch + popq %rbp + popq %rsi + popq %rdi + movq 3032(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_379), .-GL_PREFIX(_dispatch_stub_379) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_380) + .type GL_PREFIX(_dispatch_stub_380), @function + HIDDEN(GL_PREFIX(_dispatch_stub_380)) +GL_PREFIX(_dispatch_stub_380): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 3040(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rbp + call _x86_64_get_dispatch@PLT + popq %rbp + popq %rsi + popq %rdi + movq 3040(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 3040(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rbp + call _glapi_get_dispatch + popq %rbp + popq %rsi + popq %rdi + movq 3040(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_380), .-GL_PREFIX(_dispatch_stub_380) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_381) + .type GL_PREFIX(_dispatch_stub_381), @function + HIDDEN(GL_PREFIX(_dispatch_stub_381)) +GL_PREFIX(_dispatch_stub_381): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 3048(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rbp + call _x86_64_get_dispatch@PLT + popq %rbp + popq %rsi + popq %rdi + movq 3048(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 3048(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rbp + call _glapi_get_dispatch + popq %rbp + popq %rsi + popq %rdi + movq 3048(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_381), .-GL_PREFIX(_dispatch_stub_381) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_382) + .type GL_PREFIX(_dispatch_stub_382), @function + HIDDEN(GL_PREFIX(_dispatch_stub_382)) +GL_PREFIX(_dispatch_stub_382): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 3056(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rbp + call _x86_64_get_dispatch@PLT + popq %rbp + popq %rsi + popq %rdi + movq 3056(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 3056(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rbp + call _glapi_get_dispatch + popq %rbp + popq %rsi + popq %rdi + movq 3056(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_382), .-GL_PREFIX(_dispatch_stub_382) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_383) + .type GL_PREFIX(_dispatch_stub_383), @function + HIDDEN(GL_PREFIX(_dispatch_stub_383)) +GL_PREFIX(_dispatch_stub_383): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 3064(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rbp + call _x86_64_get_dispatch@PLT + popq %rbp + popq %rsi + popq %rdi + movq 3064(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 3064(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rbp + call _glapi_get_dispatch + popq %rbp + popq %rsi + popq %rdi + movq 3064(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_383), .-GL_PREFIX(_dispatch_stub_383) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_384) + .type GL_PREFIX(_dispatch_stub_384), @function + HIDDEN(GL_PREFIX(_dispatch_stub_384)) +GL_PREFIX(_dispatch_stub_384): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 3072(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + subq $24, %rsp + movq %rdi, (%rsp) + movq %xmm0, 8(%rsp) + movq %xmm1, 16(%rsp) + call _x86_64_get_dispatch@PLT + movq 16(%rsp), %xmm1 + movq 8(%rsp), %xmm0 + movq (%rsp), %rdi + addq $24, %rsp + movq 3072(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 3072(%rax), %r11 + jmp *%r11 +1: + subq $24, %rsp + movq %rdi, (%rsp) + movq %xmm0, 8(%rsp) + movq %xmm1, 16(%rsp) + call _glapi_get_dispatch + movq 16(%rsp), %xmm1 + movq 8(%rsp), %xmm0 + movq (%rsp), %rdi + addq $24, %rsp + movq 3072(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_384), .-GL_PREFIX(_dispatch_stub_384) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_385) + .type GL_PREFIX(_dispatch_stub_385), @function + HIDDEN(GL_PREFIX(_dispatch_stub_385)) +GL_PREFIX(_dispatch_stub_385): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 3080(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rbp + call _x86_64_get_dispatch@PLT + popq %rbp + popq %rsi + popq %rdi + movq 3080(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 3080(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rbp + call _glapi_get_dispatch + popq %rbp + popq %rsi + popq %rdi + movq 3080(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_385), .-GL_PREFIX(_dispatch_stub_385) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_386) + .type GL_PREFIX(_dispatch_stub_386), @function + HIDDEN(GL_PREFIX(_dispatch_stub_386)) +GL_PREFIX(_dispatch_stub_386): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 3088(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + subq $24, %rsp + movq %rdi, (%rsp) + movq %xmm0, 8(%rsp) + movq %xmm1, 16(%rsp) + call _x86_64_get_dispatch@PLT + movq 16(%rsp), %xmm1 + movq 8(%rsp), %xmm0 + movq (%rsp), %rdi + addq $24, %rsp + movq 3088(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 3088(%rax), %r11 + jmp *%r11 +1: + subq $24, %rsp + movq %rdi, (%rsp) + movq %xmm0, 8(%rsp) + movq %xmm1, 16(%rsp) + call _glapi_get_dispatch + movq 16(%rsp), %xmm1 + movq 8(%rsp), %xmm0 + movq (%rsp), %rdi + addq $24, %rsp + movq 3088(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_386), .-GL_PREFIX(_dispatch_stub_386) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_387) + .type GL_PREFIX(_dispatch_stub_387), @function + HIDDEN(GL_PREFIX(_dispatch_stub_387)) +GL_PREFIX(_dispatch_stub_387): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 3096(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rbp + call _x86_64_get_dispatch@PLT + popq %rbp + popq %rsi + popq %rdi + movq 3096(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 3096(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rbp + call _glapi_get_dispatch + popq %rbp + popq %rsi + popq %rdi + movq 3096(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_387), .-GL_PREFIX(_dispatch_stub_387) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_388) + .type GL_PREFIX(_dispatch_stub_388), @function + HIDDEN(GL_PREFIX(_dispatch_stub_388)) +GL_PREFIX(_dispatch_stub_388): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 3104(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rdx + call _x86_64_get_dispatch@PLT + popq %rdx + popq %rsi + popq %rdi + movq 3104(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 3104(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rdx + call _glapi_get_dispatch + popq %rdx + popq %rsi + popq %rdi + movq 3104(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_388), .-GL_PREFIX(_dispatch_stub_388) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_389) + .type GL_PREFIX(_dispatch_stub_389), @function + HIDDEN(GL_PREFIX(_dispatch_stub_389)) +GL_PREFIX(_dispatch_stub_389): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 3112(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rbp + call _x86_64_get_dispatch@PLT + popq %rbp + popq %rsi + popq %rdi + movq 3112(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 3112(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rbp + call _glapi_get_dispatch + popq %rbp + popq %rsi + popq %rdi + movq 3112(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_389), .-GL_PREFIX(_dispatch_stub_389) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_390) + .type GL_PREFIX(_dispatch_stub_390), @function + HIDDEN(GL_PREFIX(_dispatch_stub_390)) +GL_PREFIX(_dispatch_stub_390): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 3120(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rdx + call _x86_64_get_dispatch@PLT + popq %rdx + popq %rsi + popq %rdi + movq 3120(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 3120(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rdx + call _glapi_get_dispatch + popq %rdx + popq %rsi + popq %rdi + movq 3120(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_390), .-GL_PREFIX(_dispatch_stub_390) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_391) + .type GL_PREFIX(_dispatch_stub_391), @function + HIDDEN(GL_PREFIX(_dispatch_stub_391)) +GL_PREFIX(_dispatch_stub_391): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 3128(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rbp + call _x86_64_get_dispatch@PLT + popq %rbp + popq %rsi + popq %rdi + movq 3128(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 3128(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rbp + call _glapi_get_dispatch + popq %rbp + popq %rsi + popq %rdi + movq 3128(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_391), .-GL_PREFIX(_dispatch_stub_391) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_392) + .type GL_PREFIX(_dispatch_stub_392), @function + HIDDEN(GL_PREFIX(_dispatch_stub_392)) +GL_PREFIX(_dispatch_stub_392): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 3136(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + subq $40, %rsp + movq %rdi, (%rsp) + movq %xmm0, 8(%rsp) + movq %xmm1, 16(%rsp) + movq %xmm2, 24(%rsp) + call _x86_64_get_dispatch@PLT + movq 24(%rsp), %xmm2 + movq 16(%rsp), %xmm1 + movq 8(%rsp), %xmm0 + movq (%rsp), %rdi + addq $40, %rsp + movq 3136(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 3136(%rax), %r11 + jmp *%r11 +1: + subq $40, %rsp + movq %rdi, (%rsp) + movq %xmm0, 8(%rsp) + movq %xmm1, 16(%rsp) + movq %xmm2, 24(%rsp) + call _glapi_get_dispatch + movq 24(%rsp), %xmm2 + movq 16(%rsp), %xmm1 + movq 8(%rsp), %xmm0 + movq (%rsp), %rdi + addq $40, %rsp + movq 3136(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_392), .-GL_PREFIX(_dispatch_stub_392) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_393) + .type GL_PREFIX(_dispatch_stub_393), @function + HIDDEN(GL_PREFIX(_dispatch_stub_393)) +GL_PREFIX(_dispatch_stub_393): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 3144(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rbp + call _x86_64_get_dispatch@PLT + popq %rbp + popq %rsi + popq %rdi + movq 3144(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 3144(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rbp + call _glapi_get_dispatch + popq %rbp + popq %rsi + popq %rdi + movq 3144(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_393), .-GL_PREFIX(_dispatch_stub_393) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_394) + .type GL_PREFIX(_dispatch_stub_394), @function + HIDDEN(GL_PREFIX(_dispatch_stub_394)) +GL_PREFIX(_dispatch_stub_394): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 3152(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + subq $40, %rsp + movq %rdi, (%rsp) + movq %xmm0, 8(%rsp) + movq %xmm1, 16(%rsp) + movq %xmm2, 24(%rsp) + call _x86_64_get_dispatch@PLT + movq 24(%rsp), %xmm2 + movq 16(%rsp), %xmm1 + movq 8(%rsp), %xmm0 + movq (%rsp), %rdi + addq $40, %rsp + movq 3152(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 3152(%rax), %r11 + jmp *%r11 +1: + subq $40, %rsp + movq %rdi, (%rsp) + movq %xmm0, 8(%rsp) + movq %xmm1, 16(%rsp) + movq %xmm2, 24(%rsp) + call _glapi_get_dispatch + movq 24(%rsp), %xmm2 + movq 16(%rsp), %xmm1 + movq 8(%rsp), %xmm0 + movq (%rsp), %rdi + addq $40, %rsp + movq 3152(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_394), .-GL_PREFIX(_dispatch_stub_394) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_395) + .type GL_PREFIX(_dispatch_stub_395), @function + HIDDEN(GL_PREFIX(_dispatch_stub_395)) +GL_PREFIX(_dispatch_stub_395): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 3160(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rbp + call _x86_64_get_dispatch@PLT + popq %rbp + popq %rsi + popq %rdi + movq 3160(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 3160(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rbp + call _glapi_get_dispatch + popq %rbp + popq %rsi + popq %rdi + movq 3160(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_395), .-GL_PREFIX(_dispatch_stub_395) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_396) + .type GL_PREFIX(_dispatch_stub_396), @function + HIDDEN(GL_PREFIX(_dispatch_stub_396)) +GL_PREFIX(_dispatch_stub_396): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 3168(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rdx + pushq %rcx + pushq %rbp + call _x86_64_get_dispatch@PLT + popq %rbp + popq %rcx + popq %rdx + popq %rsi + popq %rdi + movq 3168(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 3168(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rdx + pushq %rcx + pushq %rbp + call _glapi_get_dispatch + popq %rbp + popq %rcx + popq %rdx + popq %rsi + popq %rdi + movq 3168(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_396), .-GL_PREFIX(_dispatch_stub_396) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_397) + .type GL_PREFIX(_dispatch_stub_397), @function + HIDDEN(GL_PREFIX(_dispatch_stub_397)) +GL_PREFIX(_dispatch_stub_397): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 3176(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rbp + call _x86_64_get_dispatch@PLT + popq %rbp + popq %rsi + popq %rdi + movq 3176(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 3176(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rbp + call _glapi_get_dispatch + popq %rbp + popq %rsi + popq %rdi + movq 3176(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_397), .-GL_PREFIX(_dispatch_stub_397) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_398) + .type GL_PREFIX(_dispatch_stub_398), @function + HIDDEN(GL_PREFIX(_dispatch_stub_398)) +GL_PREFIX(_dispatch_stub_398): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 3184(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rdx + pushq %rcx + pushq %rbp + call _x86_64_get_dispatch@PLT + popq %rbp + popq %rcx + popq %rdx + popq %rsi + popq %rdi + movq 3184(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 3184(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rdx + pushq %rcx + pushq %rbp + call _glapi_get_dispatch + popq %rbp + popq %rcx + popq %rdx + popq %rsi + popq %rdi + movq 3184(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_398), .-GL_PREFIX(_dispatch_stub_398) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_399) + .type GL_PREFIX(_dispatch_stub_399), @function + HIDDEN(GL_PREFIX(_dispatch_stub_399)) +GL_PREFIX(_dispatch_stub_399): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 3192(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rbp + call _x86_64_get_dispatch@PLT + popq %rbp + popq %rsi + popq %rdi + movq 3192(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 3192(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rbp + call _glapi_get_dispatch + popq %rbp + popq %rsi + popq %rdi + movq 3192(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_399), .-GL_PREFIX(_dispatch_stub_399) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_400) + .type GL_PREFIX(_dispatch_stub_400), @function + HIDDEN(GL_PREFIX(_dispatch_stub_400)) +GL_PREFIX(_dispatch_stub_400): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 3200(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + subq $40, %rsp + movq %rdi, (%rsp) + movq %xmm0, 8(%rsp) + movq %xmm1, 16(%rsp) + movq %xmm2, 24(%rsp) + movq %xmm3, 32(%rsp) + call _x86_64_get_dispatch@PLT + movq 32(%rsp), %xmm3 + movq 24(%rsp), %xmm2 + movq 16(%rsp), %xmm1 + movq 8(%rsp), %xmm0 + movq (%rsp), %rdi + addq $40, %rsp + movq 3200(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 3200(%rax), %r11 + jmp *%r11 +1: + subq $40, %rsp + movq %rdi, (%rsp) + movq %xmm0, 8(%rsp) + movq %xmm1, 16(%rsp) + movq %xmm2, 24(%rsp) + movq %xmm3, 32(%rsp) + call _glapi_get_dispatch + movq 32(%rsp), %xmm3 + movq 24(%rsp), %xmm2 + movq 16(%rsp), %xmm1 + movq 8(%rsp), %xmm0 + movq (%rsp), %rdi + addq $40, %rsp + movq 3200(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_400), .-GL_PREFIX(_dispatch_stub_400) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_401) + .type GL_PREFIX(_dispatch_stub_401), @function + HIDDEN(GL_PREFIX(_dispatch_stub_401)) +GL_PREFIX(_dispatch_stub_401): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 3208(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rbp + call _x86_64_get_dispatch@PLT + popq %rbp + popq %rsi + popq %rdi + movq 3208(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 3208(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rbp + call _glapi_get_dispatch + popq %rbp + popq %rsi + popq %rdi + movq 3208(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_401), .-GL_PREFIX(_dispatch_stub_401) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_402) + .type GL_PREFIX(_dispatch_stub_402), @function + HIDDEN(GL_PREFIX(_dispatch_stub_402)) +GL_PREFIX(_dispatch_stub_402): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 3216(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + subq $40, %rsp + movq %rdi, (%rsp) + movq %xmm0, 8(%rsp) + movq %xmm1, 16(%rsp) + movq %xmm2, 24(%rsp) + movq %xmm3, 32(%rsp) + call _x86_64_get_dispatch@PLT + movq 32(%rsp), %xmm3 + movq 24(%rsp), %xmm2 + movq 16(%rsp), %xmm1 + movq 8(%rsp), %xmm0 + movq (%rsp), %rdi + addq $40, %rsp + movq 3216(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 3216(%rax), %r11 + jmp *%r11 +1: + subq $40, %rsp + movq %rdi, (%rsp) + movq %xmm0, 8(%rsp) + movq %xmm1, 16(%rsp) + movq %xmm2, 24(%rsp) + movq %xmm3, 32(%rsp) + call _glapi_get_dispatch + movq 32(%rsp), %xmm3 + movq 24(%rsp), %xmm2 + movq 16(%rsp), %xmm1 + movq 8(%rsp), %xmm0 + movq (%rsp), %rdi + addq $40, %rsp + movq 3216(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_402), .-GL_PREFIX(_dispatch_stub_402) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_403) + .type GL_PREFIX(_dispatch_stub_403), @function + HIDDEN(GL_PREFIX(_dispatch_stub_403)) +GL_PREFIX(_dispatch_stub_403): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 3224(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rbp + call _x86_64_get_dispatch@PLT + popq %rbp + popq %rsi + popq %rdi + movq 3224(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 3224(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rbp + call _glapi_get_dispatch + popq %rbp + popq %rsi + popq %rdi + movq 3224(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_403), .-GL_PREFIX(_dispatch_stub_403) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_404) + .type GL_PREFIX(_dispatch_stub_404), @function + HIDDEN(GL_PREFIX(_dispatch_stub_404)) +GL_PREFIX(_dispatch_stub_404): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 3232(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rdx + pushq %rcx + pushq %r8 + call _x86_64_get_dispatch@PLT + popq %r8 + popq %rcx + popq %rdx + popq %rsi + popq %rdi + movq 3232(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 3232(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rdx + pushq %rcx + pushq %r8 + call _glapi_get_dispatch + popq %r8 + popq %rcx + popq %rdx + popq %rsi + popq %rdi + movq 3232(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_404), .-GL_PREFIX(_dispatch_stub_404) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_405) + .type GL_PREFIX(_dispatch_stub_405), @function + HIDDEN(GL_PREFIX(_dispatch_stub_405)) +GL_PREFIX(_dispatch_stub_405): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 3240(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rbp + call _x86_64_get_dispatch@PLT + popq %rbp + popq %rsi + popq %rdi + movq 3240(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 3240(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rbp + call _glapi_get_dispatch + popq %rbp + popq %rsi + popq %rdi + movq 3240(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_405), .-GL_PREFIX(_dispatch_stub_405) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_406) + .type GL_PREFIX(_dispatch_stub_406), @function + HIDDEN(GL_PREFIX(_dispatch_stub_406)) +GL_PREFIX(_dispatch_stub_406): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 3248(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rdx + pushq %rcx + pushq %r8 + call _x86_64_get_dispatch@PLT + popq %r8 + popq %rcx + popq %rdx + popq %rsi + popq %rdi + movq 3248(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 3248(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rdx + pushq %rcx + pushq %r8 + call _glapi_get_dispatch + popq %r8 + popq %rcx + popq %rdx + popq %rsi + popq %rdi + movq 3248(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_406), .-GL_PREFIX(_dispatch_stub_406) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_407) + .type GL_PREFIX(_dispatch_stub_407), @function + HIDDEN(GL_PREFIX(_dispatch_stub_407)) +GL_PREFIX(_dispatch_stub_407): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 3256(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rbp + call _x86_64_get_dispatch@PLT + popq %rbp + popq %rsi + popq %rdi + movq 3256(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 3256(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rbp + call _glapi_get_dispatch + popq %rbp + popq %rsi + popq %rdi + movq 3256(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_407), .-GL_PREFIX(_dispatch_stub_407) + + .p2align 4,,15 + .globl GL_PREFIX(GetBufferPointervOES) + .type GL_PREFIX(GetBufferPointervOES), @function +GL_PREFIX(GetBufferPointervOES): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 3264(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rdx + call _x86_64_get_dispatch@PLT + popq %rdx + popq %rsi + popq %rdi + movq 3264(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 3264(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rdx + call _glapi_get_dispatch + popq %rdx + popq %rsi + popq %rdi + movq 3264(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(GetBufferPointervOES), .-GL_PREFIX(GetBufferPointervOES) + + .p2align 4,,15 + .globl GL_PREFIX(MapBufferOES) + .type GL_PREFIX(MapBufferOES), @function +GL_PREFIX(MapBufferOES): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 3272(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rbp + call _x86_64_get_dispatch@PLT + popq %rbp + popq %rsi + popq %rdi + movq 3272(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 3272(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rbp + call _glapi_get_dispatch + popq %rbp + popq %rsi + popq %rdi + movq 3272(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(MapBufferOES), .-GL_PREFIX(MapBufferOES) + + .p2align 4,,15 + .globl GL_PREFIX(UnmapBufferOES) + .type GL_PREFIX(UnmapBufferOES), @function +GL_PREFIX(UnmapBufferOES): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 3280(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + call _x86_64_get_dispatch@PLT + popq %rdi + movq 3280(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 3280(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + call _glapi_get_dispatch + popq %rdi + movq 3280(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(UnmapBufferOES), .-GL_PREFIX(UnmapBufferOES) + + .p2align 4,,15 + .globl GL_PREFIX(CompressedTexImage3DOES) + .type GL_PREFIX(CompressedTexImage3DOES), @function +GL_PREFIX(CompressedTexImage3DOES): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 3288(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rdx + pushq %rcx + pushq %r8 + pushq %r9 + pushq %rbp + call _x86_64_get_dispatch@PLT + popq %rbp + popq %r9 + popq %r8 + popq %rcx + popq %rdx + popq %rsi + popq %rdi + movq 3288(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 3288(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rdx + pushq %rcx + pushq %r8 + pushq %r9 + pushq %rbp + call _glapi_get_dispatch + popq %rbp + popq %r9 + popq %r8 + popq %rcx + popq %rdx + popq %rsi + popq %rdi + movq 3288(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(CompressedTexImage3DOES), .-GL_PREFIX(CompressedTexImage3DOES) + + .p2align 4,,15 + .globl GL_PREFIX(CompressedTexSubImage3DOES) + .type GL_PREFIX(CompressedTexSubImage3DOES), @function +GL_PREFIX(CompressedTexSubImage3DOES): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 3296(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rdx + pushq %rcx + pushq %r8 + pushq %r9 + pushq %rbp + call _x86_64_get_dispatch@PLT + popq %rbp + popq %r9 + popq %r8 + popq %rcx + popq %rdx + popq %rsi + popq %rdi + movq 3296(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 3296(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rdx + pushq %rcx + pushq %r8 + pushq %r9 + pushq %rbp + call _glapi_get_dispatch + popq %rbp + popq %r9 + popq %r8 + popq %rcx + popq %rdx + popq %rsi + popq %rdi + movq 3296(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(CompressedTexSubImage3DOES), .-GL_PREFIX(CompressedTexSubImage3DOES) + + .p2align 4,,15 + .globl GL_PREFIX(FramebufferTexture3DOES) + .type GL_PREFIX(FramebufferTexture3DOES), @function +GL_PREFIX(FramebufferTexture3DOES): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 3304(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rdx + pushq %rcx + pushq %r8 + pushq %r9 + pushq %rbp + call _x86_64_get_dispatch@PLT + popq %rbp + popq %r9 + popq %r8 + popq %rcx + popq %rdx + popq %rsi + popq %rdi + movq 3304(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 3304(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rdx + pushq %rcx + pushq %r8 + pushq %r9 + pushq %rbp + call _glapi_get_dispatch + popq %rbp + popq %r9 + popq %r8 + popq %rcx + popq %rdx + popq %rsi + popq %rdi + movq 3304(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(FramebufferTexture3DOES), .-GL_PREFIX(FramebufferTexture3DOES) + + .p2align 4,,15 + .globl GL_PREFIX(GetProgramBinaryOES) + .type GL_PREFIX(GetProgramBinaryOES), @function +GL_PREFIX(GetProgramBinaryOES): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 3312(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rdx + pushq %rcx + pushq %r8 + call _x86_64_get_dispatch@PLT + popq %r8 + popq %rcx + popq %rdx + popq %rsi + popq %rdi + movq 3312(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 3312(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rdx + pushq %rcx + pushq %r8 + call _glapi_get_dispatch + popq %r8 + popq %rcx + popq %rdx + popq %rsi + popq %rdi + movq 3312(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(GetProgramBinaryOES), .-GL_PREFIX(GetProgramBinaryOES) + + .p2align 4,,15 + .globl GL_PREFIX(ProgramBinaryOES) + .type GL_PREFIX(ProgramBinaryOES), @function +GL_PREFIX(ProgramBinaryOES): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 3320(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rdx + pushq %rcx + pushq %rbp + call _x86_64_get_dispatch@PLT + popq %rbp + popq %rcx + popq %rdx + popq %rsi + popq %rdi + movq 3320(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 3320(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rdx + pushq %rcx + pushq %rbp + call _glapi_get_dispatch + popq %rbp + popq %rcx + popq %rdx + popq %rsi + popq %rdi + movq 3320(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(ProgramBinaryOES), .-GL_PREFIX(ProgramBinaryOES) + + .p2align 4,,15 + .globl GL_PREFIX(MultiDrawArraysEXT) + .type GL_PREFIX(MultiDrawArraysEXT), @function +GL_PREFIX(MultiDrawArraysEXT): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 3328(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rdx + pushq %rcx + pushq %rbp + call _x86_64_get_dispatch@PLT + popq %rbp + popq %rcx + popq %rdx + popq %rsi + popq %rdi + movq 3328(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 3328(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rdx + pushq %rcx + pushq %rbp + call _glapi_get_dispatch + popq %rbp + popq %rcx + popq %rdx + popq %rsi + popq %rdi + movq 3328(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(MultiDrawArraysEXT), .-GL_PREFIX(MultiDrawArraysEXT) + + .p2align 4,,15 + .globl GL_PREFIX(MultiDrawElementsEXT) + .type GL_PREFIX(MultiDrawElementsEXT), @function +GL_PREFIX(MultiDrawElementsEXT): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 3336(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rdx + pushq %rcx + pushq %r8 + call _x86_64_get_dispatch@PLT + popq %r8 + popq %rcx + popq %rdx + popq %rsi + popq %rdi + movq 3336(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 3336(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rdx + pushq %rcx + pushq %r8 + call _glapi_get_dispatch + popq %r8 + popq %rcx + popq %rdx + popq %rsi + popq %rdi + movq 3336(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(MultiDrawElementsEXT), .-GL_PREFIX(MultiDrawElementsEXT) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_418) + .type GL_PREFIX(_dispatch_stub_418), @function + HIDDEN(GL_PREFIX(_dispatch_stub_418)) +GL_PREFIX(_dispatch_stub_418): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 3344(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + call _x86_64_get_dispatch@PLT + popq %rdi + movq 3344(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 3344(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + call _glapi_get_dispatch + popq %rdi + movq 3344(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_418), .-GL_PREFIX(_dispatch_stub_418) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_419) + .type GL_PREFIX(_dispatch_stub_419), @function + HIDDEN(GL_PREFIX(_dispatch_stub_419)) +GL_PREFIX(_dispatch_stub_419): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 3352(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rbp + call _x86_64_get_dispatch@PLT + popq %rbp + popq %rsi + popq %rdi + movq 3352(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 3352(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rbp + call _glapi_get_dispatch + popq %rbp + popq %rsi + popq %rdi + movq 3352(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_419), .-GL_PREFIX(_dispatch_stub_419) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_420) + .type GL_PREFIX(_dispatch_stub_420), @function + HIDDEN(GL_PREFIX(_dispatch_stub_420)) +GL_PREFIX(_dispatch_stub_420): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 3360(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rbp + call _x86_64_get_dispatch@PLT + popq %rbp + popq %rsi + popq %rdi + movq 3360(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 3360(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rbp + call _glapi_get_dispatch + popq %rbp + popq %rsi + popq %rdi + movq 3360(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_420), .-GL_PREFIX(_dispatch_stub_420) + + .p2align 4,,15 + .globl GL_PREFIX(_dispatch_stub_421) + .type GL_PREFIX(_dispatch_stub_421), @function + HIDDEN(GL_PREFIX(_dispatch_stub_421)) +GL_PREFIX(_dispatch_stub_421): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 3368(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + call _x86_64_get_dispatch@PLT + popq %rdi + movq 3368(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 3368(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + call _glapi_get_dispatch + popq %rdi + movq 3368(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(_dispatch_stub_421), .-GL_PREFIX(_dispatch_stub_421) + + .p2align 4,,15 + .globl GL_PREFIX(EGLImageTargetRenderbufferStorageOES) + .type GL_PREFIX(EGLImageTargetRenderbufferStorageOES), @function +GL_PREFIX(EGLImageTargetRenderbufferStorageOES): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 3376(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rbp + call _x86_64_get_dispatch@PLT + popq %rbp + popq %rsi + popq %rdi + movq 3376(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 3376(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rbp + call _glapi_get_dispatch + popq %rbp + popq %rsi + popq %rdi + movq 3376(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(EGLImageTargetRenderbufferStorageOES), .-GL_PREFIX(EGLImageTargetRenderbufferStorageOES) + + .p2align 4,,15 + .globl GL_PREFIX(EGLImageTargetTexture2DOES) + .type GL_PREFIX(EGLImageTargetTexture2DOES), @function +GL_PREFIX(EGLImageTargetTexture2DOES): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 3384(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rbp + call _x86_64_get_dispatch@PLT + popq %rbp + popq %rsi + popq %rdi + movq 3384(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 3384(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rbp + call _glapi_get_dispatch + popq %rbp + popq %rsi + popq %rdi + movq 3384(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(EGLImageTargetTexture2DOES), .-GL_PREFIX(EGLImageTargetTexture2DOES) + + .p2align 4,,15 + .globl GL_PREFIX(CompressedTexImage2D) + .type GL_PREFIX(CompressedTexImage2D), @function +GL_PREFIX(CompressedTexImage2D): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 3392(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rdx + pushq %rcx + pushq %r8 + pushq %r9 + pushq %rbp + call _x86_64_get_dispatch@PLT + popq %rbp + popq %r9 + popq %r8 + popq %rcx + popq %rdx + popq %rsi + popq %rdi + movq 3392(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 3392(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rdx + pushq %rcx + pushq %r8 + pushq %r9 + pushq %rbp + call _glapi_get_dispatch + popq %rbp + popq %r9 + popq %r8 + popq %rcx + popq %rdx + popq %rsi + popq %rdi + movq 3392(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(CompressedTexImage2D), .-GL_PREFIX(CompressedTexImage2D) + + .p2align 4,,15 + .globl GL_PREFIX(CompressedTexSubImage2D) + .type GL_PREFIX(CompressedTexSubImage2D), @function +GL_PREFIX(CompressedTexSubImage2D): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 3400(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rdx + pushq %rcx + pushq %r8 + pushq %r9 + pushq %rbp + call _x86_64_get_dispatch@PLT + popq %rbp + popq %r9 + popq %r8 + popq %rcx + popq %rdx + popq %rsi + popq %rdi + movq 3400(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 3400(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rdx + pushq %rcx + pushq %r8 + pushq %r9 + pushq %rbp + call _glapi_get_dispatch + popq %rbp + popq %r9 + popq %r8 + popq %rcx + popq %rdx + popq %rsi + popq %rdi + movq 3400(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(CompressedTexSubImage2D), .-GL_PREFIX(CompressedTexSubImage2D) + + .p2align 4,,15 + .globl GL_PREFIX(SampleCoverage) + .type GL_PREFIX(SampleCoverage), @function +GL_PREFIX(SampleCoverage): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 3408(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rbp + call _x86_64_get_dispatch@PLT + popq %rbp + popq %rsi + popq %rdi + movq 3408(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 3408(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rbp + call _glapi_get_dispatch + popq %rbp + popq %rsi + popq %rdi + movq 3408(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(SampleCoverage), .-GL_PREFIX(SampleCoverage) + + .p2align 4,,15 + .globl GL_PREFIX(BindBuffer) + .type GL_PREFIX(BindBuffer), @function +GL_PREFIX(BindBuffer): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 3416(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rbp + call _x86_64_get_dispatch@PLT + popq %rbp + popq %rsi + popq %rdi + movq 3416(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 3416(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rbp + call _glapi_get_dispatch + popq %rbp + popq %rsi + popq %rdi + movq 3416(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(BindBuffer), .-GL_PREFIX(BindBuffer) + + .p2align 4,,15 + .globl GL_PREFIX(BufferData) + .type GL_PREFIX(BufferData), @function +GL_PREFIX(BufferData): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 3424(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rdx + pushq %rcx + pushq %rbp + call _x86_64_get_dispatch@PLT + popq %rbp + popq %rcx + popq %rdx + popq %rsi + popq %rdi + movq 3424(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 3424(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rdx + pushq %rcx + pushq %rbp + call _glapi_get_dispatch + popq %rbp + popq %rcx + popq %rdx + popq %rsi + popq %rdi + movq 3424(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(BufferData), .-GL_PREFIX(BufferData) + + .p2align 4,,15 + .globl GL_PREFIX(BufferSubData) + .type GL_PREFIX(BufferSubData), @function +GL_PREFIX(BufferSubData): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 3432(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rdx + pushq %rcx + pushq %rbp + call _x86_64_get_dispatch@PLT + popq %rbp + popq %rcx + popq %rdx + popq %rsi + popq %rdi + movq 3432(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 3432(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rdx + pushq %rcx + pushq %rbp + call _glapi_get_dispatch + popq %rbp + popq %rcx + popq %rdx + popq %rsi + popq %rdi + movq 3432(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(BufferSubData), .-GL_PREFIX(BufferSubData) + + .p2align 4,,15 + .globl GL_PREFIX(DeleteBuffers) + .type GL_PREFIX(DeleteBuffers), @function +GL_PREFIX(DeleteBuffers): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 3440(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rbp + call _x86_64_get_dispatch@PLT + popq %rbp + popq %rsi + popq %rdi + movq 3440(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 3440(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rbp + call _glapi_get_dispatch + popq %rbp + popq %rsi + popq %rdi + movq 3440(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(DeleteBuffers), .-GL_PREFIX(DeleteBuffers) + + .p2align 4,,15 + .globl GL_PREFIX(GenBuffers) + .type GL_PREFIX(GenBuffers), @function +GL_PREFIX(GenBuffers): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 3448(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rbp + call _x86_64_get_dispatch@PLT + popq %rbp + popq %rsi + popq %rdi + movq 3448(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 3448(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rbp + call _glapi_get_dispatch + popq %rbp + popq %rsi + popq %rdi + movq 3448(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(GenBuffers), .-GL_PREFIX(GenBuffers) + + .p2align 4,,15 + .globl GL_PREFIX(GetBufferParameteriv) + .type GL_PREFIX(GetBufferParameteriv), @function +GL_PREFIX(GetBufferParameteriv): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 3456(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rdx + call _x86_64_get_dispatch@PLT + popq %rdx + popq %rsi + popq %rdi + movq 3456(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 3456(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rdx + call _glapi_get_dispatch + popq %rdx + popq %rsi + popq %rdi + movq 3456(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(GetBufferParameteriv), .-GL_PREFIX(GetBufferParameteriv) + + .p2align 4,,15 + .globl GL_PREFIX(IsBuffer) + .type GL_PREFIX(IsBuffer), @function +GL_PREFIX(IsBuffer): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 3464(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + call _x86_64_get_dispatch@PLT + popq %rdi + movq 3464(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 3464(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + call _glapi_get_dispatch + popq %rdi + movq 3464(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(IsBuffer), .-GL_PREFIX(IsBuffer) + + .p2align 4,,15 + .globl GL_PREFIX(AttachShader) + .type GL_PREFIX(AttachShader), @function +GL_PREFIX(AttachShader): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 3472(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rbp + call _x86_64_get_dispatch@PLT + popq %rbp + popq %rsi + popq %rdi + movq 3472(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 3472(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rbp + call _glapi_get_dispatch + popq %rbp + popq %rsi + popq %rdi + movq 3472(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(AttachShader), .-GL_PREFIX(AttachShader) + + .p2align 4,,15 + .globl GL_PREFIX(BindAttribLocation) + .type GL_PREFIX(BindAttribLocation), @function +GL_PREFIX(BindAttribLocation): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 3480(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rdx + call _x86_64_get_dispatch@PLT + popq %rdx + popq %rsi + popq %rdi + movq 3480(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 3480(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rdx + call _glapi_get_dispatch + popq %rdx + popq %rsi + popq %rdi + movq 3480(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(BindAttribLocation), .-GL_PREFIX(BindAttribLocation) + + .p2align 4,,15 + .globl GL_PREFIX(BlendEquationSeparate) + .type GL_PREFIX(BlendEquationSeparate), @function +GL_PREFIX(BlendEquationSeparate): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 3488(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rbp + call _x86_64_get_dispatch@PLT + popq %rbp + popq %rsi + popq %rdi + movq 3488(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 3488(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rbp + call _glapi_get_dispatch + popq %rbp + popq %rsi + popq %rdi + movq 3488(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(BlendEquationSeparate), .-GL_PREFIX(BlendEquationSeparate) + + .p2align 4,,15 + .globl GL_PREFIX(CompileShader) + .type GL_PREFIX(CompileShader), @function +GL_PREFIX(CompileShader): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 3496(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + call _x86_64_get_dispatch@PLT + popq %rdi + movq 3496(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 3496(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + call _glapi_get_dispatch + popq %rdi + movq 3496(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(CompileShader), .-GL_PREFIX(CompileShader) + + .p2align 4,,15 + .globl GL_PREFIX(CreateProgram) + .type GL_PREFIX(CreateProgram), @function +GL_PREFIX(CreateProgram): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 3504(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rbp + call _x86_64_get_dispatch@PLT + popq %rbp + movq 3504(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 3504(%rax), %r11 + jmp *%r11 +1: + pushq %rbp + call _glapi_get_dispatch + popq %rbp + movq 3504(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(CreateProgram), .-GL_PREFIX(CreateProgram) + + .p2align 4,,15 + .globl GL_PREFIX(CreateShader) + .type GL_PREFIX(CreateShader), @function +GL_PREFIX(CreateShader): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 3512(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + call _x86_64_get_dispatch@PLT + popq %rdi + movq 3512(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 3512(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + call _glapi_get_dispatch + popq %rdi + movq 3512(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(CreateShader), .-GL_PREFIX(CreateShader) + + .p2align 4,,15 + .globl GL_PREFIX(DeleteProgram) + .type GL_PREFIX(DeleteProgram), @function +GL_PREFIX(DeleteProgram): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 3520(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + call _x86_64_get_dispatch@PLT + popq %rdi + movq 3520(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 3520(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + call _glapi_get_dispatch + popq %rdi + movq 3520(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(DeleteProgram), .-GL_PREFIX(DeleteProgram) + + .p2align 4,,15 + .globl GL_PREFIX(DeleteShader) + .type GL_PREFIX(DeleteShader), @function +GL_PREFIX(DeleteShader): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 3528(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + call _x86_64_get_dispatch@PLT + popq %rdi + movq 3528(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 3528(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + call _glapi_get_dispatch + popq %rdi + movq 3528(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(DeleteShader), .-GL_PREFIX(DeleteShader) + + .p2align 4,,15 + .globl GL_PREFIX(DetachShader) + .type GL_PREFIX(DetachShader), @function +GL_PREFIX(DetachShader): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 3536(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rbp + call _x86_64_get_dispatch@PLT + popq %rbp + popq %rsi + popq %rdi + movq 3536(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 3536(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rbp + call _glapi_get_dispatch + popq %rbp + popq %rsi + popq %rdi + movq 3536(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(DetachShader), .-GL_PREFIX(DetachShader) + + .p2align 4,,15 + .globl GL_PREFIX(DisableVertexAttribArray) + .type GL_PREFIX(DisableVertexAttribArray), @function +GL_PREFIX(DisableVertexAttribArray): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 3544(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + call _x86_64_get_dispatch@PLT + popq %rdi + movq 3544(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 3544(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + call _glapi_get_dispatch + popq %rdi + movq 3544(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(DisableVertexAttribArray), .-GL_PREFIX(DisableVertexAttribArray) + + .p2align 4,,15 + .globl GL_PREFIX(EnableVertexAttribArray) + .type GL_PREFIX(EnableVertexAttribArray), @function +GL_PREFIX(EnableVertexAttribArray): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 3552(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + call _x86_64_get_dispatch@PLT + popq %rdi + movq 3552(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 3552(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + call _glapi_get_dispatch + popq %rdi + movq 3552(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(EnableVertexAttribArray), .-GL_PREFIX(EnableVertexAttribArray) + + .p2align 4,,15 + .globl GL_PREFIX(GetActiveAttrib) + .type GL_PREFIX(GetActiveAttrib), @function +GL_PREFIX(GetActiveAttrib): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 3560(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rdx + pushq %rcx + pushq %r8 + pushq %r9 + pushq %rbp + call _x86_64_get_dispatch@PLT + popq %rbp + popq %r9 + popq %r8 + popq %rcx + popq %rdx + popq %rsi + popq %rdi + movq 3560(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 3560(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rdx + pushq %rcx + pushq %r8 + pushq %r9 + pushq %rbp + call _glapi_get_dispatch + popq %rbp + popq %r9 + popq %r8 + popq %rcx + popq %rdx + popq %rsi + popq %rdi + movq 3560(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(GetActiveAttrib), .-GL_PREFIX(GetActiveAttrib) + + .p2align 4,,15 + .globl GL_PREFIX(GetActiveUniform) + .type GL_PREFIX(GetActiveUniform), @function +GL_PREFIX(GetActiveUniform): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 3568(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rdx + pushq %rcx + pushq %r8 + pushq %r9 + pushq %rbp + call _x86_64_get_dispatch@PLT + popq %rbp + popq %r9 + popq %r8 + popq %rcx + popq %rdx + popq %rsi + popq %rdi + movq 3568(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 3568(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rdx + pushq %rcx + pushq %r8 + pushq %r9 + pushq %rbp + call _glapi_get_dispatch + popq %rbp + popq %r9 + popq %r8 + popq %rcx + popq %rdx + popq %rsi + popq %rdi + movq 3568(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(GetActiveUniform), .-GL_PREFIX(GetActiveUniform) + + .p2align 4,,15 + .globl GL_PREFIX(GetAttachedShaders) + .type GL_PREFIX(GetAttachedShaders), @function +GL_PREFIX(GetAttachedShaders): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 3576(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rdx + pushq %rcx + pushq %rbp + call _x86_64_get_dispatch@PLT + popq %rbp + popq %rcx + popq %rdx + popq %rsi + popq %rdi + movq 3576(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 3576(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rdx + pushq %rcx + pushq %rbp + call _glapi_get_dispatch + popq %rbp + popq %rcx + popq %rdx + popq %rsi + popq %rdi + movq 3576(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(GetAttachedShaders), .-GL_PREFIX(GetAttachedShaders) + + .p2align 4,,15 + .globl GL_PREFIX(GetAttribLocation) + .type GL_PREFIX(GetAttribLocation), @function +GL_PREFIX(GetAttribLocation): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 3584(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rbp + call _x86_64_get_dispatch@PLT + popq %rbp + popq %rsi + popq %rdi + movq 3584(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 3584(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rbp + call _glapi_get_dispatch + popq %rbp + popq %rsi + popq %rdi + movq 3584(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(GetAttribLocation), .-GL_PREFIX(GetAttribLocation) + + .p2align 4,,15 + .globl GL_PREFIX(GetProgramInfoLog) + .type GL_PREFIX(GetProgramInfoLog), @function +GL_PREFIX(GetProgramInfoLog): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 3592(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rdx + pushq %rcx + pushq %rbp + call _x86_64_get_dispatch@PLT + popq %rbp + popq %rcx + popq %rdx + popq %rsi + popq %rdi + movq 3592(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 3592(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rdx + pushq %rcx + pushq %rbp + call _glapi_get_dispatch + popq %rbp + popq %rcx + popq %rdx + popq %rsi + popq %rdi + movq 3592(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(GetProgramInfoLog), .-GL_PREFIX(GetProgramInfoLog) + + .p2align 4,,15 + .globl GL_PREFIX(GetProgramiv) + .type GL_PREFIX(GetProgramiv), @function +GL_PREFIX(GetProgramiv): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 3600(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rdx + call _x86_64_get_dispatch@PLT + popq %rdx + popq %rsi + popq %rdi + movq 3600(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 3600(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rdx + call _glapi_get_dispatch + popq %rdx + popq %rsi + popq %rdi + movq 3600(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(GetProgramiv), .-GL_PREFIX(GetProgramiv) + + .p2align 4,,15 + .globl GL_PREFIX(GetShaderInfoLog) + .type GL_PREFIX(GetShaderInfoLog), @function +GL_PREFIX(GetShaderInfoLog): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 3608(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rdx + pushq %rcx + pushq %rbp + call _x86_64_get_dispatch@PLT + popq %rbp + popq %rcx + popq %rdx + popq %rsi + popq %rdi + movq 3608(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 3608(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rdx + pushq %rcx + pushq %rbp + call _glapi_get_dispatch + popq %rbp + popq %rcx + popq %rdx + popq %rsi + popq %rdi + movq 3608(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(GetShaderInfoLog), .-GL_PREFIX(GetShaderInfoLog) + + .p2align 4,,15 + .globl GL_PREFIX(GetShaderSource) + .type GL_PREFIX(GetShaderSource), @function +GL_PREFIX(GetShaderSource): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 3616(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rdx + pushq %rcx + pushq %rbp + call _x86_64_get_dispatch@PLT + popq %rbp + popq %rcx + popq %rdx + popq %rsi + popq %rdi + movq 3616(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 3616(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rdx + pushq %rcx + pushq %rbp + call _glapi_get_dispatch + popq %rbp + popq %rcx + popq %rdx + popq %rsi + popq %rdi + movq 3616(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(GetShaderSource), .-GL_PREFIX(GetShaderSource) + + .p2align 4,,15 + .globl GL_PREFIX(GetShaderiv) + .type GL_PREFIX(GetShaderiv), @function +GL_PREFIX(GetShaderiv): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 3624(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rdx + call _x86_64_get_dispatch@PLT + popq %rdx + popq %rsi + popq %rdi + movq 3624(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 3624(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rdx + call _glapi_get_dispatch + popq %rdx + popq %rsi + popq %rdi + movq 3624(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(GetShaderiv), .-GL_PREFIX(GetShaderiv) + + .p2align 4,,15 + .globl GL_PREFIX(GetUniformLocation) + .type GL_PREFIX(GetUniformLocation), @function +GL_PREFIX(GetUniformLocation): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 3632(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rbp + call _x86_64_get_dispatch@PLT + popq %rbp + popq %rsi + popq %rdi + movq 3632(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 3632(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rbp + call _glapi_get_dispatch + popq %rbp + popq %rsi + popq %rdi + movq 3632(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(GetUniformLocation), .-GL_PREFIX(GetUniformLocation) + + .p2align 4,,15 + .globl GL_PREFIX(GetUniformfv) + .type GL_PREFIX(GetUniformfv), @function +GL_PREFIX(GetUniformfv): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 3640(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rdx + call _x86_64_get_dispatch@PLT + popq %rdx + popq %rsi + popq %rdi + movq 3640(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 3640(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rdx + call _glapi_get_dispatch + popq %rdx + popq %rsi + popq %rdi + movq 3640(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(GetUniformfv), .-GL_PREFIX(GetUniformfv) + + .p2align 4,,15 + .globl GL_PREFIX(GetUniformiv) + .type GL_PREFIX(GetUniformiv), @function +GL_PREFIX(GetUniformiv): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 3648(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rdx + call _x86_64_get_dispatch@PLT + popq %rdx + popq %rsi + popq %rdi + movq 3648(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 3648(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rdx + call _glapi_get_dispatch + popq %rdx + popq %rsi + popq %rdi + movq 3648(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(GetUniformiv), .-GL_PREFIX(GetUniformiv) + + .p2align 4,,15 + .globl GL_PREFIX(GetVertexAttribPointerv) + .type GL_PREFIX(GetVertexAttribPointerv), @function +GL_PREFIX(GetVertexAttribPointerv): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 3656(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rdx + call _x86_64_get_dispatch@PLT + popq %rdx + popq %rsi + popq %rdi + movq 3656(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 3656(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rdx + call _glapi_get_dispatch + popq %rdx + popq %rsi + popq %rdi + movq 3656(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(GetVertexAttribPointerv), .-GL_PREFIX(GetVertexAttribPointerv) + + .p2align 4,,15 + .globl GL_PREFIX(GetVertexAttribfv) + .type GL_PREFIX(GetVertexAttribfv), @function +GL_PREFIX(GetVertexAttribfv): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 3664(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rdx + call _x86_64_get_dispatch@PLT + popq %rdx + popq %rsi + popq %rdi + movq 3664(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 3664(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rdx + call _glapi_get_dispatch + popq %rdx + popq %rsi + popq %rdi + movq 3664(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(GetVertexAttribfv), .-GL_PREFIX(GetVertexAttribfv) + + .p2align 4,,15 + .globl GL_PREFIX(GetVertexAttribiv) + .type GL_PREFIX(GetVertexAttribiv), @function +GL_PREFIX(GetVertexAttribiv): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 3672(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rdx + call _x86_64_get_dispatch@PLT + popq %rdx + popq %rsi + popq %rdi + movq 3672(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 3672(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rdx + call _glapi_get_dispatch + popq %rdx + popq %rsi + popq %rdi + movq 3672(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(GetVertexAttribiv), .-GL_PREFIX(GetVertexAttribiv) + + .p2align 4,,15 + .globl GL_PREFIX(IsProgram) + .type GL_PREFIX(IsProgram), @function +GL_PREFIX(IsProgram): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 3680(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + call _x86_64_get_dispatch@PLT + popq %rdi + movq 3680(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 3680(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + call _glapi_get_dispatch + popq %rdi + movq 3680(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(IsProgram), .-GL_PREFIX(IsProgram) + + .p2align 4,,15 + .globl GL_PREFIX(IsShader) + .type GL_PREFIX(IsShader), @function +GL_PREFIX(IsShader): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 3688(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + call _x86_64_get_dispatch@PLT + popq %rdi + movq 3688(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 3688(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + call _glapi_get_dispatch + popq %rdi + movq 3688(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(IsShader), .-GL_PREFIX(IsShader) + + .p2align 4,,15 + .globl GL_PREFIX(LinkProgram) + .type GL_PREFIX(LinkProgram), @function +GL_PREFIX(LinkProgram): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 3696(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + call _x86_64_get_dispatch@PLT + popq %rdi + movq 3696(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 3696(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + call _glapi_get_dispatch + popq %rdi + movq 3696(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(LinkProgram), .-GL_PREFIX(LinkProgram) + + .p2align 4,,15 + .globl GL_PREFIX(ShaderSource) + .type GL_PREFIX(ShaderSource), @function +GL_PREFIX(ShaderSource): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 3704(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rdx + pushq %rcx + pushq %rbp + call _x86_64_get_dispatch@PLT + popq %rbp + popq %rcx + popq %rdx + popq %rsi + popq %rdi + movq 3704(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 3704(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rdx + pushq %rcx + pushq %rbp + call _glapi_get_dispatch + popq %rbp + popq %rcx + popq %rdx + popq %rsi + popq %rdi + movq 3704(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(ShaderSource), .-GL_PREFIX(ShaderSource) + + .p2align 4,,15 + .globl GL_PREFIX(StencilFuncSeparate) + .type GL_PREFIX(StencilFuncSeparate), @function +GL_PREFIX(StencilFuncSeparate): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 3712(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rdx + pushq %rcx + pushq %rbp + call _x86_64_get_dispatch@PLT + popq %rbp + popq %rcx + popq %rdx + popq %rsi + popq %rdi + movq 3712(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 3712(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rdx + pushq %rcx + pushq %rbp + call _glapi_get_dispatch + popq %rbp + popq %rcx + popq %rdx + popq %rsi + popq %rdi + movq 3712(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(StencilFuncSeparate), .-GL_PREFIX(StencilFuncSeparate) + + .p2align 4,,15 + .globl GL_PREFIX(StencilMaskSeparate) + .type GL_PREFIX(StencilMaskSeparate), @function +GL_PREFIX(StencilMaskSeparate): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 3720(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rbp + call _x86_64_get_dispatch@PLT + popq %rbp + popq %rsi + popq %rdi + movq 3720(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 3720(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rbp + call _glapi_get_dispatch + popq %rbp + popq %rsi + popq %rdi + movq 3720(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(StencilMaskSeparate), .-GL_PREFIX(StencilMaskSeparate) + + .p2align 4,,15 + .globl GL_PREFIX(StencilOpSeparate) + .type GL_PREFIX(StencilOpSeparate), @function +GL_PREFIX(StencilOpSeparate): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 3728(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rdx + pushq %rcx + pushq %rbp + call _x86_64_get_dispatch@PLT + popq %rbp + popq %rcx + popq %rdx + popq %rsi + popq %rdi + movq 3728(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 3728(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rdx + pushq %rcx + pushq %rbp + call _glapi_get_dispatch + popq %rbp + popq %rcx + popq %rdx + popq %rsi + popq %rdi + movq 3728(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(StencilOpSeparate), .-GL_PREFIX(StencilOpSeparate) + + .p2align 4,,15 + .globl GL_PREFIX(Uniform1f) + .type GL_PREFIX(Uniform1f), @function +GL_PREFIX(Uniform1f): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 3736(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + subq $24, %rsp + movq %rdi, (%rsp) + movq %xmm0, 8(%rsp) + call _x86_64_get_dispatch@PLT + movq 8(%rsp), %xmm0 + movq (%rsp), %rdi + addq $24, %rsp + movq 3736(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 3736(%rax), %r11 + jmp *%r11 +1: + subq $24, %rsp + movq %rdi, (%rsp) + movq %xmm0, 8(%rsp) + call _glapi_get_dispatch + movq 8(%rsp), %xmm0 + movq (%rsp), %rdi + addq $24, %rsp + movq 3736(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(Uniform1f), .-GL_PREFIX(Uniform1f) + + .p2align 4,,15 + .globl GL_PREFIX(Uniform1fv) + .type GL_PREFIX(Uniform1fv), @function +GL_PREFIX(Uniform1fv): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 3744(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rdx + call _x86_64_get_dispatch@PLT + popq %rdx + popq %rsi + popq %rdi + movq 3744(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 3744(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rdx + call _glapi_get_dispatch + popq %rdx + popq %rsi + popq %rdi + movq 3744(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(Uniform1fv), .-GL_PREFIX(Uniform1fv) + + .p2align 4,,15 + .globl GL_PREFIX(Uniform1i) + .type GL_PREFIX(Uniform1i), @function +GL_PREFIX(Uniform1i): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 3752(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rbp + call _x86_64_get_dispatch@PLT + popq %rbp + popq %rsi + popq %rdi + movq 3752(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 3752(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rbp + call _glapi_get_dispatch + popq %rbp + popq %rsi + popq %rdi + movq 3752(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(Uniform1i), .-GL_PREFIX(Uniform1i) + + .p2align 4,,15 + .globl GL_PREFIX(Uniform1iv) + .type GL_PREFIX(Uniform1iv), @function +GL_PREFIX(Uniform1iv): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 3760(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rdx + call _x86_64_get_dispatch@PLT + popq %rdx + popq %rsi + popq %rdi + movq 3760(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 3760(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rdx + call _glapi_get_dispatch + popq %rdx + popq %rsi + popq %rdi + movq 3760(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(Uniform1iv), .-GL_PREFIX(Uniform1iv) + + .p2align 4,,15 + .globl GL_PREFIX(Uniform2f) + .type GL_PREFIX(Uniform2f), @function +GL_PREFIX(Uniform2f): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 3768(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + subq $24, %rsp + movq %rdi, (%rsp) + movq %xmm0, 8(%rsp) + movq %xmm1, 16(%rsp) + call _x86_64_get_dispatch@PLT + movq 16(%rsp), %xmm1 + movq 8(%rsp), %xmm0 + movq (%rsp), %rdi + addq $24, %rsp + movq 3768(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 3768(%rax), %r11 + jmp *%r11 +1: + subq $24, %rsp + movq %rdi, (%rsp) + movq %xmm0, 8(%rsp) + movq %xmm1, 16(%rsp) + call _glapi_get_dispatch + movq 16(%rsp), %xmm1 + movq 8(%rsp), %xmm0 + movq (%rsp), %rdi + addq $24, %rsp + movq 3768(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(Uniform2f), .-GL_PREFIX(Uniform2f) + + .p2align 4,,15 + .globl GL_PREFIX(Uniform2fv) + .type GL_PREFIX(Uniform2fv), @function +GL_PREFIX(Uniform2fv): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 3776(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rdx + call _x86_64_get_dispatch@PLT + popq %rdx + popq %rsi + popq %rdi + movq 3776(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 3776(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rdx + call _glapi_get_dispatch + popq %rdx + popq %rsi + popq %rdi + movq 3776(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(Uniform2fv), .-GL_PREFIX(Uniform2fv) + + .p2align 4,,15 + .globl GL_PREFIX(Uniform2i) + .type GL_PREFIX(Uniform2i), @function +GL_PREFIX(Uniform2i): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 3784(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rdx + call _x86_64_get_dispatch@PLT + popq %rdx + popq %rsi + popq %rdi + movq 3784(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 3784(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rdx + call _glapi_get_dispatch + popq %rdx + popq %rsi + popq %rdi + movq 3784(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(Uniform2i), .-GL_PREFIX(Uniform2i) + + .p2align 4,,15 + .globl GL_PREFIX(Uniform2iv) + .type GL_PREFIX(Uniform2iv), @function +GL_PREFIX(Uniform2iv): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 3792(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rdx + call _x86_64_get_dispatch@PLT + popq %rdx + popq %rsi + popq %rdi + movq 3792(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 3792(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rdx + call _glapi_get_dispatch + popq %rdx + popq %rsi + popq %rdi + movq 3792(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(Uniform2iv), .-GL_PREFIX(Uniform2iv) + + .p2align 4,,15 + .globl GL_PREFIX(Uniform3f) + .type GL_PREFIX(Uniform3f), @function +GL_PREFIX(Uniform3f): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 3800(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + subq $40, %rsp + movq %rdi, (%rsp) + movq %xmm0, 8(%rsp) + movq %xmm1, 16(%rsp) + movq %xmm2, 24(%rsp) + call _x86_64_get_dispatch@PLT + movq 24(%rsp), %xmm2 + movq 16(%rsp), %xmm1 + movq 8(%rsp), %xmm0 + movq (%rsp), %rdi + addq $40, %rsp + movq 3800(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 3800(%rax), %r11 + jmp *%r11 +1: + subq $40, %rsp + movq %rdi, (%rsp) + movq %xmm0, 8(%rsp) + movq %xmm1, 16(%rsp) + movq %xmm2, 24(%rsp) + call _glapi_get_dispatch + movq 24(%rsp), %xmm2 + movq 16(%rsp), %xmm1 + movq 8(%rsp), %xmm0 + movq (%rsp), %rdi + addq $40, %rsp + movq 3800(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(Uniform3f), .-GL_PREFIX(Uniform3f) + + .p2align 4,,15 + .globl GL_PREFIX(Uniform3fv) + .type GL_PREFIX(Uniform3fv), @function +GL_PREFIX(Uniform3fv): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 3808(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rdx + call _x86_64_get_dispatch@PLT + popq %rdx + popq %rsi + popq %rdi + movq 3808(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 3808(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rdx + call _glapi_get_dispatch + popq %rdx + popq %rsi + popq %rdi + movq 3808(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(Uniform3fv), .-GL_PREFIX(Uniform3fv) + + .p2align 4,,15 + .globl GL_PREFIX(Uniform3i) + .type GL_PREFIX(Uniform3i), @function +GL_PREFIX(Uniform3i): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 3816(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rdx + pushq %rcx + pushq %rbp + call _x86_64_get_dispatch@PLT + popq %rbp + popq %rcx + popq %rdx + popq %rsi + popq %rdi + movq 3816(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 3816(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rdx + pushq %rcx + pushq %rbp + call _glapi_get_dispatch + popq %rbp + popq %rcx + popq %rdx + popq %rsi + popq %rdi + movq 3816(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(Uniform3i), .-GL_PREFIX(Uniform3i) + + .p2align 4,,15 + .globl GL_PREFIX(Uniform3iv) + .type GL_PREFIX(Uniform3iv), @function +GL_PREFIX(Uniform3iv): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 3824(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rdx + call _x86_64_get_dispatch@PLT + popq %rdx + popq %rsi + popq %rdi + movq 3824(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 3824(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rdx + call _glapi_get_dispatch + popq %rdx + popq %rsi + popq %rdi + movq 3824(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(Uniform3iv), .-GL_PREFIX(Uniform3iv) + + .p2align 4,,15 + .globl GL_PREFIX(Uniform4f) + .type GL_PREFIX(Uniform4f), @function +GL_PREFIX(Uniform4f): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 3832(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + subq $40, %rsp + movq %rdi, (%rsp) + movq %xmm0, 8(%rsp) + movq %xmm1, 16(%rsp) + movq %xmm2, 24(%rsp) + movq %xmm3, 32(%rsp) + call _x86_64_get_dispatch@PLT + movq 32(%rsp), %xmm3 + movq 24(%rsp), %xmm2 + movq 16(%rsp), %xmm1 + movq 8(%rsp), %xmm0 + movq (%rsp), %rdi + addq $40, %rsp + movq 3832(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 3832(%rax), %r11 + jmp *%r11 +1: + subq $40, %rsp + movq %rdi, (%rsp) + movq %xmm0, 8(%rsp) + movq %xmm1, 16(%rsp) + movq %xmm2, 24(%rsp) + movq %xmm3, 32(%rsp) + call _glapi_get_dispatch + movq 32(%rsp), %xmm3 + movq 24(%rsp), %xmm2 + movq 16(%rsp), %xmm1 + movq 8(%rsp), %xmm0 + movq (%rsp), %rdi + addq $40, %rsp + movq 3832(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(Uniform4f), .-GL_PREFIX(Uniform4f) + + .p2align 4,,15 + .globl GL_PREFIX(Uniform4fv) + .type GL_PREFIX(Uniform4fv), @function +GL_PREFIX(Uniform4fv): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 3840(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rdx + call _x86_64_get_dispatch@PLT + popq %rdx + popq %rsi + popq %rdi + movq 3840(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 3840(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rdx + call _glapi_get_dispatch + popq %rdx + popq %rsi + popq %rdi + movq 3840(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(Uniform4fv), .-GL_PREFIX(Uniform4fv) + + .p2align 4,,15 + .globl GL_PREFIX(Uniform4i) + .type GL_PREFIX(Uniform4i), @function +GL_PREFIX(Uniform4i): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 3848(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rdx + pushq %rcx + pushq %r8 + call _x86_64_get_dispatch@PLT + popq %r8 + popq %rcx + popq %rdx + popq %rsi + popq %rdi + movq 3848(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 3848(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rdx + pushq %rcx + pushq %r8 + call _glapi_get_dispatch + popq %r8 + popq %rcx + popq %rdx + popq %rsi + popq %rdi + movq 3848(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(Uniform4i), .-GL_PREFIX(Uniform4i) + + .p2align 4,,15 + .globl GL_PREFIX(Uniform4iv) + .type GL_PREFIX(Uniform4iv), @function +GL_PREFIX(Uniform4iv): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 3856(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rdx + call _x86_64_get_dispatch@PLT + popq %rdx + popq %rsi + popq %rdi + movq 3856(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 3856(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rdx + call _glapi_get_dispatch + popq %rdx + popq %rsi + popq %rdi + movq 3856(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(Uniform4iv), .-GL_PREFIX(Uniform4iv) + + .p2align 4,,15 + .globl GL_PREFIX(UniformMatrix2fv) + .type GL_PREFIX(UniformMatrix2fv), @function +GL_PREFIX(UniformMatrix2fv): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 3864(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rdx + pushq %rcx + pushq %rbp + call _x86_64_get_dispatch@PLT + popq %rbp + popq %rcx + popq %rdx + popq %rsi + popq %rdi + movq 3864(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 3864(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rdx + pushq %rcx + pushq %rbp + call _glapi_get_dispatch + popq %rbp + popq %rcx + popq %rdx + popq %rsi + popq %rdi + movq 3864(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(UniformMatrix2fv), .-GL_PREFIX(UniformMatrix2fv) + + .p2align 4,,15 + .globl GL_PREFIX(UniformMatrix3fv) + .type GL_PREFIX(UniformMatrix3fv), @function +GL_PREFIX(UniformMatrix3fv): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 3872(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rdx + pushq %rcx + pushq %rbp + call _x86_64_get_dispatch@PLT + popq %rbp + popq %rcx + popq %rdx + popq %rsi + popq %rdi + movq 3872(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 3872(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rdx + pushq %rcx + pushq %rbp + call _glapi_get_dispatch + popq %rbp + popq %rcx + popq %rdx + popq %rsi + popq %rdi + movq 3872(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(UniformMatrix3fv), .-GL_PREFIX(UniformMatrix3fv) + + .p2align 4,,15 + .globl GL_PREFIX(UniformMatrix4fv) + .type GL_PREFIX(UniformMatrix4fv), @function +GL_PREFIX(UniformMatrix4fv): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 3880(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rdx + pushq %rcx + pushq %rbp + call _x86_64_get_dispatch@PLT + popq %rbp + popq %rcx + popq %rdx + popq %rsi + popq %rdi + movq 3880(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 3880(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rdx + pushq %rcx + pushq %rbp + call _glapi_get_dispatch + popq %rbp + popq %rcx + popq %rdx + popq %rsi + popq %rdi + movq 3880(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(UniformMatrix4fv), .-GL_PREFIX(UniformMatrix4fv) + + .p2align 4,,15 + .globl GL_PREFIX(UseProgram) + .type GL_PREFIX(UseProgram), @function +GL_PREFIX(UseProgram): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 3888(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + call _x86_64_get_dispatch@PLT + popq %rdi + movq 3888(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 3888(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + call _glapi_get_dispatch + popq %rdi + movq 3888(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(UseProgram), .-GL_PREFIX(UseProgram) + + .p2align 4,,15 + .globl GL_PREFIX(ValidateProgram) + .type GL_PREFIX(ValidateProgram), @function +GL_PREFIX(ValidateProgram): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 3896(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + call _x86_64_get_dispatch@PLT + popq %rdi + movq 3896(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 3896(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + call _glapi_get_dispatch + popq %rdi + movq 3896(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(ValidateProgram), .-GL_PREFIX(ValidateProgram) + + .p2align 4,,15 + .globl GL_PREFIX(VertexAttrib1f) + .type GL_PREFIX(VertexAttrib1f), @function +GL_PREFIX(VertexAttrib1f): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 3904(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + subq $24, %rsp + movq %rdi, (%rsp) + movq %xmm0, 8(%rsp) + call _x86_64_get_dispatch@PLT + movq 8(%rsp), %xmm0 + movq (%rsp), %rdi + addq $24, %rsp + movq 3904(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 3904(%rax), %r11 + jmp *%r11 +1: + subq $24, %rsp + movq %rdi, (%rsp) + movq %xmm0, 8(%rsp) + call _glapi_get_dispatch + movq 8(%rsp), %xmm0 + movq (%rsp), %rdi + addq $24, %rsp + movq 3904(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(VertexAttrib1f), .-GL_PREFIX(VertexAttrib1f) + + .p2align 4,,15 + .globl GL_PREFIX(VertexAttrib1fv) + .type GL_PREFIX(VertexAttrib1fv), @function +GL_PREFIX(VertexAttrib1fv): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 3912(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rbp + call _x86_64_get_dispatch@PLT + popq %rbp + popq %rsi + popq %rdi + movq 3912(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 3912(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rbp + call _glapi_get_dispatch + popq %rbp + popq %rsi + popq %rdi + movq 3912(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(VertexAttrib1fv), .-GL_PREFIX(VertexAttrib1fv) + + .p2align 4,,15 + .globl GL_PREFIX(VertexAttrib2f) + .type GL_PREFIX(VertexAttrib2f), @function +GL_PREFIX(VertexAttrib2f): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 3920(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + subq $24, %rsp + movq %rdi, (%rsp) + movq %xmm0, 8(%rsp) + movq %xmm1, 16(%rsp) + call _x86_64_get_dispatch@PLT + movq 16(%rsp), %xmm1 + movq 8(%rsp), %xmm0 + movq (%rsp), %rdi + addq $24, %rsp + movq 3920(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 3920(%rax), %r11 + jmp *%r11 +1: + subq $24, %rsp + movq %rdi, (%rsp) + movq %xmm0, 8(%rsp) + movq %xmm1, 16(%rsp) + call _glapi_get_dispatch + movq 16(%rsp), %xmm1 + movq 8(%rsp), %xmm0 + movq (%rsp), %rdi + addq $24, %rsp + movq 3920(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(VertexAttrib2f), .-GL_PREFIX(VertexAttrib2f) + + .p2align 4,,15 + .globl GL_PREFIX(VertexAttrib2fv) + .type GL_PREFIX(VertexAttrib2fv), @function +GL_PREFIX(VertexAttrib2fv): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 3928(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rbp + call _x86_64_get_dispatch@PLT + popq %rbp + popq %rsi + popq %rdi + movq 3928(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 3928(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rbp + call _glapi_get_dispatch + popq %rbp + popq %rsi + popq %rdi + movq 3928(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(VertexAttrib2fv), .-GL_PREFIX(VertexAttrib2fv) + + .p2align 4,,15 + .globl GL_PREFIX(VertexAttrib3f) + .type GL_PREFIX(VertexAttrib3f), @function +GL_PREFIX(VertexAttrib3f): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 3936(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + subq $40, %rsp + movq %rdi, (%rsp) + movq %xmm0, 8(%rsp) + movq %xmm1, 16(%rsp) + movq %xmm2, 24(%rsp) + call _x86_64_get_dispatch@PLT + movq 24(%rsp), %xmm2 + movq 16(%rsp), %xmm1 + movq 8(%rsp), %xmm0 + movq (%rsp), %rdi + addq $40, %rsp + movq 3936(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 3936(%rax), %r11 + jmp *%r11 +1: + subq $40, %rsp + movq %rdi, (%rsp) + movq %xmm0, 8(%rsp) + movq %xmm1, 16(%rsp) + movq %xmm2, 24(%rsp) + call _glapi_get_dispatch + movq 24(%rsp), %xmm2 + movq 16(%rsp), %xmm1 + movq 8(%rsp), %xmm0 + movq (%rsp), %rdi + addq $40, %rsp + movq 3936(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(VertexAttrib3f), .-GL_PREFIX(VertexAttrib3f) + + .p2align 4,,15 + .globl GL_PREFIX(VertexAttrib3fv) + .type GL_PREFIX(VertexAttrib3fv), @function +GL_PREFIX(VertexAttrib3fv): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 3944(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rbp + call _x86_64_get_dispatch@PLT + popq %rbp + popq %rsi + popq %rdi + movq 3944(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 3944(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rbp + call _glapi_get_dispatch + popq %rbp + popq %rsi + popq %rdi + movq 3944(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(VertexAttrib3fv), .-GL_PREFIX(VertexAttrib3fv) + + .p2align 4,,15 + .globl GL_PREFIX(VertexAttrib4f) + .type GL_PREFIX(VertexAttrib4f), @function +GL_PREFIX(VertexAttrib4f): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 3952(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + subq $40, %rsp + movq %rdi, (%rsp) + movq %xmm0, 8(%rsp) + movq %xmm1, 16(%rsp) + movq %xmm2, 24(%rsp) + movq %xmm3, 32(%rsp) + call _x86_64_get_dispatch@PLT + movq 32(%rsp), %xmm3 + movq 24(%rsp), %xmm2 + movq 16(%rsp), %xmm1 + movq 8(%rsp), %xmm0 + movq (%rsp), %rdi + addq $40, %rsp + movq 3952(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 3952(%rax), %r11 + jmp *%r11 +1: + subq $40, %rsp + movq %rdi, (%rsp) + movq %xmm0, 8(%rsp) + movq %xmm1, 16(%rsp) + movq %xmm2, 24(%rsp) + movq %xmm3, 32(%rsp) + call _glapi_get_dispatch + movq 32(%rsp), %xmm3 + movq 24(%rsp), %xmm2 + movq 16(%rsp), %xmm1 + movq 8(%rsp), %xmm0 + movq (%rsp), %rdi + addq $40, %rsp + movq 3952(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(VertexAttrib4f), .-GL_PREFIX(VertexAttrib4f) + + .p2align 4,,15 + .globl GL_PREFIX(VertexAttrib4fv) + .type GL_PREFIX(VertexAttrib4fv), @function +GL_PREFIX(VertexAttrib4fv): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 3960(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rbp + call _x86_64_get_dispatch@PLT + popq %rbp + popq %rsi + popq %rdi + movq 3960(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 3960(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rbp + call _glapi_get_dispatch + popq %rbp + popq %rsi + popq %rdi + movq 3960(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(VertexAttrib4fv), .-GL_PREFIX(VertexAttrib4fv) + + .p2align 4,,15 + .globl GL_PREFIX(VertexAttribPointer) + .type GL_PREFIX(VertexAttribPointer), @function +GL_PREFIX(VertexAttribPointer): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 3968(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rdx + pushq %rcx + pushq %r8 + pushq %r9 + pushq %rbp + call _x86_64_get_dispatch@PLT + popq %rbp + popq %r9 + popq %r8 + popq %rcx + popq %rdx + popq %rsi + popq %rdi + movq 3968(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 3968(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rdx + pushq %rcx + pushq %r8 + pushq %r9 + pushq %rbp + call _glapi_get_dispatch + popq %rbp + popq %r9 + popq %r8 + popq %rcx + popq %rdx + popq %rsi + popq %rdi + movq 3968(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(VertexAttribPointer), .-GL_PREFIX(VertexAttribPointer) + + .p2align 4,,15 + .globl GL_PREFIX(BlendFuncSeparate) + .type GL_PREFIX(BlendFuncSeparate), @function +GL_PREFIX(BlendFuncSeparate): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 3976(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rdx + pushq %rcx + pushq %rbp + call _x86_64_get_dispatch@PLT + popq %rbp + popq %rcx + popq %rdx + popq %rsi + popq %rdi + movq 3976(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 3976(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rdx + pushq %rcx + pushq %rbp + call _glapi_get_dispatch + popq %rbp + popq %rcx + popq %rdx + popq %rsi + popq %rdi + movq 3976(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(BlendFuncSeparate), .-GL_PREFIX(BlendFuncSeparate) + + .p2align 4,,15 + .globl GL_PREFIX(BindFramebuffer) + .type GL_PREFIX(BindFramebuffer), @function +GL_PREFIX(BindFramebuffer): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 3984(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rbp + call _x86_64_get_dispatch@PLT + popq %rbp + popq %rsi + popq %rdi + movq 3984(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 3984(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rbp + call _glapi_get_dispatch + popq %rbp + popq %rsi + popq %rdi + movq 3984(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(BindFramebuffer), .-GL_PREFIX(BindFramebuffer) + + .p2align 4,,15 + .globl GL_PREFIX(BindRenderbuffer) + .type GL_PREFIX(BindRenderbuffer), @function +GL_PREFIX(BindRenderbuffer): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 3992(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rbp + call _x86_64_get_dispatch@PLT + popq %rbp + popq %rsi + popq %rdi + movq 3992(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 3992(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rbp + call _glapi_get_dispatch + popq %rbp + popq %rsi + popq %rdi + movq 3992(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(BindRenderbuffer), .-GL_PREFIX(BindRenderbuffer) + + .p2align 4,,15 + .globl GL_PREFIX(CheckFramebufferStatus) + .type GL_PREFIX(CheckFramebufferStatus), @function +GL_PREFIX(CheckFramebufferStatus): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 4000(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + call _x86_64_get_dispatch@PLT + popq %rdi + movq 4000(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 4000(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + call _glapi_get_dispatch + popq %rdi + movq 4000(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(CheckFramebufferStatus), .-GL_PREFIX(CheckFramebufferStatus) + + .p2align 4,,15 + .globl GL_PREFIX(ClearDepthf) + .type GL_PREFIX(ClearDepthf), @function +GL_PREFIX(ClearDepthf): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 4008(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + call _x86_64_get_dispatch@PLT + popq %rdi + movq 4008(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 4008(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + call _glapi_get_dispatch + popq %rdi + movq 4008(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(ClearDepthf), .-GL_PREFIX(ClearDepthf) + + .p2align 4,,15 + .globl GL_PREFIX(DeleteFramebuffers) + .type GL_PREFIX(DeleteFramebuffers), @function +GL_PREFIX(DeleteFramebuffers): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 4016(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rbp + call _x86_64_get_dispatch@PLT + popq %rbp + popq %rsi + popq %rdi + movq 4016(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 4016(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rbp + call _glapi_get_dispatch + popq %rbp + popq %rsi + popq %rdi + movq 4016(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(DeleteFramebuffers), .-GL_PREFIX(DeleteFramebuffers) + + .p2align 4,,15 + .globl GL_PREFIX(DeleteRenderbuffers) + .type GL_PREFIX(DeleteRenderbuffers), @function +GL_PREFIX(DeleteRenderbuffers): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 4024(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rbp + call _x86_64_get_dispatch@PLT + popq %rbp + popq %rsi + popq %rdi + movq 4024(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 4024(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rbp + call _glapi_get_dispatch + popq %rbp + popq %rsi + popq %rdi + movq 4024(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(DeleteRenderbuffers), .-GL_PREFIX(DeleteRenderbuffers) + + .p2align 4,,15 + .globl GL_PREFIX(DepthRangef) + .type GL_PREFIX(DepthRangef), @function +GL_PREFIX(DepthRangef): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 4032(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rbp + call _x86_64_get_dispatch@PLT + popq %rbp + popq %rsi + popq %rdi + movq 4032(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 4032(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rbp + call _glapi_get_dispatch + popq %rbp + popq %rsi + popq %rdi + movq 4032(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(DepthRangef), .-GL_PREFIX(DepthRangef) + + .p2align 4,,15 + .globl GL_PREFIX(FramebufferRenderbuffer) + .type GL_PREFIX(FramebufferRenderbuffer), @function +GL_PREFIX(FramebufferRenderbuffer): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 4040(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rdx + pushq %rcx + pushq %rbp + call _x86_64_get_dispatch@PLT + popq %rbp + popq %rcx + popq %rdx + popq %rsi + popq %rdi + movq 4040(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 4040(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rdx + pushq %rcx + pushq %rbp + call _glapi_get_dispatch + popq %rbp + popq %rcx + popq %rdx + popq %rsi + popq %rdi + movq 4040(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(FramebufferRenderbuffer), .-GL_PREFIX(FramebufferRenderbuffer) + + .p2align 4,,15 + .globl GL_PREFIX(FramebufferTexture2D) + .type GL_PREFIX(FramebufferTexture2D), @function +GL_PREFIX(FramebufferTexture2D): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 4048(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rdx + pushq %rcx + pushq %r8 + call _x86_64_get_dispatch@PLT + popq %r8 + popq %rcx + popq %rdx + popq %rsi + popq %rdi + movq 4048(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 4048(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rdx + pushq %rcx + pushq %r8 + call _glapi_get_dispatch + popq %r8 + popq %rcx + popq %rdx + popq %rsi + popq %rdi + movq 4048(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(FramebufferTexture2D), .-GL_PREFIX(FramebufferTexture2D) + + .p2align 4,,15 + .globl GL_PREFIX(GenFramebuffers) + .type GL_PREFIX(GenFramebuffers), @function +GL_PREFIX(GenFramebuffers): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 4056(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rbp + call _x86_64_get_dispatch@PLT + popq %rbp + popq %rsi + popq %rdi + movq 4056(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 4056(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rbp + call _glapi_get_dispatch + popq %rbp + popq %rsi + popq %rdi + movq 4056(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(GenFramebuffers), .-GL_PREFIX(GenFramebuffers) + + .p2align 4,,15 + .globl GL_PREFIX(GenRenderbuffers) + .type GL_PREFIX(GenRenderbuffers), @function +GL_PREFIX(GenRenderbuffers): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 4064(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rbp + call _x86_64_get_dispatch@PLT + popq %rbp + popq %rsi + popq %rdi + movq 4064(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 4064(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rbp + call _glapi_get_dispatch + popq %rbp + popq %rsi + popq %rdi + movq 4064(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(GenRenderbuffers), .-GL_PREFIX(GenRenderbuffers) + + .p2align 4,,15 + .globl GL_PREFIX(GenerateMipmap) + .type GL_PREFIX(GenerateMipmap), @function +GL_PREFIX(GenerateMipmap): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 4072(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + call _x86_64_get_dispatch@PLT + popq %rdi + movq 4072(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 4072(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + call _glapi_get_dispatch + popq %rdi + movq 4072(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(GenerateMipmap), .-GL_PREFIX(GenerateMipmap) + + .p2align 4,,15 + .globl GL_PREFIX(GetFramebufferAttachmentParameteriv) + .type GL_PREFIX(GetFramebufferAttachmentParameteriv), @function +GL_PREFIX(GetFramebufferAttachmentParameteriv): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 4080(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rdx + pushq %rcx + pushq %rbp + call _x86_64_get_dispatch@PLT + popq %rbp + popq %rcx + popq %rdx + popq %rsi + popq %rdi + movq 4080(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 4080(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rdx + pushq %rcx + pushq %rbp + call _glapi_get_dispatch + popq %rbp + popq %rcx + popq %rdx + popq %rsi + popq %rdi + movq 4080(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(GetFramebufferAttachmentParameteriv), .-GL_PREFIX(GetFramebufferAttachmentParameteriv) + + .p2align 4,,15 + .globl GL_PREFIX(GetRenderbufferParameteriv) + .type GL_PREFIX(GetRenderbufferParameteriv), @function +GL_PREFIX(GetRenderbufferParameteriv): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 4088(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rdx + call _x86_64_get_dispatch@PLT + popq %rdx + popq %rsi + popq %rdi + movq 4088(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 4088(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rdx + call _glapi_get_dispatch + popq %rdx + popq %rsi + popq %rdi + movq 4088(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(GetRenderbufferParameteriv), .-GL_PREFIX(GetRenderbufferParameteriv) + + .p2align 4,,15 + .globl GL_PREFIX(GetShaderPrecisionFormat) + .type GL_PREFIX(GetShaderPrecisionFormat), @function +GL_PREFIX(GetShaderPrecisionFormat): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 4096(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rdx + pushq %rcx + pushq %rbp + call _x86_64_get_dispatch@PLT + popq %rbp + popq %rcx + popq %rdx + popq %rsi + popq %rdi + movq 4096(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 4096(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rdx + pushq %rcx + pushq %rbp + call _glapi_get_dispatch + popq %rbp + popq %rcx + popq %rdx + popq %rsi + popq %rdi + movq 4096(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(GetShaderPrecisionFormat), .-GL_PREFIX(GetShaderPrecisionFormat) + + .p2align 4,,15 + .globl GL_PREFIX(IsFramebuffer) + .type GL_PREFIX(IsFramebuffer), @function +GL_PREFIX(IsFramebuffer): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 4104(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + call _x86_64_get_dispatch@PLT + popq %rdi + movq 4104(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 4104(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + call _glapi_get_dispatch + popq %rdi + movq 4104(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(IsFramebuffer), .-GL_PREFIX(IsFramebuffer) + + .p2align 4,,15 + .globl GL_PREFIX(IsRenderbuffer) + .type GL_PREFIX(IsRenderbuffer), @function +GL_PREFIX(IsRenderbuffer): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 4112(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + call _x86_64_get_dispatch@PLT + popq %rdi + movq 4112(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 4112(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + call _glapi_get_dispatch + popq %rdi + movq 4112(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(IsRenderbuffer), .-GL_PREFIX(IsRenderbuffer) + + .p2align 4,,15 + .globl GL_PREFIX(ReleaseShaderCompiler) + .type GL_PREFIX(ReleaseShaderCompiler), @function +GL_PREFIX(ReleaseShaderCompiler): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 4120(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rbp + call _x86_64_get_dispatch@PLT + popq %rbp + movq 4120(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 4120(%rax), %r11 + jmp *%r11 +1: + pushq %rbp + call _glapi_get_dispatch + popq %rbp + movq 4120(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(ReleaseShaderCompiler), .-GL_PREFIX(ReleaseShaderCompiler) + + .p2align 4,,15 + .globl GL_PREFIX(RenderbufferStorage) + .type GL_PREFIX(RenderbufferStorage), @function +GL_PREFIX(RenderbufferStorage): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 4128(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rdx + pushq %rcx + pushq %rbp + call _x86_64_get_dispatch@PLT + popq %rbp + popq %rcx + popq %rdx + popq %rsi + popq %rdi + movq 4128(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 4128(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rdx + pushq %rcx + pushq %rbp + call _glapi_get_dispatch + popq %rbp + popq %rcx + popq %rdx + popq %rsi + popq %rdi + movq 4128(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(RenderbufferStorage), .-GL_PREFIX(RenderbufferStorage) + + .p2align 4,,15 + .globl GL_PREFIX(ShaderBinary) + .type GL_PREFIX(ShaderBinary), @function +GL_PREFIX(ShaderBinary): +#if defined(GLX_USE_TLS) + call _x86_64_get_dispatch@PLT + movq 4136(%rax), %r11 + jmp *%r11 +#elif defined(PTHREADS) + pushq %rdi + pushq %rsi + pushq %rdx + pushq %rcx + pushq %r8 + call _x86_64_get_dispatch@PLT + popq %r8 + popq %rcx + popq %rdx + popq %rsi + popq %rdi + movq 4136(%rax), %r11 + jmp *%r11 +#else + movq _glapi_Dispatch(%rip), %rax + testq %rax, %rax + je 1f + movq 4136(%rax), %r11 + jmp *%r11 +1: + pushq %rdi + pushq %rsi + pushq %rdx + pushq %rcx + pushq %r8 + call _glapi_get_dispatch + popq %r8 + popq %rcx + popq %rdx + popq %rsi + popq %rdi + movq 4136(%rax), %r11 + jmp *%r11 +#endif /* defined(GLX_USE_TLS) */ + .size GL_PREFIX(ShaderBinary), .-GL_PREFIX(ShaderBinary) + + +#if defined(GLX_USE_TLS) && defined(__linux__) + .section ".note.ABI-tag", "a" + .p2align 2 + .long 1f - 0f /* name length */ + .long 3f - 2f /* data length */ + .long 1 /* note length */ +0: .asciz "GNU" /* vendor name */ +1: .p2align 2 +2: .long 0 /* note data: the ABI tag */ + .long 2,4,20 /* Minimum kernel version w/TLS */ +3: .p2align 2 /* pad out section */ +#endif /* GLX_USE_TLS */ + +#if defined (__ELF__) && defined (__linux__) + .section .note.GNU-stack,"",%progbits +#endif diff --git a/src/mapi/es2api/glapi/glapi_x86.S b/src/mapi/es2api/glapi/glapi_x86.S new file mode 100644 index 00000000000..b377c137413 --- /dev/null +++ b/src/mapi/es2api/glapi/glapi_x86.S @@ -0,0 +1,1053 @@ +/* DO NOT EDIT - This file generated automatically by gl_x86_asm.py (from Mesa) script */ + +/* + * Copyright (C) 1999-2001 Brian Paul All Rights Reserved. + * (C) Copyright IBM Corporation 2004, 2005 + * All Rights Reserved. + * + * Permission is hereby granted, free of charge, to any person obtaining a + * copy of this software and associated documentation files (the "Software"), + * to deal in the Software without restriction, including without limitation + * the rights to use, copy, modify, merge, publish, distribute, sub license, + * and/or sell copies of the Software, and to permit persons to whom the + * Software is furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice (including the next + * paragraph) shall be included in all copies or substantial portions of the + * Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL + * BRIAN PAUL, IBM, + * AND/OR THEIR SUPPLIERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, + * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF + * OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE + * SOFTWARE. + */ + +#include "x86/assyntax.h" + +#if defined(STDCALL_API) +# if defined(USE_MGL_NAMESPACE) +# define GL_PREFIX(n,n2) GLNAME(CONCAT(mgl,n2)) +# else +# define GL_PREFIX(n,n2) GLNAME(CONCAT(gl,n2)) +# endif +#else +# if defined(USE_MGL_NAMESPACE) +# define GL_PREFIX(n,n2) GLNAME(CONCAT(mgl,n)) +# define _glapi_Dispatch _mglapi_Dispatch +# else +# define GL_PREFIX(n,n2) GLNAME(CONCAT(gl,n)) +# endif +#endif + +#define GL_OFFSET(x) CODEPTR(REGOFF(4 * x, EAX)) + +#if defined(GNU_ASSEMBLER) && !defined(__DJGPP__) && !defined(__MINGW32__) && !defined(__APPLE__) +#define GLOBL_FN(x) GLOBL x ; .type x, function +#else +#define GLOBL_FN(x) GLOBL x +#endif + +#if defined(PTHREADS) || defined(WIN32) || defined(BEOS_THREADS) +# define THREADS +#endif + +#ifdef GLX_USE_TLS + +#ifdef GLX_X86_READONLY_TEXT +# define CTX_INSNS MOV_L(GS:(EAX), EAX) +#else +# define CTX_INSNS NOP /* Pad for init_glapi_relocs() */ +#endif + +# define GL_STUB(fn,off,fn_alt) \ +ALIGNTEXT16; \ +GLOBL_FN(GL_PREFIX(fn, fn_alt)); \ +GL_PREFIX(fn, fn_alt): \ + CALL(_x86_get_dispatch) ; \ + CTX_INSNS ; \ + JMP(GL_OFFSET(off)) + +#elif defined(PTHREADS) +# define GL_STUB(fn,off,fn_alt) \ +ALIGNTEXT16; \ +GLOBL_FN(GL_PREFIX(fn, fn_alt)); \ +GL_PREFIX(fn, fn_alt): \ + MOV_L(CONTENT(GLNAME(_glapi_Dispatch)), EAX) ; \ + TEST_L(EAX, EAX) ; \ + JE(1f) ; \ + JMP(GL_OFFSET(off)) ; \ +1: CALL(_x86_get_dispatch) ; \ + JMP(GL_OFFSET(off)) +#elif defined(THREADS) +# define GL_STUB(fn,off,fn_alt) \ +ALIGNTEXT16; \ +GLOBL_FN(GL_PREFIX(fn, fn_alt)); \ +GL_PREFIX(fn, fn_alt): \ + MOV_L(CONTENT(GLNAME(_glapi_Dispatch)), EAX) ; \ + TEST_L(EAX, EAX) ; \ + JE(1f) ; \ + JMP(GL_OFFSET(off)) ; \ +1: CALL(_glapi_get_dispatch) ; \ + JMP(GL_OFFSET(off)) +#else /* Non-threaded version. */ +# define GL_STUB(fn,off,fn_alt) \ +ALIGNTEXT16; \ +GLOBL_FN(GL_PREFIX(fn, fn_alt)); \ +GL_PREFIX(fn, fn_alt): \ + MOV_L(CONTENT(GLNAME(_glapi_Dispatch)), EAX) ; \ + JMP(GL_OFFSET(off)) +#endif + +#ifdef HAVE_ALIAS +# define GL_STUB_ALIAS(fn,off,fn_alt,alias,alias_alt) \ + .globl GL_PREFIX(fn, fn_alt) ; \ + .set GL_PREFIX(fn, fn_alt), GL_PREFIX(alias, alias_alt) +#else +# define GL_STUB_ALIAS(fn,off,fn_alt,alias,alias_alt) \ + GL_STUB(fn, off, fn_alt) +#endif + +SEG_TEXT + +#ifdef GLX_USE_TLS + + GLOBL GLNAME(_x86_get_dispatch) + HIDDEN(GLNAME(_x86_get_dispatch)) +ALIGNTEXT16 +GLNAME(_x86_get_dispatch): + call 1f +1: popl %eax + addl $_GLOBAL_OFFSET_TABLE_+[.-1b], %eax + movl _glapi_tls_Dispatch@GOTNTPOFF(%eax), %eax + ret + +#elif defined(PTHREADS) +EXTERN GLNAME(_glapi_Dispatch) +EXTERN GLNAME(_gl_DispatchTSD) +EXTERN GLNAME(pthread_getspecific) + +ALIGNTEXT16 +GLNAME(_x86_get_dispatch): + SUB_L(CONST(24), ESP) + PUSH_L(GLNAME(_gl_DispatchTSD)) + CALL(GLNAME(pthread_getspecific)) + ADD_L(CONST(28), ESP) + RET +#elif defined(THREADS) +EXTERN GLNAME(_glapi_get_dispatch) +#endif + +#if defined( GLX_USE_TLS ) && !defined( GLX_X86_READONLY_TEXT ) + .section wtext, "awx", @progbits +#endif /* defined( GLX_USE_TLS ) */ + + ALIGNTEXT16 + GLOBL GLNAME(gl_dispatch_functions_start) + HIDDEN(GLNAME(gl_dispatch_functions_start)) +GLNAME(gl_dispatch_functions_start): + + GL_STUB(_dispatch_stub_0, 0, _dispatch_stub_0@8) + HIDDEN(GL_PREFIX(_dispatch_stub_0, _dispatch_stub_0@8)) + GL_STUB(_dispatch_stub_1, 1, _dispatch_stub_1@0) + HIDDEN(GL_PREFIX(_dispatch_stub_1, _dispatch_stub_1@0)) + GL_STUB(_dispatch_stub_2, 2, _dispatch_stub_2@4) + HIDDEN(GL_PREFIX(_dispatch_stub_2, _dispatch_stub_2@4)) + GL_STUB(_dispatch_stub_3, 3, _dispatch_stub_3@12) + HIDDEN(GL_PREFIX(_dispatch_stub_3, _dispatch_stub_3@12)) + GL_STUB(_dispatch_stub_4, 4, _dispatch_stub_4@8) + HIDDEN(GL_PREFIX(_dispatch_stub_4, _dispatch_stub_4@8)) + GL_STUB(_dispatch_stub_5, 5, _dispatch_stub_5@4) + HIDDEN(GL_PREFIX(_dispatch_stub_5, _dispatch_stub_5@4)) + GL_STUB(_dispatch_stub_6, 6, _dispatch_stub_6@4) + HIDDEN(GL_PREFIX(_dispatch_stub_6, _dispatch_stub_6@4)) + GL_STUB(_dispatch_stub_7, 7, _dispatch_stub_7@4) + HIDDEN(GL_PREFIX(_dispatch_stub_7, _dispatch_stub_7@4)) + GL_STUB(_dispatch_stub_8, 8, _dispatch_stub_8@28) + HIDDEN(GL_PREFIX(_dispatch_stub_8, _dispatch_stub_8@28)) + GL_STUB(_dispatch_stub_9, 9, _dispatch_stub_9@12) + HIDDEN(GL_PREFIX(_dispatch_stub_9, _dispatch_stub_9@12)) + GL_STUB(_dispatch_stub_10, 10, _dispatch_stub_10@4) + HIDDEN(GL_PREFIX(_dispatch_stub_10, _dispatch_stub_10@4)) + GL_STUB(_dispatch_stub_11, 11, _dispatch_stub_11@24) + HIDDEN(GL_PREFIX(_dispatch_stub_11, _dispatch_stub_11@24)) + GL_STUB(_dispatch_stub_12, 12, _dispatch_stub_12@4) + HIDDEN(GL_PREFIX(_dispatch_stub_12, _dispatch_stub_12@4)) + GL_STUB(_dispatch_stub_13, 13, _dispatch_stub_13@12) + HIDDEN(GL_PREFIX(_dispatch_stub_13, _dispatch_stub_13@12)) + GL_STUB(_dispatch_stub_14, 14, _dispatch_stub_14@4) + HIDDEN(GL_PREFIX(_dispatch_stub_14, _dispatch_stub_14@4)) + GL_STUB(_dispatch_stub_15, 15, _dispatch_stub_15@12) + HIDDEN(GL_PREFIX(_dispatch_stub_15, _dispatch_stub_15@12)) + GL_STUB(_dispatch_stub_16, 16, _dispatch_stub_16@4) + HIDDEN(GL_PREFIX(_dispatch_stub_16, _dispatch_stub_16@4)) + GL_STUB(_dispatch_stub_17, 17, _dispatch_stub_17@12) + HIDDEN(GL_PREFIX(_dispatch_stub_17, _dispatch_stub_17@12)) + GL_STUB(_dispatch_stub_18, 18, _dispatch_stub_18@4) + HIDDEN(GL_PREFIX(_dispatch_stub_18, _dispatch_stub_18@4)) + GL_STUB(_dispatch_stub_19, 19, _dispatch_stub_19@12) + HIDDEN(GL_PREFIX(_dispatch_stub_19, _dispatch_stub_19@12)) + GL_STUB(_dispatch_stub_20, 20, _dispatch_stub_20@4) + HIDDEN(GL_PREFIX(_dispatch_stub_20, _dispatch_stub_20@4)) + GL_STUB(_dispatch_stub_21, 21, _dispatch_stub_21@12) + HIDDEN(GL_PREFIX(_dispatch_stub_21, _dispatch_stub_21@12)) + GL_STUB(_dispatch_stub_22, 22, _dispatch_stub_22@4) + HIDDEN(GL_PREFIX(_dispatch_stub_22, _dispatch_stub_22@4)) + GL_STUB(_dispatch_stub_23, 23, _dispatch_stub_23@12) + HIDDEN(GL_PREFIX(_dispatch_stub_23, _dispatch_stub_23@12)) + GL_STUB(_dispatch_stub_24, 24, _dispatch_stub_24@4) + HIDDEN(GL_PREFIX(_dispatch_stub_24, _dispatch_stub_24@4)) + GL_STUB(_dispatch_stub_25, 25, _dispatch_stub_25@16) + HIDDEN(GL_PREFIX(_dispatch_stub_25, _dispatch_stub_25@16)) + GL_STUB(_dispatch_stub_26, 26, _dispatch_stub_26@4) + HIDDEN(GL_PREFIX(_dispatch_stub_26, _dispatch_stub_26@4)) + GL_STUB(_dispatch_stub_27, 27, _dispatch_stub_27@32) + HIDDEN(GL_PREFIX(_dispatch_stub_27, _dispatch_stub_27@32)) + GL_STUB(_dispatch_stub_28, 28, _dispatch_stub_28@4) + HIDDEN(GL_PREFIX(_dispatch_stub_28, _dispatch_stub_28@4)) + GL_STUB(_dispatch_stub_29, 29, _dispatch_stub_29@16) + HIDDEN(GL_PREFIX(_dispatch_stub_29, _dispatch_stub_29@16)) + GL_STUB(_dispatch_stub_30, 30, _dispatch_stub_30@4) + HIDDEN(GL_PREFIX(_dispatch_stub_30, _dispatch_stub_30@4)) + GL_STUB(_dispatch_stub_31, 31, _dispatch_stub_31@16) + HIDDEN(GL_PREFIX(_dispatch_stub_31, _dispatch_stub_31@16)) + GL_STUB(_dispatch_stub_32, 32, _dispatch_stub_32@4) + HIDDEN(GL_PREFIX(_dispatch_stub_32, _dispatch_stub_32@4)) + GL_STUB(_dispatch_stub_33, 33, _dispatch_stub_33@16) + HIDDEN(GL_PREFIX(_dispatch_stub_33, _dispatch_stub_33@16)) + GL_STUB(_dispatch_stub_34, 34, _dispatch_stub_34@4) + HIDDEN(GL_PREFIX(_dispatch_stub_34, _dispatch_stub_34@4)) + GL_STUB(_dispatch_stub_35, 35, _dispatch_stub_35@16) + HIDDEN(GL_PREFIX(_dispatch_stub_35, _dispatch_stub_35@16)) + GL_STUB(_dispatch_stub_36, 36, _dispatch_stub_36@4) + HIDDEN(GL_PREFIX(_dispatch_stub_36, _dispatch_stub_36@4)) + GL_STUB(_dispatch_stub_37, 37, _dispatch_stub_37@16) + HIDDEN(GL_PREFIX(_dispatch_stub_37, _dispatch_stub_37@16)) + GL_STUB(_dispatch_stub_38, 38, _dispatch_stub_38@4) + HIDDEN(GL_PREFIX(_dispatch_stub_38, _dispatch_stub_38@4)) + GL_STUB(_dispatch_stub_39, 39, _dispatch_stub_39@16) + HIDDEN(GL_PREFIX(_dispatch_stub_39, _dispatch_stub_39@16)) + GL_STUB(_dispatch_stub_40, 40, _dispatch_stub_40@4) + HIDDEN(GL_PREFIX(_dispatch_stub_40, _dispatch_stub_40@4)) + GL_STUB(_dispatch_stub_41, 41, _dispatch_stub_41@4) + HIDDEN(GL_PREFIX(_dispatch_stub_41, _dispatch_stub_41@4)) + GL_STUB(_dispatch_stub_42, 42, _dispatch_stub_42@4) + HIDDEN(GL_PREFIX(_dispatch_stub_42, _dispatch_stub_42@4)) + GL_STUB(_dispatch_stub_43, 43, _dispatch_stub_43@0) + HIDDEN(GL_PREFIX(_dispatch_stub_43, _dispatch_stub_43@0)) + GL_STUB(_dispatch_stub_44, 44, _dispatch_stub_44@8) + HIDDEN(GL_PREFIX(_dispatch_stub_44, _dispatch_stub_44@8)) + GL_STUB(_dispatch_stub_45, 45, _dispatch_stub_45@4) + HIDDEN(GL_PREFIX(_dispatch_stub_45, _dispatch_stub_45@4)) + GL_STUB(_dispatch_stub_46, 46, _dispatch_stub_46@4) + HIDDEN(GL_PREFIX(_dispatch_stub_46, _dispatch_stub_46@4)) + GL_STUB(_dispatch_stub_47, 47, _dispatch_stub_47@4) + HIDDEN(GL_PREFIX(_dispatch_stub_47, _dispatch_stub_47@4)) + GL_STUB(_dispatch_stub_48, 48, _dispatch_stub_48@4) + HIDDEN(GL_PREFIX(_dispatch_stub_48, _dispatch_stub_48@4)) + GL_STUB(_dispatch_stub_49, 49, _dispatch_stub_49@4) + HIDDEN(GL_PREFIX(_dispatch_stub_49, _dispatch_stub_49@4)) + GL_STUB(_dispatch_stub_50, 50, _dispatch_stub_50@4) + HIDDEN(GL_PREFIX(_dispatch_stub_50, _dispatch_stub_50@4)) + GL_STUB(_dispatch_stub_51, 51, _dispatch_stub_51@4) + HIDDEN(GL_PREFIX(_dispatch_stub_51, _dispatch_stub_51@4)) + GL_STUB(_dispatch_stub_52, 52, _dispatch_stub_52@12) + HIDDEN(GL_PREFIX(_dispatch_stub_52, _dispatch_stub_52@12)) + GL_STUB(_dispatch_stub_53, 53, _dispatch_stub_53@4) + HIDDEN(GL_PREFIX(_dispatch_stub_53, _dispatch_stub_53@4)) + GL_STUB(_dispatch_stub_54, 54, _dispatch_stub_54@24) + HIDDEN(GL_PREFIX(_dispatch_stub_54, _dispatch_stub_54@24)) + GL_STUB(_dispatch_stub_55, 55, _dispatch_stub_55@4) + HIDDEN(GL_PREFIX(_dispatch_stub_55, _dispatch_stub_55@4)) + GL_STUB(_dispatch_stub_56, 56, _dispatch_stub_56@12) + HIDDEN(GL_PREFIX(_dispatch_stub_56, _dispatch_stub_56@12)) + GL_STUB(_dispatch_stub_57, 57, _dispatch_stub_57@4) + HIDDEN(GL_PREFIX(_dispatch_stub_57, _dispatch_stub_57@4)) + GL_STUB(_dispatch_stub_58, 58, _dispatch_stub_58@12) + HIDDEN(GL_PREFIX(_dispatch_stub_58, _dispatch_stub_58@12)) + GL_STUB(_dispatch_stub_59, 59, _dispatch_stub_59@4) + HIDDEN(GL_PREFIX(_dispatch_stub_59, _dispatch_stub_59@4)) + GL_STUB(_dispatch_stub_60, 60, _dispatch_stub_60@12) + HIDDEN(GL_PREFIX(_dispatch_stub_60, _dispatch_stub_60@12)) + GL_STUB(_dispatch_stub_61, 61, _dispatch_stub_61@4) + HIDDEN(GL_PREFIX(_dispatch_stub_61, _dispatch_stub_61@4)) + GL_STUB(_dispatch_stub_62, 62, _dispatch_stub_62@16) + HIDDEN(GL_PREFIX(_dispatch_stub_62, _dispatch_stub_62@16)) + GL_STUB(_dispatch_stub_63, 63, _dispatch_stub_63@4) + HIDDEN(GL_PREFIX(_dispatch_stub_63, _dispatch_stub_63@4)) + GL_STUB(_dispatch_stub_64, 64, _dispatch_stub_64@8) + HIDDEN(GL_PREFIX(_dispatch_stub_64, _dispatch_stub_64@8)) + GL_STUB(_dispatch_stub_65, 65, _dispatch_stub_65@4) + HIDDEN(GL_PREFIX(_dispatch_stub_65, _dispatch_stub_65@4)) + GL_STUB(_dispatch_stub_66, 66, _dispatch_stub_66@8) + HIDDEN(GL_PREFIX(_dispatch_stub_66, _dispatch_stub_66@8)) + GL_STUB(_dispatch_stub_67, 67, _dispatch_stub_67@4) + HIDDEN(GL_PREFIX(_dispatch_stub_67, _dispatch_stub_67@4)) + GL_STUB(_dispatch_stub_68, 68, _dispatch_stub_68@8) + HIDDEN(GL_PREFIX(_dispatch_stub_68, _dispatch_stub_68@8)) + GL_STUB(_dispatch_stub_69, 69, _dispatch_stub_69@4) + HIDDEN(GL_PREFIX(_dispatch_stub_69, _dispatch_stub_69@4)) + GL_STUB(_dispatch_stub_70, 70, _dispatch_stub_70@24) + HIDDEN(GL_PREFIX(_dispatch_stub_70, _dispatch_stub_70@24)) + GL_STUB(_dispatch_stub_71, 71, _dispatch_stub_71@4) + HIDDEN(GL_PREFIX(_dispatch_stub_71, _dispatch_stub_71@4)) + GL_STUB(_dispatch_stub_72, 72, _dispatch_stub_72@12) + HIDDEN(GL_PREFIX(_dispatch_stub_72, _dispatch_stub_72@12)) + GL_STUB(_dispatch_stub_73, 73, _dispatch_stub_73@4) + HIDDEN(GL_PREFIX(_dispatch_stub_73, _dispatch_stub_73@4)) + GL_STUB(_dispatch_stub_74, 74, _dispatch_stub_74@12) + HIDDEN(GL_PREFIX(_dispatch_stub_74, _dispatch_stub_74@12)) + GL_STUB(_dispatch_stub_75, 75, _dispatch_stub_75@4) + HIDDEN(GL_PREFIX(_dispatch_stub_75, _dispatch_stub_75@4)) + GL_STUB(_dispatch_stub_76, 76, _dispatch_stub_76@12) + HIDDEN(GL_PREFIX(_dispatch_stub_76, _dispatch_stub_76@12)) + GL_STUB(_dispatch_stub_77, 77, _dispatch_stub_77@4) + HIDDEN(GL_PREFIX(_dispatch_stub_77, _dispatch_stub_77@4)) + GL_STUB(_dispatch_stub_78, 78, _dispatch_stub_78@32) + HIDDEN(GL_PREFIX(_dispatch_stub_78, _dispatch_stub_78@32)) + GL_STUB(_dispatch_stub_79, 79, _dispatch_stub_79@4) + HIDDEN(GL_PREFIX(_dispatch_stub_79, _dispatch_stub_79@4)) + GL_STUB(_dispatch_stub_80, 80, _dispatch_stub_80@16) + HIDDEN(GL_PREFIX(_dispatch_stub_80, _dispatch_stub_80@16)) + GL_STUB(_dispatch_stub_81, 81, _dispatch_stub_81@4) + HIDDEN(GL_PREFIX(_dispatch_stub_81, _dispatch_stub_81@4)) + GL_STUB(_dispatch_stub_82, 82, _dispatch_stub_82@16) + HIDDEN(GL_PREFIX(_dispatch_stub_82, _dispatch_stub_82@16)) + GL_STUB(_dispatch_stub_83, 83, _dispatch_stub_83@4) + HIDDEN(GL_PREFIX(_dispatch_stub_83, _dispatch_stub_83@4)) + GL_STUB(_dispatch_stub_84, 84, _dispatch_stub_84@16) + HIDDEN(GL_PREFIX(_dispatch_stub_84, _dispatch_stub_84@16)) + GL_STUB(_dispatch_stub_85, 85, _dispatch_stub_85@4) + HIDDEN(GL_PREFIX(_dispatch_stub_85, _dispatch_stub_85@4)) + GL_STUB(_dispatch_stub_86, 86, _dispatch_stub_86@32) + HIDDEN(GL_PREFIX(_dispatch_stub_86, _dispatch_stub_86@32)) + GL_STUB(_dispatch_stub_87, 87, _dispatch_stub_87@8) + HIDDEN(GL_PREFIX(_dispatch_stub_87, _dispatch_stub_87@8)) + GL_STUB(_dispatch_stub_88, 88, _dispatch_stub_88@16) + HIDDEN(GL_PREFIX(_dispatch_stub_88, _dispatch_stub_88@16)) + GL_STUB(_dispatch_stub_89, 89, _dispatch_stub_89@8) + HIDDEN(GL_PREFIX(_dispatch_stub_89, _dispatch_stub_89@8)) + GL_STUB(_dispatch_stub_90, 90, _dispatch_stub_90@16) + HIDDEN(GL_PREFIX(_dispatch_stub_90, _dispatch_stub_90@16)) + GL_STUB(_dispatch_stub_91, 91, _dispatch_stub_91@8) + HIDDEN(GL_PREFIX(_dispatch_stub_91, _dispatch_stub_91@8)) + GL_STUB(_dispatch_stub_92, 92, _dispatch_stub_92@16) + HIDDEN(GL_PREFIX(_dispatch_stub_92, _dispatch_stub_92@16)) + GL_STUB(_dispatch_stub_93, 93, _dispatch_stub_93@8) + HIDDEN(GL_PREFIX(_dispatch_stub_93, _dispatch_stub_93@8)) + GL_STUB(_dispatch_stub_94, 94, _dispatch_stub_94@8) + HIDDEN(GL_PREFIX(_dispatch_stub_94, _dispatch_stub_94@8)) + GL_STUB(_dispatch_stub_95, 95, _dispatch_stub_95@4) + HIDDEN(GL_PREFIX(_dispatch_stub_95, _dispatch_stub_95@4)) + GL_STUB(_dispatch_stub_96, 96, _dispatch_stub_96@4) + HIDDEN(GL_PREFIX(_dispatch_stub_96, _dispatch_stub_96@4)) + GL_STUB(_dispatch_stub_97, 97, _dispatch_stub_97@4) + HIDDEN(GL_PREFIX(_dispatch_stub_97, _dispatch_stub_97@4)) + GL_STUB(_dispatch_stub_98, 98, _dispatch_stub_98@4) + HIDDEN(GL_PREFIX(_dispatch_stub_98, _dispatch_stub_98@4)) + GL_STUB(_dispatch_stub_99, 99, _dispatch_stub_99@4) + HIDDEN(GL_PREFIX(_dispatch_stub_99, _dispatch_stub_99@4)) + GL_STUB(_dispatch_stub_100, 100, _dispatch_stub_100@4) + HIDDEN(GL_PREFIX(_dispatch_stub_100, _dispatch_stub_100@4)) + GL_STUB(_dispatch_stub_101, 101, _dispatch_stub_101@4) + HIDDEN(GL_PREFIX(_dispatch_stub_101, _dispatch_stub_101@4)) + GL_STUB(_dispatch_stub_102, 102, _dispatch_stub_102@16) + HIDDEN(GL_PREFIX(_dispatch_stub_102, _dispatch_stub_102@16)) + GL_STUB(_dispatch_stub_103, 103, _dispatch_stub_103@4) + HIDDEN(GL_PREFIX(_dispatch_stub_103, _dispatch_stub_103@4)) + GL_STUB(_dispatch_stub_104, 104, _dispatch_stub_104@8) + HIDDEN(GL_PREFIX(_dispatch_stub_104, _dispatch_stub_104@8)) + GL_STUB(_dispatch_stub_105, 105, _dispatch_stub_105@4) + HIDDEN(GL_PREFIX(_dispatch_stub_105, _dispatch_stub_105@4)) + GL_STUB(_dispatch_stub_106, 106, _dispatch_stub_106@8) + HIDDEN(GL_PREFIX(_dispatch_stub_106, _dispatch_stub_106@8)) + GL_STUB(_dispatch_stub_107, 107, _dispatch_stub_107@4) + HIDDEN(GL_PREFIX(_dispatch_stub_107, _dispatch_stub_107@4)) + GL_STUB(_dispatch_stub_108, 108, _dispatch_stub_108@8) + HIDDEN(GL_PREFIX(_dispatch_stub_108, _dispatch_stub_108@8)) + GL_STUB(_dispatch_stub_109, 109, _dispatch_stub_109@4) + HIDDEN(GL_PREFIX(_dispatch_stub_109, _dispatch_stub_109@4)) + GL_STUB(_dispatch_stub_110, 110, _dispatch_stub_110@24) + HIDDEN(GL_PREFIX(_dispatch_stub_110, _dispatch_stub_110@24)) + GL_STUB(_dispatch_stub_111, 111, _dispatch_stub_111@4) + HIDDEN(GL_PREFIX(_dispatch_stub_111, _dispatch_stub_111@4)) + GL_STUB(_dispatch_stub_112, 112, _dispatch_stub_112@12) + HIDDEN(GL_PREFIX(_dispatch_stub_112, _dispatch_stub_112@12)) + GL_STUB(_dispatch_stub_113, 113, _dispatch_stub_113@4) + HIDDEN(GL_PREFIX(_dispatch_stub_113, _dispatch_stub_113@4)) + GL_STUB(_dispatch_stub_114, 114, _dispatch_stub_114@12) + HIDDEN(GL_PREFIX(_dispatch_stub_114, _dispatch_stub_114@12)) + GL_STUB(_dispatch_stub_115, 115, _dispatch_stub_115@4) + HIDDEN(GL_PREFIX(_dispatch_stub_115, _dispatch_stub_115@4)) + GL_STUB(_dispatch_stub_116, 116, _dispatch_stub_116@12) + HIDDEN(GL_PREFIX(_dispatch_stub_116, _dispatch_stub_116@12)) + GL_STUB(_dispatch_stub_117, 117, _dispatch_stub_117@4) + HIDDEN(GL_PREFIX(_dispatch_stub_117, _dispatch_stub_117@4)) + GL_STUB(_dispatch_stub_118, 118, _dispatch_stub_118@32) + HIDDEN(GL_PREFIX(_dispatch_stub_118, _dispatch_stub_118@32)) + GL_STUB(_dispatch_stub_119, 119, _dispatch_stub_119@4) + HIDDEN(GL_PREFIX(_dispatch_stub_119, _dispatch_stub_119@4)) + GL_STUB(_dispatch_stub_120, 120, _dispatch_stub_120@16) + HIDDEN(GL_PREFIX(_dispatch_stub_120, _dispatch_stub_120@16)) + GL_STUB(_dispatch_stub_121, 121, _dispatch_stub_121@4) + HIDDEN(GL_PREFIX(_dispatch_stub_121, _dispatch_stub_121@4)) + GL_STUB(_dispatch_stub_122, 122, _dispatch_stub_122@16) + HIDDEN(GL_PREFIX(_dispatch_stub_122, _dispatch_stub_122@16)) + GL_STUB(_dispatch_stub_123, 123, _dispatch_stub_123@4) + HIDDEN(GL_PREFIX(_dispatch_stub_123, _dispatch_stub_123@4)) + GL_STUB(_dispatch_stub_124, 124, _dispatch_stub_124@16) + HIDDEN(GL_PREFIX(_dispatch_stub_124, _dispatch_stub_124@16)) + GL_STUB(_dispatch_stub_125, 125, _dispatch_stub_125@4) + HIDDEN(GL_PREFIX(_dispatch_stub_125, _dispatch_stub_125@4)) + GL_STUB(_dispatch_stub_126, 126, _dispatch_stub_126@16) + HIDDEN(GL_PREFIX(_dispatch_stub_126, _dispatch_stub_126@16)) + GL_STUB(_dispatch_stub_127, 127, _dispatch_stub_127@4) + HIDDEN(GL_PREFIX(_dispatch_stub_127, _dispatch_stub_127@4)) + GL_STUB(_dispatch_stub_128, 128, _dispatch_stub_128@8) + HIDDEN(GL_PREFIX(_dispatch_stub_128, _dispatch_stub_128@8)) + GL_STUB(_dispatch_stub_129, 129, _dispatch_stub_129@4) + HIDDEN(GL_PREFIX(_dispatch_stub_129, _dispatch_stub_129@4)) + GL_STUB(_dispatch_stub_130, 130, _dispatch_stub_130@8) + HIDDEN(GL_PREFIX(_dispatch_stub_130, _dispatch_stub_130@8)) + GL_STUB(_dispatch_stub_131, 131, _dispatch_stub_131@4) + HIDDEN(GL_PREFIX(_dispatch_stub_131, _dispatch_stub_131@4)) + GL_STUB(_dispatch_stub_132, 132, _dispatch_stub_132@8) + HIDDEN(GL_PREFIX(_dispatch_stub_132, _dispatch_stub_132@8)) + GL_STUB(_dispatch_stub_133, 133, _dispatch_stub_133@4) + HIDDEN(GL_PREFIX(_dispatch_stub_133, _dispatch_stub_133@4)) + GL_STUB(_dispatch_stub_134, 134, _dispatch_stub_134@24) + HIDDEN(GL_PREFIX(_dispatch_stub_134, _dispatch_stub_134@24)) + GL_STUB(_dispatch_stub_135, 135, _dispatch_stub_135@4) + HIDDEN(GL_PREFIX(_dispatch_stub_135, _dispatch_stub_135@4)) + GL_STUB(_dispatch_stub_136, 136, _dispatch_stub_136@12) + HIDDEN(GL_PREFIX(_dispatch_stub_136, _dispatch_stub_136@12)) + GL_STUB(_dispatch_stub_137, 137, _dispatch_stub_137@4) + HIDDEN(GL_PREFIX(_dispatch_stub_137, _dispatch_stub_137@4)) + GL_STUB(_dispatch_stub_138, 138, _dispatch_stub_138@12) + HIDDEN(GL_PREFIX(_dispatch_stub_138, _dispatch_stub_138@12)) + GL_STUB(_dispatch_stub_139, 139, _dispatch_stub_139@4) + HIDDEN(GL_PREFIX(_dispatch_stub_139, _dispatch_stub_139@4)) + GL_STUB(_dispatch_stub_140, 140, _dispatch_stub_140@12) + HIDDEN(GL_PREFIX(_dispatch_stub_140, _dispatch_stub_140@12)) + GL_STUB(_dispatch_stub_141, 141, _dispatch_stub_141@4) + HIDDEN(GL_PREFIX(_dispatch_stub_141, _dispatch_stub_141@4)) + GL_STUB(_dispatch_stub_142, 142, _dispatch_stub_142@32) + HIDDEN(GL_PREFIX(_dispatch_stub_142, _dispatch_stub_142@32)) + GL_STUB(_dispatch_stub_143, 143, _dispatch_stub_143@4) + HIDDEN(GL_PREFIX(_dispatch_stub_143, _dispatch_stub_143@4)) + GL_STUB(_dispatch_stub_144, 144, _dispatch_stub_144@16) + HIDDEN(GL_PREFIX(_dispatch_stub_144, _dispatch_stub_144@16)) + GL_STUB(_dispatch_stub_145, 145, _dispatch_stub_145@4) + HIDDEN(GL_PREFIX(_dispatch_stub_145, _dispatch_stub_145@4)) + GL_STUB(_dispatch_stub_146, 146, _dispatch_stub_146@16) + HIDDEN(GL_PREFIX(_dispatch_stub_146, _dispatch_stub_146@16)) + GL_STUB(_dispatch_stub_147, 147, _dispatch_stub_147@4) + HIDDEN(GL_PREFIX(_dispatch_stub_147, _dispatch_stub_147@4)) + GL_STUB(_dispatch_stub_148, 148, _dispatch_stub_148@16) + HIDDEN(GL_PREFIX(_dispatch_stub_148, _dispatch_stub_148@16)) + GL_STUB(_dispatch_stub_149, 149, _dispatch_stub_149@4) + HIDDEN(GL_PREFIX(_dispatch_stub_149, _dispatch_stub_149@4)) + GL_STUB(_dispatch_stub_150, 150, _dispatch_stub_150@8) + HIDDEN(GL_PREFIX(_dispatch_stub_150, _dispatch_stub_150@8)) + GL_STUB(_dispatch_stub_151, 151, _dispatch_stub_151@8) + HIDDEN(GL_PREFIX(_dispatch_stub_151, _dispatch_stub_151@8)) + GL_STUB(CullFace, 152, CullFace@4) + GL_STUB(_dispatch_stub_153, 153, _dispatch_stub_153@8) + HIDDEN(GL_PREFIX(_dispatch_stub_153, _dispatch_stub_153@8)) + GL_STUB(_dispatch_stub_154, 154, _dispatch_stub_154@8) + HIDDEN(GL_PREFIX(_dispatch_stub_154, _dispatch_stub_154@8)) + GL_STUB(_dispatch_stub_155, 155, _dispatch_stub_155@8) + HIDDEN(GL_PREFIX(_dispatch_stub_155, _dispatch_stub_155@8)) + GL_STUB(_dispatch_stub_156, 156, _dispatch_stub_156@8) + HIDDEN(GL_PREFIX(_dispatch_stub_156, _dispatch_stub_156@8)) + GL_STUB(FrontFace, 157, FrontFace@4) + GL_STUB(Hint, 158, Hint@8) + GL_STUB(_dispatch_stub_159, 159, _dispatch_stub_159@12) + HIDDEN(GL_PREFIX(_dispatch_stub_159, _dispatch_stub_159@12)) + GL_STUB(_dispatch_stub_160, 160, _dispatch_stub_160@12) + HIDDEN(GL_PREFIX(_dispatch_stub_160, _dispatch_stub_160@12)) + GL_STUB(_dispatch_stub_161, 161, _dispatch_stub_161@12) + HIDDEN(GL_PREFIX(_dispatch_stub_161, _dispatch_stub_161@12)) + GL_STUB(_dispatch_stub_162, 162, _dispatch_stub_162@12) + HIDDEN(GL_PREFIX(_dispatch_stub_162, _dispatch_stub_162@12)) + GL_STUB(_dispatch_stub_163, 163, _dispatch_stub_163@8) + HIDDEN(GL_PREFIX(_dispatch_stub_163, _dispatch_stub_163@8)) + GL_STUB(_dispatch_stub_164, 164, _dispatch_stub_164@8) + HIDDEN(GL_PREFIX(_dispatch_stub_164, _dispatch_stub_164@8)) + GL_STUB(_dispatch_stub_165, 165, _dispatch_stub_165@8) + HIDDEN(GL_PREFIX(_dispatch_stub_165, _dispatch_stub_165@8)) + GL_STUB(_dispatch_stub_166, 166, _dispatch_stub_166@8) + HIDDEN(GL_PREFIX(_dispatch_stub_166, _dispatch_stub_166@8)) + GL_STUB(_dispatch_stub_167, 167, _dispatch_stub_167@8) + HIDDEN(GL_PREFIX(_dispatch_stub_167, _dispatch_stub_167@8)) + GL_STUB(LineWidth, 168, LineWidth@4) + GL_STUB(_dispatch_stub_169, 169, _dispatch_stub_169@12) + HIDDEN(GL_PREFIX(_dispatch_stub_169, _dispatch_stub_169@12)) + GL_STUB(_dispatch_stub_170, 170, _dispatch_stub_170@12) + HIDDEN(GL_PREFIX(_dispatch_stub_170, _dispatch_stub_170@12)) + GL_STUB(_dispatch_stub_171, 171, _dispatch_stub_171@12) + HIDDEN(GL_PREFIX(_dispatch_stub_171, _dispatch_stub_171@12)) + GL_STUB(_dispatch_stub_172, 172, _dispatch_stub_172@12) + HIDDEN(GL_PREFIX(_dispatch_stub_172, _dispatch_stub_172@12)) + GL_STUB(_dispatch_stub_173, 173, _dispatch_stub_173@4) + HIDDEN(GL_PREFIX(_dispatch_stub_173, _dispatch_stub_173@4)) + GL_STUB(_dispatch_stub_174, 174, _dispatch_stub_174@8) + HIDDEN(GL_PREFIX(_dispatch_stub_174, _dispatch_stub_174@8)) + GL_STUB(_dispatch_stub_175, 175, _dispatch_stub_175@4) + HIDDEN(GL_PREFIX(_dispatch_stub_175, _dispatch_stub_175@4)) + GL_STUB(Scissor, 176, Scissor@16) + GL_STUB(_dispatch_stub_177, 177, _dispatch_stub_177@4) + HIDDEN(GL_PREFIX(_dispatch_stub_177, _dispatch_stub_177@4)) + GL_STUB(TexParameterf, 178, TexParameterf@12) + GL_STUB(TexParameterfv, 179, TexParameterfv@12) + GL_STUB(TexParameteri, 180, TexParameteri@12) + GL_STUB(TexParameteriv, 181, TexParameteriv@12) + GL_STUB(_dispatch_stub_182, 182, _dispatch_stub_182@32) + HIDDEN(GL_PREFIX(_dispatch_stub_182, _dispatch_stub_182@32)) + GL_STUB(TexImage2D, 183, TexImage2D@36) + GL_STUB(_dispatch_stub_184, 184, _dispatch_stub_184@12) + HIDDEN(GL_PREFIX(_dispatch_stub_184, _dispatch_stub_184@12)) + GL_STUB(_dispatch_stub_185, 185, _dispatch_stub_185@12) + HIDDEN(GL_PREFIX(_dispatch_stub_185, _dispatch_stub_185@12)) + GL_STUB(_dispatch_stub_186, 186, _dispatch_stub_186@12) + HIDDEN(GL_PREFIX(_dispatch_stub_186, _dispatch_stub_186@12)) + GL_STUB(_dispatch_stub_187, 187, _dispatch_stub_187@12) + HIDDEN(GL_PREFIX(_dispatch_stub_187, _dispatch_stub_187@12)) + GL_STUB(_dispatch_stub_188, 188, _dispatch_stub_188@16) + HIDDEN(GL_PREFIX(_dispatch_stub_188, _dispatch_stub_188@16)) + GL_STUB(_dispatch_stub_189, 189, _dispatch_stub_189@12) + HIDDEN(GL_PREFIX(_dispatch_stub_189, _dispatch_stub_189@12)) + GL_STUB(_dispatch_stub_190, 190, _dispatch_stub_190@12) + HIDDEN(GL_PREFIX(_dispatch_stub_190, _dispatch_stub_190@12)) + GL_STUB(_dispatch_stub_191, 191, _dispatch_stub_191@12) + HIDDEN(GL_PREFIX(_dispatch_stub_191, _dispatch_stub_191@12)) + GL_STUB(_dispatch_stub_192, 192, _dispatch_stub_192@12) + HIDDEN(GL_PREFIX(_dispatch_stub_192, _dispatch_stub_192@12)) + GL_STUB(_dispatch_stub_193, 193, _dispatch_stub_193@12) + HIDDEN(GL_PREFIX(_dispatch_stub_193, _dispatch_stub_193@12)) + GL_STUB(_dispatch_stub_194, 194, _dispatch_stub_194@12) + HIDDEN(GL_PREFIX(_dispatch_stub_194, _dispatch_stub_194@12)) + GL_STUB(_dispatch_stub_195, 195, _dispatch_stub_195@8) + HIDDEN(GL_PREFIX(_dispatch_stub_195, _dispatch_stub_195@8)) + GL_STUB(_dispatch_stub_196, 196, _dispatch_stub_196@4) + HIDDEN(GL_PREFIX(_dispatch_stub_196, _dispatch_stub_196@4)) + GL_STUB(_dispatch_stub_197, 197, _dispatch_stub_197@0) + HIDDEN(GL_PREFIX(_dispatch_stub_197, _dispatch_stub_197@0)) + GL_STUB(_dispatch_stub_198, 198, _dispatch_stub_198@4) + HIDDEN(GL_PREFIX(_dispatch_stub_198, _dispatch_stub_198@4)) + GL_STUB(_dispatch_stub_199, 199, _dispatch_stub_199@4) + HIDDEN(GL_PREFIX(_dispatch_stub_199, _dispatch_stub_199@4)) + GL_STUB(_dispatch_stub_200, 200, _dispatch_stub_200@0) + HIDDEN(GL_PREFIX(_dispatch_stub_200, _dispatch_stub_200@0)) + GL_STUB(_dispatch_stub_201, 201, _dispatch_stub_201@4) + HIDDEN(GL_PREFIX(_dispatch_stub_201, _dispatch_stub_201@4)) + GL_STUB(_dispatch_stub_202, 202, _dispatch_stub_202@4) + HIDDEN(GL_PREFIX(_dispatch_stub_202, _dispatch_stub_202@4)) + GL_STUB(Clear, 203, Clear@4) + GL_STUB(_dispatch_stub_204, 204, _dispatch_stub_204@16) + HIDDEN(GL_PREFIX(_dispatch_stub_204, _dispatch_stub_204@16)) + GL_STUB(_dispatch_stub_205, 205, _dispatch_stub_205@4) + HIDDEN(GL_PREFIX(_dispatch_stub_205, _dispatch_stub_205@4)) + GL_STUB(ClearColor, 206, ClearColor@16) + GL_STUB(ClearStencil, 207, ClearStencil@4) + GL_STUB(_dispatch_stub_208, 208, _dispatch_stub_208@8) + HIDDEN(GL_PREFIX(_dispatch_stub_208, _dispatch_stub_208@8)) + GL_STUB(StencilMask, 209, StencilMask@4) + GL_STUB(ColorMask, 210, ColorMask@16) + GL_STUB(DepthMask, 211, DepthMask@4) + GL_STUB(_dispatch_stub_212, 212, _dispatch_stub_212@4) + HIDDEN(GL_PREFIX(_dispatch_stub_212, _dispatch_stub_212@4)) + GL_STUB(_dispatch_stub_213, 213, _dispatch_stub_213@8) + HIDDEN(GL_PREFIX(_dispatch_stub_213, _dispatch_stub_213@8)) + GL_STUB(Disable, 214, Disable@4) + GL_STUB(Enable, 215, Enable@4) + GL_STUB(Finish, 216, Finish@0) + GL_STUB(Flush, 217, Flush@0) + GL_STUB(_dispatch_stub_218, 218, _dispatch_stub_218@0) + HIDDEN(GL_PREFIX(_dispatch_stub_218, _dispatch_stub_218@0)) + GL_STUB(_dispatch_stub_219, 219, _dispatch_stub_219@4) + HIDDEN(GL_PREFIX(_dispatch_stub_219, _dispatch_stub_219@4)) + GL_STUB(_dispatch_stub_220, 220, _dispatch_stub_220@32) + HIDDEN(GL_PREFIX(_dispatch_stub_220, _dispatch_stub_220@32)) + GL_STUB(_dispatch_stub_221, 221, _dispatch_stub_221@24) + HIDDEN(GL_PREFIX(_dispatch_stub_221, _dispatch_stub_221@24)) + GL_STUB(_dispatch_stub_222, 222, _dispatch_stub_222@56) + HIDDEN(GL_PREFIX(_dispatch_stub_222, _dispatch_stub_222@56)) + GL_STUB(_dispatch_stub_223, 223, _dispatch_stub_223@40) + HIDDEN(GL_PREFIX(_dispatch_stub_223, _dispatch_stub_223@40)) + GL_STUB(_dispatch_stub_224, 224, _dispatch_stub_224@20) + HIDDEN(GL_PREFIX(_dispatch_stub_224, _dispatch_stub_224@20)) + GL_STUB(_dispatch_stub_225, 225, _dispatch_stub_225@12) + HIDDEN(GL_PREFIX(_dispatch_stub_225, _dispatch_stub_225@12)) + GL_STUB(_dispatch_stub_226, 226, _dispatch_stub_226@40) + HIDDEN(GL_PREFIX(_dispatch_stub_226, _dispatch_stub_226@40)) + GL_STUB(_dispatch_stub_227, 227, _dispatch_stub_227@24) + HIDDEN(GL_PREFIX(_dispatch_stub_227, _dispatch_stub_227@24)) + GL_STUB(_dispatch_stub_228, 228, _dispatch_stub_228@8) + HIDDEN(GL_PREFIX(_dispatch_stub_228, _dispatch_stub_228@8)) + GL_STUB(_dispatch_stub_229, 229, _dispatch_stub_229@4) + HIDDEN(GL_PREFIX(_dispatch_stub_229, _dispatch_stub_229@4)) + GL_STUB(_dispatch_stub_230, 230, _dispatch_stub_230@4) + HIDDEN(GL_PREFIX(_dispatch_stub_230, _dispatch_stub_230@4)) + GL_STUB(_dispatch_stub_231, 231, _dispatch_stub_231@4) + HIDDEN(GL_PREFIX(_dispatch_stub_231, _dispatch_stub_231@4)) + GL_STUB(_dispatch_stub_232, 232, _dispatch_stub_232@16) + HIDDEN(GL_PREFIX(_dispatch_stub_232, _dispatch_stub_232@16)) + GL_STUB(_dispatch_stub_233, 233, _dispatch_stub_233@4) + HIDDEN(GL_PREFIX(_dispatch_stub_233, _dispatch_stub_233@4)) + GL_STUB(_dispatch_stub_234, 234, _dispatch_stub_234@8) + HIDDEN(GL_PREFIX(_dispatch_stub_234, _dispatch_stub_234@8)) + GL_STUB(_dispatch_stub_235, 235, _dispatch_stub_235@4) + HIDDEN(GL_PREFIX(_dispatch_stub_235, _dispatch_stub_235@4)) + GL_STUB(_dispatch_stub_236, 236, _dispatch_stub_236@12) + HIDDEN(GL_PREFIX(_dispatch_stub_236, _dispatch_stub_236@12)) + GL_STUB(_dispatch_stub_237, 237, _dispatch_stub_237@4) + HIDDEN(GL_PREFIX(_dispatch_stub_237, _dispatch_stub_237@4)) + GL_STUB(_dispatch_stub_238, 238, _dispatch_stub_238@20) + HIDDEN(GL_PREFIX(_dispatch_stub_238, _dispatch_stub_238@20)) + GL_STUB(_dispatch_stub_239, 239, _dispatch_stub_239@8) + HIDDEN(GL_PREFIX(_dispatch_stub_239, _dispatch_stub_239@8)) + GL_STUB(_dispatch_stub_240, 240, _dispatch_stub_240@8) + HIDDEN(GL_PREFIX(_dispatch_stub_240, _dispatch_stub_240@8)) + GL_STUB(BlendFunc, 241, BlendFunc@8) + GL_STUB(_dispatch_stub_242, 242, _dispatch_stub_242@4) + HIDDEN(GL_PREFIX(_dispatch_stub_242, _dispatch_stub_242@4)) + GL_STUB(StencilFunc, 243, StencilFunc@12) + GL_STUB(StencilOp, 244, StencilOp@12) + GL_STUB(DepthFunc, 245, DepthFunc@4) + GL_STUB(_dispatch_stub_246, 246, _dispatch_stub_246@8) + HIDDEN(GL_PREFIX(_dispatch_stub_246, _dispatch_stub_246@8)) + GL_STUB(_dispatch_stub_247, 247, _dispatch_stub_247@8) + HIDDEN(GL_PREFIX(_dispatch_stub_247, _dispatch_stub_247@8)) + GL_STUB(_dispatch_stub_248, 248, _dispatch_stub_248@8) + HIDDEN(GL_PREFIX(_dispatch_stub_248, _dispatch_stub_248@8)) + GL_STUB(_dispatch_stub_249, 249, _dispatch_stub_249@8) + HIDDEN(GL_PREFIX(_dispatch_stub_249, _dispatch_stub_249@8)) + GL_STUB(PixelStorei, 250, PixelStorei@8) + GL_STUB(_dispatch_stub_251, 251, _dispatch_stub_251@12) + HIDDEN(GL_PREFIX(_dispatch_stub_251, _dispatch_stub_251@12)) + GL_STUB(_dispatch_stub_252, 252, _dispatch_stub_252@12) + HIDDEN(GL_PREFIX(_dispatch_stub_252, _dispatch_stub_252@12)) + GL_STUB(_dispatch_stub_253, 253, _dispatch_stub_253@12) + HIDDEN(GL_PREFIX(_dispatch_stub_253, _dispatch_stub_253@12)) + GL_STUB(_dispatch_stub_254, 254, _dispatch_stub_254@4) + HIDDEN(GL_PREFIX(_dispatch_stub_254, _dispatch_stub_254@4)) + GL_STUB(_dispatch_stub_255, 255, _dispatch_stub_255@20) + HIDDEN(GL_PREFIX(_dispatch_stub_255, _dispatch_stub_255@20)) + GL_STUB(ReadPixels, 256, ReadPixels@28) + GL_STUB(_dispatch_stub_257, 257, _dispatch_stub_257@20) + HIDDEN(GL_PREFIX(_dispatch_stub_257, _dispatch_stub_257@20)) + GL_STUB(GetBooleanv, 258, GetBooleanv@8) + GL_STUB(_dispatch_stub_259, 259, _dispatch_stub_259@8) + HIDDEN(GL_PREFIX(_dispatch_stub_259, _dispatch_stub_259@8)) + GL_STUB(_dispatch_stub_260, 260, _dispatch_stub_260@8) + HIDDEN(GL_PREFIX(_dispatch_stub_260, _dispatch_stub_260@8)) + GL_STUB(GetError, 261, GetError@0) + GL_STUB(GetFloatv, 262, GetFloatv@8) + GL_STUB(GetIntegerv, 263, GetIntegerv@8) + GL_STUB(_dispatch_stub_264, 264, _dispatch_stub_264@12) + HIDDEN(GL_PREFIX(_dispatch_stub_264, _dispatch_stub_264@12)) + GL_STUB(_dispatch_stub_265, 265, _dispatch_stub_265@12) + HIDDEN(GL_PREFIX(_dispatch_stub_265, _dispatch_stub_265@12)) + GL_STUB(_dispatch_stub_266, 266, _dispatch_stub_266@12) + HIDDEN(GL_PREFIX(_dispatch_stub_266, _dispatch_stub_266@12)) + GL_STUB(_dispatch_stub_267, 267, _dispatch_stub_267@12) + HIDDEN(GL_PREFIX(_dispatch_stub_267, _dispatch_stub_267@12)) + GL_STUB(_dispatch_stub_268, 268, _dispatch_stub_268@12) + HIDDEN(GL_PREFIX(_dispatch_stub_268, _dispatch_stub_268@12)) + GL_STUB(_dispatch_stub_269, 269, _dispatch_stub_269@12) + HIDDEN(GL_PREFIX(_dispatch_stub_269, _dispatch_stub_269@12)) + GL_STUB(_dispatch_stub_270, 270, _dispatch_stub_270@12) + HIDDEN(GL_PREFIX(_dispatch_stub_270, _dispatch_stub_270@12)) + GL_STUB(_dispatch_stub_271, 271, _dispatch_stub_271@8) + HIDDEN(GL_PREFIX(_dispatch_stub_271, _dispatch_stub_271@8)) + GL_STUB(_dispatch_stub_272, 272, _dispatch_stub_272@8) + HIDDEN(GL_PREFIX(_dispatch_stub_272, _dispatch_stub_272@8)) + GL_STUB(_dispatch_stub_273, 273, _dispatch_stub_273@8) + HIDDEN(GL_PREFIX(_dispatch_stub_273, _dispatch_stub_273@8)) + GL_STUB(_dispatch_stub_274, 274, _dispatch_stub_274@4) + HIDDEN(GL_PREFIX(_dispatch_stub_274, _dispatch_stub_274@4)) + GL_STUB(GetString, 275, GetString@4) + GL_STUB(_dispatch_stub_276, 276, _dispatch_stub_276@12) + HIDDEN(GL_PREFIX(_dispatch_stub_276, _dispatch_stub_276@12)) + GL_STUB(_dispatch_stub_277, 277, _dispatch_stub_277@12) + HIDDEN(GL_PREFIX(_dispatch_stub_277, _dispatch_stub_277@12)) + GL_STUB(_dispatch_stub_278, 278, _dispatch_stub_278@12) + HIDDEN(GL_PREFIX(_dispatch_stub_278, _dispatch_stub_278@12)) + GL_STUB(_dispatch_stub_279, 279, _dispatch_stub_279@12) + HIDDEN(GL_PREFIX(_dispatch_stub_279, _dispatch_stub_279@12)) + GL_STUB(_dispatch_stub_280, 280, _dispatch_stub_280@12) + HIDDEN(GL_PREFIX(_dispatch_stub_280, _dispatch_stub_280@12)) + GL_STUB(_dispatch_stub_281, 281, _dispatch_stub_281@20) + HIDDEN(GL_PREFIX(_dispatch_stub_281, _dispatch_stub_281@20)) + GL_STUB(GetTexParameterfv, 282, GetTexParameterfv@12) + GL_STUB(GetTexParameteriv, 283, GetTexParameteriv@12) + GL_STUB(_dispatch_stub_284, 284, _dispatch_stub_284@16) + HIDDEN(GL_PREFIX(_dispatch_stub_284, _dispatch_stub_284@16)) + GL_STUB(_dispatch_stub_285, 285, _dispatch_stub_285@16) + HIDDEN(GL_PREFIX(_dispatch_stub_285, _dispatch_stub_285@16)) + GL_STUB(IsEnabled, 286, IsEnabled@4) + GL_STUB(_dispatch_stub_287, 287, _dispatch_stub_287@4) + HIDDEN(GL_PREFIX(_dispatch_stub_287, _dispatch_stub_287@4)) + GL_STUB(_dispatch_stub_288, 288, _dispatch_stub_288@16) + HIDDEN(GL_PREFIX(_dispatch_stub_288, _dispatch_stub_288@16)) + GL_STUB(_dispatch_stub_289, 289, _dispatch_stub_289@48) + HIDDEN(GL_PREFIX(_dispatch_stub_289, _dispatch_stub_289@48)) + GL_STUB(_dispatch_stub_290, 290, _dispatch_stub_290@0) + HIDDEN(GL_PREFIX(_dispatch_stub_290, _dispatch_stub_290@0)) + GL_STUB(_dispatch_stub_291, 291, _dispatch_stub_291@4) + HIDDEN(GL_PREFIX(_dispatch_stub_291, _dispatch_stub_291@4)) + GL_STUB(_dispatch_stub_292, 292, _dispatch_stub_292@4) + HIDDEN(GL_PREFIX(_dispatch_stub_292, _dispatch_stub_292@4)) + GL_STUB(_dispatch_stub_293, 293, _dispatch_stub_293@4) + HIDDEN(GL_PREFIX(_dispatch_stub_293, _dispatch_stub_293@4)) + GL_STUB(_dispatch_stub_294, 294, _dispatch_stub_294@4) + HIDDEN(GL_PREFIX(_dispatch_stub_294, _dispatch_stub_294@4)) + GL_STUB(_dispatch_stub_295, 295, _dispatch_stub_295@4) + HIDDEN(GL_PREFIX(_dispatch_stub_295, _dispatch_stub_295@4)) + GL_STUB(_dispatch_stub_296, 296, _dispatch_stub_296@48) + HIDDEN(GL_PREFIX(_dispatch_stub_296, _dispatch_stub_296@48)) + GL_STUB(_dispatch_stub_297, 297, _dispatch_stub_297@0) + HIDDEN(GL_PREFIX(_dispatch_stub_297, _dispatch_stub_297@0)) + GL_STUB(_dispatch_stub_298, 298, _dispatch_stub_298@0) + HIDDEN(GL_PREFIX(_dispatch_stub_298, _dispatch_stub_298@0)) + GL_STUB(_dispatch_stub_299, 299, _dispatch_stub_299@32) + HIDDEN(GL_PREFIX(_dispatch_stub_299, _dispatch_stub_299@32)) + GL_STUB(_dispatch_stub_300, 300, _dispatch_stub_300@16) + HIDDEN(GL_PREFIX(_dispatch_stub_300, _dispatch_stub_300@16)) + GL_STUB(_dispatch_stub_301, 301, _dispatch_stub_301@24) + HIDDEN(GL_PREFIX(_dispatch_stub_301, _dispatch_stub_301@24)) + GL_STUB(_dispatch_stub_302, 302, _dispatch_stub_302@12) + HIDDEN(GL_PREFIX(_dispatch_stub_302, _dispatch_stub_302@12)) + GL_STUB(_dispatch_stub_303, 303, _dispatch_stub_303@24) + HIDDEN(GL_PREFIX(_dispatch_stub_303, _dispatch_stub_303@24)) + GL_STUB(_dispatch_stub_304, 304, _dispatch_stub_304@12) + HIDDEN(GL_PREFIX(_dispatch_stub_304, _dispatch_stub_304@12)) + GL_STUB(Viewport, 305, Viewport@16) + GL_STUB(_dispatch_stub_306, 306, _dispatch_stub_306@4) + HIDDEN(GL_PREFIX(_dispatch_stub_306, _dispatch_stub_306@4)) + GL_STUB(BindTexture, 307, BindTexture@8) + GL_STUB(_dispatch_stub_308, 308, _dispatch_stub_308@16) + HIDDEN(GL_PREFIX(_dispatch_stub_308, _dispatch_stub_308@16)) + GL_STUB(_dispatch_stub_309, 309, _dispatch_stub_309@4) + HIDDEN(GL_PREFIX(_dispatch_stub_309, _dispatch_stub_309@4)) + GL_STUB(DrawArrays, 310, DrawArrays@12) + GL_STUB(DrawElements, 311, DrawElements@16) + GL_STUB(_dispatch_stub_312, 312, _dispatch_stub_312@8) + HIDDEN(GL_PREFIX(_dispatch_stub_312, _dispatch_stub_312@8)) + GL_STUB(_dispatch_stub_313, 313, _dispatch_stub_313@4) + HIDDEN(GL_PREFIX(_dispatch_stub_313, _dispatch_stub_313@4)) + GL_STUB(_dispatch_stub_314, 314, _dispatch_stub_314@12) + HIDDEN(GL_PREFIX(_dispatch_stub_314, _dispatch_stub_314@12)) + GL_STUB(_dispatch_stub_315, 315, _dispatch_stub_315@4) + HIDDEN(GL_PREFIX(_dispatch_stub_315, _dispatch_stub_315@4)) + GL_STUB(_dispatch_stub_316, 316, _dispatch_stub_316@4) + HIDDEN(GL_PREFIX(_dispatch_stub_316, _dispatch_stub_316@4)) + GL_STUB(_dispatch_stub_317, 317, _dispatch_stub_317@12) + HIDDEN(GL_PREFIX(_dispatch_stub_317, _dispatch_stub_317@12)) + GL_STUB(_dispatch_stub_318, 318, _dispatch_stub_318@12) + HIDDEN(GL_PREFIX(_dispatch_stub_318, _dispatch_stub_318@12)) + GL_STUB(PolygonOffset, 319, PolygonOffset@8) + GL_STUB(_dispatch_stub_320, 320, _dispatch_stub_320@16) + HIDDEN(GL_PREFIX(_dispatch_stub_320, _dispatch_stub_320@16)) + GL_STUB(_dispatch_stub_321, 321, _dispatch_stub_321@16) + HIDDEN(GL_PREFIX(_dispatch_stub_321, _dispatch_stub_321@16)) + GL_STUB(_dispatch_stub_322, 322, _dispatch_stub_322@12) + HIDDEN(GL_PREFIX(_dispatch_stub_322, _dispatch_stub_322@12)) + GL_STUB(_dispatch_stub_323, 323, _dispatch_stub_323@28) + HIDDEN(GL_PREFIX(_dispatch_stub_323, _dispatch_stub_323@28)) + GL_STUB(CopyTexImage2D, 324, CopyTexImage2D@32) + GL_STUB(_dispatch_stub_325, 325, _dispatch_stub_325@24) + HIDDEN(GL_PREFIX(_dispatch_stub_325, _dispatch_stub_325@24)) + GL_STUB(CopyTexSubImage2D, 326, CopyTexSubImage2D@32) + GL_STUB(DeleteTextures, 327, DeleteTextures@8) + GL_STUB(GenTextures, 328, GenTextures@8) + GL_STUB(_dispatch_stub_329, 329, _dispatch_stub_329@8) + HIDDEN(GL_PREFIX(_dispatch_stub_329, _dispatch_stub_329@8)) + GL_STUB(IsTexture, 330, IsTexture@4) + GL_STUB(_dispatch_stub_331, 331, _dispatch_stub_331@12) + HIDDEN(GL_PREFIX(_dispatch_stub_331, _dispatch_stub_331@12)) + GL_STUB(_dispatch_stub_332, 332, _dispatch_stub_332@28) + HIDDEN(GL_PREFIX(_dispatch_stub_332, _dispatch_stub_332@28)) + GL_STUB(TexSubImage2D, 333, TexSubImage2D@36) + GL_STUB(_dispatch_stub_334, 334, _dispatch_stub_334@0) + HIDDEN(GL_PREFIX(_dispatch_stub_334, _dispatch_stub_334@0)) + GL_STUB(_dispatch_stub_335, 335, _dispatch_stub_335@4) + HIDDEN(GL_PREFIX(_dispatch_stub_335, _dispatch_stub_335@4)) + GL_STUB(BlendColor, 336, BlendColor@16) + GL_STUB(BlendEquation, 337, BlendEquation@4) + GL_STUB(_dispatch_stub_338, 338, _dispatch_stub_338@24) + HIDDEN(GL_PREFIX(_dispatch_stub_338, _dispatch_stub_338@24)) + GL_STUB(_dispatch_stub_339, 339, _dispatch_stub_339@24) + HIDDEN(GL_PREFIX(_dispatch_stub_339, _dispatch_stub_339@24)) + GL_STUB(_dispatch_stub_340, 340, _dispatch_stub_340@12) + HIDDEN(GL_PREFIX(_dispatch_stub_340, _dispatch_stub_340@12)) + GL_STUB(_dispatch_stub_341, 341, _dispatch_stub_341@12) + HIDDEN(GL_PREFIX(_dispatch_stub_341, _dispatch_stub_341@12)) + GL_STUB(_dispatch_stub_342, 342, _dispatch_stub_342@20) + HIDDEN(GL_PREFIX(_dispatch_stub_342, _dispatch_stub_342@20)) + GL_STUB(_dispatch_stub_343, 343, _dispatch_stub_343@16) + HIDDEN(GL_PREFIX(_dispatch_stub_343, _dispatch_stub_343@16)) + GL_STUB(_dispatch_stub_344, 344, _dispatch_stub_344@12) + HIDDEN(GL_PREFIX(_dispatch_stub_344, _dispatch_stub_344@12)) + GL_STUB(_dispatch_stub_345, 345, _dispatch_stub_345@12) + HIDDEN(GL_PREFIX(_dispatch_stub_345, _dispatch_stub_345@12)) + GL_STUB(_dispatch_stub_346, 346, _dispatch_stub_346@24) + HIDDEN(GL_PREFIX(_dispatch_stub_346, _dispatch_stub_346@24)) + GL_STUB(_dispatch_stub_347, 347, _dispatch_stub_347@20) + HIDDEN(GL_PREFIX(_dispatch_stub_347, _dispatch_stub_347@20)) + GL_STUB(_dispatch_stub_348, 348, _dispatch_stub_348@24) + HIDDEN(GL_PREFIX(_dispatch_stub_348, _dispatch_stub_348@24)) + GL_STUB(_dispatch_stub_349, 349, _dispatch_stub_349@28) + HIDDEN(GL_PREFIX(_dispatch_stub_349, _dispatch_stub_349@28)) + GL_STUB(_dispatch_stub_350, 350, _dispatch_stub_350@12) + HIDDEN(GL_PREFIX(_dispatch_stub_350, _dispatch_stub_350@12)) + GL_STUB(_dispatch_stub_351, 351, _dispatch_stub_351@12) + HIDDEN(GL_PREFIX(_dispatch_stub_351, _dispatch_stub_351@12)) + GL_STUB(_dispatch_stub_352, 352, _dispatch_stub_352@12) + HIDDEN(GL_PREFIX(_dispatch_stub_352, _dispatch_stub_352@12)) + GL_STUB(_dispatch_stub_353, 353, _dispatch_stub_353@12) + HIDDEN(GL_PREFIX(_dispatch_stub_353, _dispatch_stub_353@12)) + GL_STUB(_dispatch_stub_354, 354, _dispatch_stub_354@20) + HIDDEN(GL_PREFIX(_dispatch_stub_354, _dispatch_stub_354@20)) + GL_STUB(_dispatch_stub_355, 355, _dispatch_stub_355@24) + HIDDEN(GL_PREFIX(_dispatch_stub_355, _dispatch_stub_355@24)) + GL_STUB(_dispatch_stub_356, 356, _dispatch_stub_356@16) + HIDDEN(GL_PREFIX(_dispatch_stub_356, _dispatch_stub_356@16)) + GL_STUB(_dispatch_stub_357, 357, _dispatch_stub_357@12) + HIDDEN(GL_PREFIX(_dispatch_stub_357, _dispatch_stub_357@12)) + GL_STUB(_dispatch_stub_358, 358, _dispatch_stub_358@12) + HIDDEN(GL_PREFIX(_dispatch_stub_358, _dispatch_stub_358@12)) + GL_STUB(_dispatch_stub_359, 359, _dispatch_stub_359@24) + HIDDEN(GL_PREFIX(_dispatch_stub_359, _dispatch_stub_359@24)) + GL_STUB(_dispatch_stub_360, 360, _dispatch_stub_360@32) + HIDDEN(GL_PREFIX(_dispatch_stub_360, _dispatch_stub_360@32)) + GL_STUB(_dispatch_stub_361, 361, _dispatch_stub_361@20) + HIDDEN(GL_PREFIX(_dispatch_stub_361, _dispatch_stub_361@20)) + GL_STUB(_dispatch_stub_362, 362, _dispatch_stub_362@12) + HIDDEN(GL_PREFIX(_dispatch_stub_362, _dispatch_stub_362@12)) + GL_STUB(_dispatch_stub_363, 363, _dispatch_stub_363@12) + HIDDEN(GL_PREFIX(_dispatch_stub_363, _dispatch_stub_363@12)) + GL_STUB(_dispatch_stub_364, 364, _dispatch_stub_364@20) + HIDDEN(GL_PREFIX(_dispatch_stub_364, _dispatch_stub_364@20)) + GL_STUB(_dispatch_stub_365, 365, _dispatch_stub_365@12) + HIDDEN(GL_PREFIX(_dispatch_stub_365, _dispatch_stub_365@12)) + GL_STUB(_dispatch_stub_366, 366, _dispatch_stub_366@12) + HIDDEN(GL_PREFIX(_dispatch_stub_366, _dispatch_stub_366@12)) + GL_STUB(_dispatch_stub_367, 367, _dispatch_stub_367@16) + HIDDEN(GL_PREFIX(_dispatch_stub_367, _dispatch_stub_367@16)) + GL_STUB(_dispatch_stub_368, 368, _dispatch_stub_368@12) + HIDDEN(GL_PREFIX(_dispatch_stub_368, _dispatch_stub_368@12)) + GL_STUB(_dispatch_stub_369, 369, _dispatch_stub_369@4) + HIDDEN(GL_PREFIX(_dispatch_stub_369, _dispatch_stub_369@4)) + GL_STUB(_dispatch_stub_370, 370, _dispatch_stub_370@4) + HIDDEN(GL_PREFIX(_dispatch_stub_370, _dispatch_stub_370@4)) + GL_STUB(TexImage3DOES, 371, TexImage3DOES@40) + GL_STUB(TexSubImage3DOES, 372, TexSubImage3DOES@44) + GL_STUB(CopyTexSubImage3DOES, 373, CopyTexSubImage3DOES@36) + GL_STUB(ActiveTexture, 374, ActiveTexture@4) + GL_STUB(_dispatch_stub_375, 375, _dispatch_stub_375@4) + HIDDEN(GL_PREFIX(_dispatch_stub_375, _dispatch_stub_375@4)) + GL_STUB(_dispatch_stub_376, 376, _dispatch_stub_376@12) + HIDDEN(GL_PREFIX(_dispatch_stub_376, _dispatch_stub_376@12)) + GL_STUB(_dispatch_stub_377, 377, _dispatch_stub_377@8) + HIDDEN(GL_PREFIX(_dispatch_stub_377, _dispatch_stub_377@8)) + GL_STUB(_dispatch_stub_378, 378, _dispatch_stub_378@8) + HIDDEN(GL_PREFIX(_dispatch_stub_378, _dispatch_stub_378@8)) + GL_STUB(_dispatch_stub_379, 379, _dispatch_stub_379@8) + HIDDEN(GL_PREFIX(_dispatch_stub_379, _dispatch_stub_379@8)) + GL_STUB(_dispatch_stub_380, 380, _dispatch_stub_380@8) + HIDDEN(GL_PREFIX(_dispatch_stub_380, _dispatch_stub_380@8)) + GL_STUB(_dispatch_stub_381, 381, _dispatch_stub_381@8) + HIDDEN(GL_PREFIX(_dispatch_stub_381, _dispatch_stub_381@8)) + GL_STUB(_dispatch_stub_382, 382, _dispatch_stub_382@8) + HIDDEN(GL_PREFIX(_dispatch_stub_382, _dispatch_stub_382@8)) + GL_STUB(_dispatch_stub_383, 383, _dispatch_stub_383@8) + HIDDEN(GL_PREFIX(_dispatch_stub_383, _dispatch_stub_383@8)) + GL_STUB(_dispatch_stub_384, 384, _dispatch_stub_384@20) + HIDDEN(GL_PREFIX(_dispatch_stub_384, _dispatch_stub_384@20)) + GL_STUB(_dispatch_stub_385, 385, _dispatch_stub_385@8) + HIDDEN(GL_PREFIX(_dispatch_stub_385, _dispatch_stub_385@8)) + GL_STUB(_dispatch_stub_386, 386, _dispatch_stub_386@12) + HIDDEN(GL_PREFIX(_dispatch_stub_386, _dispatch_stub_386@12)) + GL_STUB(_dispatch_stub_387, 387, _dispatch_stub_387@8) + HIDDEN(GL_PREFIX(_dispatch_stub_387, _dispatch_stub_387@8)) + GL_STUB(_dispatch_stub_388, 388, _dispatch_stub_388@12) + HIDDEN(GL_PREFIX(_dispatch_stub_388, _dispatch_stub_388@12)) + GL_STUB(_dispatch_stub_389, 389, _dispatch_stub_389@8) + HIDDEN(GL_PREFIX(_dispatch_stub_389, _dispatch_stub_389@8)) + GL_STUB(_dispatch_stub_390, 390, _dispatch_stub_390@12) + HIDDEN(GL_PREFIX(_dispatch_stub_390, _dispatch_stub_390@12)) + GL_STUB(_dispatch_stub_391, 391, _dispatch_stub_391@8) + HIDDEN(GL_PREFIX(_dispatch_stub_391, _dispatch_stub_391@8)) + GL_STUB(_dispatch_stub_392, 392, _dispatch_stub_392@28) + HIDDEN(GL_PREFIX(_dispatch_stub_392, _dispatch_stub_392@28)) + GL_STUB(_dispatch_stub_393, 393, _dispatch_stub_393@8) + HIDDEN(GL_PREFIX(_dispatch_stub_393, _dispatch_stub_393@8)) + GL_STUB(_dispatch_stub_394, 394, _dispatch_stub_394@16) + HIDDEN(GL_PREFIX(_dispatch_stub_394, _dispatch_stub_394@16)) + GL_STUB(_dispatch_stub_395, 395, _dispatch_stub_395@8) + HIDDEN(GL_PREFIX(_dispatch_stub_395, _dispatch_stub_395@8)) + GL_STUB(_dispatch_stub_396, 396, _dispatch_stub_396@16) + HIDDEN(GL_PREFIX(_dispatch_stub_396, _dispatch_stub_396@16)) + GL_STUB(_dispatch_stub_397, 397, _dispatch_stub_397@8) + HIDDEN(GL_PREFIX(_dispatch_stub_397, _dispatch_stub_397@8)) + GL_STUB(_dispatch_stub_398, 398, _dispatch_stub_398@16) + HIDDEN(GL_PREFIX(_dispatch_stub_398, _dispatch_stub_398@16)) + GL_STUB(_dispatch_stub_399, 399, _dispatch_stub_399@8) + HIDDEN(GL_PREFIX(_dispatch_stub_399, _dispatch_stub_399@8)) + GL_STUB(_dispatch_stub_400, 400, _dispatch_stub_400@36) + HIDDEN(GL_PREFIX(_dispatch_stub_400, _dispatch_stub_400@36)) + GL_STUB(_dispatch_stub_401, 401, _dispatch_stub_401@8) + HIDDEN(GL_PREFIX(_dispatch_stub_401, _dispatch_stub_401@8)) + GL_STUB(_dispatch_stub_402, 402, _dispatch_stub_402@20) + HIDDEN(GL_PREFIX(_dispatch_stub_402, _dispatch_stub_402@20)) + GL_STUB(_dispatch_stub_403, 403, _dispatch_stub_403@8) + HIDDEN(GL_PREFIX(_dispatch_stub_403, _dispatch_stub_403@8)) + GL_STUB(_dispatch_stub_404, 404, _dispatch_stub_404@20) + HIDDEN(GL_PREFIX(_dispatch_stub_404, _dispatch_stub_404@20)) + GL_STUB(_dispatch_stub_405, 405, _dispatch_stub_405@8) + HIDDEN(GL_PREFIX(_dispatch_stub_405, _dispatch_stub_405@8)) + GL_STUB(_dispatch_stub_406, 406, _dispatch_stub_406@20) + HIDDEN(GL_PREFIX(_dispatch_stub_406, _dispatch_stub_406@20)) + GL_STUB(_dispatch_stub_407, 407, _dispatch_stub_407@8) + HIDDEN(GL_PREFIX(_dispatch_stub_407, _dispatch_stub_407@8)) + GL_STUB(GetBufferPointervOES, 408, GetBufferPointervOES@12) + GL_STUB(MapBufferOES, 409, MapBufferOES@8) + GL_STUB(UnmapBufferOES, 410, UnmapBufferOES@4) + GL_STUB(CompressedTexImage3DOES, 411, CompressedTexImage3DOES@36) + GL_STUB(CompressedTexSubImage3DOES, 412, CompressedTexSubImage3DOES@44) + GL_STUB(FramebufferTexture3DOES, 413, FramebufferTexture3DOES@24) + GL_STUB(GetProgramBinaryOES, 414, GetProgramBinaryOES@20) + GL_STUB(ProgramBinaryOES, 415, ProgramBinaryOES@16) + GL_STUB(MultiDrawArraysEXT, 416, MultiDrawArraysEXT@16) + GL_STUB(MultiDrawElementsEXT, 417, MultiDrawElementsEXT@20) + GL_STUB(_dispatch_stub_418, 418, _dispatch_stub_418@4) + HIDDEN(GL_PREFIX(_dispatch_stub_418, _dispatch_stub_418@4)) + GL_STUB(_dispatch_stub_419, 419, _dispatch_stub_419@8) + HIDDEN(GL_PREFIX(_dispatch_stub_419, _dispatch_stub_419@8)) + GL_STUB(_dispatch_stub_420, 420, _dispatch_stub_420@8) + HIDDEN(GL_PREFIX(_dispatch_stub_420, _dispatch_stub_420@8)) + GL_STUB(_dispatch_stub_421, 421, _dispatch_stub_421@4) + HIDDEN(GL_PREFIX(_dispatch_stub_421, _dispatch_stub_421@4)) + GL_STUB(EGLImageTargetRenderbufferStorageOES, 422, EGLImageTargetRenderbufferStorageOES@8) + GL_STUB(EGLImageTargetTexture2DOES, 423, EGLImageTargetTexture2DOES@8) + GL_STUB(CompressedTexImage2D, 424, CompressedTexImage2D@32) + GL_STUB(CompressedTexSubImage2D, 425, CompressedTexSubImage2D@36) + GL_STUB(SampleCoverage, 426, SampleCoverage@8) + GL_STUB(BindBuffer, 427, BindBuffer@8) + GL_STUB(BufferData, 428, BufferData@16) + GL_STUB(BufferSubData, 429, BufferSubData@16) + GL_STUB(DeleteBuffers, 430, DeleteBuffers@8) + GL_STUB(GenBuffers, 431, GenBuffers@8) + GL_STUB(GetBufferParameteriv, 432, GetBufferParameteriv@12) + GL_STUB(IsBuffer, 433, IsBuffer@4) + GL_STUB(AttachShader, 434, AttachShader@8) + GL_STUB(BindAttribLocation, 435, BindAttribLocation@12) + GL_STUB(BlendEquationSeparate, 436, BlendEquationSeparate@8) + GL_STUB(CompileShader, 437, CompileShader@4) + GL_STUB(CreateProgram, 438, CreateProgram@0) + GL_STUB(CreateShader, 439, CreateShader@4) + GL_STUB(DeleteProgram, 440, DeleteProgram@4) + GL_STUB(DeleteShader, 441, DeleteShader@4) + GL_STUB(DetachShader, 442, DetachShader@8) + GL_STUB(DisableVertexAttribArray, 443, DisableVertexAttribArray@4) + GL_STUB(EnableVertexAttribArray, 444, EnableVertexAttribArray@4) + GL_STUB(GetActiveAttrib, 445, GetActiveAttrib@28) + GL_STUB(GetActiveUniform, 446, GetActiveUniform@28) + GL_STUB(GetAttachedShaders, 447, GetAttachedShaders@16) + GL_STUB(GetAttribLocation, 448, GetAttribLocation@8) + GL_STUB(GetProgramInfoLog, 449, GetProgramInfoLog@16) + GL_STUB(GetProgramiv, 450, GetProgramiv@12) + GL_STUB(GetShaderInfoLog, 451, GetShaderInfoLog@16) + GL_STUB(GetShaderSource, 452, GetShaderSource@16) + GL_STUB(GetShaderiv, 453, GetShaderiv@12) + GL_STUB(GetUniformLocation, 454, GetUniformLocation@8) + GL_STUB(GetUniformfv, 455, GetUniformfv@12) + GL_STUB(GetUniformiv, 456, GetUniformiv@12) + GL_STUB(GetVertexAttribPointerv, 457, GetVertexAttribPointerv@12) + GL_STUB(GetVertexAttribfv, 458, GetVertexAttribfv@12) + GL_STUB(GetVertexAttribiv, 459, GetVertexAttribiv@12) + GL_STUB(IsProgram, 460, IsProgram@4) + GL_STUB(IsShader, 461, IsShader@4) + GL_STUB(LinkProgram, 462, LinkProgram@4) + GL_STUB(ShaderSource, 463, ShaderSource@16) + GL_STUB(StencilFuncSeparate, 464, StencilFuncSeparate@16) + GL_STUB(StencilMaskSeparate, 465, StencilMaskSeparate@8) + GL_STUB(StencilOpSeparate, 466, StencilOpSeparate@16) + GL_STUB(Uniform1f, 467, Uniform1f@8) + GL_STUB(Uniform1fv, 468, Uniform1fv@12) + GL_STUB(Uniform1i, 469, Uniform1i@8) + GL_STUB(Uniform1iv, 470, Uniform1iv@12) + GL_STUB(Uniform2f, 471, Uniform2f@12) + GL_STUB(Uniform2fv, 472, Uniform2fv@12) + GL_STUB(Uniform2i, 473, Uniform2i@12) + GL_STUB(Uniform2iv, 474, Uniform2iv@12) + GL_STUB(Uniform3f, 475, Uniform3f@16) + GL_STUB(Uniform3fv, 476, Uniform3fv@12) + GL_STUB(Uniform3i, 477, Uniform3i@16) + GL_STUB(Uniform3iv, 478, Uniform3iv@12) + GL_STUB(Uniform4f, 479, Uniform4f@20) + GL_STUB(Uniform4fv, 480, Uniform4fv@12) + GL_STUB(Uniform4i, 481, Uniform4i@20) + GL_STUB(Uniform4iv, 482, Uniform4iv@12) + GL_STUB(UniformMatrix2fv, 483, UniformMatrix2fv@16) + GL_STUB(UniformMatrix3fv, 484, UniformMatrix3fv@16) + GL_STUB(UniformMatrix4fv, 485, UniformMatrix4fv@16) + GL_STUB(UseProgram, 486, UseProgram@4) + GL_STUB(ValidateProgram, 487, ValidateProgram@4) + GL_STUB(VertexAttrib1f, 488, VertexAttrib1f@8) + GL_STUB(VertexAttrib1fv, 489, VertexAttrib1fv@8) + GL_STUB(VertexAttrib2f, 490, VertexAttrib2f@12) + GL_STUB(VertexAttrib2fv, 491, VertexAttrib2fv@8) + GL_STUB(VertexAttrib3f, 492, VertexAttrib3f@16) + GL_STUB(VertexAttrib3fv, 493, VertexAttrib3fv@8) + GL_STUB(VertexAttrib4f, 494, VertexAttrib4f@20) + GL_STUB(VertexAttrib4fv, 495, VertexAttrib4fv@8) + GL_STUB(VertexAttribPointer, 496, VertexAttribPointer@24) + GL_STUB(BlendFuncSeparate, 497, BlendFuncSeparate@16) + GL_STUB(BindFramebuffer, 498, BindFramebuffer@8) + GL_STUB(BindRenderbuffer, 499, BindRenderbuffer@8) + GL_STUB(CheckFramebufferStatus, 500, CheckFramebufferStatus@4) + GL_STUB(ClearDepthf, 501, ClearDepthf@4) + GL_STUB(DeleteFramebuffers, 502, DeleteFramebuffers@8) + GL_STUB(DeleteRenderbuffers, 503, DeleteRenderbuffers@8) + GL_STUB(DepthRangef, 504, DepthRangef@8) + GL_STUB(FramebufferRenderbuffer, 505, FramebufferRenderbuffer@16) + GL_STUB(FramebufferTexture2D, 506, FramebufferTexture2D@20) + GL_STUB(GenFramebuffers, 507, GenFramebuffers@8) + GL_STUB(GenRenderbuffers, 508, GenRenderbuffers@8) + GL_STUB(GenerateMipmap, 509, GenerateMipmap@4) + GL_STUB(GetFramebufferAttachmentParameteriv, 510, GetFramebufferAttachmentParameteriv@16) + GL_STUB(GetRenderbufferParameteriv, 511, GetRenderbufferParameteriv@12) + GL_STUB(GetShaderPrecisionFormat, 512, GetShaderPrecisionFormat@16) + GL_STUB(IsFramebuffer, 513, IsFramebuffer@4) + GL_STUB(IsRenderbuffer, 514, IsRenderbuffer@4) + GL_STUB(ReleaseShaderCompiler, 515, ReleaseShaderCompiler@0) + GL_STUB(RenderbufferStorage, 516, RenderbufferStorage@16) + GL_STUB(ShaderBinary, 517, ShaderBinary@20) + + GLOBL GLNAME(gl_dispatch_functions_end) + HIDDEN(GLNAME(gl_dispatch_functions_end)) + ALIGNTEXT16 +GLNAME(gl_dispatch_functions_end): + +#if defined(GLX_USE_TLS) && defined(__linux__) + .section ".note.ABI-tag", "a" + .p2align 2 + .long 1f - 0f /* name length */ + .long 3f - 2f /* data length */ + .long 1 /* note length */ +0: .asciz "GNU" /* vendor name */ +1: .p2align 2 +2: .long 0 /* note data: the ABI tag */ + .long 2,4,20 /* Minimum kernel version w/TLS */ +3: .p2align 2 /* pad out section */ +#endif /* GLX_USE_TLS */ + +#if defined (__ELF__) && defined (__linux__) + .section .note.GNU-stack,"",%progbits +#endif diff --git a/src/mapi/es2api/glapi/glapitable.h b/src/mapi/es2api/glapi/glapitable.h new file mode 100644 index 00000000000..c531ea11fcf --- /dev/null +++ b/src/mapi/es2api/glapi/glapitable.h @@ -0,0 +1,563 @@ +/* DO NOT EDIT - This file generated automatically by gl_table.py (from Mesa) script */ + +/* + * Copyright (C) 1999-2003 Brian Paul All Rights Reserved. + * (C) Copyright IBM Corporation 2004 + * All Rights Reserved. + * + * Permission is hereby granted, free of charge, to any person obtaining a + * copy of this software and associated documentation files (the "Software"), + * to deal in the Software without restriction, including without limitation + * the rights to use, copy, modify, merge, publish, distribute, sub license, + * and/or sell copies of the Software, and to permit persons to whom the + * Software is furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice (including the next + * paragraph) shall be included in all copies or substantial portions of the + * Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL + * BRIAN PAUL, IBM, + * AND/OR THEIR SUPPLIERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, + * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF + * OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE + * SOFTWARE. + */ + +#if !defined( _GLAPI_TABLE_H_ ) +# define _GLAPI_TABLE_H_ + +#ifndef GLAPIENTRYP +# ifndef GLAPIENTRY +# define GLAPIENTRY +# endif + +# define GLAPIENTRYP GLAPIENTRY * +#endif + + +struct _glapi_table +{ + void (GLAPIENTRYP NewList)(GLuint list, GLenum mode); /* 0 */ + void (GLAPIENTRYP EndList)(void); /* 1 */ + void (GLAPIENTRYP CallList)(GLuint list); /* 2 */ + void (GLAPIENTRYP CallLists)(GLsizei n, GLenum type, const GLvoid * lists); /* 3 */ + void (GLAPIENTRYP DeleteLists)(GLuint list, GLsizei range); /* 4 */ + GLuint (GLAPIENTRYP GenLists)(GLsizei range); /* 5 */ + void (GLAPIENTRYP ListBase)(GLuint base); /* 6 */ + void (GLAPIENTRYP Begin)(GLenum mode); /* 7 */ + void (GLAPIENTRYP Bitmap)(GLsizei width, GLsizei height, GLfloat xorig, GLfloat yorig, GLfloat xmove, GLfloat ymove, const GLubyte * bitmap); /* 8 */ + void (GLAPIENTRYP Color3b)(GLbyte red, GLbyte green, GLbyte blue); /* 9 */ + void (GLAPIENTRYP Color3bv)(const GLbyte * v); /* 10 */ + void (GLAPIENTRYP Color3d)(GLdouble red, GLdouble green, GLdouble blue); /* 11 */ + void (GLAPIENTRYP Color3dv)(const GLdouble * v); /* 12 */ + void (GLAPIENTRYP Color3f)(GLfloat red, GLfloat green, GLfloat blue); /* 13 */ + void (GLAPIENTRYP Color3fv)(const GLfloat * v); /* 14 */ + void (GLAPIENTRYP Color3i)(GLint red, GLint green, GLint blue); /* 15 */ + void (GLAPIENTRYP Color3iv)(const GLint * v); /* 16 */ + void (GLAPIENTRYP Color3s)(GLshort red, GLshort green, GLshort blue); /* 17 */ + void (GLAPIENTRYP Color3sv)(const GLshort * v); /* 18 */ + void (GLAPIENTRYP Color3ub)(GLubyte red, GLubyte green, GLubyte blue); /* 19 */ + void (GLAPIENTRYP Color3ubv)(const GLubyte * v); /* 20 */ + void (GLAPIENTRYP Color3ui)(GLuint red, GLuint green, GLuint blue); /* 21 */ + void (GLAPIENTRYP Color3uiv)(const GLuint * v); /* 22 */ + void (GLAPIENTRYP Color3us)(GLushort red, GLushort green, GLushort blue); /* 23 */ + void (GLAPIENTRYP Color3usv)(const GLushort * v); /* 24 */ + void (GLAPIENTRYP Color4b)(GLbyte red, GLbyte green, GLbyte blue, GLbyte alpha); /* 25 */ + void (GLAPIENTRYP Color4bv)(const GLbyte * v); /* 26 */ + void (GLAPIENTRYP Color4d)(GLdouble red, GLdouble green, GLdouble blue, GLdouble alpha); /* 27 */ + void (GLAPIENTRYP Color4dv)(const GLdouble * v); /* 28 */ + void (GLAPIENTRYP Color4f)(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha); /* 29 */ + void (GLAPIENTRYP Color4fv)(const GLfloat * v); /* 30 */ + void (GLAPIENTRYP Color4i)(GLint red, GLint green, GLint blue, GLint alpha); /* 31 */ + void (GLAPIENTRYP Color4iv)(const GLint * v); /* 32 */ + void (GLAPIENTRYP Color4s)(GLshort red, GLshort green, GLshort blue, GLshort alpha); /* 33 */ + void (GLAPIENTRYP Color4sv)(const GLshort * v); /* 34 */ + void (GLAPIENTRYP Color4ub)(GLubyte red, GLubyte green, GLubyte blue, GLubyte alpha); /* 35 */ + void (GLAPIENTRYP Color4ubv)(const GLubyte * v); /* 36 */ + void (GLAPIENTRYP Color4ui)(GLuint red, GLuint green, GLuint blue, GLuint alpha); /* 37 */ + void (GLAPIENTRYP Color4uiv)(const GLuint * v); /* 38 */ + void (GLAPIENTRYP Color4us)(GLushort red, GLushort green, GLushort blue, GLushort alpha); /* 39 */ + void (GLAPIENTRYP Color4usv)(const GLushort * v); /* 40 */ + void (GLAPIENTRYP EdgeFlag)(GLboolean flag); /* 41 */ + void (GLAPIENTRYP EdgeFlagv)(const GLboolean * flag); /* 42 */ + void (GLAPIENTRYP End)(void); /* 43 */ + void (GLAPIENTRYP Indexd)(GLdouble c); /* 44 */ + void (GLAPIENTRYP Indexdv)(const GLdouble * c); /* 45 */ + void (GLAPIENTRYP Indexf)(GLfloat c); /* 46 */ + void (GLAPIENTRYP Indexfv)(const GLfloat * c); /* 47 */ + void (GLAPIENTRYP Indexi)(GLint c); /* 48 */ + void (GLAPIENTRYP Indexiv)(const GLint * c); /* 49 */ + void (GLAPIENTRYP Indexs)(GLshort c); /* 50 */ + void (GLAPIENTRYP Indexsv)(const GLshort * c); /* 51 */ + void (GLAPIENTRYP Normal3b)(GLbyte nx, GLbyte ny, GLbyte nz); /* 52 */ + void (GLAPIENTRYP Normal3bv)(const GLbyte * v); /* 53 */ + void (GLAPIENTRYP Normal3d)(GLdouble nx, GLdouble ny, GLdouble nz); /* 54 */ + void (GLAPIENTRYP Normal3dv)(const GLdouble * v); /* 55 */ + void (GLAPIENTRYP Normal3f)(GLfloat nx, GLfloat ny, GLfloat nz); /* 56 */ + void (GLAPIENTRYP Normal3fv)(const GLfloat * v); /* 57 */ + void (GLAPIENTRYP Normal3i)(GLint nx, GLint ny, GLint nz); /* 58 */ + void (GLAPIENTRYP Normal3iv)(const GLint * v); /* 59 */ + void (GLAPIENTRYP Normal3s)(GLshort nx, GLshort ny, GLshort nz); /* 60 */ + void (GLAPIENTRYP Normal3sv)(const GLshort * v); /* 61 */ + void (GLAPIENTRYP RasterPos2d)(GLdouble x, GLdouble y); /* 62 */ + void (GLAPIENTRYP RasterPos2dv)(const GLdouble * v); /* 63 */ + void (GLAPIENTRYP RasterPos2f)(GLfloat x, GLfloat y); /* 64 */ + void (GLAPIENTRYP RasterPos2fv)(const GLfloat * v); /* 65 */ + void (GLAPIENTRYP RasterPos2i)(GLint x, GLint y); /* 66 */ + void (GLAPIENTRYP RasterPos2iv)(const GLint * v); /* 67 */ + void (GLAPIENTRYP RasterPos2s)(GLshort x, GLshort y); /* 68 */ + void (GLAPIENTRYP RasterPos2sv)(const GLshort * v); /* 69 */ + void (GLAPIENTRYP RasterPos3d)(GLdouble x, GLdouble y, GLdouble z); /* 70 */ + void (GLAPIENTRYP RasterPos3dv)(const GLdouble * v); /* 71 */ + void (GLAPIENTRYP RasterPos3f)(GLfloat x, GLfloat y, GLfloat z); /* 72 */ + void (GLAPIENTRYP RasterPos3fv)(const GLfloat * v); /* 73 */ + void (GLAPIENTRYP RasterPos3i)(GLint x, GLint y, GLint z); /* 74 */ + void (GLAPIENTRYP RasterPos3iv)(const GLint * v); /* 75 */ + void (GLAPIENTRYP RasterPos3s)(GLshort x, GLshort y, GLshort z); /* 76 */ + void (GLAPIENTRYP RasterPos3sv)(const GLshort * v); /* 77 */ + void (GLAPIENTRYP RasterPos4d)(GLdouble x, GLdouble y, GLdouble z, GLdouble w); /* 78 */ + void (GLAPIENTRYP RasterPos4dv)(const GLdouble * v); /* 79 */ + void (GLAPIENTRYP RasterPos4f)(GLfloat x, GLfloat y, GLfloat z, GLfloat w); /* 80 */ + void (GLAPIENTRYP RasterPos4fv)(const GLfloat * v); /* 81 */ + void (GLAPIENTRYP RasterPos4i)(GLint x, GLint y, GLint z, GLint w); /* 82 */ + void (GLAPIENTRYP RasterPos4iv)(const GLint * v); /* 83 */ + void (GLAPIENTRYP RasterPos4s)(GLshort x, GLshort y, GLshort z, GLshort w); /* 84 */ + void (GLAPIENTRYP RasterPos4sv)(const GLshort * v); /* 85 */ + void (GLAPIENTRYP Rectd)(GLdouble x1, GLdouble y1, GLdouble x2, GLdouble y2); /* 86 */ + void (GLAPIENTRYP Rectdv)(const GLdouble * v1, const GLdouble * v2); /* 87 */ + void (GLAPIENTRYP Rectf)(GLfloat x1, GLfloat y1, GLfloat x2, GLfloat y2); /* 88 */ + void (GLAPIENTRYP Rectfv)(const GLfloat * v1, const GLfloat * v2); /* 89 */ + void (GLAPIENTRYP Recti)(GLint x1, GLint y1, GLint x2, GLint y2); /* 90 */ + void (GLAPIENTRYP Rectiv)(const GLint * v1, const GLint * v2); /* 91 */ + void (GLAPIENTRYP Rects)(GLshort x1, GLshort y1, GLshort x2, GLshort y2); /* 92 */ + void (GLAPIENTRYP Rectsv)(const GLshort * v1, const GLshort * v2); /* 93 */ + void (GLAPIENTRYP TexCoord1d)(GLdouble s); /* 94 */ + void (GLAPIENTRYP TexCoord1dv)(const GLdouble * v); /* 95 */ + void (GLAPIENTRYP TexCoord1f)(GLfloat s); /* 96 */ + void (GLAPIENTRYP TexCoord1fv)(const GLfloat * v); /* 97 */ + void (GLAPIENTRYP TexCoord1i)(GLint s); /* 98 */ + void (GLAPIENTRYP TexCoord1iv)(const GLint * v); /* 99 */ + void (GLAPIENTRYP TexCoord1s)(GLshort s); /* 100 */ + void (GLAPIENTRYP TexCoord1sv)(const GLshort * v); /* 101 */ + void (GLAPIENTRYP TexCoord2d)(GLdouble s, GLdouble t); /* 102 */ + void (GLAPIENTRYP TexCoord2dv)(const GLdouble * v); /* 103 */ + void (GLAPIENTRYP TexCoord2f)(GLfloat s, GLfloat t); /* 104 */ + void (GLAPIENTRYP TexCoord2fv)(const GLfloat * v); /* 105 */ + void (GLAPIENTRYP TexCoord2i)(GLint s, GLint t); /* 106 */ + void (GLAPIENTRYP TexCoord2iv)(const GLint * v); /* 107 */ + void (GLAPIENTRYP TexCoord2s)(GLshort s, GLshort t); /* 108 */ + void (GLAPIENTRYP TexCoord2sv)(const GLshort * v); /* 109 */ + void (GLAPIENTRYP TexCoord3d)(GLdouble s, GLdouble t, GLdouble r); /* 110 */ + void (GLAPIENTRYP TexCoord3dv)(const GLdouble * v); /* 111 */ + void (GLAPIENTRYP TexCoord3f)(GLfloat s, GLfloat t, GLfloat r); /* 112 */ + void (GLAPIENTRYP TexCoord3fv)(const GLfloat * v); /* 113 */ + void (GLAPIENTRYP TexCoord3i)(GLint s, GLint t, GLint r); /* 114 */ + void (GLAPIENTRYP TexCoord3iv)(const GLint * v); /* 115 */ + void (GLAPIENTRYP TexCoord3s)(GLshort s, GLshort t, GLshort r); /* 116 */ + void (GLAPIENTRYP TexCoord3sv)(const GLshort * v); /* 117 */ + void (GLAPIENTRYP TexCoord4d)(GLdouble s, GLdouble t, GLdouble r, GLdouble q); /* 118 */ + void (GLAPIENTRYP TexCoord4dv)(const GLdouble * v); /* 119 */ + void (GLAPIENTRYP TexCoord4f)(GLfloat s, GLfloat t, GLfloat r, GLfloat q); /* 120 */ + void (GLAPIENTRYP TexCoord4fv)(const GLfloat * v); /* 121 */ + void (GLAPIENTRYP TexCoord4i)(GLint s, GLint t, GLint r, GLint q); /* 122 */ + void (GLAPIENTRYP TexCoord4iv)(const GLint * v); /* 123 */ + void (GLAPIENTRYP TexCoord4s)(GLshort s, GLshort t, GLshort r, GLshort q); /* 124 */ + void (GLAPIENTRYP TexCoord4sv)(const GLshort * v); /* 125 */ + void (GLAPIENTRYP Vertex2d)(GLdouble x, GLdouble y); /* 126 */ + void (GLAPIENTRYP Vertex2dv)(const GLdouble * v); /* 127 */ + void (GLAPIENTRYP Vertex2f)(GLfloat x, GLfloat y); /* 128 */ + void (GLAPIENTRYP Vertex2fv)(const GLfloat * v); /* 129 */ + void (GLAPIENTRYP Vertex2i)(GLint x, GLint y); /* 130 */ + void (GLAPIENTRYP Vertex2iv)(const GLint * v); /* 131 */ + void (GLAPIENTRYP Vertex2s)(GLshort x, GLshort y); /* 132 */ + void (GLAPIENTRYP Vertex2sv)(const GLshort * v); /* 133 */ + void (GLAPIENTRYP Vertex3d)(GLdouble x, GLdouble y, GLdouble z); /* 134 */ + void (GLAPIENTRYP Vertex3dv)(const GLdouble * v); /* 135 */ + void (GLAPIENTRYP Vertex3f)(GLfloat x, GLfloat y, GLfloat z); /* 136 */ + void (GLAPIENTRYP Vertex3fv)(const GLfloat * v); /* 137 */ + void (GLAPIENTRYP Vertex3i)(GLint x, GLint y, GLint z); /* 138 */ + void (GLAPIENTRYP Vertex3iv)(const GLint * v); /* 139 */ + void (GLAPIENTRYP Vertex3s)(GLshort x, GLshort y, GLshort z); /* 140 */ + void (GLAPIENTRYP Vertex3sv)(const GLshort * v); /* 141 */ + void (GLAPIENTRYP Vertex4d)(GLdouble x, GLdouble y, GLdouble z, GLdouble w); /* 142 */ + void (GLAPIENTRYP Vertex4dv)(const GLdouble * v); /* 143 */ + void (GLAPIENTRYP Vertex4f)(GLfloat x, GLfloat y, GLfloat z, GLfloat w); /* 144 */ + void (GLAPIENTRYP Vertex4fv)(const GLfloat * v); /* 145 */ + void (GLAPIENTRYP Vertex4i)(GLint x, GLint y, GLint z, GLint w); /* 146 */ + void (GLAPIENTRYP Vertex4iv)(const GLint * v); /* 147 */ + void (GLAPIENTRYP Vertex4s)(GLshort x, GLshort y, GLshort z, GLshort w); /* 148 */ + void (GLAPIENTRYP Vertex4sv)(const GLshort * v); /* 149 */ + void (GLAPIENTRYP ClipPlane)(GLenum plane, const GLdouble * equation); /* 150 */ + void (GLAPIENTRYP ColorMaterial)(GLenum face, GLenum mode); /* 151 */ + void (GLAPIENTRYP CullFace)(GLenum mode); /* 152 */ + void (GLAPIENTRYP Fogf)(GLenum pname, GLfloat param); /* 153 */ + void (GLAPIENTRYP Fogfv)(GLenum pname, const GLfloat * params); /* 154 */ + void (GLAPIENTRYP Fogi)(GLenum pname, GLint param); /* 155 */ + void (GLAPIENTRYP Fogiv)(GLenum pname, const GLint * params); /* 156 */ + void (GLAPIENTRYP FrontFace)(GLenum mode); /* 157 */ + void (GLAPIENTRYP Hint)(GLenum target, GLenum mode); /* 158 */ + void (GLAPIENTRYP Lightf)(GLenum light, GLenum pname, GLfloat param); /* 159 */ + void (GLAPIENTRYP Lightfv)(GLenum light, GLenum pname, const GLfloat * params); /* 160 */ + void (GLAPIENTRYP Lighti)(GLenum light, GLenum pname, GLint param); /* 161 */ + void (GLAPIENTRYP Lightiv)(GLenum light, GLenum pname, const GLint * params); /* 162 */ + void (GLAPIENTRYP LightModelf)(GLenum pname, GLfloat param); /* 163 */ + void (GLAPIENTRYP LightModelfv)(GLenum pname, const GLfloat * params); /* 164 */ + void (GLAPIENTRYP LightModeli)(GLenum pname, GLint param); /* 165 */ + void (GLAPIENTRYP LightModeliv)(GLenum pname, const GLint * params); /* 166 */ + void (GLAPIENTRYP LineStipple)(GLint factor, GLushort pattern); /* 167 */ + void (GLAPIENTRYP LineWidth)(GLfloat width); /* 168 */ + void (GLAPIENTRYP Materialf)(GLenum face, GLenum pname, GLfloat param); /* 169 */ + void (GLAPIENTRYP Materialfv)(GLenum face, GLenum pname, const GLfloat * params); /* 170 */ + void (GLAPIENTRYP Materiali)(GLenum face, GLenum pname, GLint param); /* 171 */ + void (GLAPIENTRYP Materialiv)(GLenum face, GLenum pname, const GLint * params); /* 172 */ + void (GLAPIENTRYP PointSize)(GLfloat size); /* 173 */ + void (GLAPIENTRYP PolygonMode)(GLenum face, GLenum mode); /* 174 */ + void (GLAPIENTRYP PolygonStipple)(const GLubyte * mask); /* 175 */ + void (GLAPIENTRYP Scissor)(GLint x, GLint y, GLsizei width, GLsizei height); /* 176 */ + void (GLAPIENTRYP ShadeModel)(GLenum mode); /* 177 */ + void (GLAPIENTRYP TexParameterf)(GLenum target, GLenum pname, GLfloat param); /* 178 */ + void (GLAPIENTRYP TexParameterfv)(GLenum target, GLenum pname, const GLfloat * params); /* 179 */ + void (GLAPIENTRYP TexParameteri)(GLenum target, GLenum pname, GLint param); /* 180 */ + void (GLAPIENTRYP TexParameteriv)(GLenum target, GLenum pname, const GLint * params); /* 181 */ + void (GLAPIENTRYP TexImage1D)(GLenum target, GLint level, GLint internalformat, GLsizei width, GLint border, GLenum format, GLenum type, const GLvoid * pixels); /* 182 */ + void (GLAPIENTRYP TexImage2D)(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const GLvoid * pixels); /* 183 */ + void (GLAPIENTRYP TexEnvf)(GLenum target, GLenum pname, GLfloat param); /* 184 */ + void (GLAPIENTRYP TexEnvfv)(GLenum target, GLenum pname, const GLfloat * params); /* 185 */ + void (GLAPIENTRYP TexEnvi)(GLenum target, GLenum pname, GLint param); /* 186 */ + void (GLAPIENTRYP TexEnviv)(GLenum target, GLenum pname, const GLint * params); /* 187 */ + void (GLAPIENTRYP TexGend)(GLenum coord, GLenum pname, GLdouble param); /* 188 */ + void (GLAPIENTRYP TexGendv)(GLenum coord, GLenum pname, const GLdouble * params); /* 189 */ + void (GLAPIENTRYP TexGenf)(GLenum coord, GLenum pname, GLfloat param); /* 190 */ + void (GLAPIENTRYP TexGenfv)(GLenum coord, GLenum pname, const GLfloat * params); /* 191 */ + void (GLAPIENTRYP TexGeni)(GLenum coord, GLenum pname, GLint param); /* 192 */ + void (GLAPIENTRYP TexGeniv)(GLenum coord, GLenum pname, const GLint * params); /* 193 */ + void (GLAPIENTRYP FeedbackBuffer)(GLsizei size, GLenum type, GLfloat * buffer); /* 194 */ + void (GLAPIENTRYP SelectBuffer)(GLsizei size, GLuint * buffer); /* 195 */ + GLint (GLAPIENTRYP RenderMode)(GLenum mode); /* 196 */ + void (GLAPIENTRYP InitNames)(void); /* 197 */ + void (GLAPIENTRYP LoadName)(GLuint name); /* 198 */ + void (GLAPIENTRYP PassThrough)(GLfloat token); /* 199 */ + void (GLAPIENTRYP PopName)(void); /* 200 */ + void (GLAPIENTRYP PushName)(GLuint name); /* 201 */ + void (GLAPIENTRYP DrawBuffer)(GLenum mode); /* 202 */ + void (GLAPIENTRYP Clear)(GLbitfield mask); /* 203 */ + void (GLAPIENTRYP ClearAccum)(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha); /* 204 */ + void (GLAPIENTRYP ClearIndex)(GLfloat c); /* 205 */ + void (GLAPIENTRYP ClearColor)(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha); /* 206 */ + void (GLAPIENTRYP ClearStencil)(GLint s); /* 207 */ + void (GLAPIENTRYP ClearDepth)(GLclampd depth); /* 208 */ + void (GLAPIENTRYP StencilMask)(GLuint mask); /* 209 */ + void (GLAPIENTRYP ColorMask)(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha); /* 210 */ + void (GLAPIENTRYP DepthMask)(GLboolean flag); /* 211 */ + void (GLAPIENTRYP IndexMask)(GLuint mask); /* 212 */ + void (GLAPIENTRYP Accum)(GLenum op, GLfloat value); /* 213 */ + void (GLAPIENTRYP Disable)(GLenum cap); /* 214 */ + void (GLAPIENTRYP Enable)(GLenum cap); /* 215 */ + void (GLAPIENTRYP Finish)(void); /* 216 */ + void (GLAPIENTRYP Flush)(void); /* 217 */ + void (GLAPIENTRYP PopAttrib)(void); /* 218 */ + void (GLAPIENTRYP PushAttrib)(GLbitfield mask); /* 219 */ + void (GLAPIENTRYP Map1d)(GLenum target, GLdouble u1, GLdouble u2, GLint stride, GLint order, const GLdouble * points); /* 220 */ + void (GLAPIENTRYP Map1f)(GLenum target, GLfloat u1, GLfloat u2, GLint stride, GLint order, const GLfloat * points); /* 221 */ + void (GLAPIENTRYP Map2d)(GLenum target, GLdouble u1, GLdouble u2, GLint ustride, GLint uorder, GLdouble v1, GLdouble v2, GLint vstride, GLint vorder, const GLdouble * points); /* 222 */ + void (GLAPIENTRYP Map2f)(GLenum target, GLfloat u1, GLfloat u2, GLint ustride, GLint uorder, GLfloat v1, GLfloat v2, GLint vstride, GLint vorder, const GLfloat * points); /* 223 */ + void (GLAPIENTRYP MapGrid1d)(GLint un, GLdouble u1, GLdouble u2); /* 224 */ + void (GLAPIENTRYP MapGrid1f)(GLint un, GLfloat u1, GLfloat u2); /* 225 */ + void (GLAPIENTRYP MapGrid2d)(GLint un, GLdouble u1, GLdouble u2, GLint vn, GLdouble v1, GLdouble v2); /* 226 */ + void (GLAPIENTRYP MapGrid2f)(GLint un, GLfloat u1, GLfloat u2, GLint vn, GLfloat v1, GLfloat v2); /* 227 */ + void (GLAPIENTRYP EvalCoord1d)(GLdouble u); /* 228 */ + void (GLAPIENTRYP EvalCoord1dv)(const GLdouble * u); /* 229 */ + void (GLAPIENTRYP EvalCoord1f)(GLfloat u); /* 230 */ + void (GLAPIENTRYP EvalCoord1fv)(const GLfloat * u); /* 231 */ + void (GLAPIENTRYP EvalCoord2d)(GLdouble u, GLdouble v); /* 232 */ + void (GLAPIENTRYP EvalCoord2dv)(const GLdouble * u); /* 233 */ + void (GLAPIENTRYP EvalCoord2f)(GLfloat u, GLfloat v); /* 234 */ + void (GLAPIENTRYP EvalCoord2fv)(const GLfloat * u); /* 235 */ + void (GLAPIENTRYP EvalMesh1)(GLenum mode, GLint i1, GLint i2); /* 236 */ + void (GLAPIENTRYP EvalPoint1)(GLint i); /* 237 */ + void (GLAPIENTRYP EvalMesh2)(GLenum mode, GLint i1, GLint i2, GLint j1, GLint j2); /* 238 */ + void (GLAPIENTRYP EvalPoint2)(GLint i, GLint j); /* 239 */ + void (GLAPIENTRYP AlphaFunc)(GLenum func, GLclampf ref); /* 240 */ + void (GLAPIENTRYP BlendFunc)(GLenum sfactor, GLenum dfactor); /* 241 */ + void (GLAPIENTRYP LogicOp)(GLenum opcode); /* 242 */ + void (GLAPIENTRYP StencilFunc)(GLenum func, GLint ref, GLuint mask); /* 243 */ + void (GLAPIENTRYP StencilOp)(GLenum fail, GLenum zfail, GLenum zpass); /* 244 */ + void (GLAPIENTRYP DepthFunc)(GLenum func); /* 245 */ + void (GLAPIENTRYP PixelZoom)(GLfloat xfactor, GLfloat yfactor); /* 246 */ + void (GLAPIENTRYP PixelTransferf)(GLenum pname, GLfloat param); /* 247 */ + void (GLAPIENTRYP PixelTransferi)(GLenum pname, GLint param); /* 248 */ + void (GLAPIENTRYP PixelStoref)(GLenum pname, GLfloat param); /* 249 */ + void (GLAPIENTRYP PixelStorei)(GLenum pname, GLint param); /* 250 */ + void (GLAPIENTRYP PixelMapfv)(GLenum map, GLsizei mapsize, const GLfloat * values); /* 251 */ + void (GLAPIENTRYP PixelMapuiv)(GLenum map, GLsizei mapsize, const GLuint * values); /* 252 */ + void (GLAPIENTRYP PixelMapusv)(GLenum map, GLsizei mapsize, const GLushort * values); /* 253 */ + void (GLAPIENTRYP ReadBuffer)(GLenum mode); /* 254 */ + void (GLAPIENTRYP CopyPixels)(GLint x, GLint y, GLsizei width, GLsizei height, GLenum type); /* 255 */ + void (GLAPIENTRYP ReadPixels)(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLvoid * pixels); /* 256 */ + void (GLAPIENTRYP DrawPixels)(GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid * pixels); /* 257 */ + void (GLAPIENTRYP GetBooleanv)(GLenum pname, GLboolean * params); /* 258 */ + void (GLAPIENTRYP GetClipPlane)(GLenum plane, GLdouble * equation); /* 259 */ + void (GLAPIENTRYP GetDoublev)(GLenum pname, GLdouble * params); /* 260 */ + GLenum (GLAPIENTRYP GetError)(void); /* 261 */ + void (GLAPIENTRYP GetFloatv)(GLenum pname, GLfloat * params); /* 262 */ + void (GLAPIENTRYP GetIntegerv)(GLenum pname, GLint * params); /* 263 */ + void (GLAPIENTRYP GetLightfv)(GLenum light, GLenum pname, GLfloat * params); /* 264 */ + void (GLAPIENTRYP GetLightiv)(GLenum light, GLenum pname, GLint * params); /* 265 */ + void (GLAPIENTRYP GetMapdv)(GLenum target, GLenum query, GLdouble * v); /* 266 */ + void (GLAPIENTRYP GetMapfv)(GLenum target, GLenum query, GLfloat * v); /* 267 */ + void (GLAPIENTRYP GetMapiv)(GLenum target, GLenum query, GLint * v); /* 268 */ + void (GLAPIENTRYP GetMaterialfv)(GLenum face, GLenum pname, GLfloat * params); /* 269 */ + void (GLAPIENTRYP GetMaterialiv)(GLenum face, GLenum pname, GLint * params); /* 270 */ + void (GLAPIENTRYP GetPixelMapfv)(GLenum map, GLfloat * values); /* 271 */ + void (GLAPIENTRYP GetPixelMapuiv)(GLenum map, GLuint * values); /* 272 */ + void (GLAPIENTRYP GetPixelMapusv)(GLenum map, GLushort * values); /* 273 */ + void (GLAPIENTRYP GetPolygonStipple)(GLubyte * mask); /* 274 */ + const GLubyte * (GLAPIENTRYP GetString)(GLenum name); /* 275 */ + void (GLAPIENTRYP GetTexEnvfv)(GLenum target, GLenum pname, GLfloat * params); /* 276 */ + void (GLAPIENTRYP GetTexEnviv)(GLenum target, GLenum pname, GLint * params); /* 277 */ + void (GLAPIENTRYP GetTexGendv)(GLenum coord, GLenum pname, GLdouble * params); /* 278 */ + void (GLAPIENTRYP GetTexGenfv)(GLenum coord, GLenum pname, GLfloat * params); /* 279 */ + void (GLAPIENTRYP GetTexGeniv)(GLenum coord, GLenum pname, GLint * params); /* 280 */ + void (GLAPIENTRYP GetTexImage)(GLenum target, GLint level, GLenum format, GLenum type, GLvoid * pixels); /* 281 */ + void (GLAPIENTRYP GetTexParameterfv)(GLenum target, GLenum pname, GLfloat * params); /* 282 */ + void (GLAPIENTRYP GetTexParameteriv)(GLenum target, GLenum pname, GLint * params); /* 283 */ + void (GLAPIENTRYP GetTexLevelParameterfv)(GLenum target, GLint level, GLenum pname, GLfloat * params); /* 284 */ + void (GLAPIENTRYP GetTexLevelParameteriv)(GLenum target, GLint level, GLenum pname, GLint * params); /* 285 */ + GLboolean (GLAPIENTRYP IsEnabled)(GLenum cap); /* 286 */ + GLboolean (GLAPIENTRYP IsList)(GLuint list); /* 287 */ + void (GLAPIENTRYP DepthRange)(GLclampd zNear, GLclampd zFar); /* 288 */ + void (GLAPIENTRYP Frustum)(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar); /* 289 */ + void (GLAPIENTRYP LoadIdentity)(void); /* 290 */ + void (GLAPIENTRYP LoadMatrixf)(const GLfloat * m); /* 291 */ + void (GLAPIENTRYP LoadMatrixd)(const GLdouble * m); /* 292 */ + void (GLAPIENTRYP MatrixMode)(GLenum mode); /* 293 */ + void (GLAPIENTRYP MultMatrixf)(const GLfloat * m); /* 294 */ + void (GLAPIENTRYP MultMatrixd)(const GLdouble * m); /* 295 */ + void (GLAPIENTRYP Ortho)(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar); /* 296 */ + void (GLAPIENTRYP PopMatrix)(void); /* 297 */ + void (GLAPIENTRYP PushMatrix)(void); /* 298 */ + void (GLAPIENTRYP Rotated)(GLdouble angle, GLdouble x, GLdouble y, GLdouble z); /* 299 */ + void (GLAPIENTRYP Rotatef)(GLfloat angle, GLfloat x, GLfloat y, GLfloat z); /* 300 */ + void (GLAPIENTRYP Scaled)(GLdouble x, GLdouble y, GLdouble z); /* 301 */ + void (GLAPIENTRYP Scalef)(GLfloat x, GLfloat y, GLfloat z); /* 302 */ + void (GLAPIENTRYP Translated)(GLdouble x, GLdouble y, GLdouble z); /* 303 */ + void (GLAPIENTRYP Translatef)(GLfloat x, GLfloat y, GLfloat z); /* 304 */ + void (GLAPIENTRYP Viewport)(GLint x, GLint y, GLsizei width, GLsizei height); /* 305 */ + void (GLAPIENTRYP ArrayElement)(GLint i); /* 306 */ + void (GLAPIENTRYP BindTexture)(GLenum target, GLuint texture); /* 307 */ + void (GLAPIENTRYP ColorPointer)(GLint size, GLenum type, GLsizei stride, const GLvoid * pointer); /* 308 */ + void (GLAPIENTRYP DisableClientState)(GLenum array); /* 309 */ + void (GLAPIENTRYP DrawArrays)(GLenum mode, GLint first, GLsizei count); /* 310 */ + void (GLAPIENTRYP DrawElements)(GLenum mode, GLsizei count, GLenum type, const GLvoid * indices); /* 311 */ + void (GLAPIENTRYP EdgeFlagPointer)(GLsizei stride, const GLvoid * pointer); /* 312 */ + void (GLAPIENTRYP EnableClientState)(GLenum array); /* 313 */ + void (GLAPIENTRYP IndexPointer)(GLenum type, GLsizei stride, const GLvoid * pointer); /* 314 */ + void (GLAPIENTRYP Indexub)(GLubyte c); /* 315 */ + void (GLAPIENTRYP Indexubv)(const GLubyte * c); /* 316 */ + void (GLAPIENTRYP InterleavedArrays)(GLenum format, GLsizei stride, const GLvoid * pointer); /* 317 */ + void (GLAPIENTRYP NormalPointer)(GLenum type, GLsizei stride, const GLvoid * pointer); /* 318 */ + void (GLAPIENTRYP PolygonOffset)(GLfloat factor, GLfloat units); /* 319 */ + void (GLAPIENTRYP TexCoordPointer)(GLint size, GLenum type, GLsizei stride, const GLvoid * pointer); /* 320 */ + void (GLAPIENTRYP VertexPointer)(GLint size, GLenum type, GLsizei stride, const GLvoid * pointer); /* 321 */ + GLboolean (GLAPIENTRYP AreTexturesResident)(GLsizei n, const GLuint * textures, GLboolean * residences); /* 322 */ + void (GLAPIENTRYP CopyTexImage1D)(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLint border); /* 323 */ + void (GLAPIENTRYP CopyTexImage2D)(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border); /* 324 */ + void (GLAPIENTRYP CopyTexSubImage1D)(GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width); /* 325 */ + void (GLAPIENTRYP CopyTexSubImage2D)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height); /* 326 */ + void (GLAPIENTRYP DeleteTextures)(GLsizei n, const GLuint * textures); /* 327 */ + void (GLAPIENTRYP GenTextures)(GLsizei n, GLuint * textures); /* 328 */ + void (GLAPIENTRYP GetPointerv)(GLenum pname, GLvoid ** params); /* 329 */ + GLboolean (GLAPIENTRYP IsTexture)(GLuint texture); /* 330 */ + void (GLAPIENTRYP PrioritizeTextures)(GLsizei n, const GLuint * textures, const GLclampf * priorities); /* 331 */ + void (GLAPIENTRYP TexSubImage1D)(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const GLvoid * pixels); /* 332 */ + void (GLAPIENTRYP TexSubImage2D)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid * pixels); /* 333 */ + void (GLAPIENTRYP PopClientAttrib)(void); /* 334 */ + void (GLAPIENTRYP PushClientAttrib)(GLbitfield mask); /* 335 */ + void (GLAPIENTRYP BlendColor)(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha); /* 336 */ + void (GLAPIENTRYP BlendEquation)(GLenum mode); /* 337 */ + void (GLAPIENTRYP DrawRangeElements)(GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const GLvoid * indices); /* 338 */ + void (GLAPIENTRYP ColorTable)(GLenum target, GLenum internalformat, GLsizei width, GLenum format, GLenum type, const GLvoid * table); /* 339 */ + void (GLAPIENTRYP ColorTableParameterfv)(GLenum target, GLenum pname, const GLfloat * params); /* 340 */ + void (GLAPIENTRYP ColorTableParameteriv)(GLenum target, GLenum pname, const GLint * params); /* 341 */ + void (GLAPIENTRYP CopyColorTable)(GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width); /* 342 */ + void (GLAPIENTRYP GetColorTable)(GLenum target, GLenum format, GLenum type, GLvoid * table); /* 343 */ + void (GLAPIENTRYP GetColorTableParameterfv)(GLenum target, GLenum pname, GLfloat * params); /* 344 */ + void (GLAPIENTRYP GetColorTableParameteriv)(GLenum target, GLenum pname, GLint * params); /* 345 */ + void (GLAPIENTRYP ColorSubTable)(GLenum target, GLsizei start, GLsizei count, GLenum format, GLenum type, const GLvoid * data); /* 346 */ + void (GLAPIENTRYP CopyColorSubTable)(GLenum target, GLsizei start, GLint x, GLint y, GLsizei width); /* 347 */ + void (GLAPIENTRYP ConvolutionFilter1D)(GLenum target, GLenum internalformat, GLsizei width, GLenum format, GLenum type, const GLvoid * image); /* 348 */ + void (GLAPIENTRYP ConvolutionFilter2D)(GLenum target, GLenum internalformat, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid * image); /* 349 */ + void (GLAPIENTRYP ConvolutionParameterf)(GLenum target, GLenum pname, GLfloat params); /* 350 */ + void (GLAPIENTRYP ConvolutionParameterfv)(GLenum target, GLenum pname, const GLfloat * params); /* 351 */ + void (GLAPIENTRYP ConvolutionParameteri)(GLenum target, GLenum pname, GLint params); /* 352 */ + void (GLAPIENTRYP ConvolutionParameteriv)(GLenum target, GLenum pname, const GLint * params); /* 353 */ + void (GLAPIENTRYP CopyConvolutionFilter1D)(GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width); /* 354 */ + void (GLAPIENTRYP CopyConvolutionFilter2D)(GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height); /* 355 */ + void (GLAPIENTRYP GetConvolutionFilter)(GLenum target, GLenum format, GLenum type, GLvoid * image); /* 356 */ + void (GLAPIENTRYP GetConvolutionParameterfv)(GLenum target, GLenum pname, GLfloat * params); /* 357 */ + void (GLAPIENTRYP GetConvolutionParameteriv)(GLenum target, GLenum pname, GLint * params); /* 358 */ + void (GLAPIENTRYP GetSeparableFilter)(GLenum target, GLenum format, GLenum type, GLvoid * row, GLvoid * column, GLvoid * span); /* 359 */ + void (GLAPIENTRYP SeparableFilter2D)(GLenum target, GLenum internalformat, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid * row, const GLvoid * column); /* 360 */ + void (GLAPIENTRYP GetHistogram)(GLenum target, GLboolean reset, GLenum format, GLenum type, GLvoid * values); /* 361 */ + void (GLAPIENTRYP GetHistogramParameterfv)(GLenum target, GLenum pname, GLfloat * params); /* 362 */ + void (GLAPIENTRYP GetHistogramParameteriv)(GLenum target, GLenum pname, GLint * params); /* 363 */ + void (GLAPIENTRYP GetMinmax)(GLenum target, GLboolean reset, GLenum format, GLenum type, GLvoid * values); /* 364 */ + void (GLAPIENTRYP GetMinmaxParameterfv)(GLenum target, GLenum pname, GLfloat * params); /* 365 */ + void (GLAPIENTRYP GetMinmaxParameteriv)(GLenum target, GLenum pname, GLint * params); /* 366 */ + void (GLAPIENTRYP Histogram)(GLenum target, GLsizei width, GLenum internalformat, GLboolean sink); /* 367 */ + void (GLAPIENTRYP Minmax)(GLenum target, GLenum internalformat, GLboolean sink); /* 368 */ + void (GLAPIENTRYP ResetHistogram)(GLenum target); /* 369 */ + void (GLAPIENTRYP ResetMinmax)(GLenum target); /* 370 */ + void (GLAPIENTRYP TexImage3DOES)(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const GLvoid * pixels); /* 371 */ + void (GLAPIENTRYP TexSubImage3DOES)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const GLvoid * pixels); /* 372 */ + void (GLAPIENTRYP CopyTexSubImage3DOES)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height); /* 373 */ + void (GLAPIENTRYP ActiveTexture)(GLenum texture); /* 374 */ + void (GLAPIENTRYP ClientActiveTextureARB)(GLenum texture); /* 375 */ + void (GLAPIENTRYP MultiTexCoord1dARB)(GLenum target, GLdouble s); /* 376 */ + void (GLAPIENTRYP MultiTexCoord1dvARB)(GLenum target, const GLdouble * v); /* 377 */ + void (GLAPIENTRYP MultiTexCoord1fARB)(GLenum target, GLfloat s); /* 378 */ + void (GLAPIENTRYP MultiTexCoord1fvARB)(GLenum target, const GLfloat * v); /* 379 */ + void (GLAPIENTRYP MultiTexCoord1iARB)(GLenum target, GLint s); /* 380 */ + void (GLAPIENTRYP MultiTexCoord1ivARB)(GLenum target, const GLint * v); /* 381 */ + void (GLAPIENTRYP MultiTexCoord1sARB)(GLenum target, GLshort s); /* 382 */ + void (GLAPIENTRYP MultiTexCoord1svARB)(GLenum target, const GLshort * v); /* 383 */ + void (GLAPIENTRYP MultiTexCoord2dARB)(GLenum target, GLdouble s, GLdouble t); /* 384 */ + void (GLAPIENTRYP MultiTexCoord2dvARB)(GLenum target, const GLdouble * v); /* 385 */ + void (GLAPIENTRYP MultiTexCoord2fARB)(GLenum target, GLfloat s, GLfloat t); /* 386 */ + void (GLAPIENTRYP MultiTexCoord2fvARB)(GLenum target, const GLfloat * v); /* 387 */ + void (GLAPIENTRYP MultiTexCoord2iARB)(GLenum target, GLint s, GLint t); /* 388 */ + void (GLAPIENTRYP MultiTexCoord2ivARB)(GLenum target, const GLint * v); /* 389 */ + void (GLAPIENTRYP MultiTexCoord2sARB)(GLenum target, GLshort s, GLshort t); /* 390 */ + void (GLAPIENTRYP MultiTexCoord2svARB)(GLenum target, const GLshort * v); /* 391 */ + void (GLAPIENTRYP MultiTexCoord3dARB)(GLenum target, GLdouble s, GLdouble t, GLdouble r); /* 392 */ + void (GLAPIENTRYP MultiTexCoord3dvARB)(GLenum target, const GLdouble * v); /* 393 */ + void (GLAPIENTRYP MultiTexCoord3fARB)(GLenum target, GLfloat s, GLfloat t, GLfloat r); /* 394 */ + void (GLAPIENTRYP MultiTexCoord3fvARB)(GLenum target, const GLfloat * v); /* 395 */ + void (GLAPIENTRYP MultiTexCoord3iARB)(GLenum target, GLint s, GLint t, GLint r); /* 396 */ + void (GLAPIENTRYP MultiTexCoord3ivARB)(GLenum target, const GLint * v); /* 397 */ + void (GLAPIENTRYP MultiTexCoord3sARB)(GLenum target, GLshort s, GLshort t, GLshort r); /* 398 */ + void (GLAPIENTRYP MultiTexCoord3svARB)(GLenum target, const GLshort * v); /* 399 */ + void (GLAPIENTRYP MultiTexCoord4dARB)(GLenum target, GLdouble s, GLdouble t, GLdouble r, GLdouble q); /* 400 */ + void (GLAPIENTRYP MultiTexCoord4dvARB)(GLenum target, const GLdouble * v); /* 401 */ + void (GLAPIENTRYP MultiTexCoord4fARB)(GLenum target, GLfloat s, GLfloat t, GLfloat r, GLfloat q); /* 402 */ + void (GLAPIENTRYP MultiTexCoord4fvARB)(GLenum target, const GLfloat * v); /* 403 */ + void (GLAPIENTRYP MultiTexCoord4iARB)(GLenum target, GLint s, GLint t, GLint r, GLint q); /* 404 */ + void (GLAPIENTRYP MultiTexCoord4ivARB)(GLenum target, const GLint * v); /* 405 */ + void (GLAPIENTRYP MultiTexCoord4sARB)(GLenum target, GLshort s, GLshort t, GLshort r, GLshort q); /* 406 */ + void (GLAPIENTRYP MultiTexCoord4svARB)(GLenum target, const GLshort * v); /* 407 */ + void (GLAPIENTRYP GetBufferPointervOES)(GLenum target, GLenum pname, GLvoid ** params); /* 408 */ + GLvoid * (GLAPIENTRYP MapBufferOES)(GLenum target, GLenum access); /* 409 */ + GLboolean (GLAPIENTRYP UnmapBufferOES)(GLenum target); /* 410 */ + void (GLAPIENTRYP CompressedTexImage3DOES)(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const GLvoid * data); /* 411 */ + void (GLAPIENTRYP CompressedTexSubImage3DOES)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const GLvoid * data); /* 412 */ + void (GLAPIENTRYP FramebufferTexture3DOES)(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level, GLint zoffset); /* 413 */ + void (GLAPIENTRYP GetProgramBinaryOES)(GLuint program, GLsizei bufSize, GLsizei * length, GLenum * binaryFormat, GLvoid * binary); /* 414 */ + void (GLAPIENTRYP ProgramBinaryOES)(GLuint program, GLenum binaryFormat, const GLvoid * binary, GLint length); /* 415 */ + void (GLAPIENTRYP MultiDrawArraysEXT)(GLenum mode, const GLint * first, const GLsizei * count, GLsizei primcount); /* 416 */ + void (GLAPIENTRYP MultiDrawElementsEXT)(GLenum mode, const GLsizei * count, GLenum type, const GLvoid ** indices, GLsizei primcount); /* 417 */ + void (GLAPIENTRYP BindVertexArrayAPPLE)(GLuint array); /* 418 */ + void (GLAPIENTRYP DeleteVertexArraysAPPLE)(GLsizei n, const GLuint * arrays); /* 419 */ + void (GLAPIENTRYP GenVertexArraysAPPLE)(GLsizei n, GLuint * arrays); /* 420 */ + GLboolean (GLAPIENTRYP IsVertexArrayAPPLE)(GLuint array); /* 421 */ + void (GLAPIENTRYP EGLImageTargetRenderbufferStorageOES)(GLenum target, GLvoid * writeOffset); /* 422 */ + void (GLAPIENTRYP EGLImageTargetTexture2DOES)(GLenum target, GLvoid * writeOffset); /* 423 */ + void (GLAPIENTRYP CompressedTexImage2D)(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const GLvoid * data); /* 424 */ + void (GLAPIENTRYP CompressedTexSubImage2D)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const GLvoid * data); /* 425 */ + void (GLAPIENTRYP SampleCoverage)(GLclampf value, GLboolean invert); /* 426 */ + void (GLAPIENTRYP BindBuffer)(GLenum target, GLuint buffer); /* 427 */ + void (GLAPIENTRYP BufferData)(GLenum target, GLsizeiptr size, const GLvoid * data, GLenum usage); /* 428 */ + void (GLAPIENTRYP BufferSubData)(GLenum target, GLintptr offset, GLsizeiptr size, const GLvoid * data); /* 429 */ + void (GLAPIENTRYP DeleteBuffers)(GLsizei n, const GLuint * buffer); /* 430 */ + void (GLAPIENTRYP GenBuffers)(GLsizei n, GLuint * buffer); /* 431 */ + void (GLAPIENTRYP GetBufferParameteriv)(GLenum target, GLenum pname, GLint * params); /* 432 */ + GLboolean (GLAPIENTRYP IsBuffer)(GLuint buffer); /* 433 */ + void (GLAPIENTRYP AttachShader)(GLuint program, GLuint shader); /* 434 */ + void (GLAPIENTRYP BindAttribLocation)(GLuint program, GLuint index, const GLchar * name); /* 435 */ + void (GLAPIENTRYP BlendEquationSeparate)(GLenum modeRGB, GLenum modeA); /* 436 */ + void (GLAPIENTRYP CompileShader)(GLuint shader); /* 437 */ + GLuint (GLAPIENTRYP CreateProgram)(void); /* 438 */ + GLuint (GLAPIENTRYP CreateShader)(GLenum type); /* 439 */ + void (GLAPIENTRYP DeleteProgram)(GLuint program); /* 440 */ + void (GLAPIENTRYP DeleteShader)(GLuint program); /* 441 */ + void (GLAPIENTRYP DetachShader)(GLuint program, GLuint shader); /* 442 */ + void (GLAPIENTRYP DisableVertexAttribArray)(GLuint index); /* 443 */ + void (GLAPIENTRYP EnableVertexAttribArray)(GLuint index); /* 444 */ + void (GLAPIENTRYP GetActiveAttrib)(GLuint program, GLuint index, GLsizei bufSize, GLsizei * length, GLint * size, GLenum * type, GLchar * name); /* 445 */ + void (GLAPIENTRYP GetActiveUniform)(GLuint program, GLuint index, GLsizei bufSize, GLsizei * length, GLint * size, GLenum * type, GLchar * name); /* 446 */ + void (GLAPIENTRYP GetAttachedShaders)(GLuint program, GLsizei maxCount, GLsizei * count, GLuint * obj); /* 447 */ + GLint (GLAPIENTRYP GetAttribLocation)(GLuint program, const GLchar * name); /* 448 */ + void (GLAPIENTRYP GetProgramInfoLog)(GLuint program, GLsizei bufSize, GLsizei * length, GLchar * infoLog); /* 449 */ + void (GLAPIENTRYP GetProgramiv)(GLuint program, GLenum pname, GLint * params); /* 450 */ + void (GLAPIENTRYP GetShaderInfoLog)(GLuint shader, GLsizei bufSize, GLsizei * length, GLchar * infoLog); /* 451 */ + void (GLAPIENTRYP GetShaderSource)(GLuint shader, GLsizei bufSize, GLsizei * length, GLchar * source); /* 452 */ + void (GLAPIENTRYP GetShaderiv)(GLuint shader, GLenum pname, GLint * params); /* 453 */ + GLint (GLAPIENTRYP GetUniformLocation)(GLuint program, const GLchar * name); /* 454 */ + void (GLAPIENTRYP GetUniformfv)(GLuint program, GLint location, GLfloat * params); /* 455 */ + void (GLAPIENTRYP GetUniformiv)(GLuint program, GLint location, GLint * params); /* 456 */ + void (GLAPIENTRYP GetVertexAttribPointerv)(GLuint index, GLenum pname, GLvoid ** pointer); /* 457 */ + void (GLAPIENTRYP GetVertexAttribfv)(GLuint index, GLenum pname, GLfloat * params); /* 458 */ + void (GLAPIENTRYP GetVertexAttribiv)(GLuint index, GLenum pname, GLint * params); /* 459 */ + GLboolean (GLAPIENTRYP IsProgram)(GLuint program); /* 460 */ + GLboolean (GLAPIENTRYP IsShader)(GLuint shader); /* 461 */ + void (GLAPIENTRYP LinkProgram)(GLuint program); /* 462 */ + void (GLAPIENTRYP ShaderSource)(GLuint shader, GLsizei count, const GLchar ** string, const GLint * length); /* 463 */ + void (GLAPIENTRYP StencilFuncSeparate)(GLenum face, GLenum func, GLint ref, GLuint mask); /* 464 */ + void (GLAPIENTRYP StencilMaskSeparate)(GLenum face, GLuint mask); /* 465 */ + void (GLAPIENTRYP StencilOpSeparate)(GLenum face, GLenum sfail, GLenum zfail, GLenum zpass); /* 466 */ + void (GLAPIENTRYP Uniform1f)(GLint location, GLfloat v0); /* 467 */ + void (GLAPIENTRYP Uniform1fv)(GLint location, GLsizei count, const GLfloat * value); /* 468 */ + void (GLAPIENTRYP Uniform1i)(GLint location, GLint v0); /* 469 */ + void (GLAPIENTRYP Uniform1iv)(GLint location, GLsizei count, const GLint * value); /* 470 */ + void (GLAPIENTRYP Uniform2f)(GLint location, GLfloat v0, GLfloat v1); /* 471 */ + void (GLAPIENTRYP Uniform2fv)(GLint location, GLsizei count, const GLfloat * value); /* 472 */ + void (GLAPIENTRYP Uniform2i)(GLint location, GLint v0, GLint v1); /* 473 */ + void (GLAPIENTRYP Uniform2iv)(GLint location, GLsizei count, const GLint * value); /* 474 */ + void (GLAPIENTRYP Uniform3f)(GLint location, GLfloat v0, GLfloat v1, GLfloat v2); /* 475 */ + void (GLAPIENTRYP Uniform3fv)(GLint location, GLsizei count, const GLfloat * value); /* 476 */ + void (GLAPIENTRYP Uniform3i)(GLint location, GLint v0, GLint v1, GLint v2); /* 477 */ + void (GLAPIENTRYP Uniform3iv)(GLint location, GLsizei count, const GLint * value); /* 478 */ + void (GLAPIENTRYP Uniform4f)(GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3); /* 479 */ + void (GLAPIENTRYP Uniform4fv)(GLint location, GLsizei count, const GLfloat * value); /* 480 */ + void (GLAPIENTRYP Uniform4i)(GLint location, GLint v0, GLint v1, GLint v2, GLint v3); /* 481 */ + void (GLAPIENTRYP Uniform4iv)(GLint location, GLsizei count, const GLint * value); /* 482 */ + void (GLAPIENTRYP UniformMatrix2fv)(GLint location, GLsizei count, GLboolean transpose, const GLfloat * value); /* 483 */ + void (GLAPIENTRYP UniformMatrix3fv)(GLint location, GLsizei count, GLboolean transpose, const GLfloat * value); /* 484 */ + void (GLAPIENTRYP UniformMatrix4fv)(GLint location, GLsizei count, GLboolean transpose, const GLfloat * value); /* 485 */ + void (GLAPIENTRYP UseProgram)(GLuint program); /* 486 */ + void (GLAPIENTRYP ValidateProgram)(GLuint program); /* 487 */ + void (GLAPIENTRYP VertexAttrib1f)(GLuint index, GLfloat x); /* 488 */ + void (GLAPIENTRYP VertexAttrib1fv)(GLuint index, const GLfloat * v); /* 489 */ + void (GLAPIENTRYP VertexAttrib2f)(GLuint index, GLfloat x, GLfloat y); /* 490 */ + void (GLAPIENTRYP VertexAttrib2fv)(GLuint index, const GLfloat * v); /* 491 */ + void (GLAPIENTRYP VertexAttrib3f)(GLuint index, GLfloat x, GLfloat y, GLfloat z); /* 492 */ + void (GLAPIENTRYP VertexAttrib3fv)(GLuint index, const GLfloat * v); /* 493 */ + void (GLAPIENTRYP VertexAttrib4f)(GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w); /* 494 */ + void (GLAPIENTRYP VertexAttrib4fv)(GLuint index, const GLfloat * v); /* 495 */ + void (GLAPIENTRYP VertexAttribPointer)(GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const GLvoid * pointer); /* 496 */ + void (GLAPIENTRYP BlendFuncSeparate)(GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha); /* 497 */ + void (GLAPIENTRYP BindFramebuffer)(GLenum target, GLuint framebuffer); /* 498 */ + void (GLAPIENTRYP BindRenderbuffer)(GLenum target, GLuint renderbuffer); /* 499 */ + GLenum (GLAPIENTRYP CheckFramebufferStatus)(GLenum target); /* 500 */ + void (GLAPIENTRYP ClearDepthf)(GLclampf depth); /* 501 */ + void (GLAPIENTRYP DeleteFramebuffers)(GLsizei n, const GLuint * framebuffers); /* 502 */ + void (GLAPIENTRYP DeleteRenderbuffers)(GLsizei n, const GLuint * renderbuffers); /* 503 */ + void (GLAPIENTRYP DepthRangef)(GLclampf zNear, GLclampf zFar); /* 504 */ + void (GLAPIENTRYP FramebufferRenderbuffer)(GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer); /* 505 */ + void (GLAPIENTRYP FramebufferTexture2D)(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level); /* 506 */ + void (GLAPIENTRYP GenFramebuffers)(GLsizei n, GLuint * framebuffers); /* 507 */ + void (GLAPIENTRYP GenRenderbuffers)(GLsizei n, GLuint * renderbuffers); /* 508 */ + void (GLAPIENTRYP GenerateMipmap)(GLenum target); /* 509 */ + void (GLAPIENTRYP GetFramebufferAttachmentParameteriv)(GLenum target, GLenum attachment, GLenum pname, GLint * params); /* 510 */ + void (GLAPIENTRYP GetRenderbufferParameteriv)(GLenum target, GLenum pname, GLint * params); /* 511 */ + void (GLAPIENTRYP GetShaderPrecisionFormat)(GLenum shadertype, GLenum precisiontype, GLint * range, GLint * precision); /* 512 */ + GLboolean (GLAPIENTRYP IsFramebuffer)(GLuint framebuffer); /* 513 */ + GLboolean (GLAPIENTRYP IsRenderbuffer)(GLuint renderbuffer); /* 514 */ + void (GLAPIENTRYP ReleaseShaderCompiler)(void); /* 515 */ + void (GLAPIENTRYP RenderbufferStorage)(GLenum target, GLenum internalformat, GLsizei width, GLsizei height); /* 516 */ + void (GLAPIENTRYP ShaderBinary)(GLsizei n, const GLuint * shaders, GLenum binaryformat, const GLvoid * binary, GLsizei length); /* 517 */ +}; + +#endif /* !defined( _GLAPI_TABLE_H_ ) */ diff --git a/src/mapi/es2api/glapi/glapitemp.h b/src/mapi/es2api/glapi/glapitemp.h new file mode 100644 index 00000000000..7ec8a524b88 --- /dev/null +++ b/src/mapi/es2api/glapi/glapitemp.h @@ -0,0 +1,4170 @@ +/* DO NOT EDIT - This file generated automatically by gl_apitemp.py (from Mesa) script */ + +/* + * Copyright (C) 1999-2001 Brian Paul All Rights Reserved. + * (C) Copyright IBM Corporation 2004 + * All Rights Reserved. + * + * Permission is hereby granted, free of charge, to any person obtaining a + * copy of this software and associated documentation files (the "Software"), + * to deal in the Software without restriction, including without limitation + * the rights to use, copy, modify, merge, publish, distribute, sub license, + * and/or sell copies of the Software, and to permit persons to whom the + * Software is furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice (including the next + * paragraph) shall be included in all copies or substantial portions of the + * Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL + * BRIAN PAUL, IBM, + * AND/OR THEIR SUPPLIERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, + * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF + * OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE + * SOFTWARE. + */ + + +# if defined(__GNUC__) || (defined(__SUNPRO_C) && (__SUNPRO_C >= 0x590)) && defined(__ELF__) +# define HIDDEN __attribute__((visibility("hidden"))) +# else +# define HIDDEN +# endif + +/* + * This file is a template which generates the OpenGL API entry point + * functions. It should be included by a .c file which first defines + * the following macros: + * KEYWORD1 - usually nothing, but might be __declspec(dllexport) on Win32 + * KEYWORD2 - usually nothing, but might be __stdcall on Win32 + * NAME(n) - builds the final function name (usually add "gl" prefix) + * DISPATCH(func, args, msg) - code to do dispatch of named function. + * msg is a printf-style debug message. + * RETURN_DISPATCH(func, args, msg) - code to do dispatch with a return value + * + * Here is an example which generates the usual OpenGL functions: + * #define KEYWORD1 + * #define KEYWORD2 + * #define NAME(func) gl##func + * #define DISPATCH(func, args, msg) \ + * struct _glapi_table *dispatch = CurrentDispatch; \ + * (*dispatch->func) args + * #define RETURN DISPATCH(func, args, msg) \ + * struct _glapi_table *dispatch = CurrentDispatch; \ + * return (*dispatch->func) args + * + */ + + +#if defined( NAME ) +#ifndef KEYWORD1 +#define KEYWORD1 +#endif + +#ifndef KEYWORD1_ALT +#define KEYWORD1_ALT HIDDEN +#endif + +#ifndef KEYWORD2 +#define KEYWORD2 +#endif + +#ifndef DISPATCH +#error DISPATCH must be defined +#endif + +#ifndef RETURN_DISPATCH +#error RETURN_DISPATCH must be defined +#endif + + +#ifndef _GLAPI_SKIP_NORMAL_ENTRY_POINTS + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_0)(GLuint list, GLenum mode); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_0)(GLuint list, GLenum mode) +{ + DISPATCH(NewList, (list, mode), (F, "glNewList(%d, 0x%x);\n", list, mode)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_1)(void); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_1)(void) +{ + DISPATCH(EndList, (), (F, "glEndList();\n")); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_2)(GLuint list); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_2)(GLuint list) +{ + DISPATCH(CallList, (list), (F, "glCallList(%d);\n", list)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_3)(GLsizei n, GLenum type, const GLvoid * lists); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_3)(GLsizei n, GLenum type, const GLvoid * lists) +{ + DISPATCH(CallLists, (n, type, lists), (F, "glCallLists(%d, 0x%x, %p);\n", n, type, (const void *) lists)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_4)(GLuint list, GLsizei range); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_4)(GLuint list, GLsizei range) +{ + DISPATCH(DeleteLists, (list, range), (F, "glDeleteLists(%d, %d);\n", list, range)); +} + +KEYWORD1_ALT GLuint KEYWORD2 NAME(_dispatch_stub_5)(GLsizei range); + +KEYWORD1_ALT GLuint KEYWORD2 NAME(_dispatch_stub_5)(GLsizei range) +{ + RETURN_DISPATCH(GenLists, (range), (F, "glGenLists(%d);\n", range)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_6)(GLuint base); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_6)(GLuint base) +{ + DISPATCH(ListBase, (base), (F, "glListBase(%d);\n", base)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_7)(GLenum mode); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_7)(GLenum mode) +{ + DISPATCH(Begin, (mode), (F, "glBegin(0x%x);\n", mode)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_8)(GLsizei width, GLsizei height, GLfloat xorig, GLfloat yorig, GLfloat xmove, GLfloat ymove, const GLubyte * bitmap); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_8)(GLsizei width, GLsizei height, GLfloat xorig, GLfloat yorig, GLfloat xmove, GLfloat ymove, const GLubyte * bitmap) +{ + DISPATCH(Bitmap, (width, height, xorig, yorig, xmove, ymove, bitmap), (F, "glBitmap(%d, %d, %f, %f, %f, %f, %p);\n", width, height, xorig, yorig, xmove, ymove, (const void *) bitmap)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_9)(GLbyte red, GLbyte green, GLbyte blue); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_9)(GLbyte red, GLbyte green, GLbyte blue) +{ + DISPATCH(Color3b, (red, green, blue), (F, "glColor3b(%d, %d, %d);\n", red, green, blue)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_10)(const GLbyte * v); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_10)(const GLbyte * v) +{ + DISPATCH(Color3bv, (v), (F, "glColor3bv(%p);\n", (const void *) v)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_11)(GLdouble red, GLdouble green, GLdouble blue); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_11)(GLdouble red, GLdouble green, GLdouble blue) +{ + DISPATCH(Color3d, (red, green, blue), (F, "glColor3d(%f, %f, %f);\n", red, green, blue)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_12)(const GLdouble * v); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_12)(const GLdouble * v) +{ + DISPATCH(Color3dv, (v), (F, "glColor3dv(%p);\n", (const void *) v)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_13)(GLfloat red, GLfloat green, GLfloat blue); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_13)(GLfloat red, GLfloat green, GLfloat blue) +{ + DISPATCH(Color3f, (red, green, blue), (F, "glColor3f(%f, %f, %f);\n", red, green, blue)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_14)(const GLfloat * v); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_14)(const GLfloat * v) +{ + DISPATCH(Color3fv, (v), (F, "glColor3fv(%p);\n", (const void *) v)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_15)(GLint red, GLint green, GLint blue); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_15)(GLint red, GLint green, GLint blue) +{ + DISPATCH(Color3i, (red, green, blue), (F, "glColor3i(%d, %d, %d);\n", red, green, blue)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_16)(const GLint * v); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_16)(const GLint * v) +{ + DISPATCH(Color3iv, (v), (F, "glColor3iv(%p);\n", (const void *) v)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_17)(GLshort red, GLshort green, GLshort blue); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_17)(GLshort red, GLshort green, GLshort blue) +{ + DISPATCH(Color3s, (red, green, blue), (F, "glColor3s(%d, %d, %d);\n", red, green, blue)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_18)(const GLshort * v); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_18)(const GLshort * v) +{ + DISPATCH(Color3sv, (v), (F, "glColor3sv(%p);\n", (const void *) v)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_19)(GLubyte red, GLubyte green, GLubyte blue); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_19)(GLubyte red, GLubyte green, GLubyte blue) +{ + DISPATCH(Color3ub, (red, green, blue), (F, "glColor3ub(%d, %d, %d);\n", red, green, blue)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_20)(const GLubyte * v); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_20)(const GLubyte * v) +{ + DISPATCH(Color3ubv, (v), (F, "glColor3ubv(%p);\n", (const void *) v)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_21)(GLuint red, GLuint green, GLuint blue); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_21)(GLuint red, GLuint green, GLuint blue) +{ + DISPATCH(Color3ui, (red, green, blue), (F, "glColor3ui(%d, %d, %d);\n", red, green, blue)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_22)(const GLuint * v); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_22)(const GLuint * v) +{ + DISPATCH(Color3uiv, (v), (F, "glColor3uiv(%p);\n", (const void *) v)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_23)(GLushort red, GLushort green, GLushort blue); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_23)(GLushort red, GLushort green, GLushort blue) +{ + DISPATCH(Color3us, (red, green, blue), (F, "glColor3us(%d, %d, %d);\n", red, green, blue)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_24)(const GLushort * v); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_24)(const GLushort * v) +{ + DISPATCH(Color3usv, (v), (F, "glColor3usv(%p);\n", (const void *) v)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_25)(GLbyte red, GLbyte green, GLbyte blue, GLbyte alpha); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_25)(GLbyte red, GLbyte green, GLbyte blue, GLbyte alpha) +{ + DISPATCH(Color4b, (red, green, blue, alpha), (F, "glColor4b(%d, %d, %d, %d);\n", red, green, blue, alpha)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_26)(const GLbyte * v); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_26)(const GLbyte * v) +{ + DISPATCH(Color4bv, (v), (F, "glColor4bv(%p);\n", (const void *) v)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_27)(GLdouble red, GLdouble green, GLdouble blue, GLdouble alpha); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_27)(GLdouble red, GLdouble green, GLdouble blue, GLdouble alpha) +{ + DISPATCH(Color4d, (red, green, blue, alpha), (F, "glColor4d(%f, %f, %f, %f);\n", red, green, blue, alpha)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_28)(const GLdouble * v); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_28)(const GLdouble * v) +{ + DISPATCH(Color4dv, (v), (F, "glColor4dv(%p);\n", (const void *) v)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_29)(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_29)(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha) +{ + DISPATCH(Color4f, (red, green, blue, alpha), (F, "glColor4f(%f, %f, %f, %f);\n", red, green, blue, alpha)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_30)(const GLfloat * v); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_30)(const GLfloat * v) +{ + DISPATCH(Color4fv, (v), (F, "glColor4fv(%p);\n", (const void *) v)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_31)(GLint red, GLint green, GLint blue, GLint alpha); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_31)(GLint red, GLint green, GLint blue, GLint alpha) +{ + DISPATCH(Color4i, (red, green, blue, alpha), (F, "glColor4i(%d, %d, %d, %d);\n", red, green, blue, alpha)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_32)(const GLint * v); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_32)(const GLint * v) +{ + DISPATCH(Color4iv, (v), (F, "glColor4iv(%p);\n", (const void *) v)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_33)(GLshort red, GLshort green, GLshort blue, GLshort alpha); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_33)(GLshort red, GLshort green, GLshort blue, GLshort alpha) +{ + DISPATCH(Color4s, (red, green, blue, alpha), (F, "glColor4s(%d, %d, %d, %d);\n", red, green, blue, alpha)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_34)(const GLshort * v); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_34)(const GLshort * v) +{ + DISPATCH(Color4sv, (v), (F, "glColor4sv(%p);\n", (const void *) v)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_35)(GLubyte red, GLubyte green, GLubyte blue, GLubyte alpha); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_35)(GLubyte red, GLubyte green, GLubyte blue, GLubyte alpha) +{ + DISPATCH(Color4ub, (red, green, blue, alpha), (F, "glColor4ub(%d, %d, %d, %d);\n", red, green, blue, alpha)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_36)(const GLubyte * v); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_36)(const GLubyte * v) +{ + DISPATCH(Color4ubv, (v), (F, "glColor4ubv(%p);\n", (const void *) v)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_37)(GLuint red, GLuint green, GLuint blue, GLuint alpha); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_37)(GLuint red, GLuint green, GLuint blue, GLuint alpha) +{ + DISPATCH(Color4ui, (red, green, blue, alpha), (F, "glColor4ui(%d, %d, %d, %d);\n", red, green, blue, alpha)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_38)(const GLuint * v); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_38)(const GLuint * v) +{ + DISPATCH(Color4uiv, (v), (F, "glColor4uiv(%p);\n", (const void *) v)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_39)(GLushort red, GLushort green, GLushort blue, GLushort alpha); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_39)(GLushort red, GLushort green, GLushort blue, GLushort alpha) +{ + DISPATCH(Color4us, (red, green, blue, alpha), (F, "glColor4us(%d, %d, %d, %d);\n", red, green, blue, alpha)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_40)(const GLushort * v); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_40)(const GLushort * v) +{ + DISPATCH(Color4usv, (v), (F, "glColor4usv(%p);\n", (const void *) v)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_41)(GLboolean flag); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_41)(GLboolean flag) +{ + DISPATCH(EdgeFlag, (flag), (F, "glEdgeFlag(%d);\n", flag)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_42)(const GLboolean * flag); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_42)(const GLboolean * flag) +{ + DISPATCH(EdgeFlagv, (flag), (F, "glEdgeFlagv(%p);\n", (const void *) flag)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_43)(void); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_43)(void) +{ + DISPATCH(End, (), (F, "glEnd();\n")); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_44)(GLdouble c); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_44)(GLdouble c) +{ + DISPATCH(Indexd, (c), (F, "glIndexd(%f);\n", c)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_45)(const GLdouble * c); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_45)(const GLdouble * c) +{ + DISPATCH(Indexdv, (c), (F, "glIndexdv(%p);\n", (const void *) c)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_46)(GLfloat c); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_46)(GLfloat c) +{ + DISPATCH(Indexf, (c), (F, "glIndexf(%f);\n", c)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_47)(const GLfloat * c); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_47)(const GLfloat * c) +{ + DISPATCH(Indexfv, (c), (F, "glIndexfv(%p);\n", (const void *) c)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_48)(GLint c); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_48)(GLint c) +{ + DISPATCH(Indexi, (c), (F, "glIndexi(%d);\n", c)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_49)(const GLint * c); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_49)(const GLint * c) +{ + DISPATCH(Indexiv, (c), (F, "glIndexiv(%p);\n", (const void *) c)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_50)(GLshort c); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_50)(GLshort c) +{ + DISPATCH(Indexs, (c), (F, "glIndexs(%d);\n", c)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_51)(const GLshort * c); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_51)(const GLshort * c) +{ + DISPATCH(Indexsv, (c), (F, "glIndexsv(%p);\n", (const void *) c)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_52)(GLbyte nx, GLbyte ny, GLbyte nz); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_52)(GLbyte nx, GLbyte ny, GLbyte nz) +{ + DISPATCH(Normal3b, (nx, ny, nz), (F, "glNormal3b(%d, %d, %d);\n", nx, ny, nz)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_53)(const GLbyte * v); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_53)(const GLbyte * v) +{ + DISPATCH(Normal3bv, (v), (F, "glNormal3bv(%p);\n", (const void *) v)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_54)(GLdouble nx, GLdouble ny, GLdouble nz); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_54)(GLdouble nx, GLdouble ny, GLdouble nz) +{ + DISPATCH(Normal3d, (nx, ny, nz), (F, "glNormal3d(%f, %f, %f);\n", nx, ny, nz)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_55)(const GLdouble * v); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_55)(const GLdouble * v) +{ + DISPATCH(Normal3dv, (v), (F, "glNormal3dv(%p);\n", (const void *) v)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_56)(GLfloat nx, GLfloat ny, GLfloat nz); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_56)(GLfloat nx, GLfloat ny, GLfloat nz) +{ + DISPATCH(Normal3f, (nx, ny, nz), (F, "glNormal3f(%f, %f, %f);\n", nx, ny, nz)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_57)(const GLfloat * v); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_57)(const GLfloat * v) +{ + DISPATCH(Normal3fv, (v), (F, "glNormal3fv(%p);\n", (const void *) v)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_58)(GLint nx, GLint ny, GLint nz); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_58)(GLint nx, GLint ny, GLint nz) +{ + DISPATCH(Normal3i, (nx, ny, nz), (F, "glNormal3i(%d, %d, %d);\n", nx, ny, nz)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_59)(const GLint * v); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_59)(const GLint * v) +{ + DISPATCH(Normal3iv, (v), (F, "glNormal3iv(%p);\n", (const void *) v)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_60)(GLshort nx, GLshort ny, GLshort nz); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_60)(GLshort nx, GLshort ny, GLshort nz) +{ + DISPATCH(Normal3s, (nx, ny, nz), (F, "glNormal3s(%d, %d, %d);\n", nx, ny, nz)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_61)(const GLshort * v); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_61)(const GLshort * v) +{ + DISPATCH(Normal3sv, (v), (F, "glNormal3sv(%p);\n", (const void *) v)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_62)(GLdouble x, GLdouble y); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_62)(GLdouble x, GLdouble y) +{ + DISPATCH(RasterPos2d, (x, y), (F, "glRasterPos2d(%f, %f);\n", x, y)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_63)(const GLdouble * v); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_63)(const GLdouble * v) +{ + DISPATCH(RasterPos2dv, (v), (F, "glRasterPos2dv(%p);\n", (const void *) v)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_64)(GLfloat x, GLfloat y); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_64)(GLfloat x, GLfloat y) +{ + DISPATCH(RasterPos2f, (x, y), (F, "glRasterPos2f(%f, %f);\n", x, y)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_65)(const GLfloat * v); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_65)(const GLfloat * v) +{ + DISPATCH(RasterPos2fv, (v), (F, "glRasterPos2fv(%p);\n", (const void *) v)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_66)(GLint x, GLint y); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_66)(GLint x, GLint y) +{ + DISPATCH(RasterPos2i, (x, y), (F, "glRasterPos2i(%d, %d);\n", x, y)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_67)(const GLint * v); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_67)(const GLint * v) +{ + DISPATCH(RasterPos2iv, (v), (F, "glRasterPos2iv(%p);\n", (const void *) v)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_68)(GLshort x, GLshort y); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_68)(GLshort x, GLshort y) +{ + DISPATCH(RasterPos2s, (x, y), (F, "glRasterPos2s(%d, %d);\n", x, y)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_69)(const GLshort * v); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_69)(const GLshort * v) +{ + DISPATCH(RasterPos2sv, (v), (F, "glRasterPos2sv(%p);\n", (const void *) v)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_70)(GLdouble x, GLdouble y, GLdouble z); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_70)(GLdouble x, GLdouble y, GLdouble z) +{ + DISPATCH(RasterPos3d, (x, y, z), (F, "glRasterPos3d(%f, %f, %f);\n", x, y, z)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_71)(const GLdouble * v); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_71)(const GLdouble * v) +{ + DISPATCH(RasterPos3dv, (v), (F, "glRasterPos3dv(%p);\n", (const void *) v)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_72)(GLfloat x, GLfloat y, GLfloat z); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_72)(GLfloat x, GLfloat y, GLfloat z) +{ + DISPATCH(RasterPos3f, (x, y, z), (F, "glRasterPos3f(%f, %f, %f);\n", x, y, z)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_73)(const GLfloat * v); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_73)(const GLfloat * v) +{ + DISPATCH(RasterPos3fv, (v), (F, "glRasterPos3fv(%p);\n", (const void *) v)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_74)(GLint x, GLint y, GLint z); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_74)(GLint x, GLint y, GLint z) +{ + DISPATCH(RasterPos3i, (x, y, z), (F, "glRasterPos3i(%d, %d, %d);\n", x, y, z)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_75)(const GLint * v); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_75)(const GLint * v) +{ + DISPATCH(RasterPos3iv, (v), (F, "glRasterPos3iv(%p);\n", (const void *) v)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_76)(GLshort x, GLshort y, GLshort z); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_76)(GLshort x, GLshort y, GLshort z) +{ + DISPATCH(RasterPos3s, (x, y, z), (F, "glRasterPos3s(%d, %d, %d);\n", x, y, z)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_77)(const GLshort * v); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_77)(const GLshort * v) +{ + DISPATCH(RasterPos3sv, (v), (F, "glRasterPos3sv(%p);\n", (const void *) v)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_78)(GLdouble x, GLdouble y, GLdouble z, GLdouble w); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_78)(GLdouble x, GLdouble y, GLdouble z, GLdouble w) +{ + DISPATCH(RasterPos4d, (x, y, z, w), (F, "glRasterPos4d(%f, %f, %f, %f);\n", x, y, z, w)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_79)(const GLdouble * v); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_79)(const GLdouble * v) +{ + DISPATCH(RasterPos4dv, (v), (F, "glRasterPos4dv(%p);\n", (const void *) v)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_80)(GLfloat x, GLfloat y, GLfloat z, GLfloat w); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_80)(GLfloat x, GLfloat y, GLfloat z, GLfloat w) +{ + DISPATCH(RasterPos4f, (x, y, z, w), (F, "glRasterPos4f(%f, %f, %f, %f);\n", x, y, z, w)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_81)(const GLfloat * v); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_81)(const GLfloat * v) +{ + DISPATCH(RasterPos4fv, (v), (F, "glRasterPos4fv(%p);\n", (const void *) v)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_82)(GLint x, GLint y, GLint z, GLint w); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_82)(GLint x, GLint y, GLint z, GLint w) +{ + DISPATCH(RasterPos4i, (x, y, z, w), (F, "glRasterPos4i(%d, %d, %d, %d);\n", x, y, z, w)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_83)(const GLint * v); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_83)(const GLint * v) +{ + DISPATCH(RasterPos4iv, (v), (F, "glRasterPos4iv(%p);\n", (const void *) v)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_84)(GLshort x, GLshort y, GLshort z, GLshort w); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_84)(GLshort x, GLshort y, GLshort z, GLshort w) +{ + DISPATCH(RasterPos4s, (x, y, z, w), (F, "glRasterPos4s(%d, %d, %d, %d);\n", x, y, z, w)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_85)(const GLshort * v); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_85)(const GLshort * v) +{ + DISPATCH(RasterPos4sv, (v), (F, "glRasterPos4sv(%p);\n", (const void *) v)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_86)(GLdouble x1, GLdouble y1, GLdouble x2, GLdouble y2); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_86)(GLdouble x1, GLdouble y1, GLdouble x2, GLdouble y2) +{ + DISPATCH(Rectd, (x1, y1, x2, y2), (F, "glRectd(%f, %f, %f, %f);\n", x1, y1, x2, y2)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_87)(const GLdouble * v1, const GLdouble * v2); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_87)(const GLdouble * v1, const GLdouble * v2) +{ + DISPATCH(Rectdv, (v1, v2), (F, "glRectdv(%p, %p);\n", (const void *) v1, (const void *) v2)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_88)(GLfloat x1, GLfloat y1, GLfloat x2, GLfloat y2); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_88)(GLfloat x1, GLfloat y1, GLfloat x2, GLfloat y2) +{ + DISPATCH(Rectf, (x1, y1, x2, y2), (F, "glRectf(%f, %f, %f, %f);\n", x1, y1, x2, y2)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_89)(const GLfloat * v1, const GLfloat * v2); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_89)(const GLfloat * v1, const GLfloat * v2) +{ + DISPATCH(Rectfv, (v1, v2), (F, "glRectfv(%p, %p);\n", (const void *) v1, (const void *) v2)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_90)(GLint x1, GLint y1, GLint x2, GLint y2); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_90)(GLint x1, GLint y1, GLint x2, GLint y2) +{ + DISPATCH(Recti, (x1, y1, x2, y2), (F, "glRecti(%d, %d, %d, %d);\n", x1, y1, x2, y2)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_91)(const GLint * v1, const GLint * v2); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_91)(const GLint * v1, const GLint * v2) +{ + DISPATCH(Rectiv, (v1, v2), (F, "glRectiv(%p, %p);\n", (const void *) v1, (const void *) v2)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_92)(GLshort x1, GLshort y1, GLshort x2, GLshort y2); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_92)(GLshort x1, GLshort y1, GLshort x2, GLshort y2) +{ + DISPATCH(Rects, (x1, y1, x2, y2), (F, "glRects(%d, %d, %d, %d);\n", x1, y1, x2, y2)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_93)(const GLshort * v1, const GLshort * v2); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_93)(const GLshort * v1, const GLshort * v2) +{ + DISPATCH(Rectsv, (v1, v2), (F, "glRectsv(%p, %p);\n", (const void *) v1, (const void *) v2)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_94)(GLdouble s); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_94)(GLdouble s) +{ + DISPATCH(TexCoord1d, (s), (F, "glTexCoord1d(%f);\n", s)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_95)(const GLdouble * v); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_95)(const GLdouble * v) +{ + DISPATCH(TexCoord1dv, (v), (F, "glTexCoord1dv(%p);\n", (const void *) v)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_96)(GLfloat s); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_96)(GLfloat s) +{ + DISPATCH(TexCoord1f, (s), (F, "glTexCoord1f(%f);\n", s)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_97)(const GLfloat * v); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_97)(const GLfloat * v) +{ + DISPATCH(TexCoord1fv, (v), (F, "glTexCoord1fv(%p);\n", (const void *) v)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_98)(GLint s); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_98)(GLint s) +{ + DISPATCH(TexCoord1i, (s), (F, "glTexCoord1i(%d);\n", s)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_99)(const GLint * v); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_99)(const GLint * v) +{ + DISPATCH(TexCoord1iv, (v), (F, "glTexCoord1iv(%p);\n", (const void *) v)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_100)(GLshort s); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_100)(GLshort s) +{ + DISPATCH(TexCoord1s, (s), (F, "glTexCoord1s(%d);\n", s)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_101)(const GLshort * v); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_101)(const GLshort * v) +{ + DISPATCH(TexCoord1sv, (v), (F, "glTexCoord1sv(%p);\n", (const void *) v)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_102)(GLdouble s, GLdouble t); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_102)(GLdouble s, GLdouble t) +{ + DISPATCH(TexCoord2d, (s, t), (F, "glTexCoord2d(%f, %f);\n", s, t)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_103)(const GLdouble * v); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_103)(const GLdouble * v) +{ + DISPATCH(TexCoord2dv, (v), (F, "glTexCoord2dv(%p);\n", (const void *) v)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_104)(GLfloat s, GLfloat t); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_104)(GLfloat s, GLfloat t) +{ + DISPATCH(TexCoord2f, (s, t), (F, "glTexCoord2f(%f, %f);\n", s, t)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_105)(const GLfloat * v); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_105)(const GLfloat * v) +{ + DISPATCH(TexCoord2fv, (v), (F, "glTexCoord2fv(%p);\n", (const void *) v)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_106)(GLint s, GLint t); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_106)(GLint s, GLint t) +{ + DISPATCH(TexCoord2i, (s, t), (F, "glTexCoord2i(%d, %d);\n", s, t)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_107)(const GLint * v); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_107)(const GLint * v) +{ + DISPATCH(TexCoord2iv, (v), (F, "glTexCoord2iv(%p);\n", (const void *) v)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_108)(GLshort s, GLshort t); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_108)(GLshort s, GLshort t) +{ + DISPATCH(TexCoord2s, (s, t), (F, "glTexCoord2s(%d, %d);\n", s, t)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_109)(const GLshort * v); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_109)(const GLshort * v) +{ + DISPATCH(TexCoord2sv, (v), (F, "glTexCoord2sv(%p);\n", (const void *) v)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_110)(GLdouble s, GLdouble t, GLdouble r); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_110)(GLdouble s, GLdouble t, GLdouble r) +{ + DISPATCH(TexCoord3d, (s, t, r), (F, "glTexCoord3d(%f, %f, %f);\n", s, t, r)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_111)(const GLdouble * v); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_111)(const GLdouble * v) +{ + DISPATCH(TexCoord3dv, (v), (F, "glTexCoord3dv(%p);\n", (const void *) v)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_112)(GLfloat s, GLfloat t, GLfloat r); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_112)(GLfloat s, GLfloat t, GLfloat r) +{ + DISPATCH(TexCoord3f, (s, t, r), (F, "glTexCoord3f(%f, %f, %f);\n", s, t, r)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_113)(const GLfloat * v); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_113)(const GLfloat * v) +{ + DISPATCH(TexCoord3fv, (v), (F, "glTexCoord3fv(%p);\n", (const void *) v)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_114)(GLint s, GLint t, GLint r); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_114)(GLint s, GLint t, GLint r) +{ + DISPATCH(TexCoord3i, (s, t, r), (F, "glTexCoord3i(%d, %d, %d);\n", s, t, r)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_115)(const GLint * v); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_115)(const GLint * v) +{ + DISPATCH(TexCoord3iv, (v), (F, "glTexCoord3iv(%p);\n", (const void *) v)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_116)(GLshort s, GLshort t, GLshort r); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_116)(GLshort s, GLshort t, GLshort r) +{ + DISPATCH(TexCoord3s, (s, t, r), (F, "glTexCoord3s(%d, %d, %d);\n", s, t, r)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_117)(const GLshort * v); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_117)(const GLshort * v) +{ + DISPATCH(TexCoord3sv, (v), (F, "glTexCoord3sv(%p);\n", (const void *) v)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_118)(GLdouble s, GLdouble t, GLdouble r, GLdouble q); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_118)(GLdouble s, GLdouble t, GLdouble r, GLdouble q) +{ + DISPATCH(TexCoord4d, (s, t, r, q), (F, "glTexCoord4d(%f, %f, %f, %f);\n", s, t, r, q)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_119)(const GLdouble * v); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_119)(const GLdouble * v) +{ + DISPATCH(TexCoord4dv, (v), (F, "glTexCoord4dv(%p);\n", (const void *) v)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_120)(GLfloat s, GLfloat t, GLfloat r, GLfloat q); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_120)(GLfloat s, GLfloat t, GLfloat r, GLfloat q) +{ + DISPATCH(TexCoord4f, (s, t, r, q), (F, "glTexCoord4f(%f, %f, %f, %f);\n", s, t, r, q)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_121)(const GLfloat * v); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_121)(const GLfloat * v) +{ + DISPATCH(TexCoord4fv, (v), (F, "glTexCoord4fv(%p);\n", (const void *) v)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_122)(GLint s, GLint t, GLint r, GLint q); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_122)(GLint s, GLint t, GLint r, GLint q) +{ + DISPATCH(TexCoord4i, (s, t, r, q), (F, "glTexCoord4i(%d, %d, %d, %d);\n", s, t, r, q)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_123)(const GLint * v); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_123)(const GLint * v) +{ + DISPATCH(TexCoord4iv, (v), (F, "glTexCoord4iv(%p);\n", (const void *) v)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_124)(GLshort s, GLshort t, GLshort r, GLshort q); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_124)(GLshort s, GLshort t, GLshort r, GLshort q) +{ + DISPATCH(TexCoord4s, (s, t, r, q), (F, "glTexCoord4s(%d, %d, %d, %d);\n", s, t, r, q)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_125)(const GLshort * v); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_125)(const GLshort * v) +{ + DISPATCH(TexCoord4sv, (v), (F, "glTexCoord4sv(%p);\n", (const void *) v)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_126)(GLdouble x, GLdouble y); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_126)(GLdouble x, GLdouble y) +{ + DISPATCH(Vertex2d, (x, y), (F, "glVertex2d(%f, %f);\n", x, y)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_127)(const GLdouble * v); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_127)(const GLdouble * v) +{ + DISPATCH(Vertex2dv, (v), (F, "glVertex2dv(%p);\n", (const void *) v)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_128)(GLfloat x, GLfloat y); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_128)(GLfloat x, GLfloat y) +{ + DISPATCH(Vertex2f, (x, y), (F, "glVertex2f(%f, %f);\n", x, y)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_129)(const GLfloat * v); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_129)(const GLfloat * v) +{ + DISPATCH(Vertex2fv, (v), (F, "glVertex2fv(%p);\n", (const void *) v)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_130)(GLint x, GLint y); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_130)(GLint x, GLint y) +{ + DISPATCH(Vertex2i, (x, y), (F, "glVertex2i(%d, %d);\n", x, y)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_131)(const GLint * v); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_131)(const GLint * v) +{ + DISPATCH(Vertex2iv, (v), (F, "glVertex2iv(%p);\n", (const void *) v)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_132)(GLshort x, GLshort y); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_132)(GLshort x, GLshort y) +{ + DISPATCH(Vertex2s, (x, y), (F, "glVertex2s(%d, %d);\n", x, y)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_133)(const GLshort * v); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_133)(const GLshort * v) +{ + DISPATCH(Vertex2sv, (v), (F, "glVertex2sv(%p);\n", (const void *) v)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_134)(GLdouble x, GLdouble y, GLdouble z); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_134)(GLdouble x, GLdouble y, GLdouble z) +{ + DISPATCH(Vertex3d, (x, y, z), (F, "glVertex3d(%f, %f, %f);\n", x, y, z)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_135)(const GLdouble * v); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_135)(const GLdouble * v) +{ + DISPATCH(Vertex3dv, (v), (F, "glVertex3dv(%p);\n", (const void *) v)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_136)(GLfloat x, GLfloat y, GLfloat z); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_136)(GLfloat x, GLfloat y, GLfloat z) +{ + DISPATCH(Vertex3f, (x, y, z), (F, "glVertex3f(%f, %f, %f);\n", x, y, z)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_137)(const GLfloat * v); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_137)(const GLfloat * v) +{ + DISPATCH(Vertex3fv, (v), (F, "glVertex3fv(%p);\n", (const void *) v)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_138)(GLint x, GLint y, GLint z); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_138)(GLint x, GLint y, GLint z) +{ + DISPATCH(Vertex3i, (x, y, z), (F, "glVertex3i(%d, %d, %d);\n", x, y, z)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_139)(const GLint * v); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_139)(const GLint * v) +{ + DISPATCH(Vertex3iv, (v), (F, "glVertex3iv(%p);\n", (const void *) v)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_140)(GLshort x, GLshort y, GLshort z); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_140)(GLshort x, GLshort y, GLshort z) +{ + DISPATCH(Vertex3s, (x, y, z), (F, "glVertex3s(%d, %d, %d);\n", x, y, z)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_141)(const GLshort * v); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_141)(const GLshort * v) +{ + DISPATCH(Vertex3sv, (v), (F, "glVertex3sv(%p);\n", (const void *) v)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_142)(GLdouble x, GLdouble y, GLdouble z, GLdouble w); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_142)(GLdouble x, GLdouble y, GLdouble z, GLdouble w) +{ + DISPATCH(Vertex4d, (x, y, z, w), (F, "glVertex4d(%f, %f, %f, %f);\n", x, y, z, w)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_143)(const GLdouble * v); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_143)(const GLdouble * v) +{ + DISPATCH(Vertex4dv, (v), (F, "glVertex4dv(%p);\n", (const void *) v)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_144)(GLfloat x, GLfloat y, GLfloat z, GLfloat w); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_144)(GLfloat x, GLfloat y, GLfloat z, GLfloat w) +{ + DISPATCH(Vertex4f, (x, y, z, w), (F, "glVertex4f(%f, %f, %f, %f);\n", x, y, z, w)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_145)(const GLfloat * v); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_145)(const GLfloat * v) +{ + DISPATCH(Vertex4fv, (v), (F, "glVertex4fv(%p);\n", (const void *) v)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_146)(GLint x, GLint y, GLint z, GLint w); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_146)(GLint x, GLint y, GLint z, GLint w) +{ + DISPATCH(Vertex4i, (x, y, z, w), (F, "glVertex4i(%d, %d, %d, %d);\n", x, y, z, w)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_147)(const GLint * v); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_147)(const GLint * v) +{ + DISPATCH(Vertex4iv, (v), (F, "glVertex4iv(%p);\n", (const void *) v)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_148)(GLshort x, GLshort y, GLshort z, GLshort w); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_148)(GLshort x, GLshort y, GLshort z, GLshort w) +{ + DISPATCH(Vertex4s, (x, y, z, w), (F, "glVertex4s(%d, %d, %d, %d);\n", x, y, z, w)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_149)(const GLshort * v); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_149)(const GLshort * v) +{ + DISPATCH(Vertex4sv, (v), (F, "glVertex4sv(%p);\n", (const void *) v)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_150)(GLenum plane, const GLdouble * equation); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_150)(GLenum plane, const GLdouble * equation) +{ + DISPATCH(ClipPlane, (plane, equation), (F, "glClipPlane(0x%x, %p);\n", plane, (const void *) equation)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_151)(GLenum face, GLenum mode); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_151)(GLenum face, GLenum mode) +{ + DISPATCH(ColorMaterial, (face, mode), (F, "glColorMaterial(0x%x, 0x%x);\n", face, mode)); +} + +KEYWORD1 void KEYWORD2 NAME(CullFace)(GLenum mode) +{ + DISPATCH(CullFace, (mode), (F, "glCullFace(0x%x);\n", mode)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_153)(GLenum pname, GLfloat param); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_153)(GLenum pname, GLfloat param) +{ + DISPATCH(Fogf, (pname, param), (F, "glFogf(0x%x, %f);\n", pname, param)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_154)(GLenum pname, const GLfloat * params); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_154)(GLenum pname, const GLfloat * params) +{ + DISPATCH(Fogfv, (pname, params), (F, "glFogfv(0x%x, %p);\n", pname, (const void *) params)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_155)(GLenum pname, GLint param); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_155)(GLenum pname, GLint param) +{ + DISPATCH(Fogi, (pname, param), (F, "glFogi(0x%x, %d);\n", pname, param)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_156)(GLenum pname, const GLint * params); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_156)(GLenum pname, const GLint * params) +{ + DISPATCH(Fogiv, (pname, params), (F, "glFogiv(0x%x, %p);\n", pname, (const void *) params)); +} + +KEYWORD1 void KEYWORD2 NAME(FrontFace)(GLenum mode) +{ + DISPATCH(FrontFace, (mode), (F, "glFrontFace(0x%x);\n", mode)); +} + +KEYWORD1 void KEYWORD2 NAME(Hint)(GLenum target, GLenum mode) +{ + DISPATCH(Hint, (target, mode), (F, "glHint(0x%x, 0x%x);\n", target, mode)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_159)(GLenum light, GLenum pname, GLfloat param); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_159)(GLenum light, GLenum pname, GLfloat param) +{ + DISPATCH(Lightf, (light, pname, param), (F, "glLightf(0x%x, 0x%x, %f);\n", light, pname, param)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_160)(GLenum light, GLenum pname, const GLfloat * params); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_160)(GLenum light, GLenum pname, const GLfloat * params) +{ + DISPATCH(Lightfv, (light, pname, params), (F, "glLightfv(0x%x, 0x%x, %p);\n", light, pname, (const void *) params)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_161)(GLenum light, GLenum pname, GLint param); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_161)(GLenum light, GLenum pname, GLint param) +{ + DISPATCH(Lighti, (light, pname, param), (F, "glLighti(0x%x, 0x%x, %d);\n", light, pname, param)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_162)(GLenum light, GLenum pname, const GLint * params); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_162)(GLenum light, GLenum pname, const GLint * params) +{ + DISPATCH(Lightiv, (light, pname, params), (F, "glLightiv(0x%x, 0x%x, %p);\n", light, pname, (const void *) params)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_163)(GLenum pname, GLfloat param); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_163)(GLenum pname, GLfloat param) +{ + DISPATCH(LightModelf, (pname, param), (F, "glLightModelf(0x%x, %f);\n", pname, param)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_164)(GLenum pname, const GLfloat * params); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_164)(GLenum pname, const GLfloat * params) +{ + DISPATCH(LightModelfv, (pname, params), (F, "glLightModelfv(0x%x, %p);\n", pname, (const void *) params)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_165)(GLenum pname, GLint param); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_165)(GLenum pname, GLint param) +{ + DISPATCH(LightModeli, (pname, param), (F, "glLightModeli(0x%x, %d);\n", pname, param)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_166)(GLenum pname, const GLint * params); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_166)(GLenum pname, const GLint * params) +{ + DISPATCH(LightModeliv, (pname, params), (F, "glLightModeliv(0x%x, %p);\n", pname, (const void *) params)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_167)(GLint factor, GLushort pattern); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_167)(GLint factor, GLushort pattern) +{ + DISPATCH(LineStipple, (factor, pattern), (F, "glLineStipple(%d, %d);\n", factor, pattern)); +} + +KEYWORD1 void KEYWORD2 NAME(LineWidth)(GLfloat width) +{ + DISPATCH(LineWidth, (width), (F, "glLineWidth(%f);\n", width)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_169)(GLenum face, GLenum pname, GLfloat param); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_169)(GLenum face, GLenum pname, GLfloat param) +{ + DISPATCH(Materialf, (face, pname, param), (F, "glMaterialf(0x%x, 0x%x, %f);\n", face, pname, param)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_170)(GLenum face, GLenum pname, const GLfloat * params); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_170)(GLenum face, GLenum pname, const GLfloat * params) +{ + DISPATCH(Materialfv, (face, pname, params), (F, "glMaterialfv(0x%x, 0x%x, %p);\n", face, pname, (const void *) params)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_171)(GLenum face, GLenum pname, GLint param); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_171)(GLenum face, GLenum pname, GLint param) +{ + DISPATCH(Materiali, (face, pname, param), (F, "glMateriali(0x%x, 0x%x, %d);\n", face, pname, param)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_172)(GLenum face, GLenum pname, const GLint * params); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_172)(GLenum face, GLenum pname, const GLint * params) +{ + DISPATCH(Materialiv, (face, pname, params), (F, "glMaterialiv(0x%x, 0x%x, %p);\n", face, pname, (const void *) params)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_173)(GLfloat size); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_173)(GLfloat size) +{ + DISPATCH(PointSize, (size), (F, "glPointSize(%f);\n", size)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_174)(GLenum face, GLenum mode); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_174)(GLenum face, GLenum mode) +{ + DISPATCH(PolygonMode, (face, mode), (F, "glPolygonMode(0x%x, 0x%x);\n", face, mode)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_175)(const GLubyte * mask); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_175)(const GLubyte * mask) +{ + DISPATCH(PolygonStipple, (mask), (F, "glPolygonStipple(%p);\n", (const void *) mask)); +} + +KEYWORD1 void KEYWORD2 NAME(Scissor)(GLint x, GLint y, GLsizei width, GLsizei height) +{ + DISPATCH(Scissor, (x, y, width, height), (F, "glScissor(%d, %d, %d, %d);\n", x, y, width, height)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_177)(GLenum mode); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_177)(GLenum mode) +{ + DISPATCH(ShadeModel, (mode), (F, "glShadeModel(0x%x);\n", mode)); +} + +KEYWORD1 void KEYWORD2 NAME(TexParameterf)(GLenum target, GLenum pname, GLfloat param) +{ + DISPATCH(TexParameterf, (target, pname, param), (F, "glTexParameterf(0x%x, 0x%x, %f);\n", target, pname, param)); +} + +KEYWORD1 void KEYWORD2 NAME(TexParameterfv)(GLenum target, GLenum pname, const GLfloat * params) +{ + DISPATCH(TexParameterfv, (target, pname, params), (F, "glTexParameterfv(0x%x, 0x%x, %p);\n", target, pname, (const void *) params)); +} + +KEYWORD1 void KEYWORD2 NAME(TexParameteri)(GLenum target, GLenum pname, GLint param) +{ + DISPATCH(TexParameteri, (target, pname, param), (F, "glTexParameteri(0x%x, 0x%x, %d);\n", target, pname, param)); +} + +KEYWORD1 void KEYWORD2 NAME(TexParameteriv)(GLenum target, GLenum pname, const GLint * params) +{ + DISPATCH(TexParameteriv, (target, pname, params), (F, "glTexParameteriv(0x%x, 0x%x, %p);\n", target, pname, (const void *) params)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_182)(GLenum target, GLint level, GLint internalformat, GLsizei width, GLint border, GLenum format, GLenum type, const GLvoid * pixels); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_182)(GLenum target, GLint level, GLint internalformat, GLsizei width, GLint border, GLenum format, GLenum type, const GLvoid * pixels) +{ + DISPATCH(TexImage1D, (target, level, internalformat, width, border, format, type, pixels), (F, "glTexImage1D(0x%x, %d, %d, %d, %d, 0x%x, 0x%x, %p);\n", target, level, internalformat, width, border, format, type, (const void *) pixels)); +} + +KEYWORD1 void KEYWORD2 NAME(TexImage2D)(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const GLvoid * pixels) +{ + DISPATCH(TexImage2D, (target, level, internalformat, width, height, border, format, type, pixels), (F, "glTexImage2D(0x%x, %d, %d, %d, %d, %d, 0x%x, 0x%x, %p);\n", target, level, internalformat, width, height, border, format, type, (const void *) pixels)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_184)(GLenum target, GLenum pname, GLfloat param); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_184)(GLenum target, GLenum pname, GLfloat param) +{ + DISPATCH(TexEnvf, (target, pname, param), (F, "glTexEnvf(0x%x, 0x%x, %f);\n", target, pname, param)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_185)(GLenum target, GLenum pname, const GLfloat * params); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_185)(GLenum target, GLenum pname, const GLfloat * params) +{ + DISPATCH(TexEnvfv, (target, pname, params), (F, "glTexEnvfv(0x%x, 0x%x, %p);\n", target, pname, (const void *) params)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_186)(GLenum target, GLenum pname, GLint param); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_186)(GLenum target, GLenum pname, GLint param) +{ + DISPATCH(TexEnvi, (target, pname, param), (F, "glTexEnvi(0x%x, 0x%x, %d);\n", target, pname, param)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_187)(GLenum target, GLenum pname, const GLint * params); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_187)(GLenum target, GLenum pname, const GLint * params) +{ + DISPATCH(TexEnviv, (target, pname, params), (F, "glTexEnviv(0x%x, 0x%x, %p);\n", target, pname, (const void *) params)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_188)(GLenum coord, GLenum pname, GLdouble param); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_188)(GLenum coord, GLenum pname, GLdouble param) +{ + DISPATCH(TexGend, (coord, pname, param), (F, "glTexGend(0x%x, 0x%x, %f);\n", coord, pname, param)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_189)(GLenum coord, GLenum pname, const GLdouble * params); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_189)(GLenum coord, GLenum pname, const GLdouble * params) +{ + DISPATCH(TexGendv, (coord, pname, params), (F, "glTexGendv(0x%x, 0x%x, %p);\n", coord, pname, (const void *) params)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_190)(GLenum coord, GLenum pname, GLfloat param); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_190)(GLenum coord, GLenum pname, GLfloat param) +{ + DISPATCH(TexGenf, (coord, pname, param), (F, "glTexGenf(0x%x, 0x%x, %f);\n", coord, pname, param)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_191)(GLenum coord, GLenum pname, const GLfloat * params); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_191)(GLenum coord, GLenum pname, const GLfloat * params) +{ + DISPATCH(TexGenfv, (coord, pname, params), (F, "glTexGenfv(0x%x, 0x%x, %p);\n", coord, pname, (const void *) params)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_192)(GLenum coord, GLenum pname, GLint param); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_192)(GLenum coord, GLenum pname, GLint param) +{ + DISPATCH(TexGeni, (coord, pname, param), (F, "glTexGeni(0x%x, 0x%x, %d);\n", coord, pname, param)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_193)(GLenum coord, GLenum pname, const GLint * params); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_193)(GLenum coord, GLenum pname, const GLint * params) +{ + DISPATCH(TexGeniv, (coord, pname, params), (F, "glTexGeniv(0x%x, 0x%x, %p);\n", coord, pname, (const void *) params)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_194)(GLsizei size, GLenum type, GLfloat * buffer); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_194)(GLsizei size, GLenum type, GLfloat * buffer) +{ + DISPATCH(FeedbackBuffer, (size, type, buffer), (F, "glFeedbackBuffer(%d, 0x%x, %p);\n", size, type, (const void *) buffer)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_195)(GLsizei size, GLuint * buffer); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_195)(GLsizei size, GLuint * buffer) +{ + DISPATCH(SelectBuffer, (size, buffer), (F, "glSelectBuffer(%d, %p);\n", size, (const void *) buffer)); +} + +KEYWORD1_ALT GLint KEYWORD2 NAME(_dispatch_stub_196)(GLenum mode); + +KEYWORD1_ALT GLint KEYWORD2 NAME(_dispatch_stub_196)(GLenum mode) +{ + RETURN_DISPATCH(RenderMode, (mode), (F, "glRenderMode(0x%x);\n", mode)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_197)(void); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_197)(void) +{ + DISPATCH(InitNames, (), (F, "glInitNames();\n")); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_198)(GLuint name); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_198)(GLuint name) +{ + DISPATCH(LoadName, (name), (F, "glLoadName(%d);\n", name)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_199)(GLfloat token); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_199)(GLfloat token) +{ + DISPATCH(PassThrough, (token), (F, "glPassThrough(%f);\n", token)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_200)(void); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_200)(void) +{ + DISPATCH(PopName, (), (F, "glPopName();\n")); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_201)(GLuint name); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_201)(GLuint name) +{ + DISPATCH(PushName, (name), (F, "glPushName(%d);\n", name)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_202)(GLenum mode); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_202)(GLenum mode) +{ + DISPATCH(DrawBuffer, (mode), (F, "glDrawBuffer(0x%x);\n", mode)); +} + +KEYWORD1 void KEYWORD2 NAME(Clear)(GLbitfield mask) +{ + DISPATCH(Clear, (mask), (F, "glClear(%d);\n", mask)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_204)(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_204)(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha) +{ + DISPATCH(ClearAccum, (red, green, blue, alpha), (F, "glClearAccum(%f, %f, %f, %f);\n", red, green, blue, alpha)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_205)(GLfloat c); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_205)(GLfloat c) +{ + DISPATCH(ClearIndex, (c), (F, "glClearIndex(%f);\n", c)); +} + +KEYWORD1 void KEYWORD2 NAME(ClearColor)(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha) +{ + DISPATCH(ClearColor, (red, green, blue, alpha), (F, "glClearColor(%f, %f, %f, %f);\n", red, green, blue, alpha)); +} + +KEYWORD1 void KEYWORD2 NAME(ClearStencil)(GLint s) +{ + DISPATCH(ClearStencil, (s), (F, "glClearStencil(%d);\n", s)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_208)(GLclampd depth); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_208)(GLclampd depth) +{ + DISPATCH(ClearDepth, (depth), (F, "glClearDepth(%f);\n", depth)); +} + +KEYWORD1 void KEYWORD2 NAME(StencilMask)(GLuint mask) +{ + DISPATCH(StencilMask, (mask), (F, "glStencilMask(%d);\n", mask)); +} + +KEYWORD1 void KEYWORD2 NAME(ColorMask)(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha) +{ + DISPATCH(ColorMask, (red, green, blue, alpha), (F, "glColorMask(%d, %d, %d, %d);\n", red, green, blue, alpha)); +} + +KEYWORD1 void KEYWORD2 NAME(DepthMask)(GLboolean flag) +{ + DISPATCH(DepthMask, (flag), (F, "glDepthMask(%d);\n", flag)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_212)(GLuint mask); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_212)(GLuint mask) +{ + DISPATCH(IndexMask, (mask), (F, "glIndexMask(%d);\n", mask)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_213)(GLenum op, GLfloat value); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_213)(GLenum op, GLfloat value) +{ + DISPATCH(Accum, (op, value), (F, "glAccum(0x%x, %f);\n", op, value)); +} + +KEYWORD1 void KEYWORD2 NAME(Disable)(GLenum cap) +{ + DISPATCH(Disable, (cap), (F, "glDisable(0x%x);\n", cap)); +} + +KEYWORD1 void KEYWORD2 NAME(Enable)(GLenum cap) +{ + DISPATCH(Enable, (cap), (F, "glEnable(0x%x);\n", cap)); +} + +KEYWORD1 void KEYWORD2 NAME(Finish)(void) +{ + DISPATCH(Finish, (), (F, "glFinish();\n")); +} + +KEYWORD1 void KEYWORD2 NAME(Flush)(void) +{ + DISPATCH(Flush, (), (F, "glFlush();\n")); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_218)(void); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_218)(void) +{ + DISPATCH(PopAttrib, (), (F, "glPopAttrib();\n")); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_219)(GLbitfield mask); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_219)(GLbitfield mask) +{ + DISPATCH(PushAttrib, (mask), (F, "glPushAttrib(%d);\n", mask)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_220)(GLenum target, GLdouble u1, GLdouble u2, GLint stride, GLint order, const GLdouble * points); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_220)(GLenum target, GLdouble u1, GLdouble u2, GLint stride, GLint order, const GLdouble * points) +{ + DISPATCH(Map1d, (target, u1, u2, stride, order, points), (F, "glMap1d(0x%x, %f, %f, %d, %d, %p);\n", target, u1, u2, stride, order, (const void *) points)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_221)(GLenum target, GLfloat u1, GLfloat u2, GLint stride, GLint order, const GLfloat * points); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_221)(GLenum target, GLfloat u1, GLfloat u2, GLint stride, GLint order, const GLfloat * points) +{ + DISPATCH(Map1f, (target, u1, u2, stride, order, points), (F, "glMap1f(0x%x, %f, %f, %d, %d, %p);\n", target, u1, u2, stride, order, (const void *) points)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_222)(GLenum target, GLdouble u1, GLdouble u2, GLint ustride, GLint uorder, GLdouble v1, GLdouble v2, GLint vstride, GLint vorder, const GLdouble * points); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_222)(GLenum target, GLdouble u1, GLdouble u2, GLint ustride, GLint uorder, GLdouble v1, GLdouble v2, GLint vstride, GLint vorder, const GLdouble * points) +{ + DISPATCH(Map2d, (target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, points), (F, "glMap2d(0x%x, %f, %f, %d, %d, %f, %f, %d, %d, %p);\n", target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, (const void *) points)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_223)(GLenum target, GLfloat u1, GLfloat u2, GLint ustride, GLint uorder, GLfloat v1, GLfloat v2, GLint vstride, GLint vorder, const GLfloat * points); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_223)(GLenum target, GLfloat u1, GLfloat u2, GLint ustride, GLint uorder, GLfloat v1, GLfloat v2, GLint vstride, GLint vorder, const GLfloat * points) +{ + DISPATCH(Map2f, (target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, points), (F, "glMap2f(0x%x, %f, %f, %d, %d, %f, %f, %d, %d, %p);\n", target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, (const void *) points)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_224)(GLint un, GLdouble u1, GLdouble u2); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_224)(GLint un, GLdouble u1, GLdouble u2) +{ + DISPATCH(MapGrid1d, (un, u1, u2), (F, "glMapGrid1d(%d, %f, %f);\n", un, u1, u2)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_225)(GLint un, GLfloat u1, GLfloat u2); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_225)(GLint un, GLfloat u1, GLfloat u2) +{ + DISPATCH(MapGrid1f, (un, u1, u2), (F, "glMapGrid1f(%d, %f, %f);\n", un, u1, u2)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_226)(GLint un, GLdouble u1, GLdouble u2, GLint vn, GLdouble v1, GLdouble v2); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_226)(GLint un, GLdouble u1, GLdouble u2, GLint vn, GLdouble v1, GLdouble v2) +{ + DISPATCH(MapGrid2d, (un, u1, u2, vn, v1, v2), (F, "glMapGrid2d(%d, %f, %f, %d, %f, %f);\n", un, u1, u2, vn, v1, v2)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_227)(GLint un, GLfloat u1, GLfloat u2, GLint vn, GLfloat v1, GLfloat v2); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_227)(GLint un, GLfloat u1, GLfloat u2, GLint vn, GLfloat v1, GLfloat v2) +{ + DISPATCH(MapGrid2f, (un, u1, u2, vn, v1, v2), (F, "glMapGrid2f(%d, %f, %f, %d, %f, %f);\n", un, u1, u2, vn, v1, v2)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_228)(GLdouble u); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_228)(GLdouble u) +{ + DISPATCH(EvalCoord1d, (u), (F, "glEvalCoord1d(%f);\n", u)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_229)(const GLdouble * u); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_229)(const GLdouble * u) +{ + DISPATCH(EvalCoord1dv, (u), (F, "glEvalCoord1dv(%p);\n", (const void *) u)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_230)(GLfloat u); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_230)(GLfloat u) +{ + DISPATCH(EvalCoord1f, (u), (F, "glEvalCoord1f(%f);\n", u)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_231)(const GLfloat * u); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_231)(const GLfloat * u) +{ + DISPATCH(EvalCoord1fv, (u), (F, "glEvalCoord1fv(%p);\n", (const void *) u)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_232)(GLdouble u, GLdouble v); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_232)(GLdouble u, GLdouble v) +{ + DISPATCH(EvalCoord2d, (u, v), (F, "glEvalCoord2d(%f, %f);\n", u, v)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_233)(const GLdouble * u); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_233)(const GLdouble * u) +{ + DISPATCH(EvalCoord2dv, (u), (F, "glEvalCoord2dv(%p);\n", (const void *) u)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_234)(GLfloat u, GLfloat v); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_234)(GLfloat u, GLfloat v) +{ + DISPATCH(EvalCoord2f, (u, v), (F, "glEvalCoord2f(%f, %f);\n", u, v)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_235)(const GLfloat * u); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_235)(const GLfloat * u) +{ + DISPATCH(EvalCoord2fv, (u), (F, "glEvalCoord2fv(%p);\n", (const void *) u)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_236)(GLenum mode, GLint i1, GLint i2); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_236)(GLenum mode, GLint i1, GLint i2) +{ + DISPATCH(EvalMesh1, (mode, i1, i2), (F, "glEvalMesh1(0x%x, %d, %d);\n", mode, i1, i2)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_237)(GLint i); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_237)(GLint i) +{ + DISPATCH(EvalPoint1, (i), (F, "glEvalPoint1(%d);\n", i)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_238)(GLenum mode, GLint i1, GLint i2, GLint j1, GLint j2); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_238)(GLenum mode, GLint i1, GLint i2, GLint j1, GLint j2) +{ + DISPATCH(EvalMesh2, (mode, i1, i2, j1, j2), (F, "glEvalMesh2(0x%x, %d, %d, %d, %d);\n", mode, i1, i2, j1, j2)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_239)(GLint i, GLint j); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_239)(GLint i, GLint j) +{ + DISPATCH(EvalPoint2, (i, j), (F, "glEvalPoint2(%d, %d);\n", i, j)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_240)(GLenum func, GLclampf ref); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_240)(GLenum func, GLclampf ref) +{ + DISPATCH(AlphaFunc, (func, ref), (F, "glAlphaFunc(0x%x, %f);\n", func, ref)); +} + +KEYWORD1 void KEYWORD2 NAME(BlendFunc)(GLenum sfactor, GLenum dfactor) +{ + DISPATCH(BlendFunc, (sfactor, dfactor), (F, "glBlendFunc(0x%x, 0x%x);\n", sfactor, dfactor)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_242)(GLenum opcode); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_242)(GLenum opcode) +{ + DISPATCH(LogicOp, (opcode), (F, "glLogicOp(0x%x);\n", opcode)); +} + +KEYWORD1 void KEYWORD2 NAME(StencilFunc)(GLenum func, GLint ref, GLuint mask) +{ + DISPATCH(StencilFunc, (func, ref, mask), (F, "glStencilFunc(0x%x, %d, %d);\n", func, ref, mask)); +} + +KEYWORD1 void KEYWORD2 NAME(StencilOp)(GLenum fail, GLenum zfail, GLenum zpass) +{ + DISPATCH(StencilOp, (fail, zfail, zpass), (F, "glStencilOp(0x%x, 0x%x, 0x%x);\n", fail, zfail, zpass)); +} + +KEYWORD1 void KEYWORD2 NAME(DepthFunc)(GLenum func) +{ + DISPATCH(DepthFunc, (func), (F, "glDepthFunc(0x%x);\n", func)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_246)(GLfloat xfactor, GLfloat yfactor); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_246)(GLfloat xfactor, GLfloat yfactor) +{ + DISPATCH(PixelZoom, (xfactor, yfactor), (F, "glPixelZoom(%f, %f);\n", xfactor, yfactor)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_247)(GLenum pname, GLfloat param); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_247)(GLenum pname, GLfloat param) +{ + DISPATCH(PixelTransferf, (pname, param), (F, "glPixelTransferf(0x%x, %f);\n", pname, param)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_248)(GLenum pname, GLint param); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_248)(GLenum pname, GLint param) +{ + DISPATCH(PixelTransferi, (pname, param), (F, "glPixelTransferi(0x%x, %d);\n", pname, param)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_249)(GLenum pname, GLfloat param); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_249)(GLenum pname, GLfloat param) +{ + DISPATCH(PixelStoref, (pname, param), (F, "glPixelStoref(0x%x, %f);\n", pname, param)); +} + +KEYWORD1 void KEYWORD2 NAME(PixelStorei)(GLenum pname, GLint param) +{ + DISPATCH(PixelStorei, (pname, param), (F, "glPixelStorei(0x%x, %d);\n", pname, param)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_251)(GLenum map, GLsizei mapsize, const GLfloat * values); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_251)(GLenum map, GLsizei mapsize, const GLfloat * values) +{ + DISPATCH(PixelMapfv, (map, mapsize, values), (F, "glPixelMapfv(0x%x, %d, %p);\n", map, mapsize, (const void *) values)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_252)(GLenum map, GLsizei mapsize, const GLuint * values); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_252)(GLenum map, GLsizei mapsize, const GLuint * values) +{ + DISPATCH(PixelMapuiv, (map, mapsize, values), (F, "glPixelMapuiv(0x%x, %d, %p);\n", map, mapsize, (const void *) values)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_253)(GLenum map, GLsizei mapsize, const GLushort * values); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_253)(GLenum map, GLsizei mapsize, const GLushort * values) +{ + DISPATCH(PixelMapusv, (map, mapsize, values), (F, "glPixelMapusv(0x%x, %d, %p);\n", map, mapsize, (const void *) values)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_254)(GLenum mode); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_254)(GLenum mode) +{ + DISPATCH(ReadBuffer, (mode), (F, "glReadBuffer(0x%x);\n", mode)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_255)(GLint x, GLint y, GLsizei width, GLsizei height, GLenum type); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_255)(GLint x, GLint y, GLsizei width, GLsizei height, GLenum type) +{ + DISPATCH(CopyPixels, (x, y, width, height, type), (F, "glCopyPixels(%d, %d, %d, %d, 0x%x);\n", x, y, width, height, type)); +} + +KEYWORD1 void KEYWORD2 NAME(ReadPixels)(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLvoid * pixels) +{ + DISPATCH(ReadPixels, (x, y, width, height, format, type, pixels), (F, "glReadPixels(%d, %d, %d, %d, 0x%x, 0x%x, %p);\n", x, y, width, height, format, type, (const void *) pixels)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_257)(GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid * pixels); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_257)(GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid * pixels) +{ + DISPATCH(DrawPixels, (width, height, format, type, pixels), (F, "glDrawPixels(%d, %d, 0x%x, 0x%x, %p);\n", width, height, format, type, (const void *) pixels)); +} + +KEYWORD1 void KEYWORD2 NAME(GetBooleanv)(GLenum pname, GLboolean * params) +{ + DISPATCH(GetBooleanv, (pname, params), (F, "glGetBooleanv(0x%x, %p);\n", pname, (const void *) params)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_259)(GLenum plane, GLdouble * equation); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_259)(GLenum plane, GLdouble * equation) +{ + DISPATCH(GetClipPlane, (plane, equation), (F, "glGetClipPlane(0x%x, %p);\n", plane, (const void *) equation)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_260)(GLenum pname, GLdouble * params); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_260)(GLenum pname, GLdouble * params) +{ + DISPATCH(GetDoublev, (pname, params), (F, "glGetDoublev(0x%x, %p);\n", pname, (const void *) params)); +} + +KEYWORD1 GLenum KEYWORD2 NAME(GetError)(void) +{ + RETURN_DISPATCH(GetError, (), (F, "glGetError();\n")); +} + +KEYWORD1 void KEYWORD2 NAME(GetFloatv)(GLenum pname, GLfloat * params) +{ + DISPATCH(GetFloatv, (pname, params), (F, "glGetFloatv(0x%x, %p);\n", pname, (const void *) params)); +} + +KEYWORD1 void KEYWORD2 NAME(GetIntegerv)(GLenum pname, GLint * params) +{ + DISPATCH(GetIntegerv, (pname, params), (F, "glGetIntegerv(0x%x, %p);\n", pname, (const void *) params)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_264)(GLenum light, GLenum pname, GLfloat * params); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_264)(GLenum light, GLenum pname, GLfloat * params) +{ + DISPATCH(GetLightfv, (light, pname, params), (F, "glGetLightfv(0x%x, 0x%x, %p);\n", light, pname, (const void *) params)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_265)(GLenum light, GLenum pname, GLint * params); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_265)(GLenum light, GLenum pname, GLint * params) +{ + DISPATCH(GetLightiv, (light, pname, params), (F, "glGetLightiv(0x%x, 0x%x, %p);\n", light, pname, (const void *) params)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_266)(GLenum target, GLenum query, GLdouble * v); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_266)(GLenum target, GLenum query, GLdouble * v) +{ + DISPATCH(GetMapdv, (target, query, v), (F, "glGetMapdv(0x%x, 0x%x, %p);\n", target, query, (const void *) v)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_267)(GLenum target, GLenum query, GLfloat * v); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_267)(GLenum target, GLenum query, GLfloat * v) +{ + DISPATCH(GetMapfv, (target, query, v), (F, "glGetMapfv(0x%x, 0x%x, %p);\n", target, query, (const void *) v)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_268)(GLenum target, GLenum query, GLint * v); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_268)(GLenum target, GLenum query, GLint * v) +{ + DISPATCH(GetMapiv, (target, query, v), (F, "glGetMapiv(0x%x, 0x%x, %p);\n", target, query, (const void *) v)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_269)(GLenum face, GLenum pname, GLfloat * params); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_269)(GLenum face, GLenum pname, GLfloat * params) +{ + DISPATCH(GetMaterialfv, (face, pname, params), (F, "glGetMaterialfv(0x%x, 0x%x, %p);\n", face, pname, (const void *) params)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_270)(GLenum face, GLenum pname, GLint * params); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_270)(GLenum face, GLenum pname, GLint * params) +{ + DISPATCH(GetMaterialiv, (face, pname, params), (F, "glGetMaterialiv(0x%x, 0x%x, %p);\n", face, pname, (const void *) params)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_271)(GLenum map, GLfloat * values); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_271)(GLenum map, GLfloat * values) +{ + DISPATCH(GetPixelMapfv, (map, values), (F, "glGetPixelMapfv(0x%x, %p);\n", map, (const void *) values)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_272)(GLenum map, GLuint * values); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_272)(GLenum map, GLuint * values) +{ + DISPATCH(GetPixelMapuiv, (map, values), (F, "glGetPixelMapuiv(0x%x, %p);\n", map, (const void *) values)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_273)(GLenum map, GLushort * values); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_273)(GLenum map, GLushort * values) +{ + DISPATCH(GetPixelMapusv, (map, values), (F, "glGetPixelMapusv(0x%x, %p);\n", map, (const void *) values)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_274)(GLubyte * mask); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_274)(GLubyte * mask) +{ + DISPATCH(GetPolygonStipple, (mask), (F, "glGetPolygonStipple(%p);\n", (const void *) mask)); +} + +KEYWORD1 const GLubyte * KEYWORD2 NAME(GetString)(GLenum name) +{ + RETURN_DISPATCH(GetString, (name), (F, "glGetString(0x%x);\n", name)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_276)(GLenum target, GLenum pname, GLfloat * params); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_276)(GLenum target, GLenum pname, GLfloat * params) +{ + DISPATCH(GetTexEnvfv, (target, pname, params), (F, "glGetTexEnvfv(0x%x, 0x%x, %p);\n", target, pname, (const void *) params)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_277)(GLenum target, GLenum pname, GLint * params); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_277)(GLenum target, GLenum pname, GLint * params) +{ + DISPATCH(GetTexEnviv, (target, pname, params), (F, "glGetTexEnviv(0x%x, 0x%x, %p);\n", target, pname, (const void *) params)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_278)(GLenum coord, GLenum pname, GLdouble * params); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_278)(GLenum coord, GLenum pname, GLdouble * params) +{ + DISPATCH(GetTexGendv, (coord, pname, params), (F, "glGetTexGendv(0x%x, 0x%x, %p);\n", coord, pname, (const void *) params)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_279)(GLenum coord, GLenum pname, GLfloat * params); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_279)(GLenum coord, GLenum pname, GLfloat * params) +{ + DISPATCH(GetTexGenfv, (coord, pname, params), (F, "glGetTexGenfv(0x%x, 0x%x, %p);\n", coord, pname, (const void *) params)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_280)(GLenum coord, GLenum pname, GLint * params); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_280)(GLenum coord, GLenum pname, GLint * params) +{ + DISPATCH(GetTexGeniv, (coord, pname, params), (F, "glGetTexGeniv(0x%x, 0x%x, %p);\n", coord, pname, (const void *) params)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_281)(GLenum target, GLint level, GLenum format, GLenum type, GLvoid * pixels); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_281)(GLenum target, GLint level, GLenum format, GLenum type, GLvoid * pixels) +{ + DISPATCH(GetTexImage, (target, level, format, type, pixels), (F, "glGetTexImage(0x%x, %d, 0x%x, 0x%x, %p);\n", target, level, format, type, (const void *) pixels)); +} + +KEYWORD1 void KEYWORD2 NAME(GetTexParameterfv)(GLenum target, GLenum pname, GLfloat * params) +{ + DISPATCH(GetTexParameterfv, (target, pname, params), (F, "glGetTexParameterfv(0x%x, 0x%x, %p);\n", target, pname, (const void *) params)); +} + +KEYWORD1 void KEYWORD2 NAME(GetTexParameteriv)(GLenum target, GLenum pname, GLint * params) +{ + DISPATCH(GetTexParameteriv, (target, pname, params), (F, "glGetTexParameteriv(0x%x, 0x%x, %p);\n", target, pname, (const void *) params)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_284)(GLenum target, GLint level, GLenum pname, GLfloat * params); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_284)(GLenum target, GLint level, GLenum pname, GLfloat * params) +{ + DISPATCH(GetTexLevelParameterfv, (target, level, pname, params), (F, "glGetTexLevelParameterfv(0x%x, %d, 0x%x, %p);\n", target, level, pname, (const void *) params)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_285)(GLenum target, GLint level, GLenum pname, GLint * params); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_285)(GLenum target, GLint level, GLenum pname, GLint * params) +{ + DISPATCH(GetTexLevelParameteriv, (target, level, pname, params), (F, "glGetTexLevelParameteriv(0x%x, %d, 0x%x, %p);\n", target, level, pname, (const void *) params)); +} + +KEYWORD1 GLboolean KEYWORD2 NAME(IsEnabled)(GLenum cap) +{ + RETURN_DISPATCH(IsEnabled, (cap), (F, "glIsEnabled(0x%x);\n", cap)); +} + +KEYWORD1_ALT GLboolean KEYWORD2 NAME(_dispatch_stub_287)(GLuint list); + +KEYWORD1_ALT GLboolean KEYWORD2 NAME(_dispatch_stub_287)(GLuint list) +{ + RETURN_DISPATCH(IsList, (list), (F, "glIsList(%d);\n", list)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_288)(GLclampd zNear, GLclampd zFar); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_288)(GLclampd zNear, GLclampd zFar) +{ + DISPATCH(DepthRange, (zNear, zFar), (F, "glDepthRange(%f, %f);\n", zNear, zFar)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_289)(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_289)(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar) +{ + DISPATCH(Frustum, (left, right, bottom, top, zNear, zFar), (F, "glFrustum(%f, %f, %f, %f, %f, %f);\n", left, right, bottom, top, zNear, zFar)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_290)(void); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_290)(void) +{ + DISPATCH(LoadIdentity, (), (F, "glLoadIdentity();\n")); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_291)(const GLfloat * m); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_291)(const GLfloat * m) +{ + DISPATCH(LoadMatrixf, (m), (F, "glLoadMatrixf(%p);\n", (const void *) m)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_292)(const GLdouble * m); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_292)(const GLdouble * m) +{ + DISPATCH(LoadMatrixd, (m), (F, "glLoadMatrixd(%p);\n", (const void *) m)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_293)(GLenum mode); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_293)(GLenum mode) +{ + DISPATCH(MatrixMode, (mode), (F, "glMatrixMode(0x%x);\n", mode)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_294)(const GLfloat * m); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_294)(const GLfloat * m) +{ + DISPATCH(MultMatrixf, (m), (F, "glMultMatrixf(%p);\n", (const void *) m)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_295)(const GLdouble * m); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_295)(const GLdouble * m) +{ + DISPATCH(MultMatrixd, (m), (F, "glMultMatrixd(%p);\n", (const void *) m)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_296)(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_296)(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar) +{ + DISPATCH(Ortho, (left, right, bottom, top, zNear, zFar), (F, "glOrtho(%f, %f, %f, %f, %f, %f);\n", left, right, bottom, top, zNear, zFar)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_297)(void); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_297)(void) +{ + DISPATCH(PopMatrix, (), (F, "glPopMatrix();\n")); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_298)(void); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_298)(void) +{ + DISPATCH(PushMatrix, (), (F, "glPushMatrix();\n")); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_299)(GLdouble angle, GLdouble x, GLdouble y, GLdouble z); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_299)(GLdouble angle, GLdouble x, GLdouble y, GLdouble z) +{ + DISPATCH(Rotated, (angle, x, y, z), (F, "glRotated(%f, %f, %f, %f);\n", angle, x, y, z)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_300)(GLfloat angle, GLfloat x, GLfloat y, GLfloat z); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_300)(GLfloat angle, GLfloat x, GLfloat y, GLfloat z) +{ + DISPATCH(Rotatef, (angle, x, y, z), (F, "glRotatef(%f, %f, %f, %f);\n", angle, x, y, z)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_301)(GLdouble x, GLdouble y, GLdouble z); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_301)(GLdouble x, GLdouble y, GLdouble z) +{ + DISPATCH(Scaled, (x, y, z), (F, "glScaled(%f, %f, %f);\n", x, y, z)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_302)(GLfloat x, GLfloat y, GLfloat z); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_302)(GLfloat x, GLfloat y, GLfloat z) +{ + DISPATCH(Scalef, (x, y, z), (F, "glScalef(%f, %f, %f);\n", x, y, z)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_303)(GLdouble x, GLdouble y, GLdouble z); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_303)(GLdouble x, GLdouble y, GLdouble z) +{ + DISPATCH(Translated, (x, y, z), (F, "glTranslated(%f, %f, %f);\n", x, y, z)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_304)(GLfloat x, GLfloat y, GLfloat z); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_304)(GLfloat x, GLfloat y, GLfloat z) +{ + DISPATCH(Translatef, (x, y, z), (F, "glTranslatef(%f, %f, %f);\n", x, y, z)); +} + +KEYWORD1 void KEYWORD2 NAME(Viewport)(GLint x, GLint y, GLsizei width, GLsizei height) +{ + DISPATCH(Viewport, (x, y, width, height), (F, "glViewport(%d, %d, %d, %d);\n", x, y, width, height)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_306)(GLint i); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_306)(GLint i) +{ + DISPATCH(ArrayElement, (i), (F, "glArrayElement(%d);\n", i)); +} + +KEYWORD1 void KEYWORD2 NAME(BindTexture)(GLenum target, GLuint texture) +{ + DISPATCH(BindTexture, (target, texture), (F, "glBindTexture(0x%x, %d);\n", target, texture)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_308)(GLint size, GLenum type, GLsizei stride, const GLvoid * pointer); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_308)(GLint size, GLenum type, GLsizei stride, const GLvoid * pointer) +{ + DISPATCH(ColorPointer, (size, type, stride, pointer), (F, "glColorPointer(%d, 0x%x, %d, %p);\n", size, type, stride, (const void *) pointer)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_309)(GLenum array); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_309)(GLenum array) +{ + DISPATCH(DisableClientState, (array), (F, "glDisableClientState(0x%x);\n", array)); +} + +KEYWORD1 void KEYWORD2 NAME(DrawArrays)(GLenum mode, GLint first, GLsizei count) +{ + DISPATCH(DrawArrays, (mode, first, count), (F, "glDrawArrays(0x%x, %d, %d);\n", mode, first, count)); +} + +KEYWORD1 void KEYWORD2 NAME(DrawElements)(GLenum mode, GLsizei count, GLenum type, const GLvoid * indices) +{ + DISPATCH(DrawElements, (mode, count, type, indices), (F, "glDrawElements(0x%x, %d, 0x%x, %p);\n", mode, count, type, (const void *) indices)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_312)(GLsizei stride, const GLvoid * pointer); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_312)(GLsizei stride, const GLvoid * pointer) +{ + DISPATCH(EdgeFlagPointer, (stride, pointer), (F, "glEdgeFlagPointer(%d, %p);\n", stride, (const void *) pointer)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_313)(GLenum array); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_313)(GLenum array) +{ + DISPATCH(EnableClientState, (array), (F, "glEnableClientState(0x%x);\n", array)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_314)(GLenum type, GLsizei stride, const GLvoid * pointer); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_314)(GLenum type, GLsizei stride, const GLvoid * pointer) +{ + DISPATCH(IndexPointer, (type, stride, pointer), (F, "glIndexPointer(0x%x, %d, %p);\n", type, stride, (const void *) pointer)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_315)(GLubyte c); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_315)(GLubyte c) +{ + DISPATCH(Indexub, (c), (F, "glIndexub(%d);\n", c)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_316)(const GLubyte * c); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_316)(const GLubyte * c) +{ + DISPATCH(Indexubv, (c), (F, "glIndexubv(%p);\n", (const void *) c)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_317)(GLenum format, GLsizei stride, const GLvoid * pointer); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_317)(GLenum format, GLsizei stride, const GLvoid * pointer) +{ + DISPATCH(InterleavedArrays, (format, stride, pointer), (F, "glInterleavedArrays(0x%x, %d, %p);\n", format, stride, (const void *) pointer)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_318)(GLenum type, GLsizei stride, const GLvoid * pointer); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_318)(GLenum type, GLsizei stride, const GLvoid * pointer) +{ + DISPATCH(NormalPointer, (type, stride, pointer), (F, "glNormalPointer(0x%x, %d, %p);\n", type, stride, (const void *) pointer)); +} + +KEYWORD1 void KEYWORD2 NAME(PolygonOffset)(GLfloat factor, GLfloat units) +{ + DISPATCH(PolygonOffset, (factor, units), (F, "glPolygonOffset(%f, %f);\n", factor, units)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_320)(GLint size, GLenum type, GLsizei stride, const GLvoid * pointer); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_320)(GLint size, GLenum type, GLsizei stride, const GLvoid * pointer) +{ + DISPATCH(TexCoordPointer, (size, type, stride, pointer), (F, "glTexCoordPointer(%d, 0x%x, %d, %p);\n", size, type, stride, (const void *) pointer)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_321)(GLint size, GLenum type, GLsizei stride, const GLvoid * pointer); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_321)(GLint size, GLenum type, GLsizei stride, const GLvoid * pointer) +{ + DISPATCH(VertexPointer, (size, type, stride, pointer), (F, "glVertexPointer(%d, 0x%x, %d, %p);\n", size, type, stride, (const void *) pointer)); +} + +KEYWORD1_ALT GLboolean KEYWORD2 NAME(_dispatch_stub_322)(GLsizei n, const GLuint * textures, GLboolean * residences); + +KEYWORD1_ALT GLboolean KEYWORD2 NAME(_dispatch_stub_322)(GLsizei n, const GLuint * textures, GLboolean * residences) +{ + RETURN_DISPATCH(AreTexturesResident, (n, textures, residences), (F, "glAreTexturesResident(%d, %p, %p);\n", n, (const void *) textures, (const void *) residences)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_323)(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLint border); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_323)(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLint border) +{ + DISPATCH(CopyTexImage1D, (target, level, internalformat, x, y, width, border), (F, "glCopyTexImage1D(0x%x, %d, 0x%x, %d, %d, %d, %d);\n", target, level, internalformat, x, y, width, border)); +} + +KEYWORD1 void KEYWORD2 NAME(CopyTexImage2D)(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border) +{ + DISPATCH(CopyTexImage2D, (target, level, internalformat, x, y, width, height, border), (F, "glCopyTexImage2D(0x%x, %d, 0x%x, %d, %d, %d, %d, %d);\n", target, level, internalformat, x, y, width, height, border)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_325)(GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_325)(GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width) +{ + DISPATCH(CopyTexSubImage1D, (target, level, xoffset, x, y, width), (F, "glCopyTexSubImage1D(0x%x, %d, %d, %d, %d, %d);\n", target, level, xoffset, x, y, width)); +} + +KEYWORD1 void KEYWORD2 NAME(CopyTexSubImage2D)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height) +{ + DISPATCH(CopyTexSubImage2D, (target, level, xoffset, yoffset, x, y, width, height), (F, "glCopyTexSubImage2D(0x%x, %d, %d, %d, %d, %d, %d, %d);\n", target, level, xoffset, yoffset, x, y, width, height)); +} + +KEYWORD1 void KEYWORD2 NAME(DeleteTextures)(GLsizei n, const GLuint * textures) +{ + DISPATCH(DeleteTextures, (n, textures), (F, "glDeleteTextures(%d, %p);\n", n, (const void *) textures)); +} + +KEYWORD1 void KEYWORD2 NAME(GenTextures)(GLsizei n, GLuint * textures) +{ + DISPATCH(GenTextures, (n, textures), (F, "glGenTextures(%d, %p);\n", n, (const void *) textures)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_329)(GLenum pname, GLvoid ** params); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_329)(GLenum pname, GLvoid ** params) +{ + DISPATCH(GetPointerv, (pname, params), (F, "glGetPointerv(0x%x, %p);\n", pname, (const void *) params)); +} + +KEYWORD1 GLboolean KEYWORD2 NAME(IsTexture)(GLuint texture) +{ + RETURN_DISPATCH(IsTexture, (texture), (F, "glIsTexture(%d);\n", texture)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_331)(GLsizei n, const GLuint * textures, const GLclampf * priorities); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_331)(GLsizei n, const GLuint * textures, const GLclampf * priorities) +{ + DISPATCH(PrioritizeTextures, (n, textures, priorities), (F, "glPrioritizeTextures(%d, %p, %p);\n", n, (const void *) textures, (const void *) priorities)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_332)(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const GLvoid * pixels); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_332)(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const GLvoid * pixels) +{ + DISPATCH(TexSubImage1D, (target, level, xoffset, width, format, type, pixels), (F, "glTexSubImage1D(0x%x, %d, %d, %d, 0x%x, 0x%x, %p);\n", target, level, xoffset, width, format, type, (const void *) pixels)); +} + +KEYWORD1 void KEYWORD2 NAME(TexSubImage2D)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid * pixels) +{ + DISPATCH(TexSubImage2D, (target, level, xoffset, yoffset, width, height, format, type, pixels), (F, "glTexSubImage2D(0x%x, %d, %d, %d, %d, %d, 0x%x, 0x%x, %p);\n", target, level, xoffset, yoffset, width, height, format, type, (const void *) pixels)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_334)(void); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_334)(void) +{ + DISPATCH(PopClientAttrib, (), (F, "glPopClientAttrib();\n")); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_335)(GLbitfield mask); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_335)(GLbitfield mask) +{ + DISPATCH(PushClientAttrib, (mask), (F, "glPushClientAttrib(%d);\n", mask)); +} + +KEYWORD1 void KEYWORD2 NAME(BlendColor)(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha) +{ + DISPATCH(BlendColor, (red, green, blue, alpha), (F, "glBlendColor(%f, %f, %f, %f);\n", red, green, blue, alpha)); +} + +KEYWORD1 void KEYWORD2 NAME(BlendEquation)(GLenum mode) +{ + DISPATCH(BlendEquation, (mode), (F, "glBlendEquation(0x%x);\n", mode)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_338)(GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const GLvoid * indices); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_338)(GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const GLvoid * indices) +{ + DISPATCH(DrawRangeElements, (mode, start, end, count, type, indices), (F, "glDrawRangeElements(0x%x, %d, %d, %d, 0x%x, %p);\n", mode, start, end, count, type, (const void *) indices)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_339)(GLenum target, GLenum internalformat, GLsizei width, GLenum format, GLenum type, const GLvoid * table); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_339)(GLenum target, GLenum internalformat, GLsizei width, GLenum format, GLenum type, const GLvoid * table) +{ + DISPATCH(ColorTable, (target, internalformat, width, format, type, table), (F, "glColorTable(0x%x, 0x%x, %d, 0x%x, 0x%x, %p);\n", target, internalformat, width, format, type, (const void *) table)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_340)(GLenum target, GLenum pname, const GLfloat * params); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_340)(GLenum target, GLenum pname, const GLfloat * params) +{ + DISPATCH(ColorTableParameterfv, (target, pname, params), (F, "glColorTableParameterfv(0x%x, 0x%x, %p);\n", target, pname, (const void *) params)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_341)(GLenum target, GLenum pname, const GLint * params); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_341)(GLenum target, GLenum pname, const GLint * params) +{ + DISPATCH(ColorTableParameteriv, (target, pname, params), (F, "glColorTableParameteriv(0x%x, 0x%x, %p);\n", target, pname, (const void *) params)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_342)(GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_342)(GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width) +{ + DISPATCH(CopyColorTable, (target, internalformat, x, y, width), (F, "glCopyColorTable(0x%x, 0x%x, %d, %d, %d);\n", target, internalformat, x, y, width)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_343)(GLenum target, GLenum format, GLenum type, GLvoid * table); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_343)(GLenum target, GLenum format, GLenum type, GLvoid * table) +{ + DISPATCH(GetColorTable, (target, format, type, table), (F, "glGetColorTable(0x%x, 0x%x, 0x%x, %p);\n", target, format, type, (const void *) table)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_344)(GLenum target, GLenum pname, GLfloat * params); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_344)(GLenum target, GLenum pname, GLfloat * params) +{ + DISPATCH(GetColorTableParameterfv, (target, pname, params), (F, "glGetColorTableParameterfv(0x%x, 0x%x, %p);\n", target, pname, (const void *) params)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_345)(GLenum target, GLenum pname, GLint * params); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_345)(GLenum target, GLenum pname, GLint * params) +{ + DISPATCH(GetColorTableParameteriv, (target, pname, params), (F, "glGetColorTableParameteriv(0x%x, 0x%x, %p);\n", target, pname, (const void *) params)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_346)(GLenum target, GLsizei start, GLsizei count, GLenum format, GLenum type, const GLvoid * data); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_346)(GLenum target, GLsizei start, GLsizei count, GLenum format, GLenum type, const GLvoid * data) +{ + DISPATCH(ColorSubTable, (target, start, count, format, type, data), (F, "glColorSubTable(0x%x, %d, %d, 0x%x, 0x%x, %p);\n", target, start, count, format, type, (const void *) data)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_347)(GLenum target, GLsizei start, GLint x, GLint y, GLsizei width); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_347)(GLenum target, GLsizei start, GLint x, GLint y, GLsizei width) +{ + DISPATCH(CopyColorSubTable, (target, start, x, y, width), (F, "glCopyColorSubTable(0x%x, %d, %d, %d, %d);\n", target, start, x, y, width)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_348)(GLenum target, GLenum internalformat, GLsizei width, GLenum format, GLenum type, const GLvoid * image); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_348)(GLenum target, GLenum internalformat, GLsizei width, GLenum format, GLenum type, const GLvoid * image) +{ + DISPATCH(ConvolutionFilter1D, (target, internalformat, width, format, type, image), (F, "glConvolutionFilter1D(0x%x, 0x%x, %d, 0x%x, 0x%x, %p);\n", target, internalformat, width, format, type, (const void *) image)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_349)(GLenum target, GLenum internalformat, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid * image); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_349)(GLenum target, GLenum internalformat, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid * image) +{ + DISPATCH(ConvolutionFilter2D, (target, internalformat, width, height, format, type, image), (F, "glConvolutionFilter2D(0x%x, 0x%x, %d, %d, 0x%x, 0x%x, %p);\n", target, internalformat, width, height, format, type, (const void *) image)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_350)(GLenum target, GLenum pname, GLfloat params); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_350)(GLenum target, GLenum pname, GLfloat params) +{ + DISPATCH(ConvolutionParameterf, (target, pname, params), (F, "glConvolutionParameterf(0x%x, 0x%x, %f);\n", target, pname, params)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_351)(GLenum target, GLenum pname, const GLfloat * params); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_351)(GLenum target, GLenum pname, const GLfloat * params) +{ + DISPATCH(ConvolutionParameterfv, (target, pname, params), (F, "glConvolutionParameterfv(0x%x, 0x%x, %p);\n", target, pname, (const void *) params)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_352)(GLenum target, GLenum pname, GLint params); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_352)(GLenum target, GLenum pname, GLint params) +{ + DISPATCH(ConvolutionParameteri, (target, pname, params), (F, "glConvolutionParameteri(0x%x, 0x%x, %d);\n", target, pname, params)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_353)(GLenum target, GLenum pname, const GLint * params); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_353)(GLenum target, GLenum pname, const GLint * params) +{ + DISPATCH(ConvolutionParameteriv, (target, pname, params), (F, "glConvolutionParameteriv(0x%x, 0x%x, %p);\n", target, pname, (const void *) params)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_354)(GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_354)(GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width) +{ + DISPATCH(CopyConvolutionFilter1D, (target, internalformat, x, y, width), (F, "glCopyConvolutionFilter1D(0x%x, 0x%x, %d, %d, %d);\n", target, internalformat, x, y, width)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_355)(GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_355)(GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height) +{ + DISPATCH(CopyConvolutionFilter2D, (target, internalformat, x, y, width, height), (F, "glCopyConvolutionFilter2D(0x%x, 0x%x, %d, %d, %d, %d);\n", target, internalformat, x, y, width, height)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_356)(GLenum target, GLenum format, GLenum type, GLvoid * image); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_356)(GLenum target, GLenum format, GLenum type, GLvoid * image) +{ + DISPATCH(GetConvolutionFilter, (target, format, type, image), (F, "glGetConvolutionFilter(0x%x, 0x%x, 0x%x, %p);\n", target, format, type, (const void *) image)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_357)(GLenum target, GLenum pname, GLfloat * params); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_357)(GLenum target, GLenum pname, GLfloat * params) +{ + DISPATCH(GetConvolutionParameterfv, (target, pname, params), (F, "glGetConvolutionParameterfv(0x%x, 0x%x, %p);\n", target, pname, (const void *) params)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_358)(GLenum target, GLenum pname, GLint * params); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_358)(GLenum target, GLenum pname, GLint * params) +{ + DISPATCH(GetConvolutionParameteriv, (target, pname, params), (F, "glGetConvolutionParameteriv(0x%x, 0x%x, %p);\n", target, pname, (const void *) params)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_359)(GLenum target, GLenum format, GLenum type, GLvoid * row, GLvoid * column, GLvoid * span); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_359)(GLenum target, GLenum format, GLenum type, GLvoid * row, GLvoid * column, GLvoid * span) +{ + DISPATCH(GetSeparableFilter, (target, format, type, row, column, span), (F, "glGetSeparableFilter(0x%x, 0x%x, 0x%x, %p, %p, %p);\n", target, format, type, (const void *) row, (const void *) column, (const void *) span)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_360)(GLenum target, GLenum internalformat, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid * row, const GLvoid * column); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_360)(GLenum target, GLenum internalformat, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid * row, const GLvoid * column) +{ + DISPATCH(SeparableFilter2D, (target, internalformat, width, height, format, type, row, column), (F, "glSeparableFilter2D(0x%x, 0x%x, %d, %d, 0x%x, 0x%x, %p, %p);\n", target, internalformat, width, height, format, type, (const void *) row, (const void *) column)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_361)(GLenum target, GLboolean reset, GLenum format, GLenum type, GLvoid * values); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_361)(GLenum target, GLboolean reset, GLenum format, GLenum type, GLvoid * values) +{ + DISPATCH(GetHistogram, (target, reset, format, type, values), (F, "glGetHistogram(0x%x, %d, 0x%x, 0x%x, %p);\n", target, reset, format, type, (const void *) values)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_362)(GLenum target, GLenum pname, GLfloat * params); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_362)(GLenum target, GLenum pname, GLfloat * params) +{ + DISPATCH(GetHistogramParameterfv, (target, pname, params), (F, "glGetHistogramParameterfv(0x%x, 0x%x, %p);\n", target, pname, (const void *) params)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_363)(GLenum target, GLenum pname, GLint * params); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_363)(GLenum target, GLenum pname, GLint * params) +{ + DISPATCH(GetHistogramParameteriv, (target, pname, params), (F, "glGetHistogramParameteriv(0x%x, 0x%x, %p);\n", target, pname, (const void *) params)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_364)(GLenum target, GLboolean reset, GLenum format, GLenum type, GLvoid * values); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_364)(GLenum target, GLboolean reset, GLenum format, GLenum type, GLvoid * values) +{ + DISPATCH(GetMinmax, (target, reset, format, type, values), (F, "glGetMinmax(0x%x, %d, 0x%x, 0x%x, %p);\n", target, reset, format, type, (const void *) values)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_365)(GLenum target, GLenum pname, GLfloat * params); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_365)(GLenum target, GLenum pname, GLfloat * params) +{ + DISPATCH(GetMinmaxParameterfv, (target, pname, params), (F, "glGetMinmaxParameterfv(0x%x, 0x%x, %p);\n", target, pname, (const void *) params)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_366)(GLenum target, GLenum pname, GLint * params); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_366)(GLenum target, GLenum pname, GLint * params) +{ + DISPATCH(GetMinmaxParameteriv, (target, pname, params), (F, "glGetMinmaxParameteriv(0x%x, 0x%x, %p);\n", target, pname, (const void *) params)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_367)(GLenum target, GLsizei width, GLenum internalformat, GLboolean sink); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_367)(GLenum target, GLsizei width, GLenum internalformat, GLboolean sink) +{ + DISPATCH(Histogram, (target, width, internalformat, sink), (F, "glHistogram(0x%x, %d, 0x%x, %d);\n", target, width, internalformat, sink)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_368)(GLenum target, GLenum internalformat, GLboolean sink); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_368)(GLenum target, GLenum internalformat, GLboolean sink) +{ + DISPATCH(Minmax, (target, internalformat, sink), (F, "glMinmax(0x%x, 0x%x, %d);\n", target, internalformat, sink)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_369)(GLenum target); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_369)(GLenum target) +{ + DISPATCH(ResetHistogram, (target), (F, "glResetHistogram(0x%x);\n", target)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_370)(GLenum target); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_370)(GLenum target) +{ + DISPATCH(ResetMinmax, (target), (F, "glResetMinmax(0x%x);\n", target)); +} + +KEYWORD1 void KEYWORD2 NAME(TexImage3DOES)(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const GLvoid * pixels); + +KEYWORD1 void KEYWORD2 NAME(TexImage3DOES)(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const GLvoid * pixels) +{ + DISPATCH(TexImage3DOES, (target, level, internalformat, width, height, depth, border, format, type, pixels), (F, "glTexImage3DOES(0x%x, %d, 0x%x, %d, %d, %d, %d, 0x%x, 0x%x, %p);\n", target, level, internalformat, width, height, depth, border, format, type, (const void *) pixels)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_371)(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const GLvoid * pixels); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_371)(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const GLvoid * pixels) +{ + DISPATCH(TexImage3DOES, (target, level, internalformat, width, height, depth, border, format, type, pixels), (F, "glTexImage3D(0x%x, %d, 0x%x, %d, %d, %d, %d, 0x%x, 0x%x, %p);\n", target, level, internalformat, width, height, depth, border, format, type, (const void *) pixels)); +} + +KEYWORD1 void KEYWORD2 NAME(TexSubImage3DOES)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const GLvoid * pixels); + +KEYWORD1 void KEYWORD2 NAME(TexSubImage3DOES)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const GLvoid * pixels) +{ + DISPATCH(TexSubImage3DOES, (target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, pixels), (F, "glTexSubImage3DOES(0x%x, %d, %d, %d, %d, %d, %d, %d, 0x%x, 0x%x, %p);\n", target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, (const void *) pixels)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_372)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const GLvoid * pixels); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_372)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const GLvoid * pixels) +{ + DISPATCH(TexSubImage3DOES, (target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, pixels), (F, "glTexSubImage3D(0x%x, %d, %d, %d, %d, %d, %d, %d, 0x%x, 0x%x, %p);\n", target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, (const void *) pixels)); +} + +KEYWORD1 void KEYWORD2 NAME(CopyTexSubImage3DOES)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height); + +KEYWORD1 void KEYWORD2 NAME(CopyTexSubImage3DOES)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height) +{ + DISPATCH(CopyTexSubImage3DOES, (target, level, xoffset, yoffset, zoffset, x, y, width, height), (F, "glCopyTexSubImage3DOES(0x%x, %d, %d, %d, %d, %d, %d, %d, %d);\n", target, level, xoffset, yoffset, zoffset, x, y, width, height)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_373)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_373)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height) +{ + DISPATCH(CopyTexSubImage3DOES, (target, level, xoffset, yoffset, zoffset, x, y, width, height), (F, "glCopyTexSubImage3D(0x%x, %d, %d, %d, %d, %d, %d, %d, %d);\n", target, level, xoffset, yoffset, zoffset, x, y, width, height)); +} + +KEYWORD1 void KEYWORD2 NAME(ActiveTexture)(GLenum texture) +{ + DISPATCH(ActiveTexture, (texture), (F, "glActiveTexture(0x%x);\n", texture)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_374)(GLenum texture); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_374)(GLenum texture) +{ + DISPATCH(ActiveTexture, (texture), (F, "glActiveTextureARB(0x%x);\n", texture)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_375)(GLenum texture); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_375)(GLenum texture) +{ + DISPATCH(ClientActiveTextureARB, (texture), (F, "glClientActiveTextureARB(0x%x);\n", texture)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_376)(GLenum target, GLdouble s); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_376)(GLenum target, GLdouble s) +{ + DISPATCH(MultiTexCoord1dARB, (target, s), (F, "glMultiTexCoord1dARB(0x%x, %f);\n", target, s)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_377)(GLenum target, const GLdouble * v); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_377)(GLenum target, const GLdouble * v) +{ + DISPATCH(MultiTexCoord1dvARB, (target, v), (F, "glMultiTexCoord1dvARB(0x%x, %p);\n", target, (const void *) v)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_378)(GLenum target, GLfloat s); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_378)(GLenum target, GLfloat s) +{ + DISPATCH(MultiTexCoord1fARB, (target, s), (F, "glMultiTexCoord1fARB(0x%x, %f);\n", target, s)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_379)(GLenum target, const GLfloat * v); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_379)(GLenum target, const GLfloat * v) +{ + DISPATCH(MultiTexCoord1fvARB, (target, v), (F, "glMultiTexCoord1fvARB(0x%x, %p);\n", target, (const void *) v)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_380)(GLenum target, GLint s); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_380)(GLenum target, GLint s) +{ + DISPATCH(MultiTexCoord1iARB, (target, s), (F, "glMultiTexCoord1iARB(0x%x, %d);\n", target, s)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_381)(GLenum target, const GLint * v); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_381)(GLenum target, const GLint * v) +{ + DISPATCH(MultiTexCoord1ivARB, (target, v), (F, "glMultiTexCoord1ivARB(0x%x, %p);\n", target, (const void *) v)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_382)(GLenum target, GLshort s); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_382)(GLenum target, GLshort s) +{ + DISPATCH(MultiTexCoord1sARB, (target, s), (F, "glMultiTexCoord1sARB(0x%x, %d);\n", target, s)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_383)(GLenum target, const GLshort * v); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_383)(GLenum target, const GLshort * v) +{ + DISPATCH(MultiTexCoord1svARB, (target, v), (F, "glMultiTexCoord1svARB(0x%x, %p);\n", target, (const void *) v)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_384)(GLenum target, GLdouble s, GLdouble t); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_384)(GLenum target, GLdouble s, GLdouble t) +{ + DISPATCH(MultiTexCoord2dARB, (target, s, t), (F, "glMultiTexCoord2dARB(0x%x, %f, %f);\n", target, s, t)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_385)(GLenum target, const GLdouble * v); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_385)(GLenum target, const GLdouble * v) +{ + DISPATCH(MultiTexCoord2dvARB, (target, v), (F, "glMultiTexCoord2dvARB(0x%x, %p);\n", target, (const void *) v)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_386)(GLenum target, GLfloat s, GLfloat t); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_386)(GLenum target, GLfloat s, GLfloat t) +{ + DISPATCH(MultiTexCoord2fARB, (target, s, t), (F, "glMultiTexCoord2fARB(0x%x, %f, %f);\n", target, s, t)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_387)(GLenum target, const GLfloat * v); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_387)(GLenum target, const GLfloat * v) +{ + DISPATCH(MultiTexCoord2fvARB, (target, v), (F, "glMultiTexCoord2fvARB(0x%x, %p);\n", target, (const void *) v)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_388)(GLenum target, GLint s, GLint t); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_388)(GLenum target, GLint s, GLint t) +{ + DISPATCH(MultiTexCoord2iARB, (target, s, t), (F, "glMultiTexCoord2iARB(0x%x, %d, %d);\n", target, s, t)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_389)(GLenum target, const GLint * v); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_389)(GLenum target, const GLint * v) +{ + DISPATCH(MultiTexCoord2ivARB, (target, v), (F, "glMultiTexCoord2ivARB(0x%x, %p);\n", target, (const void *) v)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_390)(GLenum target, GLshort s, GLshort t); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_390)(GLenum target, GLshort s, GLshort t) +{ + DISPATCH(MultiTexCoord2sARB, (target, s, t), (F, "glMultiTexCoord2sARB(0x%x, %d, %d);\n", target, s, t)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_391)(GLenum target, const GLshort * v); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_391)(GLenum target, const GLshort * v) +{ + DISPATCH(MultiTexCoord2svARB, (target, v), (F, "glMultiTexCoord2svARB(0x%x, %p);\n", target, (const void *) v)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_392)(GLenum target, GLdouble s, GLdouble t, GLdouble r); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_392)(GLenum target, GLdouble s, GLdouble t, GLdouble r) +{ + DISPATCH(MultiTexCoord3dARB, (target, s, t, r), (F, "glMultiTexCoord3dARB(0x%x, %f, %f, %f);\n", target, s, t, r)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_393)(GLenum target, const GLdouble * v); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_393)(GLenum target, const GLdouble * v) +{ + DISPATCH(MultiTexCoord3dvARB, (target, v), (F, "glMultiTexCoord3dvARB(0x%x, %p);\n", target, (const void *) v)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_394)(GLenum target, GLfloat s, GLfloat t, GLfloat r); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_394)(GLenum target, GLfloat s, GLfloat t, GLfloat r) +{ + DISPATCH(MultiTexCoord3fARB, (target, s, t, r), (F, "glMultiTexCoord3fARB(0x%x, %f, %f, %f);\n", target, s, t, r)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_395)(GLenum target, const GLfloat * v); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_395)(GLenum target, const GLfloat * v) +{ + DISPATCH(MultiTexCoord3fvARB, (target, v), (F, "glMultiTexCoord3fvARB(0x%x, %p);\n", target, (const void *) v)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_396)(GLenum target, GLint s, GLint t, GLint r); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_396)(GLenum target, GLint s, GLint t, GLint r) +{ + DISPATCH(MultiTexCoord3iARB, (target, s, t, r), (F, "glMultiTexCoord3iARB(0x%x, %d, %d, %d);\n", target, s, t, r)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_397)(GLenum target, const GLint * v); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_397)(GLenum target, const GLint * v) +{ + DISPATCH(MultiTexCoord3ivARB, (target, v), (F, "glMultiTexCoord3ivARB(0x%x, %p);\n", target, (const void *) v)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_398)(GLenum target, GLshort s, GLshort t, GLshort r); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_398)(GLenum target, GLshort s, GLshort t, GLshort r) +{ + DISPATCH(MultiTexCoord3sARB, (target, s, t, r), (F, "glMultiTexCoord3sARB(0x%x, %d, %d, %d);\n", target, s, t, r)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_399)(GLenum target, const GLshort * v); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_399)(GLenum target, const GLshort * v) +{ + DISPATCH(MultiTexCoord3svARB, (target, v), (F, "glMultiTexCoord3svARB(0x%x, %p);\n", target, (const void *) v)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_400)(GLenum target, GLdouble s, GLdouble t, GLdouble r, GLdouble q); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_400)(GLenum target, GLdouble s, GLdouble t, GLdouble r, GLdouble q) +{ + DISPATCH(MultiTexCoord4dARB, (target, s, t, r, q), (F, "glMultiTexCoord4dARB(0x%x, %f, %f, %f, %f);\n", target, s, t, r, q)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_401)(GLenum target, const GLdouble * v); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_401)(GLenum target, const GLdouble * v) +{ + DISPATCH(MultiTexCoord4dvARB, (target, v), (F, "glMultiTexCoord4dvARB(0x%x, %p);\n", target, (const void *) v)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_402)(GLenum target, GLfloat s, GLfloat t, GLfloat r, GLfloat q); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_402)(GLenum target, GLfloat s, GLfloat t, GLfloat r, GLfloat q) +{ + DISPATCH(MultiTexCoord4fARB, (target, s, t, r, q), (F, "glMultiTexCoord4fARB(0x%x, %f, %f, %f, %f);\n", target, s, t, r, q)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_403)(GLenum target, const GLfloat * v); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_403)(GLenum target, const GLfloat * v) +{ + DISPATCH(MultiTexCoord4fvARB, (target, v), (F, "glMultiTexCoord4fvARB(0x%x, %p);\n", target, (const void *) v)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_404)(GLenum target, GLint s, GLint t, GLint r, GLint q); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_404)(GLenum target, GLint s, GLint t, GLint r, GLint q) +{ + DISPATCH(MultiTexCoord4iARB, (target, s, t, r, q), (F, "glMultiTexCoord4iARB(0x%x, %d, %d, %d, %d);\n", target, s, t, r, q)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_405)(GLenum target, const GLint * v); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_405)(GLenum target, const GLint * v) +{ + DISPATCH(MultiTexCoord4ivARB, (target, v), (F, "glMultiTexCoord4ivARB(0x%x, %p);\n", target, (const void *) v)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_406)(GLenum target, GLshort s, GLshort t, GLshort r, GLshort q); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_406)(GLenum target, GLshort s, GLshort t, GLshort r, GLshort q) +{ + DISPATCH(MultiTexCoord4sARB, (target, s, t, r, q), (F, "glMultiTexCoord4sARB(0x%x, %d, %d, %d, %d);\n", target, s, t, r, q)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_407)(GLenum target, const GLshort * v); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_407)(GLenum target, const GLshort * v) +{ + DISPATCH(MultiTexCoord4svARB, (target, v), (F, "glMultiTexCoord4svARB(0x%x, %p);\n", target, (const void *) v)); +} + +KEYWORD1 void KEYWORD2 NAME(GetBufferPointervOES)(GLenum target, GLenum pname, GLvoid ** params); + +KEYWORD1 void KEYWORD2 NAME(GetBufferPointervOES)(GLenum target, GLenum pname, GLvoid ** params) +{ + DISPATCH(GetBufferPointervOES, (target, pname, params), (F, "glGetBufferPointervOES(0x%x, 0x%x, %p);\n", target, pname, (const void *) params)); +} + +KEYWORD1 GLvoid * KEYWORD2 NAME(MapBufferOES)(GLenum target, GLenum access); + +KEYWORD1 GLvoid * KEYWORD2 NAME(MapBufferOES)(GLenum target, GLenum access) +{ + RETURN_DISPATCH(MapBufferOES, (target, access), (F, "glMapBufferOES(0x%x, 0x%x);\n", target, access)); +} + +KEYWORD1 GLboolean KEYWORD2 NAME(UnmapBufferOES)(GLenum target); + +KEYWORD1 GLboolean KEYWORD2 NAME(UnmapBufferOES)(GLenum target) +{ + RETURN_DISPATCH(UnmapBufferOES, (target), (F, "glUnmapBufferOES(0x%x);\n", target)); +} + +KEYWORD1 void KEYWORD2 NAME(CompressedTexImage3DOES)(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const GLvoid * data); + +KEYWORD1 void KEYWORD2 NAME(CompressedTexImage3DOES)(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const GLvoid * data) +{ + DISPATCH(CompressedTexImage3DOES, (target, level, internalformat, width, height, depth, border, imageSize, data), (F, "glCompressedTexImage3DOES(0x%x, %d, 0x%x, %d, %d, %d, %d, %d, %p);\n", target, level, internalformat, width, height, depth, border, imageSize, (const void *) data)); +} + +KEYWORD1 void KEYWORD2 NAME(CompressedTexSubImage3DOES)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const GLvoid * data); + +KEYWORD1 void KEYWORD2 NAME(CompressedTexSubImage3DOES)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const GLvoid * data) +{ + DISPATCH(CompressedTexSubImage3DOES, (target, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, data), (F, "glCompressedTexSubImage3DOES(0x%x, %d, %d, %d, %d, %d, %d, %d, 0x%x, %d, %p);\n", target, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, (const void *) data)); +} + +KEYWORD1 void KEYWORD2 NAME(FramebufferTexture3DOES)(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level, GLint zoffset); + +KEYWORD1 void KEYWORD2 NAME(FramebufferTexture3DOES)(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level, GLint zoffset) +{ + DISPATCH(FramebufferTexture3DOES, (target, attachment, textarget, texture, level, zoffset), (F, "glFramebufferTexture3DOES(0x%x, 0x%x, 0x%x, %d, %d, %d);\n", target, attachment, textarget, texture, level, zoffset)); +} + +KEYWORD1 void KEYWORD2 NAME(GetProgramBinaryOES)(GLuint program, GLsizei bufSize, GLsizei * length, GLenum * binaryFormat, GLvoid * binary); + +KEYWORD1 void KEYWORD2 NAME(GetProgramBinaryOES)(GLuint program, GLsizei bufSize, GLsizei * length, GLenum * binaryFormat, GLvoid * binary) +{ + DISPATCH(GetProgramBinaryOES, (program, bufSize, length, binaryFormat, binary), (F, "glGetProgramBinaryOES(%d, %d, %p, %p, %p);\n", program, bufSize, (const void *) length, (const void *) binaryFormat, (const void *) binary)); +} + +KEYWORD1 void KEYWORD2 NAME(ProgramBinaryOES)(GLuint program, GLenum binaryFormat, const GLvoid * binary, GLint length); + +KEYWORD1 void KEYWORD2 NAME(ProgramBinaryOES)(GLuint program, GLenum binaryFormat, const GLvoid * binary, GLint length) +{ + DISPATCH(ProgramBinaryOES, (program, binaryFormat, binary, length), (F, "glProgramBinaryOES(%d, 0x%x, %p, %d);\n", program, binaryFormat, (const void *) binary, length)); +} + +KEYWORD1 void KEYWORD2 NAME(MultiDrawArraysEXT)(GLenum mode, const GLint * first, const GLsizei * count, GLsizei primcount) +{ + DISPATCH(MultiDrawArraysEXT, (mode, first, count, primcount), (F, "glMultiDrawArraysEXT(0x%x, %p, %p, %d);\n", mode, (const void *) first, (const void *) count, primcount)); +} + +KEYWORD1 void KEYWORD2 NAME(MultiDrawElementsEXT)(GLenum mode, const GLsizei * count, GLenum type, const GLvoid ** indices, GLsizei primcount) +{ + DISPATCH(MultiDrawElementsEXT, (mode, count, type, indices, primcount), (F, "glMultiDrawElementsEXT(0x%x, %p, 0x%x, %p, %d);\n", mode, (const void *) count, type, (const void *) indices, primcount)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_418)(GLuint array); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_418)(GLuint array) +{ + DISPATCH(BindVertexArrayAPPLE, (array), (F, "glBindVertexArrayAPPLE(%d);\n", array)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_419)(GLsizei n, const GLuint * arrays); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_419)(GLsizei n, const GLuint * arrays) +{ + DISPATCH(DeleteVertexArraysAPPLE, (n, arrays), (F, "glDeleteVertexArraysAPPLE(%d, %p);\n", n, (const void *) arrays)); +} + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_420)(GLsizei n, GLuint * arrays); + +KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_420)(GLsizei n, GLuint * arrays) +{ + DISPATCH(GenVertexArraysAPPLE, (n, arrays), (F, "glGenVertexArraysAPPLE(%d, %p);\n", n, (const void *) arrays)); +} + +KEYWORD1_ALT GLboolean KEYWORD2 NAME(_dispatch_stub_421)(GLuint array); + +KEYWORD1_ALT GLboolean KEYWORD2 NAME(_dispatch_stub_421)(GLuint array) +{ + RETURN_DISPATCH(IsVertexArrayAPPLE, (array), (F, "glIsVertexArrayAPPLE(%d);\n", array)); +} + +KEYWORD1 void KEYWORD2 NAME(EGLImageTargetRenderbufferStorageOES)(GLenum target, GLvoid * writeOffset); + +KEYWORD1 void KEYWORD2 NAME(EGLImageTargetRenderbufferStorageOES)(GLenum target, GLvoid * writeOffset) +{ + DISPATCH(EGLImageTargetRenderbufferStorageOES, (target, writeOffset), (F, "glEGLImageTargetRenderbufferStorageOES(0x%x, %p);\n", target, (const void *) writeOffset)); +} + +KEYWORD1 void KEYWORD2 NAME(EGLImageTargetTexture2DOES)(GLenum target, GLvoid * writeOffset); + +KEYWORD1 void KEYWORD2 NAME(EGLImageTargetTexture2DOES)(GLenum target, GLvoid * writeOffset) +{ + DISPATCH(EGLImageTargetTexture2DOES, (target, writeOffset), (F, "glEGLImageTargetTexture2DOES(0x%x, %p);\n", target, (const void *) writeOffset)); +} + +KEYWORD1 void KEYWORD2 NAME(CompressedTexImage2D)(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const GLvoid * data) +{ + DISPATCH(CompressedTexImage2D, (target, level, internalformat, width, height, border, imageSize, data), (F, "glCompressedTexImage2D(0x%x, %d, 0x%x, %d, %d, %d, %d, %p);\n", target, level, internalformat, width, height, border, imageSize, (const void *) data)); +} + +KEYWORD1 void KEYWORD2 NAME(CompressedTexSubImage2D)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const GLvoid * data) +{ + DISPATCH(CompressedTexSubImage2D, (target, level, xoffset, yoffset, width, height, format, imageSize, data), (F, "glCompressedTexSubImage2D(0x%x, %d, %d, %d, %d, %d, 0x%x, %d, %p);\n", target, level, xoffset, yoffset, width, height, format, imageSize, (const void *) data)); +} + +KEYWORD1 void KEYWORD2 NAME(SampleCoverage)(GLclampf value, GLboolean invert) +{ + DISPATCH(SampleCoverage, (value, invert), (F, "glSampleCoverage(%f, %d);\n", value, invert)); +} + +KEYWORD1 void KEYWORD2 NAME(BindBuffer)(GLenum target, GLuint buffer) +{ + DISPATCH(BindBuffer, (target, buffer), (F, "glBindBuffer(0x%x, %d);\n", target, buffer)); +} + +KEYWORD1 void KEYWORD2 NAME(BufferData)(GLenum target, GLsizeiptr size, const GLvoid * data, GLenum usage) +{ + DISPATCH(BufferData, (target, size, data, usage), (F, "glBufferData(0x%x, %d, %p, 0x%x);\n", target, size, (const void *) data, usage)); +} + +KEYWORD1 void KEYWORD2 NAME(BufferSubData)(GLenum target, GLintptr offset, GLsizeiptr size, const GLvoid * data) +{ + DISPATCH(BufferSubData, (target, offset, size, data), (F, "glBufferSubData(0x%x, %d, %d, %p);\n", target, offset, size, (const void *) data)); +} + +KEYWORD1 void KEYWORD2 NAME(DeleteBuffers)(GLsizei n, const GLuint * buffer) +{ + DISPATCH(DeleteBuffers, (n, buffer), (F, "glDeleteBuffers(%d, %p);\n", n, (const void *) buffer)); +} + +KEYWORD1 void KEYWORD2 NAME(GenBuffers)(GLsizei n, GLuint * buffer) +{ + DISPATCH(GenBuffers, (n, buffer), (F, "glGenBuffers(%d, %p);\n", n, (const void *) buffer)); +} + +KEYWORD1 void KEYWORD2 NAME(GetBufferParameteriv)(GLenum target, GLenum pname, GLint * params) +{ + DISPATCH(GetBufferParameteriv, (target, pname, params), (F, "glGetBufferParameteriv(0x%x, 0x%x, %p);\n", target, pname, (const void *) params)); +} + +KEYWORD1 GLboolean KEYWORD2 NAME(IsBuffer)(GLuint buffer) +{ + RETURN_DISPATCH(IsBuffer, (buffer), (F, "glIsBuffer(%d);\n", buffer)); +} + +KEYWORD1 void KEYWORD2 NAME(AttachShader)(GLuint program, GLuint shader) +{ + DISPATCH(AttachShader, (program, shader), (F, "glAttachShader(%d, %d);\n", program, shader)); +} + +KEYWORD1 void KEYWORD2 NAME(BindAttribLocation)(GLuint program, GLuint index, const GLchar * name) +{ + DISPATCH(BindAttribLocation, (program, index, name), (F, "glBindAttribLocation(%d, %d, %p);\n", program, index, (const void *) name)); +} + +KEYWORD1 void KEYWORD2 NAME(BlendEquationSeparate)(GLenum modeRGB, GLenum modeA) +{ + DISPATCH(BlendEquationSeparate, (modeRGB, modeA), (F, "glBlendEquationSeparate(0x%x, 0x%x);\n", modeRGB, modeA)); +} + +KEYWORD1 void KEYWORD2 NAME(CompileShader)(GLuint shader) +{ + DISPATCH(CompileShader, (shader), (F, "glCompileShader(%d);\n", shader)); +} + +KEYWORD1 GLuint KEYWORD2 NAME(CreateProgram)(void) +{ + RETURN_DISPATCH(CreateProgram, (), (F, "glCreateProgram();\n")); +} + +KEYWORD1 GLuint KEYWORD2 NAME(CreateShader)(GLenum type) +{ + RETURN_DISPATCH(CreateShader, (type), (F, "glCreateShader(0x%x);\n", type)); +} + +KEYWORD1 void KEYWORD2 NAME(DeleteProgram)(GLuint program) +{ + DISPATCH(DeleteProgram, (program), (F, "glDeleteProgram(%d);\n", program)); +} + +KEYWORD1 void KEYWORD2 NAME(DeleteShader)(GLuint program) +{ + DISPATCH(DeleteShader, (program), (F, "glDeleteShader(%d);\n", program)); +} + +KEYWORD1 void KEYWORD2 NAME(DetachShader)(GLuint program, GLuint shader) +{ + DISPATCH(DetachShader, (program, shader), (F, "glDetachShader(%d, %d);\n", program, shader)); +} + +KEYWORD1 void KEYWORD2 NAME(DisableVertexAttribArray)(GLuint index) +{ + DISPATCH(DisableVertexAttribArray, (index), (F, "glDisableVertexAttribArray(%d);\n", index)); +} + +KEYWORD1 void KEYWORD2 NAME(EnableVertexAttribArray)(GLuint index) +{ + DISPATCH(EnableVertexAttribArray, (index), (F, "glEnableVertexAttribArray(%d);\n", index)); +} + +KEYWORD1 void KEYWORD2 NAME(GetActiveAttrib)(GLuint program, GLuint index, GLsizei bufSize, GLsizei * length, GLint * size, GLenum * type, GLchar * name) +{ + DISPATCH(GetActiveAttrib, (program, index, bufSize, length, size, type, name), (F, "glGetActiveAttrib(%d, %d, %d, %p, %p, %p, %p);\n", program, index, bufSize, (const void *) length, (const void *) size, (const void *) type, (const void *) name)); +} + +KEYWORD1 void KEYWORD2 NAME(GetActiveUniform)(GLuint program, GLuint index, GLsizei bufSize, GLsizei * length, GLint * size, GLenum * type, GLchar * name) +{ + DISPATCH(GetActiveUniform, (program, index, bufSize, length, size, type, name), (F, "glGetActiveUniform(%d, %d, %d, %p, %p, %p, %p);\n", program, index, bufSize, (const void *) length, (const void *) size, (const void *) type, (const void *) name)); +} + +KEYWORD1 void KEYWORD2 NAME(GetAttachedShaders)(GLuint program, GLsizei maxCount, GLsizei * count, GLuint * obj) +{ + DISPATCH(GetAttachedShaders, (program, maxCount, count, obj), (F, "glGetAttachedShaders(%d, %d, %p, %p);\n", program, maxCount, (const void *) count, (const void *) obj)); +} + +KEYWORD1 GLint KEYWORD2 NAME(GetAttribLocation)(GLuint program, const GLchar * name) +{ + RETURN_DISPATCH(GetAttribLocation, (program, name), (F, "glGetAttribLocation(%d, %p);\n", program, (const void *) name)); +} + +KEYWORD1 void KEYWORD2 NAME(GetProgramInfoLog)(GLuint program, GLsizei bufSize, GLsizei * length, GLchar * infoLog) +{ + DISPATCH(GetProgramInfoLog, (program, bufSize, length, infoLog), (F, "glGetProgramInfoLog(%d, %d, %p, %p);\n", program, bufSize, (const void *) length, (const void *) infoLog)); +} + +KEYWORD1 void KEYWORD2 NAME(GetProgramiv)(GLuint program, GLenum pname, GLint * params) +{ + DISPATCH(GetProgramiv, (program, pname, params), (F, "glGetProgramiv(%d, 0x%x, %p);\n", program, pname, (const void *) params)); +} + +KEYWORD1 void KEYWORD2 NAME(GetShaderInfoLog)(GLuint shader, GLsizei bufSize, GLsizei * length, GLchar * infoLog) +{ + DISPATCH(GetShaderInfoLog, (shader, bufSize, length, infoLog), (F, "glGetShaderInfoLog(%d, %d, %p, %p);\n", shader, bufSize, (const void *) length, (const void *) infoLog)); +} + +KEYWORD1 void KEYWORD2 NAME(GetShaderSource)(GLuint shader, GLsizei bufSize, GLsizei * length, GLchar * source) +{ + DISPATCH(GetShaderSource, (shader, bufSize, length, source), (F, "glGetShaderSource(%d, %d, %p, %p);\n", shader, bufSize, (const void *) length, (const void *) source)); +} + +KEYWORD1 void KEYWORD2 NAME(GetShaderiv)(GLuint shader, GLenum pname, GLint * params) +{ + DISPATCH(GetShaderiv, (shader, pname, params), (F, "glGetShaderiv(%d, 0x%x, %p);\n", shader, pname, (const void *) params)); +} + +KEYWORD1 GLint KEYWORD2 NAME(GetUniformLocation)(GLuint program, const GLchar * name) +{ + RETURN_DISPATCH(GetUniformLocation, (program, name), (F, "glGetUniformLocation(%d, %p);\n", program, (const void *) name)); +} + +KEYWORD1 void KEYWORD2 NAME(GetUniformfv)(GLuint program, GLint location, GLfloat * params) +{ + DISPATCH(GetUniformfv, (program, location, params), (F, "glGetUniformfv(%d, %d, %p);\n", program, location, (const void *) params)); +} + +KEYWORD1 void KEYWORD2 NAME(GetUniformiv)(GLuint program, GLint location, GLint * params) +{ + DISPATCH(GetUniformiv, (program, location, params), (F, "glGetUniformiv(%d, %d, %p);\n", program, location, (const void *) params)); +} + +KEYWORD1 void KEYWORD2 NAME(GetVertexAttribPointerv)(GLuint index, GLenum pname, GLvoid ** pointer) +{ + DISPATCH(GetVertexAttribPointerv, (index, pname, pointer), (F, "glGetVertexAttribPointerv(%d, 0x%x, %p);\n", index, pname, (const void *) pointer)); +} + +KEYWORD1 void KEYWORD2 NAME(GetVertexAttribfv)(GLuint index, GLenum pname, GLfloat * params) +{ + DISPATCH(GetVertexAttribfv, (index, pname, params), (F, "glGetVertexAttribfv(%d, 0x%x, %p);\n", index, pname, (const void *) params)); +} + +KEYWORD1 void KEYWORD2 NAME(GetVertexAttribiv)(GLuint index, GLenum pname, GLint * params) +{ + DISPATCH(GetVertexAttribiv, (index, pname, params), (F, "glGetVertexAttribiv(%d, 0x%x, %p);\n", index, pname, (const void *) params)); +} + +KEYWORD1 GLboolean KEYWORD2 NAME(IsProgram)(GLuint program) +{ + RETURN_DISPATCH(IsProgram, (program), (F, "glIsProgram(%d);\n", program)); +} + +KEYWORD1 GLboolean KEYWORD2 NAME(IsShader)(GLuint shader) +{ + RETURN_DISPATCH(IsShader, (shader), (F, "glIsShader(%d);\n", shader)); +} + +KEYWORD1 void KEYWORD2 NAME(LinkProgram)(GLuint program) +{ + DISPATCH(LinkProgram, (program), (F, "glLinkProgram(%d);\n", program)); +} + +KEYWORD1 void KEYWORD2 NAME(ShaderSource)(GLuint shader, GLsizei count, const GLchar ** string, const GLint * length) +{ + DISPATCH(ShaderSource, (shader, count, string, length), (F, "glShaderSource(%d, %d, %p, %p);\n", shader, count, (const void *) string, (const void *) length)); +} + +KEYWORD1 void KEYWORD2 NAME(StencilFuncSeparate)(GLenum face, GLenum func, GLint ref, GLuint mask) +{ + DISPATCH(StencilFuncSeparate, (face, func, ref, mask), (F, "glStencilFuncSeparate(0x%x, 0x%x, %d, %d);\n", face, func, ref, mask)); +} + +KEYWORD1 void KEYWORD2 NAME(StencilMaskSeparate)(GLenum face, GLuint mask) +{ + DISPATCH(StencilMaskSeparate, (face, mask), (F, "glStencilMaskSeparate(0x%x, %d);\n", face, mask)); +} + +KEYWORD1 void KEYWORD2 NAME(StencilOpSeparate)(GLenum face, GLenum sfail, GLenum zfail, GLenum zpass) +{ + DISPATCH(StencilOpSeparate, (face, sfail, zfail, zpass), (F, "glStencilOpSeparate(0x%x, 0x%x, 0x%x, 0x%x);\n", face, sfail, zfail, zpass)); +} + +KEYWORD1 void KEYWORD2 NAME(Uniform1f)(GLint location, GLfloat v0) +{ + DISPATCH(Uniform1f, (location, v0), (F, "glUniform1f(%d, %f);\n", location, v0)); +} + +KEYWORD1 void KEYWORD2 NAME(Uniform1fv)(GLint location, GLsizei count, const GLfloat * value) +{ + DISPATCH(Uniform1fv, (location, count, value), (F, "glUniform1fv(%d, %d, %p);\n", location, count, (const void *) value)); +} + +KEYWORD1 void KEYWORD2 NAME(Uniform1i)(GLint location, GLint v0) +{ + DISPATCH(Uniform1i, (location, v0), (F, "glUniform1i(%d, %d);\n", location, v0)); +} + +KEYWORD1 void KEYWORD2 NAME(Uniform1iv)(GLint location, GLsizei count, const GLint * value) +{ + DISPATCH(Uniform1iv, (location, count, value), (F, "glUniform1iv(%d, %d, %p);\n", location, count, (const void *) value)); +} + +KEYWORD1 void KEYWORD2 NAME(Uniform2f)(GLint location, GLfloat v0, GLfloat v1) +{ + DISPATCH(Uniform2f, (location, v0, v1), (F, "glUniform2f(%d, %f, %f);\n", location, v0, v1)); +} + +KEYWORD1 void KEYWORD2 NAME(Uniform2fv)(GLint location, GLsizei count, const GLfloat * value) +{ + DISPATCH(Uniform2fv, (location, count, value), (F, "glUniform2fv(%d, %d, %p);\n", location, count, (const void *) value)); +} + +KEYWORD1 void KEYWORD2 NAME(Uniform2i)(GLint location, GLint v0, GLint v1) +{ + DISPATCH(Uniform2i, (location, v0, v1), (F, "glUniform2i(%d, %d, %d);\n", location, v0, v1)); +} + +KEYWORD1 void KEYWORD2 NAME(Uniform2iv)(GLint location, GLsizei count, const GLint * value) +{ + DISPATCH(Uniform2iv, (location, count, value), (F, "glUniform2iv(%d, %d, %p);\n", location, count, (const void *) value)); +} + +KEYWORD1 void KEYWORD2 NAME(Uniform3f)(GLint location, GLfloat v0, GLfloat v1, GLfloat v2) +{ + DISPATCH(Uniform3f, (location, v0, v1, v2), (F, "glUniform3f(%d, %f, %f, %f);\n", location, v0, v1, v2)); +} + +KEYWORD1 void KEYWORD2 NAME(Uniform3fv)(GLint location, GLsizei count, const GLfloat * value) +{ + DISPATCH(Uniform3fv, (location, count, value), (F, "glUniform3fv(%d, %d, %p);\n", location, count, (const void *) value)); +} + +KEYWORD1 void KEYWORD2 NAME(Uniform3i)(GLint location, GLint v0, GLint v1, GLint v2) +{ + DISPATCH(Uniform3i, (location, v0, v1, v2), (F, "glUniform3i(%d, %d, %d, %d);\n", location, v0, v1, v2)); +} + +KEYWORD1 void KEYWORD2 NAME(Uniform3iv)(GLint location, GLsizei count, const GLint * value) +{ + DISPATCH(Uniform3iv, (location, count, value), (F, "glUniform3iv(%d, %d, %p);\n", location, count, (const void *) value)); +} + +KEYWORD1 void KEYWORD2 NAME(Uniform4f)(GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3) +{ + DISPATCH(Uniform4f, (location, v0, v1, v2, v3), (F, "glUniform4f(%d, %f, %f, %f, %f);\n", location, v0, v1, v2, v3)); +} + +KEYWORD1 void KEYWORD2 NAME(Uniform4fv)(GLint location, GLsizei count, const GLfloat * value) +{ + DISPATCH(Uniform4fv, (location, count, value), (F, "glUniform4fv(%d, %d, %p);\n", location, count, (const void *) value)); +} + +KEYWORD1 void KEYWORD2 NAME(Uniform4i)(GLint location, GLint v0, GLint v1, GLint v2, GLint v3) +{ + DISPATCH(Uniform4i, (location, v0, v1, v2, v3), (F, "glUniform4i(%d, %d, %d, %d, %d);\n", location, v0, v1, v2, v3)); +} + +KEYWORD1 void KEYWORD2 NAME(Uniform4iv)(GLint location, GLsizei count, const GLint * value) +{ + DISPATCH(Uniform4iv, (location, count, value), (F, "glUniform4iv(%d, %d, %p);\n", location, count, (const void *) value)); +} + +KEYWORD1 void KEYWORD2 NAME(UniformMatrix2fv)(GLint location, GLsizei count, GLboolean transpose, const GLfloat * value) +{ + DISPATCH(UniformMatrix2fv, (location, count, transpose, value), (F, "glUniformMatrix2fv(%d, %d, %d, %p);\n", location, count, transpose, (const void *) value)); +} + +KEYWORD1 void KEYWORD2 NAME(UniformMatrix3fv)(GLint location, GLsizei count, GLboolean transpose, const GLfloat * value) +{ + DISPATCH(UniformMatrix3fv, (location, count, transpose, value), (F, "glUniformMatrix3fv(%d, %d, %d, %p);\n", location, count, transpose, (const void *) value)); +} + +KEYWORD1 void KEYWORD2 NAME(UniformMatrix4fv)(GLint location, GLsizei count, GLboolean transpose, const GLfloat * value) +{ + DISPATCH(UniformMatrix4fv, (location, count, transpose, value), (F, "glUniformMatrix4fv(%d, %d, %d, %p);\n", location, count, transpose, (const void *) value)); +} + +KEYWORD1 void KEYWORD2 NAME(UseProgram)(GLuint program) +{ + DISPATCH(UseProgram, (program), (F, "glUseProgram(%d);\n", program)); +} + +KEYWORD1 void KEYWORD2 NAME(ValidateProgram)(GLuint program) +{ + DISPATCH(ValidateProgram, (program), (F, "glValidateProgram(%d);\n", program)); +} + +KEYWORD1 void KEYWORD2 NAME(VertexAttrib1f)(GLuint index, GLfloat x) +{ + DISPATCH(VertexAttrib1f, (index, x), (F, "glVertexAttrib1f(%d, %f);\n", index, x)); +} + +KEYWORD1 void KEYWORD2 NAME(VertexAttrib1fv)(GLuint index, const GLfloat * v) +{ + DISPATCH(VertexAttrib1fv, (index, v), (F, "glVertexAttrib1fv(%d, %p);\n", index, (const void *) v)); +} + +KEYWORD1 void KEYWORD2 NAME(VertexAttrib2f)(GLuint index, GLfloat x, GLfloat y) +{ + DISPATCH(VertexAttrib2f, (index, x, y), (F, "glVertexAttrib2f(%d, %f, %f);\n", index, x, y)); +} + +KEYWORD1 void KEYWORD2 NAME(VertexAttrib2fv)(GLuint index, const GLfloat * v) +{ + DISPATCH(VertexAttrib2fv, (index, v), (F, "glVertexAttrib2fv(%d, %p);\n", index, (const void *) v)); +} + +KEYWORD1 void KEYWORD2 NAME(VertexAttrib3f)(GLuint index, GLfloat x, GLfloat y, GLfloat z) +{ + DISPATCH(VertexAttrib3f, (index, x, y, z), (F, "glVertexAttrib3f(%d, %f, %f, %f);\n", index, x, y, z)); +} + +KEYWORD1 void KEYWORD2 NAME(VertexAttrib3fv)(GLuint index, const GLfloat * v) +{ + DISPATCH(VertexAttrib3fv, (index, v), (F, "glVertexAttrib3fv(%d, %p);\n", index, (const void *) v)); +} + +KEYWORD1 void KEYWORD2 NAME(VertexAttrib4f)(GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w) +{ + DISPATCH(VertexAttrib4f, (index, x, y, z, w), (F, "glVertexAttrib4f(%d, %f, %f, %f, %f);\n", index, x, y, z, w)); +} + +KEYWORD1 void KEYWORD2 NAME(VertexAttrib4fv)(GLuint index, const GLfloat * v) +{ + DISPATCH(VertexAttrib4fv, (index, v), (F, "glVertexAttrib4fv(%d, %p);\n", index, (const void *) v)); +} + +KEYWORD1 void KEYWORD2 NAME(VertexAttribPointer)(GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const GLvoid * pointer) +{ + DISPATCH(VertexAttribPointer, (index, size, type, normalized, stride, pointer), (F, "glVertexAttribPointer(%d, %d, 0x%x, %d, %d, %p);\n", index, size, type, normalized, stride, (const void *) pointer)); +} + +KEYWORD1 void KEYWORD2 NAME(BlendFuncSeparate)(GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha) +{ + DISPATCH(BlendFuncSeparate, (sfactorRGB, dfactorRGB, sfactorAlpha, dfactorAlpha), (F, "glBlendFuncSeparate(0x%x, 0x%x, 0x%x, 0x%x);\n", sfactorRGB, dfactorRGB, sfactorAlpha, dfactorAlpha)); +} + +KEYWORD1 void KEYWORD2 NAME(BindFramebuffer)(GLenum target, GLuint framebuffer); + +KEYWORD1 void KEYWORD2 NAME(BindFramebuffer)(GLenum target, GLuint framebuffer) +{ + DISPATCH(BindFramebuffer, (target, framebuffer), (F, "glBindFramebuffer(0x%x, %d);\n", target, framebuffer)); +} + +KEYWORD1 void KEYWORD2 NAME(BindRenderbuffer)(GLenum target, GLuint renderbuffer); + +KEYWORD1 void KEYWORD2 NAME(BindRenderbuffer)(GLenum target, GLuint renderbuffer) +{ + DISPATCH(BindRenderbuffer, (target, renderbuffer), (F, "glBindRenderbuffer(0x%x, %d);\n", target, renderbuffer)); +} + +KEYWORD1 GLenum KEYWORD2 NAME(CheckFramebufferStatus)(GLenum target); + +KEYWORD1 GLenum KEYWORD2 NAME(CheckFramebufferStatus)(GLenum target) +{ + RETURN_DISPATCH(CheckFramebufferStatus, (target), (F, "glCheckFramebufferStatus(0x%x);\n", target)); +} + +KEYWORD1 void KEYWORD2 NAME(ClearDepthf)(GLclampf depth); + +KEYWORD1 void KEYWORD2 NAME(ClearDepthf)(GLclampf depth) +{ + DISPATCH(ClearDepthf, (depth), (F, "glClearDepthf(%f);\n", depth)); +} + +KEYWORD1 void KEYWORD2 NAME(DeleteFramebuffers)(GLsizei n, const GLuint * framebuffers); + +KEYWORD1 void KEYWORD2 NAME(DeleteFramebuffers)(GLsizei n, const GLuint * framebuffers) +{ + DISPATCH(DeleteFramebuffers, (n, framebuffers), (F, "glDeleteFramebuffers(%d, %p);\n", n, (const void *) framebuffers)); +} + +KEYWORD1 void KEYWORD2 NAME(DeleteRenderbuffers)(GLsizei n, const GLuint * renderbuffers); + +KEYWORD1 void KEYWORD2 NAME(DeleteRenderbuffers)(GLsizei n, const GLuint * renderbuffers) +{ + DISPATCH(DeleteRenderbuffers, (n, renderbuffers), (F, "glDeleteRenderbuffers(%d, %p);\n", n, (const void *) renderbuffers)); +} + +KEYWORD1 void KEYWORD2 NAME(DepthRangef)(GLclampf zNear, GLclampf zFar); + +KEYWORD1 void KEYWORD2 NAME(DepthRangef)(GLclampf zNear, GLclampf zFar) +{ + DISPATCH(DepthRangef, (zNear, zFar), (F, "glDepthRangef(%f, %f);\n", zNear, zFar)); +} + +KEYWORD1 void KEYWORD2 NAME(FramebufferRenderbuffer)(GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer); + +KEYWORD1 void KEYWORD2 NAME(FramebufferRenderbuffer)(GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer) +{ + DISPATCH(FramebufferRenderbuffer, (target, attachment, renderbuffertarget, renderbuffer), (F, "glFramebufferRenderbuffer(0x%x, 0x%x, 0x%x, %d);\n", target, attachment, renderbuffertarget, renderbuffer)); +} + +KEYWORD1 void KEYWORD2 NAME(FramebufferTexture2D)(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level); + +KEYWORD1 void KEYWORD2 NAME(FramebufferTexture2D)(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level) +{ + DISPATCH(FramebufferTexture2D, (target, attachment, textarget, texture, level), (F, "glFramebufferTexture2D(0x%x, 0x%x, 0x%x, %d, %d);\n", target, attachment, textarget, texture, level)); +} + +KEYWORD1 void KEYWORD2 NAME(GenFramebuffers)(GLsizei n, GLuint * framebuffers); + +KEYWORD1 void KEYWORD2 NAME(GenFramebuffers)(GLsizei n, GLuint * framebuffers) +{ + DISPATCH(GenFramebuffers, (n, framebuffers), (F, "glGenFramebuffers(%d, %p);\n", n, (const void *) framebuffers)); +} + +KEYWORD1 void KEYWORD2 NAME(GenRenderbuffers)(GLsizei n, GLuint * renderbuffers); + +KEYWORD1 void KEYWORD2 NAME(GenRenderbuffers)(GLsizei n, GLuint * renderbuffers) +{ + DISPATCH(GenRenderbuffers, (n, renderbuffers), (F, "glGenRenderbuffers(%d, %p);\n", n, (const void *) renderbuffers)); +} + +KEYWORD1 void KEYWORD2 NAME(GenerateMipmap)(GLenum target); + +KEYWORD1 void KEYWORD2 NAME(GenerateMipmap)(GLenum target) +{ + DISPATCH(GenerateMipmap, (target), (F, "glGenerateMipmap(0x%x);\n", target)); +} + +KEYWORD1 void KEYWORD2 NAME(GetFramebufferAttachmentParameteriv)(GLenum target, GLenum attachment, GLenum pname, GLint * params); + +KEYWORD1 void KEYWORD2 NAME(GetFramebufferAttachmentParameteriv)(GLenum target, GLenum attachment, GLenum pname, GLint * params) +{ + DISPATCH(GetFramebufferAttachmentParameteriv, (target, attachment, pname, params), (F, "glGetFramebufferAttachmentParameteriv(0x%x, 0x%x, 0x%x, %p);\n", target, attachment, pname, (const void *) params)); +} + +KEYWORD1 void KEYWORD2 NAME(GetRenderbufferParameteriv)(GLenum target, GLenum pname, GLint * params); + +KEYWORD1 void KEYWORD2 NAME(GetRenderbufferParameteriv)(GLenum target, GLenum pname, GLint * params) +{ + DISPATCH(GetRenderbufferParameteriv, (target, pname, params), (F, "glGetRenderbufferParameteriv(0x%x, 0x%x, %p);\n", target, pname, (const void *) params)); +} + +KEYWORD1 void KEYWORD2 NAME(GetShaderPrecisionFormat)(GLenum shadertype, GLenum precisiontype, GLint * range, GLint * precision); + +KEYWORD1 void KEYWORD2 NAME(GetShaderPrecisionFormat)(GLenum shadertype, GLenum precisiontype, GLint * range, GLint * precision) +{ + DISPATCH(GetShaderPrecisionFormat, (shadertype, precisiontype, range, precision), (F, "glGetShaderPrecisionFormat(0x%x, 0x%x, %p, %p);\n", shadertype, precisiontype, (const void *) range, (const void *) precision)); +} + +KEYWORD1 GLboolean KEYWORD2 NAME(IsFramebuffer)(GLuint framebuffer); + +KEYWORD1 GLboolean KEYWORD2 NAME(IsFramebuffer)(GLuint framebuffer) +{ + RETURN_DISPATCH(IsFramebuffer, (framebuffer), (F, "glIsFramebuffer(%d);\n", framebuffer)); +} + +KEYWORD1 GLboolean KEYWORD2 NAME(IsRenderbuffer)(GLuint renderbuffer); + +KEYWORD1 GLboolean KEYWORD2 NAME(IsRenderbuffer)(GLuint renderbuffer) +{ + RETURN_DISPATCH(IsRenderbuffer, (renderbuffer), (F, "glIsRenderbuffer(%d);\n", renderbuffer)); +} + +KEYWORD1 void KEYWORD2 NAME(ReleaseShaderCompiler)(void); + +KEYWORD1 void KEYWORD2 NAME(ReleaseShaderCompiler)(void) +{ + DISPATCH(ReleaseShaderCompiler, (), (F, "glReleaseShaderCompiler();\n")); +} + +KEYWORD1 void KEYWORD2 NAME(RenderbufferStorage)(GLenum target, GLenum internalformat, GLsizei width, GLsizei height); + +KEYWORD1 void KEYWORD2 NAME(RenderbufferStorage)(GLenum target, GLenum internalformat, GLsizei width, GLsizei height) +{ + DISPATCH(RenderbufferStorage, (target, internalformat, width, height), (F, "glRenderbufferStorage(0x%x, 0x%x, %d, %d);\n", target, internalformat, width, height)); +} + +KEYWORD1 void KEYWORD2 NAME(ShaderBinary)(GLsizei n, const GLuint * shaders, GLenum binaryformat, const GLvoid * binary, GLsizei length); + +KEYWORD1 void KEYWORD2 NAME(ShaderBinary)(GLsizei n, const GLuint * shaders, GLenum binaryformat, const GLvoid * binary, GLsizei length) +{ + DISPATCH(ShaderBinary, (n, shaders, binaryformat, binary, length), (F, "glShaderBinary(%d, %p, 0x%x, %p, %d);\n", n, (const void *) shaders, binaryformat, (const void *) binary, length)); +} + + +#endif /* _GLAPI_SKIP_NORMAL_ENTRY_POINTS */ + +/* these entry points might require different protocols */ +#ifndef _GLAPI_SKIP_PROTO_ENTRY_POINTS + + +#endif /* _GLAPI_SKIP_PROTO_ENTRY_POINTS */ + + +#endif /* defined( NAME ) */ + +/* + * This is how a dispatch table can be initialized with all the functions + * we generated above. + */ +#ifdef DISPATCH_TABLE_NAME + +#ifndef TABLE_ENTRY +#error TABLE_ENTRY must be defined +#endif + +#ifdef _GLAPI_SKIP_NORMAL_ENTRY_POINTS +#error _GLAPI_SKIP_NORMAL_ENTRY_POINTS must not be defined +#endif + +_glapi_proc DISPATCH_TABLE_NAME[] = { + TABLE_ENTRY(_dispatch_stub_0), + TABLE_ENTRY(_dispatch_stub_1), + TABLE_ENTRY(_dispatch_stub_2), + TABLE_ENTRY(_dispatch_stub_3), + TABLE_ENTRY(_dispatch_stub_4), + TABLE_ENTRY(_dispatch_stub_5), + TABLE_ENTRY(_dispatch_stub_6), + TABLE_ENTRY(_dispatch_stub_7), + TABLE_ENTRY(_dispatch_stub_8), + TABLE_ENTRY(_dispatch_stub_9), + TABLE_ENTRY(_dispatch_stub_10), + TABLE_ENTRY(_dispatch_stub_11), + TABLE_ENTRY(_dispatch_stub_12), + TABLE_ENTRY(_dispatch_stub_13), + TABLE_ENTRY(_dispatch_stub_14), + TABLE_ENTRY(_dispatch_stub_15), + TABLE_ENTRY(_dispatch_stub_16), + TABLE_ENTRY(_dispatch_stub_17), + TABLE_ENTRY(_dispatch_stub_18), + TABLE_ENTRY(_dispatch_stub_19), + TABLE_ENTRY(_dispatch_stub_20), + TABLE_ENTRY(_dispatch_stub_21), + TABLE_ENTRY(_dispatch_stub_22), + TABLE_ENTRY(_dispatch_stub_23), + TABLE_ENTRY(_dispatch_stub_24), + TABLE_ENTRY(_dispatch_stub_25), + TABLE_ENTRY(_dispatch_stub_26), + TABLE_ENTRY(_dispatch_stub_27), + TABLE_ENTRY(_dispatch_stub_28), + TABLE_ENTRY(_dispatch_stub_29), + TABLE_ENTRY(_dispatch_stub_30), + TABLE_ENTRY(_dispatch_stub_31), + TABLE_ENTRY(_dispatch_stub_32), + TABLE_ENTRY(_dispatch_stub_33), + TABLE_ENTRY(_dispatch_stub_34), + TABLE_ENTRY(_dispatch_stub_35), + TABLE_ENTRY(_dispatch_stub_36), + TABLE_ENTRY(_dispatch_stub_37), + TABLE_ENTRY(_dispatch_stub_38), + TABLE_ENTRY(_dispatch_stub_39), + TABLE_ENTRY(_dispatch_stub_40), + TABLE_ENTRY(_dispatch_stub_41), + TABLE_ENTRY(_dispatch_stub_42), + TABLE_ENTRY(_dispatch_stub_43), + TABLE_ENTRY(_dispatch_stub_44), + TABLE_ENTRY(_dispatch_stub_45), + TABLE_ENTRY(_dispatch_stub_46), + TABLE_ENTRY(_dispatch_stub_47), + TABLE_ENTRY(_dispatch_stub_48), + TABLE_ENTRY(_dispatch_stub_49), + TABLE_ENTRY(_dispatch_stub_50), + TABLE_ENTRY(_dispatch_stub_51), + TABLE_ENTRY(_dispatch_stub_52), + TABLE_ENTRY(_dispatch_stub_53), + TABLE_ENTRY(_dispatch_stub_54), + TABLE_ENTRY(_dispatch_stub_55), + TABLE_ENTRY(_dispatch_stub_56), + TABLE_ENTRY(_dispatch_stub_57), + TABLE_ENTRY(_dispatch_stub_58), + TABLE_ENTRY(_dispatch_stub_59), + TABLE_ENTRY(_dispatch_stub_60), + TABLE_ENTRY(_dispatch_stub_61), + TABLE_ENTRY(_dispatch_stub_62), + TABLE_ENTRY(_dispatch_stub_63), + TABLE_ENTRY(_dispatch_stub_64), + TABLE_ENTRY(_dispatch_stub_65), + TABLE_ENTRY(_dispatch_stub_66), + TABLE_ENTRY(_dispatch_stub_67), + TABLE_ENTRY(_dispatch_stub_68), + TABLE_ENTRY(_dispatch_stub_69), + TABLE_ENTRY(_dispatch_stub_70), + TABLE_ENTRY(_dispatch_stub_71), + TABLE_ENTRY(_dispatch_stub_72), + TABLE_ENTRY(_dispatch_stub_73), + TABLE_ENTRY(_dispatch_stub_74), + TABLE_ENTRY(_dispatch_stub_75), + TABLE_ENTRY(_dispatch_stub_76), + TABLE_ENTRY(_dispatch_stub_77), + TABLE_ENTRY(_dispatch_stub_78), + TABLE_ENTRY(_dispatch_stub_79), + TABLE_ENTRY(_dispatch_stub_80), + TABLE_ENTRY(_dispatch_stub_81), + TABLE_ENTRY(_dispatch_stub_82), + TABLE_ENTRY(_dispatch_stub_83), + TABLE_ENTRY(_dispatch_stub_84), + TABLE_ENTRY(_dispatch_stub_85), + TABLE_ENTRY(_dispatch_stub_86), + TABLE_ENTRY(_dispatch_stub_87), + TABLE_ENTRY(_dispatch_stub_88), + TABLE_ENTRY(_dispatch_stub_89), + TABLE_ENTRY(_dispatch_stub_90), + TABLE_ENTRY(_dispatch_stub_91), + TABLE_ENTRY(_dispatch_stub_92), + TABLE_ENTRY(_dispatch_stub_93), + TABLE_ENTRY(_dispatch_stub_94), + TABLE_ENTRY(_dispatch_stub_95), + TABLE_ENTRY(_dispatch_stub_96), + TABLE_ENTRY(_dispatch_stub_97), + TABLE_ENTRY(_dispatch_stub_98), + TABLE_ENTRY(_dispatch_stub_99), + TABLE_ENTRY(_dispatch_stub_100), + TABLE_ENTRY(_dispatch_stub_101), + TABLE_ENTRY(_dispatch_stub_102), + TABLE_ENTRY(_dispatch_stub_103), + TABLE_ENTRY(_dispatch_stub_104), + TABLE_ENTRY(_dispatch_stub_105), + TABLE_ENTRY(_dispatch_stub_106), + TABLE_ENTRY(_dispatch_stub_107), + TABLE_ENTRY(_dispatch_stub_108), + TABLE_ENTRY(_dispatch_stub_109), + TABLE_ENTRY(_dispatch_stub_110), + TABLE_ENTRY(_dispatch_stub_111), + TABLE_ENTRY(_dispatch_stub_112), + TABLE_ENTRY(_dispatch_stub_113), + TABLE_ENTRY(_dispatch_stub_114), + TABLE_ENTRY(_dispatch_stub_115), + TABLE_ENTRY(_dispatch_stub_116), + TABLE_ENTRY(_dispatch_stub_117), + TABLE_ENTRY(_dispatch_stub_118), + TABLE_ENTRY(_dispatch_stub_119), + TABLE_ENTRY(_dispatch_stub_120), + TABLE_ENTRY(_dispatch_stub_121), + TABLE_ENTRY(_dispatch_stub_122), + TABLE_ENTRY(_dispatch_stub_123), + TABLE_ENTRY(_dispatch_stub_124), + TABLE_ENTRY(_dispatch_stub_125), + TABLE_ENTRY(_dispatch_stub_126), + TABLE_ENTRY(_dispatch_stub_127), + TABLE_ENTRY(_dispatch_stub_128), + TABLE_ENTRY(_dispatch_stub_129), + TABLE_ENTRY(_dispatch_stub_130), + TABLE_ENTRY(_dispatch_stub_131), + TABLE_ENTRY(_dispatch_stub_132), + TABLE_ENTRY(_dispatch_stub_133), + TABLE_ENTRY(_dispatch_stub_134), + TABLE_ENTRY(_dispatch_stub_135), + TABLE_ENTRY(_dispatch_stub_136), + TABLE_ENTRY(_dispatch_stub_137), + TABLE_ENTRY(_dispatch_stub_138), + TABLE_ENTRY(_dispatch_stub_139), + TABLE_ENTRY(_dispatch_stub_140), + TABLE_ENTRY(_dispatch_stub_141), + TABLE_ENTRY(_dispatch_stub_142), + TABLE_ENTRY(_dispatch_stub_143), + TABLE_ENTRY(_dispatch_stub_144), + TABLE_ENTRY(_dispatch_stub_145), + TABLE_ENTRY(_dispatch_stub_146), + TABLE_ENTRY(_dispatch_stub_147), + TABLE_ENTRY(_dispatch_stub_148), + TABLE_ENTRY(_dispatch_stub_149), + TABLE_ENTRY(_dispatch_stub_150), + TABLE_ENTRY(_dispatch_stub_151), + TABLE_ENTRY(CullFace), + TABLE_ENTRY(_dispatch_stub_153), + TABLE_ENTRY(_dispatch_stub_154), + TABLE_ENTRY(_dispatch_stub_155), + TABLE_ENTRY(_dispatch_stub_156), + TABLE_ENTRY(FrontFace), + TABLE_ENTRY(Hint), + TABLE_ENTRY(_dispatch_stub_159), + TABLE_ENTRY(_dispatch_stub_160), + TABLE_ENTRY(_dispatch_stub_161), + TABLE_ENTRY(_dispatch_stub_162), + TABLE_ENTRY(_dispatch_stub_163), + TABLE_ENTRY(_dispatch_stub_164), + TABLE_ENTRY(_dispatch_stub_165), + TABLE_ENTRY(_dispatch_stub_166), + TABLE_ENTRY(_dispatch_stub_167), + TABLE_ENTRY(LineWidth), + TABLE_ENTRY(_dispatch_stub_169), + TABLE_ENTRY(_dispatch_stub_170), + TABLE_ENTRY(_dispatch_stub_171), + TABLE_ENTRY(_dispatch_stub_172), + TABLE_ENTRY(_dispatch_stub_173), + TABLE_ENTRY(_dispatch_stub_174), + TABLE_ENTRY(_dispatch_stub_175), + TABLE_ENTRY(Scissor), + TABLE_ENTRY(_dispatch_stub_177), + TABLE_ENTRY(TexParameterf), + TABLE_ENTRY(TexParameterfv), + TABLE_ENTRY(TexParameteri), + TABLE_ENTRY(TexParameteriv), + TABLE_ENTRY(_dispatch_stub_182), + TABLE_ENTRY(TexImage2D), + TABLE_ENTRY(_dispatch_stub_184), + TABLE_ENTRY(_dispatch_stub_185), + TABLE_ENTRY(_dispatch_stub_186), + TABLE_ENTRY(_dispatch_stub_187), + TABLE_ENTRY(_dispatch_stub_188), + TABLE_ENTRY(_dispatch_stub_189), + TABLE_ENTRY(_dispatch_stub_190), + TABLE_ENTRY(_dispatch_stub_191), + TABLE_ENTRY(_dispatch_stub_192), + TABLE_ENTRY(_dispatch_stub_193), + TABLE_ENTRY(_dispatch_stub_194), + TABLE_ENTRY(_dispatch_stub_195), + TABLE_ENTRY(_dispatch_stub_196), + TABLE_ENTRY(_dispatch_stub_197), + TABLE_ENTRY(_dispatch_stub_198), + TABLE_ENTRY(_dispatch_stub_199), + TABLE_ENTRY(_dispatch_stub_200), + TABLE_ENTRY(_dispatch_stub_201), + TABLE_ENTRY(_dispatch_stub_202), + TABLE_ENTRY(Clear), + TABLE_ENTRY(_dispatch_stub_204), + TABLE_ENTRY(_dispatch_stub_205), + TABLE_ENTRY(ClearColor), + TABLE_ENTRY(ClearStencil), + TABLE_ENTRY(_dispatch_stub_208), + TABLE_ENTRY(StencilMask), + TABLE_ENTRY(ColorMask), + TABLE_ENTRY(DepthMask), + TABLE_ENTRY(_dispatch_stub_212), + TABLE_ENTRY(_dispatch_stub_213), + TABLE_ENTRY(Disable), + TABLE_ENTRY(Enable), + TABLE_ENTRY(Finish), + TABLE_ENTRY(Flush), + TABLE_ENTRY(_dispatch_stub_218), + TABLE_ENTRY(_dispatch_stub_219), + TABLE_ENTRY(_dispatch_stub_220), + TABLE_ENTRY(_dispatch_stub_221), + TABLE_ENTRY(_dispatch_stub_222), + TABLE_ENTRY(_dispatch_stub_223), + TABLE_ENTRY(_dispatch_stub_224), + TABLE_ENTRY(_dispatch_stub_225), + TABLE_ENTRY(_dispatch_stub_226), + TABLE_ENTRY(_dispatch_stub_227), + TABLE_ENTRY(_dispatch_stub_228), + TABLE_ENTRY(_dispatch_stub_229), + TABLE_ENTRY(_dispatch_stub_230), + TABLE_ENTRY(_dispatch_stub_231), + TABLE_ENTRY(_dispatch_stub_232), + TABLE_ENTRY(_dispatch_stub_233), + TABLE_ENTRY(_dispatch_stub_234), + TABLE_ENTRY(_dispatch_stub_235), + TABLE_ENTRY(_dispatch_stub_236), + TABLE_ENTRY(_dispatch_stub_237), + TABLE_ENTRY(_dispatch_stub_238), + TABLE_ENTRY(_dispatch_stub_239), + TABLE_ENTRY(_dispatch_stub_240), + TABLE_ENTRY(BlendFunc), + TABLE_ENTRY(_dispatch_stub_242), + TABLE_ENTRY(StencilFunc), + TABLE_ENTRY(StencilOp), + TABLE_ENTRY(DepthFunc), + TABLE_ENTRY(_dispatch_stub_246), + TABLE_ENTRY(_dispatch_stub_247), + TABLE_ENTRY(_dispatch_stub_248), + TABLE_ENTRY(_dispatch_stub_249), + TABLE_ENTRY(PixelStorei), + TABLE_ENTRY(_dispatch_stub_251), + TABLE_ENTRY(_dispatch_stub_252), + TABLE_ENTRY(_dispatch_stub_253), + TABLE_ENTRY(_dispatch_stub_254), + TABLE_ENTRY(_dispatch_stub_255), + TABLE_ENTRY(ReadPixels), + TABLE_ENTRY(_dispatch_stub_257), + TABLE_ENTRY(GetBooleanv), + TABLE_ENTRY(_dispatch_stub_259), + TABLE_ENTRY(_dispatch_stub_260), + TABLE_ENTRY(GetError), + TABLE_ENTRY(GetFloatv), + TABLE_ENTRY(GetIntegerv), + TABLE_ENTRY(_dispatch_stub_264), + TABLE_ENTRY(_dispatch_stub_265), + TABLE_ENTRY(_dispatch_stub_266), + TABLE_ENTRY(_dispatch_stub_267), + TABLE_ENTRY(_dispatch_stub_268), + TABLE_ENTRY(_dispatch_stub_269), + TABLE_ENTRY(_dispatch_stub_270), + TABLE_ENTRY(_dispatch_stub_271), + TABLE_ENTRY(_dispatch_stub_272), + TABLE_ENTRY(_dispatch_stub_273), + TABLE_ENTRY(_dispatch_stub_274), + TABLE_ENTRY(GetString), + TABLE_ENTRY(_dispatch_stub_276), + TABLE_ENTRY(_dispatch_stub_277), + TABLE_ENTRY(_dispatch_stub_278), + TABLE_ENTRY(_dispatch_stub_279), + TABLE_ENTRY(_dispatch_stub_280), + TABLE_ENTRY(_dispatch_stub_281), + TABLE_ENTRY(GetTexParameterfv), + TABLE_ENTRY(GetTexParameteriv), + TABLE_ENTRY(_dispatch_stub_284), + TABLE_ENTRY(_dispatch_stub_285), + TABLE_ENTRY(IsEnabled), + TABLE_ENTRY(_dispatch_stub_287), + TABLE_ENTRY(_dispatch_stub_288), + TABLE_ENTRY(_dispatch_stub_289), + TABLE_ENTRY(_dispatch_stub_290), + TABLE_ENTRY(_dispatch_stub_291), + TABLE_ENTRY(_dispatch_stub_292), + TABLE_ENTRY(_dispatch_stub_293), + TABLE_ENTRY(_dispatch_stub_294), + TABLE_ENTRY(_dispatch_stub_295), + TABLE_ENTRY(_dispatch_stub_296), + TABLE_ENTRY(_dispatch_stub_297), + TABLE_ENTRY(_dispatch_stub_298), + TABLE_ENTRY(_dispatch_stub_299), + TABLE_ENTRY(_dispatch_stub_300), + TABLE_ENTRY(_dispatch_stub_301), + TABLE_ENTRY(_dispatch_stub_302), + TABLE_ENTRY(_dispatch_stub_303), + TABLE_ENTRY(_dispatch_stub_304), + TABLE_ENTRY(Viewport), + TABLE_ENTRY(_dispatch_stub_306), + TABLE_ENTRY(BindTexture), + TABLE_ENTRY(_dispatch_stub_308), + TABLE_ENTRY(_dispatch_stub_309), + TABLE_ENTRY(DrawArrays), + TABLE_ENTRY(DrawElements), + TABLE_ENTRY(_dispatch_stub_312), + TABLE_ENTRY(_dispatch_stub_313), + TABLE_ENTRY(_dispatch_stub_314), + TABLE_ENTRY(_dispatch_stub_315), + TABLE_ENTRY(_dispatch_stub_316), + TABLE_ENTRY(_dispatch_stub_317), + TABLE_ENTRY(_dispatch_stub_318), + TABLE_ENTRY(PolygonOffset), + TABLE_ENTRY(_dispatch_stub_320), + TABLE_ENTRY(_dispatch_stub_321), + TABLE_ENTRY(_dispatch_stub_322), + TABLE_ENTRY(_dispatch_stub_323), + TABLE_ENTRY(CopyTexImage2D), + TABLE_ENTRY(_dispatch_stub_325), + TABLE_ENTRY(CopyTexSubImage2D), + TABLE_ENTRY(DeleteTextures), + TABLE_ENTRY(GenTextures), + TABLE_ENTRY(_dispatch_stub_329), + TABLE_ENTRY(IsTexture), + TABLE_ENTRY(_dispatch_stub_331), + TABLE_ENTRY(_dispatch_stub_332), + TABLE_ENTRY(TexSubImage2D), + TABLE_ENTRY(_dispatch_stub_334), + TABLE_ENTRY(_dispatch_stub_335), + TABLE_ENTRY(BlendColor), + TABLE_ENTRY(BlendEquation), + TABLE_ENTRY(_dispatch_stub_338), + TABLE_ENTRY(_dispatch_stub_339), + TABLE_ENTRY(_dispatch_stub_340), + TABLE_ENTRY(_dispatch_stub_341), + TABLE_ENTRY(_dispatch_stub_342), + TABLE_ENTRY(_dispatch_stub_343), + TABLE_ENTRY(_dispatch_stub_344), + TABLE_ENTRY(_dispatch_stub_345), + TABLE_ENTRY(_dispatch_stub_346), + TABLE_ENTRY(_dispatch_stub_347), + TABLE_ENTRY(_dispatch_stub_348), + TABLE_ENTRY(_dispatch_stub_349), + TABLE_ENTRY(_dispatch_stub_350), + TABLE_ENTRY(_dispatch_stub_351), + TABLE_ENTRY(_dispatch_stub_352), + TABLE_ENTRY(_dispatch_stub_353), + TABLE_ENTRY(_dispatch_stub_354), + TABLE_ENTRY(_dispatch_stub_355), + TABLE_ENTRY(_dispatch_stub_356), + TABLE_ENTRY(_dispatch_stub_357), + TABLE_ENTRY(_dispatch_stub_358), + TABLE_ENTRY(_dispatch_stub_359), + TABLE_ENTRY(_dispatch_stub_360), + TABLE_ENTRY(_dispatch_stub_361), + TABLE_ENTRY(_dispatch_stub_362), + TABLE_ENTRY(_dispatch_stub_363), + TABLE_ENTRY(_dispatch_stub_364), + TABLE_ENTRY(_dispatch_stub_365), + TABLE_ENTRY(_dispatch_stub_366), + TABLE_ENTRY(_dispatch_stub_367), + TABLE_ENTRY(_dispatch_stub_368), + TABLE_ENTRY(_dispatch_stub_369), + TABLE_ENTRY(_dispatch_stub_370), + TABLE_ENTRY(TexImage3DOES), + TABLE_ENTRY(TexSubImage3DOES), + TABLE_ENTRY(CopyTexSubImage3DOES), + TABLE_ENTRY(ActiveTexture), + TABLE_ENTRY(_dispatch_stub_375), + TABLE_ENTRY(_dispatch_stub_376), + TABLE_ENTRY(_dispatch_stub_377), + TABLE_ENTRY(_dispatch_stub_378), + TABLE_ENTRY(_dispatch_stub_379), + TABLE_ENTRY(_dispatch_stub_380), + TABLE_ENTRY(_dispatch_stub_381), + TABLE_ENTRY(_dispatch_stub_382), + TABLE_ENTRY(_dispatch_stub_383), + TABLE_ENTRY(_dispatch_stub_384), + TABLE_ENTRY(_dispatch_stub_385), + TABLE_ENTRY(_dispatch_stub_386), + TABLE_ENTRY(_dispatch_stub_387), + TABLE_ENTRY(_dispatch_stub_388), + TABLE_ENTRY(_dispatch_stub_389), + TABLE_ENTRY(_dispatch_stub_390), + TABLE_ENTRY(_dispatch_stub_391), + TABLE_ENTRY(_dispatch_stub_392), + TABLE_ENTRY(_dispatch_stub_393), + TABLE_ENTRY(_dispatch_stub_394), + TABLE_ENTRY(_dispatch_stub_395), + TABLE_ENTRY(_dispatch_stub_396), + TABLE_ENTRY(_dispatch_stub_397), + TABLE_ENTRY(_dispatch_stub_398), + TABLE_ENTRY(_dispatch_stub_399), + TABLE_ENTRY(_dispatch_stub_400), + TABLE_ENTRY(_dispatch_stub_401), + TABLE_ENTRY(_dispatch_stub_402), + TABLE_ENTRY(_dispatch_stub_403), + TABLE_ENTRY(_dispatch_stub_404), + TABLE_ENTRY(_dispatch_stub_405), + TABLE_ENTRY(_dispatch_stub_406), + TABLE_ENTRY(_dispatch_stub_407), + TABLE_ENTRY(GetBufferPointervOES), + TABLE_ENTRY(MapBufferOES), + TABLE_ENTRY(UnmapBufferOES), + TABLE_ENTRY(CompressedTexImage3DOES), + TABLE_ENTRY(CompressedTexSubImage3DOES), + TABLE_ENTRY(FramebufferTexture3DOES), + TABLE_ENTRY(GetProgramBinaryOES), + TABLE_ENTRY(ProgramBinaryOES), + TABLE_ENTRY(MultiDrawArraysEXT), + TABLE_ENTRY(MultiDrawElementsEXT), + TABLE_ENTRY(_dispatch_stub_418), + TABLE_ENTRY(_dispatch_stub_419), + TABLE_ENTRY(_dispatch_stub_420), + TABLE_ENTRY(_dispatch_stub_421), + TABLE_ENTRY(EGLImageTargetRenderbufferStorageOES), + TABLE_ENTRY(EGLImageTargetTexture2DOES), + TABLE_ENTRY(CompressedTexImage2D), + TABLE_ENTRY(CompressedTexSubImage2D), + TABLE_ENTRY(SampleCoverage), + TABLE_ENTRY(BindBuffer), + TABLE_ENTRY(BufferData), + TABLE_ENTRY(BufferSubData), + TABLE_ENTRY(DeleteBuffers), + TABLE_ENTRY(GenBuffers), + TABLE_ENTRY(GetBufferParameteriv), + TABLE_ENTRY(IsBuffer), + TABLE_ENTRY(AttachShader), + TABLE_ENTRY(BindAttribLocation), + TABLE_ENTRY(BlendEquationSeparate), + TABLE_ENTRY(CompileShader), + TABLE_ENTRY(CreateProgram), + TABLE_ENTRY(CreateShader), + TABLE_ENTRY(DeleteProgram), + TABLE_ENTRY(DeleteShader), + TABLE_ENTRY(DetachShader), + TABLE_ENTRY(DisableVertexAttribArray), + TABLE_ENTRY(EnableVertexAttribArray), + TABLE_ENTRY(GetActiveAttrib), + TABLE_ENTRY(GetActiveUniform), + TABLE_ENTRY(GetAttachedShaders), + TABLE_ENTRY(GetAttribLocation), + TABLE_ENTRY(GetProgramInfoLog), + TABLE_ENTRY(GetProgramiv), + TABLE_ENTRY(GetShaderInfoLog), + TABLE_ENTRY(GetShaderSource), + TABLE_ENTRY(GetShaderiv), + TABLE_ENTRY(GetUniformLocation), + TABLE_ENTRY(GetUniformfv), + TABLE_ENTRY(GetUniformiv), + TABLE_ENTRY(GetVertexAttribPointerv), + TABLE_ENTRY(GetVertexAttribfv), + TABLE_ENTRY(GetVertexAttribiv), + TABLE_ENTRY(IsProgram), + TABLE_ENTRY(IsShader), + TABLE_ENTRY(LinkProgram), + TABLE_ENTRY(ShaderSource), + TABLE_ENTRY(StencilFuncSeparate), + TABLE_ENTRY(StencilMaskSeparate), + TABLE_ENTRY(StencilOpSeparate), + TABLE_ENTRY(Uniform1f), + TABLE_ENTRY(Uniform1fv), + TABLE_ENTRY(Uniform1i), + TABLE_ENTRY(Uniform1iv), + TABLE_ENTRY(Uniform2f), + TABLE_ENTRY(Uniform2fv), + TABLE_ENTRY(Uniform2i), + TABLE_ENTRY(Uniform2iv), + TABLE_ENTRY(Uniform3f), + TABLE_ENTRY(Uniform3fv), + TABLE_ENTRY(Uniform3i), + TABLE_ENTRY(Uniform3iv), + TABLE_ENTRY(Uniform4f), + TABLE_ENTRY(Uniform4fv), + TABLE_ENTRY(Uniform4i), + TABLE_ENTRY(Uniform4iv), + TABLE_ENTRY(UniformMatrix2fv), + TABLE_ENTRY(UniformMatrix3fv), + TABLE_ENTRY(UniformMatrix4fv), + TABLE_ENTRY(UseProgram), + TABLE_ENTRY(ValidateProgram), + TABLE_ENTRY(VertexAttrib1f), + TABLE_ENTRY(VertexAttrib1fv), + TABLE_ENTRY(VertexAttrib2f), + TABLE_ENTRY(VertexAttrib2fv), + TABLE_ENTRY(VertexAttrib3f), + TABLE_ENTRY(VertexAttrib3fv), + TABLE_ENTRY(VertexAttrib4f), + TABLE_ENTRY(VertexAttrib4fv), + TABLE_ENTRY(VertexAttribPointer), + TABLE_ENTRY(BlendFuncSeparate), + TABLE_ENTRY(BindFramebuffer), + TABLE_ENTRY(BindRenderbuffer), + TABLE_ENTRY(CheckFramebufferStatus), + TABLE_ENTRY(ClearDepthf), + TABLE_ENTRY(DeleteFramebuffers), + TABLE_ENTRY(DeleteRenderbuffers), + TABLE_ENTRY(DepthRangef), + TABLE_ENTRY(FramebufferRenderbuffer), + TABLE_ENTRY(FramebufferTexture2D), + TABLE_ENTRY(GenFramebuffers), + TABLE_ENTRY(GenRenderbuffers), + TABLE_ENTRY(GenerateMipmap), + TABLE_ENTRY(GetFramebufferAttachmentParameteriv), + TABLE_ENTRY(GetRenderbufferParameteriv), + TABLE_ENTRY(GetShaderPrecisionFormat), + TABLE_ENTRY(IsFramebuffer), + TABLE_ENTRY(IsRenderbuffer), + TABLE_ENTRY(ReleaseShaderCompiler), + TABLE_ENTRY(RenderbufferStorage), + TABLE_ENTRY(ShaderBinary), + /* A whole bunch of no-op functions. These might be called + * when someone tries to call a dynamically-registered + * extension function without a current rendering context. + */ + TABLE_ENTRY(Unused), + TABLE_ENTRY(Unused), + TABLE_ENTRY(Unused), + TABLE_ENTRY(Unused), + TABLE_ENTRY(Unused), + TABLE_ENTRY(Unused), + TABLE_ENTRY(Unused), + TABLE_ENTRY(Unused), + TABLE_ENTRY(Unused), + TABLE_ENTRY(Unused), + TABLE_ENTRY(Unused), + TABLE_ENTRY(Unused), + TABLE_ENTRY(Unused), + TABLE_ENTRY(Unused), + TABLE_ENTRY(Unused), + TABLE_ENTRY(Unused), + TABLE_ENTRY(Unused), + TABLE_ENTRY(Unused), + TABLE_ENTRY(Unused), + TABLE_ENTRY(Unused), + TABLE_ENTRY(Unused), + TABLE_ENTRY(Unused), + TABLE_ENTRY(Unused), + TABLE_ENTRY(Unused), + TABLE_ENTRY(Unused), + TABLE_ENTRY(Unused), + TABLE_ENTRY(Unused), + TABLE_ENTRY(Unused), + TABLE_ENTRY(Unused), + TABLE_ENTRY(Unused), + TABLE_ENTRY(Unused), + TABLE_ENTRY(Unused), + TABLE_ENTRY(Unused), + TABLE_ENTRY(Unused), + TABLE_ENTRY(Unused), + TABLE_ENTRY(Unused), + TABLE_ENTRY(Unused), + TABLE_ENTRY(Unused), + TABLE_ENTRY(Unused), + TABLE_ENTRY(Unused), + TABLE_ENTRY(Unused), + TABLE_ENTRY(Unused), + TABLE_ENTRY(Unused), + TABLE_ENTRY(Unused), + TABLE_ENTRY(Unused), + TABLE_ENTRY(Unused), + TABLE_ENTRY(Unused), + TABLE_ENTRY(Unused), + TABLE_ENTRY(Unused), + TABLE_ENTRY(Unused), + TABLE_ENTRY(Unused), + TABLE_ENTRY(Unused), + TABLE_ENTRY(Unused), + TABLE_ENTRY(Unused), + TABLE_ENTRY(Unused), + TABLE_ENTRY(Unused), + TABLE_ENTRY(Unused), + TABLE_ENTRY(Unused), + TABLE_ENTRY(Unused), + TABLE_ENTRY(Unused), + TABLE_ENTRY(Unused), + TABLE_ENTRY(Unused), + TABLE_ENTRY(Unused), + TABLE_ENTRY(Unused), + TABLE_ENTRY(Unused), + TABLE_ENTRY(Unused), + TABLE_ENTRY(Unused), + TABLE_ENTRY(Unused), + TABLE_ENTRY(Unused), + TABLE_ENTRY(Unused), + TABLE_ENTRY(Unused), + TABLE_ENTRY(Unused), + TABLE_ENTRY(Unused), + TABLE_ENTRY(Unused), + TABLE_ENTRY(Unused), + TABLE_ENTRY(Unused), + TABLE_ENTRY(Unused), + TABLE_ENTRY(Unused), + TABLE_ENTRY(Unused), + TABLE_ENTRY(Unused), + TABLE_ENTRY(Unused), + TABLE_ENTRY(Unused), + TABLE_ENTRY(Unused), + TABLE_ENTRY(Unused), + TABLE_ENTRY(Unused), + TABLE_ENTRY(Unused), + TABLE_ENTRY(Unused), + TABLE_ENTRY(Unused), + TABLE_ENTRY(Unused), + TABLE_ENTRY(Unused), + TABLE_ENTRY(Unused), + TABLE_ENTRY(Unused), + TABLE_ENTRY(Unused), + TABLE_ENTRY(Unused), + TABLE_ENTRY(Unused), + TABLE_ENTRY(Unused), + TABLE_ENTRY(Unused), + TABLE_ENTRY(Unused), + TABLE_ENTRY(Unused), +}; +#endif /* DISPATCH_TABLE_NAME */ + + +/* + * This is just used to silence compiler warnings. + * We list the functions which are not otherwise used. + */ +#ifdef UNUSED_TABLE_NAME +_glapi_proc UNUSED_TABLE_NAME[] = { +#ifndef _GLAPI_SKIP_NORMAL_ENTRY_POINTS + TABLE_ENTRY(_dispatch_stub_371), + TABLE_ENTRY(_dispatch_stub_372), + TABLE_ENTRY(_dispatch_stub_373), + TABLE_ENTRY(_dispatch_stub_374), +#endif /* _GLAPI_SKIP_NORMAL_ENTRY_POINTS */ +#ifndef _GLAPI_SKIP_PROTO_ENTRY_POINTS +#endif /* _GLAPI_SKIP_PROTO_ENTRY_POINTS */ +}; +#endif /*UNUSED_TABLE_NAME*/ + + +# undef KEYWORD1 +# undef KEYWORD1_ALT +# undef KEYWORD2 +# undef NAME +# undef DISPATCH +# undef RETURN_DISPATCH +# undef DISPATCH_TABLE_NAME +# undef UNUSED_TABLE_NAME +# undef TABLE_ENTRY +# undef HIDDEN diff --git a/src/mapi/es2api/glapi/glprocs.h b/src/mapi/es2api/glapi/glprocs.h new file mode 100644 index 00000000000..fa27c57f33c --- /dev/null +++ b/src/mapi/es2api/glapi/glprocs.h @@ -0,0 +1,1877 @@ +/* DO NOT EDIT - This file generated automatically by gl_procs.py (from Mesa) script */ + +/* + * Copyright (C) 1999-2001 Brian Paul All Rights Reserved. + * (C) Copyright IBM Corporation 2004, 2006 + * All Rights Reserved. + * + * Permission is hereby granted, free of charge, to any person obtaining a + * copy of this software and associated documentation files (the "Software"), + * to deal in the Software without restriction, including without limitation + * the rights to use, copy, modify, merge, publish, distribute, sub license, + * and/or sell copies of the Software, and to permit persons to whom the + * Software is furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice (including the next + * paragraph) shall be included in all copies or substantial portions of the + * Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL + * BRIAN PAUL, IBM, + * AND/OR THEIR SUPPLIERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, + * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF + * OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE + * SOFTWARE. + */ + + +/* This file is only included by glapi.c and is used for + * the GetProcAddress() function + */ + +typedef struct { + GLint Name_offset; +#if defined(NEED_FUNCTION_POINTER) || defined(GLX_INDIRECT_RENDERING) + _glapi_proc Address; +#endif + GLuint Offset; +} glprocs_table_t; + +#if !defined(NEED_FUNCTION_POINTER) && !defined(GLX_INDIRECT_RENDERING) +# define NAME_FUNC_OFFSET(n,f1,f2,f3,o) { n , o } +#elif defined(NEED_FUNCTION_POINTER) && !defined(GLX_INDIRECT_RENDERING) +# define NAME_FUNC_OFFSET(n,f1,f2,f3,o) { n , (_glapi_proc) f1 , o } +#elif defined(NEED_FUNCTION_POINTER) && defined(GLX_INDIRECT_RENDERING) +# define NAME_FUNC_OFFSET(n,f1,f2,f3,o) { n , (_glapi_proc) f2 , o } +#elif !defined(NEED_FUNCTION_POINTER) && defined(GLX_INDIRECT_RENDERING) +# define NAME_FUNC_OFFSET(n,f1,f2,f3,o) { n , (_glapi_proc) f3 , o } +#endif + + + +static const char gl_string_table[] = + "glNewList\0" + "glEndList\0" + "glCallList\0" + "glCallLists\0" + "glDeleteLists\0" + "glGenLists\0" + "glListBase\0" + "glBegin\0" + "glBitmap\0" + "glColor3b\0" + "glColor3bv\0" + "glColor3d\0" + "glColor3dv\0" + "glColor3f\0" + "glColor3fv\0" + "glColor3i\0" + "glColor3iv\0" + "glColor3s\0" + "glColor3sv\0" + "glColor3ub\0" + "glColor3ubv\0" + "glColor3ui\0" + "glColor3uiv\0" + "glColor3us\0" + "glColor3usv\0" + "glColor4b\0" + "glColor4bv\0" + "glColor4d\0" + "glColor4dv\0" + "glColor4f\0" + "glColor4fv\0" + "glColor4i\0" + "glColor4iv\0" + "glColor4s\0" + "glColor4sv\0" + "glColor4ub\0" + "glColor4ubv\0" + "glColor4ui\0" + "glColor4uiv\0" + "glColor4us\0" + "glColor4usv\0" + "glEdgeFlag\0" + "glEdgeFlagv\0" + "glEnd\0" + "glIndexd\0" + "glIndexdv\0" + "glIndexf\0" + "glIndexfv\0" + "glIndexi\0" + "glIndexiv\0" + "glIndexs\0" + "glIndexsv\0" + "glNormal3b\0" + "glNormal3bv\0" + "glNormal3d\0" + "glNormal3dv\0" + "glNormal3f\0" + "glNormal3fv\0" + "glNormal3i\0" + "glNormal3iv\0" + "glNormal3s\0" + "glNormal3sv\0" + "glRasterPos2d\0" + "glRasterPos2dv\0" + "glRasterPos2f\0" + "glRasterPos2fv\0" + "glRasterPos2i\0" + "glRasterPos2iv\0" + "glRasterPos2s\0" + "glRasterPos2sv\0" + "glRasterPos3d\0" + "glRasterPos3dv\0" + "glRasterPos3f\0" + "glRasterPos3fv\0" + "glRasterPos3i\0" + "glRasterPos3iv\0" + "glRasterPos3s\0" + "glRasterPos3sv\0" + "glRasterPos4d\0" + "glRasterPos4dv\0" + "glRasterPos4f\0" + "glRasterPos4fv\0" + "glRasterPos4i\0" + "glRasterPos4iv\0" + "glRasterPos4s\0" + "glRasterPos4sv\0" + "glRectd\0" + "glRectdv\0" + "glRectf\0" + "glRectfv\0" + "glRecti\0" + "glRectiv\0" + "glRects\0" + "glRectsv\0" + "glTexCoord1d\0" + "glTexCoord1dv\0" + "glTexCoord1f\0" + "glTexCoord1fv\0" + "glTexCoord1i\0" + "glTexCoord1iv\0" + "glTexCoord1s\0" + "glTexCoord1sv\0" + "glTexCoord2d\0" + "glTexCoord2dv\0" + "glTexCoord2f\0" + "glTexCoord2fv\0" + "glTexCoord2i\0" + "glTexCoord2iv\0" + "glTexCoord2s\0" + "glTexCoord2sv\0" + "glTexCoord3d\0" + "glTexCoord3dv\0" + "glTexCoord3f\0" + "glTexCoord3fv\0" + "glTexCoord3i\0" + "glTexCoord3iv\0" + "glTexCoord3s\0" + "glTexCoord3sv\0" + "glTexCoord4d\0" + "glTexCoord4dv\0" + "glTexCoord4f\0" + "glTexCoord4fv\0" + "glTexCoord4i\0" + "glTexCoord4iv\0" + "glTexCoord4s\0" + "glTexCoord4sv\0" + "glVertex2d\0" + "glVertex2dv\0" + "glVertex2f\0" + "glVertex2fv\0" + "glVertex2i\0" + "glVertex2iv\0" + "glVertex2s\0" + "glVertex2sv\0" + "glVertex3d\0" + "glVertex3dv\0" + "glVertex3f\0" + "glVertex3fv\0" + "glVertex3i\0" + "glVertex3iv\0" + "glVertex3s\0" + "glVertex3sv\0" + "glVertex4d\0" + "glVertex4dv\0" + "glVertex4f\0" + "glVertex4fv\0" + "glVertex4i\0" + "glVertex4iv\0" + "glVertex4s\0" + "glVertex4sv\0" + "glClipPlane\0" + "glColorMaterial\0" + "glCullFace\0" + "glFogf\0" + "glFogfv\0" + "glFogi\0" + "glFogiv\0" + "glFrontFace\0" + "glHint\0" + "glLightf\0" + "glLightfv\0" + "glLighti\0" + "glLightiv\0" + "glLightModelf\0" + "glLightModelfv\0" + "glLightModeli\0" + "glLightModeliv\0" + "glLineStipple\0" + "glLineWidth\0" + "glMaterialf\0" + "glMaterialfv\0" + "glMateriali\0" + "glMaterialiv\0" + "glPointSize\0" + "glPolygonMode\0" + "glPolygonStipple\0" + "glScissor\0" + "glShadeModel\0" + "glTexParameterf\0" + "glTexParameterfv\0" + "glTexParameteri\0" + "glTexParameteriv\0" + "glTexImage1D\0" + "glTexImage2D\0" + "glTexEnvf\0" + "glTexEnvfv\0" + "glTexEnvi\0" + "glTexEnviv\0" + "glTexGend\0" + "glTexGendv\0" + "glTexGenf\0" + "glTexGenfv\0" + "glTexGeni\0" + "glTexGeniv\0" + "glFeedbackBuffer\0" + "glSelectBuffer\0" + "glRenderMode\0" + "glInitNames\0" + "glLoadName\0" + "glPassThrough\0" + "glPopName\0" + "glPushName\0" + "glDrawBuffer\0" + "glClear\0" + "glClearAccum\0" + "glClearIndex\0" + "glClearColor\0" + "glClearStencil\0" + "glClearDepth\0" + "glStencilMask\0" + "glColorMask\0" + "glDepthMask\0" + "glIndexMask\0" + "glAccum\0" + "glDisable\0" + "glEnable\0" + "glFinish\0" + "glFlush\0" + "glPopAttrib\0" + "glPushAttrib\0" + "glMap1d\0" + "glMap1f\0" + "glMap2d\0" + "glMap2f\0" + "glMapGrid1d\0" + "glMapGrid1f\0" + "glMapGrid2d\0" + "glMapGrid2f\0" + "glEvalCoord1d\0" + "glEvalCoord1dv\0" + "glEvalCoord1f\0" + "glEvalCoord1fv\0" + "glEvalCoord2d\0" + "glEvalCoord2dv\0" + "glEvalCoord2f\0" + "glEvalCoord2fv\0" + "glEvalMesh1\0" + "glEvalPoint1\0" + "glEvalMesh2\0" + "glEvalPoint2\0" + "glAlphaFunc\0" + "glBlendFunc\0" + "glLogicOp\0" + "glStencilFunc\0" + "glStencilOp\0" + "glDepthFunc\0" + "glPixelZoom\0" + "glPixelTransferf\0" + "glPixelTransferi\0" + "glPixelStoref\0" + "glPixelStorei\0" + "glPixelMapfv\0" + "glPixelMapuiv\0" + "glPixelMapusv\0" + "glReadBuffer\0" + "glCopyPixels\0" + "glReadPixels\0" + "glDrawPixels\0" + "glGetBooleanv\0" + "glGetClipPlane\0" + "glGetDoublev\0" + "glGetError\0" + "glGetFloatv\0" + "glGetIntegerv\0" + "glGetLightfv\0" + "glGetLightiv\0" + "glGetMapdv\0" + "glGetMapfv\0" + "glGetMapiv\0" + "glGetMaterialfv\0" + "glGetMaterialiv\0" + "glGetPixelMapfv\0" + "glGetPixelMapuiv\0" + "glGetPixelMapusv\0" + "glGetPolygonStipple\0" + "glGetString\0" + "glGetTexEnvfv\0" + "glGetTexEnviv\0" + "glGetTexGendv\0" + "glGetTexGenfv\0" + "glGetTexGeniv\0" + "glGetTexImage\0" + "glGetTexParameterfv\0" + "glGetTexParameteriv\0" + "glGetTexLevelParameterfv\0" + "glGetTexLevelParameteriv\0" + "glIsEnabled\0" + "glIsList\0" + "glDepthRange\0" + "glFrustum\0" + "glLoadIdentity\0" + "glLoadMatrixf\0" + "glLoadMatrixd\0" + "glMatrixMode\0" + "glMultMatrixf\0" + "glMultMatrixd\0" + "glOrtho\0" + "glPopMatrix\0" + "glPushMatrix\0" + "glRotated\0" + "glRotatef\0" + "glScaled\0" + "glScalef\0" + "glTranslated\0" + "glTranslatef\0" + "glViewport\0" + "glArrayElement\0" + "glBindTexture\0" + "glColorPointer\0" + "glDisableClientState\0" + "glDrawArrays\0" + "glDrawElements\0" + "glEdgeFlagPointer\0" + "glEnableClientState\0" + "glIndexPointer\0" + "glIndexub\0" + "glIndexubv\0" + "glInterleavedArrays\0" + "glNormalPointer\0" + "glPolygonOffset\0" + "glTexCoordPointer\0" + "glVertexPointer\0" + "glAreTexturesResident\0" + "glCopyTexImage1D\0" + "glCopyTexImage2D\0" + "glCopyTexSubImage1D\0" + "glCopyTexSubImage2D\0" + "glDeleteTextures\0" + "glGenTextures\0" + "glGetPointerv\0" + "glIsTexture\0" + "glPrioritizeTextures\0" + "glTexSubImage1D\0" + "glTexSubImage2D\0" + "glPopClientAttrib\0" + "glPushClientAttrib\0" + "glBlendColor\0" + "glBlendEquation\0" + "glDrawRangeElements\0" + "glColorTable\0" + "glColorTableParameterfv\0" + "glColorTableParameteriv\0" + "glCopyColorTable\0" + "glGetColorTable\0" + "glGetColorTableParameterfv\0" + "glGetColorTableParameteriv\0" + "glColorSubTable\0" + "glCopyColorSubTable\0" + "glConvolutionFilter1D\0" + "glConvolutionFilter2D\0" + "glConvolutionParameterf\0" + "glConvolutionParameterfv\0" + "glConvolutionParameteri\0" + "glConvolutionParameteriv\0" + "glCopyConvolutionFilter1D\0" + "glCopyConvolutionFilter2D\0" + "glGetConvolutionFilter\0" + "glGetConvolutionParameterfv\0" + "glGetConvolutionParameteriv\0" + "glGetSeparableFilter\0" + "glSeparableFilter2D\0" + "glGetHistogram\0" + "glGetHistogramParameterfv\0" + "glGetHistogramParameteriv\0" + "glGetMinmax\0" + "glGetMinmaxParameterfv\0" + "glGetMinmaxParameteriv\0" + "glHistogram\0" + "glMinmax\0" + "glResetHistogram\0" + "glResetMinmax\0" + "glTexImage3DOES\0" + "glTexSubImage3DOES\0" + "glCopyTexSubImage3DOES\0" + "glActiveTexture\0" + "glClientActiveTextureARB\0" + "glMultiTexCoord1dARB\0" + "glMultiTexCoord1dvARB\0" + "glMultiTexCoord1fARB\0" + "glMultiTexCoord1fvARB\0" + "glMultiTexCoord1iARB\0" + "glMultiTexCoord1ivARB\0" + "glMultiTexCoord1sARB\0" + "glMultiTexCoord1svARB\0" + "glMultiTexCoord2dARB\0" + "glMultiTexCoord2dvARB\0" + "glMultiTexCoord2fARB\0" + "glMultiTexCoord2fvARB\0" + "glMultiTexCoord2iARB\0" + "glMultiTexCoord2ivARB\0" + "glMultiTexCoord2sARB\0" + "glMultiTexCoord2svARB\0" + "glMultiTexCoord3dARB\0" + "glMultiTexCoord3dvARB\0" + "glMultiTexCoord3fARB\0" + "glMultiTexCoord3fvARB\0" + "glMultiTexCoord3iARB\0" + "glMultiTexCoord3ivARB\0" + "glMultiTexCoord3sARB\0" + "glMultiTexCoord3svARB\0" + "glMultiTexCoord4dARB\0" + "glMultiTexCoord4dvARB\0" + "glMultiTexCoord4fARB\0" + "glMultiTexCoord4fvARB\0" + "glMultiTexCoord4iARB\0" + "glMultiTexCoord4ivARB\0" + "glMultiTexCoord4sARB\0" + "glMultiTexCoord4svARB\0" + "glGetBufferPointervOES\0" + "glMapBufferOES\0" + "glUnmapBufferOES\0" + "glCompressedTexImage3DOES\0" + "glCompressedTexSubImage3DOES\0" + "glFramebufferTexture3DOES\0" + "glGetProgramBinaryOES\0" + "glProgramBinaryOES\0" + "glMultiDrawArraysEXT\0" + "glMultiDrawElementsEXT\0" + "glBindVertexArrayAPPLE\0" + "glDeleteVertexArraysAPPLE\0" + "glGenVertexArraysAPPLE\0" + "glIsVertexArrayAPPLE\0" + "glEGLImageTargetRenderbufferStorageOES\0" + "glEGLImageTargetTexture2DOES\0" + "glCompressedTexImage2D\0" + "glCompressedTexSubImage2D\0" + "glSampleCoverage\0" + "glBindBuffer\0" + "glBufferData\0" + "glBufferSubData\0" + "glDeleteBuffers\0" + "glGenBuffers\0" + "glGetBufferParameteriv\0" + "glIsBuffer\0" + "glAttachShader\0" + "glBindAttribLocation\0" + "glBlendEquationSeparate\0" + "glCompileShader\0" + "glCreateProgram\0" + "glCreateShader\0" + "glDeleteProgram\0" + "glDeleteShader\0" + "glDetachShader\0" + "glDisableVertexAttribArray\0" + "glEnableVertexAttribArray\0" + "glGetActiveAttrib\0" + "glGetActiveUniform\0" + "glGetAttachedShaders\0" + "glGetAttribLocation\0" + "glGetProgramInfoLog\0" + "glGetProgramiv\0" + "glGetShaderInfoLog\0" + "glGetShaderSource\0" + "glGetShaderiv\0" + "glGetUniformLocation\0" + "glGetUniformfv\0" + "glGetUniformiv\0" + "glGetVertexAttribPointerv\0" + "glGetVertexAttribfv\0" + "glGetVertexAttribiv\0" + "glIsProgram\0" + "glIsShader\0" + "glLinkProgram\0" + "glShaderSource\0" + "glStencilFuncSeparate\0" + "glStencilMaskSeparate\0" + "glStencilOpSeparate\0" + "glUniform1f\0" + "glUniform1fv\0" + "glUniform1i\0" + "glUniform1iv\0" + "glUniform2f\0" + "glUniform2fv\0" + "glUniform2i\0" + "glUniform2iv\0" + "glUniform3f\0" + "glUniform3fv\0" + "glUniform3i\0" + "glUniform3iv\0" + "glUniform4f\0" + "glUniform4fv\0" + "glUniform4i\0" + "glUniform4iv\0" + "glUniformMatrix2fv\0" + "glUniformMatrix3fv\0" + "glUniformMatrix4fv\0" + "glUseProgram\0" + "glValidateProgram\0" + "glVertexAttrib1f\0" + "glVertexAttrib1fv\0" + "glVertexAttrib2f\0" + "glVertexAttrib2fv\0" + "glVertexAttrib3f\0" + "glVertexAttrib3fv\0" + "glVertexAttrib4f\0" + "glVertexAttrib4fv\0" + "glVertexAttribPointer\0" + "glBlendFuncSeparate\0" + "glBindFramebuffer\0" + "glBindRenderbuffer\0" + "glCheckFramebufferStatus\0" + "glClearDepthf\0" + "glDeleteFramebuffers\0" + "glDeleteRenderbuffers\0" + "glDepthRangef\0" + "glFramebufferRenderbuffer\0" + "glFramebufferTexture2D\0" + "glGenFramebuffers\0" + "glGenRenderbuffers\0" + "glGenerateMipmap\0" + "glGetFramebufferAttachmentParameteriv\0" + "glGetRenderbufferParameteriv\0" + "glGetShaderPrecisionFormat\0" + "glIsFramebuffer\0" + "glIsRenderbuffer\0" + "glReleaseShaderCompiler\0" + "glRenderbufferStorage\0" + "glShaderBinary\0" + "glTexImage3D\0" + "glTexSubImage3D\0" + "glCopyTexSubImage3D\0" + "glActiveTextureARB\0" + ; + + +#ifdef USE_MGL_NAMESPACE +#define gl_dispatch_stub_0 mgl_dispatch_stub_0 +#define gl_dispatch_stub_1 mgl_dispatch_stub_1 +#define gl_dispatch_stub_2 mgl_dispatch_stub_2 +#define gl_dispatch_stub_3 mgl_dispatch_stub_3 +#define gl_dispatch_stub_4 mgl_dispatch_stub_4 +#define gl_dispatch_stub_5 mgl_dispatch_stub_5 +#define gl_dispatch_stub_6 mgl_dispatch_stub_6 +#define gl_dispatch_stub_7 mgl_dispatch_stub_7 +#define gl_dispatch_stub_8 mgl_dispatch_stub_8 +#define gl_dispatch_stub_9 mgl_dispatch_stub_9 +#define gl_dispatch_stub_10 mgl_dispatch_stub_10 +#define gl_dispatch_stub_11 mgl_dispatch_stub_11 +#define gl_dispatch_stub_12 mgl_dispatch_stub_12 +#define gl_dispatch_stub_13 mgl_dispatch_stub_13 +#define gl_dispatch_stub_14 mgl_dispatch_stub_14 +#define gl_dispatch_stub_15 mgl_dispatch_stub_15 +#define gl_dispatch_stub_16 mgl_dispatch_stub_16 +#define gl_dispatch_stub_17 mgl_dispatch_stub_17 +#define gl_dispatch_stub_18 mgl_dispatch_stub_18 +#define gl_dispatch_stub_19 mgl_dispatch_stub_19 +#define gl_dispatch_stub_20 mgl_dispatch_stub_20 +#define gl_dispatch_stub_21 mgl_dispatch_stub_21 +#define gl_dispatch_stub_22 mgl_dispatch_stub_22 +#define gl_dispatch_stub_23 mgl_dispatch_stub_23 +#define gl_dispatch_stub_24 mgl_dispatch_stub_24 +#define gl_dispatch_stub_25 mgl_dispatch_stub_25 +#define gl_dispatch_stub_26 mgl_dispatch_stub_26 +#define gl_dispatch_stub_27 mgl_dispatch_stub_27 +#define gl_dispatch_stub_28 mgl_dispatch_stub_28 +#define gl_dispatch_stub_29 mgl_dispatch_stub_29 +#define gl_dispatch_stub_30 mgl_dispatch_stub_30 +#define gl_dispatch_stub_31 mgl_dispatch_stub_31 +#define gl_dispatch_stub_32 mgl_dispatch_stub_32 +#define gl_dispatch_stub_33 mgl_dispatch_stub_33 +#define gl_dispatch_stub_34 mgl_dispatch_stub_34 +#define gl_dispatch_stub_35 mgl_dispatch_stub_35 +#define gl_dispatch_stub_36 mgl_dispatch_stub_36 +#define gl_dispatch_stub_37 mgl_dispatch_stub_37 +#define gl_dispatch_stub_38 mgl_dispatch_stub_38 +#define gl_dispatch_stub_39 mgl_dispatch_stub_39 +#define gl_dispatch_stub_40 mgl_dispatch_stub_40 +#define gl_dispatch_stub_41 mgl_dispatch_stub_41 +#define gl_dispatch_stub_42 mgl_dispatch_stub_42 +#define gl_dispatch_stub_43 mgl_dispatch_stub_43 +#define gl_dispatch_stub_44 mgl_dispatch_stub_44 +#define gl_dispatch_stub_45 mgl_dispatch_stub_45 +#define gl_dispatch_stub_46 mgl_dispatch_stub_46 +#define gl_dispatch_stub_47 mgl_dispatch_stub_47 +#define gl_dispatch_stub_48 mgl_dispatch_stub_48 +#define gl_dispatch_stub_49 mgl_dispatch_stub_49 +#define gl_dispatch_stub_50 mgl_dispatch_stub_50 +#define gl_dispatch_stub_51 mgl_dispatch_stub_51 +#define gl_dispatch_stub_52 mgl_dispatch_stub_52 +#define gl_dispatch_stub_53 mgl_dispatch_stub_53 +#define gl_dispatch_stub_54 mgl_dispatch_stub_54 +#define gl_dispatch_stub_55 mgl_dispatch_stub_55 +#define gl_dispatch_stub_56 mgl_dispatch_stub_56 +#define gl_dispatch_stub_57 mgl_dispatch_stub_57 +#define gl_dispatch_stub_58 mgl_dispatch_stub_58 +#define gl_dispatch_stub_59 mgl_dispatch_stub_59 +#define gl_dispatch_stub_60 mgl_dispatch_stub_60 +#define gl_dispatch_stub_61 mgl_dispatch_stub_61 +#define gl_dispatch_stub_62 mgl_dispatch_stub_62 +#define gl_dispatch_stub_63 mgl_dispatch_stub_63 +#define gl_dispatch_stub_64 mgl_dispatch_stub_64 +#define gl_dispatch_stub_65 mgl_dispatch_stub_65 +#define gl_dispatch_stub_66 mgl_dispatch_stub_66 +#define gl_dispatch_stub_67 mgl_dispatch_stub_67 +#define gl_dispatch_stub_68 mgl_dispatch_stub_68 +#define gl_dispatch_stub_69 mgl_dispatch_stub_69 +#define gl_dispatch_stub_70 mgl_dispatch_stub_70 +#define gl_dispatch_stub_71 mgl_dispatch_stub_71 +#define gl_dispatch_stub_72 mgl_dispatch_stub_72 +#define gl_dispatch_stub_73 mgl_dispatch_stub_73 +#define gl_dispatch_stub_74 mgl_dispatch_stub_74 +#define gl_dispatch_stub_75 mgl_dispatch_stub_75 +#define gl_dispatch_stub_76 mgl_dispatch_stub_76 +#define gl_dispatch_stub_77 mgl_dispatch_stub_77 +#define gl_dispatch_stub_78 mgl_dispatch_stub_78 +#define gl_dispatch_stub_79 mgl_dispatch_stub_79 +#define gl_dispatch_stub_80 mgl_dispatch_stub_80 +#define gl_dispatch_stub_81 mgl_dispatch_stub_81 +#define gl_dispatch_stub_82 mgl_dispatch_stub_82 +#define gl_dispatch_stub_83 mgl_dispatch_stub_83 +#define gl_dispatch_stub_84 mgl_dispatch_stub_84 +#define gl_dispatch_stub_85 mgl_dispatch_stub_85 +#define gl_dispatch_stub_86 mgl_dispatch_stub_86 +#define gl_dispatch_stub_87 mgl_dispatch_stub_87 +#define gl_dispatch_stub_88 mgl_dispatch_stub_88 +#define gl_dispatch_stub_89 mgl_dispatch_stub_89 +#define gl_dispatch_stub_90 mgl_dispatch_stub_90 +#define gl_dispatch_stub_91 mgl_dispatch_stub_91 +#define gl_dispatch_stub_92 mgl_dispatch_stub_92 +#define gl_dispatch_stub_93 mgl_dispatch_stub_93 +#define gl_dispatch_stub_94 mgl_dispatch_stub_94 +#define gl_dispatch_stub_95 mgl_dispatch_stub_95 +#define gl_dispatch_stub_96 mgl_dispatch_stub_96 +#define gl_dispatch_stub_97 mgl_dispatch_stub_97 +#define gl_dispatch_stub_98 mgl_dispatch_stub_98 +#define gl_dispatch_stub_99 mgl_dispatch_stub_99 +#define gl_dispatch_stub_100 mgl_dispatch_stub_100 +#define gl_dispatch_stub_101 mgl_dispatch_stub_101 +#define gl_dispatch_stub_102 mgl_dispatch_stub_102 +#define gl_dispatch_stub_103 mgl_dispatch_stub_103 +#define gl_dispatch_stub_104 mgl_dispatch_stub_104 +#define gl_dispatch_stub_105 mgl_dispatch_stub_105 +#define gl_dispatch_stub_106 mgl_dispatch_stub_106 +#define gl_dispatch_stub_107 mgl_dispatch_stub_107 +#define gl_dispatch_stub_108 mgl_dispatch_stub_108 +#define gl_dispatch_stub_109 mgl_dispatch_stub_109 +#define gl_dispatch_stub_110 mgl_dispatch_stub_110 +#define gl_dispatch_stub_111 mgl_dispatch_stub_111 +#define gl_dispatch_stub_112 mgl_dispatch_stub_112 +#define gl_dispatch_stub_113 mgl_dispatch_stub_113 +#define gl_dispatch_stub_114 mgl_dispatch_stub_114 +#define gl_dispatch_stub_115 mgl_dispatch_stub_115 +#define gl_dispatch_stub_116 mgl_dispatch_stub_116 +#define gl_dispatch_stub_117 mgl_dispatch_stub_117 +#define gl_dispatch_stub_118 mgl_dispatch_stub_118 +#define gl_dispatch_stub_119 mgl_dispatch_stub_119 +#define gl_dispatch_stub_120 mgl_dispatch_stub_120 +#define gl_dispatch_stub_121 mgl_dispatch_stub_121 +#define gl_dispatch_stub_122 mgl_dispatch_stub_122 +#define gl_dispatch_stub_123 mgl_dispatch_stub_123 +#define gl_dispatch_stub_124 mgl_dispatch_stub_124 +#define gl_dispatch_stub_125 mgl_dispatch_stub_125 +#define gl_dispatch_stub_126 mgl_dispatch_stub_126 +#define gl_dispatch_stub_127 mgl_dispatch_stub_127 +#define gl_dispatch_stub_128 mgl_dispatch_stub_128 +#define gl_dispatch_stub_129 mgl_dispatch_stub_129 +#define gl_dispatch_stub_130 mgl_dispatch_stub_130 +#define gl_dispatch_stub_131 mgl_dispatch_stub_131 +#define gl_dispatch_stub_132 mgl_dispatch_stub_132 +#define gl_dispatch_stub_133 mgl_dispatch_stub_133 +#define gl_dispatch_stub_134 mgl_dispatch_stub_134 +#define gl_dispatch_stub_135 mgl_dispatch_stub_135 +#define gl_dispatch_stub_136 mgl_dispatch_stub_136 +#define gl_dispatch_stub_137 mgl_dispatch_stub_137 +#define gl_dispatch_stub_138 mgl_dispatch_stub_138 +#define gl_dispatch_stub_139 mgl_dispatch_stub_139 +#define gl_dispatch_stub_140 mgl_dispatch_stub_140 +#define gl_dispatch_stub_141 mgl_dispatch_stub_141 +#define gl_dispatch_stub_142 mgl_dispatch_stub_142 +#define gl_dispatch_stub_143 mgl_dispatch_stub_143 +#define gl_dispatch_stub_144 mgl_dispatch_stub_144 +#define gl_dispatch_stub_145 mgl_dispatch_stub_145 +#define gl_dispatch_stub_146 mgl_dispatch_stub_146 +#define gl_dispatch_stub_147 mgl_dispatch_stub_147 +#define gl_dispatch_stub_148 mgl_dispatch_stub_148 +#define gl_dispatch_stub_149 mgl_dispatch_stub_149 +#define gl_dispatch_stub_150 mgl_dispatch_stub_150 +#define gl_dispatch_stub_151 mgl_dispatch_stub_151 +#define gl_dispatch_stub_153 mgl_dispatch_stub_153 +#define gl_dispatch_stub_154 mgl_dispatch_stub_154 +#define gl_dispatch_stub_155 mgl_dispatch_stub_155 +#define gl_dispatch_stub_156 mgl_dispatch_stub_156 +#define gl_dispatch_stub_159 mgl_dispatch_stub_159 +#define gl_dispatch_stub_160 mgl_dispatch_stub_160 +#define gl_dispatch_stub_161 mgl_dispatch_stub_161 +#define gl_dispatch_stub_162 mgl_dispatch_stub_162 +#define gl_dispatch_stub_163 mgl_dispatch_stub_163 +#define gl_dispatch_stub_164 mgl_dispatch_stub_164 +#define gl_dispatch_stub_165 mgl_dispatch_stub_165 +#define gl_dispatch_stub_166 mgl_dispatch_stub_166 +#define gl_dispatch_stub_167 mgl_dispatch_stub_167 +#define gl_dispatch_stub_169 mgl_dispatch_stub_169 +#define gl_dispatch_stub_170 mgl_dispatch_stub_170 +#define gl_dispatch_stub_171 mgl_dispatch_stub_171 +#define gl_dispatch_stub_172 mgl_dispatch_stub_172 +#define gl_dispatch_stub_173 mgl_dispatch_stub_173 +#define gl_dispatch_stub_174 mgl_dispatch_stub_174 +#define gl_dispatch_stub_175 mgl_dispatch_stub_175 +#define gl_dispatch_stub_177 mgl_dispatch_stub_177 +#define gl_dispatch_stub_182 mgl_dispatch_stub_182 +#define gl_dispatch_stub_184 mgl_dispatch_stub_184 +#define gl_dispatch_stub_185 mgl_dispatch_stub_185 +#define gl_dispatch_stub_186 mgl_dispatch_stub_186 +#define gl_dispatch_stub_187 mgl_dispatch_stub_187 +#define gl_dispatch_stub_188 mgl_dispatch_stub_188 +#define gl_dispatch_stub_189 mgl_dispatch_stub_189 +#define gl_dispatch_stub_190 mgl_dispatch_stub_190 +#define gl_dispatch_stub_191 mgl_dispatch_stub_191 +#define gl_dispatch_stub_192 mgl_dispatch_stub_192 +#define gl_dispatch_stub_193 mgl_dispatch_stub_193 +#define gl_dispatch_stub_194 mgl_dispatch_stub_194 +#define gl_dispatch_stub_195 mgl_dispatch_stub_195 +#define gl_dispatch_stub_196 mgl_dispatch_stub_196 +#define gl_dispatch_stub_197 mgl_dispatch_stub_197 +#define gl_dispatch_stub_198 mgl_dispatch_stub_198 +#define gl_dispatch_stub_199 mgl_dispatch_stub_199 +#define gl_dispatch_stub_200 mgl_dispatch_stub_200 +#define gl_dispatch_stub_201 mgl_dispatch_stub_201 +#define gl_dispatch_stub_202 mgl_dispatch_stub_202 +#define gl_dispatch_stub_204 mgl_dispatch_stub_204 +#define gl_dispatch_stub_205 mgl_dispatch_stub_205 +#define gl_dispatch_stub_208 mgl_dispatch_stub_208 +#define gl_dispatch_stub_212 mgl_dispatch_stub_212 +#define gl_dispatch_stub_213 mgl_dispatch_stub_213 +#define gl_dispatch_stub_218 mgl_dispatch_stub_218 +#define gl_dispatch_stub_219 mgl_dispatch_stub_219 +#define gl_dispatch_stub_220 mgl_dispatch_stub_220 +#define gl_dispatch_stub_221 mgl_dispatch_stub_221 +#define gl_dispatch_stub_222 mgl_dispatch_stub_222 +#define gl_dispatch_stub_223 mgl_dispatch_stub_223 +#define gl_dispatch_stub_224 mgl_dispatch_stub_224 +#define gl_dispatch_stub_225 mgl_dispatch_stub_225 +#define gl_dispatch_stub_226 mgl_dispatch_stub_226 +#define gl_dispatch_stub_227 mgl_dispatch_stub_227 +#define gl_dispatch_stub_228 mgl_dispatch_stub_228 +#define gl_dispatch_stub_229 mgl_dispatch_stub_229 +#define gl_dispatch_stub_230 mgl_dispatch_stub_230 +#define gl_dispatch_stub_231 mgl_dispatch_stub_231 +#define gl_dispatch_stub_232 mgl_dispatch_stub_232 +#define gl_dispatch_stub_233 mgl_dispatch_stub_233 +#define gl_dispatch_stub_234 mgl_dispatch_stub_234 +#define gl_dispatch_stub_235 mgl_dispatch_stub_235 +#define gl_dispatch_stub_236 mgl_dispatch_stub_236 +#define gl_dispatch_stub_237 mgl_dispatch_stub_237 +#define gl_dispatch_stub_238 mgl_dispatch_stub_238 +#define gl_dispatch_stub_239 mgl_dispatch_stub_239 +#define gl_dispatch_stub_240 mgl_dispatch_stub_240 +#define gl_dispatch_stub_242 mgl_dispatch_stub_242 +#define gl_dispatch_stub_246 mgl_dispatch_stub_246 +#define gl_dispatch_stub_247 mgl_dispatch_stub_247 +#define gl_dispatch_stub_248 mgl_dispatch_stub_248 +#define gl_dispatch_stub_249 mgl_dispatch_stub_249 +#define gl_dispatch_stub_251 mgl_dispatch_stub_251 +#define gl_dispatch_stub_252 mgl_dispatch_stub_252 +#define gl_dispatch_stub_253 mgl_dispatch_stub_253 +#define gl_dispatch_stub_254 mgl_dispatch_stub_254 +#define gl_dispatch_stub_255 mgl_dispatch_stub_255 +#define gl_dispatch_stub_257 mgl_dispatch_stub_257 +#define gl_dispatch_stub_259 mgl_dispatch_stub_259 +#define gl_dispatch_stub_260 mgl_dispatch_stub_260 +#define gl_dispatch_stub_264 mgl_dispatch_stub_264 +#define gl_dispatch_stub_265 mgl_dispatch_stub_265 +#define gl_dispatch_stub_266 mgl_dispatch_stub_266 +#define gl_dispatch_stub_267 mgl_dispatch_stub_267 +#define gl_dispatch_stub_268 mgl_dispatch_stub_268 +#define gl_dispatch_stub_269 mgl_dispatch_stub_269 +#define gl_dispatch_stub_270 mgl_dispatch_stub_270 +#define gl_dispatch_stub_271 mgl_dispatch_stub_271 +#define gl_dispatch_stub_272 mgl_dispatch_stub_272 +#define gl_dispatch_stub_273 mgl_dispatch_stub_273 +#define gl_dispatch_stub_274 mgl_dispatch_stub_274 +#define gl_dispatch_stub_276 mgl_dispatch_stub_276 +#define gl_dispatch_stub_277 mgl_dispatch_stub_277 +#define gl_dispatch_stub_278 mgl_dispatch_stub_278 +#define gl_dispatch_stub_279 mgl_dispatch_stub_279 +#define gl_dispatch_stub_280 mgl_dispatch_stub_280 +#define gl_dispatch_stub_281 mgl_dispatch_stub_281 +#define gl_dispatch_stub_284 mgl_dispatch_stub_284 +#define gl_dispatch_stub_285 mgl_dispatch_stub_285 +#define gl_dispatch_stub_287 mgl_dispatch_stub_287 +#define gl_dispatch_stub_288 mgl_dispatch_stub_288 +#define gl_dispatch_stub_289 mgl_dispatch_stub_289 +#define gl_dispatch_stub_290 mgl_dispatch_stub_290 +#define gl_dispatch_stub_291 mgl_dispatch_stub_291 +#define gl_dispatch_stub_292 mgl_dispatch_stub_292 +#define gl_dispatch_stub_293 mgl_dispatch_stub_293 +#define gl_dispatch_stub_294 mgl_dispatch_stub_294 +#define gl_dispatch_stub_295 mgl_dispatch_stub_295 +#define gl_dispatch_stub_296 mgl_dispatch_stub_296 +#define gl_dispatch_stub_297 mgl_dispatch_stub_297 +#define gl_dispatch_stub_298 mgl_dispatch_stub_298 +#define gl_dispatch_stub_299 mgl_dispatch_stub_299 +#define gl_dispatch_stub_300 mgl_dispatch_stub_300 +#define gl_dispatch_stub_301 mgl_dispatch_stub_301 +#define gl_dispatch_stub_302 mgl_dispatch_stub_302 +#define gl_dispatch_stub_303 mgl_dispatch_stub_303 +#define gl_dispatch_stub_304 mgl_dispatch_stub_304 +#define gl_dispatch_stub_306 mgl_dispatch_stub_306 +#define gl_dispatch_stub_308 mgl_dispatch_stub_308 +#define gl_dispatch_stub_309 mgl_dispatch_stub_309 +#define gl_dispatch_stub_312 mgl_dispatch_stub_312 +#define gl_dispatch_stub_313 mgl_dispatch_stub_313 +#define gl_dispatch_stub_314 mgl_dispatch_stub_314 +#define gl_dispatch_stub_315 mgl_dispatch_stub_315 +#define gl_dispatch_stub_316 mgl_dispatch_stub_316 +#define gl_dispatch_stub_317 mgl_dispatch_stub_317 +#define gl_dispatch_stub_318 mgl_dispatch_stub_318 +#define gl_dispatch_stub_320 mgl_dispatch_stub_320 +#define gl_dispatch_stub_321 mgl_dispatch_stub_321 +#define gl_dispatch_stub_322 mgl_dispatch_stub_322 +#define gl_dispatch_stub_323 mgl_dispatch_stub_323 +#define gl_dispatch_stub_325 mgl_dispatch_stub_325 +#define gl_dispatch_stub_329 mgl_dispatch_stub_329 +#define gl_dispatch_stub_331 mgl_dispatch_stub_331 +#define gl_dispatch_stub_332 mgl_dispatch_stub_332 +#define gl_dispatch_stub_334 mgl_dispatch_stub_334 +#define gl_dispatch_stub_335 mgl_dispatch_stub_335 +#define gl_dispatch_stub_338 mgl_dispatch_stub_338 +#define gl_dispatch_stub_339 mgl_dispatch_stub_339 +#define gl_dispatch_stub_340 mgl_dispatch_stub_340 +#define gl_dispatch_stub_341 mgl_dispatch_stub_341 +#define gl_dispatch_stub_342 mgl_dispatch_stub_342 +#define gl_dispatch_stub_343 mgl_dispatch_stub_343 +#define gl_dispatch_stub_344 mgl_dispatch_stub_344 +#define gl_dispatch_stub_345 mgl_dispatch_stub_345 +#define gl_dispatch_stub_346 mgl_dispatch_stub_346 +#define gl_dispatch_stub_347 mgl_dispatch_stub_347 +#define gl_dispatch_stub_348 mgl_dispatch_stub_348 +#define gl_dispatch_stub_349 mgl_dispatch_stub_349 +#define gl_dispatch_stub_350 mgl_dispatch_stub_350 +#define gl_dispatch_stub_351 mgl_dispatch_stub_351 +#define gl_dispatch_stub_352 mgl_dispatch_stub_352 +#define gl_dispatch_stub_353 mgl_dispatch_stub_353 +#define gl_dispatch_stub_354 mgl_dispatch_stub_354 +#define gl_dispatch_stub_355 mgl_dispatch_stub_355 +#define gl_dispatch_stub_356 mgl_dispatch_stub_356 +#define gl_dispatch_stub_357 mgl_dispatch_stub_357 +#define gl_dispatch_stub_358 mgl_dispatch_stub_358 +#define gl_dispatch_stub_359 mgl_dispatch_stub_359 +#define gl_dispatch_stub_360 mgl_dispatch_stub_360 +#define gl_dispatch_stub_361 mgl_dispatch_stub_361 +#define gl_dispatch_stub_362 mgl_dispatch_stub_362 +#define gl_dispatch_stub_363 mgl_dispatch_stub_363 +#define gl_dispatch_stub_364 mgl_dispatch_stub_364 +#define gl_dispatch_stub_365 mgl_dispatch_stub_365 +#define gl_dispatch_stub_366 mgl_dispatch_stub_366 +#define gl_dispatch_stub_367 mgl_dispatch_stub_367 +#define gl_dispatch_stub_368 mgl_dispatch_stub_368 +#define gl_dispatch_stub_369 mgl_dispatch_stub_369 +#define gl_dispatch_stub_370 mgl_dispatch_stub_370 +#define gl_dispatch_stub_375 mgl_dispatch_stub_375 +#define gl_dispatch_stub_376 mgl_dispatch_stub_376 +#define gl_dispatch_stub_377 mgl_dispatch_stub_377 +#define gl_dispatch_stub_378 mgl_dispatch_stub_378 +#define gl_dispatch_stub_379 mgl_dispatch_stub_379 +#define gl_dispatch_stub_380 mgl_dispatch_stub_380 +#define gl_dispatch_stub_381 mgl_dispatch_stub_381 +#define gl_dispatch_stub_382 mgl_dispatch_stub_382 +#define gl_dispatch_stub_383 mgl_dispatch_stub_383 +#define gl_dispatch_stub_384 mgl_dispatch_stub_384 +#define gl_dispatch_stub_385 mgl_dispatch_stub_385 +#define gl_dispatch_stub_386 mgl_dispatch_stub_386 +#define gl_dispatch_stub_387 mgl_dispatch_stub_387 +#define gl_dispatch_stub_388 mgl_dispatch_stub_388 +#define gl_dispatch_stub_389 mgl_dispatch_stub_389 +#define gl_dispatch_stub_390 mgl_dispatch_stub_390 +#define gl_dispatch_stub_391 mgl_dispatch_stub_391 +#define gl_dispatch_stub_392 mgl_dispatch_stub_392 +#define gl_dispatch_stub_393 mgl_dispatch_stub_393 +#define gl_dispatch_stub_394 mgl_dispatch_stub_394 +#define gl_dispatch_stub_395 mgl_dispatch_stub_395 +#define gl_dispatch_stub_396 mgl_dispatch_stub_396 +#define gl_dispatch_stub_397 mgl_dispatch_stub_397 +#define gl_dispatch_stub_398 mgl_dispatch_stub_398 +#define gl_dispatch_stub_399 mgl_dispatch_stub_399 +#define gl_dispatch_stub_400 mgl_dispatch_stub_400 +#define gl_dispatch_stub_401 mgl_dispatch_stub_401 +#define gl_dispatch_stub_402 mgl_dispatch_stub_402 +#define gl_dispatch_stub_403 mgl_dispatch_stub_403 +#define gl_dispatch_stub_404 mgl_dispatch_stub_404 +#define gl_dispatch_stub_405 mgl_dispatch_stub_405 +#define gl_dispatch_stub_406 mgl_dispatch_stub_406 +#define gl_dispatch_stub_407 mgl_dispatch_stub_407 +#define gl_dispatch_stub_418 mgl_dispatch_stub_418 +#define gl_dispatch_stub_419 mgl_dispatch_stub_419 +#define gl_dispatch_stub_420 mgl_dispatch_stub_420 +#define gl_dispatch_stub_421 mgl_dispatch_stub_421 +#endif /* USE_MGL_NAMESPACE */ + + +#if defined(NEED_FUNCTION_POINTER) || defined(GLX_INDIRECT_RENDERING) +void GLAPIENTRY gl_dispatch_stub_0(GLuint list, GLenum mode); +void GLAPIENTRY gl_dispatch_stub_1(void); +void GLAPIENTRY gl_dispatch_stub_2(GLuint list); +void GLAPIENTRY gl_dispatch_stub_3(GLsizei n, GLenum type, const GLvoid * lists); +void GLAPIENTRY gl_dispatch_stub_4(GLuint list, GLsizei range); +GLuint GLAPIENTRY gl_dispatch_stub_5(GLsizei range); +void GLAPIENTRY gl_dispatch_stub_6(GLuint base); +void GLAPIENTRY gl_dispatch_stub_7(GLenum mode); +void GLAPIENTRY gl_dispatch_stub_8(GLsizei width, GLsizei height, GLfloat xorig, GLfloat yorig, GLfloat xmove, GLfloat ymove, const GLubyte * bitmap); +void GLAPIENTRY gl_dispatch_stub_9(GLbyte red, GLbyte green, GLbyte blue); +void GLAPIENTRY gl_dispatch_stub_10(const GLbyte * v); +void GLAPIENTRY gl_dispatch_stub_11(GLdouble red, GLdouble green, GLdouble blue); +void GLAPIENTRY gl_dispatch_stub_12(const GLdouble * v); +void GLAPIENTRY gl_dispatch_stub_13(GLfloat red, GLfloat green, GLfloat blue); +void GLAPIENTRY gl_dispatch_stub_14(const GLfloat * v); +void GLAPIENTRY gl_dispatch_stub_15(GLint red, GLint green, GLint blue); +void GLAPIENTRY gl_dispatch_stub_16(const GLint * v); +void GLAPIENTRY gl_dispatch_stub_17(GLshort red, GLshort green, GLshort blue); +void GLAPIENTRY gl_dispatch_stub_18(const GLshort * v); +void GLAPIENTRY gl_dispatch_stub_19(GLubyte red, GLubyte green, GLubyte blue); +void GLAPIENTRY gl_dispatch_stub_20(const GLubyte * v); +void GLAPIENTRY gl_dispatch_stub_21(GLuint red, GLuint green, GLuint blue); +void GLAPIENTRY gl_dispatch_stub_22(const GLuint * v); +void GLAPIENTRY gl_dispatch_stub_23(GLushort red, GLushort green, GLushort blue); +void GLAPIENTRY gl_dispatch_stub_24(const GLushort * v); +void GLAPIENTRY gl_dispatch_stub_25(GLbyte red, GLbyte green, GLbyte blue, GLbyte alpha); +void GLAPIENTRY gl_dispatch_stub_26(const GLbyte * v); +void GLAPIENTRY gl_dispatch_stub_27(GLdouble red, GLdouble green, GLdouble blue, GLdouble alpha); +void GLAPIENTRY gl_dispatch_stub_28(const GLdouble * v); +void GLAPIENTRY gl_dispatch_stub_29(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha); +void GLAPIENTRY gl_dispatch_stub_30(const GLfloat * v); +void GLAPIENTRY gl_dispatch_stub_31(GLint red, GLint green, GLint blue, GLint alpha); +void GLAPIENTRY gl_dispatch_stub_32(const GLint * v); +void GLAPIENTRY gl_dispatch_stub_33(GLshort red, GLshort green, GLshort blue, GLshort alpha); +void GLAPIENTRY gl_dispatch_stub_34(const GLshort * v); +void GLAPIENTRY gl_dispatch_stub_35(GLubyte red, GLubyte green, GLubyte blue, GLubyte alpha); +void GLAPIENTRY gl_dispatch_stub_36(const GLubyte * v); +void GLAPIENTRY gl_dispatch_stub_37(GLuint red, GLuint green, GLuint blue, GLuint alpha); +void GLAPIENTRY gl_dispatch_stub_38(const GLuint * v); +void GLAPIENTRY gl_dispatch_stub_39(GLushort red, GLushort green, GLushort blue, GLushort alpha); +void GLAPIENTRY gl_dispatch_stub_40(const GLushort * v); +void GLAPIENTRY gl_dispatch_stub_41(GLboolean flag); +void GLAPIENTRY gl_dispatch_stub_42(const GLboolean * flag); +void GLAPIENTRY gl_dispatch_stub_43(void); +void GLAPIENTRY gl_dispatch_stub_44(GLdouble c); +void GLAPIENTRY gl_dispatch_stub_45(const GLdouble * c); +void GLAPIENTRY gl_dispatch_stub_46(GLfloat c); +void GLAPIENTRY gl_dispatch_stub_47(const GLfloat * c); +void GLAPIENTRY gl_dispatch_stub_48(GLint c); +void GLAPIENTRY gl_dispatch_stub_49(const GLint * c); +void GLAPIENTRY gl_dispatch_stub_50(GLshort c); +void GLAPIENTRY gl_dispatch_stub_51(const GLshort * c); +void GLAPIENTRY gl_dispatch_stub_52(GLbyte nx, GLbyte ny, GLbyte nz); +void GLAPIENTRY gl_dispatch_stub_53(const GLbyte * v); +void GLAPIENTRY gl_dispatch_stub_54(GLdouble nx, GLdouble ny, GLdouble nz); +void GLAPIENTRY gl_dispatch_stub_55(const GLdouble * v); +void GLAPIENTRY gl_dispatch_stub_56(GLfloat nx, GLfloat ny, GLfloat nz); +void GLAPIENTRY gl_dispatch_stub_57(const GLfloat * v); +void GLAPIENTRY gl_dispatch_stub_58(GLint nx, GLint ny, GLint nz); +void GLAPIENTRY gl_dispatch_stub_59(const GLint * v); +void GLAPIENTRY gl_dispatch_stub_60(GLshort nx, GLshort ny, GLshort nz); +void GLAPIENTRY gl_dispatch_stub_61(const GLshort * v); +void GLAPIENTRY gl_dispatch_stub_62(GLdouble x, GLdouble y); +void GLAPIENTRY gl_dispatch_stub_63(const GLdouble * v); +void GLAPIENTRY gl_dispatch_stub_64(GLfloat x, GLfloat y); +void GLAPIENTRY gl_dispatch_stub_65(const GLfloat * v); +void GLAPIENTRY gl_dispatch_stub_66(GLint x, GLint y); +void GLAPIENTRY gl_dispatch_stub_67(const GLint * v); +void GLAPIENTRY gl_dispatch_stub_68(GLshort x, GLshort y); +void GLAPIENTRY gl_dispatch_stub_69(const GLshort * v); +void GLAPIENTRY gl_dispatch_stub_70(GLdouble x, GLdouble y, GLdouble z); +void GLAPIENTRY gl_dispatch_stub_71(const GLdouble * v); +void GLAPIENTRY gl_dispatch_stub_72(GLfloat x, GLfloat y, GLfloat z); +void GLAPIENTRY gl_dispatch_stub_73(const GLfloat * v); +void GLAPIENTRY gl_dispatch_stub_74(GLint x, GLint y, GLint z); +void GLAPIENTRY gl_dispatch_stub_75(const GLint * v); +void GLAPIENTRY gl_dispatch_stub_76(GLshort x, GLshort y, GLshort z); +void GLAPIENTRY gl_dispatch_stub_77(const GLshort * v); +void GLAPIENTRY gl_dispatch_stub_78(GLdouble x, GLdouble y, GLdouble z, GLdouble w); +void GLAPIENTRY gl_dispatch_stub_79(const GLdouble * v); +void GLAPIENTRY gl_dispatch_stub_80(GLfloat x, GLfloat y, GLfloat z, GLfloat w); +void GLAPIENTRY gl_dispatch_stub_81(const GLfloat * v); +void GLAPIENTRY gl_dispatch_stub_82(GLint x, GLint y, GLint z, GLint w); +void GLAPIENTRY gl_dispatch_stub_83(const GLint * v); +void GLAPIENTRY gl_dispatch_stub_84(GLshort x, GLshort y, GLshort z, GLshort w); +void GLAPIENTRY gl_dispatch_stub_85(const GLshort * v); +void GLAPIENTRY gl_dispatch_stub_86(GLdouble x1, GLdouble y1, GLdouble x2, GLdouble y2); +void GLAPIENTRY gl_dispatch_stub_87(const GLdouble * v1, const GLdouble * v2); +void GLAPIENTRY gl_dispatch_stub_88(GLfloat x1, GLfloat y1, GLfloat x2, GLfloat y2); +void GLAPIENTRY gl_dispatch_stub_89(const GLfloat * v1, const GLfloat * v2); +void GLAPIENTRY gl_dispatch_stub_90(GLint x1, GLint y1, GLint x2, GLint y2); +void GLAPIENTRY gl_dispatch_stub_91(const GLint * v1, const GLint * v2); +void GLAPIENTRY gl_dispatch_stub_92(GLshort x1, GLshort y1, GLshort x2, GLshort y2); +void GLAPIENTRY gl_dispatch_stub_93(const GLshort * v1, const GLshort * v2); +void GLAPIENTRY gl_dispatch_stub_94(GLdouble s); +void GLAPIENTRY gl_dispatch_stub_95(const GLdouble * v); +void GLAPIENTRY gl_dispatch_stub_96(GLfloat s); +void GLAPIENTRY gl_dispatch_stub_97(const GLfloat * v); +void GLAPIENTRY gl_dispatch_stub_98(GLint s); +void GLAPIENTRY gl_dispatch_stub_99(const GLint * v); +void GLAPIENTRY gl_dispatch_stub_100(GLshort s); +void GLAPIENTRY gl_dispatch_stub_101(const GLshort * v); +void GLAPIENTRY gl_dispatch_stub_102(GLdouble s, GLdouble t); +void GLAPIENTRY gl_dispatch_stub_103(const GLdouble * v); +void GLAPIENTRY gl_dispatch_stub_104(GLfloat s, GLfloat t); +void GLAPIENTRY gl_dispatch_stub_105(const GLfloat * v); +void GLAPIENTRY gl_dispatch_stub_106(GLint s, GLint t); +void GLAPIENTRY gl_dispatch_stub_107(const GLint * v); +void GLAPIENTRY gl_dispatch_stub_108(GLshort s, GLshort t); +void GLAPIENTRY gl_dispatch_stub_109(const GLshort * v); +void GLAPIENTRY gl_dispatch_stub_110(GLdouble s, GLdouble t, GLdouble r); +void GLAPIENTRY gl_dispatch_stub_111(const GLdouble * v); +void GLAPIENTRY gl_dispatch_stub_112(GLfloat s, GLfloat t, GLfloat r); +void GLAPIENTRY gl_dispatch_stub_113(const GLfloat * v); +void GLAPIENTRY gl_dispatch_stub_114(GLint s, GLint t, GLint r); +void GLAPIENTRY gl_dispatch_stub_115(const GLint * v); +void GLAPIENTRY gl_dispatch_stub_116(GLshort s, GLshort t, GLshort r); +void GLAPIENTRY gl_dispatch_stub_117(const GLshort * v); +void GLAPIENTRY gl_dispatch_stub_118(GLdouble s, GLdouble t, GLdouble r, GLdouble q); +void GLAPIENTRY gl_dispatch_stub_119(const GLdouble * v); +void GLAPIENTRY gl_dispatch_stub_120(GLfloat s, GLfloat t, GLfloat r, GLfloat q); +void GLAPIENTRY gl_dispatch_stub_121(const GLfloat * v); +void GLAPIENTRY gl_dispatch_stub_122(GLint s, GLint t, GLint r, GLint q); +void GLAPIENTRY gl_dispatch_stub_123(const GLint * v); +void GLAPIENTRY gl_dispatch_stub_124(GLshort s, GLshort t, GLshort r, GLshort q); +void GLAPIENTRY gl_dispatch_stub_125(const GLshort * v); +void GLAPIENTRY gl_dispatch_stub_126(GLdouble x, GLdouble y); +void GLAPIENTRY gl_dispatch_stub_127(const GLdouble * v); +void GLAPIENTRY gl_dispatch_stub_128(GLfloat x, GLfloat y); +void GLAPIENTRY gl_dispatch_stub_129(const GLfloat * v); +void GLAPIENTRY gl_dispatch_stub_130(GLint x, GLint y); +void GLAPIENTRY gl_dispatch_stub_131(const GLint * v); +void GLAPIENTRY gl_dispatch_stub_132(GLshort x, GLshort y); +void GLAPIENTRY gl_dispatch_stub_133(const GLshort * v); +void GLAPIENTRY gl_dispatch_stub_134(GLdouble x, GLdouble y, GLdouble z); +void GLAPIENTRY gl_dispatch_stub_135(const GLdouble * v); +void GLAPIENTRY gl_dispatch_stub_136(GLfloat x, GLfloat y, GLfloat z); +void GLAPIENTRY gl_dispatch_stub_137(const GLfloat * v); +void GLAPIENTRY gl_dispatch_stub_138(GLint x, GLint y, GLint z); +void GLAPIENTRY gl_dispatch_stub_139(const GLint * v); +void GLAPIENTRY gl_dispatch_stub_140(GLshort x, GLshort y, GLshort z); +void GLAPIENTRY gl_dispatch_stub_141(const GLshort * v); +void GLAPIENTRY gl_dispatch_stub_142(GLdouble x, GLdouble y, GLdouble z, GLdouble w); +void GLAPIENTRY gl_dispatch_stub_143(const GLdouble * v); +void GLAPIENTRY gl_dispatch_stub_144(GLfloat x, GLfloat y, GLfloat z, GLfloat w); +void GLAPIENTRY gl_dispatch_stub_145(const GLfloat * v); +void GLAPIENTRY gl_dispatch_stub_146(GLint x, GLint y, GLint z, GLint w); +void GLAPIENTRY gl_dispatch_stub_147(const GLint * v); +void GLAPIENTRY gl_dispatch_stub_148(GLshort x, GLshort y, GLshort z, GLshort w); +void GLAPIENTRY gl_dispatch_stub_149(const GLshort * v); +void GLAPIENTRY gl_dispatch_stub_150(GLenum plane, const GLdouble * equation); +void GLAPIENTRY gl_dispatch_stub_151(GLenum face, GLenum mode); +void GLAPIENTRY gl_dispatch_stub_153(GLenum pname, GLfloat param); +void GLAPIENTRY gl_dispatch_stub_154(GLenum pname, const GLfloat * params); +void GLAPIENTRY gl_dispatch_stub_155(GLenum pname, GLint param); +void GLAPIENTRY gl_dispatch_stub_156(GLenum pname, const GLint * params); +void GLAPIENTRY gl_dispatch_stub_159(GLenum light, GLenum pname, GLfloat param); +void GLAPIENTRY gl_dispatch_stub_160(GLenum light, GLenum pname, const GLfloat * params); +void GLAPIENTRY gl_dispatch_stub_161(GLenum light, GLenum pname, GLint param); +void GLAPIENTRY gl_dispatch_stub_162(GLenum light, GLenum pname, const GLint * params); +void GLAPIENTRY gl_dispatch_stub_163(GLenum pname, GLfloat param); +void GLAPIENTRY gl_dispatch_stub_164(GLenum pname, const GLfloat * params); +void GLAPIENTRY gl_dispatch_stub_165(GLenum pname, GLint param); +void GLAPIENTRY gl_dispatch_stub_166(GLenum pname, const GLint * params); +void GLAPIENTRY gl_dispatch_stub_167(GLint factor, GLushort pattern); +void GLAPIENTRY gl_dispatch_stub_169(GLenum face, GLenum pname, GLfloat param); +void GLAPIENTRY gl_dispatch_stub_170(GLenum face, GLenum pname, const GLfloat * params); +void GLAPIENTRY gl_dispatch_stub_171(GLenum face, GLenum pname, GLint param); +void GLAPIENTRY gl_dispatch_stub_172(GLenum face, GLenum pname, const GLint * params); +void GLAPIENTRY gl_dispatch_stub_173(GLfloat size); +void GLAPIENTRY gl_dispatch_stub_174(GLenum face, GLenum mode); +void GLAPIENTRY gl_dispatch_stub_175(const GLubyte * mask); +void GLAPIENTRY gl_dispatch_stub_177(GLenum mode); +void GLAPIENTRY gl_dispatch_stub_182(GLenum target, GLint level, GLint internalformat, GLsizei width, GLint border, GLenum format, GLenum type, const GLvoid * pixels); +void GLAPIENTRY gl_dispatch_stub_184(GLenum target, GLenum pname, GLfloat param); +void GLAPIENTRY gl_dispatch_stub_185(GLenum target, GLenum pname, const GLfloat * params); +void GLAPIENTRY gl_dispatch_stub_186(GLenum target, GLenum pname, GLint param); +void GLAPIENTRY gl_dispatch_stub_187(GLenum target, GLenum pname, const GLint * params); +void GLAPIENTRY gl_dispatch_stub_188(GLenum coord, GLenum pname, GLdouble param); +void GLAPIENTRY gl_dispatch_stub_189(GLenum coord, GLenum pname, const GLdouble * params); +void GLAPIENTRY gl_dispatch_stub_190(GLenum coord, GLenum pname, GLfloat param); +void GLAPIENTRY gl_dispatch_stub_191(GLenum coord, GLenum pname, const GLfloat * params); +void GLAPIENTRY gl_dispatch_stub_192(GLenum coord, GLenum pname, GLint param); +void GLAPIENTRY gl_dispatch_stub_193(GLenum coord, GLenum pname, const GLint * params); +void GLAPIENTRY gl_dispatch_stub_194(GLsizei size, GLenum type, GLfloat * buffer); +void GLAPIENTRY gl_dispatch_stub_195(GLsizei size, GLuint * buffer); +GLint GLAPIENTRY gl_dispatch_stub_196(GLenum mode); +void GLAPIENTRY gl_dispatch_stub_197(void); +void GLAPIENTRY gl_dispatch_stub_198(GLuint name); +void GLAPIENTRY gl_dispatch_stub_199(GLfloat token); +void GLAPIENTRY gl_dispatch_stub_200(void); +void GLAPIENTRY gl_dispatch_stub_201(GLuint name); +void GLAPIENTRY gl_dispatch_stub_202(GLenum mode); +void GLAPIENTRY gl_dispatch_stub_204(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha); +void GLAPIENTRY gl_dispatch_stub_205(GLfloat c); +void GLAPIENTRY gl_dispatch_stub_208(GLclampd depth); +void GLAPIENTRY gl_dispatch_stub_212(GLuint mask); +void GLAPIENTRY gl_dispatch_stub_213(GLenum op, GLfloat value); +void GLAPIENTRY gl_dispatch_stub_218(void); +void GLAPIENTRY gl_dispatch_stub_219(GLbitfield mask); +void GLAPIENTRY gl_dispatch_stub_220(GLenum target, GLdouble u1, GLdouble u2, GLint stride, GLint order, const GLdouble * points); +void GLAPIENTRY gl_dispatch_stub_221(GLenum target, GLfloat u1, GLfloat u2, GLint stride, GLint order, const GLfloat * points); +void GLAPIENTRY gl_dispatch_stub_222(GLenum target, GLdouble u1, GLdouble u2, GLint ustride, GLint uorder, GLdouble v1, GLdouble v2, GLint vstride, GLint vorder, const GLdouble * points); +void GLAPIENTRY gl_dispatch_stub_223(GLenum target, GLfloat u1, GLfloat u2, GLint ustride, GLint uorder, GLfloat v1, GLfloat v2, GLint vstride, GLint vorder, const GLfloat * points); +void GLAPIENTRY gl_dispatch_stub_224(GLint un, GLdouble u1, GLdouble u2); +void GLAPIENTRY gl_dispatch_stub_225(GLint un, GLfloat u1, GLfloat u2); +void GLAPIENTRY gl_dispatch_stub_226(GLint un, GLdouble u1, GLdouble u2, GLint vn, GLdouble v1, GLdouble v2); +void GLAPIENTRY gl_dispatch_stub_227(GLint un, GLfloat u1, GLfloat u2, GLint vn, GLfloat v1, GLfloat v2); +void GLAPIENTRY gl_dispatch_stub_228(GLdouble u); +void GLAPIENTRY gl_dispatch_stub_229(const GLdouble * u); +void GLAPIENTRY gl_dispatch_stub_230(GLfloat u); +void GLAPIENTRY gl_dispatch_stub_231(const GLfloat * u); +void GLAPIENTRY gl_dispatch_stub_232(GLdouble u, GLdouble v); +void GLAPIENTRY gl_dispatch_stub_233(const GLdouble * u); +void GLAPIENTRY gl_dispatch_stub_234(GLfloat u, GLfloat v); +void GLAPIENTRY gl_dispatch_stub_235(const GLfloat * u); +void GLAPIENTRY gl_dispatch_stub_236(GLenum mode, GLint i1, GLint i2); +void GLAPIENTRY gl_dispatch_stub_237(GLint i); +void GLAPIENTRY gl_dispatch_stub_238(GLenum mode, GLint i1, GLint i2, GLint j1, GLint j2); +void GLAPIENTRY gl_dispatch_stub_239(GLint i, GLint j); +void GLAPIENTRY gl_dispatch_stub_240(GLenum func, GLclampf ref); +void GLAPIENTRY gl_dispatch_stub_242(GLenum opcode); +void GLAPIENTRY gl_dispatch_stub_246(GLfloat xfactor, GLfloat yfactor); +void GLAPIENTRY gl_dispatch_stub_247(GLenum pname, GLfloat param); +void GLAPIENTRY gl_dispatch_stub_248(GLenum pname, GLint param); +void GLAPIENTRY gl_dispatch_stub_249(GLenum pname, GLfloat param); +void GLAPIENTRY gl_dispatch_stub_251(GLenum map, GLsizei mapsize, const GLfloat * values); +void GLAPIENTRY gl_dispatch_stub_252(GLenum map, GLsizei mapsize, const GLuint * values); +void GLAPIENTRY gl_dispatch_stub_253(GLenum map, GLsizei mapsize, const GLushort * values); +void GLAPIENTRY gl_dispatch_stub_254(GLenum mode); +void GLAPIENTRY gl_dispatch_stub_255(GLint x, GLint y, GLsizei width, GLsizei height, GLenum type); +void GLAPIENTRY gl_dispatch_stub_257(GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid * pixels); +void GLAPIENTRY gl_dispatch_stub_259(GLenum plane, GLdouble * equation); +void GLAPIENTRY gl_dispatch_stub_260(GLenum pname, GLdouble * params); +void GLAPIENTRY gl_dispatch_stub_264(GLenum light, GLenum pname, GLfloat * params); +void GLAPIENTRY gl_dispatch_stub_265(GLenum light, GLenum pname, GLint * params); +void GLAPIENTRY gl_dispatch_stub_266(GLenum target, GLenum query, GLdouble * v); +void GLAPIENTRY gl_dispatch_stub_267(GLenum target, GLenum query, GLfloat * v); +void GLAPIENTRY gl_dispatch_stub_268(GLenum target, GLenum query, GLint * v); +void GLAPIENTRY gl_dispatch_stub_269(GLenum face, GLenum pname, GLfloat * params); +void GLAPIENTRY gl_dispatch_stub_270(GLenum face, GLenum pname, GLint * params); +void GLAPIENTRY gl_dispatch_stub_271(GLenum map, GLfloat * values); +void GLAPIENTRY gl_dispatch_stub_272(GLenum map, GLuint * values); +void GLAPIENTRY gl_dispatch_stub_273(GLenum map, GLushort * values); +void GLAPIENTRY gl_dispatch_stub_274(GLubyte * mask); +void GLAPIENTRY gl_dispatch_stub_276(GLenum target, GLenum pname, GLfloat * params); +void GLAPIENTRY gl_dispatch_stub_277(GLenum target, GLenum pname, GLint * params); +void GLAPIENTRY gl_dispatch_stub_278(GLenum coord, GLenum pname, GLdouble * params); +void GLAPIENTRY gl_dispatch_stub_279(GLenum coord, GLenum pname, GLfloat * params); +void GLAPIENTRY gl_dispatch_stub_280(GLenum coord, GLenum pname, GLint * params); +void GLAPIENTRY gl_dispatch_stub_281(GLenum target, GLint level, GLenum format, GLenum type, GLvoid * pixels); +void GLAPIENTRY gl_dispatch_stub_284(GLenum target, GLint level, GLenum pname, GLfloat * params); +void GLAPIENTRY gl_dispatch_stub_285(GLenum target, GLint level, GLenum pname, GLint * params); +GLboolean GLAPIENTRY gl_dispatch_stub_287(GLuint list); +void GLAPIENTRY gl_dispatch_stub_288(GLclampd zNear, GLclampd zFar); +void GLAPIENTRY gl_dispatch_stub_289(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar); +void GLAPIENTRY gl_dispatch_stub_290(void); +void GLAPIENTRY gl_dispatch_stub_291(const GLfloat * m); +void GLAPIENTRY gl_dispatch_stub_292(const GLdouble * m); +void GLAPIENTRY gl_dispatch_stub_293(GLenum mode); +void GLAPIENTRY gl_dispatch_stub_294(const GLfloat * m); +void GLAPIENTRY gl_dispatch_stub_295(const GLdouble * m); +void GLAPIENTRY gl_dispatch_stub_296(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar); +void GLAPIENTRY gl_dispatch_stub_297(void); +void GLAPIENTRY gl_dispatch_stub_298(void); +void GLAPIENTRY gl_dispatch_stub_299(GLdouble angle, GLdouble x, GLdouble y, GLdouble z); +void GLAPIENTRY gl_dispatch_stub_300(GLfloat angle, GLfloat x, GLfloat y, GLfloat z); +void GLAPIENTRY gl_dispatch_stub_301(GLdouble x, GLdouble y, GLdouble z); +void GLAPIENTRY gl_dispatch_stub_302(GLfloat x, GLfloat y, GLfloat z); +void GLAPIENTRY gl_dispatch_stub_303(GLdouble x, GLdouble y, GLdouble z); +void GLAPIENTRY gl_dispatch_stub_304(GLfloat x, GLfloat y, GLfloat z); +void GLAPIENTRY gl_dispatch_stub_306(GLint i); +void GLAPIENTRY gl_dispatch_stub_308(GLint size, GLenum type, GLsizei stride, const GLvoid * pointer); +void GLAPIENTRY gl_dispatch_stub_309(GLenum array); +void GLAPIENTRY gl_dispatch_stub_312(GLsizei stride, const GLvoid * pointer); +void GLAPIENTRY gl_dispatch_stub_313(GLenum array); +void GLAPIENTRY gl_dispatch_stub_314(GLenum type, GLsizei stride, const GLvoid * pointer); +void GLAPIENTRY gl_dispatch_stub_315(GLubyte c); +void GLAPIENTRY gl_dispatch_stub_316(const GLubyte * c); +void GLAPIENTRY gl_dispatch_stub_317(GLenum format, GLsizei stride, const GLvoid * pointer); +void GLAPIENTRY gl_dispatch_stub_318(GLenum type, GLsizei stride, const GLvoid * pointer); +void GLAPIENTRY gl_dispatch_stub_320(GLint size, GLenum type, GLsizei stride, const GLvoid * pointer); +void GLAPIENTRY gl_dispatch_stub_321(GLint size, GLenum type, GLsizei stride, const GLvoid * pointer); +GLboolean GLAPIENTRY gl_dispatch_stub_322(GLsizei n, const GLuint * textures, GLboolean * residences); +void GLAPIENTRY gl_dispatch_stub_323(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLint border); +void GLAPIENTRY gl_dispatch_stub_325(GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width); +void GLAPIENTRY gl_dispatch_stub_329(GLenum pname, GLvoid ** params); +void GLAPIENTRY gl_dispatch_stub_331(GLsizei n, const GLuint * textures, const GLclampf * priorities); +void GLAPIENTRY gl_dispatch_stub_332(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const GLvoid * pixels); +void GLAPIENTRY gl_dispatch_stub_334(void); +void GLAPIENTRY gl_dispatch_stub_335(GLbitfield mask); +void GLAPIENTRY gl_dispatch_stub_338(GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const GLvoid * indices); +void GLAPIENTRY gl_dispatch_stub_339(GLenum target, GLenum internalformat, GLsizei width, GLenum format, GLenum type, const GLvoid * table); +void GLAPIENTRY gl_dispatch_stub_340(GLenum target, GLenum pname, const GLfloat * params); +void GLAPIENTRY gl_dispatch_stub_341(GLenum target, GLenum pname, const GLint * params); +void GLAPIENTRY gl_dispatch_stub_342(GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width); +void GLAPIENTRY gl_dispatch_stub_343(GLenum target, GLenum format, GLenum type, GLvoid * table); +void GLAPIENTRY gl_dispatch_stub_344(GLenum target, GLenum pname, GLfloat * params); +void GLAPIENTRY gl_dispatch_stub_345(GLenum target, GLenum pname, GLint * params); +void GLAPIENTRY gl_dispatch_stub_346(GLenum target, GLsizei start, GLsizei count, GLenum format, GLenum type, const GLvoid * data); +void GLAPIENTRY gl_dispatch_stub_347(GLenum target, GLsizei start, GLint x, GLint y, GLsizei width); +void GLAPIENTRY gl_dispatch_stub_348(GLenum target, GLenum internalformat, GLsizei width, GLenum format, GLenum type, const GLvoid * image); +void GLAPIENTRY gl_dispatch_stub_349(GLenum target, GLenum internalformat, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid * image); +void GLAPIENTRY gl_dispatch_stub_350(GLenum target, GLenum pname, GLfloat params); +void GLAPIENTRY gl_dispatch_stub_351(GLenum target, GLenum pname, const GLfloat * params); +void GLAPIENTRY gl_dispatch_stub_352(GLenum target, GLenum pname, GLint params); +void GLAPIENTRY gl_dispatch_stub_353(GLenum target, GLenum pname, const GLint * params); +void GLAPIENTRY gl_dispatch_stub_354(GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width); +void GLAPIENTRY gl_dispatch_stub_355(GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height); +void GLAPIENTRY gl_dispatch_stub_356(GLenum target, GLenum format, GLenum type, GLvoid * image); +void GLAPIENTRY gl_dispatch_stub_357(GLenum target, GLenum pname, GLfloat * params); +void GLAPIENTRY gl_dispatch_stub_358(GLenum target, GLenum pname, GLint * params); +void GLAPIENTRY gl_dispatch_stub_359(GLenum target, GLenum format, GLenum type, GLvoid * row, GLvoid * column, GLvoid * span); +void GLAPIENTRY gl_dispatch_stub_360(GLenum target, GLenum internalformat, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid * row, const GLvoid * column); +void GLAPIENTRY gl_dispatch_stub_361(GLenum target, GLboolean reset, GLenum format, GLenum type, GLvoid * values); +void GLAPIENTRY gl_dispatch_stub_362(GLenum target, GLenum pname, GLfloat * params); +void GLAPIENTRY gl_dispatch_stub_363(GLenum target, GLenum pname, GLint * params); +void GLAPIENTRY gl_dispatch_stub_364(GLenum target, GLboolean reset, GLenum format, GLenum type, GLvoid * values); +void GLAPIENTRY gl_dispatch_stub_365(GLenum target, GLenum pname, GLfloat * params); +void GLAPIENTRY gl_dispatch_stub_366(GLenum target, GLenum pname, GLint * params); +void GLAPIENTRY gl_dispatch_stub_367(GLenum target, GLsizei width, GLenum internalformat, GLboolean sink); +void GLAPIENTRY gl_dispatch_stub_368(GLenum target, GLenum internalformat, GLboolean sink); +void GLAPIENTRY gl_dispatch_stub_369(GLenum target); +void GLAPIENTRY gl_dispatch_stub_370(GLenum target); +void GLAPIENTRY gl_dispatch_stub_375(GLenum texture); +void GLAPIENTRY gl_dispatch_stub_376(GLenum target, GLdouble s); +void GLAPIENTRY gl_dispatch_stub_377(GLenum target, const GLdouble * v); +void GLAPIENTRY gl_dispatch_stub_378(GLenum target, GLfloat s); +void GLAPIENTRY gl_dispatch_stub_379(GLenum target, const GLfloat * v); +void GLAPIENTRY gl_dispatch_stub_380(GLenum target, GLint s); +void GLAPIENTRY gl_dispatch_stub_381(GLenum target, const GLint * v); +void GLAPIENTRY gl_dispatch_stub_382(GLenum target, GLshort s); +void GLAPIENTRY gl_dispatch_stub_383(GLenum target, const GLshort * v); +void GLAPIENTRY gl_dispatch_stub_384(GLenum target, GLdouble s, GLdouble t); +void GLAPIENTRY gl_dispatch_stub_385(GLenum target, const GLdouble * v); +void GLAPIENTRY gl_dispatch_stub_386(GLenum target, GLfloat s, GLfloat t); +void GLAPIENTRY gl_dispatch_stub_387(GLenum target, const GLfloat * v); +void GLAPIENTRY gl_dispatch_stub_388(GLenum target, GLint s, GLint t); +void GLAPIENTRY gl_dispatch_stub_389(GLenum target, const GLint * v); +void GLAPIENTRY gl_dispatch_stub_390(GLenum target, GLshort s, GLshort t); +void GLAPIENTRY gl_dispatch_stub_391(GLenum target, const GLshort * v); +void GLAPIENTRY gl_dispatch_stub_392(GLenum target, GLdouble s, GLdouble t, GLdouble r); +void GLAPIENTRY gl_dispatch_stub_393(GLenum target, const GLdouble * v); +void GLAPIENTRY gl_dispatch_stub_394(GLenum target, GLfloat s, GLfloat t, GLfloat r); +void GLAPIENTRY gl_dispatch_stub_395(GLenum target, const GLfloat * v); +void GLAPIENTRY gl_dispatch_stub_396(GLenum target, GLint s, GLint t, GLint r); +void GLAPIENTRY gl_dispatch_stub_397(GLenum target, const GLint * v); +void GLAPIENTRY gl_dispatch_stub_398(GLenum target, GLshort s, GLshort t, GLshort r); +void GLAPIENTRY gl_dispatch_stub_399(GLenum target, const GLshort * v); +void GLAPIENTRY gl_dispatch_stub_400(GLenum target, GLdouble s, GLdouble t, GLdouble r, GLdouble q); +void GLAPIENTRY gl_dispatch_stub_401(GLenum target, const GLdouble * v); +void GLAPIENTRY gl_dispatch_stub_402(GLenum target, GLfloat s, GLfloat t, GLfloat r, GLfloat q); +void GLAPIENTRY gl_dispatch_stub_403(GLenum target, const GLfloat * v); +void GLAPIENTRY gl_dispatch_stub_404(GLenum target, GLint s, GLint t, GLint r, GLint q); +void GLAPIENTRY gl_dispatch_stub_405(GLenum target, const GLint * v); +void GLAPIENTRY gl_dispatch_stub_406(GLenum target, GLshort s, GLshort t, GLshort r, GLshort q); +void GLAPIENTRY gl_dispatch_stub_407(GLenum target, const GLshort * v); +void GLAPIENTRY gl_dispatch_stub_418(GLuint array); +void GLAPIENTRY gl_dispatch_stub_419(GLsizei n, const GLuint * arrays); +void GLAPIENTRY gl_dispatch_stub_420(GLsizei n, GLuint * arrays); +GLboolean GLAPIENTRY gl_dispatch_stub_421(GLuint array); + +/* OpenGL ES specific prototypes */ + +/* category GL_OES_EGL_image */ +GLAPI void GLAPIENTRY glEGLImageTargetRenderbufferStorageOES(GLenum target, GLvoid * writeOffset); +GLAPI void GLAPIENTRY glEGLImageTargetTexture2DOES(GLenum target, GLvoid * writeOffset); +/* category GL_OES_get_program_binary */ +GLAPI void GLAPIENTRY glGetProgramBinaryOES(GLuint program, GLsizei bufSize, GLsizei * length, GLenum * binaryFormat, GLvoid * binary); +GLAPI void GLAPIENTRY glProgramBinaryOES(GLuint program, GLenum binaryFormat, const GLvoid * binary, GLint length); +/* category GL_OES_mapbuffer */ +GLAPI void GLAPIENTRY glGetBufferPointervOES(GLenum target, GLenum pname, GLvoid ** params); +GLAPI GLvoid * GLAPIENTRY glMapBufferOES(GLenum target, GLenum access); +GLAPI GLboolean GLAPIENTRY glUnmapBufferOES(GLenum target); +/* category GL_OES_texture_3D */ +GLAPI void GLAPIENTRY glTexImage3DOES(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const GLvoid * pixels); +GLAPI void GLAPIENTRY glTexSubImage3DOES(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const GLvoid * pixels); +GLAPI void GLAPIENTRY glCopyTexSubImage3DOES(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height); +GLAPI void GLAPIENTRY glCompressedTexImage3DOES(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const GLvoid * data); +GLAPI void GLAPIENTRY glCompressedTexSubImage3DOES(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const GLvoid * data); +GLAPI void GLAPIENTRY glFramebufferTexture3DOES(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level, GLint zoffset); +/* category es2.0 */ +GLAPI void GLAPIENTRY glBindFramebuffer(GLenum target, GLuint framebuffer); +GLAPI void GLAPIENTRY glBindRenderbuffer(GLenum target, GLuint renderbuffer); +GLAPI GLenum GLAPIENTRY glCheckFramebufferStatus(GLenum target); +GLAPI void GLAPIENTRY glClearDepthf(GLclampf depth); +GLAPI void GLAPIENTRY glDeleteFramebuffers(GLsizei n, const GLuint * framebuffers); +GLAPI void GLAPIENTRY glDeleteRenderbuffers(GLsizei n, const GLuint * renderbuffers); +GLAPI void GLAPIENTRY glDepthRangef(GLclampf zNear, GLclampf zFar); +GLAPI void GLAPIENTRY glFramebufferRenderbuffer(GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer); +GLAPI void GLAPIENTRY glFramebufferTexture2D(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level); +GLAPI void GLAPIENTRY glGenFramebuffers(GLsizei n, GLuint * framebuffers); +GLAPI void GLAPIENTRY glGenRenderbuffers(GLsizei n, GLuint * renderbuffers); +GLAPI void GLAPIENTRY glGenerateMipmap(GLenum target); +GLAPI void GLAPIENTRY glGetFramebufferAttachmentParameteriv(GLenum target, GLenum attachment, GLenum pname, GLint * params); +GLAPI void GLAPIENTRY glGetRenderbufferParameteriv(GLenum target, GLenum pname, GLint * params); +GLAPI void GLAPIENTRY glGetShaderPrecisionFormat(GLenum shadertype, GLenum precisiontype, GLint * range, GLint * precision); +GLAPI GLboolean GLAPIENTRY glIsFramebuffer(GLuint framebuffer); +GLAPI GLboolean GLAPIENTRY glIsRenderbuffer(GLuint renderbuffer); +GLAPI void GLAPIENTRY glReleaseShaderCompiler(void); +GLAPI void GLAPIENTRY glRenderbufferStorage(GLenum target, GLenum internalformat, GLsizei width, GLsizei height); +GLAPI void GLAPIENTRY glShaderBinary(GLsizei n, const GLuint * shaders, GLenum binaryformat, const GLvoid * binary, GLsizei length); + +#endif /* defined(NEED_FUNCTION_POINTER) || defined(GLX_INDIRECT_RENDERING) */ + +static const glprocs_table_t static_functions[] = { + NAME_FUNC_OFFSET( 0, gl_dispatch_stub_0, gl_dispatch_stub_0, NULL, 0), + NAME_FUNC_OFFSET( 10, gl_dispatch_stub_1, gl_dispatch_stub_1, NULL, 1), + NAME_FUNC_OFFSET( 20, gl_dispatch_stub_2, gl_dispatch_stub_2, NULL, 2), + NAME_FUNC_OFFSET( 31, gl_dispatch_stub_3, gl_dispatch_stub_3, NULL, 3), + NAME_FUNC_OFFSET( 43, gl_dispatch_stub_4, gl_dispatch_stub_4, NULL, 4), + NAME_FUNC_OFFSET( 57, gl_dispatch_stub_5, gl_dispatch_stub_5, NULL, 5), + NAME_FUNC_OFFSET( 68, gl_dispatch_stub_6, gl_dispatch_stub_6, NULL, 6), + NAME_FUNC_OFFSET( 79, gl_dispatch_stub_7, gl_dispatch_stub_7, NULL, 7), + NAME_FUNC_OFFSET( 87, gl_dispatch_stub_8, gl_dispatch_stub_8, NULL, 8), + NAME_FUNC_OFFSET( 96, gl_dispatch_stub_9, gl_dispatch_stub_9, NULL, 9), + NAME_FUNC_OFFSET( 106, gl_dispatch_stub_10, gl_dispatch_stub_10, NULL, 10), + NAME_FUNC_OFFSET( 117, gl_dispatch_stub_11, gl_dispatch_stub_11, NULL, 11), + NAME_FUNC_OFFSET( 127, gl_dispatch_stub_12, gl_dispatch_stub_12, NULL, 12), + NAME_FUNC_OFFSET( 138, gl_dispatch_stub_13, gl_dispatch_stub_13, NULL, 13), + NAME_FUNC_OFFSET( 148, gl_dispatch_stub_14, gl_dispatch_stub_14, NULL, 14), + NAME_FUNC_OFFSET( 159, gl_dispatch_stub_15, gl_dispatch_stub_15, NULL, 15), + NAME_FUNC_OFFSET( 169, gl_dispatch_stub_16, gl_dispatch_stub_16, NULL, 16), + NAME_FUNC_OFFSET( 180, gl_dispatch_stub_17, gl_dispatch_stub_17, NULL, 17), + NAME_FUNC_OFFSET( 190, gl_dispatch_stub_18, gl_dispatch_stub_18, NULL, 18), + NAME_FUNC_OFFSET( 201, gl_dispatch_stub_19, gl_dispatch_stub_19, NULL, 19), + NAME_FUNC_OFFSET( 212, gl_dispatch_stub_20, gl_dispatch_stub_20, NULL, 20), + NAME_FUNC_OFFSET( 224, gl_dispatch_stub_21, gl_dispatch_stub_21, NULL, 21), + NAME_FUNC_OFFSET( 235, gl_dispatch_stub_22, gl_dispatch_stub_22, NULL, 22), + NAME_FUNC_OFFSET( 247, gl_dispatch_stub_23, gl_dispatch_stub_23, NULL, 23), + NAME_FUNC_OFFSET( 258, gl_dispatch_stub_24, gl_dispatch_stub_24, NULL, 24), + NAME_FUNC_OFFSET( 270, gl_dispatch_stub_25, gl_dispatch_stub_25, NULL, 25), + NAME_FUNC_OFFSET( 280, gl_dispatch_stub_26, gl_dispatch_stub_26, NULL, 26), + NAME_FUNC_OFFSET( 291, gl_dispatch_stub_27, gl_dispatch_stub_27, NULL, 27), + NAME_FUNC_OFFSET( 301, gl_dispatch_stub_28, gl_dispatch_stub_28, NULL, 28), + NAME_FUNC_OFFSET( 312, gl_dispatch_stub_29, gl_dispatch_stub_29, NULL, 29), + NAME_FUNC_OFFSET( 322, gl_dispatch_stub_30, gl_dispatch_stub_30, NULL, 30), + NAME_FUNC_OFFSET( 333, gl_dispatch_stub_31, gl_dispatch_stub_31, NULL, 31), + NAME_FUNC_OFFSET( 343, gl_dispatch_stub_32, gl_dispatch_stub_32, NULL, 32), + NAME_FUNC_OFFSET( 354, gl_dispatch_stub_33, gl_dispatch_stub_33, NULL, 33), + NAME_FUNC_OFFSET( 364, gl_dispatch_stub_34, gl_dispatch_stub_34, NULL, 34), + NAME_FUNC_OFFSET( 375, gl_dispatch_stub_35, gl_dispatch_stub_35, NULL, 35), + NAME_FUNC_OFFSET( 386, gl_dispatch_stub_36, gl_dispatch_stub_36, NULL, 36), + NAME_FUNC_OFFSET( 398, gl_dispatch_stub_37, gl_dispatch_stub_37, NULL, 37), + NAME_FUNC_OFFSET( 409, gl_dispatch_stub_38, gl_dispatch_stub_38, NULL, 38), + NAME_FUNC_OFFSET( 421, gl_dispatch_stub_39, gl_dispatch_stub_39, NULL, 39), + NAME_FUNC_OFFSET( 432, gl_dispatch_stub_40, gl_dispatch_stub_40, NULL, 40), + NAME_FUNC_OFFSET( 444, gl_dispatch_stub_41, gl_dispatch_stub_41, NULL, 41), + NAME_FUNC_OFFSET( 455, gl_dispatch_stub_42, gl_dispatch_stub_42, NULL, 42), + NAME_FUNC_OFFSET( 467, gl_dispatch_stub_43, gl_dispatch_stub_43, NULL, 43), + NAME_FUNC_OFFSET( 473, gl_dispatch_stub_44, gl_dispatch_stub_44, NULL, 44), + NAME_FUNC_OFFSET( 482, gl_dispatch_stub_45, gl_dispatch_stub_45, NULL, 45), + NAME_FUNC_OFFSET( 492, gl_dispatch_stub_46, gl_dispatch_stub_46, NULL, 46), + NAME_FUNC_OFFSET( 501, gl_dispatch_stub_47, gl_dispatch_stub_47, NULL, 47), + NAME_FUNC_OFFSET( 511, gl_dispatch_stub_48, gl_dispatch_stub_48, NULL, 48), + NAME_FUNC_OFFSET( 520, gl_dispatch_stub_49, gl_dispatch_stub_49, NULL, 49), + NAME_FUNC_OFFSET( 530, gl_dispatch_stub_50, gl_dispatch_stub_50, NULL, 50), + NAME_FUNC_OFFSET( 539, gl_dispatch_stub_51, gl_dispatch_stub_51, NULL, 51), + NAME_FUNC_OFFSET( 549, gl_dispatch_stub_52, gl_dispatch_stub_52, NULL, 52), + NAME_FUNC_OFFSET( 560, gl_dispatch_stub_53, gl_dispatch_stub_53, NULL, 53), + NAME_FUNC_OFFSET( 572, gl_dispatch_stub_54, gl_dispatch_stub_54, NULL, 54), + NAME_FUNC_OFFSET( 583, gl_dispatch_stub_55, gl_dispatch_stub_55, NULL, 55), + NAME_FUNC_OFFSET( 595, gl_dispatch_stub_56, gl_dispatch_stub_56, NULL, 56), + NAME_FUNC_OFFSET( 606, gl_dispatch_stub_57, gl_dispatch_stub_57, NULL, 57), + NAME_FUNC_OFFSET( 618, gl_dispatch_stub_58, gl_dispatch_stub_58, NULL, 58), + NAME_FUNC_OFFSET( 629, gl_dispatch_stub_59, gl_dispatch_stub_59, NULL, 59), + NAME_FUNC_OFFSET( 641, gl_dispatch_stub_60, gl_dispatch_stub_60, NULL, 60), + NAME_FUNC_OFFSET( 652, gl_dispatch_stub_61, gl_dispatch_stub_61, NULL, 61), + NAME_FUNC_OFFSET( 664, gl_dispatch_stub_62, gl_dispatch_stub_62, NULL, 62), + NAME_FUNC_OFFSET( 678, gl_dispatch_stub_63, gl_dispatch_stub_63, NULL, 63), + NAME_FUNC_OFFSET( 693, gl_dispatch_stub_64, gl_dispatch_stub_64, NULL, 64), + NAME_FUNC_OFFSET( 707, gl_dispatch_stub_65, gl_dispatch_stub_65, NULL, 65), + NAME_FUNC_OFFSET( 722, gl_dispatch_stub_66, gl_dispatch_stub_66, NULL, 66), + NAME_FUNC_OFFSET( 736, gl_dispatch_stub_67, gl_dispatch_stub_67, NULL, 67), + NAME_FUNC_OFFSET( 751, gl_dispatch_stub_68, gl_dispatch_stub_68, NULL, 68), + NAME_FUNC_OFFSET( 765, gl_dispatch_stub_69, gl_dispatch_stub_69, NULL, 69), + NAME_FUNC_OFFSET( 780, gl_dispatch_stub_70, gl_dispatch_stub_70, NULL, 70), + NAME_FUNC_OFFSET( 794, gl_dispatch_stub_71, gl_dispatch_stub_71, NULL, 71), + NAME_FUNC_OFFSET( 809, gl_dispatch_stub_72, gl_dispatch_stub_72, NULL, 72), + NAME_FUNC_OFFSET( 823, gl_dispatch_stub_73, gl_dispatch_stub_73, NULL, 73), + NAME_FUNC_OFFSET( 838, gl_dispatch_stub_74, gl_dispatch_stub_74, NULL, 74), + NAME_FUNC_OFFSET( 852, gl_dispatch_stub_75, gl_dispatch_stub_75, NULL, 75), + NAME_FUNC_OFFSET( 867, gl_dispatch_stub_76, gl_dispatch_stub_76, NULL, 76), + NAME_FUNC_OFFSET( 881, gl_dispatch_stub_77, gl_dispatch_stub_77, NULL, 77), + NAME_FUNC_OFFSET( 896, gl_dispatch_stub_78, gl_dispatch_stub_78, NULL, 78), + NAME_FUNC_OFFSET( 910, gl_dispatch_stub_79, gl_dispatch_stub_79, NULL, 79), + NAME_FUNC_OFFSET( 925, gl_dispatch_stub_80, gl_dispatch_stub_80, NULL, 80), + NAME_FUNC_OFFSET( 939, gl_dispatch_stub_81, gl_dispatch_stub_81, NULL, 81), + NAME_FUNC_OFFSET( 954, gl_dispatch_stub_82, gl_dispatch_stub_82, NULL, 82), + NAME_FUNC_OFFSET( 968, gl_dispatch_stub_83, gl_dispatch_stub_83, NULL, 83), + NAME_FUNC_OFFSET( 983, gl_dispatch_stub_84, gl_dispatch_stub_84, NULL, 84), + NAME_FUNC_OFFSET( 997, gl_dispatch_stub_85, gl_dispatch_stub_85, NULL, 85), + NAME_FUNC_OFFSET( 1012, gl_dispatch_stub_86, gl_dispatch_stub_86, NULL, 86), + NAME_FUNC_OFFSET( 1020, gl_dispatch_stub_87, gl_dispatch_stub_87, NULL, 87), + NAME_FUNC_OFFSET( 1029, gl_dispatch_stub_88, gl_dispatch_stub_88, NULL, 88), + NAME_FUNC_OFFSET( 1037, gl_dispatch_stub_89, gl_dispatch_stub_89, NULL, 89), + NAME_FUNC_OFFSET( 1046, gl_dispatch_stub_90, gl_dispatch_stub_90, NULL, 90), + NAME_FUNC_OFFSET( 1054, gl_dispatch_stub_91, gl_dispatch_stub_91, NULL, 91), + NAME_FUNC_OFFSET( 1063, gl_dispatch_stub_92, gl_dispatch_stub_92, NULL, 92), + NAME_FUNC_OFFSET( 1071, gl_dispatch_stub_93, gl_dispatch_stub_93, NULL, 93), + NAME_FUNC_OFFSET( 1080, gl_dispatch_stub_94, gl_dispatch_stub_94, NULL, 94), + NAME_FUNC_OFFSET( 1093, gl_dispatch_stub_95, gl_dispatch_stub_95, NULL, 95), + NAME_FUNC_OFFSET( 1107, gl_dispatch_stub_96, gl_dispatch_stub_96, NULL, 96), + NAME_FUNC_OFFSET( 1120, gl_dispatch_stub_97, gl_dispatch_stub_97, NULL, 97), + NAME_FUNC_OFFSET( 1134, gl_dispatch_stub_98, gl_dispatch_stub_98, NULL, 98), + NAME_FUNC_OFFSET( 1147, gl_dispatch_stub_99, gl_dispatch_stub_99, NULL, 99), + NAME_FUNC_OFFSET( 1161, gl_dispatch_stub_100, gl_dispatch_stub_100, NULL, 100), + NAME_FUNC_OFFSET( 1174, gl_dispatch_stub_101, gl_dispatch_stub_101, NULL, 101), + NAME_FUNC_OFFSET( 1188, gl_dispatch_stub_102, gl_dispatch_stub_102, NULL, 102), + NAME_FUNC_OFFSET( 1201, gl_dispatch_stub_103, gl_dispatch_stub_103, NULL, 103), + NAME_FUNC_OFFSET( 1215, gl_dispatch_stub_104, gl_dispatch_stub_104, NULL, 104), + NAME_FUNC_OFFSET( 1228, gl_dispatch_stub_105, gl_dispatch_stub_105, NULL, 105), + NAME_FUNC_OFFSET( 1242, gl_dispatch_stub_106, gl_dispatch_stub_106, NULL, 106), + NAME_FUNC_OFFSET( 1255, gl_dispatch_stub_107, gl_dispatch_stub_107, NULL, 107), + NAME_FUNC_OFFSET( 1269, gl_dispatch_stub_108, gl_dispatch_stub_108, NULL, 108), + NAME_FUNC_OFFSET( 1282, gl_dispatch_stub_109, gl_dispatch_stub_109, NULL, 109), + NAME_FUNC_OFFSET( 1296, gl_dispatch_stub_110, gl_dispatch_stub_110, NULL, 110), + NAME_FUNC_OFFSET( 1309, gl_dispatch_stub_111, gl_dispatch_stub_111, NULL, 111), + NAME_FUNC_OFFSET( 1323, gl_dispatch_stub_112, gl_dispatch_stub_112, NULL, 112), + NAME_FUNC_OFFSET( 1336, gl_dispatch_stub_113, gl_dispatch_stub_113, NULL, 113), + NAME_FUNC_OFFSET( 1350, gl_dispatch_stub_114, gl_dispatch_stub_114, NULL, 114), + NAME_FUNC_OFFSET( 1363, gl_dispatch_stub_115, gl_dispatch_stub_115, NULL, 115), + NAME_FUNC_OFFSET( 1377, gl_dispatch_stub_116, gl_dispatch_stub_116, NULL, 116), + NAME_FUNC_OFFSET( 1390, gl_dispatch_stub_117, gl_dispatch_stub_117, NULL, 117), + NAME_FUNC_OFFSET( 1404, gl_dispatch_stub_118, gl_dispatch_stub_118, NULL, 118), + NAME_FUNC_OFFSET( 1417, gl_dispatch_stub_119, gl_dispatch_stub_119, NULL, 119), + NAME_FUNC_OFFSET( 1431, gl_dispatch_stub_120, gl_dispatch_stub_120, NULL, 120), + NAME_FUNC_OFFSET( 1444, gl_dispatch_stub_121, gl_dispatch_stub_121, NULL, 121), + NAME_FUNC_OFFSET( 1458, gl_dispatch_stub_122, gl_dispatch_stub_122, NULL, 122), + NAME_FUNC_OFFSET( 1471, gl_dispatch_stub_123, gl_dispatch_stub_123, NULL, 123), + NAME_FUNC_OFFSET( 1485, gl_dispatch_stub_124, gl_dispatch_stub_124, NULL, 124), + NAME_FUNC_OFFSET( 1498, gl_dispatch_stub_125, gl_dispatch_stub_125, NULL, 125), + NAME_FUNC_OFFSET( 1512, gl_dispatch_stub_126, gl_dispatch_stub_126, NULL, 126), + NAME_FUNC_OFFSET( 1523, gl_dispatch_stub_127, gl_dispatch_stub_127, NULL, 127), + NAME_FUNC_OFFSET( 1535, gl_dispatch_stub_128, gl_dispatch_stub_128, NULL, 128), + NAME_FUNC_OFFSET( 1546, gl_dispatch_stub_129, gl_dispatch_stub_129, NULL, 129), + NAME_FUNC_OFFSET( 1558, gl_dispatch_stub_130, gl_dispatch_stub_130, NULL, 130), + NAME_FUNC_OFFSET( 1569, gl_dispatch_stub_131, gl_dispatch_stub_131, NULL, 131), + NAME_FUNC_OFFSET( 1581, gl_dispatch_stub_132, gl_dispatch_stub_132, NULL, 132), + NAME_FUNC_OFFSET( 1592, gl_dispatch_stub_133, gl_dispatch_stub_133, NULL, 133), + NAME_FUNC_OFFSET( 1604, gl_dispatch_stub_134, gl_dispatch_stub_134, NULL, 134), + NAME_FUNC_OFFSET( 1615, gl_dispatch_stub_135, gl_dispatch_stub_135, NULL, 135), + NAME_FUNC_OFFSET( 1627, gl_dispatch_stub_136, gl_dispatch_stub_136, NULL, 136), + NAME_FUNC_OFFSET( 1638, gl_dispatch_stub_137, gl_dispatch_stub_137, NULL, 137), + NAME_FUNC_OFFSET( 1650, gl_dispatch_stub_138, gl_dispatch_stub_138, NULL, 138), + NAME_FUNC_OFFSET( 1661, gl_dispatch_stub_139, gl_dispatch_stub_139, NULL, 139), + NAME_FUNC_OFFSET( 1673, gl_dispatch_stub_140, gl_dispatch_stub_140, NULL, 140), + NAME_FUNC_OFFSET( 1684, gl_dispatch_stub_141, gl_dispatch_stub_141, NULL, 141), + NAME_FUNC_OFFSET( 1696, gl_dispatch_stub_142, gl_dispatch_stub_142, NULL, 142), + NAME_FUNC_OFFSET( 1707, gl_dispatch_stub_143, gl_dispatch_stub_143, NULL, 143), + NAME_FUNC_OFFSET( 1719, gl_dispatch_stub_144, gl_dispatch_stub_144, NULL, 144), + NAME_FUNC_OFFSET( 1730, gl_dispatch_stub_145, gl_dispatch_stub_145, NULL, 145), + NAME_FUNC_OFFSET( 1742, gl_dispatch_stub_146, gl_dispatch_stub_146, NULL, 146), + NAME_FUNC_OFFSET( 1753, gl_dispatch_stub_147, gl_dispatch_stub_147, NULL, 147), + NAME_FUNC_OFFSET( 1765, gl_dispatch_stub_148, gl_dispatch_stub_148, NULL, 148), + NAME_FUNC_OFFSET( 1776, gl_dispatch_stub_149, gl_dispatch_stub_149, NULL, 149), + NAME_FUNC_OFFSET( 1788, gl_dispatch_stub_150, gl_dispatch_stub_150, NULL, 150), + NAME_FUNC_OFFSET( 1800, gl_dispatch_stub_151, gl_dispatch_stub_151, NULL, 151), + NAME_FUNC_OFFSET( 1816, glCullFace, glCullFace, NULL, 152), + NAME_FUNC_OFFSET( 1827, gl_dispatch_stub_153, gl_dispatch_stub_153, NULL, 153), + NAME_FUNC_OFFSET( 1834, gl_dispatch_stub_154, gl_dispatch_stub_154, NULL, 154), + NAME_FUNC_OFFSET( 1842, gl_dispatch_stub_155, gl_dispatch_stub_155, NULL, 155), + NAME_FUNC_OFFSET( 1849, gl_dispatch_stub_156, gl_dispatch_stub_156, NULL, 156), + NAME_FUNC_OFFSET( 1857, glFrontFace, glFrontFace, NULL, 157), + NAME_FUNC_OFFSET( 1869, glHint, glHint, NULL, 158), + NAME_FUNC_OFFSET( 1876, gl_dispatch_stub_159, gl_dispatch_stub_159, NULL, 159), + NAME_FUNC_OFFSET( 1885, gl_dispatch_stub_160, gl_dispatch_stub_160, NULL, 160), + NAME_FUNC_OFFSET( 1895, gl_dispatch_stub_161, gl_dispatch_stub_161, NULL, 161), + NAME_FUNC_OFFSET( 1904, gl_dispatch_stub_162, gl_dispatch_stub_162, NULL, 162), + NAME_FUNC_OFFSET( 1914, gl_dispatch_stub_163, gl_dispatch_stub_163, NULL, 163), + NAME_FUNC_OFFSET( 1928, gl_dispatch_stub_164, gl_dispatch_stub_164, NULL, 164), + NAME_FUNC_OFFSET( 1943, gl_dispatch_stub_165, gl_dispatch_stub_165, NULL, 165), + NAME_FUNC_OFFSET( 1957, gl_dispatch_stub_166, gl_dispatch_stub_166, NULL, 166), + NAME_FUNC_OFFSET( 1972, gl_dispatch_stub_167, gl_dispatch_stub_167, NULL, 167), + NAME_FUNC_OFFSET( 1986, glLineWidth, glLineWidth, NULL, 168), + NAME_FUNC_OFFSET( 1998, gl_dispatch_stub_169, gl_dispatch_stub_169, NULL, 169), + NAME_FUNC_OFFSET( 2010, gl_dispatch_stub_170, gl_dispatch_stub_170, NULL, 170), + NAME_FUNC_OFFSET( 2023, gl_dispatch_stub_171, gl_dispatch_stub_171, NULL, 171), + NAME_FUNC_OFFSET( 2035, gl_dispatch_stub_172, gl_dispatch_stub_172, NULL, 172), + NAME_FUNC_OFFSET( 2048, gl_dispatch_stub_173, gl_dispatch_stub_173, NULL, 173), + NAME_FUNC_OFFSET( 2060, gl_dispatch_stub_174, gl_dispatch_stub_174, NULL, 174), + NAME_FUNC_OFFSET( 2074, gl_dispatch_stub_175, gl_dispatch_stub_175, NULL, 175), + NAME_FUNC_OFFSET( 2091, glScissor, glScissor, NULL, 176), + NAME_FUNC_OFFSET( 2101, gl_dispatch_stub_177, gl_dispatch_stub_177, NULL, 177), + NAME_FUNC_OFFSET( 2114, glTexParameterf, glTexParameterf, NULL, 178), + NAME_FUNC_OFFSET( 2130, glTexParameterfv, glTexParameterfv, NULL, 179), + NAME_FUNC_OFFSET( 2147, glTexParameteri, glTexParameteri, NULL, 180), + NAME_FUNC_OFFSET( 2163, glTexParameteriv, glTexParameteriv, NULL, 181), + NAME_FUNC_OFFSET( 2180, gl_dispatch_stub_182, gl_dispatch_stub_182, NULL, 182), + NAME_FUNC_OFFSET( 2193, glTexImage2D, glTexImage2D, NULL, 183), + NAME_FUNC_OFFSET( 2206, gl_dispatch_stub_184, gl_dispatch_stub_184, NULL, 184), + NAME_FUNC_OFFSET( 2216, gl_dispatch_stub_185, gl_dispatch_stub_185, NULL, 185), + NAME_FUNC_OFFSET( 2227, gl_dispatch_stub_186, gl_dispatch_stub_186, NULL, 186), + NAME_FUNC_OFFSET( 2237, gl_dispatch_stub_187, gl_dispatch_stub_187, NULL, 187), + NAME_FUNC_OFFSET( 2248, gl_dispatch_stub_188, gl_dispatch_stub_188, NULL, 188), + NAME_FUNC_OFFSET( 2258, gl_dispatch_stub_189, gl_dispatch_stub_189, NULL, 189), + NAME_FUNC_OFFSET( 2269, gl_dispatch_stub_190, gl_dispatch_stub_190, NULL, 190), + NAME_FUNC_OFFSET( 2279, gl_dispatch_stub_191, gl_dispatch_stub_191, NULL, 191), + NAME_FUNC_OFFSET( 2290, gl_dispatch_stub_192, gl_dispatch_stub_192, NULL, 192), + NAME_FUNC_OFFSET( 2300, gl_dispatch_stub_193, gl_dispatch_stub_193, NULL, 193), + NAME_FUNC_OFFSET( 2311, gl_dispatch_stub_194, gl_dispatch_stub_194, NULL, 194), + NAME_FUNC_OFFSET( 2328, gl_dispatch_stub_195, gl_dispatch_stub_195, NULL, 195), + NAME_FUNC_OFFSET( 2343, gl_dispatch_stub_196, gl_dispatch_stub_196, NULL, 196), + NAME_FUNC_OFFSET( 2356, gl_dispatch_stub_197, gl_dispatch_stub_197, NULL, 197), + NAME_FUNC_OFFSET( 2368, gl_dispatch_stub_198, gl_dispatch_stub_198, NULL, 198), + NAME_FUNC_OFFSET( 2379, gl_dispatch_stub_199, gl_dispatch_stub_199, NULL, 199), + NAME_FUNC_OFFSET( 2393, gl_dispatch_stub_200, gl_dispatch_stub_200, NULL, 200), + NAME_FUNC_OFFSET( 2403, gl_dispatch_stub_201, gl_dispatch_stub_201, NULL, 201), + NAME_FUNC_OFFSET( 2414, gl_dispatch_stub_202, gl_dispatch_stub_202, NULL, 202), + NAME_FUNC_OFFSET( 2427, glClear, glClear, NULL, 203), + NAME_FUNC_OFFSET( 2435, gl_dispatch_stub_204, gl_dispatch_stub_204, NULL, 204), + NAME_FUNC_OFFSET( 2448, gl_dispatch_stub_205, gl_dispatch_stub_205, NULL, 205), + NAME_FUNC_OFFSET( 2461, glClearColor, glClearColor, NULL, 206), + NAME_FUNC_OFFSET( 2474, glClearStencil, glClearStencil, NULL, 207), + NAME_FUNC_OFFSET( 2489, gl_dispatch_stub_208, gl_dispatch_stub_208, NULL, 208), + NAME_FUNC_OFFSET( 2502, glStencilMask, glStencilMask, NULL, 209), + NAME_FUNC_OFFSET( 2516, glColorMask, glColorMask, NULL, 210), + NAME_FUNC_OFFSET( 2528, glDepthMask, glDepthMask, NULL, 211), + NAME_FUNC_OFFSET( 2540, gl_dispatch_stub_212, gl_dispatch_stub_212, NULL, 212), + NAME_FUNC_OFFSET( 2552, gl_dispatch_stub_213, gl_dispatch_stub_213, NULL, 213), + NAME_FUNC_OFFSET( 2560, glDisable, glDisable, NULL, 214), + NAME_FUNC_OFFSET( 2570, glEnable, glEnable, NULL, 215), + NAME_FUNC_OFFSET( 2579, glFinish, glFinish, NULL, 216), + NAME_FUNC_OFFSET( 2588, glFlush, glFlush, NULL, 217), + NAME_FUNC_OFFSET( 2596, gl_dispatch_stub_218, gl_dispatch_stub_218, NULL, 218), + NAME_FUNC_OFFSET( 2608, gl_dispatch_stub_219, gl_dispatch_stub_219, NULL, 219), + NAME_FUNC_OFFSET( 2621, gl_dispatch_stub_220, gl_dispatch_stub_220, NULL, 220), + NAME_FUNC_OFFSET( 2629, gl_dispatch_stub_221, gl_dispatch_stub_221, NULL, 221), + NAME_FUNC_OFFSET( 2637, gl_dispatch_stub_222, gl_dispatch_stub_222, NULL, 222), + NAME_FUNC_OFFSET( 2645, gl_dispatch_stub_223, gl_dispatch_stub_223, NULL, 223), + NAME_FUNC_OFFSET( 2653, gl_dispatch_stub_224, gl_dispatch_stub_224, NULL, 224), + NAME_FUNC_OFFSET( 2665, gl_dispatch_stub_225, gl_dispatch_stub_225, NULL, 225), + NAME_FUNC_OFFSET( 2677, gl_dispatch_stub_226, gl_dispatch_stub_226, NULL, 226), + NAME_FUNC_OFFSET( 2689, gl_dispatch_stub_227, gl_dispatch_stub_227, NULL, 227), + NAME_FUNC_OFFSET( 2701, gl_dispatch_stub_228, gl_dispatch_stub_228, NULL, 228), + NAME_FUNC_OFFSET( 2715, gl_dispatch_stub_229, gl_dispatch_stub_229, NULL, 229), + NAME_FUNC_OFFSET( 2730, gl_dispatch_stub_230, gl_dispatch_stub_230, NULL, 230), + NAME_FUNC_OFFSET( 2744, gl_dispatch_stub_231, gl_dispatch_stub_231, NULL, 231), + NAME_FUNC_OFFSET( 2759, gl_dispatch_stub_232, gl_dispatch_stub_232, NULL, 232), + NAME_FUNC_OFFSET( 2773, gl_dispatch_stub_233, gl_dispatch_stub_233, NULL, 233), + NAME_FUNC_OFFSET( 2788, gl_dispatch_stub_234, gl_dispatch_stub_234, NULL, 234), + NAME_FUNC_OFFSET( 2802, gl_dispatch_stub_235, gl_dispatch_stub_235, NULL, 235), + NAME_FUNC_OFFSET( 2817, gl_dispatch_stub_236, gl_dispatch_stub_236, NULL, 236), + NAME_FUNC_OFFSET( 2829, gl_dispatch_stub_237, gl_dispatch_stub_237, NULL, 237), + NAME_FUNC_OFFSET( 2842, gl_dispatch_stub_238, gl_dispatch_stub_238, NULL, 238), + NAME_FUNC_OFFSET( 2854, gl_dispatch_stub_239, gl_dispatch_stub_239, NULL, 239), + NAME_FUNC_OFFSET( 2867, gl_dispatch_stub_240, gl_dispatch_stub_240, NULL, 240), + NAME_FUNC_OFFSET( 2879, glBlendFunc, glBlendFunc, NULL, 241), + NAME_FUNC_OFFSET( 2891, gl_dispatch_stub_242, gl_dispatch_stub_242, NULL, 242), + NAME_FUNC_OFFSET( 2901, glStencilFunc, glStencilFunc, NULL, 243), + NAME_FUNC_OFFSET( 2915, glStencilOp, glStencilOp, NULL, 244), + NAME_FUNC_OFFSET( 2927, glDepthFunc, glDepthFunc, NULL, 245), + NAME_FUNC_OFFSET( 2939, gl_dispatch_stub_246, gl_dispatch_stub_246, NULL, 246), + NAME_FUNC_OFFSET( 2951, gl_dispatch_stub_247, gl_dispatch_stub_247, NULL, 247), + NAME_FUNC_OFFSET( 2968, gl_dispatch_stub_248, gl_dispatch_stub_248, NULL, 248), + NAME_FUNC_OFFSET( 2985, gl_dispatch_stub_249, gl_dispatch_stub_249, NULL, 249), + NAME_FUNC_OFFSET( 2999, glPixelStorei, glPixelStorei, NULL, 250), + NAME_FUNC_OFFSET( 3013, gl_dispatch_stub_251, gl_dispatch_stub_251, NULL, 251), + NAME_FUNC_OFFSET( 3026, gl_dispatch_stub_252, gl_dispatch_stub_252, NULL, 252), + NAME_FUNC_OFFSET( 3040, gl_dispatch_stub_253, gl_dispatch_stub_253, NULL, 253), + NAME_FUNC_OFFSET( 3054, gl_dispatch_stub_254, gl_dispatch_stub_254, NULL, 254), + NAME_FUNC_OFFSET( 3067, gl_dispatch_stub_255, gl_dispatch_stub_255, NULL, 255), + NAME_FUNC_OFFSET( 3080, glReadPixels, glReadPixels, NULL, 256), + NAME_FUNC_OFFSET( 3093, gl_dispatch_stub_257, gl_dispatch_stub_257, NULL, 257), + NAME_FUNC_OFFSET( 3106, glGetBooleanv, glGetBooleanv, NULL, 258), + NAME_FUNC_OFFSET( 3120, gl_dispatch_stub_259, gl_dispatch_stub_259, NULL, 259), + NAME_FUNC_OFFSET( 3135, gl_dispatch_stub_260, gl_dispatch_stub_260, NULL, 260), + NAME_FUNC_OFFSET( 3148, glGetError, glGetError, NULL, 261), + NAME_FUNC_OFFSET( 3159, glGetFloatv, glGetFloatv, NULL, 262), + NAME_FUNC_OFFSET( 3171, glGetIntegerv, glGetIntegerv, NULL, 263), + NAME_FUNC_OFFSET( 3185, gl_dispatch_stub_264, gl_dispatch_stub_264, NULL, 264), + NAME_FUNC_OFFSET( 3198, gl_dispatch_stub_265, gl_dispatch_stub_265, NULL, 265), + NAME_FUNC_OFFSET( 3211, gl_dispatch_stub_266, gl_dispatch_stub_266, NULL, 266), + NAME_FUNC_OFFSET( 3222, gl_dispatch_stub_267, gl_dispatch_stub_267, NULL, 267), + NAME_FUNC_OFFSET( 3233, gl_dispatch_stub_268, gl_dispatch_stub_268, NULL, 268), + NAME_FUNC_OFFSET( 3244, gl_dispatch_stub_269, gl_dispatch_stub_269, NULL, 269), + NAME_FUNC_OFFSET( 3260, gl_dispatch_stub_270, gl_dispatch_stub_270, NULL, 270), + NAME_FUNC_OFFSET( 3276, gl_dispatch_stub_271, gl_dispatch_stub_271, NULL, 271), + NAME_FUNC_OFFSET( 3292, gl_dispatch_stub_272, gl_dispatch_stub_272, NULL, 272), + NAME_FUNC_OFFSET( 3309, gl_dispatch_stub_273, gl_dispatch_stub_273, NULL, 273), + NAME_FUNC_OFFSET( 3326, gl_dispatch_stub_274, gl_dispatch_stub_274, NULL, 274), + NAME_FUNC_OFFSET( 3346, glGetString, glGetString, NULL, 275), + NAME_FUNC_OFFSET( 3358, gl_dispatch_stub_276, gl_dispatch_stub_276, NULL, 276), + NAME_FUNC_OFFSET( 3372, gl_dispatch_stub_277, gl_dispatch_stub_277, NULL, 277), + NAME_FUNC_OFFSET( 3386, gl_dispatch_stub_278, gl_dispatch_stub_278, NULL, 278), + NAME_FUNC_OFFSET( 3400, gl_dispatch_stub_279, gl_dispatch_stub_279, NULL, 279), + NAME_FUNC_OFFSET( 3414, gl_dispatch_stub_280, gl_dispatch_stub_280, NULL, 280), + NAME_FUNC_OFFSET( 3428, gl_dispatch_stub_281, gl_dispatch_stub_281, NULL, 281), + NAME_FUNC_OFFSET( 3442, glGetTexParameterfv, glGetTexParameterfv, NULL, 282), + NAME_FUNC_OFFSET( 3462, glGetTexParameteriv, glGetTexParameteriv, NULL, 283), + NAME_FUNC_OFFSET( 3482, gl_dispatch_stub_284, gl_dispatch_stub_284, NULL, 284), + NAME_FUNC_OFFSET( 3507, gl_dispatch_stub_285, gl_dispatch_stub_285, NULL, 285), + NAME_FUNC_OFFSET( 3532, glIsEnabled, glIsEnabled, NULL, 286), + NAME_FUNC_OFFSET( 3544, gl_dispatch_stub_287, gl_dispatch_stub_287, NULL, 287), + NAME_FUNC_OFFSET( 3553, gl_dispatch_stub_288, gl_dispatch_stub_288, NULL, 288), + NAME_FUNC_OFFSET( 3566, gl_dispatch_stub_289, gl_dispatch_stub_289, NULL, 289), + NAME_FUNC_OFFSET( 3576, gl_dispatch_stub_290, gl_dispatch_stub_290, NULL, 290), + NAME_FUNC_OFFSET( 3591, gl_dispatch_stub_291, gl_dispatch_stub_291, NULL, 291), + NAME_FUNC_OFFSET( 3605, gl_dispatch_stub_292, gl_dispatch_stub_292, NULL, 292), + NAME_FUNC_OFFSET( 3619, gl_dispatch_stub_293, gl_dispatch_stub_293, NULL, 293), + NAME_FUNC_OFFSET( 3632, gl_dispatch_stub_294, gl_dispatch_stub_294, NULL, 294), + NAME_FUNC_OFFSET( 3646, gl_dispatch_stub_295, gl_dispatch_stub_295, NULL, 295), + NAME_FUNC_OFFSET( 3660, gl_dispatch_stub_296, gl_dispatch_stub_296, NULL, 296), + NAME_FUNC_OFFSET( 3668, gl_dispatch_stub_297, gl_dispatch_stub_297, NULL, 297), + NAME_FUNC_OFFSET( 3680, gl_dispatch_stub_298, gl_dispatch_stub_298, NULL, 298), + NAME_FUNC_OFFSET( 3693, gl_dispatch_stub_299, gl_dispatch_stub_299, NULL, 299), + NAME_FUNC_OFFSET( 3703, gl_dispatch_stub_300, gl_dispatch_stub_300, NULL, 300), + NAME_FUNC_OFFSET( 3713, gl_dispatch_stub_301, gl_dispatch_stub_301, NULL, 301), + NAME_FUNC_OFFSET( 3722, gl_dispatch_stub_302, gl_dispatch_stub_302, NULL, 302), + NAME_FUNC_OFFSET( 3731, gl_dispatch_stub_303, gl_dispatch_stub_303, NULL, 303), + NAME_FUNC_OFFSET( 3744, gl_dispatch_stub_304, gl_dispatch_stub_304, NULL, 304), + NAME_FUNC_OFFSET( 3757, glViewport, glViewport, NULL, 305), + NAME_FUNC_OFFSET( 3768, gl_dispatch_stub_306, gl_dispatch_stub_306, NULL, 306), + NAME_FUNC_OFFSET( 3783, glBindTexture, glBindTexture, NULL, 307), + NAME_FUNC_OFFSET( 3797, gl_dispatch_stub_308, gl_dispatch_stub_308, NULL, 308), + NAME_FUNC_OFFSET( 3812, gl_dispatch_stub_309, gl_dispatch_stub_309, NULL, 309), + NAME_FUNC_OFFSET( 3833, glDrawArrays, glDrawArrays, NULL, 310), + NAME_FUNC_OFFSET( 3846, glDrawElements, glDrawElements, NULL, 311), + NAME_FUNC_OFFSET( 3861, gl_dispatch_stub_312, gl_dispatch_stub_312, NULL, 312), + NAME_FUNC_OFFSET( 3879, gl_dispatch_stub_313, gl_dispatch_stub_313, NULL, 313), + NAME_FUNC_OFFSET( 3899, gl_dispatch_stub_314, gl_dispatch_stub_314, NULL, 314), + NAME_FUNC_OFFSET( 3914, gl_dispatch_stub_315, gl_dispatch_stub_315, NULL, 315), + NAME_FUNC_OFFSET( 3924, gl_dispatch_stub_316, gl_dispatch_stub_316, NULL, 316), + NAME_FUNC_OFFSET( 3935, gl_dispatch_stub_317, gl_dispatch_stub_317, NULL, 317), + NAME_FUNC_OFFSET( 3955, gl_dispatch_stub_318, gl_dispatch_stub_318, NULL, 318), + NAME_FUNC_OFFSET( 3971, glPolygonOffset, glPolygonOffset, NULL, 319), + NAME_FUNC_OFFSET( 3987, gl_dispatch_stub_320, gl_dispatch_stub_320, NULL, 320), + NAME_FUNC_OFFSET( 4005, gl_dispatch_stub_321, gl_dispatch_stub_321, NULL, 321), + NAME_FUNC_OFFSET( 4021, gl_dispatch_stub_322, gl_dispatch_stub_322, NULL, 322), + NAME_FUNC_OFFSET( 4043, gl_dispatch_stub_323, gl_dispatch_stub_323, NULL, 323), + NAME_FUNC_OFFSET( 4060, glCopyTexImage2D, glCopyTexImage2D, NULL, 324), + NAME_FUNC_OFFSET( 4077, gl_dispatch_stub_325, gl_dispatch_stub_325, NULL, 325), + NAME_FUNC_OFFSET( 4097, glCopyTexSubImage2D, glCopyTexSubImage2D, NULL, 326), + NAME_FUNC_OFFSET( 4117, glDeleteTextures, glDeleteTextures, NULL, 327), + NAME_FUNC_OFFSET( 4134, glGenTextures, glGenTextures, NULL, 328), + NAME_FUNC_OFFSET( 4148, gl_dispatch_stub_329, gl_dispatch_stub_329, NULL, 329), + NAME_FUNC_OFFSET( 4162, glIsTexture, glIsTexture, NULL, 330), + NAME_FUNC_OFFSET( 4174, gl_dispatch_stub_331, gl_dispatch_stub_331, NULL, 331), + NAME_FUNC_OFFSET( 4195, gl_dispatch_stub_332, gl_dispatch_stub_332, NULL, 332), + NAME_FUNC_OFFSET( 4211, glTexSubImage2D, glTexSubImage2D, NULL, 333), + NAME_FUNC_OFFSET( 4227, gl_dispatch_stub_334, gl_dispatch_stub_334, NULL, 334), + NAME_FUNC_OFFSET( 4245, gl_dispatch_stub_335, gl_dispatch_stub_335, NULL, 335), + NAME_FUNC_OFFSET( 4264, glBlendColor, glBlendColor, NULL, 336), + NAME_FUNC_OFFSET( 4277, glBlendEquation, glBlendEquation, NULL, 337), + NAME_FUNC_OFFSET( 4293, gl_dispatch_stub_338, gl_dispatch_stub_338, NULL, 338), + NAME_FUNC_OFFSET( 4313, gl_dispatch_stub_339, gl_dispatch_stub_339, NULL, 339), + NAME_FUNC_OFFSET( 4326, gl_dispatch_stub_340, gl_dispatch_stub_340, NULL, 340), + NAME_FUNC_OFFSET( 4350, gl_dispatch_stub_341, gl_dispatch_stub_341, NULL, 341), + NAME_FUNC_OFFSET( 4374, gl_dispatch_stub_342, gl_dispatch_stub_342, NULL, 342), + NAME_FUNC_OFFSET( 4391, gl_dispatch_stub_343, gl_dispatch_stub_343, NULL, 343), + NAME_FUNC_OFFSET( 4407, gl_dispatch_stub_344, gl_dispatch_stub_344, NULL, 344), + NAME_FUNC_OFFSET( 4434, gl_dispatch_stub_345, gl_dispatch_stub_345, NULL, 345), + NAME_FUNC_OFFSET( 4461, gl_dispatch_stub_346, gl_dispatch_stub_346, NULL, 346), + NAME_FUNC_OFFSET( 4477, gl_dispatch_stub_347, gl_dispatch_stub_347, NULL, 347), + NAME_FUNC_OFFSET( 4497, gl_dispatch_stub_348, gl_dispatch_stub_348, NULL, 348), + NAME_FUNC_OFFSET( 4519, gl_dispatch_stub_349, gl_dispatch_stub_349, NULL, 349), + NAME_FUNC_OFFSET( 4541, gl_dispatch_stub_350, gl_dispatch_stub_350, NULL, 350), + NAME_FUNC_OFFSET( 4565, gl_dispatch_stub_351, gl_dispatch_stub_351, NULL, 351), + NAME_FUNC_OFFSET( 4590, gl_dispatch_stub_352, gl_dispatch_stub_352, NULL, 352), + NAME_FUNC_OFFSET( 4614, gl_dispatch_stub_353, gl_dispatch_stub_353, NULL, 353), + NAME_FUNC_OFFSET( 4639, gl_dispatch_stub_354, gl_dispatch_stub_354, NULL, 354), + NAME_FUNC_OFFSET( 4665, gl_dispatch_stub_355, gl_dispatch_stub_355, NULL, 355), + NAME_FUNC_OFFSET( 4691, gl_dispatch_stub_356, gl_dispatch_stub_356, NULL, 356), + NAME_FUNC_OFFSET( 4714, gl_dispatch_stub_357, gl_dispatch_stub_357, NULL, 357), + NAME_FUNC_OFFSET( 4742, gl_dispatch_stub_358, gl_dispatch_stub_358, NULL, 358), + NAME_FUNC_OFFSET( 4770, gl_dispatch_stub_359, gl_dispatch_stub_359, NULL, 359), + NAME_FUNC_OFFSET( 4791, gl_dispatch_stub_360, gl_dispatch_stub_360, NULL, 360), + NAME_FUNC_OFFSET( 4811, gl_dispatch_stub_361, gl_dispatch_stub_361, NULL, 361), + NAME_FUNC_OFFSET( 4826, gl_dispatch_stub_362, gl_dispatch_stub_362, NULL, 362), + NAME_FUNC_OFFSET( 4852, gl_dispatch_stub_363, gl_dispatch_stub_363, NULL, 363), + NAME_FUNC_OFFSET( 4878, gl_dispatch_stub_364, gl_dispatch_stub_364, NULL, 364), + NAME_FUNC_OFFSET( 4890, gl_dispatch_stub_365, gl_dispatch_stub_365, NULL, 365), + NAME_FUNC_OFFSET( 4913, gl_dispatch_stub_366, gl_dispatch_stub_366, NULL, 366), + NAME_FUNC_OFFSET( 4936, gl_dispatch_stub_367, gl_dispatch_stub_367, NULL, 367), + NAME_FUNC_OFFSET( 4948, gl_dispatch_stub_368, gl_dispatch_stub_368, NULL, 368), + NAME_FUNC_OFFSET( 4957, gl_dispatch_stub_369, gl_dispatch_stub_369, NULL, 369), + NAME_FUNC_OFFSET( 4974, gl_dispatch_stub_370, gl_dispatch_stub_370, NULL, 370), + NAME_FUNC_OFFSET( 4988, glTexImage3DOES, glTexImage3DOES, NULL, 371), + NAME_FUNC_OFFSET( 5004, glTexSubImage3DOES, glTexSubImage3DOES, NULL, 372), + NAME_FUNC_OFFSET( 5023, glCopyTexSubImage3DOES, glCopyTexSubImage3DOES, NULL, 373), + NAME_FUNC_OFFSET( 5046, glActiveTexture, glActiveTexture, NULL, 374), + NAME_FUNC_OFFSET( 5062, gl_dispatch_stub_375, gl_dispatch_stub_375, NULL, 375), + NAME_FUNC_OFFSET( 5087, gl_dispatch_stub_376, gl_dispatch_stub_376, NULL, 376), + NAME_FUNC_OFFSET( 5108, gl_dispatch_stub_377, gl_dispatch_stub_377, NULL, 377), + NAME_FUNC_OFFSET( 5130, gl_dispatch_stub_378, gl_dispatch_stub_378, NULL, 378), + NAME_FUNC_OFFSET( 5151, gl_dispatch_stub_379, gl_dispatch_stub_379, NULL, 379), + NAME_FUNC_OFFSET( 5173, gl_dispatch_stub_380, gl_dispatch_stub_380, NULL, 380), + NAME_FUNC_OFFSET( 5194, gl_dispatch_stub_381, gl_dispatch_stub_381, NULL, 381), + NAME_FUNC_OFFSET( 5216, gl_dispatch_stub_382, gl_dispatch_stub_382, NULL, 382), + NAME_FUNC_OFFSET( 5237, gl_dispatch_stub_383, gl_dispatch_stub_383, NULL, 383), + NAME_FUNC_OFFSET( 5259, gl_dispatch_stub_384, gl_dispatch_stub_384, NULL, 384), + NAME_FUNC_OFFSET( 5280, gl_dispatch_stub_385, gl_dispatch_stub_385, NULL, 385), + NAME_FUNC_OFFSET( 5302, gl_dispatch_stub_386, gl_dispatch_stub_386, NULL, 386), + NAME_FUNC_OFFSET( 5323, gl_dispatch_stub_387, gl_dispatch_stub_387, NULL, 387), + NAME_FUNC_OFFSET( 5345, gl_dispatch_stub_388, gl_dispatch_stub_388, NULL, 388), + NAME_FUNC_OFFSET( 5366, gl_dispatch_stub_389, gl_dispatch_stub_389, NULL, 389), + NAME_FUNC_OFFSET( 5388, gl_dispatch_stub_390, gl_dispatch_stub_390, NULL, 390), + NAME_FUNC_OFFSET( 5409, gl_dispatch_stub_391, gl_dispatch_stub_391, NULL, 391), + NAME_FUNC_OFFSET( 5431, gl_dispatch_stub_392, gl_dispatch_stub_392, NULL, 392), + NAME_FUNC_OFFSET( 5452, gl_dispatch_stub_393, gl_dispatch_stub_393, NULL, 393), + NAME_FUNC_OFFSET( 5474, gl_dispatch_stub_394, gl_dispatch_stub_394, NULL, 394), + NAME_FUNC_OFFSET( 5495, gl_dispatch_stub_395, gl_dispatch_stub_395, NULL, 395), + NAME_FUNC_OFFSET( 5517, gl_dispatch_stub_396, gl_dispatch_stub_396, NULL, 396), + NAME_FUNC_OFFSET( 5538, gl_dispatch_stub_397, gl_dispatch_stub_397, NULL, 397), + NAME_FUNC_OFFSET( 5560, gl_dispatch_stub_398, gl_dispatch_stub_398, NULL, 398), + NAME_FUNC_OFFSET( 5581, gl_dispatch_stub_399, gl_dispatch_stub_399, NULL, 399), + NAME_FUNC_OFFSET( 5603, gl_dispatch_stub_400, gl_dispatch_stub_400, NULL, 400), + NAME_FUNC_OFFSET( 5624, gl_dispatch_stub_401, gl_dispatch_stub_401, NULL, 401), + NAME_FUNC_OFFSET( 5646, gl_dispatch_stub_402, gl_dispatch_stub_402, NULL, 402), + NAME_FUNC_OFFSET( 5667, gl_dispatch_stub_403, gl_dispatch_stub_403, NULL, 403), + NAME_FUNC_OFFSET( 5689, gl_dispatch_stub_404, gl_dispatch_stub_404, NULL, 404), + NAME_FUNC_OFFSET( 5710, gl_dispatch_stub_405, gl_dispatch_stub_405, NULL, 405), + NAME_FUNC_OFFSET( 5732, gl_dispatch_stub_406, gl_dispatch_stub_406, NULL, 406), + NAME_FUNC_OFFSET( 5753, gl_dispatch_stub_407, gl_dispatch_stub_407, NULL, 407), + NAME_FUNC_OFFSET( 5775, glGetBufferPointervOES, glGetBufferPointervOES, NULL, 408), + NAME_FUNC_OFFSET( 5798, glMapBufferOES, glMapBufferOES, NULL, 409), + NAME_FUNC_OFFSET( 5813, glUnmapBufferOES, glUnmapBufferOES, NULL, 410), + NAME_FUNC_OFFSET( 5830, glCompressedTexImage3DOES, glCompressedTexImage3DOES, NULL, 411), + NAME_FUNC_OFFSET( 5856, glCompressedTexSubImage3DOES, glCompressedTexSubImage3DOES, NULL, 412), + NAME_FUNC_OFFSET( 5885, glFramebufferTexture3DOES, glFramebufferTexture3DOES, NULL, 413), + NAME_FUNC_OFFSET( 5911, glGetProgramBinaryOES, glGetProgramBinaryOES, NULL, 414), + NAME_FUNC_OFFSET( 5933, glProgramBinaryOES, glProgramBinaryOES, NULL, 415), + NAME_FUNC_OFFSET( 5952, glMultiDrawArraysEXT, glMultiDrawArraysEXT, NULL, 416), + NAME_FUNC_OFFSET( 5973, glMultiDrawElementsEXT, glMultiDrawElementsEXT, NULL, 417), + NAME_FUNC_OFFSET( 5996, gl_dispatch_stub_418, gl_dispatch_stub_418, NULL, 418), + NAME_FUNC_OFFSET( 6019, gl_dispatch_stub_419, gl_dispatch_stub_419, NULL, 419), + NAME_FUNC_OFFSET( 6045, gl_dispatch_stub_420, gl_dispatch_stub_420, NULL, 420), + NAME_FUNC_OFFSET( 6068, gl_dispatch_stub_421, gl_dispatch_stub_421, NULL, 421), + NAME_FUNC_OFFSET( 6089, glEGLImageTargetRenderbufferStorageOES, glEGLImageTargetRenderbufferStorageOES, NULL, 422), + NAME_FUNC_OFFSET( 6128, glEGLImageTargetTexture2DOES, glEGLImageTargetTexture2DOES, NULL, 423), + NAME_FUNC_OFFSET( 6157, glCompressedTexImage2D, glCompressedTexImage2D, NULL, 424), + NAME_FUNC_OFFSET( 6180, glCompressedTexSubImage2D, glCompressedTexSubImage2D, NULL, 425), + NAME_FUNC_OFFSET( 6206, glSampleCoverage, glSampleCoverage, NULL, 426), + NAME_FUNC_OFFSET( 6223, glBindBuffer, glBindBuffer, NULL, 427), + NAME_FUNC_OFFSET( 6236, glBufferData, glBufferData, NULL, 428), + NAME_FUNC_OFFSET( 6249, glBufferSubData, glBufferSubData, NULL, 429), + NAME_FUNC_OFFSET( 6265, glDeleteBuffers, glDeleteBuffers, NULL, 430), + NAME_FUNC_OFFSET( 6281, glGenBuffers, glGenBuffers, NULL, 431), + NAME_FUNC_OFFSET( 6294, glGetBufferParameteriv, glGetBufferParameteriv, NULL, 432), + NAME_FUNC_OFFSET( 6317, glIsBuffer, glIsBuffer, NULL, 433), + NAME_FUNC_OFFSET( 6328, glAttachShader, glAttachShader, NULL, 434), + NAME_FUNC_OFFSET( 6343, glBindAttribLocation, glBindAttribLocation, NULL, 435), + NAME_FUNC_OFFSET( 6364, glBlendEquationSeparate, glBlendEquationSeparate, NULL, 436), + NAME_FUNC_OFFSET( 6388, glCompileShader, glCompileShader, NULL, 437), + NAME_FUNC_OFFSET( 6404, glCreateProgram, glCreateProgram, NULL, 438), + NAME_FUNC_OFFSET( 6420, glCreateShader, glCreateShader, NULL, 439), + NAME_FUNC_OFFSET( 6435, glDeleteProgram, glDeleteProgram, NULL, 440), + NAME_FUNC_OFFSET( 6451, glDeleteShader, glDeleteShader, NULL, 441), + NAME_FUNC_OFFSET( 6466, glDetachShader, glDetachShader, NULL, 442), + NAME_FUNC_OFFSET( 6481, glDisableVertexAttribArray, glDisableVertexAttribArray, NULL, 443), + NAME_FUNC_OFFSET( 6508, glEnableVertexAttribArray, glEnableVertexAttribArray, NULL, 444), + NAME_FUNC_OFFSET( 6534, glGetActiveAttrib, glGetActiveAttrib, NULL, 445), + NAME_FUNC_OFFSET( 6552, glGetActiveUniform, glGetActiveUniform, NULL, 446), + NAME_FUNC_OFFSET( 6571, glGetAttachedShaders, glGetAttachedShaders, NULL, 447), + NAME_FUNC_OFFSET( 6592, glGetAttribLocation, glGetAttribLocation, NULL, 448), + NAME_FUNC_OFFSET( 6612, glGetProgramInfoLog, glGetProgramInfoLog, NULL, 449), + NAME_FUNC_OFFSET( 6632, glGetProgramiv, glGetProgramiv, NULL, 450), + NAME_FUNC_OFFSET( 6647, glGetShaderInfoLog, glGetShaderInfoLog, NULL, 451), + NAME_FUNC_OFFSET( 6666, glGetShaderSource, glGetShaderSource, NULL, 452), + NAME_FUNC_OFFSET( 6684, glGetShaderiv, glGetShaderiv, NULL, 453), + NAME_FUNC_OFFSET( 6698, glGetUniformLocation, glGetUniformLocation, NULL, 454), + NAME_FUNC_OFFSET( 6719, glGetUniformfv, glGetUniformfv, NULL, 455), + NAME_FUNC_OFFSET( 6734, glGetUniformiv, glGetUniformiv, NULL, 456), + NAME_FUNC_OFFSET( 6749, glGetVertexAttribPointerv, glGetVertexAttribPointerv, NULL, 457), + NAME_FUNC_OFFSET( 6775, glGetVertexAttribfv, glGetVertexAttribfv, NULL, 458), + NAME_FUNC_OFFSET( 6795, glGetVertexAttribiv, glGetVertexAttribiv, NULL, 459), + NAME_FUNC_OFFSET( 6815, glIsProgram, glIsProgram, NULL, 460), + NAME_FUNC_OFFSET( 6827, glIsShader, glIsShader, NULL, 461), + NAME_FUNC_OFFSET( 6838, glLinkProgram, glLinkProgram, NULL, 462), + NAME_FUNC_OFFSET( 6852, glShaderSource, glShaderSource, NULL, 463), + NAME_FUNC_OFFSET( 6867, glStencilFuncSeparate, glStencilFuncSeparate, NULL, 464), + NAME_FUNC_OFFSET( 6889, glStencilMaskSeparate, glStencilMaskSeparate, NULL, 465), + NAME_FUNC_OFFSET( 6911, glStencilOpSeparate, glStencilOpSeparate, NULL, 466), + NAME_FUNC_OFFSET( 6931, glUniform1f, glUniform1f, NULL, 467), + NAME_FUNC_OFFSET( 6943, glUniform1fv, glUniform1fv, NULL, 468), + NAME_FUNC_OFFSET( 6956, glUniform1i, glUniform1i, NULL, 469), + NAME_FUNC_OFFSET( 6968, glUniform1iv, glUniform1iv, NULL, 470), + NAME_FUNC_OFFSET( 6981, glUniform2f, glUniform2f, NULL, 471), + NAME_FUNC_OFFSET( 6993, glUniform2fv, glUniform2fv, NULL, 472), + NAME_FUNC_OFFSET( 7006, glUniform2i, glUniform2i, NULL, 473), + NAME_FUNC_OFFSET( 7018, glUniform2iv, glUniform2iv, NULL, 474), + NAME_FUNC_OFFSET( 7031, glUniform3f, glUniform3f, NULL, 475), + NAME_FUNC_OFFSET( 7043, glUniform3fv, glUniform3fv, NULL, 476), + NAME_FUNC_OFFSET( 7056, glUniform3i, glUniform3i, NULL, 477), + NAME_FUNC_OFFSET( 7068, glUniform3iv, glUniform3iv, NULL, 478), + NAME_FUNC_OFFSET( 7081, glUniform4f, glUniform4f, NULL, 479), + NAME_FUNC_OFFSET( 7093, glUniform4fv, glUniform4fv, NULL, 480), + NAME_FUNC_OFFSET( 7106, glUniform4i, glUniform4i, NULL, 481), + NAME_FUNC_OFFSET( 7118, glUniform4iv, glUniform4iv, NULL, 482), + NAME_FUNC_OFFSET( 7131, glUniformMatrix2fv, glUniformMatrix2fv, NULL, 483), + NAME_FUNC_OFFSET( 7150, glUniformMatrix3fv, glUniformMatrix3fv, NULL, 484), + NAME_FUNC_OFFSET( 7169, glUniformMatrix4fv, glUniformMatrix4fv, NULL, 485), + NAME_FUNC_OFFSET( 7188, glUseProgram, glUseProgram, NULL, 486), + NAME_FUNC_OFFSET( 7201, glValidateProgram, glValidateProgram, NULL, 487), + NAME_FUNC_OFFSET( 7219, glVertexAttrib1f, glVertexAttrib1f, NULL, 488), + NAME_FUNC_OFFSET( 7236, glVertexAttrib1fv, glVertexAttrib1fv, NULL, 489), + NAME_FUNC_OFFSET( 7254, glVertexAttrib2f, glVertexAttrib2f, NULL, 490), + NAME_FUNC_OFFSET( 7271, glVertexAttrib2fv, glVertexAttrib2fv, NULL, 491), + NAME_FUNC_OFFSET( 7289, glVertexAttrib3f, glVertexAttrib3f, NULL, 492), + NAME_FUNC_OFFSET( 7306, glVertexAttrib3fv, glVertexAttrib3fv, NULL, 493), + NAME_FUNC_OFFSET( 7324, glVertexAttrib4f, glVertexAttrib4f, NULL, 494), + NAME_FUNC_OFFSET( 7341, glVertexAttrib4fv, glVertexAttrib4fv, NULL, 495), + NAME_FUNC_OFFSET( 7359, glVertexAttribPointer, glVertexAttribPointer, NULL, 496), + NAME_FUNC_OFFSET( 7381, glBlendFuncSeparate, glBlendFuncSeparate, NULL, 497), + NAME_FUNC_OFFSET( 7401, glBindFramebuffer, glBindFramebuffer, NULL, 498), + NAME_FUNC_OFFSET( 7419, glBindRenderbuffer, glBindRenderbuffer, NULL, 499), + NAME_FUNC_OFFSET( 7438, glCheckFramebufferStatus, glCheckFramebufferStatus, NULL, 500), + NAME_FUNC_OFFSET( 7463, glClearDepthf, glClearDepthf, NULL, 501), + NAME_FUNC_OFFSET( 7477, glDeleteFramebuffers, glDeleteFramebuffers, NULL, 502), + NAME_FUNC_OFFSET( 7498, glDeleteRenderbuffers, glDeleteRenderbuffers, NULL, 503), + NAME_FUNC_OFFSET( 7520, glDepthRangef, glDepthRangef, NULL, 504), + NAME_FUNC_OFFSET( 7534, glFramebufferRenderbuffer, glFramebufferRenderbuffer, NULL, 505), + NAME_FUNC_OFFSET( 7560, glFramebufferTexture2D, glFramebufferTexture2D, NULL, 506), + NAME_FUNC_OFFSET( 7583, glGenFramebuffers, glGenFramebuffers, NULL, 507), + NAME_FUNC_OFFSET( 7601, glGenRenderbuffers, glGenRenderbuffers, NULL, 508), + NAME_FUNC_OFFSET( 7620, glGenerateMipmap, glGenerateMipmap, NULL, 509), + NAME_FUNC_OFFSET( 7637, glGetFramebufferAttachmentParameteriv, glGetFramebufferAttachmentParameteriv, NULL, 510), + NAME_FUNC_OFFSET( 7675, glGetRenderbufferParameteriv, glGetRenderbufferParameteriv, NULL, 511), + NAME_FUNC_OFFSET( 7704, glGetShaderPrecisionFormat, glGetShaderPrecisionFormat, NULL, 512), + NAME_FUNC_OFFSET( 7731, glIsFramebuffer, glIsFramebuffer, NULL, 513), + NAME_FUNC_OFFSET( 7747, glIsRenderbuffer, glIsRenderbuffer, NULL, 514), + NAME_FUNC_OFFSET( 7764, glReleaseShaderCompiler, glReleaseShaderCompiler, NULL, 515), + NAME_FUNC_OFFSET( 7788, glRenderbufferStorage, glRenderbufferStorage, NULL, 516), + NAME_FUNC_OFFSET( 7810, glShaderBinary, glShaderBinary, NULL, 517), + NAME_FUNC_OFFSET( 7825, glTexImage3DOES, glTexImage3DOES, NULL, 371), + NAME_FUNC_OFFSET( 7838, glTexSubImage3DOES, glTexSubImage3DOES, NULL, 372), + NAME_FUNC_OFFSET( 7854, glCopyTexSubImage3DOES, glCopyTexSubImage3DOES, NULL, 373), + NAME_FUNC_OFFSET( 7874, glActiveTexture, glActiveTexture, NULL, 374), + NAME_FUNC_OFFSET(-1, NULL, NULL, NULL, 0) +}; + +#undef NAME_FUNC_OFFSET diff --git a/src/mapi/es2api/main/glapidispatch.h b/src/mapi/es2api/main/glapidispatch.h new file mode 100644 index 00000000000..06a45974d75 --- /dev/null +++ b/src/mapi/es2api/main/glapidispatch.h @@ -0,0 +1,2392 @@ +/* DO NOT EDIT - This file generated automatically by gl_table.py (from Mesa) script */ + +/* + * (C) Copyright IBM Corporation 2005 + * All Rights Reserved. + * + * Permission is hereby granted, free of charge, to any person obtaining a + * copy of this software and associated documentation files (the "Software"), + * to deal in the Software without restriction, including without limitation + * the rights to use, copy, modify, merge, publish, distribute, sub license, + * and/or sell copies of the Software, and to permit persons to whom the + * Software is furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice (including the next + * paragraph) shall be included in all copies or substantial portions of the + * Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL + * IBM, + * AND/OR THEIR SUPPLIERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, + * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF + * OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE + * SOFTWARE. + */ + +#if !defined( _GLAPI_DISPATCH_H_ ) +# define _GLAPI_DISPATCH_H_ + + +/* this file should not be included directly in mesa */ + +/** + * \file glapidispatch.h + * Macros for handling GL dispatch tables. + * + * For each known GL function, there are 3 macros in this file. The first + * macro is named CALL_FuncName and is used to call that GL function using + * the specified dispatch table. The other 2 macros, called GET_FuncName + * can SET_FuncName, are used to get and set the dispatch pointer for the + * named function in the specified dispatch table. + */ + +#define CALL_by_offset(disp, cast, offset, parameters) \ + (*(cast (GET_by_offset(disp, offset)))) parameters +#define GET_by_offset(disp, offset) \ + (offset >= 0) ? (((_glapi_proc *)(disp))[offset]) : NULL +#define SET_by_offset(disp, offset, fn) \ + do { \ + if ( (offset) < 0 ) { \ + /* fprintf( stderr, "[%s:%u] SET_by_offset(%p, %d, %s)!\n", */ \ + /* __func__, __LINE__, disp, offset, # fn); */ \ + /* abort(); */ \ + } \ + else { \ + ( (_glapi_proc *) (disp) )[offset] = (_glapi_proc) fn; \ + } \ + } while(0) + +/* total number of offsets below */ +#define _gloffset_COUNT 518 + +#define _gloffset_NewList 0 +#define _gloffset_EndList 1 +#define _gloffset_CallList 2 +#define _gloffset_CallLists 3 +#define _gloffset_DeleteLists 4 +#define _gloffset_GenLists 5 +#define _gloffset_ListBase 6 +#define _gloffset_Begin 7 +#define _gloffset_Bitmap 8 +#define _gloffset_Color3b 9 +#define _gloffset_Color3bv 10 +#define _gloffset_Color3d 11 +#define _gloffset_Color3dv 12 +#define _gloffset_Color3f 13 +#define _gloffset_Color3fv 14 +#define _gloffset_Color3i 15 +#define _gloffset_Color3iv 16 +#define _gloffset_Color3s 17 +#define _gloffset_Color3sv 18 +#define _gloffset_Color3ub 19 +#define _gloffset_Color3ubv 20 +#define _gloffset_Color3ui 21 +#define _gloffset_Color3uiv 22 +#define _gloffset_Color3us 23 +#define _gloffset_Color3usv 24 +#define _gloffset_Color4b 25 +#define _gloffset_Color4bv 26 +#define _gloffset_Color4d 27 +#define _gloffset_Color4dv 28 +#define _gloffset_Color4f 29 +#define _gloffset_Color4fv 30 +#define _gloffset_Color4i 31 +#define _gloffset_Color4iv 32 +#define _gloffset_Color4s 33 +#define _gloffset_Color4sv 34 +#define _gloffset_Color4ub 35 +#define _gloffset_Color4ubv 36 +#define _gloffset_Color4ui 37 +#define _gloffset_Color4uiv 38 +#define _gloffset_Color4us 39 +#define _gloffset_Color4usv 40 +#define _gloffset_EdgeFlag 41 +#define _gloffset_EdgeFlagv 42 +#define _gloffset_End 43 +#define _gloffset_Indexd 44 +#define _gloffset_Indexdv 45 +#define _gloffset_Indexf 46 +#define _gloffset_Indexfv 47 +#define _gloffset_Indexi 48 +#define _gloffset_Indexiv 49 +#define _gloffset_Indexs 50 +#define _gloffset_Indexsv 51 +#define _gloffset_Normal3b 52 +#define _gloffset_Normal3bv 53 +#define _gloffset_Normal3d 54 +#define _gloffset_Normal3dv 55 +#define _gloffset_Normal3f 56 +#define _gloffset_Normal3fv 57 +#define _gloffset_Normal3i 58 +#define _gloffset_Normal3iv 59 +#define _gloffset_Normal3s 60 +#define _gloffset_Normal3sv 61 +#define _gloffset_RasterPos2d 62 +#define _gloffset_RasterPos2dv 63 +#define _gloffset_RasterPos2f 64 +#define _gloffset_RasterPos2fv 65 +#define _gloffset_RasterPos2i 66 +#define _gloffset_RasterPos2iv 67 +#define _gloffset_RasterPos2s 68 +#define _gloffset_RasterPos2sv 69 +#define _gloffset_RasterPos3d 70 +#define _gloffset_RasterPos3dv 71 +#define _gloffset_RasterPos3f 72 +#define _gloffset_RasterPos3fv 73 +#define _gloffset_RasterPos3i 74 +#define _gloffset_RasterPos3iv 75 +#define _gloffset_RasterPos3s 76 +#define _gloffset_RasterPos3sv 77 +#define _gloffset_RasterPos4d 78 +#define _gloffset_RasterPos4dv 79 +#define _gloffset_RasterPos4f 80 +#define _gloffset_RasterPos4fv 81 +#define _gloffset_RasterPos4i 82 +#define _gloffset_RasterPos4iv 83 +#define _gloffset_RasterPos4s 84 +#define _gloffset_RasterPos4sv 85 +#define _gloffset_Rectd 86 +#define _gloffset_Rectdv 87 +#define _gloffset_Rectf 88 +#define _gloffset_Rectfv 89 +#define _gloffset_Recti 90 +#define _gloffset_Rectiv 91 +#define _gloffset_Rects 92 +#define _gloffset_Rectsv 93 +#define _gloffset_TexCoord1d 94 +#define _gloffset_TexCoord1dv 95 +#define _gloffset_TexCoord1f 96 +#define _gloffset_TexCoord1fv 97 +#define _gloffset_TexCoord1i 98 +#define _gloffset_TexCoord1iv 99 +#define _gloffset_TexCoord1s 100 +#define _gloffset_TexCoord1sv 101 +#define _gloffset_TexCoord2d 102 +#define _gloffset_TexCoord2dv 103 +#define _gloffset_TexCoord2f 104 +#define _gloffset_TexCoord2fv 105 +#define _gloffset_TexCoord2i 106 +#define _gloffset_TexCoord2iv 107 +#define _gloffset_TexCoord2s 108 +#define _gloffset_TexCoord2sv 109 +#define _gloffset_TexCoord3d 110 +#define _gloffset_TexCoord3dv 111 +#define _gloffset_TexCoord3f 112 +#define _gloffset_TexCoord3fv 113 +#define _gloffset_TexCoord3i 114 +#define _gloffset_TexCoord3iv 115 +#define _gloffset_TexCoord3s 116 +#define _gloffset_TexCoord3sv 117 +#define _gloffset_TexCoord4d 118 +#define _gloffset_TexCoord4dv 119 +#define _gloffset_TexCoord4f 120 +#define _gloffset_TexCoord4fv 121 +#define _gloffset_TexCoord4i 122 +#define _gloffset_TexCoord4iv 123 +#define _gloffset_TexCoord4s 124 +#define _gloffset_TexCoord4sv 125 +#define _gloffset_Vertex2d 126 +#define _gloffset_Vertex2dv 127 +#define _gloffset_Vertex2f 128 +#define _gloffset_Vertex2fv 129 +#define _gloffset_Vertex2i 130 +#define _gloffset_Vertex2iv 131 +#define _gloffset_Vertex2s 132 +#define _gloffset_Vertex2sv 133 +#define _gloffset_Vertex3d 134 +#define _gloffset_Vertex3dv 135 +#define _gloffset_Vertex3f 136 +#define _gloffset_Vertex3fv 137 +#define _gloffset_Vertex3i 138 +#define _gloffset_Vertex3iv 139 +#define _gloffset_Vertex3s 140 +#define _gloffset_Vertex3sv 141 +#define _gloffset_Vertex4d 142 +#define _gloffset_Vertex4dv 143 +#define _gloffset_Vertex4f 144 +#define _gloffset_Vertex4fv 145 +#define _gloffset_Vertex4i 146 +#define _gloffset_Vertex4iv 147 +#define _gloffset_Vertex4s 148 +#define _gloffset_Vertex4sv 149 +#define _gloffset_ClipPlane 150 +#define _gloffset_ColorMaterial 151 +#define _gloffset_CullFace 152 +#define _gloffset_Fogf 153 +#define _gloffset_Fogfv 154 +#define _gloffset_Fogi 155 +#define _gloffset_Fogiv 156 +#define _gloffset_FrontFace 157 +#define _gloffset_Hint 158 +#define _gloffset_Lightf 159 +#define _gloffset_Lightfv 160 +#define _gloffset_Lighti 161 +#define _gloffset_Lightiv 162 +#define _gloffset_LightModelf 163 +#define _gloffset_LightModelfv 164 +#define _gloffset_LightModeli 165 +#define _gloffset_LightModeliv 166 +#define _gloffset_LineStipple 167 +#define _gloffset_LineWidth 168 +#define _gloffset_Materialf 169 +#define _gloffset_Materialfv 170 +#define _gloffset_Materiali 171 +#define _gloffset_Materialiv 172 +#define _gloffset_PointSize 173 +#define _gloffset_PolygonMode 174 +#define _gloffset_PolygonStipple 175 +#define _gloffset_Scissor 176 +#define _gloffset_ShadeModel 177 +#define _gloffset_TexParameterf 178 +#define _gloffset_TexParameterfv 179 +#define _gloffset_TexParameteri 180 +#define _gloffset_TexParameteriv 181 +#define _gloffset_TexImage1D 182 +#define _gloffset_TexImage2D 183 +#define _gloffset_TexEnvf 184 +#define _gloffset_TexEnvfv 185 +#define _gloffset_TexEnvi 186 +#define _gloffset_TexEnviv 187 +#define _gloffset_TexGend 188 +#define _gloffset_TexGendv 189 +#define _gloffset_TexGenf 190 +#define _gloffset_TexGenfv 191 +#define _gloffset_TexGeni 192 +#define _gloffset_TexGeniv 193 +#define _gloffset_FeedbackBuffer 194 +#define _gloffset_SelectBuffer 195 +#define _gloffset_RenderMode 196 +#define _gloffset_InitNames 197 +#define _gloffset_LoadName 198 +#define _gloffset_PassThrough 199 +#define _gloffset_PopName 200 +#define _gloffset_PushName 201 +#define _gloffset_DrawBuffer 202 +#define _gloffset_Clear 203 +#define _gloffset_ClearAccum 204 +#define _gloffset_ClearIndex 205 +#define _gloffset_ClearColor 206 +#define _gloffset_ClearStencil 207 +#define _gloffset_ClearDepth 208 +#define _gloffset_StencilMask 209 +#define _gloffset_ColorMask 210 +#define _gloffset_DepthMask 211 +#define _gloffset_IndexMask 212 +#define _gloffset_Accum 213 +#define _gloffset_Disable 214 +#define _gloffset_Enable 215 +#define _gloffset_Finish 216 +#define _gloffset_Flush 217 +#define _gloffset_PopAttrib 218 +#define _gloffset_PushAttrib 219 +#define _gloffset_Map1d 220 +#define _gloffset_Map1f 221 +#define _gloffset_Map2d 222 +#define _gloffset_Map2f 223 +#define _gloffset_MapGrid1d 224 +#define _gloffset_MapGrid1f 225 +#define _gloffset_MapGrid2d 226 +#define _gloffset_MapGrid2f 227 +#define _gloffset_EvalCoord1d 228 +#define _gloffset_EvalCoord1dv 229 +#define _gloffset_EvalCoord1f 230 +#define _gloffset_EvalCoord1fv 231 +#define _gloffset_EvalCoord2d 232 +#define _gloffset_EvalCoord2dv 233 +#define _gloffset_EvalCoord2f 234 +#define _gloffset_EvalCoord2fv 235 +#define _gloffset_EvalMesh1 236 +#define _gloffset_EvalPoint1 237 +#define _gloffset_EvalMesh2 238 +#define _gloffset_EvalPoint2 239 +#define _gloffset_AlphaFunc 240 +#define _gloffset_BlendFunc 241 +#define _gloffset_LogicOp 242 +#define _gloffset_StencilFunc 243 +#define _gloffset_StencilOp 244 +#define _gloffset_DepthFunc 245 +#define _gloffset_PixelZoom 246 +#define _gloffset_PixelTransferf 247 +#define _gloffset_PixelTransferi 248 +#define _gloffset_PixelStoref 249 +#define _gloffset_PixelStorei 250 +#define _gloffset_PixelMapfv 251 +#define _gloffset_PixelMapuiv 252 +#define _gloffset_PixelMapusv 253 +#define _gloffset_ReadBuffer 254 +#define _gloffset_CopyPixels 255 +#define _gloffset_ReadPixels 256 +#define _gloffset_DrawPixels 257 +#define _gloffset_GetBooleanv 258 +#define _gloffset_GetClipPlane 259 +#define _gloffset_GetDoublev 260 +#define _gloffset_GetError 261 +#define _gloffset_GetFloatv 262 +#define _gloffset_GetIntegerv 263 +#define _gloffset_GetLightfv 264 +#define _gloffset_GetLightiv 265 +#define _gloffset_GetMapdv 266 +#define _gloffset_GetMapfv 267 +#define _gloffset_GetMapiv 268 +#define _gloffset_GetMaterialfv 269 +#define _gloffset_GetMaterialiv 270 +#define _gloffset_GetPixelMapfv 271 +#define _gloffset_GetPixelMapuiv 272 +#define _gloffset_GetPixelMapusv 273 +#define _gloffset_GetPolygonStipple 274 +#define _gloffset_GetString 275 +#define _gloffset_GetTexEnvfv 276 +#define _gloffset_GetTexEnviv 277 +#define _gloffset_GetTexGendv 278 +#define _gloffset_GetTexGenfv 279 +#define _gloffset_GetTexGeniv 280 +#define _gloffset_GetTexImage 281 +#define _gloffset_GetTexParameterfv 282 +#define _gloffset_GetTexParameteriv 283 +#define _gloffset_GetTexLevelParameterfv 284 +#define _gloffset_GetTexLevelParameteriv 285 +#define _gloffset_IsEnabled 286 +#define _gloffset_IsList 287 +#define _gloffset_DepthRange 288 +#define _gloffset_Frustum 289 +#define _gloffset_LoadIdentity 290 +#define _gloffset_LoadMatrixf 291 +#define _gloffset_LoadMatrixd 292 +#define _gloffset_MatrixMode 293 +#define _gloffset_MultMatrixf 294 +#define _gloffset_MultMatrixd 295 +#define _gloffset_Ortho 296 +#define _gloffset_PopMatrix 297 +#define _gloffset_PushMatrix 298 +#define _gloffset_Rotated 299 +#define _gloffset_Rotatef 300 +#define _gloffset_Scaled 301 +#define _gloffset_Scalef 302 +#define _gloffset_Translated 303 +#define _gloffset_Translatef 304 +#define _gloffset_Viewport 305 +#define _gloffset_ArrayElement 306 +#define _gloffset_BindTexture 307 +#define _gloffset_ColorPointer 308 +#define _gloffset_DisableClientState 309 +#define _gloffset_DrawArrays 310 +#define _gloffset_DrawElements 311 +#define _gloffset_EdgeFlagPointer 312 +#define _gloffset_EnableClientState 313 +#define _gloffset_IndexPointer 314 +#define _gloffset_Indexub 315 +#define _gloffset_Indexubv 316 +#define _gloffset_InterleavedArrays 317 +#define _gloffset_NormalPointer 318 +#define _gloffset_PolygonOffset 319 +#define _gloffset_TexCoordPointer 320 +#define _gloffset_VertexPointer 321 +#define _gloffset_AreTexturesResident 322 +#define _gloffset_CopyTexImage1D 323 +#define _gloffset_CopyTexImage2D 324 +#define _gloffset_CopyTexSubImage1D 325 +#define _gloffset_CopyTexSubImage2D 326 +#define _gloffset_DeleteTextures 327 +#define _gloffset_GenTextures 328 +#define _gloffset_GetPointerv 329 +#define _gloffset_IsTexture 330 +#define _gloffset_PrioritizeTextures 331 +#define _gloffset_TexSubImage1D 332 +#define _gloffset_TexSubImage2D 333 +#define _gloffset_PopClientAttrib 334 +#define _gloffset_PushClientAttrib 335 +#define _gloffset_BlendColor 336 +#define _gloffset_BlendEquation 337 +#define _gloffset_DrawRangeElements 338 +#define _gloffset_ColorTable 339 +#define _gloffset_ColorTableParameterfv 340 +#define _gloffset_ColorTableParameteriv 341 +#define _gloffset_CopyColorTable 342 +#define _gloffset_GetColorTable 343 +#define _gloffset_GetColorTableParameterfv 344 +#define _gloffset_GetColorTableParameteriv 345 +#define _gloffset_ColorSubTable 346 +#define _gloffset_CopyColorSubTable 347 +#define _gloffset_ConvolutionFilter1D 348 +#define _gloffset_ConvolutionFilter2D 349 +#define _gloffset_ConvolutionParameterf 350 +#define _gloffset_ConvolutionParameterfv 351 +#define _gloffset_ConvolutionParameteri 352 +#define _gloffset_ConvolutionParameteriv 353 +#define _gloffset_CopyConvolutionFilter1D 354 +#define _gloffset_CopyConvolutionFilter2D 355 +#define _gloffset_GetConvolutionFilter 356 +#define _gloffset_GetConvolutionParameterfv 357 +#define _gloffset_GetConvolutionParameteriv 358 +#define _gloffset_GetSeparableFilter 359 +#define _gloffset_SeparableFilter2D 360 +#define _gloffset_GetHistogram 361 +#define _gloffset_GetHistogramParameterfv 362 +#define _gloffset_GetHistogramParameteriv 363 +#define _gloffset_GetMinmax 364 +#define _gloffset_GetMinmaxParameterfv 365 +#define _gloffset_GetMinmaxParameteriv 366 +#define _gloffset_Histogram 367 +#define _gloffset_Minmax 368 +#define _gloffset_ResetHistogram 369 +#define _gloffset_ResetMinmax 370 +#define _gloffset_TexImage3DOES 371 +#define _gloffset_TexSubImage3DOES 372 +#define _gloffset_CopyTexSubImage3DOES 373 +#define _gloffset_ActiveTexture 374 +#define _gloffset_ClientActiveTextureARB 375 +#define _gloffset_MultiTexCoord1dARB 376 +#define _gloffset_MultiTexCoord1dvARB 377 +#define _gloffset_MultiTexCoord1fARB 378 +#define _gloffset_MultiTexCoord1fvARB 379 +#define _gloffset_MultiTexCoord1iARB 380 +#define _gloffset_MultiTexCoord1ivARB 381 +#define _gloffset_MultiTexCoord1sARB 382 +#define _gloffset_MultiTexCoord1svARB 383 +#define _gloffset_MultiTexCoord2dARB 384 +#define _gloffset_MultiTexCoord2dvARB 385 +#define _gloffset_MultiTexCoord2fARB 386 +#define _gloffset_MultiTexCoord2fvARB 387 +#define _gloffset_MultiTexCoord2iARB 388 +#define _gloffset_MultiTexCoord2ivARB 389 +#define _gloffset_MultiTexCoord2sARB 390 +#define _gloffset_MultiTexCoord2svARB 391 +#define _gloffset_MultiTexCoord3dARB 392 +#define _gloffset_MultiTexCoord3dvARB 393 +#define _gloffset_MultiTexCoord3fARB 394 +#define _gloffset_MultiTexCoord3fvARB 395 +#define _gloffset_MultiTexCoord3iARB 396 +#define _gloffset_MultiTexCoord3ivARB 397 +#define _gloffset_MultiTexCoord3sARB 398 +#define _gloffset_MultiTexCoord3svARB 399 +#define _gloffset_MultiTexCoord4dARB 400 +#define _gloffset_MultiTexCoord4dvARB 401 +#define _gloffset_MultiTexCoord4fARB 402 +#define _gloffset_MultiTexCoord4fvARB 403 +#define _gloffset_MultiTexCoord4iARB 404 +#define _gloffset_MultiTexCoord4ivARB 405 +#define _gloffset_MultiTexCoord4sARB 406 +#define _gloffset_MultiTexCoord4svARB 407 + +#if !defined(_GLAPI_USE_REMAP_TABLE) + +#define _gloffset_GetBufferPointervOES 408 +#define _gloffset_MapBufferOES 409 +#define _gloffset_UnmapBufferOES 410 +#define _gloffset_CompressedTexImage3DOES 411 +#define _gloffset_CompressedTexSubImage3DOES 412 +#define _gloffset_FramebufferTexture3DOES 413 +#define _gloffset_GetProgramBinaryOES 414 +#define _gloffset_ProgramBinaryOES 415 +#define _gloffset_MultiDrawArraysEXT 416 +#define _gloffset_MultiDrawElementsEXT 417 +#define _gloffset_BindVertexArrayAPPLE 418 +#define _gloffset_DeleteVertexArraysAPPLE 419 +#define _gloffset_GenVertexArraysAPPLE 420 +#define _gloffset_IsVertexArrayAPPLE 421 +#define _gloffset_EGLImageTargetRenderbufferStorageOES 422 +#define _gloffset_EGLImageTargetTexture2DOES 423 +#define _gloffset_CompressedTexImage2D 424 +#define _gloffset_CompressedTexSubImage2D 425 +#define _gloffset_SampleCoverage 426 +#define _gloffset_BindBuffer 427 +#define _gloffset_BufferData 428 +#define _gloffset_BufferSubData 429 +#define _gloffset_DeleteBuffers 430 +#define _gloffset_GenBuffers 431 +#define _gloffset_GetBufferParameteriv 432 +#define _gloffset_IsBuffer 433 +#define _gloffset_AttachShader 434 +#define _gloffset_BindAttribLocation 435 +#define _gloffset_BlendEquationSeparate 436 +#define _gloffset_CompileShader 437 +#define _gloffset_CreateProgram 438 +#define _gloffset_CreateShader 439 +#define _gloffset_DeleteProgram 440 +#define _gloffset_DeleteShader 441 +#define _gloffset_DetachShader 442 +#define _gloffset_DisableVertexAttribArray 443 +#define _gloffset_EnableVertexAttribArray 444 +#define _gloffset_GetActiveAttrib 445 +#define _gloffset_GetActiveUniform 446 +#define _gloffset_GetAttachedShaders 447 +#define _gloffset_GetAttribLocation 448 +#define _gloffset_GetProgramInfoLog 449 +#define _gloffset_GetProgramiv 450 +#define _gloffset_GetShaderInfoLog 451 +#define _gloffset_GetShaderSource 452 +#define _gloffset_GetShaderiv 453 +#define _gloffset_GetUniformLocation 454 +#define _gloffset_GetUniformfv 455 +#define _gloffset_GetUniformiv 456 +#define _gloffset_GetVertexAttribPointerv 457 +#define _gloffset_GetVertexAttribfv 458 +#define _gloffset_GetVertexAttribiv 459 +#define _gloffset_IsProgram 460 +#define _gloffset_IsShader 461 +#define _gloffset_LinkProgram 462 +#define _gloffset_ShaderSource 463 +#define _gloffset_StencilFuncSeparate 464 +#define _gloffset_StencilMaskSeparate 465 +#define _gloffset_StencilOpSeparate 466 +#define _gloffset_Uniform1f 467 +#define _gloffset_Uniform1fv 468 +#define _gloffset_Uniform1i 469 +#define _gloffset_Uniform1iv 470 +#define _gloffset_Uniform2f 471 +#define _gloffset_Uniform2fv 472 +#define _gloffset_Uniform2i 473 +#define _gloffset_Uniform2iv 474 +#define _gloffset_Uniform3f 475 +#define _gloffset_Uniform3fv 476 +#define _gloffset_Uniform3i 477 +#define _gloffset_Uniform3iv 478 +#define _gloffset_Uniform4f 479 +#define _gloffset_Uniform4fv 480 +#define _gloffset_Uniform4i 481 +#define _gloffset_Uniform4iv 482 +#define _gloffset_UniformMatrix2fv 483 +#define _gloffset_UniformMatrix3fv 484 +#define _gloffset_UniformMatrix4fv 485 +#define _gloffset_UseProgram 486 +#define _gloffset_ValidateProgram 487 +#define _gloffset_VertexAttrib1f 488 +#define _gloffset_VertexAttrib1fv 489 +#define _gloffset_VertexAttrib2f 490 +#define _gloffset_VertexAttrib2fv 491 +#define _gloffset_VertexAttrib3f 492 +#define _gloffset_VertexAttrib3fv 493 +#define _gloffset_VertexAttrib4f 494 +#define _gloffset_VertexAttrib4fv 495 +#define _gloffset_VertexAttribPointer 496 +#define _gloffset_BlendFuncSeparate 497 +#define _gloffset_BindFramebuffer 498 +#define _gloffset_BindRenderbuffer 499 +#define _gloffset_CheckFramebufferStatus 500 +#define _gloffset_ClearDepthf 501 +#define _gloffset_DeleteFramebuffers 502 +#define _gloffset_DeleteRenderbuffers 503 +#define _gloffset_DepthRangef 504 +#define _gloffset_FramebufferRenderbuffer 505 +#define _gloffset_FramebufferTexture2D 506 +#define _gloffset_GenFramebuffers 507 +#define _gloffset_GenRenderbuffers 508 +#define _gloffset_GenerateMipmap 509 +#define _gloffset_GetFramebufferAttachmentParameteriv 510 +#define _gloffset_GetRenderbufferParameteriv 511 +#define _gloffset_GetShaderPrecisionFormat 512 +#define _gloffset_IsFramebuffer 513 +#define _gloffset_IsRenderbuffer 514 +#define _gloffset_ReleaseShaderCompiler 515 +#define _gloffset_RenderbufferStorage 516 +#define _gloffset_ShaderBinary 517 + +#else /* !_GLAPI_USE_REMAP_TABLE */ + +#define driDispatchRemapTable_size 110 +extern int driDispatchRemapTable[ driDispatchRemapTable_size ]; + +#define GetBufferPointervOES_remap_index 0 +#define MapBufferOES_remap_index 1 +#define UnmapBufferOES_remap_index 2 +#define CompressedTexImage3DOES_remap_index 3 +#define CompressedTexSubImage3DOES_remap_index 4 +#define FramebufferTexture3DOES_remap_index 5 +#define GetProgramBinaryOES_remap_index 6 +#define ProgramBinaryOES_remap_index 7 +#define MultiDrawArraysEXT_remap_index 8 +#define MultiDrawElementsEXT_remap_index 9 +#define BindVertexArrayAPPLE_remap_index 10 +#define DeleteVertexArraysAPPLE_remap_index 11 +#define GenVertexArraysAPPLE_remap_index 12 +#define IsVertexArrayAPPLE_remap_index 13 +#define EGLImageTargetRenderbufferStorageOES_remap_index 14 +#define EGLImageTargetTexture2DOES_remap_index 15 +#define CompressedTexImage2D_remap_index 16 +#define CompressedTexSubImage2D_remap_index 17 +#define SampleCoverage_remap_index 18 +#define BindBuffer_remap_index 19 +#define BufferData_remap_index 20 +#define BufferSubData_remap_index 21 +#define DeleteBuffers_remap_index 22 +#define GenBuffers_remap_index 23 +#define GetBufferParameteriv_remap_index 24 +#define IsBuffer_remap_index 25 +#define AttachShader_remap_index 26 +#define BindAttribLocation_remap_index 27 +#define BlendEquationSeparate_remap_index 28 +#define CompileShader_remap_index 29 +#define CreateProgram_remap_index 30 +#define CreateShader_remap_index 31 +#define DeleteProgram_remap_index 32 +#define DeleteShader_remap_index 33 +#define DetachShader_remap_index 34 +#define DisableVertexAttribArray_remap_index 35 +#define EnableVertexAttribArray_remap_index 36 +#define GetActiveAttrib_remap_index 37 +#define GetActiveUniform_remap_index 38 +#define GetAttachedShaders_remap_index 39 +#define GetAttribLocation_remap_index 40 +#define GetProgramInfoLog_remap_index 41 +#define GetProgramiv_remap_index 42 +#define GetShaderInfoLog_remap_index 43 +#define GetShaderSource_remap_index 44 +#define GetShaderiv_remap_index 45 +#define GetUniformLocation_remap_index 46 +#define GetUniformfv_remap_index 47 +#define GetUniformiv_remap_index 48 +#define GetVertexAttribPointerv_remap_index 49 +#define GetVertexAttribfv_remap_index 50 +#define GetVertexAttribiv_remap_index 51 +#define IsProgram_remap_index 52 +#define IsShader_remap_index 53 +#define LinkProgram_remap_index 54 +#define ShaderSource_remap_index 55 +#define StencilFuncSeparate_remap_index 56 +#define StencilMaskSeparate_remap_index 57 +#define StencilOpSeparate_remap_index 58 +#define Uniform1f_remap_index 59 +#define Uniform1fv_remap_index 60 +#define Uniform1i_remap_index 61 +#define Uniform1iv_remap_index 62 +#define Uniform2f_remap_index 63 +#define Uniform2fv_remap_index 64 +#define Uniform2i_remap_index 65 +#define Uniform2iv_remap_index 66 +#define Uniform3f_remap_index 67 +#define Uniform3fv_remap_index 68 +#define Uniform3i_remap_index 69 +#define Uniform3iv_remap_index 70 +#define Uniform4f_remap_index 71 +#define Uniform4fv_remap_index 72 +#define Uniform4i_remap_index 73 +#define Uniform4iv_remap_index 74 +#define UniformMatrix2fv_remap_index 75 +#define UniformMatrix3fv_remap_index 76 +#define UniformMatrix4fv_remap_index 77 +#define UseProgram_remap_index 78 +#define ValidateProgram_remap_index 79 +#define VertexAttrib1f_remap_index 80 +#define VertexAttrib1fv_remap_index 81 +#define VertexAttrib2f_remap_index 82 +#define VertexAttrib2fv_remap_index 83 +#define VertexAttrib3f_remap_index 84 +#define VertexAttrib3fv_remap_index 85 +#define VertexAttrib4f_remap_index 86 +#define VertexAttrib4fv_remap_index 87 +#define VertexAttribPointer_remap_index 88 +#define BlendFuncSeparate_remap_index 89 +#define BindFramebuffer_remap_index 90 +#define BindRenderbuffer_remap_index 91 +#define CheckFramebufferStatus_remap_index 92 +#define ClearDepthf_remap_index 93 +#define DeleteFramebuffers_remap_index 94 +#define DeleteRenderbuffers_remap_index 95 +#define DepthRangef_remap_index 96 +#define FramebufferRenderbuffer_remap_index 97 +#define FramebufferTexture2D_remap_index 98 +#define GenFramebuffers_remap_index 99 +#define GenRenderbuffers_remap_index 100 +#define GenerateMipmap_remap_index 101 +#define GetFramebufferAttachmentParameteriv_remap_index 102 +#define GetRenderbufferParameteriv_remap_index 103 +#define GetShaderPrecisionFormat_remap_index 104 +#define IsFramebuffer_remap_index 105 +#define IsRenderbuffer_remap_index 106 +#define ReleaseShaderCompiler_remap_index 107 +#define RenderbufferStorage_remap_index 108 +#define ShaderBinary_remap_index 109 + +#define _gloffset_GetBufferPointervOES driDispatchRemapTable[GetBufferPointervOES_remap_index] +#define _gloffset_MapBufferOES driDispatchRemapTable[MapBufferOES_remap_index] +#define _gloffset_UnmapBufferOES driDispatchRemapTable[UnmapBufferOES_remap_index] +#define _gloffset_CompressedTexImage3DOES driDispatchRemapTable[CompressedTexImage3DOES_remap_index] +#define _gloffset_CompressedTexSubImage3DOES driDispatchRemapTable[CompressedTexSubImage3DOES_remap_index] +#define _gloffset_FramebufferTexture3DOES driDispatchRemapTable[FramebufferTexture3DOES_remap_index] +#define _gloffset_GetProgramBinaryOES driDispatchRemapTable[GetProgramBinaryOES_remap_index] +#define _gloffset_ProgramBinaryOES driDispatchRemapTable[ProgramBinaryOES_remap_index] +#define _gloffset_MultiDrawArraysEXT driDispatchRemapTable[MultiDrawArraysEXT_remap_index] +#define _gloffset_MultiDrawElementsEXT driDispatchRemapTable[MultiDrawElementsEXT_remap_index] +#define _gloffset_BindVertexArrayAPPLE driDispatchRemapTable[BindVertexArrayAPPLE_remap_index] +#define _gloffset_DeleteVertexArraysAPPLE driDispatchRemapTable[DeleteVertexArraysAPPLE_remap_index] +#define _gloffset_GenVertexArraysAPPLE driDispatchRemapTable[GenVertexArraysAPPLE_remap_index] +#define _gloffset_IsVertexArrayAPPLE driDispatchRemapTable[IsVertexArrayAPPLE_remap_index] +#define _gloffset_EGLImageTargetRenderbufferStorageOES driDispatchRemapTable[EGLImageTargetRenderbufferStorageOES_remap_index] +#define _gloffset_EGLImageTargetTexture2DOES driDispatchRemapTable[EGLImageTargetTexture2DOES_remap_index] +#define _gloffset_CompressedTexImage2D driDispatchRemapTable[CompressedTexImage2D_remap_index] +#define _gloffset_CompressedTexSubImage2D driDispatchRemapTable[CompressedTexSubImage2D_remap_index] +#define _gloffset_SampleCoverage driDispatchRemapTable[SampleCoverage_remap_index] +#define _gloffset_BindBuffer driDispatchRemapTable[BindBuffer_remap_index] +#define _gloffset_BufferData driDispatchRemapTable[BufferData_remap_index] +#define _gloffset_BufferSubData driDispatchRemapTable[BufferSubData_remap_index] +#define _gloffset_DeleteBuffers driDispatchRemapTable[DeleteBuffers_remap_index] +#define _gloffset_GenBuffers driDispatchRemapTable[GenBuffers_remap_index] +#define _gloffset_GetBufferParameteriv driDispatchRemapTable[GetBufferParameteriv_remap_index] +#define _gloffset_IsBuffer driDispatchRemapTable[IsBuffer_remap_index] +#define _gloffset_AttachShader driDispatchRemapTable[AttachShader_remap_index] +#define _gloffset_BindAttribLocation driDispatchRemapTable[BindAttribLocation_remap_index] +#define _gloffset_BlendEquationSeparate driDispatchRemapTable[BlendEquationSeparate_remap_index] +#define _gloffset_CompileShader driDispatchRemapTable[CompileShader_remap_index] +#define _gloffset_CreateProgram driDispatchRemapTable[CreateProgram_remap_index] +#define _gloffset_CreateShader driDispatchRemapTable[CreateShader_remap_index] +#define _gloffset_DeleteProgram driDispatchRemapTable[DeleteProgram_remap_index] +#define _gloffset_DeleteShader driDispatchRemapTable[DeleteShader_remap_index] +#define _gloffset_DetachShader driDispatchRemapTable[DetachShader_remap_index] +#define _gloffset_DisableVertexAttribArray driDispatchRemapTable[DisableVertexAttribArray_remap_index] +#define _gloffset_EnableVertexAttribArray driDispatchRemapTable[EnableVertexAttribArray_remap_index] +#define _gloffset_GetActiveAttrib driDispatchRemapTable[GetActiveAttrib_remap_index] +#define _gloffset_GetActiveUniform driDispatchRemapTable[GetActiveUniform_remap_index] +#define _gloffset_GetAttachedShaders driDispatchRemapTable[GetAttachedShaders_remap_index] +#define _gloffset_GetAttribLocation driDispatchRemapTable[GetAttribLocation_remap_index] +#define _gloffset_GetProgramInfoLog driDispatchRemapTable[GetProgramInfoLog_remap_index] +#define _gloffset_GetProgramiv driDispatchRemapTable[GetProgramiv_remap_index] +#define _gloffset_GetShaderInfoLog driDispatchRemapTable[GetShaderInfoLog_remap_index] +#define _gloffset_GetShaderSource driDispatchRemapTable[GetShaderSource_remap_index] +#define _gloffset_GetShaderiv driDispatchRemapTable[GetShaderiv_remap_index] +#define _gloffset_GetUniformLocation driDispatchRemapTable[GetUniformLocation_remap_index] +#define _gloffset_GetUniformfv driDispatchRemapTable[GetUniformfv_remap_index] +#define _gloffset_GetUniformiv driDispatchRemapTable[GetUniformiv_remap_index] +#define _gloffset_GetVertexAttribPointerv driDispatchRemapTable[GetVertexAttribPointerv_remap_index] +#define _gloffset_GetVertexAttribfv driDispatchRemapTable[GetVertexAttribfv_remap_index] +#define _gloffset_GetVertexAttribiv driDispatchRemapTable[GetVertexAttribiv_remap_index] +#define _gloffset_IsProgram driDispatchRemapTable[IsProgram_remap_index] +#define _gloffset_IsShader driDispatchRemapTable[IsShader_remap_index] +#define _gloffset_LinkProgram driDispatchRemapTable[LinkProgram_remap_index] +#define _gloffset_ShaderSource driDispatchRemapTable[ShaderSource_remap_index] +#define _gloffset_StencilFuncSeparate driDispatchRemapTable[StencilFuncSeparate_remap_index] +#define _gloffset_StencilMaskSeparate driDispatchRemapTable[StencilMaskSeparate_remap_index] +#define _gloffset_StencilOpSeparate driDispatchRemapTable[StencilOpSeparate_remap_index] +#define _gloffset_Uniform1f driDispatchRemapTable[Uniform1f_remap_index] +#define _gloffset_Uniform1fv driDispatchRemapTable[Uniform1fv_remap_index] +#define _gloffset_Uniform1i driDispatchRemapTable[Uniform1i_remap_index] +#define _gloffset_Uniform1iv driDispatchRemapTable[Uniform1iv_remap_index] +#define _gloffset_Uniform2f driDispatchRemapTable[Uniform2f_remap_index] +#define _gloffset_Uniform2fv driDispatchRemapTable[Uniform2fv_remap_index] +#define _gloffset_Uniform2i driDispatchRemapTable[Uniform2i_remap_index] +#define _gloffset_Uniform2iv driDispatchRemapTable[Uniform2iv_remap_index] +#define _gloffset_Uniform3f driDispatchRemapTable[Uniform3f_remap_index] +#define _gloffset_Uniform3fv driDispatchRemapTable[Uniform3fv_remap_index] +#define _gloffset_Uniform3i driDispatchRemapTable[Uniform3i_remap_index] +#define _gloffset_Uniform3iv driDispatchRemapTable[Uniform3iv_remap_index] +#define _gloffset_Uniform4f driDispatchRemapTable[Uniform4f_remap_index] +#define _gloffset_Uniform4fv driDispatchRemapTable[Uniform4fv_remap_index] +#define _gloffset_Uniform4i driDispatchRemapTable[Uniform4i_remap_index] +#define _gloffset_Uniform4iv driDispatchRemapTable[Uniform4iv_remap_index] +#define _gloffset_UniformMatrix2fv driDispatchRemapTable[UniformMatrix2fv_remap_index] +#define _gloffset_UniformMatrix3fv driDispatchRemapTable[UniformMatrix3fv_remap_index] +#define _gloffset_UniformMatrix4fv driDispatchRemapTable[UniformMatrix4fv_remap_index] +#define _gloffset_UseProgram driDispatchRemapTable[UseProgram_remap_index] +#define _gloffset_ValidateProgram driDispatchRemapTable[ValidateProgram_remap_index] +#define _gloffset_VertexAttrib1f driDispatchRemapTable[VertexAttrib1f_remap_index] +#define _gloffset_VertexAttrib1fv driDispatchRemapTable[VertexAttrib1fv_remap_index] +#define _gloffset_VertexAttrib2f driDispatchRemapTable[VertexAttrib2f_remap_index] +#define _gloffset_VertexAttrib2fv driDispatchRemapTable[VertexAttrib2fv_remap_index] +#define _gloffset_VertexAttrib3f driDispatchRemapTable[VertexAttrib3f_remap_index] +#define _gloffset_VertexAttrib3fv driDispatchRemapTable[VertexAttrib3fv_remap_index] +#define _gloffset_VertexAttrib4f driDispatchRemapTable[VertexAttrib4f_remap_index] +#define _gloffset_VertexAttrib4fv driDispatchRemapTable[VertexAttrib4fv_remap_index] +#define _gloffset_VertexAttribPointer driDispatchRemapTable[VertexAttribPointer_remap_index] +#define _gloffset_BlendFuncSeparate driDispatchRemapTable[BlendFuncSeparate_remap_index] +#define _gloffset_BindFramebuffer driDispatchRemapTable[BindFramebuffer_remap_index] +#define _gloffset_BindRenderbuffer driDispatchRemapTable[BindRenderbuffer_remap_index] +#define _gloffset_CheckFramebufferStatus driDispatchRemapTable[CheckFramebufferStatus_remap_index] +#define _gloffset_ClearDepthf driDispatchRemapTable[ClearDepthf_remap_index] +#define _gloffset_DeleteFramebuffers driDispatchRemapTable[DeleteFramebuffers_remap_index] +#define _gloffset_DeleteRenderbuffers driDispatchRemapTable[DeleteRenderbuffers_remap_index] +#define _gloffset_DepthRangef driDispatchRemapTable[DepthRangef_remap_index] +#define _gloffset_FramebufferRenderbuffer driDispatchRemapTable[FramebufferRenderbuffer_remap_index] +#define _gloffset_FramebufferTexture2D driDispatchRemapTable[FramebufferTexture2D_remap_index] +#define _gloffset_GenFramebuffers driDispatchRemapTable[GenFramebuffers_remap_index] +#define _gloffset_GenRenderbuffers driDispatchRemapTable[GenRenderbuffers_remap_index] +#define _gloffset_GenerateMipmap driDispatchRemapTable[GenerateMipmap_remap_index] +#define _gloffset_GetFramebufferAttachmentParameteriv driDispatchRemapTable[GetFramebufferAttachmentParameteriv_remap_index] +#define _gloffset_GetRenderbufferParameteriv driDispatchRemapTable[GetRenderbufferParameteriv_remap_index] +#define _gloffset_GetShaderPrecisionFormat driDispatchRemapTable[GetShaderPrecisionFormat_remap_index] +#define _gloffset_IsFramebuffer driDispatchRemapTable[IsFramebuffer_remap_index] +#define _gloffset_IsRenderbuffer driDispatchRemapTable[IsRenderbuffer_remap_index] +#define _gloffset_ReleaseShaderCompiler driDispatchRemapTable[ReleaseShaderCompiler_remap_index] +#define _gloffset_RenderbufferStorage driDispatchRemapTable[RenderbufferStorage_remap_index] +#define _gloffset_ShaderBinary driDispatchRemapTable[ShaderBinary_remap_index] + +#endif /* _GLAPI_USE_REMAP_TABLE */ + +#define CALL_NewList(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLuint, GLenum)), _gloffset_NewList, parameters) +#define GET_NewList(disp) GET_by_offset(disp, _gloffset_NewList) +#define SET_NewList(disp, fn) SET_by_offset(disp, _gloffset_NewList, fn) +#define CALL_EndList(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(void)), _gloffset_EndList, parameters) +#define GET_EndList(disp) GET_by_offset(disp, _gloffset_EndList) +#define SET_EndList(disp, fn) SET_by_offset(disp, _gloffset_EndList, fn) +#define CALL_CallList(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLuint)), _gloffset_CallList, parameters) +#define GET_CallList(disp) GET_by_offset(disp, _gloffset_CallList) +#define SET_CallList(disp, fn) SET_by_offset(disp, _gloffset_CallList, fn) +#define CALL_CallLists(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLsizei, GLenum, const GLvoid *)), _gloffset_CallLists, parameters) +#define GET_CallLists(disp) GET_by_offset(disp, _gloffset_CallLists) +#define SET_CallLists(disp, fn) SET_by_offset(disp, _gloffset_CallLists, fn) +#define CALL_DeleteLists(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLuint, GLsizei)), _gloffset_DeleteLists, parameters) +#define GET_DeleteLists(disp) GET_by_offset(disp, _gloffset_DeleteLists) +#define SET_DeleteLists(disp, fn) SET_by_offset(disp, _gloffset_DeleteLists, fn) +#define CALL_GenLists(disp, parameters) CALL_by_offset(disp, (GLuint (GLAPIENTRYP)(GLsizei)), _gloffset_GenLists, parameters) +#define GET_GenLists(disp) GET_by_offset(disp, _gloffset_GenLists) +#define SET_GenLists(disp, fn) SET_by_offset(disp, _gloffset_GenLists, fn) +#define CALL_ListBase(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLuint)), _gloffset_ListBase, parameters) +#define GET_ListBase(disp) GET_by_offset(disp, _gloffset_ListBase) +#define SET_ListBase(disp, fn) SET_by_offset(disp, _gloffset_ListBase, fn) +#define CALL_Begin(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum)), _gloffset_Begin, parameters) +#define GET_Begin(disp) GET_by_offset(disp, _gloffset_Begin) +#define SET_Begin(disp, fn) SET_by_offset(disp, _gloffset_Begin, fn) +#define CALL_Bitmap(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLsizei, GLsizei, GLfloat, GLfloat, GLfloat, GLfloat, const GLubyte *)), _gloffset_Bitmap, parameters) +#define GET_Bitmap(disp) GET_by_offset(disp, _gloffset_Bitmap) +#define SET_Bitmap(disp, fn) SET_by_offset(disp, _gloffset_Bitmap, fn) +#define CALL_Color3b(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLbyte, GLbyte, GLbyte)), _gloffset_Color3b, parameters) +#define GET_Color3b(disp) GET_by_offset(disp, _gloffset_Color3b) +#define SET_Color3b(disp, fn) SET_by_offset(disp, _gloffset_Color3b, fn) +#define CALL_Color3bv(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(const GLbyte *)), _gloffset_Color3bv, parameters) +#define GET_Color3bv(disp) GET_by_offset(disp, _gloffset_Color3bv) +#define SET_Color3bv(disp, fn) SET_by_offset(disp, _gloffset_Color3bv, fn) +#define CALL_Color3d(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLdouble, GLdouble, GLdouble)), _gloffset_Color3d, parameters) +#define GET_Color3d(disp) GET_by_offset(disp, _gloffset_Color3d) +#define SET_Color3d(disp, fn) SET_by_offset(disp, _gloffset_Color3d, fn) +#define CALL_Color3dv(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(const GLdouble *)), _gloffset_Color3dv, parameters) +#define GET_Color3dv(disp) GET_by_offset(disp, _gloffset_Color3dv) +#define SET_Color3dv(disp, fn) SET_by_offset(disp, _gloffset_Color3dv, fn) +#define CALL_Color3f(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLfloat, GLfloat, GLfloat)), _gloffset_Color3f, parameters) +#define GET_Color3f(disp) GET_by_offset(disp, _gloffset_Color3f) +#define SET_Color3f(disp, fn) SET_by_offset(disp, _gloffset_Color3f, fn) +#define CALL_Color3fv(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(const GLfloat *)), _gloffset_Color3fv, parameters) +#define GET_Color3fv(disp) GET_by_offset(disp, _gloffset_Color3fv) +#define SET_Color3fv(disp, fn) SET_by_offset(disp, _gloffset_Color3fv, fn) +#define CALL_Color3i(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLint, GLint, GLint)), _gloffset_Color3i, parameters) +#define GET_Color3i(disp) GET_by_offset(disp, _gloffset_Color3i) +#define SET_Color3i(disp, fn) SET_by_offset(disp, _gloffset_Color3i, fn) +#define CALL_Color3iv(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(const GLint *)), _gloffset_Color3iv, parameters) +#define GET_Color3iv(disp) GET_by_offset(disp, _gloffset_Color3iv) +#define SET_Color3iv(disp, fn) SET_by_offset(disp, _gloffset_Color3iv, fn) +#define CALL_Color3s(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLshort, GLshort, GLshort)), _gloffset_Color3s, parameters) +#define GET_Color3s(disp) GET_by_offset(disp, _gloffset_Color3s) +#define SET_Color3s(disp, fn) SET_by_offset(disp, _gloffset_Color3s, fn) +#define CALL_Color3sv(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(const GLshort *)), _gloffset_Color3sv, parameters) +#define GET_Color3sv(disp) GET_by_offset(disp, _gloffset_Color3sv) +#define SET_Color3sv(disp, fn) SET_by_offset(disp, _gloffset_Color3sv, fn) +#define CALL_Color3ub(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLubyte, GLubyte, GLubyte)), _gloffset_Color3ub, parameters) +#define GET_Color3ub(disp) GET_by_offset(disp, _gloffset_Color3ub) +#define SET_Color3ub(disp, fn) SET_by_offset(disp, _gloffset_Color3ub, fn) +#define CALL_Color3ubv(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(const GLubyte *)), _gloffset_Color3ubv, parameters) +#define GET_Color3ubv(disp) GET_by_offset(disp, _gloffset_Color3ubv) +#define SET_Color3ubv(disp, fn) SET_by_offset(disp, _gloffset_Color3ubv, fn) +#define CALL_Color3ui(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLuint, GLuint, GLuint)), _gloffset_Color3ui, parameters) +#define GET_Color3ui(disp) GET_by_offset(disp, _gloffset_Color3ui) +#define SET_Color3ui(disp, fn) SET_by_offset(disp, _gloffset_Color3ui, fn) +#define CALL_Color3uiv(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(const GLuint *)), _gloffset_Color3uiv, parameters) +#define GET_Color3uiv(disp) GET_by_offset(disp, _gloffset_Color3uiv) +#define SET_Color3uiv(disp, fn) SET_by_offset(disp, _gloffset_Color3uiv, fn) +#define CALL_Color3us(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLushort, GLushort, GLushort)), _gloffset_Color3us, parameters) +#define GET_Color3us(disp) GET_by_offset(disp, _gloffset_Color3us) +#define SET_Color3us(disp, fn) SET_by_offset(disp, _gloffset_Color3us, fn) +#define CALL_Color3usv(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(const GLushort *)), _gloffset_Color3usv, parameters) +#define GET_Color3usv(disp) GET_by_offset(disp, _gloffset_Color3usv) +#define SET_Color3usv(disp, fn) SET_by_offset(disp, _gloffset_Color3usv, fn) +#define CALL_Color4b(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLbyte, GLbyte, GLbyte, GLbyte)), _gloffset_Color4b, parameters) +#define GET_Color4b(disp) GET_by_offset(disp, _gloffset_Color4b) +#define SET_Color4b(disp, fn) SET_by_offset(disp, _gloffset_Color4b, fn) +#define CALL_Color4bv(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(const GLbyte *)), _gloffset_Color4bv, parameters) +#define GET_Color4bv(disp) GET_by_offset(disp, _gloffset_Color4bv) +#define SET_Color4bv(disp, fn) SET_by_offset(disp, _gloffset_Color4bv, fn) +#define CALL_Color4d(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLdouble, GLdouble, GLdouble, GLdouble)), _gloffset_Color4d, parameters) +#define GET_Color4d(disp) GET_by_offset(disp, _gloffset_Color4d) +#define SET_Color4d(disp, fn) SET_by_offset(disp, _gloffset_Color4d, fn) +#define CALL_Color4dv(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(const GLdouble *)), _gloffset_Color4dv, parameters) +#define GET_Color4dv(disp) GET_by_offset(disp, _gloffset_Color4dv) +#define SET_Color4dv(disp, fn) SET_by_offset(disp, _gloffset_Color4dv, fn) +#define CALL_Color4f(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLfloat, GLfloat, GLfloat, GLfloat)), _gloffset_Color4f, parameters) +#define GET_Color4f(disp) GET_by_offset(disp, _gloffset_Color4f) +#define SET_Color4f(disp, fn) SET_by_offset(disp, _gloffset_Color4f, fn) +#define CALL_Color4fv(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(const GLfloat *)), _gloffset_Color4fv, parameters) +#define GET_Color4fv(disp) GET_by_offset(disp, _gloffset_Color4fv) +#define SET_Color4fv(disp, fn) SET_by_offset(disp, _gloffset_Color4fv, fn) +#define CALL_Color4i(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLint, GLint, GLint, GLint)), _gloffset_Color4i, parameters) +#define GET_Color4i(disp) GET_by_offset(disp, _gloffset_Color4i) +#define SET_Color4i(disp, fn) SET_by_offset(disp, _gloffset_Color4i, fn) +#define CALL_Color4iv(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(const GLint *)), _gloffset_Color4iv, parameters) +#define GET_Color4iv(disp) GET_by_offset(disp, _gloffset_Color4iv) +#define SET_Color4iv(disp, fn) SET_by_offset(disp, _gloffset_Color4iv, fn) +#define CALL_Color4s(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLshort, GLshort, GLshort, GLshort)), _gloffset_Color4s, parameters) +#define GET_Color4s(disp) GET_by_offset(disp, _gloffset_Color4s) +#define SET_Color4s(disp, fn) SET_by_offset(disp, _gloffset_Color4s, fn) +#define CALL_Color4sv(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(const GLshort *)), _gloffset_Color4sv, parameters) +#define GET_Color4sv(disp) GET_by_offset(disp, _gloffset_Color4sv) +#define SET_Color4sv(disp, fn) SET_by_offset(disp, _gloffset_Color4sv, fn) +#define CALL_Color4ub(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLubyte, GLubyte, GLubyte, GLubyte)), _gloffset_Color4ub, parameters) +#define GET_Color4ub(disp) GET_by_offset(disp, _gloffset_Color4ub) +#define SET_Color4ub(disp, fn) SET_by_offset(disp, _gloffset_Color4ub, fn) +#define CALL_Color4ubv(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(const GLubyte *)), _gloffset_Color4ubv, parameters) +#define GET_Color4ubv(disp) GET_by_offset(disp, _gloffset_Color4ubv) +#define SET_Color4ubv(disp, fn) SET_by_offset(disp, _gloffset_Color4ubv, fn) +#define CALL_Color4ui(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLuint, GLuint, GLuint, GLuint)), _gloffset_Color4ui, parameters) +#define GET_Color4ui(disp) GET_by_offset(disp, _gloffset_Color4ui) +#define SET_Color4ui(disp, fn) SET_by_offset(disp, _gloffset_Color4ui, fn) +#define CALL_Color4uiv(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(const GLuint *)), _gloffset_Color4uiv, parameters) +#define GET_Color4uiv(disp) GET_by_offset(disp, _gloffset_Color4uiv) +#define SET_Color4uiv(disp, fn) SET_by_offset(disp, _gloffset_Color4uiv, fn) +#define CALL_Color4us(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLushort, GLushort, GLushort, GLushort)), _gloffset_Color4us, parameters) +#define GET_Color4us(disp) GET_by_offset(disp, _gloffset_Color4us) +#define SET_Color4us(disp, fn) SET_by_offset(disp, _gloffset_Color4us, fn) +#define CALL_Color4usv(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(const GLushort *)), _gloffset_Color4usv, parameters) +#define GET_Color4usv(disp) GET_by_offset(disp, _gloffset_Color4usv) +#define SET_Color4usv(disp, fn) SET_by_offset(disp, _gloffset_Color4usv, fn) +#define CALL_EdgeFlag(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLboolean)), _gloffset_EdgeFlag, parameters) +#define GET_EdgeFlag(disp) GET_by_offset(disp, _gloffset_EdgeFlag) +#define SET_EdgeFlag(disp, fn) SET_by_offset(disp, _gloffset_EdgeFlag, fn) +#define CALL_EdgeFlagv(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(const GLboolean *)), _gloffset_EdgeFlagv, parameters) +#define GET_EdgeFlagv(disp) GET_by_offset(disp, _gloffset_EdgeFlagv) +#define SET_EdgeFlagv(disp, fn) SET_by_offset(disp, _gloffset_EdgeFlagv, fn) +#define CALL_End(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(void)), _gloffset_End, parameters) +#define GET_End(disp) GET_by_offset(disp, _gloffset_End) +#define SET_End(disp, fn) SET_by_offset(disp, _gloffset_End, fn) +#define CALL_Indexd(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLdouble)), _gloffset_Indexd, parameters) +#define GET_Indexd(disp) GET_by_offset(disp, _gloffset_Indexd) +#define SET_Indexd(disp, fn) SET_by_offset(disp, _gloffset_Indexd, fn) +#define CALL_Indexdv(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(const GLdouble *)), _gloffset_Indexdv, parameters) +#define GET_Indexdv(disp) GET_by_offset(disp, _gloffset_Indexdv) +#define SET_Indexdv(disp, fn) SET_by_offset(disp, _gloffset_Indexdv, fn) +#define CALL_Indexf(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLfloat)), _gloffset_Indexf, parameters) +#define GET_Indexf(disp) GET_by_offset(disp, _gloffset_Indexf) +#define SET_Indexf(disp, fn) SET_by_offset(disp, _gloffset_Indexf, fn) +#define CALL_Indexfv(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(const GLfloat *)), _gloffset_Indexfv, parameters) +#define GET_Indexfv(disp) GET_by_offset(disp, _gloffset_Indexfv) +#define SET_Indexfv(disp, fn) SET_by_offset(disp, _gloffset_Indexfv, fn) +#define CALL_Indexi(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLint)), _gloffset_Indexi, parameters) +#define GET_Indexi(disp) GET_by_offset(disp, _gloffset_Indexi) +#define SET_Indexi(disp, fn) SET_by_offset(disp, _gloffset_Indexi, fn) +#define CALL_Indexiv(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(const GLint *)), _gloffset_Indexiv, parameters) +#define GET_Indexiv(disp) GET_by_offset(disp, _gloffset_Indexiv) +#define SET_Indexiv(disp, fn) SET_by_offset(disp, _gloffset_Indexiv, fn) +#define CALL_Indexs(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLshort)), _gloffset_Indexs, parameters) +#define GET_Indexs(disp) GET_by_offset(disp, _gloffset_Indexs) +#define SET_Indexs(disp, fn) SET_by_offset(disp, _gloffset_Indexs, fn) +#define CALL_Indexsv(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(const GLshort *)), _gloffset_Indexsv, parameters) +#define GET_Indexsv(disp) GET_by_offset(disp, _gloffset_Indexsv) +#define SET_Indexsv(disp, fn) SET_by_offset(disp, _gloffset_Indexsv, fn) +#define CALL_Normal3b(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLbyte, GLbyte, GLbyte)), _gloffset_Normal3b, parameters) +#define GET_Normal3b(disp) GET_by_offset(disp, _gloffset_Normal3b) +#define SET_Normal3b(disp, fn) SET_by_offset(disp, _gloffset_Normal3b, fn) +#define CALL_Normal3bv(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(const GLbyte *)), _gloffset_Normal3bv, parameters) +#define GET_Normal3bv(disp) GET_by_offset(disp, _gloffset_Normal3bv) +#define SET_Normal3bv(disp, fn) SET_by_offset(disp, _gloffset_Normal3bv, fn) +#define CALL_Normal3d(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLdouble, GLdouble, GLdouble)), _gloffset_Normal3d, parameters) +#define GET_Normal3d(disp) GET_by_offset(disp, _gloffset_Normal3d) +#define SET_Normal3d(disp, fn) SET_by_offset(disp, _gloffset_Normal3d, fn) +#define CALL_Normal3dv(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(const GLdouble *)), _gloffset_Normal3dv, parameters) +#define GET_Normal3dv(disp) GET_by_offset(disp, _gloffset_Normal3dv) +#define SET_Normal3dv(disp, fn) SET_by_offset(disp, _gloffset_Normal3dv, fn) +#define CALL_Normal3f(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLfloat, GLfloat, GLfloat)), _gloffset_Normal3f, parameters) +#define GET_Normal3f(disp) GET_by_offset(disp, _gloffset_Normal3f) +#define SET_Normal3f(disp, fn) SET_by_offset(disp, _gloffset_Normal3f, fn) +#define CALL_Normal3fv(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(const GLfloat *)), _gloffset_Normal3fv, parameters) +#define GET_Normal3fv(disp) GET_by_offset(disp, _gloffset_Normal3fv) +#define SET_Normal3fv(disp, fn) SET_by_offset(disp, _gloffset_Normal3fv, fn) +#define CALL_Normal3i(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLint, GLint, GLint)), _gloffset_Normal3i, parameters) +#define GET_Normal3i(disp) GET_by_offset(disp, _gloffset_Normal3i) +#define SET_Normal3i(disp, fn) SET_by_offset(disp, _gloffset_Normal3i, fn) +#define CALL_Normal3iv(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(const GLint *)), _gloffset_Normal3iv, parameters) +#define GET_Normal3iv(disp) GET_by_offset(disp, _gloffset_Normal3iv) +#define SET_Normal3iv(disp, fn) SET_by_offset(disp, _gloffset_Normal3iv, fn) +#define CALL_Normal3s(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLshort, GLshort, GLshort)), _gloffset_Normal3s, parameters) +#define GET_Normal3s(disp) GET_by_offset(disp, _gloffset_Normal3s) +#define SET_Normal3s(disp, fn) SET_by_offset(disp, _gloffset_Normal3s, fn) +#define CALL_Normal3sv(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(const GLshort *)), _gloffset_Normal3sv, parameters) +#define GET_Normal3sv(disp) GET_by_offset(disp, _gloffset_Normal3sv) +#define SET_Normal3sv(disp, fn) SET_by_offset(disp, _gloffset_Normal3sv, fn) +#define CALL_RasterPos2d(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLdouble, GLdouble)), _gloffset_RasterPos2d, parameters) +#define GET_RasterPos2d(disp) GET_by_offset(disp, _gloffset_RasterPos2d) +#define SET_RasterPos2d(disp, fn) SET_by_offset(disp, _gloffset_RasterPos2d, fn) +#define CALL_RasterPos2dv(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(const GLdouble *)), _gloffset_RasterPos2dv, parameters) +#define GET_RasterPos2dv(disp) GET_by_offset(disp, _gloffset_RasterPos2dv) +#define SET_RasterPos2dv(disp, fn) SET_by_offset(disp, _gloffset_RasterPos2dv, fn) +#define CALL_RasterPos2f(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLfloat, GLfloat)), _gloffset_RasterPos2f, parameters) +#define GET_RasterPos2f(disp) GET_by_offset(disp, _gloffset_RasterPos2f) +#define SET_RasterPos2f(disp, fn) SET_by_offset(disp, _gloffset_RasterPos2f, fn) +#define CALL_RasterPos2fv(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(const GLfloat *)), _gloffset_RasterPos2fv, parameters) +#define GET_RasterPos2fv(disp) GET_by_offset(disp, _gloffset_RasterPos2fv) +#define SET_RasterPos2fv(disp, fn) SET_by_offset(disp, _gloffset_RasterPos2fv, fn) +#define CALL_RasterPos2i(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLint, GLint)), _gloffset_RasterPos2i, parameters) +#define GET_RasterPos2i(disp) GET_by_offset(disp, _gloffset_RasterPos2i) +#define SET_RasterPos2i(disp, fn) SET_by_offset(disp, _gloffset_RasterPos2i, fn) +#define CALL_RasterPos2iv(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(const GLint *)), _gloffset_RasterPos2iv, parameters) +#define GET_RasterPos2iv(disp) GET_by_offset(disp, _gloffset_RasterPos2iv) +#define SET_RasterPos2iv(disp, fn) SET_by_offset(disp, _gloffset_RasterPos2iv, fn) +#define CALL_RasterPos2s(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLshort, GLshort)), _gloffset_RasterPos2s, parameters) +#define GET_RasterPos2s(disp) GET_by_offset(disp, _gloffset_RasterPos2s) +#define SET_RasterPos2s(disp, fn) SET_by_offset(disp, _gloffset_RasterPos2s, fn) +#define CALL_RasterPos2sv(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(const GLshort *)), _gloffset_RasterPos2sv, parameters) +#define GET_RasterPos2sv(disp) GET_by_offset(disp, _gloffset_RasterPos2sv) +#define SET_RasterPos2sv(disp, fn) SET_by_offset(disp, _gloffset_RasterPos2sv, fn) +#define CALL_RasterPos3d(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLdouble, GLdouble, GLdouble)), _gloffset_RasterPos3d, parameters) +#define GET_RasterPos3d(disp) GET_by_offset(disp, _gloffset_RasterPos3d) +#define SET_RasterPos3d(disp, fn) SET_by_offset(disp, _gloffset_RasterPos3d, fn) +#define CALL_RasterPos3dv(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(const GLdouble *)), _gloffset_RasterPos3dv, parameters) +#define GET_RasterPos3dv(disp) GET_by_offset(disp, _gloffset_RasterPos3dv) +#define SET_RasterPos3dv(disp, fn) SET_by_offset(disp, _gloffset_RasterPos3dv, fn) +#define CALL_RasterPos3f(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLfloat, GLfloat, GLfloat)), _gloffset_RasterPos3f, parameters) +#define GET_RasterPos3f(disp) GET_by_offset(disp, _gloffset_RasterPos3f) +#define SET_RasterPos3f(disp, fn) SET_by_offset(disp, _gloffset_RasterPos3f, fn) +#define CALL_RasterPos3fv(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(const GLfloat *)), _gloffset_RasterPos3fv, parameters) +#define GET_RasterPos3fv(disp) GET_by_offset(disp, _gloffset_RasterPos3fv) +#define SET_RasterPos3fv(disp, fn) SET_by_offset(disp, _gloffset_RasterPos3fv, fn) +#define CALL_RasterPos3i(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLint, GLint, GLint)), _gloffset_RasterPos3i, parameters) +#define GET_RasterPos3i(disp) GET_by_offset(disp, _gloffset_RasterPos3i) +#define SET_RasterPos3i(disp, fn) SET_by_offset(disp, _gloffset_RasterPos3i, fn) +#define CALL_RasterPos3iv(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(const GLint *)), _gloffset_RasterPos3iv, parameters) +#define GET_RasterPos3iv(disp) GET_by_offset(disp, _gloffset_RasterPos3iv) +#define SET_RasterPos3iv(disp, fn) SET_by_offset(disp, _gloffset_RasterPos3iv, fn) +#define CALL_RasterPos3s(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLshort, GLshort, GLshort)), _gloffset_RasterPos3s, parameters) +#define GET_RasterPos3s(disp) GET_by_offset(disp, _gloffset_RasterPos3s) +#define SET_RasterPos3s(disp, fn) SET_by_offset(disp, _gloffset_RasterPos3s, fn) +#define CALL_RasterPos3sv(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(const GLshort *)), _gloffset_RasterPos3sv, parameters) +#define GET_RasterPos3sv(disp) GET_by_offset(disp, _gloffset_RasterPos3sv) +#define SET_RasterPos3sv(disp, fn) SET_by_offset(disp, _gloffset_RasterPos3sv, fn) +#define CALL_RasterPos4d(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLdouble, GLdouble, GLdouble, GLdouble)), _gloffset_RasterPos4d, parameters) +#define GET_RasterPos4d(disp) GET_by_offset(disp, _gloffset_RasterPos4d) +#define SET_RasterPos4d(disp, fn) SET_by_offset(disp, _gloffset_RasterPos4d, fn) +#define CALL_RasterPos4dv(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(const GLdouble *)), _gloffset_RasterPos4dv, parameters) +#define GET_RasterPos4dv(disp) GET_by_offset(disp, _gloffset_RasterPos4dv) +#define SET_RasterPos4dv(disp, fn) SET_by_offset(disp, _gloffset_RasterPos4dv, fn) +#define CALL_RasterPos4f(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLfloat, GLfloat, GLfloat, GLfloat)), _gloffset_RasterPos4f, parameters) +#define GET_RasterPos4f(disp) GET_by_offset(disp, _gloffset_RasterPos4f) +#define SET_RasterPos4f(disp, fn) SET_by_offset(disp, _gloffset_RasterPos4f, fn) +#define CALL_RasterPos4fv(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(const GLfloat *)), _gloffset_RasterPos4fv, parameters) +#define GET_RasterPos4fv(disp) GET_by_offset(disp, _gloffset_RasterPos4fv) +#define SET_RasterPos4fv(disp, fn) SET_by_offset(disp, _gloffset_RasterPos4fv, fn) +#define CALL_RasterPos4i(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLint, GLint, GLint, GLint)), _gloffset_RasterPos4i, parameters) +#define GET_RasterPos4i(disp) GET_by_offset(disp, _gloffset_RasterPos4i) +#define SET_RasterPos4i(disp, fn) SET_by_offset(disp, _gloffset_RasterPos4i, fn) +#define CALL_RasterPos4iv(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(const GLint *)), _gloffset_RasterPos4iv, parameters) +#define GET_RasterPos4iv(disp) GET_by_offset(disp, _gloffset_RasterPos4iv) +#define SET_RasterPos4iv(disp, fn) SET_by_offset(disp, _gloffset_RasterPos4iv, fn) +#define CALL_RasterPos4s(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLshort, GLshort, GLshort, GLshort)), _gloffset_RasterPos4s, parameters) +#define GET_RasterPos4s(disp) GET_by_offset(disp, _gloffset_RasterPos4s) +#define SET_RasterPos4s(disp, fn) SET_by_offset(disp, _gloffset_RasterPos4s, fn) +#define CALL_RasterPos4sv(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(const GLshort *)), _gloffset_RasterPos4sv, parameters) +#define GET_RasterPos4sv(disp) GET_by_offset(disp, _gloffset_RasterPos4sv) +#define SET_RasterPos4sv(disp, fn) SET_by_offset(disp, _gloffset_RasterPos4sv, fn) +#define CALL_Rectd(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLdouble, GLdouble, GLdouble, GLdouble)), _gloffset_Rectd, parameters) +#define GET_Rectd(disp) GET_by_offset(disp, _gloffset_Rectd) +#define SET_Rectd(disp, fn) SET_by_offset(disp, _gloffset_Rectd, fn) +#define CALL_Rectdv(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(const GLdouble *, const GLdouble *)), _gloffset_Rectdv, parameters) +#define GET_Rectdv(disp) GET_by_offset(disp, _gloffset_Rectdv) +#define SET_Rectdv(disp, fn) SET_by_offset(disp, _gloffset_Rectdv, fn) +#define CALL_Rectf(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLfloat, GLfloat, GLfloat, GLfloat)), _gloffset_Rectf, parameters) +#define GET_Rectf(disp) GET_by_offset(disp, _gloffset_Rectf) +#define SET_Rectf(disp, fn) SET_by_offset(disp, _gloffset_Rectf, fn) +#define CALL_Rectfv(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(const GLfloat *, const GLfloat *)), _gloffset_Rectfv, parameters) +#define GET_Rectfv(disp) GET_by_offset(disp, _gloffset_Rectfv) +#define SET_Rectfv(disp, fn) SET_by_offset(disp, _gloffset_Rectfv, fn) +#define CALL_Recti(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLint, GLint, GLint, GLint)), _gloffset_Recti, parameters) +#define GET_Recti(disp) GET_by_offset(disp, _gloffset_Recti) +#define SET_Recti(disp, fn) SET_by_offset(disp, _gloffset_Recti, fn) +#define CALL_Rectiv(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(const GLint *, const GLint *)), _gloffset_Rectiv, parameters) +#define GET_Rectiv(disp) GET_by_offset(disp, _gloffset_Rectiv) +#define SET_Rectiv(disp, fn) SET_by_offset(disp, _gloffset_Rectiv, fn) +#define CALL_Rects(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLshort, GLshort, GLshort, GLshort)), _gloffset_Rects, parameters) +#define GET_Rects(disp) GET_by_offset(disp, _gloffset_Rects) +#define SET_Rects(disp, fn) SET_by_offset(disp, _gloffset_Rects, fn) +#define CALL_Rectsv(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(const GLshort *, const GLshort *)), _gloffset_Rectsv, parameters) +#define GET_Rectsv(disp) GET_by_offset(disp, _gloffset_Rectsv) +#define SET_Rectsv(disp, fn) SET_by_offset(disp, _gloffset_Rectsv, fn) +#define CALL_TexCoord1d(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLdouble)), _gloffset_TexCoord1d, parameters) +#define GET_TexCoord1d(disp) GET_by_offset(disp, _gloffset_TexCoord1d) +#define SET_TexCoord1d(disp, fn) SET_by_offset(disp, _gloffset_TexCoord1d, fn) +#define CALL_TexCoord1dv(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(const GLdouble *)), _gloffset_TexCoord1dv, parameters) +#define GET_TexCoord1dv(disp) GET_by_offset(disp, _gloffset_TexCoord1dv) +#define SET_TexCoord1dv(disp, fn) SET_by_offset(disp, _gloffset_TexCoord1dv, fn) +#define CALL_TexCoord1f(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLfloat)), _gloffset_TexCoord1f, parameters) +#define GET_TexCoord1f(disp) GET_by_offset(disp, _gloffset_TexCoord1f) +#define SET_TexCoord1f(disp, fn) SET_by_offset(disp, _gloffset_TexCoord1f, fn) +#define CALL_TexCoord1fv(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(const GLfloat *)), _gloffset_TexCoord1fv, parameters) +#define GET_TexCoord1fv(disp) GET_by_offset(disp, _gloffset_TexCoord1fv) +#define SET_TexCoord1fv(disp, fn) SET_by_offset(disp, _gloffset_TexCoord1fv, fn) +#define CALL_TexCoord1i(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLint)), _gloffset_TexCoord1i, parameters) +#define GET_TexCoord1i(disp) GET_by_offset(disp, _gloffset_TexCoord1i) +#define SET_TexCoord1i(disp, fn) SET_by_offset(disp, _gloffset_TexCoord1i, fn) +#define CALL_TexCoord1iv(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(const GLint *)), _gloffset_TexCoord1iv, parameters) +#define GET_TexCoord1iv(disp) GET_by_offset(disp, _gloffset_TexCoord1iv) +#define SET_TexCoord1iv(disp, fn) SET_by_offset(disp, _gloffset_TexCoord1iv, fn) +#define CALL_TexCoord1s(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLshort)), _gloffset_TexCoord1s, parameters) +#define GET_TexCoord1s(disp) GET_by_offset(disp, _gloffset_TexCoord1s) +#define SET_TexCoord1s(disp, fn) SET_by_offset(disp, _gloffset_TexCoord1s, fn) +#define CALL_TexCoord1sv(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(const GLshort *)), _gloffset_TexCoord1sv, parameters) +#define GET_TexCoord1sv(disp) GET_by_offset(disp, _gloffset_TexCoord1sv) +#define SET_TexCoord1sv(disp, fn) SET_by_offset(disp, _gloffset_TexCoord1sv, fn) +#define CALL_TexCoord2d(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLdouble, GLdouble)), _gloffset_TexCoord2d, parameters) +#define GET_TexCoord2d(disp) GET_by_offset(disp, _gloffset_TexCoord2d) +#define SET_TexCoord2d(disp, fn) SET_by_offset(disp, _gloffset_TexCoord2d, fn) +#define CALL_TexCoord2dv(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(const GLdouble *)), _gloffset_TexCoord2dv, parameters) +#define GET_TexCoord2dv(disp) GET_by_offset(disp, _gloffset_TexCoord2dv) +#define SET_TexCoord2dv(disp, fn) SET_by_offset(disp, _gloffset_TexCoord2dv, fn) +#define CALL_TexCoord2f(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLfloat, GLfloat)), _gloffset_TexCoord2f, parameters) +#define GET_TexCoord2f(disp) GET_by_offset(disp, _gloffset_TexCoord2f) +#define SET_TexCoord2f(disp, fn) SET_by_offset(disp, _gloffset_TexCoord2f, fn) +#define CALL_TexCoord2fv(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(const GLfloat *)), _gloffset_TexCoord2fv, parameters) +#define GET_TexCoord2fv(disp) GET_by_offset(disp, _gloffset_TexCoord2fv) +#define SET_TexCoord2fv(disp, fn) SET_by_offset(disp, _gloffset_TexCoord2fv, fn) +#define CALL_TexCoord2i(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLint, GLint)), _gloffset_TexCoord2i, parameters) +#define GET_TexCoord2i(disp) GET_by_offset(disp, _gloffset_TexCoord2i) +#define SET_TexCoord2i(disp, fn) SET_by_offset(disp, _gloffset_TexCoord2i, fn) +#define CALL_TexCoord2iv(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(const GLint *)), _gloffset_TexCoord2iv, parameters) +#define GET_TexCoord2iv(disp) GET_by_offset(disp, _gloffset_TexCoord2iv) +#define SET_TexCoord2iv(disp, fn) SET_by_offset(disp, _gloffset_TexCoord2iv, fn) +#define CALL_TexCoord2s(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLshort, GLshort)), _gloffset_TexCoord2s, parameters) +#define GET_TexCoord2s(disp) GET_by_offset(disp, _gloffset_TexCoord2s) +#define SET_TexCoord2s(disp, fn) SET_by_offset(disp, _gloffset_TexCoord2s, fn) +#define CALL_TexCoord2sv(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(const GLshort *)), _gloffset_TexCoord2sv, parameters) +#define GET_TexCoord2sv(disp) GET_by_offset(disp, _gloffset_TexCoord2sv) +#define SET_TexCoord2sv(disp, fn) SET_by_offset(disp, _gloffset_TexCoord2sv, fn) +#define CALL_TexCoord3d(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLdouble, GLdouble, GLdouble)), _gloffset_TexCoord3d, parameters) +#define GET_TexCoord3d(disp) GET_by_offset(disp, _gloffset_TexCoord3d) +#define SET_TexCoord3d(disp, fn) SET_by_offset(disp, _gloffset_TexCoord3d, fn) +#define CALL_TexCoord3dv(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(const GLdouble *)), _gloffset_TexCoord3dv, parameters) +#define GET_TexCoord3dv(disp) GET_by_offset(disp, _gloffset_TexCoord3dv) +#define SET_TexCoord3dv(disp, fn) SET_by_offset(disp, _gloffset_TexCoord3dv, fn) +#define CALL_TexCoord3f(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLfloat, GLfloat, GLfloat)), _gloffset_TexCoord3f, parameters) +#define GET_TexCoord3f(disp) GET_by_offset(disp, _gloffset_TexCoord3f) +#define SET_TexCoord3f(disp, fn) SET_by_offset(disp, _gloffset_TexCoord3f, fn) +#define CALL_TexCoord3fv(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(const GLfloat *)), _gloffset_TexCoord3fv, parameters) +#define GET_TexCoord3fv(disp) GET_by_offset(disp, _gloffset_TexCoord3fv) +#define SET_TexCoord3fv(disp, fn) SET_by_offset(disp, _gloffset_TexCoord3fv, fn) +#define CALL_TexCoord3i(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLint, GLint, GLint)), _gloffset_TexCoord3i, parameters) +#define GET_TexCoord3i(disp) GET_by_offset(disp, _gloffset_TexCoord3i) +#define SET_TexCoord3i(disp, fn) SET_by_offset(disp, _gloffset_TexCoord3i, fn) +#define CALL_TexCoord3iv(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(const GLint *)), _gloffset_TexCoord3iv, parameters) +#define GET_TexCoord3iv(disp) GET_by_offset(disp, _gloffset_TexCoord3iv) +#define SET_TexCoord3iv(disp, fn) SET_by_offset(disp, _gloffset_TexCoord3iv, fn) +#define CALL_TexCoord3s(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLshort, GLshort, GLshort)), _gloffset_TexCoord3s, parameters) +#define GET_TexCoord3s(disp) GET_by_offset(disp, _gloffset_TexCoord3s) +#define SET_TexCoord3s(disp, fn) SET_by_offset(disp, _gloffset_TexCoord3s, fn) +#define CALL_TexCoord3sv(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(const GLshort *)), _gloffset_TexCoord3sv, parameters) +#define GET_TexCoord3sv(disp) GET_by_offset(disp, _gloffset_TexCoord3sv) +#define SET_TexCoord3sv(disp, fn) SET_by_offset(disp, _gloffset_TexCoord3sv, fn) +#define CALL_TexCoord4d(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLdouble, GLdouble, GLdouble, GLdouble)), _gloffset_TexCoord4d, parameters) +#define GET_TexCoord4d(disp) GET_by_offset(disp, _gloffset_TexCoord4d) +#define SET_TexCoord4d(disp, fn) SET_by_offset(disp, _gloffset_TexCoord4d, fn) +#define CALL_TexCoord4dv(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(const GLdouble *)), _gloffset_TexCoord4dv, parameters) +#define GET_TexCoord4dv(disp) GET_by_offset(disp, _gloffset_TexCoord4dv) +#define SET_TexCoord4dv(disp, fn) SET_by_offset(disp, _gloffset_TexCoord4dv, fn) +#define CALL_TexCoord4f(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLfloat, GLfloat, GLfloat, GLfloat)), _gloffset_TexCoord4f, parameters) +#define GET_TexCoord4f(disp) GET_by_offset(disp, _gloffset_TexCoord4f) +#define SET_TexCoord4f(disp, fn) SET_by_offset(disp, _gloffset_TexCoord4f, fn) +#define CALL_TexCoord4fv(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(const GLfloat *)), _gloffset_TexCoord4fv, parameters) +#define GET_TexCoord4fv(disp) GET_by_offset(disp, _gloffset_TexCoord4fv) +#define SET_TexCoord4fv(disp, fn) SET_by_offset(disp, _gloffset_TexCoord4fv, fn) +#define CALL_TexCoord4i(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLint, GLint, GLint, GLint)), _gloffset_TexCoord4i, parameters) +#define GET_TexCoord4i(disp) GET_by_offset(disp, _gloffset_TexCoord4i) +#define SET_TexCoord4i(disp, fn) SET_by_offset(disp, _gloffset_TexCoord4i, fn) +#define CALL_TexCoord4iv(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(const GLint *)), _gloffset_TexCoord4iv, parameters) +#define GET_TexCoord4iv(disp) GET_by_offset(disp, _gloffset_TexCoord4iv) +#define SET_TexCoord4iv(disp, fn) SET_by_offset(disp, _gloffset_TexCoord4iv, fn) +#define CALL_TexCoord4s(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLshort, GLshort, GLshort, GLshort)), _gloffset_TexCoord4s, parameters) +#define GET_TexCoord4s(disp) GET_by_offset(disp, _gloffset_TexCoord4s) +#define SET_TexCoord4s(disp, fn) SET_by_offset(disp, _gloffset_TexCoord4s, fn) +#define CALL_TexCoord4sv(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(const GLshort *)), _gloffset_TexCoord4sv, parameters) +#define GET_TexCoord4sv(disp) GET_by_offset(disp, _gloffset_TexCoord4sv) +#define SET_TexCoord4sv(disp, fn) SET_by_offset(disp, _gloffset_TexCoord4sv, fn) +#define CALL_Vertex2d(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLdouble, GLdouble)), _gloffset_Vertex2d, parameters) +#define GET_Vertex2d(disp) GET_by_offset(disp, _gloffset_Vertex2d) +#define SET_Vertex2d(disp, fn) SET_by_offset(disp, _gloffset_Vertex2d, fn) +#define CALL_Vertex2dv(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(const GLdouble *)), _gloffset_Vertex2dv, parameters) +#define GET_Vertex2dv(disp) GET_by_offset(disp, _gloffset_Vertex2dv) +#define SET_Vertex2dv(disp, fn) SET_by_offset(disp, _gloffset_Vertex2dv, fn) +#define CALL_Vertex2f(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLfloat, GLfloat)), _gloffset_Vertex2f, parameters) +#define GET_Vertex2f(disp) GET_by_offset(disp, _gloffset_Vertex2f) +#define SET_Vertex2f(disp, fn) SET_by_offset(disp, _gloffset_Vertex2f, fn) +#define CALL_Vertex2fv(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(const GLfloat *)), _gloffset_Vertex2fv, parameters) +#define GET_Vertex2fv(disp) GET_by_offset(disp, _gloffset_Vertex2fv) +#define SET_Vertex2fv(disp, fn) SET_by_offset(disp, _gloffset_Vertex2fv, fn) +#define CALL_Vertex2i(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLint, GLint)), _gloffset_Vertex2i, parameters) +#define GET_Vertex2i(disp) GET_by_offset(disp, _gloffset_Vertex2i) +#define SET_Vertex2i(disp, fn) SET_by_offset(disp, _gloffset_Vertex2i, fn) +#define CALL_Vertex2iv(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(const GLint *)), _gloffset_Vertex2iv, parameters) +#define GET_Vertex2iv(disp) GET_by_offset(disp, _gloffset_Vertex2iv) +#define SET_Vertex2iv(disp, fn) SET_by_offset(disp, _gloffset_Vertex2iv, fn) +#define CALL_Vertex2s(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLshort, GLshort)), _gloffset_Vertex2s, parameters) +#define GET_Vertex2s(disp) GET_by_offset(disp, _gloffset_Vertex2s) +#define SET_Vertex2s(disp, fn) SET_by_offset(disp, _gloffset_Vertex2s, fn) +#define CALL_Vertex2sv(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(const GLshort *)), _gloffset_Vertex2sv, parameters) +#define GET_Vertex2sv(disp) GET_by_offset(disp, _gloffset_Vertex2sv) +#define SET_Vertex2sv(disp, fn) SET_by_offset(disp, _gloffset_Vertex2sv, fn) +#define CALL_Vertex3d(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLdouble, GLdouble, GLdouble)), _gloffset_Vertex3d, parameters) +#define GET_Vertex3d(disp) GET_by_offset(disp, _gloffset_Vertex3d) +#define SET_Vertex3d(disp, fn) SET_by_offset(disp, _gloffset_Vertex3d, fn) +#define CALL_Vertex3dv(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(const GLdouble *)), _gloffset_Vertex3dv, parameters) +#define GET_Vertex3dv(disp) GET_by_offset(disp, _gloffset_Vertex3dv) +#define SET_Vertex3dv(disp, fn) SET_by_offset(disp, _gloffset_Vertex3dv, fn) +#define CALL_Vertex3f(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLfloat, GLfloat, GLfloat)), _gloffset_Vertex3f, parameters) +#define GET_Vertex3f(disp) GET_by_offset(disp, _gloffset_Vertex3f) +#define SET_Vertex3f(disp, fn) SET_by_offset(disp, _gloffset_Vertex3f, fn) +#define CALL_Vertex3fv(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(const GLfloat *)), _gloffset_Vertex3fv, parameters) +#define GET_Vertex3fv(disp) GET_by_offset(disp, _gloffset_Vertex3fv) +#define SET_Vertex3fv(disp, fn) SET_by_offset(disp, _gloffset_Vertex3fv, fn) +#define CALL_Vertex3i(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLint, GLint, GLint)), _gloffset_Vertex3i, parameters) +#define GET_Vertex3i(disp) GET_by_offset(disp, _gloffset_Vertex3i) +#define SET_Vertex3i(disp, fn) SET_by_offset(disp, _gloffset_Vertex3i, fn) +#define CALL_Vertex3iv(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(const GLint *)), _gloffset_Vertex3iv, parameters) +#define GET_Vertex3iv(disp) GET_by_offset(disp, _gloffset_Vertex3iv) +#define SET_Vertex3iv(disp, fn) SET_by_offset(disp, _gloffset_Vertex3iv, fn) +#define CALL_Vertex3s(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLshort, GLshort, GLshort)), _gloffset_Vertex3s, parameters) +#define GET_Vertex3s(disp) GET_by_offset(disp, _gloffset_Vertex3s) +#define SET_Vertex3s(disp, fn) SET_by_offset(disp, _gloffset_Vertex3s, fn) +#define CALL_Vertex3sv(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(const GLshort *)), _gloffset_Vertex3sv, parameters) +#define GET_Vertex3sv(disp) GET_by_offset(disp, _gloffset_Vertex3sv) +#define SET_Vertex3sv(disp, fn) SET_by_offset(disp, _gloffset_Vertex3sv, fn) +#define CALL_Vertex4d(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLdouble, GLdouble, GLdouble, GLdouble)), _gloffset_Vertex4d, parameters) +#define GET_Vertex4d(disp) GET_by_offset(disp, _gloffset_Vertex4d) +#define SET_Vertex4d(disp, fn) SET_by_offset(disp, _gloffset_Vertex4d, fn) +#define CALL_Vertex4dv(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(const GLdouble *)), _gloffset_Vertex4dv, parameters) +#define GET_Vertex4dv(disp) GET_by_offset(disp, _gloffset_Vertex4dv) +#define SET_Vertex4dv(disp, fn) SET_by_offset(disp, _gloffset_Vertex4dv, fn) +#define CALL_Vertex4f(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLfloat, GLfloat, GLfloat, GLfloat)), _gloffset_Vertex4f, parameters) +#define GET_Vertex4f(disp) GET_by_offset(disp, _gloffset_Vertex4f) +#define SET_Vertex4f(disp, fn) SET_by_offset(disp, _gloffset_Vertex4f, fn) +#define CALL_Vertex4fv(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(const GLfloat *)), _gloffset_Vertex4fv, parameters) +#define GET_Vertex4fv(disp) GET_by_offset(disp, _gloffset_Vertex4fv) +#define SET_Vertex4fv(disp, fn) SET_by_offset(disp, _gloffset_Vertex4fv, fn) +#define CALL_Vertex4i(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLint, GLint, GLint, GLint)), _gloffset_Vertex4i, parameters) +#define GET_Vertex4i(disp) GET_by_offset(disp, _gloffset_Vertex4i) +#define SET_Vertex4i(disp, fn) SET_by_offset(disp, _gloffset_Vertex4i, fn) +#define CALL_Vertex4iv(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(const GLint *)), _gloffset_Vertex4iv, parameters) +#define GET_Vertex4iv(disp) GET_by_offset(disp, _gloffset_Vertex4iv) +#define SET_Vertex4iv(disp, fn) SET_by_offset(disp, _gloffset_Vertex4iv, fn) +#define CALL_Vertex4s(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLshort, GLshort, GLshort, GLshort)), _gloffset_Vertex4s, parameters) +#define GET_Vertex4s(disp) GET_by_offset(disp, _gloffset_Vertex4s) +#define SET_Vertex4s(disp, fn) SET_by_offset(disp, _gloffset_Vertex4s, fn) +#define CALL_Vertex4sv(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(const GLshort *)), _gloffset_Vertex4sv, parameters) +#define GET_Vertex4sv(disp) GET_by_offset(disp, _gloffset_Vertex4sv) +#define SET_Vertex4sv(disp, fn) SET_by_offset(disp, _gloffset_Vertex4sv, fn) +#define CALL_ClipPlane(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, const GLdouble *)), _gloffset_ClipPlane, parameters) +#define GET_ClipPlane(disp) GET_by_offset(disp, _gloffset_ClipPlane) +#define SET_ClipPlane(disp, fn) SET_by_offset(disp, _gloffset_ClipPlane, fn) +#define CALL_ColorMaterial(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLenum)), _gloffset_ColorMaterial, parameters) +#define GET_ColorMaterial(disp) GET_by_offset(disp, _gloffset_ColorMaterial) +#define SET_ColorMaterial(disp, fn) SET_by_offset(disp, _gloffset_ColorMaterial, fn) +#define CALL_CullFace(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum)), _gloffset_CullFace, parameters) +#define GET_CullFace(disp) GET_by_offset(disp, _gloffset_CullFace) +#define SET_CullFace(disp, fn) SET_by_offset(disp, _gloffset_CullFace, fn) +#define CALL_Fogf(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLfloat)), _gloffset_Fogf, parameters) +#define GET_Fogf(disp) GET_by_offset(disp, _gloffset_Fogf) +#define SET_Fogf(disp, fn) SET_by_offset(disp, _gloffset_Fogf, fn) +#define CALL_Fogfv(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, const GLfloat *)), _gloffset_Fogfv, parameters) +#define GET_Fogfv(disp) GET_by_offset(disp, _gloffset_Fogfv) +#define SET_Fogfv(disp, fn) SET_by_offset(disp, _gloffset_Fogfv, fn) +#define CALL_Fogi(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLint)), _gloffset_Fogi, parameters) +#define GET_Fogi(disp) GET_by_offset(disp, _gloffset_Fogi) +#define SET_Fogi(disp, fn) SET_by_offset(disp, _gloffset_Fogi, fn) +#define CALL_Fogiv(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, const GLint *)), _gloffset_Fogiv, parameters) +#define GET_Fogiv(disp) GET_by_offset(disp, _gloffset_Fogiv) +#define SET_Fogiv(disp, fn) SET_by_offset(disp, _gloffset_Fogiv, fn) +#define CALL_FrontFace(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum)), _gloffset_FrontFace, parameters) +#define GET_FrontFace(disp) GET_by_offset(disp, _gloffset_FrontFace) +#define SET_FrontFace(disp, fn) SET_by_offset(disp, _gloffset_FrontFace, fn) +#define CALL_Hint(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLenum)), _gloffset_Hint, parameters) +#define GET_Hint(disp) GET_by_offset(disp, _gloffset_Hint) +#define SET_Hint(disp, fn) SET_by_offset(disp, _gloffset_Hint, fn) +#define CALL_Lightf(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLenum, GLfloat)), _gloffset_Lightf, parameters) +#define GET_Lightf(disp) GET_by_offset(disp, _gloffset_Lightf) +#define SET_Lightf(disp, fn) SET_by_offset(disp, _gloffset_Lightf, fn) +#define CALL_Lightfv(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLenum, const GLfloat *)), _gloffset_Lightfv, parameters) +#define GET_Lightfv(disp) GET_by_offset(disp, _gloffset_Lightfv) +#define SET_Lightfv(disp, fn) SET_by_offset(disp, _gloffset_Lightfv, fn) +#define CALL_Lighti(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLenum, GLint)), _gloffset_Lighti, parameters) +#define GET_Lighti(disp) GET_by_offset(disp, _gloffset_Lighti) +#define SET_Lighti(disp, fn) SET_by_offset(disp, _gloffset_Lighti, fn) +#define CALL_Lightiv(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLenum, const GLint *)), _gloffset_Lightiv, parameters) +#define GET_Lightiv(disp) GET_by_offset(disp, _gloffset_Lightiv) +#define SET_Lightiv(disp, fn) SET_by_offset(disp, _gloffset_Lightiv, fn) +#define CALL_LightModelf(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLfloat)), _gloffset_LightModelf, parameters) +#define GET_LightModelf(disp) GET_by_offset(disp, _gloffset_LightModelf) +#define SET_LightModelf(disp, fn) SET_by_offset(disp, _gloffset_LightModelf, fn) +#define CALL_LightModelfv(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, const GLfloat *)), _gloffset_LightModelfv, parameters) +#define GET_LightModelfv(disp) GET_by_offset(disp, _gloffset_LightModelfv) +#define SET_LightModelfv(disp, fn) SET_by_offset(disp, _gloffset_LightModelfv, fn) +#define CALL_LightModeli(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLint)), _gloffset_LightModeli, parameters) +#define GET_LightModeli(disp) GET_by_offset(disp, _gloffset_LightModeli) +#define SET_LightModeli(disp, fn) SET_by_offset(disp, _gloffset_LightModeli, fn) +#define CALL_LightModeliv(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, const GLint *)), _gloffset_LightModeliv, parameters) +#define GET_LightModeliv(disp) GET_by_offset(disp, _gloffset_LightModeliv) +#define SET_LightModeliv(disp, fn) SET_by_offset(disp, _gloffset_LightModeliv, fn) +#define CALL_LineStipple(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLint, GLushort)), _gloffset_LineStipple, parameters) +#define GET_LineStipple(disp) GET_by_offset(disp, _gloffset_LineStipple) +#define SET_LineStipple(disp, fn) SET_by_offset(disp, _gloffset_LineStipple, fn) +#define CALL_LineWidth(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLfloat)), _gloffset_LineWidth, parameters) +#define GET_LineWidth(disp) GET_by_offset(disp, _gloffset_LineWidth) +#define SET_LineWidth(disp, fn) SET_by_offset(disp, _gloffset_LineWidth, fn) +#define CALL_Materialf(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLenum, GLfloat)), _gloffset_Materialf, parameters) +#define GET_Materialf(disp) GET_by_offset(disp, _gloffset_Materialf) +#define SET_Materialf(disp, fn) SET_by_offset(disp, _gloffset_Materialf, fn) +#define CALL_Materialfv(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLenum, const GLfloat *)), _gloffset_Materialfv, parameters) +#define GET_Materialfv(disp) GET_by_offset(disp, _gloffset_Materialfv) +#define SET_Materialfv(disp, fn) SET_by_offset(disp, _gloffset_Materialfv, fn) +#define CALL_Materiali(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLenum, GLint)), _gloffset_Materiali, parameters) +#define GET_Materiali(disp) GET_by_offset(disp, _gloffset_Materiali) +#define SET_Materiali(disp, fn) SET_by_offset(disp, _gloffset_Materiali, fn) +#define CALL_Materialiv(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLenum, const GLint *)), _gloffset_Materialiv, parameters) +#define GET_Materialiv(disp) GET_by_offset(disp, _gloffset_Materialiv) +#define SET_Materialiv(disp, fn) SET_by_offset(disp, _gloffset_Materialiv, fn) +#define CALL_PointSize(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLfloat)), _gloffset_PointSize, parameters) +#define GET_PointSize(disp) GET_by_offset(disp, _gloffset_PointSize) +#define SET_PointSize(disp, fn) SET_by_offset(disp, _gloffset_PointSize, fn) +#define CALL_PolygonMode(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLenum)), _gloffset_PolygonMode, parameters) +#define GET_PolygonMode(disp) GET_by_offset(disp, _gloffset_PolygonMode) +#define SET_PolygonMode(disp, fn) SET_by_offset(disp, _gloffset_PolygonMode, fn) +#define CALL_PolygonStipple(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(const GLubyte *)), _gloffset_PolygonStipple, parameters) +#define GET_PolygonStipple(disp) GET_by_offset(disp, _gloffset_PolygonStipple) +#define SET_PolygonStipple(disp, fn) SET_by_offset(disp, _gloffset_PolygonStipple, fn) +#define CALL_Scissor(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLint, GLint, GLsizei, GLsizei)), _gloffset_Scissor, parameters) +#define GET_Scissor(disp) GET_by_offset(disp, _gloffset_Scissor) +#define SET_Scissor(disp, fn) SET_by_offset(disp, _gloffset_Scissor, fn) +#define CALL_ShadeModel(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum)), _gloffset_ShadeModel, parameters) +#define GET_ShadeModel(disp) GET_by_offset(disp, _gloffset_ShadeModel) +#define SET_ShadeModel(disp, fn) SET_by_offset(disp, _gloffset_ShadeModel, fn) +#define CALL_TexParameterf(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLenum, GLfloat)), _gloffset_TexParameterf, parameters) +#define GET_TexParameterf(disp) GET_by_offset(disp, _gloffset_TexParameterf) +#define SET_TexParameterf(disp, fn) SET_by_offset(disp, _gloffset_TexParameterf, fn) +#define CALL_TexParameterfv(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLenum, const GLfloat *)), _gloffset_TexParameterfv, parameters) +#define GET_TexParameterfv(disp) GET_by_offset(disp, _gloffset_TexParameterfv) +#define SET_TexParameterfv(disp, fn) SET_by_offset(disp, _gloffset_TexParameterfv, fn) +#define CALL_TexParameteri(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLenum, GLint)), _gloffset_TexParameteri, parameters) +#define GET_TexParameteri(disp) GET_by_offset(disp, _gloffset_TexParameteri) +#define SET_TexParameteri(disp, fn) SET_by_offset(disp, _gloffset_TexParameteri, fn) +#define CALL_TexParameteriv(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLenum, const GLint *)), _gloffset_TexParameteriv, parameters) +#define GET_TexParameteriv(disp) GET_by_offset(disp, _gloffset_TexParameteriv) +#define SET_TexParameteriv(disp, fn) SET_by_offset(disp, _gloffset_TexParameteriv, fn) +#define CALL_TexImage1D(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLint, GLint, GLsizei, GLint, GLenum, GLenum, const GLvoid *)), _gloffset_TexImage1D, parameters) +#define GET_TexImage1D(disp) GET_by_offset(disp, _gloffset_TexImage1D) +#define SET_TexImage1D(disp, fn) SET_by_offset(disp, _gloffset_TexImage1D, fn) +#define CALL_TexImage2D(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLint, GLint, GLsizei, GLsizei, GLint, GLenum, GLenum, const GLvoid *)), _gloffset_TexImage2D, parameters) +#define GET_TexImage2D(disp) GET_by_offset(disp, _gloffset_TexImage2D) +#define SET_TexImage2D(disp, fn) SET_by_offset(disp, _gloffset_TexImage2D, fn) +#define CALL_TexEnvf(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLenum, GLfloat)), _gloffset_TexEnvf, parameters) +#define GET_TexEnvf(disp) GET_by_offset(disp, _gloffset_TexEnvf) +#define SET_TexEnvf(disp, fn) SET_by_offset(disp, _gloffset_TexEnvf, fn) +#define CALL_TexEnvfv(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLenum, const GLfloat *)), _gloffset_TexEnvfv, parameters) +#define GET_TexEnvfv(disp) GET_by_offset(disp, _gloffset_TexEnvfv) +#define SET_TexEnvfv(disp, fn) SET_by_offset(disp, _gloffset_TexEnvfv, fn) +#define CALL_TexEnvi(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLenum, GLint)), _gloffset_TexEnvi, parameters) +#define GET_TexEnvi(disp) GET_by_offset(disp, _gloffset_TexEnvi) +#define SET_TexEnvi(disp, fn) SET_by_offset(disp, _gloffset_TexEnvi, fn) +#define CALL_TexEnviv(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLenum, const GLint *)), _gloffset_TexEnviv, parameters) +#define GET_TexEnviv(disp) GET_by_offset(disp, _gloffset_TexEnviv) +#define SET_TexEnviv(disp, fn) SET_by_offset(disp, _gloffset_TexEnviv, fn) +#define CALL_TexGend(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLenum, GLdouble)), _gloffset_TexGend, parameters) +#define GET_TexGend(disp) GET_by_offset(disp, _gloffset_TexGend) +#define SET_TexGend(disp, fn) SET_by_offset(disp, _gloffset_TexGend, fn) +#define CALL_TexGendv(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLenum, const GLdouble *)), _gloffset_TexGendv, parameters) +#define GET_TexGendv(disp) GET_by_offset(disp, _gloffset_TexGendv) +#define SET_TexGendv(disp, fn) SET_by_offset(disp, _gloffset_TexGendv, fn) +#define CALL_TexGenf(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLenum, GLfloat)), _gloffset_TexGenf, parameters) +#define GET_TexGenf(disp) GET_by_offset(disp, _gloffset_TexGenf) +#define SET_TexGenf(disp, fn) SET_by_offset(disp, _gloffset_TexGenf, fn) +#define CALL_TexGenfv(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLenum, const GLfloat *)), _gloffset_TexGenfv, parameters) +#define GET_TexGenfv(disp) GET_by_offset(disp, _gloffset_TexGenfv) +#define SET_TexGenfv(disp, fn) SET_by_offset(disp, _gloffset_TexGenfv, fn) +#define CALL_TexGeni(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLenum, GLint)), _gloffset_TexGeni, parameters) +#define GET_TexGeni(disp) GET_by_offset(disp, _gloffset_TexGeni) +#define SET_TexGeni(disp, fn) SET_by_offset(disp, _gloffset_TexGeni, fn) +#define CALL_TexGeniv(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLenum, const GLint *)), _gloffset_TexGeniv, parameters) +#define GET_TexGeniv(disp) GET_by_offset(disp, _gloffset_TexGeniv) +#define SET_TexGeniv(disp, fn) SET_by_offset(disp, _gloffset_TexGeniv, fn) +#define CALL_FeedbackBuffer(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLsizei, GLenum, GLfloat *)), _gloffset_FeedbackBuffer, parameters) +#define GET_FeedbackBuffer(disp) GET_by_offset(disp, _gloffset_FeedbackBuffer) +#define SET_FeedbackBuffer(disp, fn) SET_by_offset(disp, _gloffset_FeedbackBuffer, fn) +#define CALL_SelectBuffer(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLsizei, GLuint *)), _gloffset_SelectBuffer, parameters) +#define GET_SelectBuffer(disp) GET_by_offset(disp, _gloffset_SelectBuffer) +#define SET_SelectBuffer(disp, fn) SET_by_offset(disp, _gloffset_SelectBuffer, fn) +#define CALL_RenderMode(disp, parameters) CALL_by_offset(disp, (GLint (GLAPIENTRYP)(GLenum)), _gloffset_RenderMode, parameters) +#define GET_RenderMode(disp) GET_by_offset(disp, _gloffset_RenderMode) +#define SET_RenderMode(disp, fn) SET_by_offset(disp, _gloffset_RenderMode, fn) +#define CALL_InitNames(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(void)), _gloffset_InitNames, parameters) +#define GET_InitNames(disp) GET_by_offset(disp, _gloffset_InitNames) +#define SET_InitNames(disp, fn) SET_by_offset(disp, _gloffset_InitNames, fn) +#define CALL_LoadName(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLuint)), _gloffset_LoadName, parameters) +#define GET_LoadName(disp) GET_by_offset(disp, _gloffset_LoadName) +#define SET_LoadName(disp, fn) SET_by_offset(disp, _gloffset_LoadName, fn) +#define CALL_PassThrough(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLfloat)), _gloffset_PassThrough, parameters) +#define GET_PassThrough(disp) GET_by_offset(disp, _gloffset_PassThrough) +#define SET_PassThrough(disp, fn) SET_by_offset(disp, _gloffset_PassThrough, fn) +#define CALL_PopName(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(void)), _gloffset_PopName, parameters) +#define GET_PopName(disp) GET_by_offset(disp, _gloffset_PopName) +#define SET_PopName(disp, fn) SET_by_offset(disp, _gloffset_PopName, fn) +#define CALL_PushName(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLuint)), _gloffset_PushName, parameters) +#define GET_PushName(disp) GET_by_offset(disp, _gloffset_PushName) +#define SET_PushName(disp, fn) SET_by_offset(disp, _gloffset_PushName, fn) +#define CALL_DrawBuffer(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum)), _gloffset_DrawBuffer, parameters) +#define GET_DrawBuffer(disp) GET_by_offset(disp, _gloffset_DrawBuffer) +#define SET_DrawBuffer(disp, fn) SET_by_offset(disp, _gloffset_DrawBuffer, fn) +#define CALL_Clear(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLbitfield)), _gloffset_Clear, parameters) +#define GET_Clear(disp) GET_by_offset(disp, _gloffset_Clear) +#define SET_Clear(disp, fn) SET_by_offset(disp, _gloffset_Clear, fn) +#define CALL_ClearAccum(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLfloat, GLfloat, GLfloat, GLfloat)), _gloffset_ClearAccum, parameters) +#define GET_ClearAccum(disp) GET_by_offset(disp, _gloffset_ClearAccum) +#define SET_ClearAccum(disp, fn) SET_by_offset(disp, _gloffset_ClearAccum, fn) +#define CALL_ClearIndex(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLfloat)), _gloffset_ClearIndex, parameters) +#define GET_ClearIndex(disp) GET_by_offset(disp, _gloffset_ClearIndex) +#define SET_ClearIndex(disp, fn) SET_by_offset(disp, _gloffset_ClearIndex, fn) +#define CALL_ClearColor(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLclampf, GLclampf, GLclampf, GLclampf)), _gloffset_ClearColor, parameters) +#define GET_ClearColor(disp) GET_by_offset(disp, _gloffset_ClearColor) +#define SET_ClearColor(disp, fn) SET_by_offset(disp, _gloffset_ClearColor, fn) +#define CALL_ClearStencil(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLint)), _gloffset_ClearStencil, parameters) +#define GET_ClearStencil(disp) GET_by_offset(disp, _gloffset_ClearStencil) +#define SET_ClearStencil(disp, fn) SET_by_offset(disp, _gloffset_ClearStencil, fn) +#define CALL_ClearDepth(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLclampd)), _gloffset_ClearDepth, parameters) +#define GET_ClearDepth(disp) GET_by_offset(disp, _gloffset_ClearDepth) +#define SET_ClearDepth(disp, fn) SET_by_offset(disp, _gloffset_ClearDepth, fn) +#define CALL_StencilMask(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLuint)), _gloffset_StencilMask, parameters) +#define GET_StencilMask(disp) GET_by_offset(disp, _gloffset_StencilMask) +#define SET_StencilMask(disp, fn) SET_by_offset(disp, _gloffset_StencilMask, fn) +#define CALL_ColorMask(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLboolean, GLboolean, GLboolean, GLboolean)), _gloffset_ColorMask, parameters) +#define GET_ColorMask(disp) GET_by_offset(disp, _gloffset_ColorMask) +#define SET_ColorMask(disp, fn) SET_by_offset(disp, _gloffset_ColorMask, fn) +#define CALL_DepthMask(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLboolean)), _gloffset_DepthMask, parameters) +#define GET_DepthMask(disp) GET_by_offset(disp, _gloffset_DepthMask) +#define SET_DepthMask(disp, fn) SET_by_offset(disp, _gloffset_DepthMask, fn) +#define CALL_IndexMask(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLuint)), _gloffset_IndexMask, parameters) +#define GET_IndexMask(disp) GET_by_offset(disp, _gloffset_IndexMask) +#define SET_IndexMask(disp, fn) SET_by_offset(disp, _gloffset_IndexMask, fn) +#define CALL_Accum(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLfloat)), _gloffset_Accum, parameters) +#define GET_Accum(disp) GET_by_offset(disp, _gloffset_Accum) +#define SET_Accum(disp, fn) SET_by_offset(disp, _gloffset_Accum, fn) +#define CALL_Disable(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum)), _gloffset_Disable, parameters) +#define GET_Disable(disp) GET_by_offset(disp, _gloffset_Disable) +#define SET_Disable(disp, fn) SET_by_offset(disp, _gloffset_Disable, fn) +#define CALL_Enable(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum)), _gloffset_Enable, parameters) +#define GET_Enable(disp) GET_by_offset(disp, _gloffset_Enable) +#define SET_Enable(disp, fn) SET_by_offset(disp, _gloffset_Enable, fn) +#define CALL_Finish(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(void)), _gloffset_Finish, parameters) +#define GET_Finish(disp) GET_by_offset(disp, _gloffset_Finish) +#define SET_Finish(disp, fn) SET_by_offset(disp, _gloffset_Finish, fn) +#define CALL_Flush(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(void)), _gloffset_Flush, parameters) +#define GET_Flush(disp) GET_by_offset(disp, _gloffset_Flush) +#define SET_Flush(disp, fn) SET_by_offset(disp, _gloffset_Flush, fn) +#define CALL_PopAttrib(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(void)), _gloffset_PopAttrib, parameters) +#define GET_PopAttrib(disp) GET_by_offset(disp, _gloffset_PopAttrib) +#define SET_PopAttrib(disp, fn) SET_by_offset(disp, _gloffset_PopAttrib, fn) +#define CALL_PushAttrib(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLbitfield)), _gloffset_PushAttrib, parameters) +#define GET_PushAttrib(disp) GET_by_offset(disp, _gloffset_PushAttrib) +#define SET_PushAttrib(disp, fn) SET_by_offset(disp, _gloffset_PushAttrib, fn) +#define CALL_Map1d(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLdouble, GLdouble, GLint, GLint, const GLdouble *)), _gloffset_Map1d, parameters) +#define GET_Map1d(disp) GET_by_offset(disp, _gloffset_Map1d) +#define SET_Map1d(disp, fn) SET_by_offset(disp, _gloffset_Map1d, fn) +#define CALL_Map1f(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLfloat, GLfloat, GLint, GLint, const GLfloat *)), _gloffset_Map1f, parameters) +#define GET_Map1f(disp) GET_by_offset(disp, _gloffset_Map1f) +#define SET_Map1f(disp, fn) SET_by_offset(disp, _gloffset_Map1f, fn) +#define CALL_Map2d(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLdouble, GLdouble, GLint, GLint, GLdouble, GLdouble, GLint, GLint, const GLdouble *)), _gloffset_Map2d, parameters) +#define GET_Map2d(disp) GET_by_offset(disp, _gloffset_Map2d) +#define SET_Map2d(disp, fn) SET_by_offset(disp, _gloffset_Map2d, fn) +#define CALL_Map2f(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLfloat, GLfloat, GLint, GLint, GLfloat, GLfloat, GLint, GLint, const GLfloat *)), _gloffset_Map2f, parameters) +#define GET_Map2f(disp) GET_by_offset(disp, _gloffset_Map2f) +#define SET_Map2f(disp, fn) SET_by_offset(disp, _gloffset_Map2f, fn) +#define CALL_MapGrid1d(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLint, GLdouble, GLdouble)), _gloffset_MapGrid1d, parameters) +#define GET_MapGrid1d(disp) GET_by_offset(disp, _gloffset_MapGrid1d) +#define SET_MapGrid1d(disp, fn) SET_by_offset(disp, _gloffset_MapGrid1d, fn) +#define CALL_MapGrid1f(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLint, GLfloat, GLfloat)), _gloffset_MapGrid1f, parameters) +#define GET_MapGrid1f(disp) GET_by_offset(disp, _gloffset_MapGrid1f) +#define SET_MapGrid1f(disp, fn) SET_by_offset(disp, _gloffset_MapGrid1f, fn) +#define CALL_MapGrid2d(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLint, GLdouble, GLdouble, GLint, GLdouble, GLdouble)), _gloffset_MapGrid2d, parameters) +#define GET_MapGrid2d(disp) GET_by_offset(disp, _gloffset_MapGrid2d) +#define SET_MapGrid2d(disp, fn) SET_by_offset(disp, _gloffset_MapGrid2d, fn) +#define CALL_MapGrid2f(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLint, GLfloat, GLfloat, GLint, GLfloat, GLfloat)), _gloffset_MapGrid2f, parameters) +#define GET_MapGrid2f(disp) GET_by_offset(disp, _gloffset_MapGrid2f) +#define SET_MapGrid2f(disp, fn) SET_by_offset(disp, _gloffset_MapGrid2f, fn) +#define CALL_EvalCoord1d(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLdouble)), _gloffset_EvalCoord1d, parameters) +#define GET_EvalCoord1d(disp) GET_by_offset(disp, _gloffset_EvalCoord1d) +#define SET_EvalCoord1d(disp, fn) SET_by_offset(disp, _gloffset_EvalCoord1d, fn) +#define CALL_EvalCoord1dv(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(const GLdouble *)), _gloffset_EvalCoord1dv, parameters) +#define GET_EvalCoord1dv(disp) GET_by_offset(disp, _gloffset_EvalCoord1dv) +#define SET_EvalCoord1dv(disp, fn) SET_by_offset(disp, _gloffset_EvalCoord1dv, fn) +#define CALL_EvalCoord1f(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLfloat)), _gloffset_EvalCoord1f, parameters) +#define GET_EvalCoord1f(disp) GET_by_offset(disp, _gloffset_EvalCoord1f) +#define SET_EvalCoord1f(disp, fn) SET_by_offset(disp, _gloffset_EvalCoord1f, fn) +#define CALL_EvalCoord1fv(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(const GLfloat *)), _gloffset_EvalCoord1fv, parameters) +#define GET_EvalCoord1fv(disp) GET_by_offset(disp, _gloffset_EvalCoord1fv) +#define SET_EvalCoord1fv(disp, fn) SET_by_offset(disp, _gloffset_EvalCoord1fv, fn) +#define CALL_EvalCoord2d(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLdouble, GLdouble)), _gloffset_EvalCoord2d, parameters) +#define GET_EvalCoord2d(disp) GET_by_offset(disp, _gloffset_EvalCoord2d) +#define SET_EvalCoord2d(disp, fn) SET_by_offset(disp, _gloffset_EvalCoord2d, fn) +#define CALL_EvalCoord2dv(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(const GLdouble *)), _gloffset_EvalCoord2dv, parameters) +#define GET_EvalCoord2dv(disp) GET_by_offset(disp, _gloffset_EvalCoord2dv) +#define SET_EvalCoord2dv(disp, fn) SET_by_offset(disp, _gloffset_EvalCoord2dv, fn) +#define CALL_EvalCoord2f(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLfloat, GLfloat)), _gloffset_EvalCoord2f, parameters) +#define GET_EvalCoord2f(disp) GET_by_offset(disp, _gloffset_EvalCoord2f) +#define SET_EvalCoord2f(disp, fn) SET_by_offset(disp, _gloffset_EvalCoord2f, fn) +#define CALL_EvalCoord2fv(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(const GLfloat *)), _gloffset_EvalCoord2fv, parameters) +#define GET_EvalCoord2fv(disp) GET_by_offset(disp, _gloffset_EvalCoord2fv) +#define SET_EvalCoord2fv(disp, fn) SET_by_offset(disp, _gloffset_EvalCoord2fv, fn) +#define CALL_EvalMesh1(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLint, GLint)), _gloffset_EvalMesh1, parameters) +#define GET_EvalMesh1(disp) GET_by_offset(disp, _gloffset_EvalMesh1) +#define SET_EvalMesh1(disp, fn) SET_by_offset(disp, _gloffset_EvalMesh1, fn) +#define CALL_EvalPoint1(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLint)), _gloffset_EvalPoint1, parameters) +#define GET_EvalPoint1(disp) GET_by_offset(disp, _gloffset_EvalPoint1) +#define SET_EvalPoint1(disp, fn) SET_by_offset(disp, _gloffset_EvalPoint1, fn) +#define CALL_EvalMesh2(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLint, GLint, GLint, GLint)), _gloffset_EvalMesh2, parameters) +#define GET_EvalMesh2(disp) GET_by_offset(disp, _gloffset_EvalMesh2) +#define SET_EvalMesh2(disp, fn) SET_by_offset(disp, _gloffset_EvalMesh2, fn) +#define CALL_EvalPoint2(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLint, GLint)), _gloffset_EvalPoint2, parameters) +#define GET_EvalPoint2(disp) GET_by_offset(disp, _gloffset_EvalPoint2) +#define SET_EvalPoint2(disp, fn) SET_by_offset(disp, _gloffset_EvalPoint2, fn) +#define CALL_AlphaFunc(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLclampf)), _gloffset_AlphaFunc, parameters) +#define GET_AlphaFunc(disp) GET_by_offset(disp, _gloffset_AlphaFunc) +#define SET_AlphaFunc(disp, fn) SET_by_offset(disp, _gloffset_AlphaFunc, fn) +#define CALL_BlendFunc(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLenum)), _gloffset_BlendFunc, parameters) +#define GET_BlendFunc(disp) GET_by_offset(disp, _gloffset_BlendFunc) +#define SET_BlendFunc(disp, fn) SET_by_offset(disp, _gloffset_BlendFunc, fn) +#define CALL_LogicOp(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum)), _gloffset_LogicOp, parameters) +#define GET_LogicOp(disp) GET_by_offset(disp, _gloffset_LogicOp) +#define SET_LogicOp(disp, fn) SET_by_offset(disp, _gloffset_LogicOp, fn) +#define CALL_StencilFunc(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLint, GLuint)), _gloffset_StencilFunc, parameters) +#define GET_StencilFunc(disp) GET_by_offset(disp, _gloffset_StencilFunc) +#define SET_StencilFunc(disp, fn) SET_by_offset(disp, _gloffset_StencilFunc, fn) +#define CALL_StencilOp(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLenum, GLenum)), _gloffset_StencilOp, parameters) +#define GET_StencilOp(disp) GET_by_offset(disp, _gloffset_StencilOp) +#define SET_StencilOp(disp, fn) SET_by_offset(disp, _gloffset_StencilOp, fn) +#define CALL_DepthFunc(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum)), _gloffset_DepthFunc, parameters) +#define GET_DepthFunc(disp) GET_by_offset(disp, _gloffset_DepthFunc) +#define SET_DepthFunc(disp, fn) SET_by_offset(disp, _gloffset_DepthFunc, fn) +#define CALL_PixelZoom(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLfloat, GLfloat)), _gloffset_PixelZoom, parameters) +#define GET_PixelZoom(disp) GET_by_offset(disp, _gloffset_PixelZoom) +#define SET_PixelZoom(disp, fn) SET_by_offset(disp, _gloffset_PixelZoom, fn) +#define CALL_PixelTransferf(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLfloat)), _gloffset_PixelTransferf, parameters) +#define GET_PixelTransferf(disp) GET_by_offset(disp, _gloffset_PixelTransferf) +#define SET_PixelTransferf(disp, fn) SET_by_offset(disp, _gloffset_PixelTransferf, fn) +#define CALL_PixelTransferi(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLint)), _gloffset_PixelTransferi, parameters) +#define GET_PixelTransferi(disp) GET_by_offset(disp, _gloffset_PixelTransferi) +#define SET_PixelTransferi(disp, fn) SET_by_offset(disp, _gloffset_PixelTransferi, fn) +#define CALL_PixelStoref(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLfloat)), _gloffset_PixelStoref, parameters) +#define GET_PixelStoref(disp) GET_by_offset(disp, _gloffset_PixelStoref) +#define SET_PixelStoref(disp, fn) SET_by_offset(disp, _gloffset_PixelStoref, fn) +#define CALL_PixelStorei(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLint)), _gloffset_PixelStorei, parameters) +#define GET_PixelStorei(disp) GET_by_offset(disp, _gloffset_PixelStorei) +#define SET_PixelStorei(disp, fn) SET_by_offset(disp, _gloffset_PixelStorei, fn) +#define CALL_PixelMapfv(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLsizei, const GLfloat *)), _gloffset_PixelMapfv, parameters) +#define GET_PixelMapfv(disp) GET_by_offset(disp, _gloffset_PixelMapfv) +#define SET_PixelMapfv(disp, fn) SET_by_offset(disp, _gloffset_PixelMapfv, fn) +#define CALL_PixelMapuiv(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLsizei, const GLuint *)), _gloffset_PixelMapuiv, parameters) +#define GET_PixelMapuiv(disp) GET_by_offset(disp, _gloffset_PixelMapuiv) +#define SET_PixelMapuiv(disp, fn) SET_by_offset(disp, _gloffset_PixelMapuiv, fn) +#define CALL_PixelMapusv(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLsizei, const GLushort *)), _gloffset_PixelMapusv, parameters) +#define GET_PixelMapusv(disp) GET_by_offset(disp, _gloffset_PixelMapusv) +#define SET_PixelMapusv(disp, fn) SET_by_offset(disp, _gloffset_PixelMapusv, fn) +#define CALL_ReadBuffer(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum)), _gloffset_ReadBuffer, parameters) +#define GET_ReadBuffer(disp) GET_by_offset(disp, _gloffset_ReadBuffer) +#define SET_ReadBuffer(disp, fn) SET_by_offset(disp, _gloffset_ReadBuffer, fn) +#define CALL_CopyPixels(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLint, GLint, GLsizei, GLsizei, GLenum)), _gloffset_CopyPixels, parameters) +#define GET_CopyPixels(disp) GET_by_offset(disp, _gloffset_CopyPixels) +#define SET_CopyPixels(disp, fn) SET_by_offset(disp, _gloffset_CopyPixels, fn) +#define CALL_ReadPixels(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLint, GLint, GLsizei, GLsizei, GLenum, GLenum, GLvoid *)), _gloffset_ReadPixels, parameters) +#define GET_ReadPixels(disp) GET_by_offset(disp, _gloffset_ReadPixels) +#define SET_ReadPixels(disp, fn) SET_by_offset(disp, _gloffset_ReadPixels, fn) +#define CALL_DrawPixels(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLsizei, GLsizei, GLenum, GLenum, const GLvoid *)), _gloffset_DrawPixels, parameters) +#define GET_DrawPixels(disp) GET_by_offset(disp, _gloffset_DrawPixels) +#define SET_DrawPixels(disp, fn) SET_by_offset(disp, _gloffset_DrawPixels, fn) +#define CALL_GetBooleanv(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLboolean *)), _gloffset_GetBooleanv, parameters) +#define GET_GetBooleanv(disp) GET_by_offset(disp, _gloffset_GetBooleanv) +#define SET_GetBooleanv(disp, fn) SET_by_offset(disp, _gloffset_GetBooleanv, fn) +#define CALL_GetClipPlane(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLdouble *)), _gloffset_GetClipPlane, parameters) +#define GET_GetClipPlane(disp) GET_by_offset(disp, _gloffset_GetClipPlane) +#define SET_GetClipPlane(disp, fn) SET_by_offset(disp, _gloffset_GetClipPlane, fn) +#define CALL_GetDoublev(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLdouble *)), _gloffset_GetDoublev, parameters) +#define GET_GetDoublev(disp) GET_by_offset(disp, _gloffset_GetDoublev) +#define SET_GetDoublev(disp, fn) SET_by_offset(disp, _gloffset_GetDoublev, fn) +#define CALL_GetError(disp, parameters) CALL_by_offset(disp, (GLenum (GLAPIENTRYP)(void)), _gloffset_GetError, parameters) +#define GET_GetError(disp) GET_by_offset(disp, _gloffset_GetError) +#define SET_GetError(disp, fn) SET_by_offset(disp, _gloffset_GetError, fn) +#define CALL_GetFloatv(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLfloat *)), _gloffset_GetFloatv, parameters) +#define GET_GetFloatv(disp) GET_by_offset(disp, _gloffset_GetFloatv) +#define SET_GetFloatv(disp, fn) SET_by_offset(disp, _gloffset_GetFloatv, fn) +#define CALL_GetIntegerv(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLint *)), _gloffset_GetIntegerv, parameters) +#define GET_GetIntegerv(disp) GET_by_offset(disp, _gloffset_GetIntegerv) +#define SET_GetIntegerv(disp, fn) SET_by_offset(disp, _gloffset_GetIntegerv, fn) +#define CALL_GetLightfv(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLenum, GLfloat *)), _gloffset_GetLightfv, parameters) +#define GET_GetLightfv(disp) GET_by_offset(disp, _gloffset_GetLightfv) +#define SET_GetLightfv(disp, fn) SET_by_offset(disp, _gloffset_GetLightfv, fn) +#define CALL_GetLightiv(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLenum, GLint *)), _gloffset_GetLightiv, parameters) +#define GET_GetLightiv(disp) GET_by_offset(disp, _gloffset_GetLightiv) +#define SET_GetLightiv(disp, fn) SET_by_offset(disp, _gloffset_GetLightiv, fn) +#define CALL_GetMapdv(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLenum, GLdouble *)), _gloffset_GetMapdv, parameters) +#define GET_GetMapdv(disp) GET_by_offset(disp, _gloffset_GetMapdv) +#define SET_GetMapdv(disp, fn) SET_by_offset(disp, _gloffset_GetMapdv, fn) +#define CALL_GetMapfv(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLenum, GLfloat *)), _gloffset_GetMapfv, parameters) +#define GET_GetMapfv(disp) GET_by_offset(disp, _gloffset_GetMapfv) +#define SET_GetMapfv(disp, fn) SET_by_offset(disp, _gloffset_GetMapfv, fn) +#define CALL_GetMapiv(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLenum, GLint *)), _gloffset_GetMapiv, parameters) +#define GET_GetMapiv(disp) GET_by_offset(disp, _gloffset_GetMapiv) +#define SET_GetMapiv(disp, fn) SET_by_offset(disp, _gloffset_GetMapiv, fn) +#define CALL_GetMaterialfv(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLenum, GLfloat *)), _gloffset_GetMaterialfv, parameters) +#define GET_GetMaterialfv(disp) GET_by_offset(disp, _gloffset_GetMaterialfv) +#define SET_GetMaterialfv(disp, fn) SET_by_offset(disp, _gloffset_GetMaterialfv, fn) +#define CALL_GetMaterialiv(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLenum, GLint *)), _gloffset_GetMaterialiv, parameters) +#define GET_GetMaterialiv(disp) GET_by_offset(disp, _gloffset_GetMaterialiv) +#define SET_GetMaterialiv(disp, fn) SET_by_offset(disp, _gloffset_GetMaterialiv, fn) +#define CALL_GetPixelMapfv(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLfloat *)), _gloffset_GetPixelMapfv, parameters) +#define GET_GetPixelMapfv(disp) GET_by_offset(disp, _gloffset_GetPixelMapfv) +#define SET_GetPixelMapfv(disp, fn) SET_by_offset(disp, _gloffset_GetPixelMapfv, fn) +#define CALL_GetPixelMapuiv(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLuint *)), _gloffset_GetPixelMapuiv, parameters) +#define GET_GetPixelMapuiv(disp) GET_by_offset(disp, _gloffset_GetPixelMapuiv) +#define SET_GetPixelMapuiv(disp, fn) SET_by_offset(disp, _gloffset_GetPixelMapuiv, fn) +#define CALL_GetPixelMapusv(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLushort *)), _gloffset_GetPixelMapusv, parameters) +#define GET_GetPixelMapusv(disp) GET_by_offset(disp, _gloffset_GetPixelMapusv) +#define SET_GetPixelMapusv(disp, fn) SET_by_offset(disp, _gloffset_GetPixelMapusv, fn) +#define CALL_GetPolygonStipple(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLubyte *)), _gloffset_GetPolygonStipple, parameters) +#define GET_GetPolygonStipple(disp) GET_by_offset(disp, _gloffset_GetPolygonStipple) +#define SET_GetPolygonStipple(disp, fn) SET_by_offset(disp, _gloffset_GetPolygonStipple, fn) +#define CALL_GetString(disp, parameters) CALL_by_offset(disp, (const GLubyte * (GLAPIENTRYP)(GLenum)), _gloffset_GetString, parameters) +#define GET_GetString(disp) GET_by_offset(disp, _gloffset_GetString) +#define SET_GetString(disp, fn) SET_by_offset(disp, _gloffset_GetString, fn) +#define CALL_GetTexEnvfv(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLenum, GLfloat *)), _gloffset_GetTexEnvfv, parameters) +#define GET_GetTexEnvfv(disp) GET_by_offset(disp, _gloffset_GetTexEnvfv) +#define SET_GetTexEnvfv(disp, fn) SET_by_offset(disp, _gloffset_GetTexEnvfv, fn) +#define CALL_GetTexEnviv(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLenum, GLint *)), _gloffset_GetTexEnviv, parameters) +#define GET_GetTexEnviv(disp) GET_by_offset(disp, _gloffset_GetTexEnviv) +#define SET_GetTexEnviv(disp, fn) SET_by_offset(disp, _gloffset_GetTexEnviv, fn) +#define CALL_GetTexGendv(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLenum, GLdouble *)), _gloffset_GetTexGendv, parameters) +#define GET_GetTexGendv(disp) GET_by_offset(disp, _gloffset_GetTexGendv) +#define SET_GetTexGendv(disp, fn) SET_by_offset(disp, _gloffset_GetTexGendv, fn) +#define CALL_GetTexGenfv(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLenum, GLfloat *)), _gloffset_GetTexGenfv, parameters) +#define GET_GetTexGenfv(disp) GET_by_offset(disp, _gloffset_GetTexGenfv) +#define SET_GetTexGenfv(disp, fn) SET_by_offset(disp, _gloffset_GetTexGenfv, fn) +#define CALL_GetTexGeniv(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLenum, GLint *)), _gloffset_GetTexGeniv, parameters) +#define GET_GetTexGeniv(disp) GET_by_offset(disp, _gloffset_GetTexGeniv) +#define SET_GetTexGeniv(disp, fn) SET_by_offset(disp, _gloffset_GetTexGeniv, fn) +#define CALL_GetTexImage(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLint, GLenum, GLenum, GLvoid *)), _gloffset_GetTexImage, parameters) +#define GET_GetTexImage(disp) GET_by_offset(disp, _gloffset_GetTexImage) +#define SET_GetTexImage(disp, fn) SET_by_offset(disp, _gloffset_GetTexImage, fn) +#define CALL_GetTexParameterfv(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLenum, GLfloat *)), _gloffset_GetTexParameterfv, parameters) +#define GET_GetTexParameterfv(disp) GET_by_offset(disp, _gloffset_GetTexParameterfv) +#define SET_GetTexParameterfv(disp, fn) SET_by_offset(disp, _gloffset_GetTexParameterfv, fn) +#define CALL_GetTexParameteriv(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLenum, GLint *)), _gloffset_GetTexParameteriv, parameters) +#define GET_GetTexParameteriv(disp) GET_by_offset(disp, _gloffset_GetTexParameteriv) +#define SET_GetTexParameteriv(disp, fn) SET_by_offset(disp, _gloffset_GetTexParameteriv, fn) +#define CALL_GetTexLevelParameterfv(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLint, GLenum, GLfloat *)), _gloffset_GetTexLevelParameterfv, parameters) +#define GET_GetTexLevelParameterfv(disp) GET_by_offset(disp, _gloffset_GetTexLevelParameterfv) +#define SET_GetTexLevelParameterfv(disp, fn) SET_by_offset(disp, _gloffset_GetTexLevelParameterfv, fn) +#define CALL_GetTexLevelParameteriv(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLint, GLenum, GLint *)), _gloffset_GetTexLevelParameteriv, parameters) +#define GET_GetTexLevelParameteriv(disp) GET_by_offset(disp, _gloffset_GetTexLevelParameteriv) +#define SET_GetTexLevelParameteriv(disp, fn) SET_by_offset(disp, _gloffset_GetTexLevelParameteriv, fn) +#define CALL_IsEnabled(disp, parameters) CALL_by_offset(disp, (GLboolean (GLAPIENTRYP)(GLenum)), _gloffset_IsEnabled, parameters) +#define GET_IsEnabled(disp) GET_by_offset(disp, _gloffset_IsEnabled) +#define SET_IsEnabled(disp, fn) SET_by_offset(disp, _gloffset_IsEnabled, fn) +#define CALL_IsList(disp, parameters) CALL_by_offset(disp, (GLboolean (GLAPIENTRYP)(GLuint)), _gloffset_IsList, parameters) +#define GET_IsList(disp) GET_by_offset(disp, _gloffset_IsList) +#define SET_IsList(disp, fn) SET_by_offset(disp, _gloffset_IsList, fn) +#define CALL_DepthRange(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLclampd, GLclampd)), _gloffset_DepthRange, parameters) +#define GET_DepthRange(disp) GET_by_offset(disp, _gloffset_DepthRange) +#define SET_DepthRange(disp, fn) SET_by_offset(disp, _gloffset_DepthRange, fn) +#define CALL_Frustum(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLdouble, GLdouble, GLdouble, GLdouble, GLdouble, GLdouble)), _gloffset_Frustum, parameters) +#define GET_Frustum(disp) GET_by_offset(disp, _gloffset_Frustum) +#define SET_Frustum(disp, fn) SET_by_offset(disp, _gloffset_Frustum, fn) +#define CALL_LoadIdentity(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(void)), _gloffset_LoadIdentity, parameters) +#define GET_LoadIdentity(disp) GET_by_offset(disp, _gloffset_LoadIdentity) +#define SET_LoadIdentity(disp, fn) SET_by_offset(disp, _gloffset_LoadIdentity, fn) +#define CALL_LoadMatrixf(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(const GLfloat *)), _gloffset_LoadMatrixf, parameters) +#define GET_LoadMatrixf(disp) GET_by_offset(disp, _gloffset_LoadMatrixf) +#define SET_LoadMatrixf(disp, fn) SET_by_offset(disp, _gloffset_LoadMatrixf, fn) +#define CALL_LoadMatrixd(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(const GLdouble *)), _gloffset_LoadMatrixd, parameters) +#define GET_LoadMatrixd(disp) GET_by_offset(disp, _gloffset_LoadMatrixd) +#define SET_LoadMatrixd(disp, fn) SET_by_offset(disp, _gloffset_LoadMatrixd, fn) +#define CALL_MatrixMode(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum)), _gloffset_MatrixMode, parameters) +#define GET_MatrixMode(disp) GET_by_offset(disp, _gloffset_MatrixMode) +#define SET_MatrixMode(disp, fn) SET_by_offset(disp, _gloffset_MatrixMode, fn) +#define CALL_MultMatrixf(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(const GLfloat *)), _gloffset_MultMatrixf, parameters) +#define GET_MultMatrixf(disp) GET_by_offset(disp, _gloffset_MultMatrixf) +#define SET_MultMatrixf(disp, fn) SET_by_offset(disp, _gloffset_MultMatrixf, fn) +#define CALL_MultMatrixd(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(const GLdouble *)), _gloffset_MultMatrixd, parameters) +#define GET_MultMatrixd(disp) GET_by_offset(disp, _gloffset_MultMatrixd) +#define SET_MultMatrixd(disp, fn) SET_by_offset(disp, _gloffset_MultMatrixd, fn) +#define CALL_Ortho(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLdouble, GLdouble, GLdouble, GLdouble, GLdouble, GLdouble)), _gloffset_Ortho, parameters) +#define GET_Ortho(disp) GET_by_offset(disp, _gloffset_Ortho) +#define SET_Ortho(disp, fn) SET_by_offset(disp, _gloffset_Ortho, fn) +#define CALL_PopMatrix(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(void)), _gloffset_PopMatrix, parameters) +#define GET_PopMatrix(disp) GET_by_offset(disp, _gloffset_PopMatrix) +#define SET_PopMatrix(disp, fn) SET_by_offset(disp, _gloffset_PopMatrix, fn) +#define CALL_PushMatrix(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(void)), _gloffset_PushMatrix, parameters) +#define GET_PushMatrix(disp) GET_by_offset(disp, _gloffset_PushMatrix) +#define SET_PushMatrix(disp, fn) SET_by_offset(disp, _gloffset_PushMatrix, fn) +#define CALL_Rotated(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLdouble, GLdouble, GLdouble, GLdouble)), _gloffset_Rotated, parameters) +#define GET_Rotated(disp) GET_by_offset(disp, _gloffset_Rotated) +#define SET_Rotated(disp, fn) SET_by_offset(disp, _gloffset_Rotated, fn) +#define CALL_Rotatef(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLfloat, GLfloat, GLfloat, GLfloat)), _gloffset_Rotatef, parameters) +#define GET_Rotatef(disp) GET_by_offset(disp, _gloffset_Rotatef) +#define SET_Rotatef(disp, fn) SET_by_offset(disp, _gloffset_Rotatef, fn) +#define CALL_Scaled(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLdouble, GLdouble, GLdouble)), _gloffset_Scaled, parameters) +#define GET_Scaled(disp) GET_by_offset(disp, _gloffset_Scaled) +#define SET_Scaled(disp, fn) SET_by_offset(disp, _gloffset_Scaled, fn) +#define CALL_Scalef(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLfloat, GLfloat, GLfloat)), _gloffset_Scalef, parameters) +#define GET_Scalef(disp) GET_by_offset(disp, _gloffset_Scalef) +#define SET_Scalef(disp, fn) SET_by_offset(disp, _gloffset_Scalef, fn) +#define CALL_Translated(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLdouble, GLdouble, GLdouble)), _gloffset_Translated, parameters) +#define GET_Translated(disp) GET_by_offset(disp, _gloffset_Translated) +#define SET_Translated(disp, fn) SET_by_offset(disp, _gloffset_Translated, fn) +#define CALL_Translatef(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLfloat, GLfloat, GLfloat)), _gloffset_Translatef, parameters) +#define GET_Translatef(disp) GET_by_offset(disp, _gloffset_Translatef) +#define SET_Translatef(disp, fn) SET_by_offset(disp, _gloffset_Translatef, fn) +#define CALL_Viewport(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLint, GLint, GLsizei, GLsizei)), _gloffset_Viewport, parameters) +#define GET_Viewport(disp) GET_by_offset(disp, _gloffset_Viewport) +#define SET_Viewport(disp, fn) SET_by_offset(disp, _gloffset_Viewport, fn) +#define CALL_ArrayElement(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLint)), _gloffset_ArrayElement, parameters) +#define GET_ArrayElement(disp) GET_by_offset(disp, _gloffset_ArrayElement) +#define SET_ArrayElement(disp, fn) SET_by_offset(disp, _gloffset_ArrayElement, fn) +#define CALL_BindTexture(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLuint)), _gloffset_BindTexture, parameters) +#define GET_BindTexture(disp) GET_by_offset(disp, _gloffset_BindTexture) +#define SET_BindTexture(disp, fn) SET_by_offset(disp, _gloffset_BindTexture, fn) +#define CALL_ColorPointer(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLint, GLenum, GLsizei, const GLvoid *)), _gloffset_ColorPointer, parameters) +#define GET_ColorPointer(disp) GET_by_offset(disp, _gloffset_ColorPointer) +#define SET_ColorPointer(disp, fn) SET_by_offset(disp, _gloffset_ColorPointer, fn) +#define CALL_DisableClientState(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum)), _gloffset_DisableClientState, parameters) +#define GET_DisableClientState(disp) GET_by_offset(disp, _gloffset_DisableClientState) +#define SET_DisableClientState(disp, fn) SET_by_offset(disp, _gloffset_DisableClientState, fn) +#define CALL_DrawArrays(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLint, GLsizei)), _gloffset_DrawArrays, parameters) +#define GET_DrawArrays(disp) GET_by_offset(disp, _gloffset_DrawArrays) +#define SET_DrawArrays(disp, fn) SET_by_offset(disp, _gloffset_DrawArrays, fn) +#define CALL_DrawElements(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLsizei, GLenum, const GLvoid *)), _gloffset_DrawElements, parameters) +#define GET_DrawElements(disp) GET_by_offset(disp, _gloffset_DrawElements) +#define SET_DrawElements(disp, fn) SET_by_offset(disp, _gloffset_DrawElements, fn) +#define CALL_EdgeFlagPointer(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLsizei, const GLvoid *)), _gloffset_EdgeFlagPointer, parameters) +#define GET_EdgeFlagPointer(disp) GET_by_offset(disp, _gloffset_EdgeFlagPointer) +#define SET_EdgeFlagPointer(disp, fn) SET_by_offset(disp, _gloffset_EdgeFlagPointer, fn) +#define CALL_EnableClientState(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum)), _gloffset_EnableClientState, parameters) +#define GET_EnableClientState(disp) GET_by_offset(disp, _gloffset_EnableClientState) +#define SET_EnableClientState(disp, fn) SET_by_offset(disp, _gloffset_EnableClientState, fn) +#define CALL_IndexPointer(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLsizei, const GLvoid *)), _gloffset_IndexPointer, parameters) +#define GET_IndexPointer(disp) GET_by_offset(disp, _gloffset_IndexPointer) +#define SET_IndexPointer(disp, fn) SET_by_offset(disp, _gloffset_IndexPointer, fn) +#define CALL_Indexub(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLubyte)), _gloffset_Indexub, parameters) +#define GET_Indexub(disp) GET_by_offset(disp, _gloffset_Indexub) +#define SET_Indexub(disp, fn) SET_by_offset(disp, _gloffset_Indexub, fn) +#define CALL_Indexubv(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(const GLubyte *)), _gloffset_Indexubv, parameters) +#define GET_Indexubv(disp) GET_by_offset(disp, _gloffset_Indexubv) +#define SET_Indexubv(disp, fn) SET_by_offset(disp, _gloffset_Indexubv, fn) +#define CALL_InterleavedArrays(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLsizei, const GLvoid *)), _gloffset_InterleavedArrays, parameters) +#define GET_InterleavedArrays(disp) GET_by_offset(disp, _gloffset_InterleavedArrays) +#define SET_InterleavedArrays(disp, fn) SET_by_offset(disp, _gloffset_InterleavedArrays, fn) +#define CALL_NormalPointer(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLsizei, const GLvoid *)), _gloffset_NormalPointer, parameters) +#define GET_NormalPointer(disp) GET_by_offset(disp, _gloffset_NormalPointer) +#define SET_NormalPointer(disp, fn) SET_by_offset(disp, _gloffset_NormalPointer, fn) +#define CALL_PolygonOffset(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLfloat, GLfloat)), _gloffset_PolygonOffset, parameters) +#define GET_PolygonOffset(disp) GET_by_offset(disp, _gloffset_PolygonOffset) +#define SET_PolygonOffset(disp, fn) SET_by_offset(disp, _gloffset_PolygonOffset, fn) +#define CALL_TexCoordPointer(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLint, GLenum, GLsizei, const GLvoid *)), _gloffset_TexCoordPointer, parameters) +#define GET_TexCoordPointer(disp) GET_by_offset(disp, _gloffset_TexCoordPointer) +#define SET_TexCoordPointer(disp, fn) SET_by_offset(disp, _gloffset_TexCoordPointer, fn) +#define CALL_VertexPointer(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLint, GLenum, GLsizei, const GLvoid *)), _gloffset_VertexPointer, parameters) +#define GET_VertexPointer(disp) GET_by_offset(disp, _gloffset_VertexPointer) +#define SET_VertexPointer(disp, fn) SET_by_offset(disp, _gloffset_VertexPointer, fn) +#define CALL_AreTexturesResident(disp, parameters) CALL_by_offset(disp, (GLboolean (GLAPIENTRYP)(GLsizei, const GLuint *, GLboolean *)), _gloffset_AreTexturesResident, parameters) +#define GET_AreTexturesResident(disp) GET_by_offset(disp, _gloffset_AreTexturesResident) +#define SET_AreTexturesResident(disp, fn) SET_by_offset(disp, _gloffset_AreTexturesResident, fn) +#define CALL_CopyTexImage1D(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLint, GLenum, GLint, GLint, GLsizei, GLint)), _gloffset_CopyTexImage1D, parameters) +#define GET_CopyTexImage1D(disp) GET_by_offset(disp, _gloffset_CopyTexImage1D) +#define SET_CopyTexImage1D(disp, fn) SET_by_offset(disp, _gloffset_CopyTexImage1D, fn) +#define CALL_CopyTexImage2D(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLint, GLenum, GLint, GLint, GLsizei, GLsizei, GLint)), _gloffset_CopyTexImage2D, parameters) +#define GET_CopyTexImage2D(disp) GET_by_offset(disp, _gloffset_CopyTexImage2D) +#define SET_CopyTexImage2D(disp, fn) SET_by_offset(disp, _gloffset_CopyTexImage2D, fn) +#define CALL_CopyTexSubImage1D(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLint, GLint, GLint, GLint, GLsizei)), _gloffset_CopyTexSubImage1D, parameters) +#define GET_CopyTexSubImage1D(disp) GET_by_offset(disp, _gloffset_CopyTexSubImage1D) +#define SET_CopyTexSubImage1D(disp, fn) SET_by_offset(disp, _gloffset_CopyTexSubImage1D, fn) +#define CALL_CopyTexSubImage2D(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLint, GLint, GLint, GLint, GLint, GLsizei, GLsizei)), _gloffset_CopyTexSubImage2D, parameters) +#define GET_CopyTexSubImage2D(disp) GET_by_offset(disp, _gloffset_CopyTexSubImage2D) +#define SET_CopyTexSubImage2D(disp, fn) SET_by_offset(disp, _gloffset_CopyTexSubImage2D, fn) +#define CALL_DeleteTextures(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLsizei, const GLuint *)), _gloffset_DeleteTextures, parameters) +#define GET_DeleteTextures(disp) GET_by_offset(disp, _gloffset_DeleteTextures) +#define SET_DeleteTextures(disp, fn) SET_by_offset(disp, _gloffset_DeleteTextures, fn) +#define CALL_GenTextures(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLsizei, GLuint *)), _gloffset_GenTextures, parameters) +#define GET_GenTextures(disp) GET_by_offset(disp, _gloffset_GenTextures) +#define SET_GenTextures(disp, fn) SET_by_offset(disp, _gloffset_GenTextures, fn) +#define CALL_GetPointerv(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLvoid **)), _gloffset_GetPointerv, parameters) +#define GET_GetPointerv(disp) GET_by_offset(disp, _gloffset_GetPointerv) +#define SET_GetPointerv(disp, fn) SET_by_offset(disp, _gloffset_GetPointerv, fn) +#define CALL_IsTexture(disp, parameters) CALL_by_offset(disp, (GLboolean (GLAPIENTRYP)(GLuint)), _gloffset_IsTexture, parameters) +#define GET_IsTexture(disp) GET_by_offset(disp, _gloffset_IsTexture) +#define SET_IsTexture(disp, fn) SET_by_offset(disp, _gloffset_IsTexture, fn) +#define CALL_PrioritizeTextures(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLsizei, const GLuint *, const GLclampf *)), _gloffset_PrioritizeTextures, parameters) +#define GET_PrioritizeTextures(disp) GET_by_offset(disp, _gloffset_PrioritizeTextures) +#define SET_PrioritizeTextures(disp, fn) SET_by_offset(disp, _gloffset_PrioritizeTextures, fn) +#define CALL_TexSubImage1D(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLint, GLint, GLsizei, GLenum, GLenum, const GLvoid *)), _gloffset_TexSubImage1D, parameters) +#define GET_TexSubImage1D(disp) GET_by_offset(disp, _gloffset_TexSubImage1D) +#define SET_TexSubImage1D(disp, fn) SET_by_offset(disp, _gloffset_TexSubImage1D, fn) +#define CALL_TexSubImage2D(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLint, GLint, GLint, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *)), _gloffset_TexSubImage2D, parameters) +#define GET_TexSubImage2D(disp) GET_by_offset(disp, _gloffset_TexSubImage2D) +#define SET_TexSubImage2D(disp, fn) SET_by_offset(disp, _gloffset_TexSubImage2D, fn) +#define CALL_PopClientAttrib(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(void)), _gloffset_PopClientAttrib, parameters) +#define GET_PopClientAttrib(disp) GET_by_offset(disp, _gloffset_PopClientAttrib) +#define SET_PopClientAttrib(disp, fn) SET_by_offset(disp, _gloffset_PopClientAttrib, fn) +#define CALL_PushClientAttrib(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLbitfield)), _gloffset_PushClientAttrib, parameters) +#define GET_PushClientAttrib(disp) GET_by_offset(disp, _gloffset_PushClientAttrib) +#define SET_PushClientAttrib(disp, fn) SET_by_offset(disp, _gloffset_PushClientAttrib, fn) +#define CALL_BlendColor(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLclampf, GLclampf, GLclampf, GLclampf)), _gloffset_BlendColor, parameters) +#define GET_BlendColor(disp) GET_by_offset(disp, _gloffset_BlendColor) +#define SET_BlendColor(disp, fn) SET_by_offset(disp, _gloffset_BlendColor, fn) +#define CALL_BlendEquation(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum)), _gloffset_BlendEquation, parameters) +#define GET_BlendEquation(disp) GET_by_offset(disp, _gloffset_BlendEquation) +#define SET_BlendEquation(disp, fn) SET_by_offset(disp, _gloffset_BlendEquation, fn) +#define CALL_DrawRangeElements(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLuint, GLuint, GLsizei, GLenum, const GLvoid *)), _gloffset_DrawRangeElements, parameters) +#define GET_DrawRangeElements(disp) GET_by_offset(disp, _gloffset_DrawRangeElements) +#define SET_DrawRangeElements(disp, fn) SET_by_offset(disp, _gloffset_DrawRangeElements, fn) +#define CALL_ColorTable(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLenum, GLsizei, GLenum, GLenum, const GLvoid *)), _gloffset_ColorTable, parameters) +#define GET_ColorTable(disp) GET_by_offset(disp, _gloffset_ColorTable) +#define SET_ColorTable(disp, fn) SET_by_offset(disp, _gloffset_ColorTable, fn) +#define CALL_ColorTableParameterfv(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLenum, const GLfloat *)), _gloffset_ColorTableParameterfv, parameters) +#define GET_ColorTableParameterfv(disp) GET_by_offset(disp, _gloffset_ColorTableParameterfv) +#define SET_ColorTableParameterfv(disp, fn) SET_by_offset(disp, _gloffset_ColorTableParameterfv, fn) +#define CALL_ColorTableParameteriv(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLenum, const GLint *)), _gloffset_ColorTableParameteriv, parameters) +#define GET_ColorTableParameteriv(disp) GET_by_offset(disp, _gloffset_ColorTableParameteriv) +#define SET_ColorTableParameteriv(disp, fn) SET_by_offset(disp, _gloffset_ColorTableParameteriv, fn) +#define CALL_CopyColorTable(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLenum, GLint, GLint, GLsizei)), _gloffset_CopyColorTable, parameters) +#define GET_CopyColorTable(disp) GET_by_offset(disp, _gloffset_CopyColorTable) +#define SET_CopyColorTable(disp, fn) SET_by_offset(disp, _gloffset_CopyColorTable, fn) +#define CALL_GetColorTable(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLenum, GLenum, GLvoid *)), _gloffset_GetColorTable, parameters) +#define GET_GetColorTable(disp) GET_by_offset(disp, _gloffset_GetColorTable) +#define SET_GetColorTable(disp, fn) SET_by_offset(disp, _gloffset_GetColorTable, fn) +#define CALL_GetColorTableParameterfv(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLenum, GLfloat *)), _gloffset_GetColorTableParameterfv, parameters) +#define GET_GetColorTableParameterfv(disp) GET_by_offset(disp, _gloffset_GetColorTableParameterfv) +#define SET_GetColorTableParameterfv(disp, fn) SET_by_offset(disp, _gloffset_GetColorTableParameterfv, fn) +#define CALL_GetColorTableParameteriv(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLenum, GLint *)), _gloffset_GetColorTableParameteriv, parameters) +#define GET_GetColorTableParameteriv(disp) GET_by_offset(disp, _gloffset_GetColorTableParameteriv) +#define SET_GetColorTableParameteriv(disp, fn) SET_by_offset(disp, _gloffset_GetColorTableParameteriv, fn) +#define CALL_ColorSubTable(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *)), _gloffset_ColorSubTable, parameters) +#define GET_ColorSubTable(disp) GET_by_offset(disp, _gloffset_ColorSubTable) +#define SET_ColorSubTable(disp, fn) SET_by_offset(disp, _gloffset_ColorSubTable, fn) +#define CALL_CopyColorSubTable(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLsizei, GLint, GLint, GLsizei)), _gloffset_CopyColorSubTable, parameters) +#define GET_CopyColorSubTable(disp) GET_by_offset(disp, _gloffset_CopyColorSubTable) +#define SET_CopyColorSubTable(disp, fn) SET_by_offset(disp, _gloffset_CopyColorSubTable, fn) +#define CALL_ConvolutionFilter1D(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLenum, GLsizei, GLenum, GLenum, const GLvoid *)), _gloffset_ConvolutionFilter1D, parameters) +#define GET_ConvolutionFilter1D(disp) GET_by_offset(disp, _gloffset_ConvolutionFilter1D) +#define SET_ConvolutionFilter1D(disp, fn) SET_by_offset(disp, _gloffset_ConvolutionFilter1D, fn) +#define CALL_ConvolutionFilter2D(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLenum, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *)), _gloffset_ConvolutionFilter2D, parameters) +#define GET_ConvolutionFilter2D(disp) GET_by_offset(disp, _gloffset_ConvolutionFilter2D) +#define SET_ConvolutionFilter2D(disp, fn) SET_by_offset(disp, _gloffset_ConvolutionFilter2D, fn) +#define CALL_ConvolutionParameterf(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLenum, GLfloat)), _gloffset_ConvolutionParameterf, parameters) +#define GET_ConvolutionParameterf(disp) GET_by_offset(disp, _gloffset_ConvolutionParameterf) +#define SET_ConvolutionParameterf(disp, fn) SET_by_offset(disp, _gloffset_ConvolutionParameterf, fn) +#define CALL_ConvolutionParameterfv(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLenum, const GLfloat *)), _gloffset_ConvolutionParameterfv, parameters) +#define GET_ConvolutionParameterfv(disp) GET_by_offset(disp, _gloffset_ConvolutionParameterfv) +#define SET_ConvolutionParameterfv(disp, fn) SET_by_offset(disp, _gloffset_ConvolutionParameterfv, fn) +#define CALL_ConvolutionParameteri(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLenum, GLint)), _gloffset_ConvolutionParameteri, parameters) +#define GET_ConvolutionParameteri(disp) GET_by_offset(disp, _gloffset_ConvolutionParameteri) +#define SET_ConvolutionParameteri(disp, fn) SET_by_offset(disp, _gloffset_ConvolutionParameteri, fn) +#define CALL_ConvolutionParameteriv(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLenum, const GLint *)), _gloffset_ConvolutionParameteriv, parameters) +#define GET_ConvolutionParameteriv(disp) GET_by_offset(disp, _gloffset_ConvolutionParameteriv) +#define SET_ConvolutionParameteriv(disp, fn) SET_by_offset(disp, _gloffset_ConvolutionParameteriv, fn) +#define CALL_CopyConvolutionFilter1D(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLenum, GLint, GLint, GLsizei)), _gloffset_CopyConvolutionFilter1D, parameters) +#define GET_CopyConvolutionFilter1D(disp) GET_by_offset(disp, _gloffset_CopyConvolutionFilter1D) +#define SET_CopyConvolutionFilter1D(disp, fn) SET_by_offset(disp, _gloffset_CopyConvolutionFilter1D, fn) +#define CALL_CopyConvolutionFilter2D(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLenum, GLint, GLint, GLsizei, GLsizei)), _gloffset_CopyConvolutionFilter2D, parameters) +#define GET_CopyConvolutionFilter2D(disp) GET_by_offset(disp, _gloffset_CopyConvolutionFilter2D) +#define SET_CopyConvolutionFilter2D(disp, fn) SET_by_offset(disp, _gloffset_CopyConvolutionFilter2D, fn) +#define CALL_GetConvolutionFilter(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLenum, GLenum, GLvoid *)), _gloffset_GetConvolutionFilter, parameters) +#define GET_GetConvolutionFilter(disp) GET_by_offset(disp, _gloffset_GetConvolutionFilter) +#define SET_GetConvolutionFilter(disp, fn) SET_by_offset(disp, _gloffset_GetConvolutionFilter, fn) +#define CALL_GetConvolutionParameterfv(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLenum, GLfloat *)), _gloffset_GetConvolutionParameterfv, parameters) +#define GET_GetConvolutionParameterfv(disp) GET_by_offset(disp, _gloffset_GetConvolutionParameterfv) +#define SET_GetConvolutionParameterfv(disp, fn) SET_by_offset(disp, _gloffset_GetConvolutionParameterfv, fn) +#define CALL_GetConvolutionParameteriv(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLenum, GLint *)), _gloffset_GetConvolutionParameteriv, parameters) +#define GET_GetConvolutionParameteriv(disp) GET_by_offset(disp, _gloffset_GetConvolutionParameteriv) +#define SET_GetConvolutionParameteriv(disp, fn) SET_by_offset(disp, _gloffset_GetConvolutionParameteriv, fn) +#define CALL_GetSeparableFilter(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLenum, GLenum, GLvoid *, GLvoid *, GLvoid *)), _gloffset_GetSeparableFilter, parameters) +#define GET_GetSeparableFilter(disp) GET_by_offset(disp, _gloffset_GetSeparableFilter) +#define SET_GetSeparableFilter(disp, fn) SET_by_offset(disp, _gloffset_GetSeparableFilter, fn) +#define CALL_SeparableFilter2D(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLenum, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *, const GLvoid *)), _gloffset_SeparableFilter2D, parameters) +#define GET_SeparableFilter2D(disp) GET_by_offset(disp, _gloffset_SeparableFilter2D) +#define SET_SeparableFilter2D(disp, fn) SET_by_offset(disp, _gloffset_SeparableFilter2D, fn) +#define CALL_GetHistogram(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLboolean, GLenum, GLenum, GLvoid *)), _gloffset_GetHistogram, parameters) +#define GET_GetHistogram(disp) GET_by_offset(disp, _gloffset_GetHistogram) +#define SET_GetHistogram(disp, fn) SET_by_offset(disp, _gloffset_GetHistogram, fn) +#define CALL_GetHistogramParameterfv(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLenum, GLfloat *)), _gloffset_GetHistogramParameterfv, parameters) +#define GET_GetHistogramParameterfv(disp) GET_by_offset(disp, _gloffset_GetHistogramParameterfv) +#define SET_GetHistogramParameterfv(disp, fn) SET_by_offset(disp, _gloffset_GetHistogramParameterfv, fn) +#define CALL_GetHistogramParameteriv(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLenum, GLint *)), _gloffset_GetHistogramParameteriv, parameters) +#define GET_GetHistogramParameteriv(disp) GET_by_offset(disp, _gloffset_GetHistogramParameteriv) +#define SET_GetHistogramParameteriv(disp, fn) SET_by_offset(disp, _gloffset_GetHistogramParameteriv, fn) +#define CALL_GetMinmax(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLboolean, GLenum, GLenum, GLvoid *)), _gloffset_GetMinmax, parameters) +#define GET_GetMinmax(disp) GET_by_offset(disp, _gloffset_GetMinmax) +#define SET_GetMinmax(disp, fn) SET_by_offset(disp, _gloffset_GetMinmax, fn) +#define CALL_GetMinmaxParameterfv(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLenum, GLfloat *)), _gloffset_GetMinmaxParameterfv, parameters) +#define GET_GetMinmaxParameterfv(disp) GET_by_offset(disp, _gloffset_GetMinmaxParameterfv) +#define SET_GetMinmaxParameterfv(disp, fn) SET_by_offset(disp, _gloffset_GetMinmaxParameterfv, fn) +#define CALL_GetMinmaxParameteriv(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLenum, GLint *)), _gloffset_GetMinmaxParameteriv, parameters) +#define GET_GetMinmaxParameteriv(disp) GET_by_offset(disp, _gloffset_GetMinmaxParameteriv) +#define SET_GetMinmaxParameteriv(disp, fn) SET_by_offset(disp, _gloffset_GetMinmaxParameteriv, fn) +#define CALL_Histogram(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLsizei, GLenum, GLboolean)), _gloffset_Histogram, parameters) +#define GET_Histogram(disp) GET_by_offset(disp, _gloffset_Histogram) +#define SET_Histogram(disp, fn) SET_by_offset(disp, _gloffset_Histogram, fn) +#define CALL_Minmax(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLenum, GLboolean)), _gloffset_Minmax, parameters) +#define GET_Minmax(disp) GET_by_offset(disp, _gloffset_Minmax) +#define SET_Minmax(disp, fn) SET_by_offset(disp, _gloffset_Minmax, fn) +#define CALL_ResetHistogram(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum)), _gloffset_ResetHistogram, parameters) +#define GET_ResetHistogram(disp) GET_by_offset(disp, _gloffset_ResetHistogram) +#define SET_ResetHistogram(disp, fn) SET_by_offset(disp, _gloffset_ResetHistogram, fn) +#define CALL_ResetMinmax(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum)), _gloffset_ResetMinmax, parameters) +#define GET_ResetMinmax(disp) GET_by_offset(disp, _gloffset_ResetMinmax) +#define SET_ResetMinmax(disp, fn) SET_by_offset(disp, _gloffset_ResetMinmax, fn) +#define CALL_TexImage3DOES(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLint, GLenum, GLsizei, GLsizei, GLsizei, GLint, GLenum, GLenum, const GLvoid *)), _gloffset_TexImage3DOES, parameters) +#define GET_TexImage3DOES(disp) GET_by_offset(disp, _gloffset_TexImage3DOES) +#define SET_TexImage3DOES(disp, fn) SET_by_offset(disp, _gloffset_TexImage3DOES, fn) +#define CALL_TexSubImage3DOES(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *)), _gloffset_TexSubImage3DOES, parameters) +#define GET_TexSubImage3DOES(disp) GET_by_offset(disp, _gloffset_TexSubImage3DOES) +#define SET_TexSubImage3DOES(disp, fn) SET_by_offset(disp, _gloffset_TexSubImage3DOES, fn) +#define CALL_CopyTexSubImage3DOES(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLint, GLint, GLint, GLint, GLint, GLint, GLsizei, GLsizei)), _gloffset_CopyTexSubImage3DOES, parameters) +#define GET_CopyTexSubImage3DOES(disp) GET_by_offset(disp, _gloffset_CopyTexSubImage3DOES) +#define SET_CopyTexSubImage3DOES(disp, fn) SET_by_offset(disp, _gloffset_CopyTexSubImage3DOES, fn) +#define CALL_ActiveTexture(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum)), _gloffset_ActiveTexture, parameters) +#define GET_ActiveTexture(disp) GET_by_offset(disp, _gloffset_ActiveTexture) +#define SET_ActiveTexture(disp, fn) SET_by_offset(disp, _gloffset_ActiveTexture, fn) +#define CALL_ClientActiveTextureARB(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum)), _gloffset_ClientActiveTextureARB, parameters) +#define GET_ClientActiveTextureARB(disp) GET_by_offset(disp, _gloffset_ClientActiveTextureARB) +#define SET_ClientActiveTextureARB(disp, fn) SET_by_offset(disp, _gloffset_ClientActiveTextureARB, fn) +#define CALL_MultiTexCoord1dARB(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLdouble)), _gloffset_MultiTexCoord1dARB, parameters) +#define GET_MultiTexCoord1dARB(disp) GET_by_offset(disp, _gloffset_MultiTexCoord1dARB) +#define SET_MultiTexCoord1dARB(disp, fn) SET_by_offset(disp, _gloffset_MultiTexCoord1dARB, fn) +#define CALL_MultiTexCoord1dvARB(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, const GLdouble *)), _gloffset_MultiTexCoord1dvARB, parameters) +#define GET_MultiTexCoord1dvARB(disp) GET_by_offset(disp, _gloffset_MultiTexCoord1dvARB) +#define SET_MultiTexCoord1dvARB(disp, fn) SET_by_offset(disp, _gloffset_MultiTexCoord1dvARB, fn) +#define CALL_MultiTexCoord1fARB(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLfloat)), _gloffset_MultiTexCoord1fARB, parameters) +#define GET_MultiTexCoord1fARB(disp) GET_by_offset(disp, _gloffset_MultiTexCoord1fARB) +#define SET_MultiTexCoord1fARB(disp, fn) SET_by_offset(disp, _gloffset_MultiTexCoord1fARB, fn) +#define CALL_MultiTexCoord1fvARB(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, const GLfloat *)), _gloffset_MultiTexCoord1fvARB, parameters) +#define GET_MultiTexCoord1fvARB(disp) GET_by_offset(disp, _gloffset_MultiTexCoord1fvARB) +#define SET_MultiTexCoord1fvARB(disp, fn) SET_by_offset(disp, _gloffset_MultiTexCoord1fvARB, fn) +#define CALL_MultiTexCoord1iARB(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLint)), _gloffset_MultiTexCoord1iARB, parameters) +#define GET_MultiTexCoord1iARB(disp) GET_by_offset(disp, _gloffset_MultiTexCoord1iARB) +#define SET_MultiTexCoord1iARB(disp, fn) SET_by_offset(disp, _gloffset_MultiTexCoord1iARB, fn) +#define CALL_MultiTexCoord1ivARB(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, const GLint *)), _gloffset_MultiTexCoord1ivARB, parameters) +#define GET_MultiTexCoord1ivARB(disp) GET_by_offset(disp, _gloffset_MultiTexCoord1ivARB) +#define SET_MultiTexCoord1ivARB(disp, fn) SET_by_offset(disp, _gloffset_MultiTexCoord1ivARB, fn) +#define CALL_MultiTexCoord1sARB(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLshort)), _gloffset_MultiTexCoord1sARB, parameters) +#define GET_MultiTexCoord1sARB(disp) GET_by_offset(disp, _gloffset_MultiTexCoord1sARB) +#define SET_MultiTexCoord1sARB(disp, fn) SET_by_offset(disp, _gloffset_MultiTexCoord1sARB, fn) +#define CALL_MultiTexCoord1svARB(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, const GLshort *)), _gloffset_MultiTexCoord1svARB, parameters) +#define GET_MultiTexCoord1svARB(disp) GET_by_offset(disp, _gloffset_MultiTexCoord1svARB) +#define SET_MultiTexCoord1svARB(disp, fn) SET_by_offset(disp, _gloffset_MultiTexCoord1svARB, fn) +#define CALL_MultiTexCoord2dARB(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLdouble, GLdouble)), _gloffset_MultiTexCoord2dARB, parameters) +#define GET_MultiTexCoord2dARB(disp) GET_by_offset(disp, _gloffset_MultiTexCoord2dARB) +#define SET_MultiTexCoord2dARB(disp, fn) SET_by_offset(disp, _gloffset_MultiTexCoord2dARB, fn) +#define CALL_MultiTexCoord2dvARB(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, const GLdouble *)), _gloffset_MultiTexCoord2dvARB, parameters) +#define GET_MultiTexCoord2dvARB(disp) GET_by_offset(disp, _gloffset_MultiTexCoord2dvARB) +#define SET_MultiTexCoord2dvARB(disp, fn) SET_by_offset(disp, _gloffset_MultiTexCoord2dvARB, fn) +#define CALL_MultiTexCoord2fARB(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLfloat, GLfloat)), _gloffset_MultiTexCoord2fARB, parameters) +#define GET_MultiTexCoord2fARB(disp) GET_by_offset(disp, _gloffset_MultiTexCoord2fARB) +#define SET_MultiTexCoord2fARB(disp, fn) SET_by_offset(disp, _gloffset_MultiTexCoord2fARB, fn) +#define CALL_MultiTexCoord2fvARB(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, const GLfloat *)), _gloffset_MultiTexCoord2fvARB, parameters) +#define GET_MultiTexCoord2fvARB(disp) GET_by_offset(disp, _gloffset_MultiTexCoord2fvARB) +#define SET_MultiTexCoord2fvARB(disp, fn) SET_by_offset(disp, _gloffset_MultiTexCoord2fvARB, fn) +#define CALL_MultiTexCoord2iARB(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLint, GLint)), _gloffset_MultiTexCoord2iARB, parameters) +#define GET_MultiTexCoord2iARB(disp) GET_by_offset(disp, _gloffset_MultiTexCoord2iARB) +#define SET_MultiTexCoord2iARB(disp, fn) SET_by_offset(disp, _gloffset_MultiTexCoord2iARB, fn) +#define CALL_MultiTexCoord2ivARB(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, const GLint *)), _gloffset_MultiTexCoord2ivARB, parameters) +#define GET_MultiTexCoord2ivARB(disp) GET_by_offset(disp, _gloffset_MultiTexCoord2ivARB) +#define SET_MultiTexCoord2ivARB(disp, fn) SET_by_offset(disp, _gloffset_MultiTexCoord2ivARB, fn) +#define CALL_MultiTexCoord2sARB(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLshort, GLshort)), _gloffset_MultiTexCoord2sARB, parameters) +#define GET_MultiTexCoord2sARB(disp) GET_by_offset(disp, _gloffset_MultiTexCoord2sARB) +#define SET_MultiTexCoord2sARB(disp, fn) SET_by_offset(disp, _gloffset_MultiTexCoord2sARB, fn) +#define CALL_MultiTexCoord2svARB(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, const GLshort *)), _gloffset_MultiTexCoord2svARB, parameters) +#define GET_MultiTexCoord2svARB(disp) GET_by_offset(disp, _gloffset_MultiTexCoord2svARB) +#define SET_MultiTexCoord2svARB(disp, fn) SET_by_offset(disp, _gloffset_MultiTexCoord2svARB, fn) +#define CALL_MultiTexCoord3dARB(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLdouble, GLdouble, GLdouble)), _gloffset_MultiTexCoord3dARB, parameters) +#define GET_MultiTexCoord3dARB(disp) GET_by_offset(disp, _gloffset_MultiTexCoord3dARB) +#define SET_MultiTexCoord3dARB(disp, fn) SET_by_offset(disp, _gloffset_MultiTexCoord3dARB, fn) +#define CALL_MultiTexCoord3dvARB(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, const GLdouble *)), _gloffset_MultiTexCoord3dvARB, parameters) +#define GET_MultiTexCoord3dvARB(disp) GET_by_offset(disp, _gloffset_MultiTexCoord3dvARB) +#define SET_MultiTexCoord3dvARB(disp, fn) SET_by_offset(disp, _gloffset_MultiTexCoord3dvARB, fn) +#define CALL_MultiTexCoord3fARB(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLfloat, GLfloat, GLfloat)), _gloffset_MultiTexCoord3fARB, parameters) +#define GET_MultiTexCoord3fARB(disp) GET_by_offset(disp, _gloffset_MultiTexCoord3fARB) +#define SET_MultiTexCoord3fARB(disp, fn) SET_by_offset(disp, _gloffset_MultiTexCoord3fARB, fn) +#define CALL_MultiTexCoord3fvARB(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, const GLfloat *)), _gloffset_MultiTexCoord3fvARB, parameters) +#define GET_MultiTexCoord3fvARB(disp) GET_by_offset(disp, _gloffset_MultiTexCoord3fvARB) +#define SET_MultiTexCoord3fvARB(disp, fn) SET_by_offset(disp, _gloffset_MultiTexCoord3fvARB, fn) +#define CALL_MultiTexCoord3iARB(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLint, GLint, GLint)), _gloffset_MultiTexCoord3iARB, parameters) +#define GET_MultiTexCoord3iARB(disp) GET_by_offset(disp, _gloffset_MultiTexCoord3iARB) +#define SET_MultiTexCoord3iARB(disp, fn) SET_by_offset(disp, _gloffset_MultiTexCoord3iARB, fn) +#define CALL_MultiTexCoord3ivARB(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, const GLint *)), _gloffset_MultiTexCoord3ivARB, parameters) +#define GET_MultiTexCoord3ivARB(disp) GET_by_offset(disp, _gloffset_MultiTexCoord3ivARB) +#define SET_MultiTexCoord3ivARB(disp, fn) SET_by_offset(disp, _gloffset_MultiTexCoord3ivARB, fn) +#define CALL_MultiTexCoord3sARB(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLshort, GLshort, GLshort)), _gloffset_MultiTexCoord3sARB, parameters) +#define GET_MultiTexCoord3sARB(disp) GET_by_offset(disp, _gloffset_MultiTexCoord3sARB) +#define SET_MultiTexCoord3sARB(disp, fn) SET_by_offset(disp, _gloffset_MultiTexCoord3sARB, fn) +#define CALL_MultiTexCoord3svARB(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, const GLshort *)), _gloffset_MultiTexCoord3svARB, parameters) +#define GET_MultiTexCoord3svARB(disp) GET_by_offset(disp, _gloffset_MultiTexCoord3svARB) +#define SET_MultiTexCoord3svARB(disp, fn) SET_by_offset(disp, _gloffset_MultiTexCoord3svARB, fn) +#define CALL_MultiTexCoord4dARB(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLdouble, GLdouble, GLdouble, GLdouble)), _gloffset_MultiTexCoord4dARB, parameters) +#define GET_MultiTexCoord4dARB(disp) GET_by_offset(disp, _gloffset_MultiTexCoord4dARB) +#define SET_MultiTexCoord4dARB(disp, fn) SET_by_offset(disp, _gloffset_MultiTexCoord4dARB, fn) +#define CALL_MultiTexCoord4dvARB(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, const GLdouble *)), _gloffset_MultiTexCoord4dvARB, parameters) +#define GET_MultiTexCoord4dvARB(disp) GET_by_offset(disp, _gloffset_MultiTexCoord4dvARB) +#define SET_MultiTexCoord4dvARB(disp, fn) SET_by_offset(disp, _gloffset_MultiTexCoord4dvARB, fn) +#define CALL_MultiTexCoord4fARB(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLfloat, GLfloat, GLfloat, GLfloat)), _gloffset_MultiTexCoord4fARB, parameters) +#define GET_MultiTexCoord4fARB(disp) GET_by_offset(disp, _gloffset_MultiTexCoord4fARB) +#define SET_MultiTexCoord4fARB(disp, fn) SET_by_offset(disp, _gloffset_MultiTexCoord4fARB, fn) +#define CALL_MultiTexCoord4fvARB(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, const GLfloat *)), _gloffset_MultiTexCoord4fvARB, parameters) +#define GET_MultiTexCoord4fvARB(disp) GET_by_offset(disp, _gloffset_MultiTexCoord4fvARB) +#define SET_MultiTexCoord4fvARB(disp, fn) SET_by_offset(disp, _gloffset_MultiTexCoord4fvARB, fn) +#define CALL_MultiTexCoord4iARB(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLint, GLint, GLint, GLint)), _gloffset_MultiTexCoord4iARB, parameters) +#define GET_MultiTexCoord4iARB(disp) GET_by_offset(disp, _gloffset_MultiTexCoord4iARB) +#define SET_MultiTexCoord4iARB(disp, fn) SET_by_offset(disp, _gloffset_MultiTexCoord4iARB, fn) +#define CALL_MultiTexCoord4ivARB(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, const GLint *)), _gloffset_MultiTexCoord4ivARB, parameters) +#define GET_MultiTexCoord4ivARB(disp) GET_by_offset(disp, _gloffset_MultiTexCoord4ivARB) +#define SET_MultiTexCoord4ivARB(disp, fn) SET_by_offset(disp, _gloffset_MultiTexCoord4ivARB, fn) +#define CALL_MultiTexCoord4sARB(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLshort, GLshort, GLshort, GLshort)), _gloffset_MultiTexCoord4sARB, parameters) +#define GET_MultiTexCoord4sARB(disp) GET_by_offset(disp, _gloffset_MultiTexCoord4sARB) +#define SET_MultiTexCoord4sARB(disp, fn) SET_by_offset(disp, _gloffset_MultiTexCoord4sARB, fn) +#define CALL_MultiTexCoord4svARB(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, const GLshort *)), _gloffset_MultiTexCoord4svARB, parameters) +#define GET_MultiTexCoord4svARB(disp) GET_by_offset(disp, _gloffset_MultiTexCoord4svARB) +#define SET_MultiTexCoord4svARB(disp, fn) SET_by_offset(disp, _gloffset_MultiTexCoord4svARB, fn) +#define CALL_GetBufferPointervOES(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLenum, GLvoid **)), _gloffset_GetBufferPointervOES, parameters) +#define GET_GetBufferPointervOES(disp) GET_by_offset(disp, _gloffset_GetBufferPointervOES) +#define SET_GetBufferPointervOES(disp, fn) SET_by_offset(disp, _gloffset_GetBufferPointervOES, fn) +#define CALL_MapBufferOES(disp, parameters) CALL_by_offset(disp, (GLvoid * (GLAPIENTRYP)(GLenum, GLenum)), _gloffset_MapBufferOES, parameters) +#define GET_MapBufferOES(disp) GET_by_offset(disp, _gloffset_MapBufferOES) +#define SET_MapBufferOES(disp, fn) SET_by_offset(disp, _gloffset_MapBufferOES, fn) +#define CALL_UnmapBufferOES(disp, parameters) CALL_by_offset(disp, (GLboolean (GLAPIENTRYP)(GLenum)), _gloffset_UnmapBufferOES, parameters) +#define GET_UnmapBufferOES(disp) GET_by_offset(disp, _gloffset_UnmapBufferOES) +#define SET_UnmapBufferOES(disp, fn) SET_by_offset(disp, _gloffset_UnmapBufferOES, fn) +#define CALL_CompressedTexImage3DOES(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLint, GLenum, GLsizei, GLsizei, GLsizei, GLint, GLsizei, const GLvoid *)), _gloffset_CompressedTexImage3DOES, parameters) +#define GET_CompressedTexImage3DOES(disp) GET_by_offset(disp, _gloffset_CompressedTexImage3DOES) +#define SET_CompressedTexImage3DOES(disp, fn) SET_by_offset(disp, _gloffset_CompressedTexImage3DOES, fn) +#define CALL_CompressedTexSubImage3DOES(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei, GLenum, GLsizei, const GLvoid *)), _gloffset_CompressedTexSubImage3DOES, parameters) +#define GET_CompressedTexSubImage3DOES(disp) GET_by_offset(disp, _gloffset_CompressedTexSubImage3DOES) +#define SET_CompressedTexSubImage3DOES(disp, fn) SET_by_offset(disp, _gloffset_CompressedTexSubImage3DOES, fn) +#define CALL_FramebufferTexture3DOES(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLenum, GLenum, GLuint, GLint, GLint)), _gloffset_FramebufferTexture3DOES, parameters) +#define GET_FramebufferTexture3DOES(disp) GET_by_offset(disp, _gloffset_FramebufferTexture3DOES) +#define SET_FramebufferTexture3DOES(disp, fn) SET_by_offset(disp, _gloffset_FramebufferTexture3DOES, fn) +#define CALL_GetProgramBinaryOES(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLuint, GLsizei, GLsizei *, GLenum *, GLvoid *)), _gloffset_GetProgramBinaryOES, parameters) +#define GET_GetProgramBinaryOES(disp) GET_by_offset(disp, _gloffset_GetProgramBinaryOES) +#define SET_GetProgramBinaryOES(disp, fn) SET_by_offset(disp, _gloffset_GetProgramBinaryOES, fn) +#define CALL_ProgramBinaryOES(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLuint, GLenum, const GLvoid *, GLint)), _gloffset_ProgramBinaryOES, parameters) +#define GET_ProgramBinaryOES(disp) GET_by_offset(disp, _gloffset_ProgramBinaryOES) +#define SET_ProgramBinaryOES(disp, fn) SET_by_offset(disp, _gloffset_ProgramBinaryOES, fn) +#define CALL_MultiDrawArraysEXT(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, const GLint *, const GLsizei *, GLsizei)), _gloffset_MultiDrawArraysEXT, parameters) +#define GET_MultiDrawArraysEXT(disp) GET_by_offset(disp, _gloffset_MultiDrawArraysEXT) +#define SET_MultiDrawArraysEXT(disp, fn) SET_by_offset(disp, _gloffset_MultiDrawArraysEXT, fn) +#define CALL_MultiDrawElementsEXT(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, const GLsizei *, GLenum, const GLvoid **, GLsizei)), _gloffset_MultiDrawElementsEXT, parameters) +#define GET_MultiDrawElementsEXT(disp) GET_by_offset(disp, _gloffset_MultiDrawElementsEXT) +#define SET_MultiDrawElementsEXT(disp, fn) SET_by_offset(disp, _gloffset_MultiDrawElementsEXT, fn) +#define CALL_BindVertexArrayAPPLE(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLuint)), _gloffset_BindVertexArrayAPPLE, parameters) +#define GET_BindVertexArrayAPPLE(disp) GET_by_offset(disp, _gloffset_BindVertexArrayAPPLE) +#define SET_BindVertexArrayAPPLE(disp, fn) SET_by_offset(disp, _gloffset_BindVertexArrayAPPLE, fn) +#define CALL_DeleteVertexArraysAPPLE(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLsizei, const GLuint *)), _gloffset_DeleteVertexArraysAPPLE, parameters) +#define GET_DeleteVertexArraysAPPLE(disp) GET_by_offset(disp, _gloffset_DeleteVertexArraysAPPLE) +#define SET_DeleteVertexArraysAPPLE(disp, fn) SET_by_offset(disp, _gloffset_DeleteVertexArraysAPPLE, fn) +#define CALL_GenVertexArraysAPPLE(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLsizei, GLuint *)), _gloffset_GenVertexArraysAPPLE, parameters) +#define GET_GenVertexArraysAPPLE(disp) GET_by_offset(disp, _gloffset_GenVertexArraysAPPLE) +#define SET_GenVertexArraysAPPLE(disp, fn) SET_by_offset(disp, _gloffset_GenVertexArraysAPPLE, fn) +#define CALL_IsVertexArrayAPPLE(disp, parameters) CALL_by_offset(disp, (GLboolean (GLAPIENTRYP)(GLuint)), _gloffset_IsVertexArrayAPPLE, parameters) +#define GET_IsVertexArrayAPPLE(disp) GET_by_offset(disp, _gloffset_IsVertexArrayAPPLE) +#define SET_IsVertexArrayAPPLE(disp, fn) SET_by_offset(disp, _gloffset_IsVertexArrayAPPLE, fn) +#define CALL_EGLImageTargetRenderbufferStorageOES(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLvoid *)), _gloffset_EGLImageTargetRenderbufferStorageOES, parameters) +#define GET_EGLImageTargetRenderbufferStorageOES(disp) GET_by_offset(disp, _gloffset_EGLImageTargetRenderbufferStorageOES) +#define SET_EGLImageTargetRenderbufferStorageOES(disp, fn) SET_by_offset(disp, _gloffset_EGLImageTargetRenderbufferStorageOES, fn) +#define CALL_EGLImageTargetTexture2DOES(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLvoid *)), _gloffset_EGLImageTargetTexture2DOES, parameters) +#define GET_EGLImageTargetTexture2DOES(disp) GET_by_offset(disp, _gloffset_EGLImageTargetTexture2DOES) +#define SET_EGLImageTargetTexture2DOES(disp, fn) SET_by_offset(disp, _gloffset_EGLImageTargetTexture2DOES, fn) +#define CALL_CompressedTexImage2D(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLint, GLenum, GLsizei, GLsizei, GLint, GLsizei, const GLvoid *)), _gloffset_CompressedTexImage2D, parameters) +#define GET_CompressedTexImage2D(disp) GET_by_offset(disp, _gloffset_CompressedTexImage2D) +#define SET_CompressedTexImage2D(disp, fn) SET_by_offset(disp, _gloffset_CompressedTexImage2D, fn) +#define CALL_CompressedTexSubImage2D(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLint, GLint, GLint, GLsizei, GLsizei, GLenum, GLsizei, const GLvoid *)), _gloffset_CompressedTexSubImage2D, parameters) +#define GET_CompressedTexSubImage2D(disp) GET_by_offset(disp, _gloffset_CompressedTexSubImage2D) +#define SET_CompressedTexSubImage2D(disp, fn) SET_by_offset(disp, _gloffset_CompressedTexSubImage2D, fn) +#define CALL_SampleCoverage(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLclampf, GLboolean)), _gloffset_SampleCoverage, parameters) +#define GET_SampleCoverage(disp) GET_by_offset(disp, _gloffset_SampleCoverage) +#define SET_SampleCoverage(disp, fn) SET_by_offset(disp, _gloffset_SampleCoverage, fn) +#define CALL_BindBuffer(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLuint)), _gloffset_BindBuffer, parameters) +#define GET_BindBuffer(disp) GET_by_offset(disp, _gloffset_BindBuffer) +#define SET_BindBuffer(disp, fn) SET_by_offset(disp, _gloffset_BindBuffer, fn) +#define CALL_BufferData(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLsizeiptr, const GLvoid *, GLenum)), _gloffset_BufferData, parameters) +#define GET_BufferData(disp) GET_by_offset(disp, _gloffset_BufferData) +#define SET_BufferData(disp, fn) SET_by_offset(disp, _gloffset_BufferData, fn) +#define CALL_BufferSubData(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLintptr, GLsizeiptr, const GLvoid *)), _gloffset_BufferSubData, parameters) +#define GET_BufferSubData(disp) GET_by_offset(disp, _gloffset_BufferSubData) +#define SET_BufferSubData(disp, fn) SET_by_offset(disp, _gloffset_BufferSubData, fn) +#define CALL_DeleteBuffers(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLsizei, const GLuint *)), _gloffset_DeleteBuffers, parameters) +#define GET_DeleteBuffers(disp) GET_by_offset(disp, _gloffset_DeleteBuffers) +#define SET_DeleteBuffers(disp, fn) SET_by_offset(disp, _gloffset_DeleteBuffers, fn) +#define CALL_GenBuffers(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLsizei, GLuint *)), _gloffset_GenBuffers, parameters) +#define GET_GenBuffers(disp) GET_by_offset(disp, _gloffset_GenBuffers) +#define SET_GenBuffers(disp, fn) SET_by_offset(disp, _gloffset_GenBuffers, fn) +#define CALL_GetBufferParameteriv(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLenum, GLint *)), _gloffset_GetBufferParameteriv, parameters) +#define GET_GetBufferParameteriv(disp) GET_by_offset(disp, _gloffset_GetBufferParameteriv) +#define SET_GetBufferParameteriv(disp, fn) SET_by_offset(disp, _gloffset_GetBufferParameteriv, fn) +#define CALL_IsBuffer(disp, parameters) CALL_by_offset(disp, (GLboolean (GLAPIENTRYP)(GLuint)), _gloffset_IsBuffer, parameters) +#define GET_IsBuffer(disp) GET_by_offset(disp, _gloffset_IsBuffer) +#define SET_IsBuffer(disp, fn) SET_by_offset(disp, _gloffset_IsBuffer, fn) +#define CALL_AttachShader(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLuint, GLuint)), _gloffset_AttachShader, parameters) +#define GET_AttachShader(disp) GET_by_offset(disp, _gloffset_AttachShader) +#define SET_AttachShader(disp, fn) SET_by_offset(disp, _gloffset_AttachShader, fn) +#define CALL_BindAttribLocation(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLuint, GLuint, const GLchar *)), _gloffset_BindAttribLocation, parameters) +#define GET_BindAttribLocation(disp) GET_by_offset(disp, _gloffset_BindAttribLocation) +#define SET_BindAttribLocation(disp, fn) SET_by_offset(disp, _gloffset_BindAttribLocation, fn) +#define CALL_BlendEquationSeparate(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLenum)), _gloffset_BlendEquationSeparate, parameters) +#define GET_BlendEquationSeparate(disp) GET_by_offset(disp, _gloffset_BlendEquationSeparate) +#define SET_BlendEquationSeparate(disp, fn) SET_by_offset(disp, _gloffset_BlendEquationSeparate, fn) +#define CALL_CompileShader(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLuint)), _gloffset_CompileShader, parameters) +#define GET_CompileShader(disp) GET_by_offset(disp, _gloffset_CompileShader) +#define SET_CompileShader(disp, fn) SET_by_offset(disp, _gloffset_CompileShader, fn) +#define CALL_CreateProgram(disp, parameters) CALL_by_offset(disp, (GLuint (GLAPIENTRYP)(void)), _gloffset_CreateProgram, parameters) +#define GET_CreateProgram(disp) GET_by_offset(disp, _gloffset_CreateProgram) +#define SET_CreateProgram(disp, fn) SET_by_offset(disp, _gloffset_CreateProgram, fn) +#define CALL_CreateShader(disp, parameters) CALL_by_offset(disp, (GLuint (GLAPIENTRYP)(GLenum)), _gloffset_CreateShader, parameters) +#define GET_CreateShader(disp) GET_by_offset(disp, _gloffset_CreateShader) +#define SET_CreateShader(disp, fn) SET_by_offset(disp, _gloffset_CreateShader, fn) +#define CALL_DeleteProgram(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLuint)), _gloffset_DeleteProgram, parameters) +#define GET_DeleteProgram(disp) GET_by_offset(disp, _gloffset_DeleteProgram) +#define SET_DeleteProgram(disp, fn) SET_by_offset(disp, _gloffset_DeleteProgram, fn) +#define CALL_DeleteShader(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLuint)), _gloffset_DeleteShader, parameters) +#define GET_DeleteShader(disp) GET_by_offset(disp, _gloffset_DeleteShader) +#define SET_DeleteShader(disp, fn) SET_by_offset(disp, _gloffset_DeleteShader, fn) +#define CALL_DetachShader(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLuint, GLuint)), _gloffset_DetachShader, parameters) +#define GET_DetachShader(disp) GET_by_offset(disp, _gloffset_DetachShader) +#define SET_DetachShader(disp, fn) SET_by_offset(disp, _gloffset_DetachShader, fn) +#define CALL_DisableVertexAttribArray(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLuint)), _gloffset_DisableVertexAttribArray, parameters) +#define GET_DisableVertexAttribArray(disp) GET_by_offset(disp, _gloffset_DisableVertexAttribArray) +#define SET_DisableVertexAttribArray(disp, fn) SET_by_offset(disp, _gloffset_DisableVertexAttribArray, fn) +#define CALL_EnableVertexAttribArray(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLuint)), _gloffset_EnableVertexAttribArray, parameters) +#define GET_EnableVertexAttribArray(disp) GET_by_offset(disp, _gloffset_EnableVertexAttribArray) +#define SET_EnableVertexAttribArray(disp, fn) SET_by_offset(disp, _gloffset_EnableVertexAttribArray, fn) +#define CALL_GetActiveAttrib(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLuint, GLuint, GLsizei , GLsizei *, GLint *, GLenum *, GLchar *)), _gloffset_GetActiveAttrib, parameters) +#define GET_GetActiveAttrib(disp) GET_by_offset(disp, _gloffset_GetActiveAttrib) +#define SET_GetActiveAttrib(disp, fn) SET_by_offset(disp, _gloffset_GetActiveAttrib, fn) +#define CALL_GetActiveUniform(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLuint, GLuint, GLsizei, GLsizei *, GLint *, GLenum *, GLchar *)), _gloffset_GetActiveUniform, parameters) +#define GET_GetActiveUniform(disp) GET_by_offset(disp, _gloffset_GetActiveUniform) +#define SET_GetActiveUniform(disp, fn) SET_by_offset(disp, _gloffset_GetActiveUniform, fn) +#define CALL_GetAttachedShaders(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLuint, GLsizei, GLsizei *, GLuint *)), _gloffset_GetAttachedShaders, parameters) +#define GET_GetAttachedShaders(disp) GET_by_offset(disp, _gloffset_GetAttachedShaders) +#define SET_GetAttachedShaders(disp, fn) SET_by_offset(disp, _gloffset_GetAttachedShaders, fn) +#define CALL_GetAttribLocation(disp, parameters) CALL_by_offset(disp, (GLint (GLAPIENTRYP)(GLuint, const GLchar *)), _gloffset_GetAttribLocation, parameters) +#define GET_GetAttribLocation(disp) GET_by_offset(disp, _gloffset_GetAttribLocation) +#define SET_GetAttribLocation(disp, fn) SET_by_offset(disp, _gloffset_GetAttribLocation, fn) +#define CALL_GetProgramInfoLog(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLuint, GLsizei, GLsizei *, GLchar *)), _gloffset_GetProgramInfoLog, parameters) +#define GET_GetProgramInfoLog(disp) GET_by_offset(disp, _gloffset_GetProgramInfoLog) +#define SET_GetProgramInfoLog(disp, fn) SET_by_offset(disp, _gloffset_GetProgramInfoLog, fn) +#define CALL_GetProgramiv(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLuint, GLenum, GLint *)), _gloffset_GetProgramiv, parameters) +#define GET_GetProgramiv(disp) GET_by_offset(disp, _gloffset_GetProgramiv) +#define SET_GetProgramiv(disp, fn) SET_by_offset(disp, _gloffset_GetProgramiv, fn) +#define CALL_GetShaderInfoLog(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLuint, GLsizei, GLsizei *, GLchar *)), _gloffset_GetShaderInfoLog, parameters) +#define GET_GetShaderInfoLog(disp) GET_by_offset(disp, _gloffset_GetShaderInfoLog) +#define SET_GetShaderInfoLog(disp, fn) SET_by_offset(disp, _gloffset_GetShaderInfoLog, fn) +#define CALL_GetShaderSource(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLuint, GLsizei, GLsizei *, GLchar *)), _gloffset_GetShaderSource, parameters) +#define GET_GetShaderSource(disp) GET_by_offset(disp, _gloffset_GetShaderSource) +#define SET_GetShaderSource(disp, fn) SET_by_offset(disp, _gloffset_GetShaderSource, fn) +#define CALL_GetShaderiv(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLuint, GLenum, GLint *)), _gloffset_GetShaderiv, parameters) +#define GET_GetShaderiv(disp) GET_by_offset(disp, _gloffset_GetShaderiv) +#define SET_GetShaderiv(disp, fn) SET_by_offset(disp, _gloffset_GetShaderiv, fn) +#define CALL_GetUniformLocation(disp, parameters) CALL_by_offset(disp, (GLint (GLAPIENTRYP)(GLuint, const GLchar *)), _gloffset_GetUniformLocation, parameters) +#define GET_GetUniformLocation(disp) GET_by_offset(disp, _gloffset_GetUniformLocation) +#define SET_GetUniformLocation(disp, fn) SET_by_offset(disp, _gloffset_GetUniformLocation, fn) +#define CALL_GetUniformfv(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLuint, GLint, GLfloat *)), _gloffset_GetUniformfv, parameters) +#define GET_GetUniformfv(disp) GET_by_offset(disp, _gloffset_GetUniformfv) +#define SET_GetUniformfv(disp, fn) SET_by_offset(disp, _gloffset_GetUniformfv, fn) +#define CALL_GetUniformiv(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLuint, GLint, GLint *)), _gloffset_GetUniformiv, parameters) +#define GET_GetUniformiv(disp) GET_by_offset(disp, _gloffset_GetUniformiv) +#define SET_GetUniformiv(disp, fn) SET_by_offset(disp, _gloffset_GetUniformiv, fn) +#define CALL_GetVertexAttribPointerv(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLuint, GLenum, GLvoid **)), _gloffset_GetVertexAttribPointerv, parameters) +#define GET_GetVertexAttribPointerv(disp) GET_by_offset(disp, _gloffset_GetVertexAttribPointerv) +#define SET_GetVertexAttribPointerv(disp, fn) SET_by_offset(disp, _gloffset_GetVertexAttribPointerv, fn) +#define CALL_GetVertexAttribfv(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLuint, GLenum, GLfloat *)), _gloffset_GetVertexAttribfv, parameters) +#define GET_GetVertexAttribfv(disp) GET_by_offset(disp, _gloffset_GetVertexAttribfv) +#define SET_GetVertexAttribfv(disp, fn) SET_by_offset(disp, _gloffset_GetVertexAttribfv, fn) +#define CALL_GetVertexAttribiv(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLuint, GLenum, GLint *)), _gloffset_GetVertexAttribiv, parameters) +#define GET_GetVertexAttribiv(disp) GET_by_offset(disp, _gloffset_GetVertexAttribiv) +#define SET_GetVertexAttribiv(disp, fn) SET_by_offset(disp, _gloffset_GetVertexAttribiv, fn) +#define CALL_IsProgram(disp, parameters) CALL_by_offset(disp, (GLboolean (GLAPIENTRYP)(GLuint)), _gloffset_IsProgram, parameters) +#define GET_IsProgram(disp) GET_by_offset(disp, _gloffset_IsProgram) +#define SET_IsProgram(disp, fn) SET_by_offset(disp, _gloffset_IsProgram, fn) +#define CALL_IsShader(disp, parameters) CALL_by_offset(disp, (GLboolean (GLAPIENTRYP)(GLuint)), _gloffset_IsShader, parameters) +#define GET_IsShader(disp) GET_by_offset(disp, _gloffset_IsShader) +#define SET_IsShader(disp, fn) SET_by_offset(disp, _gloffset_IsShader, fn) +#define CALL_LinkProgram(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLuint)), _gloffset_LinkProgram, parameters) +#define GET_LinkProgram(disp) GET_by_offset(disp, _gloffset_LinkProgram) +#define SET_LinkProgram(disp, fn) SET_by_offset(disp, _gloffset_LinkProgram, fn) +#define CALL_ShaderSource(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLuint, GLsizei, const GLchar **, const GLint *)), _gloffset_ShaderSource, parameters) +#define GET_ShaderSource(disp) GET_by_offset(disp, _gloffset_ShaderSource) +#define SET_ShaderSource(disp, fn) SET_by_offset(disp, _gloffset_ShaderSource, fn) +#define CALL_StencilFuncSeparate(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLenum, GLint, GLuint)), _gloffset_StencilFuncSeparate, parameters) +#define GET_StencilFuncSeparate(disp) GET_by_offset(disp, _gloffset_StencilFuncSeparate) +#define SET_StencilFuncSeparate(disp, fn) SET_by_offset(disp, _gloffset_StencilFuncSeparate, fn) +#define CALL_StencilMaskSeparate(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLuint)), _gloffset_StencilMaskSeparate, parameters) +#define GET_StencilMaskSeparate(disp) GET_by_offset(disp, _gloffset_StencilMaskSeparate) +#define SET_StencilMaskSeparate(disp, fn) SET_by_offset(disp, _gloffset_StencilMaskSeparate, fn) +#define CALL_StencilOpSeparate(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLenum, GLenum, GLenum)), _gloffset_StencilOpSeparate, parameters) +#define GET_StencilOpSeparate(disp) GET_by_offset(disp, _gloffset_StencilOpSeparate) +#define SET_StencilOpSeparate(disp, fn) SET_by_offset(disp, _gloffset_StencilOpSeparate, fn) +#define CALL_Uniform1f(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLint, GLfloat)), _gloffset_Uniform1f, parameters) +#define GET_Uniform1f(disp) GET_by_offset(disp, _gloffset_Uniform1f) +#define SET_Uniform1f(disp, fn) SET_by_offset(disp, _gloffset_Uniform1f, fn) +#define CALL_Uniform1fv(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLint, GLsizei, const GLfloat *)), _gloffset_Uniform1fv, parameters) +#define GET_Uniform1fv(disp) GET_by_offset(disp, _gloffset_Uniform1fv) +#define SET_Uniform1fv(disp, fn) SET_by_offset(disp, _gloffset_Uniform1fv, fn) +#define CALL_Uniform1i(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLint, GLint)), _gloffset_Uniform1i, parameters) +#define GET_Uniform1i(disp) GET_by_offset(disp, _gloffset_Uniform1i) +#define SET_Uniform1i(disp, fn) SET_by_offset(disp, _gloffset_Uniform1i, fn) +#define CALL_Uniform1iv(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLint, GLsizei, const GLint *)), _gloffset_Uniform1iv, parameters) +#define GET_Uniform1iv(disp) GET_by_offset(disp, _gloffset_Uniform1iv) +#define SET_Uniform1iv(disp, fn) SET_by_offset(disp, _gloffset_Uniform1iv, fn) +#define CALL_Uniform2f(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLint, GLfloat, GLfloat)), _gloffset_Uniform2f, parameters) +#define GET_Uniform2f(disp) GET_by_offset(disp, _gloffset_Uniform2f) +#define SET_Uniform2f(disp, fn) SET_by_offset(disp, _gloffset_Uniform2f, fn) +#define CALL_Uniform2fv(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLint, GLsizei, const GLfloat *)), _gloffset_Uniform2fv, parameters) +#define GET_Uniform2fv(disp) GET_by_offset(disp, _gloffset_Uniform2fv) +#define SET_Uniform2fv(disp, fn) SET_by_offset(disp, _gloffset_Uniform2fv, fn) +#define CALL_Uniform2i(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLint, GLint, GLint)), _gloffset_Uniform2i, parameters) +#define GET_Uniform2i(disp) GET_by_offset(disp, _gloffset_Uniform2i) +#define SET_Uniform2i(disp, fn) SET_by_offset(disp, _gloffset_Uniform2i, fn) +#define CALL_Uniform2iv(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLint, GLsizei, const GLint *)), _gloffset_Uniform2iv, parameters) +#define GET_Uniform2iv(disp) GET_by_offset(disp, _gloffset_Uniform2iv) +#define SET_Uniform2iv(disp, fn) SET_by_offset(disp, _gloffset_Uniform2iv, fn) +#define CALL_Uniform3f(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLint, GLfloat, GLfloat, GLfloat)), _gloffset_Uniform3f, parameters) +#define GET_Uniform3f(disp) GET_by_offset(disp, _gloffset_Uniform3f) +#define SET_Uniform3f(disp, fn) SET_by_offset(disp, _gloffset_Uniform3f, fn) +#define CALL_Uniform3fv(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLint, GLsizei, const GLfloat *)), _gloffset_Uniform3fv, parameters) +#define GET_Uniform3fv(disp) GET_by_offset(disp, _gloffset_Uniform3fv) +#define SET_Uniform3fv(disp, fn) SET_by_offset(disp, _gloffset_Uniform3fv, fn) +#define CALL_Uniform3i(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLint, GLint, GLint, GLint)), _gloffset_Uniform3i, parameters) +#define GET_Uniform3i(disp) GET_by_offset(disp, _gloffset_Uniform3i) +#define SET_Uniform3i(disp, fn) SET_by_offset(disp, _gloffset_Uniform3i, fn) +#define CALL_Uniform3iv(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLint, GLsizei, const GLint *)), _gloffset_Uniform3iv, parameters) +#define GET_Uniform3iv(disp) GET_by_offset(disp, _gloffset_Uniform3iv) +#define SET_Uniform3iv(disp, fn) SET_by_offset(disp, _gloffset_Uniform3iv, fn) +#define CALL_Uniform4f(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLint, GLfloat, GLfloat, GLfloat, GLfloat)), _gloffset_Uniform4f, parameters) +#define GET_Uniform4f(disp) GET_by_offset(disp, _gloffset_Uniform4f) +#define SET_Uniform4f(disp, fn) SET_by_offset(disp, _gloffset_Uniform4f, fn) +#define CALL_Uniform4fv(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLint, GLsizei, const GLfloat *)), _gloffset_Uniform4fv, parameters) +#define GET_Uniform4fv(disp) GET_by_offset(disp, _gloffset_Uniform4fv) +#define SET_Uniform4fv(disp, fn) SET_by_offset(disp, _gloffset_Uniform4fv, fn) +#define CALL_Uniform4i(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLint, GLint, GLint, GLint, GLint)), _gloffset_Uniform4i, parameters) +#define GET_Uniform4i(disp) GET_by_offset(disp, _gloffset_Uniform4i) +#define SET_Uniform4i(disp, fn) SET_by_offset(disp, _gloffset_Uniform4i, fn) +#define CALL_Uniform4iv(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLint, GLsizei, const GLint *)), _gloffset_Uniform4iv, parameters) +#define GET_Uniform4iv(disp) GET_by_offset(disp, _gloffset_Uniform4iv) +#define SET_Uniform4iv(disp, fn) SET_by_offset(disp, _gloffset_Uniform4iv, fn) +#define CALL_UniformMatrix2fv(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLint, GLsizei, GLboolean, const GLfloat *)), _gloffset_UniformMatrix2fv, parameters) +#define GET_UniformMatrix2fv(disp) GET_by_offset(disp, _gloffset_UniformMatrix2fv) +#define SET_UniformMatrix2fv(disp, fn) SET_by_offset(disp, _gloffset_UniformMatrix2fv, fn) +#define CALL_UniformMatrix3fv(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLint, GLsizei, GLboolean, const GLfloat *)), _gloffset_UniformMatrix3fv, parameters) +#define GET_UniformMatrix3fv(disp) GET_by_offset(disp, _gloffset_UniformMatrix3fv) +#define SET_UniformMatrix3fv(disp, fn) SET_by_offset(disp, _gloffset_UniformMatrix3fv, fn) +#define CALL_UniformMatrix4fv(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLint, GLsizei, GLboolean, const GLfloat *)), _gloffset_UniformMatrix4fv, parameters) +#define GET_UniformMatrix4fv(disp) GET_by_offset(disp, _gloffset_UniformMatrix4fv) +#define SET_UniformMatrix4fv(disp, fn) SET_by_offset(disp, _gloffset_UniformMatrix4fv, fn) +#define CALL_UseProgram(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLuint)), _gloffset_UseProgram, parameters) +#define GET_UseProgram(disp) GET_by_offset(disp, _gloffset_UseProgram) +#define SET_UseProgram(disp, fn) SET_by_offset(disp, _gloffset_UseProgram, fn) +#define CALL_ValidateProgram(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLuint)), _gloffset_ValidateProgram, parameters) +#define GET_ValidateProgram(disp) GET_by_offset(disp, _gloffset_ValidateProgram) +#define SET_ValidateProgram(disp, fn) SET_by_offset(disp, _gloffset_ValidateProgram, fn) +#define CALL_VertexAttrib1f(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLuint, GLfloat)), _gloffset_VertexAttrib1f, parameters) +#define GET_VertexAttrib1f(disp) GET_by_offset(disp, _gloffset_VertexAttrib1f) +#define SET_VertexAttrib1f(disp, fn) SET_by_offset(disp, _gloffset_VertexAttrib1f, fn) +#define CALL_VertexAttrib1fv(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLuint, const GLfloat *)), _gloffset_VertexAttrib1fv, parameters) +#define GET_VertexAttrib1fv(disp) GET_by_offset(disp, _gloffset_VertexAttrib1fv) +#define SET_VertexAttrib1fv(disp, fn) SET_by_offset(disp, _gloffset_VertexAttrib1fv, fn) +#define CALL_VertexAttrib2f(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLuint, GLfloat, GLfloat)), _gloffset_VertexAttrib2f, parameters) +#define GET_VertexAttrib2f(disp) GET_by_offset(disp, _gloffset_VertexAttrib2f) +#define SET_VertexAttrib2f(disp, fn) SET_by_offset(disp, _gloffset_VertexAttrib2f, fn) +#define CALL_VertexAttrib2fv(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLuint, const GLfloat *)), _gloffset_VertexAttrib2fv, parameters) +#define GET_VertexAttrib2fv(disp) GET_by_offset(disp, _gloffset_VertexAttrib2fv) +#define SET_VertexAttrib2fv(disp, fn) SET_by_offset(disp, _gloffset_VertexAttrib2fv, fn) +#define CALL_VertexAttrib3f(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLuint, GLfloat, GLfloat, GLfloat)), _gloffset_VertexAttrib3f, parameters) +#define GET_VertexAttrib3f(disp) GET_by_offset(disp, _gloffset_VertexAttrib3f) +#define SET_VertexAttrib3f(disp, fn) SET_by_offset(disp, _gloffset_VertexAttrib3f, fn) +#define CALL_VertexAttrib3fv(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLuint, const GLfloat *)), _gloffset_VertexAttrib3fv, parameters) +#define GET_VertexAttrib3fv(disp) GET_by_offset(disp, _gloffset_VertexAttrib3fv) +#define SET_VertexAttrib3fv(disp, fn) SET_by_offset(disp, _gloffset_VertexAttrib3fv, fn) +#define CALL_VertexAttrib4f(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLuint, GLfloat, GLfloat, GLfloat, GLfloat)), _gloffset_VertexAttrib4f, parameters) +#define GET_VertexAttrib4f(disp) GET_by_offset(disp, _gloffset_VertexAttrib4f) +#define SET_VertexAttrib4f(disp, fn) SET_by_offset(disp, _gloffset_VertexAttrib4f, fn) +#define CALL_VertexAttrib4fv(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLuint, const GLfloat *)), _gloffset_VertexAttrib4fv, parameters) +#define GET_VertexAttrib4fv(disp) GET_by_offset(disp, _gloffset_VertexAttrib4fv) +#define SET_VertexAttrib4fv(disp, fn) SET_by_offset(disp, _gloffset_VertexAttrib4fv, fn) +#define CALL_VertexAttribPointer(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLuint, GLint, GLenum, GLboolean, GLsizei, const GLvoid *)), _gloffset_VertexAttribPointer, parameters) +#define GET_VertexAttribPointer(disp) GET_by_offset(disp, _gloffset_VertexAttribPointer) +#define SET_VertexAttribPointer(disp, fn) SET_by_offset(disp, _gloffset_VertexAttribPointer, fn) +#define CALL_BlendFuncSeparate(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLenum, GLenum, GLenum)), _gloffset_BlendFuncSeparate, parameters) +#define GET_BlendFuncSeparate(disp) GET_by_offset(disp, _gloffset_BlendFuncSeparate) +#define SET_BlendFuncSeparate(disp, fn) SET_by_offset(disp, _gloffset_BlendFuncSeparate, fn) +#define CALL_BindFramebuffer(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLuint)), _gloffset_BindFramebuffer, parameters) +#define GET_BindFramebuffer(disp) GET_by_offset(disp, _gloffset_BindFramebuffer) +#define SET_BindFramebuffer(disp, fn) SET_by_offset(disp, _gloffset_BindFramebuffer, fn) +#define CALL_BindRenderbuffer(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLuint)), _gloffset_BindRenderbuffer, parameters) +#define GET_BindRenderbuffer(disp) GET_by_offset(disp, _gloffset_BindRenderbuffer) +#define SET_BindRenderbuffer(disp, fn) SET_by_offset(disp, _gloffset_BindRenderbuffer, fn) +#define CALL_CheckFramebufferStatus(disp, parameters) CALL_by_offset(disp, (GLenum (GLAPIENTRYP)(GLenum)), _gloffset_CheckFramebufferStatus, parameters) +#define GET_CheckFramebufferStatus(disp) GET_by_offset(disp, _gloffset_CheckFramebufferStatus) +#define SET_CheckFramebufferStatus(disp, fn) SET_by_offset(disp, _gloffset_CheckFramebufferStatus, fn) +#define CALL_ClearDepthf(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLclampf)), _gloffset_ClearDepthf, parameters) +#define GET_ClearDepthf(disp) GET_by_offset(disp, _gloffset_ClearDepthf) +#define SET_ClearDepthf(disp, fn) SET_by_offset(disp, _gloffset_ClearDepthf, fn) +#define CALL_DeleteFramebuffers(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLsizei, const GLuint *)), _gloffset_DeleteFramebuffers, parameters) +#define GET_DeleteFramebuffers(disp) GET_by_offset(disp, _gloffset_DeleteFramebuffers) +#define SET_DeleteFramebuffers(disp, fn) SET_by_offset(disp, _gloffset_DeleteFramebuffers, fn) +#define CALL_DeleteRenderbuffers(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLsizei, const GLuint *)), _gloffset_DeleteRenderbuffers, parameters) +#define GET_DeleteRenderbuffers(disp) GET_by_offset(disp, _gloffset_DeleteRenderbuffers) +#define SET_DeleteRenderbuffers(disp, fn) SET_by_offset(disp, _gloffset_DeleteRenderbuffers, fn) +#define CALL_DepthRangef(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLclampf, GLclampf)), _gloffset_DepthRangef, parameters) +#define GET_DepthRangef(disp) GET_by_offset(disp, _gloffset_DepthRangef) +#define SET_DepthRangef(disp, fn) SET_by_offset(disp, _gloffset_DepthRangef, fn) +#define CALL_FramebufferRenderbuffer(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLenum, GLenum, GLuint)), _gloffset_FramebufferRenderbuffer, parameters) +#define GET_FramebufferRenderbuffer(disp) GET_by_offset(disp, _gloffset_FramebufferRenderbuffer) +#define SET_FramebufferRenderbuffer(disp, fn) SET_by_offset(disp, _gloffset_FramebufferRenderbuffer, fn) +#define CALL_FramebufferTexture2D(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLenum, GLenum, GLuint, GLint)), _gloffset_FramebufferTexture2D, parameters) +#define GET_FramebufferTexture2D(disp) GET_by_offset(disp, _gloffset_FramebufferTexture2D) +#define SET_FramebufferTexture2D(disp, fn) SET_by_offset(disp, _gloffset_FramebufferTexture2D, fn) +#define CALL_GenFramebuffers(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLsizei, GLuint *)), _gloffset_GenFramebuffers, parameters) +#define GET_GenFramebuffers(disp) GET_by_offset(disp, _gloffset_GenFramebuffers) +#define SET_GenFramebuffers(disp, fn) SET_by_offset(disp, _gloffset_GenFramebuffers, fn) +#define CALL_GenRenderbuffers(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLsizei, GLuint *)), _gloffset_GenRenderbuffers, parameters) +#define GET_GenRenderbuffers(disp) GET_by_offset(disp, _gloffset_GenRenderbuffers) +#define SET_GenRenderbuffers(disp, fn) SET_by_offset(disp, _gloffset_GenRenderbuffers, fn) +#define CALL_GenerateMipmap(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum)), _gloffset_GenerateMipmap, parameters) +#define GET_GenerateMipmap(disp) GET_by_offset(disp, _gloffset_GenerateMipmap) +#define SET_GenerateMipmap(disp, fn) SET_by_offset(disp, _gloffset_GenerateMipmap, fn) +#define CALL_GetFramebufferAttachmentParameteriv(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLenum, GLenum, GLint *)), _gloffset_GetFramebufferAttachmentParameteriv, parameters) +#define GET_GetFramebufferAttachmentParameteriv(disp) GET_by_offset(disp, _gloffset_GetFramebufferAttachmentParameteriv) +#define SET_GetFramebufferAttachmentParameteriv(disp, fn) SET_by_offset(disp, _gloffset_GetFramebufferAttachmentParameteriv, fn) +#define CALL_GetRenderbufferParameteriv(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLenum, GLint *)), _gloffset_GetRenderbufferParameteriv, parameters) +#define GET_GetRenderbufferParameteriv(disp) GET_by_offset(disp, _gloffset_GetRenderbufferParameteriv) +#define SET_GetRenderbufferParameteriv(disp, fn) SET_by_offset(disp, _gloffset_GetRenderbufferParameteriv, fn) +#define CALL_GetShaderPrecisionFormat(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLenum, GLint *, GLint *)), _gloffset_GetShaderPrecisionFormat, parameters) +#define GET_GetShaderPrecisionFormat(disp) GET_by_offset(disp, _gloffset_GetShaderPrecisionFormat) +#define SET_GetShaderPrecisionFormat(disp, fn) SET_by_offset(disp, _gloffset_GetShaderPrecisionFormat, fn) +#define CALL_IsFramebuffer(disp, parameters) CALL_by_offset(disp, (GLboolean (GLAPIENTRYP)(GLuint)), _gloffset_IsFramebuffer, parameters) +#define GET_IsFramebuffer(disp) GET_by_offset(disp, _gloffset_IsFramebuffer) +#define SET_IsFramebuffer(disp, fn) SET_by_offset(disp, _gloffset_IsFramebuffer, fn) +#define CALL_IsRenderbuffer(disp, parameters) CALL_by_offset(disp, (GLboolean (GLAPIENTRYP)(GLuint)), _gloffset_IsRenderbuffer, parameters) +#define GET_IsRenderbuffer(disp) GET_by_offset(disp, _gloffset_IsRenderbuffer) +#define SET_IsRenderbuffer(disp, fn) SET_by_offset(disp, _gloffset_IsRenderbuffer, fn) +#define CALL_ReleaseShaderCompiler(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(void)), _gloffset_ReleaseShaderCompiler, parameters) +#define GET_ReleaseShaderCompiler(disp) GET_by_offset(disp, _gloffset_ReleaseShaderCompiler) +#define SET_ReleaseShaderCompiler(disp, fn) SET_by_offset(disp, _gloffset_ReleaseShaderCompiler, fn) +#define CALL_RenderbufferStorage(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLenum, GLsizei, GLsizei)), _gloffset_RenderbufferStorage, parameters) +#define GET_RenderbufferStorage(disp) GET_by_offset(disp, _gloffset_RenderbufferStorage) +#define SET_RenderbufferStorage(disp, fn) SET_by_offset(disp, _gloffset_RenderbufferStorage, fn) +#define CALL_ShaderBinary(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLsizei, const GLuint *, GLenum, const GLvoid *, GLsizei)), _gloffset_ShaderBinary, parameters) +#define GET_ShaderBinary(disp) GET_by_offset(disp, _gloffset_ShaderBinary) +#define SET_ShaderBinary(disp, fn) SET_by_offset(disp, _gloffset_ShaderBinary, fn) + +/* define aliases for compatibility */ +#define CALL_TexImage3D(disp, parameters) CALL_TexImage3DOES(disp, parameters) +#define GET_TexImage3D(disp) GET_TexImage3DOES(disp) +#define SET_TexImage3D(disp, fn) SET_TexImage3DOES(disp, fn) +#define CALL_TexSubImage3D(disp, parameters) CALL_TexSubImage3DOES(disp, parameters) +#define GET_TexSubImage3D(disp) GET_TexSubImage3DOES(disp) +#define SET_TexSubImage3D(disp, fn) SET_TexSubImage3DOES(disp, fn) +#define CALL_CopyTexSubImage3D(disp, parameters) CALL_CopyTexSubImage3DOES(disp, parameters) +#define GET_CopyTexSubImage3D(disp) GET_CopyTexSubImage3DOES(disp) +#define SET_CopyTexSubImage3D(disp, fn) SET_CopyTexSubImage3DOES(disp, fn) +#define CALL_ActiveTextureARB(disp, parameters) CALL_ActiveTexture(disp, parameters) +#define GET_ActiveTextureARB(disp) GET_ActiveTexture(disp) +#define SET_ActiveTextureARB(disp, fn) SET_ActiveTexture(disp, fn) + +#if defined(_GLAPI_USE_REMAP_TABLE) +#define TexImage3D_remap_index TexImage3DOES_remap_index +#define TexSubImage3D_remap_index TexSubImage3DOES_remap_index +#define CopyTexSubImage3D_remap_index CopyTexSubImage3DOES_remap_index +#define ActiveTextureARB_remap_index ActiveTexture_remap_index +#endif /* defined(_GLAPI_USE_REMAP_TABLE) */ + + +#endif /* !defined( _GLAPI_DISPATCH_H_ ) */ diff --git a/src/mapi/es2api/main/remap_helper.h b/src/mapi/es2api/main/remap_helper.h new file mode 100644 index 00000000000..fb1c1ec7a5a --- /dev/null +++ b/src/mapi/es2api/main/remap_helper.h @@ -0,0 +1,2269 @@ +/* DO NOT EDIT - This file generated automatically by remap_helper.py (from Mesa) script */ + +/* + * Copyright (C) 2009 Chia-I Wu + * All Rights Reserved. + * + * Permission is hereby granted, free of charge, to any person obtaining a + * copy of this software and associated documentation files (the "Software"), + * to deal in the Software without restriction, including without limitation + * the rights to use, copy, modify, merge, publish, distribute, sub license, + * and/or sell copies of the Software, and to permit persons to whom the + * Software is furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice (including the next + * paragraph) shall be included in all copies or substantial portions of the + * Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL + * Chia-I Wu, + * AND/OR THEIR SUPPLIERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, + * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF + * OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE + * SOFTWARE. + */ + +#include "main/dispatch.h" +#include "main/remap.h" + +/* this is internal to remap.c */ +#ifdef need_MESA_remap_table + +static const char _mesa_function_pool[] = + /* _mesa_function_pool[0]: MapGrid1d (offset 224) */ + "idd\0" + "glMapGrid1d\0" + "\0" + /* _mesa_function_pool[17]: MapGrid1f (offset 225) */ + "iff\0" + "glMapGrid1f\0" + "\0" + /* _mesa_function_pool[34]: RasterPos4i (offset 82) */ + "iiii\0" + "glRasterPos4i\0" + "\0" + /* _mesa_function_pool[54]: RasterPos4d (offset 78) */ + "dddd\0" + "glRasterPos4d\0" + "\0" + /* _mesa_function_pool[74]: NewList (dynamic) */ + "ii\0" + "glNewList\0" + "\0" + /* _mesa_function_pool[88]: RasterPos4f (offset 80) */ + "ffff\0" + "glRasterPos4f\0" + "\0" + /* _mesa_function_pool[108]: LoadIdentity (offset 290) */ + "\0" + "glLoadIdentity\0" + "\0" + /* _mesa_function_pool[125]: ConvolutionFilter1D (offset 348) */ + "iiiiip\0" + "glConvolutionFilter1D\0" + "\0" + /* _mesa_function_pool[155]: RasterPos3dv (offset 71) */ + "p\0" + "glRasterPos3dv\0" + "\0" + /* _mesa_function_pool[173]: GetProgramiv (will be remapped) */ + "iip\0" + "glGetProgramiv\0" + "\0" + /* _mesa_function_pool[193]: TexCoord1iv (offset 99) */ + "p\0" + "glTexCoord1iv\0" + "\0" + /* _mesa_function_pool[210]: TexCoord4sv (offset 125) */ + "p\0" + "glTexCoord4sv\0" + "\0" + /* _mesa_function_pool[227]: RasterPos4s (offset 84) */ + "iiii\0" + "glRasterPos4s\0" + "\0" + /* _mesa_function_pool[247]: TexCoord1f (offset 96) */ + "f\0" + "glTexCoord1f\0" + "\0" + /* _mesa_function_pool[263]: TexCoord1d (offset 94) */ + "d\0" + "glTexCoord1d\0" + "\0" + /* _mesa_function_pool[279]: TexCoord1i (offset 98) */ + "i\0" + "glTexCoord1i\0" + "\0" + /* _mesa_function_pool[295]: Histogram (offset 367) */ + "iiii\0" + "glHistogram\0" + "\0" + /* _mesa_function_pool[313]: TexCoord1s (offset 100) */ + "i\0" + "glTexCoord1s\0" + "\0" + /* _mesa_function_pool[329]: GetMapfv (offset 267) */ + "iip\0" + "glGetMapfv\0" + "\0" + /* _mesa_function_pool[345]: GetProgramInfoLog (will be remapped) */ + "iipp\0" + "glGetProgramInfoLog\0" + "\0" + /* _mesa_function_pool[371]: Uniform2fv (will be remapped) */ + "iip\0" + "glUniform2fv\0" + "\0" + /* _mesa_function_pool[389]: PolygonStipple (offset 175) */ + "p\0" + "glPolygonStipple\0" + "\0" + /* _mesa_function_pool[409]: TexImage3DOES (offset 371) */ + "iiiiiiiiip\0" + "glTexImage3DOES\0" + "glTexImage3D\0" + "\0" + /* _mesa_function_pool[450]: VertexAttrib4fv (will be remapped) */ + "ip\0" + "glVertexAttrib4fv\0" + "\0" + /* _mesa_function_pool[472]: GetPixelMapfv (offset 271) */ + "ip\0" + "glGetPixelMapfv\0" + "\0" + /* _mesa_function_pool[492]: Color3uiv (offset 22) */ + "p\0" + "glColor3uiv\0" + "\0" + /* _mesa_function_pool[507]: IsEnabled (offset 286) */ + "i\0" + "glIsEnabled\0" + "\0" + /* _mesa_function_pool[522]: EvalCoord2fv (offset 235) */ + "p\0" + "glEvalCoord2fv\0" + "\0" + /* _mesa_function_pool[540]: AttachShader (will be remapped) */ + "ii\0" + "glAttachShader\0" + "\0" + /* _mesa_function_pool[559]: GetMapiv (offset 268) */ + "iip\0" + "glGetMapiv\0" + "\0" + /* _mesa_function_pool[575]: Indexubv (offset 316) */ + "p\0" + "glIndexubv\0" + "\0" + /* _mesa_function_pool[589]: EdgeFlagPointer (offset 312) */ + "ip\0" + "glEdgeFlagPointer\0" + "\0" + /* _mesa_function_pool[611]: Color3ubv (offset 20) */ + "p\0" + "glColor3ubv\0" + "\0" + /* _mesa_function_pool[626]: Vertex3dv (offset 135) */ + "p\0" + "glVertex3dv\0" + "\0" + /* _mesa_function_pool[641]: LightModeliv (offset 166) */ + "ip\0" + "glLightModeliv\0" + "\0" + /* _mesa_function_pool[660]: GetVertexAttribfv (will be remapped) */ + "iip\0" + "glGetVertexAttribfv\0" + "\0" + /* _mesa_function_pool[685]: Normal3bv (offset 53) */ + "p\0" + "glNormal3bv\0" + "\0" + /* _mesa_function_pool[700]: TexGeniv (offset 193) */ + "iip\0" + "glTexGeniv\0" + "\0" + /* _mesa_function_pool[716]: Vertex3iv (offset 139) */ + "p\0" + "glVertex3iv\0" + "\0" + /* _mesa_function_pool[731]: RenderbufferStorage (will be remapped) */ + "iiii\0" + "glRenderbufferStorage\0" + "\0" + /* _mesa_function_pool[759]: CopyConvolutionFilter1D (offset 354) */ + "iiiii\0" + "glCopyConvolutionFilter1D\0" + "\0" + /* _mesa_function_pool[792]: ClearColor (offset 206) */ + "ffff\0" + "glClearColor\0" + "\0" + /* _mesa_function_pool[811]: Uniform3i (will be remapped) */ + "iiii\0" + "glUniform3i\0" + "\0" + /* _mesa_function_pool[829]: BlendColor (offset 336) */ + "ffff\0" + "glBlendColor\0" + "\0" + /* _mesa_function_pool[848]: DeleteVertexArraysAPPLE (will be remapped) */ + "ip\0" + "glDeleteVertexArraysAPPLE\0" + "\0" + /* _mesa_function_pool[878]: Scalef (offset 302) */ + "fff\0" + "glScalef\0" + "\0" + /* _mesa_function_pool[892]: Uniform3f (will be remapped) */ + "ifff\0" + "glUniform3f\0" + "\0" + /* _mesa_function_pool[910]: Normal3iv (offset 59) */ + "p\0" + "glNormal3iv\0" + "\0" + /* _mesa_function_pool[925]: Indexdv (offset 45) */ + "p\0" + "glIndexdv\0" + "\0" + /* _mesa_function_pool[938]: Viewport (offset 305) */ + "iiii\0" + "glViewport\0" + "\0" + /* _mesa_function_pool[955]: UniformMatrix3fv (will be remapped) */ + "iiip\0" + "glUniformMatrix3fv\0" + "\0" + /* _mesa_function_pool[980]: DepthRange (offset 288) */ + "dd\0" + "glDepthRange\0" + "\0" + /* _mesa_function_pool[997]: LoadMatrixf (offset 291) */ + "p\0" + "glLoadMatrixf\0" + "\0" + /* _mesa_function_pool[1014]: VertexAttrib3f (will be remapped) */ + "ifff\0" + "glVertexAttrib3f\0" + "\0" + /* _mesa_function_pool[1037]: CompressedTexSubImage2D (will be remapped) */ + "iiiiiiiip\0" + "glCompressedTexSubImage2D\0" + "\0" + /* _mesa_function_pool[1074]: TexCoord2sv (offset 109) */ + "p\0" + "glTexCoord2sv\0" + "\0" + /* _mesa_function_pool[1091]: TexCoord2dv (offset 103) */ + "p\0" + "glTexCoord2dv\0" + "\0" + /* _mesa_function_pool[1108]: StencilMaskSeparate (will be remapped) */ + "ii\0" + "glStencilMaskSeparate\0" + "\0" + /* _mesa_function_pool[1134]: Color3sv (offset 18) */ + "p\0" + "glColor3sv\0" + "\0" + /* _mesa_function_pool[1148]: EvalCoord1f (offset 230) */ + "f\0" + "glEvalCoord1f\0" + "\0" + /* _mesa_function_pool[1165]: GetConvolutionParameteriv (offset 358) */ + "iip\0" + "glGetConvolutionParameteriv\0" + "\0" + /* _mesa_function_pool[1198]: AlphaFunc (offset 240) */ + "if\0" + "glAlphaFunc\0" + "\0" + /* _mesa_function_pool[1214]: MultiTexCoord1fvARB (offset 379) */ + "ip\0" + "glMultiTexCoord1fvARB\0" + "\0" + /* _mesa_function_pool[1240]: TexCoord3iv (offset 115) */ + "p\0" + "glTexCoord3iv\0" + "\0" + /* _mesa_function_pool[1257]: Color3fv (offset 14) */ + "p\0" + "glColor3fv\0" + "\0" + /* _mesa_function_pool[1271]: CompressedTexImage3DOES (will be remapped) */ + "iiiiiiiip\0" + "glCompressedTexImage3DOES\0" + "\0" + /* _mesa_function_pool[1308]: Translatef (offset 304) */ + "fff\0" + "glTranslatef\0" + "\0" + /* _mesa_function_pool[1326]: PointSize (offset 173) */ + "f\0" + "glPointSize\0" + "\0" + /* _mesa_function_pool[1341]: PopName (offset 200) */ + "\0" + "glPopName\0" + "\0" + /* _mesa_function_pool[1353]: Vertex4sv (offset 149) */ + "p\0" + "glVertex4sv\0" + "\0" + /* _mesa_function_pool[1368]: GetTexEnvfv (offset 276) */ + "iip\0" + "glGetTexEnvfv\0" + "\0" + /* _mesa_function_pool[1387]: BindAttribLocation (will be remapped) */ + "iip\0" + "glBindAttribLocation\0" + "\0" + /* _mesa_function_pool[1413]: GetProgramBinaryOES (will be remapped) */ + "iippp\0" + "glGetProgramBinaryOES\0" + "\0" + /* _mesa_function_pool[1442]: LineStipple (offset 167) */ + "ii\0" + "glLineStipple\0" + "\0" + /* _mesa_function_pool[1460]: TexEnvi (offset 186) */ + "iii\0" + "glTexEnvi\0" + "\0" + /* _mesa_function_pool[1475]: GetClipPlane (offset 259) */ + "ip\0" + "glGetClipPlane\0" + "\0" + /* _mesa_function_pool[1494]: Scaled (offset 301) */ + "ddd\0" + "glScaled\0" + "\0" + /* _mesa_function_pool[1508]: CallLists (offset 3) */ + "iip\0" + "glCallLists\0" + "\0" + /* _mesa_function_pool[1525]: GetUniformfv (will be remapped) */ + "iip\0" + "glGetUniformfv\0" + "\0" + /* _mesa_function_pool[1545]: Vertex2dv (offset 127) */ + "p\0" + "glVertex2dv\0" + "\0" + /* _mesa_function_pool[1560]: EdgeFlag (offset 41) */ + "i\0" + "glEdgeFlag\0" + "\0" + /* _mesa_function_pool[1574]: TexCoord2iv (offset 107) */ + "p\0" + "glTexCoord2iv\0" + "\0" + /* _mesa_function_pool[1591]: Rotated (offset 299) */ + "dddd\0" + "glRotated\0" + "\0" + /* _mesa_function_pool[1607]: ReadPixels (offset 256) */ + "iiiiiip\0" + "glReadPixels\0" + "\0" + /* _mesa_function_pool[1629]: EdgeFlagv (offset 42) */ + "p\0" + "glEdgeFlagv\0" + "\0" + /* _mesa_function_pool[1644]: Indexd (offset 44) */ + "d\0" + "glIndexd\0" + "\0" + /* _mesa_function_pool[1656]: TexParameterf (offset 178) */ + "iif\0" + "glTexParameterf\0" + "\0" + /* _mesa_function_pool[1677]: TexParameteri (offset 180) */ + "iii\0" + "glTexParameteri\0" + "\0" + /* _mesa_function_pool[1698]: MultiTexCoord3dARB (offset 392) */ + "iddd\0" + "glMultiTexCoord3dARB\0" + "\0" + /* _mesa_function_pool[1725]: GetUniformiv (will be remapped) */ + "iip\0" + "glGetUniformiv\0" + "\0" + /* _mesa_function_pool[1745]: DrawPixels (offset 257) */ + "iiiip\0" + "glDrawPixels\0" + "\0" + /* _mesa_function_pool[1765]: MultiTexCoord2svARB (offset 391) */ + "ip\0" + "glMultiTexCoord2svARB\0" + "\0" + /* _mesa_function_pool[1791]: MultiTexCoord2iARB (offset 388) */ + "iii\0" + "glMultiTexCoord2iARB\0" + "\0" + /* _mesa_function_pool[1817]: MultiTexCoord3svARB (offset 399) */ + "ip\0" + "glMultiTexCoord3svARB\0" + "\0" + /* _mesa_function_pool[1843]: CreateProgram (will be remapped) */ + "\0" + "glCreateProgram\0" + "\0" + /* _mesa_function_pool[1861]: DepthRangef (will be remapped) */ + "ff\0" + "glDepthRangef\0" + "\0" + /* _mesa_function_pool[1879]: Uniform3fv (will be remapped) */ + "iip\0" + "glUniform3fv\0" + "\0" + /* _mesa_function_pool[1897]: MapGrid2f (offset 227) */ + "iffiff\0" + "glMapGrid2f\0" + "\0" + /* _mesa_function_pool[1917]: ValidateProgram (will be remapped) */ + "i\0" + "glValidateProgram\0" + "\0" + /* _mesa_function_pool[1938]: Scissor (offset 176) */ + "iiii\0" + "glScissor\0" + "\0" + /* _mesa_function_pool[1954]: Fogf (offset 153) */ + "if\0" + "glFogf\0" + "\0" + /* _mesa_function_pool[1965]: TexSubImage1D (offset 332) */ + "iiiiiip\0" + "glTexSubImage1D\0" + "\0" + /* _mesa_function_pool[1990]: Color4usv (offset 40) */ + "p\0" + "glColor4usv\0" + "\0" + /* _mesa_function_pool[2005]: Fogi (offset 155) */ + "ii\0" + "glFogi\0" + "\0" + /* _mesa_function_pool[2016]: MultiTexCoord3sARB (offset 398) */ + "iiii\0" + "glMultiTexCoord3sARB\0" + "\0" + /* _mesa_function_pool[2043]: RasterPos3iv (offset 75) */ + "p\0" + "glRasterPos3iv\0" + "\0" + /* _mesa_function_pool[2061]: GetActiveAttrib (will be remapped) */ + "iiipppp\0" + "glGetActiveAttrib\0" + "\0" + /* _mesa_function_pool[2088]: TexCoord2i (offset 106) */ + "ii\0" + "glTexCoord2i\0" + "\0" + /* _mesa_function_pool[2105]: DepthFunc (offset 245) */ + "i\0" + "glDepthFunc\0" + "\0" + /* _mesa_function_pool[2120]: Color4ui (offset 37) */ + "iiii\0" + "glColor4ui\0" + "\0" + /* _mesa_function_pool[2137]: RasterPos3s (offset 76) */ + "iii\0" + "glRasterPos3s\0" + "\0" + /* _mesa_function_pool[2156]: Color3usv (offset 24) */ + "p\0" + "glColor3usv\0" + "\0" + /* _mesa_function_pool[2171]: TexCoord2f (offset 104) */ + "ff\0" + "glTexCoord2f\0" + "\0" + /* _mesa_function_pool[2188]: TexCoord2d (offset 102) */ + "dd\0" + "glTexCoord2d\0" + "\0" + /* _mesa_function_pool[2205]: RasterPos3d (offset 70) */ + "ddd\0" + "glRasterPos3d\0" + "\0" + /* _mesa_function_pool[2224]: RasterPos3f (offset 72) */ + "fff\0" + "glRasterPos3f\0" + "\0" + /* _mesa_function_pool[2243]: AreTexturesResident (offset 322) */ + "ipp\0" + "glAreTexturesResident\0" + "\0" + /* _mesa_function_pool[2270]: TexCoord2s (offset 108) */ + "ii\0" + "glTexCoord2s\0" + "\0" + /* _mesa_function_pool[2287]: StencilOpSeparate (will be remapped) */ + "iiii\0" + "glStencilOpSeparate\0" + "\0" + /* _mesa_function_pool[2313]: RasterPos3i (offset 74) */ + "iii\0" + "glRasterPos3i\0" + "\0" + /* _mesa_function_pool[2332]: Color4us (offset 39) */ + "iiii\0" + "glColor4us\0" + "\0" + /* _mesa_function_pool[2349]: GetTexParameteriv (offset 283) */ + "iip\0" + "glGetTexParameteriv\0" + "\0" + /* _mesa_function_pool[2374]: MapBufferOES (will be remapped) */ + "ii\0" + "glMapBufferOES\0" + "\0" + /* _mesa_function_pool[2393]: MultiTexCoord2fARB (offset 386) */ + "iff\0" + "glMultiTexCoord2fARB\0" + "\0" + /* _mesa_function_pool[2419]: ColorTable (offset 339) */ + "iiiiip\0" + "glColorTable\0" + "\0" + /* _mesa_function_pool[2440]: IndexPointer (offset 314) */ + "iip\0" + "glIndexPointer\0" + "\0" + /* _mesa_function_pool[2460]: Accum (offset 213) */ + "if\0" + "glAccum\0" + "\0" + /* _mesa_function_pool[2472]: GetTexImage (offset 281) */ + "iiiip\0" + "glGetTexImage\0" + "\0" + /* _mesa_function_pool[2493]: LoadName (offset 198) */ + "i\0" + "glLoadName\0" + "\0" + /* _mesa_function_pool[2507]: Finish (offset 216) */ + "\0" + "glFinish\0" + "\0" + /* _mesa_function_pool[2518]: ClearStencil (offset 207) */ + "i\0" + "glClearStencil\0" + "\0" + /* _mesa_function_pool[2536]: ConvolutionParameteriv (offset 353) */ + "iip\0" + "glConvolutionParameteriv\0" + "\0" + /* _mesa_function_pool[2566]: GenBuffers (will be remapped) */ + "ip\0" + "glGenBuffers\0" + "\0" + /* _mesa_function_pool[2583]: InterleavedArrays (offset 317) */ + "iip\0" + "glInterleavedArrays\0" + "\0" + /* _mesa_function_pool[2608]: RasterPos2fv (offset 65) */ + "p\0" + "glRasterPos2fv\0" + "\0" + /* _mesa_function_pool[2626]: TexCoord1fv (offset 97) */ + "p\0" + "glTexCoord1fv\0" + "\0" + /* _mesa_function_pool[2643]: MultiTexCoord1sARB (offset 382) */ + "ii\0" + "glMultiTexCoord1sARB\0" + "\0" + /* _mesa_function_pool[2668]: EnableVertexAttribArray (will be remapped) */ + "i\0" + "glEnableVertexAttribArray\0" + "\0" + /* _mesa_function_pool[2697]: Color4i (offset 31) */ + "iiii\0" + "glColor4i\0" + "\0" + /* _mesa_function_pool[2713]: Color4f (offset 29) */ + "ffff\0" + "glColor4f\0" + "\0" + /* _mesa_function_pool[2729]: RasterPos4fv (offset 81) */ + "p\0" + "glRasterPos4fv\0" + "\0" + /* _mesa_function_pool[2747]: Color4d (offset 27) */ + "dddd\0" + "glColor4d\0" + "\0" + /* _mesa_function_pool[2763]: ClearIndex (offset 205) */ + "f\0" + "glClearIndex\0" + "\0" + /* _mesa_function_pool[2779]: Color4b (offset 25) */ + "iiii\0" + "glColor4b\0" + "\0" + /* _mesa_function_pool[2795]: LoadMatrixd (offset 292) */ + "p\0" + "glLoadMatrixd\0" + "\0" + /* _mesa_function_pool[2812]: PushMatrix (offset 298) */ + "\0" + "glPushMatrix\0" + "\0" + /* _mesa_function_pool[2827]: ConvolutionParameterfv (offset 351) */ + "iip\0" + "glConvolutionParameterfv\0" + "\0" + /* _mesa_function_pool[2857]: GetTexGendv (offset 278) */ + "iip\0" + "glGetTexGendv\0" + "\0" + /* _mesa_function_pool[2876]: EndList (offset 1) */ + "\0" + "glEndList\0" + "\0" + /* _mesa_function_pool[2888]: EvalCoord1fv (offset 231) */ + "p\0" + "glEvalCoord1fv\0" + "\0" + /* _mesa_function_pool[2906]: DrawRangeElements (offset 338) */ + "iiiiip\0" + "glDrawRangeElements\0" + "\0" + /* _mesa_function_pool[2934]: EvalMesh2 (offset 238) */ + "iiiii\0" + "glEvalMesh2\0" + "\0" + /* _mesa_function_pool[2953]: Vertex4fv (offset 145) */ + "p\0" + "glVertex4fv\0" + "\0" + /* _mesa_function_pool[2968]: BindFramebuffer (will be remapped) */ + "ii\0" + "glBindFramebuffer\0" + "\0" + /* _mesa_function_pool[2990]: GenLists (offset 5) */ + "i\0" + "glGenLists\0" + "\0" + /* _mesa_function_pool[3004]: ReleaseShaderCompiler (will be remapped) */ + "\0" + "glReleaseShaderCompiler\0" + "\0" + /* _mesa_function_pool[3030]: GetMinmax (offset 364) */ + "iiiip\0" + "glGetMinmax\0" + "\0" + /* _mesa_function_pool[3049]: BlendFuncSeparate (will be remapped) */ + "iiii\0" + "glBlendFuncSeparate\0" + "\0" + /* _mesa_function_pool[3075]: StencilFuncSeparate (will be remapped) */ + "iiii\0" + "glStencilFuncSeparate\0" + "\0" + /* _mesa_function_pool[3103]: ShaderSource (will be remapped) */ + "iipp\0" + "glShaderSource\0" + "\0" + /* _mesa_function_pool[3124]: Normal3fv (offset 57) */ + "p\0" + "glNormal3fv\0" + "\0" + /* _mesa_function_pool[3139]: Color3us (offset 23) */ + "iii\0" + "glColor3us\0" + "\0" + /* _mesa_function_pool[3155]: End (offset 43) */ + "\0" + "glEnd\0" + "\0" + /* _mesa_function_pool[3163]: MultiTexCoord3fvARB (offset 395) */ + "ip\0" + "glMultiTexCoord3fvARB\0" + "\0" + /* _mesa_function_pool[3189]: Color3ub (offset 19) */ + "iii\0" + "glColor3ub\0" + "\0" + /* _mesa_function_pool[3205]: BufferData (will be remapped) */ + "iipi\0" + "glBufferData\0" + "\0" + /* _mesa_function_pool[3224]: Color3ui (offset 21) */ + "iii\0" + "glColor3ui\0" + "\0" + /* _mesa_function_pool[3240]: TexSubImage2D (offset 333) */ + "iiiiiiiip\0" + "glTexSubImage2D\0" + "\0" + /* _mesa_function_pool[3267]: Enable (offset 215) */ + "i\0" + "glEnable\0" + "\0" + /* _mesa_function_pool[3279]: GetVertexAttribiv (will be remapped) */ + "iip\0" + "glGetVertexAttribiv\0" + "\0" + /* _mesa_function_pool[3304]: ShaderBinary (will be remapped) */ + "ipipi\0" + "glShaderBinary\0" + "\0" + /* _mesa_function_pool[3326]: MultiTexCoord4sARB (offset 406) */ + "iiiii\0" + "glMultiTexCoord4sARB\0" + "\0" + /* _mesa_function_pool[3354]: MapGrid2d (offset 226) */ + "iddidd\0" + "glMapGrid2d\0" + "\0" + /* _mesa_function_pool[3374]: BlendEquation (offset 337) */ + "i\0" + "glBlendEquation\0" + "\0" + /* _mesa_function_pool[3393]: GetError (offset 261) */ + "\0" + "glGetError\0" + "\0" + /* _mesa_function_pool[3406]: TexCoord3dv (offset 111) */ + "p\0" + "glTexCoord3dv\0" + "\0" + /* _mesa_function_pool[3423]: PassThrough (offset 199) */ + "f\0" + "glPassThrough\0" + "\0" + /* _mesa_function_pool[3440]: Normal3s (offset 60) */ + "iii\0" + "glNormal3s\0" + "\0" + /* _mesa_function_pool[3456]: PushName (offset 201) */ + "i\0" + "glPushName\0" + "\0" + /* _mesa_function_pool[3470]: MultiTexCoord2dvARB (offset 385) */ + "ip\0" + "glMultiTexCoord2dvARB\0" + "\0" + /* _mesa_function_pool[3496]: Normal3i (offset 58) */ + "iii\0" + "glNormal3i\0" + "\0" + /* _mesa_function_pool[3512]: DeleteRenderbuffers (will be remapped) */ + "ip\0" + "glDeleteRenderbuffers\0" + "\0" + /* _mesa_function_pool[3538]: Normal3b (offset 52) */ + "iii\0" + "glNormal3b\0" + "\0" + /* _mesa_function_pool[3554]: Normal3d (offset 54) */ + "ddd\0" + "glNormal3d\0" + "\0" + /* _mesa_function_pool[3570]: CopyTexSubImage3DOES (offset 373) */ + "iiiiiiiii\0" + "glCopyTexSubImage3DOES\0" + "glCopyTexSubImage3D\0" + "\0" + /* _mesa_function_pool[3624]: Normal3f (offset 56) */ + "fff\0" + "glNormal3f\0" + "\0" + /* _mesa_function_pool[3640]: MultiTexCoord1svARB (offset 383) */ + "ip\0" + "glMultiTexCoord1svARB\0" + "\0" + /* _mesa_function_pool[3666]: Indexi (offset 48) */ + "i\0" + "glIndexi\0" + "\0" + /* _mesa_function_pool[3678]: EGLImageTargetTexture2DOES (will be remapped) */ + "ip\0" + "glEGLImageTargetTexture2DOES\0" + "\0" + /* _mesa_function_pool[3711]: IsRenderbuffer (will be remapped) */ + "i\0" + "glIsRenderbuffer\0" + "\0" + /* _mesa_function_pool[3731]: DepthMask (offset 211) */ + "i\0" + "glDepthMask\0" + "\0" + /* _mesa_function_pool[3746]: IsShader (will be remapped) */ + "i\0" + "glIsShader\0" + "\0" + /* _mesa_function_pool[3760]: Indexf (offset 46) */ + "f\0" + "glIndexf\0" + "\0" + /* _mesa_function_pool[3772]: Color4iv (offset 32) */ + "p\0" + "glColor4iv\0" + "\0" + /* _mesa_function_pool[3786]: GetMaterialiv (offset 270) */ + "iip\0" + "glGetMaterialiv\0" + "\0" + /* _mesa_function_pool[3807]: StencilOp (offset 244) */ + "iii\0" + "glStencilOp\0" + "\0" + /* _mesa_function_pool[3824]: GetShaderInfoLog (will be remapped) */ + "iipp\0" + "glGetShaderInfoLog\0" + "\0" + /* _mesa_function_pool[3849]: TexEnvfv (offset 185) */ + "iip\0" + "glTexEnvfv\0" + "\0" + /* _mesa_function_pool[3865]: MultiTexCoord4iARB (offset 404) */ + "iiiii\0" + "glMultiTexCoord4iARB\0" + "\0" + /* _mesa_function_pool[3893]: Indexs (offset 50) */ + "i\0" + "glIndexs\0" + "\0" + /* _mesa_function_pool[3905]: EGLImageTargetRenderbufferStorageOES (will be remapped) */ + "ip\0" + "glEGLImageTargetRenderbufferStorageOES\0" + "\0" + /* _mesa_function_pool[3948]: Vertex2i (offset 130) */ + "ii\0" + "glVertex2i\0" + "\0" + /* _mesa_function_pool[3963]: Vertex2d (offset 126) */ + "dd\0" + "glVertex2d\0" + "\0" + /* _mesa_function_pool[3978]: Vertex2f (offset 128) */ + "ff\0" + "glVertex2f\0" + "\0" + /* _mesa_function_pool[3993]: Color4bv (offset 26) */ + "p\0" + "glColor4bv\0" + "\0" + /* _mesa_function_pool[4007]: VertexPointer (offset 321) */ + "iiip\0" + "glVertexPointer\0" + "\0" + /* _mesa_function_pool[4029]: DeleteLists (offset 4) */ + "ii\0" + "glDeleteLists\0" + "\0" + /* _mesa_function_pool[4047]: LogicOp (offset 242) */ + "i\0" + "glLogicOp\0" + "\0" + /* _mesa_function_pool[4060]: Vertex2s (offset 132) */ + "ii\0" + "glVertex2s\0" + "\0" + /* _mesa_function_pool[4075]: TexCoord4fv (offset 121) */ + "p\0" + "glTexCoord4fv\0" + "\0" + /* _mesa_function_pool[4092]: ActiveTexture (offset 374) */ + "i\0" + "glActiveTexture\0" + "glActiveTextureARB\0" + "\0" + /* _mesa_function_pool[4130]: MultiTexCoord3iARB (offset 396) */ + "iiii\0" + "glMultiTexCoord3iARB\0" + "\0" + /* _mesa_function_pool[4157]: IsProgram (will be remapped) */ + "i\0" + "glIsProgram\0" + "\0" + /* _mesa_function_pool[4172]: GenTextures (offset 328) */ + "ip\0" + "glGenTextures\0" + "\0" + /* _mesa_function_pool[4190]: RasterPos2sv (offset 69) */ + "p\0" + "glRasterPos2sv\0" + "\0" + /* _mesa_function_pool[4208]: Color4ubv (offset 36) */ + "p\0" + "glColor4ubv\0" + "\0" + /* _mesa_function_pool[4223]: DrawBuffer (offset 202) */ + "i\0" + "glDrawBuffer\0" + "\0" + /* _mesa_function_pool[4239]: TexCoord2fv (offset 105) */ + "p\0" + "glTexCoord2fv\0" + "\0" + /* _mesa_function_pool[4256]: GetPointerv (offset 329) */ + "ip\0" + "glGetPointerv\0" + "\0" + /* _mesa_function_pool[4274]: TexCoord1sv (offset 101) */ + "p\0" + "glTexCoord1sv\0" + "\0" + /* _mesa_function_pool[4291]: PixelMapfv (offset 251) */ + "iip\0" + "glPixelMapfv\0" + "\0" + /* _mesa_function_pool[4309]: PixelMapusv (offset 253) */ + "iip\0" + "glPixelMapusv\0" + "\0" + /* _mesa_function_pool[4328]: MultiTexCoord1dARB (offset 376) */ + "id\0" + "glMultiTexCoord1dARB\0" + "\0" + /* _mesa_function_pool[4353]: BlendFunc (offset 241) */ + "ii\0" + "glBlendFunc\0" + "\0" + /* _mesa_function_pool[4369]: Uniform4i (will be remapped) */ + "iiiii\0" + "glUniform4i\0" + "\0" + /* _mesa_function_pool[4388]: ProgramBinaryOES (will be remapped) */ + "iipi\0" + "glProgramBinaryOES\0" + "\0" + /* _mesa_function_pool[4413]: CompressedTexImage2D (will be remapped) */ + "iiiiiiip\0" + "glCompressedTexImage2D\0" + "\0" + /* _mesa_function_pool[4446]: MultiTexCoord3dvARB (offset 393) */ + "ip\0" + "glMultiTexCoord3dvARB\0" + "\0" + /* _mesa_function_pool[4472]: GetShaderPrecisionFormat (will be remapped) */ + "iipp\0" + "glGetShaderPrecisionFormat\0" + "\0" + /* _mesa_function_pool[4505]: Flush (offset 217) */ + "\0" + "glFlush\0" + "\0" + /* _mesa_function_pool[4515]: Color4uiv (offset 38) */ + "p\0" + "glColor4uiv\0" + "\0" + /* _mesa_function_pool[4530]: RasterPos3sv (offset 77) */ + "p\0" + "glRasterPos3sv\0" + "\0" + /* _mesa_function_pool[4548]: PushAttrib (offset 219) */ + "i\0" + "glPushAttrib\0" + "\0" + /* _mesa_function_pool[4564]: RasterPos2i (offset 66) */ + "ii\0" + "glRasterPos2i\0" + "\0" + /* _mesa_function_pool[4582]: Uniform3iv (will be remapped) */ + "iip\0" + "glUniform3iv\0" + "\0" + /* _mesa_function_pool[4600]: TexParameteriv (offset 181) */ + "iip\0" + "glTexParameteriv\0" + "\0" + /* _mesa_function_pool[4622]: GetAttribLocation (will be remapped) */ + "ip\0" + "glGetAttribLocation\0" + "\0" + /* _mesa_function_pool[4646]: RasterPos2f (offset 64) */ + "ff\0" + "glRasterPos2f\0" + "\0" + /* _mesa_function_pool[4664]: RasterPos2d (offset 62) */ + "dd\0" + "glRasterPos2d\0" + "\0" + /* _mesa_function_pool[4682]: RasterPos3fv (offset 73) */ + "p\0" + "glRasterPos3fv\0" + "\0" + /* _mesa_function_pool[4700]: Color4ub (offset 35) */ + "iiii\0" + "glColor4ub\0" + "\0" + /* _mesa_function_pool[4717]: RasterPos2s (offset 68) */ + "ii\0" + "glRasterPos2s\0" + "\0" + /* _mesa_function_pool[4735]: GetColorTable (offset 343) */ + "iiip\0" + "glGetColorTable\0" + "\0" + /* _mesa_function_pool[4757]: Indexiv (offset 49) */ + "p\0" + "glIndexiv\0" + "\0" + /* _mesa_function_pool[4770]: TexCoord3i (offset 114) */ + "iii\0" + "glTexCoord3i\0" + "\0" + /* _mesa_function_pool[4788]: CopyColorTable (offset 342) */ + "iiiii\0" + "glCopyColorTable\0" + "\0" + /* _mesa_function_pool[4812]: GetHistogramParameterfv (offset 362) */ + "iip\0" + "glGetHistogramParameterfv\0" + "\0" + /* _mesa_function_pool[4843]: Frustum (offset 289) */ + "dddddd\0" + "glFrustum\0" + "\0" + /* _mesa_function_pool[4861]: GetString (offset 275) */ + "i\0" + "glGetString\0" + "\0" + /* _mesa_function_pool[4876]: TexEnvf (offset 184) */ + "iif\0" + "glTexEnvf\0" + "\0" + /* _mesa_function_pool[4891]: TexCoord3d (offset 110) */ + "ddd\0" + "glTexCoord3d\0" + "\0" + /* _mesa_function_pool[4909]: VertexAttrib3fv (will be remapped) */ + "ip\0" + "glVertexAttrib3fv\0" + "\0" + /* _mesa_function_pool[4931]: TexCoord3f (offset 112) */ + "fff\0" + "glTexCoord3f\0" + "\0" + /* _mesa_function_pool[4949]: MultiTexCoord3ivARB (offset 397) */ + "ip\0" + "glMultiTexCoord3ivARB\0" + "\0" + /* _mesa_function_pool[4975]: MultiTexCoord2sARB (offset 390) */ + "iii\0" + "glMultiTexCoord2sARB\0" + "\0" + /* _mesa_function_pool[5001]: DeleteTextures (offset 327) */ + "ip\0" + "glDeleteTextures\0" + "\0" + /* _mesa_function_pool[5022]: TexCoord3s (offset 116) */ + "iii\0" + "glTexCoord3s\0" + "\0" + /* _mesa_function_pool[5040]: GetTexLevelParameteriv (offset 285) */ + "iiip\0" + "glGetTexLevelParameteriv\0" + "\0" + /* _mesa_function_pool[5071]: ClearAccum (offset 204) */ + "ffff\0" + "glClearAccum\0" + "\0" + /* _mesa_function_pool[5090]: TexCoord4iv (offset 123) */ + "p\0" + "glTexCoord4iv\0" + "\0" + /* _mesa_function_pool[5107]: PolygonOffset (offset 319) */ + "ff\0" + "glPolygonOffset\0" + "\0" + /* _mesa_function_pool[5127]: GetBufferParameteriv (will be remapped) */ + "iip\0" + "glGetBufferParameteriv\0" + "\0" + /* _mesa_function_pool[5155]: Indexfv (offset 47) */ + "p\0" + "glIndexfv\0" + "\0" + /* _mesa_function_pool[5168]: ColorTableParameteriv (offset 341) */ + "iip\0" + "glColorTableParameteriv\0" + "\0" + /* _mesa_function_pool[5197]: CopyTexImage2D (offset 324) */ + "iiiiiiii\0" + "glCopyTexImage2D\0" + "\0" + /* _mesa_function_pool[5224]: GenVertexArraysAPPLE (will be remapped) */ + "ip\0" + "glGenVertexArraysAPPLE\0" + "\0" + /* _mesa_function_pool[5251]: Lightfv (offset 160) */ + "iip\0" + "glLightfv\0" + "\0" + /* _mesa_function_pool[5266]: GetFramebufferAttachmentParameteriv (will be remapped) */ + "iiip\0" + "glGetFramebufferAttachmentParameteriv\0" + "\0" + /* _mesa_function_pool[5310]: ClearDepth (offset 208) */ + "d\0" + "glClearDepth\0" + "\0" + /* _mesa_function_pool[5326]: GetVertexAttribPointerv (will be remapped) */ + "iip\0" + "glGetVertexAttribPointerv\0" + "\0" + /* _mesa_function_pool[5357]: ColorSubTable (offset 346) */ + "iiiiip\0" + "glColorSubTable\0" + "\0" + /* _mesa_function_pool[5381]: Color4fv (offset 30) */ + "p\0" + "glColor4fv\0" + "\0" + /* _mesa_function_pool[5395]: MultiTexCoord4ivARB (offset 405) */ + "ip\0" + "glMultiTexCoord4ivARB\0" + "\0" + /* _mesa_function_pool[5421]: ColorPointer (offset 308) */ + "iiip\0" + "glColorPointer\0" + "\0" + /* _mesa_function_pool[5442]: GetShaderiv (will be remapped) */ + "iip\0" + "glGetShaderiv\0" + "\0" + /* _mesa_function_pool[5461]: Lightiv (offset 162) */ + "iip\0" + "glLightiv\0" + "\0" + /* _mesa_function_pool[5476]: Color3bv (offset 10) */ + "p\0" + "glColor3bv\0" + "\0" + /* _mesa_function_pool[5490]: GetBufferPointervOES (will be remapped) */ + "iip\0" + "glGetBufferPointervOES\0" + "\0" + /* _mesa_function_pool[5518]: Rectdv (offset 87) */ + "pp\0" + "glRectdv\0" + "\0" + /* _mesa_function_pool[5531]: GetAttachedShaders (will be remapped) */ + "iipp\0" + "glGetAttachedShaders\0" + "\0" + /* _mesa_function_pool[5558]: Materialiv (offset 172) */ + "iip\0" + "glMaterialiv\0" + "\0" + /* _mesa_function_pool[5576]: PushClientAttrib (offset 335) */ + "i\0" + "glPushClientAttrib\0" + "\0" + /* _mesa_function_pool[5598]: PolygonMode (offset 174) */ + "ii\0" + "glPolygonMode\0" + "\0" + /* _mesa_function_pool[5616]: LinkProgram (will be remapped) */ + "i\0" + "glLinkProgram\0" + "\0" + /* _mesa_function_pool[5633]: Uniform1f (will be remapped) */ + "if\0" + "glUniform1f\0" + "\0" + /* _mesa_function_pool[5649]: DisableClientState (offset 309) */ + "i\0" + "glDisableClientState\0" + "\0" + /* _mesa_function_pool[5673]: TexGeni (offset 192) */ + "iii\0" + "glTexGeni\0" + "\0" + /* _mesa_function_pool[5688]: TexGenf (offset 190) */ + "iif\0" + "glTexGenf\0" + "\0" + /* _mesa_function_pool[5703]: TexGend (offset 188) */ + "iid\0" + "glTexGend\0" + "\0" + /* _mesa_function_pool[5718]: Uniform1i (will be remapped) */ + "ii\0" + "glUniform1i\0" + "\0" + /* _mesa_function_pool[5734]: GetPolygonStipple (offset 274) */ + "p\0" + "glGetPolygonStipple\0" + "\0" + /* _mesa_function_pool[5757]: VertexAttrib4f (will be remapped) */ + "iffff\0" + "glVertexAttrib4f\0" + "\0" + /* _mesa_function_pool[5781]: ConvolutionFilter2D (offset 349) */ + "iiiiiip\0" + "glConvolutionFilter2D\0" + "\0" + /* _mesa_function_pool[5812]: ClientActiveTextureARB (offset 375) */ + "i\0" + "glClientActiveTextureARB\0" + "\0" + /* _mesa_function_pool[5840]: UseProgram (will be remapped) */ + "i\0" + "glUseProgram\0" + "\0" + /* _mesa_function_pool[5856]: Color4sv (offset 34) */ + "p\0" + "glColor4sv\0" + "\0" + /* _mesa_function_pool[5870]: Uniform4f (will be remapped) */ + "iffff\0" + "glUniform4f\0" + "\0" + /* _mesa_function_pool[5889]: ResetHistogram (offset 369) */ + "i\0" + "glResetHistogram\0" + "\0" + /* _mesa_function_pool[5909]: PixelZoom (offset 246) */ + "ff\0" + "glPixelZoom\0" + "\0" + /* _mesa_function_pool[5925]: ColorTableParameterfv (offset 340) */ + "iip\0" + "glColorTableParameterfv\0" + "\0" + /* _mesa_function_pool[5954]: PixelMapuiv (offset 252) */ + "iip\0" + "glPixelMapuiv\0" + "\0" + /* _mesa_function_pool[5973]: Color3dv (offset 12) */ + "p\0" + "glColor3dv\0" + "\0" + /* _mesa_function_pool[5987]: IsTexture (offset 330) */ + "i\0" + "glIsTexture\0" + "\0" + /* _mesa_function_pool[6002]: Fogfv (offset 154) */ + "ip\0" + "glFogfv\0" + "\0" + /* _mesa_function_pool[6014]: GetMapdv (offset 266) */ + "iip\0" + "glGetMapdv\0" + "\0" + /* _mesa_function_pool[6030]: GetUniformLocation (will be remapped) */ + "ip\0" + "glGetUniformLocation\0" + "\0" + /* _mesa_function_pool[6055]: PixelStoref (offset 249) */ + "if\0" + "glPixelStoref\0" + "\0" + /* _mesa_function_pool[6073]: PrioritizeTextures (offset 331) */ + "ipp\0" + "glPrioritizeTextures\0" + "\0" + /* _mesa_function_pool[6099]: PixelStorei (offset 250) */ + "ii\0" + "glPixelStorei\0" + "\0" + /* _mesa_function_pool[6117]: IsBuffer (will be remapped) */ + "i\0" + "glIsBuffer\0" + "\0" + /* _mesa_function_pool[6131]: EvalCoord2dv (offset 233) */ + "p\0" + "glEvalCoord2dv\0" + "\0" + /* _mesa_function_pool[6149]: ColorMaterial (offset 151) */ + "ii\0" + "glColorMaterial\0" + "\0" + /* _mesa_function_pool[6169]: Minmax (offset 368) */ + "iii\0" + "glMinmax\0" + "\0" + /* _mesa_function_pool[6183]: GetSeparableFilter (offset 359) */ + "iiippp\0" + "glGetSeparableFilter\0" + "\0" + /* _mesa_function_pool[6212]: FeedbackBuffer (offset 194) */ + "iip\0" + "glFeedbackBuffer\0" + "\0" + /* _mesa_function_pool[6234]: RasterPos2iv (offset 67) */ + "p\0" + "glRasterPos2iv\0" + "\0" + /* _mesa_function_pool[6252]: TexImage1D (offset 182) */ + "iiiiiiip\0" + "glTexImage1D\0" + "\0" + /* _mesa_function_pool[6275]: MultiDrawElementsEXT (will be remapped) */ + "ipipi\0" + "glMultiDrawElementsEXT\0" + "\0" + /* _mesa_function_pool[6305]: Color3s (offset 17) */ + "iii\0" + "glColor3s\0" + "\0" + /* _mesa_function_pool[6320]: CheckFramebufferStatus (will be remapped) */ + "i\0" + "glCheckFramebufferStatus\0" + "\0" + /* _mesa_function_pool[6348]: TexCoordPointer (offset 320) */ + "iiip\0" + "glTexCoordPointer\0" + "\0" + /* _mesa_function_pool[6372]: Color3i (offset 15) */ + "iii\0" + "glColor3i\0" + "\0" + /* _mesa_function_pool[6387]: FrontFace (offset 157) */ + "i\0" + "glFrontFace\0" + "\0" + /* _mesa_function_pool[6402]: EvalCoord2d (offset 232) */ + "dd\0" + "glEvalCoord2d\0" + "\0" + /* _mesa_function_pool[6420]: EvalCoord2f (offset 234) */ + "ff\0" + "glEvalCoord2f\0" + "\0" + /* _mesa_function_pool[6438]: Color3b (offset 9) */ + "iii\0" + "glColor3b\0" + "\0" + /* _mesa_function_pool[6453]: MultiTexCoord2dARB (offset 384) */ + "idd\0" + "glMultiTexCoord2dARB\0" + "\0" + /* _mesa_function_pool[6479]: Color3f (offset 13) */ + "fff\0" + "glColor3f\0" + "\0" + /* _mesa_function_pool[6494]: Color3d (offset 11) */ + "ddd\0" + "glColor3d\0" + "\0" + /* _mesa_function_pool[6509]: Normal3dv (offset 55) */ + "p\0" + "glNormal3dv\0" + "\0" + /* _mesa_function_pool[6524]: Lightf (offset 159) */ + "iif\0" + "glLightf\0" + "\0" + /* _mesa_function_pool[6538]: MatrixMode (offset 293) */ + "i\0" + "glMatrixMode\0" + "\0" + /* _mesa_function_pool[6554]: Uniform1iv (will be remapped) */ + "iip\0" + "glUniform1iv\0" + "\0" + /* _mesa_function_pool[6572]: Lighti (offset 161) */ + "iii\0" + "glLighti\0" + "\0" + /* _mesa_function_pool[6586]: GenFramebuffers (will be remapped) */ + "ip\0" + "glGenFramebuffers\0" + "\0" + /* _mesa_function_pool[6608]: Color4s (offset 33) */ + "iiii\0" + "glColor4s\0" + "\0" + /* _mesa_function_pool[6624]: IsFramebuffer (will be remapped) */ + "i\0" + "glIsFramebuffer\0" + "\0" + /* _mesa_function_pool[6643]: BlendEquationSeparate (will be remapped) */ + "ii\0" + "glBlendEquationSeparate\0" + "\0" + /* _mesa_function_pool[6671]: GetDoublev (offset 260) */ + "ip\0" + "glGetDoublev\0" + "\0" + /* _mesa_function_pool[6688]: MultMatrixd (offset 295) */ + "p\0" + "glMultMatrixd\0" + "\0" + /* _mesa_function_pool[6705]: MultMatrixf (offset 294) */ + "p\0" + "glMultMatrixf\0" + "\0" + /* _mesa_function_pool[6722]: VertexAttrib1f (will be remapped) */ + "if\0" + "glVertexAttrib1f\0" + "\0" + /* _mesa_function_pool[6743]: MultiTexCoord4fvARB (offset 403) */ + "ip\0" + "glMultiTexCoord4fvARB\0" + "\0" + /* _mesa_function_pool[6769]: RasterPos4sv (offset 85) */ + "p\0" + "glRasterPos4sv\0" + "\0" + /* _mesa_function_pool[6787]: DrawArrays (offset 310) */ + "iii\0" + "glDrawArrays\0" + "\0" + /* _mesa_function_pool[6805]: TexEnviv (offset 187) */ + "iip\0" + "glTexEnviv\0" + "\0" + /* _mesa_function_pool[6821]: CreateShader (will be remapped) */ + "i\0" + "glCreateShader\0" + "\0" + /* _mesa_function_pool[6839]: GetColorTableParameterfv (offset 344) */ + "iip\0" + "glGetColorTableParameterfv\0" + "\0" + /* _mesa_function_pool[6871]: FramebufferTexture2D (will be remapped) */ + "iiiii\0" + "glFramebufferTexture2D\0" + "\0" + /* _mesa_function_pool[6901]: Bitmap (offset 8) */ + "iiffffp\0" + "glBitmap\0" + "\0" + /* _mesa_function_pool[6919]: MultiTexCoord3fARB (offset 394) */ + "ifff\0" + "glMultiTexCoord3fARB\0" + "\0" + /* _mesa_function_pool[6946]: GetTexLevelParameterfv (offset 284) */ + "iiip\0" + "glGetTexLevelParameterfv\0" + "\0" + /* _mesa_function_pool[6977]: Vertex2sv (offset 133) */ + "p\0" + "glVertex2sv\0" + "\0" + /* _mesa_function_pool[6992]: GetIntegerv (offset 263) */ + "ip\0" + "glGetIntegerv\0" + "\0" + /* _mesa_function_pool[7010]: GetShaderSource (will be remapped) */ + "iipp\0" + "glGetShaderSource\0" + "\0" + /* _mesa_function_pool[7034]: GetActiveUniform (will be remapped) */ + "iiipppp\0" + "glGetActiveUniform\0" + "\0" + /* _mesa_function_pool[7062]: DeleteBuffers (will be remapped) */ + "ip\0" + "glDeleteBuffers\0" + "\0" + /* _mesa_function_pool[7082]: GetTexEnviv (offset 277) */ + "iip\0" + "glGetTexEnviv\0" + "\0" + /* _mesa_function_pool[7101]: PopClientAttrib (offset 334) */ + "\0" + "glPopClientAttrib\0" + "\0" + /* _mesa_function_pool[7121]: SeparableFilter2D (offset 360) */ + "iiiiiipp\0" + "glSeparableFilter2D\0" + "\0" + /* _mesa_function_pool[7151]: VertexAttrib2fv (will be remapped) */ + "ip\0" + "glVertexAttrib2fv\0" + "\0" + /* _mesa_function_pool[7173]: Map1d (offset 220) */ + "iddiip\0" + "glMap1d\0" + "\0" + /* _mesa_function_pool[7189]: Map1f (offset 221) */ + "iffiip\0" + "glMap1f\0" + "\0" + /* _mesa_function_pool[7205]: ArrayElement (offset 306) */ + "i\0" + "glArrayElement\0" + "\0" + /* _mesa_function_pool[7223]: TexImage2D (offset 183) */ + "iiiiiiiip\0" + "glTexImage2D\0" + "\0" + /* _mesa_function_pool[7247]: GetMinmaxParameteriv (offset 366) */ + "iip\0" + "glGetMinmaxParameteriv\0" + "\0" + /* _mesa_function_pool[7275]: PixelTransferf (offset 247) */ + "if\0" + "glPixelTransferf\0" + "\0" + /* _mesa_function_pool[7296]: CopyTexImage1D (offset 323) */ + "iiiiiii\0" + "glCopyTexImage1D\0" + "\0" + /* _mesa_function_pool[7322]: RasterPos2dv (offset 63) */ + "p\0" + "glRasterPos2dv\0" + "\0" + /* _mesa_function_pool[7340]: Fogiv (offset 156) */ + "ip\0" + "glFogiv\0" + "\0" + /* _mesa_function_pool[7352]: TexCoord1dv (offset 95) */ + "p\0" + "glTexCoord1dv\0" + "\0" + /* _mesa_function_pool[7369]: PixelTransferi (offset 248) */ + "ii\0" + "glPixelTransferi\0" + "\0" + /* _mesa_function_pool[7390]: Rotatef (offset 300) */ + "ffff\0" + "glRotatef\0" + "\0" + /* _mesa_function_pool[7406]: Vertex3i (offset 138) */ + "iii\0" + "glVertex3i\0" + "\0" + /* _mesa_function_pool[7422]: Vertex3f (offset 136) */ + "fff\0" + "glVertex3f\0" + "\0" + /* _mesa_function_pool[7438]: Clear (offset 203) */ + "i\0" + "glClear\0" + "\0" + /* _mesa_function_pool[7449]: Vertex3d (offset 134) */ + "ddd\0" + "glVertex3d\0" + "\0" + /* _mesa_function_pool[7465]: ReadBuffer (offset 254) */ + "i\0" + "glReadBuffer\0" + "\0" + /* _mesa_function_pool[7481]: ConvolutionParameteri (offset 352) */ + "iii\0" + "glConvolutionParameteri\0" + "\0" + /* _mesa_function_pool[7510]: Ortho (offset 296) */ + "dddddd\0" + "glOrtho\0" + "\0" + /* _mesa_function_pool[7526]: ListBase (offset 6) */ + "i\0" + "glListBase\0" + "\0" + /* _mesa_function_pool[7540]: Vertex3s (offset 140) */ + "iii\0" + "glVertex3s\0" + "\0" + /* _mesa_function_pool[7556]: ConvolutionParameterf (offset 350) */ + "iif\0" + "glConvolutionParameterf\0" + "\0" + /* _mesa_function_pool[7585]: GetColorTableParameteriv (offset 345) */ + "iip\0" + "glGetColorTableParameteriv\0" + "\0" + /* _mesa_function_pool[7617]: ShadeModel (offset 177) */ + "i\0" + "glShadeModel\0" + "\0" + /* _mesa_function_pool[7633]: GenerateMipmap (will be remapped) */ + "i\0" + "glGenerateMipmap\0" + "\0" + /* _mesa_function_pool[7653]: Rectiv (offset 91) */ + "pp\0" + "glRectiv\0" + "\0" + /* _mesa_function_pool[7666]: TexCoord3fv (offset 113) */ + "p\0" + "glTexCoord3fv\0" + "\0" + /* _mesa_function_pool[7683]: Vertex2fv (offset 129) */ + "p\0" + "glVertex2fv\0" + "\0" + /* _mesa_function_pool[7698]: MultiDrawArraysEXT (will be remapped) */ + "ippi\0" + "glMultiDrawArraysEXT\0" + "\0" + /* _mesa_function_pool[7725]: MultiTexCoord4dARB (offset 400) */ + "idddd\0" + "glMultiTexCoord4dARB\0" + "\0" + /* _mesa_function_pool[7753]: Vertex3sv (offset 141) */ + "p\0" + "glVertex3sv\0" + "\0" + /* _mesa_function_pool[7768]: EvalMesh1 (offset 236) */ + "iii\0" + "glEvalMesh1\0" + "\0" + /* _mesa_function_pool[7785]: DeleteShader (will be remapped) */ + "i\0" + "glDeleteShader\0" + "\0" + /* _mesa_function_pool[7803]: VertexAttrib2f (will be remapped) */ + "iff\0" + "glVertexAttrib2f\0" + "\0" + /* _mesa_function_pool[7825]: Uniform2f (will be remapped) */ + "iff\0" + "glUniform2f\0" + "\0" + /* _mesa_function_pool[7842]: MultiTexCoord1dvARB (offset 377) */ + "ip\0" + "glMultiTexCoord1dvARB\0" + "\0" + /* _mesa_function_pool[7868]: CompileShader (will be remapped) */ + "i\0" + "glCompileShader\0" + "\0" + /* _mesa_function_pool[7887]: Vertex2iv (offset 131) */ + "p\0" + "glVertex2iv\0" + "\0" + /* _mesa_function_pool[7902]: LineWidth (offset 168) */ + "f\0" + "glLineWidth\0" + "\0" + /* _mesa_function_pool[7917]: MultiTexCoord2ivARB (offset 389) */ + "ip\0" + "glMultiTexCoord2ivARB\0" + "\0" + /* _mesa_function_pool[7943]: Uniform2i (will be remapped) */ + "iii\0" + "glUniform2i\0" + "\0" + /* _mesa_function_pool[7960]: TexGendv (offset 189) */ + "iip\0" + "glTexGendv\0" + "\0" + /* _mesa_function_pool[7976]: Uniform1fv (will be remapped) */ + "iip\0" + "glUniform1fv\0" + "\0" + /* _mesa_function_pool[7994]: ResetMinmax (offset 370) */ + "i\0" + "glResetMinmax\0" + "\0" + /* _mesa_function_pool[8011]: EnableClientState (offset 313) */ + "i\0" + "glEnableClientState\0" + "\0" + /* _mesa_function_pool[8034]: GetConvolutionParameterfv (offset 357) */ + "iip\0" + "glGetConvolutionParameterfv\0" + "\0" + /* _mesa_function_pool[8067]: GetPixelMapusv (offset 273) */ + "ip\0" + "glGetPixelMapusv\0" + "\0" + /* _mesa_function_pool[8088]: GetMaterialfv (offset 269) */ + "iip\0" + "glGetMaterialfv\0" + "\0" + /* _mesa_function_pool[8109]: CallList (offset 2) */ + "i\0" + "glCallList\0" + "\0" + /* _mesa_function_pool[8123]: Materialfv (offset 170) */ + "iip\0" + "glMaterialfv\0" + "\0" + /* _mesa_function_pool[8141]: DeleteProgram (will be remapped) */ + "i\0" + "glDeleteProgram\0" + "\0" + /* _mesa_function_pool[8160]: CompressedTexSubImage3DOES (will be remapped) */ + "iiiiiiiiiip\0" + "glCompressedTexSubImage3DOES\0" + "\0" + /* _mesa_function_pool[8202]: MultiTexCoord1ivARB (offset 381) */ + "ip\0" + "glMultiTexCoord1ivARB\0" + "\0" + /* _mesa_function_pool[8228]: DetachShader (will be remapped) */ + "ii\0" + "glDetachShader\0" + "\0" + /* _mesa_function_pool[8247]: ClearDepthf (will be remapped) */ + "f\0" + "glClearDepthf\0" + "\0" + /* _mesa_function_pool[8264]: CopyTexSubImage2D (offset 326) */ + "iiiiiiii\0" + "glCopyTexSubImage2D\0" + "\0" + /* _mesa_function_pool[8294]: SampleCoverage (will be remapped) */ + "fi\0" + "glSampleCoverage\0" + "\0" + /* _mesa_function_pool[8315]: Color3iv (offset 16) */ + "p\0" + "glColor3iv\0" + "\0" + /* _mesa_function_pool[8329]: DrawElements (offset 311) */ + "iiip\0" + "glDrawElements\0" + "\0" + /* _mesa_function_pool[8350]: BindVertexArrayAPPLE (will be remapped) */ + "i\0" + "glBindVertexArrayAPPLE\0" + "\0" + /* _mesa_function_pool[8376]: GetHistogramParameteriv (offset 363) */ + "iip\0" + "glGetHistogramParameteriv\0" + "\0" + /* _mesa_function_pool[8407]: MultiTexCoord1iARB (offset 380) */ + "ii\0" + "glMultiTexCoord1iARB\0" + "\0" + /* _mesa_function_pool[8432]: GetConvolutionFilter (offset 356) */ + "iiip\0" + "glGetConvolutionFilter\0" + "\0" + /* _mesa_function_pool[8461]: TexSubImage3DOES (offset 372) */ + "iiiiiiiiiip\0" + "glTexSubImage3DOES\0" + "glTexSubImage3D\0" + "\0" + /* _mesa_function_pool[8509]: Uniform2iv (will be remapped) */ + "iip\0" + "glUniform2iv\0" + "\0" + /* _mesa_function_pool[8527]: BindRenderbuffer (will be remapped) */ + "ii\0" + "glBindRenderbuffer\0" + "\0" + /* _mesa_function_pool[8550]: EvalPoint2 (offset 239) */ + "ii\0" + "glEvalPoint2\0" + "\0" + /* _mesa_function_pool[8567]: EvalPoint1 (offset 237) */ + "i\0" + "glEvalPoint1\0" + "\0" + /* _mesa_function_pool[8583]: PopMatrix (offset 297) */ + "\0" + "glPopMatrix\0" + "\0" + /* _mesa_function_pool[8597]: DeleteFramebuffers (will be remapped) */ + "ip\0" + "glDeleteFramebuffers\0" + "\0" + /* _mesa_function_pool[8622]: GetTexGeniv (offset 280) */ + "iip\0" + "glGetTexGeniv\0" + "\0" + /* _mesa_function_pool[8641]: MultiTexCoord4dvARB (offset 401) */ + "ip\0" + "glMultiTexCoord4dvARB\0" + "\0" + /* _mesa_function_pool[8667]: FramebufferRenderbuffer (will be remapped) */ + "iiii\0" + "glFramebufferRenderbuffer\0" + "\0" + /* _mesa_function_pool[8699]: Map2d (offset 222) */ + "iddiiddiip\0" + "glMap2d\0" + "\0" + /* _mesa_function_pool[8719]: Map2f (offset 223) */ + "iffiiffiip\0" + "glMap2f\0" + "\0" + /* _mesa_function_pool[8739]: Vertex4s (offset 148) */ + "iiii\0" + "glVertex4s\0" + "\0" + /* _mesa_function_pool[8756]: Vertex4f (offset 144) */ + "ffff\0" + "glVertex4f\0" + "\0" + /* _mesa_function_pool[8773]: EvalCoord1d (offset 228) */ + "d\0" + "glEvalCoord1d\0" + "\0" + /* _mesa_function_pool[8790]: Vertex4d (offset 142) */ + "dddd\0" + "glVertex4d\0" + "\0" + /* _mesa_function_pool[8807]: RasterPos4dv (offset 79) */ + "p\0" + "glRasterPos4dv\0" + "\0" + /* _mesa_function_pool[8825]: GetTexGenfv (offset 279) */ + "iip\0" + "glGetTexGenfv\0" + "\0" + /* _mesa_function_pool[8844]: Vertex4i (offset 146) */ + "iiii\0" + "glVertex4i\0" + "\0" + /* _mesa_function_pool[8861]: GetHistogram (offset 361) */ + "iiiip\0" + "glGetHistogram\0" + "\0" + /* _mesa_function_pool[8883]: Materialf (offset 169) */ + "iif\0" + "glMaterialf\0" + "\0" + /* _mesa_function_pool[8900]: Materiali (offset 171) */ + "iii\0" + "glMateriali\0" + "\0" + /* _mesa_function_pool[8917]: Indexsv (offset 51) */ + "p\0" + "glIndexsv\0" + "\0" + /* _mesa_function_pool[8930]: MultiTexCoord4svARB (offset 407) */ + "ip\0" + "glMultiTexCoord4svARB\0" + "\0" + /* _mesa_function_pool[8956]: LightModelfv (offset 164) */ + "ip\0" + "glLightModelfv\0" + "\0" + /* _mesa_function_pool[8975]: Vertex4dv (offset 143) */ + "p\0" + "glVertex4dv\0" + "\0" + /* _mesa_function_pool[8990]: EvalCoord1dv (offset 229) */ + "p\0" + "glEvalCoord1dv\0" + "\0" + /* _mesa_function_pool[9008]: Translated (offset 303) */ + "ddd\0" + "glTranslated\0" + "\0" + /* _mesa_function_pool[9026]: Uniform4fv (will be remapped) */ + "iip\0" + "glUniform4fv\0" + "\0" + /* _mesa_function_pool[9044]: StencilMask (offset 209) */ + "i\0" + "glStencilMask\0" + "\0" + /* _mesa_function_pool[9061]: GetLightiv (offset 265) */ + "iip\0" + "glGetLightiv\0" + "\0" + /* _mesa_function_pool[9079]: IsList (offset 287) */ + "i\0" + "glIsList\0" + "\0" + /* _mesa_function_pool[9091]: RenderMode (offset 196) */ + "i\0" + "glRenderMode\0" + "\0" + /* _mesa_function_pool[9107]: MultiTexCoord1fARB (offset 378) */ + "if\0" + "glMultiTexCoord1fARB\0" + "\0" + /* _mesa_function_pool[9132]: BindBuffer (will be remapped) */ + "ii\0" + "glBindBuffer\0" + "\0" + /* _mesa_function_pool[9149]: CopyTexSubImage1D (offset 325) */ + "iiiiii\0" + "glCopyTexSubImage1D\0" + "\0" + /* _mesa_function_pool[9177]: CullFace (offset 152) */ + "i\0" + "glCullFace\0" + "\0" + /* _mesa_function_pool[9191]: BindTexture (offset 307) */ + "ii\0" + "glBindTexture\0" + "\0" + /* _mesa_function_pool[9209]: MultiTexCoord4fARB (offset 402) */ + "iffff\0" + "glMultiTexCoord4fARB\0" + "\0" + /* _mesa_function_pool[9237]: StencilFunc (offset 243) */ + "iii\0" + "glStencilFunc\0" + "\0" + /* _mesa_function_pool[9256]: CopyPixels (offset 255) */ + "iiiii\0" + "glCopyPixels\0" + "\0" + /* _mesa_function_pool[9276]: Rectsv (offset 93) */ + "pp\0" + "glRectsv\0" + "\0" + /* _mesa_function_pool[9289]: GetPixelMapuiv (offset 272) */ + "ip\0" + "glGetPixelMapuiv\0" + "\0" + /* _mesa_function_pool[9310]: CopyConvolutionFilter2D (offset 355) */ + "iiiiii\0" + "glCopyConvolutionFilter2D\0" + "\0" + /* _mesa_function_pool[9344]: NormalPointer (offset 318) */ + "iip\0" + "glNormalPointer\0" + "\0" + /* _mesa_function_pool[9365]: TexParameterfv (offset 179) */ + "iip\0" + "glTexParameterfv\0" + "\0" + /* _mesa_function_pool[9387]: ClipPlane (offset 150) */ + "ip\0" + "glClipPlane\0" + "\0" + /* _mesa_function_pool[9403]: Recti (offset 90) */ + "iiii\0" + "glRecti\0" + "\0" + /* _mesa_function_pool[9417]: VertexAttribPointer (will be remapped) */ + "iiiiip\0" + "glVertexAttribPointer\0" + "\0" + /* _mesa_function_pool[9447]: VertexAttrib1fv (will be remapped) */ + "ip\0" + "glVertexAttrib1fv\0" + "\0" + /* _mesa_function_pool[9469]: Rectf (offset 88) */ + "ffff\0" + "glRectf\0" + "\0" + /* _mesa_function_pool[9483]: Rectd (offset 86) */ + "dddd\0" + "glRectd\0" + "\0" + /* _mesa_function_pool[9497]: Rects (offset 92) */ + "iiii\0" + "glRects\0" + "\0" + /* _mesa_function_pool[9511]: IndexMask (offset 212) */ + "i\0" + "glIndexMask\0" + "\0" + /* _mesa_function_pool[9526]: GetFloatv (offset 262) */ + "ip\0" + "glGetFloatv\0" + "\0" + /* _mesa_function_pool[9542]: FramebufferTexture3DOES (will be remapped) */ + "iiiiii\0" + "glFramebufferTexture3DOES\0" + "\0" + /* _mesa_function_pool[9576]: TexCoord4s (offset 124) */ + "iiii\0" + "glTexCoord4s\0" + "\0" + /* _mesa_function_pool[9595]: TexCoord3sv (offset 117) */ + "p\0" + "glTexCoord3sv\0" + "\0" + /* _mesa_function_pool[9612]: PopAttrib (offset 218) */ + "\0" + "glPopAttrib\0" + "\0" + /* _mesa_function_pool[9626]: TexCoord4i (offset 122) */ + "iiii\0" + "glTexCoord4i\0" + "\0" + /* _mesa_function_pool[9645]: InitNames (offset 197) */ + "\0" + "glInitNames\0" + "\0" + /* _mesa_function_pool[9659]: Normal3sv (offset 61) */ + "p\0" + "glNormal3sv\0" + "\0" + /* _mesa_function_pool[9674]: UnmapBufferOES (will be remapped) */ + "i\0" + "glUnmapBufferOES\0" + "\0" + /* _mesa_function_pool[9694]: TexCoord4d (offset 118) */ + "dddd\0" + "glTexCoord4d\0" + "\0" + /* _mesa_function_pool[9713]: TexCoord4f (offset 120) */ + "ffff\0" + "glTexCoord4f\0" + "\0" + /* _mesa_function_pool[9732]: GetBooleanv (offset 258) */ + "ip\0" + "glGetBooleanv\0" + "\0" + /* _mesa_function_pool[9750]: Hint (offset 158) */ + "ii\0" + "glHint\0" + "\0" + /* _mesa_function_pool[9761]: Color4dv (offset 28) */ + "p\0" + "glColor4dv\0" + "\0" + /* _mesa_function_pool[9775]: DisableVertexAttribArray (will be remapped) */ + "i\0" + "glDisableVertexAttribArray\0" + "\0" + /* _mesa_function_pool[9805]: CopyColorSubTable (offset 347) */ + "iiiii\0" + "glCopyColorSubTable\0" + "\0" + /* _mesa_function_pool[9832]: IsVertexArrayAPPLE (will be remapped) */ + "i\0" + "glIsVertexArrayAPPLE\0" + "\0" + /* _mesa_function_pool[9856]: Vertex4iv (offset 147) */ + "p\0" + "glVertex4iv\0" + "\0" + /* _mesa_function_pool[9871]: BufferSubData (will be remapped) */ + "iiip\0" + "glBufferSubData\0" + "\0" + /* _mesa_function_pool[9893]: TexCoord4dv (offset 119) */ + "p\0" + "glTexCoord4dv\0" + "\0" + /* _mesa_function_pool[9910]: Begin (offset 7) */ + "i\0" + "glBegin\0" + "\0" + /* _mesa_function_pool[9921]: LightModeli (offset 165) */ + "ii\0" + "glLightModeli\0" + "\0" + /* _mesa_function_pool[9939]: Rectfv (offset 89) */ + "pp\0" + "glRectfv\0" + "\0" + /* _mesa_function_pool[9952]: UniformMatrix2fv (will be remapped) */ + "iiip\0" + "glUniformMatrix2fv\0" + "\0" + /* _mesa_function_pool[9977]: LightModelf (offset 163) */ + "if\0" + "glLightModelf\0" + "\0" + /* _mesa_function_pool[9995]: GetTexParameterfv (offset 282) */ + "iip\0" + "glGetTexParameterfv\0" + "\0" + /* _mesa_function_pool[10020]: GetLightfv (offset 264) */ + "iip\0" + "glGetLightfv\0" + "\0" + /* _mesa_function_pool[10038]: Disable (offset 214) */ + "i\0" + "glDisable\0" + "\0" + /* _mesa_function_pool[10051]: MultiTexCoord2fvARB (offset 387) */ + "ip\0" + "glMultiTexCoord2fvARB\0" + "\0" + /* _mesa_function_pool[10077]: SelectBuffer (offset 195) */ + "ip\0" + "glSelectBuffer\0" + "\0" + /* _mesa_function_pool[10096]: ColorMask (offset 210) */ + "iiii\0" + "glColorMask\0" + "\0" + /* _mesa_function_pool[10114]: RasterPos4iv (offset 83) */ + "p\0" + "glRasterPos4iv\0" + "\0" + /* _mesa_function_pool[10132]: TexGenfv (offset 191) */ + "iip\0" + "glTexGenfv\0" + "\0" + /* _mesa_function_pool[10148]: GetRenderbufferParameteriv (will be remapped) */ + "iip\0" + "glGetRenderbufferParameteriv\0" + "\0" + /* _mesa_function_pool[10182]: Indexub (offset 315) */ + "i\0" + "glIndexub\0" + "\0" + /* _mesa_function_pool[10195]: GenRenderbuffers (will be remapped) */ + "ip\0" + "glGenRenderbuffers\0" + "\0" + /* _mesa_function_pool[10218]: UniformMatrix4fv (will be remapped) */ + "iiip\0" + "glUniformMatrix4fv\0" + "\0" + /* _mesa_function_pool[10243]: GetMinmaxParameterfv (offset 365) */ + "iip\0" + "glGetMinmaxParameterfv\0" + "\0" + /* _mesa_function_pool[10271]: Vertex3fv (offset 137) */ + "p\0" + "glVertex3fv\0" + "\0" + /* _mesa_function_pool[10286]: Uniform4iv (will be remapped) */ + "iip\0" + "glUniform4iv\0" + "\0" + ; + +/* these functions need to be remapped */ +static const struct gl_function_pool_remap MESA_remap_table_functions[] = { + { 5490, GetBufferPointervOES_remap_index }, + { 2374, MapBufferOES_remap_index }, + { 9674, UnmapBufferOES_remap_index }, + { 1271, CompressedTexImage3DOES_remap_index }, + { 8160, CompressedTexSubImage3DOES_remap_index }, + { 9542, FramebufferTexture3DOES_remap_index }, + { 1413, GetProgramBinaryOES_remap_index }, + { 4388, ProgramBinaryOES_remap_index }, + { 7698, MultiDrawArraysEXT_remap_index }, + { 6275, MultiDrawElementsEXT_remap_index }, + { 8350, BindVertexArrayAPPLE_remap_index }, + { 848, DeleteVertexArraysAPPLE_remap_index }, + { 5224, GenVertexArraysAPPLE_remap_index }, + { 9832, IsVertexArrayAPPLE_remap_index }, + { 3905, EGLImageTargetRenderbufferStorageOES_remap_index }, + { 3678, EGLImageTargetTexture2DOES_remap_index }, + { 4413, CompressedTexImage2D_remap_index }, + { 1037, CompressedTexSubImage2D_remap_index }, + { 8294, SampleCoverage_remap_index }, + { 9132, BindBuffer_remap_index }, + { 3205, BufferData_remap_index }, + { 9871, BufferSubData_remap_index }, + { 7062, DeleteBuffers_remap_index }, + { 2566, GenBuffers_remap_index }, + { 5127, GetBufferParameteriv_remap_index }, + { 6117, IsBuffer_remap_index }, + { 540, AttachShader_remap_index }, + { 1387, BindAttribLocation_remap_index }, + { 6643, BlendEquationSeparate_remap_index }, + { 7868, CompileShader_remap_index }, + { 1843, CreateProgram_remap_index }, + { 6821, CreateShader_remap_index }, + { 8141, DeleteProgram_remap_index }, + { 7785, DeleteShader_remap_index }, + { 8228, DetachShader_remap_index }, + { 9775, DisableVertexAttribArray_remap_index }, + { 2668, EnableVertexAttribArray_remap_index }, + { 2061, GetActiveAttrib_remap_index }, + { 7034, GetActiveUniform_remap_index }, + { 5531, GetAttachedShaders_remap_index }, + { 4622, GetAttribLocation_remap_index }, + { 345, GetProgramInfoLog_remap_index }, + { 173, GetProgramiv_remap_index }, + { 3824, GetShaderInfoLog_remap_index }, + { 7010, GetShaderSource_remap_index }, + { 5442, GetShaderiv_remap_index }, + { 6030, GetUniformLocation_remap_index }, + { 1525, GetUniformfv_remap_index }, + { 1725, GetUniformiv_remap_index }, + { 5326, GetVertexAttribPointerv_remap_index }, + { 660, GetVertexAttribfv_remap_index }, + { 3279, GetVertexAttribiv_remap_index }, + { 4157, IsProgram_remap_index }, + { 3746, IsShader_remap_index }, + { 5616, LinkProgram_remap_index }, + { 3103, ShaderSource_remap_index }, + { 3075, StencilFuncSeparate_remap_index }, + { 1108, StencilMaskSeparate_remap_index }, + { 2287, StencilOpSeparate_remap_index }, + { 5633, Uniform1f_remap_index }, + { 7976, Uniform1fv_remap_index }, + { 5718, Uniform1i_remap_index }, + { 6554, Uniform1iv_remap_index }, + { 7825, Uniform2f_remap_index }, + { 371, Uniform2fv_remap_index }, + { 7943, Uniform2i_remap_index }, + { 8509, Uniform2iv_remap_index }, + { 892, Uniform3f_remap_index }, + { 1879, Uniform3fv_remap_index }, + { 811, Uniform3i_remap_index }, + { 4582, Uniform3iv_remap_index }, + { 5870, Uniform4f_remap_index }, + { 9026, Uniform4fv_remap_index }, + { 4369, Uniform4i_remap_index }, + { 10286, Uniform4iv_remap_index }, + { 9952, UniformMatrix2fv_remap_index }, + { 955, UniformMatrix3fv_remap_index }, + { 10218, UniformMatrix4fv_remap_index }, + { 5840, UseProgram_remap_index }, + { 1917, ValidateProgram_remap_index }, + { 6722, VertexAttrib1f_remap_index }, + { 9447, VertexAttrib1fv_remap_index }, + { 7803, VertexAttrib2f_remap_index }, + { 7151, VertexAttrib2fv_remap_index }, + { 1014, VertexAttrib3f_remap_index }, + { 4909, VertexAttrib3fv_remap_index }, + { 5757, VertexAttrib4f_remap_index }, + { 450, VertexAttrib4fv_remap_index }, + { 9417, VertexAttribPointer_remap_index }, + { 3049, BlendFuncSeparate_remap_index }, + { 2968, BindFramebuffer_remap_index }, + { 8527, BindRenderbuffer_remap_index }, + { 6320, CheckFramebufferStatus_remap_index }, + { 8247, ClearDepthf_remap_index }, + { 8597, DeleteFramebuffers_remap_index }, + { 3512, DeleteRenderbuffers_remap_index }, + { 1861, DepthRangef_remap_index }, + { 8667, FramebufferRenderbuffer_remap_index }, + { 6871, FramebufferTexture2D_remap_index }, + { 6586, GenFramebuffers_remap_index }, + { 10195, GenRenderbuffers_remap_index }, + { 7633, GenerateMipmap_remap_index }, + { 5266, GetFramebufferAttachmentParameteriv_remap_index }, + { 10148, GetRenderbufferParameteriv_remap_index }, + { 4472, GetShaderPrecisionFormat_remap_index }, + { 6624, IsFramebuffer_remap_index }, + { 3711, IsRenderbuffer_remap_index }, + { 3004, ReleaseShaderCompiler_remap_index }, + { 731, RenderbufferStorage_remap_index }, + { 3304, ShaderBinary_remap_index }, + { -1, -1 } +}; + +/* these functions are in the ABI, but have alternative names */ +static const struct gl_function_remap MESA_alt_functions[] = { + { -1, -1 } +}; + +#endif /* need_MESA_remap_table */ + +#if defined(need_GL_APPLE_vertex_array_object) +/* functions defined in MESA_remap_table_functions are excluded */ +static const struct gl_function_remap GL_APPLE_vertex_array_object_functions[] = { + { -1, -1 } +}; +#endif + +#if defined(need_GL_EXT_multi_draw_arrays) +/* functions defined in MESA_remap_table_functions are excluded */ +static const struct gl_function_remap GL_EXT_multi_draw_arrays_functions[] = { + { -1, -1 } +}; +#endif + +#if defined(need_GL_OES_EGL_image) +/* functions defined in MESA_remap_table_functions are excluded */ +static const struct gl_function_remap GL_OES_EGL_image_functions[] = { + { -1, -1 } +}; +#endif + +#if defined(need_GL_OES_get_program_binary) +/* functions defined in MESA_remap_table_functions are excluded */ +static const struct gl_function_remap GL_OES_get_program_binary_functions[] = { + { -1, -1 } +}; +#endif + +#if defined(need_GL_OES_mapbuffer) +/* functions defined in MESA_remap_table_functions are excluded */ +static const struct gl_function_remap GL_OES_mapbuffer_functions[] = { + { -1, -1 } +}; +#endif + diff --git a/src/mesa/main/.gitignore b/src/mesa/main/.gitignore index 391c334ab71..d2fe135008c 100644 --- a/src/mesa/main/.gitignore +++ b/src/mesa/main/.gitignore @@ -1,4 +1,2 @@ -api_exec_es1.c -api_exec_es2.c get_es1.c get_es2.c diff --git a/src/mesa/main/api_exec_es1.c b/src/mesa/main/api_exec_es1.c new file mode 100644 index 00000000000..b29eb5a6d61 --- /dev/null +++ b/src/mesa/main/api_exec_es1.c @@ -0,0 +1,4860 @@ +/* DO NOT EDIT ************************************************* + * THIS FILE AUTOMATICALLY GENERATED BY THE es_generator.py SCRIPT + * API specification file: main/APIspec.xml + * GLES version: GLES1.1 + * date: 2010-12-09 17:05:10 + */ + + +#include "GLES/gl.h" +#include "GLES/glext.h" +#include "main/mfeatures.h" +#include "main/compiler.h" +#include "main/api_exec.h" + +#if FEATURE_ES1 + + +/* These types are needed for the Mesa veneer, but are not defined in + * the standard GLES headers. + */ +typedef double GLdouble; +typedef double GLclampd; + +/* Mesa error handling requires these */ +extern void *_mesa_get_current_context(void); +extern void _mesa_error(void *ctx, GLenum error, const char *fmtString, ... ); + +/************************************************************* + * Generated functions begin here + */ + +extern void GL_APIENTRY _mesa_ActiveTextureARB(GLenum texture); +static void GL_APIENTRY _es_ActiveTexture(GLenum texture) +{ + switch(texture) { + case GL_TEXTURE0: + case GL_TEXTURE1: + case GL_TEXTURE2: + case GL_TEXTURE3: + case GL_TEXTURE4: + case GL_TEXTURE5: + case GL_TEXTURE6: + case GL_TEXTURE7: + case GL_TEXTURE8: + case GL_TEXTURE9: + case GL_TEXTURE10: + case GL_TEXTURE11: + case GL_TEXTURE12: + case GL_TEXTURE13: + case GL_TEXTURE14: + case GL_TEXTURE15: + case GL_TEXTURE16: + case GL_TEXTURE17: + case GL_TEXTURE18: + case GL_TEXTURE19: + case GL_TEXTURE20: + case GL_TEXTURE21: + case GL_TEXTURE22: + case GL_TEXTURE23: + case GL_TEXTURE24: + case GL_TEXTURE25: + case GL_TEXTURE26: + case GL_TEXTURE27: + case GL_TEXTURE28: + case GL_TEXTURE29: + case GL_TEXTURE30: + case GL_TEXTURE31: + break; + default: + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glActiveTexture(texture=0x%x)", texture); + return; + } + + _mesa_ActiveTextureARB(texture); +} + +extern void GL_APIENTRY _mesa_AlphaFunc(GLenum func, GLclampf ref); +static void GL_APIENTRY _es_AlphaFunc(GLenum func, GLclampf ref) +{ + switch(func) { + case GL_NEVER: + case GL_LESS: + case GL_EQUAL: + case GL_LEQUAL: + case GL_GREATER: + case GL_NOTEQUAL: + case GL_GEQUAL: + case GL_ALWAYS: + break; + default: + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glAlphaFunc(func=0x%x)", func); + return; + } + + _mesa_AlphaFunc(func, ref); +} + +extern void GL_APIENTRY _mesa_AlphaFunc(GLenum func, GLclampf ref); +static void GL_APIENTRY _es_AlphaFuncx(GLenum func, GLclampx ref) +{ + GLclampf converted_ref; + + switch(func) { + case GL_NEVER: + case GL_LESS: + case GL_EQUAL: + case GL_LEQUAL: + case GL_GREATER: + case GL_NOTEQUAL: + case GL_GEQUAL: + case GL_ALWAYS: + break; + default: + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glAlphaFuncx(func=0x%x)", func); + return; + } + + converted_ref = (GLclampf) (ref / 65536.0f); + + _mesa_AlphaFunc(func, converted_ref); +} + +extern void GL_APIENTRY _mesa_BindBufferARB(GLenum target, GLuint buffer); +static void GL_APIENTRY _es_BindBuffer(GLenum target, GLuint buffer) +{ + switch(target) { + case GL_ARRAY_BUFFER: + case GL_ELEMENT_ARRAY_BUFFER: + break; + default: + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glBindBuffer(target=0x%x)", target); + return; + } + + _mesa_BindBufferARB(target, buffer); +} + +extern void GL_APIENTRY _mesa_BindFramebufferEXT(GLenum target, GLuint framebuffer); +static void GL_APIENTRY _es_BindFramebufferOES(GLenum target, GLuint framebuffer) +{ + switch(target) { + case GL_FRAMEBUFFER_OES: + break; + default: + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glBindFramebufferOES(target=0x%x)", target); + return; + } + + _mesa_BindFramebufferEXT(target, framebuffer); +} + +extern void GL_APIENTRY _mesa_BindRenderbufferEXT(GLenum target, GLuint renderbuffer); +static void GL_APIENTRY _es_BindRenderbufferOES(GLenum target, GLuint renderbuffer) +{ + switch(target) { + case GL_RENDERBUFFER_OES: + break; + default: + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glBindRenderbufferOES(target=0x%x)", target); + return; + } + + _mesa_BindRenderbufferEXT(target, renderbuffer); +} + +extern void GL_APIENTRY _mesa_BindTexture(GLenum target, GLuint texture); +static void GL_APIENTRY _es_BindTexture(GLenum target, GLuint texture) +{ + switch(target) { + case GL_TEXTURE_2D: + case GL_TEXTURE_CUBE_MAP_OES: + break; + default: + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glBindTexture(target=0x%x)", target); + return; + } + + _mesa_BindTexture(target, texture); +} + +extern void GL_APIENTRY _mesa_BlendEquation(GLenum mode); +static void GL_APIENTRY _es_BlendEquationOES(GLenum mode) +{ + switch(mode) { + case GL_FUNC_ADD_OES: + case GL_FUNC_SUBTRACT_OES: + case GL_FUNC_REVERSE_SUBTRACT_OES: + case GL_MIN_EXT: + case GL_MAX_EXT: + break; + default: + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glBlendEquationOES(mode=0x%x)", mode); + return; + } + + _mesa_BlendEquation(mode); +} + +extern void GL_APIENTRY _mesa_BlendEquationSeparateEXT(GLenum modeRGB, GLenum modeAlpha); +static void GL_APIENTRY _es_BlendEquationSeparateOES(GLenum modeRGB, GLenum modeAlpha) +{ + switch(modeRGB) { + case GL_FUNC_ADD_OES: + case GL_FUNC_SUBTRACT_OES: + case GL_FUNC_REVERSE_SUBTRACT_OES: + case GL_MIN_EXT: + case GL_MAX_EXT: + break; + default: + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glBlendEquationSeparateOES(modeRGB=0x%x)", modeRGB); + return; + } + switch(modeAlpha) { + case GL_FUNC_ADD_OES: + case GL_FUNC_SUBTRACT_OES: + case GL_FUNC_REVERSE_SUBTRACT_OES: + case GL_MIN_EXT: + case GL_MAX_EXT: + break; + default: + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glBlendEquationSeparateOES(modeAlpha=0x%x)", modeAlpha); + return; + } + + _mesa_BlendEquationSeparateEXT(modeRGB, modeAlpha); +} + +extern void GL_APIENTRY _mesa_BlendFunc(GLenum sfactor, GLenum dfactor); +static void GL_APIENTRY _es_BlendFunc(GLenum sfactor, GLenum dfactor) +{ + switch(sfactor) { + case GL_ZERO: + case GL_ONE: + case GL_SRC_COLOR: + case GL_ONE_MINUS_SRC_COLOR: + case GL_SRC_ALPHA: + case GL_ONE_MINUS_SRC_ALPHA: + case GL_DST_ALPHA: + case GL_ONE_MINUS_DST_ALPHA: + case GL_DST_COLOR: + case GL_ONE_MINUS_DST_COLOR: + case GL_SRC_ALPHA_SATURATE: + break; + default: + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glBlendFunc(sfactor=0x%x)", sfactor); + return; + } + switch(dfactor) { + case GL_ZERO: + case GL_ONE: + case GL_SRC_COLOR: + case GL_ONE_MINUS_SRC_COLOR: + case GL_SRC_ALPHA: + case GL_ONE_MINUS_SRC_ALPHA: + case GL_DST_ALPHA: + case GL_ONE_MINUS_DST_ALPHA: + case GL_DST_COLOR: + case GL_ONE_MINUS_DST_COLOR: + break; + default: + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glBlendFunc(dfactor=0x%x)", dfactor); + return; + } + + _mesa_BlendFunc(sfactor, dfactor); +} + +extern void GL_APIENTRY _mesa_BlendFuncSeparateEXT(GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha, GLenum dstAlpha); +static void GL_APIENTRY _es_BlendFuncSeparateOES(GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha, GLenum dstAlpha) +{ + switch(srcRGB) { + case GL_ZERO: + case GL_ONE: + case GL_SRC_COLOR: + case GL_ONE_MINUS_SRC_COLOR: + case GL_SRC_ALPHA: + case GL_ONE_MINUS_SRC_ALPHA: + case GL_DST_ALPHA: + case GL_ONE_MINUS_DST_ALPHA: + case GL_DST_COLOR: + case GL_ONE_MINUS_DST_COLOR: + case GL_SRC_ALPHA_SATURATE: + break; + default: + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glBlendFuncSeparateOES(srcRGB=0x%x)", srcRGB); + return; + } + switch(dstRGB) { + case GL_ZERO: + case GL_ONE: + case GL_SRC_COLOR: + case GL_ONE_MINUS_SRC_COLOR: + case GL_SRC_ALPHA: + case GL_ONE_MINUS_SRC_ALPHA: + case GL_DST_ALPHA: + case GL_ONE_MINUS_DST_ALPHA: + case GL_DST_COLOR: + case GL_ONE_MINUS_DST_COLOR: + break; + default: + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glBlendFuncSeparateOES(dstRGB=0x%x)", dstRGB); + return; + } + switch(srcAlpha) { + case GL_ZERO: + case GL_ONE: + case GL_SRC_COLOR: + case GL_ONE_MINUS_SRC_COLOR: + case GL_SRC_ALPHA: + case GL_ONE_MINUS_SRC_ALPHA: + case GL_DST_ALPHA: + case GL_ONE_MINUS_DST_ALPHA: + case GL_DST_COLOR: + case GL_ONE_MINUS_DST_COLOR: + case GL_SRC_ALPHA_SATURATE: + break; + default: + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glBlendFuncSeparateOES(srcAlpha=0x%x)", srcAlpha); + return; + } + switch(dstAlpha) { + case GL_ZERO: + case GL_ONE: + case GL_SRC_COLOR: + case GL_ONE_MINUS_SRC_COLOR: + case GL_SRC_ALPHA: + case GL_ONE_MINUS_SRC_ALPHA: + case GL_DST_ALPHA: + case GL_ONE_MINUS_DST_ALPHA: + case GL_DST_COLOR: + case GL_ONE_MINUS_DST_COLOR: + break; + default: + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glBlendFuncSeparateOES(dstAlpha=0x%x)", dstAlpha); + return; + } + + _mesa_BlendFuncSeparateEXT(srcRGB, dstRGB, srcAlpha, dstAlpha); +} + +extern void GL_APIENTRY _mesa_BufferDataARB(GLenum target, GLsizeiptr size, const GLvoid * data, GLenum usage); +static void GL_APIENTRY _es_BufferData(GLenum target, GLsizeiptr size, const GLvoid *data, GLenum usage) +{ + switch(target) { + case GL_ARRAY_BUFFER: + case GL_ELEMENT_ARRAY_BUFFER: + break; + default: + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glBufferData(target=0x%x)", target); + return; + } + switch(usage) { + case GL_STATIC_DRAW: + case GL_DYNAMIC_DRAW: + break; + default: + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glBufferData(usage=0x%x)", usage); + return; + } + + _mesa_BufferDataARB(target, size, data, usage); +} + +extern void GL_APIENTRY _mesa_BufferSubDataARB(GLenum target, GLintptr offset, GLsizeiptr size, const GLvoid * data); +static void GL_APIENTRY _es_BufferSubData(GLenum target, GLintptr offset, GLsizeiptr size, const GLvoid *data) +{ + switch(target) { + case GL_ARRAY_BUFFER: + case GL_ELEMENT_ARRAY_BUFFER: + break; + default: + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glBufferSubData(target=0x%x)", target); + return; + } + + _mesa_BufferSubDataARB(target, offset, size, data); +} + +extern GLenum GL_APIENTRY _mesa_CheckFramebufferStatusEXT(GLenum target); +static GLenum GL_APIENTRY _es_CheckFramebufferStatusOES(GLenum target) +{ + switch(target) { + case GL_FRAMEBUFFER_OES: + break; + default: + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glCheckFramebufferStatusOES(target=0x%x)", target); + return (GLenum) 0; + } + + return _mesa_CheckFramebufferStatusEXT(target); +} + +extern void GL_APIENTRY _mesa_Clear(GLbitfield mask); +static void GL_APIENTRY _es_Clear(GLbitfield mask) +{ + switch(mask) { + case 0: + case (GL_COLOR_BUFFER_BIT): + case (GL_DEPTH_BUFFER_BIT): + case (GL_STENCIL_BUFFER_BIT): + case (GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT): + case (GL_COLOR_BUFFER_BIT|GL_STENCIL_BUFFER_BIT): + case (GL_DEPTH_BUFFER_BIT|GL_STENCIL_BUFFER_BIT): + case (GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT|GL_STENCIL_BUFFER_BIT): + break; + default: + _mesa_error(_mesa_get_current_context(), GL_INVALID_VALUE, "glClear(mask=0x%x)", mask); + return; + } + + _mesa_Clear(mask); +} + +extern void GL_APIENTRY _mesa_ClearColor(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha); +#define _es_ClearColor _mesa_ClearColor + +extern void GL_APIENTRY _mesa_ClearColor(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha); +static void GL_APIENTRY _es_ClearColorx(GLclampx red, GLclampx green, GLclampx blue, GLclampx alpha) +{ + GLclampf converted_red; + GLclampf converted_green; + GLclampf converted_blue; + GLclampf converted_alpha; + + converted_red = (GLclampf) (red / 65536.0f); + converted_green = (GLclampf) (green / 65536.0f); + converted_blue = (GLclampf) (blue / 65536.0f); + converted_alpha = (GLclampf) (alpha / 65536.0f); + + _mesa_ClearColor(converted_red, converted_green, converted_blue, converted_alpha); +} + +extern void GL_APIENTRY _mesa_ClearDepth(GLclampd depth); +static void GL_APIENTRY _es_ClearDepthf(GLclampf depth) +{ + GLclampd converted_depth; + + converted_depth = (GLclampd) (depth); + + _mesa_ClearDepth(converted_depth); +} + +extern void GL_APIENTRY _mesa_ClearDepth(GLclampd depth); +static void GL_APIENTRY _es_ClearDepthx(GLclampx depth) +{ + GLclampd converted_depth; + + converted_depth = (GLclampd) (depth / 65536.0); + + _mesa_ClearDepth(converted_depth); +} + +extern void GL_APIENTRY _mesa_ClearStencil(GLint s); +#define _es_ClearStencil _mesa_ClearStencil + +extern void GL_APIENTRY _mesa_ClientActiveTextureARB(GLenum texture); +static void GL_APIENTRY _es_ClientActiveTexture(GLenum texture) +{ + switch(texture) { + case GL_TEXTURE0: + case GL_TEXTURE1: + case GL_TEXTURE2: + case GL_TEXTURE3: + case GL_TEXTURE4: + case GL_TEXTURE5: + case GL_TEXTURE6: + case GL_TEXTURE7: + case GL_TEXTURE8: + case GL_TEXTURE9: + case GL_TEXTURE10: + case GL_TEXTURE11: + case GL_TEXTURE12: + case GL_TEXTURE13: + case GL_TEXTURE14: + case GL_TEXTURE15: + case GL_TEXTURE16: + case GL_TEXTURE17: + case GL_TEXTURE18: + case GL_TEXTURE19: + case GL_TEXTURE20: + case GL_TEXTURE21: + case GL_TEXTURE22: + case GL_TEXTURE23: + case GL_TEXTURE24: + case GL_TEXTURE25: + case GL_TEXTURE26: + case GL_TEXTURE27: + case GL_TEXTURE28: + case GL_TEXTURE29: + case GL_TEXTURE30: + case GL_TEXTURE31: + break; + default: + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glClientActiveTexture(texture=0x%x)", texture); + return; + } + + _mesa_ClientActiveTextureARB(texture); +} + +extern void GL_APIENTRY _mesa_ClipPlane(GLenum plane, GLdouble const * equation); +static void GL_APIENTRY _es_ClipPlanef(GLenum plane, const GLfloat *equation) +{ + register unsigned int i; + unsigned int n_equation = 4; + GLdouble converted_equation[4]; + + switch(plane) { + case GL_CLIP_PLANE0: + case GL_CLIP_PLANE1: + case GL_CLIP_PLANE2: + case GL_CLIP_PLANE3: + case GL_CLIP_PLANE4: + case GL_CLIP_PLANE5: + break; + default: + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glClipPlanef(plane=0x%x)", plane); + return; + } + + for (i = 0; i < n_equation; i++) { + converted_equation[i] = (GLdouble) (equation[i]); + } + + _mesa_ClipPlane(plane, converted_equation); +} + +extern void GL_APIENTRY _mesa_ClipPlane(GLenum plane, GLdouble const * equation); +static void GL_APIENTRY _es_ClipPlanex(GLenum plane, const GLfixed *equation) +{ + register unsigned int i; + unsigned int n_equation = 4; + GLdouble converted_equation[4]; + + switch(plane) { + case GL_CLIP_PLANE0: + case GL_CLIP_PLANE1: + case GL_CLIP_PLANE2: + case GL_CLIP_PLANE3: + case GL_CLIP_PLANE4: + case GL_CLIP_PLANE5: + break; + default: + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glClipPlanex(plane=0x%x)", plane); + return; + } + + for (i = 0; i < n_equation; i++) { + converted_equation[i] = (GLdouble) (equation[i] / 65536.0); + } + + _mesa_ClipPlane(plane, converted_equation); +} + +/* this function is special and is defined elsewhere */ +extern void GL_APIENTRY _es_Color4f(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha); +#define _check_Color4f _es_Color4f + +extern void GL_APIENTRY _es_Color4f(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha); +static void GL_APIENTRY _es_Color4ub(GLubyte red, GLubyte green, GLubyte blue, GLubyte alpha) +{ + GLfloat converted_red; + GLfloat converted_green; + GLfloat converted_blue; + GLfloat converted_alpha; + + converted_red = (GLfloat) (red / 255.0f); + converted_green = (GLfloat) (green / 255.0f); + converted_blue = (GLfloat) (blue / 255.0f); + converted_alpha = (GLfloat) (alpha / 255.0f); + + _es_Color4f(converted_red, converted_green, converted_blue, converted_alpha); +} + +extern void GL_APIENTRY _es_Color4f(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha); +static void GL_APIENTRY _es_Color4x(GLfixed red, GLfixed green, GLfixed blue, GLfixed alpha) +{ + GLfloat converted_red; + GLfloat converted_green; + GLfloat converted_blue; + GLfloat converted_alpha; + + converted_red = (GLfloat) (red / 65536.0f); + converted_green = (GLfloat) (green / 65536.0f); + converted_blue = (GLfloat) (blue / 65536.0f); + converted_alpha = (GLfloat) (alpha / 65536.0f); + + _es_Color4f(converted_red, converted_green, converted_blue, converted_alpha); +} + +extern void GL_APIENTRY _mesa_ColorMask(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha); +#define _es_ColorMask _mesa_ColorMask + +extern void GL_APIENTRY _mesa_ColorPointer(GLint size, GLenum type, GLsizei stride, const GLvoid * pointer); +static void GL_APIENTRY _es_ColorPointer(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer) +{ + switch(size) { + case 4: + break; + default: + _mesa_error(_mesa_get_current_context(), GL_INVALID_VALUE, "glColorPointer(size=%d)", size); + return; + } + switch(type) { + case GL_UNSIGNED_BYTE: + case GL_FLOAT: + case GL_FIXED: + break; + default: + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glColorPointer(type=0x%x)", type); + return; + } + + _mesa_ColorPointer(size, type, stride, pointer); +} + +extern void GL_APIENTRY _mesa_CompressedTexImage2DARB(GLenum target, GLint level, GLenum internalFormat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const GLvoid * data); +static void GL_APIENTRY _es_CompressedTexImage2D(GLenum target, GLint level, GLenum internalFormat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const GLvoid *data) +{ + switch(target) { + case GL_TEXTURE_2D: + case GL_TEXTURE_CUBE_MAP_POSITIVE_X_OES: + case GL_TEXTURE_CUBE_MAP_POSITIVE_Y_OES: + case GL_TEXTURE_CUBE_MAP_POSITIVE_Z_OES: + case GL_TEXTURE_CUBE_MAP_NEGATIVE_X_OES: + case GL_TEXTURE_CUBE_MAP_NEGATIVE_Y_OES: + case GL_TEXTURE_CUBE_MAP_NEGATIVE_Z_OES: + break; + default: + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glCompressedTexImage2D(target=0x%x)", target); + return; + } + switch(internalFormat) { + case GL_PALETTE4_RGB8_OES: + case GL_PALETTE4_RGBA8_OES: + case GL_PALETTE4_R5_G6_B5_OES: + case GL_PALETTE4_RGBA4_OES: + case GL_PALETTE4_RGB5_A1_OES: + case GL_PALETTE8_RGB8_OES: + case GL_PALETTE8_RGBA8_OES: + case GL_PALETTE8_R5_G6_B5_OES: + case GL_PALETTE8_RGBA4_OES: + case GL_PALETTE8_RGB5_A1_OES: + break; + default: + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glCompressedTexImage2D(internalFormat=0x%x)", internalFormat); + return; + } + switch(border) { + case 0: + break; + default: + _mesa_error(_mesa_get_current_context(), GL_INVALID_VALUE, "glCompressedTexImage2D(border=%d)", border); + return; + } + + _mesa_CompressedTexImage2DARB(target, level, internalFormat, width, height, border, imageSize, data); +} + +extern void GL_APIENTRY _mesa_CompressedTexSubImage2DARB(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const GLvoid * data); +static void GL_APIENTRY _es_CompressedTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const GLvoid *data) +{ + switch(target) { + case GL_TEXTURE_2D: + case GL_TEXTURE_CUBE_MAP_POSITIVE_X_OES: + case GL_TEXTURE_CUBE_MAP_POSITIVE_Y_OES: + case GL_TEXTURE_CUBE_MAP_POSITIVE_Z_OES: + case GL_TEXTURE_CUBE_MAP_NEGATIVE_X_OES: + case GL_TEXTURE_CUBE_MAP_NEGATIVE_Y_OES: + case GL_TEXTURE_CUBE_MAP_NEGATIVE_Z_OES: + break; + default: + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glCompressedTexSubImage2D(target=0x%x)", target); + return; + } + + _mesa_CompressedTexSubImage2DARB(target, level, xoffset, yoffset, width, height, format, imageSize, data); +} + +extern void GL_APIENTRY _mesa_CopyTexImage2D(GLenum target, GLint level, GLenum internalFormat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border); +static void GL_APIENTRY _es_CopyTexImage2D(GLenum target, GLint level, GLenum internalFormat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border) +{ + switch(target) { + case GL_TEXTURE_2D: + case GL_TEXTURE_CUBE_MAP_POSITIVE_X_OES: + case GL_TEXTURE_CUBE_MAP_POSITIVE_Y_OES: + case GL_TEXTURE_CUBE_MAP_POSITIVE_Z_OES: + case GL_TEXTURE_CUBE_MAP_NEGATIVE_X_OES: + case GL_TEXTURE_CUBE_MAP_NEGATIVE_Y_OES: + case GL_TEXTURE_CUBE_MAP_NEGATIVE_Z_OES: + break; + default: + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glCopyTexImage2D(target=0x%x)", target); + return; + } + switch(internalFormat) { + case GL_ALPHA: + case GL_RGB: + case GL_RGBA: + case GL_LUMINANCE: + case GL_LUMINANCE_ALPHA: + break; + default: + _mesa_error(_mesa_get_current_context(), GL_INVALID_VALUE, "glCopyTexImage2D(internalFormat=0x%x)", internalFormat); + return; + } + switch(border) { + case 0: + break; + default: + _mesa_error(_mesa_get_current_context(), GL_INVALID_VALUE, "glCopyTexImage2D(border=%d)", border); + return; + } + + _mesa_CopyTexImage2D(target, level, internalFormat, x, y, width, height, border); +} + +extern void GL_APIENTRY _mesa_CopyTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height); +static void GL_APIENTRY _es_CopyTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height) +{ + switch(target) { + case GL_TEXTURE_2D: + case GL_TEXTURE_CUBE_MAP_POSITIVE_X_OES: + case GL_TEXTURE_CUBE_MAP_POSITIVE_Y_OES: + case GL_TEXTURE_CUBE_MAP_POSITIVE_Z_OES: + case GL_TEXTURE_CUBE_MAP_NEGATIVE_X_OES: + case GL_TEXTURE_CUBE_MAP_NEGATIVE_Y_OES: + case GL_TEXTURE_CUBE_MAP_NEGATIVE_Z_OES: + break; + default: + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glCopyTexSubImage2D(target=0x%x)", target); + return; + } + + _mesa_CopyTexSubImage2D(target, level, xoffset, yoffset, x, y, width, height); +} + +extern void GL_APIENTRY _mesa_CullFace(GLenum mode); +static void GL_APIENTRY _es_CullFace(GLenum mode) +{ + switch(mode) { + case GL_FRONT: + case GL_BACK: + case GL_FRONT_AND_BACK: + break; + default: + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glCullFace(mode=0x%x)", mode); + return; + } + + _mesa_CullFace(mode); +} + +extern void GL_APIENTRY _mesa_DeleteBuffersARB(GLsizei n, const GLuint * buffer); +#define _es_DeleteBuffers _mesa_DeleteBuffersARB + +extern void GL_APIENTRY _mesa_DeleteFramebuffersEXT(GLsizei n, const GLuint * framebuffers); +#define _es_DeleteFramebuffersOES _mesa_DeleteFramebuffersEXT + +extern void GL_APIENTRY _mesa_DeleteRenderbuffersEXT(GLsizei n, const GLuint * renderbuffers); +#define _es_DeleteRenderbuffersOES _mesa_DeleteRenderbuffersEXT + +extern void GL_APIENTRY _mesa_DeleteTextures(GLsizei n, const GLuint * textures); +#define _es_DeleteTextures _mesa_DeleteTextures + +extern void GL_APIENTRY _mesa_DepthFunc(GLenum func); +static void GL_APIENTRY _es_DepthFunc(GLenum func) +{ + switch(func) { + case GL_NEVER: + case GL_LESS: + case GL_EQUAL: + case GL_LEQUAL: + case GL_GREATER: + case GL_NOTEQUAL: + case GL_GEQUAL: + case GL_ALWAYS: + break; + default: + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glDepthFunc(func=0x%x)", func); + return; + } + + _mesa_DepthFunc(func); +} + +extern void GL_APIENTRY _mesa_DepthMask(GLboolean flag); +#define _es_DepthMask _mesa_DepthMask + +extern void GL_APIENTRY _mesa_DepthRange(GLclampd zNear, GLclampd zFar); +static void GL_APIENTRY _es_DepthRangef(GLclampf zNear, GLclampf zFar) +{ + GLclampd converted_zNear; + GLclampd converted_zFar; + + converted_zNear = (GLclampd) (zNear); + converted_zFar = (GLclampd) (zFar); + + _mesa_DepthRange(converted_zNear, converted_zFar); +} + +extern void GL_APIENTRY _mesa_DepthRange(GLclampd zNear, GLclampd zFar); +static void GL_APIENTRY _es_DepthRangex(GLclampx zNear, GLclampx zFar) +{ + GLclampd converted_zNear; + GLclampd converted_zFar; + + converted_zNear = (GLclampd) (zNear / 65536.0); + converted_zFar = (GLclampd) (zFar / 65536.0); + + _mesa_DepthRange(converted_zNear, converted_zFar); +} + +extern void GL_APIENTRY _mesa_Disable(GLenum cap); +static void GL_APIENTRY _es_Disable(GLenum cap) +{ + switch(cap) { + case GL_NORMALIZE: + case GL_RESCALE_NORMAL: + case GL_CLIP_PLANE0: + case GL_CLIP_PLANE1: + case GL_CLIP_PLANE2: + case GL_CLIP_PLANE3: + case GL_CLIP_PLANE4: + case GL_CLIP_PLANE5: + case GL_FOG: + case GL_LIGHTING: + case GL_COLOR_MATERIAL: + case GL_LIGHT0: + case GL_LIGHT1: + case GL_LIGHT2: + case GL_LIGHT3: + case GL_LIGHT4: + case GL_LIGHT5: + case GL_LIGHT6: + case GL_LIGHT7: + case GL_POINT_SMOOTH: + case GL_LINE_SMOOTH: + case GL_CULL_FACE: + case GL_POLYGON_OFFSET_FILL: + case GL_MULTISAMPLE: + case GL_SAMPLE_ALPHA_TO_COVERAGE: + case GL_SAMPLE_ALPHA_TO_ONE: + case GL_SAMPLE_COVERAGE: + case GL_TEXTURE_2D: + case GL_SCISSOR_TEST: + case GL_ALPHA_TEST: + case GL_STENCIL_TEST: + case GL_DEPTH_TEST: + case GL_BLEND: + case GL_DITHER: + case GL_COLOR_LOGIC_OP: + case GL_POINT_SPRITE_OES: + case GL_MATRIX_PALETTE_OES: + case GL_TEXTURE_CUBE_MAP_OES: + case GL_TEXTURE_GEN_STR_OES: + break; + default: + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glDisable(cap=0x%x)", cap); + return; + } + + _mesa_Disable(cap); +} + +extern void GL_APIENTRY _mesa_DisableClientState(GLenum array); +static void GL_APIENTRY _es_DisableClientState(GLenum array) +{ + switch(array) { + case GL_VERTEX_ARRAY: + case GL_NORMAL_ARRAY: + case GL_COLOR_ARRAY: + case GL_TEXTURE_COORD_ARRAY: + case GL_MATRIX_INDEX_ARRAY_OES: + case GL_WEIGHT_ARRAY_OES: + case GL_POINT_SIZE_ARRAY_OES: + break; + default: + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glDisableClientState(array=0x%x)", array); + return; + } + + _mesa_DisableClientState(array); +} + +extern void GL_APIENTRY _mesa_DrawArrays(GLenum mode, GLint first, GLsizei count); +static void GL_APIENTRY _es_DrawArrays(GLenum mode, GLint first, GLsizei count) +{ + switch(mode) { + case GL_POINTS: + case GL_LINES: + case GL_LINE_LOOP: + case GL_LINE_STRIP: + case GL_TRIANGLES: + case GL_TRIANGLE_STRIP: + case GL_TRIANGLE_FAN: + break; + default: + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glDrawArrays(mode=0x%x)", mode); + return; + } + + _mesa_DrawArrays(mode, first, count); +} + +extern void GL_APIENTRY _mesa_DrawElements(GLenum mode, GLsizei count, GLenum type, const GLvoid * indices); +static void GL_APIENTRY _es_DrawElements(GLenum mode, GLsizei count, GLenum type, const GLvoid *indices) +{ + switch(mode) { + case GL_POINTS: + case GL_LINES: + case GL_LINE_LOOP: + case GL_LINE_STRIP: + case GL_TRIANGLES: + case GL_TRIANGLE_STRIP: + case GL_TRIANGLE_FAN: + break; + default: + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glDrawElements(mode=0x%x)", mode); + return; + } + switch(type) { + case GL_UNSIGNED_BYTE: + case GL_UNSIGNED_SHORT: + case GL_UNSIGNED_INT: + break; + default: + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glDrawElements(type=0x%x)", type); + return; + } + + _mesa_DrawElements(mode, count, type, indices); +} + +extern void GL_APIENTRY _mesa_DrawTexf(GLfloat x, GLfloat y, GLfloat z, GLfloat w, GLfloat h); +#define _es_DrawTexfOES _mesa_DrawTexf + +extern void GL_APIENTRY _mesa_DrawTexfv(const GLfloat * coords); +#define _es_DrawTexfvOES _mesa_DrawTexfv + +extern void GL_APIENTRY _mesa_DrawTexi(GLint x, GLint y, GLint z, GLint w, GLint h); +#define _es_DrawTexiOES _mesa_DrawTexi + +extern void GL_APIENTRY _mesa_DrawTexiv(const GLint * coords); +#define _es_DrawTexivOES _mesa_DrawTexiv + +extern void GL_APIENTRY _mesa_DrawTexs(GLshort x, GLshort y, GLshort z, GLshort w, GLshort h); +#define _es_DrawTexsOES _mesa_DrawTexs + +extern void GL_APIENTRY _mesa_DrawTexsv(const GLshort * coords); +#define _es_DrawTexsvOES _mesa_DrawTexsv + +extern void GL_APIENTRY _mesa_DrawTexf(GLfloat x, GLfloat y, GLfloat z, GLfloat w, GLfloat h); +static void GL_APIENTRY _es_DrawTexxOES(GLfixed x, GLfixed y, GLfixed z, GLfixed w, GLfixed h) +{ + GLfloat converted_x; + GLfloat converted_y; + GLfloat converted_z; + GLfloat converted_w; + GLfloat converted_h; + + converted_x = (GLfloat) (x / 65536.0f); + converted_y = (GLfloat) (y / 65536.0f); + converted_z = (GLfloat) (z / 65536.0f); + converted_w = (GLfloat) (w / 65536.0f); + converted_h = (GLfloat) (h / 65536.0f); + + _mesa_DrawTexf(converted_x, converted_y, converted_z, converted_w, converted_h); +} + +extern void GL_APIENTRY _mesa_DrawTexfv(GLfloat const * coords); +static void GL_APIENTRY _es_DrawTexxvOES(const GLfixed *coords) +{ + register unsigned int i; + unsigned int n_coords = 5; + GLfloat converted_coords[5]; + + for (i = 0; i < n_coords; i++) { + converted_coords[i] = (GLfloat) (coords[i] / 65536.0f); + } + + _mesa_DrawTexfv(converted_coords); +} + +extern void GL_APIENTRY _mesa_EGLImageTargetRenderbufferStorageOES(GLenum target, GLeglImageOES image); +static void GL_APIENTRY _es_EGLImageTargetRenderbufferStorageOES(GLenum target, GLeglImageOES image) +{ + switch(target) { + case GL_RENDERBUFFER_OES: + break; + default: + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glEGLImageTargetRenderbufferStorageOES(target=0x%x)", target); + return; + } + + _mesa_EGLImageTargetRenderbufferStorageOES(target, image); +} + +extern void GL_APIENTRY _mesa_EGLImageTargetTexture2DOES(GLenum target, GLeglImageOES image); +static void GL_APIENTRY _es_EGLImageTargetTexture2DOES(GLenum target, GLeglImageOES image) +{ + switch(target) { + case GL_TEXTURE_2D: + break; + default: + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glEGLImageTargetTexture2DOES(target=0x%x)", target); + return; + } + + _mesa_EGLImageTargetTexture2DOES(target, image); +} + +extern void GL_APIENTRY _mesa_Enable(GLenum cap); +static void GL_APIENTRY _es_Enable(GLenum cap) +{ + switch(cap) { + case GL_NORMALIZE: + case GL_RESCALE_NORMAL: + case GL_CLIP_PLANE0: + case GL_CLIP_PLANE1: + case GL_CLIP_PLANE2: + case GL_CLIP_PLANE3: + case GL_CLIP_PLANE4: + case GL_CLIP_PLANE5: + case GL_FOG: + case GL_LIGHTING: + case GL_COLOR_MATERIAL: + case GL_LIGHT0: + case GL_LIGHT1: + case GL_LIGHT2: + case GL_LIGHT3: + case GL_LIGHT4: + case GL_LIGHT5: + case GL_LIGHT6: + case GL_LIGHT7: + case GL_POINT_SMOOTH: + case GL_LINE_SMOOTH: + case GL_CULL_FACE: + case GL_POLYGON_OFFSET_FILL: + case GL_MULTISAMPLE: + case GL_SAMPLE_ALPHA_TO_COVERAGE: + case GL_SAMPLE_ALPHA_TO_ONE: + case GL_SAMPLE_COVERAGE: + case GL_TEXTURE_2D: + case GL_SCISSOR_TEST: + case GL_ALPHA_TEST: + case GL_STENCIL_TEST: + case GL_DEPTH_TEST: + case GL_BLEND: + case GL_DITHER: + case GL_COLOR_LOGIC_OP: + case GL_POINT_SPRITE_OES: + case GL_MATRIX_PALETTE_OES: + case GL_TEXTURE_CUBE_MAP_OES: + case GL_TEXTURE_GEN_STR_OES: + break; + default: + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glEnable(cap=0x%x)", cap); + return; + } + + _mesa_Enable(cap); +} + +extern void GL_APIENTRY _mesa_EnableClientState(GLenum array); +static void GL_APIENTRY _es_EnableClientState(GLenum array) +{ + switch(array) { + case GL_VERTEX_ARRAY: + case GL_NORMAL_ARRAY: + case GL_COLOR_ARRAY: + case GL_TEXTURE_COORD_ARRAY: + case GL_MATRIX_INDEX_ARRAY_OES: + case GL_WEIGHT_ARRAY_OES: + case GL_POINT_SIZE_ARRAY_OES: + break; + default: + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glEnableClientState(array=0x%x)", array); + return; + } + + _mesa_EnableClientState(array); +} + +extern void GL_APIENTRY _mesa_Finish(void); +#define _es_Finish _mesa_Finish + +extern void GL_APIENTRY _mesa_Flush(void); +#define _es_Flush _mesa_Flush + +extern void GL_APIENTRY _mesa_Fogf(GLenum pname, GLfloat param); +static void GL_APIENTRY _es_Fogf(GLenum pname, GLfloat param) +{ + switch(pname) { + case GL_FOG_MODE: + if (param != GL_EXP && param != GL_EXP2 && param != GL_LINEAR) { + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glFogf(pname=0x%x)", pname); + return; + } + break; + case GL_FOG_DENSITY: + case GL_FOG_START: + case GL_FOG_END: + break; + default: + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glFogf(pname=0x%x)", pname); + return; + } + + _mesa_Fogf(pname, param); +} + +extern void GL_APIENTRY _mesa_Fogfv(GLenum pname, const GLfloat * params); +static void GL_APIENTRY _es_Fogfv(GLenum pname, const GLfloat *params) +{ + switch(pname) { + case GL_FOG_MODE: /* size 1 */ + if (params[0] != GL_EXP && params[0] != GL_EXP2 && params[0] != GL_LINEAR) { + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glFogfv(pname=0x%x)", pname); + return; + } + break; + case GL_FOG_COLOR: /* size 4 */ + case GL_FOG_DENSITY: /* size 1 */ + case GL_FOG_START: /* size 1 */ + case GL_FOG_END: /* size 1 */ + break; + default: + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glFogfv(pname=0x%x)", pname); + return; + } + + _mesa_Fogfv(pname, params); +} + +extern void GL_APIENTRY _mesa_Fogf(GLenum pname, GLfloat param); +static void GL_APIENTRY _es_Fogx(GLenum pname, GLfixed param) +{ + GLfloat converted_param; + int convert_param_value = 1; + + switch(pname) { + case GL_FOG_MODE: + if (param != GL_EXP && param != GL_EXP2 && param != GL_LINEAR) { + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glFogx(pname=0x%x)", pname); + return; + } + convert_param_value = 0; + break; + case GL_FOG_DENSITY: + case GL_FOG_START: + case GL_FOG_END: + break; + default: + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glFogx(pname=0x%x)", pname); + return; + } + + if (convert_param_value) { + converted_param = (GLfloat) (param / 65536.0f); + } else { + converted_param = (GLfloat) param; + } + + _mesa_Fogf(pname, converted_param); +} + +extern void GL_APIENTRY _mesa_Fogfv(GLenum pname, GLfloat const * params); +static void GL_APIENTRY _es_Fogxv(GLenum pname, const GLfixed *params) +{ + register unsigned int i; + unsigned int n_params = 4; + GLfloat converted_params[4]; + int convert_params_value = 1; + + switch(pname) { + case GL_FOG_MODE: + if (params[0] != GL_EXP && params[0] != GL_EXP2 && params[0] != GL_LINEAR) { + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glFogxv(pname=0x%x)", pname); + return; + } + convert_params_value = 0; + n_params = 1; + break; + case GL_FOG_COLOR: + n_params = 4; + break; + case GL_FOG_DENSITY: + case GL_FOG_START: + case GL_FOG_END: + n_params = 1; + break; + default: + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glFogxv(pname=0x%x)", pname); + return; + } + + if (convert_params_value) { + for (i = 0; i < n_params; i++) { + converted_params[i] = (GLfloat) (params[i] / 65536.0f); + } + } else { + for (i = 0; i < n_params; i++) { + converted_params[i] = (GLfloat) params[i]; + } + } + + _mesa_Fogfv(pname, converted_params); +} + +extern void GL_APIENTRY _mesa_FramebufferRenderbufferEXT(GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer); +static void GL_APIENTRY _es_FramebufferRenderbufferOES(GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer) +{ + switch(target) { + case GL_FRAMEBUFFER_OES: + break; + default: + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glFramebufferRenderbufferOES(target=0x%x)", target); + return; + } + switch(attachment) { + case GL_COLOR_ATTACHMENT0_OES: + case GL_DEPTH_ATTACHMENT_OES: + case GL_STENCIL_ATTACHMENT_OES: + break; + default: + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glFramebufferRenderbufferOES(attachment=0x%x)", attachment); + return; + } + switch(renderbuffertarget) { + case GL_RENDERBUFFER_OES: + break; + default: + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glFramebufferRenderbufferOES(renderbuffertarget=0x%x)", renderbuffertarget); + return; + } + + _mesa_FramebufferRenderbufferEXT(target, attachment, renderbuffertarget, renderbuffer); +} + +extern void GL_APIENTRY _mesa_FramebufferTexture2DEXT(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level); +static void GL_APIENTRY _es_FramebufferTexture2DOES(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level) +{ + switch(target) { + case GL_FRAMEBUFFER_OES: + break; + default: + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glFramebufferTexture2DOES(target=0x%x)", target); + return; + } + switch(attachment) { + case GL_COLOR_ATTACHMENT0_OES: + case GL_DEPTH_ATTACHMENT_OES: + case GL_STENCIL_ATTACHMENT_OES: + break; + default: + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glFramebufferTexture2DOES(attachment=0x%x)", attachment); + return; + } + switch(textarget) { + case GL_TEXTURE_2D: + case GL_TEXTURE_CUBE_MAP_POSITIVE_X_OES: + case GL_TEXTURE_CUBE_MAP_POSITIVE_Y_OES: + case GL_TEXTURE_CUBE_MAP_POSITIVE_Z_OES: + case GL_TEXTURE_CUBE_MAP_NEGATIVE_X_OES: + case GL_TEXTURE_CUBE_MAP_NEGATIVE_Y_OES: + case GL_TEXTURE_CUBE_MAP_NEGATIVE_Z_OES: + break; + default: + _mesa_error(_mesa_get_current_context(), GL_INVALID_OPERATION, "glFramebufferTexture2DOES(textarget=0x%x)", textarget); + return; + } + + _mesa_FramebufferTexture2DEXT(target, attachment, textarget, texture, level); +} + +extern void GL_APIENTRY _mesa_FrontFace(GLenum mode); +static void GL_APIENTRY _es_FrontFace(GLenum mode) +{ + switch(mode) { + case GL_CW: + case GL_CCW: + break; + default: + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glFrontFace(mode=0x%x)", mode); + return; + } + + _mesa_FrontFace(mode); +} + +extern void GL_APIENTRY _mesa_Frustum(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar); +static void GL_APIENTRY _es_Frustumf(GLfloat left, GLfloat right, GLfloat bottom, GLfloat top, GLfloat zNear, GLfloat zFar) +{ + GLdouble converted_left; + GLdouble converted_right; + GLdouble converted_bottom; + GLdouble converted_top; + GLdouble converted_zNear; + GLdouble converted_zFar; + + converted_left = (GLdouble) (left); + converted_right = (GLdouble) (right); + converted_bottom = (GLdouble) (bottom); + converted_top = (GLdouble) (top); + converted_zNear = (GLdouble) (zNear); + converted_zFar = (GLdouble) (zFar); + + _mesa_Frustum(converted_left, converted_right, converted_bottom, converted_top, converted_zNear, converted_zFar); +} + +extern void GL_APIENTRY _mesa_Frustum(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar); +static void GL_APIENTRY _es_Frustumx(GLfixed left, GLfixed right, GLfixed bottom, GLfixed top, GLfixed zNear, GLfixed zFar) +{ + GLdouble converted_left; + GLdouble converted_right; + GLdouble converted_bottom; + GLdouble converted_top; + GLdouble converted_zNear; + GLdouble converted_zFar; + + converted_left = (GLdouble) (left / 65536.0); + converted_right = (GLdouble) (right / 65536.0); + converted_bottom = (GLdouble) (bottom / 65536.0); + converted_top = (GLdouble) (top / 65536.0); + converted_zNear = (GLdouble) (zNear / 65536.0); + converted_zFar = (GLdouble) (zFar / 65536.0); + + _mesa_Frustum(converted_left, converted_right, converted_bottom, converted_top, converted_zNear, converted_zFar); +} + +extern void GL_APIENTRY _mesa_GenBuffersARB(GLsizei n, GLuint * buffer); +#define _es_GenBuffers _mesa_GenBuffersARB + +extern void GL_APIENTRY _mesa_GenFramebuffersEXT(GLsizei n, GLuint * ids); +#define _es_GenFramebuffersOES _mesa_GenFramebuffersEXT + +extern void GL_APIENTRY _mesa_GenRenderbuffersEXT(GLsizei n, GLuint * renderbuffers); +#define _es_GenRenderbuffersOES _mesa_GenRenderbuffersEXT + +extern void GL_APIENTRY _mesa_GenTextures(GLsizei n, GLuint * textures); +#define _es_GenTextures _mesa_GenTextures + +extern void GL_APIENTRY _mesa_GenerateMipmapEXT(GLenum target); +static void GL_APIENTRY _es_GenerateMipmapOES(GLenum target) +{ + switch(target) { + case GL_TEXTURE_2D: + case GL_TEXTURE_CUBE_MAP_OES: + break; + default: + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glGenerateMipmapOES(target=0x%x)", target); + return; + } + + _mesa_GenerateMipmapEXT(target); +} + +extern void GL_APIENTRY _mesa_GetBooleanv(GLenum pname, GLboolean * params); +#define _es_GetBooleanv _mesa_GetBooleanv + +extern void GL_APIENTRY _mesa_GetBufferParameterivARB(GLenum target, GLenum pname, GLint * params); +static void GL_APIENTRY _es_GetBufferParameteriv(GLenum target, GLenum pname, GLint *params) +{ + switch(target) { + case GL_ARRAY_BUFFER: + case GL_ELEMENT_ARRAY_BUFFER: + break; + default: + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glGetBufferParameteriv(target=0x%x)", target); + return; + } + switch(pname) { + case GL_BUFFER_SIZE: + case GL_BUFFER_USAGE: + case GL_BUFFER_ACCESS_OES: + case GL_BUFFER_MAPPED_OES: + break; + default: + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glGetBufferParameteriv(pname=0x%x)", pname); + return; + } + + _mesa_GetBufferParameterivARB(target, pname, params); +} + +extern void GL_APIENTRY _mesa_GetBufferPointervARB(GLenum target, GLenum pname, GLvoid ** params); +static void GL_APIENTRY _es_GetBufferPointervOES(GLenum target, GLenum pname, GLvoid **params) +{ + switch(target) { + case GL_ARRAY_BUFFER: + case GL_ELEMENT_ARRAY_BUFFER: + break; + default: + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glGetBufferPointervOES(target=0x%x)", target); + return; + } + switch(pname) { + case GL_BUFFER_MAP_POINTER_OES: + break; + default: + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glGetBufferPointervOES(pname=0x%x)", pname); + return; + } + + _mesa_GetBufferPointervARB(target, pname, params); +} + +extern void GL_APIENTRY _mesa_GetClipPlane(GLenum plane, GLdouble * equation); +static void GL_APIENTRY _es_GetClipPlanef(GLenum plane, GLfloat *equation) +{ + register unsigned int i; + unsigned int n_equation = 4; + GLdouble converted_equation[4]; + + switch(plane) { + case GL_CLIP_PLANE0: + case GL_CLIP_PLANE1: + case GL_CLIP_PLANE2: + case GL_CLIP_PLANE3: + case GL_CLIP_PLANE4: + case GL_CLIP_PLANE5: + break; + default: + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glGetClipPlanef(plane=0x%x)", plane); + return; + } + + _mesa_GetClipPlane(plane, converted_equation); + for (i = 0; i < n_equation; i++) { + equation[i] = (GLfloat) (converted_equation[i]); + } +} + +extern void GL_APIENTRY _mesa_GetClipPlane(GLenum plane, GLdouble * equation); +static void GL_APIENTRY _es_GetClipPlanex(GLenum plane, GLfixed *equation) +{ + register unsigned int i; + unsigned int n_equation = 4; + GLdouble converted_equation[4]; + + switch(plane) { + case GL_CLIP_PLANE0: + case GL_CLIP_PLANE1: + case GL_CLIP_PLANE2: + case GL_CLIP_PLANE3: + case GL_CLIP_PLANE4: + case GL_CLIP_PLANE5: + break; + default: + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glGetClipPlanex(plane=0x%x)", plane); + return; + } + + _mesa_GetClipPlane(plane, converted_equation); + for (i = 0; i < n_equation; i++) { + equation[i] = (GLfixed) (converted_equation[i] * 65536); + } +} + +extern GLenum GL_APIENTRY _mesa_GetError(void); +#define _es_GetError _mesa_GetError + +extern void GL_APIENTRY _mesa_GetFixedv(GLenum pname, GLfixed * params); +#define _es_GetFixedv _mesa_GetFixedv + +extern void GL_APIENTRY _mesa_GetFloatv(GLenum pname, GLfloat * params); +#define _es_GetFloatv _mesa_GetFloatv + +extern void GL_APIENTRY _mesa_GetFramebufferAttachmentParameterivEXT(GLenum target, GLenum attachment, GLenum pname, GLint * params); +static void GL_APIENTRY _es_GetFramebufferAttachmentParameterivOES(GLenum target, GLenum attachment, GLenum pname, GLint *params) +{ + switch(target) { + case GL_FRAMEBUFFER_OES: + break; + default: + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glGetFramebufferAttachmentParameterivOES(target=0x%x)", target); + return; + } + switch(pname) { + case GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE_OES: /* size 1 */ + case GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME_OES: /* size 1 */ + case GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL_OES: /* size 1 */ + case GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE_OES: /* size 1 */ + break; + default: + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glGetFramebufferAttachmentParameterivOES(pname=0x%x)", pname); + return; + } + + _mesa_GetFramebufferAttachmentParameterivEXT(target, attachment, pname, params); +} + +extern void GL_APIENTRY _mesa_GetIntegerv(GLenum pname, GLint * params); +#define _es_GetIntegerv _mesa_GetIntegerv + +extern void GL_APIENTRY _mesa_GetLightfv(GLenum light, GLenum pname, GLfloat * params); +static void GL_APIENTRY _es_GetLightfv(GLenum light, GLenum pname, GLfloat *params) +{ + switch(light) { + case GL_LIGHT0: + case GL_LIGHT1: + case GL_LIGHT2: + case GL_LIGHT3: + case GL_LIGHT4: + case GL_LIGHT5: + case GL_LIGHT6: + case GL_LIGHT7: + break; + default: + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glGetLightfv(light=0x%x)", light); + return; + } + switch(pname) { + case GL_AMBIENT: /* size 4 */ + case GL_DIFFUSE: /* size 4 */ + case GL_SPECULAR: /* size 4 */ + case GL_POSITION: /* size 4 */ + case GL_SPOT_DIRECTION: /* size 3 */ + case GL_SPOT_EXPONENT: /* size 1 */ + case GL_SPOT_CUTOFF: /* size 1 */ + case GL_CONSTANT_ATTENUATION: /* size 1 */ + case GL_LINEAR_ATTENUATION: /* size 1 */ + case GL_QUADRATIC_ATTENUATION: /* size 1 */ + break; + default: + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glGetLightfv(pname=0x%x)", pname); + return; + } + + _mesa_GetLightfv(light, pname, params); +} + +extern void GL_APIENTRY _mesa_GetLightfv(GLenum light, GLenum pname, GLfloat * params); +static void GL_APIENTRY _es_GetLightxv(GLenum light, GLenum pname, GLfixed *params) +{ + register unsigned int i; + unsigned int n_params = 4; + GLfloat converted_params[4]; + + switch(light) { + case GL_LIGHT0: + case GL_LIGHT1: + case GL_LIGHT2: + case GL_LIGHT3: + case GL_LIGHT4: + case GL_LIGHT5: + case GL_LIGHT6: + case GL_LIGHT7: + break; + default: + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glGetLightxv(light=0x%x)", light); + return; + } + switch(pname) { + case GL_AMBIENT: + case GL_DIFFUSE: + case GL_SPECULAR: + case GL_POSITION: + n_params = 4; + break; + case GL_SPOT_DIRECTION: + n_params = 3; + break; + case GL_SPOT_EXPONENT: + case GL_SPOT_CUTOFF: + case GL_CONSTANT_ATTENUATION: + case GL_LINEAR_ATTENUATION: + case GL_QUADRATIC_ATTENUATION: + n_params = 1; + break; + default: + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glGetLightxv(pname=0x%x)", pname); + return; + } + + _mesa_GetLightfv(light, pname, converted_params); + for (i = 0; i < n_params; i++) { + params[i] = (GLint) (converted_params[i] * 65536); + } +} + +extern void GL_APIENTRY _mesa_GetMaterialfv(GLenum face, GLenum pname, GLfloat * params); +static void GL_APIENTRY _es_GetMaterialfv(GLenum face, GLenum pname, GLfloat *params) +{ + switch(face) { + case GL_FRONT: + case GL_BACK: + break; + default: + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glGetMaterialfv(face=0x%x)", face); + return; + } + switch(pname) { + case GL_SHININESS: /* size 1 */ + case GL_AMBIENT: /* size 4 */ + case GL_DIFFUSE: /* size 4 */ + case GL_AMBIENT_AND_DIFFUSE: /* size 4 */ + case GL_SPECULAR: /* size 4 */ + case GL_EMISSION: /* size 4 */ + break; + default: + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glGetMaterialfv(pname=0x%x)", pname); + return; + } + + _mesa_GetMaterialfv(face, pname, params); +} + +extern void GL_APIENTRY _mesa_GetMaterialfv(GLenum face, GLenum pname, GLfloat * params); +static void GL_APIENTRY _es_GetMaterialxv(GLenum face, GLenum pname, GLfixed *params) +{ + register unsigned int i; + unsigned int n_params = 4; + GLfloat converted_params[4]; + + switch(face) { + case GL_FRONT: + case GL_BACK: + break; + default: + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glGetMaterialxv(face=0x%x)", face); + return; + } + switch(pname) { + case GL_SHININESS: + n_params = 1; + break; + case GL_AMBIENT: + case GL_DIFFUSE: + case GL_AMBIENT_AND_DIFFUSE: + case GL_SPECULAR: + case GL_EMISSION: + n_params = 4; + break; + default: + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glGetMaterialxv(pname=0x%x)", pname); + return; + } + + _mesa_GetMaterialfv(face, pname, converted_params); + for (i = 0; i < n_params; i++) { + params[i] = (GLint) (converted_params[i] * 65536); + } +} + +extern void GL_APIENTRY _mesa_GetPointerv(GLenum pname, GLvoid ** params); +static void GL_APIENTRY _es_GetPointerv(GLenum pname, GLvoid **params) +{ + switch(pname) { + case GL_VERTEX_ARRAY_POINTER: + case GL_NORMAL_ARRAY_POINTER: + case GL_COLOR_ARRAY_POINTER: + case GL_TEXTURE_COORD_ARRAY_POINTER: + case GL_MATRIX_INDEX_ARRAY_POINTER_OES: + case GL_WEIGHT_ARRAY_POINTER_OES: + case GL_POINT_SIZE_ARRAY_POINTER_OES: + break; + default: + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glGetPointerv(pname=0x%x)", pname); + return; + } + + _mesa_GetPointerv(pname, params); +} + +extern void GL_APIENTRY _mesa_GetRenderbufferParameterivEXT(GLenum target, GLenum pname, GLint * params); +static void GL_APIENTRY _es_GetRenderbufferParameterivOES(GLenum target, GLenum pname, GLint *params) +{ + switch(target) { + case GL_RENDERBUFFER_OES: + break; + default: + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glGetRenderbufferParameterivOES(target=0x%x)", target); + return; + } + switch(pname) { + case GL_RENDERBUFFER_WIDTH_OES: /* size 1 */ + case GL_RENDERBUFFER_HEIGHT_OES: /* size 1 */ + case GL_RENDERBUFFER_INTERNAL_FORMAT_OES: /* size 1 */ + case GL_RENDERBUFFER_RED_SIZE_OES: /* size 1 */ + case GL_RENDERBUFFER_GREEN_SIZE_OES: /* size 1 */ + case GL_RENDERBUFFER_BLUE_SIZE_OES: /* size 1 */ + case GL_RENDERBUFFER_ALPHA_SIZE_OES: /* size 1 */ + case GL_RENDERBUFFER_DEPTH_SIZE_OES: /* size 1 */ + case GL_RENDERBUFFER_STENCIL_SIZE_OES: /* size 1 */ + break; + default: + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glGetRenderbufferParameterivOES(pname=0x%x)", pname); + return; + } + + _mesa_GetRenderbufferParameterivEXT(target, pname, params); +} + +extern const GLubyte * GL_APIENTRY _mesa_GetString(GLenum name); +static const GLubyte * GL_APIENTRY _es_GetString(GLenum name) +{ + switch(name) { + case GL_VENDOR: + case GL_RENDERER: + case GL_VERSION: + case GL_EXTENSIONS: + break; + default: + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glGetString(name=0x%x)", name); + return (const GLubyte *) 0; + } + + return _mesa_GetString(name); +} + +extern void GL_APIENTRY _mesa_GetTexEnvfv(GLenum target, GLenum pname, GLfloat * params); +static void GL_APIENTRY _es_GetTexEnvfv(GLenum target, GLenum pname, GLfloat *params) +{ + switch(target) { + case GL_POINT_SPRITE_OES: + if (pname != GL_COORD_REPLACE_OES) { + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glGetTexEnvfv(target=0x%x)", target); + return; + } + break; + case GL_TEXTURE_FILTER_CONTROL_EXT: + if (pname != GL_TEXTURE_LOD_BIAS_EXT) { + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glGetTexEnvfv(target=0x%x)", target); + return; + } + break; + case GL_TEXTURE_ENV: + if (pname != GL_TEXTURE_ENV_COLOR && pname != GL_RGB_SCALE && pname != GL_ALPHA_SCALE && pname != GL_TEXTURE_ENV_MODE && pname != GL_COMBINE_RGB && pname != GL_COMBINE_ALPHA && pname != GL_SRC0_RGB && pname != GL_SRC1_RGB && pname != GL_SRC2_RGB && pname != GL_SRC0_ALPHA && pname != GL_SRC1_ALPHA && pname != GL_SRC2_ALPHA && pname != GL_OPERAND0_RGB && pname != GL_OPERAND1_RGB && pname != GL_OPERAND2_RGB && pname != GL_OPERAND0_ALPHA && pname != GL_OPERAND1_ALPHA && pname != GL_OPERAND2_ALPHA) { + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glGetTexEnvfv(target=0x%x)", target); + return; + } + break; + default: + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glGetTexEnvfv(target=0x%x)", target); + return; + } + switch(pname) { + case GL_COORD_REPLACE_OES: /* size 1 */ + break; + case GL_TEXTURE_LOD_BIAS_EXT: /* size 1 */ + case GL_TEXTURE_ENV_COLOR: /* size 4 */ + case GL_RGB_SCALE: /* size 1 */ + case GL_ALPHA_SCALE: /* size 1 */ + break; + case GL_TEXTURE_ENV_MODE: /* size 1 */ + case GL_COMBINE_RGB: /* size 1 */ + case GL_COMBINE_ALPHA: /* size 1 */ + case GL_SRC0_RGB: /* size 1 */ + case GL_SRC1_RGB: /* size 1 */ + case GL_SRC2_RGB: /* size 1 */ + case GL_SRC0_ALPHA: /* size 1 */ + case GL_SRC1_ALPHA: /* size 1 */ + case GL_SRC2_ALPHA: /* size 1 */ + case GL_OPERAND0_RGB: /* size 1 */ + case GL_OPERAND1_RGB: /* size 1 */ + case GL_OPERAND2_RGB: /* size 1 */ + case GL_OPERAND0_ALPHA: /* size 1 */ + case GL_OPERAND1_ALPHA: /* size 1 */ + case GL_OPERAND2_ALPHA: /* size 1 */ + break; + default: + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glGetTexEnvfv(pname=0x%x)", pname); + return; + } + + _mesa_GetTexEnvfv(target, pname, params); +} + +extern void GL_APIENTRY _mesa_GetTexEnviv(GLenum target, GLenum pname, GLint * params); +static void GL_APIENTRY _es_GetTexEnviv(GLenum target, GLenum pname, GLint *params) +{ + switch(target) { + case GL_POINT_SPRITE_OES: + if (pname != GL_COORD_REPLACE_OES) { + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glGetTexEnviv(target=0x%x)", target); + return; + } + break; + case GL_TEXTURE_FILTER_CONTROL_EXT: + if (pname != GL_TEXTURE_LOD_BIAS_EXT) { + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glGetTexEnviv(target=0x%x)", target); + return; + } + break; + case GL_TEXTURE_ENV: + if (pname != GL_TEXTURE_ENV_COLOR && pname != GL_RGB_SCALE && pname != GL_ALPHA_SCALE && pname != GL_TEXTURE_ENV_MODE && pname != GL_COMBINE_RGB && pname != GL_COMBINE_ALPHA && pname != GL_SRC0_RGB && pname != GL_SRC1_RGB && pname != GL_SRC2_RGB && pname != GL_SRC0_ALPHA && pname != GL_SRC1_ALPHA && pname != GL_SRC2_ALPHA && pname != GL_OPERAND0_RGB && pname != GL_OPERAND1_RGB && pname != GL_OPERAND2_RGB && pname != GL_OPERAND0_ALPHA && pname != GL_OPERAND1_ALPHA && pname != GL_OPERAND2_ALPHA) { + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glGetTexEnviv(target=0x%x)", target); + return; + } + break; + default: + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glGetTexEnviv(target=0x%x)", target); + return; + } + switch(pname) { + case GL_COORD_REPLACE_OES: /* size 1 */ + break; + case GL_TEXTURE_LOD_BIAS_EXT: /* size 1 */ + case GL_TEXTURE_ENV_COLOR: /* size 4 */ + case GL_RGB_SCALE: /* size 1 */ + case GL_ALPHA_SCALE: /* size 1 */ + break; + case GL_TEXTURE_ENV_MODE: /* size 1 */ + case GL_COMBINE_RGB: /* size 1 */ + case GL_COMBINE_ALPHA: /* size 1 */ + case GL_SRC0_RGB: /* size 1 */ + case GL_SRC1_RGB: /* size 1 */ + case GL_SRC2_RGB: /* size 1 */ + case GL_SRC0_ALPHA: /* size 1 */ + case GL_SRC1_ALPHA: /* size 1 */ + case GL_SRC2_ALPHA: /* size 1 */ + case GL_OPERAND0_RGB: /* size 1 */ + case GL_OPERAND1_RGB: /* size 1 */ + case GL_OPERAND2_RGB: /* size 1 */ + case GL_OPERAND0_ALPHA: /* size 1 */ + case GL_OPERAND1_ALPHA: /* size 1 */ + case GL_OPERAND2_ALPHA: /* size 1 */ + break; + default: + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glGetTexEnviv(pname=0x%x)", pname); + return; + } + + _mesa_GetTexEnviv(target, pname, params); +} + +extern void GL_APIENTRY _mesa_GetTexEnvfv(GLenum target, GLenum pname, GLfloat * params); +static void GL_APIENTRY _es_GetTexEnvxv(GLenum target, GLenum pname, GLfixed *params) +{ + register unsigned int i; + unsigned int n_params = 4; + GLfloat converted_params[4]; + int convert_params_value = 1; + + switch(target) { + case GL_POINT_SPRITE_OES: + if (pname != GL_COORD_REPLACE_OES) { + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glGetTexEnvxv(target=0x%x)", target); + return; + } + break; + case GL_TEXTURE_FILTER_CONTROL_EXT: + if (pname != GL_TEXTURE_LOD_BIAS_EXT) { + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glGetTexEnvxv(target=0x%x)", target); + return; + } + break; + case GL_TEXTURE_ENV: + if (pname != GL_TEXTURE_ENV_COLOR && pname != GL_RGB_SCALE && pname != GL_ALPHA_SCALE && pname != GL_TEXTURE_ENV_MODE && pname != GL_COMBINE_RGB && pname != GL_COMBINE_ALPHA && pname != GL_SRC0_RGB && pname != GL_SRC1_RGB && pname != GL_SRC2_RGB && pname != GL_SRC0_ALPHA && pname != GL_SRC1_ALPHA && pname != GL_SRC2_ALPHA && pname != GL_OPERAND0_RGB && pname != GL_OPERAND1_RGB && pname != GL_OPERAND2_RGB && pname != GL_OPERAND0_ALPHA && pname != GL_OPERAND1_ALPHA && pname != GL_OPERAND2_ALPHA) { + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glGetTexEnvxv(target=0x%x)", target); + return; + } + break; + default: + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glGetTexEnvxv(target=0x%x)", target); + return; + } + switch(pname) { + case GL_COORD_REPLACE_OES: + convert_params_value = 0; + n_params = 1; + break; + case GL_TEXTURE_LOD_BIAS_EXT: + n_params = 1; + break; + case GL_TEXTURE_ENV_COLOR: + n_params = 4; + break; + case GL_RGB_SCALE: + case GL_ALPHA_SCALE: + n_params = 1; + break; + case GL_TEXTURE_ENV_MODE: + case GL_COMBINE_RGB: + case GL_COMBINE_ALPHA: + case GL_SRC0_RGB: + case GL_SRC1_RGB: + case GL_SRC2_RGB: + case GL_SRC0_ALPHA: + case GL_SRC1_ALPHA: + case GL_SRC2_ALPHA: + case GL_OPERAND0_RGB: + case GL_OPERAND1_RGB: + case GL_OPERAND2_RGB: + case GL_OPERAND0_ALPHA: + case GL_OPERAND1_ALPHA: + case GL_OPERAND2_ALPHA: + convert_params_value = 0; + n_params = 1; + break; + default: + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glGetTexEnvxv(pname=0x%x)", pname); + return; + } + + _mesa_GetTexEnvfv(target, pname, converted_params); + if (convert_params_value) { + for (i = 0; i < n_params; i++) { + params[i] = (GLint) (converted_params[i] * 65536); + } + } else { + for (i = 0; i < n_params; i++) { + params[i] = (GLfixed) converted_params[i]; + } + } +} + +/* this function is special and is defined elsewhere */ +extern void GL_APIENTRY _es_GetTexGenfv(GLenum coord, GLenum pname, GLfloat * params); +static void GL_APIENTRY _check_GetTexGenfvOES(GLenum coord, GLenum pname, GLfloat *params) +{ + switch(coord) { + case GL_TEXTURE_GEN_STR_OES: + break; + default: + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glGetTexGenfvOES(coord=0x%x)", coord); + return; + } + switch(pname) { + case GL_TEXTURE_GEN_MODE_OES: /* size 1 */ + break; + default: + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glGetTexGenfvOES(pname=0x%x)", pname); + return; + } + + _es_GetTexGenfv(coord, pname, params); +} + +/* this function is special and is defined elsewhere */ +extern void GL_APIENTRY _es_GetTexGenfv(GLenum coord, GLenum pname, GLfloat * params); +static void GL_APIENTRY _check_GetTexGenivOES(GLenum coord, GLenum pname, GLint *params) +{ + register unsigned int i; + unsigned int n_params = 1; + GLfloat converted_params[1]; + + switch(coord) { + case GL_TEXTURE_GEN_STR_OES: + break; + default: + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glGetTexGenivOES(coord=0x%x)", coord); + return; + } + switch(pname) { + case GL_TEXTURE_GEN_MODE_OES: + n_params = 1; + break; + default: + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glGetTexGenivOES(pname=0x%x)", pname); + return; + } + + _es_GetTexGenfv(coord, pname, converted_params); + for (i = 0; i < n_params; i++) { + params[i] = (GLfloat) converted_params[i]; + } +} + +/* this function is special and is defined elsewhere */ +extern void GL_APIENTRY _es_GetTexGenfv(GLenum coord, GLenum pname, GLfloat * params); +static void GL_APIENTRY _check_GetTexGenxvOES(GLenum coord, GLenum pname, GLfixed *params) +{ + register unsigned int i; + unsigned int n_params = 1; + GLfloat converted_params[1]; + + switch(coord) { + case GL_TEXTURE_GEN_STR_OES: + break; + default: + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glGetTexGenxvOES(coord=0x%x)", coord); + return; + } + switch(pname) { + case GL_TEXTURE_GEN_MODE_OES: + n_params = 1; + break; + default: + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glGetTexGenxvOES(pname=0x%x)", pname); + return; + } + + _es_GetTexGenfv(coord, pname, converted_params); + for (i = 0; i < n_params; i++) { + params[i] = (GLfloat) converted_params[i]; + } +} + +extern void GL_APIENTRY _mesa_GetTexParameterfv(GLenum target, GLenum pname, GLfloat * params); +static void GL_APIENTRY _es_GetTexParameterfv(GLenum target, GLenum pname, GLfloat *params) +{ + switch(target) { + case GL_TEXTURE_2D: + case GL_TEXTURE_CUBE_MAP_OES: + break; + default: + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glGetTexParameterfv(target=0x%x)", target); + return; + } + switch(pname) { + case GL_TEXTURE_WRAP_S: /* size 1 */ + case GL_TEXTURE_WRAP_T: /* size 1 */ + case GL_TEXTURE_MIN_FILTER: /* size 1 */ + case GL_TEXTURE_MAG_FILTER: /* size 1 */ + case GL_GENERATE_MIPMAP: /* size 1 */ + break; + case GL_TEXTURE_CROP_RECT_OES: /* size 4 */ + break; + default: + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glGetTexParameterfv(pname=0x%x)", pname); + return; + } + + _mesa_GetTexParameterfv(target, pname, params); +} + +extern void GL_APIENTRY _mesa_GetTexParameteriv(GLenum target, GLenum pname, GLint * params); +static void GL_APIENTRY _es_GetTexParameteriv(GLenum target, GLenum pname, GLint *params) +{ + switch(target) { + case GL_TEXTURE_2D: + case GL_TEXTURE_CUBE_MAP_OES: + break; + default: + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glGetTexParameteriv(target=0x%x)", target); + return; + } + switch(pname) { + case GL_TEXTURE_WRAP_S: /* size 1 */ + case GL_TEXTURE_WRAP_T: /* size 1 */ + case GL_TEXTURE_MIN_FILTER: /* size 1 */ + case GL_TEXTURE_MAG_FILTER: /* size 1 */ + case GL_GENERATE_MIPMAP: /* size 1 */ + break; + case GL_TEXTURE_CROP_RECT_OES: /* size 4 */ + break; + default: + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glGetTexParameteriv(pname=0x%x)", pname); + return; + } + + _mesa_GetTexParameteriv(target, pname, params); +} + +extern void GL_APIENTRY _mesa_GetTexParameterfv(GLenum target, GLenum pname, GLfloat * params); +static void GL_APIENTRY _es_GetTexParameterxv(GLenum target, GLenum pname, GLfixed *params) +{ + register unsigned int i; + unsigned int n_params = 4; + GLfloat converted_params[4]; + int convert_params_value = 1; + + switch(target) { + case GL_TEXTURE_2D: + case GL_TEXTURE_CUBE_MAP_OES: + break; + default: + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glGetTexParameterxv(target=0x%x)", target); + return; + } + switch(pname) { + case GL_TEXTURE_WRAP_S: + case GL_TEXTURE_WRAP_T: + case GL_TEXTURE_MIN_FILTER: + case GL_TEXTURE_MAG_FILTER: + case GL_GENERATE_MIPMAP: + convert_params_value = 0; + n_params = 1; + break; + case GL_TEXTURE_CROP_RECT_OES: + n_params = 4; + break; + default: + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glGetTexParameterxv(pname=0x%x)", pname); + return; + } + + _mesa_GetTexParameterfv(target, pname, converted_params); + if (convert_params_value) { + for (i = 0; i < n_params; i++) { + params[i] = (GLint) (converted_params[i] * 65536); + } + } else { + for (i = 0; i < n_params; i++) { + params[i] = (GLfixed) converted_params[i]; + } + } +} + +extern void GL_APIENTRY _mesa_Hint(GLenum target, GLenum mode); +static void GL_APIENTRY _es_Hint(GLenum target, GLenum mode) +{ + switch(target) { + case GL_FOG_HINT: + case GL_LINE_SMOOTH_HINT: + case GL_PERSPECTIVE_CORRECTION_HINT: + case GL_POINT_SMOOTH_HINT: + case GL_GENERATE_MIPMAP_HINT: + break; + default: + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glHint(target=0x%x)", target); + return; + } + switch(mode) { + case GL_FASTEST: + case GL_NICEST: + case GL_DONT_CARE: + break; + default: + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glHint(mode=0x%x)", mode); + return; + } + + _mesa_Hint(target, mode); +} + +extern GLboolean GL_APIENTRY _mesa_IsBufferARB(GLuint buffer); +#define _es_IsBuffer _mesa_IsBufferARB + +extern GLboolean GL_APIENTRY _mesa_IsEnabled(GLenum cap); +static GLboolean GL_APIENTRY _es_IsEnabled(GLenum cap) +{ + switch(cap) { + case GL_NORMALIZE: + case GL_RESCALE_NORMAL: + case GL_CLIP_PLANE0: + case GL_CLIP_PLANE1: + case GL_CLIP_PLANE2: + case GL_CLIP_PLANE3: + case GL_CLIP_PLANE4: + case GL_CLIP_PLANE5: + case GL_FOG: + case GL_LIGHTING: + case GL_COLOR_MATERIAL: + case GL_LIGHT0: + case GL_LIGHT1: + case GL_LIGHT2: + case GL_LIGHT3: + case GL_LIGHT4: + case GL_LIGHT5: + case GL_LIGHT6: + case GL_LIGHT7: + case GL_POINT_SMOOTH: + case GL_LINE_SMOOTH: + case GL_CULL_FACE: + case GL_POLYGON_OFFSET_FILL: + case GL_MULTISAMPLE: + case GL_SAMPLE_ALPHA_TO_COVERAGE: + case GL_SAMPLE_ALPHA_TO_ONE: + case GL_SAMPLE_COVERAGE: + case GL_TEXTURE_2D: + case GL_SCISSOR_TEST: + case GL_ALPHA_TEST: + case GL_STENCIL_TEST: + case GL_DEPTH_TEST: + case GL_BLEND: + case GL_DITHER: + case GL_COLOR_LOGIC_OP: + case GL_POINT_SPRITE_OES: + case GL_TEXTURE_CUBE_MAP_OES: + case GL_TEXTURE_GEN_STR_OES: + case GL_VERTEX_ARRAY: + case GL_NORMAL_ARRAY: + case GL_COLOR_ARRAY: + case GL_TEXTURE_COORD_ARRAY: + case GL_MATRIX_INDEX_ARRAY_OES: + case GL_WEIGHT_ARRAY_OES: + case GL_POINT_SIZE_ARRAY_OES: + break; + default: + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glIsEnabled(cap=0x%x)", cap); + return GL_FALSE; + } + + return _mesa_IsEnabled(cap); +} + +extern GLboolean GL_APIENTRY _mesa_IsFramebufferEXT(GLuint framebuffer); +#define _es_IsFramebufferOES _mesa_IsFramebufferEXT + +extern GLboolean GL_APIENTRY _mesa_IsRenderbufferEXT(GLuint renderbuffer); +#define _es_IsRenderbufferOES _mesa_IsRenderbufferEXT + +extern GLboolean GL_APIENTRY _mesa_IsTexture(GLuint texture); +#define _es_IsTexture _mesa_IsTexture + +extern void GL_APIENTRY _mesa_LightModelf(GLenum pname, GLfloat param); +static void GL_APIENTRY _es_LightModelf(GLenum pname, GLfloat param) +{ + switch(pname) { + case GL_LIGHT_MODEL_TWO_SIDE: + if (param != GL_TRUE && param != GL_FALSE) { + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glLightModelf(pname=0x%x)", pname); + return; + } + break; + default: + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glLightModelf(pname=0x%x)", pname); + return; + } + + _mesa_LightModelf(pname, param); +} + +extern void GL_APIENTRY _mesa_LightModelfv(GLenum pname, const GLfloat * params); +static void GL_APIENTRY _es_LightModelfv(GLenum pname, const GLfloat *params) +{ + switch(pname) { + case GL_LIGHT_MODEL_AMBIENT: /* size 4 */ + break; + case GL_LIGHT_MODEL_TWO_SIDE: /* size 1 */ + if (params[0] != GL_TRUE && params[0] != GL_FALSE) { + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glLightModelfv(pname=0x%x)", pname); + return; + } + break; + default: + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glLightModelfv(pname=0x%x)", pname); + return; + } + + _mesa_LightModelfv(pname, params); +} + +extern void GL_APIENTRY _mesa_LightModelf(GLenum pname, GLfloat param); +static void GL_APIENTRY _es_LightModelx(GLenum pname, GLfixed param) +{ + GLfloat converted_param; + + switch(pname) { + case GL_LIGHT_MODEL_TWO_SIDE: + if (param != GL_TRUE && param != GL_FALSE) { + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glLightModelx(pname=0x%x)", pname); + return; + } + break; + default: + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glLightModelx(pname=0x%x)", pname); + return; + } + + converted_param = (GLfloat) param; + + _mesa_LightModelf(pname, converted_param); +} + +extern void GL_APIENTRY _mesa_LightModelfv(GLenum pname, GLfloat const * params); +static void GL_APIENTRY _es_LightModelxv(GLenum pname, const GLfixed *params) +{ + register unsigned int i; + unsigned int n_params = 4; + GLfloat converted_params[4]; + int convert_params_value = 1; + + switch(pname) { + case GL_LIGHT_MODEL_AMBIENT: + n_params = 4; + break; + case GL_LIGHT_MODEL_TWO_SIDE: + if (params[0] != GL_TRUE && params[0] != GL_FALSE) { + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glLightModelxv(pname=0x%x)", pname); + return; + } + convert_params_value = 0; + n_params = 1; + break; + default: + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glLightModelxv(pname=0x%x)", pname); + return; + } + + if (convert_params_value) { + for (i = 0; i < n_params; i++) { + converted_params[i] = (GLfloat) (params[i] / 65536.0f); + } + } else { + for (i = 0; i < n_params; i++) { + converted_params[i] = (GLfloat) params[i]; + } + } + + _mesa_LightModelfv(pname, converted_params); +} + +extern void GL_APIENTRY _mesa_Lightf(GLenum light, GLenum pname, GLfloat param); +static void GL_APIENTRY _es_Lightf(GLenum light, GLenum pname, GLfloat param) +{ + switch(light) { + case GL_LIGHT0: + case GL_LIGHT1: + case GL_LIGHT2: + case GL_LIGHT3: + case GL_LIGHT4: + case GL_LIGHT5: + case GL_LIGHT6: + case GL_LIGHT7: + break; + default: + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glLightf(light=0x%x)", light); + return; + } + switch(pname) { + case GL_SPOT_EXPONENT: + case GL_SPOT_CUTOFF: + case GL_CONSTANT_ATTENUATION: + case GL_LINEAR_ATTENUATION: + case GL_QUADRATIC_ATTENUATION: + break; + default: + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glLightf(pname=0x%x)", pname); + return; + } + + _mesa_Lightf(light, pname, param); +} + +extern void GL_APIENTRY _mesa_Lightfv(GLenum light, GLenum pname, const GLfloat * params); +static void GL_APIENTRY _es_Lightfv(GLenum light, GLenum pname, const GLfloat *params) +{ + switch(light) { + case GL_LIGHT0: + case GL_LIGHT1: + case GL_LIGHT2: + case GL_LIGHT3: + case GL_LIGHT4: + case GL_LIGHT5: + case GL_LIGHT6: + case GL_LIGHT7: + break; + default: + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glLightfv(light=0x%x)", light); + return; + } + switch(pname) { + case GL_AMBIENT: /* size 4 */ + case GL_DIFFUSE: /* size 4 */ + case GL_SPECULAR: /* size 4 */ + case GL_POSITION: /* size 4 */ + case GL_SPOT_DIRECTION: /* size 3 */ + case GL_SPOT_EXPONENT: /* size 1 */ + case GL_SPOT_CUTOFF: /* size 1 */ + case GL_CONSTANT_ATTENUATION: /* size 1 */ + case GL_LINEAR_ATTENUATION: /* size 1 */ + case GL_QUADRATIC_ATTENUATION: /* size 1 */ + break; + default: + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glLightfv(pname=0x%x)", pname); + return; + } + + _mesa_Lightfv(light, pname, params); +} + +extern void GL_APIENTRY _mesa_Lightf(GLenum light, GLenum pname, GLfloat param); +static void GL_APIENTRY _es_Lightx(GLenum light, GLenum pname, GLfixed param) +{ + GLfloat converted_param; + + switch(light) { + case GL_LIGHT0: + case GL_LIGHT1: + case GL_LIGHT2: + case GL_LIGHT3: + case GL_LIGHT4: + case GL_LIGHT5: + case GL_LIGHT6: + case GL_LIGHT7: + break; + default: + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glLightx(light=0x%x)", light); + return; + } + switch(pname) { + case GL_SPOT_EXPONENT: + case GL_SPOT_CUTOFF: + case GL_CONSTANT_ATTENUATION: + case GL_LINEAR_ATTENUATION: + case GL_QUADRATIC_ATTENUATION: + break; + default: + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glLightx(pname=0x%x)", pname); + return; + } + + converted_param = (GLfloat) (param / 65536.0f); + + _mesa_Lightf(light, pname, converted_param); +} + +extern void GL_APIENTRY _mesa_Lightfv(GLenum light, GLenum pname, GLfloat const * params); +static void GL_APIENTRY _es_Lightxv(GLenum light, GLenum pname, const GLfixed *params) +{ + register unsigned int i; + unsigned int n_params = 4; + GLfloat converted_params[4]; + + switch(light) { + case GL_LIGHT0: + case GL_LIGHT1: + case GL_LIGHT2: + case GL_LIGHT3: + case GL_LIGHT4: + case GL_LIGHT5: + case GL_LIGHT6: + case GL_LIGHT7: + break; + default: + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glLightxv(light=0x%x)", light); + return; + } + switch(pname) { + case GL_AMBIENT: + case GL_DIFFUSE: + case GL_SPECULAR: + case GL_POSITION: + n_params = 4; + break; + case GL_SPOT_DIRECTION: + n_params = 3; + break; + case GL_SPOT_EXPONENT: + case GL_SPOT_CUTOFF: + case GL_CONSTANT_ATTENUATION: + case GL_LINEAR_ATTENUATION: + case GL_QUADRATIC_ATTENUATION: + n_params = 1; + break; + default: + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glLightxv(pname=0x%x)", pname); + return; + } + + for (i = 0; i < n_params; i++) { + converted_params[i] = (GLfloat) (params[i] / 65536.0f); + } + + _mesa_Lightfv(light, pname, converted_params); +} + +extern void GL_APIENTRY _mesa_LineWidth(GLfloat width); +#define _es_LineWidth _mesa_LineWidth + +extern void GL_APIENTRY _mesa_LineWidth(GLfloat width); +static void GL_APIENTRY _es_LineWidthx(GLfixed width) +{ + GLfloat converted_width; + + converted_width = (GLfloat) (width / 65536.0f); + + _mesa_LineWidth(converted_width); +} + +extern void GL_APIENTRY _mesa_LoadIdentity(void); +#define _es_LoadIdentity _mesa_LoadIdentity + +extern void GL_APIENTRY _mesa_LoadMatrixf(const GLfloat * m); +#define _es_LoadMatrixf _mesa_LoadMatrixf + +extern void GL_APIENTRY _mesa_LoadMatrixf(GLfloat const * m); +static void GL_APIENTRY _es_LoadMatrixx(const GLfixed *m) +{ + register unsigned int i; + unsigned int n_m = 16; + GLfloat converted_m[16]; + + for (i = 0; i < n_m; i++) { + converted_m[i] = (GLfloat) (m[i] / 65536.0f); + } + + _mesa_LoadMatrixf(converted_m); +} + +extern void GL_APIENTRY _mesa_LogicOp(GLenum opcode); +static void GL_APIENTRY _es_LogicOp(GLenum opcode) +{ + switch(opcode) { + case GL_CLEAR: + case GL_SET: + case GL_COPY: + case GL_COPY_INVERTED: + case GL_NOOP: + case GL_INVERT: + case GL_AND: + case GL_NAND: + case GL_OR: + case GL_NOR: + case GL_XOR: + case GL_EQUIV: + case GL_AND_REVERSE: + case GL_AND_INVERTED: + case GL_OR_REVERSE: + case GL_OR_INVERTED: + break; + default: + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glLogicOp(opcode=0x%x)", opcode); + return; + } + + _mesa_LogicOp(opcode); +} + +extern void * GL_APIENTRY _mesa_MapBufferARB(GLenum target, GLenum access); +static void * GL_APIENTRY _es_MapBufferOES(GLenum target, GLenum access) +{ + switch(target) { + case GL_ARRAY_BUFFER: + case GL_ELEMENT_ARRAY_BUFFER: + break; + default: + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glMapBufferOES(target=0x%x)", target); + return (void *) 0; + } + switch(access) { + case GL_WRITE_ONLY_OES: + break; + default: + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glMapBufferOES(access=0x%x)", access); + return (void *) 0; + } + + return _mesa_MapBufferARB(target, access); +} + +/* this function is special and is defined elsewhere */ +extern void GL_APIENTRY _es_Materialf(GLenum face, GLenum pname, GLfloat param); +static void GL_APIENTRY _check_Materialf(GLenum face, GLenum pname, GLfloat param) +{ + switch(face) { + case GL_FRONT_AND_BACK: + break; + default: + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glMaterialf(face=0x%x)", face); + return; + } + switch(pname) { + case GL_SHININESS: + break; + default: + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glMaterialf(pname=0x%x)", pname); + return; + } + + _es_Materialf(face, pname, param); +} + +/* this function is special and is defined elsewhere */ +extern void GL_APIENTRY _es_Materialfv(GLenum face, GLenum pname, const GLfloat * params); +static void GL_APIENTRY _check_Materialfv(GLenum face, GLenum pname, const GLfloat *params) +{ + switch(face) { + case GL_FRONT_AND_BACK: + break; + default: + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glMaterialfv(face=0x%x)", face); + return; + } + switch(pname) { + case GL_AMBIENT: /* size 4 */ + case GL_DIFFUSE: /* size 4 */ + case GL_AMBIENT_AND_DIFFUSE: /* size 4 */ + case GL_SPECULAR: /* size 4 */ + case GL_EMISSION: /* size 4 */ + case GL_SHININESS: /* size 1 */ + break; + default: + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glMaterialfv(pname=0x%x)", pname); + return; + } + + _es_Materialfv(face, pname, params); +} + +extern void GL_APIENTRY _es_Materialf(GLenum face, GLenum pname, GLfloat param); +static void GL_APIENTRY _es_Materialx(GLenum face, GLenum pname, GLfixed param) +{ + GLfloat converted_param; + + switch(face) { + case GL_FRONT_AND_BACK: + break; + default: + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glMaterialx(face=0x%x)", face); + return; + } + switch(pname) { + case GL_SHININESS: + break; + default: + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glMaterialx(pname=0x%x)", pname); + return; + } + + converted_param = (GLfloat) (param / 65536.0f); + + _es_Materialf(face, pname, converted_param); +} + +extern void GL_APIENTRY _es_Materialfv(GLenum face, GLenum pname, GLfloat const * params); +static void GL_APIENTRY _es_Materialxv(GLenum face, GLenum pname, const GLfixed *params) +{ + register unsigned int i; + unsigned int n_params = 4; + GLfloat converted_params[4]; + + switch(face) { + case GL_FRONT_AND_BACK: + break; + default: + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glMaterialxv(face=0x%x)", face); + return; + } + switch(pname) { + case GL_AMBIENT: + case GL_DIFFUSE: + case GL_AMBIENT_AND_DIFFUSE: + case GL_SPECULAR: + case GL_EMISSION: + n_params = 4; + break; + case GL_SHININESS: + n_params = 1; + break; + default: + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glMaterialxv(pname=0x%x)", pname); + return; + } + + for (i = 0; i < n_params; i++) { + converted_params[i] = (GLfloat) (params[i] / 65536.0f); + } + + _es_Materialfv(face, pname, converted_params); +} + +extern void GL_APIENTRY _mesa_MatrixMode(GLenum mode); +static void GL_APIENTRY _es_MatrixMode(GLenum mode) +{ + switch(mode) { + case GL_MODELVIEW: + case GL_PROJECTION: + case GL_TEXTURE: + case GL_MATRIX_PALETTE_OES: + break; + default: + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glMatrixMode(mode=0x%x)", mode); + return; + } + + _mesa_MatrixMode(mode); +} + +extern void GL_APIENTRY _mesa_MultMatrixf(const GLfloat * m); +#define _es_MultMatrixf _mesa_MultMatrixf + +extern void GL_APIENTRY _mesa_MultMatrixf(GLfloat const * m); +static void GL_APIENTRY _es_MultMatrixx(const GLfixed *m) +{ + register unsigned int i; + unsigned int n_m = 16; + GLfloat converted_m[16]; + + for (i = 0; i < n_m; i++) { + converted_m[i] = (GLfloat) (m[i] / 65536.0f); + } + + _mesa_MultMatrixf(converted_m); +} + +extern void GL_APIENTRY _mesa_MultiDrawArraysEXT(GLenum mode, const GLint * first, const GLsizei * count, GLsizei primcount); +static void GL_APIENTRY _es_MultiDrawArraysEXT(GLenum mode, const GLint *first, const GLsizei *count, GLsizei primcount) +{ + switch(mode) { + case GL_POINTS: + case GL_LINES: + case GL_LINE_LOOP: + case GL_LINE_STRIP: + case GL_TRIANGLES: + case GL_TRIANGLE_STRIP: + case GL_TRIANGLE_FAN: + break; + default: + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glMultiDrawArraysEXT(mode=0x%x)", mode); + return; + } + + _mesa_MultiDrawArraysEXT(mode, first, count, primcount); +} + +extern void GL_APIENTRY _mesa_MultiDrawElementsEXT(GLenum mode, const GLsizei * count, GLenum type, const GLvoid ** indices, GLsizei primcount); +static void GL_APIENTRY _es_MultiDrawElementsEXT(GLenum mode, const GLsizei *count, GLenum type, const GLvoid **indices, GLsizei primcount) +{ + switch(mode) { + case GL_POINTS: + case GL_LINES: + case GL_LINE_LOOP: + case GL_LINE_STRIP: + case GL_TRIANGLES: + case GL_TRIANGLE_STRIP: + case GL_TRIANGLE_FAN: + break; + default: + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glMultiDrawElementsEXT(mode=0x%x)", mode); + return; + } + switch(type) { + case GL_UNSIGNED_BYTE: + case GL_UNSIGNED_SHORT: + case GL_UNSIGNED_INT: + break; + default: + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glMultiDrawElementsEXT(type=0x%x)", type); + return; + } + + _mesa_MultiDrawElementsEXT(mode, count, type, indices, primcount); +} + +/* this function is special and is defined elsewhere */ +extern void GL_APIENTRY _es_MultiTexCoord4f(GLenum texture, GLfloat s, GLfloat t, GLfloat r, GLfloat q); +static void GL_APIENTRY _check_MultiTexCoord4f(GLenum texture, GLfloat s, GLfloat t, GLfloat r, GLfloat q) +{ + switch(texture) { + case GL_TEXTURE0: + case GL_TEXTURE1: + case GL_TEXTURE2: + case GL_TEXTURE3: + case GL_TEXTURE4: + case GL_TEXTURE5: + case GL_TEXTURE6: + case GL_TEXTURE7: + case GL_TEXTURE8: + case GL_TEXTURE9: + case GL_TEXTURE10: + case GL_TEXTURE11: + case GL_TEXTURE12: + case GL_TEXTURE13: + case GL_TEXTURE14: + case GL_TEXTURE15: + case GL_TEXTURE16: + case GL_TEXTURE17: + case GL_TEXTURE18: + case GL_TEXTURE19: + case GL_TEXTURE20: + case GL_TEXTURE21: + case GL_TEXTURE22: + case GL_TEXTURE23: + case GL_TEXTURE24: + case GL_TEXTURE25: + case GL_TEXTURE26: + case GL_TEXTURE27: + case GL_TEXTURE28: + case GL_TEXTURE29: + case GL_TEXTURE30: + case GL_TEXTURE31: + break; + default: + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glMultiTexCoord4f(texture=0x%x)", texture); + return; + } + + _es_MultiTexCoord4f(texture, s, t, r, q); +} + +extern void GL_APIENTRY _es_MultiTexCoord4f(GLenum texture, GLfloat s, GLfloat t, GLfloat r, GLfloat q); +static void GL_APIENTRY _es_MultiTexCoord4x(GLenum texture, GLfixed s, GLfixed t, GLfixed r, GLfixed q) +{ + GLfloat converted_s; + GLfloat converted_t; + GLfloat converted_r; + GLfloat converted_q; + + switch(texture) { + case GL_TEXTURE0: + case GL_TEXTURE1: + case GL_TEXTURE2: + case GL_TEXTURE3: + case GL_TEXTURE4: + case GL_TEXTURE5: + case GL_TEXTURE6: + case GL_TEXTURE7: + case GL_TEXTURE8: + case GL_TEXTURE9: + case GL_TEXTURE10: + case GL_TEXTURE11: + case GL_TEXTURE12: + case GL_TEXTURE13: + case GL_TEXTURE14: + case GL_TEXTURE15: + case GL_TEXTURE16: + case GL_TEXTURE17: + case GL_TEXTURE18: + case GL_TEXTURE19: + case GL_TEXTURE20: + case GL_TEXTURE21: + case GL_TEXTURE22: + case GL_TEXTURE23: + case GL_TEXTURE24: + case GL_TEXTURE25: + case GL_TEXTURE26: + case GL_TEXTURE27: + case GL_TEXTURE28: + case GL_TEXTURE29: + case GL_TEXTURE30: + case GL_TEXTURE31: + break; + default: + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glMultiTexCoord4x(texture=0x%x)", texture); + return; + } + + converted_s = (GLfloat) (s / 65536.0f); + converted_t = (GLfloat) (t / 65536.0f); + converted_r = (GLfloat) (r / 65536.0f); + converted_q = (GLfloat) (q / 65536.0f); + + _es_MultiTexCoord4f(texture, converted_s, converted_t, converted_r, converted_q); +} + +/* this function is special and is defined elsewhere */ +extern void GL_APIENTRY _es_Normal3f(GLfloat nx, GLfloat ny, GLfloat nz); +#define _check_Normal3f _es_Normal3f + +extern void GL_APIENTRY _es_Normal3f(GLfloat nx, GLfloat ny, GLfloat nz); +static void GL_APIENTRY _es_Normal3x(GLfixed nx, GLfixed ny, GLfixed nz) +{ + GLfloat converted_nx; + GLfloat converted_ny; + GLfloat converted_nz; + + converted_nx = (GLfloat) (nx / 65536.0f); + converted_ny = (GLfloat) (ny / 65536.0f); + converted_nz = (GLfloat) (nz / 65536.0f); + + _es_Normal3f(converted_nx, converted_ny, converted_nz); +} + +extern void GL_APIENTRY _mesa_NormalPointer(GLenum type, GLsizei stride, const GLvoid * pointer); +static void GL_APIENTRY _es_NormalPointer(GLenum type, GLsizei stride, const GLvoid *pointer) +{ + switch(type) { + case GL_BYTE: + case GL_SHORT: + case GL_FLOAT: + case GL_FIXED: + break; + default: + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glNormalPointer(type=0x%x)", type); + return; + } + + _mesa_NormalPointer(type, stride, pointer); +} + +extern void GL_APIENTRY _mesa_Ortho(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar); +static void GL_APIENTRY _es_Orthof(GLfloat left, GLfloat right, GLfloat bottom, GLfloat top, GLfloat zNear, GLfloat zFar) +{ + GLdouble converted_left; + GLdouble converted_right; + GLdouble converted_bottom; + GLdouble converted_top; + GLdouble converted_zNear; + GLdouble converted_zFar; + + converted_left = (GLdouble) (left); + converted_right = (GLdouble) (right); + converted_bottom = (GLdouble) (bottom); + converted_top = (GLdouble) (top); + converted_zNear = (GLdouble) (zNear); + converted_zFar = (GLdouble) (zFar); + + _mesa_Ortho(converted_left, converted_right, converted_bottom, converted_top, converted_zNear, converted_zFar); +} + +extern void GL_APIENTRY _mesa_Ortho(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar); +static void GL_APIENTRY _es_Orthox(GLfixed left, GLfixed right, GLfixed bottom, GLfixed top, GLfixed zNear, GLfixed zFar) +{ + GLdouble converted_left; + GLdouble converted_right; + GLdouble converted_bottom; + GLdouble converted_top; + GLdouble converted_zNear; + GLdouble converted_zFar; + + converted_left = (GLdouble) (left / 65536.0); + converted_right = (GLdouble) (right / 65536.0); + converted_bottom = (GLdouble) (bottom / 65536.0); + converted_top = (GLdouble) (top / 65536.0); + converted_zNear = (GLdouble) (zNear / 65536.0); + converted_zFar = (GLdouble) (zFar / 65536.0); + + _mesa_Ortho(converted_left, converted_right, converted_bottom, converted_top, converted_zNear, converted_zFar); +} + +extern void GL_APIENTRY _mesa_PixelStorei(GLenum pname, GLint param); +static void GL_APIENTRY _es_PixelStorei(GLenum pname, GLint param) +{ + switch(pname) { + case GL_PACK_ALIGNMENT: + case GL_UNPACK_ALIGNMENT: + break; + default: + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glPixelStorei(pname=0x%x)", pname); + return; + } + switch(param) { + case 1: + case 2: + case 4: + case 8: + break; + default: + _mesa_error(_mesa_get_current_context(), GL_INVALID_VALUE, "glPixelStorei(param=%d)", param); + return; + } + + _mesa_PixelStorei(pname, param); +} + +extern void GL_APIENTRY _mesa_PointParameterf(GLenum pname, GLfloat param); +static void GL_APIENTRY _es_PointParameterf(GLenum pname, GLfloat param) +{ + switch(pname) { + case GL_POINT_SIZE_MIN: + case GL_POINT_SIZE_MAX: + case GL_POINT_FADE_THRESHOLD_SIZE: + break; + default: + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glPointParameterf(pname=0x%x)", pname); + return; + } + + _mesa_PointParameterf(pname, param); +} + +extern void GL_APIENTRY _mesa_PointParameterfv(GLenum pname, const GLfloat * params); +static void GL_APIENTRY _es_PointParameterfv(GLenum pname, const GLfloat *params) +{ + switch(pname) { + case GL_POINT_SIZE_MIN: /* size 1 */ + case GL_POINT_SIZE_MAX: /* size 1 */ + case GL_POINT_FADE_THRESHOLD_SIZE: /* size 1 */ + case GL_POINT_DISTANCE_ATTENUATION: /* size 3 */ + break; + default: + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glPointParameterfv(pname=0x%x)", pname); + return; + } + + _mesa_PointParameterfv(pname, params); +} + +extern void GL_APIENTRY _mesa_PointParameterf(GLenum pname, GLfloat param); +static void GL_APIENTRY _es_PointParameterx(GLenum pname, GLfixed param) +{ + GLfloat converted_param; + + switch(pname) { + case GL_POINT_SIZE_MIN: + case GL_POINT_SIZE_MAX: + case GL_POINT_FADE_THRESHOLD_SIZE: + break; + default: + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glPointParameterx(pname=0x%x)", pname); + return; + } + + converted_param = (GLfloat) (param / 65536.0f); + + _mesa_PointParameterf(pname, converted_param); +} + +extern void GL_APIENTRY _mesa_PointParameterfv(GLenum pname, GLfloat const * params); +static void GL_APIENTRY _es_PointParameterxv(GLenum pname, const GLfixed *params) +{ + register unsigned int i; + unsigned int n_params = 3; + GLfloat converted_params[3]; + + switch(pname) { + case GL_POINT_SIZE_MIN: + case GL_POINT_SIZE_MAX: + case GL_POINT_FADE_THRESHOLD_SIZE: + n_params = 1; + break; + case GL_POINT_DISTANCE_ATTENUATION: + n_params = 3; + break; + default: + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glPointParameterxv(pname=0x%x)", pname); + return; + } + + for (i = 0; i < n_params; i++) { + converted_params[i] = (GLfloat) (params[i] / 65536.0f); + } + + _mesa_PointParameterfv(pname, converted_params); +} + +extern void GL_APIENTRY _mesa_PointSize(GLfloat size); +#define _es_PointSize _mesa_PointSize + +extern void GL_APIENTRY _mesa_PointSizePointer(GLenum type, GLsizei stride, const GLvoid * pointer); +static void GL_APIENTRY _es_PointSizePointerOES(GLenum type, GLsizei stride, const GLvoid *pointer) +{ + switch(type) { + case GL_FLOAT: + case GL_FIXED: + break; + default: + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glPointSizePointerOES(type=0x%x)", type); + return; + } + + _mesa_PointSizePointer(type, stride, pointer); +} + +extern void GL_APIENTRY _mesa_PointSize(GLfloat size); +static void GL_APIENTRY _es_PointSizex(GLfixed size) +{ + GLfloat converted_size; + + converted_size = (GLfloat) (size / 65536.0f); + + _mesa_PointSize(converted_size); +} + +extern void GL_APIENTRY _mesa_PolygonOffset(GLfloat factor, GLfloat units); +#define _es_PolygonOffset _mesa_PolygonOffset + +extern void GL_APIENTRY _mesa_PolygonOffset(GLfloat factor, GLfloat units); +static void GL_APIENTRY _es_PolygonOffsetx(GLfixed factor, GLfixed units) +{ + GLfloat converted_factor; + GLfloat converted_units; + + converted_factor = (GLfloat) (factor / 65536.0f); + converted_units = (GLfloat) (units / 65536.0f); + + _mesa_PolygonOffset(converted_factor, converted_units); +} + +extern void GL_APIENTRY _mesa_PopMatrix(void); +#define _es_PopMatrix _mesa_PopMatrix + +extern void GL_APIENTRY _mesa_PushMatrix(void); +#define _es_PushMatrix _mesa_PushMatrix + +/* this function is special and is defined elsewhere */ +extern GLbitfield GL_APIENTRY _es_QueryMatrixxOES(GLfixed * mantissa, GLint * exponent); +#define _check_QueryMatrixxOES _es_QueryMatrixxOES + +extern void GL_APIENTRY _mesa_ReadPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLvoid * pixels); +static void GL_APIENTRY _es_ReadPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLvoid *pixels) +{ + switch(format) { + case GL_ALPHA: + if (type != GL_UNSIGNED_BYTE) { + _mesa_error(_mesa_get_current_context(), GL_INVALID_OPERATION, "glReadPixels(format=0x%x)", format); + return; + } + break; + case GL_RGB: + if (type != GL_UNSIGNED_BYTE && type != GL_UNSIGNED_SHORT_5_6_5) { + _mesa_error(_mesa_get_current_context(), GL_INVALID_OPERATION, "glReadPixels(format=0x%x)", format); + return; + } + break; + case GL_RGBA: + if (type != GL_UNSIGNED_BYTE && type != GL_UNSIGNED_SHORT_4_4_4_4 && type != GL_UNSIGNED_SHORT_5_5_5_1) { + _mesa_error(_mesa_get_current_context(), GL_INVALID_OPERATION, "glReadPixels(format=0x%x)", format); + return; + } + break; + case GL_LUMINANCE: + case GL_LUMINANCE_ALPHA: + if (type != GL_UNSIGNED_BYTE) { + _mesa_error(_mesa_get_current_context(), GL_INVALID_OPERATION, "glReadPixels(format=0x%x)", format); + return; + } + break; + default: + _mesa_error(_mesa_get_current_context(), GL_INVALID_OPERATION, "glReadPixels(format=0x%x)", format); + return; + } + + _mesa_ReadPixels(x, y, width, height, format, type, pixels); +} + +/* this function is special and is defined elsewhere */ +extern void GL_APIENTRY _es_RenderbufferStorageEXT(GLenum target, GLenum internalFormat, GLsizei width, GLsizei height); +static void GL_APIENTRY _check_RenderbufferStorageOES(GLenum target, GLenum internalFormat, GLsizei width, GLsizei height) +{ + switch(target) { + case GL_RENDERBUFFER_OES: + break; + default: + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glRenderbufferStorageOES(target=0x%x)", target); + return; + } + switch(internalFormat) { + case GL_DEPTH_COMPONENT16_OES: + case GL_RGBA4_OES: + case GL_RGB5_A1_OES: + case GL_RGB565_OES: + case GL_STENCIL_INDEX8_OES: + case GL_DEPTH_COMPONENT24_OES: + case GL_DEPTH_COMPONENT32_OES: + case GL_RGB8_OES: + case GL_RGBA8_OES: + case GL_STENCIL_INDEX1_OES: + case GL_STENCIL_INDEX4_OES: + break; + default: + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glRenderbufferStorageOES(internalFormat=0x%x)", internalFormat); + return; + } + + _es_RenderbufferStorageEXT(target, internalFormat, width, height); +} + +extern void GL_APIENTRY _mesa_Rotatef(GLfloat angle, GLfloat x, GLfloat y, GLfloat z); +#define _es_Rotatef _mesa_Rotatef + +extern void GL_APIENTRY _mesa_Rotatef(GLfloat angle, GLfloat x, GLfloat y, GLfloat z); +static void GL_APIENTRY _es_Rotatex(GLfixed angle, GLfixed x, GLfixed y, GLfixed z) +{ + GLfloat converted_angle; + GLfloat converted_x; + GLfloat converted_y; + GLfloat converted_z; + + converted_angle = (GLfloat) (angle / 65536.0f); + converted_x = (GLfloat) (x / 65536.0f); + converted_y = (GLfloat) (y / 65536.0f); + converted_z = (GLfloat) (z / 65536.0f); + + _mesa_Rotatef(converted_angle, converted_x, converted_y, converted_z); +} + +extern void GL_APIENTRY _mesa_SampleCoverageARB(GLclampf value, GLboolean invert); +#define _es_SampleCoverage _mesa_SampleCoverageARB + +extern void GL_APIENTRY _mesa_SampleCoverageARB(GLclampf value, GLboolean invert); +static void GL_APIENTRY _es_SampleCoveragex(GLclampx value, GLboolean invert) +{ + GLclampf converted_value; + + converted_value = (GLclampf) (value / 65536.0f); + + _mesa_SampleCoverageARB(converted_value, invert); +} + +extern void GL_APIENTRY _mesa_Scalef(GLfloat x, GLfloat y, GLfloat z); +#define _es_Scalef _mesa_Scalef + +extern void GL_APIENTRY _mesa_Scalef(GLfloat x, GLfloat y, GLfloat z); +static void GL_APIENTRY _es_Scalex(GLfixed x, GLfixed y, GLfixed z) +{ + GLfloat converted_x; + GLfloat converted_y; + GLfloat converted_z; + + converted_x = (GLfloat) (x / 65536.0f); + converted_y = (GLfloat) (y / 65536.0f); + converted_z = (GLfloat) (z / 65536.0f); + + _mesa_Scalef(converted_x, converted_y, converted_z); +} + +extern void GL_APIENTRY _mesa_Scissor(GLint x, GLint y, GLsizei width, GLsizei height); +#define _es_Scissor _mesa_Scissor + +extern void GL_APIENTRY _mesa_ShadeModel(GLenum mode); +static void GL_APIENTRY _es_ShadeModel(GLenum mode) +{ + switch(mode) { + case GL_FLAT: + case GL_SMOOTH: + break; + default: + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glShadeModel(mode=0x%x)", mode); + return; + } + + _mesa_ShadeModel(mode); +} + +extern void GL_APIENTRY _mesa_StencilFunc(GLenum func, GLint ref, GLuint mask); +static void GL_APIENTRY _es_StencilFunc(GLenum func, GLint ref, GLuint mask) +{ + switch(func) { + case GL_NEVER: + case GL_LESS: + case GL_LEQUAL: + case GL_GREATER: + case GL_GEQUAL: + case GL_EQUAL: + case GL_NOTEQUAL: + case GL_ALWAYS: + break; + default: + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glStencilFunc(func=0x%x)", func); + return; + } + + _mesa_StencilFunc(func, ref, mask); +} + +extern void GL_APIENTRY _mesa_StencilMask(GLuint mask); +#define _es_StencilMask _mesa_StencilMask + +extern void GL_APIENTRY _mesa_StencilOp(GLenum fail, GLenum zfail, GLenum zpass); +static void GL_APIENTRY _es_StencilOp(GLenum fail, GLenum zfail, GLenum zpass) +{ + switch(fail) { + case GL_KEEP: + case GL_ZERO: + case GL_REPLACE: + case GL_INCR: + case GL_DECR: + case GL_INVERT: + case GL_INCR_WRAP_OES: + case GL_DECR_WRAP_OES: + break; + default: + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glStencilOp(fail=0x%x)", fail); + return; + } + switch(zfail) { + case GL_KEEP: + case GL_ZERO: + case GL_REPLACE: + case GL_INCR: + case GL_DECR: + case GL_INVERT: + case GL_INCR_WRAP_OES: + case GL_DECR_WRAP_OES: + break; + default: + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glStencilOp(zfail=0x%x)", zfail); + return; + } + switch(zpass) { + case GL_KEEP: + case GL_ZERO: + case GL_REPLACE: + case GL_INCR: + case GL_DECR: + case GL_INVERT: + case GL_INCR_WRAP_OES: + case GL_DECR_WRAP_OES: + break; + default: + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glStencilOp(zpass=0x%x)", zpass); + return; + } + + _mesa_StencilOp(fail, zfail, zpass); +} + +extern void GL_APIENTRY _mesa_TexCoordPointer(GLint size, GLenum type, GLsizei stride, const GLvoid * pointer); +static void GL_APIENTRY _es_TexCoordPointer(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer) +{ + switch(size) { + case 2: + case 3: + case 4: + break; + default: + _mesa_error(_mesa_get_current_context(), GL_INVALID_VALUE, "glTexCoordPointer(size=%d)", size); + return; + } + switch(type) { + case GL_BYTE: + case GL_SHORT: + case GL_FLOAT: + case GL_FIXED: + break; + default: + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glTexCoordPointer(type=0x%x)", type); + return; + } + + _mesa_TexCoordPointer(size, type, stride, pointer); +} + +extern void GL_APIENTRY _mesa_TexEnvf(GLenum target, GLenum pname, GLfloat param); +static void GL_APIENTRY _es_TexEnvf(GLenum target, GLenum pname, GLfloat param) +{ + switch(target) { + case GL_POINT_SPRITE_OES: + if (pname != GL_COORD_REPLACE_OES) { + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glTexEnvf(target=0x%x)", target); + return; + } + break; + case GL_TEXTURE_FILTER_CONTROL_EXT: + if (pname != GL_TEXTURE_LOD_BIAS_EXT) { + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glTexEnvf(target=0x%x)", target); + return; + } + break; + case GL_TEXTURE_ENV: + if (pname != GL_TEXTURE_ENV_MODE && pname != GL_COMBINE_RGB && pname != GL_COMBINE_ALPHA && pname != GL_RGB_SCALE && pname != GL_ALPHA_SCALE && pname != GL_SRC0_RGB && pname != GL_SRC1_RGB && pname != GL_SRC2_RGB && pname != GL_SRC0_ALPHA && pname != GL_SRC1_ALPHA && pname != GL_SRC2_ALPHA && pname != GL_OPERAND0_RGB && pname != GL_OPERAND1_RGB && pname != GL_OPERAND2_RGB && pname != GL_OPERAND0_ALPHA && pname != GL_OPERAND1_ALPHA && pname != GL_OPERAND2_ALPHA && pname != GL_TEXTURE_ENV_COLOR) { + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glTexEnvf(target=0x%x)", target); + return; + } + break; + default: + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glTexEnvf(target=0x%x)", target); + return; + } + switch(pname) { + case GL_COORD_REPLACE_OES: + if (param != GL_TRUE && param != GL_FALSE) { + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glTexEnvf(pname=0x%x)", pname); + return; + } + break; + case GL_TEXTURE_LOD_BIAS_EXT: + break; + case GL_TEXTURE_ENV_MODE: + if (param != GL_REPLACE && param != GL_MODULATE && param != GL_DECAL && param != GL_BLEND && param != GL_ADD && param != GL_COMBINE) { + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glTexEnvf(pname=0x%x)", pname); + return; + } + break; + case GL_COMBINE_RGB: + if (param != GL_REPLACE && param != GL_MODULATE && param != GL_ADD && param != GL_ADD_SIGNED && param != GL_INTERPOLATE && param != GL_SUBTRACT && param != GL_DOT3_RGB && param != GL_DOT3_RGBA) { + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glTexEnvf(pname=0x%x)", pname); + return; + } + break; + case GL_COMBINE_ALPHA: + if (param != GL_REPLACE && param != GL_MODULATE && param != GL_ADD && param != GL_ADD_SIGNED && param != GL_INTERPOLATE && param != GL_SUBTRACT) { + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glTexEnvf(pname=0x%x)", pname); + return; + } + break; + case GL_RGB_SCALE: + case GL_ALPHA_SCALE: + if (param != 1.0 && param != 2.0 && param != 4.0) { + _mesa_error(_mesa_get_current_context(), GL_INVALID_VALUE, "glTexEnvf(pname=0x%x)", pname); + return; + } + break; + case GL_SRC0_RGB: + case GL_SRC1_RGB: + case GL_SRC2_RGB: + case GL_SRC0_ALPHA: + case GL_SRC1_ALPHA: + case GL_SRC2_ALPHA: + if (param != GL_TEXTURE && param != GL_CONSTANT && param != GL_PRIMARY_COLOR && param != GL_PREVIOUS && param != GL_TEXTURE0 && param != GL_TEXTURE1 && param != GL_TEXTURE2 && param != GL_TEXTURE3 && param != GL_TEXTURE4 && param != GL_TEXTURE5 && param != GL_TEXTURE6 && param != GL_TEXTURE7 && param != GL_TEXTURE8 && param != GL_TEXTURE9 && param != GL_TEXTURE10 && param != GL_TEXTURE11 && param != GL_TEXTURE12 && param != GL_TEXTURE13 && param != GL_TEXTURE14 && param != GL_TEXTURE15 && param != GL_TEXTURE16 && param != GL_TEXTURE17 && param != GL_TEXTURE18 && param != GL_TEXTURE19 && param != GL_TEXTURE20 && param != GL_TEXTURE21 && param != GL_TEXTURE22 && param != GL_TEXTURE23 && param != GL_TEXTURE24 && param != GL_TEXTURE25 && param != GL_TEXTURE26 && param != GL_TEXTURE27 && param != GL_TEXTURE28 && param != GL_TEXTURE29 && param != GL_TEXTURE30 && param != GL_TEXTURE31) { + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glTexEnvf(pname=0x%x)", pname); + return; + } + break; + case GL_OPERAND0_RGB: + case GL_OPERAND1_RGB: + case GL_OPERAND2_RGB: + if (param != GL_SRC_COLOR && param != GL_ONE_MINUS_SRC_COLOR && param != GL_SRC_ALPHA && param != GL_ONE_MINUS_SRC_ALPHA) { + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glTexEnvf(pname=0x%x)", pname); + return; + } + break; + case GL_OPERAND0_ALPHA: + case GL_OPERAND1_ALPHA: + case GL_OPERAND2_ALPHA: + if (param != GL_SRC_ALPHA && param != GL_ONE_MINUS_SRC_ALPHA) { + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glTexEnvf(pname=0x%x)", pname); + return; + } + break; + default: + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glTexEnvf(pname=0x%x)", pname); + return; + } + + _mesa_TexEnvf(target, pname, param); +} + +extern void GL_APIENTRY _mesa_TexEnvfv(GLenum target, GLenum pname, const GLfloat * params); +static void GL_APIENTRY _es_TexEnvfv(GLenum target, GLenum pname, const GLfloat *params) +{ + switch(target) { + case GL_POINT_SPRITE_OES: + if (pname != GL_COORD_REPLACE_OES) { + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glTexEnvfv(target=0x%x)", target); + return; + } + break; + case GL_TEXTURE_FILTER_CONTROL_EXT: + if (pname != GL_TEXTURE_LOD_BIAS_EXT) { + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glTexEnvfv(target=0x%x)", target); + return; + } + break; + case GL_TEXTURE_ENV: + if (pname != GL_TEXTURE_ENV_MODE && pname != GL_COMBINE_RGB && pname != GL_COMBINE_ALPHA && pname != GL_RGB_SCALE && pname != GL_ALPHA_SCALE && pname != GL_SRC0_RGB && pname != GL_SRC1_RGB && pname != GL_SRC2_RGB && pname != GL_SRC0_ALPHA && pname != GL_SRC1_ALPHA && pname != GL_SRC2_ALPHA && pname != GL_OPERAND0_RGB && pname != GL_OPERAND1_RGB && pname != GL_OPERAND2_RGB && pname != GL_OPERAND0_ALPHA && pname != GL_OPERAND1_ALPHA && pname != GL_OPERAND2_ALPHA && pname != GL_TEXTURE_ENV_COLOR) { + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glTexEnvfv(target=0x%x)", target); + return; + } + break; + default: + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glTexEnvfv(target=0x%x)", target); + return; + } + switch(pname) { + case GL_COORD_REPLACE_OES: /* size 1 */ + if (params[0] != GL_TRUE && params[0] != GL_FALSE) { + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glTexEnvfv(pname=0x%x)", pname); + return; + } + break; + case GL_TEXTURE_LOD_BIAS_EXT: /* size 1 */ + break; + case GL_TEXTURE_ENV_MODE: /* size 1 */ + if (params[0] != GL_REPLACE && params[0] != GL_MODULATE && params[0] != GL_DECAL && params[0] != GL_BLEND && params[0] != GL_ADD && params[0] != GL_COMBINE) { + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glTexEnvfv(pname=0x%x)", pname); + return; + } + break; + case GL_COMBINE_RGB: /* size 1 */ + if (params[0] != GL_REPLACE && params[0] != GL_MODULATE && params[0] != GL_ADD && params[0] != GL_ADD_SIGNED && params[0] != GL_INTERPOLATE && params[0] != GL_SUBTRACT && params[0] != GL_DOT3_RGB && params[0] != GL_DOT3_RGBA) { + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glTexEnvfv(pname=0x%x)", pname); + return; + } + break; + case GL_COMBINE_ALPHA: /* size 1 */ + if (params[0] != GL_REPLACE && params[0] != GL_MODULATE && params[0] != GL_ADD && params[0] != GL_ADD_SIGNED && params[0] != GL_INTERPOLATE && params[0] != GL_SUBTRACT) { + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glTexEnvfv(pname=0x%x)", pname); + return; + } + break; + case GL_RGB_SCALE: + case GL_ALPHA_SCALE: + if (params[0] != 1.0 && params[0] != 2.0 && params[0] != 4.0) { + _mesa_error(_mesa_get_current_context(), GL_INVALID_VALUE, "glTexEnvfv(pname=0x%x)", pname); + return; + } + break; + case GL_SRC0_RGB: /* size 1 */ + case GL_SRC1_RGB: /* size 1 */ + case GL_SRC2_RGB: /* size 1 */ + case GL_SRC0_ALPHA: /* size 1 */ + case GL_SRC1_ALPHA: /* size 1 */ + case GL_SRC2_ALPHA: /* size 1 */ + if (params[0] != GL_TEXTURE && params[0] != GL_CONSTANT && params[0] != GL_PRIMARY_COLOR && params[0] != GL_PREVIOUS && params[0] != GL_TEXTURE0 && params[0] != GL_TEXTURE1 && params[0] != GL_TEXTURE2 && params[0] != GL_TEXTURE3 && params[0] != GL_TEXTURE4 && params[0] != GL_TEXTURE5 && params[0] != GL_TEXTURE6 && params[0] != GL_TEXTURE7 && params[0] != GL_TEXTURE8 && params[0] != GL_TEXTURE9 && params[0] != GL_TEXTURE10 && params[0] != GL_TEXTURE11 && params[0] != GL_TEXTURE12 && params[0] != GL_TEXTURE13 && params[0] != GL_TEXTURE14 && params[0] != GL_TEXTURE15 && params[0] != GL_TEXTURE16 && params[0] != GL_TEXTURE17 && params[0] != GL_TEXTURE18 && params[0] != GL_TEXTURE19 && params[0] != GL_TEXTURE20 && params[0] != GL_TEXTURE21 && params[0] != GL_TEXTURE22 && params[0] != GL_TEXTURE23 && params[0] != GL_TEXTURE24 && params[0] != GL_TEXTURE25 && params[0] != GL_TEXTURE26 && params[0] != GL_TEXTURE27 && params[0] != GL_TEXTURE28 && params[0] != GL_TEXTURE29 && params[0] != GL_TEXTURE30 && params[0] != GL_TEXTURE31) { + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glTexEnvfv(pname=0x%x)", pname); + return; + } + break; + case GL_OPERAND0_RGB: /* size 1 */ + case GL_OPERAND1_RGB: /* size 1 */ + case GL_OPERAND2_RGB: /* size 1 */ + if (params[0] != GL_SRC_COLOR && params[0] != GL_ONE_MINUS_SRC_COLOR && params[0] != GL_SRC_ALPHA && params[0] != GL_ONE_MINUS_SRC_ALPHA) { + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glTexEnvfv(pname=0x%x)", pname); + return; + } + break; + case GL_OPERAND0_ALPHA: /* size 1 */ + case GL_OPERAND1_ALPHA: /* size 1 */ + case GL_OPERAND2_ALPHA: /* size 1 */ + if (params[0] != GL_SRC_ALPHA && params[0] != GL_ONE_MINUS_SRC_ALPHA) { + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glTexEnvfv(pname=0x%x)", pname); + return; + } + break; + case GL_TEXTURE_ENV_COLOR: /* size 4 */ + break; + default: + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glTexEnvfv(pname=0x%x)", pname); + return; + } + + _mesa_TexEnvfv(target, pname, params); +} + +extern void GL_APIENTRY _mesa_TexEnvi(GLenum target, GLenum pname, GLint param); +static void GL_APIENTRY _es_TexEnvi(GLenum target, GLenum pname, GLint param) +{ + switch(target) { + case GL_POINT_SPRITE_OES: + if (pname != GL_COORD_REPLACE_OES) { + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glTexEnvi(target=0x%x)", target); + return; + } + break; + case GL_TEXTURE_FILTER_CONTROL_EXT: + if (pname != GL_TEXTURE_LOD_BIAS_EXT) { + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glTexEnvi(target=0x%x)", target); + return; + } + break; + case GL_TEXTURE_ENV: + if (pname != GL_TEXTURE_ENV_MODE && pname != GL_COMBINE_RGB && pname != GL_COMBINE_ALPHA && pname != GL_RGB_SCALE && pname != GL_ALPHA_SCALE && pname != GL_SRC0_RGB && pname != GL_SRC1_RGB && pname != GL_SRC2_RGB && pname != GL_SRC0_ALPHA && pname != GL_SRC1_ALPHA && pname != GL_SRC2_ALPHA && pname != GL_OPERAND0_RGB && pname != GL_OPERAND1_RGB && pname != GL_OPERAND2_RGB && pname != GL_OPERAND0_ALPHA && pname != GL_OPERAND1_ALPHA && pname != GL_OPERAND2_ALPHA && pname != GL_TEXTURE_ENV_COLOR) { + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glTexEnvi(target=0x%x)", target); + return; + } + break; + default: + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glTexEnvi(target=0x%x)", target); + return; + } + switch(pname) { + case GL_COORD_REPLACE_OES: + if (param != GL_TRUE && param != GL_FALSE) { + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glTexEnvi(pname=0x%x)", pname); + return; + } + break; + case GL_TEXTURE_LOD_BIAS_EXT: + break; + case GL_TEXTURE_ENV_MODE: + if (param != GL_REPLACE && param != GL_MODULATE && param != GL_DECAL && param != GL_BLEND && param != GL_ADD && param != GL_COMBINE) { + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glTexEnvi(pname=0x%x)", pname); + return; + } + break; + case GL_COMBINE_RGB: + if (param != GL_REPLACE && param != GL_MODULATE && param != GL_ADD && param != GL_ADD_SIGNED && param != GL_INTERPOLATE && param != GL_SUBTRACT && param != GL_DOT3_RGB && param != GL_DOT3_RGBA) { + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glTexEnvi(pname=0x%x)", pname); + return; + } + break; + case GL_COMBINE_ALPHA: + if (param != GL_REPLACE && param != GL_MODULATE && param != GL_ADD && param != GL_ADD_SIGNED && param != GL_INTERPOLATE && param != GL_SUBTRACT) { + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glTexEnvi(pname=0x%x)", pname); + return; + } + break; + case GL_RGB_SCALE: + case GL_ALPHA_SCALE: + if (param != 1.0 && param != 2.0 && param != 4.0) { + _mesa_error(_mesa_get_current_context(), GL_INVALID_VALUE, "glTexEnvi(pname=0x%x)", pname); + return; + } + break; + case GL_SRC0_RGB: + case GL_SRC1_RGB: + case GL_SRC2_RGB: + case GL_SRC0_ALPHA: + case GL_SRC1_ALPHA: + case GL_SRC2_ALPHA: + if (param != GL_TEXTURE && param != GL_CONSTANT && param != GL_PRIMARY_COLOR && param != GL_PREVIOUS && param != GL_TEXTURE0 && param != GL_TEXTURE1 && param != GL_TEXTURE2 && param != GL_TEXTURE3 && param != GL_TEXTURE4 && param != GL_TEXTURE5 && param != GL_TEXTURE6 && param != GL_TEXTURE7 && param != GL_TEXTURE8 && param != GL_TEXTURE9 && param != GL_TEXTURE10 && param != GL_TEXTURE11 && param != GL_TEXTURE12 && param != GL_TEXTURE13 && param != GL_TEXTURE14 && param != GL_TEXTURE15 && param != GL_TEXTURE16 && param != GL_TEXTURE17 && param != GL_TEXTURE18 && param != GL_TEXTURE19 && param != GL_TEXTURE20 && param != GL_TEXTURE21 && param != GL_TEXTURE22 && param != GL_TEXTURE23 && param != GL_TEXTURE24 && param != GL_TEXTURE25 && param != GL_TEXTURE26 && param != GL_TEXTURE27 && param != GL_TEXTURE28 && param != GL_TEXTURE29 && param != GL_TEXTURE30 && param != GL_TEXTURE31) { + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glTexEnvi(pname=0x%x)", pname); + return; + } + break; + case GL_OPERAND0_RGB: + case GL_OPERAND1_RGB: + case GL_OPERAND2_RGB: + if (param != GL_SRC_COLOR && param != GL_ONE_MINUS_SRC_COLOR && param != GL_SRC_ALPHA && param != GL_ONE_MINUS_SRC_ALPHA) { + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glTexEnvi(pname=0x%x)", pname); + return; + } + break; + case GL_OPERAND0_ALPHA: + case GL_OPERAND1_ALPHA: + case GL_OPERAND2_ALPHA: + if (param != GL_SRC_ALPHA && param != GL_ONE_MINUS_SRC_ALPHA) { + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glTexEnvi(pname=0x%x)", pname); + return; + } + break; + default: + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glTexEnvi(pname=0x%x)", pname); + return; + } + + _mesa_TexEnvi(target, pname, param); +} + +extern void GL_APIENTRY _mesa_TexEnviv(GLenum target, GLenum pname, const GLint * params); +static void GL_APIENTRY _es_TexEnviv(GLenum target, GLenum pname, const GLint *params) +{ + switch(target) { + case GL_POINT_SPRITE_OES: + if (pname != GL_COORD_REPLACE_OES) { + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glTexEnviv(target=0x%x)", target); + return; + } + break; + case GL_TEXTURE_FILTER_CONTROL_EXT: + if (pname != GL_TEXTURE_LOD_BIAS_EXT) { + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glTexEnviv(target=0x%x)", target); + return; + } + break; + case GL_TEXTURE_ENV: + if (pname != GL_TEXTURE_ENV_MODE && pname != GL_COMBINE_RGB && pname != GL_COMBINE_ALPHA && pname != GL_RGB_SCALE && pname != GL_ALPHA_SCALE && pname != GL_SRC0_RGB && pname != GL_SRC1_RGB && pname != GL_SRC2_RGB && pname != GL_SRC0_ALPHA && pname != GL_SRC1_ALPHA && pname != GL_SRC2_ALPHA && pname != GL_OPERAND0_RGB && pname != GL_OPERAND1_RGB && pname != GL_OPERAND2_RGB && pname != GL_OPERAND0_ALPHA && pname != GL_OPERAND1_ALPHA && pname != GL_OPERAND2_ALPHA && pname != GL_TEXTURE_ENV_COLOR) { + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glTexEnviv(target=0x%x)", target); + return; + } + break; + default: + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glTexEnviv(target=0x%x)", target); + return; + } + switch(pname) { + case GL_COORD_REPLACE_OES: /* size 1 */ + if (params[0] != GL_TRUE && params[0] != GL_FALSE) { + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glTexEnviv(pname=0x%x)", pname); + return; + } + break; + case GL_TEXTURE_LOD_BIAS_EXT: /* size 1 */ + break; + case GL_TEXTURE_ENV_MODE: /* size 1 */ + if (params[0] != GL_REPLACE && params[0] != GL_MODULATE && params[0] != GL_DECAL && params[0] != GL_BLEND && params[0] != GL_ADD && params[0] != GL_COMBINE) { + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glTexEnviv(pname=0x%x)", pname); + return; + } + break; + case GL_COMBINE_RGB: /* size 1 */ + if (params[0] != GL_REPLACE && params[0] != GL_MODULATE && params[0] != GL_ADD && params[0] != GL_ADD_SIGNED && params[0] != GL_INTERPOLATE && params[0] != GL_SUBTRACT && params[0] != GL_DOT3_RGB && params[0] != GL_DOT3_RGBA) { + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glTexEnviv(pname=0x%x)", pname); + return; + } + break; + case GL_COMBINE_ALPHA: /* size 1 */ + if (params[0] != GL_REPLACE && params[0] != GL_MODULATE && params[0] != GL_ADD && params[0] != GL_ADD_SIGNED && params[0] != GL_INTERPOLATE && params[0] != GL_SUBTRACT) { + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glTexEnviv(pname=0x%x)", pname); + return; + } + break; + case GL_RGB_SCALE: + case GL_ALPHA_SCALE: + if (params[0] != 1.0 && params[0] != 2.0 && params[0] != 4.0) { + _mesa_error(_mesa_get_current_context(), GL_INVALID_VALUE, "glTexEnviv(pname=0x%x)", pname); + return; + } + break; + case GL_SRC0_RGB: /* size 1 */ + case GL_SRC1_RGB: /* size 1 */ + case GL_SRC2_RGB: /* size 1 */ + case GL_SRC0_ALPHA: /* size 1 */ + case GL_SRC1_ALPHA: /* size 1 */ + case GL_SRC2_ALPHA: /* size 1 */ + if (params[0] != GL_TEXTURE && params[0] != GL_CONSTANT && params[0] != GL_PRIMARY_COLOR && params[0] != GL_PREVIOUS && params[0] != GL_TEXTURE0 && params[0] != GL_TEXTURE1 && params[0] != GL_TEXTURE2 && params[0] != GL_TEXTURE3 && params[0] != GL_TEXTURE4 && params[0] != GL_TEXTURE5 && params[0] != GL_TEXTURE6 && params[0] != GL_TEXTURE7 && params[0] != GL_TEXTURE8 && params[0] != GL_TEXTURE9 && params[0] != GL_TEXTURE10 && params[0] != GL_TEXTURE11 && params[0] != GL_TEXTURE12 && params[0] != GL_TEXTURE13 && params[0] != GL_TEXTURE14 && params[0] != GL_TEXTURE15 && params[0] != GL_TEXTURE16 && params[0] != GL_TEXTURE17 && params[0] != GL_TEXTURE18 && params[0] != GL_TEXTURE19 && params[0] != GL_TEXTURE20 && params[0] != GL_TEXTURE21 && params[0] != GL_TEXTURE22 && params[0] != GL_TEXTURE23 && params[0] != GL_TEXTURE24 && params[0] != GL_TEXTURE25 && params[0] != GL_TEXTURE26 && params[0] != GL_TEXTURE27 && params[0] != GL_TEXTURE28 && params[0] != GL_TEXTURE29 && params[0] != GL_TEXTURE30 && params[0] != GL_TEXTURE31) { + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glTexEnviv(pname=0x%x)", pname); + return; + } + break; + case GL_OPERAND0_RGB: /* size 1 */ + case GL_OPERAND1_RGB: /* size 1 */ + case GL_OPERAND2_RGB: /* size 1 */ + if (params[0] != GL_SRC_COLOR && params[0] != GL_ONE_MINUS_SRC_COLOR && params[0] != GL_SRC_ALPHA && params[0] != GL_ONE_MINUS_SRC_ALPHA) { + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glTexEnviv(pname=0x%x)", pname); + return; + } + break; + case GL_OPERAND0_ALPHA: /* size 1 */ + case GL_OPERAND1_ALPHA: /* size 1 */ + case GL_OPERAND2_ALPHA: /* size 1 */ + if (params[0] != GL_SRC_ALPHA && params[0] != GL_ONE_MINUS_SRC_ALPHA) { + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glTexEnviv(pname=0x%x)", pname); + return; + } + break; + case GL_TEXTURE_ENV_COLOR: /* size 4 */ + break; + default: + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glTexEnviv(pname=0x%x)", pname); + return; + } + + _mesa_TexEnviv(target, pname, params); +} + +extern void GL_APIENTRY _mesa_TexEnvf(GLenum target, GLenum pname, GLfloat param); +static void GL_APIENTRY _es_TexEnvx(GLenum target, GLenum pname, GLfixed param) +{ + GLfloat converted_param; + int convert_param_value = 1; + + switch(target) { + case GL_POINT_SPRITE_OES: + if (pname != GL_COORD_REPLACE_OES) { + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glTexEnvx(target=0x%x)", target); + return; + } + break; + case GL_TEXTURE_FILTER_CONTROL_EXT: + if (pname != GL_TEXTURE_LOD_BIAS_EXT) { + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glTexEnvx(target=0x%x)", target); + return; + } + break; + case GL_TEXTURE_ENV: + if (pname != GL_TEXTURE_ENV_MODE && pname != GL_COMBINE_RGB && pname != GL_COMBINE_ALPHA && pname != GL_RGB_SCALE && pname != GL_ALPHA_SCALE && pname != GL_SRC0_RGB && pname != GL_SRC1_RGB && pname != GL_SRC2_RGB && pname != GL_SRC0_ALPHA && pname != GL_SRC1_ALPHA && pname != GL_SRC2_ALPHA && pname != GL_OPERAND0_RGB && pname != GL_OPERAND1_RGB && pname != GL_OPERAND2_RGB && pname != GL_OPERAND0_ALPHA && pname != GL_OPERAND1_ALPHA && pname != GL_OPERAND2_ALPHA && pname != GL_TEXTURE_ENV_COLOR) { + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glTexEnvx(target=0x%x)", target); + return; + } + break; + default: + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glTexEnvx(target=0x%x)", target); + return; + } + switch(pname) { + case GL_COORD_REPLACE_OES: + if (param != GL_TRUE && param != GL_FALSE) { + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glTexEnvx(pname=0x%x)", pname); + return; + } + convert_param_value = 0; + break; + case GL_TEXTURE_LOD_BIAS_EXT: + break; + case GL_TEXTURE_ENV_MODE: + if (param != GL_REPLACE && param != GL_MODULATE && param != GL_DECAL && param != GL_BLEND && param != GL_ADD && param != GL_COMBINE) { + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glTexEnvx(pname=0x%x)", pname); + return; + } + convert_param_value = 0; + break; + case GL_COMBINE_RGB: + if (param != GL_REPLACE && param != GL_MODULATE && param != GL_ADD && param != GL_ADD_SIGNED && param != GL_INTERPOLATE && param != GL_SUBTRACT && param != GL_DOT3_RGB && param != GL_DOT3_RGBA) { + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glTexEnvx(pname=0x%x)", pname); + return; + } + convert_param_value = 0; + break; + case GL_COMBINE_ALPHA: + if (param != GL_REPLACE && param != GL_MODULATE && param != GL_ADD && param != GL_ADD_SIGNED && param != GL_INTERPOLATE && param != GL_SUBTRACT) { + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glTexEnvx(pname=0x%x)", pname); + return; + } + convert_param_value = 0; + break; + case GL_RGB_SCALE: + case GL_ALPHA_SCALE: + if (param != 1.0 && param != 2.0 && param != 4.0) { + _mesa_error(_mesa_get_current_context(), GL_INVALID_VALUE, "glTexEnvx(pname=0x%x)", pname); + return; + } + break; + case GL_SRC0_RGB: + case GL_SRC1_RGB: + case GL_SRC2_RGB: + case GL_SRC0_ALPHA: + case GL_SRC1_ALPHA: + case GL_SRC2_ALPHA: + if (param != GL_TEXTURE && param != GL_CONSTANT && param != GL_PRIMARY_COLOR && param != GL_PREVIOUS && param != GL_TEXTURE0 && param != GL_TEXTURE1 && param != GL_TEXTURE2 && param != GL_TEXTURE3 && param != GL_TEXTURE4 && param != GL_TEXTURE5 && param != GL_TEXTURE6 && param != GL_TEXTURE7 && param != GL_TEXTURE8 && param != GL_TEXTURE9 && param != GL_TEXTURE10 && param != GL_TEXTURE11 && param != GL_TEXTURE12 && param != GL_TEXTURE13 && param != GL_TEXTURE14 && param != GL_TEXTURE15 && param != GL_TEXTURE16 && param != GL_TEXTURE17 && param != GL_TEXTURE18 && param != GL_TEXTURE19 && param != GL_TEXTURE20 && param != GL_TEXTURE21 && param != GL_TEXTURE22 && param != GL_TEXTURE23 && param != GL_TEXTURE24 && param != GL_TEXTURE25 && param != GL_TEXTURE26 && param != GL_TEXTURE27 && param != GL_TEXTURE28 && param != GL_TEXTURE29 && param != GL_TEXTURE30 && param != GL_TEXTURE31) { + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glTexEnvx(pname=0x%x)", pname); + return; + } + convert_param_value = 0; + break; + case GL_OPERAND0_RGB: + case GL_OPERAND1_RGB: + case GL_OPERAND2_RGB: + if (param != GL_SRC_COLOR && param != GL_ONE_MINUS_SRC_COLOR && param != GL_SRC_ALPHA && param != GL_ONE_MINUS_SRC_ALPHA) { + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glTexEnvx(pname=0x%x)", pname); + return; + } + convert_param_value = 0; + break; + case GL_OPERAND0_ALPHA: + case GL_OPERAND1_ALPHA: + case GL_OPERAND2_ALPHA: + if (param != GL_SRC_ALPHA && param != GL_ONE_MINUS_SRC_ALPHA) { + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glTexEnvx(pname=0x%x)", pname); + return; + } + convert_param_value = 0; + break; + default: + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glTexEnvx(pname=0x%x)", pname); + return; + } + + if (convert_param_value) { + converted_param = (GLfloat) (param / 65536.0f); + } else { + converted_param = (GLfloat) param; + } + + _mesa_TexEnvf(target, pname, converted_param); +} + +extern void GL_APIENTRY _mesa_TexEnvfv(GLenum target, GLenum pname, GLfloat const * params); +static void GL_APIENTRY _es_TexEnvxv(GLenum target, GLenum pname, const GLfixed *params) +{ + register unsigned int i; + unsigned int n_params = 4; + GLfloat converted_params[4]; + int convert_params_value = 1; + + switch(target) { + case GL_POINT_SPRITE_OES: + if (pname != GL_COORD_REPLACE_OES) { + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glTexEnvxv(target=0x%x)", target); + return; + } + break; + case GL_TEXTURE_FILTER_CONTROL_EXT: + if (pname != GL_TEXTURE_LOD_BIAS_EXT) { + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glTexEnvxv(target=0x%x)", target); + return; + } + break; + case GL_TEXTURE_ENV: + if (pname != GL_TEXTURE_ENV_MODE && pname != GL_COMBINE_RGB && pname != GL_COMBINE_ALPHA && pname != GL_RGB_SCALE && pname != GL_ALPHA_SCALE && pname != GL_SRC0_RGB && pname != GL_SRC1_RGB && pname != GL_SRC2_RGB && pname != GL_SRC0_ALPHA && pname != GL_SRC1_ALPHA && pname != GL_SRC2_ALPHA && pname != GL_OPERAND0_RGB && pname != GL_OPERAND1_RGB && pname != GL_OPERAND2_RGB && pname != GL_OPERAND0_ALPHA && pname != GL_OPERAND1_ALPHA && pname != GL_OPERAND2_ALPHA && pname != GL_TEXTURE_ENV_COLOR) { + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glTexEnvxv(target=0x%x)", target); + return; + } + break; + default: + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glTexEnvxv(target=0x%x)", target); + return; + } + switch(pname) { + case GL_COORD_REPLACE_OES: + if (params[0] != GL_TRUE && params[0] != GL_FALSE) { + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glTexEnvxv(pname=0x%x)", pname); + return; + } + convert_params_value = 0; + n_params = 1; + break; + case GL_TEXTURE_LOD_BIAS_EXT: + n_params = 1; + break; + case GL_TEXTURE_ENV_MODE: + if (params[0] != GL_REPLACE && params[0] != GL_MODULATE && params[0] != GL_DECAL && params[0] != GL_BLEND && params[0] != GL_ADD && params[0] != GL_COMBINE) { + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glTexEnvxv(pname=0x%x)", pname); + return; + } + convert_params_value = 0; + n_params = 1; + break; + case GL_COMBINE_RGB: + if (params[0] != GL_REPLACE && params[0] != GL_MODULATE && params[0] != GL_ADD && params[0] != GL_ADD_SIGNED && params[0] != GL_INTERPOLATE && params[0] != GL_SUBTRACT && params[0] != GL_DOT3_RGB && params[0] != GL_DOT3_RGBA) { + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glTexEnvxv(pname=0x%x)", pname); + return; + } + convert_params_value = 0; + n_params = 1; + break; + case GL_COMBINE_ALPHA: + if (params[0] != GL_REPLACE && params[0] != GL_MODULATE && params[0] != GL_ADD && params[0] != GL_ADD_SIGNED && params[0] != GL_INTERPOLATE && params[0] != GL_SUBTRACT) { + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glTexEnvxv(pname=0x%x)", pname); + return; + } + convert_params_value = 0; + n_params = 1; + break; + case GL_RGB_SCALE: + case GL_ALPHA_SCALE: + if (params[0] != 1.0 && params[0] != 2.0 && params[0] != 4.0) { + _mesa_error(_mesa_get_current_context(), GL_INVALID_VALUE, "glTexEnvxv(pname=0x%x)", pname); + return; + } + break; + case GL_SRC0_RGB: + case GL_SRC1_RGB: + case GL_SRC2_RGB: + case GL_SRC0_ALPHA: + case GL_SRC1_ALPHA: + case GL_SRC2_ALPHA: + if (params[0] != GL_TEXTURE && params[0] != GL_CONSTANT && params[0] != GL_PRIMARY_COLOR && params[0] != GL_PREVIOUS && params[0] != GL_TEXTURE0 && params[0] != GL_TEXTURE1 && params[0] != GL_TEXTURE2 && params[0] != GL_TEXTURE3 && params[0] != GL_TEXTURE4 && params[0] != GL_TEXTURE5 && params[0] != GL_TEXTURE6 && params[0] != GL_TEXTURE7 && params[0] != GL_TEXTURE8 && params[0] != GL_TEXTURE9 && params[0] != GL_TEXTURE10 && params[0] != GL_TEXTURE11 && params[0] != GL_TEXTURE12 && params[0] != GL_TEXTURE13 && params[0] != GL_TEXTURE14 && params[0] != GL_TEXTURE15 && params[0] != GL_TEXTURE16 && params[0] != GL_TEXTURE17 && params[0] != GL_TEXTURE18 && params[0] != GL_TEXTURE19 && params[0] != GL_TEXTURE20 && params[0] != GL_TEXTURE21 && params[0] != GL_TEXTURE22 && params[0] != GL_TEXTURE23 && params[0] != GL_TEXTURE24 && params[0] != GL_TEXTURE25 && params[0] != GL_TEXTURE26 && params[0] != GL_TEXTURE27 && params[0] != GL_TEXTURE28 && params[0] != GL_TEXTURE29 && params[0] != GL_TEXTURE30 && params[0] != GL_TEXTURE31) { + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glTexEnvxv(pname=0x%x)", pname); + return; + } + convert_params_value = 0; + n_params = 1; + break; + case GL_OPERAND0_RGB: + case GL_OPERAND1_RGB: + case GL_OPERAND2_RGB: + if (params[0] != GL_SRC_COLOR && params[0] != GL_ONE_MINUS_SRC_COLOR && params[0] != GL_SRC_ALPHA && params[0] != GL_ONE_MINUS_SRC_ALPHA) { + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glTexEnvxv(pname=0x%x)", pname); + return; + } + convert_params_value = 0; + n_params = 1; + break; + case GL_OPERAND0_ALPHA: + case GL_OPERAND1_ALPHA: + case GL_OPERAND2_ALPHA: + if (params[0] != GL_SRC_ALPHA && params[0] != GL_ONE_MINUS_SRC_ALPHA) { + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glTexEnvxv(pname=0x%x)", pname); + return; + } + convert_params_value = 0; + n_params = 1; + break; + case GL_TEXTURE_ENV_COLOR: + n_params = 4; + break; + default: + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glTexEnvxv(pname=0x%x)", pname); + return; + } + + if (convert_params_value) { + for (i = 0; i < n_params; i++) { + converted_params[i] = (GLfloat) (params[i] / 65536.0f); + } + } else { + for (i = 0; i < n_params; i++) { + converted_params[i] = (GLfloat) params[i]; + } + } + + _mesa_TexEnvfv(target, pname, converted_params); +} + +/* this function is special and is defined elsewhere */ +extern void GL_APIENTRY _es_TexGenf(GLenum coord, GLenum pname, GLfloat param); +static void GL_APIENTRY _check_TexGenfOES(GLenum coord, GLenum pname, GLfloat param) +{ + switch(coord) { + case GL_TEXTURE_GEN_STR_OES: + break; + default: + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glTexGenfOES(coord=0x%x)", coord); + return; + } + switch(pname) { + case GL_TEXTURE_GEN_MODE_OES: + if (param != GL_NORMAL_MAP_OES && param != GL_REFLECTION_MAP_OES) { + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glTexGenfOES(pname=0x%x)", pname); + return; + } + break; + default: + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glTexGenfOES(pname=0x%x)", pname); + return; + } + + _es_TexGenf(coord, pname, param); +} + +/* this function is special and is defined elsewhere */ +extern void GL_APIENTRY _es_TexGenfv(GLenum coord, GLenum pname, const GLfloat * params); +static void GL_APIENTRY _check_TexGenfvOES(GLenum coord, GLenum pname, const GLfloat *params) +{ + switch(coord) { + case GL_TEXTURE_GEN_STR_OES: + break; + default: + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glTexGenfvOES(coord=0x%x)", coord); + return; + } + switch(pname) { + case GL_TEXTURE_GEN_MODE_OES: /* size 1 */ + if (params[0] != GL_NORMAL_MAP_OES && params[0] != GL_REFLECTION_MAP_OES) { + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glTexGenfvOES(pname=0x%x)", pname); + return; + } + break; + default: + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glTexGenfvOES(pname=0x%x)", pname); + return; + } + + _es_TexGenfv(coord, pname, params); +} + +/* this function is special and is defined elsewhere */ +extern void GL_APIENTRY _es_TexGenf(GLenum coord, GLenum pname, GLfloat param); +static void GL_APIENTRY _check_TexGeniOES(GLenum coord, GLenum pname, GLint param) +{ + GLfloat converted_param; + + switch(coord) { + case GL_TEXTURE_GEN_STR_OES: + break; + default: + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glTexGeniOES(coord=0x%x)", coord); + return; + } + switch(pname) { + case GL_TEXTURE_GEN_MODE_OES: + if (param != GL_NORMAL_MAP_OES && param != GL_REFLECTION_MAP_OES) { + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glTexGeniOES(pname=0x%x)", pname); + return; + } + break; + default: + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glTexGeniOES(pname=0x%x)", pname); + return; + } + + converted_param = (GLfloat) param; + + _es_TexGenf(coord, pname, converted_param); +} + +/* this function is special and is defined elsewhere */ +extern void GL_APIENTRY _es_TexGenfv(GLenum coord, GLenum pname, GLfloat const * params); +static void GL_APIENTRY _check_TexGenivOES(GLenum coord, GLenum pname, const GLint *params) +{ + register unsigned int i; + unsigned int n_params = 1; + GLfloat converted_params[1]; + + switch(coord) { + case GL_TEXTURE_GEN_STR_OES: + break; + default: + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glTexGenivOES(coord=0x%x)", coord); + return; + } + switch(pname) { + case GL_TEXTURE_GEN_MODE_OES: + if (params[0] != GL_NORMAL_MAP_OES && params[0] != GL_REFLECTION_MAP_OES) { + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glTexGenivOES(pname=0x%x)", pname); + return; + } + n_params = 1; + break; + default: + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glTexGenivOES(pname=0x%x)", pname); + return; + } + + for (i = 0; i < n_params; i++) { + converted_params[i] = (GLfloat) params[i]; + } + + _es_TexGenfv(coord, pname, converted_params); +} + +/* this function is special and is defined elsewhere */ +extern void GL_APIENTRY _es_TexGenf(GLenum coord, GLenum pname, GLfloat param); +static void GL_APIENTRY _check_TexGenxOES(GLenum coord, GLenum pname, GLfixed param) +{ + GLfloat converted_param; + + switch(coord) { + case GL_TEXTURE_GEN_STR_OES: + break; + default: + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glTexGenxOES(coord=0x%x)", coord); + return; + } + switch(pname) { + case GL_TEXTURE_GEN_MODE_OES: + if (param != GL_NORMAL_MAP_OES && param != GL_REFLECTION_MAP_OES) { + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glTexGenxOES(pname=0x%x)", pname); + return; + } + break; + default: + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glTexGenxOES(pname=0x%x)", pname); + return; + } + + converted_param = (GLfloat) param; + + _es_TexGenf(coord, pname, converted_param); +} + +/* this function is special and is defined elsewhere */ +extern void GL_APIENTRY _es_TexGenfv(GLenum coord, GLenum pname, GLfloat const * params); +static void GL_APIENTRY _check_TexGenxvOES(GLenum coord, GLenum pname, const GLfixed *params) +{ + register unsigned int i; + unsigned int n_params = 1; + GLfloat converted_params[1]; + + switch(coord) { + case GL_TEXTURE_GEN_STR_OES: + break; + default: + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glTexGenxvOES(coord=0x%x)", coord); + return; + } + switch(pname) { + case GL_TEXTURE_GEN_MODE_OES: + if (params[0] != GL_NORMAL_MAP_OES && params[0] != GL_REFLECTION_MAP_OES) { + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glTexGenxvOES(pname=0x%x)", pname); + return; + } + n_params = 1; + break; + default: + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glTexGenxvOES(pname=0x%x)", pname); + return; + } + + for (i = 0; i < n_params; i++) { + converted_params[i] = (GLfloat) params[i]; + } + + _es_TexGenfv(coord, pname, converted_params); +} + +extern void GL_APIENTRY _mesa_TexImage2D(GLenum target, GLint level, GLint internalFormat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const GLvoid * pixels); +static void GL_APIENTRY _es_TexImage2D(GLenum target, GLint level, GLint internalFormat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const GLvoid *pixels) +{ + switch(target) { + case GL_TEXTURE_2D: + case GL_TEXTURE_CUBE_MAP_POSITIVE_X_OES: + case GL_TEXTURE_CUBE_MAP_POSITIVE_Y_OES: + case GL_TEXTURE_CUBE_MAP_POSITIVE_Z_OES: + case GL_TEXTURE_CUBE_MAP_NEGATIVE_X_OES: + case GL_TEXTURE_CUBE_MAP_NEGATIVE_Y_OES: + case GL_TEXTURE_CUBE_MAP_NEGATIVE_Z_OES: + break; + default: + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glTexImage2D(target=0x%x)", target); + return; + } + switch(internalFormat) { + case GL_ALPHA: + case GL_RGB: + case GL_RGBA: + case GL_BGRA_EXT: + case GL_LUMINANCE: + case GL_LUMINANCE_ALPHA: + break; + default: + _mesa_error(_mesa_get_current_context(), GL_INVALID_VALUE, "glTexImage2D(internalFormat=%d)", internalFormat); + return; + } + switch(border) { + case 0: + break; + default: + _mesa_error(_mesa_get_current_context(), GL_INVALID_VALUE, "glTexImage2D(border=%d)", border); + return; + } + switch(format) { + case GL_ALPHA: + if (type != GL_UNSIGNED_BYTE) { + _mesa_error(_mesa_get_current_context(), GL_INVALID_OPERATION, "glTexImage2D(format=0x%x)", format); + return; + } + break; + case GL_RGB: + if (type != GL_UNSIGNED_BYTE && type != GL_UNSIGNED_SHORT_5_6_5) { + _mesa_error(_mesa_get_current_context(), GL_INVALID_OPERATION, "glTexImage2D(format=0x%x)", format); + return; + } + break; + case GL_RGBA: + if (type != GL_UNSIGNED_BYTE && type != GL_UNSIGNED_SHORT_4_4_4_4 && type != GL_UNSIGNED_SHORT_5_5_5_1) { + _mesa_error(_mesa_get_current_context(), GL_INVALID_OPERATION, "glTexImage2D(format=0x%x)", format); + return; + } + break; + case GL_LUMINANCE: + case GL_LUMINANCE_ALPHA: + if (type != GL_UNSIGNED_BYTE) { + _mesa_error(_mesa_get_current_context(), GL_INVALID_OPERATION, "glTexImage2D(format=0x%x)", format); + return; + } + break; + default: + _mesa_error(_mesa_get_current_context(), GL_INVALID_OPERATION, "glTexImage2D(format=0x%x)", format); + return; + } + + _mesa_TexImage2D(target, level, internalFormat, width, height, border, format, type, pixels); +} + +extern void GL_APIENTRY _mesa_TexParameterf(GLenum target, GLenum pname, GLfloat param); +static void GL_APIENTRY _es_TexParameterf(GLenum target, GLenum pname, GLfloat param) +{ + switch(target) { + case GL_TEXTURE_2D: + case GL_TEXTURE_CUBE_MAP_OES: + break; + default: + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glTexParameterf(target=0x%x)", target); + return; + } + switch(pname) { + case GL_TEXTURE_WRAP_S: + case GL_TEXTURE_WRAP_T: + if (param != GL_CLAMP_TO_EDGE && param != GL_REPEAT && param != GL_MIRRORED_REPEAT_OES) { + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glTexParameterf(pname=0x%x)", pname); + return; + } + break; + case GL_TEXTURE_MIN_FILTER: + if (param != GL_NEAREST && param != GL_LINEAR && param != GL_NEAREST_MIPMAP_NEAREST && param != GL_NEAREST_MIPMAP_LINEAR && param != GL_LINEAR_MIPMAP_NEAREST && param != GL_LINEAR_MIPMAP_LINEAR) { + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glTexParameterf(pname=0x%x)", pname); + return; + } + break; + case GL_TEXTURE_MAG_FILTER: + if (param != GL_NEAREST && param != GL_LINEAR) { + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glTexParameterf(pname=0x%x)", pname); + return; + } + break; + case GL_GENERATE_MIPMAP: + if (param != GL_TRUE && param != GL_FALSE) { + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glTexParameterf(pname=0x%x)", pname); + return; + } + break; + case GL_TEXTURE_MAX_ANISOTROPY_EXT: + break; + default: + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glTexParameterf(pname=0x%x)", pname); + return; + } + + _mesa_TexParameterf(target, pname, param); +} + +extern void GL_APIENTRY _mesa_TexParameterfv(GLenum target, GLenum pname, const GLfloat * params); +static void GL_APIENTRY _es_TexParameterfv(GLenum target, GLenum pname, const GLfloat *params) +{ + switch(target) { + case GL_TEXTURE_2D: + case GL_TEXTURE_CUBE_MAP_OES: + break; + default: + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glTexParameterfv(target=0x%x)", target); + return; + } + switch(pname) { + case GL_TEXTURE_WRAP_S: /* size 1 */ + case GL_TEXTURE_WRAP_T: /* size 1 */ + if (params[0] != GL_CLAMP_TO_EDGE && params[0] != GL_REPEAT && params[0] != GL_MIRRORED_REPEAT_OES) { + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glTexParameterfv(pname=0x%x)", pname); + return; + } + break; + case GL_TEXTURE_MIN_FILTER: /* size 1 */ + if (params[0] != GL_NEAREST && params[0] != GL_LINEAR && params[0] != GL_NEAREST_MIPMAP_NEAREST && params[0] != GL_NEAREST_MIPMAP_LINEAR && params[0] != GL_LINEAR_MIPMAP_NEAREST && params[0] != GL_LINEAR_MIPMAP_LINEAR) { + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glTexParameterfv(pname=0x%x)", pname); + return; + } + break; + case GL_TEXTURE_MAG_FILTER: /* size 1 */ + if (params[0] != GL_NEAREST && params[0] != GL_LINEAR) { + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glTexParameterfv(pname=0x%x)", pname); + return; + } + break; + case GL_GENERATE_MIPMAP: /* size 1 */ + if (params[0] != GL_TRUE && params[0] != GL_FALSE) { + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glTexParameterfv(pname=0x%x)", pname); + return; + } + break; + case GL_TEXTURE_MAX_ANISOTROPY_EXT: /* size 1 */ + case GL_TEXTURE_CROP_RECT_OES: /* size 4 */ + break; + default: + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glTexParameterfv(pname=0x%x)", pname); + return; + } + + _mesa_TexParameterfv(target, pname, params); +} + +extern void GL_APIENTRY _mesa_TexParameteri(GLenum target, GLenum pname, GLint param); +static void GL_APIENTRY _es_TexParameteri(GLenum target, GLenum pname, GLint param) +{ + switch(target) { + case GL_TEXTURE_2D: + case GL_TEXTURE_CUBE_MAP_OES: + break; + default: + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glTexParameteri(target=0x%x)", target); + return; + } + switch(pname) { + case GL_TEXTURE_WRAP_S: + case GL_TEXTURE_WRAP_T: + if (param != GL_CLAMP_TO_EDGE && param != GL_REPEAT && param != GL_MIRRORED_REPEAT_OES) { + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glTexParameteri(pname=0x%x)", pname); + return; + } + break; + case GL_TEXTURE_MIN_FILTER: + if (param != GL_NEAREST && param != GL_LINEAR && param != GL_NEAREST_MIPMAP_NEAREST && param != GL_NEAREST_MIPMAP_LINEAR && param != GL_LINEAR_MIPMAP_NEAREST && param != GL_LINEAR_MIPMAP_LINEAR) { + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glTexParameteri(pname=0x%x)", pname); + return; + } + break; + case GL_TEXTURE_MAG_FILTER: + if (param != GL_NEAREST && param != GL_LINEAR) { + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glTexParameteri(pname=0x%x)", pname); + return; + } + break; + case GL_GENERATE_MIPMAP: + if (param != GL_TRUE && param != GL_FALSE) { + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glTexParameteri(pname=0x%x)", pname); + return; + } + break; + case GL_TEXTURE_MAX_ANISOTROPY_EXT: + break; + default: + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glTexParameteri(pname=0x%x)", pname); + return; + } + + _mesa_TexParameteri(target, pname, param); +} + +extern void GL_APIENTRY _mesa_TexParameteriv(GLenum target, GLenum pname, const GLint * params); +static void GL_APIENTRY _es_TexParameteriv(GLenum target, GLenum pname, const GLint *params) +{ + switch(target) { + case GL_TEXTURE_2D: + case GL_TEXTURE_CUBE_MAP_OES: + break; + default: + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glTexParameteriv(target=0x%x)", target); + return; + } + switch(pname) { + case GL_TEXTURE_WRAP_S: /* size 1 */ + case GL_TEXTURE_WRAP_T: /* size 1 */ + if (params[0] != GL_CLAMP_TO_EDGE && params[0] != GL_REPEAT && params[0] != GL_MIRRORED_REPEAT_OES) { + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glTexParameteriv(pname=0x%x)", pname); + return; + } + break; + case GL_TEXTURE_MIN_FILTER: /* size 1 */ + if (params[0] != GL_NEAREST && params[0] != GL_LINEAR && params[0] != GL_NEAREST_MIPMAP_NEAREST && params[0] != GL_NEAREST_MIPMAP_LINEAR && params[0] != GL_LINEAR_MIPMAP_NEAREST && params[0] != GL_LINEAR_MIPMAP_LINEAR) { + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glTexParameteriv(pname=0x%x)", pname); + return; + } + break; + case GL_TEXTURE_MAG_FILTER: /* size 1 */ + if (params[0] != GL_NEAREST && params[0] != GL_LINEAR) { + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glTexParameteriv(pname=0x%x)", pname); + return; + } + break; + case GL_GENERATE_MIPMAP: /* size 1 */ + if (params[0] != GL_TRUE && params[0] != GL_FALSE) { + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glTexParameteriv(pname=0x%x)", pname); + return; + } + break; + case GL_TEXTURE_MAX_ANISOTROPY_EXT: /* size 1 */ + case GL_TEXTURE_CROP_RECT_OES: /* size 4 */ + break; + default: + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glTexParameteriv(pname=0x%x)", pname); + return; + } + + _mesa_TexParameteriv(target, pname, params); +} + +extern void GL_APIENTRY _mesa_TexParameterf(GLenum target, GLenum pname, GLfloat param); +static void GL_APIENTRY _es_TexParameterx(GLenum target, GLenum pname, GLfixed param) +{ + GLfloat converted_param; + int convert_param_value = 1; + + switch(target) { + case GL_TEXTURE_2D: + case GL_TEXTURE_CUBE_MAP_OES: + break; + default: + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glTexParameterx(target=0x%x)", target); + return; + } + switch(pname) { + case GL_TEXTURE_WRAP_S: + case GL_TEXTURE_WRAP_T: + if (param != GL_CLAMP_TO_EDGE && param != GL_REPEAT && param != GL_MIRRORED_REPEAT_OES) { + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glTexParameterx(pname=0x%x)", pname); + return; + } + convert_param_value = 0; + break; + case GL_TEXTURE_MIN_FILTER: + if (param != GL_NEAREST && param != GL_LINEAR && param != GL_NEAREST_MIPMAP_NEAREST && param != GL_NEAREST_MIPMAP_LINEAR && param != GL_LINEAR_MIPMAP_NEAREST && param != GL_LINEAR_MIPMAP_LINEAR) { + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glTexParameterx(pname=0x%x)", pname); + return; + } + convert_param_value = 0; + break; + case GL_TEXTURE_MAG_FILTER: + if (param != GL_NEAREST && param != GL_LINEAR) { + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glTexParameterx(pname=0x%x)", pname); + return; + } + convert_param_value = 0; + break; + case GL_GENERATE_MIPMAP: + if (param != GL_TRUE && param != GL_FALSE) { + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glTexParameterx(pname=0x%x)", pname); + return; + } + convert_param_value = 0; + break; + case GL_TEXTURE_MAX_ANISOTROPY_EXT: + break; + default: + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glTexParameterx(pname=0x%x)", pname); + return; + } + + if (convert_param_value) { + converted_param = (GLfloat) (param / 65536.0f); + } else { + converted_param = (GLfloat) param; + } + + _mesa_TexParameterf(target, pname, converted_param); +} + +extern void GL_APIENTRY _mesa_TexParameterfv(GLenum target, GLenum pname, GLfloat const * params); +static void GL_APIENTRY _es_TexParameterxv(GLenum target, GLenum pname, const GLfixed *params) +{ + register unsigned int i; + unsigned int n_params = 4; + GLfloat converted_params[4]; + int convert_params_value = 1; + + switch(target) { + case GL_TEXTURE_2D: + case GL_TEXTURE_CUBE_MAP_OES: + break; + default: + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glTexParameterxv(target=0x%x)", target); + return; + } + switch(pname) { + case GL_TEXTURE_WRAP_S: + case GL_TEXTURE_WRAP_T: + if (params[0] != GL_CLAMP_TO_EDGE && params[0] != GL_REPEAT && params[0] != GL_MIRRORED_REPEAT_OES) { + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glTexParameterxv(pname=0x%x)", pname); + return; + } + convert_params_value = 0; + n_params = 1; + break; + case GL_TEXTURE_MIN_FILTER: + if (params[0] != GL_NEAREST && params[0] != GL_LINEAR && params[0] != GL_NEAREST_MIPMAP_NEAREST && params[0] != GL_NEAREST_MIPMAP_LINEAR && params[0] != GL_LINEAR_MIPMAP_NEAREST && params[0] != GL_LINEAR_MIPMAP_LINEAR) { + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glTexParameterxv(pname=0x%x)", pname); + return; + } + convert_params_value = 0; + n_params = 1; + break; + case GL_TEXTURE_MAG_FILTER: + if (params[0] != GL_NEAREST && params[0] != GL_LINEAR) { + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glTexParameterxv(pname=0x%x)", pname); + return; + } + convert_params_value = 0; + n_params = 1; + break; + case GL_GENERATE_MIPMAP: + if (params[0] != GL_TRUE && params[0] != GL_FALSE) { + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glTexParameterxv(pname=0x%x)", pname); + return; + } + convert_params_value = 0; + n_params = 1; + break; + case GL_TEXTURE_MAX_ANISOTROPY_EXT: + n_params = 1; + break; + case GL_TEXTURE_CROP_RECT_OES: + n_params = 4; + break; + default: + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glTexParameterxv(pname=0x%x)", pname); + return; + } + + if (convert_params_value) { + for (i = 0; i < n_params; i++) { + converted_params[i] = (GLfloat) (params[i] / 65536.0f); + } + } else { + for (i = 0; i < n_params; i++) { + converted_params[i] = (GLfloat) params[i]; + } + } + + _mesa_TexParameterfv(target, pname, converted_params); +} + +extern void GL_APIENTRY _mesa_TexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid * pixels); +static void GL_APIENTRY _es_TexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *pixels) +{ + switch(target) { + case GL_TEXTURE_2D: + case GL_TEXTURE_CUBE_MAP_POSITIVE_X_OES: + case GL_TEXTURE_CUBE_MAP_POSITIVE_Y_OES: + case GL_TEXTURE_CUBE_MAP_POSITIVE_Z_OES: + case GL_TEXTURE_CUBE_MAP_NEGATIVE_X_OES: + case GL_TEXTURE_CUBE_MAP_NEGATIVE_Y_OES: + case GL_TEXTURE_CUBE_MAP_NEGATIVE_Z_OES: + break; + default: + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glTexSubImage2D(target=0x%x)", target); + return; + } + switch(format) { + case GL_ALPHA: + if (type != GL_UNSIGNED_BYTE) { + _mesa_error(_mesa_get_current_context(), GL_INVALID_OPERATION, "glTexSubImage2D(format=0x%x)", format); + return; + } + break; + case GL_RGB: + if (type != GL_UNSIGNED_BYTE && type != GL_UNSIGNED_SHORT_5_6_5) { + _mesa_error(_mesa_get_current_context(), GL_INVALID_OPERATION, "glTexSubImage2D(format=0x%x)", format); + return; + } + break; + case GL_RGBA: + if (type != GL_UNSIGNED_BYTE && type != GL_UNSIGNED_SHORT_4_4_4_4 && type != GL_UNSIGNED_SHORT_5_5_5_1) { + _mesa_error(_mesa_get_current_context(), GL_INVALID_OPERATION, "glTexSubImage2D(format=0x%x)", format); + return; + } + break; + case GL_LUMINANCE: + case GL_LUMINANCE_ALPHA: + if (type != GL_UNSIGNED_BYTE) { + _mesa_error(_mesa_get_current_context(), GL_INVALID_OPERATION, "glTexSubImage2D(format=0x%x)", format); + return; + } + break; + default: + _mesa_error(_mesa_get_current_context(), GL_INVALID_OPERATION, "glTexSubImage2D(format=0x%x)", format); + return; + } + + _mesa_TexSubImage2D(target, level, xoffset, yoffset, width, height, format, type, pixels); +} + +extern void GL_APIENTRY _mesa_Translatef(GLfloat x, GLfloat y, GLfloat z); +#define _es_Translatef _mesa_Translatef + +extern void GL_APIENTRY _mesa_Translatef(GLfloat x, GLfloat y, GLfloat z); +static void GL_APIENTRY _es_Translatex(GLfixed x, GLfixed y, GLfixed z) +{ + GLfloat converted_x; + GLfloat converted_y; + GLfloat converted_z; + + converted_x = (GLfloat) (x / 65536.0f); + converted_y = (GLfloat) (y / 65536.0f); + converted_z = (GLfloat) (z / 65536.0f); + + _mesa_Translatef(converted_x, converted_y, converted_z); +} + +extern GLboolean GL_APIENTRY _mesa_UnmapBufferARB(GLenum target); +static GLboolean GL_APIENTRY _es_UnmapBufferOES(GLenum target) +{ + switch(target) { + case GL_ARRAY_BUFFER: + case GL_ELEMENT_ARRAY_BUFFER: + break; + default: + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glUnmapBufferOES(target=0x%x)", target); + return GL_FALSE; + } + + return _mesa_UnmapBufferARB(target); +} + +extern void GL_APIENTRY _mesa_VertexPointer(GLint size, GLenum type, GLsizei stride, const GLvoid * pointer); +static void GL_APIENTRY _es_VertexPointer(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer) +{ + switch(size) { + case 2: + case 3: + case 4: + break; + default: + _mesa_error(_mesa_get_current_context(), GL_INVALID_VALUE, "glVertexPointer(size=%d)", size); + return; + } + switch(type) { + case GL_BYTE: + case GL_SHORT: + case GL_FLOAT: + case GL_FIXED: + break; + default: + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glVertexPointer(type=0x%x)", type); + return; + } + + _mesa_VertexPointer(size, type, stride, pointer); +} + +extern void GL_APIENTRY _mesa_Viewport(GLint x, GLint y, GLsizei width, GLsizei height); +#define _es_Viewport _mesa_Viewport + + +#include "glapi/glapi.h" + +#if FEATURE_remap_table + +/* cannot include main/dispatch.h here */ +#define _GLAPI_USE_REMAP_TABLE +#include "es1api/main/glapidispatch.h" + +#define need_MESA_remap_table +#include "es1api/main/remap_helper.h" + +/* force SET_* macros to use the local remap table */ +#define driDispatchRemapTable remap_table +static int remap_table[driDispatchRemapTable_size]; + +static void +init_remap_table(void) +{ + _glthread_DECLARE_STATIC_MUTEX(mutex); + static GLboolean initialized = GL_FALSE; + const struct gl_function_pool_remap *remap = MESA_remap_table_functions; + int i; + + _glthread_LOCK_MUTEX(mutex); + if (initialized) { + _glthread_UNLOCK_MUTEX(mutex); + return; + } + + for (i = 0; i < driDispatchRemapTable_size; i++) { + GLint offset; + const char *spec; + + /* sanity check */ + ASSERT(i == remap[i].remap_index); + spec = _mesa_function_pool + remap[i].pool_index; + + offset = _mesa_map_function_spec(spec); + remap_table[i] = offset; + } + initialized = GL_TRUE; + _glthread_UNLOCK_MUTEX(mutex); +} + +#else /* FEATURE_remap_table */ + +/* cannot include main/dispatch.h here */ +#include "es1api/main/glapidispatch.h" + +static INLINE void +init_remap_table(void) +{ +} + +#endif /* FEATURE_remap_table */ + +struct _glapi_table * +_mesa_create_exec_table_es1(void) +{ + struct _glapi_table *exec; + + exec = _mesa_alloc_dispatch_table(_gloffset_COUNT); + if (exec == NULL) + return NULL; + + init_remap_table(); + + SET_ActiveTexture(exec, _es_ActiveTexture); + SET_AlphaFunc(exec, _es_AlphaFunc); + SET_AlphaFuncx(exec, _es_AlphaFuncx); + SET_BindBuffer(exec, _es_BindBuffer); + SET_BindFramebufferOES(exec, _es_BindFramebufferOES); + SET_BindRenderbufferOES(exec, _es_BindRenderbufferOES); + SET_BindTexture(exec, _es_BindTexture); + SET_BlendEquationOES(exec, _es_BlendEquationOES); + SET_BlendEquationSeparateOES(exec, _es_BlendEquationSeparateOES); + SET_BlendFunc(exec, _es_BlendFunc); + SET_BlendFuncSeparateOES(exec, _es_BlendFuncSeparateOES); + SET_BufferData(exec, _es_BufferData); + SET_BufferSubData(exec, _es_BufferSubData); + SET_CheckFramebufferStatusOES(exec, _es_CheckFramebufferStatusOES); + SET_Clear(exec, _es_Clear); + SET_ClearColor(exec, _es_ClearColor); + SET_ClearColorx(exec, _es_ClearColorx); + SET_ClearDepthf(exec, _es_ClearDepthf); + SET_ClearDepthx(exec, _es_ClearDepthx); + SET_ClearStencil(exec, _es_ClearStencil); + SET_ClientActiveTexture(exec, _es_ClientActiveTexture); + SET_ClipPlanef(exec, _es_ClipPlanef); + SET_ClipPlanex(exec, _es_ClipPlanex); + SET_Color4f(exec, _check_Color4f); + SET_Color4ub(exec, _es_Color4ub); + SET_Color4x(exec, _es_Color4x); + SET_ColorMask(exec, _es_ColorMask); + SET_ColorPointer(exec, _es_ColorPointer); + SET_CompressedTexImage2D(exec, _es_CompressedTexImage2D); + SET_CompressedTexSubImage2D(exec, _es_CompressedTexSubImage2D); + SET_CopyTexImage2D(exec, _es_CopyTexImage2D); + SET_CopyTexSubImage2D(exec, _es_CopyTexSubImage2D); + SET_CullFace(exec, _es_CullFace); + SET_DeleteBuffers(exec, _es_DeleteBuffers); + SET_DeleteFramebuffersOES(exec, _es_DeleteFramebuffersOES); + SET_DeleteRenderbuffersOES(exec, _es_DeleteRenderbuffersOES); + SET_DeleteTextures(exec, _es_DeleteTextures); + SET_DepthFunc(exec, _es_DepthFunc); + SET_DepthMask(exec, _es_DepthMask); + SET_DepthRangef(exec, _es_DepthRangef); + SET_DepthRangex(exec, _es_DepthRangex); + SET_Disable(exec, _es_Disable); + SET_DisableClientState(exec, _es_DisableClientState); + SET_DrawArrays(exec, _es_DrawArrays); + SET_DrawElements(exec, _es_DrawElements); + SET_DrawTexfOES(exec, _es_DrawTexfOES); + SET_DrawTexfvOES(exec, _es_DrawTexfvOES); + SET_DrawTexiOES(exec, _es_DrawTexiOES); + SET_DrawTexivOES(exec, _es_DrawTexivOES); + SET_DrawTexsOES(exec, _es_DrawTexsOES); + SET_DrawTexsvOES(exec, _es_DrawTexsvOES); + SET_DrawTexxOES(exec, _es_DrawTexxOES); + SET_DrawTexxvOES(exec, _es_DrawTexxvOES); + SET_EGLImageTargetRenderbufferStorageOES(exec, _es_EGLImageTargetRenderbufferStorageOES); + SET_EGLImageTargetTexture2DOES(exec, _es_EGLImageTargetTexture2DOES); + SET_Enable(exec, _es_Enable); + SET_EnableClientState(exec, _es_EnableClientState); + SET_Finish(exec, _es_Finish); + SET_Flush(exec, _es_Flush); + SET_Fogf(exec, _es_Fogf); + SET_Fogfv(exec, _es_Fogfv); + SET_Fogx(exec, _es_Fogx); + SET_Fogxv(exec, _es_Fogxv); + SET_FramebufferRenderbufferOES(exec, _es_FramebufferRenderbufferOES); + SET_FramebufferTexture2DOES(exec, _es_FramebufferTexture2DOES); + SET_FrontFace(exec, _es_FrontFace); + SET_Frustumf(exec, _es_Frustumf); + SET_Frustumx(exec, _es_Frustumx); + SET_GenBuffers(exec, _es_GenBuffers); + SET_GenFramebuffersOES(exec, _es_GenFramebuffersOES); + SET_GenRenderbuffersOES(exec, _es_GenRenderbuffersOES); + SET_GenTextures(exec, _es_GenTextures); + SET_GenerateMipmapOES(exec, _es_GenerateMipmapOES); + SET_GetBooleanv(exec, _es_GetBooleanv); + SET_GetBufferParameteriv(exec, _es_GetBufferParameteriv); + SET_GetBufferPointervOES(exec, _es_GetBufferPointervOES); + SET_GetClipPlanef(exec, _es_GetClipPlanef); + SET_GetClipPlanex(exec, _es_GetClipPlanex); + SET_GetError(exec, _es_GetError); + SET_GetFixedv(exec, _es_GetFixedv); + SET_GetFloatv(exec, _es_GetFloatv); + SET_GetFramebufferAttachmentParameterivOES(exec, _es_GetFramebufferAttachmentParameterivOES); + SET_GetIntegerv(exec, _es_GetIntegerv); + SET_GetLightfv(exec, _es_GetLightfv); + SET_GetLightxv(exec, _es_GetLightxv); + SET_GetMaterialfv(exec, _es_GetMaterialfv); + SET_GetMaterialxv(exec, _es_GetMaterialxv); + SET_GetPointerv(exec, _es_GetPointerv); + SET_GetRenderbufferParameterivOES(exec, _es_GetRenderbufferParameterivOES); + SET_GetString(exec, _es_GetString); + SET_GetTexEnvfv(exec, _es_GetTexEnvfv); + SET_GetTexEnviv(exec, _es_GetTexEnviv); + SET_GetTexEnvxv(exec, _es_GetTexEnvxv); + SET_GetTexGenfvOES(exec, _check_GetTexGenfvOES); + SET_GetTexGenivOES(exec, _check_GetTexGenivOES); + SET_GetTexGenxvOES(exec, _check_GetTexGenxvOES); + SET_GetTexParameterfv(exec, _es_GetTexParameterfv); + SET_GetTexParameteriv(exec, _es_GetTexParameteriv); + SET_GetTexParameterxv(exec, _es_GetTexParameterxv); + SET_Hint(exec, _es_Hint); + SET_IsBuffer(exec, _es_IsBuffer); + SET_IsEnabled(exec, _es_IsEnabled); + SET_IsFramebufferOES(exec, _es_IsFramebufferOES); + SET_IsRenderbufferOES(exec, _es_IsRenderbufferOES); + SET_IsTexture(exec, _es_IsTexture); + SET_LightModelf(exec, _es_LightModelf); + SET_LightModelfv(exec, _es_LightModelfv); + SET_LightModelx(exec, _es_LightModelx); + SET_LightModelxv(exec, _es_LightModelxv); + SET_Lightf(exec, _es_Lightf); + SET_Lightfv(exec, _es_Lightfv); + SET_Lightx(exec, _es_Lightx); + SET_Lightxv(exec, _es_Lightxv); + SET_LineWidth(exec, _es_LineWidth); + SET_LineWidthx(exec, _es_LineWidthx); + SET_LoadIdentity(exec, _es_LoadIdentity); + SET_LoadMatrixf(exec, _es_LoadMatrixf); + SET_LoadMatrixx(exec, _es_LoadMatrixx); + SET_LogicOp(exec, _es_LogicOp); + SET_MapBufferOES(exec, _es_MapBufferOES); + SET_Materialf(exec, _check_Materialf); + SET_Materialfv(exec, _check_Materialfv); + SET_Materialx(exec, _es_Materialx); + SET_Materialxv(exec, _es_Materialxv); + SET_MatrixMode(exec, _es_MatrixMode); + SET_MultMatrixf(exec, _es_MultMatrixf); + SET_MultMatrixx(exec, _es_MultMatrixx); + SET_MultiDrawArraysEXT(exec, _es_MultiDrawArraysEXT); + SET_MultiDrawElementsEXT(exec, _es_MultiDrawElementsEXT); + SET_MultiTexCoord4f(exec, _check_MultiTexCoord4f); + SET_MultiTexCoord4x(exec, _es_MultiTexCoord4x); + SET_Normal3f(exec, _check_Normal3f); + SET_Normal3x(exec, _es_Normal3x); + SET_NormalPointer(exec, _es_NormalPointer); + SET_Orthof(exec, _es_Orthof); + SET_Orthox(exec, _es_Orthox); + SET_PixelStorei(exec, _es_PixelStorei); + SET_PointParameterf(exec, _es_PointParameterf); + SET_PointParameterfv(exec, _es_PointParameterfv); + SET_PointParameterx(exec, _es_PointParameterx); + SET_PointParameterxv(exec, _es_PointParameterxv); + SET_PointSize(exec, _es_PointSize); + SET_PointSizePointerOES(exec, _es_PointSizePointerOES); + SET_PointSizex(exec, _es_PointSizex); + SET_PolygonOffset(exec, _es_PolygonOffset); + SET_PolygonOffsetx(exec, _es_PolygonOffsetx); + SET_PopMatrix(exec, _es_PopMatrix); + SET_PushMatrix(exec, _es_PushMatrix); + SET_QueryMatrixxOES(exec, _check_QueryMatrixxOES); + SET_ReadPixels(exec, _es_ReadPixels); + SET_RenderbufferStorageOES(exec, _check_RenderbufferStorageOES); + SET_Rotatef(exec, _es_Rotatef); + SET_Rotatex(exec, _es_Rotatex); + SET_SampleCoverage(exec, _es_SampleCoverage); + SET_SampleCoveragex(exec, _es_SampleCoveragex); + SET_Scalef(exec, _es_Scalef); + SET_Scalex(exec, _es_Scalex); + SET_Scissor(exec, _es_Scissor); + SET_ShadeModel(exec, _es_ShadeModel); + SET_StencilFunc(exec, _es_StencilFunc); + SET_StencilMask(exec, _es_StencilMask); + SET_StencilOp(exec, _es_StencilOp); + SET_TexCoordPointer(exec, _es_TexCoordPointer); + SET_TexEnvf(exec, _es_TexEnvf); + SET_TexEnvfv(exec, _es_TexEnvfv); + SET_TexEnvi(exec, _es_TexEnvi); + SET_TexEnviv(exec, _es_TexEnviv); + SET_TexEnvx(exec, _es_TexEnvx); + SET_TexEnvxv(exec, _es_TexEnvxv); + SET_TexGenfOES(exec, _check_TexGenfOES); + SET_TexGenfvOES(exec, _check_TexGenfvOES); + SET_TexGeniOES(exec, _check_TexGeniOES); + SET_TexGenivOES(exec, _check_TexGenivOES); + SET_TexGenxOES(exec, _check_TexGenxOES); + SET_TexGenxvOES(exec, _check_TexGenxvOES); + SET_TexImage2D(exec, _es_TexImage2D); + SET_TexParameterf(exec, _es_TexParameterf); + SET_TexParameterfv(exec, _es_TexParameterfv); + SET_TexParameteri(exec, _es_TexParameteri); + SET_TexParameteriv(exec, _es_TexParameteriv); + SET_TexParameterx(exec, _es_TexParameterx); + SET_TexParameterxv(exec, _es_TexParameterxv); + SET_TexSubImage2D(exec, _es_TexSubImage2D); + SET_Translatef(exec, _es_Translatef); + SET_Translatex(exec, _es_Translatex); + SET_UnmapBufferOES(exec, _es_UnmapBufferOES); + SET_VertexPointer(exec, _es_VertexPointer); + SET_Viewport(exec, _es_Viewport); + + return exec; +} + +#endif /* FEATURE_ES1 */ diff --git a/src/mesa/main/api_exec_es2.c b/src/mesa/main/api_exec_es2.c new file mode 100644 index 00000000000..e706bc2c322 --- /dev/null +++ b/src/mesa/main/api_exec_es2.c @@ -0,0 +1,2519 @@ +/* DO NOT EDIT ************************************************* + * THIS FILE AUTOMATICALLY GENERATED BY THE es_generator.py SCRIPT + * API specification file: main/APIspec.xml + * GLES version: GLES2.0 + * date: 2010-12-09 17:05:11 + */ + + +#include "GLES2/gl2.h" +#include "GLES2/gl2ext.h" +#include "main/mfeatures.h" +#include "main/compiler.h" +#include "main/api_exec.h" + +#if FEATURE_ES2 + + +/* These types are needed for the Mesa veneer, but are not defined in + * the standard GLES headers. + */ +typedef double GLdouble; +typedef double GLclampd; + +/* Mesa error handling requires these */ +extern void *_mesa_get_current_context(void); +extern void _mesa_error(void *ctx, GLenum error, const char *fmtString, ... ); + +/************************************************************* + * Generated functions begin here + */ + +extern void GL_APIENTRY _mesa_ActiveTextureARB(GLenum texture); +static void GL_APIENTRY _es_ActiveTexture(GLenum texture) +{ + switch(texture) { + case GL_TEXTURE0: + case GL_TEXTURE1: + case GL_TEXTURE2: + case GL_TEXTURE3: + case GL_TEXTURE4: + case GL_TEXTURE5: + case GL_TEXTURE6: + case GL_TEXTURE7: + case GL_TEXTURE8: + case GL_TEXTURE9: + case GL_TEXTURE10: + case GL_TEXTURE11: + case GL_TEXTURE12: + case GL_TEXTURE13: + case GL_TEXTURE14: + case GL_TEXTURE15: + case GL_TEXTURE16: + case GL_TEXTURE17: + case GL_TEXTURE18: + case GL_TEXTURE19: + case GL_TEXTURE20: + case GL_TEXTURE21: + case GL_TEXTURE22: + case GL_TEXTURE23: + case GL_TEXTURE24: + case GL_TEXTURE25: + case GL_TEXTURE26: + case GL_TEXTURE27: + case GL_TEXTURE28: + case GL_TEXTURE29: + case GL_TEXTURE30: + case GL_TEXTURE31: + break; + default: + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glActiveTexture(texture=0x%x)", texture); + return; + } + + _mesa_ActiveTextureARB(texture); +} + +extern void GL_APIENTRY _mesa_AttachShader(GLuint program, GLuint shader); +#define _es_AttachShader _mesa_AttachShader + +extern void GL_APIENTRY _mesa_BindAttribLocationARB(GLuint program, GLuint index, const char * name); +#define _es_BindAttribLocation _mesa_BindAttribLocationARB + +extern void GL_APIENTRY _mesa_BindBufferARB(GLenum target, GLuint buffer); +static void GL_APIENTRY _es_BindBuffer(GLenum target, GLuint buffer) +{ + switch(target) { + case GL_ARRAY_BUFFER: + case GL_ELEMENT_ARRAY_BUFFER: + break; + default: + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glBindBuffer(target=0x%x)", target); + return; + } + + _mesa_BindBufferARB(target, buffer); +} + +extern void GL_APIENTRY _mesa_BindFramebufferEXT(GLenum target, GLuint framebuffer); +static void GL_APIENTRY _es_BindFramebuffer(GLenum target, GLuint framebuffer) +{ + switch(target) { + case GL_FRAMEBUFFER: + break; + default: + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glBindFramebuffer(target=0x%x)", target); + return; + } + + _mesa_BindFramebufferEXT(target, framebuffer); +} + +extern void GL_APIENTRY _mesa_BindRenderbufferEXT(GLenum target, GLuint renderbuffer); +static void GL_APIENTRY _es_BindRenderbuffer(GLenum target, GLuint renderbuffer) +{ + switch(target) { + case GL_RENDERBUFFER: + break; + default: + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glBindRenderbuffer(target=0x%x)", target); + return; + } + + _mesa_BindRenderbufferEXT(target, renderbuffer); +} + +extern void GL_APIENTRY _mesa_BindTexture(GLenum target, GLuint texture); +static void GL_APIENTRY _es_BindTexture(GLenum target, GLuint texture) +{ + switch(target) { + case GL_TEXTURE_2D: + case GL_TEXTURE_CUBE_MAP: + case GL_TEXTURE_3D_OES: + break; + default: + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glBindTexture(target=0x%x)", target); + return; + } + + _mesa_BindTexture(target, texture); +} + +extern void GL_APIENTRY _mesa_BlendColor(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha); +#define _es_BlendColor _mesa_BlendColor + +extern void GL_APIENTRY _mesa_BlendEquation(GLenum mode); +static void GL_APIENTRY _es_BlendEquation(GLenum mode) +{ + switch(mode) { + case GL_FUNC_ADD: + case GL_FUNC_SUBTRACT: + case GL_FUNC_REVERSE_SUBTRACT: + case GL_MIN_EXT: + case GL_MAX_EXT: + break; + default: + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glBlendEquation(mode=0x%x)", mode); + return; + } + + _mesa_BlendEquation(mode); +} + +extern void GL_APIENTRY _mesa_BlendEquationSeparateEXT(GLenum modeRGB, GLenum modeAlpha); +static void GL_APIENTRY _es_BlendEquationSeparate(GLenum modeRGB, GLenum modeAlpha) +{ + switch(modeRGB) { + case GL_FUNC_ADD: + case GL_FUNC_SUBTRACT: + case GL_FUNC_REVERSE_SUBTRACT: + case GL_MIN_EXT: + case GL_MAX_EXT: + break; + default: + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glBlendEquationSeparate(modeRGB=0x%x)", modeRGB); + return; + } + switch(modeAlpha) { + case GL_FUNC_ADD: + case GL_FUNC_SUBTRACT: + case GL_FUNC_REVERSE_SUBTRACT: + case GL_MIN_EXT: + case GL_MAX_EXT: + break; + default: + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glBlendEquationSeparate(modeAlpha=0x%x)", modeAlpha); + return; + } + + _mesa_BlendEquationSeparateEXT(modeRGB, modeAlpha); +} + +extern void GL_APIENTRY _mesa_BlendFunc(GLenum sfactor, GLenum dfactor); +static void GL_APIENTRY _es_BlendFunc(GLenum sfactor, GLenum dfactor) +{ + switch(sfactor) { + case GL_ZERO: + case GL_ONE: + case GL_SRC_COLOR: + case GL_ONE_MINUS_SRC_COLOR: + case GL_SRC_ALPHA: + case GL_ONE_MINUS_SRC_ALPHA: + case GL_DST_ALPHA: + case GL_ONE_MINUS_DST_ALPHA: + case GL_DST_COLOR: + case GL_ONE_MINUS_DST_COLOR: + case GL_SRC_ALPHA_SATURATE: + case GL_CONSTANT_COLOR: + case GL_CONSTANT_ALPHA: + case GL_ONE_MINUS_CONSTANT_COLOR: + case GL_ONE_MINUS_CONSTANT_ALPHA: + break; + default: + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glBlendFunc(sfactor=0x%x)", sfactor); + return; + } + switch(dfactor) { + case GL_ZERO: + case GL_ONE: + case GL_SRC_COLOR: + case GL_ONE_MINUS_SRC_COLOR: + case GL_SRC_ALPHA: + case GL_ONE_MINUS_SRC_ALPHA: + case GL_DST_ALPHA: + case GL_ONE_MINUS_DST_ALPHA: + case GL_DST_COLOR: + case GL_ONE_MINUS_DST_COLOR: + case GL_CONSTANT_COLOR: + case GL_CONSTANT_ALPHA: + case GL_ONE_MINUS_CONSTANT_COLOR: + case GL_ONE_MINUS_CONSTANT_ALPHA: + break; + default: + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glBlendFunc(dfactor=0x%x)", dfactor); + return; + } + + _mesa_BlendFunc(sfactor, dfactor); +} + +extern void GL_APIENTRY _mesa_BlendFuncSeparateEXT(GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha, GLenum dstAlpha); +static void GL_APIENTRY _es_BlendFuncSeparate(GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha, GLenum dstAlpha) +{ + switch(srcRGB) { + case GL_ZERO: + case GL_ONE: + case GL_SRC_COLOR: + case GL_ONE_MINUS_SRC_COLOR: + case GL_SRC_ALPHA: + case GL_ONE_MINUS_SRC_ALPHA: + case GL_DST_ALPHA: + case GL_ONE_MINUS_DST_ALPHA: + case GL_DST_COLOR: + case GL_ONE_MINUS_DST_COLOR: + case GL_SRC_ALPHA_SATURATE: + case GL_CONSTANT_COLOR: + case GL_ONE_MINUS_CONSTANT_COLOR: + case GL_CONSTANT_ALPHA: + case GL_ONE_MINUS_CONSTANT_ALPHA: + break; + default: + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glBlendFuncSeparate(srcRGB=0x%x)", srcRGB); + return; + } + switch(dstRGB) { + case GL_ZERO: + case GL_ONE: + case GL_SRC_COLOR: + case GL_ONE_MINUS_SRC_COLOR: + case GL_SRC_ALPHA: + case GL_ONE_MINUS_SRC_ALPHA: + case GL_DST_ALPHA: + case GL_ONE_MINUS_DST_ALPHA: + case GL_DST_COLOR: + case GL_ONE_MINUS_DST_COLOR: + case GL_CONSTANT_COLOR: + case GL_ONE_MINUS_CONSTANT_COLOR: + case GL_CONSTANT_ALPHA: + case GL_ONE_MINUS_CONSTANT_ALPHA: + break; + default: + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glBlendFuncSeparate(dstRGB=0x%x)", dstRGB); + return; + } + switch(srcAlpha) { + case GL_ZERO: + case GL_ONE: + case GL_SRC_COLOR: + case GL_ONE_MINUS_SRC_COLOR: + case GL_SRC_ALPHA: + case GL_ONE_MINUS_SRC_ALPHA: + case GL_DST_ALPHA: + case GL_ONE_MINUS_DST_ALPHA: + case GL_DST_COLOR: + case GL_ONE_MINUS_DST_COLOR: + case GL_SRC_ALPHA_SATURATE: + case GL_CONSTANT_COLOR: + case GL_ONE_MINUS_CONSTANT_COLOR: + case GL_CONSTANT_ALPHA: + case GL_ONE_MINUS_CONSTANT_ALPHA: + break; + default: + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glBlendFuncSeparate(srcAlpha=0x%x)", srcAlpha); + return; + } + switch(dstAlpha) { + case GL_ZERO: + case GL_ONE: + case GL_SRC_COLOR: + case GL_ONE_MINUS_SRC_COLOR: + case GL_SRC_ALPHA: + case GL_ONE_MINUS_SRC_ALPHA: + case GL_DST_ALPHA: + case GL_ONE_MINUS_DST_ALPHA: + case GL_DST_COLOR: + case GL_ONE_MINUS_DST_COLOR: + case GL_CONSTANT_COLOR: + case GL_ONE_MINUS_CONSTANT_COLOR: + case GL_CONSTANT_ALPHA: + case GL_ONE_MINUS_CONSTANT_ALPHA: + break; + default: + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glBlendFuncSeparate(dstAlpha=0x%x)", dstAlpha); + return; + } + + _mesa_BlendFuncSeparateEXT(srcRGB, dstRGB, srcAlpha, dstAlpha); +} + +extern void GL_APIENTRY _mesa_BufferDataARB(GLenum target, GLsizeiptr size, const GLvoid * data, GLenum usage); +static void GL_APIENTRY _es_BufferData(GLenum target, GLsizeiptr size, const GLvoid *data, GLenum usage) +{ + switch(target) { + case GL_ARRAY_BUFFER: + case GL_ELEMENT_ARRAY_BUFFER: + break; + default: + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glBufferData(target=0x%x)", target); + return; + } + switch(usage) { + case GL_STATIC_DRAW: + case GL_DYNAMIC_DRAW: + case GL_STREAM_DRAW: + break; + default: + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glBufferData(usage=0x%x)", usage); + return; + } + + _mesa_BufferDataARB(target, size, data, usage); +} + +extern void GL_APIENTRY _mesa_BufferSubDataARB(GLenum target, GLintptr offset, GLsizeiptr size, const GLvoid * data); +static void GL_APIENTRY _es_BufferSubData(GLenum target, GLintptr offset, GLsizeiptr size, const GLvoid *data) +{ + switch(target) { + case GL_ARRAY_BUFFER: + case GL_ELEMENT_ARRAY_BUFFER: + break; + default: + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glBufferSubData(target=0x%x)", target); + return; + } + + _mesa_BufferSubDataARB(target, offset, size, data); +} + +extern GLenum GL_APIENTRY _mesa_CheckFramebufferStatusEXT(GLenum target); +static GLenum GL_APIENTRY _es_CheckFramebufferStatus(GLenum target) +{ + switch(target) { + case GL_FRAMEBUFFER: + break; + default: + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glCheckFramebufferStatus(target=0x%x)", target); + return (GLenum) 0; + } + + return _mesa_CheckFramebufferStatusEXT(target); +} + +extern void GL_APIENTRY _mesa_Clear(GLbitfield mask); +static void GL_APIENTRY _es_Clear(GLbitfield mask) +{ + switch(mask) { + case 0: + case (GL_COLOR_BUFFER_BIT): + case (GL_DEPTH_BUFFER_BIT): + case (GL_STENCIL_BUFFER_BIT): + case (GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT): + case (GL_COLOR_BUFFER_BIT|GL_STENCIL_BUFFER_BIT): + case (GL_DEPTH_BUFFER_BIT|GL_STENCIL_BUFFER_BIT): + case (GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT|GL_STENCIL_BUFFER_BIT): + break; + default: + _mesa_error(_mesa_get_current_context(), GL_INVALID_VALUE, "glClear(mask=0x%x)", mask); + return; + } + + _mesa_Clear(mask); +} + +extern void GL_APIENTRY _mesa_ClearColor(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha); +#define _es_ClearColor _mesa_ClearColor + +extern void GL_APIENTRY _mesa_ClearDepth(GLclampd depth); +static void GL_APIENTRY _es_ClearDepthf(GLclampf depth) +{ + GLclampd converted_depth; + + converted_depth = (GLclampd) (depth); + + _mesa_ClearDepth(converted_depth); +} + +extern void GL_APIENTRY _mesa_ClearStencil(GLint s); +#define _es_ClearStencil _mesa_ClearStencil + +extern void GL_APIENTRY _mesa_ColorMask(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha); +#define _es_ColorMask _mesa_ColorMask + +extern void GL_APIENTRY _mesa_CompileShaderARB(GLuint shader); +#define _es_CompileShader _mesa_CompileShaderARB + +extern void GL_APIENTRY _mesa_CompressedTexImage2DARB(GLenum target, GLint level, GLenum internalFormat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const GLvoid * data); +static void GL_APIENTRY _es_CompressedTexImage2D(GLenum target, GLint level, GLenum internalFormat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const GLvoid *data) +{ + switch(target) { + case GL_TEXTURE_2D: + case GL_TEXTURE_CUBE_MAP_POSITIVE_X: + case GL_TEXTURE_CUBE_MAP_POSITIVE_Y: + case GL_TEXTURE_CUBE_MAP_POSITIVE_Z: + case GL_TEXTURE_CUBE_MAP_NEGATIVE_X: + case GL_TEXTURE_CUBE_MAP_NEGATIVE_Y: + case GL_TEXTURE_CUBE_MAP_NEGATIVE_Z: + break; + default: + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glCompressedTexImage2D(target=0x%x)", target); + return; + } + switch(internalFormat) { + case GL_PALETTE4_RGB8_OES: + case GL_PALETTE4_RGBA8_OES: + case GL_PALETTE4_R5_G6_B5_OES: + case GL_PALETTE4_RGBA4_OES: + case GL_PALETTE4_RGB5_A1_OES: + case GL_PALETTE8_RGB8_OES: + case GL_PALETTE8_RGBA8_OES: + case GL_PALETTE8_R5_G6_B5_OES: + case GL_PALETTE8_RGBA4_OES: + case GL_PALETTE8_RGB5_A1_OES: + case GL_COMPRESSED_RGB_S3TC_DXT1_EXT: + case GL_COMPRESSED_RGBA_S3TC_DXT1_EXT: + break; + default: + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glCompressedTexImage2D(internalFormat=0x%x)", internalFormat); + return; + } + switch(border) { + case 0: + break; + default: + _mesa_error(_mesa_get_current_context(), GL_INVALID_VALUE, "glCompressedTexImage2D(border=%d)", border); + return; + } + + _mesa_CompressedTexImage2DARB(target, level, internalFormat, width, height, border, imageSize, data); +} + +extern void GL_APIENTRY _mesa_CompressedTexImage3DARB(GLenum target, GLint level, GLenum internalFormat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imagesize, const GLvoid * data); +static void GL_APIENTRY _es_CompressedTexImage3DOES(GLenum target, GLint level, GLenum internalFormat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imagesize, const GLvoid *data) +{ + switch(target) { + case GL_TEXTURE_3D_OES: + break; + default: + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glCompressedTexImage3DOES(target=0x%x)", target); + return; + } + + _mesa_CompressedTexImage3DARB(target, level, internalFormat, width, height, depth, border, imagesize, data); +} + +extern void GL_APIENTRY _mesa_CompressedTexSubImage2DARB(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const GLvoid * data); +static void GL_APIENTRY _es_CompressedTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const GLvoid *data) +{ + switch(target) { + case GL_TEXTURE_2D: + case GL_TEXTURE_CUBE_MAP_POSITIVE_X: + case GL_TEXTURE_CUBE_MAP_POSITIVE_Y: + case GL_TEXTURE_CUBE_MAP_POSITIVE_Z: + case GL_TEXTURE_CUBE_MAP_NEGATIVE_X: + case GL_TEXTURE_CUBE_MAP_NEGATIVE_Y: + case GL_TEXTURE_CUBE_MAP_NEGATIVE_Z: + break; + default: + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glCompressedTexSubImage2D(target=0x%x)", target); + return; + } + switch(format) { + case GL_COMPRESSED_RGB_S3TC_DXT1_EXT: + case GL_COMPRESSED_RGBA_S3TC_DXT1_EXT: + break; + default: + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glCompressedTexSubImage2D(format=0x%x)", format); + return; + } + + _mesa_CompressedTexSubImage2DARB(target, level, xoffset, yoffset, width, height, format, imageSize, data); +} + +extern void GL_APIENTRY _mesa_CompressedTexSubImage3DARB(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imagesize, const GLvoid * data); +static void GL_APIENTRY _es_CompressedTexSubImage3DOES(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imagesize, const GLvoid *data) +{ + switch(target) { + case GL_TEXTURE_3D_OES: + break; + default: + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glCompressedTexSubImage3DOES(target=0x%x)", target); + return; + } + + _mesa_CompressedTexSubImage3DARB(target, level, xoffset, yoffset, zoffset, width, height, depth, format, imagesize, data); +} + +extern void GL_APIENTRY _mesa_CopyTexImage2D(GLenum target, GLint level, GLenum internalFormat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border); +static void GL_APIENTRY _es_CopyTexImage2D(GLenum target, GLint level, GLenum internalFormat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border) +{ + switch(target) { + case GL_TEXTURE_2D: + case GL_TEXTURE_CUBE_MAP_POSITIVE_X: + case GL_TEXTURE_CUBE_MAP_POSITIVE_Y: + case GL_TEXTURE_CUBE_MAP_POSITIVE_Z: + case GL_TEXTURE_CUBE_MAP_NEGATIVE_X: + case GL_TEXTURE_CUBE_MAP_NEGATIVE_Y: + case GL_TEXTURE_CUBE_MAP_NEGATIVE_Z: + break; + default: + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glCopyTexImage2D(target=0x%x)", target); + return; + } + switch(internalFormat) { + case GL_ALPHA: + case GL_RGB: + case GL_RGBA: + case GL_LUMINANCE: + case GL_LUMINANCE_ALPHA: + break; + default: + _mesa_error(_mesa_get_current_context(), GL_INVALID_VALUE, "glCopyTexImage2D(internalFormat=0x%x)", internalFormat); + return; + } + switch(border) { + case 0: + break; + default: + _mesa_error(_mesa_get_current_context(), GL_INVALID_VALUE, "glCopyTexImage2D(border=%d)", border); + return; + } + + _mesa_CopyTexImage2D(target, level, internalFormat, x, y, width, height, border); +} + +extern void GL_APIENTRY _mesa_CopyTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height); +static void GL_APIENTRY _es_CopyTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height) +{ + switch(target) { + case GL_TEXTURE_2D: + case GL_TEXTURE_CUBE_MAP_POSITIVE_X: + case GL_TEXTURE_CUBE_MAP_POSITIVE_Y: + case GL_TEXTURE_CUBE_MAP_POSITIVE_Z: + case GL_TEXTURE_CUBE_MAP_NEGATIVE_X: + case GL_TEXTURE_CUBE_MAP_NEGATIVE_Y: + case GL_TEXTURE_CUBE_MAP_NEGATIVE_Z: + break; + default: + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glCopyTexSubImage2D(target=0x%x)", target); + return; + } + + _mesa_CopyTexSubImage2D(target, level, xoffset, yoffset, x, y, width, height); +} + +extern void GL_APIENTRY _mesa_CopyTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height); +static void GL_APIENTRY _es_CopyTexSubImage3DOES(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height) +{ + switch(target) { + case GL_TEXTURE_3D_OES: + break; + default: + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glCopyTexSubImage3DOES(target=0x%x)", target); + return; + } + + _mesa_CopyTexSubImage3D(target, level, xoffset, yoffset, zoffset, x, y, width, height); +} + +extern GLuint GL_APIENTRY _mesa_CreateProgram(void); +#define _es_CreateProgram _mesa_CreateProgram + +extern GLuint GL_APIENTRY _mesa_CreateShader(GLenum type); +static GLuint GL_APIENTRY _es_CreateShader(GLenum type) +{ + switch(type) { + case GL_VERTEX_SHADER: + case GL_FRAGMENT_SHADER: + break; + default: + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glCreateShader(type=0x%x)", type); + return (GLuint) 0; + } + + return _mesa_CreateShader(type); +} + +extern void GL_APIENTRY _mesa_CullFace(GLenum mode); +static void GL_APIENTRY _es_CullFace(GLenum mode) +{ + switch(mode) { + case GL_FRONT: + case GL_BACK: + case GL_FRONT_AND_BACK: + break; + default: + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glCullFace(mode=0x%x)", mode); + return; + } + + _mesa_CullFace(mode); +} + +extern void GL_APIENTRY _mesa_DeleteBuffersARB(GLsizei n, const GLuint * buffer); +#define _es_DeleteBuffers _mesa_DeleteBuffersARB + +extern void GL_APIENTRY _mesa_DeleteFramebuffersEXT(GLsizei n, const GLuint * framebuffers); +#define _es_DeleteFramebuffers _mesa_DeleteFramebuffersEXT + +extern void GL_APIENTRY _mesa_DeleteProgram(GLuint program); +#define _es_DeleteProgram _mesa_DeleteProgram + +extern void GL_APIENTRY _mesa_DeleteRenderbuffersEXT(GLsizei n, const GLuint * renderbuffers); +#define _es_DeleteRenderbuffers _mesa_DeleteRenderbuffersEXT + +extern void GL_APIENTRY _mesa_DeleteShader(GLuint shader); +#define _es_DeleteShader _mesa_DeleteShader + +extern void GL_APIENTRY _mesa_DeleteTextures(GLsizei n, const GLuint * textures); +#define _es_DeleteTextures _mesa_DeleteTextures + +extern void GL_APIENTRY _mesa_DepthFunc(GLenum func); +static void GL_APIENTRY _es_DepthFunc(GLenum func) +{ + switch(func) { + case GL_NEVER: + case GL_LESS: + case GL_EQUAL: + case GL_LEQUAL: + case GL_GREATER: + case GL_NOTEQUAL: + case GL_GEQUAL: + case GL_ALWAYS: + break; + default: + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glDepthFunc(func=0x%x)", func); + return; + } + + _mesa_DepthFunc(func); +} + +extern void GL_APIENTRY _mesa_DepthMask(GLboolean flag); +#define _es_DepthMask _mesa_DepthMask + +extern void GL_APIENTRY _mesa_DepthRange(GLclampd zNear, GLclampd zFar); +static void GL_APIENTRY _es_DepthRangef(GLclampf zNear, GLclampf zFar) +{ + GLclampd converted_zNear; + GLclampd converted_zFar; + + converted_zNear = (GLclampd) (zNear); + converted_zFar = (GLclampd) (zFar); + + _mesa_DepthRange(converted_zNear, converted_zFar); +} + +extern void GL_APIENTRY _mesa_DetachShader(GLuint program, GLuint shader); +#define _es_DetachShader _mesa_DetachShader + +extern void GL_APIENTRY _mesa_Disable(GLenum cap); +static void GL_APIENTRY _es_Disable(GLenum cap) +{ + switch(cap) { + case GL_CULL_FACE: + case GL_SCISSOR_TEST: + case GL_POLYGON_OFFSET_FILL: + case GL_SAMPLE_ALPHA_TO_COVERAGE: + case GL_SAMPLE_COVERAGE: + case GL_STENCIL_TEST: + case GL_DEPTH_TEST: + case GL_DITHER: + case GL_BLEND: + break; + default: + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glDisable(cap=0x%x)", cap); + return; + } + + _mesa_Disable(cap); +} + +extern void GL_APIENTRY _mesa_DisableVertexAttribArrayARB(GLuint index); +#define _es_DisableVertexAttribArray _mesa_DisableVertexAttribArrayARB + +extern void GL_APIENTRY _mesa_DrawArrays(GLenum mode, GLint first, GLsizei count); +static void GL_APIENTRY _es_DrawArrays(GLenum mode, GLint first, GLsizei count) +{ + switch(mode) { + case GL_POINTS: + case GL_LINES: + case GL_LINE_LOOP: + case GL_LINE_STRIP: + case GL_TRIANGLES: + case GL_TRIANGLE_STRIP: + case GL_TRIANGLE_FAN: + break; + default: + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glDrawArrays(mode=0x%x)", mode); + return; + } + + _mesa_DrawArrays(mode, first, count); +} + +extern void GL_APIENTRY _mesa_DrawElements(GLenum mode, GLsizei count, GLenum type, const GLvoid * indices); +static void GL_APIENTRY _es_DrawElements(GLenum mode, GLsizei count, GLenum type, const GLvoid *indices) +{ + switch(mode) { + case GL_POINTS: + case GL_LINES: + case GL_LINE_LOOP: + case GL_LINE_STRIP: + case GL_TRIANGLES: + case GL_TRIANGLE_STRIP: + case GL_TRIANGLE_FAN: + break; + default: + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glDrawElements(mode=0x%x)", mode); + return; + } + switch(type) { + case GL_UNSIGNED_BYTE: + case GL_UNSIGNED_SHORT: + case GL_UNSIGNED_INT: + break; + default: + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glDrawElements(type=0x%x)", type); + return; + } + + _mesa_DrawElements(mode, count, type, indices); +} + +extern void GL_APIENTRY _mesa_EGLImageTargetRenderbufferStorageOES(GLenum target, GLeglImageOES image); +static void GL_APIENTRY _es_EGLImageTargetRenderbufferStorageOES(GLenum target, GLeglImageOES image) +{ + switch(target) { + case GL_RENDERBUFFER: + break; + default: + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glEGLImageTargetRenderbufferStorageOES(target=0x%x)", target); + return; + } + + _mesa_EGLImageTargetRenderbufferStorageOES(target, image); +} + +extern void GL_APIENTRY _mesa_EGLImageTargetTexture2DOES(GLenum target, GLeglImageOES image); +static void GL_APIENTRY _es_EGLImageTargetTexture2DOES(GLenum target, GLeglImageOES image) +{ + switch(target) { + case GL_TEXTURE_2D: + break; + default: + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glEGLImageTargetTexture2DOES(target=0x%x)", target); + return; + } + + _mesa_EGLImageTargetTexture2DOES(target, image); +} + +extern void GL_APIENTRY _mesa_Enable(GLenum cap); +static void GL_APIENTRY _es_Enable(GLenum cap) +{ + switch(cap) { + case GL_CULL_FACE: + case GL_SCISSOR_TEST: + case GL_POLYGON_OFFSET_FILL: + case GL_SAMPLE_ALPHA_TO_COVERAGE: + case GL_SAMPLE_COVERAGE: + case GL_STENCIL_TEST: + case GL_DEPTH_TEST: + case GL_DITHER: + case GL_BLEND: + break; + default: + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glEnable(cap=0x%x)", cap); + return; + } + + _mesa_Enable(cap); +} + +extern void GL_APIENTRY _mesa_EnableVertexAttribArrayARB(GLuint index); +#define _es_EnableVertexAttribArray _mesa_EnableVertexAttribArrayARB + +extern void GL_APIENTRY _mesa_Finish(void); +#define _es_Finish _mesa_Finish + +extern void GL_APIENTRY _mesa_Flush(void); +#define _es_Flush _mesa_Flush + +extern void GL_APIENTRY _mesa_FramebufferRenderbufferEXT(GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer); +static void GL_APIENTRY _es_FramebufferRenderbuffer(GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer) +{ + switch(target) { + case GL_FRAMEBUFFER: + break; + default: + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glFramebufferRenderbuffer(target=0x%x)", target); + return; + } + switch(attachment) { + case GL_COLOR_ATTACHMENT0: + case GL_DEPTH_ATTACHMENT: + case GL_STENCIL_ATTACHMENT: + break; + default: + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glFramebufferRenderbuffer(attachment=0x%x)", attachment); + return; + } + switch(renderbuffertarget) { + case GL_RENDERBUFFER: + break; + default: + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glFramebufferRenderbuffer(renderbuffertarget=0x%x)", renderbuffertarget); + return; + } + + _mesa_FramebufferRenderbufferEXT(target, attachment, renderbuffertarget, renderbuffer); +} + +extern void GL_APIENTRY _mesa_FramebufferTexture2DEXT(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level); +static void GL_APIENTRY _es_FramebufferTexture2D(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level) +{ + switch(target) { + case GL_FRAMEBUFFER: + break; + default: + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glFramebufferTexture2D(target=0x%x)", target); + return; + } + switch(attachment) { + case GL_COLOR_ATTACHMENT0: + case GL_DEPTH_ATTACHMENT: + case GL_STENCIL_ATTACHMENT: + break; + default: + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glFramebufferTexture2D(attachment=0x%x)", attachment); + return; + } + switch(textarget) { + case GL_TEXTURE_2D: + case GL_TEXTURE_CUBE_MAP_POSITIVE_X: + case GL_TEXTURE_CUBE_MAP_POSITIVE_Y: + case GL_TEXTURE_CUBE_MAP_POSITIVE_Z: + case GL_TEXTURE_CUBE_MAP_NEGATIVE_X: + case GL_TEXTURE_CUBE_MAP_NEGATIVE_Y: + case GL_TEXTURE_CUBE_MAP_NEGATIVE_Z: + break; + default: + _mesa_error(_mesa_get_current_context(), GL_INVALID_OPERATION, "glFramebufferTexture2D(textarget=0x%x)", textarget); + return; + } + + _mesa_FramebufferTexture2DEXT(target, attachment, textarget, texture, level); +} + +extern void GL_APIENTRY _mesa_FramebufferTexture3DEXT(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level, GLint zoffset); +static void GL_APIENTRY _es_FramebufferTexture3DOES(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level, GLint zoffset) +{ + switch(target) { + case GL_FRAMEBUFFER: + break; + default: + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glFramebufferTexture3DOES(target=0x%x)", target); + return; + } + switch(attachment) { + case GL_COLOR_ATTACHMENT0: + case GL_DEPTH_ATTACHMENT: + case GL_STENCIL_ATTACHMENT: + break; + default: + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glFramebufferTexture3DOES(attachment=0x%x)", attachment); + return; + } + switch(textarget) { + case GL_TEXTURE_3D_OES: + break; + default: + _mesa_error(_mesa_get_current_context(), GL_INVALID_OPERATION, "glFramebufferTexture3DOES(textarget=0x%x)", textarget); + return; + } + + _mesa_FramebufferTexture3DEXT(target, attachment, textarget, texture, level, zoffset); +} + +extern void GL_APIENTRY _mesa_FrontFace(GLenum mode); +static void GL_APIENTRY _es_FrontFace(GLenum mode) +{ + switch(mode) { + case GL_CW: + case GL_CCW: + break; + default: + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glFrontFace(mode=0x%x)", mode); + return; + } + + _mesa_FrontFace(mode); +} + +extern void GL_APIENTRY _mesa_GenBuffersARB(GLsizei n, GLuint * buffer); +#define _es_GenBuffers _mesa_GenBuffersARB + +extern void GL_APIENTRY _mesa_GenFramebuffersEXT(GLsizei n, GLuint * ids); +#define _es_GenFramebuffers _mesa_GenFramebuffersEXT + +extern void GL_APIENTRY _mesa_GenRenderbuffersEXT(GLsizei n, GLuint * renderbuffers); +#define _es_GenRenderbuffers _mesa_GenRenderbuffersEXT + +extern void GL_APIENTRY _mesa_GenTextures(GLsizei n, GLuint * textures); +#define _es_GenTextures _mesa_GenTextures + +extern void GL_APIENTRY _mesa_GenerateMipmapEXT(GLenum target); +static void GL_APIENTRY _es_GenerateMipmap(GLenum target) +{ + switch(target) { + case GL_TEXTURE_2D: + case GL_TEXTURE_CUBE_MAP: + case GL_TEXTURE_3D_OES: + break; + default: + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glGenerateMipmap(target=0x%x)", target); + return; + } + + _mesa_GenerateMipmapEXT(target); +} + +extern void GL_APIENTRY _mesa_GetActiveAttribARB(GLuint program, GLuint index, GLsizei bufSize, GLsizei * length, GLint * size, GLenum * type, GLchar * name); +#define _es_GetActiveAttrib _mesa_GetActiveAttribARB + +extern void GL_APIENTRY _mesa_GetActiveUniformARB(GLuint program, GLuint index, GLsizei bufSize, GLsizei * length, GLint * size, GLenum * type, GLchar * name); +#define _es_GetActiveUniform _mesa_GetActiveUniformARB + +extern void GL_APIENTRY _mesa_GetAttachedShaders(GLuint program, GLsizei maxCount, GLsizei * count, GLuint * shaders); +#define _es_GetAttachedShaders _mesa_GetAttachedShaders + +extern GLint GL_APIENTRY _mesa_GetAttribLocationARB(GLuint program, const char * name); +#define _es_GetAttribLocation _mesa_GetAttribLocationARB + +extern void GL_APIENTRY _mesa_GetBooleanv(GLenum pname, GLboolean * params); +#define _es_GetBooleanv _mesa_GetBooleanv + +extern void GL_APIENTRY _mesa_GetBufferParameterivARB(GLenum target, GLenum pname, GLint * params); +static void GL_APIENTRY _es_GetBufferParameteriv(GLenum target, GLenum pname, GLint *params) +{ + switch(target) { + case GL_ARRAY_BUFFER: + case GL_ELEMENT_ARRAY_BUFFER: + break; + default: + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glGetBufferParameteriv(target=0x%x)", target); + return; + } + switch(pname) { + case GL_BUFFER_SIZE: + case GL_BUFFER_USAGE: + case GL_BUFFER_ACCESS_OES: + case GL_BUFFER_MAPPED_OES: + break; + default: + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glGetBufferParameteriv(pname=0x%x)", pname); + return; + } + + _mesa_GetBufferParameterivARB(target, pname, params); +} + +extern void GL_APIENTRY _mesa_GetBufferPointervARB(GLenum target, GLenum pname, GLvoid ** params); +static void GL_APIENTRY _es_GetBufferPointervOES(GLenum target, GLenum pname, GLvoid **params) +{ + switch(target) { + case GL_ARRAY_BUFFER: + case GL_ELEMENT_ARRAY_BUFFER: + break; + default: + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glGetBufferPointervOES(target=0x%x)", target); + return; + } + switch(pname) { + case GL_BUFFER_MAP_POINTER_OES: + break; + default: + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glGetBufferPointervOES(pname=0x%x)", pname); + return; + } + + _mesa_GetBufferPointervARB(target, pname, params); +} + +extern GLenum GL_APIENTRY _mesa_GetError(void); +#define _es_GetError _mesa_GetError + +extern void GL_APIENTRY _mesa_GetFloatv(GLenum pname, GLfloat * params); +#define _es_GetFloatv _mesa_GetFloatv + +extern void GL_APIENTRY _mesa_GetFramebufferAttachmentParameterivEXT(GLenum target, GLenum attachment, GLenum pname, GLint * params); +static void GL_APIENTRY _es_GetFramebufferAttachmentParameteriv(GLenum target, GLenum attachment, GLenum pname, GLint *params) +{ + switch(target) { + case GL_FRAMEBUFFER: + break; + default: + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glGetFramebufferAttachmentParameteriv(target=0x%x)", target); + return; + } + switch(pname) { + case GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE: /* size 1 */ + case GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME: /* size 1 */ + case GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL: /* size 1 */ + case GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE: /* size 1 */ + case GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_3D_ZOFFSET_OES: /* size 1 */ + break; + default: + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glGetFramebufferAttachmentParameteriv(pname=0x%x)", pname); + return; + } + + _mesa_GetFramebufferAttachmentParameterivEXT(target, attachment, pname, params); +} + +extern void GL_APIENTRY _mesa_GetIntegerv(GLenum pname, GLint * params); +#define _es_GetIntegerv _mesa_GetIntegerv + +extern void GL_APIENTRY _mesa_GetProgramInfoLog(GLuint program, GLsizei bufSize, GLsizei * length, GLchar * infoLog); +#define _es_GetProgramInfoLog _mesa_GetProgramInfoLog + +extern void GL_APIENTRY _mesa_GetProgramiv(GLuint program, GLenum pname, GLint * params); +static void GL_APIENTRY _es_GetProgramiv(GLuint program, GLenum pname, GLint *params) +{ + switch(pname) { + case GL_DELETE_STATUS: + case GL_LINK_STATUS: + case GL_VALIDATE_STATUS: + case GL_INFO_LOG_LENGTH: + case GL_ATTACHED_SHADERS: + case GL_ACTIVE_ATTRIBUTES: + case GL_ACTIVE_ATTRIBUTE_MAX_LENGTH: + case GL_ACTIVE_UNIFORMS: + case GL_ACTIVE_UNIFORM_MAX_LENGTH: + break; + default: + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glGetProgramiv(pname=0x%x)", pname); + return; + } + + _mesa_GetProgramiv(program, pname, params); +} + +extern void GL_APIENTRY _mesa_GetRenderbufferParameterivEXT(GLenum target, GLenum pname, GLint * params); +static void GL_APIENTRY _es_GetRenderbufferParameteriv(GLenum target, GLenum pname, GLint *params) +{ + switch(target) { + case GL_RENDERBUFFER: + break; + default: + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glGetRenderbufferParameteriv(target=0x%x)", target); + return; + } + switch(pname) { + case GL_RENDERBUFFER_WIDTH: /* size 1 */ + case GL_RENDERBUFFER_HEIGHT: /* size 1 */ + case GL_RENDERBUFFER_INTERNAL_FORMAT: /* size 1 */ + case GL_RENDERBUFFER_RED_SIZE: /* size 1 */ + case GL_RENDERBUFFER_GREEN_SIZE: /* size 1 */ + case GL_RENDERBUFFER_BLUE_SIZE: /* size 1 */ + case GL_RENDERBUFFER_ALPHA_SIZE: /* size 1 */ + case GL_RENDERBUFFER_DEPTH_SIZE: /* size 1 */ + case GL_RENDERBUFFER_STENCIL_SIZE: /* size 1 */ + break; + default: + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glGetRenderbufferParameteriv(pname=0x%x)", pname); + return; + } + + _mesa_GetRenderbufferParameterivEXT(target, pname, params); +} + +extern void GL_APIENTRY _mesa_GetShaderInfoLog(GLuint shader, GLsizei bufSize, GLsizei * length, GLchar * infoLog); +#define _es_GetShaderInfoLog _mesa_GetShaderInfoLog + +extern void GL_APIENTRY _mesa_GetShaderPrecisionFormat(GLenum shadertype, GLenum precisiontype, GLint * range, GLint * precision); +static void GL_APIENTRY _es_GetShaderPrecisionFormat(GLenum shadertype, GLenum precisiontype, GLint *range, GLint *precision) +{ + switch(shadertype) { + case GL_VERTEX_SHADER: + case GL_FRAGMENT_SHADER: + break; + default: + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glGetShaderPrecisionFormat(shadertype=0x%x)", shadertype); + return; + } + switch(precisiontype) { + case GL_LOW_FLOAT: + case GL_MEDIUM_FLOAT: + case GL_HIGH_FLOAT: + case GL_LOW_INT: + case GL_MEDIUM_INT: + case GL_HIGH_INT: + break; + default: + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glGetShaderPrecisionFormat(precisiontype=0x%x)", precisiontype); + return; + } + + _mesa_GetShaderPrecisionFormat(shadertype, precisiontype, range, precision); +} + +extern void GL_APIENTRY _mesa_GetShaderSourceARB(GLuint shader, GLsizei bufSize, GLsizei * length, GLchar * source); +#define _es_GetShaderSource _mesa_GetShaderSourceARB + +extern void GL_APIENTRY _mesa_GetShaderiv(GLuint shader, GLenum pname, GLint * params); +static void GL_APIENTRY _es_GetShaderiv(GLuint shader, GLenum pname, GLint *params) +{ + switch(pname) { + case GL_SHADER_TYPE: + case GL_COMPILE_STATUS: + case GL_DELETE_STATUS: + case GL_INFO_LOG_LENGTH: + case GL_SHADER_SOURCE_LENGTH: + break; + default: + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glGetShaderiv(pname=0x%x)", pname); + return; + } + + _mesa_GetShaderiv(shader, pname, params); +} + +extern const GLubyte * GL_APIENTRY _mesa_GetString(GLenum name); +static const GLubyte * GL_APIENTRY _es_GetString(GLenum name) +{ + switch(name) { + case GL_VENDOR: + case GL_RENDERER: + case GL_VERSION: + case GL_EXTENSIONS: + case GL_SHADING_LANGUAGE_VERSION: + break; + default: + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glGetString(name=0x%x)", name); + return (const GLubyte *) 0; + } + + return _mesa_GetString(name); +} + +extern void GL_APIENTRY _mesa_GetTexParameterfv(GLenum target, GLenum pname, GLfloat * params); +static void GL_APIENTRY _es_GetTexParameterfv(GLenum target, GLenum pname, GLfloat *params) +{ + switch(target) { + case GL_TEXTURE_2D: + case GL_TEXTURE_CUBE_MAP: + case GL_TEXTURE_3D_OES: + break; + default: + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glGetTexParameterfv(target=0x%x)", target); + return; + } + switch(pname) { + case GL_TEXTURE_WRAP_S: /* size 1 */ + case GL_TEXTURE_WRAP_T: /* size 1 */ + case GL_TEXTURE_WRAP_R_OES: /* size 1 */ + case GL_TEXTURE_MIN_FILTER: /* size 1 */ + case GL_TEXTURE_MAG_FILTER: /* size 1 */ + break; + default: + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glGetTexParameterfv(pname=0x%x)", pname); + return; + } + + _mesa_GetTexParameterfv(target, pname, params); +} + +extern void GL_APIENTRY _mesa_GetTexParameteriv(GLenum target, GLenum pname, GLint * params); +static void GL_APIENTRY _es_GetTexParameteriv(GLenum target, GLenum pname, GLint *params) +{ + switch(target) { + case GL_TEXTURE_2D: + case GL_TEXTURE_CUBE_MAP: + case GL_TEXTURE_3D_OES: + break; + default: + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glGetTexParameteriv(target=0x%x)", target); + return; + } + switch(pname) { + case GL_TEXTURE_WRAP_S: /* size 1 */ + case GL_TEXTURE_WRAP_T: /* size 1 */ + case GL_TEXTURE_WRAP_R_OES: /* size 1 */ + case GL_TEXTURE_MIN_FILTER: /* size 1 */ + case GL_TEXTURE_MAG_FILTER: /* size 1 */ + break; + default: + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glGetTexParameteriv(pname=0x%x)", pname); + return; + } + + _mesa_GetTexParameteriv(target, pname, params); +} + +extern GLint GL_APIENTRY _mesa_GetUniformLocationARB(GLuint program, const char * name); +#define _es_GetUniformLocation _mesa_GetUniformLocationARB + +extern void GL_APIENTRY _mesa_GetUniformfvARB(GLuint program, GLint location, GLfloat * params); +#define _es_GetUniformfv _mesa_GetUniformfvARB + +extern void GL_APIENTRY _mesa_GetUniformivARB(GLuint program, GLint location, GLint * params); +#define _es_GetUniformiv _mesa_GetUniformivARB + +extern void GL_APIENTRY _mesa_GetVertexAttribPointervARB(GLuint index, GLenum pname, GLvoid ** pointer); +static void GL_APIENTRY _es_GetVertexAttribPointerv(GLuint index, GLenum pname, GLvoid **pointer) +{ + switch(pname) { + case GL_VERTEX_ATTRIB_ARRAY_POINTER: + break; + default: + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glGetVertexAttribPointerv(pname=0x%x)", pname); + return; + } + + _mesa_GetVertexAttribPointervARB(index, pname, pointer); +} + +extern void GL_APIENTRY _mesa_GetVertexAttribfvARB(GLuint index, GLenum pname, GLfloat * params); +static void GL_APIENTRY _es_GetVertexAttribfv(GLuint index, GLenum pname, GLfloat *params) +{ + switch(pname) { + case GL_VERTEX_ATTRIB_ARRAY_ENABLED: /* size 1 */ + case GL_VERTEX_ATTRIB_ARRAY_SIZE: /* size 1 */ + case GL_VERTEX_ATTRIB_ARRAY_STRIDE: /* size 1 */ + case GL_VERTEX_ATTRIB_ARRAY_TYPE: /* size 1 */ + case GL_VERTEX_ATTRIB_ARRAY_NORMALIZED: /* size 1 */ + case GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING: /* size 1 */ + case GL_CURRENT_VERTEX_ATTRIB: /* size 16? */ + break; + default: + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glGetVertexAttribfv(pname=0x%x)", pname); + return; + } + + _mesa_GetVertexAttribfvARB(index, pname, params); +} + +extern void GL_APIENTRY _mesa_GetVertexAttribivARB(GLuint index, GLenum pname, GLint * params); +static void GL_APIENTRY _es_GetVertexAttribiv(GLuint index, GLenum pname, GLint *params) +{ + switch(pname) { + case GL_VERTEX_ATTRIB_ARRAY_ENABLED: /* size 1 */ + case GL_VERTEX_ATTRIB_ARRAY_SIZE: /* size 1 */ + case GL_VERTEX_ATTRIB_ARRAY_STRIDE: /* size 1 */ + case GL_VERTEX_ATTRIB_ARRAY_TYPE: /* size 1 */ + case GL_VERTEX_ATTRIB_ARRAY_NORMALIZED: /* size 1 */ + case GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING: /* size 1 */ + case GL_CURRENT_VERTEX_ATTRIB: /* size 16? */ + break; + default: + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glGetVertexAttribiv(pname=0x%x)", pname); + return; + } + + _mesa_GetVertexAttribivARB(index, pname, params); +} + +extern void GL_APIENTRY _mesa_Hint(GLenum target, GLenum mode); +static void GL_APIENTRY _es_Hint(GLenum target, GLenum mode) +{ + switch(target) { + case GL_FRAGMENT_SHADER_DERIVATIVE_HINT_OES: + case GL_GENERATE_MIPMAP_HINT: + break; + default: + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glHint(target=0x%x)", target); + return; + } + switch(mode) { + case GL_FASTEST: + case GL_NICEST: + case GL_DONT_CARE: + break; + default: + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glHint(mode=0x%x)", mode); + return; + } + + _mesa_Hint(target, mode); +} + +extern GLboolean GL_APIENTRY _mesa_IsBufferARB(GLuint buffer); +#define _es_IsBuffer _mesa_IsBufferARB + +extern GLboolean GL_APIENTRY _mesa_IsEnabled(GLenum cap); +static GLboolean GL_APIENTRY _es_IsEnabled(GLenum cap) +{ + switch(cap) { + case GL_CULL_FACE: + case GL_SCISSOR_TEST: + case GL_POLYGON_OFFSET_FILL: + case GL_SAMPLE_ALPHA_TO_COVERAGE: + case GL_SAMPLE_COVERAGE: + case GL_STENCIL_TEST: + case GL_DEPTH_TEST: + case GL_DITHER: + case GL_BLEND: + break; + default: + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glIsEnabled(cap=0x%x)", cap); + return GL_FALSE; + } + + return _mesa_IsEnabled(cap); +} + +extern GLboolean GL_APIENTRY _mesa_IsFramebufferEXT(GLuint framebuffer); +#define _es_IsFramebuffer _mesa_IsFramebufferEXT + +extern GLboolean GL_APIENTRY _mesa_IsProgram(GLuint program); +#define _es_IsProgram _mesa_IsProgram + +extern GLboolean GL_APIENTRY _mesa_IsRenderbufferEXT(GLuint renderbuffer); +#define _es_IsRenderbuffer _mesa_IsRenderbufferEXT + +extern GLboolean GL_APIENTRY _mesa_IsShader(GLuint shader); +#define _es_IsShader _mesa_IsShader + +extern GLboolean GL_APIENTRY _mesa_IsTexture(GLuint texture); +#define _es_IsTexture _mesa_IsTexture + +extern void GL_APIENTRY _mesa_LineWidth(GLfloat width); +#define _es_LineWidth _mesa_LineWidth + +extern void GL_APIENTRY _mesa_LinkProgramARB(GLuint program); +#define _es_LinkProgram _mesa_LinkProgramARB + +extern void * GL_APIENTRY _mesa_MapBufferARB(GLenum target, GLenum access); +static void * GL_APIENTRY _es_MapBufferOES(GLenum target, GLenum access) +{ + switch(target) { + case GL_ARRAY_BUFFER: + case GL_ELEMENT_ARRAY_BUFFER: + break; + default: + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glMapBufferOES(target=0x%x)", target); + return (void *) 0; + } + switch(access) { + case GL_WRITE_ONLY_OES: + break; + default: + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glMapBufferOES(access=0x%x)", access); + return (void *) 0; + } + + return _mesa_MapBufferARB(target, access); +} + +extern void GL_APIENTRY _mesa_MultiDrawArraysEXT(GLenum mode, const GLint * first, const GLsizei * count, GLsizei primcount); +static void GL_APIENTRY _es_MultiDrawArraysEXT(GLenum mode, const GLint *first, const GLsizei *count, GLsizei primcount) +{ + switch(mode) { + case GL_POINTS: + case GL_LINES: + case GL_LINE_LOOP: + case GL_LINE_STRIP: + case GL_TRIANGLES: + case GL_TRIANGLE_STRIP: + case GL_TRIANGLE_FAN: + break; + default: + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glMultiDrawArraysEXT(mode=0x%x)", mode); + return; + } + + _mesa_MultiDrawArraysEXT(mode, first, count, primcount); +} + +extern void GL_APIENTRY _mesa_MultiDrawElementsEXT(GLenum mode, const GLsizei * count, GLenum type, const GLvoid ** indices, GLsizei primcount); +static void GL_APIENTRY _es_MultiDrawElementsEXT(GLenum mode, const GLsizei *count, GLenum type, const GLvoid **indices, GLsizei primcount) +{ + switch(mode) { + case GL_POINTS: + case GL_LINES: + case GL_LINE_LOOP: + case GL_LINE_STRIP: + case GL_TRIANGLES: + case GL_TRIANGLE_STRIP: + case GL_TRIANGLE_FAN: + break; + default: + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glMultiDrawElementsEXT(mode=0x%x)", mode); + return; + } + switch(type) { + case GL_UNSIGNED_BYTE: + case GL_UNSIGNED_SHORT: + case GL_UNSIGNED_INT: + break; + default: + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glMultiDrawElementsEXT(type=0x%x)", type); + return; + } + + _mesa_MultiDrawElementsEXT(mode, count, type, indices, primcount); +} + +extern void GL_APIENTRY _mesa_PixelStorei(GLenum pname, GLint param); +static void GL_APIENTRY _es_PixelStorei(GLenum pname, GLint param) +{ + switch(pname) { + case GL_PACK_ALIGNMENT: + case GL_UNPACK_ALIGNMENT: + break; + default: + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glPixelStorei(pname=0x%x)", pname); + return; + } + switch(param) { + case 1: + case 2: + case 4: + case 8: + break; + default: + _mesa_error(_mesa_get_current_context(), GL_INVALID_VALUE, "glPixelStorei(param=%d)", param); + return; + } + + _mesa_PixelStorei(pname, param); +} + +extern void GL_APIENTRY _mesa_PolygonOffset(GLfloat factor, GLfloat units); +#define _es_PolygonOffset _mesa_PolygonOffset + +extern void GL_APIENTRY _mesa_ReadPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLvoid * pixels); +static void GL_APIENTRY _es_ReadPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLvoid *pixels) +{ + switch(format) { + case GL_ALPHA: + if (type != GL_UNSIGNED_BYTE) { + _mesa_error(_mesa_get_current_context(), GL_INVALID_OPERATION, "glReadPixels(format=0x%x)", format); + return; + } + break; + case GL_RGB: + if (type != GL_UNSIGNED_BYTE && type != GL_UNSIGNED_SHORT_5_6_5) { + _mesa_error(_mesa_get_current_context(), GL_INVALID_OPERATION, "glReadPixels(format=0x%x)", format); + return; + } + break; + case GL_RGBA: + if (type != GL_UNSIGNED_BYTE && type != GL_UNSIGNED_SHORT_4_4_4_4 && type != GL_UNSIGNED_SHORT_5_5_5_1) { + _mesa_error(_mesa_get_current_context(), GL_INVALID_OPERATION, "glReadPixels(format=0x%x)", format); + return; + } + break; + case GL_LUMINANCE: + case GL_LUMINANCE_ALPHA: + if (type != GL_UNSIGNED_BYTE) { + _mesa_error(_mesa_get_current_context(), GL_INVALID_OPERATION, "glReadPixels(format=0x%x)", format); + return; + } + break; + default: + _mesa_error(_mesa_get_current_context(), GL_INVALID_OPERATION, "glReadPixels(format=0x%x)", format); + return; + } + + _mesa_ReadPixels(x, y, width, height, format, type, pixels); +} + +extern void GL_APIENTRY _mesa_ReleaseShaderCompiler(void); +#define _es_ReleaseShaderCompiler _mesa_ReleaseShaderCompiler + +/* this function is special and is defined elsewhere */ +extern void GL_APIENTRY _es_RenderbufferStorageEXT(GLenum target, GLenum internalFormat, GLsizei width, GLsizei height); +static void GL_APIENTRY _check_RenderbufferStorage(GLenum target, GLenum internalFormat, GLsizei width, GLsizei height) +{ + switch(target) { + case GL_RENDERBUFFER: + break; + default: + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glRenderbufferStorage(target=0x%x)", target); + return; + } + switch(internalFormat) { + case GL_DEPTH_COMPONENT16: + case GL_RGBA4: + case GL_RGB5_A1: + case GL_RGB565: + case GL_STENCIL_INDEX8: + case GL_DEPTH_COMPONENT24_OES: + case GL_DEPTH_COMPONENT32_OES: + case GL_RGB8_OES: + case GL_RGBA8_OES: + case GL_STENCIL_INDEX1_OES: + case GL_STENCIL_INDEX4_OES: + case GL_DEPTH24_STENCIL8_OES: + break; + default: + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glRenderbufferStorage(internalFormat=0x%x)", internalFormat); + return; + } + + _es_RenderbufferStorageEXT(target, internalFormat, width, height); +} + +extern void GL_APIENTRY _mesa_SampleCoverageARB(GLclampf value, GLboolean invert); +#define _es_SampleCoverage _mesa_SampleCoverageARB + +extern void GL_APIENTRY _mesa_Scissor(GLint x, GLint y, GLsizei width, GLsizei height); +#define _es_Scissor _mesa_Scissor + +extern void GL_APIENTRY _mesa_ShaderBinary(GLsizei n, const GLuint * shaders, GLenum binaryformat, const GLvoid * binary, GLsizei length); +#define _es_ShaderBinary _mesa_ShaderBinary + +extern void GL_APIENTRY _mesa_ShaderSourceARB(GLuint shader, GLsizei count, const GLchar ** string, const int * length); +#define _es_ShaderSource _mesa_ShaderSourceARB + +extern void GL_APIENTRY _mesa_StencilFunc(GLenum func, GLint ref, GLuint mask); +static void GL_APIENTRY _es_StencilFunc(GLenum func, GLint ref, GLuint mask) +{ + switch(func) { + case GL_NEVER: + case GL_LESS: + case GL_LEQUAL: + case GL_GREATER: + case GL_GEQUAL: + case GL_EQUAL: + case GL_NOTEQUAL: + case GL_ALWAYS: + break; + default: + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glStencilFunc(func=0x%x)", func); + return; + } + + _mesa_StencilFunc(func, ref, mask); +} + +extern void GL_APIENTRY _mesa_StencilFuncSeparate(GLenum face, GLenum func, GLint ref, GLuint mask); +static void GL_APIENTRY _es_StencilFuncSeparate(GLenum face, GLenum func, GLint ref, GLuint mask) +{ + switch(face) { + case GL_FRONT: + case GL_BACK: + case GL_FRONT_AND_BACK: + break; + default: + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glStencilFuncSeparate(face=0x%x)", face); + return; + } + switch(func) { + case GL_NEVER: + case GL_LESS: + case GL_LEQUAL: + case GL_GREATER: + case GL_GEQUAL: + case GL_EQUAL: + case GL_NOTEQUAL: + case GL_ALWAYS: + break; + default: + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glStencilFuncSeparate(func=0x%x)", func); + return; + } + + _mesa_StencilFuncSeparate(face, func, ref, mask); +} + +extern void GL_APIENTRY _mesa_StencilMask(GLuint mask); +#define _es_StencilMask _mesa_StencilMask + +extern void GL_APIENTRY _mesa_StencilMaskSeparate(GLenum face, GLuint mask); +static void GL_APIENTRY _es_StencilMaskSeparate(GLenum face, GLuint mask) +{ + switch(face) { + case GL_FRONT: + case GL_BACK: + case GL_FRONT_AND_BACK: + break; + default: + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glStencilMaskSeparate(face=0x%x)", face); + return; + } + + _mesa_StencilMaskSeparate(face, mask); +} + +extern void GL_APIENTRY _mesa_StencilOp(GLenum fail, GLenum zfail, GLenum zpass); +static void GL_APIENTRY _es_StencilOp(GLenum fail, GLenum zfail, GLenum zpass) +{ + switch(fail) { + case GL_KEEP: + case GL_ZERO: + case GL_REPLACE: + case GL_INCR: + case GL_DECR: + case GL_INVERT: + case GL_INCR_WRAP: + case GL_DECR_WRAP: + break; + default: + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glStencilOp(fail=0x%x)", fail); + return; + } + switch(zfail) { + case GL_KEEP: + case GL_ZERO: + case GL_REPLACE: + case GL_INCR: + case GL_DECR: + case GL_INVERT: + case GL_INCR_WRAP: + case GL_DECR_WRAP: + break; + default: + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glStencilOp(zfail=0x%x)", zfail); + return; + } + switch(zpass) { + case GL_KEEP: + case GL_ZERO: + case GL_REPLACE: + case GL_INCR: + case GL_DECR: + case GL_INVERT: + case GL_INCR_WRAP: + case GL_DECR_WRAP: + break; + default: + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glStencilOp(zpass=0x%x)", zpass); + return; + } + + _mesa_StencilOp(fail, zfail, zpass); +} + +extern void GL_APIENTRY _mesa_StencilOpSeparate(GLenum face, GLenum fail, GLenum zfail, GLenum zpass); +static void GL_APIENTRY _es_StencilOpSeparate(GLenum face, GLenum fail, GLenum zfail, GLenum zpass) +{ + switch(face) { + case GL_FRONT: + case GL_BACK: + case GL_FRONT_AND_BACK: + break; + default: + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glStencilOpSeparate(face=0x%x)", face); + return; + } + switch(fail) { + case GL_KEEP: + case GL_ZERO: + case GL_REPLACE: + case GL_INCR: + case GL_DECR: + case GL_INVERT: + case GL_INCR_WRAP: + case GL_DECR_WRAP: + break; + default: + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glStencilOpSeparate(fail=0x%x)", fail); + return; + } + switch(zfail) { + case GL_KEEP: + case GL_ZERO: + case GL_REPLACE: + case GL_INCR: + case GL_DECR: + case GL_INVERT: + case GL_INCR_WRAP: + case GL_DECR_WRAP: + break; + default: + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glStencilOpSeparate(zfail=0x%x)", zfail); + return; + } + switch(zpass) { + case GL_KEEP: + case GL_ZERO: + case GL_REPLACE: + case GL_INCR: + case GL_DECR: + case GL_INVERT: + case GL_INCR_WRAP: + case GL_DECR_WRAP: + break; + default: + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glStencilOpSeparate(zpass=0x%x)", zpass); + return; + } + + _mesa_StencilOpSeparate(face, fail, zfail, zpass); +} + +extern void GL_APIENTRY _mesa_TexImage2D(GLenum target, GLint level, GLint internalFormat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const GLvoid * pixels); +static void GL_APIENTRY _es_TexImage2D(GLenum target, GLint level, GLint internalFormat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const GLvoid *pixels) +{ + switch(target) { + case GL_TEXTURE_2D: + case GL_TEXTURE_CUBE_MAP_POSITIVE_X: + case GL_TEXTURE_CUBE_MAP_POSITIVE_Y: + case GL_TEXTURE_CUBE_MAP_POSITIVE_Z: + case GL_TEXTURE_CUBE_MAP_NEGATIVE_X: + case GL_TEXTURE_CUBE_MAP_NEGATIVE_Y: + case GL_TEXTURE_CUBE_MAP_NEGATIVE_Z: + break; + default: + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glTexImage2D(target=0x%x)", target); + return; + } + switch(internalFormat) { + case GL_ALPHA: + case GL_RGB: + case GL_RGBA: + case GL_BGRA_EXT: + case GL_LUMINANCE: + case GL_LUMINANCE_ALPHA: + case GL_DEPTH_COMPONENT: + case GL_DEPTH_STENCIL_OES: + break; + default: + _mesa_error(_mesa_get_current_context(), GL_INVALID_VALUE, "glTexImage2D(internalFormat=%d)", internalFormat); + return; + } + switch(border) { + case 0: + break; + default: + _mesa_error(_mesa_get_current_context(), GL_INVALID_VALUE, "glTexImage2D(border=%d)", border); + return; + } + switch(format) { + case GL_ALPHA: + if (type != GL_UNSIGNED_BYTE) { + _mesa_error(_mesa_get_current_context(), GL_INVALID_OPERATION, "glTexImage2D(format=0x%x)", format); + return; + } + break; + case GL_RGB: + if (type != GL_UNSIGNED_BYTE && type != GL_UNSIGNED_SHORT_5_6_5) { + _mesa_error(_mesa_get_current_context(), GL_INVALID_OPERATION, "glTexImage2D(format=0x%x)", format); + return; + } + break; + case GL_RGBA: + if (type != GL_UNSIGNED_BYTE && type != GL_UNSIGNED_SHORT_4_4_4_4 && type != GL_UNSIGNED_SHORT_5_5_5_1 && type != GL_UNSIGNED_INT_2_10_10_10_REV_EXT) { + _mesa_error(_mesa_get_current_context(), GL_INVALID_OPERATION, "glTexImage2D(format=0x%x)", format); + return; + } + break; + case GL_LUMINANCE: + case GL_LUMINANCE_ALPHA: + if (type != GL_UNSIGNED_BYTE) { + _mesa_error(_mesa_get_current_context(), GL_INVALID_OPERATION, "glTexImage2D(format=0x%x)", format); + return; + } + break; + case GL_DEPTH_COMPONENT: + if (type != GL_UNSIGNED_SHORT && type != GL_UNSIGNED_INT) { + _mesa_error(_mesa_get_current_context(), GL_INVALID_OPERATION, "glTexImage2D(format=0x%x)", format); + return; + } + break; + case GL_DEPTH_STENCIL_OES: + if (type != GL_UNSIGNED_INT_24_8_OES) { + _mesa_error(_mesa_get_current_context(), GL_INVALID_OPERATION, "glTexImage2D(format=0x%x)", format); + return; + } + break; + case GL_BGRA_EXT: + if (type != GL_UNSIGNED_BYTE) { + _mesa_error(_mesa_get_current_context(), GL_INVALID_OPERATION, "glTexImage2D(format=0x%x)", format); + return; + } + break; + default: + _mesa_error(_mesa_get_current_context(), GL_INVALID_OPERATION, "glTexImage2D(format=0x%x)", format); + return; + } + + _mesa_TexImage2D(target, level, internalFormat, width, height, border, format, type, pixels); +} + +extern void GL_APIENTRY _mesa_TexImage3D(GLenum target, GLint level, GLenum internalFormat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const GLvoid * pixels); +static void GL_APIENTRY _es_TexImage3DOES(GLenum target, GLint level, GLenum internalFormat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const GLvoid *pixels) +{ + switch(target) { + case GL_TEXTURE_3D_OES: + break; + default: + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glTexImage3DOES(target=0x%x)", target); + return; + } + switch(internalFormat) { + case GL_ALPHA: + case GL_RGB: + case GL_RGBA: + case GL_LUMINANCE: + case GL_LUMINANCE_ALPHA: + break; + default: + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glTexImage3DOES(internalFormat=0x%x)", internalFormat); + return; + } + switch(format) { + case GL_ALPHA: + if (type != GL_UNSIGNED_BYTE) { + _mesa_error(_mesa_get_current_context(), GL_INVALID_OPERATION, "glTexImage3DOES(format=0x%x)", format); + return; + } + break; + case GL_RGB: + if (type != GL_UNSIGNED_BYTE && type != GL_UNSIGNED_SHORT_5_6_5) { + _mesa_error(_mesa_get_current_context(), GL_INVALID_OPERATION, "glTexImage3DOES(format=0x%x)", format); + return; + } + break; + case GL_RGBA: + if (type != GL_UNSIGNED_BYTE && type != GL_UNSIGNED_SHORT_4_4_4_4 && type != GL_UNSIGNED_SHORT_5_5_5_1 && type != GL_UNSIGNED_INT_2_10_10_10_REV_EXT) { + _mesa_error(_mesa_get_current_context(), GL_INVALID_OPERATION, "glTexImage3DOES(format=0x%x)", format); + return; + } + break; + case GL_LUMINANCE: + case GL_LUMINANCE_ALPHA: + if (type != GL_UNSIGNED_BYTE) { + _mesa_error(_mesa_get_current_context(), GL_INVALID_OPERATION, "glTexImage3DOES(format=0x%x)", format); + return; + } + break; + default: + _mesa_error(_mesa_get_current_context(), GL_INVALID_OPERATION, "glTexImage3DOES(format=0x%x)", format); + return; + } + + _mesa_TexImage3D(target, level, internalFormat, width, height, depth, border, format, type, pixels); +} + +extern void GL_APIENTRY _mesa_TexParameterf(GLenum target, GLenum pname, GLfloat param); +static void GL_APIENTRY _es_TexParameterf(GLenum target, GLenum pname, GLfloat param) +{ + switch(target) { + case GL_TEXTURE_2D: + case GL_TEXTURE_CUBE_MAP: + case GL_TEXTURE_3D_OES: + break; + default: + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glTexParameterf(target=0x%x)", target); + return; + } + switch(pname) { + case GL_TEXTURE_WRAP_S: + case GL_TEXTURE_WRAP_T: + case GL_TEXTURE_WRAP_R_OES: + if (param != GL_CLAMP_TO_EDGE && param != GL_REPEAT && param != GL_MIRRORED_REPEAT) { + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glTexParameterf(pname=0x%x)", pname); + return; + } + break; + case GL_TEXTURE_MIN_FILTER: + if (param != GL_NEAREST && param != GL_LINEAR && param != GL_NEAREST_MIPMAP_NEAREST && param != GL_NEAREST_MIPMAP_LINEAR && param != GL_LINEAR_MIPMAP_NEAREST && param != GL_LINEAR_MIPMAP_LINEAR) { + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glTexParameterf(pname=0x%x)", pname); + return; + } + break; + case GL_TEXTURE_MAG_FILTER: + if (param != GL_NEAREST && param != GL_LINEAR) { + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glTexParameterf(pname=0x%x)", pname); + return; + } + break; + case GL_TEXTURE_MAX_ANISOTROPY_EXT: + break; + default: + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glTexParameterf(pname=0x%x)", pname); + return; + } + + _mesa_TexParameterf(target, pname, param); +} + +extern void GL_APIENTRY _mesa_TexParameterfv(GLenum target, GLenum pname, const GLfloat * params); +static void GL_APIENTRY _es_TexParameterfv(GLenum target, GLenum pname, const GLfloat *params) +{ + switch(target) { + case GL_TEXTURE_2D: + case GL_TEXTURE_CUBE_MAP: + case GL_TEXTURE_3D_OES: + break; + default: + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glTexParameterfv(target=0x%x)", target); + return; + } + switch(pname) { + case GL_TEXTURE_WRAP_S: /* size 1 */ + case GL_TEXTURE_WRAP_T: /* size 1 */ + case GL_TEXTURE_WRAP_R_OES: /* size 1 */ + if (params[0] != GL_CLAMP_TO_EDGE && params[0] != GL_REPEAT && params[0] != GL_MIRRORED_REPEAT) { + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glTexParameterfv(pname=0x%x)", pname); + return; + } + break; + case GL_TEXTURE_MIN_FILTER: /* size 1 */ + if (params[0] != GL_NEAREST && params[0] != GL_LINEAR && params[0] != GL_NEAREST_MIPMAP_NEAREST && params[0] != GL_NEAREST_MIPMAP_LINEAR && params[0] != GL_LINEAR_MIPMAP_NEAREST && params[0] != GL_LINEAR_MIPMAP_LINEAR) { + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glTexParameterfv(pname=0x%x)", pname); + return; + } + break; + case GL_TEXTURE_MAG_FILTER: /* size 1 */ + if (params[0] != GL_NEAREST && params[0] != GL_LINEAR) { + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glTexParameterfv(pname=0x%x)", pname); + return; + } + break; + case GL_TEXTURE_MAX_ANISOTROPY_EXT: /* size 1 */ + break; + default: + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glTexParameterfv(pname=0x%x)", pname); + return; + } + + _mesa_TexParameterfv(target, pname, params); +} + +extern void GL_APIENTRY _mesa_TexParameteri(GLenum target, GLenum pname, GLint param); +static void GL_APIENTRY _es_TexParameteri(GLenum target, GLenum pname, GLint param) +{ + switch(target) { + case GL_TEXTURE_2D: + case GL_TEXTURE_CUBE_MAP: + case GL_TEXTURE_3D_OES: + break; + default: + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glTexParameteri(target=0x%x)", target); + return; + } + switch(pname) { + case GL_TEXTURE_WRAP_S: + case GL_TEXTURE_WRAP_T: + case GL_TEXTURE_WRAP_R_OES: + if (param != GL_CLAMP_TO_EDGE && param != GL_REPEAT && param != GL_MIRRORED_REPEAT) { + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glTexParameteri(pname=0x%x)", pname); + return; + } + break; + case GL_TEXTURE_MIN_FILTER: + if (param != GL_NEAREST && param != GL_LINEAR && param != GL_NEAREST_MIPMAP_NEAREST && param != GL_NEAREST_MIPMAP_LINEAR && param != GL_LINEAR_MIPMAP_NEAREST && param != GL_LINEAR_MIPMAP_LINEAR) { + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glTexParameteri(pname=0x%x)", pname); + return; + } + break; + case GL_TEXTURE_MAG_FILTER: + if (param != GL_NEAREST && param != GL_LINEAR) { + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glTexParameteri(pname=0x%x)", pname); + return; + } + break; + case GL_TEXTURE_MAX_ANISOTROPY_EXT: + break; + default: + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glTexParameteri(pname=0x%x)", pname); + return; + } + + _mesa_TexParameteri(target, pname, param); +} + +extern void GL_APIENTRY _mesa_TexParameteriv(GLenum target, GLenum pname, const GLint * params); +static void GL_APIENTRY _es_TexParameteriv(GLenum target, GLenum pname, const GLint *params) +{ + switch(target) { + case GL_TEXTURE_2D: + case GL_TEXTURE_CUBE_MAP: + case GL_TEXTURE_3D_OES: + break; + default: + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glTexParameteriv(target=0x%x)", target); + return; + } + switch(pname) { + case GL_TEXTURE_WRAP_S: /* size 1 */ + case GL_TEXTURE_WRAP_T: /* size 1 */ + case GL_TEXTURE_WRAP_R_OES: /* size 1 */ + if (params[0] != GL_CLAMP_TO_EDGE && params[0] != GL_REPEAT && params[0] != GL_MIRRORED_REPEAT) { + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glTexParameteriv(pname=0x%x)", pname); + return; + } + break; + case GL_TEXTURE_MIN_FILTER: /* size 1 */ + if (params[0] != GL_NEAREST && params[0] != GL_LINEAR && params[0] != GL_NEAREST_MIPMAP_NEAREST && params[0] != GL_NEAREST_MIPMAP_LINEAR && params[0] != GL_LINEAR_MIPMAP_NEAREST && params[0] != GL_LINEAR_MIPMAP_LINEAR) { + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glTexParameteriv(pname=0x%x)", pname); + return; + } + break; + case GL_TEXTURE_MAG_FILTER: /* size 1 */ + if (params[0] != GL_NEAREST && params[0] != GL_LINEAR) { + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glTexParameteriv(pname=0x%x)", pname); + return; + } + break; + case GL_TEXTURE_MAX_ANISOTROPY_EXT: /* size 1 */ + break; + default: + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glTexParameteriv(pname=0x%x)", pname); + return; + } + + _mesa_TexParameteriv(target, pname, params); +} + +extern void GL_APIENTRY _mesa_TexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid * pixels); +static void GL_APIENTRY _es_TexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *pixels) +{ + switch(target) { + case GL_TEXTURE_2D: + case GL_TEXTURE_CUBE_MAP_POSITIVE_X: + case GL_TEXTURE_CUBE_MAP_POSITIVE_Y: + case GL_TEXTURE_CUBE_MAP_POSITIVE_Z: + case GL_TEXTURE_CUBE_MAP_NEGATIVE_X: + case GL_TEXTURE_CUBE_MAP_NEGATIVE_Y: + case GL_TEXTURE_CUBE_MAP_NEGATIVE_Z: + break; + default: + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glTexSubImage2D(target=0x%x)", target); + return; + } + switch(format) { + case GL_ALPHA: + if (type != GL_UNSIGNED_BYTE) { + _mesa_error(_mesa_get_current_context(), GL_INVALID_OPERATION, "glTexSubImage2D(format=0x%x)", format); + return; + } + break; + case GL_RGB: + if (type != GL_UNSIGNED_BYTE && type != GL_UNSIGNED_SHORT_5_6_5) { + _mesa_error(_mesa_get_current_context(), GL_INVALID_OPERATION, "glTexSubImage2D(format=0x%x)", format); + return; + } + break; + case GL_RGBA: + if (type != GL_UNSIGNED_BYTE && type != GL_UNSIGNED_SHORT_4_4_4_4 && type != GL_UNSIGNED_SHORT_5_5_5_1 && type != GL_UNSIGNED_INT_2_10_10_10_REV_EXT) { + _mesa_error(_mesa_get_current_context(), GL_INVALID_OPERATION, "glTexSubImage2D(format=0x%x)", format); + return; + } + break; + case GL_LUMINANCE: + case GL_LUMINANCE_ALPHA: + if (type != GL_UNSIGNED_BYTE) { + _mesa_error(_mesa_get_current_context(), GL_INVALID_OPERATION, "glTexSubImage2D(format=0x%x)", format); + return; + } + break; + case GL_DEPTH_COMPONENT: + if (type != GL_UNSIGNED_SHORT && type != GL_UNSIGNED_INT) { + _mesa_error(_mesa_get_current_context(), GL_INVALID_OPERATION, "glTexSubImage2D(format=0x%x)", format); + return; + } + break; + case GL_DEPTH_STENCIL_OES: + if (type != GL_UNSIGNED_INT_24_8_OES) { + _mesa_error(_mesa_get_current_context(), GL_INVALID_OPERATION, "glTexSubImage2D(format=0x%x)", format); + return; + } + break; + default: + _mesa_error(_mesa_get_current_context(), GL_INVALID_OPERATION, "glTexSubImage2D(format=0x%x)", format); + return; + } + + _mesa_TexSubImage2D(target, level, xoffset, yoffset, width, height, format, type, pixels); +} + +extern void GL_APIENTRY _mesa_TexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const GLvoid * pixels); +static void GL_APIENTRY _es_TexSubImage3DOES(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const GLvoid *pixels) +{ + switch(target) { + case GL_TEXTURE_3D_OES: + break; + default: + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glTexSubImage3DOES(target=0x%x)", target); + return; + } + switch(format) { + case GL_ALPHA: + if (type != GL_UNSIGNED_BYTE) { + _mesa_error(_mesa_get_current_context(), GL_INVALID_OPERATION, "glTexSubImage3DOES(format=0x%x)", format); + return; + } + break; + case GL_RGB: + if (type != GL_UNSIGNED_BYTE && type != GL_UNSIGNED_SHORT_5_6_5) { + _mesa_error(_mesa_get_current_context(), GL_INVALID_OPERATION, "glTexSubImage3DOES(format=0x%x)", format); + return; + } + break; + case GL_RGBA: + if (type != GL_UNSIGNED_BYTE && type != GL_UNSIGNED_SHORT_4_4_4_4 && type != GL_UNSIGNED_SHORT_5_5_5_1 && type != GL_UNSIGNED_INT_2_10_10_10_REV_EXT) { + _mesa_error(_mesa_get_current_context(), GL_INVALID_OPERATION, "glTexSubImage3DOES(format=0x%x)", format); + return; + } + break; + case GL_LUMINANCE: + case GL_LUMINANCE_ALPHA: + if (type != GL_UNSIGNED_BYTE) { + _mesa_error(_mesa_get_current_context(), GL_INVALID_OPERATION, "glTexSubImage3DOES(format=0x%x)", format); + return; + } + break; + default: + _mesa_error(_mesa_get_current_context(), GL_INVALID_OPERATION, "glTexSubImage3DOES(format=0x%x)", format); + return; + } + + _mesa_TexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, pixels); +} + +extern void GL_APIENTRY _mesa_Uniform1fARB(GLint location, GLfloat v0); +#define _es_Uniform1f _mesa_Uniform1fARB + +extern void GL_APIENTRY _mesa_Uniform1fvARB(GLint location, GLsizei count, const GLfloat * values); +#define _es_Uniform1fv _mesa_Uniform1fvARB + +extern void GL_APIENTRY _mesa_Uniform1iARB(GLint location, GLint v0); +#define _es_Uniform1i _mesa_Uniform1iARB + +extern void GL_APIENTRY _mesa_Uniform1ivARB(GLint location, GLsizei count, const GLint * values); +#define _es_Uniform1iv _mesa_Uniform1ivARB + +extern void GL_APIENTRY _mesa_Uniform2fARB(GLint location, GLfloat v0, GLfloat v1); +#define _es_Uniform2f _mesa_Uniform2fARB + +extern void GL_APIENTRY _mesa_Uniform2fvARB(GLint location, GLsizei count, const GLfloat * values); +#define _es_Uniform2fv _mesa_Uniform2fvARB + +extern void GL_APIENTRY _mesa_Uniform2iARB(GLint location, GLint v0, GLint v1); +#define _es_Uniform2i _mesa_Uniform2iARB + +extern void GL_APIENTRY _mesa_Uniform2ivARB(GLint location, GLsizei count, const GLint * values); +#define _es_Uniform2iv _mesa_Uniform2ivARB + +extern void GL_APIENTRY _mesa_Uniform3fARB(GLint location, GLfloat v0, GLfloat v1, GLfloat v2); +#define _es_Uniform3f _mesa_Uniform3fARB + +extern void GL_APIENTRY _mesa_Uniform3fvARB(GLint location, GLsizei count, const GLfloat * values); +#define _es_Uniform3fv _mesa_Uniform3fvARB + +extern void GL_APIENTRY _mesa_Uniform3iARB(GLint location, GLint v0, GLint v1, GLint v2); +#define _es_Uniform3i _mesa_Uniform3iARB + +extern void GL_APIENTRY _mesa_Uniform3ivARB(GLint location, GLsizei count, const GLint * values); +#define _es_Uniform3iv _mesa_Uniform3ivARB + +extern void GL_APIENTRY _mesa_Uniform4fARB(GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3); +#define _es_Uniform4f _mesa_Uniform4fARB + +extern void GL_APIENTRY _mesa_Uniform4fvARB(GLint location, GLsizei count, const GLfloat * values); +#define _es_Uniform4fv _mesa_Uniform4fvARB + +extern void GL_APIENTRY _mesa_Uniform4iARB(GLint location, GLint v0, GLint v1, GLint v2, GLint v3); +#define _es_Uniform4i _mesa_Uniform4iARB + +extern void GL_APIENTRY _mesa_Uniform4ivARB(GLint location, GLsizei count, const GLint * values); +#define _es_Uniform4iv _mesa_Uniform4ivARB + +extern void GL_APIENTRY _mesa_UniformMatrix2fvARB(GLint location, GLsizei count, GLboolean transpose, const GLfloat * value); +#define _es_UniformMatrix2fv _mesa_UniformMatrix2fvARB + +extern void GL_APIENTRY _mesa_UniformMatrix3fvARB(GLint location, GLsizei count, GLboolean transpose, const GLfloat * value); +#define _es_UniformMatrix3fv _mesa_UniformMatrix3fvARB + +extern void GL_APIENTRY _mesa_UniformMatrix4fvARB(GLint location, GLsizei count, GLboolean transpose, const GLfloat * value); +#define _es_UniformMatrix4fv _mesa_UniformMatrix4fvARB + +extern GLboolean GL_APIENTRY _mesa_UnmapBufferARB(GLenum target); +static GLboolean GL_APIENTRY _es_UnmapBufferOES(GLenum target) +{ + switch(target) { + case GL_ARRAY_BUFFER: + case GL_ELEMENT_ARRAY_BUFFER: + break; + default: + _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM, "glUnmapBufferOES(target=0x%x)", target); + return GL_FALSE; + } + + return _mesa_UnmapBufferARB(target); +} + +extern void GL_APIENTRY _mesa_UseProgramObjectARB(GLuint program); +#define _es_UseProgram _mesa_UseProgramObjectARB + +extern void GL_APIENTRY _mesa_ValidateProgramARB(GLuint program); +#define _es_ValidateProgram _mesa_ValidateProgramARB + +/* this function is special and is defined elsewhere */ +extern void GL_APIENTRY _es_VertexAttrib1f(GLuint index, GLfloat x); +#define _check_VertexAttrib1f _es_VertexAttrib1f + +/* this function is special and is defined elsewhere */ +extern void GL_APIENTRY _es_VertexAttrib1fv(GLuint index, const GLfloat * v); +#define _check_VertexAttrib1fv _es_VertexAttrib1fv + +/* this function is special and is defined elsewhere */ +extern void GL_APIENTRY _es_VertexAttrib2f(GLuint index, GLfloat x, GLfloat y); +#define _check_VertexAttrib2f _es_VertexAttrib2f + +/* this function is special and is defined elsewhere */ +extern void GL_APIENTRY _es_VertexAttrib2fv(GLuint index, const GLfloat * v); +#define _check_VertexAttrib2fv _es_VertexAttrib2fv + +/* this function is special and is defined elsewhere */ +extern void GL_APIENTRY _es_VertexAttrib3f(GLuint index, GLfloat x, GLfloat y, GLfloat z); +#define _check_VertexAttrib3f _es_VertexAttrib3f + +/* this function is special and is defined elsewhere */ +extern void GL_APIENTRY _es_VertexAttrib3fv(GLuint index, const GLfloat * v); +#define _check_VertexAttrib3fv _es_VertexAttrib3fv + +/* this function is special and is defined elsewhere */ +extern void GL_APIENTRY _es_VertexAttrib4f(GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w); +#define _check_VertexAttrib4f _es_VertexAttrib4f + +/* this function is special and is defined elsewhere */ +extern void GL_APIENTRY _es_VertexAttrib4fv(GLuint index, const GLfloat * v); +#define _check_VertexAttrib4fv _es_VertexAttrib4fv + +extern void GL_APIENTRY _mesa_VertexAttribPointerARB(GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const GLvoid * pointer); +static void GL_APIENTRY _es_VertexAttribPointer(GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const GLvoid *pointer) +{ + switch(size) { + case 1: + case 2: + case 3: + case 4: + break; + default: + _mesa_error(_mesa_get_current_context(), GL_INVALID_VALUE, "glVertexAttribPointer(size=%d)", size); + return; + } + switch(type) { + case GL_BYTE: + case GL_UNSIGNED_BYTE: + case GL_SHORT: + case GL_UNSIGNED_SHORT: + case GL_FLOAT: + case GL_FIXED: + break; + default: + _mesa_error(_mesa_get_current_context(), GL_INVALID_VALUE, "glVertexAttribPointer(type=0x%x)", type); + return; + } + + _mesa_VertexAttribPointerARB(index, size, type, normalized, stride, pointer); +} + +extern void GL_APIENTRY _mesa_Viewport(GLint x, GLint y, GLsizei width, GLsizei height); +#define _es_Viewport _mesa_Viewport + + +#include "glapi/glapi.h" + +#if FEATURE_remap_table + +/* cannot include main/dispatch.h here */ +#define _GLAPI_USE_REMAP_TABLE +#include "es2api/main/glapidispatch.h" + +#define need_MESA_remap_table +#include "es2api/main/remap_helper.h" + +/* force SET_* macros to use the local remap table */ +#define driDispatchRemapTable remap_table +static int remap_table[driDispatchRemapTable_size]; + +static void +init_remap_table(void) +{ + _glthread_DECLARE_STATIC_MUTEX(mutex); + static GLboolean initialized = GL_FALSE; + const struct gl_function_pool_remap *remap = MESA_remap_table_functions; + int i; + + _glthread_LOCK_MUTEX(mutex); + if (initialized) { + _glthread_UNLOCK_MUTEX(mutex); + return; + } + + for (i = 0; i < driDispatchRemapTable_size; i++) { + GLint offset; + const char *spec; + + /* sanity check */ + ASSERT(i == remap[i].remap_index); + spec = _mesa_function_pool + remap[i].pool_index; + + offset = _mesa_map_function_spec(spec); + remap_table[i] = offset; + } + initialized = GL_TRUE; + _glthread_UNLOCK_MUTEX(mutex); +} + +#else /* FEATURE_remap_table */ + +/* cannot include main/dispatch.h here */ +#include "es2api/main/glapidispatch.h" + +static INLINE void +init_remap_table(void) +{ +} + +#endif /* FEATURE_remap_table */ + +struct _glapi_table * +_mesa_create_exec_table_es2(void) +{ + struct _glapi_table *exec; + + exec = _mesa_alloc_dispatch_table(_gloffset_COUNT); + if (exec == NULL) + return NULL; + + init_remap_table(); + + SET_ActiveTexture(exec, _es_ActiveTexture); + SET_AttachShader(exec, _es_AttachShader); + SET_BindAttribLocation(exec, _es_BindAttribLocation); + SET_BindBuffer(exec, _es_BindBuffer); + SET_BindFramebuffer(exec, _es_BindFramebuffer); + SET_BindRenderbuffer(exec, _es_BindRenderbuffer); + SET_BindTexture(exec, _es_BindTexture); + SET_BlendColor(exec, _es_BlendColor); + SET_BlendEquation(exec, _es_BlendEquation); + SET_BlendEquationSeparate(exec, _es_BlendEquationSeparate); + SET_BlendFunc(exec, _es_BlendFunc); + SET_BlendFuncSeparate(exec, _es_BlendFuncSeparate); + SET_BufferData(exec, _es_BufferData); + SET_BufferSubData(exec, _es_BufferSubData); + SET_CheckFramebufferStatus(exec, _es_CheckFramebufferStatus); + SET_Clear(exec, _es_Clear); + SET_ClearColor(exec, _es_ClearColor); + SET_ClearDepthf(exec, _es_ClearDepthf); + SET_ClearStencil(exec, _es_ClearStencil); + SET_ColorMask(exec, _es_ColorMask); + SET_CompileShader(exec, _es_CompileShader); + SET_CompressedTexImage2D(exec, _es_CompressedTexImage2D); + SET_CompressedTexImage3DOES(exec, _es_CompressedTexImage3DOES); + SET_CompressedTexSubImage2D(exec, _es_CompressedTexSubImage2D); + SET_CompressedTexSubImage3DOES(exec, _es_CompressedTexSubImage3DOES); + SET_CopyTexImage2D(exec, _es_CopyTexImage2D); + SET_CopyTexSubImage2D(exec, _es_CopyTexSubImage2D); + SET_CopyTexSubImage3DOES(exec, _es_CopyTexSubImage3DOES); + SET_CreateProgram(exec, _es_CreateProgram); + SET_CreateShader(exec, _es_CreateShader); + SET_CullFace(exec, _es_CullFace); + SET_DeleteBuffers(exec, _es_DeleteBuffers); + SET_DeleteFramebuffers(exec, _es_DeleteFramebuffers); + SET_DeleteProgram(exec, _es_DeleteProgram); + SET_DeleteRenderbuffers(exec, _es_DeleteRenderbuffers); + SET_DeleteShader(exec, _es_DeleteShader); + SET_DeleteTextures(exec, _es_DeleteTextures); + SET_DepthFunc(exec, _es_DepthFunc); + SET_DepthMask(exec, _es_DepthMask); + SET_DepthRangef(exec, _es_DepthRangef); + SET_DetachShader(exec, _es_DetachShader); + SET_Disable(exec, _es_Disable); + SET_DisableVertexAttribArray(exec, _es_DisableVertexAttribArray); + SET_DrawArrays(exec, _es_DrawArrays); + SET_DrawElements(exec, _es_DrawElements); + SET_EGLImageTargetRenderbufferStorageOES(exec, _es_EGLImageTargetRenderbufferStorageOES); + SET_EGLImageTargetTexture2DOES(exec, _es_EGLImageTargetTexture2DOES); + SET_Enable(exec, _es_Enable); + SET_EnableVertexAttribArray(exec, _es_EnableVertexAttribArray); + SET_Finish(exec, _es_Finish); + SET_Flush(exec, _es_Flush); + SET_FramebufferRenderbuffer(exec, _es_FramebufferRenderbuffer); + SET_FramebufferTexture2D(exec, _es_FramebufferTexture2D); + SET_FramebufferTexture3DOES(exec, _es_FramebufferTexture3DOES); + SET_FrontFace(exec, _es_FrontFace); + SET_GenBuffers(exec, _es_GenBuffers); + SET_GenFramebuffers(exec, _es_GenFramebuffers); + SET_GenRenderbuffers(exec, _es_GenRenderbuffers); + SET_GenTextures(exec, _es_GenTextures); + SET_GenerateMipmap(exec, _es_GenerateMipmap); + SET_GetActiveAttrib(exec, _es_GetActiveAttrib); + SET_GetActiveUniform(exec, _es_GetActiveUniform); + SET_GetAttachedShaders(exec, _es_GetAttachedShaders); + SET_GetAttribLocation(exec, _es_GetAttribLocation); + SET_GetBooleanv(exec, _es_GetBooleanv); + SET_GetBufferParameteriv(exec, _es_GetBufferParameteriv); + SET_GetBufferPointervOES(exec, _es_GetBufferPointervOES); + SET_GetError(exec, _es_GetError); + SET_GetFloatv(exec, _es_GetFloatv); + SET_GetFramebufferAttachmentParameteriv(exec, _es_GetFramebufferAttachmentParameteriv); + SET_GetIntegerv(exec, _es_GetIntegerv); + SET_GetProgramInfoLog(exec, _es_GetProgramInfoLog); + SET_GetProgramiv(exec, _es_GetProgramiv); + SET_GetRenderbufferParameteriv(exec, _es_GetRenderbufferParameteriv); + SET_GetShaderInfoLog(exec, _es_GetShaderInfoLog); + SET_GetShaderPrecisionFormat(exec, _es_GetShaderPrecisionFormat); + SET_GetShaderSource(exec, _es_GetShaderSource); + SET_GetShaderiv(exec, _es_GetShaderiv); + SET_GetString(exec, _es_GetString); + SET_GetTexParameterfv(exec, _es_GetTexParameterfv); + SET_GetTexParameteriv(exec, _es_GetTexParameteriv); + SET_GetUniformLocation(exec, _es_GetUniformLocation); + SET_GetUniformfv(exec, _es_GetUniformfv); + SET_GetUniformiv(exec, _es_GetUniformiv); + SET_GetVertexAttribPointerv(exec, _es_GetVertexAttribPointerv); + SET_GetVertexAttribfv(exec, _es_GetVertexAttribfv); + SET_GetVertexAttribiv(exec, _es_GetVertexAttribiv); + SET_Hint(exec, _es_Hint); + SET_IsBuffer(exec, _es_IsBuffer); + SET_IsEnabled(exec, _es_IsEnabled); + SET_IsFramebuffer(exec, _es_IsFramebuffer); + SET_IsProgram(exec, _es_IsProgram); + SET_IsRenderbuffer(exec, _es_IsRenderbuffer); + SET_IsShader(exec, _es_IsShader); + SET_IsTexture(exec, _es_IsTexture); + SET_LineWidth(exec, _es_LineWidth); + SET_LinkProgram(exec, _es_LinkProgram); + SET_MapBufferOES(exec, _es_MapBufferOES); + SET_MultiDrawArraysEXT(exec, _es_MultiDrawArraysEXT); + SET_MultiDrawElementsEXT(exec, _es_MultiDrawElementsEXT); + SET_PixelStorei(exec, _es_PixelStorei); + SET_PolygonOffset(exec, _es_PolygonOffset); + SET_ReadPixels(exec, _es_ReadPixels); + SET_ReleaseShaderCompiler(exec, _es_ReleaseShaderCompiler); + SET_RenderbufferStorage(exec, _check_RenderbufferStorage); + SET_SampleCoverage(exec, _es_SampleCoverage); + SET_Scissor(exec, _es_Scissor); + SET_ShaderBinary(exec, _es_ShaderBinary); + SET_ShaderSource(exec, _es_ShaderSource); + SET_StencilFunc(exec, _es_StencilFunc); + SET_StencilFuncSeparate(exec, _es_StencilFuncSeparate); + SET_StencilMask(exec, _es_StencilMask); + SET_StencilMaskSeparate(exec, _es_StencilMaskSeparate); + SET_StencilOp(exec, _es_StencilOp); + SET_StencilOpSeparate(exec, _es_StencilOpSeparate); + SET_TexImage2D(exec, _es_TexImage2D); + SET_TexImage3DOES(exec, _es_TexImage3DOES); + SET_TexParameterf(exec, _es_TexParameterf); + SET_TexParameterfv(exec, _es_TexParameterfv); + SET_TexParameteri(exec, _es_TexParameteri); + SET_TexParameteriv(exec, _es_TexParameteriv); + SET_TexSubImage2D(exec, _es_TexSubImage2D); + SET_TexSubImage3DOES(exec, _es_TexSubImage3DOES); + SET_Uniform1f(exec, _es_Uniform1f); + SET_Uniform1fv(exec, _es_Uniform1fv); + SET_Uniform1i(exec, _es_Uniform1i); + SET_Uniform1iv(exec, _es_Uniform1iv); + SET_Uniform2f(exec, _es_Uniform2f); + SET_Uniform2fv(exec, _es_Uniform2fv); + SET_Uniform2i(exec, _es_Uniform2i); + SET_Uniform2iv(exec, _es_Uniform2iv); + SET_Uniform3f(exec, _es_Uniform3f); + SET_Uniform3fv(exec, _es_Uniform3fv); + SET_Uniform3i(exec, _es_Uniform3i); + SET_Uniform3iv(exec, _es_Uniform3iv); + SET_Uniform4f(exec, _es_Uniform4f); + SET_Uniform4fv(exec, _es_Uniform4fv); + SET_Uniform4i(exec, _es_Uniform4i); + SET_Uniform4iv(exec, _es_Uniform4iv); + SET_UniformMatrix2fv(exec, _es_UniformMatrix2fv); + SET_UniformMatrix3fv(exec, _es_UniformMatrix3fv); + SET_UniformMatrix4fv(exec, _es_UniformMatrix4fv); + SET_UnmapBufferOES(exec, _es_UnmapBufferOES); + SET_UseProgram(exec, _es_UseProgram); + SET_ValidateProgram(exec, _es_ValidateProgram); + SET_VertexAttrib1f(exec, _check_VertexAttrib1f); + SET_VertexAttrib1fv(exec, _check_VertexAttrib1fv); + SET_VertexAttrib2f(exec, _check_VertexAttrib2f); + SET_VertexAttrib2fv(exec, _check_VertexAttrib2fv); + SET_VertexAttrib3f(exec, _check_VertexAttrib3f); + SET_VertexAttrib3fv(exec, _check_VertexAttrib3fv); + SET_VertexAttrib4f(exec, _check_VertexAttrib4f); + SET_VertexAttrib4fv(exec, _check_VertexAttrib4fv); + SET_VertexAttribPointer(exec, _es_VertexAttribPointer); + SET_Viewport(exec, _es_Viewport); + + return exec; +} + +#endif /* FEATURE_ES2 */ -- cgit v1.2.3 From 88721c8555e1c65cdb1fa57f50e588d169e77915 Mon Sep 17 00:00:00 2001 From: Chia-I Wu Date: Mon, 11 Oct 2010 16:07:09 +0800 Subject: android: Add Android.mk's. --- Android.mk | 3 + src/Android.mk | 86 +++++++++++++ src/egl/Android.mk | 68 ++++++++++ src/gallium/Android.mk | 3 + src/gallium/auxiliary/Android.mk | 213 ++++++++++++++++++++++++++++++++ src/gallium/drivers/Android.mk | 1 + src/gallium/drivers/i915/Android.mk | 48 +++++++ src/gallium/drivers/softpipe/Android.mk | 52 ++++++++ src/gallium/drivers/svga/Android.mk | 73 +++++++++++ src/gallium/state_trackers/Android.mk | 38 ++++++ src/gallium/targets/Android.mk | 157 +++++++++++++++++++++++ src/gallium/winsys/Android.mk | 1 + src/gallium/winsys/i915/Android.mk | 33 +++++ src/gallium/winsys/svga/Android.mk | 39 ++++++ src/gallium/winsys/sw/Android.mk | 19 +++ src/glsl/Android.mk | 96 ++++++++++++++ src/gralloc/Android.mk | 54 ++++++++ src/mapi/Android.mk | 38 ++++++ src/mapi/generate_glapi.mk | 43 +++++++ src/mesa/Android.mk | 80 ++++++++++++ src/mesa/drivers/Android.mk | 129 +++++++++++++++++++ src/talloc/Android.mk | 13 ++ 22 files changed, 1287 insertions(+) create mode 100644 Android.mk create mode 100644 src/Android.mk create mode 100644 src/egl/Android.mk create mode 100644 src/gallium/Android.mk create mode 100644 src/gallium/auxiliary/Android.mk create mode 100644 src/gallium/drivers/Android.mk create mode 100644 src/gallium/drivers/i915/Android.mk create mode 100644 src/gallium/drivers/softpipe/Android.mk create mode 100644 src/gallium/drivers/svga/Android.mk create mode 100644 src/gallium/state_trackers/Android.mk create mode 100644 src/gallium/targets/Android.mk create mode 100644 src/gallium/winsys/Android.mk create mode 100644 src/gallium/winsys/i915/Android.mk create mode 100644 src/gallium/winsys/svga/Android.mk create mode 100644 src/gallium/winsys/sw/Android.mk create mode 100644 src/glsl/Android.mk create mode 100644 src/gralloc/Android.mk create mode 100644 src/mapi/Android.mk create mode 100644 src/mapi/generate_glapi.mk create mode 100644 src/mesa/Android.mk create mode 100644 src/mesa/drivers/Android.mk create mode 100644 src/talloc/Android.mk diff --git a/Android.mk b/Android.mk new file mode 100644 index 00000000000..ba187a6d13f --- /dev/null +++ b/Android.mk @@ -0,0 +1,3 @@ +ifneq ($(TARGET_SIMULATOR),true) +include $(call all-subdir-makefiles) +endif diff --git a/src/Android.mk b/src/Android.mk new file mode 100644 index 00000000000..ea0ff8988a9 --- /dev/null +++ b/src/Android.mk @@ -0,0 +1,86 @@ +LOCAL_PATH := $(call my-dir) + +# build classic static libraries +MESA_BUILD_CLASSIC := false + +# build gallium static libraries +MESA_BUILD_GALLIUM := false + +# build gralloc.i915 +MESA_BUILD_I915 := false + +# build libGLES_i915c +MESA_BUILD_I915C := false + +# build libGLES_swrast +MESA_BUILD_SWRAST := false + +# build gralloc.vmwgfx +MESA_BUILD_VMWGFX := false + +# build libGLES_i915g +MESA_BUILD_I915G := false + +# for testing purpose +#BOARD_USES_I915C := true +#BOARD_USES_I915G := true +#BOARD_USES_VMWGFX := true + +MESA_GRALLOC_NAME := +MESA_GLES_NAME := + +ifeq ($(strip $(BOARD_USES_I915C)),true) +MESA_BUILD_CLASSIC := true +MESA_BUILD_I915 := true +MESA_BUILD_I915C := true + +MESA_GRALLOC_NAME := i915 +MESA_GLES_NAME := i915c +endif + +ifeq ($(strip $(BOARD_USES_I915G)),true) +MESA_BUILD_GALLIUM := true +MESA_BUILD_I915 := true +MESA_BUILD_I915G := true + +MESA_GRALLOC_NAME := i915 +MESA_GLES_NAME := i915g +endif + +ifeq ($(strip $(BOARD_USES_VMWGFX)),true) +MESA_BUILD_GALLIUM := true +MESA_BUILD_SWRAST := true +MESA_BUILD_VMWGFX := true + +MESA_GRALLOC_NAME := vmwgfx +MESA_GLES_NAME := swrast +endif + +ifneq ($(strip $(MESA_GRALLOC_NAME) $(MESA_GLES_NAME)),) + +# build the real modules +include $(call all-subdir-makefiles) + +include $(CLEAR_VARS) + +symlink := $(TARGET_OUT_SHARED_LIBRARIES)/hw/gralloc.$(TARGET_PRODUCT)$(TARGET_SHLIB_SUFFIX) +symlink_to := gralloc.$(MESA_GRALLOC_NAME)$(TARGET_SHLIB_SUFFIX) +$(symlink): PRIVATE_TO := $(symlink_to) +$(symlink): $(TARGET_OUT_SHARED_LIBRARIES)/hw/$(symlink_to) + @echo "Symlink: $@ -> $(PRIVATE_TO)" + @mkdir -p $(dir $@) + @rm -rf $@ + $(hide) ln -sf $(PRIVATE_TO) $@ +ALL_PREBUILT += $(symlink) + +symlink := $(TARGET_OUT_SHARED_LIBRARIES)/egl/libGLES_mesa$(TARGET_SHLIB_SUFFIX) +symlink_to := libGLES_$(MESA_GLES_NAME)$(TARGET_SHLIB_SUFFIX) +$(symlink): PRIVATE_TO := $(symlink_to) +$(symlink): $(TARGET_OUT_SHARED_LIBRARIES)/egl/$(symlink_to) + @echo "Symlink: $@ -> $(PRIVATE_TO)" + @mkdir -p $(dir $@) + @rm -rf $@ + $(hide) ln -sf $(PRIVATE_TO) $@ +ALL_PREBUILT += $(symlink) + +endif # MESA_GRALLOC_NAME || MESA_GLES_NAME diff --git a/src/egl/Android.mk b/src/egl/Android.mk new file mode 100644 index 00000000000..8e89eb012bd --- /dev/null +++ b/src/egl/Android.mk @@ -0,0 +1,68 @@ +LOCAL_PATH := $(call my-dir) + +# from main/Makefile +SOURCES = \ + eglapi.c \ + eglarray.c \ + eglconfig.c \ + eglcontext.c \ + eglcurrent.c \ + egldisplay.c \ + egldriver.c \ + eglfallbacks.c \ + eglglobals.c \ + eglimage.c \ + egllog.c \ + eglmisc.c \ + eglmode.c \ + eglscreen.c \ + eglstring.c \ + eglsurface.c \ + eglsync.c + +include $(CLEAR_VARS) + +LOCAL_SRC_FILES := \ + $(addprefix main/, $(SOURCES)) + +LOCAL_CFLAGS := \ + -DPTHREADS \ + -D_EGL_NATIVE_PLATFORM=_EGL_PLATFORM_ANDROID \ + -D_EGL_DRIVER_SEARCH_DIR=\"/system/lib/egl\" \ + -fvisibility=hidden \ + -Wno-sign-compare + +LOCAL_C_INCLUDES := \ + external/mesa/include + +LOCAL_MODULE := libmesa_egl + +include $(BUILD_STATIC_LIBRARY) + +ifeq ($(strip $(MESA_BUILD_CLASSIC)),true) +include $(CLEAR_VARS) + +LOCAL_SRC_FILES := \ + drivers/android/egl_android.c \ + drivers/android/droid.c \ + drivers/android/droid_core.c \ + drivers/android/droid_image.c + + +LOCAL_CFLAGS := \ + -DPTHREADS \ + -fvisibility=hidden \ + -Wno-sign-compare + +LOCAL_C_INCLUDES := \ + external/mesa/include \ + external/mesa/src/mapi \ + external/mesa/src/egl/main \ + external/mesa/src/gralloc \ + external/drm \ + external/drm/include/drm + +LOCAL_MODULE := libmesa_classic_egl + +include $(BUILD_STATIC_LIBRARY) +endif # MESA_BUILD_CLASSIC diff --git a/src/gallium/Android.mk b/src/gallium/Android.mk new file mode 100644 index 00000000000..32f8a7af3b8 --- /dev/null +++ b/src/gallium/Android.mk @@ -0,0 +1,3 @@ +ifeq ($(strip $(MESA_BUILD_GALLIUM)),true) +include $(call all-subdir-makefiles) +endif diff --git a/src/gallium/auxiliary/Android.mk b/src/gallium/auxiliary/Android.mk new file mode 100644 index 00000000000..7c333051b47 --- /dev/null +++ b/src/gallium/auxiliary/Android.mk @@ -0,0 +1,213 @@ +LOCAL_PATH := $(call my-dir) + +# from Makefile +C_SOURCES = \ + cso_cache/cso_cache.c \ + cso_cache/cso_context.c \ + cso_cache/cso_hash.c \ + draw/draw_context.c \ + draw/draw_fs.c \ + draw/draw_gs.c \ + draw/draw_pipe.c \ + draw/draw_pipe_aaline.c \ + draw/draw_pipe_aapoint.c \ + draw/draw_pipe_clip.c \ + draw/draw_pipe_cull.c \ + draw/draw_pipe_flatshade.c \ + draw/draw_pipe_offset.c \ + draw/draw_pipe_pstipple.c \ + draw/draw_pipe_stipple.c \ + draw/draw_pipe_twoside.c \ + draw/draw_pipe_unfilled.c \ + draw/draw_pipe_util.c \ + draw/draw_pipe_validate.c \ + draw/draw_pipe_vbuf.c \ + draw/draw_pipe_wide_line.c \ + draw/draw_pipe_wide_point.c \ + draw/draw_pt.c \ + draw/draw_pt_emit.c \ + draw/draw_pt_fetch.c \ + draw/draw_pt_fetch_emit.c \ + draw/draw_pt_fetch_shade_emit.c \ + draw/draw_pt_fetch_shade_pipeline.c \ + draw/draw_pt_post_vs.c \ + draw/draw_pt_so_emit.c \ + draw/draw_pt_util.c \ + draw/draw_pt_vsplit.c \ + draw/draw_vertex.c \ + draw/draw_vs.c \ + draw/draw_vs_aos.c \ + draw/draw_vs_aos_io.c \ + draw/draw_vs_aos_machine.c \ + draw/draw_vs_exec.c \ + draw/draw_vs_ppc.c \ + draw/draw_vs_sse.c \ + draw/draw_vs_varient.c \ + indices/u_indices_gen.c \ + indices/u_unfilled_gen.c \ + os/os_misc.c \ + os/os_stream.c \ + os/os_stream_log.c \ + os/os_stream_null.c \ + os/os_stream_stdc.c \ + os/os_stream_str.c \ + os/os_time.c \ + pipebuffer/pb_buffer_fenced.c \ + pipebuffer/pb_buffer_malloc.c \ + pipebuffer/pb_bufmgr_alt.c \ + pipebuffer/pb_bufmgr_cache.c \ + pipebuffer/pb_bufmgr_debug.c \ + pipebuffer/pb_bufmgr_mm.c \ + pipebuffer/pb_bufmgr_ondemand.c \ + pipebuffer/pb_bufmgr_pool.c \ + pipebuffer/pb_bufmgr_slab.c \ + pipebuffer/pb_validate.c \ + rbug/rbug_connection.c \ + rbug/rbug_context.c \ + rbug/rbug_core.c \ + rbug/rbug_demarshal.c \ + rbug/rbug_texture.c \ + rbug/rbug_shader.c \ + rtasm/rtasm_cpu.c \ + rtasm/rtasm_execmem.c \ + rtasm/rtasm_ppc.c \ + rtasm/rtasm_ppc_spe.c \ + rtasm/rtasm_x86sse.c \ + tgsi/tgsi_build.c \ + tgsi/tgsi_dump.c \ + tgsi/tgsi_exec.c \ + tgsi/tgsi_info.c \ + tgsi/tgsi_iterate.c \ + tgsi/tgsi_parse.c \ + tgsi/tgsi_ppc.c \ + tgsi/tgsi_sanity.c \ + tgsi/tgsi_scan.c \ + tgsi/tgsi_sse2.c \ + tgsi/tgsi_text.c \ + tgsi/tgsi_transform.c \ + tgsi/tgsi_ureg.c \ + tgsi/tgsi_util.c \ + translate/translate.c \ + translate/translate_cache.c \ + translate/translate_generic.c \ + translate/translate_sse.c \ + util/u_debug.c \ + util/u_debug_describe.c \ + util/u_debug_refcnt.c \ + util/u_debug_stack.c \ + util/u_debug_symbol.c \ + util/u_dump_defines.c \ + util/u_dump_state.c \ + util/u_bitmask.c \ + util/u_blit.c \ + util/u_blitter.c \ + util/u_cache.c \ + util/u_caps.c \ + util/u_cpu_detect.c \ + util/u_dl.c \ + util/u_draw_quad.c \ + util/u_format.c \ + util/u_format_other.c \ + util/u_format_s3tc.c \ + util/u_format_srgb.c \ + util/u_format_table.c \ + util/u_format_tests.c \ + util/u_format_yuv.c \ + util/u_format_zs.c \ + util/u_framebuffer.c \ + util/u_gen_mipmap.c \ + util/u_half.c \ + util/u_handle_table.c \ + util/u_hash.c \ + util/u_hash_table.c \ + util/u_index_modify.c \ + util/u_keymap.c \ + util/u_linear.c \ + util/u_linkage.c \ + util/u_network.c \ + util/u_math.c \ + util/u_mm.c \ + util/u_rect.c \ + util/u_ringbuffer.c \ + util/u_sampler.c \ + util/u_simple_shaders.c \ + util/u_slab.c \ + util/u_snprintf.c \ + util/u_staging.c \ + util/u_surface.c \ + util/u_surfaces.c \ + util/u_texture.c \ + util/u_tile.c \ + util/u_transfer.c \ + util/u_resource.c \ + util/u_upload_mgr.c + +GENERATED_SOURCES = \ + indices/u_indices_gen.c \ + indices/u_unfilled_gen.c \ + util/u_format_srgb.c \ + util/u_format_table.c \ + util/u_half.c + +include $(CLEAR_VARS) + +LOCAL_SRC_FILES := \ + $(filter-out $(GENERATED_SOURCES), $(C_SOURCES)) + +LOCAL_CFLAGS := \ + -fvisibility=hidden \ + -Wno-sign-compare + +LOCAL_C_INCLUDES := \ + external/mesa/include \ + external/mesa/src/gallium/include \ + external/mesa/src/gallium/auxiliary \ + external/mesa/src/gallium/drivers \ + external/mesa/src/gallium/auxiliary/util + +LOCAL_MODULE := libmesa_gallium +LOCAL_MODULE_CLASS := STATIC_LIBRARIES + +intermediates := $(call local-intermediates-dir) + +GEN_SCRIPT := $(LOCAL_PATH)/indices/u_indices_gen.py +GEN := $(intermediates)/indices/u_indices_gen.c +$(GEN): PRIVATE_CUSTOM_TOOL = python $< > $@ +$(GEN): $(GEN_SCRIPT) + $(transform-generated-source) + +LOCAL_GENERATED_SOURCES += $(GEN) + +GEN_SCRIPT := $(LOCAL_PATH)/indices/u_unfilled_gen.py +GEN := $(intermediates)/indices/u_unfilled_gen.c +$(GEN): PRIVATE_CUSTOM_TOOL = python $< > $@ +$(GEN): $(GEN_SCRIPT) + $(transform-generated-source) + +LOCAL_GENERATED_SOURCES += $(GEN) + +GEN_SCRIPT := $(LOCAL_PATH)/util/u_format_srgb.py +GEN := $(intermediates)/util/u_format_srgb.c +$(GEN): PRIVATE_CUSTOM_TOOL = python $< > $@ +$(GEN): $(GEN_SCRIPT) + $(transform-generated-source) + +LOCAL_GENERATED_SOURCES += $(GEN) + +GEN_SCRIPT := $(LOCAL_PATH)/util/u_format_table.py +GEN := $(intermediates)/util/u_format_table.c +$(GEN): PRIVATE_CUSTOM_TOOL := python $(GEN_SCRIPT) $(LOCAL_PATH)/util/u_format.csv > $(GEN) +$(GEN): $(GEN_SCRIPT) $(LOCAL_PATH)/util/u_format.csv + $(transform-generated-source) + +LOCAL_GENERATED_SOURCES += $(GEN) + +GEN_SCRIPT := $(LOCAL_PATH)/util/u_half.py +GEN := $(intermediates)/util/u_half.c +$(GEN): PRIVATE_CUSTOM_TOOL = python $< > $@ +$(GEN): $(GEN_SCRIPT) + $(transform-generated-source) + +LOCAL_GENERATED_SOURCES += $(GEN) + +include $(BUILD_STATIC_LIBRARY) diff --git a/src/gallium/drivers/Android.mk b/src/gallium/drivers/Android.mk new file mode 100644 index 00000000000..5053e7d6438 --- /dev/null +++ b/src/gallium/drivers/Android.mk @@ -0,0 +1 @@ +include $(call all-subdir-makefiles) diff --git a/src/gallium/drivers/i915/Android.mk b/src/gallium/drivers/i915/Android.mk new file mode 100644 index 00000000000..f2c1e5b5f82 --- /dev/null +++ b/src/gallium/drivers/i915/Android.mk @@ -0,0 +1,48 @@ +ifeq ($(strip $(MESA_BUILD_I915G)),true) + +LOCAL_PATH := $(call my-dir) + +# from Makefile +C_SOURCES = \ + i915_blit.c \ + i915_clear.c \ + i915_flush.c \ + i915_context.c \ + i915_debug.c \ + i915_debug_fp.c \ + i915_state.c \ + i915_state_immediate.c \ + i915_state_dynamic.c \ + i915_state_derived.c \ + i915_state_emit.c \ + i915_state_fpc.c \ + i915_state_sampler.c \ + i915_state_static.c \ + i915_screen.c \ + i915_prim_emit.c \ + i915_prim_vbuf.c \ + i915_resource.c \ + i915_resource_texture.c \ + i915_resource_buffer.c \ + i915_fpc_emit.c \ + i915_fpc_translate.c \ + i915_surface.c + +include $(CLEAR_VARS) + +LOCAL_SRC_FILES := \ + $(C_SOURCES) + +LOCAL_CFLAGS := \ + -fvisibility=hidden \ + -Wno-sign-compare + +LOCAL_C_INCLUDES := \ + external/mesa/src/gallium/include \ + external/mesa/src/gallium/auxiliary + +LOCAL_MODULE := libmesa_pipe_i915 + +include $(BUILD_STATIC_LIBRARY) + +endif # MESA_BUILD_I915G diff --git a/src/gallium/drivers/softpipe/Android.mk b/src/gallium/drivers/softpipe/Android.mk new file mode 100644 index 00000000000..d8a00f44924 --- /dev/null +++ b/src/gallium/drivers/softpipe/Android.mk @@ -0,0 +1,52 @@ +LOCAL_PATH := $(call my-dir) + +# from Makefile +C_SOURCES = \ + sp_fs_exec.c \ + sp_fs_sse.c \ + sp_clear.c \ + sp_fence.c \ + sp_flush.c \ + sp_query.c \ + sp_context.c \ + sp_draw_arrays.c \ + sp_prim_vbuf.c \ + sp_quad_pipe.c \ + sp_quad_stipple.c \ + sp_quad_depth_test.c \ + sp_quad_fs.c \ + sp_quad_blend.c \ + sp_screen.c \ + sp_setup.c \ + sp_state_blend.c \ + sp_state_clip.c \ + sp_state_derived.c \ + sp_state_sampler.c \ + sp_state_shader.c \ + sp_state_so.c \ + sp_state_rasterizer.c \ + sp_state_surface.c \ + sp_state_vertex.c \ + sp_texture.c \ + sp_tex_sample.c \ + sp_tex_tile_cache.c \ + sp_tile_cache.c \ + sp_surface.c + +include $(CLEAR_VARS) + +LOCAL_SRC_FILES := \ + $(C_SOURCES) + +LOCAL_CFLAGS := \ + -fvisibility=hidden \ + -Wno-sign-compare + +LOCAL_C_INCLUDES := \ + external/mesa/include \ + external/mesa/src/gallium/include \ + external/mesa/src/gallium/auxiliary + +LOCAL_MODULE := libmesa_pipe_softpipe + +include $(BUILD_STATIC_LIBRARY) diff --git a/src/gallium/drivers/svga/Android.mk b/src/gallium/drivers/svga/Android.mk new file mode 100644 index 00000000000..c39ee19086c --- /dev/null +++ b/src/gallium/drivers/svga/Android.mk @@ -0,0 +1,73 @@ +ifeq ($(strip $(MESA_BUILD_VMWGFX)),true) + +LOCAL_PATH := $(call my-dir) + +# from Makefile +C_SOURCES = \ + svgadump/svga_shader_dump.c \ + svgadump/svga_shader_op.c \ + svgadump/svga_dump.c \ + svga_cmd.c \ + svga_context.c \ + svga_draw.c \ + svga_draw_arrays.c \ + svga_draw_elements.c \ + svga_pipe_blend.c \ + svga_pipe_blit.c \ + svga_pipe_clear.c \ + svga_pipe_constants.c \ + svga_pipe_depthstencil.c \ + svga_pipe_draw.c \ + svga_pipe_flush.c \ + svga_pipe_fs.c \ + svga_pipe_misc.c \ + svga_pipe_query.c \ + svga_pipe_rasterizer.c \ + svga_pipe_sampler.c \ + svga_pipe_vertex.c \ + svga_pipe_vs.c \ + svga_screen.c \ + svga_screen_cache.c \ + svga_state.c \ + svga_state_need_swtnl.c \ + svga_state_constants.c \ + svga_state_framebuffer.c \ + svga_state_rss.c \ + svga_state_tss.c \ + svga_state_vdecl.c \ + svga_state_fs.c \ + svga_state_vs.c \ + svga_swtnl_backend.c \ + svga_swtnl_draw.c \ + svga_swtnl_state.c \ + svga_tgsi.c \ + svga_tgsi_decl_sm20.c \ + svga_tgsi_decl_sm30.c \ + svga_tgsi_insn.c \ + svga_sampler_view.c \ + svga_surface.c \ + svga_resource.c \ + svga_resource_texture.c \ + svga_resource_buffer.c \ + svga_resource_buffer_upload.c + +include $(CLEAR_VARS) + +LOCAL_SRC_FILES := \ + $(C_SOURCES) + +LOCAL_CFLAGS := \ + -fvisibility=hidden \ + -Wno-sign-compare + +LOCAL_C_INCLUDES := \ + external/mesa/include \ + external/mesa/src/gallium/include \ + external/mesa/src/gallium/auxiliary \ + external/mesa/src/gallium/drivers/svga/include + +LOCAL_MODULE := libmesa_pipe_svga + +include $(BUILD_STATIC_LIBRARY) + +endif # MESA_BUILD_VMWGFX diff --git a/src/gallium/state_trackers/Android.mk b/src/gallium/state_trackers/Android.mk new file mode 100644 index 00000000000..e0ae5375059 --- /dev/null +++ b/src/gallium/state_trackers/Android.mk @@ -0,0 +1,38 @@ +LOCAL_PATH := $(call my-dir) + +common_SOURCES := \ + egl/common/egl_g3d.c \ + egl/common/egl_g3d_api.c \ + egl/common/egl_g3d_image.c \ + egl/common/egl_g3d_st.c \ + egl/common/egl_g3d_sync.c \ + egl/common/native_helper.c + +android_SOURCES := \ + egl/android/native_android.cpp + +include $(CLEAR_VARS) + +LOCAL_SRC_FILES := \ + $(common_SOURCES) \ + $(android_SOURCES) + +LOCAL_CFLAGS := \ + -DHAVE_ANDROID_BACKEND \ + -fvisibility=hidden \ + -Wno-sign-compare + +LOCAL_C_INCLUDES := \ + external/mesa/include \ + external/mesa/src/gallium/include \ + external/mesa/src/gallium/auxiliary \ + external/mesa/src/egl/main \ + external/mesa/src/gallium/state_trackers/egl \ + external/mesa/src/gallium/winsys/sw \ + external/mesa/src/gralloc \ + external/drm \ + external/drm/include/drm + +LOCAL_MODULE := libmesa_st_egl + +include $(BUILD_STATIC_LIBRARY) diff --git a/src/gallium/targets/Android.mk b/src/gallium/targets/Android.mk new file mode 100644 index 00000000000..110284c3c96 --- /dev/null +++ b/src/gallium/targets/Android.mk @@ -0,0 +1,157 @@ +LOCAL_PATH := $(call my-dir) + +gles_SRC_FILES := \ + egl-gdi/egl-static.c + +gles_CFLAGS := \ + -DFEATURE_ES1=1 \ + -DFEATURE_ES2=1 \ + -DGALLIUM_SOFTPIPE \ + -fvisibility=hidden \ + -Wno-sign-compare + +gles_C_INCLUDES := \ + external/mesa/include \ + external/mesa/src/gallium/include \ + external/mesa/src/gallium/auxiliary \ + external/mesa/src/gallium/drivers \ + external/mesa/src/gallium/winsys \ + external/mesa/src/gallium/state_trackers/vega \ + external/mesa/src/gallium/state_trackers/egl \ + external/mesa/src/egl/main \ + external/mesa/src/mesa + +gles_STATIC_LIBRARIES := \ + libmesa_st_egl \ + libmesa_winsys_sw \ + libmesa_pipe_softpipe \ + libmesa_st_mesa \ + libmesa_glsl \ + libmesa_st_mesa \ + libmesa_talloc \ + libmesa_gallium + +gles_WHOLE_STATIC_LIBRARIES := \ + libmesa_egl \ + libmesa_glapi + +gles_SHARED_LIBRARIES := \ + libdl \ + libhardware \ + liblog \ + libcutils + +gralloc_SRC_FILES := + +gralloc_CFLAGS := \ + -fvisibility=hidden \ + -Wno-sign-compare + +gralloc_C_INCLUDES := \ + external/mesa/src/gallium/include \ + external/mesa/src/gallium/auxiliary \ + external/mesa/src/gallium/drivers \ + external/mesa/src/gallium/winsys + +gralloc_STATIC_LIBRARIES := \ + libmesa_gallium + +gralloc_WHOLE_STATIC_LIBRARIES := \ + libmesa_st_gralloc + +gralloc_SHARED_LIBRARIES := \ + libdl \ + liblog \ + libcutils \ + libdrm \ + libEGL + +ifeq ($(strip $(MESA_BUILD_SWRAST)),true) +include $(CLEAR_VARS) + +LOCAL_SRC_FILES := \ + $(gles_SRC_FILES) + +LOCAL_CFLAGS := \ + $(gles_CFLAGS) + +LOCAL_C_INCLUDES := \ + $(gles_C_INCLUDES) + +LOCAL_STATIC_LIBRARIES := \ + $(gles_STATIC_LIBRARIES) + +LOCAL_WHOLE_STATIC_LIBRARIES := \ + $(gles_WHOLE_STATIC_LIBRARIES) + +LOCAL_SHARED_LIBRARIES := \ + $(gles_SHARED_LIBRARIES) + +LOCAL_MODULE := libGLES_swrast +LOCAL_MODULE_PATH := $(TARGET_OUT_SHARED_LIBRARIES)/egl + +include $(BUILD_SHARED_LIBRARY) +endif # MESA_BUILD_SWRAST + +ifeq ($(strip $(MESA_BUILD_I915G)),true) +include $(CLEAR_VARS) + +LOCAL_SRC_FILES := \ + $(gles_SRC_FILES) \ + egl/pipe_i915.c + +LOCAL_CFLAGS := \ + $(gles_CFLAGS) \ + -DFEATURE_DRM=1 + +LOCAL_C_INCLUDES := \ + $(gles_C_INCLUDES) + +LOCAL_STATIC_LIBRARIES := \ + libmesa_winsys_i915 \ + libmesa_pipe_i915 \ + $(gles_STATIC_LIBRARIES) + +LOCAL_WHOLE_STATIC_LIBRARIES := \ + $(gles_WHOLE_STATIC_LIBRARIES) + +LOCAL_SHARED_LIBRARIES := \ + $(gles_SHARED_LIBRARIES) \ + libdrm \ + libdrm_intel + +LOCAL_MODULE := libGLES_i915g +LOCAL_MODULE_PATH := $(TARGET_OUT_SHARED_LIBRARIES)/egl + +include $(BUILD_SHARED_LIBRARY) +endif # MESA_BUILD_I915G + +ifeq ($(strip $(MESA_BUILD_VMWGFX)),true) +include $(CLEAR_VARS) + +LOCAL_SRC_FILES := \ + egl/pipe_vmwgfx.c \ + $(gralloc_SRC_FILES) + +LOCAL_CFLAGS := \ + $(gralloc_CFLAGS) + +LOCAL_C_INCLUDES := \ + $(gralloc_C_INCLUDES) + +LOCAL_STATIC_LIBRARIES := \ + libmesa_pipe_svga \ + libmesa_winsys_svga \ + $(gralloc_STATIC_LIBRARIES) + +LOCAL_WHOLE_STATIC_LIBRARIES := \ + $(gralloc_WHOLE_STATIC_LIBRARIES) + +LOCAL_SHARED_LIBRARIES := \ + $(gralloc_SHARED_LIBRARIES) + +LOCAL_MODULE := gralloc.vmwgfx +LOCAL_MODULE_PATH := $(TARGET_OUT_SHARED_LIBRARIES)/hw + +include $(BUILD_SHARED_LIBRARY) +endif # MESA_BUILD_VMWGFX diff --git a/src/gallium/winsys/Android.mk b/src/gallium/winsys/Android.mk new file mode 100644 index 00000000000..5053e7d6438 --- /dev/null +++ b/src/gallium/winsys/Android.mk @@ -0,0 +1 @@ +include $(call all-subdir-makefiles) diff --git a/src/gallium/winsys/i915/Android.mk b/src/gallium/winsys/i915/Android.mk new file mode 100644 index 00000000000..1810b76e547 --- /dev/null +++ b/src/gallium/winsys/i915/Android.mk @@ -0,0 +1,33 @@ +ifeq ($(strip $(MESA_BUILD_I915G)),true) + +LOCAL_PATH := $(call my-dir) + +# from drm/Makefile +C_SOURCES = \ + i915_drm_batchbuffer.c \ + i915_drm_buffer.c \ + i915_drm_fence.c \ + i915_drm_winsys.c + +include $(CLEAR_VARS) + +LOCAL_SRC_FILES := \ + $(addprefix drm/, $(C_SOURCES)) + +LOCAL_CFLAGS := \ + -fvisibility=hidden \ + -Wno-sign-compare + +LOCAL_C_INCLUDES := \ + external/mesa/src/gallium/include \ + external/mesa/src/gallium/auxiliary \ + external/mesa/src/gallium/drivers \ + external/drm \ + external/drm/include/drm \ + external/drm/intel + +LOCAL_MODULE := libmesa_winsys_i915 + +include $(BUILD_STATIC_LIBRARY) + +endif # MESA_BUILD_I915G diff --git a/src/gallium/winsys/svga/Android.mk b/src/gallium/winsys/svga/Android.mk new file mode 100644 index 00000000000..61c99fb524f --- /dev/null +++ b/src/gallium/winsys/svga/Android.mk @@ -0,0 +1,39 @@ +ifeq ($(strip $(MESA_BUILD_VMWGFX)),true) + +LOCAL_PATH := $(call my-dir) + +# from drm/Makefile +C_SOURCES = \ + vmw_buffer.c \ + vmw_context.c \ + vmw_fence.c \ + vmw_screen.c \ + vmw_screen_dri.c \ + vmw_screen_ioctl.c \ + vmw_screen_pools.c \ + vmw_screen_svga.c \ + vmw_surface.c + +include $(CLEAR_VARS) + +LOCAL_SRC_FILES := \ + $(addprefix drm/, $(C_SOURCES)) + +LOCAL_CFLAGS := \ + -fvisibility=hidden \ + -Wno-sign-compare + +LOCAL_C_INCLUDES := \ + external/mesa/include \ + external/mesa/src/gallium/include \ + external/mesa/src/gallium/auxiliary \ + external/mesa/src/gallium/drivers/svga \ + external/mesa/src/gallium/drivers/svga/include \ + external/drm \ + external/drm/include/drm + +LOCAL_MODULE := libmesa_winsys_svga + +include $(BUILD_STATIC_LIBRARY) + +endif # MESA_BUILD_VMWGFX diff --git a/src/gallium/winsys/sw/Android.mk b/src/gallium/winsys/sw/Android.mk new file mode 100644 index 00000000000..368d9ee9753 --- /dev/null +++ b/src/gallium/winsys/sw/Android.mk @@ -0,0 +1,19 @@ +LOCAL_PATH := $(call my-dir) + +include $(CLEAR_VARS) + +LOCAL_SRC_FILES := \ + android/android_sw_winsys.cpp + +LOCAL_CFLAGS := \ + -fvisibility=hidden \ + -Wno-sign-compare + +LOCAL_C_INCLUDES := \ + external/mesa/include \ + external/mesa/src/gallium/include \ + external/mesa/src/gallium/auxiliary + +LOCAL_MODULE := libmesa_winsys_sw + +include $(BUILD_STATIC_LIBRARY) diff --git a/src/glsl/Android.mk b/src/glsl/Android.mk new file mode 100644 index 00000000000..a69943604c8 --- /dev/null +++ b/src/glsl/Android.mk @@ -0,0 +1,96 @@ +LOCAL_PATH := $(call my-dir) + +# from Makefile +LIBGLCPP_SOURCES = \ + glcpp/glcpp-lex.c \ + glcpp/glcpp-parse.c \ + glcpp/pp.c + +C_SOURCES = \ + $(LIBGLCPP_SOURCES) + +CXX_SOURCES = \ + ast_expr.cpp \ + ast_function.cpp \ + ast_to_hir.cpp \ + ast_type.cpp \ + builtin_function.cpp \ + glsl_lexer.cpp \ + glsl_parser.cpp \ + glsl_parser_extras.cpp \ + glsl_types.cpp \ + glsl_symbol_table.cpp \ + hir_field_selection.cpp \ + ir_basic_block.cpp \ + ir_clone.cpp \ + ir_constant_expression.cpp \ + ir.cpp \ + ir_expression_flattening.cpp \ + ir_function_can_inline.cpp \ + ir_function.cpp \ + ir_hierarchical_visitor.cpp \ + ir_hv_accept.cpp \ + ir_import_prototypes.cpp \ + ir_print_visitor.cpp \ + ir_reader.cpp \ + ir_rvalue_visitor.cpp \ + ir_set_program_inouts.cpp \ + ir_validate.cpp \ + ir_variable.cpp \ + ir_variable_refcount.cpp \ + linker.cpp \ + link_functions.cpp \ + loop_analysis.cpp \ + loop_controls.cpp \ + loop_unroll.cpp \ + lower_discard.cpp \ + lower_if_to_cond_assign.cpp \ + lower_instructions.cpp \ + lower_jumps.cpp \ + lower_mat_op_to_vec.cpp \ + lower_noise.cpp \ + lower_texture_projection.cpp \ + lower_variable_index_to_cond_assign.cpp \ + lower_vec_index_to_cond_assign.cpp \ + lower_vec_index_to_swizzle.cpp \ + lower_vector.cpp \ + opt_algebraic.cpp \ + opt_constant_folding.cpp \ + opt_constant_propagation.cpp \ + opt_constant_variable.cpp \ + opt_copy_propagation.cpp \ + opt_dead_code.cpp \ + opt_dead_code_local.cpp \ + opt_dead_functions.cpp \ + opt_discard_simplification.cpp \ + opt_function_inlining.cpp \ + opt_if_simplification.cpp \ + opt_noop_swizzle.cpp \ + opt_redundant_jumps.cpp \ + opt_structure_splitting.cpp \ + opt_swizzle_swizzle.cpp \ + opt_tree_grafting.cpp \ + s_expression.cpp + +include $(CLEAR_VARS) + +LOCAL_SRC_FILES := \ + $(C_SOURCES) \ + $(CXX_SOURCES) + +LOCAL_CFLAGS := \ + -DPTHREADS \ + -fvisibility=hidden \ + -Wno-sign-compare \ + -Wno-error=non-virtual-dtor \ + -Wno-non-virtual-dtor + +LOCAL_C_INCLUDES := \ + external/mesa/include \ + external/mesa/src/mapi \ + external/mesa/src/talloc \ + external/mesa/src/mesa + +LOCAL_MODULE := libmesa_glsl + +include $(BUILD_STATIC_LIBRARY) diff --git a/src/gralloc/Android.mk b/src/gralloc/Android.mk new file mode 100644 index 00000000000..4125548735b --- /dev/null +++ b/src/gralloc/Android.mk @@ -0,0 +1,54 @@ +LOCAL_PATH := $(call my-dir) + +common_SRC_FILES := \ + gralloc_gem.c \ + gralloc_kms.c \ + gralloc_mod.c + +common_C_INCLUDES := \ + external/drm \ + external/drm/include/drm + +common_SHARED_LIBRARIES := \ + libdrm \ + liblog \ + libcutils + +ifeq ($(strip $(MESA_BUILD_I915)),true) +include $(CLEAR_VARS) + +LOCAL_SRC_FILES := \ + $(common_SRC_FILES) \ + gralloc_gem_i915.c + +LOCAL_C_INCLUDES := \ + $(common_C_INCLUDES) \ + external/drm/intel + +LOCAL_SHARED_LIBRARIES := \ + $(common_SHARED_LIBRARIES) \ + libdrm_intel \ + libEGL + +LOCAL_MODULE_PATH := $(TARGET_OUT_SHARED_LIBRARIES)/hw +LOCAL_MODULE := gralloc.i915 + +include $(BUILD_SHARED_LIBRARY) +endif # MESA_BUILD_I915 + +ifeq ($(strip $(MESA_BUILD_GALLIUM)),true) +include $(CLEAR_VARS) + +LOCAL_SRC_FILES := \ + $(common_SRC_FILES) \ + gralloc_gem_pipe.c + +LOCAL_C_INCLUDES := \ + $(common_C_INCLUDES) \ + external/mesa/src/gallium/include \ + external/mesa/src/gallium/auxiliary + +LOCAL_MODULE := libmesa_st_gralloc + +include $(BUILD_STATIC_LIBRARY) +endif # MESA_BUILD_GALLIUM diff --git a/src/mapi/Android.mk b/src/mapi/Android.mk new file mode 100644 index 00000000000..c4737165432 --- /dev/null +++ b/src/mapi/Android.mk @@ -0,0 +1,38 @@ +LOCAL_PATH := $(call my-dir) + +include $(LOCAL_PATH)/glapi/sources.mak +include $(LOCAL_PATH)/mapi/sources.mak +glapi_SOURCES := \ + $(addprefix glapi/, $(GLAPI_SOURCES)) \ + $(addprefix mapi/, $(MAPI_GLAPI_SOURCES)) + +glapi_CFLAGS := \ + -DPTHREADS \ + -DMAPI_GLAPI_CURRENT \ + -fvisibility=hidden \ + -Wno-sign-compare + +glapi_C_INCLUDES := \ + external/mesa/include \ + external/mesa/src/mapi + +include $(CLEAR_VARS) + +LOCAL_MODULE := libmesa_glapi + +LOCAL_SRC_FILES := $(glapi_SOURCES) +LOCAL_CFLAGS := $(glapi_CFLAGS) + +## generate glapi headers +#intermediates := $(call local-intermediates-dir) +#glapi_OUT := $(intermediates)/es1api +#glapi_XML := $(LOCAL_PATH)/glapi/gen-es/es1_API.xml +#include $(LOCAL_PATH)/generate_glapi.mk +# +## depend on the generated headers +#$(intermediates)/%.o: $(LOCAL_GENERATED_SOURCES) +glapi_OUT := external/mesa/src/mapi/es1api + +LOCAL_C_INCLUDES := $(glapi_OUT) $(glapi_C_INCLUDES) + +include $(BUILD_STATIC_LIBRARY) diff --git a/src/mapi/generate_glapi.mk b/src/mapi/generate_glapi.mk new file mode 100644 index 00000000000..604983ea698 --- /dev/null +++ b/src/mapi/generate_glapi.mk @@ -0,0 +1,43 @@ +GLAPI := $(LOCAL_PATH)/glapi/gen + +GEN := $(glapi_OUT)/glapi/glapidispatch.h +$(GEN): PRIVATE_CUSTOM_TOOL := python $(GLAPI)/gl_table.py -f $(glapi_XML) -c -m remap_table > $(GEN) +$(GEN): $(glapi_XML) + $(transform-generated-source) + +LOCAL_GENERATED_SOURCES += $(GEN) + +GEN := $(glapi_OUT)/glapi/glapioffsets.h +$(GEN): PRIVATE_CUSTOM_TOOL := python $(GLAPI)/gl_offsets.py -f $(glapi_XML) -c > $(GEN) +$(GEN): $(glapi_XML) + $(transform-generated-source) + +LOCAL_GENERATED_SOURCES += $(GEN) + +GEN := $(glapi_OUT)/glapi/glapitable.h +$(GEN): PRIVATE_CUSTOM_TOOL := python $(GLAPI)/gl_table.py -f $(glapi_XML) -c > $(GEN) +$(GEN): $(glapi_XML) + $(transform-generated-source) + +LOCAL_GENERATED_SOURCES += $(GEN) + +GEN := $(glapi_OUT)/glapi/glapitemp.h +$(GEN): PRIVATE_CUSTOM_TOOL := python $(GLAPI)/gl_apitemp.py -f $(glapi_XML) -c > $(GEN) +$(GEN): $(glapi_XML) + $(transform-generated-source) + +LOCAL_GENERATED_SOURCES += $(GEN) + +GEN := $(glapi_OUT)/glapi/glprocs.h +$(GEN): PRIVATE_CUSTOM_TOOL := python $(GLAPI)/gl_procs.py -f $(glapi_XML) -c > $(GEN) +$(GEN): $(glapi_XML) + $(transform-generated-source) + +LOCAL_GENERATED_SOURCES += $(GEN) + +GEN := $(glapi_OUT)/main/remap_helper.h +$(GEN): PRIVATE_CUSTOM_TOOL := python $(GLAPI)/remap_helper.py -f $(glapi_XML) > $(GEN) +$(GEN): $(glapi_XML) + $(transform-generated-source) + +LOCAL_GENERATED_SOURCES += $(GEN) diff --git a/src/mesa/Android.mk b/src/mesa/Android.mk new file mode 100644 index 00000000000..5f1b1341f92 --- /dev/null +++ b/src/mesa/Android.mk @@ -0,0 +1,80 @@ +LOCAL_PATH := $(call my-dir) + +include $(LOCAL_PATH)/sources.mak + +common_CFLAGS := \ + -DPTHREADS \ + -DFEATURE_ES1=1 \ + -DFEATURE_ES2=1 \ + -fvisibility=hidden \ + -Wno-sign-compare + +common_C_INCLUDES := \ + external/mesa/include \ + external/mesa/src/mapi \ + external/mesa/src/glsl \ + external/mesa/src/talloc + +ifeq ($(strip $(MESA_BUILD_GALLIUM)),true) +include $(CLEAR_VARS) + +LOCAL_SRC_FILES := \ + $(filter-out $(MAIN_ES_SOURCES), $(MESA_GALLIUM_SOURCES)) \ + $(MESA_GALLIUM_CXX_SOURCES) + +LOCAL_CFLAGS := \ + $(common_CFLAGS) + +LOCAL_C_INCLUDES := \ + $(common_C_INCLUDES) \ + external/mesa/src/gallium/include \ + external/mesa/src/gallium/auxiliary + +LOCAL_MODULE := libmesa_st_mesa +LOCAL_MODULE_CLASS := STATIC_LIBRARIES + +#GEN_SCRIPT := python $(LOCAL_PATH)/main/es_generator.py +#intermediates := $(call local-intermediates-dir) +# +#GEN := $(intermediates)/main/api_exec_es1.c +#$(GEN): PRIVATE_CUSTOM_TOOL = $(GEN_SCRIPT) -S $< -V GLES1.1 > $@ +#$(GEN): $(LOCAL_PATH)/main/APIspec.xml +# $(transform-generated-source) +# +#LOCAL_GENERATED_SOURCES += $(GEN) +# +#GEN := $(intermediates)/main/api_exec_es2.c +#$(GEN): PRIVATE_CUSTOM_TOOL = $(GEN_SCRIPT) -S $< -V GLES2.0 > $@ +#$(GEN): $(LOCAL_PATH)/main/APIspec.xml +# $(transform-generated-source) +# +#LOCAL_GENERATED_SOURCES += $(GEN) +# +#LOCAL_C_INCLUDES += \ +# $(call intermediates-dir-for,SHARED_LIBRARIES,libGLESv1_CM_mesa) \ +# $(call intermediates-dir-for,SHARED_LIBRARIES,libGLESv2_mesa) +LOCAL_SRC_FILES += $(MAIN_ES_SOURCES) + +include $(BUILD_STATIC_LIBRARY) +endif # MESA_BUILD_GALLIUM + +ifeq ($(strip $(MESA_BUILD_CLASSIC)),true) +include $(CLEAR_VARS) + +LOCAL_SRC_FILES := \ + $(MESA_SOURCES) \ + $(MESA_CXX_SOURCES) + +LOCAL_CFLAGS := \ + $(common_CFLAGS) \ + -DFEATURE_GL=1 + +LOCAL_C_INCLUDES := \ + $(common_C_INCLUDES) + +LOCAL_MODULE := libmesa_classic_mesa + +include $(BUILD_STATIC_LIBRARY) + +include $(call all-makefiles-under,$(LOCAL_PATH)) +endif # MESA_BUILD_CLASSIC diff --git a/src/mesa/drivers/Android.mk b/src/mesa/drivers/Android.mk new file mode 100644 index 00000000000..219eacc2281 --- /dev/null +++ b/src/mesa/drivers/Android.mk @@ -0,0 +1,129 @@ +LOCAL_PATH := $(call my-dir) + +# from dri/Makefile.template +COMMON_SOURCES = \ + dri/common/utils.c \ + dri/common/vblank.c \ + dri/common/dri_util.c \ + dri/common/xmlconfig.c \ + dri/common/texmem.c \ + dri/common/drirenderbuffer.c \ + dri/common/dri_metaops.c \ + common/driverfuncs.c + +# from dri/i915/Makefile +i915_DRIVER_SOURCES = \ + i830_context.c \ + i830_state.c \ + i830_texblend.c \ + i830_texstate.c \ + i830_vtbl.c \ + intel_render.c \ + intel_regions.c \ + intel_buffer_objects.c \ + intel_batchbuffer.c \ + intel_clear.c \ + intel_extensions.c \ + intel_extensions_es2.c \ + intel_mipmap_tree.c \ + intel_tex_layout.c \ + intel_tex_image.c \ + intel_tex_subimage.c \ + intel_tex_copy.c \ + intel_tex_validate.c \ + intel_tex_format.c \ + intel_tex.c \ + intel_pixel.c \ + intel_pixel_bitmap.c \ + intel_pixel_copy.c \ + intel_pixel_draw.c \ + intel_pixel_read.c \ + intel_buffers.c \ + intel_blit.c \ + i915_tex_layout.c \ + i915_texstate.c \ + i915_context.c \ + i915_debug.c \ + i915_debug_fp.c \ + i915_fragprog.c \ + i915_program.c \ + i915_state.c \ + i915_vtbl.c \ + intel_context.c \ + intel_decode.c \ + intel_screen.c \ + intel_span.c \ + intel_state.c \ + intel_syncobj.c \ + intel_tris.c \ + intel_fbo.c +i915_DRIVER_SOURCES := $(addprefix dri/i915/, $(i915_DRIVER_SOURCES)) + +common_CFLAGS := \ + -DPTHREADS \ + -DFEATURE_GL=1 \ + -DFEATURE_ES1=1 \ + -fvisibility=hidden \ + -Wno-sign-compare + +common_C_INCLUDES := \ + external/mesa/include \ + external/mesa/src/mapi \ + external/mesa/src/glsl \ + external/mesa/src/talloc \ + external/mesa/src/mesa \ + external/mesa/src/mesa/drivers/dri/common \ + external/drm/ \ + external/drm/include/drm \ + external/expat/lib + +common_STATIC_LIBRARIES := \ + libmesa_classic_mesa \ + libmesa_glsl \ + libmesa_classic_mesa \ + libmesa_talloc \ + libmesa_classic_egl + +common_WHOLE_STATIC_LIBRARIES := \ + libmesa_egl \ + libmesa_glapi + +common_SHARED_LIBRARIES := \ + libdl \ + libdrm \ + libexpat \ + libhardware \ + liblog \ + libcutils + +ifeq ($(strip $(MESA_BUILD_I915C)),true) +include $(CLEAR_VARS) + +LOCAL_SRC_FILES := \ + $(COMMON_SOURCES) \ + $(i915_DRIVER_SOURCES) + +LOCAL_CFLAGS := \ + $(common_CFLAGS) \ + -DI915 + +LOCAL_C_INCLUDES := \ + $(common_C_INCLUDES) \ + external/mesa/src/mesa/drivers/dri/intel \ + external/drm/intel + +LOCAL_STATIC_LIBRARIES := \ + $(common_STATIC_LIBRARIES) + +LOCAL_WHOLE_STATIC_LIBRARIES := \ + $(common_WHOLE_STATIC_LIBRARIES) + +LOCAL_SHARED_LIBRARIES := \ + $(common_SHARED_LIBRARIES) \ + libdrm_intel + +LOCAL_MODULE_PATH := $(TARGET_OUT_SHARED_LIBRARIES)/egl +LOCAL_MODULE := libGLES_i915c + +include $(BUILD_SHARED_LIBRARY) +endif # MESA_BUILD_I915C diff --git a/src/talloc/Android.mk b/src/talloc/Android.mk new file mode 100644 index 00000000000..375c7e633dc --- /dev/null +++ b/src/talloc/Android.mk @@ -0,0 +1,13 @@ +LOCAL_PATH := $(call my-dir) + +include $(CLEAR_VARS) + +LOCAL_SRC_FILES := \ + talloc.c + +LOCAL_CFLAGS := \ + -fvisibility=hidden + +LOCAL_MODULE := libmesa_talloc + +include $(BUILD_STATIC_LIBRARY) -- cgit v1.2.3 From 6269411b816b441e17545f60a6442362ba6599d0 Mon Sep 17 00:00:00 2001 From: Chih-Wei Huang Date: Wed, 10 Nov 2010 10:28:12 +0800 Subject: android: enable support of i965c --- src/Android.mk | 10 +++ src/mesa/drivers/Android.mk | 136 +++++++++++++++++++++++++++++++ src/mesa/drivers/dri/i965/brw_wm_pass2.c | 2 +- 3 files changed, 147 insertions(+), 1 deletion(-) diff --git a/src/Android.mk b/src/Android.mk index ea0ff8988a9..66f2f913121 100644 --- a/src/Android.mk +++ b/src/Android.mk @@ -24,6 +24,7 @@ MESA_BUILD_I915G := false # for testing purpose #BOARD_USES_I915C := true #BOARD_USES_I915G := true +#BOARD_USES_I965C := true #BOARD_USES_VMWGFX := true MESA_GRALLOC_NAME := @@ -47,6 +48,15 @@ MESA_GRALLOC_NAME := i915 MESA_GLES_NAME := i915g endif +ifeq ($(strip $(BOARD_USES_I965C)),true) +MESA_BUILD_CLASSIC := true +MESA_BUILD_I915 := true +MESA_BUILD_I965C := true + +MESA_GRALLOC_NAME := i915 +MESA_GLES_NAME := i965c +endif + ifeq ($(strip $(BOARD_USES_VMWGFX)),true) MESA_BUILD_GALLIUM := true MESA_BUILD_SWRAST := true diff --git a/src/mesa/drivers/Android.mk b/src/mesa/drivers/Android.mk index 219eacc2281..28f5beb5f7a 100644 --- a/src/mesa/drivers/Android.mk +++ b/src/mesa/drivers/Android.mk @@ -59,6 +59,110 @@ i915_DRIVER_SOURCES = \ intel_fbo.c i915_DRIVER_SOURCES := $(addprefix dri/i915/, $(i915_DRIVER_SOURCES)) +i965_DRIVER_SOURCES = \ + intel_batchbuffer.c \ + intel_blit.c \ + intel_buffer_objects.c \ + intel_buffers.c \ + intel_clear.c \ + intel_context.c \ + intel_decode.c \ + intel_extensions.c \ + intel_extensions_es2.c \ + intel_fbo.c \ + intel_mipmap_tree.c \ + intel_regions.c \ + intel_screen.c \ + intel_span.c \ + intel_pixel.c \ + intel_pixel_bitmap.c \ + intel_pixel_copy.c \ + intel_pixel_draw.c \ + intel_pixel_read.c \ + intel_state.c \ + intel_syncobj.c \ + intel_tex.c \ + intel_tex_copy.c \ + intel_tex_format.c \ + intel_tex_image.c \ + intel_tex_layout.c \ + intel_tex_subimage.c \ + intel_tex_validate.c \ + brw_cc.c \ + brw_clip.c \ + brw_clip_line.c \ + brw_clip_point.c \ + brw_clip_state.c \ + brw_clip_tri.c \ + brw_clip_unfilled.c \ + brw_clip_util.c \ + brw_context.c \ + brw_curbe.c \ + brw_disasm.c \ + brw_draw.c \ + brw_draw_upload.c \ + brw_eu.c \ + brw_eu_debug.c \ + brw_eu_emit.c \ + brw_eu_util.c \ + brw_fallback.c \ + brw_gs.c \ + brw_gs_emit.c \ + brw_gs_state.c \ + brw_misc_state.c \ + brw_optimize.c \ + brw_program.c \ + brw_queryobj.c \ + brw_sf.c \ + brw_sf_emit.c \ + brw_sf_state.c \ + brw_state.c \ + brw_state_batch.c \ + brw_state_cache.c \ + brw_state_dump.c \ + brw_state_upload.c \ + brw_tex.c \ + brw_tex_layout.c \ + brw_urb.c \ + brw_util.c \ + brw_vs.c \ + brw_vs_constval.c \ + brw_vs_emit.c \ + brw_vs_state.c \ + brw_vs_surface_state.c \ + brw_vtbl.c \ + brw_wm.c \ + brw_wm_debug.c \ + brw_wm_emit.c \ + brw_wm_fp.c \ + brw_wm_iz.c \ + brw_wm_pass0.c \ + brw_wm_pass1.c \ + brw_wm_pass2.c \ + brw_wm_sampler_state.c \ + brw_wm_state.c \ + brw_wm_surface_state.c \ + gen6_cc.c \ + gen6_clip_state.c \ + gen6_depthstencil.c \ + gen6_gs_state.c \ + gen6_sampler_state.c \ + gen6_scissor_state.c \ + gen6_sf_state.c \ + gen6_urb.c \ + gen6_viewport_state.c \ + gen6_vs_state.c \ + gen6_wm_state.c +i965_CXX_SOURCES = \ + brw_cubemap_normalize.cpp \ + brw_fs.cpp \ + brw_fs_channel_expressions.cpp \ + brw_fs_reg_allocate.cpp \ + brw_fs_vector_splitting.cpp +i965_DRIVER_SOURCES := \ + $(addprefix dri/i965/, $(i965_DRIVER_SOURCES)) \ + $(addprefix dri/i965/, $(i965_CXX_SOURCES)) + common_CFLAGS := \ -DPTHREADS \ -DFEATURE_GL=1 \ @@ -127,3 +231,35 @@ LOCAL_MODULE := libGLES_i915c include $(BUILD_SHARED_LIBRARY) endif # MESA_BUILD_I915C + +ifeq ($(strip $(MESA_BUILD_I965C)),true) +include $(CLEAR_VARS) + +LOCAL_SRC_FILES := \ + $(COMMON_SOURCES) \ + $(i965_DRIVER_SOURCES) + +LOCAL_CFLAGS := \ + $(common_CFLAGS) \ + -DI965 + +LOCAL_C_INCLUDES := \ + $(common_C_INCLUDES) \ + external/mesa/src/mesa/drivers/dri/intel \ + external/drm/intel + +LOCAL_STATIC_LIBRARIES := \ + $(common_STATIC_LIBRARIES) + +LOCAL_WHOLE_STATIC_LIBRARIES := \ + $(common_WHOLE_STATIC_LIBRARIES) + +LOCAL_SHARED_LIBRARIES := \ + $(common_SHARED_LIBRARIES) \ + libdrm_intel + +LOCAL_MODULE_PATH := $(TARGET_OUT_SHARED_LIBRARIES)/egl +LOCAL_MODULE := libGLES_i965c + +include $(BUILD_SHARED_LIBRARY) +endif # MESA_BUILD_I965C diff --git a/src/mesa/drivers/dri/i965/brw_wm_pass2.c b/src/mesa/drivers/dri/i965/brw_wm_pass2.c index 8c2b9e7020b..b55c354101b 100644 --- a/src/mesa/drivers/dri/i965/brw_wm_pass2.c +++ b/src/mesa/drivers/dri/i965/brw_wm_pass2.c @@ -85,7 +85,7 @@ static void init_registers( struct brw_wm_compile *c ) prealloc_reg(c, &c->creg[j], i++); if (intel->gen >= 6) { - for (unsigned int j = 0; j < FRAG_ATTRIB_MAX; j++) { + for (j = 0; j < FRAG_ATTRIB_MAX; j++) { if (brw->fragment_program->Base.InputsRead & BITFIELD64_BIT(j)) { nr_interp_regs++; prealloc_reg(c, &c->payload.input_interp[j], i++); -- cgit v1.2.3 From f7a0636329f2ea7f3fe618849de8e154732c2a1c Mon Sep 17 00:00:00 2001 From: Chia-I Wu Date: Sat, 11 Dec 2010 21:42:15 +0800 Subject: i965: Add support for GL_FIXED. --- src/mesa/drivers/dri/i965/brw_draw_upload.c | 49 ++++++++++++++++++++++++++++- 1 file changed, 48 insertions(+), 1 deletion(-) diff --git a/src/mesa/drivers/dri/i965/brw_draw_upload.c b/src/mesa/drivers/dri/i965/brw_draw_upload.c index 2cefe614dd2..405e161bdbb 100644 --- a/src/mesa/drivers/dri/i965/brw_draw_upload.c +++ b/src/mesa/drivers/dri/i965/brw_draw_upload.c @@ -191,6 +191,7 @@ static GLuint get_surface_type( GLenum type, GLuint size, else { return ubyte_types_norm[size]; } + case GL_FIXED: return float_types[size]; /* was uploaded as floats */ default: assert(0); return 0; } } @@ -206,6 +207,7 @@ static GLuint get_surface_type( GLenum type, GLuint size, case GL_UNSIGNED_INT: return uint_types_scale[size]; case GL_UNSIGNED_SHORT: return ushort_types_scale[size]; case GL_UNSIGNED_BYTE: return ubyte_types_scale[size]; + case GL_FIXED: return float_types[size]; /* was uploaded as floats */ default: assert(0); return 0; } } @@ -224,6 +226,7 @@ static GLuint get_size( GLenum type ) case GL_UNSIGNED_INT: return sizeof(GLuint); case GL_UNSIGNED_SHORT: return sizeof(GLushort); case GL_UNSIGNED_BYTE: return sizeof(GLubyte); + case GL_FIXED: return sizeof(GLfloat); /* will be uploaded as floats */ default: return 0; } } @@ -287,6 +290,49 @@ copy_array_to_vbo_array( struct brw_context *brw, element->stride = dst_stride; } + /* upload as floats */ + if (element->glarray->Type == GL_FIXED) { + drm_intel_bo *src_bo = NULL; + const char *src; + char *dst; + GLint i, j; + + /* map source bo */ + if (_mesa_is_bufferobj(element->glarray->BufferObj)) { + struct intel_buffer_object *intel_buffer = + intel_buffer_object(element->glarray->BufferObj); + + src_bo = intel_bufferobj_buffer(&brw->intel, intel_buffer, INTEL_READ); + drm_intel_gem_bo_map_gtt(src_bo); + + src = (const char *) element->bo->virtual + + (unsigned long) element->glarray->Ptr; + } + else { + src = (const char *) element->glarray->Ptr; + } + + drm_intel_gem_bo_map_gtt(element->bo); + dst = (char *) element->bo->virtual + element->offset; + + for (i = 0; i < element->count; i++) { + const GLint *s = (GLint *) src; + GLfloat *d = (GLfloat *) dst; + + for (j = 0; j < element->glarray->Size; j++) + d[j] = s[j] / 65536.0f; + + src += element->glarray->StrideB; + dst += dst_stride; + } + + drm_intel_gem_bo_unmap_gtt(element->bo); + if (src_bo) + drm_intel_gem_bo_unmap_gtt(src_bo); + + return; + } + if (dst_stride == element->glarray->StrideB) { drm_intel_gem_bo_map_gtt(element->bo); memcpy((char *)element->bo->virtual + element->offset, @@ -356,7 +402,8 @@ static void brw_prepare_vertices(struct brw_context *brw) input->element_size = get_size(input->glarray->Type) * input->glarray->Size; - if (_mesa_is_bufferobj(input->glarray->BufferObj)) { + if (_mesa_is_bufferobj(input->glarray->BufferObj) && + input->glarray->Type != GL_FIXED) { struct intel_buffer_object *intel_buffer = intel_buffer_object(input->glarray->BufferObj); -- cgit v1.2.3 From d1ccafa5b7a79366a8439c2e39e8bf8fe7bdacb6 Mon Sep 17 00:00:00 2001 From: Chia-I Wu Date: Tue, 26 Oct 2010 15:28:28 -0400 Subject: android: Enable OpenGL ES 2.0. --- src/mapi/Android.mk | 8 ++++++++ src/mesa/drivers/Android.mk | 1 + 2 files changed, 9 insertions(+) diff --git a/src/mapi/Android.mk b/src/mapi/Android.mk index c4737165432..7a61d1571a4 100644 --- a/src/mapi/Android.mk +++ b/src/mapi/Android.mk @@ -16,6 +16,14 @@ glapi_C_INCLUDES := \ external/mesa/include \ external/mesa/src/mapi +# use x86 assembly to generate ES2 entries on the fly +glapi_SOURCES += \ + $(addprefix es1api/glapi/, $(X86_API)) +glapi_CFLAGS += \ + -DUSE_X86_ASM +glapi_C_INCLUDES += \ + external/mesa/src/mesa + include $(CLEAR_VARS) LOCAL_MODULE := libmesa_glapi diff --git a/src/mesa/drivers/Android.mk b/src/mesa/drivers/Android.mk index 28f5beb5f7a..00de3c1a82f 100644 --- a/src/mesa/drivers/Android.mk +++ b/src/mesa/drivers/Android.mk @@ -167,6 +167,7 @@ common_CFLAGS := \ -DPTHREADS \ -DFEATURE_GL=1 \ -DFEATURE_ES1=1 \ + -DFEATURE_ES2=1 \ -fvisibility=hidden \ -Wno-sign-compare -- cgit v1.2.3 From f189dfe9e92dc5eff30ed00bc2e1dae5c5e59fa4 Mon Sep 17 00:00:00 2001 From: Chih-Wei Huang Date: Thu, 16 Dec 2010 17:23:19 +0800 Subject: mesa: fix compiling issues with gcc 4.4.x Gcc 4.4 requires a class with virtual functions has to define the virtual destructor. --- src/glsl/ast.h | 1 + src/glsl/ir.h | 1 + src/glsl/ir_hierarchical_visitor.h | 1 + 3 files changed, 3 insertions(+) diff --git a/src/glsl/ast.h b/src/glsl/ast.h index a77b522705c..1420f234b6c 100644 --- a/src/glsl/ast.h +++ b/src/glsl/ast.h @@ -129,6 +129,7 @@ protected: * be created. */ ast_node(void); + virtual ~ast_node() {} }; diff --git a/src/glsl/ir.h b/src/glsl/ir.h index 102a68b6551..f3c1d42108b 100644 --- a/src/glsl/ir.h +++ b/src/glsl/ir.h @@ -131,6 +131,7 @@ protected: ir_type = ir_type_unset; type = NULL; } + virtual ~ir_instruction() {} }; diff --git a/src/glsl/ir_hierarchical_visitor.h b/src/glsl/ir_hierarchical_visitor.h index dc177f5eb0d..387563f1139 100644 --- a/src/glsl/ir_hierarchical_visitor.h +++ b/src/glsl/ir_hierarchical_visitor.h @@ -77,6 +77,7 @@ enum ir_visitor_status { class ir_hierarchical_visitor { public: ir_hierarchical_visitor(); + virtual ~ir_hierarchical_visitor() {} /** * \name Visit methods for leaf-node classes -- cgit v1.2.3