diff options
Diffstat (limited to 'nx-X11/programs/Xserver/GL/glx/g_render.c')
| -rw-r--r-- | nx-X11/programs/Xserver/GL/glx/g_render.c | 2282 |
1 files changed, 2282 insertions, 0 deletions
diff --git a/nx-X11/programs/Xserver/GL/glx/g_render.c b/nx-X11/programs/Xserver/GL/glx/g_render.c new file mode 100644 index 000000000..24c64897e --- /dev/null +++ b/nx-X11/programs/Xserver/GL/glx/g_render.c @@ -0,0 +1,2282 @@ +/* $XFree86: xc/programs/Xserver/GL/glx/g_render.c,v 1.8 2004/02/03 21:34:36 alanh Exp $ */ +/* DO NOT EDIT - THIS FILE IS AUTOMATICALLY GENERATED */ +/* +** License Applicability. Except to the extent portions of this file are +** made subject to an alternative license as permitted in the SGI Free +** Software License B, Version 1.1 (the "License"), the contents of this +** file are subject only to the provisions of the License. You may not use +** this file except in compliance with the License. You may obtain a copy +** of the License at Silicon Graphics, Inc., attn: Legal Services, 1600 +** Amphitheatre Parkway, Mountain View, CA 94043-1351, or at: +** +** http://oss.sgi.com/projects/FreeB +** +** Note that, as provided in the License, the Software is distributed on an +** "AS IS" basis, with ALL EXPRESS AND IMPLIED WARRANTIES AND CONDITIONS +** DISCLAIMED, INCLUDING, WITHOUT LIMITATION, ANY IMPLIED WARRANTIES AND +** CONDITIONS OF MERCHANTABILITY, SATISFACTORY QUALITY, FITNESS FOR A +** PARTICULAR PURPOSE, AND NON-INFRINGEMENT. +** +** Original Code. The Original Code is: OpenGL Sample Implementation, +** Version 1.2.1, released January 26, 2000, developed by Silicon Graphics, +** Inc. The Original Code is Copyright (c) 1991-2000 Silicon Graphics, Inc. +** Copyright in any portions created by third parties is as indicated +** elsewhere herein. All Rights Reserved. +** +** Additional Notice Provisions: This software was created using the +** OpenGL(R) version 1.2.1 Sample Implementation published by SGI, but has +** not been independently verified as being compliant with the OpenGL(R) +** version 1.2.1 Specification. +*/ + +#define NEED_REPLIES +#ifdef HAVE_DIX_CONFIG_H +#include <dix-config.h> +#endif + +#include "glxserver.h" +#include "glxext.h" +#include "g_disptab.h" +#include "g_disptab_EXT.h" +#include "unpack.h" +#include "impsize.h" +#include "singlesize.h" + +void __glXDisp_CallList(GLbyte *pc) +{ + glCallList( + *(GLuint *)(pc + 0) + ); +} + +void __glXDisp_ListBase(GLbyte *pc) +{ + glListBase( + *(GLuint *)(pc + 0) + ); +} + +void __glXDisp_Begin(GLbyte *pc) +{ + glBegin( + *(GLenum *)(pc + 0) + ); +} + +#define __GLX_SWAP_GLbyte(ptr) +#define __GLX_SWAP_GLshort(ptr) __GLX_SWAP_SHORT(ptr) +#define __GLX_SWAP_GLint(ptr) __GLX_SWAP_INT(ptr) +#define __GLX_SWAP_GLubyte(ptr) +#define __GLX_SWAP_GLushort(ptr) __GLX_SWAP_SHORT(ptr) +#define __GLX_SWAP_GLuint(ptr) __GLX_SWAP_INT(ptr) +#define __GLX_SWAP_GLdouble(ptr) __GLX_SWAP_DOUBLE(ptr) +#define __GLX_SWAP_GLfloat(ptr) __GLX_SWAP_FLOAT(ptr) + +#define __GLX_SWAP_GLbyte_ARRAY(ptr,count) (void) swapEnd; (void) swapPC; (void) sw; +#define __GLX_SWAP_GLshort_ARRAY(ptr,count) __GLX_SWAP_SHORT_ARRAY(ptr,count) +#define __GLX_SWAP_GLint_ARRAY(ptr,count) __GLX_SWAP_INT_ARRAY(ptr,count) +#define __GLX_SWAP_GLenum_ARRAY(ptr,count) __GLX_SWAP_INT_ARRAY(ptr,count) +#define __GLX_SWAP_GLubyte_ARRAY(ptr,count) (void) swapEnd; (void) swapPC; (void) sw; +#define __GLX_SWAP_GLushort_ARRAY(ptr,count) __GLX_SWAP_SHORT_ARRAY(ptr,count) +#define __GLX_SWAP_GLuint_ARRAY(ptr,count) __GLX_SWAP_INT_ARRAY(ptr,count) +#define __GLX_SWAP_GLdouble_ARRAY(ptr,count) __GLX_SWAP_DOUBLE_ARRAY(ptr,count) +#define __GLX_SWAP_GLfloat_ARRAY(ptr,count) __GLX_SWAP_FLOAT_ARRAY(ptr,count) + +#ifdef __GLX_ALIGN64 +/* If type is not GLdouble, the compiler should optimize this away. + */ +# define GLX_DO_ALIGN_MAGIC(count, type) \ + do { \ + if ( (sizeof(type) == 8) && ((unsigned long)(pc) & 7)) \ + { \ + __GLX_MEM_COPY(pc-4, pc, (count * sizeof( type ) )); \ + pc -= 4; \ + } \ + } while( 0 ) +#else +# define GLX_DO_ALIGN_MAGIC(count, type) +#endif + +#define dispatch_template_1( name, type ) \ + void __glXDisp_ ## name ( GLbyte * pc ) \ + { \ + GLX_DO_ALIGN_MAGIC( 1, type ); \ + gl ## name ( (type *) pc ); \ + } \ + void __glXDispSwap_ ## name ( GLbyte * pc ) \ + { \ + __GLX_DECLARE_SWAP_VARIABLES; \ + GLX_DO_ALIGN_MAGIC( 1, type ); \ + __GLX_SWAP_ ## type ( pc ); \ + gl ## name ( (type *) pc ); \ + } + +#define dispatch_template_3( name, type ) \ + void __glXDisp_ ## name ( GLbyte * pc ) \ + { \ + GLX_DO_ALIGN_MAGIC( 3, type ); \ + gl ## name ( (type *) pc ); \ + } \ + void __glXDispSwap_ ## name ( GLbyte * pc ) \ + { \ + __GLX_DECLARE_SWAP_VARIABLES; \ + __GLX_DECLARE_SWAP_ARRAY_VARIABLES; \ + GLX_DO_ALIGN_MAGIC( 3, type ); \ + __GLX_SWAP_ ## type ## _ARRAY(pc, 3); \ + gl ## name ( (type *) pc ); \ + } + +#define dispatch_template_4( name, type ) \ + void __glXDisp_ ## name ( GLbyte * pc ) \ + { \ + GLX_DO_ALIGN_MAGIC( 4, type ); \ + gl ## name ( (type *) pc ); \ + } \ + void __glXDispSwap_ ## name ( GLbyte * pc ) \ + { \ + __GLX_DECLARE_SWAP_VARIABLES; \ + __GLX_DECLARE_SWAP_ARRAY_VARIABLES; \ + GLX_DO_ALIGN_MAGIC( 4, type ); \ + __GLX_SWAP_ ## type ## _ARRAY(pc, 4); \ + gl ## name ( (type *) pc ); \ + } + +#define dispatch_template_4s( name, type ) \ + void __glXDisp_ ## name ( GLbyte * pc ) \ + { \ + GLX_DO_ALIGN_MAGIC( 4, type ); \ + gl ## name ( ((type *) pc)[0], ((type *) pc)[1], \ + ((type *) pc)[2], ((type *) pc)[3] ); \ + } \ + void __glXDispSwap_ ## name ( GLbyte * pc ) \ + { \ + __GLX_DECLARE_SWAP_VARIABLES; \ + __GLX_DECLARE_SWAP_ARRAY_VARIABLES; \ + GLX_DO_ALIGN_MAGIC( 4, type ); \ + __GLX_SWAP_ ## type ## _ARRAY(pc, 4); \ + gl ## name ( ((type *) pc)[0], ((type *) pc)[1], \ + ((type *) pc)[2], ((type *) pc)[3] ); \ + } + +/** + * \bug All of the enum1 templates need to be updated to handle the case where + * \c type is \c GLdouble. When the type is a double, the data comes before + * the enum. This is also the reason the invocation of the + * \c GLX_DO_ALIGN_MAGIC macro was removed. + */ +#define dispatch_template_enum1_1s( name, type ) \ + void __glXDisp_ ## name ( GLbyte * pc ) \ + { \ + gl ## name ( *(GLenum *) (pc + 0), \ + *(type *) (pc + 4) ); \ + } \ + void __glXDispSwap_ ## name ( GLbyte * pc ) \ + { \ + __GLX_DECLARE_SWAP_VARIABLES; \ + __GLX_SWAP_INT (pc + 0); \ + __GLX_SWAP_ ## type (pc + 4); \ + gl ## name ( *(GLenum *) (pc + 0), \ + *(type *) (pc + 4) ); \ + } + +#define dispatch_template_enum1_Vv( name, type ) \ + void __glXDisp_ ## name ( GLbyte * pc ) \ + { \ + gl ## name ( *(GLenum *) (pc + 0), \ + (type *) (pc + 4) ); \ + } \ + void __glXDispSwap_ ## name ( GLbyte * pc ) \ + { \ + GLenum pname; GLint compsize; \ + __GLX_DECLARE_SWAP_VARIABLES; \ + __GLX_DECLARE_SWAP_ARRAY_VARIABLES; \ + __GLX_SWAP_INT(pc + 0); \ + pname = *(GLenum *)(pc + 0); \ + compsize = __gl ## name ## _size(pname); \ + if (compsize < 0) compsize = 0; \ + __GLX_SWAP_ ## type ## _ARRAY(pc + 4, compsize); \ + gl ## name ( *(GLenum *) (pc + 0), \ + (type *) (pc + 4) ); \ + } + +#ifndef MISSING_GL_EXTS +dispatch_template_1( FogCoordfv, GLfloat ) +dispatch_template_1( FogCoorddv, GLdouble ) +dispatch_template_3( SecondaryColor3bv, GLbyte ) +dispatch_template_3( SecondaryColor3sv, GLshort ) +dispatch_template_3( SecondaryColor3iv, GLint ) +dispatch_template_3( SecondaryColor3ubv, GLubyte ) +dispatch_template_3( SecondaryColor3usv, GLushort ) +dispatch_template_3( SecondaryColor3uiv, GLuint ) +dispatch_template_3( SecondaryColor3fv, GLfloat ) +dispatch_template_3( SecondaryColor3dv, GLdouble ) + +dispatch_template_4s( BlendFuncSeparate, GLenum ) +#endif /* !MISSING_GL_EXTS */ + +void __glXDisp_Color3bv(GLbyte *pc) +{ + glColor3bv( + (GLbyte *)(pc + 0) + ); +} + +void __glXDisp_Color3dv(GLbyte *pc) +{ + +#ifdef __GLX_ALIGN64 + if ((unsigned long)(pc) & 7) { + __GLX_MEM_COPY(pc-4, pc, 24); + pc -= 4; + } +#endif + glColor3dv( + (GLdouble *)(pc + 0) + ); +} + +void __glXDisp_Color3fv(GLbyte *pc) +{ + glColor3fv( + (GLfloat *)(pc + 0) + ); +} + +void __glXDisp_Color3iv(GLbyte *pc) +{ + glColor3iv( + (GLint *)(pc + 0) + ); +} + +void __glXDisp_Color3sv(GLbyte *pc) +{ + glColor3sv( + (GLshort *)(pc + 0) + ); +} + +void __glXDisp_Color3ubv(GLbyte *pc) +{ + glColor3ubv( + (GLubyte *)(pc + 0) + ); +} + +void __glXDisp_Color3uiv(GLbyte *pc) +{ + glColor3uiv( + (GLuint *)(pc + 0) + ); +} + +void __glXDisp_Color3usv(GLbyte *pc) +{ + glColor3usv( + (GLushort *)(pc + 0) + ); +} + +void __glXDisp_Color4bv(GLbyte *pc) +{ + glColor4bv( + (GLbyte *)(pc + 0) + ); +} + +void __glXDisp_Color4dv(GLbyte *pc) +{ + +#ifdef __GLX_ALIGN64 + if ((unsigned long)(pc) & 7) { + __GLX_MEM_COPY(pc-4, pc, 32); + pc -= 4; + } +#endif + glColor4dv( + (GLdouble *)(pc + 0) + ); +} + +void __glXDisp_Color4fv(GLbyte *pc) +{ + glColor4fv( + (GLfloat *)(pc + 0) + ); +} + +void __glXDisp_Color4iv(GLbyte *pc) +{ + glColor4iv( + (GLint *)(pc + 0) + ); +} + +void __glXDisp_Color4sv(GLbyte *pc) +{ + glColor4sv( + (GLshort *)(pc + 0) + ); +} + +void __glXDisp_Color4ubv(GLbyte *pc) +{ + glColor4ubv( + (GLubyte *)(pc + 0) + ); +} + +void __glXDisp_Color4uiv(GLbyte *pc) +{ + glColor4uiv( + (GLuint *)(pc + 0) + ); +} + +void __glXDisp_Color4usv(GLbyte *pc) +{ + glColor4usv( + (GLushort *)(pc + 0) + ); +} + +void __glXDisp_EdgeFlagv(GLbyte *pc) +{ + glEdgeFlagv( + (GLboolean *)(pc + 0) + ); +} + +void __glXDisp_End(GLbyte *pc) +{ + glEnd( + ); +} + +void __glXDisp_Indexdv(GLbyte *pc) +{ + +#ifdef __GLX_ALIGN64 + if ((unsigned long)(pc) & 7) { + __GLX_MEM_COPY(pc-4, pc, 8); + pc -= 4; + } +#endif + glIndexdv( + (GLdouble *)(pc + 0) + ); +} + +void __glXDisp_Indexfv(GLbyte *pc) +{ + glIndexfv( + (GLfloat *)(pc + 0) + ); +} + +void __glXDisp_Indexiv(GLbyte *pc) +{ + glIndexiv( + (GLint *)(pc + 0) + ); +} + +void __glXDisp_Indexsv(GLbyte *pc) +{ + glIndexsv( + (GLshort *)(pc + 0) + ); +} + +void __glXDisp_Normal3bv(GLbyte *pc) +{ + glNormal3bv( + (GLbyte *)(pc + 0) + ); +} + +void __glXDisp_Normal3dv(GLbyte *pc) +{ + +#ifdef __GLX_ALIGN64 + if ((unsigned long)(pc) & 7) { + __GLX_MEM_COPY(pc-4, pc, 24); + pc -= 4; + } +#endif + glNormal3dv( + (GLdouble *)(pc + 0) + ); +} + +void __glXDisp_Normal3fv(GLbyte *pc) +{ + glNormal3fv( + (GLfloat *)(pc + 0) + ); +} + +void __glXDisp_Normal3iv(GLbyte *pc) +{ + glNormal3iv( + (GLint *)(pc + 0) + ); +} + +void __glXDisp_Normal3sv(GLbyte *pc) +{ + glNormal3sv( + (GLshort *)(pc + 0) + ); +} + +void __glXDisp_RasterPos2dv(GLbyte *pc) +{ + +#ifdef __GLX_ALIGN64 + if ((unsigned long)(pc) & 7) { + __GLX_MEM_COPY(pc-4, pc, 16); + pc -= 4; + } +#endif + glRasterPos2dv( + (GLdouble *)(pc + 0) + ); +} + +void __glXDisp_RasterPos2fv(GLbyte *pc) +{ + glRasterPos2fv( + (GLfloat *)(pc + 0) + ); +} + +void __glXDisp_RasterPos2iv(GLbyte *pc) +{ + glRasterPos2iv( + (GLint *)(pc + 0) + ); +} + +void __glXDisp_RasterPos2sv(GLbyte *pc) +{ + glRasterPos2sv( + (GLshort *)(pc + 0) + ); +} + +void __glXDisp_RasterPos3dv(GLbyte *pc) +{ + +#ifdef __GLX_ALIGN64 + if ((unsigned long)(pc) & 7) { + __GLX_MEM_COPY(pc-4, pc, 24); + pc -= 4; + } +#endif + glRasterPos3dv( + (GLdouble *)(pc + 0) + ); +} + +void __glXDisp_RasterPos3fv(GLbyte *pc) +{ + glRasterPos3fv( + (GLfloat *)(pc + 0) + ); +} + +void __glXDisp_RasterPos3iv(GLbyte *pc) +{ + glRasterPos3iv( + (GLint *)(pc + 0) + ); +} + +void __glXDisp_RasterPos3sv(GLbyte *pc) +{ + glRasterPos3sv( + (GLshort *)(pc + 0) + ); +} + +void __glXDisp_RasterPos4dv(GLbyte *pc) +{ + +#ifdef __GLX_ALIGN64 + if ((unsigned long)(pc) & 7) { + __GLX_MEM_COPY(pc-4, pc, 32); + pc -= 4; + } +#endif + glRasterPos4dv( + (GLdouble *)(pc + 0) + ); +} + +void __glXDisp_RasterPos4fv(GLbyte *pc) +{ + glRasterPos4fv( + (GLfloat *)(pc + 0) + ); +} + +void __glXDisp_RasterPos4iv(GLbyte *pc) +{ + glRasterPos4iv( + (GLint *)(pc + 0) + ); +} + +void __glXDisp_RasterPos4sv(GLbyte *pc) +{ + glRasterPos4sv( + (GLshort *)(pc + 0) + ); +} + +void __glXDisp_Rectdv(GLbyte *pc) +{ + +#ifdef __GLX_ALIGN64 + if ((unsigned long)(pc) & 7) { + __GLX_MEM_COPY(pc-4, pc, 32); + pc -= 4; + } +#endif + glRectdv( + (GLdouble *)(pc + 0), + (GLdouble *)(pc + 16) + ); +} + +void __glXDisp_Rectfv(GLbyte *pc) +{ + glRectfv( + (GLfloat *)(pc + 0), + (GLfloat *)(pc + 8) + ); +} + +void __glXDisp_Rectiv(GLbyte *pc) +{ + glRectiv( + (GLint *)(pc + 0), + (GLint *)(pc + 8) + ); +} + +void __glXDisp_Rectsv(GLbyte *pc) +{ + glRectsv( + (GLshort *)(pc + 0), + (GLshort *)(pc + 4) + ); +} + +void __glXDisp_TexCoord1dv(GLbyte *pc) +{ + +#ifdef __GLX_ALIGN64 + if ((unsigned long)(pc) & 7) { + __GLX_MEM_COPY(pc-4, pc, 8); + pc -= 4; + } +#endif + glTexCoord1dv( + (GLdouble *)(pc + 0) + ); +} + +void __glXDisp_TexCoord1fv(GLbyte *pc) +{ + glTexCoord1fv( + (GLfloat *)(pc + 0) + ); +} + +void __glXDisp_TexCoord1iv(GLbyte *pc) +{ + glTexCoord1iv( + (GLint *)(pc + 0) + ); +} + +void __glXDisp_TexCoord1sv(GLbyte *pc) +{ + glTexCoord1sv( + (GLshort *)(pc + 0) + ); +} + +void __glXDisp_TexCoord2dv(GLbyte *pc) +{ + +#ifdef __GLX_ALIGN64 + if ((unsigned long)(pc) & 7) { + __GLX_MEM_COPY(pc-4, pc, 16); + pc -= 4; + } +#endif + glTexCoord2dv( + (GLdouble *)(pc + 0) + ); +} + +void __glXDisp_TexCoord2fv(GLbyte *pc) +{ + glTexCoord2fv( + (GLfloat *)(pc + 0) + ); +} + +void __glXDisp_TexCoord2iv(GLbyte *pc) +{ + glTexCoord2iv( + (GLint *)(pc + 0) + ); +} + +void __glXDisp_TexCoord2sv(GLbyte *pc) +{ + glTexCoord2sv( + (GLshort *)(pc + 0) + ); +} + +void __glXDisp_TexCoord3dv(GLbyte *pc) +{ + +#ifdef __GLX_ALIGN64 + if ((unsigned long)(pc) & 7) { + __GLX_MEM_COPY(pc-4, pc, 24); + pc -= 4; + } +#endif + glTexCoord3dv( + (GLdouble *)(pc + 0) + ); +} + +void __glXDisp_TexCoord3fv(GLbyte *pc) +{ + glTexCoord3fv( + (GLfloat *)(pc + 0) + ); +} + +void __glXDisp_TexCoord3iv(GLbyte *pc) +{ + glTexCoord3iv( + (GLint *)(pc + 0) + ); +} + +void __glXDisp_TexCoord3sv(GLbyte *pc) +{ + glTexCoord3sv( + (GLshort *)(pc + 0) + ); +} + +void __glXDisp_TexCoord4dv(GLbyte *pc) +{ + +#ifdef __GLX_ALIGN64 + if ((unsigned long)(pc) & 7) { + __GLX_MEM_COPY(pc-4, pc, 32); + pc -= 4; + } +#endif + glTexCoord4dv( + (GLdouble *)(pc + 0) + ); +} + +void __glXDisp_TexCoord4fv(GLbyte *pc) +{ + glTexCoord4fv( + (GLfloat *)(pc + 0) + ); +} + +void __glXDisp_TexCoord4iv(GLbyte *pc) +{ + glTexCoord4iv( + (GLint *)(pc + 0) + ); +} + +void __glXDisp_TexCoord4sv(GLbyte *pc) +{ + glTexCoord4sv( + (GLshort *)(pc + 0) + ); +} + +void __glXDisp_Vertex2dv(GLbyte *pc) +{ + +#ifdef __GLX_ALIGN64 + if ((unsigned long)(pc) & 7) { + __GLX_MEM_COPY(pc-4, pc, 16); + pc -= 4; + } +#endif + glVertex2dv( + (GLdouble *)(pc + 0) + ); +} + +void __glXDisp_Vertex2fv(GLbyte *pc) +{ + glVertex2fv( + (GLfloat *)(pc + 0) + ); +} + +void __glXDisp_Vertex2iv(GLbyte *pc) +{ + glVertex2iv( + (GLint *)(pc + 0) + ); +} + +void __glXDisp_Vertex2sv(GLbyte *pc) +{ + glVertex2sv( + (GLshort *)(pc + 0) + ); +} + +void __glXDisp_Vertex3dv(GLbyte *pc) +{ + +#ifdef __GLX_ALIGN64 + if ((unsigned long)(pc) & 7) { + __GLX_MEM_COPY(pc-4, pc, 24); + pc -= 4; + } +#endif + glVertex3dv( + (GLdouble *)(pc + 0) + ); +} + +void __glXDisp_Vertex3fv(GLbyte *pc) +{ + glVertex3fv( + (GLfloat *)(pc + 0) + ); +} + +void __glXDisp_Vertex3iv(GLbyte *pc) +{ + glVertex3iv( + (GLint *)(pc + 0) + ); +} + +void __glXDisp_Vertex3sv(GLbyte *pc) +{ + glVertex3sv( + (GLshort *)(pc + 0) + ); +} + +void __glXDisp_Vertex4dv(GLbyte *pc) +{ + +#ifdef __GLX_ALIGN64 + if ((unsigned long)(pc) & 7) { + __GLX_MEM_COPY(pc-4, pc, 32); + pc -= 4; + } +#endif + glVertex4dv( + (GLdouble *)(pc + 0) + ); +} + +void __glXDisp_Vertex4fv(GLbyte *pc) +{ + glVertex4fv( + (GLfloat *)(pc + 0) + ); +} + +void __glXDisp_Vertex4iv(GLbyte *pc) +{ + glVertex4iv( + (GLint *)(pc + 0) + ); +} + +void __glXDisp_Vertex4sv(GLbyte *pc) +{ + glVertex4sv( + (GLshort *)(pc + 0) + ); +} + +void __glXDisp_ClipPlane(GLbyte *pc) +{ + +#ifdef __GLX_ALIGN64 + if ((unsigned long)(pc) & 7) { + __GLX_MEM_COPY(pc-4, pc, 36); + pc -= 4; + } +#endif + glClipPlane( + *(GLenum *)(pc + 32), + (GLdouble *)(pc + 0) + ); +} + +void __glXDisp_ColorMaterial(GLbyte *pc) +{ + glColorMaterial( + *(GLenum *)(pc + 0), + *(GLenum *)(pc + 4) + ); +} + +void __glXDisp_CullFace(GLbyte *pc) +{ + glCullFace( + *(GLenum *)(pc + 0) + ); +} + +void __glXDisp_Fogf(GLbyte *pc) +{ + glFogf( + *(GLenum *)(pc + 0), + *(GLfloat *)(pc + 4) + ); +} + +void __glXDisp_Fogfv(GLbyte *pc) +{ + glFogfv( + *(GLenum *)(pc + 0), + (GLfloat *)(pc + 4) + ); +} + +void __glXDisp_Fogi(GLbyte *pc) +{ + glFogi( + *(GLenum *)(pc + 0), + *(GLint *)(pc + 4) + ); +} + +void __glXDisp_Fogiv(GLbyte *pc) +{ + glFogiv( + *(GLenum *)(pc + 0), + (GLint *)(pc + 4) + ); +} + +void __glXDisp_FrontFace(GLbyte *pc) +{ + glFrontFace( + *(GLenum *)(pc + 0) + ); +} + +void __glXDisp_Hint(GLbyte *pc) +{ + glHint( + *(GLenum *)(pc + 0), + *(GLenum *)(pc + 4) + ); +} + +void __glXDisp_Lightf(GLbyte *pc) +{ + glLightf( + *(GLenum *)(pc + 0), + *(GLenum *)(pc + 4), + *(GLfloat *)(pc + 8) + ); +} + +void __glXDisp_Lightfv(GLbyte *pc) +{ + glLightfv( + *(GLenum *)(pc + 0), + *(GLenum *)(pc + 4), + (GLfloat *)(pc + 8) + ); +} + +void __glXDisp_Lighti(GLbyte *pc) +{ + glLighti( + *(GLenum *)(pc + 0), + *(GLenum *)(pc + 4), + *(GLint *)(pc + 8) + ); +} + +void __glXDisp_Lightiv(GLbyte *pc) +{ + glLightiv( + *(GLenum *)(pc + 0), + *(GLenum *)(pc + 4), + (GLint *)(pc + 8) + ); +} + +void __glXDisp_LightModelf(GLbyte *pc) +{ + glLightModelf( + *(GLenum *)(pc + 0), + *(GLfloat *)(pc + 4) + ); +} + +void __glXDisp_LightModelfv(GLbyte *pc) +{ + glLightModelfv( + *(GLenum *)(pc + 0), + (GLfloat *)(pc + 4) + ); +} + +void __glXDisp_LightModeli(GLbyte *pc) +{ + glLightModeli( + *(GLenum *)(pc + 0), + *(GLint *)(pc + 4) + ); +} + +void __glXDisp_LightModeliv(GLbyte *pc) +{ + glLightModeliv( + *(GLenum *)(pc + 0), + (GLint *)(pc + 4) + ); +} + +void __glXDisp_LineStipple(GLbyte *pc) +{ + glLineStipple( + *(GLint *)(pc + 0), + *(GLushort *)(pc + 4) + ); +} + +void __glXDisp_LineWidth(GLbyte *pc) +{ + glLineWidth( + *(GLfloat *)(pc + 0) + ); +} + +void __glXDisp_Materialf(GLbyte *pc) +{ + glMaterialf( + *(GLenum *)(pc + 0), + *(GLenum *)(pc + 4), + *(GLfloat *)(pc + 8) + ); +} + +void __glXDisp_Materialfv(GLbyte *pc) +{ + glMaterialfv( + *(GLenum *)(pc + 0), + *(GLenum *)(pc + 4), + (GLfloat *)(pc + 8) + ); +} + +void __glXDisp_Materiali(GLbyte *pc) +{ + glMateriali( + *(GLenum *)(pc + 0), + *(GLenum *)(pc + 4), + *(GLint *)(pc + 8) + ); +} + +void __glXDisp_Materialiv(GLbyte *pc) +{ + glMaterialiv( + *(GLenum *)(pc + 0), + *(GLenum *)(pc + 4), + (GLint *)(pc + 8) + ); +} + +void __glXDisp_PointSize(GLbyte *pc) +{ + glPointSize( + *(GLfloat *)(pc + 0) + ); +} + +void __glXDisp_PolygonMode(GLbyte *pc) +{ + glPolygonMode( + *(GLenum *)(pc + 0), + *(GLenum *)(pc + 4) + ); +} + +void __glXDisp_Scissor(GLbyte *pc) +{ + glScissor( + *(GLint *)(pc + 0), + *(GLint *)(pc + 4), + *(GLsizei *)(pc + 8), + *(GLsizei *)(pc + 12) + ); +} + +void __glXDisp_ShadeModel(GLbyte *pc) +{ + glShadeModel( + *(GLenum *)(pc + 0) + ); +} + +void __glXDisp_TexParameterf(GLbyte *pc) +{ + glTexParameterf( + *(GLenum *)(pc + 0), + *(GLenum *)(pc + 4), + *(GLfloat *)(pc + 8) + ); +} + +void __glXDisp_TexParameterfv(GLbyte *pc) +{ + glTexParameterfv( + *(GLenum *)(pc + 0), + *(GLenum *)(pc + 4), + (GLfloat *)(pc + 8) + ); +} + +void __glXDisp_TexParameteri(GLbyte *pc) +{ + glTexParameteri( + *(GLenum *)(pc + 0), + *(GLenum *)(pc + 4), + *(GLint *)(pc + 8) + ); +} + +void __glXDisp_TexParameteriv(GLbyte *pc) +{ + glTexParameteriv( + *(GLenum *)(pc + 0), + *(GLenum *)(pc + 4), + (GLint *)(pc + 8) + ); +} + +void __glXDisp_TexEnvf(GLbyte *pc) +{ + glTexEnvf( + *(GLenum *)(pc + 0), + *(GLenum *)(pc + 4), + *(GLfloat *)(pc + 8) + ); +} + +void __glXDisp_TexEnvfv(GLbyte *pc) +{ + glTexEnvfv( + *(GLenum *)(pc + 0), + *(GLenum *)(pc + 4), + (GLfloat *)(pc + 8) + ); +} + +void __glXDisp_TexEnvi(GLbyte *pc) +{ + glTexEnvi( + *(GLenum *)(pc + 0), + *(GLenum *)(pc + 4), + *(GLint *)(pc + 8) + ); +} + +void __glXDisp_TexEnviv(GLbyte *pc) +{ + glTexEnviv( + *(GLenum *)(pc + 0), + *(GLenum *)(pc + 4), + (GLint *)(pc + 8) + ); +} + +void __glXDisp_TexGend(GLbyte *pc) +{ + +#ifdef __GLX_ALIGN64 + if ((unsigned long)(pc) & 7) { + __GLX_MEM_COPY(pc-4, pc, 16); + pc -= 4; + } +#endif + glTexGend( + *(GLenum *)(pc + 8), + *(GLenum *)(pc + 12), + *(GLdouble *)(pc + 0) + ); +} + +void __glXDisp_TexGendv(GLbyte *pc) +{ +#ifdef __GLX_ALIGN64 + GLenum pname; + GLint cmdlen; + GLint compsize; + + pname = *(GLenum *)(pc + 4); + compsize = __glTexGendv_size(pname); + if (compsize < 0) compsize = 0; + cmdlen = __GLX_PAD(8+compsize*8); + if ((unsigned long)(pc) & 7) { + __GLX_MEM_COPY(pc-4, pc, cmdlen); + pc -= 4; + } +#endif + + glTexGendv( + *(GLenum *)(pc + 0), + *(GLenum *)(pc + 4), + (GLdouble *)(pc + 8) + ); +} + +void __glXDisp_TexGenf(GLbyte *pc) +{ + glTexGenf( + *(GLenum *)(pc + 0), + *(GLenum *)(pc + 4), + *(GLfloat *)(pc + 8) + ); +} + +void __glXDisp_TexGenfv(GLbyte *pc) +{ + glTexGenfv( + *(GLenum *)(pc + 0), + *(GLenum *)(pc + 4), + (GLfloat *)(pc + 8) + ); +} + +void __glXDisp_TexGeni(GLbyte *pc) +{ + glTexGeni( + *(GLenum *)(pc + 0), + *(GLenum *)(pc + 4), + *(GLint *)(pc + 8) + ); +} + +void __glXDisp_TexGeniv(GLbyte *pc) +{ + glTexGeniv( + *(GLenum *)(pc + 0), + *(GLenum *)(pc + 4), + (GLint *)(pc + 8) + ); +} + +void __glXDisp_InitNames(GLbyte *pc) +{ + glInitNames( + ); +} + +void __glXDisp_LoadName(GLbyte *pc) +{ + glLoadName( + *(GLuint *)(pc + 0) + ); +} + +void __glXDisp_PassThrough(GLbyte *pc) +{ + glPassThrough( + *(GLfloat *)(pc + 0) + ); +} + +void __glXDisp_PopName(GLbyte *pc) +{ + glPopName( + ); +} + +void __glXDisp_PushName(GLbyte *pc) +{ + glPushName( + *(GLuint *)(pc + 0) + ); +} + +void __glXDisp_DrawBuffer(GLbyte *pc) +{ + glDrawBuffer( + *(GLenum *)(pc + 0) + ); +} + +void __glXDisp_Clear(GLbyte *pc) +{ + glClear( + *(GLbitfield *)(pc + 0) + ); +} + +void __glXDisp_ClearAccum(GLbyte *pc) +{ + glClearAccum( + *(GLfloat *)(pc + 0), + *(GLfloat *)(pc + 4), + *(GLfloat *)(pc + 8), + *(GLfloat *)(pc + 12) + ); +} + +void __glXDisp_ClearIndex(GLbyte *pc) +{ + glClearIndex( + *(GLfloat *)(pc + 0) + ); +} + +void __glXDisp_ClearColor(GLbyte *pc) +{ + glClearColor( + *(GLclampf *)(pc + 0), + *(GLclampf *)(pc + 4), + *(GLclampf *)(pc + 8), + *(GLclampf *)(pc + 12) + ); +} + +void __glXDisp_ClearStencil(GLbyte *pc) +{ + glClearStencil( + *(GLint *)(pc + 0) + ); +} + +void __glXDisp_ClearDepth(GLbyte *pc) +{ + +#ifdef __GLX_ALIGN64 + if ((unsigned long)(pc) & 7) { + __GLX_MEM_COPY(pc-4, pc, 8); + pc -= 4; + } +#endif + glClearDepth( + *(GLclampd *)(pc + 0) + ); +} + +void __glXDisp_StencilMask(GLbyte *pc) +{ + glStencilMask( + *(GLuint *)(pc + 0) + ); +} + +void __glXDisp_ColorMask(GLbyte *pc) +{ + glColorMask( + *(GLboolean *)(pc + 0), + *(GLboolean *)(pc + 1), + *(GLboolean *)(pc + 2), + *(GLboolean *)(pc + 3) + ); +} + +void __glXDisp_DepthMask(GLbyte *pc) +{ + glDepthMask( + *(GLboolean *)(pc + 0) + ); +} + +void __glXDisp_IndexMask(GLbyte *pc) +{ + glIndexMask( + *(GLuint *)(pc + 0) + ); +} + +void __glXDisp_Accum(GLbyte *pc) +{ + glAccum( + *(GLenum *)(pc + 0), + *(GLfloat *)(pc + 4) + ); +} + +void __glXDisp_Disable(GLbyte *pc) +{ + glDisable( + *(GLenum *)(pc + 0) + ); +} + +void __glXDisp_Enable(GLbyte *pc) +{ + glEnable( + *(GLenum *)(pc + 0) + ); +} + +void __glXDisp_PopAttrib(GLbyte *pc) +{ + glPopAttrib( + ); +} + +void __glXDisp_PushAttrib(GLbyte *pc) +{ + glPushAttrib( + *(GLbitfield *)(pc + 0) + ); +} + +void __glXDisp_MapGrid1d(GLbyte *pc) +{ + +#ifdef __GLX_ALIGN64 + if ((unsigned long)(pc) & 7) { + __GLX_MEM_COPY(pc-4, pc, 20); + pc -= 4; + } +#endif + glMapGrid1d( + *(GLint *)(pc + 16), + *(GLdouble *)(pc + 0), + *(GLdouble *)(pc + 8) + ); +} + +void __glXDisp_MapGrid1f(GLbyte *pc) +{ + glMapGrid1f( + *(GLint *)(pc + 0), + *(GLfloat *)(pc + 4), + *(GLfloat *)(pc + 8) + ); +} + +void __glXDisp_MapGrid2d(GLbyte *pc) +{ + +#ifdef __GLX_ALIGN64 + if ((unsigned long)(pc) & 7) { + __GLX_MEM_COPY(pc-4, pc, 40); + pc -= 4; + } +#endif + glMapGrid2d( + *(GLint *)(pc + 32), + *(GLdouble *)(pc + 0), + *(GLdouble *)(pc + 8), + *(GLint *)(pc + 36), + *(GLdouble *)(pc + 16), + *(GLdouble *)(pc + 24) + ); +} + +void __glXDisp_MapGrid2f(GLbyte *pc) +{ + glMapGrid2f( + *(GLint *)(pc + 0), + *(GLfloat *)(pc + 4), + *(GLfloat *)(pc + 8), + *(GLint *)(pc + 12), + *(GLfloat *)(pc + 16), + *(GLfloat *)(pc + 20) + ); +} + +void __glXDisp_EvalCoord1dv(GLbyte *pc) +{ + +#ifdef __GLX_ALIGN64 + if ((unsigned long)(pc) & 7) { + __GLX_MEM_COPY(pc-4, pc, 8); + pc -= 4; + } +#endif + glEvalCoord1dv( + (GLdouble *)(pc + 0) + ); +} + +void __glXDisp_EvalCoord1fv(GLbyte *pc) +{ + glEvalCoord1fv( + (GLfloat *)(pc + 0) + ); +} + +void __glXDisp_EvalCoord2dv(GLbyte *pc) +{ + +#ifdef __GLX_ALIGN64 + if ((unsigned long)(pc) & 7) { + __GLX_MEM_COPY(pc-4, pc, 16); + pc -= 4; + } +#endif + glEvalCoord2dv( + (GLdouble *)(pc + 0) + ); +} + +void __glXDisp_EvalCoord2fv(GLbyte *pc) +{ + glEvalCoord2fv( + (GLfloat *)(pc + 0) + ); +} + +void __glXDisp_EvalMesh1(GLbyte *pc) +{ + glEvalMesh1( + *(GLenum *)(pc + 0), + *(GLint *)(pc + 4), + *(GLint *)(pc + 8) + ); +} + +void __glXDisp_EvalPoint1(GLbyte *pc) +{ + glEvalPoint1( + *(GLint *)(pc + 0) + ); +} + +void __glXDisp_EvalMesh2(GLbyte *pc) +{ + glEvalMesh2( + *(GLenum *)(pc + 0), + *(GLint *)(pc + 4), + *(GLint *)(pc + 8), + *(GLint *)(pc + 12), + *(GLint *)(pc + 16) + ); +} + +void __glXDisp_EvalPoint2(GLbyte *pc) +{ + glEvalPoint2( + *(GLint *)(pc + 0), + *(GLint *)(pc + 4) + ); +} + +void __glXDisp_AlphaFunc(GLbyte *pc) +{ + glAlphaFunc( + *(GLenum *)(pc + 0), + *(GLclampf *)(pc + 4) + ); +} + +void __glXDisp_BlendFunc(GLbyte *pc) +{ + glBlendFunc( + *(GLenum *)(pc + 0), + *(GLenum *)(pc + 4) + ); +} + +void __glXDisp_LogicOp(GLbyte *pc) +{ + glLogicOp( + *(GLenum *)(pc + 0) + ); +} + +void __glXDisp_StencilFunc(GLbyte *pc) +{ + glStencilFunc( + *(GLenum *)(pc + 0), + *(GLint *)(pc + 4), + *(GLuint *)(pc + 8) + ); +} + +void __glXDisp_StencilOp(GLbyte *pc) +{ + glStencilOp( + *(GLenum *)(pc + 0), + *(GLenum *)(pc + 4), + *(GLenum *)(pc + 8) + ); +} + +void __glXDisp_DepthFunc(GLbyte *pc) +{ + glDepthFunc( + *(GLenum *)(pc + 0) + ); +} + +void __glXDisp_PixelZoom(GLbyte *pc) +{ + glPixelZoom( + *(GLfloat *)(pc + 0), + *(GLfloat *)(pc + 4) + ); +} + +void __glXDisp_PixelTransferf(GLbyte *pc) +{ + glPixelTransferf( + *(GLenum *)(pc + 0), + *(GLfloat *)(pc + 4) + ); +} + +void __glXDisp_PixelTransferi(GLbyte *pc) +{ + glPixelTransferi( + *(GLenum *)(pc + 0), + *(GLint *)(pc + 4) + ); +} + +void __glXDisp_PixelMapfv(GLbyte *pc) +{ + glPixelMapfv( + *(GLenum *)(pc + 0), + *(GLint *)(pc + 4), + (GLfloat *)(pc + 8) + ); +} + +void __glXDisp_PixelMapuiv(GLbyte *pc) +{ + glPixelMapuiv( + *(GLenum *)(pc + 0), + *(GLint *)(pc + 4), + (GLuint *)(pc + 8) + ); +} + +void __glXDisp_PixelMapusv(GLbyte *pc) +{ + glPixelMapusv( + *(GLenum *)(pc + 0), + *(GLint *)(pc + 4), + (GLushort *)(pc + 8) + ); +} + +void __glXDisp_ReadBuffer(GLbyte *pc) +{ + glReadBuffer( + *(GLenum *)(pc + 0) + ); +} + +void __glXDisp_CopyPixels(GLbyte *pc) +{ + glCopyPixels( + *(GLint *)(pc + 0), + *(GLint *)(pc + 4), + *(GLsizei *)(pc + 8), + *(GLsizei *)(pc + 12), + *(GLenum *)(pc + 16) + ); +} + +void __glXDisp_DepthRange(GLbyte *pc) +{ + +#ifdef __GLX_ALIGN64 + if ((unsigned long)(pc) & 7) { + __GLX_MEM_COPY(pc-4, pc, 16); + pc -= 4; + } +#endif + glDepthRange( + *(GLclampd *)(pc + 0), + *(GLclampd *)(pc + 8) + ); +} + +void __glXDisp_Frustum(GLbyte *pc) +{ + +#ifdef __GLX_ALIGN64 + if ((unsigned long)(pc) & 7) { + __GLX_MEM_COPY(pc-4, pc, 48); + pc -= 4; + } +#endif + glFrustum( + *(GLdouble *)(pc + 0), + *(GLdouble *)(pc + 8), + *(GLdouble *)(pc + 16), + *(GLdouble *)(pc + 24), + *(GLdouble *)(pc + 32), + *(GLdouble *)(pc + 40) + ); +} + +void __glXDisp_LoadIdentity(GLbyte *pc) +{ + glLoadIdentity( + ); +} + +void __glXDisp_LoadMatrixf(GLbyte *pc) +{ + glLoadMatrixf( + (GLfloat *)(pc + 0) + ); +} + +void __glXDisp_LoadMatrixd(GLbyte *pc) +{ + +#ifdef __GLX_ALIGN64 + if ((unsigned long)(pc) & 7) { + __GLX_MEM_COPY(pc-4, pc, 128); + pc -= 4; + } +#endif + glLoadMatrixd( + (GLdouble *)(pc + 0) + ); +} + +void __glXDisp_MatrixMode(GLbyte *pc) +{ + glMatrixMode( + *(GLenum *)(pc + 0) + ); +} + +void __glXDisp_MultMatrixf(GLbyte *pc) +{ + glMultMatrixf( + (GLfloat *)(pc + 0) + ); +} + +void __glXDisp_MultMatrixd(GLbyte *pc) +{ + +#ifdef __GLX_ALIGN64 + if ((unsigned long)(pc) & 7) { + __GLX_MEM_COPY(pc-4, pc, 128); + pc -= 4; + } +#endif + glMultMatrixd( + (GLdouble *)(pc + 0) + ); +} + +void __glXDisp_Ortho(GLbyte *pc) +{ + +#ifdef __GLX_ALIGN64 + if ((unsigned long)(pc) & 7) { + __GLX_MEM_COPY(pc-4, pc, 48); + pc -= 4; + } +#endif + glOrtho( + *(GLdouble *)(pc + 0), + *(GLdouble *)(pc + 8), + *(GLdouble *)(pc + 16), + *(GLdouble *)(pc + 24), + *(GLdouble *)(pc + 32), + *(GLdouble *)(pc + 40) + ); +} + +void __glXDisp_PopMatrix(GLbyte *pc) +{ + glPopMatrix( + ); +} + +void __glXDisp_PushMatrix(GLbyte *pc) +{ + glPushMatrix( + ); +} + +void __glXDisp_Rotated(GLbyte *pc) +{ + +#ifdef __GLX_ALIGN64 + if ((unsigned long)(pc) & 7) { + __GLX_MEM_COPY(pc-4, pc, 32); + pc -= 4; + } +#endif + glRotated( + *(GLdouble *)(pc + 0), + *(GLdouble *)(pc + 8), + *(GLdouble *)(pc + 16), + *(GLdouble *)(pc + 24) + ); +} + +void __glXDisp_Rotatef(GLbyte *pc) +{ + glRotatef( + *(GLfloat *)(pc + 0), + *(GLfloat *)(pc + 4), + *(GLfloat *)(pc + 8), + *(GLfloat *)(pc + 12) + ); +} + +void __glXDisp_Scaled(GLbyte *pc) +{ + +#ifdef __GLX_ALIGN64 + if ((unsigned long)(pc) & 7) { + __GLX_MEM_COPY(pc-4, pc, 24); + pc -= 4; + } +#endif + glScaled( + *(GLdouble *)(pc + 0), + *(GLdouble *)(pc + 8), + *(GLdouble *)(pc + 16) + ); +} + +void __glXDisp_Scalef(GLbyte *pc) +{ + glScalef( + *(GLfloat *)(pc + 0), + *(GLfloat *)(pc + 4), + *(GLfloat *)(pc + 8) + ); +} + +void __glXDisp_Translated(GLbyte *pc) +{ + +#ifdef __GLX_ALIGN64 + if ((unsigned long)(pc) & 7) { + __GLX_MEM_COPY(pc-4, pc, 24); + pc -= 4; + } +#endif + glTranslated( + *(GLdouble *)(pc + 0), + *(GLdouble *)(pc + 8), + *(GLdouble *)(pc + 16) + ); +} + +void __glXDisp_Translatef(GLbyte *pc) +{ + glTranslatef( + *(GLfloat *)(pc + 0), + *(GLfloat *)(pc + 4), + *(GLfloat *)(pc + 8) + ); +} + +void __glXDisp_Viewport(GLbyte *pc) +{ + glViewport( + *(GLint *)(pc + 0), + *(GLint *)(pc + 4), + *(GLsizei *)(pc + 8), + *(GLsizei *)(pc + 12) + ); +} + +void __glXDisp_PolygonOffset(GLbyte *pc) +{ + glPolygonOffset( + *(GLfloat *)(pc + 0), + *(GLfloat *)(pc + 4) + ); +} + +void __glXDisp_CopyTexImage1D(GLbyte *pc) +{ + glCopyTexImage1D( + *(GLenum *)(pc + 0), + *(GLint *)(pc + 4), + *(GLenum *)(pc + 8), + *(GLint *)(pc + 12), + *(GLint *)(pc + 16), + *(GLsizei *)(pc + 20), + *(GLint *)(pc + 24) + ); +} + +void __glXDisp_CopyTexImage2D(GLbyte *pc) +{ + glCopyTexImage2D( + *(GLenum *)(pc + 0), + *(GLint *)(pc + 4), + *(GLenum *)(pc + 8), + *(GLint *)(pc + 12), + *(GLint *)(pc + 16), + *(GLsizei *)(pc + 20), + *(GLsizei *)(pc + 24), + *(GLint *)(pc + 28) + ); +} + +void __glXDisp_CopyTexSubImage1D(GLbyte *pc) +{ + glCopyTexSubImage1D( + *(GLenum *)(pc + 0), + *(GLint *)(pc + 4), + *(GLint *)(pc + 8), + *(GLint *)(pc + 12), + *(GLint *)(pc + 16), + *(GLsizei *)(pc + 20) + ); +} + +void __glXDisp_CopyTexSubImage2D(GLbyte *pc) +{ + glCopyTexSubImage2D( + *(GLenum *)(pc + 0), + *(GLint *)(pc + 4), + *(GLint *)(pc + 8), + *(GLint *)(pc + 12), + *(GLint *)(pc + 16), + *(GLint *)(pc + 20), + *(GLsizei *)(pc + 24), + *(GLsizei *)(pc + 28) + ); +} + +void __glXDisp_BindTexture(GLbyte *pc) +{ + glBindTexture( + *(GLenum *)(pc + 0), + *(GLuint *)(pc + 4) + ); +} + +void __glXDisp_PrioritizeTextures(GLbyte *pc) +{ + GLsizei n; + + n = *(GLsizei *)(pc + 0); + + glPrioritizeTextures( + *(GLsizei *)(pc + 0), + (GLuint *)(pc + 4), + (GLclampf *)(pc + 4+n*4) + ); +} + +void __glXDisp_Indexubv(GLbyte *pc) +{ + glIndexubv( + (GLubyte *)(pc + 0) + ); +} + +void __glXDisp_BlendColor(GLbyte *pc) +{ + glBlendColor( + *(GLclampf *)(pc + 0), + *(GLclampf *)(pc + 4), + *(GLclampf *)(pc + 8), + *(GLclampf *)(pc + 12) + ); +} + +void __glXDisp_BlendEquation(GLbyte *pc) +{ + glBlendEquation( + *(GLenum *)(pc + 0) + ); +} + +void __glXDisp_ColorTableParameterfv(GLbyte *pc) +{ + glColorTableParameterfv( + *(GLenum *)(pc + 0), + *(GLenum *)(pc + 4), + (GLfloat *)(pc + 8) + ); +} + +void __glXDisp_ColorTableParameteriv(GLbyte *pc) +{ + glColorTableParameteriv( + *(GLenum *)(pc + 0), + *(GLenum *)(pc + 4), + (GLint *)(pc + 8) + ); +} + +void __glXDisp_CopyColorTable(GLbyte *pc) +{ + glCopyColorTable( + *(GLenum *)(pc + 0), + *(GLenum *)(pc + 4), + *(GLint *)(pc + 8), + *(GLint *)(pc + 12), + *(GLsizei *)(pc + 16) + ); +} + +void __glXDisp_CopyColorSubTable(GLbyte *pc) +{ + glCopyColorSubTable( + *(GLenum *)(pc + 0), + *(GLsizei *)(pc + 4), + *(GLint *)(pc + 8), + *(GLint *)(pc + 12), + *(GLsizei *)(pc + 16) + ); +} + +void __glXDisp_ConvolutionParameterf(GLbyte *pc) +{ + glConvolutionParameterf( + *(GLenum *)(pc + 0), + *(GLenum *)(pc + 4), + *(GLfloat *)(pc + 8) + ); +} + +void __glXDisp_ConvolutionParameterfv(GLbyte *pc) +{ + glConvolutionParameterfv( + *(GLenum *)(pc + 0), + *(GLenum *)(pc + 4), + (GLfloat *)(pc + 8) + ); +} + +void __glXDisp_ConvolutionParameteri(GLbyte *pc) +{ + glConvolutionParameteri( + *(GLenum *)(pc + 0), + *(GLenum *)(pc + 4), + *(GLint *)(pc + 8) + ); +} + +void __glXDisp_ConvolutionParameteriv(GLbyte *pc) +{ + glConvolutionParameteriv( + *(GLenum *)(pc + 0), + *(GLenum *)(pc + 4), + (GLint *)(pc + 8) + ); +} + +void __glXDisp_CopyConvolutionFilter1D(GLbyte *pc) +{ + glCopyConvolutionFilter1D( + *(GLenum *)(pc + 0), + *(GLenum *)(pc + 4), + *(GLint *)(pc + 8), + *(GLint *)(pc + 12), + *(GLsizei *)(pc + 16) + ); +} + +void __glXDisp_CopyConvolutionFilter2D(GLbyte *pc) +{ + glCopyConvolutionFilter2D( + *(GLenum *)(pc + 0), + *(GLenum *)(pc + 4), + *(GLint *)(pc + 8), + *(GLint *)(pc + 12), + *(GLsizei *)(pc + 16), + *(GLsizei *)(pc + 20) + ); +} + +void __glXDisp_Histogram(GLbyte *pc) +{ + glHistogram( + *(GLenum *)(pc + 0), + *(GLsizei *)(pc + 4), + *(GLenum *)(pc + 8), + *(GLboolean *)(pc + 12) + ); +} + +void __glXDisp_Minmax(GLbyte *pc) +{ + glMinmax( + *(GLenum *)(pc + 0), + *(GLenum *)(pc + 4), + *(GLboolean *)(pc + 8) + ); +} + +void __glXDisp_ResetHistogram(GLbyte *pc) +{ + glResetHistogram( + *(GLenum *)(pc + 0) + ); +} + +void __glXDisp_ResetMinmax(GLbyte *pc) +{ + glResetMinmax( + *(GLenum *)(pc + 0) + ); +} + +void __glXDisp_CopyTexSubImage3D(GLbyte *pc) +{ + glCopyTexSubImage3D( + *(GLenum *)(pc + 0), + *(GLint *)(pc + 4), + *(GLint *)(pc + 8), + *(GLint *)(pc + 12), + *(GLint *)(pc + 16), + *(GLint *)(pc + 20), + *(GLint *)(pc + 24), + *(GLsizei *)(pc + 28), + *(GLsizei *)(pc + 32) + ); +} + +void __glXDisp_ActiveTextureARB(GLbyte *pc) +{ + glActiveTextureARB( + *(GLenum *)(pc + 0) + ); +} + +void __glXDisp_MultiTexCoord1dvARB(GLbyte *pc) +{ + +#ifdef __GLX_ALIGN64 + if ((unsigned long)(pc) & 7) { + __GLX_MEM_COPY(pc-4, pc, 12); + pc -= 4; + } +#endif + glMultiTexCoord1dvARB( + *(GLenum *)(pc + 8), + (GLdouble *)(pc + 0) + ); +} + +void __glXDisp_MultiTexCoord1fvARB(GLbyte *pc) +{ + glMultiTexCoord1fvARB( + *(GLenum *)(pc + 0), + (GLfloat *)(pc + 4) + ); +} + +void __glXDisp_MultiTexCoord1ivARB(GLbyte *pc) +{ + glMultiTexCoord1ivARB( + *(GLenum *)(pc + 0), + (GLint *)(pc + 4) + ); +} + +void __glXDisp_MultiTexCoord1svARB(GLbyte *pc) +{ + glMultiTexCoord1svARB( + *(GLenum *)(pc + 0), + (GLshort *)(pc + 4) + ); +} + +void __glXDisp_MultiTexCoord2dvARB(GLbyte *pc) +{ + +#ifdef __GLX_ALIGN64 + if ((unsigned long)(pc) & 7) { + __GLX_MEM_COPY(pc-4, pc, 20); + pc -= 4; + } +#endif + glMultiTexCoord2dvARB( + *(GLenum *)(pc + 16), + (GLdouble *)(pc + 0) + ); +} + +void __glXDisp_MultiTexCoord2fvARB(GLbyte *pc) +{ + glMultiTexCoord2fvARB( + *(GLenum *)(pc + 0), + (GLfloat *)(pc + 4) + ); +} + +void __glXDisp_MultiTexCoord2ivARB(GLbyte *pc) +{ + glMultiTexCoord2ivARB( + *(GLenum *)(pc + 0), + (GLint *)(pc + 4) + ); +} + +void __glXDisp_MultiTexCoord2svARB(GLbyte *pc) +{ + glMultiTexCoord2svARB( + *(GLenum *)(pc + 0), + (GLshort *)(pc + 4) + ); +} + +void __glXDisp_MultiTexCoord3dvARB(GLbyte *pc) +{ + +#ifdef __GLX_ALIGN64 + if ((unsigned long)(pc) & 7) { + __GLX_MEM_COPY(pc-4, pc, 28); + pc -= 4; + } +#endif + glMultiTexCoord3dvARB( + *(GLenum *)(pc + 24), + (GLdouble *)(pc + 0) + ); +} + +void __glXDisp_MultiTexCoord3fvARB(GLbyte *pc) +{ + glMultiTexCoord3fvARB( + *(GLenum *)(pc + 0), + (GLfloat *)(pc + 4) + ); +} + +void __glXDisp_MultiTexCoord3ivARB(GLbyte *pc) +{ + glMultiTexCoord3ivARB( + *(GLenum *)(pc + 0), + (GLint *)(pc + 4) + ); +} + +void __glXDisp_MultiTexCoord3svARB(GLbyte *pc) +{ + glMultiTexCoord3svARB( + *(GLenum *)(pc + 0), + (GLshort *)(pc + 4) + ); +} + +void __glXDisp_MultiTexCoord4dvARB(GLbyte *pc) +{ + +#ifdef __GLX_ALIGN64 + if ((unsigned long)(pc) & 7) { + __GLX_MEM_COPY(pc-4, pc, 36); + pc -= 4; + } +#endif + glMultiTexCoord4dvARB( + *(GLenum *)(pc + 32), + (GLdouble *)(pc + 0) + ); +} + +void __glXDisp_MultiTexCoord4fvARB(GLbyte *pc) +{ + glMultiTexCoord4fvARB( + *(GLenum *)(pc + 0), + (GLfloat *)(pc + 4) + ); +} + +void __glXDisp_MultiTexCoord4ivARB(GLbyte *pc) +{ + glMultiTexCoord4ivARB( + *(GLenum *)(pc + 0), + (GLint *)(pc + 4) + ); +} + +void __glXDisp_MultiTexCoord4svARB(GLbyte *pc) +{ + glMultiTexCoord4svARB( + *(GLenum *)(pc + 0), + (GLshort *)(pc + 4) + ); +} + + +/* + * Extensions + */ + +#ifndef MISSING_GL_EXTS + +void __glXDisp_PointParameterfARB(GLbyte *pc) +{ + glPointParameterfARB( + *(GLenum *)(pc + 0), + *(GLfloat *)(pc + 4) + ); +} + + +void __glXDisp_PointParameterfvARB(GLbyte *pc) +{ + glPointParameterfvARB( + *(GLenum *)(pc + 0), + (GLfloat *)(pc + 4) + ); +} + +dispatch_template_enum1_1s(PointParameteriNV, GLint) +dispatch_template_enum1_Vv(PointParameterivNV, GLint) + +void __glXDisp_ActiveStencilFaceEXT(GLbyte *pc) +{ + glActiveStencilFaceEXT( + *(GLenum *)(pc + 0) + ); +} + +void __glXDisp_WindowPos3fARB(GLbyte *pc) +{ + glWindowPos3fARB( + *(GLfloat *)(pc + 0), + *(GLfloat *)(pc + 4), + *(GLfloat *)(pc + 8) + ); +} +#endif /* !MISSING_GL_EXTS */ + +void __glXDisp_SampleCoverageARB(GLbyte *pc) +{ + glSampleCoverageARB( + *(GLfloat *)(pc + 0), + *(GLboolean *)(pc + 4) + ); +} |