1 /* DO NOT EDIT - This file generated automatically by glX_proto_recv.py (from Mesa) script */
4 * (C) Copyright IBM Corporation 2005
7 * Permission is hereby granted, free of charge, to any person obtaining a
8 * copy of this software and associated documentation files (the "Software"),
9 * to deal in the Software without restriction, including without limitation
10 * the rights to use, copy, modify, merge, publish, distribute, sub license,
11 * and/or sell copies of the Software, and to permit persons to whom the
12 * Software is furnished to do so, subject to the following conditions:
14 * The above copyright notice and this permission notice (including the next
15 * paragraph) shall be included in all copies or substantial portions of the
18 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
19 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
20 * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL
22 * AND/OR THEIR SUPPLIERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
23 * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF
24 * OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
29 #include "glxserver.h"
30 #include "indirect_size.h"
31 #include "indirect_size_get.h"
32 #include "indirect_dispatch.h"
33 #include "glxbyteorder.h"
34 #include "indirect_util.h"
35 #include "singlesize.h"
37 #define __GLX_PAD(x) (((x) + 3) & ~3)
43 extern GLboolean
__glXErrorOccured(void);
44 extern void __glXClearErrorOccured(void);
46 static const unsigned dummy_answer
[2] = { 0, 0 };
49 __glXDisp_NewList(__GLXclientState
* cl
, GLbyte
* pc
)
51 xGLXSingleReq
*const req
= (xGLXSingleReq
*) pc
;
53 __GLXcontext
*const cx
= __glXForceCurrent(cl
, req
->contextTag
, &error
);
55 pc
+= __GLX_SINGLE_HDR_SIZE
;
57 glNewList(*(GLuint
*) (pc
+ 0), *(GLenum
*) (pc
+ 4));
65 __glXDisp_EndList(__GLXclientState
* cl
, GLbyte
* pc
)
67 xGLXSingleReq
*const req
= (xGLXSingleReq
*) pc
;
69 __GLXcontext
*const cx
= __glXForceCurrent(cl
, req
->contextTag
, &error
);
71 pc
+= __GLX_SINGLE_HDR_SIZE
;
81 __glXDisp_CallList(GLbyte
* pc
)
83 glCallList(*(GLuint
*) (pc
+ 0));
87 __glXDisp_CallLists(GLbyte
* pc
)
89 const GLsizei n
= *(GLsizei
*) (pc
+ 0);
90 const GLenum type
= *(GLenum
*) (pc
+ 4);
91 const GLvoid
*lists
= (const GLvoid
*) (pc
+ 8);
93 lists
= (const GLvoid
*) (pc
+ 8);
95 glCallLists(n
, type
, lists
);
99 __glXDisp_DeleteLists(__GLXclientState
* cl
, GLbyte
* pc
)
101 xGLXSingleReq
*const req
= (xGLXSingleReq
*) pc
;
103 __GLXcontext
*const cx
= __glXForceCurrent(cl
, req
->contextTag
, &error
);
105 pc
+= __GLX_SINGLE_HDR_SIZE
;
107 glDeleteLists(*(GLuint
*) (pc
+ 0), *(GLsizei
*) (pc
+ 4));
115 __glXDisp_GenLists(__GLXclientState
* cl
, GLbyte
* pc
)
117 xGLXSingleReq
*const req
= (xGLXSingleReq
*) pc
;
119 __GLXcontext
*const cx
= __glXForceCurrent(cl
, req
->contextTag
, &error
);
121 pc
+= __GLX_SINGLE_HDR_SIZE
;
125 retval
= glGenLists(*(GLsizei
*) (pc
+ 0));
126 __glXSendReply(cl
->client
, dummy_answer
, 0, 0, GL_FALSE
, retval
);
134 __glXDisp_ListBase(GLbyte
* pc
)
136 glListBase(*(GLuint
*) (pc
+ 0));
140 __glXDisp_Begin(GLbyte
* pc
)
142 glBegin(*(GLenum
*) (pc
+ 0));
146 __glXDisp_Bitmap(GLbyte
* pc
)
148 const GLubyte
*const bitmap
= (const GLubyte
*) ((pc
+ 44));
149 __GLXpixelHeader
*const hdr
= (__GLXpixelHeader
*) (pc
);
151 glPixelStorei(GL_UNPACK_LSB_FIRST
, hdr
->lsbFirst
);
152 glPixelStorei(GL_UNPACK_ROW_LENGTH
, (GLint
) hdr
->rowLength
);
153 glPixelStorei(GL_UNPACK_SKIP_ROWS
, (GLint
) hdr
->skipRows
);
154 glPixelStorei(GL_UNPACK_SKIP_PIXELS
, (GLint
) hdr
->skipPixels
);
155 glPixelStorei(GL_UNPACK_ALIGNMENT
, (GLint
) hdr
->alignment
);
157 glBitmap(*(GLsizei
*) (pc
+ 20),
158 *(GLsizei
*) (pc
+ 24),
159 *(GLfloat
*) (pc
+ 28),
160 *(GLfloat
*) (pc
+ 32),
161 *(GLfloat
*) (pc
+ 36), *(GLfloat
*) (pc
+ 40), bitmap
);
165 __glXDisp_Color3bv(GLbyte
* pc
)
167 glColor3bv((const GLbyte
*) (pc
+ 0));
171 __glXDisp_Color3dv(GLbyte
* pc
)
174 if ((unsigned long) (pc
) & 7) {
175 (void) memmove(pc
- 4, pc
, 24);
180 glColor3dv((const GLdouble
*) (pc
+ 0));
184 __glXDisp_Color3fv(GLbyte
* pc
)
186 glColor3fv((const GLfloat
*) (pc
+ 0));
190 __glXDisp_Color3iv(GLbyte
* pc
)
192 glColor3iv((const GLint
*) (pc
+ 0));
196 __glXDisp_Color3sv(GLbyte
* pc
)
198 glColor3sv((const GLshort
*) (pc
+ 0));
202 __glXDisp_Color3ubv(GLbyte
* pc
)
204 glColor3ubv((const GLubyte
*) (pc
+ 0));
208 __glXDisp_Color3uiv(GLbyte
* pc
)
210 glColor3uiv((const GLuint
*) (pc
+ 0));
214 __glXDisp_Color3usv(GLbyte
* pc
)
216 glColor3usv((const GLushort
*) (pc
+ 0));
220 __glXDisp_Color4bv(GLbyte
* pc
)
222 glColor4bv((const GLbyte
*) (pc
+ 0));
226 __glXDisp_Color4dv(GLbyte
* pc
)
229 if ((unsigned long) (pc
) & 7) {
230 (void) memmove(pc
- 4, pc
, 32);
235 glColor4dv((const GLdouble
*) (pc
+ 0));
239 __glXDisp_Color4fv(GLbyte
* pc
)
241 glColor4fv((const GLfloat
*) (pc
+ 0));
245 __glXDisp_Color4iv(GLbyte
* pc
)
247 glColor4iv((const GLint
*) (pc
+ 0));
251 __glXDisp_Color4sv(GLbyte
* pc
)
253 glColor4sv((const GLshort
*) (pc
+ 0));
257 __glXDisp_Color4ubv(GLbyte
* pc
)
259 glColor4ubv((const GLubyte
*) (pc
+ 0));
263 __glXDisp_Color4uiv(GLbyte
* pc
)
265 glColor4uiv((const GLuint
*) (pc
+ 0));
269 __glXDisp_Color4usv(GLbyte
* pc
)
271 glColor4usv((const GLushort
*) (pc
+ 0));
275 __glXDisp_EdgeFlagv(GLbyte
* pc
)
277 glEdgeFlagv((const GLboolean
*) (pc
+ 0));
281 __glXDisp_End(GLbyte
* pc
)
287 __glXDisp_Indexdv(GLbyte
* pc
)
290 if ((unsigned long) (pc
) & 7) {
291 (void) memmove(pc
- 4, pc
, 8);
296 glIndexdv((const GLdouble
*) (pc
+ 0));
300 __glXDisp_Indexfv(GLbyte
* pc
)
302 glIndexfv((const GLfloat
*) (pc
+ 0));
306 __glXDisp_Indexiv(GLbyte
* pc
)
308 glIndexiv((const GLint
*) (pc
+ 0));
312 __glXDisp_Indexsv(GLbyte
* pc
)
314 glIndexsv((const GLshort
*) (pc
+ 0));
318 __glXDisp_Normal3bv(GLbyte
* pc
)
320 glNormal3bv((const GLbyte
*) (pc
+ 0));
324 __glXDisp_Normal3dv(GLbyte
* pc
)
327 if ((unsigned long) (pc
) & 7) {
328 (void) memmove(pc
- 4, pc
, 24);
333 glNormal3dv((const GLdouble
*) (pc
+ 0));
337 __glXDisp_Normal3fv(GLbyte
* pc
)
339 glNormal3fv((const GLfloat
*) (pc
+ 0));
343 __glXDisp_Normal3iv(GLbyte
* pc
)
345 glNormal3iv((const GLint
*) (pc
+ 0));
349 __glXDisp_Normal3sv(GLbyte
* pc
)
351 glNormal3sv((const GLshort
*) (pc
+ 0));
355 __glXDisp_RasterPos2dv(GLbyte
* pc
)
358 if ((unsigned long) (pc
) & 7) {
359 (void) memmove(pc
- 4, pc
, 16);
364 glRasterPos2dv((const GLdouble
*) (pc
+ 0));
368 __glXDisp_RasterPos2fv(GLbyte
* pc
)
370 glRasterPos2fv((const GLfloat
*) (pc
+ 0));
374 __glXDisp_RasterPos2iv(GLbyte
* pc
)
376 glRasterPos2iv((const GLint
*) (pc
+ 0));
380 __glXDisp_RasterPos2sv(GLbyte
* pc
)
382 glRasterPos2sv((const GLshort
*) (pc
+ 0));
386 __glXDisp_RasterPos3dv(GLbyte
* pc
)
389 if ((unsigned long) (pc
) & 7) {
390 (void) memmove(pc
- 4, pc
, 24);
395 glRasterPos3dv((const GLdouble
*) (pc
+ 0));
399 __glXDisp_RasterPos3fv(GLbyte
* pc
)
401 glRasterPos3fv((const GLfloat
*) (pc
+ 0));
405 __glXDisp_RasterPos3iv(GLbyte
* pc
)
407 glRasterPos3iv((const GLint
*) (pc
+ 0));
411 __glXDisp_RasterPos3sv(GLbyte
* pc
)
413 glRasterPos3sv((const GLshort
*) (pc
+ 0));
417 __glXDisp_RasterPos4dv(GLbyte
* pc
)
420 if ((unsigned long) (pc
) & 7) {
421 (void) memmove(pc
- 4, pc
, 32);
426 glRasterPos4dv((const GLdouble
*) (pc
+ 0));
430 __glXDisp_RasterPos4fv(GLbyte
* pc
)
432 glRasterPos4fv((const GLfloat
*) (pc
+ 0));
436 __glXDisp_RasterPos4iv(GLbyte
* pc
)
438 glRasterPos4iv((const GLint
*) (pc
+ 0));
442 __glXDisp_RasterPos4sv(GLbyte
* pc
)
444 glRasterPos4sv((const GLshort
*) (pc
+ 0));
448 __glXDisp_Rectdv(GLbyte
* pc
)
451 if ((unsigned long) (pc
) & 7) {
452 (void) memmove(pc
- 4, pc
, 32);
457 glRectdv((const GLdouble
*) (pc
+ 0), (const GLdouble
*) (pc
+ 16));
461 __glXDisp_Rectfv(GLbyte
* pc
)
463 glRectfv((const GLfloat
*) (pc
+ 0), (const GLfloat
*) (pc
+ 8));
467 __glXDisp_Rectiv(GLbyte
* pc
)
469 glRectiv((const GLint
*) (pc
+ 0), (const GLint
*) (pc
+ 8));
473 __glXDisp_Rectsv(GLbyte
* pc
)
475 glRectsv((const GLshort
*) (pc
+ 0), (const GLshort
*) (pc
+ 4));
479 __glXDisp_TexCoord1dv(GLbyte
* pc
)
482 if ((unsigned long) (pc
) & 7) {
483 (void) memmove(pc
- 4, pc
, 8);
488 glTexCoord1dv((const GLdouble
*) (pc
+ 0));
492 __glXDisp_TexCoord1fv(GLbyte
* pc
)
494 glTexCoord1fv((const GLfloat
*) (pc
+ 0));
498 __glXDisp_TexCoord1iv(GLbyte
* pc
)
500 glTexCoord1iv((const GLint
*) (pc
+ 0));
504 __glXDisp_TexCoord1sv(GLbyte
* pc
)
506 glTexCoord1sv((const GLshort
*) (pc
+ 0));
510 __glXDisp_TexCoord2dv(GLbyte
* pc
)
513 if ((unsigned long) (pc
) & 7) {
514 (void) memmove(pc
- 4, pc
, 16);
519 glTexCoord2dv((const GLdouble
*) (pc
+ 0));
523 __glXDisp_TexCoord2fv(GLbyte
* pc
)
525 glTexCoord2fv((const GLfloat
*) (pc
+ 0));
529 __glXDisp_TexCoord2iv(GLbyte
* pc
)
531 glTexCoord2iv((const GLint
*) (pc
+ 0));
535 __glXDisp_TexCoord2sv(GLbyte
* pc
)
537 glTexCoord2sv((const GLshort
*) (pc
+ 0));
541 __glXDisp_TexCoord3dv(GLbyte
* pc
)
544 if ((unsigned long) (pc
) & 7) {
545 (void) memmove(pc
- 4, pc
, 24);
550 glTexCoord3dv((const GLdouble
*) (pc
+ 0));
554 __glXDisp_TexCoord3fv(GLbyte
* pc
)
556 glTexCoord3fv((const GLfloat
*) (pc
+ 0));
560 __glXDisp_TexCoord3iv(GLbyte
* pc
)
562 glTexCoord3iv((const GLint
*) (pc
+ 0));
566 __glXDisp_TexCoord3sv(GLbyte
* pc
)
568 glTexCoord3sv((const GLshort
*) (pc
+ 0));
572 __glXDisp_TexCoord4dv(GLbyte
* pc
)
575 if ((unsigned long) (pc
) & 7) {
576 (void) memmove(pc
- 4, pc
, 32);
581 glTexCoord4dv((const GLdouble
*) (pc
+ 0));
585 __glXDisp_TexCoord4fv(GLbyte
* pc
)
587 glTexCoord4fv((const GLfloat
*) (pc
+ 0));
591 __glXDisp_TexCoord4iv(GLbyte
* pc
)
593 glTexCoord4iv((const GLint
*) (pc
+ 0));
597 __glXDisp_TexCoord4sv(GLbyte
* pc
)
599 glTexCoord4sv((const GLshort
*) (pc
+ 0));
603 __glXDisp_Vertex2dv(GLbyte
* pc
)
606 if ((unsigned long) (pc
) & 7) {
607 (void) memmove(pc
- 4, pc
, 16);
612 glVertex2dv((const GLdouble
*) (pc
+ 0));
616 __glXDisp_Vertex2fv(GLbyte
* pc
)
618 glVertex2fv((const GLfloat
*) (pc
+ 0));
622 __glXDisp_Vertex2iv(GLbyte
* pc
)
624 glVertex2iv((const GLint
*) (pc
+ 0));
628 __glXDisp_Vertex2sv(GLbyte
* pc
)
630 glVertex2sv((const GLshort
*) (pc
+ 0));
634 __glXDisp_Vertex3dv(GLbyte
* pc
)
637 if ((unsigned long) (pc
) & 7) {
638 (void) memmove(pc
- 4, pc
, 24);
643 glVertex3dv((const GLdouble
*) (pc
+ 0));
647 __glXDisp_Vertex3fv(GLbyte
* pc
)
649 glVertex3fv((const GLfloat
*) (pc
+ 0));
653 __glXDisp_Vertex3iv(GLbyte
* pc
)
655 glVertex3iv((const GLint
*) (pc
+ 0));
659 __glXDisp_Vertex3sv(GLbyte
* pc
)
661 glVertex3sv((const GLshort
*) (pc
+ 0));
665 __glXDisp_Vertex4dv(GLbyte
* pc
)
668 if ((unsigned long) (pc
) & 7) {
669 (void) memmove(pc
- 4, pc
, 32);
674 glVertex4dv((const GLdouble
*) (pc
+ 0));
678 __glXDisp_Vertex4fv(GLbyte
* pc
)
680 glVertex4fv((const GLfloat
*) (pc
+ 0));
684 __glXDisp_Vertex4iv(GLbyte
* pc
)
686 glVertex4iv((const GLint
*) (pc
+ 0));
690 __glXDisp_Vertex4sv(GLbyte
* pc
)
692 glVertex4sv((const GLshort
*) (pc
+ 0));
696 __glXDisp_ClipPlane(GLbyte
* pc
)
699 if ((unsigned long) (pc
) & 7) {
700 (void) memmove(pc
- 4, pc
, 36);
705 glClipPlane(*(GLenum
*) (pc
+ 32), (const GLdouble
*) (pc
+ 0));
709 __glXDisp_ColorMaterial(GLbyte
* pc
)
711 glColorMaterial(*(GLenum
*) (pc
+ 0), *(GLenum
*) (pc
+ 4));
715 __glXDisp_CullFace(GLbyte
* pc
)
717 glCullFace(*(GLenum
*) (pc
+ 0));
721 __glXDisp_Fogf(GLbyte
* pc
)
723 glFogf(*(GLenum
*) (pc
+ 0), *(GLfloat
*) (pc
+ 4));
727 __glXDisp_Fogfv(GLbyte
* pc
)
729 const GLenum pname
= *(GLenum
*) (pc
+ 0);
730 const GLfloat
*params
;
732 params
= (const GLfloat
*) (pc
+ 4);
734 glFogfv(pname
, params
);
738 __glXDisp_Fogi(GLbyte
* pc
)
740 glFogi(*(GLenum
*) (pc
+ 0), *(GLint
*) (pc
+ 4));
744 __glXDisp_Fogiv(GLbyte
* pc
)
746 const GLenum pname
= *(GLenum
*) (pc
+ 0);
749 params
= (const GLint
*) (pc
+ 4);
751 glFogiv(pname
, params
);
755 __glXDisp_FrontFace(GLbyte
* pc
)
757 glFrontFace(*(GLenum
*) (pc
+ 0));
761 __glXDisp_Hint(GLbyte
* pc
)
763 glHint(*(GLenum
*) (pc
+ 0), *(GLenum
*) (pc
+ 4));
767 __glXDisp_Lightf(GLbyte
* pc
)
769 glLightf(*(GLenum
*) (pc
+ 0), *(GLenum
*) (pc
+ 4), *(GLfloat
*) (pc
+ 8));
773 __glXDisp_Lightfv(GLbyte
* pc
)
775 const GLenum pname
= *(GLenum
*) (pc
+ 4);
776 const GLfloat
*params
;
778 params
= (const GLfloat
*) (pc
+ 8);
780 glLightfv(*(GLenum
*) (pc
+ 0), pname
, params
);
784 __glXDisp_Lighti(GLbyte
* pc
)
786 glLighti(*(GLenum
*) (pc
+ 0), *(GLenum
*) (pc
+ 4), *(GLint
*) (pc
+ 8));
790 __glXDisp_Lightiv(GLbyte
* pc
)
792 const GLenum pname
= *(GLenum
*) (pc
+ 4);
795 params
= (const GLint
*) (pc
+ 8);
797 glLightiv(*(GLenum
*) (pc
+ 0), pname
, params
);
801 __glXDisp_LightModelf(GLbyte
* pc
)
803 glLightModelf(*(GLenum
*) (pc
+ 0), *(GLfloat
*) (pc
+ 4));
807 __glXDisp_LightModelfv(GLbyte
* pc
)
809 const GLenum pname
= *(GLenum
*) (pc
+ 0);
810 const GLfloat
*params
;
812 params
= (const GLfloat
*) (pc
+ 4);
814 glLightModelfv(pname
, params
);
818 __glXDisp_LightModeli(GLbyte
* pc
)
820 glLightModeli(*(GLenum
*) (pc
+ 0), *(GLint
*) (pc
+ 4));
824 __glXDisp_LightModeliv(GLbyte
* pc
)
826 const GLenum pname
= *(GLenum
*) (pc
+ 0);
829 params
= (const GLint
*) (pc
+ 4);
831 glLightModeliv(pname
, params
);
835 __glXDisp_LineStipple(GLbyte
* pc
)
837 glLineStipple(*(GLint
*) (pc
+ 0), *(GLushort
*) (pc
+ 4));
841 __glXDisp_LineWidth(GLbyte
* pc
)
843 glLineWidth(*(GLfloat
*) (pc
+ 0));
847 __glXDisp_Materialf(GLbyte
* pc
)
849 glMaterialf(*(GLenum
*) (pc
+ 0),
850 *(GLenum
*) (pc
+ 4), *(GLfloat
*) (pc
+ 8));
854 __glXDisp_Materialfv(GLbyte
* pc
)
856 const GLenum pname
= *(GLenum
*) (pc
+ 4);
857 const GLfloat
*params
;
859 params
= (const GLfloat
*) (pc
+ 8);
861 glMaterialfv(*(GLenum
*) (pc
+ 0), pname
, params
);
865 __glXDisp_Materiali(GLbyte
* pc
)
867 glMateriali(*(GLenum
*) (pc
+ 0),
868 *(GLenum
*) (pc
+ 4), *(GLint
*) (pc
+ 8));
872 __glXDisp_Materialiv(GLbyte
* pc
)
874 const GLenum pname
= *(GLenum
*) (pc
+ 4);
877 params
= (const GLint
*) (pc
+ 8);
879 glMaterialiv(*(GLenum
*) (pc
+ 0), pname
, params
);
883 __glXDisp_PointSize(GLbyte
* pc
)
885 glPointSize(*(GLfloat
*) (pc
+ 0));
889 __glXDisp_PolygonMode(GLbyte
* pc
)
891 glPolygonMode(*(GLenum
*) (pc
+ 0), *(GLenum
*) (pc
+ 4));
895 __glXDisp_PolygonStipple(GLbyte
* pc
)
897 const GLubyte
*const mask
= (const GLubyte
*) ((pc
+ 20));
898 __GLXpixelHeader
*const hdr
= (__GLXpixelHeader
*) (pc
);
900 glPixelStorei(GL_UNPACK_LSB_FIRST
, hdr
->lsbFirst
);
901 glPixelStorei(GL_UNPACK_ROW_LENGTH
, (GLint
) hdr
->rowLength
);
902 glPixelStorei(GL_UNPACK_SKIP_ROWS
, (GLint
) hdr
->skipRows
);
903 glPixelStorei(GL_UNPACK_SKIP_PIXELS
, (GLint
) hdr
->skipPixels
);
904 glPixelStorei(GL_UNPACK_ALIGNMENT
, (GLint
) hdr
->alignment
);
906 glPolygonStipple(mask
);
910 __glXDisp_Scissor(GLbyte
* pc
)
912 glScissor(*(GLint
*) (pc
+ 0),
914 *(GLsizei
*) (pc
+ 8), *(GLsizei
*) (pc
+ 12));
918 __glXDisp_ShadeModel(GLbyte
* pc
)
920 glShadeModel(*(GLenum
*) (pc
+ 0));
924 __glXDisp_TexParameterf(GLbyte
* pc
)
926 glTexParameterf(*(GLenum
*) (pc
+ 0),
927 *(GLenum
*) (pc
+ 4), *(GLfloat
*) (pc
+ 8));
931 __glXDisp_TexParameterfv(GLbyte
* pc
)
933 const GLenum pname
= *(GLenum
*) (pc
+ 4);
934 const GLfloat
*params
;
936 params
= (const GLfloat
*) (pc
+ 8);
938 glTexParameterfv(*(GLenum
*) (pc
+ 0), pname
, params
);
942 __glXDisp_TexParameteri(GLbyte
* pc
)
944 glTexParameteri(*(GLenum
*) (pc
+ 0),
945 *(GLenum
*) (pc
+ 4), *(GLint
*) (pc
+ 8));
949 __glXDisp_TexParameteriv(GLbyte
* pc
)
951 const GLenum pname
= *(GLenum
*) (pc
+ 4);
954 params
= (const GLint
*) (pc
+ 8);
956 glTexParameteriv(*(GLenum
*) (pc
+ 0), pname
, params
);
960 __glXDisp_TexImage1D(GLbyte
* pc
)
962 const GLvoid
*const pixels
= (const GLvoid
*) ((pc
+ 52));
963 __GLXpixelHeader
*const hdr
= (__GLXpixelHeader
*) (pc
);
965 glPixelStorei(GL_UNPACK_SWAP_BYTES
, hdr
->swapBytes
);
966 glPixelStorei(GL_UNPACK_LSB_FIRST
, hdr
->lsbFirst
);
967 glPixelStorei(GL_UNPACK_ROW_LENGTH
, (GLint
) hdr
->rowLength
);
968 glPixelStorei(GL_UNPACK_SKIP_ROWS
, (GLint
) hdr
->skipRows
);
969 glPixelStorei(GL_UNPACK_SKIP_PIXELS
, (GLint
) hdr
->skipPixels
);
970 glPixelStorei(GL_UNPACK_ALIGNMENT
, (GLint
) hdr
->alignment
);
972 glTexImage1D(*(GLenum
*) (pc
+ 20),
973 *(GLint
*) (pc
+ 24),
974 *(GLint
*) (pc
+ 28),
975 *(GLsizei
*) (pc
+ 32),
976 *(GLint
*) (pc
+ 40),
977 *(GLenum
*) (pc
+ 44), *(GLenum
*) (pc
+ 48), pixels
);
981 __glXDisp_TexImage2D(GLbyte
* pc
)
983 const GLvoid
*const pixels
= (const GLvoid
*) ((pc
+ 52));
984 __GLXpixelHeader
*const hdr
= (__GLXpixelHeader
*) (pc
);
986 glPixelStorei(GL_UNPACK_SWAP_BYTES
, hdr
->swapBytes
);
987 glPixelStorei(GL_UNPACK_LSB_FIRST
, hdr
->lsbFirst
);
988 glPixelStorei(GL_UNPACK_ROW_LENGTH
, (GLint
) hdr
->rowLength
);
989 glPixelStorei(GL_UNPACK_SKIP_ROWS
, (GLint
) hdr
->skipRows
);
990 glPixelStorei(GL_UNPACK_SKIP_PIXELS
, (GLint
) hdr
->skipPixels
);
991 glPixelStorei(GL_UNPACK_ALIGNMENT
, (GLint
) hdr
->alignment
);
993 glTexImage2D(*(GLenum
*) (pc
+ 20),
994 *(GLint
*) (pc
+ 24),
995 *(GLint
*) (pc
+ 28),
996 *(GLsizei
*) (pc
+ 32),
997 *(GLsizei
*) (pc
+ 36),
998 *(GLint
*) (pc
+ 40),
999 *(GLenum
*) (pc
+ 44), *(GLenum
*) (pc
+ 48), pixels
);
1003 __glXDisp_TexEnvf(GLbyte
* pc
)
1005 glTexEnvf(*(GLenum
*) (pc
+ 0),
1006 *(GLenum
*) (pc
+ 4), *(GLfloat
*) (pc
+ 8));
1010 __glXDisp_TexEnvfv(GLbyte
* pc
)
1012 const GLenum pname
= *(GLenum
*) (pc
+ 4);
1013 const GLfloat
*params
;
1015 params
= (const GLfloat
*) (pc
+ 8);
1017 glTexEnvfv(*(GLenum
*) (pc
+ 0), pname
, params
);
1021 __glXDisp_TexEnvi(GLbyte
* pc
)
1023 glTexEnvi(*(GLenum
*) (pc
+ 0), *(GLenum
*) (pc
+ 4), *(GLint
*) (pc
+ 8));
1027 __glXDisp_TexEnviv(GLbyte
* pc
)
1029 const GLenum pname
= *(GLenum
*) (pc
+ 4);
1030 const GLint
*params
;
1032 params
= (const GLint
*) (pc
+ 8);
1034 glTexEnviv(*(GLenum
*) (pc
+ 0), pname
, params
);
1038 __glXDisp_TexGend(GLbyte
* pc
)
1040 #ifdef __GLX_ALIGN64
1041 if ((unsigned long) (pc
) & 7) {
1042 (void) memmove(pc
- 4, pc
, 16);
1047 glTexGend(*(GLenum
*) (pc
+ 8),
1048 *(GLenum
*) (pc
+ 12), *(GLdouble
*) (pc
+ 0));
1052 __glXDisp_TexGendv(GLbyte
* pc
)
1054 const GLenum pname
= *(GLenum
*) (pc
+ 4);
1055 const GLdouble
*params
;
1057 #ifdef __GLX_ALIGN64
1058 const GLuint compsize
= __glTexGendv_size(pname
);
1059 const GLuint cmdlen
= 12 + __GLX_PAD((compsize
* 8)) - 4;
1061 if ((unsigned long) (pc
) & 7) {
1062 (void) memmove(pc
- 4, pc
, cmdlen
);
1067 params
= (const GLdouble
*) (pc
+ 8);
1069 glTexGendv(*(GLenum
*) (pc
+ 0), pname
, params
);
1073 __glXDisp_TexGenf(GLbyte
* pc
)
1075 glTexGenf(*(GLenum
*) (pc
+ 0),
1076 *(GLenum
*) (pc
+ 4), *(GLfloat
*) (pc
+ 8));
1080 __glXDisp_TexGenfv(GLbyte
* pc
)
1082 const GLenum pname
= *(GLenum
*) (pc
+ 4);
1083 const GLfloat
*params
;
1085 params
= (const GLfloat
*) (pc
+ 8);
1087 glTexGenfv(*(GLenum
*) (pc
+ 0), pname
, params
);
1091 __glXDisp_TexGeni(GLbyte
* pc
)
1093 glTexGeni(*(GLenum
*) (pc
+ 0), *(GLenum
*) (pc
+ 4), *(GLint
*) (pc
+ 8));
1097 __glXDisp_TexGeniv(GLbyte
* pc
)
1099 const GLenum pname
= *(GLenum
*) (pc
+ 4);
1100 const GLint
*params
;
1102 params
= (const GLint
*) (pc
+ 8);
1104 glTexGeniv(*(GLenum
*) (pc
+ 0), pname
, params
);
1108 __glXDisp_InitNames(GLbyte
* pc
)
1114 __glXDisp_LoadName(GLbyte
* pc
)
1116 glLoadName(*(GLuint
*) (pc
+ 0));
1120 __glXDisp_PassThrough(GLbyte
* pc
)
1122 glPassThrough(*(GLfloat
*) (pc
+ 0));
1126 __glXDisp_PopName(GLbyte
* pc
)
1132 __glXDisp_PushName(GLbyte
* pc
)
1134 glPushName(*(GLuint
*) (pc
+ 0));
1138 __glXDisp_DrawBuffer(GLbyte
* pc
)
1140 glDrawBuffer(*(GLenum
*) (pc
+ 0));
1144 __glXDisp_Clear(GLbyte
* pc
)
1146 glClear(*(GLbitfield
*) (pc
+ 0));
1150 __glXDisp_ClearAccum(GLbyte
* pc
)
1152 glClearAccum(*(GLfloat
*) (pc
+ 0),
1153 *(GLfloat
*) (pc
+ 4),
1154 *(GLfloat
*) (pc
+ 8), *(GLfloat
*) (pc
+ 12));
1158 __glXDisp_ClearIndex(GLbyte
* pc
)
1160 glClearIndex(*(GLfloat
*) (pc
+ 0));
1164 __glXDisp_ClearColor(GLbyte
* pc
)
1166 glClearColor(*(GLclampf
*) (pc
+ 0),
1167 *(GLclampf
*) (pc
+ 4),
1168 *(GLclampf
*) (pc
+ 8), *(GLclampf
*) (pc
+ 12));
1172 __glXDisp_ClearStencil(GLbyte
* pc
)
1174 glClearStencil(*(GLint
*) (pc
+ 0));
1178 __glXDisp_ClearDepth(GLbyte
* pc
)
1180 #ifdef __GLX_ALIGN64
1181 if ((unsigned long) (pc
) & 7) {
1182 (void) memmove(pc
- 4, pc
, 8);
1187 glClearDepth(*(GLclampd
*) (pc
+ 0));
1191 __glXDisp_StencilMask(GLbyte
* pc
)
1193 glStencilMask(*(GLuint
*) (pc
+ 0));
1197 __glXDisp_ColorMask(GLbyte
* pc
)
1199 glColorMask(*(GLboolean
*) (pc
+ 0),
1200 *(GLboolean
*) (pc
+ 1),
1201 *(GLboolean
*) (pc
+ 2), *(GLboolean
*) (pc
+ 3));
1205 __glXDisp_DepthMask(GLbyte
* pc
)
1207 glDepthMask(*(GLboolean
*) (pc
+ 0));
1211 __glXDisp_IndexMask(GLbyte
* pc
)
1213 glIndexMask(*(GLuint
*) (pc
+ 0));
1217 __glXDisp_Accum(GLbyte
* pc
)
1219 glAccum(*(GLenum
*) (pc
+ 0), *(GLfloat
*) (pc
+ 4));
1223 __glXDisp_Disable(GLbyte
* pc
)
1225 glDisable(*(GLenum
*) (pc
+ 0));
1229 __glXDisp_Enable(GLbyte
* pc
)
1231 glEnable(*(GLenum
*) (pc
+ 0));
1235 __glXDisp_PopAttrib(GLbyte
* pc
)
1241 __glXDisp_PushAttrib(GLbyte
* pc
)
1243 glPushAttrib(*(GLbitfield
*) (pc
+ 0));
1247 __glXDisp_MapGrid1d(GLbyte
* pc
)
1249 #ifdef __GLX_ALIGN64
1250 if ((unsigned long) (pc
) & 7) {
1251 (void) memmove(pc
- 4, pc
, 20);
1256 glMapGrid1d(*(GLint
*) (pc
+ 16),
1257 *(GLdouble
*) (pc
+ 0), *(GLdouble
*) (pc
+ 8));
1261 __glXDisp_MapGrid1f(GLbyte
* pc
)
1263 glMapGrid1f(*(GLint
*) (pc
+ 0),
1264 *(GLfloat
*) (pc
+ 4), *(GLfloat
*) (pc
+ 8));
1268 __glXDisp_MapGrid2d(GLbyte
* pc
)
1270 #ifdef __GLX_ALIGN64
1271 if ((unsigned long) (pc
) & 7) {
1272 (void) memmove(pc
- 4, pc
, 40);
1277 glMapGrid2d(*(GLint
*) (pc
+ 32),
1278 *(GLdouble
*) (pc
+ 0),
1279 *(GLdouble
*) (pc
+ 8),
1280 *(GLint
*) (pc
+ 36),
1281 *(GLdouble
*) (pc
+ 16), *(GLdouble
*) (pc
+ 24));
1285 __glXDisp_MapGrid2f(GLbyte
* pc
)
1287 glMapGrid2f(*(GLint
*) (pc
+ 0),
1288 *(GLfloat
*) (pc
+ 4),
1289 *(GLfloat
*) (pc
+ 8),
1290 *(GLint
*) (pc
+ 12),
1291 *(GLfloat
*) (pc
+ 16), *(GLfloat
*) (pc
+ 20));
1295 __glXDisp_EvalCoord1dv(GLbyte
* pc
)
1297 #ifdef __GLX_ALIGN64
1298 if ((unsigned long) (pc
) & 7) {
1299 (void) memmove(pc
- 4, pc
, 8);
1304 glEvalCoord1dv((const GLdouble
*) (pc
+ 0));
1308 __glXDisp_EvalCoord1fv(GLbyte
* pc
)
1310 glEvalCoord1fv((const GLfloat
*) (pc
+ 0));
1314 __glXDisp_EvalCoord2dv(GLbyte
* pc
)
1316 #ifdef __GLX_ALIGN64
1317 if ((unsigned long) (pc
) & 7) {
1318 (void) memmove(pc
- 4, pc
, 16);
1323 glEvalCoord2dv((const GLdouble
*) (pc
+ 0));
1327 __glXDisp_EvalCoord2fv(GLbyte
* pc
)
1329 glEvalCoord2fv((const GLfloat
*) (pc
+ 0));
1333 __glXDisp_EvalMesh1(GLbyte
* pc
)
1335 glEvalMesh1(*(GLenum
*) (pc
+ 0), *(GLint
*) (pc
+ 4), *(GLint
*) (pc
+ 8));
1339 __glXDisp_EvalPoint1(GLbyte
* pc
)
1341 glEvalPoint1(*(GLint
*) (pc
+ 0));
1345 __glXDisp_EvalMesh2(GLbyte
* pc
)
1347 glEvalMesh2(*(GLenum
*) (pc
+ 0),
1348 *(GLint
*) (pc
+ 4),
1349 *(GLint
*) (pc
+ 8),
1350 *(GLint
*) (pc
+ 12), *(GLint
*) (pc
+ 16));
1354 __glXDisp_EvalPoint2(GLbyte
* pc
)
1356 glEvalPoint2(*(GLint
*) (pc
+ 0), *(GLint
*) (pc
+ 4));
1360 __glXDisp_AlphaFunc(GLbyte
* pc
)
1362 glAlphaFunc(*(GLenum
*) (pc
+ 0), *(GLclampf
*) (pc
+ 4));
1366 __glXDisp_BlendFunc(GLbyte
* pc
)
1368 glBlendFunc(*(GLenum
*) (pc
+ 0), *(GLenum
*) (pc
+ 4));
1372 __glXDisp_LogicOp(GLbyte
* pc
)
1374 glLogicOp(*(GLenum
*) (pc
+ 0));
1378 __glXDisp_StencilFunc(GLbyte
* pc
)
1380 glStencilFunc(*(GLenum
*) (pc
+ 0),
1381 *(GLint
*) (pc
+ 4), *(GLuint
*) (pc
+ 8));
1385 __glXDisp_StencilOp(GLbyte
* pc
)
1387 glStencilOp(*(GLenum
*) (pc
+ 0),
1388 *(GLenum
*) (pc
+ 4), *(GLenum
*) (pc
+ 8));
1392 __glXDisp_DepthFunc(GLbyte
* pc
)
1394 glDepthFunc(*(GLenum
*) (pc
+ 0));
1398 __glXDisp_PixelZoom(GLbyte
* pc
)
1400 glPixelZoom(*(GLfloat
*) (pc
+ 0), *(GLfloat
*) (pc
+ 4));
1404 __glXDisp_PixelTransferf(GLbyte
* pc
)
1406 glPixelTransferf(*(GLenum
*) (pc
+ 0), *(GLfloat
*) (pc
+ 4));
1410 __glXDisp_PixelTransferi(GLbyte
* pc
)
1412 glPixelTransferi(*(GLenum
*) (pc
+ 0), *(GLint
*) (pc
+ 4));
1416 __glXDisp_PixelStoref(__GLXclientState
* cl
, GLbyte
* pc
)
1418 xGLXSingleReq
*const req
= (xGLXSingleReq
*) pc
;
1420 __GLXcontext
*const cx
= __glXForceCurrent(cl
, req
->contextTag
, &error
);
1422 pc
+= __GLX_SINGLE_HDR_SIZE
;
1424 glPixelStoref(*(GLenum
*) (pc
+ 0), *(GLfloat
*) (pc
+ 4));
1432 __glXDisp_PixelStorei(__GLXclientState
* cl
, GLbyte
* pc
)
1434 xGLXSingleReq
*const req
= (xGLXSingleReq
*) pc
;
1436 __GLXcontext
*const cx
= __glXForceCurrent(cl
, req
->contextTag
, &error
);
1438 pc
+= __GLX_SINGLE_HDR_SIZE
;
1440 glPixelStorei(*(GLenum
*) (pc
+ 0), *(GLint
*) (pc
+ 4));
1448 __glXDisp_PixelMapfv(GLbyte
* pc
)
1450 const GLsizei mapsize
= *(GLsizei
*) (pc
+ 4);
1452 glPixelMapfv(*(GLenum
*) (pc
+ 0), mapsize
, (const GLfloat
*) (pc
+ 8));
1456 __glXDisp_PixelMapuiv(GLbyte
* pc
)
1458 const GLsizei mapsize
= *(GLsizei
*) (pc
+ 4);
1460 glPixelMapuiv(*(GLenum
*) (pc
+ 0), mapsize
, (const GLuint
*) (pc
+ 8));
1464 __glXDisp_PixelMapusv(GLbyte
* pc
)
1466 const GLsizei mapsize
= *(GLsizei
*) (pc
+ 4);
1468 glPixelMapusv(*(GLenum
*) (pc
+ 0), mapsize
, (const GLushort
*) (pc
+ 8));
1472 __glXDisp_ReadBuffer(GLbyte
* pc
)
1474 glReadBuffer(*(GLenum
*) (pc
+ 0));
1478 __glXDisp_CopyPixels(GLbyte
* pc
)
1480 glCopyPixels(*(GLint
*) (pc
+ 0),
1481 *(GLint
*) (pc
+ 4),
1482 *(GLsizei
*) (pc
+ 8),
1483 *(GLsizei
*) (pc
+ 12), *(GLenum
*) (pc
+ 16));
1487 __glXDisp_DrawPixels(GLbyte
* pc
)
1489 const GLvoid
*const pixels
= (const GLvoid
*) ((pc
+ 36));
1490 __GLXpixelHeader
*const hdr
= (__GLXpixelHeader
*) (pc
);
1492 glPixelStorei(GL_UNPACK_SWAP_BYTES
, hdr
->swapBytes
);
1493 glPixelStorei(GL_UNPACK_LSB_FIRST
, hdr
->lsbFirst
);
1494 glPixelStorei(GL_UNPACK_ROW_LENGTH
, (GLint
) hdr
->rowLength
);
1495 glPixelStorei(GL_UNPACK_SKIP_ROWS
, (GLint
) hdr
->skipRows
);
1496 glPixelStorei(GL_UNPACK_SKIP_PIXELS
, (GLint
) hdr
->skipPixels
);
1497 glPixelStorei(GL_UNPACK_ALIGNMENT
, (GLint
) hdr
->alignment
);
1499 glDrawPixels(*(GLsizei
*) (pc
+ 20),
1500 *(GLsizei
*) (pc
+ 24),
1501 *(GLenum
*) (pc
+ 28), *(GLenum
*) (pc
+ 32), pixels
);
1505 __glXDisp_GetBooleanv(__GLXclientState
* cl
, GLbyte
* pc
)
1507 xGLXSingleReq
*const req
= (xGLXSingleReq
*) pc
;
1509 __GLXcontext
*const cx
= __glXForceCurrent(cl
, req
->contextTag
, &error
);
1511 pc
+= __GLX_SINGLE_HDR_SIZE
;
1513 const GLenum pname
= *(GLenum
*) (pc
+ 0);
1515 const GLuint compsize
= __glGetBooleanv_size(pname
);
1516 GLboolean answerBuffer
[200];
1518 __glXGetAnswerBuffer(cl
, compsize
, answerBuffer
,
1519 sizeof(answerBuffer
), 1);
1523 __glXClearErrorOccured();
1525 glGetBooleanv(pname
, params
);
1526 __glXSendReply(cl
->client
, params
, compsize
, 1, GL_FALSE
, 0);
1534 __glXDisp_GetClipPlane(__GLXclientState
* cl
, GLbyte
* pc
)
1536 xGLXSingleReq
*const req
= (xGLXSingleReq
*) pc
;
1538 __GLXcontext
*const cx
= __glXForceCurrent(cl
, req
->contextTag
, &error
);
1540 pc
+= __GLX_SINGLE_HDR_SIZE
;
1542 GLdouble equation
[4];
1544 glGetClipPlane(*(GLenum
*) (pc
+ 0), equation
);
1545 __glXSendReply(cl
->client
, equation
, 4, 8, GL_TRUE
, 0);
1553 __glXDisp_GetDoublev(__GLXclientState
* cl
, GLbyte
* pc
)
1555 xGLXSingleReq
*const req
= (xGLXSingleReq
*) pc
;
1557 __GLXcontext
*const cx
= __glXForceCurrent(cl
, req
->contextTag
, &error
);
1559 pc
+= __GLX_SINGLE_HDR_SIZE
;
1561 const GLenum pname
= *(GLenum
*) (pc
+ 0);
1563 const GLuint compsize
= __glGetDoublev_size(pname
);
1564 GLdouble answerBuffer
[200];
1566 __glXGetAnswerBuffer(cl
, compsize
* 8, answerBuffer
,
1567 sizeof(answerBuffer
), 8);
1571 __glXClearErrorOccured();
1573 glGetDoublev(pname
, params
);
1574 __glXSendReply(cl
->client
, params
, compsize
, 8, GL_FALSE
, 0);
1582 __glXDisp_GetError(__GLXclientState
* cl
, GLbyte
* pc
)
1584 xGLXSingleReq
*const req
= (xGLXSingleReq
*) pc
;
1586 __GLXcontext
*const cx
= __glXForceCurrent(cl
, req
->contextTag
, &error
);
1588 pc
+= __GLX_SINGLE_HDR_SIZE
;
1592 retval
= glGetError();
1593 __glXSendReply(cl
->client
, dummy_answer
, 0, 0, GL_FALSE
, retval
);
1601 __glXDisp_GetFloatv(__GLXclientState
* cl
, GLbyte
* pc
)
1603 xGLXSingleReq
*const req
= (xGLXSingleReq
*) pc
;
1605 __GLXcontext
*const cx
= __glXForceCurrent(cl
, req
->contextTag
, &error
);
1607 pc
+= __GLX_SINGLE_HDR_SIZE
;
1609 const GLenum pname
= *(GLenum
*) (pc
+ 0);
1611 const GLuint compsize
= __glGetFloatv_size(pname
);
1612 GLfloat answerBuffer
[200];
1614 __glXGetAnswerBuffer(cl
, compsize
* 4, answerBuffer
,
1615 sizeof(answerBuffer
), 4);
1619 __glXClearErrorOccured();
1621 glGetFloatv(pname
, params
);
1622 __glXSendReply(cl
->client
, params
, compsize
, 4, GL_FALSE
, 0);
1630 __glXDisp_GetIntegerv(__GLXclientState
* cl
, GLbyte
* pc
)
1632 xGLXSingleReq
*const req
= (xGLXSingleReq
*) pc
;
1634 __GLXcontext
*const cx
= __glXForceCurrent(cl
, req
->contextTag
, &error
);
1636 pc
+= __GLX_SINGLE_HDR_SIZE
;
1638 const GLenum pname
= *(GLenum
*) (pc
+ 0);
1640 const GLuint compsize
= __glGetIntegerv_size(pname
);
1641 GLint answerBuffer
[200];
1643 __glXGetAnswerBuffer(cl
, compsize
* 4, answerBuffer
,
1644 sizeof(answerBuffer
), 4);
1648 __glXClearErrorOccured();
1650 glGetIntegerv(pname
, params
);
1651 __glXSendReply(cl
->client
, params
, compsize
, 4, GL_FALSE
, 0);
1659 __glXDisp_GetLightfv(__GLXclientState
* cl
, GLbyte
* pc
)
1661 xGLXSingleReq
*const req
= (xGLXSingleReq
*) pc
;
1663 __GLXcontext
*const cx
= __glXForceCurrent(cl
, req
->contextTag
, &error
);
1665 pc
+= __GLX_SINGLE_HDR_SIZE
;
1667 const GLenum pname
= *(GLenum
*) (pc
+ 4);
1669 const GLuint compsize
= __glGetLightfv_size(pname
);
1670 GLfloat answerBuffer
[200];
1672 __glXGetAnswerBuffer(cl
, compsize
* 4, answerBuffer
,
1673 sizeof(answerBuffer
), 4);
1677 __glXClearErrorOccured();
1679 glGetLightfv(*(GLenum
*) (pc
+ 0), pname
, params
);
1680 __glXSendReply(cl
->client
, params
, compsize
, 4, GL_FALSE
, 0);
1688 __glXDisp_GetLightiv(__GLXclientState
* cl
, GLbyte
* pc
)
1690 xGLXSingleReq
*const req
= (xGLXSingleReq
*) pc
;
1692 __GLXcontext
*const cx
= __glXForceCurrent(cl
, req
->contextTag
, &error
);
1694 pc
+= __GLX_SINGLE_HDR_SIZE
;
1696 const GLenum pname
= *(GLenum
*) (pc
+ 4);
1698 const GLuint compsize
= __glGetLightiv_size(pname
);
1699 GLint answerBuffer
[200];
1701 __glXGetAnswerBuffer(cl
, compsize
* 4, answerBuffer
,
1702 sizeof(answerBuffer
), 4);
1706 __glXClearErrorOccured();
1708 glGetLightiv(*(GLenum
*) (pc
+ 0), pname
, params
);
1709 __glXSendReply(cl
->client
, params
, compsize
, 4, GL_FALSE
, 0);
1717 __glXDisp_GetMapdv(__GLXclientState
* cl
, GLbyte
* pc
)
1719 xGLXSingleReq
*const req
= (xGLXSingleReq
*) pc
;
1721 __GLXcontext
*const cx
= __glXForceCurrent(cl
, req
->contextTag
, &error
);
1723 pc
+= __GLX_SINGLE_HDR_SIZE
;
1725 const GLenum target
= *(GLenum
*) (pc
+ 0);
1726 const GLenum query
= *(GLenum
*) (pc
+ 4);
1728 const GLuint compsize
= __glGetMapdv_size(target
, query
);
1729 GLdouble answerBuffer
[200];
1731 __glXGetAnswerBuffer(cl
, compsize
* 8, answerBuffer
,
1732 sizeof(answerBuffer
), 8);
1736 __glXClearErrorOccured();
1738 glGetMapdv(target
, query
, v
);
1739 __glXSendReply(cl
->client
, v
, compsize
, 8, GL_FALSE
, 0);
1747 __glXDisp_GetMapfv(__GLXclientState
* cl
, GLbyte
* pc
)
1749 xGLXSingleReq
*const req
= (xGLXSingleReq
*) pc
;
1751 __GLXcontext
*const cx
= __glXForceCurrent(cl
, req
->contextTag
, &error
);
1753 pc
+= __GLX_SINGLE_HDR_SIZE
;
1755 const GLenum target
= *(GLenum
*) (pc
+ 0);
1756 const GLenum query
= *(GLenum
*) (pc
+ 4);
1758 const GLuint compsize
= __glGetMapfv_size(target
, query
);
1759 GLfloat answerBuffer
[200];
1761 __glXGetAnswerBuffer(cl
, compsize
* 4, answerBuffer
,
1762 sizeof(answerBuffer
), 4);
1766 __glXClearErrorOccured();
1768 glGetMapfv(target
, query
, v
);
1769 __glXSendReply(cl
->client
, v
, compsize
, 4, GL_FALSE
, 0);
1777 __glXDisp_GetMapiv(__GLXclientState
* cl
, GLbyte
* pc
)
1779 xGLXSingleReq
*const req
= (xGLXSingleReq
*) pc
;
1781 __GLXcontext
*const cx
= __glXForceCurrent(cl
, req
->contextTag
, &error
);
1783 pc
+= __GLX_SINGLE_HDR_SIZE
;
1785 const GLenum target
= *(GLenum
*) (pc
+ 0);
1786 const GLenum query
= *(GLenum
*) (pc
+ 4);
1788 const GLuint compsize
= __glGetMapiv_size(target
, query
);
1789 GLint answerBuffer
[200];
1791 __glXGetAnswerBuffer(cl
, compsize
* 4, answerBuffer
,
1792 sizeof(answerBuffer
), 4);
1796 __glXClearErrorOccured();
1798 glGetMapiv(target
, query
, v
);
1799 __glXSendReply(cl
->client
, v
, compsize
, 4, GL_FALSE
, 0);
1807 __glXDisp_GetMaterialfv(__GLXclientState
* cl
, GLbyte
* pc
)
1809 xGLXSingleReq
*const req
= (xGLXSingleReq
*) pc
;
1811 __GLXcontext
*const cx
= __glXForceCurrent(cl
, req
->contextTag
, &error
);
1813 pc
+= __GLX_SINGLE_HDR_SIZE
;
1815 const GLenum pname
= *(GLenum
*) (pc
+ 4);
1817 const GLuint compsize
= __glGetMaterialfv_size(pname
);
1818 GLfloat answerBuffer
[200];
1820 __glXGetAnswerBuffer(cl
, compsize
* 4, answerBuffer
,
1821 sizeof(answerBuffer
), 4);
1825 __glXClearErrorOccured();
1827 glGetMaterialfv(*(GLenum
*) (pc
+ 0), pname
, params
);
1828 __glXSendReply(cl
->client
, params
, compsize
, 4, GL_FALSE
, 0);
1836 __glXDisp_GetMaterialiv(__GLXclientState
* cl
, GLbyte
* pc
)
1838 xGLXSingleReq
*const req
= (xGLXSingleReq
*) pc
;
1840 __GLXcontext
*const cx
= __glXForceCurrent(cl
, req
->contextTag
, &error
);
1842 pc
+= __GLX_SINGLE_HDR_SIZE
;
1844 const GLenum pname
= *(GLenum
*) (pc
+ 4);
1846 const GLuint compsize
= __glGetMaterialiv_size(pname
);
1847 GLint answerBuffer
[200];
1849 __glXGetAnswerBuffer(cl
, compsize
* 4, answerBuffer
,
1850 sizeof(answerBuffer
), 4);
1854 __glXClearErrorOccured();
1856 glGetMaterialiv(*(GLenum
*) (pc
+ 0), pname
, params
);
1857 __glXSendReply(cl
->client
, params
, compsize
, 4, GL_FALSE
, 0);
1865 __glXDisp_GetPixelMapfv(__GLXclientState
* cl
, GLbyte
* pc
)
1867 xGLXSingleReq
*const req
= (xGLXSingleReq
*) pc
;
1869 __GLXcontext
*const cx
= __glXForceCurrent(cl
, req
->contextTag
, &error
);
1871 pc
+= __GLX_SINGLE_HDR_SIZE
;
1873 const GLenum map
= *(GLenum
*) (pc
+ 0);
1875 const GLuint compsize
= __glGetPixelMapfv_size(map
);
1876 GLfloat answerBuffer
[200];
1878 __glXGetAnswerBuffer(cl
, compsize
* 4, answerBuffer
,
1879 sizeof(answerBuffer
), 4);
1883 __glXClearErrorOccured();
1885 glGetPixelMapfv(map
, values
);
1886 __glXSendReply(cl
->client
, values
, compsize
, 4, GL_FALSE
, 0);
1894 __glXDisp_GetPixelMapuiv(__GLXclientState
* cl
, GLbyte
* pc
)
1896 xGLXSingleReq
*const req
= (xGLXSingleReq
*) pc
;
1898 __GLXcontext
*const cx
= __glXForceCurrent(cl
, req
->contextTag
, &error
);
1900 pc
+= __GLX_SINGLE_HDR_SIZE
;
1902 const GLenum map
= *(GLenum
*) (pc
+ 0);
1904 const GLuint compsize
= __glGetPixelMapuiv_size(map
);
1905 GLuint answerBuffer
[200];
1907 __glXGetAnswerBuffer(cl
, compsize
* 4, answerBuffer
,
1908 sizeof(answerBuffer
), 4);
1912 __glXClearErrorOccured();
1914 glGetPixelMapuiv(map
, values
);
1915 __glXSendReply(cl
->client
, values
, compsize
, 4, GL_FALSE
, 0);
1923 __glXDisp_GetPixelMapusv(__GLXclientState
* cl
, GLbyte
* pc
)
1925 xGLXSingleReq
*const req
= (xGLXSingleReq
*) pc
;
1927 __GLXcontext
*const cx
= __glXForceCurrent(cl
, req
->contextTag
, &error
);
1929 pc
+= __GLX_SINGLE_HDR_SIZE
;
1931 const GLenum map
= *(GLenum
*) (pc
+ 0);
1933 const GLuint compsize
= __glGetPixelMapusv_size(map
);
1934 GLushort answerBuffer
[200];
1936 __glXGetAnswerBuffer(cl
, compsize
* 2, answerBuffer
,
1937 sizeof(answerBuffer
), 2);
1941 __glXClearErrorOccured();
1943 glGetPixelMapusv(map
, values
);
1944 __glXSendReply(cl
->client
, values
, compsize
, 2, GL_FALSE
, 0);
1952 __glXDisp_GetTexEnvfv(__GLXclientState
* cl
, GLbyte
* pc
)
1954 xGLXSingleReq
*const req
= (xGLXSingleReq
*) pc
;
1956 __GLXcontext
*const cx
= __glXForceCurrent(cl
, req
->contextTag
, &error
);
1958 pc
+= __GLX_SINGLE_HDR_SIZE
;
1960 const GLenum pname
= *(GLenum
*) (pc
+ 4);
1962 const GLuint compsize
= __glGetTexEnvfv_size(pname
);
1963 GLfloat answerBuffer
[200];
1965 __glXGetAnswerBuffer(cl
, compsize
* 4, answerBuffer
,
1966 sizeof(answerBuffer
), 4);
1970 __glXClearErrorOccured();
1972 glGetTexEnvfv(*(GLenum
*) (pc
+ 0), pname
, params
);
1973 __glXSendReply(cl
->client
, params
, compsize
, 4, GL_FALSE
, 0);
1981 __glXDisp_GetTexEnviv(__GLXclientState
* cl
, GLbyte
* pc
)
1983 xGLXSingleReq
*const req
= (xGLXSingleReq
*) pc
;
1985 __GLXcontext
*const cx
= __glXForceCurrent(cl
, req
->contextTag
, &error
);
1987 pc
+= __GLX_SINGLE_HDR_SIZE
;
1989 const GLenum pname
= *(GLenum
*) (pc
+ 4);
1991 const GLuint compsize
= __glGetTexEnviv_size(pname
);
1992 GLint answerBuffer
[200];
1994 __glXGetAnswerBuffer(cl
, compsize
* 4, answerBuffer
,
1995 sizeof(answerBuffer
), 4);
1999 __glXClearErrorOccured();
2001 glGetTexEnviv(*(GLenum
*) (pc
+ 0), pname
, params
);
2002 __glXSendReply(cl
->client
, params
, compsize
, 4, GL_FALSE
, 0);
2010 __glXDisp_GetTexGendv(__GLXclientState
* cl
, GLbyte
* pc
)
2012 xGLXSingleReq
*const req
= (xGLXSingleReq
*) pc
;
2014 __GLXcontext
*const cx
= __glXForceCurrent(cl
, req
->contextTag
, &error
);
2016 pc
+= __GLX_SINGLE_HDR_SIZE
;
2018 const GLenum pname
= *(GLenum
*) (pc
+ 4);
2020 const GLuint compsize
= __glGetTexGendv_size(pname
);
2021 GLdouble answerBuffer
[200];
2023 __glXGetAnswerBuffer(cl
, compsize
* 8, answerBuffer
,
2024 sizeof(answerBuffer
), 8);
2028 __glXClearErrorOccured();
2030 glGetTexGendv(*(GLenum
*) (pc
+ 0), pname
, params
);
2031 __glXSendReply(cl
->client
, params
, compsize
, 8, GL_FALSE
, 0);
2039 __glXDisp_GetTexGenfv(__GLXclientState
* cl
, GLbyte
* pc
)
2041 xGLXSingleReq
*const req
= (xGLXSingleReq
*) pc
;
2043 __GLXcontext
*const cx
= __glXForceCurrent(cl
, req
->contextTag
, &error
);
2045 pc
+= __GLX_SINGLE_HDR_SIZE
;
2047 const GLenum pname
= *(GLenum
*) (pc
+ 4);
2049 const GLuint compsize
= __glGetTexGenfv_size(pname
);
2050 GLfloat answerBuffer
[200];
2052 __glXGetAnswerBuffer(cl
, compsize
* 4, answerBuffer
,
2053 sizeof(answerBuffer
), 4);
2057 __glXClearErrorOccured();
2059 glGetTexGenfv(*(GLenum
*) (pc
+ 0), pname
, params
);
2060 __glXSendReply(cl
->client
, params
, compsize
, 4, GL_FALSE
, 0);
2068 __glXDisp_GetTexGeniv(__GLXclientState
* cl
, GLbyte
* pc
)
2070 xGLXSingleReq
*const req
= (xGLXSingleReq
*) pc
;
2072 __GLXcontext
*const cx
= __glXForceCurrent(cl
, req
->contextTag
, &error
);
2074 pc
+= __GLX_SINGLE_HDR_SIZE
;
2076 const GLenum pname
= *(GLenum
*) (pc
+ 4);
2078 const GLuint compsize
= __glGetTexGeniv_size(pname
);
2079 GLint answerBuffer
[200];
2081 __glXGetAnswerBuffer(cl
, compsize
* 4, answerBuffer
,
2082 sizeof(answerBuffer
), 4);
2086 __glXClearErrorOccured();
2088 glGetTexGeniv(*(GLenum
*) (pc
+ 0), pname
, params
);
2089 __glXSendReply(cl
->client
, params
, compsize
, 4, GL_FALSE
, 0);
2097 __glXDisp_GetTexParameterfv(__GLXclientState
* cl
, GLbyte
* pc
)
2099 xGLXSingleReq
*const req
= (xGLXSingleReq
*) pc
;
2101 __GLXcontext
*const cx
= __glXForceCurrent(cl
, req
->contextTag
, &error
);
2103 pc
+= __GLX_SINGLE_HDR_SIZE
;
2105 const GLenum pname
= *(GLenum
*) (pc
+ 4);
2107 const GLuint compsize
= __glGetTexParameterfv_size(pname
);
2108 GLfloat answerBuffer
[200];
2110 __glXGetAnswerBuffer(cl
, compsize
* 4, answerBuffer
,
2111 sizeof(answerBuffer
), 4);
2115 __glXClearErrorOccured();
2117 glGetTexParameterfv(*(GLenum
*) (pc
+ 0), pname
, params
);
2118 __glXSendReply(cl
->client
, params
, compsize
, 4, GL_FALSE
, 0);
2126 __glXDisp_GetTexParameteriv(__GLXclientState
* cl
, GLbyte
* pc
)
2128 xGLXSingleReq
*const req
= (xGLXSingleReq
*) pc
;
2130 __GLXcontext
*const cx
= __glXForceCurrent(cl
, req
->contextTag
, &error
);
2132 pc
+= __GLX_SINGLE_HDR_SIZE
;
2134 const GLenum pname
= *(GLenum
*) (pc
+ 4);
2136 const GLuint compsize
= __glGetTexParameteriv_size(pname
);
2137 GLint answerBuffer
[200];
2139 __glXGetAnswerBuffer(cl
, compsize
* 4, answerBuffer
,
2140 sizeof(answerBuffer
), 4);
2144 __glXClearErrorOccured();
2146 glGetTexParameteriv(*(GLenum
*) (pc
+ 0), pname
, params
);
2147 __glXSendReply(cl
->client
, params
, compsize
, 4, GL_FALSE
, 0);
2155 __glXDisp_GetTexLevelParameterfv(__GLXclientState
* cl
, GLbyte
* pc
)
2157 xGLXSingleReq
*const req
= (xGLXSingleReq
*) pc
;
2159 __GLXcontext
*const cx
= __glXForceCurrent(cl
, req
->contextTag
, &error
);
2161 pc
+= __GLX_SINGLE_HDR_SIZE
;
2163 const GLenum pname
= *(GLenum
*) (pc
+ 8);
2165 const GLuint compsize
= __glGetTexLevelParameterfv_size(pname
);
2166 GLfloat answerBuffer
[200];
2168 __glXGetAnswerBuffer(cl
, compsize
* 4, answerBuffer
,
2169 sizeof(answerBuffer
), 4);
2173 __glXClearErrorOccured();
2175 glGetTexLevelParameterfv(*(GLenum
*) (pc
+ 0),
2176 *(GLint
*) (pc
+ 4), pname
, params
);
2177 __glXSendReply(cl
->client
, params
, compsize
, 4, GL_FALSE
, 0);
2185 __glXDisp_GetTexLevelParameteriv(__GLXclientState
* cl
, GLbyte
* pc
)
2187 xGLXSingleReq
*const req
= (xGLXSingleReq
*) pc
;
2189 __GLXcontext
*const cx
= __glXForceCurrent(cl
, req
->contextTag
, &error
);
2191 pc
+= __GLX_SINGLE_HDR_SIZE
;
2193 const GLenum pname
= *(GLenum
*) (pc
+ 8);
2195 const GLuint compsize
= __glGetTexLevelParameteriv_size(pname
);
2196 GLint answerBuffer
[200];
2198 __glXGetAnswerBuffer(cl
, compsize
* 4, answerBuffer
,
2199 sizeof(answerBuffer
), 4);
2203 __glXClearErrorOccured();
2205 glGetTexLevelParameteriv(*(GLenum
*) (pc
+ 0),
2206 *(GLint
*) (pc
+ 4), pname
, params
);
2207 __glXSendReply(cl
->client
, params
, compsize
, 4, GL_FALSE
, 0);
2215 __glXDisp_IsEnabled(__GLXclientState
* cl
, GLbyte
* pc
)
2217 xGLXSingleReq
*const req
= (xGLXSingleReq
*) pc
;
2219 __GLXcontext
*const cx
= __glXForceCurrent(cl
, req
->contextTag
, &error
);
2221 pc
+= __GLX_SINGLE_HDR_SIZE
;
2225 retval
= glIsEnabled(*(GLenum
*) (pc
+ 0));
2226 __glXSendReply(cl
->client
, dummy_answer
, 0, 0, GL_FALSE
, retval
);
2234 __glXDisp_IsList(__GLXclientState
* cl
, GLbyte
* pc
)
2236 xGLXSingleReq
*const req
= (xGLXSingleReq
*) pc
;
2238 __GLXcontext
*const cx
= __glXForceCurrent(cl
, req
->contextTag
, &error
);
2240 pc
+= __GLX_SINGLE_HDR_SIZE
;
2244 retval
= glIsList(*(GLuint
*) (pc
+ 0));
2245 __glXSendReply(cl
->client
, dummy_answer
, 0, 0, GL_FALSE
, retval
);
2253 __glXDisp_DepthRange(GLbyte
* pc
)
2255 #ifdef __GLX_ALIGN64
2256 if ((unsigned long) (pc
) & 7) {
2257 (void) memmove(pc
- 4, pc
, 16);
2262 glDepthRange(*(GLclampd
*) (pc
+ 0), *(GLclampd
*) (pc
+ 8));
2266 __glXDisp_Frustum(GLbyte
* pc
)
2268 #ifdef __GLX_ALIGN64
2269 if ((unsigned long) (pc
) & 7) {
2270 (void) memmove(pc
- 4, pc
, 48);
2275 glFrustum(*(GLdouble
*) (pc
+ 0),
2276 *(GLdouble
*) (pc
+ 8),
2277 *(GLdouble
*) (pc
+ 16),
2278 *(GLdouble
*) (pc
+ 24),
2279 *(GLdouble
*) (pc
+ 32), *(GLdouble
*) (pc
+ 40));
2283 __glXDisp_LoadIdentity(GLbyte
* pc
)
2289 __glXDisp_LoadMatrixf(GLbyte
* pc
)
2291 glLoadMatrixf((const GLfloat
*) (pc
+ 0));
2295 __glXDisp_LoadMatrixd(GLbyte
* pc
)
2297 #ifdef __GLX_ALIGN64
2298 if ((unsigned long) (pc
) & 7) {
2299 (void) memmove(pc
- 4, pc
, 128);
2304 glLoadMatrixd((const GLdouble
*) (pc
+ 0));
2308 __glXDisp_MatrixMode(GLbyte
* pc
)
2310 glMatrixMode(*(GLenum
*) (pc
+ 0));
2314 __glXDisp_MultMatrixf(GLbyte
* pc
)
2316 glMultMatrixf((const GLfloat
*) (pc
+ 0));
2320 __glXDisp_MultMatrixd(GLbyte
* pc
)
2322 #ifdef __GLX_ALIGN64
2323 if ((unsigned long) (pc
) & 7) {
2324 (void) memmove(pc
- 4, pc
, 128);
2329 glMultMatrixd((const GLdouble
*) (pc
+ 0));
2333 __glXDisp_Ortho(GLbyte
* pc
)
2335 #ifdef __GLX_ALIGN64
2336 if ((unsigned long) (pc
) & 7) {
2337 (void) memmove(pc
- 4, pc
, 48);
2342 glOrtho(*(GLdouble
*) (pc
+ 0),
2343 *(GLdouble
*) (pc
+ 8),
2344 *(GLdouble
*) (pc
+ 16),
2345 *(GLdouble
*) (pc
+ 24),
2346 *(GLdouble
*) (pc
+ 32), *(GLdouble
*) (pc
+ 40));
2350 __glXDisp_PopMatrix(GLbyte
* pc
)
2356 __glXDisp_PushMatrix(GLbyte
* pc
)
2362 __glXDisp_Rotated(GLbyte
* pc
)
2364 #ifdef __GLX_ALIGN64
2365 if ((unsigned long) (pc
) & 7) {
2366 (void) memmove(pc
- 4, pc
, 32);
2371 glRotated(*(GLdouble
*) (pc
+ 0),
2372 *(GLdouble
*) (pc
+ 8),
2373 *(GLdouble
*) (pc
+ 16), *(GLdouble
*) (pc
+ 24));
2377 __glXDisp_Rotatef(GLbyte
* pc
)
2379 glRotatef(*(GLfloat
*) (pc
+ 0),
2380 *(GLfloat
*) (pc
+ 4),
2381 *(GLfloat
*) (pc
+ 8), *(GLfloat
*) (pc
+ 12));
2385 __glXDisp_Scaled(GLbyte
* pc
)
2387 #ifdef __GLX_ALIGN64
2388 if ((unsigned long) (pc
) & 7) {
2389 (void) memmove(pc
- 4, pc
, 24);
2394 glScaled(*(GLdouble
*) (pc
+ 0),
2395 *(GLdouble
*) (pc
+ 8), *(GLdouble
*) (pc
+ 16));
2399 __glXDisp_Scalef(GLbyte
* pc
)
2401 glScalef(*(GLfloat
*) (pc
+ 0),
2402 *(GLfloat
*) (pc
+ 4), *(GLfloat
*) (pc
+ 8));
2406 __glXDisp_Translated(GLbyte
* pc
)
2408 #ifdef __GLX_ALIGN64
2409 if ((unsigned long) (pc
) & 7) {
2410 (void) memmove(pc
- 4, pc
, 24);
2415 glTranslated(*(GLdouble
*) (pc
+ 0),
2416 *(GLdouble
*) (pc
+ 8), *(GLdouble
*) (pc
+ 16));
2420 __glXDisp_Translatef(GLbyte
* pc
)
2422 glTranslatef(*(GLfloat
*) (pc
+ 0),
2423 *(GLfloat
*) (pc
+ 4), *(GLfloat
*) (pc
+ 8));
2427 __glXDisp_Viewport(GLbyte
* pc
)
2429 glViewport(*(GLint
*) (pc
+ 0),
2430 *(GLint
*) (pc
+ 4),
2431 *(GLsizei
*) (pc
+ 8), *(GLsizei
*) (pc
+ 12));
2435 __glXDisp_BindTexture(GLbyte
* pc
)
2437 glBindTexture(*(GLenum
*) (pc
+ 0), *(GLuint
*) (pc
+ 4));
2441 __glXDisp_Indexubv(GLbyte
* pc
)
2443 glIndexubv((const GLubyte
*) (pc
+ 0));
2447 __glXDisp_PolygonOffset(GLbyte
* pc
)
2449 glPolygonOffset(*(GLfloat
*) (pc
+ 0), *(GLfloat
*) (pc
+ 4));
2453 __glXDisp_AreTexturesResident(__GLXclientState
* cl
, GLbyte
* pc
)
2455 xGLXSingleReq
*const req
= (xGLXSingleReq
*) pc
;
2457 __GLXcontext
*const cx
= __glXForceCurrent(cl
, req
->contextTag
, &error
);
2459 pc
+= __GLX_SINGLE_HDR_SIZE
;
2461 const GLsizei n
= *(GLsizei
*) (pc
+ 0);
2464 GLboolean answerBuffer
[200];
2465 GLboolean
*residences
=
2466 __glXGetAnswerBuffer(cl
, n
, answerBuffer
, sizeof(answerBuffer
), 1);
2468 glAreTexturesResident(n
, (const GLuint
*) (pc
+ 4), residences
);
2469 __glXSendReply(cl
->client
, residences
, n
, 1, GL_TRUE
, retval
);
2477 __glXDisp_AreTexturesResidentEXT(__GLXclientState
* cl
, GLbyte
* pc
)
2479 xGLXVendorPrivateReq
*const req
= (xGLXVendorPrivateReq
*) pc
;
2481 __GLXcontext
*const cx
= __glXForceCurrent(cl
, req
->contextTag
, &error
);
2483 pc
+= __GLX_VENDPRIV_HDR_SIZE
;
2485 const GLsizei n
= *(GLsizei
*) (pc
+ 0);
2488 GLboolean answerBuffer
[200];
2489 GLboolean
*residences
=
2490 __glXGetAnswerBuffer(cl
, n
, answerBuffer
, sizeof(answerBuffer
), 1);
2492 glAreTexturesResident(n
, (const GLuint
*) (pc
+ 4), residences
);
2493 __glXSendReply(cl
->client
, residences
, n
, 1, GL_TRUE
, retval
);
2501 __glXDisp_CopyTexImage1D(GLbyte
* pc
)
2503 glCopyTexImage1D(*(GLenum
*) (pc
+ 0),
2504 *(GLint
*) (pc
+ 4),
2505 *(GLenum
*) (pc
+ 8),
2506 *(GLint
*) (pc
+ 12),
2507 *(GLint
*) (pc
+ 16),
2508 *(GLsizei
*) (pc
+ 20), *(GLint
*) (pc
+ 24));
2512 __glXDisp_CopyTexImage2D(GLbyte
* pc
)
2514 glCopyTexImage2D(*(GLenum
*) (pc
+ 0),
2515 *(GLint
*) (pc
+ 4),
2516 *(GLenum
*) (pc
+ 8),
2517 *(GLint
*) (pc
+ 12),
2518 *(GLint
*) (pc
+ 16),
2519 *(GLsizei
*) (pc
+ 20),
2520 *(GLsizei
*) (pc
+ 24), *(GLint
*) (pc
+ 28));
2524 __glXDisp_CopyTexSubImage1D(GLbyte
* pc
)
2526 glCopyTexSubImage1D(*(GLenum
*) (pc
+ 0),
2527 *(GLint
*) (pc
+ 4),
2528 *(GLint
*) (pc
+ 8),
2529 *(GLint
*) (pc
+ 12),
2530 *(GLint
*) (pc
+ 16), *(GLsizei
*) (pc
+ 20));
2534 __glXDisp_CopyTexSubImage2D(GLbyte
* pc
)
2536 glCopyTexSubImage2D(*(GLenum
*) (pc
+ 0),
2537 *(GLint
*) (pc
+ 4),
2538 *(GLint
*) (pc
+ 8),
2539 *(GLint
*) (pc
+ 12),
2540 *(GLint
*) (pc
+ 16),
2541 *(GLint
*) (pc
+ 20),
2542 *(GLsizei
*) (pc
+ 24), *(GLsizei
*) (pc
+ 28));
2546 __glXDisp_DeleteTextures(__GLXclientState
* cl
, GLbyte
* pc
)
2548 xGLXSingleReq
*const req
= (xGLXSingleReq
*) pc
;
2550 __GLXcontext
*const cx
= __glXForceCurrent(cl
, req
->contextTag
, &error
);
2552 pc
+= __GLX_SINGLE_HDR_SIZE
;
2554 const GLsizei n
= *(GLsizei
*) (pc
+ 0);
2556 glDeleteTextures(n
, (const GLuint
*) (pc
+ 4));
2564 __glXDisp_DeleteTexturesEXT(__GLXclientState
* cl
, GLbyte
* pc
)
2566 xGLXVendorPrivateReq
*const req
= (xGLXVendorPrivateReq
*) pc
;
2568 __GLXcontext
*const cx
= __glXForceCurrent(cl
, req
->contextTag
, &error
);
2570 pc
+= __GLX_VENDPRIV_HDR_SIZE
;
2572 const GLsizei n
= *(GLsizei
*) (pc
+ 0);
2574 glDeleteTextures(n
, (const GLuint
*) (pc
+ 4));
2582 __glXDisp_GenTextures(__GLXclientState
* cl
, GLbyte
* pc
)
2584 xGLXSingleReq
*const req
= (xGLXSingleReq
*) pc
;
2586 __GLXcontext
*const cx
= __glXForceCurrent(cl
, req
->contextTag
, &error
);
2588 pc
+= __GLX_SINGLE_HDR_SIZE
;
2590 const GLsizei n
= *(GLsizei
*) (pc
+ 0);
2592 GLuint answerBuffer
[200];
2594 __glXGetAnswerBuffer(cl
, n
* 4, answerBuffer
, sizeof(answerBuffer
),
2596 glGenTextures(n
, textures
);
2597 __glXSendReply(cl
->client
, textures
, n
, 4, GL_TRUE
, 0);
2605 __glXDisp_GenTexturesEXT(__GLXclientState
* cl
, GLbyte
* pc
)
2607 xGLXVendorPrivateReq
*const req
= (xGLXVendorPrivateReq
*) pc
;
2609 __GLXcontext
*const cx
= __glXForceCurrent(cl
, req
->contextTag
, &error
);
2611 pc
+= __GLX_VENDPRIV_HDR_SIZE
;
2613 const GLsizei n
= *(GLsizei
*) (pc
+ 0);
2615 GLuint answerBuffer
[200];
2617 __glXGetAnswerBuffer(cl
, n
* 4, answerBuffer
, sizeof(answerBuffer
),
2619 glGenTextures(n
, textures
);
2620 __glXSendReply(cl
->client
, textures
, n
, 4, GL_TRUE
, 0);
2628 __glXDisp_IsTexture(__GLXclientState
* cl
, GLbyte
* pc
)
2630 xGLXSingleReq
*const req
= (xGLXSingleReq
*) pc
;
2632 __GLXcontext
*const cx
= __glXForceCurrent(cl
, req
->contextTag
, &error
);
2634 pc
+= __GLX_SINGLE_HDR_SIZE
;
2638 retval
= glIsTexture(*(GLuint
*) (pc
+ 0));
2639 __glXSendReply(cl
->client
, dummy_answer
, 0, 0, GL_FALSE
, retval
);
2647 __glXDisp_IsTextureEXT(__GLXclientState
* cl
, GLbyte
* pc
)
2649 xGLXVendorPrivateReq
*const req
= (xGLXVendorPrivateReq
*) pc
;
2651 __GLXcontext
*const cx
= __glXForceCurrent(cl
, req
->contextTag
, &error
);
2653 pc
+= __GLX_VENDPRIV_HDR_SIZE
;
2657 retval
= glIsTexture(*(GLuint
*) (pc
+ 0));
2658 __glXSendReply(cl
->client
, dummy_answer
, 0, 0, GL_FALSE
, retval
);
2666 __glXDisp_PrioritizeTextures(GLbyte
* pc
)
2668 const GLsizei n
= *(GLsizei
*) (pc
+ 0);
2670 glPrioritizeTextures(n
,
2671 (const GLuint
*) (pc
+ 4),
2672 (const GLclampf
*) (pc
+ 4));
2676 __glXDisp_TexSubImage1D(GLbyte
* pc
)
2678 const GLvoid
*const pixels
= (const GLvoid
*) ((pc
+ 56));
2679 __GLXpixelHeader
*const hdr
= (__GLXpixelHeader
*) (pc
);
2681 glPixelStorei(GL_UNPACK_SWAP_BYTES
, hdr
->swapBytes
);
2682 glPixelStorei(GL_UNPACK_LSB_FIRST
, hdr
->lsbFirst
);
2683 glPixelStorei(GL_UNPACK_ROW_LENGTH
, (GLint
) hdr
->rowLength
);
2684 glPixelStorei(GL_UNPACK_SKIP_ROWS
, (GLint
) hdr
->skipRows
);
2685 glPixelStorei(GL_UNPACK_SKIP_PIXELS
, (GLint
) hdr
->skipPixels
);
2686 glPixelStorei(GL_UNPACK_ALIGNMENT
, (GLint
) hdr
->alignment
);
2688 glTexSubImage1D(*(GLenum
*) (pc
+ 20),
2689 *(GLint
*) (pc
+ 24),
2690 *(GLint
*) (pc
+ 28),
2691 *(GLsizei
*) (pc
+ 36),
2692 *(GLenum
*) (pc
+ 44), *(GLenum
*) (pc
+ 48), pixels
);
2696 __glXDisp_TexSubImage2D(GLbyte
* pc
)
2698 const GLvoid
*const pixels
= (const GLvoid
*) ((pc
+ 56));
2699 __GLXpixelHeader
*const hdr
= (__GLXpixelHeader
*) (pc
);
2701 glPixelStorei(GL_UNPACK_SWAP_BYTES
, hdr
->swapBytes
);
2702 glPixelStorei(GL_UNPACK_LSB_FIRST
, hdr
->lsbFirst
);
2703 glPixelStorei(GL_UNPACK_ROW_LENGTH
, (GLint
) hdr
->rowLength
);
2704 glPixelStorei(GL_UNPACK_SKIP_ROWS
, (GLint
) hdr
->skipRows
);
2705 glPixelStorei(GL_UNPACK_SKIP_PIXELS
, (GLint
) hdr
->skipPixels
);
2706 glPixelStorei(GL_UNPACK_ALIGNMENT
, (GLint
) hdr
->alignment
);
2708 glTexSubImage2D(*(GLenum
*) (pc
+ 20),
2709 *(GLint
*) (pc
+ 24),
2710 *(GLint
*) (pc
+ 28),
2711 *(GLint
*) (pc
+ 32),
2712 *(GLsizei
*) (pc
+ 36),
2713 *(GLsizei
*) (pc
+ 40),
2714 *(GLenum
*) (pc
+ 44), *(GLenum
*) (pc
+ 48), pixels
);
2718 __glXDisp_BlendColor(GLbyte
* pc
)
2720 glBlendColor(*(GLclampf
*) (pc
+ 0),
2721 *(GLclampf
*) (pc
+ 4),
2722 *(GLclampf
*) (pc
+ 8), *(GLclampf
*) (pc
+ 12));
2726 __glXDisp_BlendEquation(GLbyte
* pc
)
2728 glBlendEquation(*(GLenum
*) (pc
+ 0));
2732 __glXDisp_ColorTable(GLbyte
* pc
)
2734 const GLvoid
*const table
= (const GLvoid
*) ((pc
+ 40));
2735 __GLXpixelHeader
*const hdr
= (__GLXpixelHeader
*) (pc
);
2737 glPixelStorei(GL_UNPACK_SWAP_BYTES
, hdr
->swapBytes
);
2738 glPixelStorei(GL_UNPACK_LSB_FIRST
, hdr
->lsbFirst
);
2739 glPixelStorei(GL_UNPACK_ROW_LENGTH
, (GLint
) hdr
->rowLength
);
2740 glPixelStorei(GL_UNPACK_SKIP_ROWS
, (GLint
) hdr
->skipRows
);
2741 glPixelStorei(GL_UNPACK_SKIP_PIXELS
, (GLint
) hdr
->skipPixels
);
2742 glPixelStorei(GL_UNPACK_ALIGNMENT
, (GLint
) hdr
->alignment
);
2744 glColorTable(*(GLenum
*) (pc
+ 20),
2745 *(GLenum
*) (pc
+ 24),
2746 *(GLsizei
*) (pc
+ 28),
2747 *(GLenum
*) (pc
+ 32), *(GLenum
*) (pc
+ 36), table
);
2751 __glXDisp_ColorTableParameterfv(GLbyte
* pc
)
2753 const GLenum pname
= *(GLenum
*) (pc
+ 4);
2754 const GLfloat
*params
;
2756 params
= (const GLfloat
*) (pc
+ 8);
2758 glColorTableParameterfv(*(GLenum
*) (pc
+ 0), pname
, params
);
2762 __glXDisp_ColorTableParameteriv(GLbyte
* pc
)
2764 const GLenum pname
= *(GLenum
*) (pc
+ 4);
2765 const GLint
*params
;
2767 params
= (const GLint
*) (pc
+ 8);
2769 glColorTableParameteriv(*(GLenum
*) (pc
+ 0), pname
, params
);
2773 __glXDisp_CopyColorTable(GLbyte
* pc
)
2775 glCopyColorTable(*(GLenum
*) (pc
+ 0),
2776 *(GLenum
*) (pc
+ 4),
2777 *(GLint
*) (pc
+ 8),
2778 *(GLint
*) (pc
+ 12), *(GLsizei
*) (pc
+ 16));
2782 __glXDisp_GetColorTableParameterfv(__GLXclientState
* cl
, GLbyte
* pc
)
2784 xGLXSingleReq
*const req
= (xGLXSingleReq
*) pc
;
2786 __GLXcontext
*const cx
= __glXForceCurrent(cl
, req
->contextTag
, &error
);
2788 pc
+= __GLX_SINGLE_HDR_SIZE
;
2790 const GLenum pname
= *(GLenum
*) (pc
+ 4);
2792 const GLuint compsize
= __glGetColorTableParameterfv_size(pname
);
2793 GLfloat answerBuffer
[200];
2795 __glXGetAnswerBuffer(cl
, compsize
* 4, answerBuffer
,
2796 sizeof(answerBuffer
), 4);
2800 __glXClearErrorOccured();
2802 glGetColorTableParameterfv(*(GLenum
*) (pc
+ 0), pname
, params
);
2803 __glXSendReply(cl
->client
, params
, compsize
, 4, GL_FALSE
, 0);
2811 __glXDisp_GetColorTableParameterfvSGI(__GLXclientState
* cl
, GLbyte
* pc
)
2813 xGLXVendorPrivateReq
*const req
= (xGLXVendorPrivateReq
*) pc
;
2815 __GLXcontext
*const cx
= __glXForceCurrent(cl
, req
->contextTag
, &error
);
2817 pc
+= __GLX_VENDPRIV_HDR_SIZE
;
2819 const GLenum pname
= *(GLenum
*) (pc
+ 4);
2821 const GLuint compsize
= __glGetColorTableParameterfv_size(pname
);
2822 GLfloat answerBuffer
[200];
2824 __glXGetAnswerBuffer(cl
, compsize
* 4, answerBuffer
,
2825 sizeof(answerBuffer
), 4);
2829 __glXClearErrorOccured();
2831 glGetColorTableParameterfv(*(GLenum
*) (pc
+ 0), pname
, params
);
2832 __glXSendReply(cl
->client
, params
, compsize
, 4, GL_FALSE
, 0);
2840 __glXDisp_GetColorTableParameteriv(__GLXclientState
* cl
, GLbyte
* pc
)
2842 xGLXSingleReq
*const req
= (xGLXSingleReq
*) pc
;
2844 __GLXcontext
*const cx
= __glXForceCurrent(cl
, req
->contextTag
, &error
);
2846 pc
+= __GLX_SINGLE_HDR_SIZE
;
2848 const GLenum pname
= *(GLenum
*) (pc
+ 4);
2850 const GLuint compsize
= __glGetColorTableParameteriv_size(pname
);
2851 GLint answerBuffer
[200];
2853 __glXGetAnswerBuffer(cl
, compsize
* 4, answerBuffer
,
2854 sizeof(answerBuffer
), 4);
2858 __glXClearErrorOccured();
2860 glGetColorTableParameteriv(*(GLenum
*) (pc
+ 0), pname
, params
);
2861 __glXSendReply(cl
->client
, params
, compsize
, 4, GL_FALSE
, 0);
2869 __glXDisp_GetColorTableParameterivSGI(__GLXclientState
* cl
, GLbyte
* pc
)
2871 xGLXVendorPrivateReq
*const req
= (xGLXVendorPrivateReq
*) pc
;
2873 __GLXcontext
*const cx
= __glXForceCurrent(cl
, req
->contextTag
, &error
);
2875 pc
+= __GLX_VENDPRIV_HDR_SIZE
;
2877 const GLenum pname
= *(GLenum
*) (pc
+ 4);
2879 const GLuint compsize
= __glGetColorTableParameteriv_size(pname
);
2880 GLint answerBuffer
[200];
2882 __glXGetAnswerBuffer(cl
, compsize
* 4, answerBuffer
,
2883 sizeof(answerBuffer
), 4);
2887 __glXClearErrorOccured();
2889 glGetColorTableParameteriv(*(GLenum
*) (pc
+ 0), pname
, params
);
2890 __glXSendReply(cl
->client
, params
, compsize
, 4, GL_FALSE
, 0);
2898 __glXDisp_ColorSubTable(GLbyte
* pc
)
2900 const GLvoid
*const data
= (const GLvoid
*) ((pc
+ 40));
2901 __GLXpixelHeader
*const hdr
= (__GLXpixelHeader
*) (pc
);
2903 glPixelStorei(GL_UNPACK_SWAP_BYTES
, hdr
->swapBytes
);
2904 glPixelStorei(GL_UNPACK_LSB_FIRST
, hdr
->lsbFirst
);
2905 glPixelStorei(GL_UNPACK_ROW_LENGTH
, (GLint
) hdr
->rowLength
);
2906 glPixelStorei(GL_UNPACK_SKIP_ROWS
, (GLint
) hdr
->skipRows
);
2907 glPixelStorei(GL_UNPACK_SKIP_PIXELS
, (GLint
) hdr
->skipPixels
);
2908 glPixelStorei(GL_UNPACK_ALIGNMENT
, (GLint
) hdr
->alignment
);
2910 glColorSubTable(*(GLenum
*) (pc
+ 20),
2911 *(GLsizei
*) (pc
+ 24),
2912 *(GLsizei
*) (pc
+ 28),
2913 *(GLenum
*) (pc
+ 32), *(GLenum
*) (pc
+ 36), data
);
2917 __glXDisp_CopyColorSubTable(GLbyte
* pc
)
2919 glCopyColorSubTable(*(GLenum
*) (pc
+ 0),
2920 *(GLsizei
*) (pc
+ 4),
2921 *(GLint
*) (pc
+ 8),
2922 *(GLint
*) (pc
+ 12), *(GLsizei
*) (pc
+ 16));
2926 __glXDisp_ConvolutionFilter1D(GLbyte
* pc
)
2928 const GLvoid
*const image
= (const GLvoid
*) ((pc
+ 44));
2929 __GLXpixelHeader
*const hdr
= (__GLXpixelHeader
*) (pc
);
2931 glPixelStorei(GL_UNPACK_SWAP_BYTES
, hdr
->swapBytes
);
2932 glPixelStorei(GL_UNPACK_LSB_FIRST
, hdr
->lsbFirst
);
2933 glPixelStorei(GL_UNPACK_ROW_LENGTH
, (GLint
) hdr
->rowLength
);
2934 glPixelStorei(GL_UNPACK_SKIP_ROWS
, (GLint
) hdr
->skipRows
);
2935 glPixelStorei(GL_UNPACK_SKIP_PIXELS
, (GLint
) hdr
->skipPixels
);
2936 glPixelStorei(GL_UNPACK_ALIGNMENT
, (GLint
) hdr
->alignment
);
2938 glConvolutionFilter1D(*(GLenum
*) (pc
+ 20),
2939 *(GLenum
*) (pc
+ 24),
2940 *(GLsizei
*) (pc
+ 28),
2941 *(GLenum
*) (pc
+ 36), *(GLenum
*) (pc
+ 40), image
);
2945 __glXDisp_ConvolutionFilter2D(GLbyte
* pc
)
2947 const GLvoid
*const image
= (const GLvoid
*) ((pc
+ 44));
2948 __GLXpixelHeader
*const hdr
= (__GLXpixelHeader
*) (pc
);
2950 glPixelStorei(GL_UNPACK_SWAP_BYTES
, hdr
->swapBytes
);
2951 glPixelStorei(GL_UNPACK_LSB_FIRST
, hdr
->lsbFirst
);
2952 glPixelStorei(GL_UNPACK_ROW_LENGTH
, (GLint
) hdr
->rowLength
);
2953 glPixelStorei(GL_UNPACK_SKIP_ROWS
, (GLint
) hdr
->skipRows
);
2954 glPixelStorei(GL_UNPACK_SKIP_PIXELS
, (GLint
) hdr
->skipPixels
);
2955 glPixelStorei(GL_UNPACK_ALIGNMENT
, (GLint
) hdr
->alignment
);
2957 glConvolutionFilter2D(*(GLenum
*) (pc
+ 20),
2958 *(GLenum
*) (pc
+ 24),
2959 *(GLsizei
*) (pc
+ 28),
2960 *(GLsizei
*) (pc
+ 32),
2961 *(GLenum
*) (pc
+ 36), *(GLenum
*) (pc
+ 40), image
);
2965 __glXDisp_ConvolutionParameterf(GLbyte
* pc
)
2967 glConvolutionParameterf(*(GLenum
*) (pc
+ 0),
2968 *(GLenum
*) (pc
+ 4), *(GLfloat
*) (pc
+ 8));
2972 __glXDisp_ConvolutionParameterfv(GLbyte
* pc
)
2974 const GLenum pname
= *(GLenum
*) (pc
+ 4);
2975 const GLfloat
*params
;
2977 params
= (const GLfloat
*) (pc
+ 8);
2979 glConvolutionParameterfv(*(GLenum
*) (pc
+ 0), pname
, params
);
2983 __glXDisp_ConvolutionParameteri(GLbyte
* pc
)
2985 glConvolutionParameteri(*(GLenum
*) (pc
+ 0),
2986 *(GLenum
*) (pc
+ 4), *(GLint
*) (pc
+ 8));
2990 __glXDisp_ConvolutionParameteriv(GLbyte
* pc
)
2992 const GLenum pname
= *(GLenum
*) (pc
+ 4);
2993 const GLint
*params
;
2995 params
= (const GLint
*) (pc
+ 8);
2997 glConvolutionParameteriv(*(GLenum
*) (pc
+ 0), pname
, params
);
3001 __glXDisp_CopyConvolutionFilter1D(GLbyte
* pc
)
3003 glCopyConvolutionFilter1D(*(GLenum
*) (pc
+ 0),
3004 *(GLenum
*) (pc
+ 4),
3005 *(GLint
*) (pc
+ 8),
3006 *(GLint
*) (pc
+ 12), *(GLsizei
*) (pc
+ 16));
3010 __glXDisp_CopyConvolutionFilter2D(GLbyte
* pc
)
3012 glCopyConvolutionFilter2D(*(GLenum
*) (pc
+ 0),
3013 *(GLenum
*) (pc
+ 4),
3014 *(GLint
*) (pc
+ 8),
3015 *(GLint
*) (pc
+ 12),
3016 *(GLsizei
*) (pc
+ 16), *(GLsizei
*) (pc
+ 20));
3020 __glXDisp_GetConvolutionParameterfv(__GLXclientState
* cl
, GLbyte
* pc
)
3022 xGLXSingleReq
*const req
= (xGLXSingleReq
*) pc
;
3024 __GLXcontext
*const cx
= __glXForceCurrent(cl
, req
->contextTag
, &error
);
3026 pc
+= __GLX_SINGLE_HDR_SIZE
;
3028 const GLenum pname
= *(GLenum
*) (pc
+ 4);
3030 const GLuint compsize
= __glGetConvolutionParameterfv_size(pname
);
3031 GLfloat answerBuffer
[200];
3033 __glXGetAnswerBuffer(cl
, compsize
* 4, answerBuffer
,
3034 sizeof(answerBuffer
), 4);
3038 __glXClearErrorOccured();
3040 glGetConvolutionParameterfv(*(GLenum
*) (pc
+ 0), pname
, params
);
3041 __glXSendReply(cl
->client
, params
, compsize
, 4, GL_FALSE
, 0);
3049 __glXDisp_GetConvolutionParameterfvEXT(__GLXclientState
* cl
, GLbyte
* pc
)
3051 xGLXVendorPrivateReq
*const req
= (xGLXVendorPrivateReq
*) pc
;
3053 __GLXcontext
*const cx
= __glXForceCurrent(cl
, req
->contextTag
, &error
);
3055 pc
+= __GLX_VENDPRIV_HDR_SIZE
;
3057 const GLenum pname
= *(GLenum
*) (pc
+ 4);
3059 const GLuint compsize
= __glGetConvolutionParameterfv_size(pname
);
3060 GLfloat answerBuffer
[200];
3062 __glXGetAnswerBuffer(cl
, compsize
* 4, answerBuffer
,
3063 sizeof(answerBuffer
), 4);
3067 __glXClearErrorOccured();
3069 glGetConvolutionParameterfv(*(GLenum
*) (pc
+ 0), pname
, params
);
3070 __glXSendReply(cl
->client
, params
, compsize
, 4, GL_FALSE
, 0);
3078 __glXDisp_GetConvolutionParameteriv(__GLXclientState
* cl
, GLbyte
* pc
)
3080 xGLXSingleReq
*const req
= (xGLXSingleReq
*) pc
;
3082 __GLXcontext
*const cx
= __glXForceCurrent(cl
, req
->contextTag
, &error
);
3084 pc
+= __GLX_SINGLE_HDR_SIZE
;
3086 const GLenum pname
= *(GLenum
*) (pc
+ 4);
3088 const GLuint compsize
= __glGetConvolutionParameteriv_size(pname
);
3089 GLint answerBuffer
[200];
3091 __glXGetAnswerBuffer(cl
, compsize
* 4, answerBuffer
,
3092 sizeof(answerBuffer
), 4);
3096 __glXClearErrorOccured();
3098 glGetConvolutionParameteriv(*(GLenum
*) (pc
+ 0), pname
, params
);
3099 __glXSendReply(cl
->client
, params
, compsize
, 4, GL_FALSE
, 0);
3107 __glXDisp_GetConvolutionParameterivEXT(__GLXclientState
* cl
, GLbyte
* pc
)
3109 xGLXVendorPrivateReq
*const req
= (xGLXVendorPrivateReq
*) pc
;
3111 __GLXcontext
*const cx
= __glXForceCurrent(cl
, req
->contextTag
, &error
);
3113 pc
+= __GLX_VENDPRIV_HDR_SIZE
;
3115 const GLenum pname
= *(GLenum
*) (pc
+ 4);
3117 const GLuint compsize
= __glGetConvolutionParameteriv_size(pname
);
3118 GLint answerBuffer
[200];
3120 __glXGetAnswerBuffer(cl
, compsize
* 4, answerBuffer
,
3121 sizeof(answerBuffer
), 4);
3125 __glXClearErrorOccured();
3127 glGetConvolutionParameteriv(*(GLenum
*) (pc
+ 0), pname
, params
);
3128 __glXSendReply(cl
->client
, params
, compsize
, 4, GL_FALSE
, 0);
3136 __glXDisp_GetHistogramParameterfv(__GLXclientState
* cl
, GLbyte
* pc
)
3138 xGLXSingleReq
*const req
= (xGLXSingleReq
*) pc
;
3140 __GLXcontext
*const cx
= __glXForceCurrent(cl
, req
->contextTag
, &error
);
3142 pc
+= __GLX_SINGLE_HDR_SIZE
;
3144 const GLenum pname
= *(GLenum
*) (pc
+ 4);
3146 const GLuint compsize
= __glGetHistogramParameterfv_size(pname
);
3147 GLfloat answerBuffer
[200];
3149 __glXGetAnswerBuffer(cl
, compsize
* 4, answerBuffer
,
3150 sizeof(answerBuffer
), 4);
3154 __glXClearErrorOccured();
3156 glGetHistogramParameterfv(*(GLenum
*) (pc
+ 0), pname
, params
);
3157 __glXSendReply(cl
->client
, params
, compsize
, 4, GL_FALSE
, 0);
3165 __glXDisp_GetHistogramParameterfvEXT(__GLXclientState
* cl
, GLbyte
* pc
)
3167 xGLXVendorPrivateReq
*const req
= (xGLXVendorPrivateReq
*) pc
;
3169 __GLXcontext
*const cx
= __glXForceCurrent(cl
, req
->contextTag
, &error
);
3171 pc
+= __GLX_VENDPRIV_HDR_SIZE
;
3173 const GLenum pname
= *(GLenum
*) (pc
+ 4);
3175 const GLuint compsize
= __glGetHistogramParameterfv_size(pname
);
3176 GLfloat answerBuffer
[200];
3178 __glXGetAnswerBuffer(cl
, compsize
* 4, answerBuffer
,
3179 sizeof(answerBuffer
), 4);
3183 __glXClearErrorOccured();
3185 glGetHistogramParameterfv(*(GLenum
*) (pc
+ 0), pname
, params
);
3186 __glXSendReply(cl
->client
, params
, compsize
, 4, GL_FALSE
, 0);
3194 __glXDisp_GetHistogramParameteriv(__GLXclientState
* cl
, GLbyte
* pc
)
3196 xGLXSingleReq
*const req
= (xGLXSingleReq
*) pc
;
3198 __GLXcontext
*const cx
= __glXForceCurrent(cl
, req
->contextTag
, &error
);
3200 pc
+= __GLX_SINGLE_HDR_SIZE
;
3202 const GLenum pname
= *(GLenum
*) (pc
+ 4);
3204 const GLuint compsize
= __glGetHistogramParameteriv_size(pname
);
3205 GLint answerBuffer
[200];
3207 __glXGetAnswerBuffer(cl
, compsize
* 4, answerBuffer
,
3208 sizeof(answerBuffer
), 4);
3212 __glXClearErrorOccured();
3214 glGetHistogramParameteriv(*(GLenum
*) (pc
+ 0), pname
, params
);
3215 __glXSendReply(cl
->client
, params
, compsize
, 4, GL_FALSE
, 0);
3223 __glXDisp_GetHistogramParameterivEXT(__GLXclientState
* cl
, GLbyte
* pc
)
3225 xGLXVendorPrivateReq
*const req
= (xGLXVendorPrivateReq
*) pc
;
3227 __GLXcontext
*const cx
= __glXForceCurrent(cl
, req
->contextTag
, &error
);
3229 pc
+= __GLX_VENDPRIV_HDR_SIZE
;
3231 const GLenum pname
= *(GLenum
*) (pc
+ 4);
3233 const GLuint compsize
= __glGetHistogramParameteriv_size(pname
);
3234 GLint answerBuffer
[200];
3236 __glXGetAnswerBuffer(cl
, compsize
* 4, answerBuffer
,
3237 sizeof(answerBuffer
), 4);
3241 __glXClearErrorOccured();
3243 glGetHistogramParameteriv(*(GLenum
*) (pc
+ 0), pname
, params
);
3244 __glXSendReply(cl
->client
, params
, compsize
, 4, GL_FALSE
, 0);
3252 __glXDisp_GetMinmaxParameterfv(__GLXclientState
* cl
, GLbyte
* pc
)
3254 xGLXSingleReq
*const req
= (xGLXSingleReq
*) pc
;
3256 __GLXcontext
*const cx
= __glXForceCurrent(cl
, req
->contextTag
, &error
);
3258 pc
+= __GLX_SINGLE_HDR_SIZE
;
3260 const GLenum pname
= *(GLenum
*) (pc
+ 4);
3262 const GLuint compsize
= __glGetMinmaxParameterfv_size(pname
);
3263 GLfloat answerBuffer
[200];
3265 __glXGetAnswerBuffer(cl
, compsize
* 4, answerBuffer
,
3266 sizeof(answerBuffer
), 4);
3270 __glXClearErrorOccured();
3272 glGetMinmaxParameterfv(*(GLenum
*) (pc
+ 0), pname
, params
);
3273 __glXSendReply(cl
->client
, params
, compsize
, 4, GL_FALSE
, 0);
3281 __glXDisp_GetMinmaxParameterfvEXT(__GLXclientState
* cl
, GLbyte
* pc
)
3283 xGLXVendorPrivateReq
*const req
= (xGLXVendorPrivateReq
*) pc
;
3285 __GLXcontext
*const cx
= __glXForceCurrent(cl
, req
->contextTag
, &error
);
3287 pc
+= __GLX_VENDPRIV_HDR_SIZE
;
3289 const GLenum pname
= *(GLenum
*) (pc
+ 4);
3291 const GLuint compsize
= __glGetMinmaxParameterfv_size(pname
);
3292 GLfloat answerBuffer
[200];
3294 __glXGetAnswerBuffer(cl
, compsize
* 4, answerBuffer
,
3295 sizeof(answerBuffer
), 4);
3299 __glXClearErrorOccured();
3301 glGetMinmaxParameterfv(*(GLenum
*) (pc
+ 0), pname
, params
);
3302 __glXSendReply(cl
->client
, params
, compsize
, 4, GL_FALSE
, 0);
3310 __glXDisp_GetMinmaxParameteriv(__GLXclientState
* cl
, GLbyte
* pc
)
3312 xGLXSingleReq
*const req
= (xGLXSingleReq
*) pc
;
3314 __GLXcontext
*const cx
= __glXForceCurrent(cl
, req
->contextTag
, &error
);
3316 pc
+= __GLX_SINGLE_HDR_SIZE
;
3318 const GLenum pname
= *(GLenum
*) (pc
+ 4);
3320 const GLuint compsize
= __glGetMinmaxParameteriv_size(pname
);
3321 GLint answerBuffer
[200];
3323 __glXGetAnswerBuffer(cl
, compsize
* 4, answerBuffer
,
3324 sizeof(answerBuffer
), 4);
3328 __glXClearErrorOccured();
3330 glGetMinmaxParameteriv(*(GLenum
*) (pc
+ 0), pname
, params
);
3331 __glXSendReply(cl
->client
, params
, compsize
, 4, GL_FALSE
, 0);
3339 __glXDisp_GetMinmaxParameterivEXT(__GLXclientState
* cl
, GLbyte
* pc
)
3341 xGLXVendorPrivateReq
*const req
= (xGLXVendorPrivateReq
*) pc
;
3343 __GLXcontext
*const cx
= __glXForceCurrent(cl
, req
->contextTag
, &error
);
3345 pc
+= __GLX_VENDPRIV_HDR_SIZE
;
3347 const GLenum pname
= *(GLenum
*) (pc
+ 4);
3349 const GLuint compsize
= __glGetMinmaxParameteriv_size(pname
);
3350 GLint answerBuffer
[200];
3352 __glXGetAnswerBuffer(cl
, compsize
* 4, answerBuffer
,
3353 sizeof(answerBuffer
), 4);
3357 __glXClearErrorOccured();
3359 glGetMinmaxParameteriv(*(GLenum
*) (pc
+ 0), pname
, params
);
3360 __glXSendReply(cl
->client
, params
, compsize
, 4, GL_FALSE
, 0);
3368 __glXDisp_Histogram(GLbyte
* pc
)
3370 glHistogram(*(GLenum
*) (pc
+ 0),
3371 *(GLsizei
*) (pc
+ 4),
3372 *(GLenum
*) (pc
+ 8), *(GLboolean
*) (pc
+ 12));
3376 __glXDisp_Minmax(GLbyte
* pc
)
3378 glMinmax(*(GLenum
*) (pc
+ 0),
3379 *(GLenum
*) (pc
+ 4), *(GLboolean
*) (pc
+ 8));
3383 __glXDisp_ResetHistogram(GLbyte
* pc
)
3385 glResetHistogram(*(GLenum
*) (pc
+ 0));
3389 __glXDisp_ResetMinmax(GLbyte
* pc
)
3391 glResetMinmax(*(GLenum
*) (pc
+ 0));
3395 __glXDisp_TexImage3D(GLbyte
* pc
)
3397 const CARD32 ptr_is_null
= *(CARD32
*) (pc
+ 76);
3398 const GLvoid
*const pixels
=
3399 (const GLvoid
*) ((ptr_is_null
!= 0) ? NULL
: (pc
+ 80));
3400 __GLXpixel3DHeader
*const hdr
= (__GLXpixel3DHeader
*) (pc
);
3402 glPixelStorei(GL_UNPACK_SWAP_BYTES
, hdr
->swapBytes
);
3403 glPixelStorei(GL_UNPACK_LSB_FIRST
, hdr
->lsbFirst
);
3404 glPixelStorei(GL_UNPACK_ROW_LENGTH
, (GLint
) hdr
->rowLength
);
3405 glPixelStorei(GL_UNPACK_IMAGE_HEIGHT
, (GLint
) hdr
->imageHeight
);
3406 glPixelStorei(GL_UNPACK_SKIP_ROWS
, (GLint
) hdr
->skipRows
);
3407 glPixelStorei(GL_UNPACK_SKIP_IMAGES
, (GLint
) hdr
->skipImages
);
3408 glPixelStorei(GL_UNPACK_SKIP_PIXELS
, (GLint
) hdr
->skipPixels
);
3409 glPixelStorei(GL_UNPACK_ALIGNMENT
, (GLint
) hdr
->alignment
);
3411 glTexImage3D(*(GLenum
*) (pc
+ 36),
3412 *(GLint
*) (pc
+ 40),
3413 *(GLint
*) (pc
+ 44),
3414 *(GLsizei
*) (pc
+ 48),
3415 *(GLsizei
*) (pc
+ 52),
3416 *(GLsizei
*) (pc
+ 56),
3417 *(GLint
*) (pc
+ 64),
3418 *(GLenum
*) (pc
+ 68), *(GLenum
*) (pc
+ 72), pixels
);
3422 __glXDisp_TexSubImage3D(GLbyte
* pc
)
3424 const GLvoid
*const pixels
= (const GLvoid
*) ((pc
+ 88));
3425 __GLXpixel3DHeader
*const hdr
= (__GLXpixel3DHeader
*) (pc
);
3427 glPixelStorei(GL_UNPACK_SWAP_BYTES
, hdr
->swapBytes
);
3428 glPixelStorei(GL_UNPACK_LSB_FIRST
, hdr
->lsbFirst
);
3429 glPixelStorei(GL_UNPACK_ROW_LENGTH
, (GLint
) hdr
->rowLength
);
3430 glPixelStorei(GL_UNPACK_IMAGE_HEIGHT
, (GLint
) hdr
->imageHeight
);
3431 glPixelStorei(GL_UNPACK_SKIP_ROWS
, (GLint
) hdr
->skipRows
);
3432 glPixelStorei(GL_UNPACK_SKIP_IMAGES
, (GLint
) hdr
->skipImages
);
3433 glPixelStorei(GL_UNPACK_SKIP_PIXELS
, (GLint
) hdr
->skipPixels
);
3434 glPixelStorei(GL_UNPACK_ALIGNMENT
, (GLint
) hdr
->alignment
);
3436 glTexSubImage3D(*(GLenum
*) (pc
+ 36),
3437 *(GLint
*) (pc
+ 40),
3438 *(GLint
*) (pc
+ 44),
3439 *(GLint
*) (pc
+ 48),
3440 *(GLint
*) (pc
+ 52),
3441 *(GLsizei
*) (pc
+ 60),
3442 *(GLsizei
*) (pc
+ 64),
3443 *(GLsizei
*) (pc
+ 68),
3444 *(GLenum
*) (pc
+ 76), *(GLenum
*) (pc
+ 80), pixels
);
3448 __glXDisp_CopyTexSubImage3D(GLbyte
* pc
)
3450 glCopyTexSubImage3D(*(GLenum
*) (pc
+ 0),
3451 *(GLint
*) (pc
+ 4),
3452 *(GLint
*) (pc
+ 8),
3453 *(GLint
*) (pc
+ 12),
3454 *(GLint
*) (pc
+ 16),
3455 *(GLint
*) (pc
+ 20),
3456 *(GLint
*) (pc
+ 24),
3457 *(GLsizei
*) (pc
+ 28), *(GLsizei
*) (pc
+ 32));
3461 __glXDisp_ActiveTexture(GLbyte
* pc
)
3463 glActiveTextureARB(*(GLenum
*) (pc
+ 0));
3467 __glXDisp_MultiTexCoord1dv(GLbyte
* pc
)
3469 #ifdef __GLX_ALIGN64
3470 if ((unsigned long) (pc
) & 7) {
3471 (void) memmove(pc
- 4, pc
, 12);
3476 glMultiTexCoord1dvARB(*(GLenum
*) (pc
+ 8), (const GLdouble
*) (pc
+ 0));
3480 __glXDisp_MultiTexCoord1fvARB(GLbyte
* pc
)
3482 glMultiTexCoord1fvARB(*(GLenum
*) (pc
+ 0), (const GLfloat
*) (pc
+ 4));
3486 __glXDisp_MultiTexCoord1iv(GLbyte
* pc
)
3488 glMultiTexCoord1ivARB(*(GLenum
*) (pc
+ 0), (const GLint
*) (pc
+ 4));
3492 __glXDisp_MultiTexCoord1sv(GLbyte
* pc
)
3494 glMultiTexCoord1svARB(*(GLenum
*) (pc
+ 0), (const GLshort
*) (pc
+ 4));
3498 __glXDisp_MultiTexCoord2dv(GLbyte
* pc
)
3500 #ifdef __GLX_ALIGN64
3501 if ((unsigned long) (pc
) & 7) {
3502 (void) memmove(pc
- 4, pc
, 20);
3507 glMultiTexCoord2dvARB(*(GLenum
*) (pc
+ 16), (const GLdouble
*) (pc
+ 0));
3511 __glXDisp_MultiTexCoord2fvARB(GLbyte
* pc
)
3513 glMultiTexCoord2fvARB(*(GLenum
*) (pc
+ 0), (const GLfloat
*) (pc
+ 4));
3517 __glXDisp_MultiTexCoord2iv(GLbyte
* pc
)
3519 glMultiTexCoord2ivARB(*(GLenum
*) (pc
+ 0), (const GLint
*) (pc
+ 4));
3523 __glXDisp_MultiTexCoord2sv(GLbyte
* pc
)
3525 glMultiTexCoord2svARB(*(GLenum
*) (pc
+ 0), (const GLshort
*) (pc
+ 4));
3529 __glXDisp_MultiTexCoord3dv(GLbyte
* pc
)
3531 #ifdef __GLX_ALIGN64
3532 if ((unsigned long) (pc
) & 7) {
3533 (void) memmove(pc
- 4, pc
, 28);
3538 glMultiTexCoord3dvARB(*(GLenum
*) (pc
+ 24), (const GLdouble
*) (pc
+ 0));
3542 __glXDisp_MultiTexCoord3fvARB(GLbyte
* pc
)
3544 glMultiTexCoord3fvARB(*(GLenum
*) (pc
+ 0), (const GLfloat
*) (pc
+ 4));
3548 __glXDisp_MultiTexCoord3iv(GLbyte
* pc
)
3550 glMultiTexCoord3ivARB(*(GLenum
*) (pc
+ 0), (const GLint
*) (pc
+ 4));
3554 __glXDisp_MultiTexCoord3sv(GLbyte
* pc
)
3556 glMultiTexCoord3svARB(*(GLenum
*) (pc
+ 0), (const GLshort
*) (pc
+ 4));
3560 __glXDisp_MultiTexCoord4dv(GLbyte
* pc
)
3562 #ifdef __GLX_ALIGN64
3563 if ((unsigned long) (pc
) & 7) {
3564 (void) memmove(pc
- 4, pc
, 36);
3569 glMultiTexCoord4dvARB(*(GLenum
*) (pc
+ 32), (const GLdouble
*) (pc
+ 0));
3573 __glXDisp_MultiTexCoord4fvARB(GLbyte
* pc
)
3575 glMultiTexCoord4fvARB(*(GLenum
*) (pc
+ 0), (const GLfloat
*) (pc
+ 4));
3579 __glXDisp_MultiTexCoord4iv(GLbyte
* pc
)
3581 glMultiTexCoord4ivARB(*(GLenum
*) (pc
+ 0), (const GLint
*) (pc
+ 4));
3585 __glXDisp_MultiTexCoord4sv(GLbyte
* pc
)
3587 glMultiTexCoord4svARB(*(GLenum
*) (pc
+ 0), (const GLshort
*) (pc
+ 4));
3591 __glXDisp_CompressedTexImage1D(GLbyte
* pc
)
3593 PFNGLCOMPRESSEDTEXIMAGE1DPROC CompressedTexImage1D
=
3594 __glGetProcAddress("glCompressedTexImage1D");
3595 const GLsizei imageSize
= *(GLsizei
*) (pc
+ 20);
3597 CompressedTexImage1D(*(GLenum
*) (pc
+ 0),
3598 *(GLint
*) (pc
+ 4),
3599 *(GLenum
*) (pc
+ 8),
3600 *(GLsizei
*) (pc
+ 12),
3601 *(GLint
*) (pc
+ 16),
3602 imageSize
, (const GLvoid
*) (pc
+ 24));
3606 __glXDisp_CompressedTexImage2D(GLbyte
* pc
)
3608 PFNGLCOMPRESSEDTEXIMAGE2DPROC CompressedTexImage2D
=
3609 __glGetProcAddress("glCompressedTexImage2D");
3610 const GLsizei imageSize
= *(GLsizei
*) (pc
+ 24);
3612 CompressedTexImage2D(*(GLenum
*) (pc
+ 0),
3613 *(GLint
*) (pc
+ 4),
3614 *(GLenum
*) (pc
+ 8),
3615 *(GLsizei
*) (pc
+ 12),
3616 *(GLsizei
*) (pc
+ 16),
3617 *(GLint
*) (pc
+ 20),
3618 imageSize
, (const GLvoid
*) (pc
+ 28));
3622 __glXDisp_CompressedTexImage3D(GLbyte
* pc
)
3624 PFNGLCOMPRESSEDTEXIMAGE3DPROC CompressedTexImage3D
=
3625 __glGetProcAddress("glCompressedTexImage3D");
3626 const GLsizei imageSize
= *(GLsizei
*) (pc
+ 28);
3628 CompressedTexImage3D(*(GLenum
*) (pc
+ 0),
3629 *(GLint
*) (pc
+ 4),
3630 *(GLenum
*) (pc
+ 8),
3631 *(GLsizei
*) (pc
+ 12),
3632 *(GLsizei
*) (pc
+ 16),
3633 *(GLsizei
*) (pc
+ 20),
3634 *(GLint
*) (pc
+ 24),
3635 imageSize
, (const GLvoid
*) (pc
+ 32));
3639 __glXDisp_CompressedTexSubImage1D(GLbyte
* pc
)
3641 PFNGLCOMPRESSEDTEXSUBIMAGE1DPROC CompressedTexSubImage1D
=
3642 __glGetProcAddress("glCompressedTexSubImage1D");
3643 const GLsizei imageSize
= *(GLsizei
*) (pc
+ 20);
3645 CompressedTexSubImage1D(*(GLenum
*) (pc
+ 0),
3646 *(GLint
*) (pc
+ 4),
3647 *(GLint
*) (pc
+ 8),
3648 *(GLsizei
*) (pc
+ 12),
3649 *(GLenum
*) (pc
+ 16),
3650 imageSize
, (const GLvoid
*) (pc
+ 24));
3654 __glXDisp_CompressedTexSubImage2D(GLbyte
* pc
)
3656 PFNGLCOMPRESSEDTEXSUBIMAGE2DPROC CompressedTexSubImage2D
=
3657 __glGetProcAddress("glCompressedTexSubImage2D");
3658 const GLsizei imageSize
= *(GLsizei
*) (pc
+ 28);
3660 CompressedTexSubImage2D(*(GLenum
*) (pc
+ 0),
3661 *(GLint
*) (pc
+ 4),
3662 *(GLint
*) (pc
+ 8),
3663 *(GLint
*) (pc
+ 12),
3664 *(GLsizei
*) (pc
+ 16),
3665 *(GLsizei
*) (pc
+ 20),
3666 *(GLenum
*) (pc
+ 24),
3667 imageSize
, (const GLvoid
*) (pc
+ 32));
3671 __glXDisp_CompressedTexSubImage3D(GLbyte
* pc
)
3673 PFNGLCOMPRESSEDTEXSUBIMAGE3DPROC CompressedTexSubImage3D
=
3674 __glGetProcAddress("glCompressedTexSubImage3D");
3675 const GLsizei imageSize
= *(GLsizei
*) (pc
+ 36);
3677 CompressedTexSubImage3D(*(GLenum
*) (pc
+ 0),
3678 *(GLint
*) (pc
+ 4),
3679 *(GLint
*) (pc
+ 8),
3680 *(GLint
*) (pc
+ 12),
3681 *(GLint
*) (pc
+ 16),
3682 *(GLsizei
*) (pc
+ 20),
3683 *(GLsizei
*) (pc
+ 24),
3684 *(GLsizei
*) (pc
+ 28),
3685 *(GLenum
*) (pc
+ 32),
3686 imageSize
, (const GLvoid
*) (pc
+ 40));
3690 __glXDisp_SampleCoverage(GLbyte
* pc
)
3692 PFNGLSAMPLECOVERAGEPROC SampleCoverage
=
3693 __glGetProcAddress("glSampleCoverage");
3694 SampleCoverage(*(GLclampf
*) (pc
+ 0), *(GLboolean
*) (pc
+ 4));
3698 __glXDisp_BlendFuncSeparate(GLbyte
* pc
)
3700 PFNGLBLENDFUNCSEPARATEPROC BlendFuncSeparate
=
3701 __glGetProcAddress("glBlendFuncSeparate");
3702 BlendFuncSeparate(*(GLenum
*) (pc
+ 0), *(GLenum
*) (pc
+ 4),
3703 *(GLenum
*) (pc
+ 8), *(GLenum
*) (pc
+ 12));
3707 __glXDisp_FogCoorddv(GLbyte
* pc
)
3709 PFNGLFOGCOORDDVPROC FogCoorddv
= __glGetProcAddress("glFogCoorddv");
3711 #ifdef __GLX_ALIGN64
3712 if ((unsigned long) (pc
) & 7) {
3713 (void) memmove(pc
- 4, pc
, 8);
3718 FogCoorddv((const GLdouble
*) (pc
+ 0));
3722 __glXDisp_PointParameterf(GLbyte
* pc
)
3724 PFNGLPOINTPARAMETERFPROC PointParameterf
=
3725 __glGetProcAddress("glPointParameterf");
3726 PointParameterf(*(GLenum
*) (pc
+ 0), *(GLfloat
*) (pc
+ 4));
3730 __glXDisp_PointParameterfv(GLbyte
* pc
)
3732 PFNGLPOINTPARAMETERFVPROC PointParameterfv
=
3733 __glGetProcAddress("glPointParameterfv");
3734 const GLenum pname
= *(GLenum
*) (pc
+ 0);
3735 const GLfloat
*params
;
3737 params
= (const GLfloat
*) (pc
+ 4);
3739 PointParameterfv(pname
, params
);
3743 __glXDisp_PointParameteri(GLbyte
* pc
)
3745 PFNGLPOINTPARAMETERIPROC PointParameteri
=
3746 __glGetProcAddress("glPointParameteri");
3747 PointParameteri(*(GLenum
*) (pc
+ 0), *(GLint
*) (pc
+ 4));
3751 __glXDisp_PointParameteriv(GLbyte
* pc
)
3753 PFNGLPOINTPARAMETERIVPROC PointParameteriv
=
3754 __glGetProcAddress("glPointParameteriv");
3755 const GLenum pname
= *(GLenum
*) (pc
+ 0);
3756 const GLint
*params
;
3758 params
= (const GLint
*) (pc
+ 4);
3760 PointParameteriv(pname
, params
);
3764 __glXDisp_SecondaryColor3bv(GLbyte
* pc
)
3766 PFNGLSECONDARYCOLOR3BVPROC SecondaryColor3bv
=
3767 __glGetProcAddress("glSecondaryColor3bv");
3768 SecondaryColor3bv((const GLbyte
*) (pc
+ 0));
3772 __glXDisp_SecondaryColor3dv(GLbyte
* pc
)
3774 PFNGLSECONDARYCOLOR3DVPROC SecondaryColor3dv
=
3775 __glGetProcAddress("glSecondaryColor3dv");
3776 #ifdef __GLX_ALIGN64
3777 if ((unsigned long) (pc
) & 7) {
3778 (void) memmove(pc
- 4, pc
, 24);
3783 SecondaryColor3dv((const GLdouble
*) (pc
+ 0));
3787 __glXDisp_SecondaryColor3iv(GLbyte
* pc
)
3789 PFNGLSECONDARYCOLOR3IVPROC SecondaryColor3iv
=
3790 __glGetProcAddress("glSecondaryColor3iv");
3791 SecondaryColor3iv((const GLint
*) (pc
+ 0));
3795 __glXDisp_SecondaryColor3sv(GLbyte
* pc
)
3797 PFNGLSECONDARYCOLOR3SVPROC SecondaryColor3sv
=
3798 __glGetProcAddress("glSecondaryColor3sv");
3799 SecondaryColor3sv((const GLshort
*) (pc
+ 0));
3803 __glXDisp_SecondaryColor3ubv(GLbyte
* pc
)
3805 PFNGLSECONDARYCOLOR3UBVPROC SecondaryColor3ubv
=
3806 __glGetProcAddress("glSecondaryColor3ubv");
3807 SecondaryColor3ubv((const GLubyte
*) (pc
+ 0));
3811 __glXDisp_SecondaryColor3uiv(GLbyte
* pc
)
3813 PFNGLSECONDARYCOLOR3UIVPROC SecondaryColor3uiv
=
3814 __glGetProcAddress("glSecondaryColor3uiv");
3815 SecondaryColor3uiv((const GLuint
*) (pc
+ 0));
3819 __glXDisp_SecondaryColor3usv(GLbyte
* pc
)
3821 PFNGLSECONDARYCOLOR3USVPROC SecondaryColor3usv
=
3822 __glGetProcAddress("glSecondaryColor3usv");
3823 SecondaryColor3usv((const GLushort
*) (pc
+ 0));
3827 __glXDisp_WindowPos3fv(GLbyte
* pc
)
3829 PFNGLWINDOWPOS3FVPROC WindowPos3fv
= __glGetProcAddress("glWindowPos3fv");
3831 WindowPos3fv((const GLfloat
*) (pc
+ 0));
3835 __glXDisp_BeginQuery(GLbyte
* pc
)
3837 PFNGLBEGINQUERYPROC BeginQuery
= __glGetProcAddress("glBeginQuery");
3839 BeginQuery(*(GLenum
*) (pc
+ 0), *(GLuint
*) (pc
+ 4));
3843 __glXDisp_DeleteQueries(__GLXclientState
* cl
, GLbyte
* pc
)
3845 PFNGLDELETEQUERIESPROC DeleteQueries
=
3846 __glGetProcAddress("glDeleteQueries");
3847 xGLXSingleReq
*const req
= (xGLXSingleReq
*) pc
;
3849 __GLXcontext
*const cx
= __glXForceCurrent(cl
, req
->contextTag
, &error
);
3851 pc
+= __GLX_SINGLE_HDR_SIZE
;
3853 const GLsizei n
= *(GLsizei
*) (pc
+ 0);
3855 DeleteQueries(n
, (const GLuint
*) (pc
+ 4));
3863 __glXDisp_EndQuery(GLbyte
* pc
)
3865 PFNGLENDQUERYPROC EndQuery
= __glGetProcAddress("glEndQuery");
3867 EndQuery(*(GLenum
*) (pc
+ 0));
3871 __glXDisp_GenQueries(__GLXclientState
* cl
, GLbyte
* pc
)
3873 PFNGLGENQUERIESPROC GenQueries
= __glGetProcAddress("glGenQueries");
3874 xGLXSingleReq
*const req
= (xGLXSingleReq
*) pc
;
3876 __GLXcontext
*const cx
= __glXForceCurrent(cl
, req
->contextTag
, &error
);
3878 pc
+= __GLX_SINGLE_HDR_SIZE
;
3880 const GLsizei n
= *(GLsizei
*) (pc
+ 0);
3882 GLuint answerBuffer
[200];
3884 __glXGetAnswerBuffer(cl
, n
* 4, answerBuffer
, sizeof(answerBuffer
),
3887 __glXSendReply(cl
->client
, ids
, n
, 4, GL_TRUE
, 0);
3895 __glXDisp_GetQueryObjectiv(__GLXclientState
* cl
, GLbyte
* pc
)
3897 PFNGLGETQUERYOBJECTIVPROC GetQueryObjectiv
=
3898 __glGetProcAddress("glGetQueryObjectiv");
3899 xGLXSingleReq
*const req
= (xGLXSingleReq
*) pc
;
3901 __GLXcontext
*const cx
= __glXForceCurrent(cl
, req
->contextTag
, &error
);
3903 pc
+= __GLX_SINGLE_HDR_SIZE
;
3905 const GLenum pname
= *(GLenum
*) (pc
+ 4);
3907 const GLuint compsize
= __glGetQueryObjectiv_size(pname
);
3908 GLint answerBuffer
[200];
3910 __glXGetAnswerBuffer(cl
, compsize
* 4, answerBuffer
,
3911 sizeof(answerBuffer
), 4);
3915 __glXClearErrorOccured();
3917 GetQueryObjectiv(*(GLuint
*) (pc
+ 0), pname
, params
);
3918 __glXSendReply(cl
->client
, params
, compsize
, 4, GL_FALSE
, 0);
3926 __glXDisp_GetQueryObjectuiv(__GLXclientState
* cl
, GLbyte
* pc
)
3928 PFNGLGETQUERYOBJECTUIVPROC GetQueryObjectuiv
=
3929 __glGetProcAddress("glGetQueryObjectuiv");
3930 xGLXSingleReq
*const req
= (xGLXSingleReq
*) pc
;
3932 __GLXcontext
*const cx
= __glXForceCurrent(cl
, req
->contextTag
, &error
);
3934 pc
+= __GLX_SINGLE_HDR_SIZE
;
3936 const GLenum pname
= *(GLenum
*) (pc
+ 4);
3938 const GLuint compsize
= __glGetQueryObjectuiv_size(pname
);
3939 GLuint answerBuffer
[200];
3941 __glXGetAnswerBuffer(cl
, compsize
* 4, answerBuffer
,
3942 sizeof(answerBuffer
), 4);
3946 __glXClearErrorOccured();
3948 GetQueryObjectuiv(*(GLuint
*) (pc
+ 0), pname
, params
);
3949 __glXSendReply(cl
->client
, params
, compsize
, 4, GL_FALSE
, 0);
3957 __glXDisp_GetQueryiv(__GLXclientState
* cl
, GLbyte
* pc
)
3959 PFNGLGETQUERYIVPROC GetQueryiv
= __glGetProcAddress("glGetQueryiv");
3960 xGLXSingleReq
*const req
= (xGLXSingleReq
*) pc
;
3962 __GLXcontext
*const cx
= __glXForceCurrent(cl
, req
->contextTag
, &error
);
3964 pc
+= __GLX_SINGLE_HDR_SIZE
;
3966 const GLenum pname
= *(GLenum
*) (pc
+ 4);
3968 const GLuint compsize
= __glGetQueryiv_size(pname
);
3969 GLint answerBuffer
[200];
3971 __glXGetAnswerBuffer(cl
, compsize
* 4, answerBuffer
,
3972 sizeof(answerBuffer
), 4);
3976 __glXClearErrorOccured();
3978 GetQueryiv(*(GLenum
*) (pc
+ 0), pname
, params
);
3979 __glXSendReply(cl
->client
, params
, compsize
, 4, GL_FALSE
, 0);
3987 __glXDisp_IsQuery(__GLXclientState
* cl
, GLbyte
* pc
)
3989 PFNGLISQUERYPROC IsQuery
= __glGetProcAddress("glIsQuery");
3990 xGLXSingleReq
*const req
= (xGLXSingleReq
*) pc
;
3992 __GLXcontext
*const cx
= __glXForceCurrent(cl
, req
->contextTag
, &error
);
3994 pc
+= __GLX_SINGLE_HDR_SIZE
;
3998 retval
= IsQuery(*(GLuint
*) (pc
+ 0));
3999 __glXSendReply(cl
->client
, dummy_answer
, 0, 0, GL_FALSE
, retval
);
4007 __glXDisp_BlendEquationSeparate(GLbyte
* pc
)
4009 PFNGLBLENDEQUATIONSEPARATEPROC BlendEquationSeparate
=
4010 __glGetProcAddress("glBlendEquationSeparate");
4011 BlendEquationSeparate(*(GLenum
*) (pc
+ 0), *(GLenum
*) (pc
+ 4));
4015 __glXDisp_DrawBuffers(GLbyte
* pc
)
4017 PFNGLDRAWBUFFERSPROC DrawBuffers
= __glGetProcAddress("glDrawBuffers");
4018 const GLsizei n
= *(GLsizei
*) (pc
+ 0);
4020 DrawBuffers(n
, (const GLenum
*) (pc
+ 4));
4024 __glXDisp_VertexAttrib1dv(GLbyte
* pc
)
4026 PFNGLVERTEXATTRIB1DVPROC VertexAttrib1dv
=
4027 __glGetProcAddress("glVertexAttrib1dv");
4028 #ifdef __GLX_ALIGN64
4029 if ((unsigned long) (pc
) & 7) {
4030 (void) memmove(pc
- 4, pc
, 12);
4035 VertexAttrib1dv(*(GLuint
*) (pc
+ 0), (const GLdouble
*) (pc
+ 4));
4039 __glXDisp_VertexAttrib1sv(GLbyte
* pc
)
4041 PFNGLVERTEXATTRIB1SVPROC VertexAttrib1sv
=
4042 __glGetProcAddress("glVertexAttrib1sv");
4043 VertexAttrib1sv(*(GLuint
*) (pc
+ 0), (const GLshort
*) (pc
+ 4));
4047 __glXDisp_VertexAttrib2dv(GLbyte
* pc
)
4049 PFNGLVERTEXATTRIB2DVPROC VertexAttrib2dv
=
4050 __glGetProcAddress("glVertexAttrib2dv");
4051 #ifdef __GLX_ALIGN64
4052 if ((unsigned long) (pc
) & 7) {
4053 (void) memmove(pc
- 4, pc
, 20);
4058 VertexAttrib2dv(*(GLuint
*) (pc
+ 0), (const GLdouble
*) (pc
+ 4));
4062 __glXDisp_VertexAttrib2sv(GLbyte
* pc
)
4064 PFNGLVERTEXATTRIB2SVPROC VertexAttrib2sv
=
4065 __glGetProcAddress("glVertexAttrib2sv");
4066 VertexAttrib2sv(*(GLuint
*) (pc
+ 0), (const GLshort
*) (pc
+ 4));
4070 __glXDisp_VertexAttrib3dv(GLbyte
* pc
)
4072 PFNGLVERTEXATTRIB3DVPROC VertexAttrib3dv
=
4073 __glGetProcAddress("glVertexAttrib3dv");
4074 #ifdef __GLX_ALIGN64
4075 if ((unsigned long) (pc
) & 7) {
4076 (void) memmove(pc
- 4, pc
, 28);
4081 VertexAttrib3dv(*(GLuint
*) (pc
+ 0), (const GLdouble
*) (pc
+ 4));
4085 __glXDisp_VertexAttrib3sv(GLbyte
* pc
)
4087 PFNGLVERTEXATTRIB3SVPROC VertexAttrib3sv
=
4088 __glGetProcAddress("glVertexAttrib3sv");
4089 VertexAttrib3sv(*(GLuint
*) (pc
+ 0), (const GLshort
*) (pc
+ 4));
4093 __glXDisp_VertexAttrib4Nbv(GLbyte
* pc
)
4095 PFNGLVERTEXATTRIB4NBVPROC VertexAttrib4Nbv
=
4096 __glGetProcAddress("glVertexAttrib4Nbv");
4097 VertexAttrib4Nbv(*(GLuint
*) (pc
+ 0), (const GLbyte
*) (pc
+ 4));
4101 __glXDisp_VertexAttrib4Niv(GLbyte
* pc
)
4103 PFNGLVERTEXATTRIB4NIVPROC VertexAttrib4Niv
=
4104 __glGetProcAddress("glVertexAttrib4Niv");
4105 VertexAttrib4Niv(*(GLuint
*) (pc
+ 0), (const GLint
*) (pc
+ 4));
4109 __glXDisp_VertexAttrib4Nsv(GLbyte
* pc
)
4111 PFNGLVERTEXATTRIB4NSVPROC VertexAttrib4Nsv
=
4112 __glGetProcAddress("glVertexAttrib4Nsv");
4113 VertexAttrib4Nsv(*(GLuint
*) (pc
+ 0), (const GLshort
*) (pc
+ 4));
4117 __glXDisp_VertexAttrib4Nubv(GLbyte
* pc
)
4119 PFNGLVERTEXATTRIB4NUBVPROC VertexAttrib4Nubv
=
4120 __glGetProcAddress("glVertexAttrib4Nubv");
4121 VertexAttrib4Nubv(*(GLuint
*) (pc
+ 0), (const GLubyte
*) (pc
+ 4));
4125 __glXDisp_VertexAttrib4Nuiv(GLbyte
* pc
)
4127 PFNGLVERTEXATTRIB4NUIVPROC VertexAttrib4Nuiv
=
4128 __glGetProcAddress("glVertexAttrib4Nuiv");
4129 VertexAttrib4Nuiv(*(GLuint
*) (pc
+ 0), (const GLuint
*) (pc
+ 4));
4133 __glXDisp_VertexAttrib4Nusv(GLbyte
* pc
)
4135 PFNGLVERTEXATTRIB4NUSVPROC VertexAttrib4Nusv
=
4136 __glGetProcAddress("glVertexAttrib4Nusv");
4137 VertexAttrib4Nusv(*(GLuint
*) (pc
+ 0), (const GLushort
*) (pc
+ 4));
4141 __glXDisp_VertexAttrib4bv(GLbyte
* pc
)
4143 PFNGLVERTEXATTRIB4BVPROC VertexAttrib4bv
=
4144 __glGetProcAddress("glVertexAttrib4bv");
4145 VertexAttrib4bv(*(GLuint
*) (pc
+ 0), (const GLbyte
*) (pc
+ 4));
4149 __glXDisp_VertexAttrib4dv(GLbyte
* pc
)
4151 PFNGLVERTEXATTRIB4DVPROC VertexAttrib4dv
=
4152 __glGetProcAddress("glVertexAttrib4dv");
4153 #ifdef __GLX_ALIGN64
4154 if ((unsigned long) (pc
) & 7) {
4155 (void) memmove(pc
- 4, pc
, 36);
4160 VertexAttrib4dv(*(GLuint
*) (pc
+ 0), (const GLdouble
*) (pc
+ 4));
4164 __glXDisp_VertexAttrib4iv(GLbyte
* pc
)
4166 PFNGLVERTEXATTRIB4IVPROC VertexAttrib4iv
=
4167 __glGetProcAddress("glVertexAttrib4iv");
4168 VertexAttrib4iv(*(GLuint
*) (pc
+ 0), (const GLint
*) (pc
+ 4));
4172 __glXDisp_VertexAttrib4sv(GLbyte
* pc
)
4174 PFNGLVERTEXATTRIB4SVPROC VertexAttrib4sv
=
4175 __glGetProcAddress("glVertexAttrib4sv");
4176 VertexAttrib4sv(*(GLuint
*) (pc
+ 0), (const GLshort
*) (pc
+ 4));
4180 __glXDisp_VertexAttrib4ubv(GLbyte
* pc
)
4182 PFNGLVERTEXATTRIB4UBVPROC VertexAttrib4ubv
=
4183 __glGetProcAddress("glVertexAttrib4ubv");
4184 VertexAttrib4ubv(*(GLuint
*) (pc
+ 0), (const GLubyte
*) (pc
+ 4));
4188 __glXDisp_VertexAttrib4uiv(GLbyte
* pc
)
4190 PFNGLVERTEXATTRIB4UIVPROC VertexAttrib4uiv
=
4191 __glGetProcAddress("glVertexAttrib4uiv");
4192 VertexAttrib4uiv(*(GLuint
*) (pc
+ 0), (const GLuint
*) (pc
+ 4));
4196 __glXDisp_VertexAttrib4usv(GLbyte
* pc
)
4198 PFNGLVERTEXATTRIB4USVPROC VertexAttrib4usv
=
4199 __glGetProcAddress("glVertexAttrib4usv");
4200 VertexAttrib4usv(*(GLuint
*) (pc
+ 0), (const GLushort
*) (pc
+ 4));
4204 __glXDisp_ClampColor(GLbyte
* pc
)
4206 PFNGLCLAMPCOLORPROC ClampColor
= __glGetProcAddress("glClampColor");
4208 ClampColor(*(GLenum
*) (pc
+ 0), *(GLenum
*) (pc
+ 4));
4212 __glXDisp_BindProgramARB(GLbyte
* pc
)
4214 PFNGLBINDPROGRAMARBPROC BindProgramARB
=
4215 __glGetProcAddress("glBindProgramARB");
4216 BindProgramARB(*(GLenum
*) (pc
+ 0), *(GLuint
*) (pc
+ 4));
4220 __glXDisp_DeleteProgramsARB(__GLXclientState
* cl
, GLbyte
* pc
)
4222 PFNGLDELETEPROGRAMSARBPROC DeleteProgramsARB
=
4223 __glGetProcAddress("glDeleteProgramsARB");
4224 xGLXVendorPrivateReq
*const req
= (xGLXVendorPrivateReq
*) pc
;
4226 __GLXcontext
*const cx
= __glXForceCurrent(cl
, req
->contextTag
, &error
);
4228 pc
+= __GLX_VENDPRIV_HDR_SIZE
;
4230 const GLsizei n
= *(GLsizei
*) (pc
+ 0);
4232 DeleteProgramsARB(n
, (const GLuint
*) (pc
+ 4));
4240 __glXDisp_GenProgramsARB(__GLXclientState
* cl
, GLbyte
* pc
)
4242 PFNGLGENPROGRAMSARBPROC GenProgramsARB
=
4243 __glGetProcAddress("glGenProgramsARB");
4244 xGLXVendorPrivateReq
*const req
= (xGLXVendorPrivateReq
*) pc
;
4246 __GLXcontext
*const cx
= __glXForceCurrent(cl
, req
->contextTag
, &error
);
4248 pc
+= __GLX_VENDPRIV_HDR_SIZE
;
4250 const GLsizei n
= *(GLsizei
*) (pc
+ 0);
4252 GLuint answerBuffer
[200];
4254 __glXGetAnswerBuffer(cl
, n
* 4, answerBuffer
, sizeof(answerBuffer
),
4256 GenProgramsARB(n
, programs
);
4257 __glXSendReply(cl
->client
, programs
, n
, 4, GL_TRUE
, 0);
4265 __glXDisp_GetProgramEnvParameterdvARB(__GLXclientState
* cl
, GLbyte
* pc
)
4267 PFNGLGETPROGRAMENVPARAMETERDVARBPROC GetProgramEnvParameterdvARB
=
4268 __glGetProcAddress("glGetProgramEnvParameterdvARB");
4269 xGLXVendorPrivateReq
*const req
= (xGLXVendorPrivateReq
*) pc
;
4271 __GLXcontext
*const cx
= __glXForceCurrent(cl
, req
->contextTag
, &error
);
4273 pc
+= __GLX_VENDPRIV_HDR_SIZE
;
4277 GetProgramEnvParameterdvARB(*(GLenum
*) (pc
+ 0),
4278 *(GLuint
*) (pc
+ 4), params
);
4279 __glXSendReply(cl
->client
, params
, 4, 8, GL_FALSE
, 0);
4287 __glXDisp_GetProgramEnvParameterfvARB(__GLXclientState
* cl
, GLbyte
* pc
)
4289 PFNGLGETPROGRAMENVPARAMETERFVARBPROC GetProgramEnvParameterfvARB
=
4290 __glGetProcAddress("glGetProgramEnvParameterfvARB");
4291 xGLXVendorPrivateReq
*const req
= (xGLXVendorPrivateReq
*) pc
;
4293 __GLXcontext
*const cx
= __glXForceCurrent(cl
, req
->contextTag
, &error
);
4295 pc
+= __GLX_VENDPRIV_HDR_SIZE
;
4299 GetProgramEnvParameterfvARB(*(GLenum
*) (pc
+ 0),
4300 *(GLuint
*) (pc
+ 4), params
);
4301 __glXSendReply(cl
->client
, params
, 4, 4, GL_FALSE
, 0);
4309 __glXDisp_GetProgramLocalParameterdvARB(__GLXclientState
* cl
, GLbyte
* pc
)
4311 PFNGLGETPROGRAMLOCALPARAMETERDVARBPROC GetProgramLocalParameterdvARB
=
4312 __glGetProcAddress("glGetProgramLocalParameterdvARB");
4313 xGLXVendorPrivateReq
*const req
= (xGLXVendorPrivateReq
*) pc
;
4315 __GLXcontext
*const cx
= __glXForceCurrent(cl
, req
->contextTag
, &error
);
4317 pc
+= __GLX_VENDPRIV_HDR_SIZE
;
4321 GetProgramLocalParameterdvARB(*(GLenum
*) (pc
+ 0),
4322 *(GLuint
*) (pc
+ 4), params
);
4323 __glXSendReply(cl
->client
, params
, 4, 8, GL_FALSE
, 0);
4331 __glXDisp_GetProgramLocalParameterfvARB(__GLXclientState
* cl
, GLbyte
* pc
)
4333 PFNGLGETPROGRAMLOCALPARAMETERFVARBPROC GetProgramLocalParameterfvARB
=
4334 __glGetProcAddress("glGetProgramLocalParameterfvARB");
4335 xGLXVendorPrivateReq
*const req
= (xGLXVendorPrivateReq
*) pc
;
4337 __GLXcontext
*const cx
= __glXForceCurrent(cl
, req
->contextTag
, &error
);
4339 pc
+= __GLX_VENDPRIV_HDR_SIZE
;
4343 GetProgramLocalParameterfvARB(*(GLenum
*) (pc
+ 0),
4344 *(GLuint
*) (pc
+ 4), params
);
4345 __glXSendReply(cl
->client
, params
, 4, 4, GL_FALSE
, 0);
4353 __glXDisp_GetProgramivARB(__GLXclientState
* cl
, GLbyte
* pc
)
4355 PFNGLGETPROGRAMIVARBPROC GetProgramivARB
=
4356 __glGetProcAddress("glGetProgramivARB");
4357 xGLXVendorPrivateReq
*const req
= (xGLXVendorPrivateReq
*) pc
;
4359 __GLXcontext
*const cx
= __glXForceCurrent(cl
, req
->contextTag
, &error
);
4361 pc
+= __GLX_VENDPRIV_HDR_SIZE
;
4363 const GLenum pname
= *(GLenum
*) (pc
+ 4);
4365 const GLuint compsize
= __glGetProgramivARB_size(pname
);
4366 GLint answerBuffer
[200];
4368 __glXGetAnswerBuffer(cl
, compsize
* 4, answerBuffer
,
4369 sizeof(answerBuffer
), 4);
4373 __glXClearErrorOccured();
4375 GetProgramivARB(*(GLenum
*) (pc
+ 0), pname
, params
);
4376 __glXSendReply(cl
->client
, params
, compsize
, 4, GL_FALSE
, 0);
4384 __glXDisp_IsProgramARB(__GLXclientState
* cl
, GLbyte
* pc
)
4386 PFNGLISPROGRAMARBPROC IsProgramARB
= __glGetProcAddress("glIsProgramARB");
4387 xGLXVendorPrivateReq
*const req
= (xGLXVendorPrivateReq
*) pc
;
4389 __GLXcontext
*const cx
= __glXForceCurrent(cl
, req
->contextTag
, &error
);
4391 pc
+= __GLX_VENDPRIV_HDR_SIZE
;
4395 retval
= IsProgramARB(*(GLuint
*) (pc
+ 0));
4396 __glXSendReply(cl
->client
, dummy_answer
, 0, 0, GL_FALSE
, retval
);
4404 __glXDisp_ProgramEnvParameter4dvARB(GLbyte
* pc
)
4406 PFNGLPROGRAMENVPARAMETER4DVARBPROC ProgramEnvParameter4dvARB
=
4407 __glGetProcAddress("glProgramEnvParameter4dvARB");
4408 #ifdef __GLX_ALIGN64
4409 if ((unsigned long) (pc
) & 7) {
4410 (void) memmove(pc
- 4, pc
, 40);
4415 ProgramEnvParameter4dvARB(*(GLenum
*) (pc
+ 0),
4416 *(GLuint
*) (pc
+ 4),
4417 (const GLdouble
*) (pc
+ 8));
4421 __glXDisp_ProgramEnvParameter4fvARB(GLbyte
* pc
)
4423 PFNGLPROGRAMENVPARAMETER4FVARBPROC ProgramEnvParameter4fvARB
=
4424 __glGetProcAddress("glProgramEnvParameter4fvARB");
4425 ProgramEnvParameter4fvARB(*(GLenum
*) (pc
+ 0), *(GLuint
*) (pc
+ 4),
4426 (const GLfloat
*) (pc
+ 8));
4430 __glXDisp_ProgramLocalParameter4dvARB(GLbyte
* pc
)
4432 PFNGLPROGRAMLOCALPARAMETER4DVARBPROC ProgramLocalParameter4dvARB
=
4433 __glGetProcAddress("glProgramLocalParameter4dvARB");
4434 #ifdef __GLX_ALIGN64
4435 if ((unsigned long) (pc
) & 7) {
4436 (void) memmove(pc
- 4, pc
, 40);
4441 ProgramLocalParameter4dvARB(*(GLenum
*) (pc
+ 0),
4442 *(GLuint
*) (pc
+ 4),
4443 (const GLdouble
*) (pc
+ 8));
4447 __glXDisp_ProgramLocalParameter4fvARB(GLbyte
* pc
)
4449 PFNGLPROGRAMLOCALPARAMETER4FVARBPROC ProgramLocalParameter4fvARB
=
4450 __glGetProcAddress("glProgramLocalParameter4fvARB");
4451 ProgramLocalParameter4fvARB(*(GLenum
*) (pc
+ 0), *(GLuint
*) (pc
+ 4),
4452 (const GLfloat
*) (pc
+ 8));
4456 __glXDisp_ProgramStringARB(GLbyte
* pc
)
4458 PFNGLPROGRAMSTRINGARBPROC ProgramStringARB
=
4459 __glGetProcAddress("glProgramStringARB");
4460 const GLsizei len
= *(GLsizei
*) (pc
+ 8);
4462 ProgramStringARB(*(GLenum
*) (pc
+ 0),
4463 *(GLenum
*) (pc
+ 4), len
, (const GLvoid
*) (pc
+ 12));
4467 __glXDisp_VertexAttrib1fvARB(GLbyte
* pc
)
4469 PFNGLVERTEXATTRIB1FVARBPROC VertexAttrib1fvARB
=
4470 __glGetProcAddress("glVertexAttrib1fvARB");
4471 VertexAttrib1fvARB(*(GLuint
*) (pc
+ 0), (const GLfloat
*) (pc
+ 4));
4475 __glXDisp_VertexAttrib2fvARB(GLbyte
* pc
)
4477 PFNGLVERTEXATTRIB2FVARBPROC VertexAttrib2fvARB
=
4478 __glGetProcAddress("glVertexAttrib2fvARB");
4479 VertexAttrib2fvARB(*(GLuint
*) (pc
+ 0), (const GLfloat
*) (pc
+ 4));
4483 __glXDisp_VertexAttrib3fvARB(GLbyte
* pc
)
4485 PFNGLVERTEXATTRIB3FVARBPROC VertexAttrib3fvARB
=
4486 __glGetProcAddress("glVertexAttrib3fvARB");
4487 VertexAttrib3fvARB(*(GLuint
*) (pc
+ 0), (const GLfloat
*) (pc
+ 4));
4491 __glXDisp_VertexAttrib4fvARB(GLbyte
* pc
)
4493 PFNGLVERTEXATTRIB4FVARBPROC VertexAttrib4fvARB
=
4494 __glGetProcAddress("glVertexAttrib4fvARB");
4495 VertexAttrib4fvARB(*(GLuint
*) (pc
+ 0), (const GLfloat
*) (pc
+ 4));
4499 __glXDisp_BindFramebuffer(GLbyte
* pc
)
4501 PFNGLBINDFRAMEBUFFERPROC BindFramebuffer
=
4502 __glGetProcAddress("glBindFramebuffer");
4503 BindFramebuffer(*(GLenum
*) (pc
+ 0), *(GLuint
*) (pc
+ 4));
4507 __glXDisp_BindRenderbuffer(GLbyte
* pc
)
4509 PFNGLBINDRENDERBUFFERPROC BindRenderbuffer
=
4510 __glGetProcAddress("glBindRenderbuffer");
4511 BindRenderbuffer(*(GLenum
*) (pc
+ 0), *(GLuint
*) (pc
+ 4));
4515 __glXDisp_BlitFramebuffer(GLbyte
* pc
)
4517 PFNGLBLITFRAMEBUFFERPROC BlitFramebuffer
=
4518 __glGetProcAddress("glBlitFramebuffer");
4519 BlitFramebuffer(*(GLint
*) (pc
+ 0), *(GLint
*) (pc
+ 4),
4520 *(GLint
*) (pc
+ 8), *(GLint
*) (pc
+ 12),
4521 *(GLint
*) (pc
+ 16), *(GLint
*) (pc
+ 20),
4522 *(GLint
*) (pc
+ 24), *(GLint
*) (pc
+ 28),
4523 *(GLbitfield
*) (pc
+ 32), *(GLenum
*) (pc
+ 36));
4527 __glXDisp_CheckFramebufferStatus(__GLXclientState
* cl
, GLbyte
* pc
)
4529 PFNGLCHECKFRAMEBUFFERSTATUSPROC CheckFramebufferStatus
=
4530 __glGetProcAddress("glCheckFramebufferStatus");
4531 xGLXVendorPrivateReq
*const req
= (xGLXVendorPrivateReq
*) pc
;
4533 __GLXcontext
*const cx
= __glXForceCurrent(cl
, req
->contextTag
, &error
);
4535 pc
+= __GLX_VENDPRIV_HDR_SIZE
;
4539 retval
= CheckFramebufferStatus(*(GLenum
*) (pc
+ 0));
4540 __glXSendReply(cl
->client
, dummy_answer
, 0, 0, GL_FALSE
, retval
);
4548 __glXDisp_DeleteFramebuffers(GLbyte
* pc
)
4550 PFNGLDELETEFRAMEBUFFERSPROC DeleteFramebuffers
=
4551 __glGetProcAddress("glDeleteFramebuffers");
4552 const GLsizei n
= *(GLsizei
*) (pc
+ 0);
4554 DeleteFramebuffers(n
, (const GLuint
*) (pc
+ 4));
4558 __glXDisp_DeleteRenderbuffers(GLbyte
* pc
)
4560 PFNGLDELETERENDERBUFFERSPROC DeleteRenderbuffers
=
4561 __glGetProcAddress("glDeleteRenderbuffers");
4562 const GLsizei n
= *(GLsizei
*) (pc
+ 0);
4564 DeleteRenderbuffers(n
, (const GLuint
*) (pc
+ 4));
4568 __glXDisp_FramebufferRenderbuffer(GLbyte
* pc
)
4570 PFNGLFRAMEBUFFERRENDERBUFFERPROC FramebufferRenderbuffer
=
4571 __glGetProcAddress("glFramebufferRenderbuffer");
4572 FramebufferRenderbuffer(*(GLenum
*) (pc
+ 0), *(GLenum
*) (pc
+ 4),
4573 *(GLenum
*) (pc
+ 8), *(GLuint
*) (pc
+ 12));
4577 __glXDisp_FramebufferTexture1D(GLbyte
* pc
)
4579 PFNGLFRAMEBUFFERTEXTURE1DPROC FramebufferTexture1D
=
4580 __glGetProcAddress("glFramebufferTexture1D");
4581 FramebufferTexture1D(*(GLenum
*) (pc
+ 0), *(GLenum
*) (pc
+ 4),
4582 *(GLenum
*) (pc
+ 8), *(GLuint
*) (pc
+ 12),
4583 *(GLint
*) (pc
+ 16));
4587 __glXDisp_FramebufferTexture2D(GLbyte
* pc
)
4589 PFNGLFRAMEBUFFERTEXTURE2DPROC FramebufferTexture2D
=
4590 __glGetProcAddress("glFramebufferTexture2D");
4591 FramebufferTexture2D(*(GLenum
*) (pc
+ 0), *(GLenum
*) (pc
+ 4),
4592 *(GLenum
*) (pc
+ 8), *(GLuint
*) (pc
+ 12),
4593 *(GLint
*) (pc
+ 16));
4597 __glXDisp_FramebufferTexture3D(GLbyte
* pc
)
4599 PFNGLFRAMEBUFFERTEXTURE3DPROC FramebufferTexture3D
=
4600 __glGetProcAddress("glFramebufferTexture3D");
4601 FramebufferTexture3D(*(GLenum
*) (pc
+ 0), *(GLenum
*) (pc
+ 4),
4602 *(GLenum
*) (pc
+ 8), *(GLuint
*) (pc
+ 12),
4603 *(GLint
*) (pc
+ 16), *(GLint
*) (pc
+ 20));
4607 __glXDisp_FramebufferTextureLayer(GLbyte
* pc
)
4609 PFNGLFRAMEBUFFERTEXTURELAYERPROC FramebufferTextureLayer
=
4610 __glGetProcAddress("glFramebufferTextureLayer");
4611 FramebufferTextureLayer(*(GLenum
*) (pc
+ 0), *(GLenum
*) (pc
+ 4),
4612 *(GLuint
*) (pc
+ 8), *(GLint
*) (pc
+ 12),
4613 *(GLint
*) (pc
+ 16));
4617 __glXDisp_GenFramebuffers(__GLXclientState
* cl
, GLbyte
* pc
)
4619 PFNGLGENFRAMEBUFFERSPROC GenFramebuffers
=
4620 __glGetProcAddress("glGenFramebuffers");
4621 xGLXVendorPrivateReq
*const req
= (xGLXVendorPrivateReq
*) pc
;
4623 __GLXcontext
*const cx
= __glXForceCurrent(cl
, req
->contextTag
, &error
);
4625 pc
+= __GLX_VENDPRIV_HDR_SIZE
;
4627 const GLsizei n
= *(GLsizei
*) (pc
+ 0);
4629 GLuint answerBuffer
[200];
4630 GLuint
*framebuffers
=
4631 __glXGetAnswerBuffer(cl
, n
* 4, answerBuffer
, sizeof(answerBuffer
),
4633 GenFramebuffers(n
, framebuffers
);
4634 __glXSendReply(cl
->client
, framebuffers
, n
, 4, GL_TRUE
, 0);
4642 __glXDisp_GenRenderbuffers(__GLXclientState
* cl
, GLbyte
* pc
)
4644 PFNGLGENRENDERBUFFERSPROC GenRenderbuffers
=
4645 __glGetProcAddress("glGenRenderbuffers");
4646 xGLXVendorPrivateReq
*const req
= (xGLXVendorPrivateReq
*) pc
;
4648 __GLXcontext
*const cx
= __glXForceCurrent(cl
, req
->contextTag
, &error
);
4650 pc
+= __GLX_VENDPRIV_HDR_SIZE
;
4652 const GLsizei n
= *(GLsizei
*) (pc
+ 0);
4654 GLuint answerBuffer
[200];
4655 GLuint
*renderbuffers
=
4656 __glXGetAnswerBuffer(cl
, n
* 4, answerBuffer
, sizeof(answerBuffer
),
4658 GenRenderbuffers(n
, renderbuffers
);
4659 __glXSendReply(cl
->client
, renderbuffers
, n
, 4, GL_TRUE
, 0);
4667 __glXDisp_GenerateMipmap(GLbyte
* pc
)
4669 PFNGLGENERATEMIPMAPPROC GenerateMipmap
=
4670 __glGetProcAddress("glGenerateMipmap");
4671 GenerateMipmap(*(GLenum
*) (pc
+ 0));
4675 __glXDisp_GetFramebufferAttachmentParameteriv(__GLXclientState
* cl
,
4678 PFNGLGETFRAMEBUFFERATTACHMENTPARAMETERIVPROC
4679 GetFramebufferAttachmentParameteriv
=
4680 __glGetProcAddress("glGetFramebufferAttachmentParameteriv");
4681 xGLXVendorPrivateReq
*const req
= (xGLXVendorPrivateReq
*) pc
;
4683 __GLXcontext
*const cx
= __glXForceCurrent(cl
, req
->contextTag
, &error
);
4685 pc
+= __GLX_VENDPRIV_HDR_SIZE
;
4689 GetFramebufferAttachmentParameteriv(*(GLenum
*) (pc
+ 0),
4690 *(GLenum
*) (pc
+ 4),
4691 *(GLenum
*) (pc
+ 8), params
);
4692 __glXSendReply(cl
->client
, params
, 1, 4, GL_FALSE
, 0);
4700 __glXDisp_GetRenderbufferParameteriv(__GLXclientState
* cl
, GLbyte
* pc
)
4702 PFNGLGETRENDERBUFFERPARAMETERIVPROC GetRenderbufferParameteriv
=
4703 __glGetProcAddress("glGetRenderbufferParameteriv");
4704 xGLXVendorPrivateReq
*const req
= (xGLXVendorPrivateReq
*) pc
;
4706 __GLXcontext
*const cx
= __glXForceCurrent(cl
, req
->contextTag
, &error
);
4708 pc
+= __GLX_VENDPRIV_HDR_SIZE
;
4712 GetRenderbufferParameteriv(*(GLenum
*) (pc
+ 0),
4713 *(GLenum
*) (pc
+ 4), params
);
4714 __glXSendReply(cl
->client
, params
, 1, 4, GL_FALSE
, 0);
4722 __glXDisp_IsFramebuffer(__GLXclientState
* cl
, GLbyte
* pc
)
4724 PFNGLISFRAMEBUFFERPROC IsFramebuffer
=
4725 __glGetProcAddress("glIsFramebuffer");
4726 xGLXVendorPrivateReq
*const req
= (xGLXVendorPrivateReq
*) pc
;
4728 __GLXcontext
*const cx
= __glXForceCurrent(cl
, req
->contextTag
, &error
);
4730 pc
+= __GLX_VENDPRIV_HDR_SIZE
;
4734 retval
= IsFramebuffer(*(GLuint
*) (pc
+ 0));
4735 __glXSendReply(cl
->client
, dummy_answer
, 0, 0, GL_FALSE
, retval
);
4743 __glXDisp_IsRenderbuffer(__GLXclientState
* cl
, GLbyte
* pc
)
4745 PFNGLISRENDERBUFFERPROC IsRenderbuffer
=
4746 __glGetProcAddress("glIsRenderbuffer");
4747 xGLXVendorPrivateReq
*const req
= (xGLXVendorPrivateReq
*) pc
;
4749 __GLXcontext
*const cx
= __glXForceCurrent(cl
, req
->contextTag
, &error
);
4751 pc
+= __GLX_VENDPRIV_HDR_SIZE
;
4755 retval
= IsRenderbuffer(*(GLuint
*) (pc
+ 0));
4756 __glXSendReply(cl
->client
, dummy_answer
, 0, 0, GL_FALSE
, retval
);
4764 __glXDisp_RenderbufferStorage(GLbyte
* pc
)
4766 PFNGLRENDERBUFFERSTORAGEPROC RenderbufferStorage
=
4767 __glGetProcAddress("glRenderbufferStorage");
4768 RenderbufferStorage(*(GLenum
*) (pc
+ 0), *(GLenum
*) (pc
+ 4),
4769 *(GLsizei
*) (pc
+ 8), *(GLsizei
*) (pc
+ 12));
4773 __glXDisp_RenderbufferStorageMultisample(GLbyte
* pc
)
4775 PFNGLRENDERBUFFERSTORAGEMULTISAMPLEPROC RenderbufferStorageMultisample
=
4776 __glGetProcAddress("glRenderbufferStorageMultisample");
4777 RenderbufferStorageMultisample(*(GLenum
*) (pc
+ 0), *(GLsizei
*) (pc
+ 4),
4778 *(GLenum
*) (pc
+ 8), *(GLsizei
*) (pc
+ 12),
4779 *(GLsizei
*) (pc
+ 16));
4783 __glXDisp_SecondaryColor3fvEXT(GLbyte
* pc
)
4785 PFNGLSECONDARYCOLOR3FVEXTPROC SecondaryColor3fvEXT
=
4786 __glGetProcAddress("glSecondaryColor3fvEXT");
4787 SecondaryColor3fvEXT((const GLfloat
*) (pc
+ 0));
4791 __glXDisp_FogCoordfvEXT(GLbyte
* pc
)
4793 PFNGLFOGCOORDFVEXTPROC FogCoordfvEXT
=
4794 __glGetProcAddress("glFogCoordfvEXT");
4795 FogCoordfvEXT((const GLfloat
*) (pc
+ 0));
4799 __glXDisp_VertexAttrib1dvNV(GLbyte
* pc
)
4801 PFNGLVERTEXATTRIB1DVNVPROC VertexAttrib1dvNV
=
4802 __glGetProcAddress("glVertexAttrib1dvNV");
4803 #ifdef __GLX_ALIGN64
4804 if ((unsigned long) (pc
) & 7) {
4805 (void) memmove(pc
- 4, pc
, 12);
4810 VertexAttrib1dvNV(*(GLuint
*) (pc
+ 0), (const GLdouble
*) (pc
+ 4));
4814 __glXDisp_VertexAttrib1fvNV(GLbyte
* pc
)
4816 PFNGLVERTEXATTRIB1FVNVPROC VertexAttrib1fvNV
=
4817 __glGetProcAddress("glVertexAttrib1fvNV");
4818 VertexAttrib1fvNV(*(GLuint
*) (pc
+ 0), (const GLfloat
*) (pc
+ 4));
4822 __glXDisp_VertexAttrib1svNV(GLbyte
* pc
)
4824 PFNGLVERTEXATTRIB1SVNVPROC VertexAttrib1svNV
=
4825 __glGetProcAddress("glVertexAttrib1svNV");
4826 VertexAttrib1svNV(*(GLuint
*) (pc
+ 0), (const GLshort
*) (pc
+ 4));
4830 __glXDisp_VertexAttrib2dvNV(GLbyte
* pc
)
4832 PFNGLVERTEXATTRIB2DVNVPROC VertexAttrib2dvNV
=
4833 __glGetProcAddress("glVertexAttrib2dvNV");
4834 #ifdef __GLX_ALIGN64
4835 if ((unsigned long) (pc
) & 7) {
4836 (void) memmove(pc
- 4, pc
, 20);
4841 VertexAttrib2dvNV(*(GLuint
*) (pc
+ 0), (const GLdouble
*) (pc
+ 4));
4845 __glXDisp_VertexAttrib2fvNV(GLbyte
* pc
)
4847 PFNGLVERTEXATTRIB2FVNVPROC VertexAttrib2fvNV
=
4848 __glGetProcAddress("glVertexAttrib2fvNV");
4849 VertexAttrib2fvNV(*(GLuint
*) (pc
+ 0), (const GLfloat
*) (pc
+ 4));
4853 __glXDisp_VertexAttrib2svNV(GLbyte
* pc
)
4855 PFNGLVERTEXATTRIB2SVNVPROC VertexAttrib2svNV
=
4856 __glGetProcAddress("glVertexAttrib2svNV");
4857 VertexAttrib2svNV(*(GLuint
*) (pc
+ 0), (const GLshort
*) (pc
+ 4));
4861 __glXDisp_VertexAttrib3dvNV(GLbyte
* pc
)
4863 PFNGLVERTEXATTRIB3DVNVPROC VertexAttrib3dvNV
=
4864 __glGetProcAddress("glVertexAttrib3dvNV");
4865 #ifdef __GLX_ALIGN64
4866 if ((unsigned long) (pc
) & 7) {
4867 (void) memmove(pc
- 4, pc
, 28);
4872 VertexAttrib3dvNV(*(GLuint
*) (pc
+ 0), (const GLdouble
*) (pc
+ 4));
4876 __glXDisp_VertexAttrib3fvNV(GLbyte
* pc
)
4878 PFNGLVERTEXATTRIB3FVNVPROC VertexAttrib3fvNV
=
4879 __glGetProcAddress("glVertexAttrib3fvNV");
4880 VertexAttrib3fvNV(*(GLuint
*) (pc
+ 0), (const GLfloat
*) (pc
+ 4));
4884 __glXDisp_VertexAttrib3svNV(GLbyte
* pc
)
4886 PFNGLVERTEXATTRIB3SVNVPROC VertexAttrib3svNV
=
4887 __glGetProcAddress("glVertexAttrib3svNV");
4888 VertexAttrib3svNV(*(GLuint
*) (pc
+ 0), (const GLshort
*) (pc
+ 4));
4892 __glXDisp_VertexAttrib4dvNV(GLbyte
* pc
)
4894 PFNGLVERTEXATTRIB4DVNVPROC VertexAttrib4dvNV
=
4895 __glGetProcAddress("glVertexAttrib4dvNV");
4896 #ifdef __GLX_ALIGN64
4897 if ((unsigned long) (pc
) & 7) {
4898 (void) memmove(pc
- 4, pc
, 36);
4903 VertexAttrib4dvNV(*(GLuint
*) (pc
+ 0), (const GLdouble
*) (pc
+ 4));
4907 __glXDisp_VertexAttrib4fvNV(GLbyte
* pc
)
4909 PFNGLVERTEXATTRIB4FVNVPROC VertexAttrib4fvNV
=
4910 __glGetProcAddress("glVertexAttrib4fvNV");
4911 VertexAttrib4fvNV(*(GLuint
*) (pc
+ 0), (const GLfloat
*) (pc
+ 4));
4915 __glXDisp_VertexAttrib4svNV(GLbyte
* pc
)
4917 PFNGLVERTEXATTRIB4SVNVPROC VertexAttrib4svNV
=
4918 __glGetProcAddress("glVertexAttrib4svNV");
4919 VertexAttrib4svNV(*(GLuint
*) (pc
+ 0), (const GLshort
*) (pc
+ 4));
4923 __glXDisp_VertexAttrib4ubvNV(GLbyte
* pc
)
4925 PFNGLVERTEXATTRIB4UBVNVPROC VertexAttrib4ubvNV
=
4926 __glGetProcAddress("glVertexAttrib4ubvNV");
4927 VertexAttrib4ubvNV(*(GLuint
*) (pc
+ 0), (const GLubyte
*) (pc
+ 4));
4931 __glXDisp_VertexAttribs1dvNV(GLbyte
* pc
)
4933 PFNGLVERTEXATTRIBS1DVNVPROC VertexAttribs1dvNV
=
4934 __glGetProcAddress("glVertexAttribs1dvNV");
4935 const GLsizei n
= *(GLsizei
*) (pc
+ 4);
4937 #ifdef __GLX_ALIGN64
4938 const GLuint cmdlen
= 12 + __GLX_PAD((n
* 8)) - 4;
4940 if ((unsigned long) (pc
) & 7) {
4941 (void) memmove(pc
- 4, pc
, cmdlen
);
4946 VertexAttribs1dvNV(*(GLuint
*) (pc
+ 0), n
, (const GLdouble
*) (pc
+ 8));
4950 __glXDisp_VertexAttribs1fvNV(GLbyte
* pc
)
4952 PFNGLVERTEXATTRIBS1FVNVPROC VertexAttribs1fvNV
=
4953 __glGetProcAddress("glVertexAttribs1fvNV");
4954 const GLsizei n
= *(GLsizei
*) (pc
+ 4);
4956 VertexAttribs1fvNV(*(GLuint
*) (pc
+ 0), n
, (const GLfloat
*) (pc
+ 8));
4960 __glXDisp_VertexAttribs1svNV(GLbyte
* pc
)
4962 PFNGLVERTEXATTRIBS1SVNVPROC VertexAttribs1svNV
=
4963 __glGetProcAddress("glVertexAttribs1svNV");
4964 const GLsizei n
= *(GLsizei
*) (pc
+ 4);
4966 VertexAttribs1svNV(*(GLuint
*) (pc
+ 0), n
, (const GLshort
*) (pc
+ 8));
4970 __glXDisp_VertexAttribs2dvNV(GLbyte
* pc
)
4972 PFNGLVERTEXATTRIBS2DVNVPROC VertexAttribs2dvNV
=
4973 __glGetProcAddress("glVertexAttribs2dvNV");
4974 const GLsizei n
= *(GLsizei
*) (pc
+ 4);
4976 #ifdef __GLX_ALIGN64
4977 const GLuint cmdlen
= 12 + __GLX_PAD((n
* 16)) - 4;
4979 if ((unsigned long) (pc
) & 7) {
4980 (void) memmove(pc
- 4, pc
, cmdlen
);
4985 VertexAttribs2dvNV(*(GLuint
*) (pc
+ 0), n
, (const GLdouble
*) (pc
+ 8));
4989 __glXDisp_VertexAttribs2fvNV(GLbyte
* pc
)
4991 PFNGLVERTEXATTRIBS2FVNVPROC VertexAttribs2fvNV
=
4992 __glGetProcAddress("glVertexAttribs2fvNV");
4993 const GLsizei n
= *(GLsizei
*) (pc
+ 4);
4995 VertexAttribs2fvNV(*(GLuint
*) (pc
+ 0), n
, (const GLfloat
*) (pc
+ 8));
4999 __glXDisp_VertexAttribs2svNV(GLbyte
* pc
)
5001 PFNGLVERTEXATTRIBS2SVNVPROC VertexAttribs2svNV
=
5002 __glGetProcAddress("glVertexAttribs2svNV");
5003 const GLsizei n
= *(GLsizei
*) (pc
+ 4);
5005 VertexAttribs2svNV(*(GLuint
*) (pc
+ 0), n
, (const GLshort
*) (pc
+ 8));
5009 __glXDisp_VertexAttribs3dvNV(GLbyte
* pc
)
5011 PFNGLVERTEXATTRIBS3DVNVPROC VertexAttribs3dvNV
=
5012 __glGetProcAddress("glVertexAttribs3dvNV");
5013 const GLsizei n
= *(GLsizei
*) (pc
+ 4);
5015 #ifdef __GLX_ALIGN64
5016 const GLuint cmdlen
= 12 + __GLX_PAD((n
* 24)) - 4;
5018 if ((unsigned long) (pc
) & 7) {
5019 (void) memmove(pc
- 4, pc
, cmdlen
);
5024 VertexAttribs3dvNV(*(GLuint
*) (pc
+ 0), n
, (const GLdouble
*) (pc
+ 8));
5028 __glXDisp_VertexAttribs3fvNV(GLbyte
* pc
)
5030 PFNGLVERTEXATTRIBS3FVNVPROC VertexAttribs3fvNV
=
5031 __glGetProcAddress("glVertexAttribs3fvNV");
5032 const GLsizei n
= *(GLsizei
*) (pc
+ 4);
5034 VertexAttribs3fvNV(*(GLuint
*) (pc
+ 0), n
, (const GLfloat
*) (pc
+ 8));
5038 __glXDisp_VertexAttribs3svNV(GLbyte
* pc
)
5040 PFNGLVERTEXATTRIBS3SVNVPROC VertexAttribs3svNV
=
5041 __glGetProcAddress("glVertexAttribs3svNV");
5042 const GLsizei n
= *(GLsizei
*) (pc
+ 4);
5044 VertexAttribs3svNV(*(GLuint
*) (pc
+ 0), n
, (const GLshort
*) (pc
+ 8));
5048 __glXDisp_VertexAttribs4dvNV(GLbyte
* pc
)
5050 PFNGLVERTEXATTRIBS4DVNVPROC VertexAttribs4dvNV
=
5051 __glGetProcAddress("glVertexAttribs4dvNV");
5052 const GLsizei n
= *(GLsizei
*) (pc
+ 4);
5054 #ifdef __GLX_ALIGN64
5055 const GLuint cmdlen
= 12 + __GLX_PAD((n
* 32)) - 4;
5057 if ((unsigned long) (pc
) & 7) {
5058 (void) memmove(pc
- 4, pc
, cmdlen
);
5063 VertexAttribs4dvNV(*(GLuint
*) (pc
+ 0), n
, (const GLdouble
*) (pc
+ 8));
5067 __glXDisp_VertexAttribs4fvNV(GLbyte
* pc
)
5069 PFNGLVERTEXATTRIBS4FVNVPROC VertexAttribs4fvNV
=
5070 __glGetProcAddress("glVertexAttribs4fvNV");
5071 const GLsizei n
= *(GLsizei
*) (pc
+ 4);
5073 VertexAttribs4fvNV(*(GLuint
*) (pc
+ 0), n
, (const GLfloat
*) (pc
+ 8));
5077 __glXDisp_VertexAttribs4svNV(GLbyte
* pc
)
5079 PFNGLVERTEXATTRIBS4SVNVPROC VertexAttribs4svNV
=
5080 __glGetProcAddress("glVertexAttribs4svNV");
5081 const GLsizei n
= *(GLsizei
*) (pc
+ 4);
5083 VertexAttribs4svNV(*(GLuint
*) (pc
+ 0), n
, (const GLshort
*) (pc
+ 8));
5087 __glXDisp_VertexAttribs4ubvNV(GLbyte
* pc
)
5089 PFNGLVERTEXATTRIBS4UBVNVPROC VertexAttribs4ubvNV
=
5090 __glGetProcAddress("glVertexAttribs4ubvNV");
5091 const GLsizei n
= *(GLsizei
*) (pc
+ 4);
5093 VertexAttribs4ubvNV(*(GLuint
*) (pc
+ 0), n
, (const GLubyte
*) (pc
+ 8));
5097 __glXDisp_ActiveStencilFaceEXT(GLbyte
* pc
)
5099 PFNGLACTIVESTENCILFACEEXTPROC ActiveStencilFaceEXT
=
5100 __glGetProcAddress("glActiveStencilFaceEXT");
5101 ActiveStencilFaceEXT(*(GLenum
*) (pc
+ 0));