1 /* DO NOT EDIT - This file generated automatically by glX_proto_send.py (from Mesa) script */
4 * (C) Copyright IBM Corporation 2004, 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
31 #include "glxclient.h"
32 #include "indirect_size.h"
33 #include "glapitable.h"
34 #include "glapidispatch.h"
37 #include <GL/glxproto.h>
39 #include <X11/Xlib-xcb.h>
44 #define __GLX_PAD(n) (((n) + 3) & ~3)
46 # if defined(__i386__) && defined(__GNUC__) && !defined(__CYGWIN__) && !defined(__MINGW32__)
47 # define FASTCALL __attribute__((fastcall))
51 # if defined(__GNUC__) || (defined(__SUNPRO_C) && (__SUNPRO_C >= 0x590))
52 # define NOINLINE __attribute__((noinline))
57 #if !defined __GNUC__ || __GNUC__ < 3
58 # define __builtin_expect(x, y) x
61 /* If the size and opcode values are known at compile-time, this will, on
62 * x86 at least, emit them with a single instruction.
64 #define emit_header(dest, op, size) \
65 do { union { short s[2]; int i; } temp; \
66 temp.s[0] = (size); temp.s[1] = (op); \
67 *((int *)(dest)) = temp.i; } while(0)
70 __glXReadReply(Display
* dpy
, size_t size
, void *dest
,
71 GLboolean reply_is_always_array
)
73 xGLXSingleReply reply
;
75 (void) _XReply(dpy
, (xReply
*) & reply
, 0, False
);
77 if ((reply
.length
> 0) || reply_is_always_array
) {
78 const GLint bytes
= (reply_is_always_array
)
79 ? (4 * reply
.length
) : (reply
.size
* size
);
80 const GLint extra
= 4 - (bytes
& 3);
82 _XRead(dpy
, dest
, bytes
);
84 _XEatData(dpy
, extra
);
87 (void) memcpy(dest
, &(reply
.pad3
), size
);
95 __glXReadPixelReply(Display
* dpy
, __GLXcontext
* gc
, unsigned max_dim
,
96 GLint width
, GLint height
, GLint depth
, GLenum format
,
97 GLenum type
, void *dest
, GLboolean dimensions_in_reply
)
99 xGLXSingleReply reply
;
102 (void) _XReply(dpy
, (xReply
*) & reply
, 0, False
);
104 if (dimensions_in_reply
) {
109 if ((height
== 0) || (max_dim
< 2)) {
112 if ((depth
== 0) || (max_dim
< 3)) {
117 size
= reply
.length
* 4;
119 void *buf
= Xmalloc(size
);
122 _XEatData(dpy
, size
);
123 __glXSetError(gc
, GL_OUT_OF_MEMORY
);
125 const GLint extra
= 4 - (size
& 3);
127 _XRead(dpy
, buf
, size
);
129 _XEatData(dpy
, extra
);
132 __glEmptyImage(gc
, 3, width
, height
, depth
, format
, type
,
139 #define X_GLXSingle 0
141 NOINLINE FASTCALL GLubyte
*
142 __glXSetupSingleRequest(__GLXcontext
* gc
, GLint sop
, GLint cmdlen
)
145 Display
*const dpy
= gc
->currentDpy
;
147 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
149 GetReqExtra(GLXSingle
, cmdlen
, req
);
150 req
->reqType
= gc
->majorOpcode
;
151 req
->contextTag
= gc
->currentContextTag
;
153 return (GLubyte
*) (req
) + sz_xGLXSingleReq
;
156 NOINLINE FASTCALL GLubyte
*
157 __glXSetupVendorRequest(__GLXcontext
* gc
, GLint code
, GLint vop
,
160 xGLXVendorPrivateReq
*req
;
161 Display
*const dpy
= gc
->currentDpy
;
163 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
165 GetReqExtra(GLXVendorPrivate
, cmdlen
, req
);
166 req
->reqType
= gc
->majorOpcode
;
168 req
->vendorCode
= vop
;
169 req
->contextTag
= gc
->currentContextTag
;
170 return (GLubyte
*) (req
) + sz_xGLXVendorPrivateReq
;
173 const GLuint __glXDefaultPixelStore
[9] = { 0, 0, 0, 0, 0, 0, 0, 0, 1 };
175 #define zero (__glXDefaultPixelStore+0)
176 #define one (__glXDefaultPixelStore+8)
177 #define default_pixel_store_1D (__glXDefaultPixelStore+4)
178 #define default_pixel_store_1D_size 20
179 #define default_pixel_store_2D (__glXDefaultPixelStore+4)
180 #define default_pixel_store_2D_size 20
181 #define default_pixel_store_3D (__glXDefaultPixelStore+0)
182 #define default_pixel_store_3D_size 36
183 #define default_pixel_store_4D (__glXDefaultPixelStore+0)
184 #define default_pixel_store_4D_size 36
186 static FASTCALL NOINLINE
void
187 generic_3_byte(GLint rop
, const void *ptr
)
189 __GLXcontext
*const gc
= __glXGetCurrentContext();
190 const GLuint cmdlen
= 8;
192 emit_header(gc
->pc
, rop
, cmdlen
);
193 (void) memcpy((void *) (gc
->pc
+ 4), ptr
, 4);
195 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
196 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
200 static FASTCALL NOINLINE
void
201 generic_4_byte(GLint rop
, const void *ptr
)
203 __GLXcontext
*const gc
= __glXGetCurrentContext();
204 const GLuint cmdlen
= 8;
206 emit_header(gc
->pc
, rop
, cmdlen
);
207 (void) memcpy((void *) (gc
->pc
+ 4), ptr
, 4);
209 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
210 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
214 static FASTCALL NOINLINE
void
215 generic_6_byte(GLint rop
, const void *ptr
)
217 __GLXcontext
*const gc
= __glXGetCurrentContext();
218 const GLuint cmdlen
= 12;
220 emit_header(gc
->pc
, rop
, cmdlen
);
221 (void) memcpy((void *) (gc
->pc
+ 4), ptr
, 8);
223 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
224 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
228 static FASTCALL NOINLINE
void
229 generic_8_byte(GLint rop
, const void *ptr
)
231 __GLXcontext
*const gc
= __glXGetCurrentContext();
232 const GLuint cmdlen
= 12;
234 emit_header(gc
->pc
, rop
, cmdlen
);
235 (void) memcpy((void *) (gc
->pc
+ 4), ptr
, 8);
237 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
238 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
242 static FASTCALL NOINLINE
void
243 generic_12_byte(GLint rop
, const void *ptr
)
245 __GLXcontext
*const gc
= __glXGetCurrentContext();
246 const GLuint cmdlen
= 16;
248 emit_header(gc
->pc
, rop
, cmdlen
);
249 (void) memcpy((void *) (gc
->pc
+ 4), ptr
, 12);
251 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
252 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
256 static FASTCALL NOINLINE
void
257 generic_16_byte(GLint rop
, const void *ptr
)
259 __GLXcontext
*const gc
= __glXGetCurrentContext();
260 const GLuint cmdlen
= 20;
262 emit_header(gc
->pc
, rop
, cmdlen
);
263 (void) memcpy((void *) (gc
->pc
+ 4), ptr
, 16);
265 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
266 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
270 static FASTCALL NOINLINE
void
271 generic_24_byte(GLint rop
, const void *ptr
)
273 __GLXcontext
*const gc
= __glXGetCurrentContext();
274 const GLuint cmdlen
= 28;
276 emit_header(gc
->pc
, rop
, cmdlen
);
277 (void) memcpy((void *) (gc
->pc
+ 4), ptr
, 24);
279 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
280 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
284 static FASTCALL NOINLINE
void
285 generic_32_byte(GLint rop
, const void *ptr
)
287 __GLXcontext
*const gc
= __glXGetCurrentContext();
288 const GLuint cmdlen
= 36;
290 emit_header(gc
->pc
, rop
, cmdlen
);
291 (void) memcpy((void *) (gc
->pc
+ 4), ptr
, 32);
293 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
294 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
298 #define X_GLsop_NewList 101
300 __indirect_glNewList(GLuint list
, GLenum mode
)
302 __GLXcontext
*const gc
= __glXGetCurrentContext();
303 Display
*const dpy
= gc
->currentDpy
;
305 const GLuint cmdlen
= 8;
307 if (__builtin_expect(dpy
!= NULL
, 1)) {
309 xcb_connection_t
*c
= XGetXCBConnection(dpy
);
310 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
311 xcb_glx_new_list(c
, gc
->currentContextTag
, list
, mode
);
314 __glXSetupSingleRequest(gc
, X_GLsop_NewList
, cmdlen
);
315 (void) memcpy((void *) (pc
+ 0), (void *) (&list
), 4);
316 (void) memcpy((void *) (pc
+ 4), (void *) (&mode
), 4);
324 #define X_GLsop_EndList 102
326 __indirect_glEndList(void)
328 __GLXcontext
*const gc
= __glXGetCurrentContext();
329 Display
*const dpy
= gc
->currentDpy
;
331 const GLuint cmdlen
= 0;
333 if (__builtin_expect(dpy
!= NULL
, 1)) {
335 xcb_connection_t
*c
= XGetXCBConnection(dpy
);
336 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
337 xcb_glx_end_list(c
, gc
->currentContextTag
);
339 (void) __glXSetupSingleRequest(gc
, X_GLsop_EndList
, cmdlen
);
347 #define X_GLrop_CallList 1
349 __indirect_glCallList(GLuint list
)
351 __GLXcontext
*const gc
= __glXGetCurrentContext();
352 const GLuint cmdlen
= 8;
353 emit_header(gc
->pc
, X_GLrop_CallList
, cmdlen
);
354 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&list
), 4);
356 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
357 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
361 #define X_GLrop_CallLists 2
363 __indirect_glCallLists(GLsizei n
, GLenum type
, const GLvoid
* lists
)
365 __GLXcontext
*const gc
= __glXGetCurrentContext();
366 const GLuint compsize
= __glCallLists_size(type
);
367 const GLuint cmdlen
= 12 + __GLX_PAD((compsize
* n
));
369 __glXSetError(gc
, GL_INVALID_VALUE
);
372 if (__builtin_expect((n
>= 0) && (gc
->currentDpy
!= NULL
), 1)) {
373 if (cmdlen
<= gc
->maxSmallRenderCommandSize
) {
374 if ((gc
->pc
+ cmdlen
) > gc
->bufEnd
) {
375 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
377 emit_header(gc
->pc
, X_GLrop_CallLists
, cmdlen
);
378 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&n
), 4);
379 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&type
), 4);
380 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (lists
),
383 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
384 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
387 const GLint op
= X_GLrop_CallLists
;
388 const GLuint cmdlenLarge
= cmdlen
+ 4;
389 GLubyte
*const pc
= __glXFlushRenderBuffer(gc
, gc
->pc
);
390 (void) memcpy((void *) (pc
+ 0), (void *) (&cmdlenLarge
), 4);
391 (void) memcpy((void *) (pc
+ 4), (void *) (&op
), 4);
392 (void) memcpy((void *) (pc
+ 8), (void *) (&n
), 4);
393 (void) memcpy((void *) (pc
+ 12), (void *) (&type
), 4);
394 __glXSendLargeCommand(gc
, pc
, 16, lists
, (compsize
* n
));
399 #define X_GLsop_DeleteLists 103
401 __indirect_glDeleteLists(GLuint list
, GLsizei range
)
403 __GLXcontext
*const gc
= __glXGetCurrentContext();
404 Display
*const dpy
= gc
->currentDpy
;
406 const GLuint cmdlen
= 8;
408 if (__builtin_expect(dpy
!= NULL
, 1)) {
410 xcb_connection_t
*c
= XGetXCBConnection(dpy
);
411 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
412 xcb_glx_delete_lists(c
, gc
->currentContextTag
, list
, range
);
415 __glXSetupSingleRequest(gc
, X_GLsop_DeleteLists
, cmdlen
);
416 (void) memcpy((void *) (pc
+ 0), (void *) (&list
), 4);
417 (void) memcpy((void *) (pc
+ 4), (void *) (&range
), 4);
425 #define X_GLsop_GenLists 104
427 __indirect_glGenLists(GLsizei range
)
429 __GLXcontext
*const gc
= __glXGetCurrentContext();
430 Display
*const dpy
= gc
->currentDpy
;
431 GLuint retval
= (GLuint
) 0;
433 const GLuint cmdlen
= 4;
435 if (__builtin_expect(dpy
!= NULL
, 1)) {
437 xcb_connection_t
*c
= XGetXCBConnection(dpy
);
438 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
439 xcb_glx_gen_lists_reply_t
*reply
=
440 xcb_glx_gen_lists_reply(c
,
442 gc
->currentContextTag
,
444 retval
= reply
->ret_val
;
448 __glXSetupSingleRequest(gc
, X_GLsop_GenLists
, cmdlen
);
449 (void) memcpy((void *) (pc
+ 0), (void *) (&range
), 4);
450 retval
= (GLuint
) __glXReadReply(dpy
, 0, NULL
, GL_FALSE
);
458 #define X_GLrop_ListBase 3
460 __indirect_glListBase(GLuint base
)
462 __GLXcontext
*const gc
= __glXGetCurrentContext();
463 const GLuint cmdlen
= 8;
464 emit_header(gc
->pc
, X_GLrop_ListBase
, cmdlen
);
465 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&base
), 4);
467 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
468 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
472 #define X_GLrop_Begin 4
474 __indirect_glBegin(GLenum mode
)
476 __GLXcontext
*const gc
= __glXGetCurrentContext();
477 const GLuint cmdlen
= 8;
478 emit_header(gc
->pc
, X_GLrop_Begin
, cmdlen
);
479 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&mode
), 4);
481 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
482 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
486 #define X_GLrop_Bitmap 5
488 __indirect_glBitmap(GLsizei width
, GLsizei height
, GLfloat xorig
,
489 GLfloat yorig
, GLfloat xmove
, GLfloat ymove
,
490 const GLubyte
*bitmap
)
492 __GLXcontext
*const gc
= __glXGetCurrentContext();
493 const GLuint compsize
=
494 (bitmap
!= NULL
) ? __glImageSize(width
, height
, 1, GL_COLOR_INDEX
,
496 const GLuint cmdlen
= 48 + __GLX_PAD(compsize
);
497 if (__builtin_expect(gc
->currentDpy
!= NULL
, 1)) {
498 if (cmdlen
<= gc
->maxSmallRenderCommandSize
) {
499 if ((gc
->pc
+ cmdlen
) > gc
->bufEnd
) {
500 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
502 emit_header(gc
->pc
, X_GLrop_Bitmap
, cmdlen
);
503 (void) memcpy((void *) (gc
->pc
+ 24), (void *) (&width
), 4);
504 (void) memcpy((void *) (gc
->pc
+ 28), (void *) (&height
), 4);
505 (void) memcpy((void *) (gc
->pc
+ 32), (void *) (&xorig
), 4);
506 (void) memcpy((void *) (gc
->pc
+ 36), (void *) (&yorig
), 4);
507 (void) memcpy((void *) (gc
->pc
+ 40), (void *) (&xmove
), 4);
508 (void) memcpy((void *) (gc
->pc
+ 44), (void *) (&ymove
), 4);
510 (*gc
->fillImage
) (gc
, 2, width
, height
, 1, GL_COLOR_INDEX
,
511 GL_BITMAP
, bitmap
, gc
->pc
+ 48, gc
->pc
+ 4);
513 (void) memcpy(gc
->pc
+ 4, default_pixel_store_2D
,
514 default_pixel_store_2D_size
);
517 if (gc
->pc
> gc
->limit
) {
518 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
521 const GLint op
= X_GLrop_Bitmap
;
522 const GLuint cmdlenLarge
= cmdlen
+ 4;
523 GLubyte
*const pc
= __glXFlushRenderBuffer(gc
, gc
->pc
);
524 (void) memcpy((void *) (pc
+ 0), (void *) (&cmdlenLarge
), 4);
525 (void) memcpy((void *) (pc
+ 4), (void *) (&op
), 4);
526 (void) memcpy((void *) (pc
+ 28), (void *) (&width
), 4);
527 (void) memcpy((void *) (pc
+ 32), (void *) (&height
), 4);
528 (void) memcpy((void *) (pc
+ 36), (void *) (&xorig
), 4);
529 (void) memcpy((void *) (pc
+ 40), (void *) (&yorig
), 4);
530 (void) memcpy((void *) (pc
+ 44), (void *) (&xmove
), 4);
531 (void) memcpy((void *) (pc
+ 48), (void *) (&ymove
), 4);
532 __glXSendLargeImage(gc
, compsize
, 2, width
, height
, 1,
533 GL_COLOR_INDEX
, GL_BITMAP
, bitmap
, pc
+ 52,
539 #define X_GLrop_Color3bv 6
541 __indirect_glColor3b(GLbyte red
, GLbyte green
, GLbyte blue
)
543 __GLXcontext
*const gc
= __glXGetCurrentContext();
544 const GLuint cmdlen
= 8;
545 emit_header(gc
->pc
, X_GLrop_Color3bv
, cmdlen
);
546 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&red
), 1);
547 (void) memcpy((void *) (gc
->pc
+ 5), (void *) (&green
), 1);
548 (void) memcpy((void *) (gc
->pc
+ 6), (void *) (&blue
), 1);
550 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
551 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
555 #define X_GLrop_Color3bv 6
557 __indirect_glColor3bv(const GLbyte
*v
)
559 generic_3_byte(X_GLrop_Color3bv
, v
);
562 #define X_GLrop_Color3dv 7
564 __indirect_glColor3d(GLdouble red
, GLdouble green
, GLdouble blue
)
566 __GLXcontext
*const gc
= __glXGetCurrentContext();
567 const GLuint cmdlen
= 28;
568 emit_header(gc
->pc
, X_GLrop_Color3dv
, cmdlen
);
569 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&red
), 8);
570 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&green
), 8);
571 (void) memcpy((void *) (gc
->pc
+ 20), (void *) (&blue
), 8);
573 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
574 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
578 #define X_GLrop_Color3dv 7
580 __indirect_glColor3dv(const GLdouble
* v
)
582 generic_24_byte(X_GLrop_Color3dv
, v
);
585 #define X_GLrop_Color3fv 8
587 __indirect_glColor3f(GLfloat red
, GLfloat green
, GLfloat blue
)
589 __GLXcontext
*const gc
= __glXGetCurrentContext();
590 const GLuint cmdlen
= 16;
591 emit_header(gc
->pc
, X_GLrop_Color3fv
, cmdlen
);
592 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&red
), 4);
593 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&green
), 4);
594 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&blue
), 4);
596 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
597 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
601 #define X_GLrop_Color3fv 8
603 __indirect_glColor3fv(const GLfloat
* v
)
605 generic_12_byte(X_GLrop_Color3fv
, v
);
608 #define X_GLrop_Color3iv 9
610 __indirect_glColor3i(GLint red
, GLint green
, GLint blue
)
612 __GLXcontext
*const gc
= __glXGetCurrentContext();
613 const GLuint cmdlen
= 16;
614 emit_header(gc
->pc
, X_GLrop_Color3iv
, cmdlen
);
615 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&red
), 4);
616 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&green
), 4);
617 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&blue
), 4);
619 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
620 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
624 #define X_GLrop_Color3iv 9
626 __indirect_glColor3iv(const GLint
* v
)
628 generic_12_byte(X_GLrop_Color3iv
, v
);
631 #define X_GLrop_Color3sv 10
633 __indirect_glColor3s(GLshort red
, GLshort green
, GLshort blue
)
635 __GLXcontext
*const gc
= __glXGetCurrentContext();
636 const GLuint cmdlen
= 12;
637 emit_header(gc
->pc
, X_GLrop_Color3sv
, cmdlen
);
638 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&red
), 2);
639 (void) memcpy((void *) (gc
->pc
+ 6), (void *) (&green
), 2);
640 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&blue
), 2);
642 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
643 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
647 #define X_GLrop_Color3sv 10
649 __indirect_glColor3sv(const GLshort
* v
)
651 generic_6_byte(X_GLrop_Color3sv
, v
);
654 #define X_GLrop_Color3ubv 11
656 __indirect_glColor3ub(GLubyte red
, GLubyte green
, GLubyte blue
)
658 __GLXcontext
*const gc
= __glXGetCurrentContext();
659 const GLuint cmdlen
= 8;
660 emit_header(gc
->pc
, X_GLrop_Color3ubv
, cmdlen
);
661 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&red
), 1);
662 (void) memcpy((void *) (gc
->pc
+ 5), (void *) (&green
), 1);
663 (void) memcpy((void *) (gc
->pc
+ 6), (void *) (&blue
), 1);
665 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
666 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
670 #define X_GLrop_Color3ubv 11
672 __indirect_glColor3ubv(const GLubyte
*v
)
674 generic_3_byte(X_GLrop_Color3ubv
, v
);
677 #define X_GLrop_Color3uiv 12
679 __indirect_glColor3ui(GLuint red
, GLuint green
, GLuint blue
)
681 __GLXcontext
*const gc
= __glXGetCurrentContext();
682 const GLuint cmdlen
= 16;
683 emit_header(gc
->pc
, X_GLrop_Color3uiv
, cmdlen
);
684 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&red
), 4);
685 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&green
), 4);
686 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&blue
), 4);
688 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
689 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
693 #define X_GLrop_Color3uiv 12
695 __indirect_glColor3uiv(const GLuint
* v
)
697 generic_12_byte(X_GLrop_Color3uiv
, v
);
700 #define X_GLrop_Color3usv 13
702 __indirect_glColor3us(GLushort red
, GLushort green
, GLushort blue
)
704 __GLXcontext
*const gc
= __glXGetCurrentContext();
705 const GLuint cmdlen
= 12;
706 emit_header(gc
->pc
, X_GLrop_Color3usv
, cmdlen
);
707 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&red
), 2);
708 (void) memcpy((void *) (gc
->pc
+ 6), (void *) (&green
), 2);
709 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&blue
), 2);
711 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
712 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
716 #define X_GLrop_Color3usv 13
718 __indirect_glColor3usv(const GLushort
* v
)
720 generic_6_byte(X_GLrop_Color3usv
, v
);
723 #define X_GLrop_Color4bv 14
725 __indirect_glColor4b(GLbyte red
, GLbyte green
, GLbyte blue
, GLbyte alpha
)
727 __GLXcontext
*const gc
= __glXGetCurrentContext();
728 const GLuint cmdlen
= 8;
729 emit_header(gc
->pc
, X_GLrop_Color4bv
, cmdlen
);
730 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&red
), 1);
731 (void) memcpy((void *) (gc
->pc
+ 5), (void *) (&green
), 1);
732 (void) memcpy((void *) (gc
->pc
+ 6), (void *) (&blue
), 1);
733 (void) memcpy((void *) (gc
->pc
+ 7), (void *) (&alpha
), 1);
735 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
736 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
740 #define X_GLrop_Color4bv 14
742 __indirect_glColor4bv(const GLbyte
*v
)
744 generic_4_byte(X_GLrop_Color4bv
, v
);
747 #define X_GLrop_Color4dv 15
749 __indirect_glColor4d(GLdouble red
, GLdouble green
, GLdouble blue
,
752 __GLXcontext
*const gc
= __glXGetCurrentContext();
753 const GLuint cmdlen
= 36;
754 emit_header(gc
->pc
, X_GLrop_Color4dv
, cmdlen
);
755 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&red
), 8);
756 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&green
), 8);
757 (void) memcpy((void *) (gc
->pc
+ 20), (void *) (&blue
), 8);
758 (void) memcpy((void *) (gc
->pc
+ 28), (void *) (&alpha
), 8);
760 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
761 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
765 #define X_GLrop_Color4dv 15
767 __indirect_glColor4dv(const GLdouble
* v
)
769 generic_32_byte(X_GLrop_Color4dv
, v
);
772 #define X_GLrop_Color4fv 16
774 __indirect_glColor4f(GLfloat red
, GLfloat green
, GLfloat blue
, GLfloat alpha
)
776 __GLXcontext
*const gc
= __glXGetCurrentContext();
777 const GLuint cmdlen
= 20;
778 emit_header(gc
->pc
, X_GLrop_Color4fv
, cmdlen
);
779 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&red
), 4);
780 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&green
), 4);
781 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&blue
), 4);
782 (void) memcpy((void *) (gc
->pc
+ 16), (void *) (&alpha
), 4);
784 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
785 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
789 #define X_GLrop_Color4fv 16
791 __indirect_glColor4fv(const GLfloat
* v
)
793 generic_16_byte(X_GLrop_Color4fv
, v
);
796 #define X_GLrop_Color4iv 17
798 __indirect_glColor4i(GLint red
, GLint green
, GLint blue
, GLint alpha
)
800 __GLXcontext
*const gc
= __glXGetCurrentContext();
801 const GLuint cmdlen
= 20;
802 emit_header(gc
->pc
, X_GLrop_Color4iv
, cmdlen
);
803 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&red
), 4);
804 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&green
), 4);
805 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&blue
), 4);
806 (void) memcpy((void *) (gc
->pc
+ 16), (void *) (&alpha
), 4);
808 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
809 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
813 #define X_GLrop_Color4iv 17
815 __indirect_glColor4iv(const GLint
* v
)
817 generic_16_byte(X_GLrop_Color4iv
, v
);
820 #define X_GLrop_Color4sv 18
822 __indirect_glColor4s(GLshort red
, GLshort green
, GLshort blue
, GLshort alpha
)
824 __GLXcontext
*const gc
= __glXGetCurrentContext();
825 const GLuint cmdlen
= 12;
826 emit_header(gc
->pc
, X_GLrop_Color4sv
, cmdlen
);
827 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&red
), 2);
828 (void) memcpy((void *) (gc
->pc
+ 6), (void *) (&green
), 2);
829 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&blue
), 2);
830 (void) memcpy((void *) (gc
->pc
+ 10), (void *) (&alpha
), 2);
832 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
833 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
837 #define X_GLrop_Color4sv 18
839 __indirect_glColor4sv(const GLshort
* v
)
841 generic_8_byte(X_GLrop_Color4sv
, v
);
844 #define X_GLrop_Color4ubv 19
846 __indirect_glColor4ub(GLubyte red
, GLubyte green
, GLubyte blue
, GLubyte alpha
)
848 __GLXcontext
*const gc
= __glXGetCurrentContext();
849 const GLuint cmdlen
= 8;
850 emit_header(gc
->pc
, X_GLrop_Color4ubv
, cmdlen
);
851 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&red
), 1);
852 (void) memcpy((void *) (gc
->pc
+ 5), (void *) (&green
), 1);
853 (void) memcpy((void *) (gc
->pc
+ 6), (void *) (&blue
), 1);
854 (void) memcpy((void *) (gc
->pc
+ 7), (void *) (&alpha
), 1);
856 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
857 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
861 #define X_GLrop_Color4ubv 19
863 __indirect_glColor4ubv(const GLubyte
*v
)
865 generic_4_byte(X_GLrop_Color4ubv
, v
);
868 #define X_GLrop_Color4uiv 20
870 __indirect_glColor4ui(GLuint red
, GLuint green
, GLuint blue
, GLuint alpha
)
872 __GLXcontext
*const gc
= __glXGetCurrentContext();
873 const GLuint cmdlen
= 20;
874 emit_header(gc
->pc
, X_GLrop_Color4uiv
, cmdlen
);
875 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&red
), 4);
876 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&green
), 4);
877 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&blue
), 4);
878 (void) memcpy((void *) (gc
->pc
+ 16), (void *) (&alpha
), 4);
880 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
881 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
885 #define X_GLrop_Color4uiv 20
887 __indirect_glColor4uiv(const GLuint
* v
)
889 generic_16_byte(X_GLrop_Color4uiv
, v
);
892 #define X_GLrop_Color4usv 21
894 __indirect_glColor4us(GLushort red
, GLushort green
, GLushort blue
,
897 __GLXcontext
*const gc
= __glXGetCurrentContext();
898 const GLuint cmdlen
= 12;
899 emit_header(gc
->pc
, X_GLrop_Color4usv
, cmdlen
);
900 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&red
), 2);
901 (void) memcpy((void *) (gc
->pc
+ 6), (void *) (&green
), 2);
902 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&blue
), 2);
903 (void) memcpy((void *) (gc
->pc
+ 10), (void *) (&alpha
), 2);
905 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
906 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
910 #define X_GLrop_Color4usv 21
912 __indirect_glColor4usv(const GLushort
* v
)
914 generic_8_byte(X_GLrop_Color4usv
, v
);
917 #define X_GLrop_EdgeFlagv 22
919 __indirect_glEdgeFlag(GLboolean flag
)
921 __GLXcontext
*const gc
= __glXGetCurrentContext();
922 const GLuint cmdlen
= 8;
923 emit_header(gc
->pc
, X_GLrop_EdgeFlagv
, cmdlen
);
924 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&flag
), 1);
926 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
927 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
931 #define X_GLrop_EdgeFlagv 22
933 __indirect_glEdgeFlagv(const GLboolean
* flag
)
935 __GLXcontext
*const gc
= __glXGetCurrentContext();
936 const GLuint cmdlen
= 8;
937 emit_header(gc
->pc
, X_GLrop_EdgeFlagv
, cmdlen
);
938 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (flag
), 1);
940 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
941 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
945 #define X_GLrop_End 23
947 __indirect_glEnd(void)
949 __GLXcontext
*const gc
= __glXGetCurrentContext();
950 const GLuint cmdlen
= 4;
951 emit_header(gc
->pc
, X_GLrop_End
, cmdlen
);
953 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
954 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
958 #define X_GLrop_Indexdv 24
960 __indirect_glIndexd(GLdouble c
)
962 __GLXcontext
*const gc
= __glXGetCurrentContext();
963 const GLuint cmdlen
= 12;
964 emit_header(gc
->pc
, X_GLrop_Indexdv
, cmdlen
);
965 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&c
), 8);
967 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
968 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
972 #define X_GLrop_Indexdv 24
974 __indirect_glIndexdv(const GLdouble
* c
)
976 generic_8_byte(X_GLrop_Indexdv
, c
);
979 #define X_GLrop_Indexfv 25
981 __indirect_glIndexf(GLfloat c
)
983 __GLXcontext
*const gc
= __glXGetCurrentContext();
984 const GLuint cmdlen
= 8;
985 emit_header(gc
->pc
, X_GLrop_Indexfv
, cmdlen
);
986 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&c
), 4);
988 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
989 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
993 #define X_GLrop_Indexfv 25
995 __indirect_glIndexfv(const GLfloat
* c
)
997 generic_4_byte(X_GLrop_Indexfv
, c
);
1000 #define X_GLrop_Indexiv 26
1002 __indirect_glIndexi(GLint c
)
1004 __GLXcontext
*const gc
= __glXGetCurrentContext();
1005 const GLuint cmdlen
= 8;
1006 emit_header(gc
->pc
, X_GLrop_Indexiv
, cmdlen
);
1007 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&c
), 4);
1009 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
1010 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
1014 #define X_GLrop_Indexiv 26
1016 __indirect_glIndexiv(const GLint
* c
)
1018 generic_4_byte(X_GLrop_Indexiv
, c
);
1021 #define X_GLrop_Indexsv 27
1023 __indirect_glIndexs(GLshort c
)
1025 __GLXcontext
*const gc
= __glXGetCurrentContext();
1026 const GLuint cmdlen
= 8;
1027 emit_header(gc
->pc
, X_GLrop_Indexsv
, cmdlen
);
1028 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&c
), 2);
1030 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
1031 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
1035 #define X_GLrop_Indexsv 27
1037 __indirect_glIndexsv(const GLshort
* c
)
1039 __GLXcontext
*const gc
= __glXGetCurrentContext();
1040 const GLuint cmdlen
= 8;
1041 emit_header(gc
->pc
, X_GLrop_Indexsv
, cmdlen
);
1042 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (c
), 2);
1044 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
1045 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
1049 #define X_GLrop_Normal3bv 28
1051 __indirect_glNormal3b(GLbyte nx
, GLbyte ny
, GLbyte nz
)
1053 __GLXcontext
*const gc
= __glXGetCurrentContext();
1054 const GLuint cmdlen
= 8;
1055 emit_header(gc
->pc
, X_GLrop_Normal3bv
, cmdlen
);
1056 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&nx
), 1);
1057 (void) memcpy((void *) (gc
->pc
+ 5), (void *) (&ny
), 1);
1058 (void) memcpy((void *) (gc
->pc
+ 6), (void *) (&nz
), 1);
1060 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
1061 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
1065 #define X_GLrop_Normal3bv 28
1067 __indirect_glNormal3bv(const GLbyte
*v
)
1069 generic_3_byte(X_GLrop_Normal3bv
, v
);
1072 #define X_GLrop_Normal3dv 29
1074 __indirect_glNormal3d(GLdouble nx
, GLdouble ny
, GLdouble nz
)
1076 __GLXcontext
*const gc
= __glXGetCurrentContext();
1077 const GLuint cmdlen
= 28;
1078 emit_header(gc
->pc
, X_GLrop_Normal3dv
, cmdlen
);
1079 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&nx
), 8);
1080 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&ny
), 8);
1081 (void) memcpy((void *) (gc
->pc
+ 20), (void *) (&nz
), 8);
1083 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
1084 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
1088 #define X_GLrop_Normal3dv 29
1090 __indirect_glNormal3dv(const GLdouble
* v
)
1092 generic_24_byte(X_GLrop_Normal3dv
, v
);
1095 #define X_GLrop_Normal3fv 30
1097 __indirect_glNormal3f(GLfloat nx
, GLfloat ny
, GLfloat nz
)
1099 __GLXcontext
*const gc
= __glXGetCurrentContext();
1100 const GLuint cmdlen
= 16;
1101 emit_header(gc
->pc
, X_GLrop_Normal3fv
, cmdlen
);
1102 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&nx
), 4);
1103 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&ny
), 4);
1104 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&nz
), 4);
1106 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
1107 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
1111 #define X_GLrop_Normal3fv 30
1113 __indirect_glNormal3fv(const GLfloat
* v
)
1115 generic_12_byte(X_GLrop_Normal3fv
, v
);
1118 #define X_GLrop_Normal3iv 31
1120 __indirect_glNormal3i(GLint nx
, GLint ny
, GLint nz
)
1122 __GLXcontext
*const gc
= __glXGetCurrentContext();
1123 const GLuint cmdlen
= 16;
1124 emit_header(gc
->pc
, X_GLrop_Normal3iv
, cmdlen
);
1125 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&nx
), 4);
1126 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&ny
), 4);
1127 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&nz
), 4);
1129 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
1130 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
1134 #define X_GLrop_Normal3iv 31
1136 __indirect_glNormal3iv(const GLint
* v
)
1138 generic_12_byte(X_GLrop_Normal3iv
, v
);
1141 #define X_GLrop_Normal3sv 32
1143 __indirect_glNormal3s(GLshort nx
, GLshort ny
, GLshort nz
)
1145 __GLXcontext
*const gc
= __glXGetCurrentContext();
1146 const GLuint cmdlen
= 12;
1147 emit_header(gc
->pc
, X_GLrop_Normal3sv
, cmdlen
);
1148 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&nx
), 2);
1149 (void) memcpy((void *) (gc
->pc
+ 6), (void *) (&ny
), 2);
1150 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&nz
), 2);
1152 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
1153 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
1157 #define X_GLrop_Normal3sv 32
1159 __indirect_glNormal3sv(const GLshort
* v
)
1161 generic_6_byte(X_GLrop_Normal3sv
, v
);
1164 #define X_GLrop_RasterPos2dv 33
1166 __indirect_glRasterPos2d(GLdouble x
, GLdouble y
)
1168 __GLXcontext
*const gc
= __glXGetCurrentContext();
1169 const GLuint cmdlen
= 20;
1170 emit_header(gc
->pc
, X_GLrop_RasterPos2dv
, cmdlen
);
1171 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&x
), 8);
1172 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&y
), 8);
1174 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
1175 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
1179 #define X_GLrop_RasterPos2dv 33
1181 __indirect_glRasterPos2dv(const GLdouble
* v
)
1183 generic_16_byte(X_GLrop_RasterPos2dv
, v
);
1186 #define X_GLrop_RasterPos2fv 34
1188 __indirect_glRasterPos2f(GLfloat x
, GLfloat y
)
1190 __GLXcontext
*const gc
= __glXGetCurrentContext();
1191 const GLuint cmdlen
= 12;
1192 emit_header(gc
->pc
, X_GLrop_RasterPos2fv
, cmdlen
);
1193 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&x
), 4);
1194 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&y
), 4);
1196 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
1197 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
1201 #define X_GLrop_RasterPos2fv 34
1203 __indirect_glRasterPos2fv(const GLfloat
* v
)
1205 generic_8_byte(X_GLrop_RasterPos2fv
, v
);
1208 #define X_GLrop_RasterPos2iv 35
1210 __indirect_glRasterPos2i(GLint x
, GLint y
)
1212 __GLXcontext
*const gc
= __glXGetCurrentContext();
1213 const GLuint cmdlen
= 12;
1214 emit_header(gc
->pc
, X_GLrop_RasterPos2iv
, cmdlen
);
1215 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&x
), 4);
1216 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&y
), 4);
1218 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
1219 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
1223 #define X_GLrop_RasterPos2iv 35
1225 __indirect_glRasterPos2iv(const GLint
* v
)
1227 generic_8_byte(X_GLrop_RasterPos2iv
, v
);
1230 #define X_GLrop_RasterPos2sv 36
1232 __indirect_glRasterPos2s(GLshort x
, GLshort y
)
1234 __GLXcontext
*const gc
= __glXGetCurrentContext();
1235 const GLuint cmdlen
= 8;
1236 emit_header(gc
->pc
, X_GLrop_RasterPos2sv
, cmdlen
);
1237 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&x
), 2);
1238 (void) memcpy((void *) (gc
->pc
+ 6), (void *) (&y
), 2);
1240 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
1241 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
1245 #define X_GLrop_RasterPos2sv 36
1247 __indirect_glRasterPos2sv(const GLshort
* v
)
1249 generic_4_byte(X_GLrop_RasterPos2sv
, v
);
1252 #define X_GLrop_RasterPos3dv 37
1254 __indirect_glRasterPos3d(GLdouble x
, GLdouble y
, GLdouble z
)
1256 __GLXcontext
*const gc
= __glXGetCurrentContext();
1257 const GLuint cmdlen
= 28;
1258 emit_header(gc
->pc
, X_GLrop_RasterPos3dv
, cmdlen
);
1259 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&x
), 8);
1260 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&y
), 8);
1261 (void) memcpy((void *) (gc
->pc
+ 20), (void *) (&z
), 8);
1263 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
1264 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
1268 #define X_GLrop_RasterPos3dv 37
1270 __indirect_glRasterPos3dv(const GLdouble
* v
)
1272 generic_24_byte(X_GLrop_RasterPos3dv
, v
);
1275 #define X_GLrop_RasterPos3fv 38
1277 __indirect_glRasterPos3f(GLfloat x
, GLfloat y
, GLfloat z
)
1279 __GLXcontext
*const gc
= __glXGetCurrentContext();
1280 const GLuint cmdlen
= 16;
1281 emit_header(gc
->pc
, X_GLrop_RasterPos3fv
, cmdlen
);
1282 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&x
), 4);
1283 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&y
), 4);
1284 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&z
), 4);
1286 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
1287 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
1291 #define X_GLrop_RasterPos3fv 38
1293 __indirect_glRasterPos3fv(const GLfloat
* v
)
1295 generic_12_byte(X_GLrop_RasterPos3fv
, v
);
1298 #define X_GLrop_RasterPos3iv 39
1300 __indirect_glRasterPos3i(GLint x
, GLint y
, GLint z
)
1302 __GLXcontext
*const gc
= __glXGetCurrentContext();
1303 const GLuint cmdlen
= 16;
1304 emit_header(gc
->pc
, X_GLrop_RasterPos3iv
, cmdlen
);
1305 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&x
), 4);
1306 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&y
), 4);
1307 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&z
), 4);
1309 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
1310 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
1314 #define X_GLrop_RasterPos3iv 39
1316 __indirect_glRasterPos3iv(const GLint
* v
)
1318 generic_12_byte(X_GLrop_RasterPos3iv
, v
);
1321 #define X_GLrop_RasterPos3sv 40
1323 __indirect_glRasterPos3s(GLshort x
, GLshort y
, GLshort z
)
1325 __GLXcontext
*const gc
= __glXGetCurrentContext();
1326 const GLuint cmdlen
= 12;
1327 emit_header(gc
->pc
, X_GLrop_RasterPos3sv
, cmdlen
);
1328 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&x
), 2);
1329 (void) memcpy((void *) (gc
->pc
+ 6), (void *) (&y
), 2);
1330 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&z
), 2);
1332 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
1333 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
1337 #define X_GLrop_RasterPos3sv 40
1339 __indirect_glRasterPos3sv(const GLshort
* v
)
1341 generic_6_byte(X_GLrop_RasterPos3sv
, v
);
1344 #define X_GLrop_RasterPos4dv 41
1346 __indirect_glRasterPos4d(GLdouble x
, GLdouble y
, GLdouble z
, GLdouble w
)
1348 __GLXcontext
*const gc
= __glXGetCurrentContext();
1349 const GLuint cmdlen
= 36;
1350 emit_header(gc
->pc
, X_GLrop_RasterPos4dv
, cmdlen
);
1351 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&x
), 8);
1352 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&y
), 8);
1353 (void) memcpy((void *) (gc
->pc
+ 20), (void *) (&z
), 8);
1354 (void) memcpy((void *) (gc
->pc
+ 28), (void *) (&w
), 8);
1356 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
1357 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
1361 #define X_GLrop_RasterPos4dv 41
1363 __indirect_glRasterPos4dv(const GLdouble
* v
)
1365 generic_32_byte(X_GLrop_RasterPos4dv
, v
);
1368 #define X_GLrop_RasterPos4fv 42
1370 __indirect_glRasterPos4f(GLfloat x
, GLfloat y
, GLfloat z
, GLfloat w
)
1372 __GLXcontext
*const gc
= __glXGetCurrentContext();
1373 const GLuint cmdlen
= 20;
1374 emit_header(gc
->pc
, X_GLrop_RasterPos4fv
, cmdlen
);
1375 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&x
), 4);
1376 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&y
), 4);
1377 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&z
), 4);
1378 (void) memcpy((void *) (gc
->pc
+ 16), (void *) (&w
), 4);
1380 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
1381 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
1385 #define X_GLrop_RasterPos4fv 42
1387 __indirect_glRasterPos4fv(const GLfloat
* v
)
1389 generic_16_byte(X_GLrop_RasterPos4fv
, v
);
1392 #define X_GLrop_RasterPos4iv 43
1394 __indirect_glRasterPos4i(GLint x
, GLint y
, GLint z
, GLint w
)
1396 __GLXcontext
*const gc
= __glXGetCurrentContext();
1397 const GLuint cmdlen
= 20;
1398 emit_header(gc
->pc
, X_GLrop_RasterPos4iv
, cmdlen
);
1399 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&x
), 4);
1400 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&y
), 4);
1401 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&z
), 4);
1402 (void) memcpy((void *) (gc
->pc
+ 16), (void *) (&w
), 4);
1404 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
1405 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
1409 #define X_GLrop_RasterPos4iv 43
1411 __indirect_glRasterPos4iv(const GLint
* v
)
1413 generic_16_byte(X_GLrop_RasterPos4iv
, v
);
1416 #define X_GLrop_RasterPos4sv 44
1418 __indirect_glRasterPos4s(GLshort x
, GLshort y
, GLshort z
, GLshort w
)
1420 __GLXcontext
*const gc
= __glXGetCurrentContext();
1421 const GLuint cmdlen
= 12;
1422 emit_header(gc
->pc
, X_GLrop_RasterPos4sv
, cmdlen
);
1423 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&x
), 2);
1424 (void) memcpy((void *) (gc
->pc
+ 6), (void *) (&y
), 2);
1425 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&z
), 2);
1426 (void) memcpy((void *) (gc
->pc
+ 10), (void *) (&w
), 2);
1428 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
1429 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
1433 #define X_GLrop_RasterPos4sv 44
1435 __indirect_glRasterPos4sv(const GLshort
* v
)
1437 generic_8_byte(X_GLrop_RasterPos4sv
, v
);
1440 #define X_GLrop_Rectdv 45
1442 __indirect_glRectd(GLdouble x1
, GLdouble y1
, GLdouble x2
, GLdouble y2
)
1444 __GLXcontext
*const gc
= __glXGetCurrentContext();
1445 const GLuint cmdlen
= 36;
1446 emit_header(gc
->pc
, X_GLrop_Rectdv
, cmdlen
);
1447 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&x1
), 8);
1448 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&y1
), 8);
1449 (void) memcpy((void *) (gc
->pc
+ 20), (void *) (&x2
), 8);
1450 (void) memcpy((void *) (gc
->pc
+ 28), (void *) (&y2
), 8);
1452 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
1453 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
1457 #define X_GLrop_Rectdv 45
1459 __indirect_glRectdv(const GLdouble
* v1
, const GLdouble
* v2
)
1461 __GLXcontext
*const gc
= __glXGetCurrentContext();
1462 const GLuint cmdlen
= 36;
1463 emit_header(gc
->pc
, X_GLrop_Rectdv
, cmdlen
);
1464 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (v1
), 16);
1465 (void) memcpy((void *) (gc
->pc
+ 20), (void *) (v2
), 16);
1467 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
1468 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
1472 #define X_GLrop_Rectfv 46
1474 __indirect_glRectf(GLfloat x1
, GLfloat y1
, GLfloat x2
, GLfloat y2
)
1476 __GLXcontext
*const gc
= __glXGetCurrentContext();
1477 const GLuint cmdlen
= 20;
1478 emit_header(gc
->pc
, X_GLrop_Rectfv
, cmdlen
);
1479 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&x1
), 4);
1480 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&y1
), 4);
1481 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&x2
), 4);
1482 (void) memcpy((void *) (gc
->pc
+ 16), (void *) (&y2
), 4);
1484 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
1485 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
1489 #define X_GLrop_Rectfv 46
1491 __indirect_glRectfv(const GLfloat
* v1
, const GLfloat
* v2
)
1493 __GLXcontext
*const gc
= __glXGetCurrentContext();
1494 const GLuint cmdlen
= 20;
1495 emit_header(gc
->pc
, X_GLrop_Rectfv
, cmdlen
);
1496 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (v1
), 8);
1497 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (v2
), 8);
1499 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
1500 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
1504 #define X_GLrop_Rectiv 47
1506 __indirect_glRecti(GLint x1
, GLint y1
, GLint x2
, GLint y2
)
1508 __GLXcontext
*const gc
= __glXGetCurrentContext();
1509 const GLuint cmdlen
= 20;
1510 emit_header(gc
->pc
, X_GLrop_Rectiv
, cmdlen
);
1511 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&x1
), 4);
1512 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&y1
), 4);
1513 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&x2
), 4);
1514 (void) memcpy((void *) (gc
->pc
+ 16), (void *) (&y2
), 4);
1516 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
1517 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
1521 #define X_GLrop_Rectiv 47
1523 __indirect_glRectiv(const GLint
* v1
, const GLint
* v2
)
1525 __GLXcontext
*const gc
= __glXGetCurrentContext();
1526 const GLuint cmdlen
= 20;
1527 emit_header(gc
->pc
, X_GLrop_Rectiv
, cmdlen
);
1528 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (v1
), 8);
1529 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (v2
), 8);
1531 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
1532 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
1536 #define X_GLrop_Rectsv 48
1538 __indirect_glRects(GLshort x1
, GLshort y1
, GLshort x2
, GLshort y2
)
1540 __GLXcontext
*const gc
= __glXGetCurrentContext();
1541 const GLuint cmdlen
= 12;
1542 emit_header(gc
->pc
, X_GLrop_Rectsv
, cmdlen
);
1543 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&x1
), 2);
1544 (void) memcpy((void *) (gc
->pc
+ 6), (void *) (&y1
), 2);
1545 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&x2
), 2);
1546 (void) memcpy((void *) (gc
->pc
+ 10), (void *) (&y2
), 2);
1548 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
1549 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
1553 #define X_GLrop_Rectsv 48
1555 __indirect_glRectsv(const GLshort
* v1
, const GLshort
* v2
)
1557 __GLXcontext
*const gc
= __glXGetCurrentContext();
1558 const GLuint cmdlen
= 12;
1559 emit_header(gc
->pc
, X_GLrop_Rectsv
, cmdlen
);
1560 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (v1
), 4);
1561 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (v2
), 4);
1563 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
1564 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
1568 #define X_GLrop_TexCoord1dv 49
1570 __indirect_glTexCoord1d(GLdouble s
)
1572 __GLXcontext
*const gc
= __glXGetCurrentContext();
1573 const GLuint cmdlen
= 12;
1574 emit_header(gc
->pc
, X_GLrop_TexCoord1dv
, cmdlen
);
1575 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&s
), 8);
1577 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
1578 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
1582 #define X_GLrop_TexCoord1dv 49
1584 __indirect_glTexCoord1dv(const GLdouble
* v
)
1586 generic_8_byte(X_GLrop_TexCoord1dv
, v
);
1589 #define X_GLrop_TexCoord1fv 50
1591 __indirect_glTexCoord1f(GLfloat s
)
1593 __GLXcontext
*const gc
= __glXGetCurrentContext();
1594 const GLuint cmdlen
= 8;
1595 emit_header(gc
->pc
, X_GLrop_TexCoord1fv
, cmdlen
);
1596 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&s
), 4);
1598 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
1599 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
1603 #define X_GLrop_TexCoord1fv 50
1605 __indirect_glTexCoord1fv(const GLfloat
* v
)
1607 generic_4_byte(X_GLrop_TexCoord1fv
, v
);
1610 #define X_GLrop_TexCoord1iv 51
1612 __indirect_glTexCoord1i(GLint s
)
1614 __GLXcontext
*const gc
= __glXGetCurrentContext();
1615 const GLuint cmdlen
= 8;
1616 emit_header(gc
->pc
, X_GLrop_TexCoord1iv
, cmdlen
);
1617 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&s
), 4);
1619 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
1620 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
1624 #define X_GLrop_TexCoord1iv 51
1626 __indirect_glTexCoord1iv(const GLint
* v
)
1628 generic_4_byte(X_GLrop_TexCoord1iv
, v
);
1631 #define X_GLrop_TexCoord1sv 52
1633 __indirect_glTexCoord1s(GLshort s
)
1635 __GLXcontext
*const gc
= __glXGetCurrentContext();
1636 const GLuint cmdlen
= 8;
1637 emit_header(gc
->pc
, X_GLrop_TexCoord1sv
, cmdlen
);
1638 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&s
), 2);
1640 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
1641 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
1645 #define X_GLrop_TexCoord1sv 52
1647 __indirect_glTexCoord1sv(const GLshort
* v
)
1649 __GLXcontext
*const gc
= __glXGetCurrentContext();
1650 const GLuint cmdlen
= 8;
1651 emit_header(gc
->pc
, X_GLrop_TexCoord1sv
, cmdlen
);
1652 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (v
), 2);
1654 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
1655 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
1659 #define X_GLrop_TexCoord2dv 53
1661 __indirect_glTexCoord2d(GLdouble s
, GLdouble t
)
1663 __GLXcontext
*const gc
= __glXGetCurrentContext();
1664 const GLuint cmdlen
= 20;
1665 emit_header(gc
->pc
, X_GLrop_TexCoord2dv
, cmdlen
);
1666 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&s
), 8);
1667 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&t
), 8);
1669 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
1670 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
1674 #define X_GLrop_TexCoord2dv 53
1676 __indirect_glTexCoord2dv(const GLdouble
* v
)
1678 generic_16_byte(X_GLrop_TexCoord2dv
, v
);
1681 #define X_GLrop_TexCoord2fv 54
1683 __indirect_glTexCoord2f(GLfloat s
, GLfloat t
)
1685 __GLXcontext
*const gc
= __glXGetCurrentContext();
1686 const GLuint cmdlen
= 12;
1687 emit_header(gc
->pc
, X_GLrop_TexCoord2fv
, cmdlen
);
1688 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&s
), 4);
1689 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&t
), 4);
1691 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
1692 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
1696 #define X_GLrop_TexCoord2fv 54
1698 __indirect_glTexCoord2fv(const GLfloat
* v
)
1700 generic_8_byte(X_GLrop_TexCoord2fv
, v
);
1703 #define X_GLrop_TexCoord2iv 55
1705 __indirect_glTexCoord2i(GLint s
, GLint t
)
1707 __GLXcontext
*const gc
= __glXGetCurrentContext();
1708 const GLuint cmdlen
= 12;
1709 emit_header(gc
->pc
, X_GLrop_TexCoord2iv
, cmdlen
);
1710 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&s
), 4);
1711 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&t
), 4);
1713 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
1714 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
1718 #define X_GLrop_TexCoord2iv 55
1720 __indirect_glTexCoord2iv(const GLint
* v
)
1722 generic_8_byte(X_GLrop_TexCoord2iv
, v
);
1725 #define X_GLrop_TexCoord2sv 56
1727 __indirect_glTexCoord2s(GLshort s
, GLshort t
)
1729 __GLXcontext
*const gc
= __glXGetCurrentContext();
1730 const GLuint cmdlen
= 8;
1731 emit_header(gc
->pc
, X_GLrop_TexCoord2sv
, cmdlen
);
1732 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&s
), 2);
1733 (void) memcpy((void *) (gc
->pc
+ 6), (void *) (&t
), 2);
1735 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
1736 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
1740 #define X_GLrop_TexCoord2sv 56
1742 __indirect_glTexCoord2sv(const GLshort
* v
)
1744 generic_4_byte(X_GLrop_TexCoord2sv
, v
);
1747 #define X_GLrop_TexCoord3dv 57
1749 __indirect_glTexCoord3d(GLdouble s
, GLdouble t
, GLdouble r
)
1751 __GLXcontext
*const gc
= __glXGetCurrentContext();
1752 const GLuint cmdlen
= 28;
1753 emit_header(gc
->pc
, X_GLrop_TexCoord3dv
, cmdlen
);
1754 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&s
), 8);
1755 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&t
), 8);
1756 (void) memcpy((void *) (gc
->pc
+ 20), (void *) (&r
), 8);
1758 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
1759 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
1763 #define X_GLrop_TexCoord3dv 57
1765 __indirect_glTexCoord3dv(const GLdouble
* v
)
1767 generic_24_byte(X_GLrop_TexCoord3dv
, v
);
1770 #define X_GLrop_TexCoord3fv 58
1772 __indirect_glTexCoord3f(GLfloat s
, GLfloat t
, GLfloat r
)
1774 __GLXcontext
*const gc
= __glXGetCurrentContext();
1775 const GLuint cmdlen
= 16;
1776 emit_header(gc
->pc
, X_GLrop_TexCoord3fv
, cmdlen
);
1777 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&s
), 4);
1778 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&t
), 4);
1779 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&r
), 4);
1781 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
1782 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
1786 #define X_GLrop_TexCoord3fv 58
1788 __indirect_glTexCoord3fv(const GLfloat
* v
)
1790 generic_12_byte(X_GLrop_TexCoord3fv
, v
);
1793 #define X_GLrop_TexCoord3iv 59
1795 __indirect_glTexCoord3i(GLint s
, GLint t
, GLint r
)
1797 __GLXcontext
*const gc
= __glXGetCurrentContext();
1798 const GLuint cmdlen
= 16;
1799 emit_header(gc
->pc
, X_GLrop_TexCoord3iv
, cmdlen
);
1800 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&s
), 4);
1801 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&t
), 4);
1802 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&r
), 4);
1804 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
1805 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
1809 #define X_GLrop_TexCoord3iv 59
1811 __indirect_glTexCoord3iv(const GLint
* v
)
1813 generic_12_byte(X_GLrop_TexCoord3iv
, v
);
1816 #define X_GLrop_TexCoord3sv 60
1818 __indirect_glTexCoord3s(GLshort s
, GLshort t
, GLshort r
)
1820 __GLXcontext
*const gc
= __glXGetCurrentContext();
1821 const GLuint cmdlen
= 12;
1822 emit_header(gc
->pc
, X_GLrop_TexCoord3sv
, cmdlen
);
1823 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&s
), 2);
1824 (void) memcpy((void *) (gc
->pc
+ 6), (void *) (&t
), 2);
1825 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&r
), 2);
1827 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
1828 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
1832 #define X_GLrop_TexCoord3sv 60
1834 __indirect_glTexCoord3sv(const GLshort
* v
)
1836 generic_6_byte(X_GLrop_TexCoord3sv
, v
);
1839 #define X_GLrop_TexCoord4dv 61
1841 __indirect_glTexCoord4d(GLdouble s
, GLdouble t
, GLdouble r
, GLdouble q
)
1843 __GLXcontext
*const gc
= __glXGetCurrentContext();
1844 const GLuint cmdlen
= 36;
1845 emit_header(gc
->pc
, X_GLrop_TexCoord4dv
, cmdlen
);
1846 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&s
), 8);
1847 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&t
), 8);
1848 (void) memcpy((void *) (gc
->pc
+ 20), (void *) (&r
), 8);
1849 (void) memcpy((void *) (gc
->pc
+ 28), (void *) (&q
), 8);
1851 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
1852 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
1856 #define X_GLrop_TexCoord4dv 61
1858 __indirect_glTexCoord4dv(const GLdouble
* v
)
1860 generic_32_byte(X_GLrop_TexCoord4dv
, v
);
1863 #define X_GLrop_TexCoord4fv 62
1865 __indirect_glTexCoord4f(GLfloat s
, GLfloat t
, GLfloat r
, GLfloat q
)
1867 __GLXcontext
*const gc
= __glXGetCurrentContext();
1868 const GLuint cmdlen
= 20;
1869 emit_header(gc
->pc
, X_GLrop_TexCoord4fv
, cmdlen
);
1870 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&s
), 4);
1871 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&t
), 4);
1872 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&r
), 4);
1873 (void) memcpy((void *) (gc
->pc
+ 16), (void *) (&q
), 4);
1875 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
1876 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
1880 #define X_GLrop_TexCoord4fv 62
1882 __indirect_glTexCoord4fv(const GLfloat
* v
)
1884 generic_16_byte(X_GLrop_TexCoord4fv
, v
);
1887 #define X_GLrop_TexCoord4iv 63
1889 __indirect_glTexCoord4i(GLint s
, GLint t
, GLint r
, GLint q
)
1891 __GLXcontext
*const gc
= __glXGetCurrentContext();
1892 const GLuint cmdlen
= 20;
1893 emit_header(gc
->pc
, X_GLrop_TexCoord4iv
, cmdlen
);
1894 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&s
), 4);
1895 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&t
), 4);
1896 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&r
), 4);
1897 (void) memcpy((void *) (gc
->pc
+ 16), (void *) (&q
), 4);
1899 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
1900 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
1904 #define X_GLrop_TexCoord4iv 63
1906 __indirect_glTexCoord4iv(const GLint
* v
)
1908 generic_16_byte(X_GLrop_TexCoord4iv
, v
);
1911 #define X_GLrop_TexCoord4sv 64
1913 __indirect_glTexCoord4s(GLshort s
, GLshort t
, GLshort r
, GLshort q
)
1915 __GLXcontext
*const gc
= __glXGetCurrentContext();
1916 const GLuint cmdlen
= 12;
1917 emit_header(gc
->pc
, X_GLrop_TexCoord4sv
, cmdlen
);
1918 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&s
), 2);
1919 (void) memcpy((void *) (gc
->pc
+ 6), (void *) (&t
), 2);
1920 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&r
), 2);
1921 (void) memcpy((void *) (gc
->pc
+ 10), (void *) (&q
), 2);
1923 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
1924 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
1928 #define X_GLrop_TexCoord4sv 64
1930 __indirect_glTexCoord4sv(const GLshort
* v
)
1932 generic_8_byte(X_GLrop_TexCoord4sv
, v
);
1935 #define X_GLrop_Vertex2dv 65
1937 __indirect_glVertex2d(GLdouble x
, GLdouble y
)
1939 __GLXcontext
*const gc
= __glXGetCurrentContext();
1940 const GLuint cmdlen
= 20;
1941 emit_header(gc
->pc
, X_GLrop_Vertex2dv
, cmdlen
);
1942 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&x
), 8);
1943 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&y
), 8);
1945 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
1946 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
1950 #define X_GLrop_Vertex2dv 65
1952 __indirect_glVertex2dv(const GLdouble
* v
)
1954 generic_16_byte(X_GLrop_Vertex2dv
, v
);
1957 #define X_GLrop_Vertex2fv 66
1959 __indirect_glVertex2f(GLfloat x
, GLfloat y
)
1961 __GLXcontext
*const gc
= __glXGetCurrentContext();
1962 const GLuint cmdlen
= 12;
1963 emit_header(gc
->pc
, X_GLrop_Vertex2fv
, cmdlen
);
1964 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&x
), 4);
1965 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&y
), 4);
1967 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
1968 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
1972 #define X_GLrop_Vertex2fv 66
1974 __indirect_glVertex2fv(const GLfloat
* v
)
1976 generic_8_byte(X_GLrop_Vertex2fv
, v
);
1979 #define X_GLrop_Vertex2iv 67
1981 __indirect_glVertex2i(GLint x
, GLint y
)
1983 __GLXcontext
*const gc
= __glXGetCurrentContext();
1984 const GLuint cmdlen
= 12;
1985 emit_header(gc
->pc
, X_GLrop_Vertex2iv
, cmdlen
);
1986 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&x
), 4);
1987 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&y
), 4);
1989 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
1990 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
1994 #define X_GLrop_Vertex2iv 67
1996 __indirect_glVertex2iv(const GLint
* v
)
1998 generic_8_byte(X_GLrop_Vertex2iv
, v
);
2001 #define X_GLrop_Vertex2sv 68
2003 __indirect_glVertex2s(GLshort x
, GLshort y
)
2005 __GLXcontext
*const gc
= __glXGetCurrentContext();
2006 const GLuint cmdlen
= 8;
2007 emit_header(gc
->pc
, X_GLrop_Vertex2sv
, cmdlen
);
2008 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&x
), 2);
2009 (void) memcpy((void *) (gc
->pc
+ 6), (void *) (&y
), 2);
2011 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
2012 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
2016 #define X_GLrop_Vertex2sv 68
2018 __indirect_glVertex2sv(const GLshort
* v
)
2020 generic_4_byte(X_GLrop_Vertex2sv
, v
);
2023 #define X_GLrop_Vertex3dv 69
2025 __indirect_glVertex3d(GLdouble x
, GLdouble y
, GLdouble z
)
2027 __GLXcontext
*const gc
= __glXGetCurrentContext();
2028 const GLuint cmdlen
= 28;
2029 emit_header(gc
->pc
, X_GLrop_Vertex3dv
, cmdlen
);
2030 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&x
), 8);
2031 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&y
), 8);
2032 (void) memcpy((void *) (gc
->pc
+ 20), (void *) (&z
), 8);
2034 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
2035 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
2039 #define X_GLrop_Vertex3dv 69
2041 __indirect_glVertex3dv(const GLdouble
* v
)
2043 generic_24_byte(X_GLrop_Vertex3dv
, v
);
2046 #define X_GLrop_Vertex3fv 70
2048 __indirect_glVertex3f(GLfloat x
, GLfloat y
, GLfloat z
)
2050 __GLXcontext
*const gc
= __glXGetCurrentContext();
2051 const GLuint cmdlen
= 16;
2052 emit_header(gc
->pc
, X_GLrop_Vertex3fv
, cmdlen
);
2053 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&x
), 4);
2054 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&y
), 4);
2055 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&z
), 4);
2057 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
2058 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
2062 #define X_GLrop_Vertex3fv 70
2064 __indirect_glVertex3fv(const GLfloat
* v
)
2066 generic_12_byte(X_GLrop_Vertex3fv
, v
);
2069 #define X_GLrop_Vertex3iv 71
2071 __indirect_glVertex3i(GLint x
, GLint y
, GLint z
)
2073 __GLXcontext
*const gc
= __glXGetCurrentContext();
2074 const GLuint cmdlen
= 16;
2075 emit_header(gc
->pc
, X_GLrop_Vertex3iv
, cmdlen
);
2076 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&x
), 4);
2077 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&y
), 4);
2078 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&z
), 4);
2080 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
2081 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
2085 #define X_GLrop_Vertex3iv 71
2087 __indirect_glVertex3iv(const GLint
* v
)
2089 generic_12_byte(X_GLrop_Vertex3iv
, v
);
2092 #define X_GLrop_Vertex3sv 72
2094 __indirect_glVertex3s(GLshort x
, GLshort y
, GLshort z
)
2096 __GLXcontext
*const gc
= __glXGetCurrentContext();
2097 const GLuint cmdlen
= 12;
2098 emit_header(gc
->pc
, X_GLrop_Vertex3sv
, cmdlen
);
2099 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&x
), 2);
2100 (void) memcpy((void *) (gc
->pc
+ 6), (void *) (&y
), 2);
2101 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&z
), 2);
2103 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
2104 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
2108 #define X_GLrop_Vertex3sv 72
2110 __indirect_glVertex3sv(const GLshort
* v
)
2112 generic_6_byte(X_GLrop_Vertex3sv
, v
);
2115 #define X_GLrop_Vertex4dv 73
2117 __indirect_glVertex4d(GLdouble x
, GLdouble y
, GLdouble z
, GLdouble w
)
2119 __GLXcontext
*const gc
= __glXGetCurrentContext();
2120 const GLuint cmdlen
= 36;
2121 emit_header(gc
->pc
, X_GLrop_Vertex4dv
, cmdlen
);
2122 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&x
), 8);
2123 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&y
), 8);
2124 (void) memcpy((void *) (gc
->pc
+ 20), (void *) (&z
), 8);
2125 (void) memcpy((void *) (gc
->pc
+ 28), (void *) (&w
), 8);
2127 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
2128 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
2132 #define X_GLrop_Vertex4dv 73
2134 __indirect_glVertex4dv(const GLdouble
* v
)
2136 generic_32_byte(X_GLrop_Vertex4dv
, v
);
2139 #define X_GLrop_Vertex4fv 74
2141 __indirect_glVertex4f(GLfloat x
, GLfloat y
, GLfloat z
, GLfloat w
)
2143 __GLXcontext
*const gc
= __glXGetCurrentContext();
2144 const GLuint cmdlen
= 20;
2145 emit_header(gc
->pc
, X_GLrop_Vertex4fv
, cmdlen
);
2146 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&x
), 4);
2147 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&y
), 4);
2148 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&z
), 4);
2149 (void) memcpy((void *) (gc
->pc
+ 16), (void *) (&w
), 4);
2151 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
2152 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
2156 #define X_GLrop_Vertex4fv 74
2158 __indirect_glVertex4fv(const GLfloat
* v
)
2160 generic_16_byte(X_GLrop_Vertex4fv
, v
);
2163 #define X_GLrop_Vertex4iv 75
2165 __indirect_glVertex4i(GLint x
, GLint y
, GLint z
, GLint w
)
2167 __GLXcontext
*const gc
= __glXGetCurrentContext();
2168 const GLuint cmdlen
= 20;
2169 emit_header(gc
->pc
, X_GLrop_Vertex4iv
, cmdlen
);
2170 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&x
), 4);
2171 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&y
), 4);
2172 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&z
), 4);
2173 (void) memcpy((void *) (gc
->pc
+ 16), (void *) (&w
), 4);
2175 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
2176 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
2180 #define X_GLrop_Vertex4iv 75
2182 __indirect_glVertex4iv(const GLint
* v
)
2184 generic_16_byte(X_GLrop_Vertex4iv
, v
);
2187 #define X_GLrop_Vertex4sv 76
2189 __indirect_glVertex4s(GLshort x
, GLshort y
, GLshort z
, GLshort w
)
2191 __GLXcontext
*const gc
= __glXGetCurrentContext();
2192 const GLuint cmdlen
= 12;
2193 emit_header(gc
->pc
, X_GLrop_Vertex4sv
, cmdlen
);
2194 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&x
), 2);
2195 (void) memcpy((void *) (gc
->pc
+ 6), (void *) (&y
), 2);
2196 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&z
), 2);
2197 (void) memcpy((void *) (gc
->pc
+ 10), (void *) (&w
), 2);
2199 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
2200 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
2204 #define X_GLrop_Vertex4sv 76
2206 __indirect_glVertex4sv(const GLshort
* v
)
2208 generic_8_byte(X_GLrop_Vertex4sv
, v
);
2211 #define X_GLrop_ClipPlane 77
2213 __indirect_glClipPlane(GLenum plane
, const GLdouble
* equation
)
2215 __GLXcontext
*const gc
= __glXGetCurrentContext();
2216 const GLuint cmdlen
= 40;
2217 emit_header(gc
->pc
, X_GLrop_ClipPlane
, cmdlen
);
2218 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (equation
), 32);
2219 (void) memcpy((void *) (gc
->pc
+ 36), (void *) (&plane
), 4);
2221 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
2222 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
2226 #define X_GLrop_ColorMaterial 78
2228 __indirect_glColorMaterial(GLenum face
, GLenum mode
)
2230 __GLXcontext
*const gc
= __glXGetCurrentContext();
2231 const GLuint cmdlen
= 12;
2232 emit_header(gc
->pc
, X_GLrop_ColorMaterial
, cmdlen
);
2233 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&face
), 4);
2234 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&mode
), 4);
2236 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
2237 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
2241 #define X_GLrop_CullFace 79
2243 __indirect_glCullFace(GLenum mode
)
2245 __GLXcontext
*const gc
= __glXGetCurrentContext();
2246 const GLuint cmdlen
= 8;
2247 emit_header(gc
->pc
, X_GLrop_CullFace
, cmdlen
);
2248 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&mode
), 4);
2250 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
2251 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
2255 #define X_GLrop_Fogf 80
2257 __indirect_glFogf(GLenum pname
, GLfloat param
)
2259 __GLXcontext
*const gc
= __glXGetCurrentContext();
2260 const GLuint cmdlen
= 12;
2261 emit_header(gc
->pc
, X_GLrop_Fogf
, cmdlen
);
2262 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&pname
), 4);
2263 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (¶m
), 4);
2265 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
2266 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
2270 #define X_GLrop_Fogfv 81
2272 __indirect_glFogfv(GLenum pname
, const GLfloat
* params
)
2274 __GLXcontext
*const gc
= __glXGetCurrentContext();
2275 const GLuint compsize
= __glFogfv_size(pname
);
2276 const GLuint cmdlen
= 8 + __GLX_PAD((compsize
* 4));
2277 emit_header(gc
->pc
, X_GLrop_Fogfv
, cmdlen
);
2278 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&pname
), 4);
2279 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (params
), (compsize
* 4));
2281 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
2282 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
2286 #define X_GLrop_Fogi 82
2288 __indirect_glFogi(GLenum pname
, GLint param
)
2290 __GLXcontext
*const gc
= __glXGetCurrentContext();
2291 const GLuint cmdlen
= 12;
2292 emit_header(gc
->pc
, X_GLrop_Fogi
, cmdlen
);
2293 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&pname
), 4);
2294 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (¶m
), 4);
2296 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
2297 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
2301 #define X_GLrop_Fogiv 83
2303 __indirect_glFogiv(GLenum pname
, const GLint
* params
)
2305 __GLXcontext
*const gc
= __glXGetCurrentContext();
2306 const GLuint compsize
= __glFogiv_size(pname
);
2307 const GLuint cmdlen
= 8 + __GLX_PAD((compsize
* 4));
2308 emit_header(gc
->pc
, X_GLrop_Fogiv
, cmdlen
);
2309 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&pname
), 4);
2310 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (params
), (compsize
* 4));
2312 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
2313 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
2317 #define X_GLrop_FrontFace 84
2319 __indirect_glFrontFace(GLenum mode
)
2321 __GLXcontext
*const gc
= __glXGetCurrentContext();
2322 const GLuint cmdlen
= 8;
2323 emit_header(gc
->pc
, X_GLrop_FrontFace
, cmdlen
);
2324 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&mode
), 4);
2326 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
2327 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
2331 #define X_GLrop_Hint 85
2333 __indirect_glHint(GLenum target
, GLenum mode
)
2335 __GLXcontext
*const gc
= __glXGetCurrentContext();
2336 const GLuint cmdlen
= 12;
2337 emit_header(gc
->pc
, X_GLrop_Hint
, cmdlen
);
2338 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&target
), 4);
2339 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&mode
), 4);
2341 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
2342 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
2346 #define X_GLrop_Lightf 86
2348 __indirect_glLightf(GLenum light
, GLenum pname
, GLfloat param
)
2350 __GLXcontext
*const gc
= __glXGetCurrentContext();
2351 const GLuint cmdlen
= 16;
2352 emit_header(gc
->pc
, X_GLrop_Lightf
, cmdlen
);
2353 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&light
), 4);
2354 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&pname
), 4);
2355 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (¶m
), 4);
2357 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
2358 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
2362 #define X_GLrop_Lightfv 87
2364 __indirect_glLightfv(GLenum light
, GLenum pname
, const GLfloat
* params
)
2366 __GLXcontext
*const gc
= __glXGetCurrentContext();
2367 const GLuint compsize
= __glLightfv_size(pname
);
2368 const GLuint cmdlen
= 12 + __GLX_PAD((compsize
* 4));
2369 emit_header(gc
->pc
, X_GLrop_Lightfv
, cmdlen
);
2370 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&light
), 4);
2371 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&pname
), 4);
2372 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (params
), (compsize
* 4));
2374 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
2375 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
2379 #define X_GLrop_Lighti 88
2381 __indirect_glLighti(GLenum light
, GLenum pname
, GLint param
)
2383 __GLXcontext
*const gc
= __glXGetCurrentContext();
2384 const GLuint cmdlen
= 16;
2385 emit_header(gc
->pc
, X_GLrop_Lighti
, cmdlen
);
2386 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&light
), 4);
2387 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&pname
), 4);
2388 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (¶m
), 4);
2390 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
2391 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
2395 #define X_GLrop_Lightiv 89
2397 __indirect_glLightiv(GLenum light
, GLenum pname
, const GLint
* params
)
2399 __GLXcontext
*const gc
= __glXGetCurrentContext();
2400 const GLuint compsize
= __glLightiv_size(pname
);
2401 const GLuint cmdlen
= 12 + __GLX_PAD((compsize
* 4));
2402 emit_header(gc
->pc
, X_GLrop_Lightiv
, cmdlen
);
2403 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&light
), 4);
2404 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&pname
), 4);
2405 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (params
), (compsize
* 4));
2407 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
2408 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
2412 #define X_GLrop_LightModelf 90
2414 __indirect_glLightModelf(GLenum pname
, GLfloat param
)
2416 __GLXcontext
*const gc
= __glXGetCurrentContext();
2417 const GLuint cmdlen
= 12;
2418 emit_header(gc
->pc
, X_GLrop_LightModelf
, cmdlen
);
2419 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&pname
), 4);
2420 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (¶m
), 4);
2422 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
2423 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
2427 #define X_GLrop_LightModelfv 91
2429 __indirect_glLightModelfv(GLenum pname
, const GLfloat
* params
)
2431 __GLXcontext
*const gc
= __glXGetCurrentContext();
2432 const GLuint compsize
= __glLightModelfv_size(pname
);
2433 const GLuint cmdlen
= 8 + __GLX_PAD((compsize
* 4));
2434 emit_header(gc
->pc
, X_GLrop_LightModelfv
, cmdlen
);
2435 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&pname
), 4);
2436 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (params
), (compsize
* 4));
2438 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
2439 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
2443 #define X_GLrop_LightModeli 92
2445 __indirect_glLightModeli(GLenum pname
, GLint param
)
2447 __GLXcontext
*const gc
= __glXGetCurrentContext();
2448 const GLuint cmdlen
= 12;
2449 emit_header(gc
->pc
, X_GLrop_LightModeli
, cmdlen
);
2450 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&pname
), 4);
2451 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (¶m
), 4);
2453 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
2454 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
2458 #define X_GLrop_LightModeliv 93
2460 __indirect_glLightModeliv(GLenum pname
, const GLint
* params
)
2462 __GLXcontext
*const gc
= __glXGetCurrentContext();
2463 const GLuint compsize
= __glLightModeliv_size(pname
);
2464 const GLuint cmdlen
= 8 + __GLX_PAD((compsize
* 4));
2465 emit_header(gc
->pc
, X_GLrop_LightModeliv
, cmdlen
);
2466 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&pname
), 4);
2467 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (params
), (compsize
* 4));
2469 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
2470 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
2474 #define X_GLrop_LineStipple 94
2476 __indirect_glLineStipple(GLint factor
, GLushort pattern
)
2478 __GLXcontext
*const gc
= __glXGetCurrentContext();
2479 const GLuint cmdlen
= 12;
2480 emit_header(gc
->pc
, X_GLrop_LineStipple
, cmdlen
);
2481 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&factor
), 4);
2482 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&pattern
), 2);
2484 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
2485 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
2489 #define X_GLrop_LineWidth 95
2491 __indirect_glLineWidth(GLfloat width
)
2493 __GLXcontext
*const gc
= __glXGetCurrentContext();
2494 const GLuint cmdlen
= 8;
2495 emit_header(gc
->pc
, X_GLrop_LineWidth
, cmdlen
);
2496 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&width
), 4);
2498 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
2499 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
2503 #define X_GLrop_Materialf 96
2505 __indirect_glMaterialf(GLenum face
, GLenum pname
, GLfloat param
)
2507 __GLXcontext
*const gc
= __glXGetCurrentContext();
2508 const GLuint cmdlen
= 16;
2509 emit_header(gc
->pc
, X_GLrop_Materialf
, cmdlen
);
2510 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&face
), 4);
2511 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&pname
), 4);
2512 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (¶m
), 4);
2514 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
2515 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
2519 #define X_GLrop_Materialfv 97
2521 __indirect_glMaterialfv(GLenum face
, GLenum pname
, const GLfloat
* params
)
2523 __GLXcontext
*const gc
= __glXGetCurrentContext();
2524 const GLuint compsize
= __glMaterialfv_size(pname
);
2525 const GLuint cmdlen
= 12 + __GLX_PAD((compsize
* 4));
2526 emit_header(gc
->pc
, X_GLrop_Materialfv
, cmdlen
);
2527 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&face
), 4);
2528 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&pname
), 4);
2529 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (params
), (compsize
* 4));
2531 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
2532 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
2536 #define X_GLrop_Materiali 98
2538 __indirect_glMateriali(GLenum face
, GLenum pname
, GLint param
)
2540 __GLXcontext
*const gc
= __glXGetCurrentContext();
2541 const GLuint cmdlen
= 16;
2542 emit_header(gc
->pc
, X_GLrop_Materiali
, cmdlen
);
2543 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&face
), 4);
2544 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&pname
), 4);
2545 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (¶m
), 4);
2547 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
2548 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
2552 #define X_GLrop_Materialiv 99
2554 __indirect_glMaterialiv(GLenum face
, GLenum pname
, const GLint
* params
)
2556 __GLXcontext
*const gc
= __glXGetCurrentContext();
2557 const GLuint compsize
= __glMaterialiv_size(pname
);
2558 const GLuint cmdlen
= 12 + __GLX_PAD((compsize
* 4));
2559 emit_header(gc
->pc
, X_GLrop_Materialiv
, cmdlen
);
2560 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&face
), 4);
2561 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&pname
), 4);
2562 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (params
), (compsize
* 4));
2564 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
2565 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
2569 #define X_GLrop_PointSize 100
2571 __indirect_glPointSize(GLfloat size
)
2573 __GLXcontext
*const gc
= __glXGetCurrentContext();
2574 const GLuint cmdlen
= 8;
2575 emit_header(gc
->pc
, X_GLrop_PointSize
, cmdlen
);
2576 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&size
), 4);
2578 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
2579 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
2583 #define X_GLrop_PolygonMode 101
2585 __indirect_glPolygonMode(GLenum face
, GLenum mode
)
2587 __GLXcontext
*const gc
= __glXGetCurrentContext();
2588 const GLuint cmdlen
= 12;
2589 emit_header(gc
->pc
, X_GLrop_PolygonMode
, cmdlen
);
2590 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&face
), 4);
2591 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&mode
), 4);
2593 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
2594 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
2598 #define X_GLrop_PolygonStipple 102
2600 __indirect_glPolygonStipple(const GLubyte
*mask
)
2602 __GLXcontext
*const gc
= __glXGetCurrentContext();
2603 const GLuint compsize
=
2604 (mask
!= NULL
) ? __glImageSize(32, 32, 1, GL_COLOR_INDEX
, GL_BITMAP
,
2606 const GLuint cmdlen
= 24 + __GLX_PAD(compsize
);
2607 emit_header(gc
->pc
, X_GLrop_PolygonStipple
, cmdlen
);
2609 (*gc
->fillImage
) (gc
, 2, 32, 32, 1, GL_COLOR_INDEX
, GL_BITMAP
, mask
,
2610 gc
->pc
+ 24, gc
->pc
+ 4);
2612 (void) memcpy(gc
->pc
+ 4, default_pixel_store_2D
,
2613 default_pixel_store_2D_size
);
2616 if (gc
->pc
> gc
->limit
) {
2617 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
2621 #define X_GLrop_Scissor 103
2623 __indirect_glScissor(GLint x
, GLint y
, GLsizei width
, GLsizei height
)
2625 __GLXcontext
*const gc
= __glXGetCurrentContext();
2626 const GLuint cmdlen
= 20;
2627 emit_header(gc
->pc
, X_GLrop_Scissor
, cmdlen
);
2628 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&x
), 4);
2629 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&y
), 4);
2630 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&width
), 4);
2631 (void) memcpy((void *) (gc
->pc
+ 16), (void *) (&height
), 4);
2633 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
2634 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
2638 #define X_GLrop_ShadeModel 104
2640 __indirect_glShadeModel(GLenum mode
)
2642 __GLXcontext
*const gc
= __glXGetCurrentContext();
2643 const GLuint cmdlen
= 8;
2644 emit_header(gc
->pc
, X_GLrop_ShadeModel
, cmdlen
);
2645 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&mode
), 4);
2647 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
2648 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
2652 #define X_GLrop_TexParameterf 105
2654 __indirect_glTexParameterf(GLenum target
, GLenum pname
, GLfloat param
)
2656 __GLXcontext
*const gc
= __glXGetCurrentContext();
2657 const GLuint cmdlen
= 16;
2658 emit_header(gc
->pc
, X_GLrop_TexParameterf
, cmdlen
);
2659 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&target
), 4);
2660 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&pname
), 4);
2661 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (¶m
), 4);
2663 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
2664 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
2668 #define X_GLrop_TexParameterfv 106
2670 __indirect_glTexParameterfv(GLenum target
, GLenum pname
,
2671 const GLfloat
* params
)
2673 __GLXcontext
*const gc
= __glXGetCurrentContext();
2674 const GLuint compsize
= __glTexParameterfv_size(pname
);
2675 const GLuint cmdlen
= 12 + __GLX_PAD((compsize
* 4));
2676 emit_header(gc
->pc
, X_GLrop_TexParameterfv
, cmdlen
);
2677 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&target
), 4);
2678 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&pname
), 4);
2679 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (params
), (compsize
* 4));
2681 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
2682 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
2686 #define X_GLrop_TexParameteri 107
2688 __indirect_glTexParameteri(GLenum target
, GLenum pname
, GLint param
)
2690 __GLXcontext
*const gc
= __glXGetCurrentContext();
2691 const GLuint cmdlen
= 16;
2692 emit_header(gc
->pc
, X_GLrop_TexParameteri
, cmdlen
);
2693 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&target
), 4);
2694 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&pname
), 4);
2695 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (¶m
), 4);
2697 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
2698 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
2702 #define X_GLrop_TexParameteriv 108
2704 __indirect_glTexParameteriv(GLenum target
, GLenum pname
, const GLint
* params
)
2706 __GLXcontext
*const gc
= __glXGetCurrentContext();
2707 const GLuint compsize
= __glTexParameteriv_size(pname
);
2708 const GLuint cmdlen
= 12 + __GLX_PAD((compsize
* 4));
2709 emit_header(gc
->pc
, X_GLrop_TexParameteriv
, cmdlen
);
2710 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&target
), 4);
2711 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&pname
), 4);
2712 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (params
), (compsize
* 4));
2714 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
2715 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
2720 __glx_TexImage_1D2D(unsigned opcode
, unsigned dim
, GLenum target
, GLint level
,
2721 GLint internalformat
, GLsizei width
, GLsizei height
,
2722 GLint border
, GLenum format
, GLenum type
,
2723 const GLvoid
* pixels
)
2725 __GLXcontext
*const gc
= __glXGetCurrentContext();
2726 const GLuint compsize
=
2727 __glImageSize(width
, height
, 1, format
, type
, target
);
2728 const GLuint cmdlen
= 56 + __GLX_PAD(compsize
);
2729 if (__builtin_expect(gc
->currentDpy
!= NULL
, 1)) {
2730 if (cmdlen
<= gc
->maxSmallRenderCommandSize
) {
2731 if ((gc
->pc
+ cmdlen
) > gc
->bufEnd
) {
2732 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
2734 emit_header(gc
->pc
, opcode
, cmdlen
);
2735 (void) memcpy((void *) (gc
->pc
+ 24), (void *) (&target
), 4);
2736 (void) memcpy((void *) (gc
->pc
+ 28), (void *) (&level
), 4);
2737 (void) memcpy((void *) (gc
->pc
+ 32), (void *) (&internalformat
),
2739 (void) memcpy((void *) (gc
->pc
+ 36), (void *) (&width
), 4);
2740 (void) memcpy((void *) (gc
->pc
+ 40), (void *) (&height
), 4);
2741 (void) memcpy((void *) (gc
->pc
+ 44), (void *) (&border
), 4);
2742 (void) memcpy((void *) (gc
->pc
+ 48), (void *) (&format
), 4);
2743 (void) memcpy((void *) (gc
->pc
+ 52), (void *) (&type
), 4);
2744 if ((compsize
> 0) && (pixels
!= NULL
)) {
2745 (*gc
->fillImage
) (gc
, dim
, width
, height
, 1, format
, type
,
2746 pixels
, gc
->pc
+ 56, gc
->pc
+ 4);
2748 (void) memcpy(gc
->pc
+ 4, default_pixel_store_2D
,
2749 default_pixel_store_2D_size
);
2752 if (gc
->pc
> gc
->limit
) {
2753 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
2756 const GLint op
= opcode
;
2757 const GLuint cmdlenLarge
= cmdlen
+ 4;
2758 GLubyte
*const pc
= __glXFlushRenderBuffer(gc
, gc
->pc
);
2759 (void) memcpy((void *) (pc
+ 0), (void *) (&cmdlenLarge
), 4);
2760 (void) memcpy((void *) (pc
+ 4), (void *) (&op
), 4);
2761 (void) memcpy((void *) (pc
+ 28), (void *) (&target
), 4);
2762 (void) memcpy((void *) (pc
+ 32), (void *) (&level
), 4);
2763 (void) memcpy((void *) (pc
+ 36), (void *) (&internalformat
), 4);
2764 (void) memcpy((void *) (pc
+ 40), (void *) (&width
), 4);
2765 (void) memcpy((void *) (pc
+ 44), (void *) (&height
), 4);
2766 (void) memcpy((void *) (pc
+ 48), (void *) (&border
), 4);
2767 (void) memcpy((void *) (pc
+ 52), (void *) (&format
), 4);
2768 (void) memcpy((void *) (pc
+ 56), (void *) (&type
), 4);
2769 __glXSendLargeImage(gc
, compsize
, dim
, width
, height
, 1, format
,
2770 type
, pixels
, pc
+ 60, pc
+ 8);
2775 #define X_GLrop_TexImage1D 109
2777 __indirect_glTexImage1D(GLenum target
, GLint level
, GLint internalformat
,
2778 GLsizei width
, GLint border
, GLenum format
,
2779 GLenum type
, const GLvoid
* pixels
)
2781 __glx_TexImage_1D2D(X_GLrop_TexImage1D
, 1, target
, level
, internalformat
,
2782 width
, 1, border
, format
, type
, pixels
);
2785 #define X_GLrop_TexImage2D 110
2787 __indirect_glTexImage2D(GLenum target
, GLint level
, GLint internalformat
,
2788 GLsizei width
, GLsizei height
, GLint border
,
2789 GLenum format
, GLenum type
, const GLvoid
* pixels
)
2791 __glx_TexImage_1D2D(X_GLrop_TexImage2D
, 2, target
, level
, internalformat
,
2792 width
, height
, border
, format
, type
, pixels
);
2795 #define X_GLrop_TexEnvf 111
2797 __indirect_glTexEnvf(GLenum target
, GLenum pname
, GLfloat param
)
2799 __GLXcontext
*const gc
= __glXGetCurrentContext();
2800 const GLuint cmdlen
= 16;
2801 emit_header(gc
->pc
, X_GLrop_TexEnvf
, cmdlen
);
2802 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&target
), 4);
2803 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&pname
), 4);
2804 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (¶m
), 4);
2806 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
2807 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
2811 #define X_GLrop_TexEnvfv 112
2813 __indirect_glTexEnvfv(GLenum target
, GLenum pname
, const GLfloat
* params
)
2815 __GLXcontext
*const gc
= __glXGetCurrentContext();
2816 const GLuint compsize
= __glTexEnvfv_size(pname
);
2817 const GLuint cmdlen
= 12 + __GLX_PAD((compsize
* 4));
2818 emit_header(gc
->pc
, X_GLrop_TexEnvfv
, cmdlen
);
2819 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&target
), 4);
2820 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&pname
), 4);
2821 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (params
), (compsize
* 4));
2823 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
2824 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
2828 #define X_GLrop_TexEnvi 113
2830 __indirect_glTexEnvi(GLenum target
, GLenum pname
, GLint param
)
2832 __GLXcontext
*const gc
= __glXGetCurrentContext();
2833 const GLuint cmdlen
= 16;
2834 emit_header(gc
->pc
, X_GLrop_TexEnvi
, cmdlen
);
2835 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&target
), 4);
2836 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&pname
), 4);
2837 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (¶m
), 4);
2839 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
2840 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
2844 #define X_GLrop_TexEnviv 114
2846 __indirect_glTexEnviv(GLenum target
, GLenum pname
, const GLint
* params
)
2848 __GLXcontext
*const gc
= __glXGetCurrentContext();
2849 const GLuint compsize
= __glTexEnviv_size(pname
);
2850 const GLuint cmdlen
= 12 + __GLX_PAD((compsize
* 4));
2851 emit_header(gc
->pc
, X_GLrop_TexEnviv
, cmdlen
);
2852 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&target
), 4);
2853 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&pname
), 4);
2854 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (params
), (compsize
* 4));
2856 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
2857 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
2861 #define X_GLrop_TexGend 115
2863 __indirect_glTexGend(GLenum coord
, GLenum pname
, GLdouble param
)
2865 __GLXcontext
*const gc
= __glXGetCurrentContext();
2866 const GLuint cmdlen
= 20;
2867 emit_header(gc
->pc
, X_GLrop_TexGend
, cmdlen
);
2868 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (¶m
), 8);
2869 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&coord
), 4);
2870 (void) memcpy((void *) (gc
->pc
+ 16), (void *) (&pname
), 4);
2872 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
2873 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
2877 #define X_GLrop_TexGendv 116
2879 __indirect_glTexGendv(GLenum coord
, GLenum pname
, const GLdouble
* params
)
2881 __GLXcontext
*const gc
= __glXGetCurrentContext();
2882 const GLuint compsize
= __glTexGendv_size(pname
);
2883 const GLuint cmdlen
= 12 + __GLX_PAD((compsize
* 8));
2884 emit_header(gc
->pc
, X_GLrop_TexGendv
, cmdlen
);
2885 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&coord
), 4);
2886 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&pname
), 4);
2887 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (params
), (compsize
* 8));
2889 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
2890 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
2894 #define X_GLrop_TexGenf 117
2896 __indirect_glTexGenf(GLenum coord
, GLenum pname
, GLfloat param
)
2898 __GLXcontext
*const gc
= __glXGetCurrentContext();
2899 const GLuint cmdlen
= 16;
2900 emit_header(gc
->pc
, X_GLrop_TexGenf
, cmdlen
);
2901 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&coord
), 4);
2902 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&pname
), 4);
2903 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (¶m
), 4);
2905 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
2906 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
2910 #define X_GLrop_TexGenfv 118
2912 __indirect_glTexGenfv(GLenum coord
, GLenum pname
, const GLfloat
* params
)
2914 __GLXcontext
*const gc
= __glXGetCurrentContext();
2915 const GLuint compsize
= __glTexGenfv_size(pname
);
2916 const GLuint cmdlen
= 12 + __GLX_PAD((compsize
* 4));
2917 emit_header(gc
->pc
, X_GLrop_TexGenfv
, cmdlen
);
2918 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&coord
), 4);
2919 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&pname
), 4);
2920 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (params
), (compsize
* 4));
2922 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
2923 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
2927 #define X_GLrop_TexGeni 119
2929 __indirect_glTexGeni(GLenum coord
, GLenum pname
, GLint param
)
2931 __GLXcontext
*const gc
= __glXGetCurrentContext();
2932 const GLuint cmdlen
= 16;
2933 emit_header(gc
->pc
, X_GLrop_TexGeni
, cmdlen
);
2934 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&coord
), 4);
2935 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&pname
), 4);
2936 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (¶m
), 4);
2938 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
2939 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
2943 #define X_GLrop_TexGeniv 120
2945 __indirect_glTexGeniv(GLenum coord
, GLenum pname
, const GLint
* params
)
2947 __GLXcontext
*const gc
= __glXGetCurrentContext();
2948 const GLuint compsize
= __glTexGeniv_size(pname
);
2949 const GLuint cmdlen
= 12 + __GLX_PAD((compsize
* 4));
2950 emit_header(gc
->pc
, X_GLrop_TexGeniv
, cmdlen
);
2951 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&coord
), 4);
2952 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&pname
), 4);
2953 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (params
), (compsize
* 4));
2955 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
2956 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
2960 #define X_GLrop_InitNames 121
2962 __indirect_glInitNames(void)
2964 __GLXcontext
*const gc
= __glXGetCurrentContext();
2965 const GLuint cmdlen
= 4;
2966 emit_header(gc
->pc
, X_GLrop_InitNames
, cmdlen
);
2968 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
2969 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
2973 #define X_GLrop_LoadName 122
2975 __indirect_glLoadName(GLuint name
)
2977 __GLXcontext
*const gc
= __glXGetCurrentContext();
2978 const GLuint cmdlen
= 8;
2979 emit_header(gc
->pc
, X_GLrop_LoadName
, cmdlen
);
2980 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&name
), 4);
2982 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
2983 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
2987 #define X_GLrop_PassThrough 123
2989 __indirect_glPassThrough(GLfloat token
)
2991 __GLXcontext
*const gc
= __glXGetCurrentContext();
2992 const GLuint cmdlen
= 8;
2993 emit_header(gc
->pc
, X_GLrop_PassThrough
, cmdlen
);
2994 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&token
), 4);
2996 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
2997 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
3001 #define X_GLrop_PopName 124
3003 __indirect_glPopName(void)
3005 __GLXcontext
*const gc
= __glXGetCurrentContext();
3006 const GLuint cmdlen
= 4;
3007 emit_header(gc
->pc
, X_GLrop_PopName
, cmdlen
);
3009 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
3010 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
3014 #define X_GLrop_PushName 125
3016 __indirect_glPushName(GLuint name
)
3018 __GLXcontext
*const gc
= __glXGetCurrentContext();
3019 const GLuint cmdlen
= 8;
3020 emit_header(gc
->pc
, X_GLrop_PushName
, cmdlen
);
3021 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&name
), 4);
3023 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
3024 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
3028 #define X_GLrop_DrawBuffer 126
3030 __indirect_glDrawBuffer(GLenum mode
)
3032 __GLXcontext
*const gc
= __glXGetCurrentContext();
3033 const GLuint cmdlen
= 8;
3034 emit_header(gc
->pc
, X_GLrop_DrawBuffer
, cmdlen
);
3035 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&mode
), 4);
3037 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
3038 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
3042 #define X_GLrop_Clear 127
3044 __indirect_glClear(GLbitfield mask
)
3046 __GLXcontext
*const gc
= __glXGetCurrentContext();
3047 const GLuint cmdlen
= 8;
3048 emit_header(gc
->pc
, X_GLrop_Clear
, cmdlen
);
3049 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&mask
), 4);
3051 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
3052 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
3056 #define X_GLrop_ClearAccum 128
3058 __indirect_glClearAccum(GLfloat red
, GLfloat green
, GLfloat blue
,
3061 __GLXcontext
*const gc
= __glXGetCurrentContext();
3062 const GLuint cmdlen
= 20;
3063 emit_header(gc
->pc
, X_GLrop_ClearAccum
, cmdlen
);
3064 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&red
), 4);
3065 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&green
), 4);
3066 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&blue
), 4);
3067 (void) memcpy((void *) (gc
->pc
+ 16), (void *) (&alpha
), 4);
3069 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
3070 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
3074 #define X_GLrop_ClearIndex 129
3076 __indirect_glClearIndex(GLfloat c
)
3078 __GLXcontext
*const gc
= __glXGetCurrentContext();
3079 const GLuint cmdlen
= 8;
3080 emit_header(gc
->pc
, X_GLrop_ClearIndex
, cmdlen
);
3081 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&c
), 4);
3083 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
3084 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
3088 #define X_GLrop_ClearColor 130
3090 __indirect_glClearColor(GLclampf red
, GLclampf green
, GLclampf blue
,
3093 __GLXcontext
*const gc
= __glXGetCurrentContext();
3094 const GLuint cmdlen
= 20;
3095 emit_header(gc
->pc
, X_GLrop_ClearColor
, cmdlen
);
3096 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&red
), 4);
3097 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&green
), 4);
3098 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&blue
), 4);
3099 (void) memcpy((void *) (gc
->pc
+ 16), (void *) (&alpha
), 4);
3101 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
3102 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
3106 #define X_GLrop_ClearStencil 131
3108 __indirect_glClearStencil(GLint s
)
3110 __GLXcontext
*const gc
= __glXGetCurrentContext();
3111 const GLuint cmdlen
= 8;
3112 emit_header(gc
->pc
, X_GLrop_ClearStencil
, cmdlen
);
3113 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&s
), 4);
3115 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
3116 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
3120 #define X_GLrop_ClearDepth 132
3122 __indirect_glClearDepth(GLclampd depth
)
3124 __GLXcontext
*const gc
= __glXGetCurrentContext();
3125 const GLuint cmdlen
= 12;
3126 emit_header(gc
->pc
, X_GLrop_ClearDepth
, cmdlen
);
3127 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&depth
), 8);
3129 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
3130 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
3134 #define X_GLrop_StencilMask 133
3136 __indirect_glStencilMask(GLuint mask
)
3138 __GLXcontext
*const gc
= __glXGetCurrentContext();
3139 const GLuint cmdlen
= 8;
3140 emit_header(gc
->pc
, X_GLrop_StencilMask
, cmdlen
);
3141 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&mask
), 4);
3143 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
3144 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
3148 #define X_GLrop_ColorMask 134
3150 __indirect_glColorMask(GLboolean red
, GLboolean green
, GLboolean blue
,
3153 __GLXcontext
*const gc
= __glXGetCurrentContext();
3154 const GLuint cmdlen
= 8;
3155 emit_header(gc
->pc
, X_GLrop_ColorMask
, cmdlen
);
3156 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&red
), 1);
3157 (void) memcpy((void *) (gc
->pc
+ 5), (void *) (&green
), 1);
3158 (void) memcpy((void *) (gc
->pc
+ 6), (void *) (&blue
), 1);
3159 (void) memcpy((void *) (gc
->pc
+ 7), (void *) (&alpha
), 1);
3161 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
3162 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
3166 #define X_GLrop_DepthMask 135
3168 __indirect_glDepthMask(GLboolean flag
)
3170 __GLXcontext
*const gc
= __glXGetCurrentContext();
3171 const GLuint cmdlen
= 8;
3172 emit_header(gc
->pc
, X_GLrop_DepthMask
, cmdlen
);
3173 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&flag
), 1);
3175 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
3176 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
3180 #define X_GLrop_IndexMask 136
3182 __indirect_glIndexMask(GLuint mask
)
3184 __GLXcontext
*const gc
= __glXGetCurrentContext();
3185 const GLuint cmdlen
= 8;
3186 emit_header(gc
->pc
, X_GLrop_IndexMask
, cmdlen
);
3187 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&mask
), 4);
3189 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
3190 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
3194 #define X_GLrop_Accum 137
3196 __indirect_glAccum(GLenum op
, GLfloat value
)
3198 __GLXcontext
*const gc
= __glXGetCurrentContext();
3199 const GLuint cmdlen
= 12;
3200 emit_header(gc
->pc
, X_GLrop_Accum
, cmdlen
);
3201 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&op
), 4);
3202 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&value
), 4);
3204 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
3205 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
3209 #define X_GLrop_PopAttrib 141
3211 __indirect_glPopAttrib(void)
3213 __GLXcontext
*const gc
= __glXGetCurrentContext();
3214 const GLuint cmdlen
= 4;
3215 emit_header(gc
->pc
, X_GLrop_PopAttrib
, cmdlen
);
3217 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
3218 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
3222 #define X_GLrop_PushAttrib 142
3224 __indirect_glPushAttrib(GLbitfield mask
)
3226 __GLXcontext
*const gc
= __glXGetCurrentContext();
3227 const GLuint cmdlen
= 8;
3228 emit_header(gc
->pc
, X_GLrop_PushAttrib
, cmdlen
);
3229 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&mask
), 4);
3231 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
3232 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
3236 #define X_GLrop_MapGrid1d 147
3238 __indirect_glMapGrid1d(GLint un
, GLdouble u1
, GLdouble u2
)
3240 __GLXcontext
*const gc
= __glXGetCurrentContext();
3241 const GLuint cmdlen
= 24;
3242 emit_header(gc
->pc
, X_GLrop_MapGrid1d
, cmdlen
);
3243 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&u1
), 8);
3244 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&u2
), 8);
3245 (void) memcpy((void *) (gc
->pc
+ 20), (void *) (&un
), 4);
3247 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
3248 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
3252 #define X_GLrop_MapGrid1f 148
3254 __indirect_glMapGrid1f(GLint un
, GLfloat u1
, GLfloat u2
)
3256 __GLXcontext
*const gc
= __glXGetCurrentContext();
3257 const GLuint cmdlen
= 16;
3258 emit_header(gc
->pc
, X_GLrop_MapGrid1f
, cmdlen
);
3259 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&un
), 4);
3260 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&u1
), 4);
3261 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&u2
), 4);
3263 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
3264 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
3268 #define X_GLrop_MapGrid2d 149
3270 __indirect_glMapGrid2d(GLint un
, GLdouble u1
, GLdouble u2
, GLint vn
,
3271 GLdouble v1
, GLdouble v2
)
3273 __GLXcontext
*const gc
= __glXGetCurrentContext();
3274 const GLuint cmdlen
= 44;
3275 emit_header(gc
->pc
, X_GLrop_MapGrid2d
, cmdlen
);
3276 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&u1
), 8);
3277 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&u2
), 8);
3278 (void) memcpy((void *) (gc
->pc
+ 20), (void *) (&v1
), 8);
3279 (void) memcpy((void *) (gc
->pc
+ 28), (void *) (&v2
), 8);
3280 (void) memcpy((void *) (gc
->pc
+ 36), (void *) (&un
), 4);
3281 (void) memcpy((void *) (gc
->pc
+ 40), (void *) (&vn
), 4);
3283 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
3284 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
3288 #define X_GLrop_MapGrid2f 150
3290 __indirect_glMapGrid2f(GLint un
, GLfloat u1
, GLfloat u2
, GLint vn
, GLfloat v1
,
3293 __GLXcontext
*const gc
= __glXGetCurrentContext();
3294 const GLuint cmdlen
= 28;
3295 emit_header(gc
->pc
, X_GLrop_MapGrid2f
, cmdlen
);
3296 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&un
), 4);
3297 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&u1
), 4);
3298 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&u2
), 4);
3299 (void) memcpy((void *) (gc
->pc
+ 16), (void *) (&vn
), 4);
3300 (void) memcpy((void *) (gc
->pc
+ 20), (void *) (&v1
), 4);
3301 (void) memcpy((void *) (gc
->pc
+ 24), (void *) (&v2
), 4);
3303 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
3304 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
3308 #define X_GLrop_EvalCoord1dv 151
3310 __indirect_glEvalCoord1d(GLdouble u
)
3312 __GLXcontext
*const gc
= __glXGetCurrentContext();
3313 const GLuint cmdlen
= 12;
3314 emit_header(gc
->pc
, X_GLrop_EvalCoord1dv
, cmdlen
);
3315 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&u
), 8);
3317 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
3318 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
3322 #define X_GLrop_EvalCoord1dv 151
3324 __indirect_glEvalCoord1dv(const GLdouble
* u
)
3326 generic_8_byte(X_GLrop_EvalCoord1dv
, u
);
3329 #define X_GLrop_EvalCoord1fv 152
3331 __indirect_glEvalCoord1f(GLfloat u
)
3333 __GLXcontext
*const gc
= __glXGetCurrentContext();
3334 const GLuint cmdlen
= 8;
3335 emit_header(gc
->pc
, X_GLrop_EvalCoord1fv
, cmdlen
);
3336 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&u
), 4);
3338 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
3339 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
3343 #define X_GLrop_EvalCoord1fv 152
3345 __indirect_glEvalCoord1fv(const GLfloat
* u
)
3347 generic_4_byte(X_GLrop_EvalCoord1fv
, u
);
3350 #define X_GLrop_EvalCoord2dv 153
3352 __indirect_glEvalCoord2d(GLdouble u
, GLdouble v
)
3354 __GLXcontext
*const gc
= __glXGetCurrentContext();
3355 const GLuint cmdlen
= 20;
3356 emit_header(gc
->pc
, X_GLrop_EvalCoord2dv
, cmdlen
);
3357 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&u
), 8);
3358 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&v
), 8);
3360 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
3361 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
3365 #define X_GLrop_EvalCoord2dv 153
3367 __indirect_glEvalCoord2dv(const GLdouble
* u
)
3369 generic_16_byte(X_GLrop_EvalCoord2dv
, u
);
3372 #define X_GLrop_EvalCoord2fv 154
3374 __indirect_glEvalCoord2f(GLfloat u
, GLfloat v
)
3376 __GLXcontext
*const gc
= __glXGetCurrentContext();
3377 const GLuint cmdlen
= 12;
3378 emit_header(gc
->pc
, X_GLrop_EvalCoord2fv
, cmdlen
);
3379 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&u
), 4);
3380 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&v
), 4);
3382 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
3383 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
3387 #define X_GLrop_EvalCoord2fv 154
3389 __indirect_glEvalCoord2fv(const GLfloat
* u
)
3391 generic_8_byte(X_GLrop_EvalCoord2fv
, u
);
3394 #define X_GLrop_EvalMesh1 155
3396 __indirect_glEvalMesh1(GLenum mode
, GLint i1
, GLint i2
)
3398 __GLXcontext
*const gc
= __glXGetCurrentContext();
3399 const GLuint cmdlen
= 16;
3400 emit_header(gc
->pc
, X_GLrop_EvalMesh1
, cmdlen
);
3401 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&mode
), 4);
3402 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&i1
), 4);
3403 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&i2
), 4);
3405 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
3406 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
3410 #define X_GLrop_EvalPoint1 156
3412 __indirect_glEvalPoint1(GLint i
)
3414 __GLXcontext
*const gc
= __glXGetCurrentContext();
3415 const GLuint cmdlen
= 8;
3416 emit_header(gc
->pc
, X_GLrop_EvalPoint1
, cmdlen
);
3417 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&i
), 4);
3419 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
3420 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
3424 #define X_GLrop_EvalMesh2 157
3426 __indirect_glEvalMesh2(GLenum mode
, GLint i1
, GLint i2
, GLint j1
, GLint j2
)
3428 __GLXcontext
*const gc
= __glXGetCurrentContext();
3429 const GLuint cmdlen
= 24;
3430 emit_header(gc
->pc
, X_GLrop_EvalMesh2
, cmdlen
);
3431 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&mode
), 4);
3432 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&i1
), 4);
3433 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&i2
), 4);
3434 (void) memcpy((void *) (gc
->pc
+ 16), (void *) (&j1
), 4);
3435 (void) memcpy((void *) (gc
->pc
+ 20), (void *) (&j2
), 4);
3437 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
3438 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
3442 #define X_GLrop_EvalPoint2 158
3444 __indirect_glEvalPoint2(GLint i
, GLint j
)
3446 __GLXcontext
*const gc
= __glXGetCurrentContext();
3447 const GLuint cmdlen
= 12;
3448 emit_header(gc
->pc
, X_GLrop_EvalPoint2
, cmdlen
);
3449 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&i
), 4);
3450 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&j
), 4);
3452 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
3453 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
3457 #define X_GLrop_AlphaFunc 159
3459 __indirect_glAlphaFunc(GLenum func
, GLclampf ref
)
3461 __GLXcontext
*const gc
= __glXGetCurrentContext();
3462 const GLuint cmdlen
= 12;
3463 emit_header(gc
->pc
, X_GLrop_AlphaFunc
, cmdlen
);
3464 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&func
), 4);
3465 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&ref
), 4);
3467 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
3468 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
3472 #define X_GLrop_BlendFunc 160
3474 __indirect_glBlendFunc(GLenum sfactor
, GLenum dfactor
)
3476 __GLXcontext
*const gc
= __glXGetCurrentContext();
3477 const GLuint cmdlen
= 12;
3478 emit_header(gc
->pc
, X_GLrop_BlendFunc
, cmdlen
);
3479 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&sfactor
), 4);
3480 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&dfactor
), 4);
3482 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
3483 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
3487 #define X_GLrop_LogicOp 161
3489 __indirect_glLogicOp(GLenum opcode
)
3491 __GLXcontext
*const gc
= __glXGetCurrentContext();
3492 const GLuint cmdlen
= 8;
3493 emit_header(gc
->pc
, X_GLrop_LogicOp
, cmdlen
);
3494 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&opcode
), 4);
3496 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
3497 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
3501 #define X_GLrop_StencilFunc 162
3503 __indirect_glStencilFunc(GLenum func
, GLint ref
, GLuint mask
)
3505 __GLXcontext
*const gc
= __glXGetCurrentContext();
3506 const GLuint cmdlen
= 16;
3507 emit_header(gc
->pc
, X_GLrop_StencilFunc
, cmdlen
);
3508 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&func
), 4);
3509 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&ref
), 4);
3510 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&mask
), 4);
3512 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
3513 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
3517 #define X_GLrop_StencilOp 163
3519 __indirect_glStencilOp(GLenum fail
, GLenum zfail
, GLenum zpass
)
3521 __GLXcontext
*const gc
= __glXGetCurrentContext();
3522 const GLuint cmdlen
= 16;
3523 emit_header(gc
->pc
, X_GLrop_StencilOp
, cmdlen
);
3524 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&fail
), 4);
3525 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&zfail
), 4);
3526 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&zpass
), 4);
3528 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
3529 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
3533 #define X_GLrop_DepthFunc 164
3535 __indirect_glDepthFunc(GLenum func
)
3537 __GLXcontext
*const gc
= __glXGetCurrentContext();
3538 const GLuint cmdlen
= 8;
3539 emit_header(gc
->pc
, X_GLrop_DepthFunc
, cmdlen
);
3540 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&func
), 4);
3542 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
3543 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
3547 #define X_GLrop_PixelZoom 165
3549 __indirect_glPixelZoom(GLfloat xfactor
, GLfloat yfactor
)
3551 __GLXcontext
*const gc
= __glXGetCurrentContext();
3552 const GLuint cmdlen
= 12;
3553 emit_header(gc
->pc
, X_GLrop_PixelZoom
, cmdlen
);
3554 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&xfactor
), 4);
3555 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&yfactor
), 4);
3557 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
3558 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
3562 #define X_GLrop_PixelTransferf 166
3564 __indirect_glPixelTransferf(GLenum pname
, GLfloat param
)
3566 __GLXcontext
*const gc
= __glXGetCurrentContext();
3567 const GLuint cmdlen
= 12;
3568 emit_header(gc
->pc
, X_GLrop_PixelTransferf
, cmdlen
);
3569 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&pname
), 4);
3570 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (¶m
), 4);
3572 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
3573 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
3577 #define X_GLrop_PixelTransferi 167
3579 __indirect_glPixelTransferi(GLenum pname
, GLint param
)
3581 __GLXcontext
*const gc
= __glXGetCurrentContext();
3582 const GLuint cmdlen
= 12;
3583 emit_header(gc
->pc
, X_GLrop_PixelTransferi
, cmdlen
);
3584 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&pname
), 4);
3585 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (¶m
), 4);
3587 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
3588 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
3592 #define X_GLrop_PixelMapfv 168
3594 __indirect_glPixelMapfv(GLenum map
, GLsizei mapsize
, const GLfloat
* values
)
3596 __GLXcontext
*const gc
= __glXGetCurrentContext();
3597 const GLuint cmdlen
= 12 + __GLX_PAD((mapsize
* 4));
3599 __glXSetError(gc
, GL_INVALID_VALUE
);
3602 if (__builtin_expect((mapsize
>= 0) && (gc
->currentDpy
!= NULL
), 1)) {
3603 if (cmdlen
<= gc
->maxSmallRenderCommandSize
) {
3604 if ((gc
->pc
+ cmdlen
) > gc
->bufEnd
) {
3605 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
3607 emit_header(gc
->pc
, X_GLrop_PixelMapfv
, cmdlen
);
3608 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&map
), 4);
3609 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&mapsize
), 4);
3610 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (values
),
3613 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
3614 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
3617 const GLint op
= X_GLrop_PixelMapfv
;
3618 const GLuint cmdlenLarge
= cmdlen
+ 4;
3619 GLubyte
*const pc
= __glXFlushRenderBuffer(gc
, gc
->pc
);
3620 (void) memcpy((void *) (pc
+ 0), (void *) (&cmdlenLarge
), 4);
3621 (void) memcpy((void *) (pc
+ 4), (void *) (&op
), 4);
3622 (void) memcpy((void *) (pc
+ 8), (void *) (&map
), 4);
3623 (void) memcpy((void *) (pc
+ 12), (void *) (&mapsize
), 4);
3624 __glXSendLargeCommand(gc
, pc
, 16, values
, (mapsize
* 4));
3629 #define X_GLrop_PixelMapuiv 169
3631 __indirect_glPixelMapuiv(GLenum map
, GLsizei mapsize
, const GLuint
* values
)
3633 __GLXcontext
*const gc
= __glXGetCurrentContext();
3634 const GLuint cmdlen
= 12 + __GLX_PAD((mapsize
* 4));
3636 __glXSetError(gc
, GL_INVALID_VALUE
);
3639 if (__builtin_expect((mapsize
>= 0) && (gc
->currentDpy
!= NULL
), 1)) {
3640 if (cmdlen
<= gc
->maxSmallRenderCommandSize
) {
3641 if ((gc
->pc
+ cmdlen
) > gc
->bufEnd
) {
3642 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
3644 emit_header(gc
->pc
, X_GLrop_PixelMapuiv
, cmdlen
);
3645 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&map
), 4);
3646 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&mapsize
), 4);
3647 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (values
),
3650 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
3651 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
3654 const GLint op
= X_GLrop_PixelMapuiv
;
3655 const GLuint cmdlenLarge
= cmdlen
+ 4;
3656 GLubyte
*const pc
= __glXFlushRenderBuffer(gc
, gc
->pc
);
3657 (void) memcpy((void *) (pc
+ 0), (void *) (&cmdlenLarge
), 4);
3658 (void) memcpy((void *) (pc
+ 4), (void *) (&op
), 4);
3659 (void) memcpy((void *) (pc
+ 8), (void *) (&map
), 4);
3660 (void) memcpy((void *) (pc
+ 12), (void *) (&mapsize
), 4);
3661 __glXSendLargeCommand(gc
, pc
, 16, values
, (mapsize
* 4));
3666 #define X_GLrop_PixelMapusv 170
3668 __indirect_glPixelMapusv(GLenum map
, GLsizei mapsize
, const GLushort
* values
)
3670 __GLXcontext
*const gc
= __glXGetCurrentContext();
3671 const GLuint cmdlen
= 12 + __GLX_PAD((mapsize
* 2));
3673 __glXSetError(gc
, GL_INVALID_VALUE
);
3676 if (__builtin_expect((mapsize
>= 0) && (gc
->currentDpy
!= NULL
), 1)) {
3677 if (cmdlen
<= gc
->maxSmallRenderCommandSize
) {
3678 if ((gc
->pc
+ cmdlen
) > gc
->bufEnd
) {
3679 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
3681 emit_header(gc
->pc
, X_GLrop_PixelMapusv
, cmdlen
);
3682 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&map
), 4);
3683 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&mapsize
), 4);
3684 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (values
),
3687 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
3688 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
3691 const GLint op
= X_GLrop_PixelMapusv
;
3692 const GLuint cmdlenLarge
= cmdlen
+ 4;
3693 GLubyte
*const pc
= __glXFlushRenderBuffer(gc
, gc
->pc
);
3694 (void) memcpy((void *) (pc
+ 0), (void *) (&cmdlenLarge
), 4);
3695 (void) memcpy((void *) (pc
+ 4), (void *) (&op
), 4);
3696 (void) memcpy((void *) (pc
+ 8), (void *) (&map
), 4);
3697 (void) memcpy((void *) (pc
+ 12), (void *) (&mapsize
), 4);
3698 __glXSendLargeCommand(gc
, pc
, 16, values
, (mapsize
* 2));
3703 #define X_GLrop_ReadBuffer 171
3705 __indirect_glReadBuffer(GLenum mode
)
3707 __GLXcontext
*const gc
= __glXGetCurrentContext();
3708 const GLuint cmdlen
= 8;
3709 emit_header(gc
->pc
, X_GLrop_ReadBuffer
, cmdlen
);
3710 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&mode
), 4);
3712 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
3713 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
3717 #define X_GLrop_CopyPixels 172
3719 __indirect_glCopyPixels(GLint x
, GLint y
, GLsizei width
, GLsizei height
,
3722 __GLXcontext
*const gc
= __glXGetCurrentContext();
3723 const GLuint cmdlen
= 24;
3724 emit_header(gc
->pc
, X_GLrop_CopyPixels
, cmdlen
);
3725 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&x
), 4);
3726 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&y
), 4);
3727 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&width
), 4);
3728 (void) memcpy((void *) (gc
->pc
+ 16), (void *) (&height
), 4);
3729 (void) memcpy((void *) (gc
->pc
+ 20), (void *) (&type
), 4);
3731 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
3732 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
3736 #define X_GLsop_ReadPixels 111
3738 __indirect_glReadPixels(GLint x
, GLint y
, GLsizei width
, GLsizei height
,
3739 GLenum format
, GLenum type
, GLvoid
* pixels
)
3741 __GLXcontext
*const gc
= __glXGetCurrentContext();
3742 const __GLXattribute
*const state
= gc
->client_state_private
;
3743 Display
*const dpy
= gc
->currentDpy
;
3745 const GLuint cmdlen
= 28;
3747 if (__builtin_expect(dpy
!= NULL
, 1)) {
3749 xcb_connection_t
*c
= XGetXCBConnection(dpy
);
3750 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
3751 xcb_glx_read_pixels_reply_t
*reply
=
3752 xcb_glx_read_pixels_reply(c
,
3753 xcb_glx_read_pixels(c
,
3756 x
, y
, width
, height
,
3761 (void) memcpy(pixels
, xcb_glx_read_pixels_data(reply
),
3762 xcb_glx_read_pixels_data_length(reply
) *
3767 __glXSetupSingleRequest(gc
, X_GLsop_ReadPixels
, cmdlen
);
3768 (void) memcpy((void *) (pc
+ 0), (void *) (&x
), 4);
3769 (void) memcpy((void *) (pc
+ 4), (void *) (&y
), 4);
3770 (void) memcpy((void *) (pc
+ 8), (void *) (&width
), 4);
3771 (void) memcpy((void *) (pc
+ 12), (void *) (&height
), 4);
3772 (void) memcpy((void *) (pc
+ 16), (void *) (&format
), 4);
3773 (void) memcpy((void *) (pc
+ 20), (void *) (&type
), 4);
3774 *(int32_t *) (pc
+ 24) = 0;
3775 *(int8_t *) (pc
+ 24) = state
->storePack
.swapEndian
;
3776 __glXReadPixelReply(dpy
, gc
, 2, width
, height
, 1, format
, type
,
3780 #endif /* USE_XCB */
3785 #define X_GLrop_DrawPixels 173
3787 __indirect_glDrawPixels(GLsizei width
, GLsizei height
, GLenum format
,
3788 GLenum type
, const GLvoid
* pixels
)
3790 __GLXcontext
*const gc
= __glXGetCurrentContext();
3791 const GLuint compsize
=
3792 (pixels
!= NULL
) ? __glImageSize(width
, height
, 1, format
, type
,
3794 const GLuint cmdlen
= 40 + __GLX_PAD(compsize
);
3795 if (__builtin_expect(gc
->currentDpy
!= NULL
, 1)) {
3796 if (cmdlen
<= gc
->maxSmallRenderCommandSize
) {
3797 if ((gc
->pc
+ cmdlen
) > gc
->bufEnd
) {
3798 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
3800 emit_header(gc
->pc
, X_GLrop_DrawPixels
, cmdlen
);
3801 (void) memcpy((void *) (gc
->pc
+ 24), (void *) (&width
), 4);
3802 (void) memcpy((void *) (gc
->pc
+ 28), (void *) (&height
), 4);
3803 (void) memcpy((void *) (gc
->pc
+ 32), (void *) (&format
), 4);
3804 (void) memcpy((void *) (gc
->pc
+ 36), (void *) (&type
), 4);
3806 (*gc
->fillImage
) (gc
, 2, width
, height
, 1, format
, type
,
3807 pixels
, gc
->pc
+ 40, gc
->pc
+ 4);
3809 (void) memcpy(gc
->pc
+ 4, default_pixel_store_2D
,
3810 default_pixel_store_2D_size
);
3813 if (gc
->pc
> gc
->limit
) {
3814 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
3817 const GLint op
= X_GLrop_DrawPixels
;
3818 const GLuint cmdlenLarge
= cmdlen
+ 4;
3819 GLubyte
*const pc
= __glXFlushRenderBuffer(gc
, gc
->pc
);
3820 (void) memcpy((void *) (pc
+ 0), (void *) (&cmdlenLarge
), 4);
3821 (void) memcpy((void *) (pc
+ 4), (void *) (&op
), 4);
3822 (void) memcpy((void *) (pc
+ 28), (void *) (&width
), 4);
3823 (void) memcpy((void *) (pc
+ 32), (void *) (&height
), 4);
3824 (void) memcpy((void *) (pc
+ 36), (void *) (&format
), 4);
3825 (void) memcpy((void *) (pc
+ 40), (void *) (&type
), 4);
3826 __glXSendLargeImage(gc
, compsize
, 2, width
, height
, 1, format
,
3827 type
, pixels
, pc
+ 44, pc
+ 8);
3832 #define X_GLsop_GetClipPlane 113
3834 __indirect_glGetClipPlane(GLenum plane
, GLdouble
* equation
)
3836 __GLXcontext
*const gc
= __glXGetCurrentContext();
3837 Display
*const dpy
= gc
->currentDpy
;
3839 const GLuint cmdlen
= 4;
3841 if (__builtin_expect(dpy
!= NULL
, 1)) {
3843 xcb_connection_t
*c
= XGetXCBConnection(dpy
);
3844 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
3845 xcb_glx_get_clip_plane_reply_t
*reply
=
3846 xcb_glx_get_clip_plane_reply(c
,
3847 xcb_glx_get_clip_plane(c
,
3851 (void) memcpy(equation
, xcb_glx_get_clip_plane_data(reply
),
3852 xcb_glx_get_clip_plane_data_length(reply
) *
3857 __glXSetupSingleRequest(gc
, X_GLsop_GetClipPlane
, cmdlen
);
3858 (void) memcpy((void *) (pc
+ 0), (void *) (&plane
), 4);
3859 (void) __glXReadReply(dpy
, 8, equation
, GL_TRUE
);
3862 #endif /* USE_XCB */
3867 #define X_GLsop_GetLightfv 118
3869 __indirect_glGetLightfv(GLenum light
, GLenum pname
, GLfloat
* params
)
3871 __GLXcontext
*const gc
= __glXGetCurrentContext();
3872 Display
*const dpy
= gc
->currentDpy
;
3874 const GLuint cmdlen
= 8;
3876 if (__builtin_expect(dpy
!= NULL
, 1)) {
3878 xcb_connection_t
*c
= XGetXCBConnection(dpy
);
3879 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
3880 xcb_glx_get_lightfv_reply_t
*reply
=
3881 xcb_glx_get_lightfv_reply(c
,
3882 xcb_glx_get_lightfv(c
,
3887 if (xcb_glx_get_lightfv_data_length(reply
) == 0)
3888 (void) memcpy(params
, &reply
->datum
, sizeof(reply
->datum
));
3890 (void) memcpy(params
, xcb_glx_get_lightfv_data(reply
),
3891 xcb_glx_get_lightfv_data_length(reply
) *
3896 __glXSetupSingleRequest(gc
, X_GLsop_GetLightfv
, cmdlen
);
3897 (void) memcpy((void *) (pc
+ 0), (void *) (&light
), 4);
3898 (void) memcpy((void *) (pc
+ 4), (void *) (&pname
), 4);
3899 (void) __glXReadReply(dpy
, 4, params
, GL_FALSE
);
3902 #endif /* USE_XCB */
3907 #define X_GLsop_GetLightiv 119
3909 __indirect_glGetLightiv(GLenum light
, GLenum pname
, GLint
* params
)
3911 __GLXcontext
*const gc
= __glXGetCurrentContext();
3912 Display
*const dpy
= gc
->currentDpy
;
3914 const GLuint cmdlen
= 8;
3916 if (__builtin_expect(dpy
!= NULL
, 1)) {
3918 xcb_connection_t
*c
= XGetXCBConnection(dpy
);
3919 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
3920 xcb_glx_get_lightiv_reply_t
*reply
=
3921 xcb_glx_get_lightiv_reply(c
,
3922 xcb_glx_get_lightiv(c
,
3927 if (xcb_glx_get_lightiv_data_length(reply
) == 0)
3928 (void) memcpy(params
, &reply
->datum
, sizeof(reply
->datum
));
3930 (void) memcpy(params
, xcb_glx_get_lightiv_data(reply
),
3931 xcb_glx_get_lightiv_data_length(reply
) *
3936 __glXSetupSingleRequest(gc
, X_GLsop_GetLightiv
, cmdlen
);
3937 (void) memcpy((void *) (pc
+ 0), (void *) (&light
), 4);
3938 (void) memcpy((void *) (pc
+ 4), (void *) (&pname
), 4);
3939 (void) __glXReadReply(dpy
, 4, params
, GL_FALSE
);
3942 #endif /* USE_XCB */
3947 #define X_GLsop_GetMapdv 120
3949 __indirect_glGetMapdv(GLenum target
, GLenum query
, GLdouble
* v
)
3951 __GLXcontext
*const gc
= __glXGetCurrentContext();
3952 Display
*const dpy
= gc
->currentDpy
;
3954 const GLuint cmdlen
= 8;
3956 if (__builtin_expect(dpy
!= NULL
, 1)) {
3958 xcb_connection_t
*c
= XGetXCBConnection(dpy
);
3959 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
3960 xcb_glx_get_mapdv_reply_t
*reply
=
3961 xcb_glx_get_mapdv_reply(c
,
3962 xcb_glx_get_mapdv(c
,
3963 gc
->currentContextTag
,
3964 target
, query
), NULL
);
3965 if (xcb_glx_get_mapdv_data_length(reply
) == 0)
3966 (void) memcpy(v
, &reply
->datum
, sizeof(reply
->datum
));
3968 (void) memcpy(v
, xcb_glx_get_mapdv_data(reply
),
3969 xcb_glx_get_mapdv_data_length(reply
) *
3974 __glXSetupSingleRequest(gc
, X_GLsop_GetMapdv
, cmdlen
);
3975 (void) memcpy((void *) (pc
+ 0), (void *) (&target
), 4);
3976 (void) memcpy((void *) (pc
+ 4), (void *) (&query
), 4);
3977 (void) __glXReadReply(dpy
, 8, v
, GL_FALSE
);
3980 #endif /* USE_XCB */
3985 #define X_GLsop_GetMapfv 121
3987 __indirect_glGetMapfv(GLenum target
, GLenum query
, GLfloat
* v
)
3989 __GLXcontext
*const gc
= __glXGetCurrentContext();
3990 Display
*const dpy
= gc
->currentDpy
;
3992 const GLuint cmdlen
= 8;
3994 if (__builtin_expect(dpy
!= NULL
, 1)) {
3996 xcb_connection_t
*c
= XGetXCBConnection(dpy
);
3997 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
3998 xcb_glx_get_mapfv_reply_t
*reply
=
3999 xcb_glx_get_mapfv_reply(c
,
4000 xcb_glx_get_mapfv(c
,
4001 gc
->currentContextTag
,
4002 target
, query
), NULL
);
4003 if (xcb_glx_get_mapfv_data_length(reply
) == 0)
4004 (void) memcpy(v
, &reply
->datum
, sizeof(reply
->datum
));
4006 (void) memcpy(v
, xcb_glx_get_mapfv_data(reply
),
4007 xcb_glx_get_mapfv_data_length(reply
) *
4012 __glXSetupSingleRequest(gc
, X_GLsop_GetMapfv
, cmdlen
);
4013 (void) memcpy((void *) (pc
+ 0), (void *) (&target
), 4);
4014 (void) memcpy((void *) (pc
+ 4), (void *) (&query
), 4);
4015 (void) __glXReadReply(dpy
, 4, v
, GL_FALSE
);
4018 #endif /* USE_XCB */
4023 #define X_GLsop_GetMapiv 122
4025 __indirect_glGetMapiv(GLenum target
, GLenum query
, GLint
* v
)
4027 __GLXcontext
*const gc
= __glXGetCurrentContext();
4028 Display
*const dpy
= gc
->currentDpy
;
4030 const GLuint cmdlen
= 8;
4032 if (__builtin_expect(dpy
!= NULL
, 1)) {
4034 xcb_connection_t
*c
= XGetXCBConnection(dpy
);
4035 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
4036 xcb_glx_get_mapiv_reply_t
*reply
=
4037 xcb_glx_get_mapiv_reply(c
,
4038 xcb_glx_get_mapiv(c
,
4039 gc
->currentContextTag
,
4040 target
, query
), NULL
);
4041 if (xcb_glx_get_mapiv_data_length(reply
) == 0)
4042 (void) memcpy(v
, &reply
->datum
, sizeof(reply
->datum
));
4044 (void) memcpy(v
, xcb_glx_get_mapiv_data(reply
),
4045 xcb_glx_get_mapiv_data_length(reply
) *
4050 __glXSetupSingleRequest(gc
, X_GLsop_GetMapiv
, cmdlen
);
4051 (void) memcpy((void *) (pc
+ 0), (void *) (&target
), 4);
4052 (void) memcpy((void *) (pc
+ 4), (void *) (&query
), 4);
4053 (void) __glXReadReply(dpy
, 4, v
, GL_FALSE
);
4056 #endif /* USE_XCB */
4061 #define X_GLsop_GetMaterialfv 123
4063 __indirect_glGetMaterialfv(GLenum face
, GLenum pname
, GLfloat
* params
)
4065 __GLXcontext
*const gc
= __glXGetCurrentContext();
4066 Display
*const dpy
= gc
->currentDpy
;
4068 const GLuint cmdlen
= 8;
4070 if (__builtin_expect(dpy
!= NULL
, 1)) {
4072 xcb_connection_t
*c
= XGetXCBConnection(dpy
);
4073 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
4074 xcb_glx_get_materialfv_reply_t
*reply
=
4075 xcb_glx_get_materialfv_reply(c
,
4076 xcb_glx_get_materialfv(c
,
4081 if (xcb_glx_get_materialfv_data_length(reply
) == 0)
4082 (void) memcpy(params
, &reply
->datum
, sizeof(reply
->datum
));
4084 (void) memcpy(params
, xcb_glx_get_materialfv_data(reply
),
4085 xcb_glx_get_materialfv_data_length(reply
) *
4090 __glXSetupSingleRequest(gc
, X_GLsop_GetMaterialfv
, cmdlen
);
4091 (void) memcpy((void *) (pc
+ 0), (void *) (&face
), 4);
4092 (void) memcpy((void *) (pc
+ 4), (void *) (&pname
), 4);
4093 (void) __glXReadReply(dpy
, 4, params
, GL_FALSE
);
4096 #endif /* USE_XCB */
4101 #define X_GLsop_GetMaterialiv 124
4103 __indirect_glGetMaterialiv(GLenum face
, GLenum pname
, GLint
* params
)
4105 __GLXcontext
*const gc
= __glXGetCurrentContext();
4106 Display
*const dpy
= gc
->currentDpy
;
4108 const GLuint cmdlen
= 8;
4110 if (__builtin_expect(dpy
!= NULL
, 1)) {
4112 xcb_connection_t
*c
= XGetXCBConnection(dpy
);
4113 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
4114 xcb_glx_get_materialiv_reply_t
*reply
=
4115 xcb_glx_get_materialiv_reply(c
,
4116 xcb_glx_get_materialiv(c
,
4121 if (xcb_glx_get_materialiv_data_length(reply
) == 0)
4122 (void) memcpy(params
, &reply
->datum
, sizeof(reply
->datum
));
4124 (void) memcpy(params
, xcb_glx_get_materialiv_data(reply
),
4125 xcb_glx_get_materialiv_data_length(reply
) *
4130 __glXSetupSingleRequest(gc
, X_GLsop_GetMaterialiv
, cmdlen
);
4131 (void) memcpy((void *) (pc
+ 0), (void *) (&face
), 4);
4132 (void) memcpy((void *) (pc
+ 4), (void *) (&pname
), 4);
4133 (void) __glXReadReply(dpy
, 4, params
, GL_FALSE
);
4136 #endif /* USE_XCB */
4141 #define X_GLsop_GetPixelMapfv 125
4143 __indirect_glGetPixelMapfv(GLenum map
, GLfloat
* values
)
4145 __GLXcontext
*const gc
= __glXGetCurrentContext();
4146 Display
*const dpy
= gc
->currentDpy
;
4148 const GLuint cmdlen
= 4;
4150 if (__builtin_expect(dpy
!= NULL
, 1)) {
4152 xcb_connection_t
*c
= XGetXCBConnection(dpy
);
4153 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
4154 xcb_glx_get_pixel_mapfv_reply_t
*reply
=
4155 xcb_glx_get_pixel_mapfv_reply(c
,
4156 xcb_glx_get_pixel_mapfv(c
,
4160 if (xcb_glx_get_pixel_mapfv_data_length(reply
) == 0)
4161 (void) memcpy(values
, &reply
->datum
, sizeof(reply
->datum
));
4163 (void) memcpy(values
, xcb_glx_get_pixel_mapfv_data(reply
),
4164 xcb_glx_get_pixel_mapfv_data_length(reply
) *
4169 __glXSetupSingleRequest(gc
, X_GLsop_GetPixelMapfv
, cmdlen
);
4170 (void) memcpy((void *) (pc
+ 0), (void *) (&map
), 4);
4171 (void) __glXReadReply(dpy
, 4, values
, GL_FALSE
);
4174 #endif /* USE_XCB */
4179 #define X_GLsop_GetPixelMapuiv 126
4181 __indirect_glGetPixelMapuiv(GLenum map
, GLuint
* values
)
4183 __GLXcontext
*const gc
= __glXGetCurrentContext();
4184 Display
*const dpy
= gc
->currentDpy
;
4186 const GLuint cmdlen
= 4;
4188 if (__builtin_expect(dpy
!= NULL
, 1)) {
4190 xcb_connection_t
*c
= XGetXCBConnection(dpy
);
4191 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
4192 xcb_glx_get_pixel_mapuiv_reply_t
*reply
=
4193 xcb_glx_get_pixel_mapuiv_reply(c
,
4194 xcb_glx_get_pixel_mapuiv(c
,
4199 if (xcb_glx_get_pixel_mapuiv_data_length(reply
) == 0)
4200 (void) memcpy(values
, &reply
->datum
, sizeof(reply
->datum
));
4202 (void) memcpy(values
, xcb_glx_get_pixel_mapuiv_data(reply
),
4203 xcb_glx_get_pixel_mapuiv_data_length(reply
) *
4208 __glXSetupSingleRequest(gc
, X_GLsop_GetPixelMapuiv
, cmdlen
);
4209 (void) memcpy((void *) (pc
+ 0), (void *) (&map
), 4);
4210 (void) __glXReadReply(dpy
, 4, values
, GL_FALSE
);
4213 #endif /* USE_XCB */
4218 #define X_GLsop_GetPixelMapusv 127
4220 __indirect_glGetPixelMapusv(GLenum map
, GLushort
* values
)
4222 __GLXcontext
*const gc
= __glXGetCurrentContext();
4223 Display
*const dpy
= gc
->currentDpy
;
4225 const GLuint cmdlen
= 4;
4227 if (__builtin_expect(dpy
!= NULL
, 1)) {
4229 xcb_connection_t
*c
= XGetXCBConnection(dpy
);
4230 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
4231 xcb_glx_get_pixel_mapusv_reply_t
*reply
=
4232 xcb_glx_get_pixel_mapusv_reply(c
,
4233 xcb_glx_get_pixel_mapusv(c
,
4238 if (xcb_glx_get_pixel_mapusv_data_length(reply
) == 0)
4239 (void) memcpy(values
, &reply
->datum
, sizeof(reply
->datum
));
4241 (void) memcpy(values
, xcb_glx_get_pixel_mapusv_data(reply
),
4242 xcb_glx_get_pixel_mapusv_data_length(reply
) *
4247 __glXSetupSingleRequest(gc
, X_GLsop_GetPixelMapusv
, cmdlen
);
4248 (void) memcpy((void *) (pc
+ 0), (void *) (&map
), 4);
4249 (void) __glXReadReply(dpy
, 2, values
, GL_FALSE
);
4252 #endif /* USE_XCB */
4257 #define X_GLsop_GetPolygonStipple 128
4259 __indirect_glGetPolygonStipple(GLubyte
*mask
)
4261 __GLXcontext
*const gc
= __glXGetCurrentContext();
4262 Display
*const dpy
= gc
->currentDpy
;
4264 const GLuint cmdlen
= 4;
4266 if (__builtin_expect(dpy
!= NULL
, 1)) {
4268 xcb_connection_t
*c
= XGetXCBConnection(dpy
);
4269 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
4270 xcb_glx_get_polygon_stipple_reply_t
*reply
=
4271 xcb_glx_get_polygon_stipple_reply(c
,
4272 xcb_glx_get_polygon_stipple(c
,
4277 (void) memcpy(mask
, xcb_glx_get_polygon_stipple_data(reply
),
4278 xcb_glx_get_polygon_stipple_data_length(reply
) *
4283 __glXSetupSingleRequest(gc
, X_GLsop_GetPolygonStipple
, cmdlen
);
4284 *(int32_t *) (pc
+ 0) = 0;
4285 __glXReadPixelReply(dpy
, gc
, 2, 32, 32, 1, GL_COLOR_INDEX
, GL_BITMAP
,
4289 #endif /* USE_XCB */
4294 #define X_GLsop_GetTexEnvfv 130
4296 __indirect_glGetTexEnvfv(GLenum target
, GLenum pname
, GLfloat
* params
)
4298 __GLXcontext
*const gc
= __glXGetCurrentContext();
4299 Display
*const dpy
= gc
->currentDpy
;
4301 const GLuint cmdlen
= 8;
4303 if (__builtin_expect(dpy
!= NULL
, 1)) {
4305 xcb_connection_t
*c
= XGetXCBConnection(dpy
);
4306 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
4307 xcb_glx_get_tex_envfv_reply_t
*reply
=
4308 xcb_glx_get_tex_envfv_reply(c
,
4309 xcb_glx_get_tex_envfv(c
,
4314 if (xcb_glx_get_tex_envfv_data_length(reply
) == 0)
4315 (void) memcpy(params
, &reply
->datum
, sizeof(reply
->datum
));
4317 (void) memcpy(params
, xcb_glx_get_tex_envfv_data(reply
),
4318 xcb_glx_get_tex_envfv_data_length(reply
) *
4323 __glXSetupSingleRequest(gc
, X_GLsop_GetTexEnvfv
, cmdlen
);
4324 (void) memcpy((void *) (pc
+ 0), (void *) (&target
), 4);
4325 (void) memcpy((void *) (pc
+ 4), (void *) (&pname
), 4);
4326 (void) __glXReadReply(dpy
, 4, params
, GL_FALSE
);
4329 #endif /* USE_XCB */
4334 #define X_GLsop_GetTexEnviv 131
4336 __indirect_glGetTexEnviv(GLenum target
, GLenum pname
, GLint
* params
)
4338 __GLXcontext
*const gc
= __glXGetCurrentContext();
4339 Display
*const dpy
= gc
->currentDpy
;
4341 const GLuint cmdlen
= 8;
4343 if (__builtin_expect(dpy
!= NULL
, 1)) {
4345 xcb_connection_t
*c
= XGetXCBConnection(dpy
);
4346 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
4347 xcb_glx_get_tex_enviv_reply_t
*reply
=
4348 xcb_glx_get_tex_enviv_reply(c
,
4349 xcb_glx_get_tex_enviv(c
,
4354 if (xcb_glx_get_tex_enviv_data_length(reply
) == 0)
4355 (void) memcpy(params
, &reply
->datum
, sizeof(reply
->datum
));
4357 (void) memcpy(params
, xcb_glx_get_tex_enviv_data(reply
),
4358 xcb_glx_get_tex_enviv_data_length(reply
) *
4363 __glXSetupSingleRequest(gc
, X_GLsop_GetTexEnviv
, cmdlen
);
4364 (void) memcpy((void *) (pc
+ 0), (void *) (&target
), 4);
4365 (void) memcpy((void *) (pc
+ 4), (void *) (&pname
), 4);
4366 (void) __glXReadReply(dpy
, 4, params
, GL_FALSE
);
4369 #endif /* USE_XCB */
4374 #define X_GLsop_GetTexGendv 132
4376 __indirect_glGetTexGendv(GLenum coord
, GLenum pname
, GLdouble
* params
)
4378 __GLXcontext
*const gc
= __glXGetCurrentContext();
4379 Display
*const dpy
= gc
->currentDpy
;
4381 const GLuint cmdlen
= 8;
4383 if (__builtin_expect(dpy
!= NULL
, 1)) {
4385 xcb_connection_t
*c
= XGetXCBConnection(dpy
);
4386 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
4387 xcb_glx_get_tex_gendv_reply_t
*reply
=
4388 xcb_glx_get_tex_gendv_reply(c
,
4389 xcb_glx_get_tex_gendv(c
,
4394 if (xcb_glx_get_tex_gendv_data_length(reply
) == 0)
4395 (void) memcpy(params
, &reply
->datum
, sizeof(reply
->datum
));
4397 (void) memcpy(params
, xcb_glx_get_tex_gendv_data(reply
),
4398 xcb_glx_get_tex_gendv_data_length(reply
) *
4403 __glXSetupSingleRequest(gc
, X_GLsop_GetTexGendv
, cmdlen
);
4404 (void) memcpy((void *) (pc
+ 0), (void *) (&coord
), 4);
4405 (void) memcpy((void *) (pc
+ 4), (void *) (&pname
), 4);
4406 (void) __glXReadReply(dpy
, 8, params
, GL_FALSE
);
4409 #endif /* USE_XCB */
4414 #define X_GLsop_GetTexGenfv 133
4416 __indirect_glGetTexGenfv(GLenum coord
, GLenum pname
, GLfloat
* params
)
4418 __GLXcontext
*const gc
= __glXGetCurrentContext();
4419 Display
*const dpy
= gc
->currentDpy
;
4421 const GLuint cmdlen
= 8;
4423 if (__builtin_expect(dpy
!= NULL
, 1)) {
4425 xcb_connection_t
*c
= XGetXCBConnection(dpy
);
4426 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
4427 xcb_glx_get_tex_genfv_reply_t
*reply
=
4428 xcb_glx_get_tex_genfv_reply(c
,
4429 xcb_glx_get_tex_genfv(c
,
4434 if (xcb_glx_get_tex_genfv_data_length(reply
) == 0)
4435 (void) memcpy(params
, &reply
->datum
, sizeof(reply
->datum
));
4437 (void) memcpy(params
, xcb_glx_get_tex_genfv_data(reply
),
4438 xcb_glx_get_tex_genfv_data_length(reply
) *
4443 __glXSetupSingleRequest(gc
, X_GLsop_GetTexGenfv
, cmdlen
);
4444 (void) memcpy((void *) (pc
+ 0), (void *) (&coord
), 4);
4445 (void) memcpy((void *) (pc
+ 4), (void *) (&pname
), 4);
4446 (void) __glXReadReply(dpy
, 4, params
, GL_FALSE
);
4449 #endif /* USE_XCB */
4454 #define X_GLsop_GetTexGeniv 134
4456 __indirect_glGetTexGeniv(GLenum coord
, GLenum pname
, GLint
* params
)
4458 __GLXcontext
*const gc
= __glXGetCurrentContext();
4459 Display
*const dpy
= gc
->currentDpy
;
4461 const GLuint cmdlen
= 8;
4463 if (__builtin_expect(dpy
!= NULL
, 1)) {
4465 xcb_connection_t
*c
= XGetXCBConnection(dpy
);
4466 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
4467 xcb_glx_get_tex_geniv_reply_t
*reply
=
4468 xcb_glx_get_tex_geniv_reply(c
,
4469 xcb_glx_get_tex_geniv(c
,
4474 if (xcb_glx_get_tex_geniv_data_length(reply
) == 0)
4475 (void) memcpy(params
, &reply
->datum
, sizeof(reply
->datum
));
4477 (void) memcpy(params
, xcb_glx_get_tex_geniv_data(reply
),
4478 xcb_glx_get_tex_geniv_data_length(reply
) *
4483 __glXSetupSingleRequest(gc
, X_GLsop_GetTexGeniv
, cmdlen
);
4484 (void) memcpy((void *) (pc
+ 0), (void *) (&coord
), 4);
4485 (void) memcpy((void *) (pc
+ 4), (void *) (&pname
), 4);
4486 (void) __glXReadReply(dpy
, 4, params
, GL_FALSE
);
4489 #endif /* USE_XCB */
4494 #define X_GLsop_GetTexImage 135
4496 __indirect_glGetTexImage(GLenum target
, GLint level
, GLenum format
,
4497 GLenum type
, GLvoid
* pixels
)
4499 __GLXcontext
*const gc
= __glXGetCurrentContext();
4500 const __GLXattribute
*const state
= gc
->client_state_private
;
4501 Display
*const dpy
= gc
->currentDpy
;
4503 const GLuint cmdlen
= 20;
4505 if (__builtin_expect(dpy
!= NULL
, 1)) {
4507 xcb_connection_t
*c
= XGetXCBConnection(dpy
);
4508 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
4509 xcb_glx_get_tex_image_reply_t
*reply
=
4510 xcb_glx_get_tex_image_reply(c
,
4511 xcb_glx_get_tex_image(c
,
4520 (void) memcpy(pixels
, xcb_glx_get_tex_image_data(reply
),
4521 xcb_glx_get_tex_image_data_length(reply
) *
4526 __glXSetupSingleRequest(gc
, X_GLsop_GetTexImage
, cmdlen
);
4527 (void) memcpy((void *) (pc
+ 0), (void *) (&target
), 4);
4528 (void) memcpy((void *) (pc
+ 4), (void *) (&level
), 4);
4529 (void) memcpy((void *) (pc
+ 8), (void *) (&format
), 4);
4530 (void) memcpy((void *) (pc
+ 12), (void *) (&type
), 4);
4531 *(int32_t *) (pc
+ 16) = 0;
4532 *(int8_t *) (pc
+ 16) = state
->storePack
.swapEndian
;
4533 __glXReadPixelReply(dpy
, gc
, 3, 0, 0, 0, format
, type
, pixels
,
4537 #endif /* USE_XCB */
4542 #define X_GLsop_GetTexParameterfv 136
4544 __indirect_glGetTexParameterfv(GLenum target
, GLenum pname
, GLfloat
* params
)
4546 __GLXcontext
*const gc
= __glXGetCurrentContext();
4547 Display
*const dpy
= gc
->currentDpy
;
4549 const GLuint cmdlen
= 8;
4551 if (__builtin_expect(dpy
!= NULL
, 1)) {
4553 xcb_connection_t
*c
= XGetXCBConnection(dpy
);
4554 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
4555 xcb_glx_get_tex_parameterfv_reply_t
*reply
=
4556 xcb_glx_get_tex_parameterfv_reply(c
,
4557 xcb_glx_get_tex_parameterfv(c
,
4563 if (xcb_glx_get_tex_parameterfv_data_length(reply
) == 0)
4564 (void) memcpy(params
, &reply
->datum
, sizeof(reply
->datum
));
4566 (void) memcpy(params
, xcb_glx_get_tex_parameterfv_data(reply
),
4567 xcb_glx_get_tex_parameterfv_data_length(reply
) *
4572 __glXSetupSingleRequest(gc
, X_GLsop_GetTexParameterfv
, cmdlen
);
4573 (void) memcpy((void *) (pc
+ 0), (void *) (&target
), 4);
4574 (void) memcpy((void *) (pc
+ 4), (void *) (&pname
), 4);
4575 (void) __glXReadReply(dpy
, 4, params
, GL_FALSE
);
4578 #endif /* USE_XCB */
4583 #define X_GLsop_GetTexParameteriv 137
4585 __indirect_glGetTexParameteriv(GLenum target
, GLenum pname
, GLint
* params
)
4587 __GLXcontext
*const gc
= __glXGetCurrentContext();
4588 Display
*const dpy
= gc
->currentDpy
;
4590 const GLuint cmdlen
= 8;
4592 if (__builtin_expect(dpy
!= NULL
, 1)) {
4594 xcb_connection_t
*c
= XGetXCBConnection(dpy
);
4595 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
4596 xcb_glx_get_tex_parameteriv_reply_t
*reply
=
4597 xcb_glx_get_tex_parameteriv_reply(c
,
4598 xcb_glx_get_tex_parameteriv(c
,
4604 if (xcb_glx_get_tex_parameteriv_data_length(reply
) == 0)
4605 (void) memcpy(params
, &reply
->datum
, sizeof(reply
->datum
));
4607 (void) memcpy(params
, xcb_glx_get_tex_parameteriv_data(reply
),
4608 xcb_glx_get_tex_parameteriv_data_length(reply
) *
4613 __glXSetupSingleRequest(gc
, X_GLsop_GetTexParameteriv
, cmdlen
);
4614 (void) memcpy((void *) (pc
+ 0), (void *) (&target
), 4);
4615 (void) memcpy((void *) (pc
+ 4), (void *) (&pname
), 4);
4616 (void) __glXReadReply(dpy
, 4, params
, GL_FALSE
);
4619 #endif /* USE_XCB */
4624 #define X_GLsop_GetTexLevelParameterfv 138
4626 __indirect_glGetTexLevelParameterfv(GLenum target
, GLint level
, GLenum pname
,
4629 __GLXcontext
*const gc
= __glXGetCurrentContext();
4630 Display
*const dpy
= gc
->currentDpy
;
4632 const GLuint cmdlen
= 12;
4634 if (__builtin_expect(dpy
!= NULL
, 1)) {
4636 xcb_connection_t
*c
= XGetXCBConnection(dpy
);
4637 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
4638 xcb_glx_get_tex_level_parameterfv_reply_t
*reply
=
4639 xcb_glx_get_tex_level_parameterfv_reply(c
,
4640 xcb_glx_get_tex_level_parameterfv
4641 (c
, gc
->currentContextTag
,
4642 target
, level
, pname
),
4644 if (xcb_glx_get_tex_level_parameterfv_data_length(reply
) == 0)
4645 (void) memcpy(params
, &reply
->datum
, sizeof(reply
->datum
));
4647 (void) memcpy(params
,
4648 xcb_glx_get_tex_level_parameterfv_data(reply
),
4649 xcb_glx_get_tex_level_parameterfv_data_length(reply
)
4654 __glXSetupSingleRequest(gc
, X_GLsop_GetTexLevelParameterfv
,
4656 (void) memcpy((void *) (pc
+ 0), (void *) (&target
), 4);
4657 (void) memcpy((void *) (pc
+ 4), (void *) (&level
), 4);
4658 (void) memcpy((void *) (pc
+ 8), (void *) (&pname
), 4);
4659 (void) __glXReadReply(dpy
, 4, params
, GL_FALSE
);
4662 #endif /* USE_XCB */
4667 #define X_GLsop_GetTexLevelParameteriv 139
4669 __indirect_glGetTexLevelParameteriv(GLenum target
, GLint level
, GLenum pname
,
4672 __GLXcontext
*const gc
= __glXGetCurrentContext();
4673 Display
*const dpy
= gc
->currentDpy
;
4675 const GLuint cmdlen
= 12;
4677 if (__builtin_expect(dpy
!= NULL
, 1)) {
4679 xcb_connection_t
*c
= XGetXCBConnection(dpy
);
4680 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
4681 xcb_glx_get_tex_level_parameteriv_reply_t
*reply
=
4682 xcb_glx_get_tex_level_parameteriv_reply(c
,
4683 xcb_glx_get_tex_level_parameteriv
4684 (c
, gc
->currentContextTag
,
4685 target
, level
, pname
),
4687 if (xcb_glx_get_tex_level_parameteriv_data_length(reply
) == 0)
4688 (void) memcpy(params
, &reply
->datum
, sizeof(reply
->datum
));
4690 (void) memcpy(params
,
4691 xcb_glx_get_tex_level_parameteriv_data(reply
),
4692 xcb_glx_get_tex_level_parameteriv_data_length(reply
)
4697 __glXSetupSingleRequest(gc
, X_GLsop_GetTexLevelParameteriv
,
4699 (void) memcpy((void *) (pc
+ 0), (void *) (&target
), 4);
4700 (void) memcpy((void *) (pc
+ 4), (void *) (&level
), 4);
4701 (void) memcpy((void *) (pc
+ 8), (void *) (&pname
), 4);
4702 (void) __glXReadReply(dpy
, 4, params
, GL_FALSE
);
4705 #endif /* USE_XCB */
4710 #define X_GLsop_IsList 141
4712 __indirect_glIsList(GLuint list
)
4714 __GLXcontext
*const gc
= __glXGetCurrentContext();
4715 Display
*const dpy
= gc
->currentDpy
;
4716 GLboolean retval
= (GLboolean
) 0;
4718 const GLuint cmdlen
= 4;
4720 if (__builtin_expect(dpy
!= NULL
, 1)) {
4722 xcb_connection_t
*c
= XGetXCBConnection(dpy
);
4723 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
4724 xcb_glx_is_list_reply_t
*reply
=
4725 xcb_glx_is_list_reply(c
,
4726 xcb_glx_is_list(c
, gc
->currentContextTag
,
4728 retval
= reply
->ret_val
;
4732 __glXSetupSingleRequest(gc
, X_GLsop_IsList
, cmdlen
);
4733 (void) memcpy((void *) (pc
+ 0), (void *) (&list
), 4);
4734 retval
= (GLboolean
) __glXReadReply(dpy
, 0, NULL
, GL_FALSE
);
4737 #endif /* USE_XCB */
4742 #define X_GLrop_DepthRange 174
4744 __indirect_glDepthRange(GLclampd zNear
, GLclampd zFar
)
4746 __GLXcontext
*const gc
= __glXGetCurrentContext();
4747 const GLuint cmdlen
= 20;
4748 emit_header(gc
->pc
, X_GLrop_DepthRange
, cmdlen
);
4749 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&zNear
), 8);
4750 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&zFar
), 8);
4752 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
4753 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
4757 #define X_GLrop_Frustum 175
4759 __indirect_glFrustum(GLdouble left
, GLdouble right
, GLdouble bottom
,
4760 GLdouble top
, GLdouble zNear
, GLdouble zFar
)
4762 __GLXcontext
*const gc
= __glXGetCurrentContext();
4763 const GLuint cmdlen
= 52;
4764 emit_header(gc
->pc
, X_GLrop_Frustum
, cmdlen
);
4765 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&left
), 8);
4766 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&right
), 8);
4767 (void) memcpy((void *) (gc
->pc
+ 20), (void *) (&bottom
), 8);
4768 (void) memcpy((void *) (gc
->pc
+ 28), (void *) (&top
), 8);
4769 (void) memcpy((void *) (gc
->pc
+ 36), (void *) (&zNear
), 8);
4770 (void) memcpy((void *) (gc
->pc
+ 44), (void *) (&zFar
), 8);
4772 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
4773 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
4777 #define X_GLrop_LoadIdentity 176
4779 __indirect_glLoadIdentity(void)
4781 __GLXcontext
*const gc
= __glXGetCurrentContext();
4782 const GLuint cmdlen
= 4;
4783 emit_header(gc
->pc
, X_GLrop_LoadIdentity
, cmdlen
);
4785 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
4786 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
4790 #define X_GLrop_LoadMatrixf 177
4792 __indirect_glLoadMatrixf(const GLfloat
* m
)
4794 __GLXcontext
*const gc
= __glXGetCurrentContext();
4795 const GLuint cmdlen
= 68;
4796 emit_header(gc
->pc
, X_GLrop_LoadMatrixf
, cmdlen
);
4797 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (m
), 64);
4799 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
4800 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
4804 #define X_GLrop_LoadMatrixd 178
4806 __indirect_glLoadMatrixd(const GLdouble
* m
)
4808 __GLXcontext
*const gc
= __glXGetCurrentContext();
4809 const GLuint cmdlen
= 132;
4810 emit_header(gc
->pc
, X_GLrop_LoadMatrixd
, cmdlen
);
4811 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (m
), 128);
4813 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
4814 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
4818 #define X_GLrop_MatrixMode 179
4820 __indirect_glMatrixMode(GLenum mode
)
4822 __GLXcontext
*const gc
= __glXGetCurrentContext();
4823 const GLuint cmdlen
= 8;
4824 emit_header(gc
->pc
, X_GLrop_MatrixMode
, cmdlen
);
4825 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&mode
), 4);
4827 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
4828 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
4832 #define X_GLrop_MultMatrixf 180
4834 __indirect_glMultMatrixf(const GLfloat
* m
)
4836 __GLXcontext
*const gc
= __glXGetCurrentContext();
4837 const GLuint cmdlen
= 68;
4838 emit_header(gc
->pc
, X_GLrop_MultMatrixf
, cmdlen
);
4839 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (m
), 64);
4841 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
4842 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
4846 #define X_GLrop_MultMatrixd 181
4848 __indirect_glMultMatrixd(const GLdouble
* m
)
4850 __GLXcontext
*const gc
= __glXGetCurrentContext();
4851 const GLuint cmdlen
= 132;
4852 emit_header(gc
->pc
, X_GLrop_MultMatrixd
, cmdlen
);
4853 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (m
), 128);
4855 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
4856 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
4860 #define X_GLrop_Ortho 182
4862 __indirect_glOrtho(GLdouble left
, GLdouble right
, GLdouble bottom
,
4863 GLdouble top
, GLdouble zNear
, GLdouble zFar
)
4865 __GLXcontext
*const gc
= __glXGetCurrentContext();
4866 const GLuint cmdlen
= 52;
4867 emit_header(gc
->pc
, X_GLrop_Ortho
, cmdlen
);
4868 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&left
), 8);
4869 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&right
), 8);
4870 (void) memcpy((void *) (gc
->pc
+ 20), (void *) (&bottom
), 8);
4871 (void) memcpy((void *) (gc
->pc
+ 28), (void *) (&top
), 8);
4872 (void) memcpy((void *) (gc
->pc
+ 36), (void *) (&zNear
), 8);
4873 (void) memcpy((void *) (gc
->pc
+ 44), (void *) (&zFar
), 8);
4875 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
4876 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
4880 #define X_GLrop_PopMatrix 183
4882 __indirect_glPopMatrix(void)
4884 __GLXcontext
*const gc
= __glXGetCurrentContext();
4885 const GLuint cmdlen
= 4;
4886 emit_header(gc
->pc
, X_GLrop_PopMatrix
, cmdlen
);
4888 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
4889 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
4893 #define X_GLrop_PushMatrix 184
4895 __indirect_glPushMatrix(void)
4897 __GLXcontext
*const gc
= __glXGetCurrentContext();
4898 const GLuint cmdlen
= 4;
4899 emit_header(gc
->pc
, X_GLrop_PushMatrix
, cmdlen
);
4901 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
4902 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
4906 #define X_GLrop_Rotated 185
4908 __indirect_glRotated(GLdouble angle
, GLdouble x
, GLdouble y
, GLdouble z
)
4910 __GLXcontext
*const gc
= __glXGetCurrentContext();
4911 const GLuint cmdlen
= 36;
4912 emit_header(gc
->pc
, X_GLrop_Rotated
, cmdlen
);
4913 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&angle
), 8);
4914 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&x
), 8);
4915 (void) memcpy((void *) (gc
->pc
+ 20), (void *) (&y
), 8);
4916 (void) memcpy((void *) (gc
->pc
+ 28), (void *) (&z
), 8);
4918 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
4919 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
4923 #define X_GLrop_Rotatef 186
4925 __indirect_glRotatef(GLfloat angle
, GLfloat x
, GLfloat y
, GLfloat z
)
4927 __GLXcontext
*const gc
= __glXGetCurrentContext();
4928 const GLuint cmdlen
= 20;
4929 emit_header(gc
->pc
, X_GLrop_Rotatef
, cmdlen
);
4930 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&angle
), 4);
4931 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&x
), 4);
4932 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&y
), 4);
4933 (void) memcpy((void *) (gc
->pc
+ 16), (void *) (&z
), 4);
4935 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
4936 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
4940 #define X_GLrop_Scaled 187
4942 __indirect_glScaled(GLdouble x
, GLdouble y
, GLdouble z
)
4944 __GLXcontext
*const gc
= __glXGetCurrentContext();
4945 const GLuint cmdlen
= 28;
4946 emit_header(gc
->pc
, X_GLrop_Scaled
, cmdlen
);
4947 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&x
), 8);
4948 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&y
), 8);
4949 (void) memcpy((void *) (gc
->pc
+ 20), (void *) (&z
), 8);
4951 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
4952 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
4956 #define X_GLrop_Scalef 188
4958 __indirect_glScalef(GLfloat x
, GLfloat y
, GLfloat z
)
4960 __GLXcontext
*const gc
= __glXGetCurrentContext();
4961 const GLuint cmdlen
= 16;
4962 emit_header(gc
->pc
, X_GLrop_Scalef
, cmdlen
);
4963 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&x
), 4);
4964 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&y
), 4);
4965 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&z
), 4);
4967 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
4968 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
4972 #define X_GLrop_Translated 189
4974 __indirect_glTranslated(GLdouble x
, GLdouble y
, GLdouble z
)
4976 __GLXcontext
*const gc
= __glXGetCurrentContext();
4977 const GLuint cmdlen
= 28;
4978 emit_header(gc
->pc
, X_GLrop_Translated
, cmdlen
);
4979 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&x
), 8);
4980 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&y
), 8);
4981 (void) memcpy((void *) (gc
->pc
+ 20), (void *) (&z
), 8);
4983 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
4984 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
4988 #define X_GLrop_Translatef 190
4990 __indirect_glTranslatef(GLfloat x
, GLfloat y
, GLfloat z
)
4992 __GLXcontext
*const gc
= __glXGetCurrentContext();
4993 const GLuint cmdlen
= 16;
4994 emit_header(gc
->pc
, X_GLrop_Translatef
, cmdlen
);
4995 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&x
), 4);
4996 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&y
), 4);
4997 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&z
), 4);
4999 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
5000 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
5004 #define X_GLrop_Viewport 191
5006 __indirect_glViewport(GLint x
, GLint y
, GLsizei width
, GLsizei height
)
5008 __GLXcontext
*const gc
= __glXGetCurrentContext();
5009 const GLuint cmdlen
= 20;
5010 emit_header(gc
->pc
, X_GLrop_Viewport
, cmdlen
);
5011 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&x
), 4);
5012 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&y
), 4);
5013 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&width
), 4);
5014 (void) memcpy((void *) (gc
->pc
+ 16), (void *) (&height
), 4);
5016 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
5017 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
5021 #define X_GLrop_BindTexture 4117
5023 __indirect_glBindTexture(GLenum target
, GLuint texture
)
5025 __GLXcontext
*const gc
= __glXGetCurrentContext();
5026 const GLuint cmdlen
= 12;
5027 emit_header(gc
->pc
, X_GLrop_BindTexture
, cmdlen
);
5028 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&target
), 4);
5029 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&texture
), 4);
5031 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
5032 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
5036 #define X_GLrop_Indexubv 194
5038 __indirect_glIndexub(GLubyte c
)
5040 __GLXcontext
*const gc
= __glXGetCurrentContext();
5041 const GLuint cmdlen
= 8;
5042 emit_header(gc
->pc
, X_GLrop_Indexubv
, cmdlen
);
5043 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&c
), 1);
5045 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
5046 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
5050 #define X_GLrop_Indexubv 194
5052 __indirect_glIndexubv(const GLubyte
*c
)
5054 __GLXcontext
*const gc
= __glXGetCurrentContext();
5055 const GLuint cmdlen
= 8;
5056 emit_header(gc
->pc
, X_GLrop_Indexubv
, cmdlen
);
5057 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (c
), 1);
5059 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
5060 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
5064 #define X_GLrop_PolygonOffset 192
5066 __indirect_glPolygonOffset(GLfloat factor
, GLfloat units
)
5068 __GLXcontext
*const gc
= __glXGetCurrentContext();
5069 const GLuint cmdlen
= 12;
5070 emit_header(gc
->pc
, X_GLrop_PolygonOffset
, cmdlen
);
5071 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&factor
), 4);
5072 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&units
), 4);
5074 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
5075 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
5079 #define X_GLrop_CopyTexImage1D 4119
5081 __indirect_glCopyTexImage1D(GLenum target
, GLint level
, GLenum internalformat
,
5082 GLint x
, GLint y
, GLsizei width
, GLint border
)
5084 __GLXcontext
*const gc
= __glXGetCurrentContext();
5085 const GLuint cmdlen
= 32;
5086 emit_header(gc
->pc
, X_GLrop_CopyTexImage1D
, cmdlen
);
5087 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&target
), 4);
5088 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&level
), 4);
5089 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&internalformat
), 4);
5090 (void) memcpy((void *) (gc
->pc
+ 16), (void *) (&x
), 4);
5091 (void) memcpy((void *) (gc
->pc
+ 20), (void *) (&y
), 4);
5092 (void) memcpy((void *) (gc
->pc
+ 24), (void *) (&width
), 4);
5093 (void) memcpy((void *) (gc
->pc
+ 28), (void *) (&border
), 4);
5095 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
5096 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
5100 #define X_GLrop_CopyTexImage2D 4120
5102 __indirect_glCopyTexImage2D(GLenum target
, GLint level
, GLenum internalformat
,
5103 GLint x
, GLint y
, GLsizei width
, GLsizei height
,
5106 __GLXcontext
*const gc
= __glXGetCurrentContext();
5107 const GLuint cmdlen
= 36;
5108 emit_header(gc
->pc
, X_GLrop_CopyTexImage2D
, cmdlen
);
5109 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&target
), 4);
5110 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&level
), 4);
5111 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&internalformat
), 4);
5112 (void) memcpy((void *) (gc
->pc
+ 16), (void *) (&x
), 4);
5113 (void) memcpy((void *) (gc
->pc
+ 20), (void *) (&y
), 4);
5114 (void) memcpy((void *) (gc
->pc
+ 24), (void *) (&width
), 4);
5115 (void) memcpy((void *) (gc
->pc
+ 28), (void *) (&height
), 4);
5116 (void) memcpy((void *) (gc
->pc
+ 32), (void *) (&border
), 4);
5118 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
5119 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
5123 #define X_GLrop_CopyTexSubImage1D 4121
5125 __indirect_glCopyTexSubImage1D(GLenum target
, GLint level
, GLint xoffset
,
5126 GLint x
, GLint y
, GLsizei width
)
5128 __GLXcontext
*const gc
= __glXGetCurrentContext();
5129 const GLuint cmdlen
= 28;
5130 emit_header(gc
->pc
, X_GLrop_CopyTexSubImage1D
, cmdlen
);
5131 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&target
), 4);
5132 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&level
), 4);
5133 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&xoffset
), 4);
5134 (void) memcpy((void *) (gc
->pc
+ 16), (void *) (&x
), 4);
5135 (void) memcpy((void *) (gc
->pc
+ 20), (void *) (&y
), 4);
5136 (void) memcpy((void *) (gc
->pc
+ 24), (void *) (&width
), 4);
5138 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
5139 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
5143 #define X_GLrop_CopyTexSubImage2D 4122
5145 __indirect_glCopyTexSubImage2D(GLenum target
, GLint level
, GLint xoffset
,
5146 GLint yoffset
, GLint x
, GLint y
, GLsizei width
,
5149 __GLXcontext
*const gc
= __glXGetCurrentContext();
5150 const GLuint cmdlen
= 36;
5151 emit_header(gc
->pc
, X_GLrop_CopyTexSubImage2D
, cmdlen
);
5152 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&target
), 4);
5153 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&level
), 4);
5154 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&xoffset
), 4);
5155 (void) memcpy((void *) (gc
->pc
+ 16), (void *) (&yoffset
), 4);
5156 (void) memcpy((void *) (gc
->pc
+ 20), (void *) (&x
), 4);
5157 (void) memcpy((void *) (gc
->pc
+ 24), (void *) (&y
), 4);
5158 (void) memcpy((void *) (gc
->pc
+ 28), (void *) (&width
), 4);
5159 (void) memcpy((void *) (gc
->pc
+ 32), (void *) (&height
), 4);
5161 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
5162 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
5166 #define X_GLsop_DeleteTextures 144
5168 __indirect_glDeleteTextures(GLsizei n
, const GLuint
* textures
)
5170 __GLXcontext
*const gc
= __glXGetCurrentContext();
5171 Display
*const dpy
= gc
->currentDpy
;
5173 const GLuint cmdlen
= 4 + __GLX_PAD((n
* 4));
5176 __glXSetError(gc
, GL_INVALID_VALUE
);
5179 if (__builtin_expect((n
>= 0) && (dpy
!= NULL
), 1)) {
5181 xcb_connection_t
*c
= XGetXCBConnection(dpy
);
5182 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
5183 xcb_glx_delete_textures(c
, gc
->currentContextTag
, n
, textures
);
5186 __glXSetupSingleRequest(gc
, X_GLsop_DeleteTextures
, cmdlen
);
5187 (void) memcpy((void *) (pc
+ 0), (void *) (&n
), 4);
5188 (void) memcpy((void *) (pc
+ 4), (void *) (textures
), (n
* 4));
5191 #endif /* USE_XCB */
5196 #define X_GLvop_DeleteTexturesEXT 12
5198 glDeleteTexturesEXT(GLsizei n
, const GLuint
* textures
)
5200 __GLXcontext
*const gc
= __glXGetCurrentContext();
5202 #ifdef GLX_DIRECT_RENDERING
5203 if (gc
->driContext
) {
5204 CALL_DeleteTextures(GET_DISPATCH(), (n
, textures
));
5208 __GLXcontext
*const gc
= __glXGetCurrentContext();
5209 Display
*const dpy
= gc
->currentDpy
;
5210 const GLuint cmdlen
= 4 + __GLX_PAD((n
* 4));
5212 __glXSetError(gc
, GL_INVALID_VALUE
);
5215 if (__builtin_expect((n
>= 0) && (dpy
!= NULL
), 1)) {
5217 __glXSetupVendorRequest(gc
, X_GLXVendorPrivate
,
5218 X_GLvop_DeleteTexturesEXT
, cmdlen
);
5219 (void) memcpy((void *) (pc
+ 0), (void *) (&n
), 4);
5220 (void) memcpy((void *) (pc
+ 4), (void *) (textures
), (n
* 4));
5228 #define X_GLsop_GenTextures 145
5230 __indirect_glGenTextures(GLsizei n
, GLuint
* textures
)
5232 __GLXcontext
*const gc
= __glXGetCurrentContext();
5233 Display
*const dpy
= gc
->currentDpy
;
5235 const GLuint cmdlen
= 4;
5238 __glXSetError(gc
, GL_INVALID_VALUE
);
5241 if (__builtin_expect((n
>= 0) && (dpy
!= NULL
), 1)) {
5243 xcb_connection_t
*c
= XGetXCBConnection(dpy
);
5244 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
5245 xcb_glx_gen_textures_reply_t
*reply
=
5246 xcb_glx_gen_textures_reply(c
,
5247 xcb_glx_gen_textures(c
,
5251 (void) memcpy(textures
, xcb_glx_gen_textures_data(reply
),
5252 xcb_glx_gen_textures_data_length(reply
) *
5257 __glXSetupSingleRequest(gc
, X_GLsop_GenTextures
, cmdlen
);
5258 (void) memcpy((void *) (pc
+ 0), (void *) (&n
), 4);
5259 (void) __glXReadReply(dpy
, 4, textures
, GL_TRUE
);
5262 #endif /* USE_XCB */
5267 #define X_GLvop_GenTexturesEXT 13
5269 glGenTexturesEXT(GLsizei n
, GLuint
* textures
)
5271 __GLXcontext
*const gc
= __glXGetCurrentContext();
5273 #ifdef GLX_DIRECT_RENDERING
5274 if (gc
->driContext
) {
5275 CALL_GenTextures(GET_DISPATCH(), (n
, textures
));
5279 __GLXcontext
*const gc
= __glXGetCurrentContext();
5280 Display
*const dpy
= gc
->currentDpy
;
5281 const GLuint cmdlen
= 4;
5283 __glXSetError(gc
, GL_INVALID_VALUE
);
5286 if (__builtin_expect((n
>= 0) && (dpy
!= NULL
), 1)) {
5288 __glXSetupVendorRequest(gc
, X_GLXVendorPrivateWithReply
,
5289 X_GLvop_GenTexturesEXT
, cmdlen
);
5290 (void) memcpy((void *) (pc
+ 0), (void *) (&n
), 4);
5291 (void) __glXReadReply(dpy
, 4, textures
, GL_TRUE
);
5299 #define X_GLsop_IsTexture 146
5301 __indirect_glIsTexture(GLuint texture
)
5303 __GLXcontext
*const gc
= __glXGetCurrentContext();
5304 Display
*const dpy
= gc
->currentDpy
;
5305 GLboolean retval
= (GLboolean
) 0;
5307 const GLuint cmdlen
= 4;
5309 if (__builtin_expect(dpy
!= NULL
, 1)) {
5311 xcb_connection_t
*c
= XGetXCBConnection(dpy
);
5312 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
5313 xcb_glx_is_texture_reply_t
*reply
=
5314 xcb_glx_is_texture_reply(c
,
5315 xcb_glx_is_texture(c
,
5316 gc
->currentContextTag
,
5318 retval
= reply
->ret_val
;
5322 __glXSetupSingleRequest(gc
, X_GLsop_IsTexture
, cmdlen
);
5323 (void) memcpy((void *) (pc
+ 0), (void *) (&texture
), 4);
5324 retval
= (GLboolean
) __glXReadReply(dpy
, 0, NULL
, GL_FALSE
);
5327 #endif /* USE_XCB */
5332 #define X_GLvop_IsTextureEXT 14
5334 glIsTextureEXT(GLuint texture
)
5336 __GLXcontext
*const gc
= __glXGetCurrentContext();
5338 #ifdef GLX_DIRECT_RENDERING
5339 if (gc
->driContext
) {
5340 return CALL_IsTexture(GET_DISPATCH(), (texture
));
5344 __GLXcontext
*const gc
= __glXGetCurrentContext();
5345 Display
*const dpy
= gc
->currentDpy
;
5346 GLboolean retval
= (GLboolean
) 0;
5347 const GLuint cmdlen
= 4;
5348 if (__builtin_expect(dpy
!= NULL
, 1)) {
5350 __glXSetupVendorRequest(gc
, X_GLXVendorPrivateWithReply
,
5351 X_GLvop_IsTextureEXT
, cmdlen
);
5352 (void) memcpy((void *) (pc
+ 0), (void *) (&texture
), 4);
5353 retval
= (GLboolean
) __glXReadReply(dpy
, 0, NULL
, GL_FALSE
);
5361 #define X_GLrop_PrioritizeTextures 4118
5363 __indirect_glPrioritizeTextures(GLsizei n
, const GLuint
* textures
,
5364 const GLclampf
* priorities
)
5366 __GLXcontext
*const gc
= __glXGetCurrentContext();
5367 const GLuint cmdlen
= 8 + __GLX_PAD((n
* 4)) + __GLX_PAD((n
* 4));
5369 __glXSetError(gc
, GL_INVALID_VALUE
);
5372 if (__builtin_expect(n
>= 0, 1)) {
5373 emit_header(gc
->pc
, X_GLrop_PrioritizeTextures
, cmdlen
);
5374 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&n
), 4);
5375 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (textures
), (n
* 4));
5376 (void) memcpy((void *) (gc
->pc
+ 8 + (n
* 4)), (void *) (priorities
),
5379 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
5380 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
5386 __glx_TexSubImage_1D2D(unsigned opcode
, unsigned dim
, GLenum target
,
5387 GLint level
, GLint xoffset
, GLint yoffset
,
5388 GLsizei width
, GLsizei height
, GLenum format
,
5389 GLenum type
, const GLvoid
* pixels
)
5391 __GLXcontext
*const gc
= __glXGetCurrentContext();
5392 const GLuint compsize
=
5393 (pixels
!= NULL
) ? __glImageSize(width
, height
, 1, format
, type
,
5395 const GLuint cmdlen
= 60 + __GLX_PAD(compsize
);
5396 if (__builtin_expect(gc
->currentDpy
!= NULL
, 1)) {
5397 if (cmdlen
<= gc
->maxSmallRenderCommandSize
) {
5398 if ((gc
->pc
+ cmdlen
) > gc
->bufEnd
) {
5399 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
5401 emit_header(gc
->pc
, opcode
, cmdlen
);
5402 (void) memcpy((void *) (gc
->pc
+ 24), (void *) (&target
), 4);
5403 (void) memcpy((void *) (gc
->pc
+ 28), (void *) (&level
), 4);
5404 (void) memcpy((void *) (gc
->pc
+ 32), (void *) (&xoffset
), 4);
5405 (void) memcpy((void *) (gc
->pc
+ 36), (void *) (&yoffset
), 4);
5406 (void) memcpy((void *) (gc
->pc
+ 40), (void *) (&width
), 4);
5407 (void) memcpy((void *) (gc
->pc
+ 44), (void *) (&height
), 4);
5408 (void) memcpy((void *) (gc
->pc
+ 48), (void *) (&format
), 4);
5409 (void) memcpy((void *) (gc
->pc
+ 52), (void *) (&type
), 4);
5410 (void) memset((void *) (gc
->pc
+ 56), 0, 4);
5412 (*gc
->fillImage
) (gc
, dim
, width
, height
, 1, format
, type
,
5413 pixels
, gc
->pc
+ 60, gc
->pc
+ 4);
5415 (void) memcpy(gc
->pc
+ 4, default_pixel_store_2D
,
5416 default_pixel_store_2D_size
);
5419 if (gc
->pc
> gc
->limit
) {
5420 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
5423 const GLint op
= opcode
;
5424 const GLuint cmdlenLarge
= cmdlen
+ 4;
5425 GLubyte
*const pc
= __glXFlushRenderBuffer(gc
, gc
->pc
);
5426 (void) memcpy((void *) (pc
+ 0), (void *) (&cmdlenLarge
), 4);
5427 (void) memcpy((void *) (pc
+ 4), (void *) (&op
), 4);
5428 (void) memcpy((void *) (pc
+ 28), (void *) (&target
), 4);
5429 (void) memcpy((void *) (pc
+ 32), (void *) (&level
), 4);
5430 (void) memcpy((void *) (pc
+ 36), (void *) (&xoffset
), 4);
5431 (void) memcpy((void *) (pc
+ 40), (void *) (&yoffset
), 4);
5432 (void) memcpy((void *) (pc
+ 44), (void *) (&width
), 4);
5433 (void) memcpy((void *) (pc
+ 48), (void *) (&height
), 4);
5434 (void) memcpy((void *) (pc
+ 52), (void *) (&format
), 4);
5435 (void) memcpy((void *) (pc
+ 56), (void *) (&type
), 4);
5436 (void) memset((void *) (pc
+ 60), 0, 4);
5437 __glXSendLargeImage(gc
, compsize
, dim
, width
, height
, 1, format
,
5438 type
, pixels
, pc
+ 64, pc
+ 8);
5443 #define X_GLrop_TexSubImage1D 4099
5445 __indirect_glTexSubImage1D(GLenum target
, GLint level
, GLint xoffset
,
5446 GLsizei width
, GLenum format
, GLenum type
,
5447 const GLvoid
* pixels
)
5449 __glx_TexSubImage_1D2D(X_GLrop_TexSubImage1D
, 1, target
, level
, xoffset
,
5450 1, width
, 1, format
, type
, pixels
);
5453 #define X_GLrop_TexSubImage2D 4100
5455 __indirect_glTexSubImage2D(GLenum target
, GLint level
, GLint xoffset
,
5456 GLint yoffset
, GLsizei width
, GLsizei height
,
5457 GLenum format
, GLenum type
, const GLvoid
* pixels
)
5459 __glx_TexSubImage_1D2D(X_GLrop_TexSubImage2D
, 2, target
, level
, xoffset
,
5460 yoffset
, width
, height
, format
, type
, pixels
);
5463 #define X_GLrop_BlendColor 4096
5465 __indirect_glBlendColor(GLclampf red
, GLclampf green
, GLclampf blue
,
5468 __GLXcontext
*const gc
= __glXGetCurrentContext();
5469 const GLuint cmdlen
= 20;
5470 emit_header(gc
->pc
, X_GLrop_BlendColor
, cmdlen
);
5471 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&red
), 4);
5472 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&green
), 4);
5473 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&blue
), 4);
5474 (void) memcpy((void *) (gc
->pc
+ 16), (void *) (&alpha
), 4);
5476 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
5477 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
5481 #define X_GLrop_BlendEquation 4097
5483 __indirect_glBlendEquation(GLenum mode
)
5485 __GLXcontext
*const gc
= __glXGetCurrentContext();
5486 const GLuint cmdlen
= 8;
5487 emit_header(gc
->pc
, X_GLrop_BlendEquation
, cmdlen
);
5488 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&mode
), 4);
5490 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
5491 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
5495 #define X_GLrop_ColorTable 2053
5497 __indirect_glColorTable(GLenum target
, GLenum internalformat
, GLsizei width
,
5498 GLenum format
, GLenum type
, const GLvoid
* table
)
5500 __GLXcontext
*const gc
= __glXGetCurrentContext();
5501 const GLuint compsize
=
5502 (table
!= NULL
) ? __glImageSize(width
, 1, 1, format
, type
,
5504 const GLuint cmdlen
= 44 + __GLX_PAD(compsize
);
5505 if (__builtin_expect(gc
->currentDpy
!= NULL
, 1)) {
5506 if (cmdlen
<= gc
->maxSmallRenderCommandSize
) {
5507 if ((gc
->pc
+ cmdlen
) > gc
->bufEnd
) {
5508 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
5510 emit_header(gc
->pc
, X_GLrop_ColorTable
, cmdlen
);
5511 (void) memcpy((void *) (gc
->pc
+ 24), (void *) (&target
), 4);
5512 (void) memcpy((void *) (gc
->pc
+ 28), (void *) (&internalformat
),
5514 (void) memcpy((void *) (gc
->pc
+ 32), (void *) (&width
), 4);
5515 (void) memcpy((void *) (gc
->pc
+ 36), (void *) (&format
), 4);
5516 (void) memcpy((void *) (gc
->pc
+ 40), (void *) (&type
), 4);
5518 (*gc
->fillImage
) (gc
, 1, width
, 1, 1, format
, type
, table
,
5519 gc
->pc
+ 44, gc
->pc
+ 4);
5521 (void) memcpy(gc
->pc
+ 4, default_pixel_store_1D
,
5522 default_pixel_store_1D_size
);
5525 if (gc
->pc
> gc
->limit
) {
5526 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
5529 const GLint op
= X_GLrop_ColorTable
;
5530 const GLuint cmdlenLarge
= cmdlen
+ 4;
5531 GLubyte
*const pc
= __glXFlushRenderBuffer(gc
, gc
->pc
);
5532 (void) memcpy((void *) (pc
+ 0), (void *) (&cmdlenLarge
), 4);
5533 (void) memcpy((void *) (pc
+ 4), (void *) (&op
), 4);
5534 (void) memcpy((void *) (pc
+ 28), (void *) (&target
), 4);
5535 (void) memcpy((void *) (pc
+ 32), (void *) (&internalformat
), 4);
5536 (void) memcpy((void *) (pc
+ 36), (void *) (&width
), 4);
5537 (void) memcpy((void *) (pc
+ 40), (void *) (&format
), 4);
5538 (void) memcpy((void *) (pc
+ 44), (void *) (&type
), 4);
5539 __glXSendLargeImage(gc
, compsize
, 1, width
, 1, 1, format
, type
,
5540 table
, pc
+ 48, pc
+ 8);
5545 #define X_GLrop_ColorTableParameterfv 2054
5547 __indirect_glColorTableParameterfv(GLenum target
, GLenum pname
,
5548 const GLfloat
* params
)
5550 __GLXcontext
*const gc
= __glXGetCurrentContext();
5551 const GLuint compsize
= __glColorTableParameterfv_size(pname
);
5552 const GLuint cmdlen
= 12 + __GLX_PAD((compsize
* 4));
5553 emit_header(gc
->pc
, X_GLrop_ColorTableParameterfv
, cmdlen
);
5554 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&target
), 4);
5555 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&pname
), 4);
5556 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (params
), (compsize
* 4));
5558 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
5559 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
5563 #define X_GLrop_ColorTableParameteriv 2055
5565 __indirect_glColorTableParameteriv(GLenum target
, GLenum pname
,
5566 const GLint
* params
)
5568 __GLXcontext
*const gc
= __glXGetCurrentContext();
5569 const GLuint compsize
= __glColorTableParameteriv_size(pname
);
5570 const GLuint cmdlen
= 12 + __GLX_PAD((compsize
* 4));
5571 emit_header(gc
->pc
, X_GLrop_ColorTableParameteriv
, cmdlen
);
5572 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&target
), 4);
5573 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&pname
), 4);
5574 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (params
), (compsize
* 4));
5576 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
5577 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
5581 #define X_GLrop_CopyColorTable 2056
5583 __indirect_glCopyColorTable(GLenum target
, GLenum internalformat
, GLint x
,
5584 GLint y
, GLsizei width
)
5586 __GLXcontext
*const gc
= __glXGetCurrentContext();
5587 const GLuint cmdlen
= 24;
5588 emit_header(gc
->pc
, X_GLrop_CopyColorTable
, cmdlen
);
5589 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&target
), 4);
5590 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&internalformat
), 4);
5591 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&x
), 4);
5592 (void) memcpy((void *) (gc
->pc
+ 16), (void *) (&y
), 4);
5593 (void) memcpy((void *) (gc
->pc
+ 20), (void *) (&width
), 4);
5595 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
5596 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
5600 #define X_GLsop_GetColorTable 147
5602 __indirect_glGetColorTable(GLenum target
, GLenum format
, GLenum type
,
5605 __GLXcontext
*const gc
= __glXGetCurrentContext();
5606 const __GLXattribute
*const state
= gc
->client_state_private
;
5607 Display
*const dpy
= gc
->currentDpy
;
5609 const GLuint cmdlen
= 16;
5611 if (__builtin_expect(dpy
!= NULL
, 1)) {
5613 xcb_connection_t
*c
= XGetXCBConnection(dpy
);
5614 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
5615 xcb_glx_get_color_table_reply_t
*reply
=
5616 xcb_glx_get_color_table_reply(c
,
5617 xcb_glx_get_color_table(c
,
5627 (void) memcpy(table
, xcb_glx_get_color_table_data(reply
),
5628 xcb_glx_get_color_table_data_length(reply
) *
5633 __glXSetupSingleRequest(gc
, X_GLsop_GetColorTable
, cmdlen
);
5634 (void) memcpy((void *) (pc
+ 0), (void *) (&target
), 4);
5635 (void) memcpy((void *) (pc
+ 4), (void *) (&format
), 4);
5636 (void) memcpy((void *) (pc
+ 8), (void *) (&type
), 4);
5637 *(int32_t *) (pc
+ 12) = 0;
5638 *(int8_t *) (pc
+ 12) = state
->storePack
.swapEndian
;
5639 __glXReadPixelReply(dpy
, gc
, 1, 0, 0, 0, format
, type
, table
,
5643 #endif /* USE_XCB */
5648 #define X_GLvop_GetColorTableSGI 4098
5650 glGetColorTableEXT(GLenum target
, GLenum format
, GLenum type
, GLvoid
* table
)
5652 __GLXcontext
*const gc
= __glXGetCurrentContext();
5654 #ifdef GLX_DIRECT_RENDERING
5655 if (gc
->driContext
) {
5656 CALL_GetColorTable(GET_DISPATCH(), (target
, format
, type
, table
));
5660 __GLXcontext
*const gc
= __glXGetCurrentContext();
5661 const __GLXattribute
*const state
= gc
->client_state_private
;
5662 Display
*const dpy
= gc
->currentDpy
;
5663 const GLuint cmdlen
= 16;
5664 if (__builtin_expect(dpy
!= NULL
, 1)) {
5666 __glXSetupVendorRequest(gc
, X_GLXVendorPrivateWithReply
,
5667 X_GLvop_GetColorTableSGI
, cmdlen
);
5668 (void) memcpy((void *) (pc
+ 0), (void *) (&target
), 4);
5669 (void) memcpy((void *) (pc
+ 4), (void *) (&format
), 4);
5670 (void) memcpy((void *) (pc
+ 8), (void *) (&type
), 4);
5671 *(int32_t *) (pc
+ 12) = 0;
5672 *(int8_t *) (pc
+ 12) = state
->storePack
.swapEndian
;
5673 __glXReadPixelReply(dpy
, gc
, 1, 0, 0, 0, format
, type
, table
,
5682 #define X_GLsop_GetColorTableParameterfv 148
5684 __indirect_glGetColorTableParameterfv(GLenum target
, GLenum pname
,
5687 __GLXcontext
*const gc
= __glXGetCurrentContext();
5688 Display
*const dpy
= gc
->currentDpy
;
5690 const GLuint cmdlen
= 8;
5692 if (__builtin_expect(dpy
!= NULL
, 1)) {
5694 xcb_connection_t
*c
= XGetXCBConnection(dpy
);
5695 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
5696 xcb_glx_get_color_table_parameterfv_reply_t
*reply
=
5697 xcb_glx_get_color_table_parameterfv_reply(c
,
5698 xcb_glx_get_color_table_parameterfv
5700 gc
->currentContextTag
,
5701 target
, pname
), NULL
);
5702 if (xcb_glx_get_color_table_parameterfv_data_length(reply
) == 0)
5703 (void) memcpy(params
, &reply
->datum
, sizeof(reply
->datum
));
5705 (void) memcpy(params
,
5706 xcb_glx_get_color_table_parameterfv_data(reply
),
5707 xcb_glx_get_color_table_parameterfv_data_length
5708 (reply
) * sizeof(GLfloat
));
5712 __glXSetupSingleRequest(gc
, X_GLsop_GetColorTableParameterfv
,
5714 (void) memcpy((void *) (pc
+ 0), (void *) (&target
), 4);
5715 (void) memcpy((void *) (pc
+ 4), (void *) (&pname
), 4);
5716 (void) __glXReadReply(dpy
, 4, params
, GL_FALSE
);
5719 #endif /* USE_XCB */
5724 #define X_GLvop_GetColorTableParameterfvSGI 4099
5726 glGetColorTableParameterfvEXT(GLenum target
, GLenum pname
, GLfloat
* params
)
5728 __GLXcontext
*const gc
= __glXGetCurrentContext();
5730 #ifdef GLX_DIRECT_RENDERING
5731 if (gc
->driContext
) {
5732 CALL_GetColorTableParameterfv(GET_DISPATCH(),
5733 (target
, pname
, params
));
5737 __GLXcontext
*const gc
= __glXGetCurrentContext();
5738 Display
*const dpy
= gc
->currentDpy
;
5739 const GLuint cmdlen
= 8;
5740 if (__builtin_expect(dpy
!= NULL
, 1)) {
5742 __glXSetupVendorRequest(gc
, X_GLXVendorPrivateWithReply
,
5743 X_GLvop_GetColorTableParameterfvSGI
,
5745 (void) memcpy((void *) (pc
+ 0), (void *) (&target
), 4);
5746 (void) memcpy((void *) (pc
+ 4), (void *) (&pname
), 4);
5747 (void) __glXReadReply(dpy
, 4, params
, GL_FALSE
);
5755 #define X_GLsop_GetColorTableParameteriv 149
5757 __indirect_glGetColorTableParameteriv(GLenum target
, GLenum pname
,
5760 __GLXcontext
*const gc
= __glXGetCurrentContext();
5761 Display
*const dpy
= gc
->currentDpy
;
5763 const GLuint cmdlen
= 8;
5765 if (__builtin_expect(dpy
!= NULL
, 1)) {
5767 xcb_connection_t
*c
= XGetXCBConnection(dpy
);
5768 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
5769 xcb_glx_get_color_table_parameteriv_reply_t
*reply
=
5770 xcb_glx_get_color_table_parameteriv_reply(c
,
5771 xcb_glx_get_color_table_parameteriv
5773 gc
->currentContextTag
,
5774 target
, pname
), NULL
);
5775 if (xcb_glx_get_color_table_parameteriv_data_length(reply
) == 0)
5776 (void) memcpy(params
, &reply
->datum
, sizeof(reply
->datum
));
5778 (void) memcpy(params
,
5779 xcb_glx_get_color_table_parameteriv_data(reply
),
5780 xcb_glx_get_color_table_parameteriv_data_length
5781 (reply
) * sizeof(GLint
));
5785 __glXSetupSingleRequest(gc
, X_GLsop_GetColorTableParameteriv
,
5787 (void) memcpy((void *) (pc
+ 0), (void *) (&target
), 4);
5788 (void) memcpy((void *) (pc
+ 4), (void *) (&pname
), 4);
5789 (void) __glXReadReply(dpy
, 4, params
, GL_FALSE
);
5792 #endif /* USE_XCB */
5797 #define X_GLvop_GetColorTableParameterivSGI 4100
5799 glGetColorTableParameterivEXT(GLenum target
, GLenum pname
, GLint
* params
)
5801 __GLXcontext
*const gc
= __glXGetCurrentContext();
5803 #ifdef GLX_DIRECT_RENDERING
5804 if (gc
->driContext
) {
5805 CALL_GetColorTableParameteriv(GET_DISPATCH(),
5806 (target
, pname
, params
));
5810 __GLXcontext
*const gc
= __glXGetCurrentContext();
5811 Display
*const dpy
= gc
->currentDpy
;
5812 const GLuint cmdlen
= 8;
5813 if (__builtin_expect(dpy
!= NULL
, 1)) {
5815 __glXSetupVendorRequest(gc
, X_GLXVendorPrivateWithReply
,
5816 X_GLvop_GetColorTableParameterivSGI
,
5818 (void) memcpy((void *) (pc
+ 0), (void *) (&target
), 4);
5819 (void) memcpy((void *) (pc
+ 4), (void *) (&pname
), 4);
5820 (void) __glXReadReply(dpy
, 4, params
, GL_FALSE
);
5828 #define X_GLrop_ColorSubTable 195
5830 __indirect_glColorSubTable(GLenum target
, GLsizei start
, GLsizei count
,
5831 GLenum format
, GLenum type
, const GLvoid
* data
)
5833 __GLXcontext
*const gc
= __glXGetCurrentContext();
5834 const GLuint compsize
=
5835 (data
!= NULL
) ? __glImageSize(count
, 1, 1, format
, type
, target
) : 0;
5836 const GLuint cmdlen
= 44 + __GLX_PAD(compsize
);
5837 if (__builtin_expect(gc
->currentDpy
!= NULL
, 1)) {
5838 if (cmdlen
<= gc
->maxSmallRenderCommandSize
) {
5839 if ((gc
->pc
+ cmdlen
) > gc
->bufEnd
) {
5840 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
5842 emit_header(gc
->pc
, X_GLrop_ColorSubTable
, cmdlen
);
5843 (void) memcpy((void *) (gc
->pc
+ 24), (void *) (&target
), 4);
5844 (void) memcpy((void *) (gc
->pc
+ 28), (void *) (&start
), 4);
5845 (void) memcpy((void *) (gc
->pc
+ 32), (void *) (&count
), 4);
5846 (void) memcpy((void *) (gc
->pc
+ 36), (void *) (&format
), 4);
5847 (void) memcpy((void *) (gc
->pc
+ 40), (void *) (&type
), 4);
5849 (*gc
->fillImage
) (gc
, 1, count
, 1, 1, format
, type
, data
,
5850 gc
->pc
+ 44, gc
->pc
+ 4);
5852 (void) memcpy(gc
->pc
+ 4, default_pixel_store_1D
,
5853 default_pixel_store_1D_size
);
5856 if (gc
->pc
> gc
->limit
) {
5857 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
5860 const GLint op
= X_GLrop_ColorSubTable
;
5861 const GLuint cmdlenLarge
= cmdlen
+ 4;
5862 GLubyte
*const pc
= __glXFlushRenderBuffer(gc
, gc
->pc
);
5863 (void) memcpy((void *) (pc
+ 0), (void *) (&cmdlenLarge
), 4);
5864 (void) memcpy((void *) (pc
+ 4), (void *) (&op
), 4);
5865 (void) memcpy((void *) (pc
+ 28), (void *) (&target
), 4);
5866 (void) memcpy((void *) (pc
+ 32), (void *) (&start
), 4);
5867 (void) memcpy((void *) (pc
+ 36), (void *) (&count
), 4);
5868 (void) memcpy((void *) (pc
+ 40), (void *) (&format
), 4);
5869 (void) memcpy((void *) (pc
+ 44), (void *) (&type
), 4);
5870 __glXSendLargeImage(gc
, compsize
, 1, count
, 1, 1, format
, type
,
5871 data
, pc
+ 48, pc
+ 8);
5876 #define X_GLrop_CopyColorSubTable 196
5878 __indirect_glCopyColorSubTable(GLenum target
, GLsizei start
, GLint x
, GLint y
,
5881 __GLXcontext
*const gc
= __glXGetCurrentContext();
5882 const GLuint cmdlen
= 24;
5883 emit_header(gc
->pc
, X_GLrop_CopyColorSubTable
, cmdlen
);
5884 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&target
), 4);
5885 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&start
), 4);
5886 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&x
), 4);
5887 (void) memcpy((void *) (gc
->pc
+ 16), (void *) (&y
), 4);
5888 (void) memcpy((void *) (gc
->pc
+ 20), (void *) (&width
), 4);
5890 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
5891 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
5896 __glx_ConvolutionFilter_1D2D(unsigned opcode
, unsigned dim
, GLenum target
,
5897 GLenum internalformat
, GLsizei width
,
5898 GLsizei height
, GLenum format
, GLenum type
,
5899 const GLvoid
* image
)
5901 __GLXcontext
*const gc
= __glXGetCurrentContext();
5902 const GLuint compsize
=
5903 (image
!= NULL
) ? __glImageSize(width
, height
, 1, format
, type
,
5905 const GLuint cmdlen
= 48 + __GLX_PAD(compsize
);
5906 if (__builtin_expect(gc
->currentDpy
!= NULL
, 1)) {
5907 if (cmdlen
<= gc
->maxSmallRenderCommandSize
) {
5908 if ((gc
->pc
+ cmdlen
) > gc
->bufEnd
) {
5909 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
5911 emit_header(gc
->pc
, opcode
, cmdlen
);
5912 (void) memcpy((void *) (gc
->pc
+ 24), (void *) (&target
), 4);
5913 (void) memcpy((void *) (gc
->pc
+ 28), (void *) (&internalformat
),
5915 (void) memcpy((void *) (gc
->pc
+ 32), (void *) (&width
), 4);
5916 (void) memcpy((void *) (gc
->pc
+ 36), (void *) (&height
), 4);
5917 (void) memcpy((void *) (gc
->pc
+ 40), (void *) (&format
), 4);
5918 (void) memcpy((void *) (gc
->pc
+ 44), (void *) (&type
), 4);
5920 (*gc
->fillImage
) (gc
, dim
, width
, height
, 1, format
, type
,
5921 image
, gc
->pc
+ 48, gc
->pc
+ 4);
5923 (void) memcpy(gc
->pc
+ 4, default_pixel_store_2D
,
5924 default_pixel_store_2D_size
);
5927 if (gc
->pc
> gc
->limit
) {
5928 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
5931 const GLint op
= opcode
;
5932 const GLuint cmdlenLarge
= cmdlen
+ 4;
5933 GLubyte
*const pc
= __glXFlushRenderBuffer(gc
, gc
->pc
);
5934 (void) memcpy((void *) (pc
+ 0), (void *) (&cmdlenLarge
), 4);
5935 (void) memcpy((void *) (pc
+ 4), (void *) (&op
), 4);
5936 (void) memcpy((void *) (pc
+ 28), (void *) (&target
), 4);
5937 (void) memcpy((void *) (pc
+ 32), (void *) (&internalformat
), 4);
5938 (void) memcpy((void *) (pc
+ 36), (void *) (&width
), 4);
5939 (void) memcpy((void *) (pc
+ 40), (void *) (&height
), 4);
5940 (void) memcpy((void *) (pc
+ 44), (void *) (&format
), 4);
5941 (void) memcpy((void *) (pc
+ 48), (void *) (&type
), 4);
5942 __glXSendLargeImage(gc
, compsize
, dim
, width
, height
, 1, format
,
5943 type
, image
, pc
+ 52, pc
+ 8);
5948 #define X_GLrop_ConvolutionFilter1D 4101
5950 __indirect_glConvolutionFilter1D(GLenum target
, GLenum internalformat
,
5951 GLsizei width
, GLenum format
, GLenum type
,
5952 const GLvoid
* image
)
5954 __glx_ConvolutionFilter_1D2D(X_GLrop_ConvolutionFilter1D
, 1, target
,
5955 internalformat
, width
, 1, format
, type
,
5959 #define X_GLrop_ConvolutionFilter2D 4102
5961 __indirect_glConvolutionFilter2D(GLenum target
, GLenum internalformat
,
5962 GLsizei width
, GLsizei height
, GLenum format
,
5963 GLenum type
, const GLvoid
* image
)
5965 __glx_ConvolutionFilter_1D2D(X_GLrop_ConvolutionFilter2D
, 2, target
,
5966 internalformat
, width
, height
, format
, type
,
5970 #define X_GLrop_ConvolutionParameterf 4103
5972 __indirect_glConvolutionParameterf(GLenum target
, GLenum pname
,
5975 __GLXcontext
*const gc
= __glXGetCurrentContext();
5976 const GLuint cmdlen
= 16;
5977 emit_header(gc
->pc
, X_GLrop_ConvolutionParameterf
, cmdlen
);
5978 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&target
), 4);
5979 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&pname
), 4);
5980 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (¶ms
), 4);
5982 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
5983 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
5987 #define X_GLrop_ConvolutionParameterfv 4104
5989 __indirect_glConvolutionParameterfv(GLenum target
, GLenum pname
,
5990 const GLfloat
* params
)
5992 __GLXcontext
*const gc
= __glXGetCurrentContext();
5993 const GLuint compsize
= __glConvolutionParameterfv_size(pname
);
5994 const GLuint cmdlen
= 12 + __GLX_PAD((compsize
* 4));
5995 emit_header(gc
->pc
, X_GLrop_ConvolutionParameterfv
, cmdlen
);
5996 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&target
), 4);
5997 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&pname
), 4);
5998 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (params
), (compsize
* 4));
6000 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
6001 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
6005 #define X_GLrop_ConvolutionParameteri 4105
6007 __indirect_glConvolutionParameteri(GLenum target
, GLenum pname
, GLint params
)
6009 __GLXcontext
*const gc
= __glXGetCurrentContext();
6010 const GLuint cmdlen
= 16;
6011 emit_header(gc
->pc
, X_GLrop_ConvolutionParameteri
, cmdlen
);
6012 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&target
), 4);
6013 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&pname
), 4);
6014 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (¶ms
), 4);
6016 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
6017 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
6021 #define X_GLrop_ConvolutionParameteriv 4106
6023 __indirect_glConvolutionParameteriv(GLenum target
, GLenum pname
,
6024 const GLint
* params
)
6026 __GLXcontext
*const gc
= __glXGetCurrentContext();
6027 const GLuint compsize
= __glConvolutionParameteriv_size(pname
);
6028 const GLuint cmdlen
= 12 + __GLX_PAD((compsize
* 4));
6029 emit_header(gc
->pc
, X_GLrop_ConvolutionParameteriv
, cmdlen
);
6030 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&target
), 4);
6031 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&pname
), 4);
6032 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (params
), (compsize
* 4));
6034 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
6035 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
6039 #define X_GLrop_CopyConvolutionFilter1D 4107
6041 __indirect_glCopyConvolutionFilter1D(GLenum target
, GLenum internalformat
,
6042 GLint x
, GLint y
, GLsizei width
)
6044 __GLXcontext
*const gc
= __glXGetCurrentContext();
6045 const GLuint cmdlen
= 24;
6046 emit_header(gc
->pc
, X_GLrop_CopyConvolutionFilter1D
, cmdlen
);
6047 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&target
), 4);
6048 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&internalformat
), 4);
6049 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&x
), 4);
6050 (void) memcpy((void *) (gc
->pc
+ 16), (void *) (&y
), 4);
6051 (void) memcpy((void *) (gc
->pc
+ 20), (void *) (&width
), 4);
6053 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
6054 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
6058 #define X_GLrop_CopyConvolutionFilter2D 4108
6060 __indirect_glCopyConvolutionFilter2D(GLenum target
, GLenum internalformat
,
6061 GLint x
, GLint y
, GLsizei width
,
6064 __GLXcontext
*const gc
= __glXGetCurrentContext();
6065 const GLuint cmdlen
= 28;
6066 emit_header(gc
->pc
, X_GLrop_CopyConvolutionFilter2D
, cmdlen
);
6067 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&target
), 4);
6068 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&internalformat
), 4);
6069 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&x
), 4);
6070 (void) memcpy((void *) (gc
->pc
+ 16), (void *) (&y
), 4);
6071 (void) memcpy((void *) (gc
->pc
+ 20), (void *) (&width
), 4);
6072 (void) memcpy((void *) (gc
->pc
+ 24), (void *) (&height
), 4);
6074 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
6075 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
6079 #define X_GLsop_GetConvolutionFilter 150
6081 __indirect_glGetConvolutionFilter(GLenum target
, GLenum format
, GLenum type
,
6084 __GLXcontext
*const gc
= __glXGetCurrentContext();
6085 const __GLXattribute
*const state
= gc
->client_state_private
;
6086 Display
*const dpy
= gc
->currentDpy
;
6088 const GLuint cmdlen
= 16;
6090 if (__builtin_expect(dpy
!= NULL
, 1)) {
6092 xcb_connection_t
*c
= XGetXCBConnection(dpy
);
6093 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
6094 xcb_glx_get_convolution_filter_reply_t
*reply
=
6095 xcb_glx_get_convolution_filter_reply(c
,
6096 xcb_glx_get_convolution_filter
6097 (c
, gc
->currentContextTag
,
6098 target
, format
, type
,
6101 (void) memcpy(image
, xcb_glx_get_convolution_filter_data(reply
),
6102 xcb_glx_get_convolution_filter_data_length(reply
) *
6107 __glXSetupSingleRequest(gc
, X_GLsop_GetConvolutionFilter
, cmdlen
);
6108 (void) memcpy((void *) (pc
+ 0), (void *) (&target
), 4);
6109 (void) memcpy((void *) (pc
+ 4), (void *) (&format
), 4);
6110 (void) memcpy((void *) (pc
+ 8), (void *) (&type
), 4);
6111 *(int32_t *) (pc
+ 12) = 0;
6112 *(int8_t *) (pc
+ 12) = state
->storePack
.swapEndian
;
6113 __glXReadPixelReply(dpy
, gc
, 2, 0, 0, 0, format
, type
, image
,
6117 #endif /* USE_XCB */
6122 #define X_GLvop_GetConvolutionFilterEXT 1
6124 gl_dispatch_stub_356(GLenum target
, GLenum format
, GLenum type
,
6127 __GLXcontext
*const gc
= __glXGetCurrentContext();
6129 #ifdef GLX_DIRECT_RENDERING
6130 if (gc
->driContext
) {
6131 CALL_GetConvolutionFilter(GET_DISPATCH(),
6132 (target
, format
, type
, image
));
6136 __GLXcontext
*const gc
= __glXGetCurrentContext();
6137 const __GLXattribute
*const state
= gc
->client_state_private
;
6138 Display
*const dpy
= gc
->currentDpy
;
6139 const GLuint cmdlen
= 16;
6140 if (__builtin_expect(dpy
!= NULL
, 1)) {
6142 __glXSetupVendorRequest(gc
, X_GLXVendorPrivateWithReply
,
6143 X_GLvop_GetConvolutionFilterEXT
,
6145 (void) memcpy((void *) (pc
+ 0), (void *) (&target
), 4);
6146 (void) memcpy((void *) (pc
+ 4), (void *) (&format
), 4);
6147 (void) memcpy((void *) (pc
+ 8), (void *) (&type
), 4);
6148 *(int32_t *) (pc
+ 12) = 0;
6149 *(int8_t *) (pc
+ 12) = state
->storePack
.swapEndian
;
6150 __glXReadPixelReply(dpy
, gc
, 2, 0, 0, 0, format
, type
, image
,
6159 #define X_GLsop_GetConvolutionParameterfv 151
6161 __indirect_glGetConvolutionParameterfv(GLenum target
, GLenum pname
,
6164 __GLXcontext
*const gc
= __glXGetCurrentContext();
6165 Display
*const dpy
= gc
->currentDpy
;
6167 const GLuint cmdlen
= 8;
6169 if (__builtin_expect(dpy
!= NULL
, 1)) {
6171 xcb_connection_t
*c
= XGetXCBConnection(dpy
);
6172 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
6173 xcb_glx_get_convolution_parameterfv_reply_t
*reply
=
6174 xcb_glx_get_convolution_parameterfv_reply(c
,
6175 xcb_glx_get_convolution_parameterfv
6177 gc
->currentContextTag
,
6178 target
, pname
), NULL
);
6179 if (xcb_glx_get_convolution_parameterfv_data_length(reply
) == 0)
6180 (void) memcpy(params
, &reply
->datum
, sizeof(reply
->datum
));
6182 (void) memcpy(params
,
6183 xcb_glx_get_convolution_parameterfv_data(reply
),
6184 xcb_glx_get_convolution_parameterfv_data_length
6185 (reply
) * sizeof(GLfloat
));
6189 __glXSetupSingleRequest(gc
, X_GLsop_GetConvolutionParameterfv
,
6191 (void) memcpy((void *) (pc
+ 0), (void *) (&target
), 4);
6192 (void) memcpy((void *) (pc
+ 4), (void *) (&pname
), 4);
6193 (void) __glXReadReply(dpy
, 4, params
, GL_FALSE
);
6196 #endif /* USE_XCB */
6201 #define X_GLvop_GetConvolutionParameterfvEXT 2
6203 gl_dispatch_stub_357(GLenum target
, GLenum pname
, GLfloat
* params
)
6205 __GLXcontext
*const gc
= __glXGetCurrentContext();
6207 #ifdef GLX_DIRECT_RENDERING
6208 if (gc
->driContext
) {
6209 CALL_GetConvolutionParameterfv(GET_DISPATCH(),
6210 (target
, pname
, params
));
6214 __GLXcontext
*const gc
= __glXGetCurrentContext();
6215 Display
*const dpy
= gc
->currentDpy
;
6216 const GLuint cmdlen
= 8;
6217 if (__builtin_expect(dpy
!= NULL
, 1)) {
6219 __glXSetupVendorRequest(gc
, X_GLXVendorPrivateWithReply
,
6220 X_GLvop_GetConvolutionParameterfvEXT
,
6222 (void) memcpy((void *) (pc
+ 0), (void *) (&target
), 4);
6223 (void) memcpy((void *) (pc
+ 4), (void *) (&pname
), 4);
6224 (void) __glXReadReply(dpy
, 4, params
, GL_FALSE
);
6232 #define X_GLsop_GetConvolutionParameteriv 152
6234 __indirect_glGetConvolutionParameteriv(GLenum target
, GLenum pname
,
6237 __GLXcontext
*const gc
= __glXGetCurrentContext();
6238 Display
*const dpy
= gc
->currentDpy
;
6240 const GLuint cmdlen
= 8;
6242 if (__builtin_expect(dpy
!= NULL
, 1)) {
6244 xcb_connection_t
*c
= XGetXCBConnection(dpy
);
6245 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
6246 xcb_glx_get_convolution_parameteriv_reply_t
*reply
=
6247 xcb_glx_get_convolution_parameteriv_reply(c
,
6248 xcb_glx_get_convolution_parameteriv
6250 gc
->currentContextTag
,
6251 target
, pname
), NULL
);
6252 if (xcb_glx_get_convolution_parameteriv_data_length(reply
) == 0)
6253 (void) memcpy(params
, &reply
->datum
, sizeof(reply
->datum
));
6255 (void) memcpy(params
,
6256 xcb_glx_get_convolution_parameteriv_data(reply
),
6257 xcb_glx_get_convolution_parameteriv_data_length
6258 (reply
) * sizeof(GLint
));
6262 __glXSetupSingleRequest(gc
, X_GLsop_GetConvolutionParameteriv
,
6264 (void) memcpy((void *) (pc
+ 0), (void *) (&target
), 4);
6265 (void) memcpy((void *) (pc
+ 4), (void *) (&pname
), 4);
6266 (void) __glXReadReply(dpy
, 4, params
, GL_FALSE
);
6269 #endif /* USE_XCB */
6274 #define X_GLvop_GetConvolutionParameterivEXT 3
6276 gl_dispatch_stub_358(GLenum target
, GLenum pname
, GLint
* params
)
6278 __GLXcontext
*const gc
= __glXGetCurrentContext();
6280 #ifdef GLX_DIRECT_RENDERING
6281 if (gc
->driContext
) {
6282 CALL_GetConvolutionParameteriv(GET_DISPATCH(),
6283 (target
, pname
, params
));
6287 __GLXcontext
*const gc
= __glXGetCurrentContext();
6288 Display
*const dpy
= gc
->currentDpy
;
6289 const GLuint cmdlen
= 8;
6290 if (__builtin_expect(dpy
!= NULL
, 1)) {
6292 __glXSetupVendorRequest(gc
, X_GLXVendorPrivateWithReply
,
6293 X_GLvop_GetConvolutionParameterivEXT
,
6295 (void) memcpy((void *) (pc
+ 0), (void *) (&target
), 4);
6296 (void) memcpy((void *) (pc
+ 4), (void *) (&pname
), 4);
6297 (void) __glXReadReply(dpy
, 4, params
, GL_FALSE
);
6305 #define X_GLsop_GetHistogram 154
6307 __indirect_glGetHistogram(GLenum target
, GLboolean reset
, GLenum format
,
6308 GLenum type
, GLvoid
* values
)
6310 __GLXcontext
*const gc
= __glXGetCurrentContext();
6311 const __GLXattribute
*const state
= gc
->client_state_private
;
6312 Display
*const dpy
= gc
->currentDpy
;
6314 const GLuint cmdlen
= 16;
6316 if (__builtin_expect(dpy
!= NULL
, 1)) {
6318 xcb_connection_t
*c
= XGetXCBConnection(dpy
);
6319 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
6320 xcb_glx_get_histogram_reply_t
*reply
=
6321 xcb_glx_get_histogram_reply(c
,
6322 xcb_glx_get_histogram(c
,
6331 (void) memcpy(values
, xcb_glx_get_histogram_data(reply
),
6332 xcb_glx_get_histogram_data_length(reply
) *
6337 __glXSetupSingleRequest(gc
, X_GLsop_GetHistogram
, cmdlen
);
6338 (void) memcpy((void *) (pc
+ 0), (void *) (&target
), 4);
6339 (void) memcpy((void *) (pc
+ 4), (void *) (&format
), 4);
6340 (void) memcpy((void *) (pc
+ 8), (void *) (&type
), 4);
6341 *(int32_t *) (pc
+ 12) = 0;
6342 *(int8_t *) (pc
+ 12) = state
->storePack
.swapEndian
;
6343 *(int8_t *) (pc
+ 13) = reset
;
6344 __glXReadPixelReply(dpy
, gc
, 1, 0, 0, 0, format
, type
, values
,
6348 #endif /* USE_XCB */
6353 #define X_GLvop_GetHistogramEXT 5
6355 gl_dispatch_stub_361(GLenum target
, GLboolean reset
, GLenum format
,
6356 GLenum type
, GLvoid
* values
)
6358 __GLXcontext
*const gc
= __glXGetCurrentContext();
6360 #ifdef GLX_DIRECT_RENDERING
6361 if (gc
->driContext
) {
6362 CALL_GetHistogram(GET_DISPATCH(),
6363 (target
, reset
, format
, type
, values
));
6367 __GLXcontext
*const gc
= __glXGetCurrentContext();
6368 const __GLXattribute
*const state
= gc
->client_state_private
;
6369 Display
*const dpy
= gc
->currentDpy
;
6370 const GLuint cmdlen
= 16;
6371 if (__builtin_expect(dpy
!= NULL
, 1)) {
6373 __glXSetupVendorRequest(gc
, X_GLXVendorPrivateWithReply
,
6374 X_GLvop_GetHistogramEXT
, cmdlen
);
6375 (void) memcpy((void *) (pc
+ 0), (void *) (&target
), 4);
6376 (void) memcpy((void *) (pc
+ 4), (void *) (&format
), 4);
6377 (void) memcpy((void *) (pc
+ 8), (void *) (&type
), 4);
6378 *(int32_t *) (pc
+ 12) = 0;
6379 *(int8_t *) (pc
+ 12) = state
->storePack
.swapEndian
;
6380 *(int8_t *) (pc
+ 13) = reset
;
6381 __glXReadPixelReply(dpy
, gc
, 1, 0, 0, 0, format
, type
, values
,
6390 #define X_GLsop_GetHistogramParameterfv 155
6392 __indirect_glGetHistogramParameterfv(GLenum target
, GLenum pname
,
6395 __GLXcontext
*const gc
= __glXGetCurrentContext();
6396 Display
*const dpy
= gc
->currentDpy
;
6398 const GLuint cmdlen
= 8;
6400 if (__builtin_expect(dpy
!= NULL
, 1)) {
6402 xcb_connection_t
*c
= XGetXCBConnection(dpy
);
6403 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
6404 xcb_glx_get_histogram_parameterfv_reply_t
*reply
=
6405 xcb_glx_get_histogram_parameterfv_reply(c
,
6406 xcb_glx_get_histogram_parameterfv
6407 (c
, gc
->currentContextTag
,
6408 target
, pname
), NULL
);
6409 if (xcb_glx_get_histogram_parameterfv_data_length(reply
) == 0)
6410 (void) memcpy(params
, &reply
->datum
, sizeof(reply
->datum
));
6412 (void) memcpy(params
,
6413 xcb_glx_get_histogram_parameterfv_data(reply
),
6414 xcb_glx_get_histogram_parameterfv_data_length(reply
)
6419 __glXSetupSingleRequest(gc
, X_GLsop_GetHistogramParameterfv
,
6421 (void) memcpy((void *) (pc
+ 0), (void *) (&target
), 4);
6422 (void) memcpy((void *) (pc
+ 4), (void *) (&pname
), 4);
6423 (void) __glXReadReply(dpy
, 4, params
, GL_FALSE
);
6426 #endif /* USE_XCB */
6431 #define X_GLvop_GetHistogramParameterfvEXT 6
6433 gl_dispatch_stub_362(GLenum target
, GLenum pname
, GLfloat
* params
)
6435 __GLXcontext
*const gc
= __glXGetCurrentContext();
6437 #ifdef GLX_DIRECT_RENDERING
6438 if (gc
->driContext
) {
6439 CALL_GetHistogramParameterfv(GET_DISPATCH(), (target
, pname
, params
));
6443 __GLXcontext
*const gc
= __glXGetCurrentContext();
6444 Display
*const dpy
= gc
->currentDpy
;
6445 const GLuint cmdlen
= 8;
6446 if (__builtin_expect(dpy
!= NULL
, 1)) {
6448 __glXSetupVendorRequest(gc
, X_GLXVendorPrivateWithReply
,
6449 X_GLvop_GetHistogramParameterfvEXT
,
6451 (void) memcpy((void *) (pc
+ 0), (void *) (&target
), 4);
6452 (void) memcpy((void *) (pc
+ 4), (void *) (&pname
), 4);
6453 (void) __glXReadReply(dpy
, 4, params
, GL_FALSE
);
6461 #define X_GLsop_GetHistogramParameteriv 156
6463 __indirect_glGetHistogramParameteriv(GLenum target
, GLenum pname
,
6466 __GLXcontext
*const gc
= __glXGetCurrentContext();
6467 Display
*const dpy
= gc
->currentDpy
;
6469 const GLuint cmdlen
= 8;
6471 if (__builtin_expect(dpy
!= NULL
, 1)) {
6473 xcb_connection_t
*c
= XGetXCBConnection(dpy
);
6474 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
6475 xcb_glx_get_histogram_parameteriv_reply_t
*reply
=
6476 xcb_glx_get_histogram_parameteriv_reply(c
,
6477 xcb_glx_get_histogram_parameteriv
6478 (c
, gc
->currentContextTag
,
6479 target
, pname
), NULL
);
6480 if (xcb_glx_get_histogram_parameteriv_data_length(reply
) == 0)
6481 (void) memcpy(params
, &reply
->datum
, sizeof(reply
->datum
));
6483 (void) memcpy(params
,
6484 xcb_glx_get_histogram_parameteriv_data(reply
),
6485 xcb_glx_get_histogram_parameteriv_data_length(reply
)
6490 __glXSetupSingleRequest(gc
, X_GLsop_GetHistogramParameteriv
,
6492 (void) memcpy((void *) (pc
+ 0), (void *) (&target
), 4);
6493 (void) memcpy((void *) (pc
+ 4), (void *) (&pname
), 4);
6494 (void) __glXReadReply(dpy
, 4, params
, GL_FALSE
);
6497 #endif /* USE_XCB */
6502 #define X_GLvop_GetHistogramParameterivEXT 7
6504 gl_dispatch_stub_363(GLenum target
, GLenum pname
, GLint
* params
)
6506 __GLXcontext
*const gc
= __glXGetCurrentContext();
6508 #ifdef GLX_DIRECT_RENDERING
6509 if (gc
->driContext
) {
6510 CALL_GetHistogramParameteriv(GET_DISPATCH(), (target
, pname
, params
));
6514 __GLXcontext
*const gc
= __glXGetCurrentContext();
6515 Display
*const dpy
= gc
->currentDpy
;
6516 const GLuint cmdlen
= 8;
6517 if (__builtin_expect(dpy
!= NULL
, 1)) {
6519 __glXSetupVendorRequest(gc
, X_GLXVendorPrivateWithReply
,
6520 X_GLvop_GetHistogramParameterivEXT
,
6522 (void) memcpy((void *) (pc
+ 0), (void *) (&target
), 4);
6523 (void) memcpy((void *) (pc
+ 4), (void *) (&pname
), 4);
6524 (void) __glXReadReply(dpy
, 4, params
, GL_FALSE
);
6532 #define X_GLsop_GetMinmax 157
6534 __indirect_glGetMinmax(GLenum target
, GLboolean reset
, GLenum format
,
6535 GLenum type
, GLvoid
* values
)
6537 __GLXcontext
*const gc
= __glXGetCurrentContext();
6538 const __GLXattribute
*const state
= gc
->client_state_private
;
6539 Display
*const dpy
= gc
->currentDpy
;
6541 const GLuint cmdlen
= 16;
6543 if (__builtin_expect(dpy
!= NULL
, 1)) {
6545 xcb_connection_t
*c
= XGetXCBConnection(dpy
);
6546 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
6547 xcb_glx_get_minmax_reply_t
*reply
=
6548 xcb_glx_get_minmax_reply(c
,
6549 xcb_glx_get_minmax(c
,
6550 gc
->currentContextTag
,
6551 target
, reset
, format
,
6555 (void) memcpy(values
, xcb_glx_get_minmax_data(reply
),
6556 xcb_glx_get_minmax_data_length(reply
) * sizeof(GLvoid
));
6560 __glXSetupSingleRequest(gc
, X_GLsop_GetMinmax
, cmdlen
);
6561 (void) memcpy((void *) (pc
+ 0), (void *) (&target
), 4);
6562 (void) memcpy((void *) (pc
+ 4), (void *) (&format
), 4);
6563 (void) memcpy((void *) (pc
+ 8), (void *) (&type
), 4);
6564 *(int32_t *) (pc
+ 12) = 0;
6565 *(int8_t *) (pc
+ 12) = state
->storePack
.swapEndian
;
6566 *(int8_t *) (pc
+ 13) = reset
;
6567 __glXReadPixelReply(dpy
, gc
, 1, 2, 1, 1, format
, type
, values
,
6571 #endif /* USE_XCB */
6576 #define X_GLvop_GetMinmaxEXT 8
6578 gl_dispatch_stub_364(GLenum target
, GLboolean reset
, GLenum format
,
6579 GLenum type
, GLvoid
* values
)
6581 __GLXcontext
*const gc
= __glXGetCurrentContext();
6583 #ifdef GLX_DIRECT_RENDERING
6584 if (gc
->driContext
) {
6585 CALL_GetMinmax(GET_DISPATCH(), (target
, reset
, format
, type
, values
));
6589 __GLXcontext
*const gc
= __glXGetCurrentContext();
6590 const __GLXattribute
*const state
= gc
->client_state_private
;
6591 Display
*const dpy
= gc
->currentDpy
;
6592 const GLuint cmdlen
= 16;
6593 if (__builtin_expect(dpy
!= NULL
, 1)) {
6595 __glXSetupVendorRequest(gc
, X_GLXVendorPrivateWithReply
,
6596 X_GLvop_GetMinmaxEXT
, cmdlen
);
6597 (void) memcpy((void *) (pc
+ 0), (void *) (&target
), 4);
6598 (void) memcpy((void *) (pc
+ 4), (void *) (&format
), 4);
6599 (void) memcpy((void *) (pc
+ 8), (void *) (&type
), 4);
6600 *(int32_t *) (pc
+ 12) = 0;
6601 *(int8_t *) (pc
+ 12) = state
->storePack
.swapEndian
;
6602 *(int8_t *) (pc
+ 13) = reset
;
6603 __glXReadPixelReply(dpy
, gc
, 1, 2, 1, 1, format
, type
, values
,
6612 #define X_GLsop_GetMinmaxParameterfv 158
6614 __indirect_glGetMinmaxParameterfv(GLenum target
, GLenum pname
,
6617 __GLXcontext
*const gc
= __glXGetCurrentContext();
6618 Display
*const dpy
= gc
->currentDpy
;
6620 const GLuint cmdlen
= 8;
6622 if (__builtin_expect(dpy
!= NULL
, 1)) {
6624 xcb_connection_t
*c
= XGetXCBConnection(dpy
);
6625 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
6626 xcb_glx_get_minmax_parameterfv_reply_t
*reply
=
6627 xcb_glx_get_minmax_parameterfv_reply(c
,
6628 xcb_glx_get_minmax_parameterfv
6629 (c
, gc
->currentContextTag
,
6630 target
, pname
), NULL
);
6631 if (xcb_glx_get_minmax_parameterfv_data_length(reply
) == 0)
6632 (void) memcpy(params
, &reply
->datum
, sizeof(reply
->datum
));
6634 (void) memcpy(params
, xcb_glx_get_minmax_parameterfv_data(reply
),
6635 xcb_glx_get_minmax_parameterfv_data_length(reply
) *
6640 __glXSetupSingleRequest(gc
, X_GLsop_GetMinmaxParameterfv
, cmdlen
);
6641 (void) memcpy((void *) (pc
+ 0), (void *) (&target
), 4);
6642 (void) memcpy((void *) (pc
+ 4), (void *) (&pname
), 4);
6643 (void) __glXReadReply(dpy
, 4, params
, GL_FALSE
);
6646 #endif /* USE_XCB */
6651 #define X_GLvop_GetMinmaxParameterfvEXT 9
6653 gl_dispatch_stub_365(GLenum target
, GLenum pname
, GLfloat
* params
)
6655 __GLXcontext
*const gc
= __glXGetCurrentContext();
6657 #ifdef GLX_DIRECT_RENDERING
6658 if (gc
->driContext
) {
6659 CALL_GetMinmaxParameterfv(GET_DISPATCH(), (target
, pname
, params
));
6663 __GLXcontext
*const gc
= __glXGetCurrentContext();
6664 Display
*const dpy
= gc
->currentDpy
;
6665 const GLuint cmdlen
= 8;
6666 if (__builtin_expect(dpy
!= NULL
, 1)) {
6668 __glXSetupVendorRequest(gc
, X_GLXVendorPrivateWithReply
,
6669 X_GLvop_GetMinmaxParameterfvEXT
,
6671 (void) memcpy((void *) (pc
+ 0), (void *) (&target
), 4);
6672 (void) memcpy((void *) (pc
+ 4), (void *) (&pname
), 4);
6673 (void) __glXReadReply(dpy
, 4, params
, GL_FALSE
);
6681 #define X_GLsop_GetMinmaxParameteriv 159
6683 __indirect_glGetMinmaxParameteriv(GLenum target
, GLenum pname
, GLint
* params
)
6685 __GLXcontext
*const gc
= __glXGetCurrentContext();
6686 Display
*const dpy
= gc
->currentDpy
;
6688 const GLuint cmdlen
= 8;
6690 if (__builtin_expect(dpy
!= NULL
, 1)) {
6692 xcb_connection_t
*c
= XGetXCBConnection(dpy
);
6693 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
6694 xcb_glx_get_minmax_parameteriv_reply_t
*reply
=
6695 xcb_glx_get_minmax_parameteriv_reply(c
,
6696 xcb_glx_get_minmax_parameteriv
6697 (c
, gc
->currentContextTag
,
6698 target
, pname
), NULL
);
6699 if (xcb_glx_get_minmax_parameteriv_data_length(reply
) == 0)
6700 (void) memcpy(params
, &reply
->datum
, sizeof(reply
->datum
));
6702 (void) memcpy(params
, xcb_glx_get_minmax_parameteriv_data(reply
),
6703 xcb_glx_get_minmax_parameteriv_data_length(reply
) *
6708 __glXSetupSingleRequest(gc
, X_GLsop_GetMinmaxParameteriv
, cmdlen
);
6709 (void) memcpy((void *) (pc
+ 0), (void *) (&target
), 4);
6710 (void) memcpy((void *) (pc
+ 4), (void *) (&pname
), 4);
6711 (void) __glXReadReply(dpy
, 4, params
, GL_FALSE
);
6714 #endif /* USE_XCB */
6719 #define X_GLvop_GetMinmaxParameterivEXT 10
6721 gl_dispatch_stub_366(GLenum target
, GLenum pname
, GLint
* params
)
6723 __GLXcontext
*const gc
= __glXGetCurrentContext();
6725 #ifdef GLX_DIRECT_RENDERING
6726 if (gc
->driContext
) {
6727 CALL_GetMinmaxParameteriv(GET_DISPATCH(), (target
, pname
, params
));
6731 __GLXcontext
*const gc
= __glXGetCurrentContext();
6732 Display
*const dpy
= gc
->currentDpy
;
6733 const GLuint cmdlen
= 8;
6734 if (__builtin_expect(dpy
!= NULL
, 1)) {
6736 __glXSetupVendorRequest(gc
, X_GLXVendorPrivateWithReply
,
6737 X_GLvop_GetMinmaxParameterivEXT
,
6739 (void) memcpy((void *) (pc
+ 0), (void *) (&target
), 4);
6740 (void) memcpy((void *) (pc
+ 4), (void *) (&pname
), 4);
6741 (void) __glXReadReply(dpy
, 4, params
, GL_FALSE
);
6749 #define X_GLrop_Histogram 4110
6751 __indirect_glHistogram(GLenum target
, GLsizei width
, GLenum internalformat
,
6754 __GLXcontext
*const gc
= __glXGetCurrentContext();
6755 const GLuint cmdlen
= 20;
6756 emit_header(gc
->pc
, X_GLrop_Histogram
, cmdlen
);
6757 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&target
), 4);
6758 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&width
), 4);
6759 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&internalformat
), 4);
6760 (void) memcpy((void *) (gc
->pc
+ 16), (void *) (&sink
), 1);
6762 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
6763 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
6767 #define X_GLrop_Minmax 4111
6769 __indirect_glMinmax(GLenum target
, GLenum internalformat
, GLboolean sink
)
6771 __GLXcontext
*const gc
= __glXGetCurrentContext();
6772 const GLuint cmdlen
= 16;
6773 emit_header(gc
->pc
, X_GLrop_Minmax
, cmdlen
);
6774 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&target
), 4);
6775 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&internalformat
), 4);
6776 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&sink
), 1);
6778 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
6779 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
6783 #define X_GLrop_ResetHistogram 4112
6785 __indirect_glResetHistogram(GLenum target
)
6787 __GLXcontext
*const gc
= __glXGetCurrentContext();
6788 const GLuint cmdlen
= 8;
6789 emit_header(gc
->pc
, X_GLrop_ResetHistogram
, cmdlen
);
6790 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&target
), 4);
6792 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
6793 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
6797 #define X_GLrop_ResetMinmax 4113
6799 __indirect_glResetMinmax(GLenum target
)
6801 __GLXcontext
*const gc
= __glXGetCurrentContext();
6802 const GLuint cmdlen
= 8;
6803 emit_header(gc
->pc
, X_GLrop_ResetMinmax
, cmdlen
);
6804 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&target
), 4);
6806 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
6807 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
6812 __glx_TexImage_3D4D(unsigned opcode
, unsigned dim
, GLenum target
, GLint level
,
6813 GLint internalformat
, GLsizei width
, GLsizei height
,
6814 GLsizei depth
, GLsizei extent
, GLint border
,
6815 GLenum format
, GLenum type
, const GLvoid
* pixels
)
6817 __GLXcontext
*const gc
= __glXGetCurrentContext();
6818 const GLuint compsize
=
6819 (pixels
!= NULL
) ? __glImageSize(width
, height
, depth
, format
, type
,
6821 const GLuint cmdlen
= 84 + __GLX_PAD(compsize
);
6822 if (__builtin_expect(gc
->currentDpy
!= NULL
, 1)) {
6823 if (cmdlen
<= gc
->maxSmallRenderCommandSize
) {
6824 if ((gc
->pc
+ cmdlen
) > gc
->bufEnd
) {
6825 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
6827 emit_header(gc
->pc
, opcode
, cmdlen
);
6828 (void) memcpy((void *) (gc
->pc
+ 40), (void *) (&target
), 4);
6829 (void) memcpy((void *) (gc
->pc
+ 44), (void *) (&level
), 4);
6830 (void) memcpy((void *) (gc
->pc
+ 48), (void *) (&internalformat
),
6832 (void) memcpy((void *) (gc
->pc
+ 52), (void *) (&width
), 4);
6833 (void) memcpy((void *) (gc
->pc
+ 56), (void *) (&height
), 4);
6834 (void) memcpy((void *) (gc
->pc
+ 60), (void *) (&depth
), 4);
6835 (void) memcpy((void *) (gc
->pc
+ 64), (void *) (&extent
), 4);
6836 (void) memcpy((void *) (gc
->pc
+ 68), (void *) (&border
), 4);
6837 (void) memcpy((void *) (gc
->pc
+ 72), (void *) (&format
), 4);
6838 (void) memcpy((void *) (gc
->pc
+ 76), (void *) (&type
), 4);
6839 (void) memcpy((void *) (gc
->pc
+ 80),
6840 (void *) ((pixels
== NULL
) ? one
: zero
), 4);
6842 (*gc
->fillImage
) (gc
, dim
, width
, height
, depth
, format
, type
,
6843 pixels
, gc
->pc
+ 84, gc
->pc
+ 4);
6845 (void) memcpy(gc
->pc
+ 4, default_pixel_store_4D
,
6846 default_pixel_store_4D_size
);
6849 if (gc
->pc
> gc
->limit
) {
6850 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
6853 const GLint op
= opcode
;
6854 const GLuint cmdlenLarge
= cmdlen
+ 4;
6855 GLubyte
*const pc
= __glXFlushRenderBuffer(gc
, gc
->pc
);
6856 (void) memcpy((void *) (pc
+ 0), (void *) (&cmdlenLarge
), 4);
6857 (void) memcpy((void *) (pc
+ 4), (void *) (&op
), 4);
6858 (void) memcpy((void *) (pc
+ 44), (void *) (&target
), 4);
6859 (void) memcpy((void *) (pc
+ 48), (void *) (&level
), 4);
6860 (void) memcpy((void *) (pc
+ 52), (void *) (&internalformat
), 4);
6861 (void) memcpy((void *) (pc
+ 56), (void *) (&width
), 4);
6862 (void) memcpy((void *) (pc
+ 60), (void *) (&height
), 4);
6863 (void) memcpy((void *) (pc
+ 64), (void *) (&depth
), 4);
6864 (void) memcpy((void *) (pc
+ 68), (void *) (&extent
), 4);
6865 (void) memcpy((void *) (pc
+ 72), (void *) (&border
), 4);
6866 (void) memcpy((void *) (pc
+ 76), (void *) (&format
), 4);
6867 (void) memcpy((void *) (pc
+ 80), (void *) (&type
), 4);
6868 (void) memcpy((void *) (pc
+ 84), zero
, 4);
6869 __glXSendLargeImage(gc
, compsize
, dim
, width
, height
, depth
,
6870 format
, type
, pixels
, pc
+ 88, pc
+ 8);
6875 #define X_GLrop_TexImage3D 4114
6877 __indirect_glTexImage3D(GLenum target
, GLint level
, GLint internalformat
,
6878 GLsizei width
, GLsizei height
, GLsizei depth
,
6879 GLint border
, GLenum format
, GLenum type
,
6880 const GLvoid
* pixels
)
6882 __glx_TexImage_3D4D(X_GLrop_TexImage3D
, 3, target
, level
, internalformat
,
6883 width
, height
, depth
, 1, border
, format
, type
,
6888 __glx_TexSubImage_3D4D(unsigned opcode
, unsigned dim
, GLenum target
,
6889 GLint level
, GLint xoffset
, GLint yoffset
,
6890 GLint zoffset
, GLint woffset
, GLsizei width
,
6891 GLsizei height
, GLsizei depth
, GLsizei extent
,
6892 GLenum format
, GLenum type
, const GLvoid
* pixels
)
6894 __GLXcontext
*const gc
= __glXGetCurrentContext();
6895 const GLuint compsize
=
6896 (pixels
!= NULL
) ? __glImageSize(width
, height
, depth
, format
, type
,
6898 const GLuint cmdlen
= 92 + __GLX_PAD(compsize
);
6899 if (__builtin_expect(gc
->currentDpy
!= NULL
, 1)) {
6900 if (cmdlen
<= gc
->maxSmallRenderCommandSize
) {
6901 if ((gc
->pc
+ cmdlen
) > gc
->bufEnd
) {
6902 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
6904 emit_header(gc
->pc
, opcode
, cmdlen
);
6905 (void) memcpy((void *) (gc
->pc
+ 40), (void *) (&target
), 4);
6906 (void) memcpy((void *) (gc
->pc
+ 44), (void *) (&level
), 4);
6907 (void) memcpy((void *) (gc
->pc
+ 48), (void *) (&xoffset
), 4);
6908 (void) memcpy((void *) (gc
->pc
+ 52), (void *) (&yoffset
), 4);
6909 (void) memcpy((void *) (gc
->pc
+ 56), (void *) (&zoffset
), 4);
6910 (void) memcpy((void *) (gc
->pc
+ 60), (void *) (&woffset
), 4);
6911 (void) memcpy((void *) (gc
->pc
+ 64), (void *) (&width
), 4);
6912 (void) memcpy((void *) (gc
->pc
+ 68), (void *) (&height
), 4);
6913 (void) memcpy((void *) (gc
->pc
+ 72), (void *) (&depth
), 4);
6914 (void) memcpy((void *) (gc
->pc
+ 76), (void *) (&extent
), 4);
6915 (void) memcpy((void *) (gc
->pc
+ 80), (void *) (&format
), 4);
6916 (void) memcpy((void *) (gc
->pc
+ 84), (void *) (&type
), 4);
6917 (void) memset((void *) (gc
->pc
+ 88), 0, 4);
6919 (*gc
->fillImage
) (gc
, dim
, width
, height
, depth
, format
, type
,
6920 pixels
, gc
->pc
+ 92, gc
->pc
+ 4);
6922 (void) memcpy(gc
->pc
+ 4, default_pixel_store_4D
,
6923 default_pixel_store_4D_size
);
6926 if (gc
->pc
> gc
->limit
) {
6927 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
6930 const GLint op
= opcode
;
6931 const GLuint cmdlenLarge
= cmdlen
+ 4;
6932 GLubyte
*const pc
= __glXFlushRenderBuffer(gc
, gc
->pc
);
6933 (void) memcpy((void *) (pc
+ 0), (void *) (&cmdlenLarge
), 4);
6934 (void) memcpy((void *) (pc
+ 4), (void *) (&op
), 4);
6935 (void) memcpy((void *) (pc
+ 44), (void *) (&target
), 4);
6936 (void) memcpy((void *) (pc
+ 48), (void *) (&level
), 4);
6937 (void) memcpy((void *) (pc
+ 52), (void *) (&xoffset
), 4);
6938 (void) memcpy((void *) (pc
+ 56), (void *) (&yoffset
), 4);
6939 (void) memcpy((void *) (pc
+ 60), (void *) (&zoffset
), 4);
6940 (void) memcpy((void *) (pc
+ 64), (void *) (&woffset
), 4);
6941 (void) memcpy((void *) (pc
+ 68), (void *) (&width
), 4);
6942 (void) memcpy((void *) (pc
+ 72), (void *) (&height
), 4);
6943 (void) memcpy((void *) (pc
+ 76), (void *) (&depth
), 4);
6944 (void) memcpy((void *) (pc
+ 80), (void *) (&extent
), 4);
6945 (void) memcpy((void *) (pc
+ 84), (void *) (&format
), 4);
6946 (void) memcpy((void *) (pc
+ 88), (void *) (&type
), 4);
6947 (void) memset((void *) (pc
+ 92), 0, 4);
6948 __glXSendLargeImage(gc
, compsize
, dim
, width
, height
, depth
,
6949 format
, type
, pixels
, pc
+ 96, pc
+ 8);
6954 #define X_GLrop_TexSubImage3D 4115
6956 __indirect_glTexSubImage3D(GLenum target
, GLint level
, GLint xoffset
,
6957 GLint yoffset
, GLint zoffset
, GLsizei width
,
6958 GLsizei height
, GLsizei depth
, GLenum format
,
6959 GLenum type
, const GLvoid
* pixels
)
6961 __glx_TexSubImage_3D4D(X_GLrop_TexSubImage3D
, 3, target
, level
, xoffset
,
6962 yoffset
, zoffset
, 1, width
, height
, depth
, 1,
6963 format
, type
, pixels
);
6966 #define X_GLrop_CopyTexSubImage3D 4123
6968 __indirect_glCopyTexSubImage3D(GLenum target
, GLint level
, GLint xoffset
,
6969 GLint yoffset
, GLint zoffset
, GLint x
, GLint y
,
6970 GLsizei width
, GLsizei height
)
6972 __GLXcontext
*const gc
= __glXGetCurrentContext();
6973 const GLuint cmdlen
= 40;
6974 emit_header(gc
->pc
, X_GLrop_CopyTexSubImage3D
, cmdlen
);
6975 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&target
), 4);
6976 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&level
), 4);
6977 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&xoffset
), 4);
6978 (void) memcpy((void *) (gc
->pc
+ 16), (void *) (&yoffset
), 4);
6979 (void) memcpy((void *) (gc
->pc
+ 20), (void *) (&zoffset
), 4);
6980 (void) memcpy((void *) (gc
->pc
+ 24), (void *) (&x
), 4);
6981 (void) memcpy((void *) (gc
->pc
+ 28), (void *) (&y
), 4);
6982 (void) memcpy((void *) (gc
->pc
+ 32), (void *) (&width
), 4);
6983 (void) memcpy((void *) (gc
->pc
+ 36), (void *) (&height
), 4);
6985 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
6986 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
6990 #define X_GLrop_ActiveTextureARB 197
6992 __indirect_glActiveTextureARB(GLenum texture
)
6994 __GLXcontext
*const gc
= __glXGetCurrentContext();
6995 const GLuint cmdlen
= 8;
6996 emit_header(gc
->pc
, X_GLrop_ActiveTextureARB
, cmdlen
);
6997 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&texture
), 4);
6999 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
7000 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
7004 #define X_GLrop_MultiTexCoord1dvARB 198
7006 __indirect_glMultiTexCoord1dARB(GLenum target
, GLdouble s
)
7008 __GLXcontext
*const gc
= __glXGetCurrentContext();
7009 const GLuint cmdlen
= 16;
7010 emit_header(gc
->pc
, X_GLrop_MultiTexCoord1dvARB
, cmdlen
);
7011 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&s
), 8);
7012 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&target
), 4);
7014 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
7015 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
7019 #define X_GLrop_MultiTexCoord1dvARB 198
7021 __indirect_glMultiTexCoord1dvARB(GLenum target
, const GLdouble
* v
)
7023 __GLXcontext
*const gc
= __glXGetCurrentContext();
7024 const GLuint cmdlen
= 16;
7025 emit_header(gc
->pc
, X_GLrop_MultiTexCoord1dvARB
, cmdlen
);
7026 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (v
), 8);
7027 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&target
), 4);
7029 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
7030 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
7034 #define X_GLrop_MultiTexCoord1fvARB 199
7036 __indirect_glMultiTexCoord1fARB(GLenum target
, GLfloat s
)
7038 __GLXcontext
*const gc
= __glXGetCurrentContext();
7039 const GLuint cmdlen
= 12;
7040 emit_header(gc
->pc
, X_GLrop_MultiTexCoord1fvARB
, cmdlen
);
7041 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&target
), 4);
7042 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&s
), 4);
7044 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
7045 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
7049 #define X_GLrop_MultiTexCoord1fvARB 199
7051 __indirect_glMultiTexCoord1fvARB(GLenum target
, const GLfloat
* v
)
7053 __GLXcontext
*const gc
= __glXGetCurrentContext();
7054 const GLuint cmdlen
= 12;
7055 emit_header(gc
->pc
, X_GLrop_MultiTexCoord1fvARB
, cmdlen
);
7056 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&target
), 4);
7057 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (v
), 4);
7059 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
7060 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
7064 #define X_GLrop_MultiTexCoord1ivARB 200
7066 __indirect_glMultiTexCoord1iARB(GLenum target
, GLint s
)
7068 __GLXcontext
*const gc
= __glXGetCurrentContext();
7069 const GLuint cmdlen
= 12;
7070 emit_header(gc
->pc
, X_GLrop_MultiTexCoord1ivARB
, cmdlen
);
7071 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&target
), 4);
7072 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&s
), 4);
7074 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
7075 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
7079 #define X_GLrop_MultiTexCoord1ivARB 200
7081 __indirect_glMultiTexCoord1ivARB(GLenum target
, const GLint
* v
)
7083 __GLXcontext
*const gc
= __glXGetCurrentContext();
7084 const GLuint cmdlen
= 12;
7085 emit_header(gc
->pc
, X_GLrop_MultiTexCoord1ivARB
, cmdlen
);
7086 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&target
), 4);
7087 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (v
), 4);
7089 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
7090 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
7094 #define X_GLrop_MultiTexCoord1svARB 201
7096 __indirect_glMultiTexCoord1sARB(GLenum target
, GLshort s
)
7098 __GLXcontext
*const gc
= __glXGetCurrentContext();
7099 const GLuint cmdlen
= 12;
7100 emit_header(gc
->pc
, X_GLrop_MultiTexCoord1svARB
, cmdlen
);
7101 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&target
), 4);
7102 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&s
), 2);
7104 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
7105 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
7109 #define X_GLrop_MultiTexCoord1svARB 201
7111 __indirect_glMultiTexCoord1svARB(GLenum target
, const GLshort
* v
)
7113 __GLXcontext
*const gc
= __glXGetCurrentContext();
7114 const GLuint cmdlen
= 12;
7115 emit_header(gc
->pc
, X_GLrop_MultiTexCoord1svARB
, cmdlen
);
7116 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&target
), 4);
7117 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (v
), 2);
7119 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
7120 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
7124 #define X_GLrop_MultiTexCoord2dvARB 202
7126 __indirect_glMultiTexCoord2dARB(GLenum target
, GLdouble s
, GLdouble t
)
7128 __GLXcontext
*const gc
= __glXGetCurrentContext();
7129 const GLuint cmdlen
= 24;
7130 emit_header(gc
->pc
, X_GLrop_MultiTexCoord2dvARB
, cmdlen
);
7131 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&s
), 8);
7132 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&t
), 8);
7133 (void) memcpy((void *) (gc
->pc
+ 20), (void *) (&target
), 4);
7135 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
7136 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
7140 #define X_GLrop_MultiTexCoord2dvARB 202
7142 __indirect_glMultiTexCoord2dvARB(GLenum target
, const GLdouble
* v
)
7144 __GLXcontext
*const gc
= __glXGetCurrentContext();
7145 const GLuint cmdlen
= 24;
7146 emit_header(gc
->pc
, X_GLrop_MultiTexCoord2dvARB
, cmdlen
);
7147 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (v
), 16);
7148 (void) memcpy((void *) (gc
->pc
+ 20), (void *) (&target
), 4);
7150 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
7151 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
7155 #define X_GLrop_MultiTexCoord2fvARB 203
7157 __indirect_glMultiTexCoord2fARB(GLenum target
, GLfloat s
, GLfloat t
)
7159 __GLXcontext
*const gc
= __glXGetCurrentContext();
7160 const GLuint cmdlen
= 16;
7161 emit_header(gc
->pc
, X_GLrop_MultiTexCoord2fvARB
, cmdlen
);
7162 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&target
), 4);
7163 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&s
), 4);
7164 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&t
), 4);
7166 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
7167 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
7171 #define X_GLrop_MultiTexCoord2fvARB 203
7173 __indirect_glMultiTexCoord2fvARB(GLenum target
, const GLfloat
* v
)
7175 __GLXcontext
*const gc
= __glXGetCurrentContext();
7176 const GLuint cmdlen
= 16;
7177 emit_header(gc
->pc
, X_GLrop_MultiTexCoord2fvARB
, cmdlen
);
7178 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&target
), 4);
7179 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (v
), 8);
7181 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
7182 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
7186 #define X_GLrop_MultiTexCoord2ivARB 204
7188 __indirect_glMultiTexCoord2iARB(GLenum target
, GLint s
, GLint t
)
7190 __GLXcontext
*const gc
= __glXGetCurrentContext();
7191 const GLuint cmdlen
= 16;
7192 emit_header(gc
->pc
, X_GLrop_MultiTexCoord2ivARB
, cmdlen
);
7193 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&target
), 4);
7194 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&s
), 4);
7195 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&t
), 4);
7197 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
7198 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
7202 #define X_GLrop_MultiTexCoord2ivARB 204
7204 __indirect_glMultiTexCoord2ivARB(GLenum target
, const GLint
* v
)
7206 __GLXcontext
*const gc
= __glXGetCurrentContext();
7207 const GLuint cmdlen
= 16;
7208 emit_header(gc
->pc
, X_GLrop_MultiTexCoord2ivARB
, cmdlen
);
7209 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&target
), 4);
7210 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (v
), 8);
7212 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
7213 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
7217 #define X_GLrop_MultiTexCoord2svARB 205
7219 __indirect_glMultiTexCoord2sARB(GLenum target
, GLshort s
, GLshort t
)
7221 __GLXcontext
*const gc
= __glXGetCurrentContext();
7222 const GLuint cmdlen
= 12;
7223 emit_header(gc
->pc
, X_GLrop_MultiTexCoord2svARB
, cmdlen
);
7224 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&target
), 4);
7225 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&s
), 2);
7226 (void) memcpy((void *) (gc
->pc
+ 10), (void *) (&t
), 2);
7228 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
7229 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
7233 #define X_GLrop_MultiTexCoord2svARB 205
7235 __indirect_glMultiTexCoord2svARB(GLenum target
, const GLshort
* v
)
7237 __GLXcontext
*const gc
= __glXGetCurrentContext();
7238 const GLuint cmdlen
= 12;
7239 emit_header(gc
->pc
, X_GLrop_MultiTexCoord2svARB
, cmdlen
);
7240 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&target
), 4);
7241 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (v
), 4);
7243 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
7244 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
7248 #define X_GLrop_MultiTexCoord3dvARB 206
7250 __indirect_glMultiTexCoord3dARB(GLenum target
, GLdouble s
, GLdouble t
,
7253 __GLXcontext
*const gc
= __glXGetCurrentContext();
7254 const GLuint cmdlen
= 32;
7255 emit_header(gc
->pc
, X_GLrop_MultiTexCoord3dvARB
, cmdlen
);
7256 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&s
), 8);
7257 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&t
), 8);
7258 (void) memcpy((void *) (gc
->pc
+ 20), (void *) (&r
), 8);
7259 (void) memcpy((void *) (gc
->pc
+ 28), (void *) (&target
), 4);
7261 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
7262 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
7266 #define X_GLrop_MultiTexCoord3dvARB 206
7268 __indirect_glMultiTexCoord3dvARB(GLenum target
, const GLdouble
* v
)
7270 __GLXcontext
*const gc
= __glXGetCurrentContext();
7271 const GLuint cmdlen
= 32;
7272 emit_header(gc
->pc
, X_GLrop_MultiTexCoord3dvARB
, cmdlen
);
7273 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (v
), 24);
7274 (void) memcpy((void *) (gc
->pc
+ 28), (void *) (&target
), 4);
7276 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
7277 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
7281 #define X_GLrop_MultiTexCoord3fvARB 207
7283 __indirect_glMultiTexCoord3fARB(GLenum target
, GLfloat s
, GLfloat t
,
7286 __GLXcontext
*const gc
= __glXGetCurrentContext();
7287 const GLuint cmdlen
= 20;
7288 emit_header(gc
->pc
, X_GLrop_MultiTexCoord3fvARB
, cmdlen
);
7289 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&target
), 4);
7290 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&s
), 4);
7291 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&t
), 4);
7292 (void) memcpy((void *) (gc
->pc
+ 16), (void *) (&r
), 4);
7294 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
7295 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
7299 #define X_GLrop_MultiTexCoord3fvARB 207
7301 __indirect_glMultiTexCoord3fvARB(GLenum target
, const GLfloat
* v
)
7303 __GLXcontext
*const gc
= __glXGetCurrentContext();
7304 const GLuint cmdlen
= 20;
7305 emit_header(gc
->pc
, X_GLrop_MultiTexCoord3fvARB
, cmdlen
);
7306 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&target
), 4);
7307 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (v
), 12);
7309 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
7310 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
7314 #define X_GLrop_MultiTexCoord3ivARB 208
7316 __indirect_glMultiTexCoord3iARB(GLenum target
, GLint s
, GLint t
, GLint r
)
7318 __GLXcontext
*const gc
= __glXGetCurrentContext();
7319 const GLuint cmdlen
= 20;
7320 emit_header(gc
->pc
, X_GLrop_MultiTexCoord3ivARB
, cmdlen
);
7321 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&target
), 4);
7322 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&s
), 4);
7323 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&t
), 4);
7324 (void) memcpy((void *) (gc
->pc
+ 16), (void *) (&r
), 4);
7326 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
7327 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
7331 #define X_GLrop_MultiTexCoord3ivARB 208
7333 __indirect_glMultiTexCoord3ivARB(GLenum target
, const GLint
* v
)
7335 __GLXcontext
*const gc
= __glXGetCurrentContext();
7336 const GLuint cmdlen
= 20;
7337 emit_header(gc
->pc
, X_GLrop_MultiTexCoord3ivARB
, cmdlen
);
7338 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&target
), 4);
7339 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (v
), 12);
7341 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
7342 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
7346 #define X_GLrop_MultiTexCoord3svARB 209
7348 __indirect_glMultiTexCoord3sARB(GLenum target
, GLshort s
, GLshort t
,
7351 __GLXcontext
*const gc
= __glXGetCurrentContext();
7352 const GLuint cmdlen
= 16;
7353 emit_header(gc
->pc
, X_GLrop_MultiTexCoord3svARB
, cmdlen
);
7354 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&target
), 4);
7355 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&s
), 2);
7356 (void) memcpy((void *) (gc
->pc
+ 10), (void *) (&t
), 2);
7357 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&r
), 2);
7359 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
7360 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
7364 #define X_GLrop_MultiTexCoord3svARB 209
7366 __indirect_glMultiTexCoord3svARB(GLenum target
, const GLshort
* v
)
7368 __GLXcontext
*const gc
= __glXGetCurrentContext();
7369 const GLuint cmdlen
= 16;
7370 emit_header(gc
->pc
, X_GLrop_MultiTexCoord3svARB
, cmdlen
);
7371 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&target
), 4);
7372 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (v
), 6);
7374 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
7375 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
7379 #define X_GLrop_MultiTexCoord4dvARB 210
7381 __indirect_glMultiTexCoord4dARB(GLenum target
, GLdouble s
, GLdouble t
,
7382 GLdouble r
, GLdouble q
)
7384 __GLXcontext
*const gc
= __glXGetCurrentContext();
7385 const GLuint cmdlen
= 40;
7386 emit_header(gc
->pc
, X_GLrop_MultiTexCoord4dvARB
, cmdlen
);
7387 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&s
), 8);
7388 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&t
), 8);
7389 (void) memcpy((void *) (gc
->pc
+ 20), (void *) (&r
), 8);
7390 (void) memcpy((void *) (gc
->pc
+ 28), (void *) (&q
), 8);
7391 (void) memcpy((void *) (gc
->pc
+ 36), (void *) (&target
), 4);
7393 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
7394 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
7398 #define X_GLrop_MultiTexCoord4dvARB 210
7400 __indirect_glMultiTexCoord4dvARB(GLenum target
, const GLdouble
* v
)
7402 __GLXcontext
*const gc
= __glXGetCurrentContext();
7403 const GLuint cmdlen
= 40;
7404 emit_header(gc
->pc
, X_GLrop_MultiTexCoord4dvARB
, cmdlen
);
7405 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (v
), 32);
7406 (void) memcpy((void *) (gc
->pc
+ 36), (void *) (&target
), 4);
7408 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
7409 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
7413 #define X_GLrop_MultiTexCoord4fvARB 211
7415 __indirect_glMultiTexCoord4fARB(GLenum target
, GLfloat s
, GLfloat t
,
7416 GLfloat r
, GLfloat q
)
7418 __GLXcontext
*const gc
= __glXGetCurrentContext();
7419 const GLuint cmdlen
= 24;
7420 emit_header(gc
->pc
, X_GLrop_MultiTexCoord4fvARB
, cmdlen
);
7421 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&target
), 4);
7422 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&s
), 4);
7423 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&t
), 4);
7424 (void) memcpy((void *) (gc
->pc
+ 16), (void *) (&r
), 4);
7425 (void) memcpy((void *) (gc
->pc
+ 20), (void *) (&q
), 4);
7427 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
7428 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
7432 #define X_GLrop_MultiTexCoord4fvARB 211
7434 __indirect_glMultiTexCoord4fvARB(GLenum target
, const GLfloat
* v
)
7436 __GLXcontext
*const gc
= __glXGetCurrentContext();
7437 const GLuint cmdlen
= 24;
7438 emit_header(gc
->pc
, X_GLrop_MultiTexCoord4fvARB
, cmdlen
);
7439 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&target
), 4);
7440 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (v
), 16);
7442 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
7443 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
7447 #define X_GLrop_MultiTexCoord4ivARB 212
7449 __indirect_glMultiTexCoord4iARB(GLenum target
, GLint s
, GLint t
, GLint r
,
7452 __GLXcontext
*const gc
= __glXGetCurrentContext();
7453 const GLuint cmdlen
= 24;
7454 emit_header(gc
->pc
, X_GLrop_MultiTexCoord4ivARB
, cmdlen
);
7455 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&target
), 4);
7456 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&s
), 4);
7457 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&t
), 4);
7458 (void) memcpy((void *) (gc
->pc
+ 16), (void *) (&r
), 4);
7459 (void) memcpy((void *) (gc
->pc
+ 20), (void *) (&q
), 4);
7461 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
7462 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
7466 #define X_GLrop_MultiTexCoord4ivARB 212
7468 __indirect_glMultiTexCoord4ivARB(GLenum target
, const GLint
* v
)
7470 __GLXcontext
*const gc
= __glXGetCurrentContext();
7471 const GLuint cmdlen
= 24;
7472 emit_header(gc
->pc
, X_GLrop_MultiTexCoord4ivARB
, cmdlen
);
7473 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&target
), 4);
7474 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (v
), 16);
7476 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
7477 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
7481 #define X_GLrop_MultiTexCoord4svARB 213
7483 __indirect_glMultiTexCoord4sARB(GLenum target
, GLshort s
, GLshort t
,
7484 GLshort r
, GLshort q
)
7486 __GLXcontext
*const gc
= __glXGetCurrentContext();
7487 const GLuint cmdlen
= 16;
7488 emit_header(gc
->pc
, X_GLrop_MultiTexCoord4svARB
, cmdlen
);
7489 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&target
), 4);
7490 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&s
), 2);
7491 (void) memcpy((void *) (gc
->pc
+ 10), (void *) (&t
), 2);
7492 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&r
), 2);
7493 (void) memcpy((void *) (gc
->pc
+ 14), (void *) (&q
), 2);
7495 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
7496 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
7500 #define X_GLrop_MultiTexCoord4svARB 213
7502 __indirect_glMultiTexCoord4svARB(GLenum target
, const GLshort
* v
)
7504 __GLXcontext
*const gc
= __glXGetCurrentContext();
7505 const GLuint cmdlen
= 16;
7506 emit_header(gc
->pc
, X_GLrop_MultiTexCoord4svARB
, cmdlen
);
7507 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&target
), 4);
7508 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (v
), 8);
7510 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
7511 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
7515 #define X_GLrop_SampleCoverageARB 229
7517 __indirect_glSampleCoverageARB(GLclampf value
, GLboolean invert
)
7519 __GLXcontext
*const gc
= __glXGetCurrentContext();
7520 const GLuint cmdlen
= 12;
7521 emit_header(gc
->pc
, X_GLrop_SampleCoverageARB
, cmdlen
);
7522 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&value
), 4);
7523 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&invert
), 1);
7525 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
7526 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
7530 #define X_GLvop_GetProgramStringARB 1308
7532 __indirect_glGetProgramStringARB(GLenum target
, GLenum pname
, GLvoid
* string
)
7534 __GLXcontext
*const gc
= __glXGetCurrentContext();
7535 Display
*const dpy
= gc
->currentDpy
;
7536 const GLuint cmdlen
= 8;
7537 if (__builtin_expect(dpy
!= NULL
, 1)) {
7539 __glXSetupVendorRequest(gc
, X_GLXVendorPrivateWithReply
,
7540 X_GLvop_GetProgramStringARB
, cmdlen
);
7541 (void) memcpy((void *) (pc
+ 0), (void *) (&target
), 4);
7542 (void) memcpy((void *) (pc
+ 4), (void *) (&pname
), 4);
7543 (void) __glXReadReply(dpy
, 1, string
, GL_TRUE
);
7550 #define X_GLvop_GetProgramivARB 1307
7552 __indirect_glGetProgramivARB(GLenum target
, GLenum pname
, GLint
* params
)
7554 __GLXcontext
*const gc
= __glXGetCurrentContext();
7555 Display
*const dpy
= gc
->currentDpy
;
7556 const GLuint cmdlen
= 8;
7557 if (__builtin_expect(dpy
!= NULL
, 1)) {
7559 __glXSetupVendorRequest(gc
, X_GLXVendorPrivateWithReply
,
7560 X_GLvop_GetProgramivARB
, cmdlen
);
7561 (void) memcpy((void *) (pc
+ 0), (void *) (&target
), 4);
7562 (void) memcpy((void *) (pc
+ 4), (void *) (&pname
), 4);
7563 (void) __glXReadReply(dpy
, 4, params
, GL_FALSE
);
7570 #define X_GLrop_ProgramEnvParameter4dvARB 4185
7572 __indirect_glProgramEnvParameter4dARB(GLenum target
, GLuint index
, GLdouble x
,
7573 GLdouble y
, GLdouble z
, GLdouble w
)
7575 __GLXcontext
*const gc
= __glXGetCurrentContext();
7576 const GLuint cmdlen
= 44;
7577 emit_header(gc
->pc
, X_GLrop_ProgramEnvParameter4dvARB
, cmdlen
);
7578 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&target
), 4);
7579 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&index
), 4);
7580 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&x
), 8);
7581 (void) memcpy((void *) (gc
->pc
+ 20), (void *) (&y
), 8);
7582 (void) memcpy((void *) (gc
->pc
+ 28), (void *) (&z
), 8);
7583 (void) memcpy((void *) (gc
->pc
+ 36), (void *) (&w
), 8);
7585 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
7586 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
7590 #define X_GLrop_ProgramEnvParameter4dvARB 4185
7592 __indirect_glProgramEnvParameter4dvARB(GLenum target
, GLuint index
,
7593 const GLdouble
* params
)
7595 __GLXcontext
*const gc
= __glXGetCurrentContext();
7596 const GLuint cmdlen
= 44;
7597 emit_header(gc
->pc
, X_GLrop_ProgramEnvParameter4dvARB
, cmdlen
);
7598 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&target
), 4);
7599 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&index
), 4);
7600 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (params
), 32);
7602 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
7603 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
7607 #define X_GLrop_ProgramEnvParameter4fvARB 4184
7609 __indirect_glProgramEnvParameter4fARB(GLenum target
, GLuint index
, GLfloat x
,
7610 GLfloat y
, GLfloat z
, GLfloat w
)
7612 __GLXcontext
*const gc
= __glXGetCurrentContext();
7613 const GLuint cmdlen
= 28;
7614 emit_header(gc
->pc
, X_GLrop_ProgramEnvParameter4fvARB
, cmdlen
);
7615 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&target
), 4);
7616 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&index
), 4);
7617 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&x
), 4);
7618 (void) memcpy((void *) (gc
->pc
+ 16), (void *) (&y
), 4);
7619 (void) memcpy((void *) (gc
->pc
+ 20), (void *) (&z
), 4);
7620 (void) memcpy((void *) (gc
->pc
+ 24), (void *) (&w
), 4);
7622 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
7623 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
7627 #define X_GLrop_ProgramEnvParameter4fvARB 4184
7629 __indirect_glProgramEnvParameter4fvARB(GLenum target
, GLuint index
,
7630 const GLfloat
* params
)
7632 __GLXcontext
*const gc
= __glXGetCurrentContext();
7633 const GLuint cmdlen
= 28;
7634 emit_header(gc
->pc
, X_GLrop_ProgramEnvParameter4fvARB
, cmdlen
);
7635 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&target
), 4);
7636 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&index
), 4);
7637 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (params
), 16);
7639 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
7640 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
7644 #define X_GLrop_ProgramLocalParameter4dvARB 4216
7646 __indirect_glProgramLocalParameter4dARB(GLenum target
, GLuint index
,
7647 GLdouble x
, GLdouble y
, GLdouble z
,
7650 __GLXcontext
*const gc
= __glXGetCurrentContext();
7651 const GLuint cmdlen
= 44;
7652 emit_header(gc
->pc
, X_GLrop_ProgramLocalParameter4dvARB
, cmdlen
);
7653 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&target
), 4);
7654 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&index
), 4);
7655 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&x
), 8);
7656 (void) memcpy((void *) (gc
->pc
+ 20), (void *) (&y
), 8);
7657 (void) memcpy((void *) (gc
->pc
+ 28), (void *) (&z
), 8);
7658 (void) memcpy((void *) (gc
->pc
+ 36), (void *) (&w
), 8);
7660 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
7661 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
7665 #define X_GLrop_ProgramLocalParameter4dvARB 4216
7667 __indirect_glProgramLocalParameter4dvARB(GLenum target
, GLuint index
,
7668 const GLdouble
* params
)
7670 __GLXcontext
*const gc
= __glXGetCurrentContext();
7671 const GLuint cmdlen
= 44;
7672 emit_header(gc
->pc
, X_GLrop_ProgramLocalParameter4dvARB
, cmdlen
);
7673 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&target
), 4);
7674 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&index
), 4);
7675 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (params
), 32);
7677 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
7678 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
7682 #define X_GLrop_ProgramLocalParameter4fvARB 4215
7684 __indirect_glProgramLocalParameter4fARB(GLenum target
, GLuint index
,
7685 GLfloat x
, GLfloat y
, GLfloat z
,
7688 __GLXcontext
*const gc
= __glXGetCurrentContext();
7689 const GLuint cmdlen
= 28;
7690 emit_header(gc
->pc
, X_GLrop_ProgramLocalParameter4fvARB
, cmdlen
);
7691 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&target
), 4);
7692 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&index
), 4);
7693 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&x
), 4);
7694 (void) memcpy((void *) (gc
->pc
+ 16), (void *) (&y
), 4);
7695 (void) memcpy((void *) (gc
->pc
+ 20), (void *) (&z
), 4);
7696 (void) memcpy((void *) (gc
->pc
+ 24), (void *) (&w
), 4);
7698 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
7699 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
7703 #define X_GLrop_ProgramLocalParameter4fvARB 4215
7705 __indirect_glProgramLocalParameter4fvARB(GLenum target
, GLuint index
,
7706 const GLfloat
* params
)
7708 __GLXcontext
*const gc
= __glXGetCurrentContext();
7709 const GLuint cmdlen
= 28;
7710 emit_header(gc
->pc
, X_GLrop_ProgramLocalParameter4fvARB
, cmdlen
);
7711 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&target
), 4);
7712 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&index
), 4);
7713 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (params
), 16);
7715 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
7716 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
7720 #define X_GLrop_ProgramStringARB 4217
7722 __indirect_glProgramStringARB(GLenum target
, GLenum format
, GLsizei len
,
7723 const GLvoid
* string
)
7725 __GLXcontext
*const gc
= __glXGetCurrentContext();
7726 const GLuint cmdlen
= 16 + __GLX_PAD(len
);
7728 __glXSetError(gc
, GL_INVALID_VALUE
);
7731 if (__builtin_expect((len
>= 0) && (gc
->currentDpy
!= NULL
), 1)) {
7732 if (cmdlen
<= gc
->maxSmallRenderCommandSize
) {
7733 if ((gc
->pc
+ cmdlen
) > gc
->bufEnd
) {
7734 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
7736 emit_header(gc
->pc
, X_GLrop_ProgramStringARB
, cmdlen
);
7737 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&target
), 4);
7738 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&format
), 4);
7739 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&len
), 4);
7740 (void) memcpy((void *) (gc
->pc
+ 16), (void *) (string
), len
);
7742 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
7743 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
7746 const GLint op
= X_GLrop_ProgramStringARB
;
7747 const GLuint cmdlenLarge
= cmdlen
+ 4;
7748 GLubyte
*const pc
= __glXFlushRenderBuffer(gc
, gc
->pc
);
7749 (void) memcpy((void *) (pc
+ 0), (void *) (&cmdlenLarge
), 4);
7750 (void) memcpy((void *) (pc
+ 4), (void *) (&op
), 4);
7751 (void) memcpy((void *) (pc
+ 8), (void *) (&target
), 4);
7752 (void) memcpy((void *) (pc
+ 12), (void *) (&format
), 4);
7753 (void) memcpy((void *) (pc
+ 16), (void *) (&len
), 4);
7754 __glXSendLargeCommand(gc
, pc
, 20, string
, len
);
7759 #define X_GLrop_VertexAttrib1dvARB 4197
7761 __indirect_glVertexAttrib1dARB(GLuint index
, GLdouble x
)
7763 __GLXcontext
*const gc
= __glXGetCurrentContext();
7764 const GLuint cmdlen
= 16;
7765 emit_header(gc
->pc
, X_GLrop_VertexAttrib1dvARB
, cmdlen
);
7766 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&index
), 4);
7767 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&x
), 8);
7769 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
7770 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
7774 #define X_GLrop_VertexAttrib1dvARB 4197
7776 __indirect_glVertexAttrib1dvARB(GLuint index
, const GLdouble
* v
)
7778 __GLXcontext
*const gc
= __glXGetCurrentContext();
7779 const GLuint cmdlen
= 16;
7780 emit_header(gc
->pc
, X_GLrop_VertexAttrib1dvARB
, cmdlen
);
7781 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&index
), 4);
7782 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (v
), 8);
7784 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
7785 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
7789 #define X_GLrop_VertexAttrib1fvARB 4193
7791 __indirect_glVertexAttrib1fARB(GLuint index
, GLfloat x
)
7793 __GLXcontext
*const gc
= __glXGetCurrentContext();
7794 const GLuint cmdlen
= 12;
7795 emit_header(gc
->pc
, X_GLrop_VertexAttrib1fvARB
, cmdlen
);
7796 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&index
), 4);
7797 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&x
), 4);
7799 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
7800 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
7804 #define X_GLrop_VertexAttrib1fvARB 4193
7806 __indirect_glVertexAttrib1fvARB(GLuint index
, const GLfloat
* v
)
7808 __GLXcontext
*const gc
= __glXGetCurrentContext();
7809 const GLuint cmdlen
= 12;
7810 emit_header(gc
->pc
, X_GLrop_VertexAttrib1fvARB
, cmdlen
);
7811 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&index
), 4);
7812 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (v
), 4);
7814 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
7815 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
7819 #define X_GLrop_VertexAttrib1svARB 4189
7821 __indirect_glVertexAttrib1sARB(GLuint index
, GLshort x
)
7823 __GLXcontext
*const gc
= __glXGetCurrentContext();
7824 const GLuint cmdlen
= 12;
7825 emit_header(gc
->pc
, X_GLrop_VertexAttrib1svARB
, cmdlen
);
7826 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&index
), 4);
7827 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&x
), 2);
7829 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
7830 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
7834 #define X_GLrop_VertexAttrib1svARB 4189
7836 __indirect_glVertexAttrib1svARB(GLuint index
, const GLshort
* v
)
7838 __GLXcontext
*const gc
= __glXGetCurrentContext();
7839 const GLuint cmdlen
= 12;
7840 emit_header(gc
->pc
, X_GLrop_VertexAttrib1svARB
, cmdlen
);
7841 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&index
), 4);
7842 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (v
), 2);
7844 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
7845 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
7849 #define X_GLrop_VertexAttrib2dvARB 4198
7851 __indirect_glVertexAttrib2dARB(GLuint index
, GLdouble x
, GLdouble y
)
7853 __GLXcontext
*const gc
= __glXGetCurrentContext();
7854 const GLuint cmdlen
= 24;
7855 emit_header(gc
->pc
, X_GLrop_VertexAttrib2dvARB
, cmdlen
);
7856 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&index
), 4);
7857 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&x
), 8);
7858 (void) memcpy((void *) (gc
->pc
+ 16), (void *) (&y
), 8);
7860 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
7861 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
7865 #define X_GLrop_VertexAttrib2dvARB 4198
7867 __indirect_glVertexAttrib2dvARB(GLuint index
, const GLdouble
* v
)
7869 __GLXcontext
*const gc
= __glXGetCurrentContext();
7870 const GLuint cmdlen
= 24;
7871 emit_header(gc
->pc
, X_GLrop_VertexAttrib2dvARB
, cmdlen
);
7872 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&index
), 4);
7873 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (v
), 16);
7875 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
7876 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
7880 #define X_GLrop_VertexAttrib2fvARB 4194
7882 __indirect_glVertexAttrib2fARB(GLuint index
, GLfloat x
, GLfloat y
)
7884 __GLXcontext
*const gc
= __glXGetCurrentContext();
7885 const GLuint cmdlen
= 16;
7886 emit_header(gc
->pc
, X_GLrop_VertexAttrib2fvARB
, cmdlen
);
7887 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&index
), 4);
7888 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&x
), 4);
7889 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&y
), 4);
7891 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
7892 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
7896 #define X_GLrop_VertexAttrib2fvARB 4194
7898 __indirect_glVertexAttrib2fvARB(GLuint index
, const GLfloat
* v
)
7900 __GLXcontext
*const gc
= __glXGetCurrentContext();
7901 const GLuint cmdlen
= 16;
7902 emit_header(gc
->pc
, X_GLrop_VertexAttrib2fvARB
, cmdlen
);
7903 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&index
), 4);
7904 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (v
), 8);
7906 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
7907 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
7911 #define X_GLrop_VertexAttrib2svARB 4190
7913 __indirect_glVertexAttrib2sARB(GLuint index
, GLshort x
, GLshort y
)
7915 __GLXcontext
*const gc
= __glXGetCurrentContext();
7916 const GLuint cmdlen
= 12;
7917 emit_header(gc
->pc
, X_GLrop_VertexAttrib2svARB
, cmdlen
);
7918 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&index
), 4);
7919 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&x
), 2);
7920 (void) memcpy((void *) (gc
->pc
+ 10), (void *) (&y
), 2);
7922 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
7923 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
7927 #define X_GLrop_VertexAttrib2svARB 4190
7929 __indirect_glVertexAttrib2svARB(GLuint index
, const GLshort
* v
)
7931 __GLXcontext
*const gc
= __glXGetCurrentContext();
7932 const GLuint cmdlen
= 12;
7933 emit_header(gc
->pc
, X_GLrop_VertexAttrib2svARB
, cmdlen
);
7934 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&index
), 4);
7935 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (v
), 4);
7937 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
7938 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
7942 #define X_GLrop_VertexAttrib3dvARB 4199
7944 __indirect_glVertexAttrib3dARB(GLuint index
, GLdouble x
, GLdouble y
,
7947 __GLXcontext
*const gc
= __glXGetCurrentContext();
7948 const GLuint cmdlen
= 32;
7949 emit_header(gc
->pc
, X_GLrop_VertexAttrib3dvARB
, cmdlen
);
7950 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&index
), 4);
7951 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&x
), 8);
7952 (void) memcpy((void *) (gc
->pc
+ 16), (void *) (&y
), 8);
7953 (void) memcpy((void *) (gc
->pc
+ 24), (void *) (&z
), 8);
7955 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
7956 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
7960 #define X_GLrop_VertexAttrib3dvARB 4199
7962 __indirect_glVertexAttrib3dvARB(GLuint index
, const GLdouble
* v
)
7964 __GLXcontext
*const gc
= __glXGetCurrentContext();
7965 const GLuint cmdlen
= 32;
7966 emit_header(gc
->pc
, X_GLrop_VertexAttrib3dvARB
, cmdlen
);
7967 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&index
), 4);
7968 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (v
), 24);
7970 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
7971 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
7975 #define X_GLrop_VertexAttrib3fvARB 4195
7977 __indirect_glVertexAttrib3fARB(GLuint index
, GLfloat x
, GLfloat y
, GLfloat z
)
7979 __GLXcontext
*const gc
= __glXGetCurrentContext();
7980 const GLuint cmdlen
= 20;
7981 emit_header(gc
->pc
, X_GLrop_VertexAttrib3fvARB
, cmdlen
);
7982 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&index
), 4);
7983 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&x
), 4);
7984 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&y
), 4);
7985 (void) memcpy((void *) (gc
->pc
+ 16), (void *) (&z
), 4);
7987 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
7988 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
7992 #define X_GLrop_VertexAttrib3fvARB 4195
7994 __indirect_glVertexAttrib3fvARB(GLuint index
, const GLfloat
* v
)
7996 __GLXcontext
*const gc
= __glXGetCurrentContext();
7997 const GLuint cmdlen
= 20;
7998 emit_header(gc
->pc
, X_GLrop_VertexAttrib3fvARB
, cmdlen
);
7999 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&index
), 4);
8000 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (v
), 12);
8002 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
8003 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
8007 #define X_GLrop_VertexAttrib3svARB 4191
8009 __indirect_glVertexAttrib3sARB(GLuint index
, GLshort x
, GLshort y
, GLshort z
)
8011 __GLXcontext
*const gc
= __glXGetCurrentContext();
8012 const GLuint cmdlen
= 16;
8013 emit_header(gc
->pc
, X_GLrop_VertexAttrib3svARB
, cmdlen
);
8014 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&index
), 4);
8015 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&x
), 2);
8016 (void) memcpy((void *) (gc
->pc
+ 10), (void *) (&y
), 2);
8017 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&z
), 2);
8019 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
8020 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
8024 #define X_GLrop_VertexAttrib3svARB 4191
8026 __indirect_glVertexAttrib3svARB(GLuint index
, const GLshort
* v
)
8028 __GLXcontext
*const gc
= __glXGetCurrentContext();
8029 const GLuint cmdlen
= 16;
8030 emit_header(gc
->pc
, X_GLrop_VertexAttrib3svARB
, cmdlen
);
8031 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&index
), 4);
8032 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (v
), 6);
8034 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
8035 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
8039 #define X_GLrop_VertexAttrib4NbvARB 4235
8041 __indirect_glVertexAttrib4NbvARB(GLuint index
, const GLbyte
*v
)
8043 __GLXcontext
*const gc
= __glXGetCurrentContext();
8044 const GLuint cmdlen
= 12;
8045 emit_header(gc
->pc
, X_GLrop_VertexAttrib4NbvARB
, cmdlen
);
8046 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&index
), 4);
8047 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (v
), 4);
8049 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
8050 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
8054 #define X_GLrop_VertexAttrib4NivARB 4237
8056 __indirect_glVertexAttrib4NivARB(GLuint index
, const GLint
* v
)
8058 __GLXcontext
*const gc
= __glXGetCurrentContext();
8059 const GLuint cmdlen
= 24;
8060 emit_header(gc
->pc
, X_GLrop_VertexAttrib4NivARB
, cmdlen
);
8061 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&index
), 4);
8062 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (v
), 16);
8064 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
8065 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
8069 #define X_GLrop_VertexAttrib4NsvARB 4236
8071 __indirect_glVertexAttrib4NsvARB(GLuint index
, const GLshort
* v
)
8073 __GLXcontext
*const gc
= __glXGetCurrentContext();
8074 const GLuint cmdlen
= 16;
8075 emit_header(gc
->pc
, X_GLrop_VertexAttrib4NsvARB
, cmdlen
);
8076 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&index
), 4);
8077 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (v
), 8);
8079 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
8080 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
8084 #define X_GLrop_VertexAttrib4NubvARB 4201
8086 __indirect_glVertexAttrib4NubARB(GLuint index
, GLubyte x
, GLubyte y
,
8087 GLubyte z
, GLubyte w
)
8089 __GLXcontext
*const gc
= __glXGetCurrentContext();
8090 const GLuint cmdlen
= 12;
8091 emit_header(gc
->pc
, X_GLrop_VertexAttrib4NubvARB
, cmdlen
);
8092 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&index
), 4);
8093 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&x
), 1);
8094 (void) memcpy((void *) (gc
->pc
+ 9), (void *) (&y
), 1);
8095 (void) memcpy((void *) (gc
->pc
+ 10), (void *) (&z
), 1);
8096 (void) memcpy((void *) (gc
->pc
+ 11), (void *) (&w
), 1);
8098 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
8099 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
8103 #define X_GLrop_VertexAttrib4NubvARB 4201
8105 __indirect_glVertexAttrib4NubvARB(GLuint index
, const GLubyte
*v
)
8107 __GLXcontext
*const gc
= __glXGetCurrentContext();
8108 const GLuint cmdlen
= 12;
8109 emit_header(gc
->pc
, X_GLrop_VertexAttrib4NubvARB
, cmdlen
);
8110 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&index
), 4);
8111 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (v
), 4);
8113 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
8114 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
8118 #define X_GLrop_VertexAttrib4NuivARB 4239
8120 __indirect_glVertexAttrib4NuivARB(GLuint index
, const GLuint
* v
)
8122 __GLXcontext
*const gc
= __glXGetCurrentContext();
8123 const GLuint cmdlen
= 24;
8124 emit_header(gc
->pc
, X_GLrop_VertexAttrib4NuivARB
, cmdlen
);
8125 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&index
), 4);
8126 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (v
), 16);
8128 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
8129 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
8133 #define X_GLrop_VertexAttrib4NusvARB 4238
8135 __indirect_glVertexAttrib4NusvARB(GLuint index
, const GLushort
* v
)
8137 __GLXcontext
*const gc
= __glXGetCurrentContext();
8138 const GLuint cmdlen
= 16;
8139 emit_header(gc
->pc
, X_GLrop_VertexAttrib4NusvARB
, cmdlen
);
8140 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&index
), 4);
8141 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (v
), 8);
8143 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
8144 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
8148 #define X_GLrop_VertexAttrib4bvARB 4230
8150 __indirect_glVertexAttrib4bvARB(GLuint index
, const GLbyte
*v
)
8152 __GLXcontext
*const gc
= __glXGetCurrentContext();
8153 const GLuint cmdlen
= 12;
8154 emit_header(gc
->pc
, X_GLrop_VertexAttrib4bvARB
, cmdlen
);
8155 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&index
), 4);
8156 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (v
), 4);
8158 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
8159 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
8163 #define X_GLrop_VertexAttrib4dvARB 4200
8165 __indirect_glVertexAttrib4dARB(GLuint index
, GLdouble x
, GLdouble y
,
8166 GLdouble z
, GLdouble w
)
8168 __GLXcontext
*const gc
= __glXGetCurrentContext();
8169 const GLuint cmdlen
= 40;
8170 emit_header(gc
->pc
, X_GLrop_VertexAttrib4dvARB
, cmdlen
);
8171 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&index
), 4);
8172 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&x
), 8);
8173 (void) memcpy((void *) (gc
->pc
+ 16), (void *) (&y
), 8);
8174 (void) memcpy((void *) (gc
->pc
+ 24), (void *) (&z
), 8);
8175 (void) memcpy((void *) (gc
->pc
+ 32), (void *) (&w
), 8);
8177 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
8178 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
8182 #define X_GLrop_VertexAttrib4dvARB 4200
8184 __indirect_glVertexAttrib4dvARB(GLuint index
, const GLdouble
* v
)
8186 __GLXcontext
*const gc
= __glXGetCurrentContext();
8187 const GLuint cmdlen
= 40;
8188 emit_header(gc
->pc
, X_GLrop_VertexAttrib4dvARB
, cmdlen
);
8189 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&index
), 4);
8190 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (v
), 32);
8192 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
8193 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
8197 #define X_GLrop_VertexAttrib4fvARB 4196
8199 __indirect_glVertexAttrib4fARB(GLuint index
, GLfloat x
, GLfloat y
, GLfloat z
,
8202 __GLXcontext
*const gc
= __glXGetCurrentContext();
8203 const GLuint cmdlen
= 24;
8204 emit_header(gc
->pc
, X_GLrop_VertexAttrib4fvARB
, cmdlen
);
8205 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&index
), 4);
8206 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&x
), 4);
8207 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&y
), 4);
8208 (void) memcpy((void *) (gc
->pc
+ 16), (void *) (&z
), 4);
8209 (void) memcpy((void *) (gc
->pc
+ 20), (void *) (&w
), 4);
8211 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
8212 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
8216 #define X_GLrop_VertexAttrib4fvARB 4196
8218 __indirect_glVertexAttrib4fvARB(GLuint index
, const GLfloat
* v
)
8220 __GLXcontext
*const gc
= __glXGetCurrentContext();
8221 const GLuint cmdlen
= 24;
8222 emit_header(gc
->pc
, X_GLrop_VertexAttrib4fvARB
, cmdlen
);
8223 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&index
), 4);
8224 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (v
), 16);
8226 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
8227 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
8231 #define X_GLrop_VertexAttrib4ivARB 4231
8233 __indirect_glVertexAttrib4ivARB(GLuint index
, const GLint
* v
)
8235 __GLXcontext
*const gc
= __glXGetCurrentContext();
8236 const GLuint cmdlen
= 24;
8237 emit_header(gc
->pc
, X_GLrop_VertexAttrib4ivARB
, cmdlen
);
8238 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&index
), 4);
8239 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (v
), 16);
8241 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
8242 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
8246 #define X_GLrop_VertexAttrib4svARB 4192
8248 __indirect_glVertexAttrib4sARB(GLuint index
, GLshort x
, GLshort y
, GLshort z
,
8251 __GLXcontext
*const gc
= __glXGetCurrentContext();
8252 const GLuint cmdlen
= 16;
8253 emit_header(gc
->pc
, X_GLrop_VertexAttrib4svARB
, cmdlen
);
8254 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&index
), 4);
8255 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&x
), 2);
8256 (void) memcpy((void *) (gc
->pc
+ 10), (void *) (&y
), 2);
8257 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&z
), 2);
8258 (void) memcpy((void *) (gc
->pc
+ 14), (void *) (&w
), 2);
8260 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
8261 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
8265 #define X_GLrop_VertexAttrib4svARB 4192
8267 __indirect_glVertexAttrib4svARB(GLuint index
, const GLshort
* v
)
8269 __GLXcontext
*const gc
= __glXGetCurrentContext();
8270 const GLuint cmdlen
= 16;
8271 emit_header(gc
->pc
, X_GLrop_VertexAttrib4svARB
, cmdlen
);
8272 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&index
), 4);
8273 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (v
), 8);
8275 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
8276 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
8280 #define X_GLrop_VertexAttrib4ubvARB 4232
8282 __indirect_glVertexAttrib4ubvARB(GLuint index
, const GLubyte
*v
)
8284 __GLXcontext
*const gc
= __glXGetCurrentContext();
8285 const GLuint cmdlen
= 12;
8286 emit_header(gc
->pc
, X_GLrop_VertexAttrib4ubvARB
, cmdlen
);
8287 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&index
), 4);
8288 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (v
), 4);
8290 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
8291 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
8295 #define X_GLrop_VertexAttrib4uivARB 4234
8297 __indirect_glVertexAttrib4uivARB(GLuint index
, const GLuint
* v
)
8299 __GLXcontext
*const gc
= __glXGetCurrentContext();
8300 const GLuint cmdlen
= 24;
8301 emit_header(gc
->pc
, X_GLrop_VertexAttrib4uivARB
, cmdlen
);
8302 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&index
), 4);
8303 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (v
), 16);
8305 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
8306 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
8310 #define X_GLrop_VertexAttrib4usvARB 4233
8312 __indirect_glVertexAttrib4usvARB(GLuint index
, const GLushort
* v
)
8314 __GLXcontext
*const gc
= __glXGetCurrentContext();
8315 const GLuint cmdlen
= 16;
8316 emit_header(gc
->pc
, X_GLrop_VertexAttrib4usvARB
, cmdlen
);
8317 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&index
), 4);
8318 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (v
), 8);
8320 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
8321 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
8325 #define X_GLrop_BeginQueryARB 231
8327 __indirect_glBeginQueryARB(GLenum target
, GLuint id
)
8329 __GLXcontext
*const gc
= __glXGetCurrentContext();
8330 const GLuint cmdlen
= 12;
8331 emit_header(gc
->pc
, X_GLrop_BeginQueryARB
, cmdlen
);
8332 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&target
), 4);
8333 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&id
), 4);
8335 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
8336 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
8340 #define X_GLsop_DeleteQueriesARB 161
8342 __indirect_glDeleteQueriesARB(GLsizei n
, const GLuint
* ids
)
8344 __GLXcontext
*const gc
= __glXGetCurrentContext();
8345 Display
*const dpy
= gc
->currentDpy
;
8347 const GLuint cmdlen
= 4 + __GLX_PAD((n
* 4));
8350 __glXSetError(gc
, GL_INVALID_VALUE
);
8353 if (__builtin_expect((n
>= 0) && (dpy
!= NULL
), 1)) {
8355 xcb_connection_t
*c
= XGetXCBConnection(dpy
);
8356 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
8357 xcb_glx_delete_queries_arb(c
, gc
->currentContextTag
, n
, ids
);
8360 __glXSetupSingleRequest(gc
, X_GLsop_DeleteQueriesARB
, cmdlen
);
8361 (void) memcpy((void *) (pc
+ 0), (void *) (&n
), 4);
8362 (void) memcpy((void *) (pc
+ 4), (void *) (ids
), (n
* 4));
8365 #endif /* USE_XCB */
8370 #define X_GLrop_EndQueryARB 232
8372 __indirect_glEndQueryARB(GLenum target
)
8374 __GLXcontext
*const gc
= __glXGetCurrentContext();
8375 const GLuint cmdlen
= 8;
8376 emit_header(gc
->pc
, X_GLrop_EndQueryARB
, cmdlen
);
8377 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&target
), 4);
8379 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
8380 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
8384 #define X_GLsop_GenQueriesARB 162
8386 __indirect_glGenQueriesARB(GLsizei n
, GLuint
* ids
)
8388 __GLXcontext
*const gc
= __glXGetCurrentContext();
8389 Display
*const dpy
= gc
->currentDpy
;
8391 const GLuint cmdlen
= 4;
8394 __glXSetError(gc
, GL_INVALID_VALUE
);
8397 if (__builtin_expect((n
>= 0) && (dpy
!= NULL
), 1)) {
8399 xcb_connection_t
*c
= XGetXCBConnection(dpy
);
8400 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
8401 xcb_glx_gen_queries_arb_reply_t
*reply
=
8402 xcb_glx_gen_queries_arb_reply(c
,
8403 xcb_glx_gen_queries_arb(c
,
8407 (void) memcpy(ids
, xcb_glx_gen_queries_arb_data(reply
),
8408 xcb_glx_gen_queries_arb_data_length(reply
) *
8413 __glXSetupSingleRequest(gc
, X_GLsop_GenQueriesARB
, cmdlen
);
8414 (void) memcpy((void *) (pc
+ 0), (void *) (&n
), 4);
8415 (void) __glXReadReply(dpy
, 4, ids
, GL_TRUE
);
8418 #endif /* USE_XCB */
8423 #define X_GLsop_GetQueryObjectivARB 165
8425 __indirect_glGetQueryObjectivARB(GLuint id
, GLenum pname
, GLint
* params
)
8427 __GLXcontext
*const gc
= __glXGetCurrentContext();
8428 Display
*const dpy
= gc
->currentDpy
;
8430 const GLuint cmdlen
= 8;
8432 if (__builtin_expect(dpy
!= NULL
, 1)) {
8434 xcb_connection_t
*c
= XGetXCBConnection(dpy
);
8435 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
8436 xcb_glx_get_query_objectiv_arb_reply_t
*reply
=
8437 xcb_glx_get_query_objectiv_arb_reply(c
,
8438 xcb_glx_get_query_objectiv_arb
8439 (c
, gc
->currentContextTag
,
8441 if (xcb_glx_get_query_objectiv_arb_data_length(reply
) == 0)
8442 (void) memcpy(params
, &reply
->datum
, sizeof(reply
->datum
));
8444 (void) memcpy(params
, xcb_glx_get_query_objectiv_arb_data(reply
),
8445 xcb_glx_get_query_objectiv_arb_data_length(reply
) *
8450 __glXSetupSingleRequest(gc
, X_GLsop_GetQueryObjectivARB
, cmdlen
);
8451 (void) memcpy((void *) (pc
+ 0), (void *) (&id
), 4);
8452 (void) memcpy((void *) (pc
+ 4), (void *) (&pname
), 4);
8453 (void) __glXReadReply(dpy
, 4, params
, GL_FALSE
);
8456 #endif /* USE_XCB */
8461 #define X_GLsop_GetQueryObjectuivARB 166
8463 __indirect_glGetQueryObjectuivARB(GLuint id
, GLenum pname
, GLuint
* params
)
8465 __GLXcontext
*const gc
= __glXGetCurrentContext();
8466 Display
*const dpy
= gc
->currentDpy
;
8468 const GLuint cmdlen
= 8;
8470 if (__builtin_expect(dpy
!= NULL
, 1)) {
8472 xcb_connection_t
*c
= XGetXCBConnection(dpy
);
8473 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
8474 xcb_glx_get_query_objectuiv_arb_reply_t
*reply
=
8475 xcb_glx_get_query_objectuiv_arb_reply(c
,
8476 xcb_glx_get_query_objectuiv_arb
8477 (c
, gc
->currentContextTag
,
8479 if (xcb_glx_get_query_objectuiv_arb_data_length(reply
) == 0)
8480 (void) memcpy(params
, &reply
->datum
, sizeof(reply
->datum
));
8482 (void) memcpy(params
, xcb_glx_get_query_objectuiv_arb_data(reply
),
8483 xcb_glx_get_query_objectuiv_arb_data_length(reply
) *
8488 __glXSetupSingleRequest(gc
, X_GLsop_GetQueryObjectuivARB
, cmdlen
);
8489 (void) memcpy((void *) (pc
+ 0), (void *) (&id
), 4);
8490 (void) memcpy((void *) (pc
+ 4), (void *) (&pname
), 4);
8491 (void) __glXReadReply(dpy
, 4, params
, GL_FALSE
);
8494 #endif /* USE_XCB */
8499 #define X_GLsop_GetQueryivARB 164
8501 __indirect_glGetQueryivARB(GLenum target
, GLenum pname
, GLint
* params
)
8503 __GLXcontext
*const gc
= __glXGetCurrentContext();
8504 Display
*const dpy
= gc
->currentDpy
;
8506 const GLuint cmdlen
= 8;
8508 if (__builtin_expect(dpy
!= NULL
, 1)) {
8510 xcb_connection_t
*c
= XGetXCBConnection(dpy
);
8511 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
8512 xcb_glx_get_queryiv_arb_reply_t
*reply
=
8513 xcb_glx_get_queryiv_arb_reply(c
,
8514 xcb_glx_get_queryiv_arb(c
,
8520 if (xcb_glx_get_queryiv_arb_data_length(reply
) == 0)
8521 (void) memcpy(params
, &reply
->datum
, sizeof(reply
->datum
));
8523 (void) memcpy(params
, xcb_glx_get_queryiv_arb_data(reply
),
8524 xcb_glx_get_queryiv_arb_data_length(reply
) *
8529 __glXSetupSingleRequest(gc
, X_GLsop_GetQueryivARB
, cmdlen
);
8530 (void) memcpy((void *) (pc
+ 0), (void *) (&target
), 4);
8531 (void) memcpy((void *) (pc
+ 4), (void *) (&pname
), 4);
8532 (void) __glXReadReply(dpy
, 4, params
, GL_FALSE
);
8535 #endif /* USE_XCB */
8540 #define X_GLsop_IsQueryARB 163
8542 __indirect_glIsQueryARB(GLuint id
)
8544 __GLXcontext
*const gc
= __glXGetCurrentContext();
8545 Display
*const dpy
= gc
->currentDpy
;
8546 GLboolean retval
= (GLboolean
) 0;
8548 const GLuint cmdlen
= 4;
8550 if (__builtin_expect(dpy
!= NULL
, 1)) {
8552 xcb_connection_t
*c
= XGetXCBConnection(dpy
);
8553 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
8554 xcb_glx_is_query_arb_reply_t
*reply
=
8555 xcb_glx_is_query_arb_reply(c
,
8556 xcb_glx_is_query_arb(c
,
8560 retval
= reply
->ret_val
;
8564 __glXSetupSingleRequest(gc
, X_GLsop_IsQueryARB
, cmdlen
);
8565 (void) memcpy((void *) (pc
+ 0), (void *) (&id
), 4);
8566 retval
= (GLboolean
) __glXReadReply(dpy
, 0, NULL
, GL_FALSE
);
8569 #endif /* USE_XCB */
8574 #define X_GLrop_DrawBuffersARB 233
8576 __indirect_glDrawBuffersARB(GLsizei n
, const GLenum
* bufs
)
8578 __GLXcontext
*const gc
= __glXGetCurrentContext();
8579 const GLuint cmdlen
= 8 + __GLX_PAD((n
* 4));
8581 __glXSetError(gc
, GL_INVALID_VALUE
);
8584 if (__builtin_expect((n
>= 0) && (gc
->currentDpy
!= NULL
), 1)) {
8585 if (cmdlen
<= gc
->maxSmallRenderCommandSize
) {
8586 if ((gc
->pc
+ cmdlen
) > gc
->bufEnd
) {
8587 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
8589 emit_header(gc
->pc
, X_GLrop_DrawBuffersARB
, cmdlen
);
8590 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&n
), 4);
8591 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (bufs
), (n
* 4));
8593 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
8594 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
8597 const GLint op
= X_GLrop_DrawBuffersARB
;
8598 const GLuint cmdlenLarge
= cmdlen
+ 4;
8599 GLubyte
*const pc
= __glXFlushRenderBuffer(gc
, gc
->pc
);
8600 (void) memcpy((void *) (pc
+ 0), (void *) (&cmdlenLarge
), 4);
8601 (void) memcpy((void *) (pc
+ 4), (void *) (&op
), 4);
8602 (void) memcpy((void *) (pc
+ 8), (void *) (&n
), 4);
8603 __glXSendLargeCommand(gc
, pc
, 12, bufs
, (n
* 4));
8608 #define X_GLrop_RenderbufferStorageMultisample 4331
8610 __indirect_glRenderbufferStorageMultisample(GLenum target
, GLsizei samples
,
8611 GLenum internalformat
,
8612 GLsizei width
, GLsizei height
)
8614 __GLXcontext
*const gc
= __glXGetCurrentContext();
8615 const GLuint cmdlen
= 24;
8616 emit_header(gc
->pc
, X_GLrop_RenderbufferStorageMultisample
, cmdlen
);
8617 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&target
), 4);
8618 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&samples
), 4);
8619 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&internalformat
), 4);
8620 (void) memcpy((void *) (gc
->pc
+ 16), (void *) (&width
), 4);
8621 (void) memcpy((void *) (gc
->pc
+ 20), (void *) (&height
), 4);
8623 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
8624 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
8628 #define X_GLrop_SampleMaskSGIS 2048
8630 __indirect_glSampleMaskSGIS(GLclampf value
, GLboolean invert
)
8632 __GLXcontext
*const gc
= __glXGetCurrentContext();
8633 const GLuint cmdlen
= 12;
8634 emit_header(gc
->pc
, X_GLrop_SampleMaskSGIS
, cmdlen
);
8635 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&value
), 4);
8636 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&invert
), 1);
8638 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
8639 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
8643 #define X_GLrop_SamplePatternSGIS 2049
8645 __indirect_glSamplePatternSGIS(GLenum pattern
)
8647 __GLXcontext
*const gc
= __glXGetCurrentContext();
8648 const GLuint cmdlen
= 8;
8649 emit_header(gc
->pc
, X_GLrop_SamplePatternSGIS
, cmdlen
);
8650 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&pattern
), 4);
8652 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
8653 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
8657 #define X_GLrop_PointParameterfEXT 2065
8659 __indirect_glPointParameterfEXT(GLenum pname
, GLfloat param
)
8661 __GLXcontext
*const gc
= __glXGetCurrentContext();
8662 const GLuint cmdlen
= 12;
8663 emit_header(gc
->pc
, X_GLrop_PointParameterfEXT
, cmdlen
);
8664 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&pname
), 4);
8665 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (¶m
), 4);
8667 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
8668 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
8672 #define X_GLrop_PointParameterfvEXT 2066
8674 __indirect_glPointParameterfvEXT(GLenum pname
, const GLfloat
* params
)
8676 __GLXcontext
*const gc
= __glXGetCurrentContext();
8677 const GLuint compsize
= __glPointParameterfvEXT_size(pname
);
8678 const GLuint cmdlen
= 8 + __GLX_PAD((compsize
* 4));
8679 emit_header(gc
->pc
, X_GLrop_PointParameterfvEXT
, cmdlen
);
8680 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&pname
), 4);
8681 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (params
), (compsize
* 4));
8683 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
8684 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
8688 #define X_GLrop_SecondaryColor3bvEXT 4126
8690 __indirect_glSecondaryColor3bEXT(GLbyte red
, GLbyte green
, GLbyte blue
)
8692 __GLXcontext
*const gc
= __glXGetCurrentContext();
8693 const GLuint cmdlen
= 8;
8694 emit_header(gc
->pc
, X_GLrop_SecondaryColor3bvEXT
, cmdlen
);
8695 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&red
), 1);
8696 (void) memcpy((void *) (gc
->pc
+ 5), (void *) (&green
), 1);
8697 (void) memcpy((void *) (gc
->pc
+ 6), (void *) (&blue
), 1);
8699 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
8700 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
8704 #define X_GLrop_SecondaryColor3bvEXT 4126
8706 __indirect_glSecondaryColor3bvEXT(const GLbyte
*v
)
8708 generic_3_byte(X_GLrop_SecondaryColor3bvEXT
, v
);
8711 #define X_GLrop_SecondaryColor3dvEXT 4130
8713 __indirect_glSecondaryColor3dEXT(GLdouble red
, GLdouble green
, GLdouble blue
)
8715 __GLXcontext
*const gc
= __glXGetCurrentContext();
8716 const GLuint cmdlen
= 28;
8717 emit_header(gc
->pc
, X_GLrop_SecondaryColor3dvEXT
, cmdlen
);
8718 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&red
), 8);
8719 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&green
), 8);
8720 (void) memcpy((void *) (gc
->pc
+ 20), (void *) (&blue
), 8);
8722 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
8723 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
8727 #define X_GLrop_SecondaryColor3dvEXT 4130
8729 __indirect_glSecondaryColor3dvEXT(const GLdouble
* v
)
8731 generic_24_byte(X_GLrop_SecondaryColor3dvEXT
, v
);
8734 #define X_GLrop_SecondaryColor3fvEXT 4129
8736 __indirect_glSecondaryColor3fEXT(GLfloat red
, GLfloat green
, GLfloat blue
)
8738 __GLXcontext
*const gc
= __glXGetCurrentContext();
8739 const GLuint cmdlen
= 16;
8740 emit_header(gc
->pc
, X_GLrop_SecondaryColor3fvEXT
, cmdlen
);
8741 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&red
), 4);
8742 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&green
), 4);
8743 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&blue
), 4);
8745 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
8746 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
8750 #define X_GLrop_SecondaryColor3fvEXT 4129
8752 __indirect_glSecondaryColor3fvEXT(const GLfloat
* v
)
8754 generic_12_byte(X_GLrop_SecondaryColor3fvEXT
, v
);
8757 #define X_GLrop_SecondaryColor3ivEXT 4128
8759 __indirect_glSecondaryColor3iEXT(GLint red
, GLint green
, GLint blue
)
8761 __GLXcontext
*const gc
= __glXGetCurrentContext();
8762 const GLuint cmdlen
= 16;
8763 emit_header(gc
->pc
, X_GLrop_SecondaryColor3ivEXT
, cmdlen
);
8764 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&red
), 4);
8765 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&green
), 4);
8766 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&blue
), 4);
8768 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
8769 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
8773 #define X_GLrop_SecondaryColor3ivEXT 4128
8775 __indirect_glSecondaryColor3ivEXT(const GLint
* v
)
8777 generic_12_byte(X_GLrop_SecondaryColor3ivEXT
, v
);
8780 #define X_GLrop_SecondaryColor3svEXT 4127
8782 __indirect_glSecondaryColor3sEXT(GLshort red
, GLshort green
, GLshort blue
)
8784 __GLXcontext
*const gc
= __glXGetCurrentContext();
8785 const GLuint cmdlen
= 12;
8786 emit_header(gc
->pc
, X_GLrop_SecondaryColor3svEXT
, cmdlen
);
8787 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&red
), 2);
8788 (void) memcpy((void *) (gc
->pc
+ 6), (void *) (&green
), 2);
8789 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&blue
), 2);
8791 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
8792 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
8796 #define X_GLrop_SecondaryColor3svEXT 4127
8798 __indirect_glSecondaryColor3svEXT(const GLshort
* v
)
8800 generic_6_byte(X_GLrop_SecondaryColor3svEXT
, v
);
8803 #define X_GLrop_SecondaryColor3ubvEXT 4131
8805 __indirect_glSecondaryColor3ubEXT(GLubyte red
, GLubyte green
, GLubyte blue
)
8807 __GLXcontext
*const gc
= __glXGetCurrentContext();
8808 const GLuint cmdlen
= 8;
8809 emit_header(gc
->pc
, X_GLrop_SecondaryColor3ubvEXT
, cmdlen
);
8810 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&red
), 1);
8811 (void) memcpy((void *) (gc
->pc
+ 5), (void *) (&green
), 1);
8812 (void) memcpy((void *) (gc
->pc
+ 6), (void *) (&blue
), 1);
8814 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
8815 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
8819 #define X_GLrop_SecondaryColor3ubvEXT 4131
8821 __indirect_glSecondaryColor3ubvEXT(const GLubyte
*v
)
8823 generic_3_byte(X_GLrop_SecondaryColor3ubvEXT
, v
);
8826 #define X_GLrop_SecondaryColor3uivEXT 4133
8828 __indirect_glSecondaryColor3uiEXT(GLuint red
, GLuint green
, GLuint blue
)
8830 __GLXcontext
*const gc
= __glXGetCurrentContext();
8831 const GLuint cmdlen
= 16;
8832 emit_header(gc
->pc
, X_GLrop_SecondaryColor3uivEXT
, cmdlen
);
8833 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&red
), 4);
8834 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&green
), 4);
8835 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&blue
), 4);
8837 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
8838 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
8842 #define X_GLrop_SecondaryColor3uivEXT 4133
8844 __indirect_glSecondaryColor3uivEXT(const GLuint
* v
)
8846 generic_12_byte(X_GLrop_SecondaryColor3uivEXT
, v
);
8849 #define X_GLrop_SecondaryColor3usvEXT 4132
8851 __indirect_glSecondaryColor3usEXT(GLushort red
, GLushort green
, GLushort blue
)
8853 __GLXcontext
*const gc
= __glXGetCurrentContext();
8854 const GLuint cmdlen
= 12;
8855 emit_header(gc
->pc
, X_GLrop_SecondaryColor3usvEXT
, cmdlen
);
8856 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&red
), 2);
8857 (void) memcpy((void *) (gc
->pc
+ 6), (void *) (&green
), 2);
8858 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&blue
), 2);
8860 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
8861 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
8865 #define X_GLrop_SecondaryColor3usvEXT 4132
8867 __indirect_glSecondaryColor3usvEXT(const GLushort
* v
)
8869 generic_6_byte(X_GLrop_SecondaryColor3usvEXT
, v
);
8872 #define X_GLrop_FogCoorddvEXT 4125
8874 __indirect_glFogCoorddEXT(GLdouble coord
)
8876 __GLXcontext
*const gc
= __glXGetCurrentContext();
8877 const GLuint cmdlen
= 12;
8878 emit_header(gc
->pc
, X_GLrop_FogCoorddvEXT
, cmdlen
);
8879 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&coord
), 8);
8881 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
8882 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
8886 #define X_GLrop_FogCoorddvEXT 4125
8888 __indirect_glFogCoorddvEXT(const GLdouble
* coord
)
8890 generic_8_byte(X_GLrop_FogCoorddvEXT
, coord
);
8893 #define X_GLrop_FogCoordfvEXT 4124
8895 __indirect_glFogCoordfEXT(GLfloat coord
)
8897 __GLXcontext
*const gc
= __glXGetCurrentContext();
8898 const GLuint cmdlen
= 8;
8899 emit_header(gc
->pc
, X_GLrop_FogCoordfvEXT
, cmdlen
);
8900 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&coord
), 4);
8902 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
8903 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
8907 #define X_GLrop_FogCoordfvEXT 4124
8909 __indirect_glFogCoordfvEXT(const GLfloat
* coord
)
8911 generic_4_byte(X_GLrop_FogCoordfvEXT
, coord
);
8914 #define X_GLrop_BlendFuncSeparateEXT 4134
8916 __indirect_glBlendFuncSeparateEXT(GLenum sfactorRGB
, GLenum dfactorRGB
,
8917 GLenum sfactorAlpha
, GLenum dfactorAlpha
)
8919 __GLXcontext
*const gc
= __glXGetCurrentContext();
8920 const GLuint cmdlen
= 20;
8921 emit_header(gc
->pc
, X_GLrop_BlendFuncSeparateEXT
, cmdlen
);
8922 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&sfactorRGB
), 4);
8923 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&dfactorRGB
), 4);
8924 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&sfactorAlpha
), 4);
8925 (void) memcpy((void *) (gc
->pc
+ 16), (void *) (&dfactorAlpha
), 4);
8927 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
8928 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
8932 #define X_GLrop_WindowPos3fvMESA 230
8934 __indirect_glWindowPos3fMESA(GLfloat x
, GLfloat y
, GLfloat z
)
8936 __GLXcontext
*const gc
= __glXGetCurrentContext();
8937 const GLuint cmdlen
= 16;
8938 emit_header(gc
->pc
, X_GLrop_WindowPos3fvMESA
, cmdlen
);
8939 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&x
), 4);
8940 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&y
), 4);
8941 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&z
), 4);
8943 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
8944 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
8948 #define X_GLrop_WindowPos3fvMESA 230
8950 __indirect_glWindowPos3fvMESA(const GLfloat
* v
)
8952 generic_12_byte(X_GLrop_WindowPos3fvMESA
, v
);
8955 #define X_GLvop_AreProgramsResidentNV 1293
8957 __indirect_glAreProgramsResidentNV(GLsizei n
, const GLuint
* ids
,
8958 GLboolean
* residences
)
8960 __GLXcontext
*const gc
= __glXGetCurrentContext();
8961 Display
*const dpy
= gc
->currentDpy
;
8962 GLboolean retval
= (GLboolean
) 0;
8963 const GLuint cmdlen
= 4 + __GLX_PAD((n
* 4));
8965 __glXSetError(gc
, GL_INVALID_VALUE
);
8968 if (__builtin_expect((n
>= 0) && (dpy
!= NULL
), 1)) {
8970 __glXSetupVendorRequest(gc
, X_GLXVendorPrivateWithReply
,
8971 X_GLvop_AreProgramsResidentNV
, cmdlen
);
8972 (void) memcpy((void *) (pc
+ 0), (void *) (&n
), 4);
8973 (void) memcpy((void *) (pc
+ 4), (void *) (ids
), (n
* 4));
8974 retval
= (GLboolean
) __glXReadReply(dpy
, 1, residences
, GL_FALSE
);
8981 #define X_GLrop_BindProgramNV 4180
8983 __indirect_glBindProgramNV(GLenum target
, GLuint program
)
8985 __GLXcontext
*const gc
= __glXGetCurrentContext();
8986 const GLuint cmdlen
= 12;
8987 emit_header(gc
->pc
, X_GLrop_BindProgramNV
, cmdlen
);
8988 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&target
), 4);
8989 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&program
), 4);
8991 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
8992 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
8996 #define X_GLvop_DeleteProgramsNV 1294
8998 __indirect_glDeleteProgramsNV(GLsizei n
, const GLuint
* programs
)
9000 __GLXcontext
*const gc
= __glXGetCurrentContext();
9001 Display
*const dpy
= gc
->currentDpy
;
9002 const GLuint cmdlen
= 4 + __GLX_PAD((n
* 4));
9004 __glXSetError(gc
, GL_INVALID_VALUE
);
9007 if (__builtin_expect((n
>= 0) && (dpy
!= NULL
), 1)) {
9009 __glXSetupVendorRequest(gc
, X_GLXVendorPrivate
,
9010 X_GLvop_DeleteProgramsNV
, cmdlen
);
9011 (void) memcpy((void *) (pc
+ 0), (void *) (&n
), 4);
9012 (void) memcpy((void *) (pc
+ 4), (void *) (programs
), (n
* 4));
9019 #define X_GLrop_ExecuteProgramNV 4181
9021 __indirect_glExecuteProgramNV(GLenum target
, GLuint id
,
9022 const GLfloat
* params
)
9024 __GLXcontext
*const gc
= __glXGetCurrentContext();
9025 const GLuint cmdlen
= 28;
9026 emit_header(gc
->pc
, X_GLrop_ExecuteProgramNV
, cmdlen
);
9027 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&target
), 4);
9028 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&id
), 4);
9029 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (params
), 16);
9031 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
9032 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
9036 #define X_GLvop_GenProgramsNV 1295
9038 __indirect_glGenProgramsNV(GLsizei n
, GLuint
* programs
)
9040 __GLXcontext
*const gc
= __glXGetCurrentContext();
9041 Display
*const dpy
= gc
->currentDpy
;
9042 const GLuint cmdlen
= 4;
9044 __glXSetError(gc
, GL_INVALID_VALUE
);
9047 if (__builtin_expect((n
>= 0) && (dpy
!= NULL
), 1)) {
9049 __glXSetupVendorRequest(gc
, X_GLXVendorPrivateWithReply
,
9050 X_GLvop_GenProgramsNV
, cmdlen
);
9051 (void) memcpy((void *) (pc
+ 0), (void *) (&n
), 4);
9052 (void) __glXReadReply(dpy
, 4, programs
, GL_TRUE
);
9059 #define X_GLvop_GetProgramParameterdvNV 1297
9061 __indirect_glGetProgramParameterdvNV(GLenum target
, GLuint index
,
9062 GLenum pname
, GLdouble
* params
)
9064 __GLXcontext
*const gc
= __glXGetCurrentContext();
9065 Display
*const dpy
= gc
->currentDpy
;
9066 const GLuint cmdlen
= 12;
9067 if (__builtin_expect(dpy
!= NULL
, 1)) {
9069 __glXSetupVendorRequest(gc
, X_GLXVendorPrivateWithReply
,
9070 X_GLvop_GetProgramParameterdvNV
, cmdlen
);
9071 (void) memcpy((void *) (pc
+ 0), (void *) (&target
), 4);
9072 (void) memcpy((void *) (pc
+ 4), (void *) (&index
), 4);
9073 (void) memcpy((void *) (pc
+ 8), (void *) (&pname
), 4);
9074 (void) __glXReadReply(dpy
, 8, params
, GL_FALSE
);
9081 #define X_GLvop_GetProgramParameterfvNV 1296
9083 __indirect_glGetProgramParameterfvNV(GLenum target
, GLuint index
,
9084 GLenum pname
, GLfloat
* params
)
9086 __GLXcontext
*const gc
= __glXGetCurrentContext();
9087 Display
*const dpy
= gc
->currentDpy
;
9088 const GLuint cmdlen
= 12;
9089 if (__builtin_expect(dpy
!= NULL
, 1)) {
9091 __glXSetupVendorRequest(gc
, X_GLXVendorPrivateWithReply
,
9092 X_GLvop_GetProgramParameterfvNV
, cmdlen
);
9093 (void) memcpy((void *) (pc
+ 0), (void *) (&target
), 4);
9094 (void) memcpy((void *) (pc
+ 4), (void *) (&index
), 4);
9095 (void) memcpy((void *) (pc
+ 8), (void *) (&pname
), 4);
9096 (void) __glXReadReply(dpy
, 4, params
, GL_FALSE
);
9103 #define X_GLvop_GetProgramStringNV 1299
9105 __indirect_glGetProgramStringNV(GLuint id
, GLenum pname
, GLubyte
*program
)
9107 __GLXcontext
*const gc
= __glXGetCurrentContext();
9108 Display
*const dpy
= gc
->currentDpy
;
9109 const GLuint cmdlen
= 8;
9110 if (__builtin_expect(dpy
!= NULL
, 1)) {
9112 __glXSetupVendorRequest(gc
, X_GLXVendorPrivateWithReply
,
9113 X_GLvop_GetProgramStringNV
, cmdlen
);
9114 (void) memcpy((void *) (pc
+ 0), (void *) (&id
), 4);
9115 (void) memcpy((void *) (pc
+ 4), (void *) (&pname
), 4);
9116 (void) __glXReadReply(dpy
, 1, program
, GL_TRUE
);
9123 #define X_GLvop_GetProgramivNV 1298
9125 __indirect_glGetProgramivNV(GLuint id
, GLenum pname
, GLint
* params
)
9127 __GLXcontext
*const gc
= __glXGetCurrentContext();
9128 Display
*const dpy
= gc
->currentDpy
;
9129 const GLuint cmdlen
= 8;
9130 if (__builtin_expect(dpy
!= NULL
, 1)) {
9132 __glXSetupVendorRequest(gc
, X_GLXVendorPrivateWithReply
,
9133 X_GLvop_GetProgramivNV
, cmdlen
);
9134 (void) memcpy((void *) (pc
+ 0), (void *) (&id
), 4);
9135 (void) memcpy((void *) (pc
+ 4), (void *) (&pname
), 4);
9136 (void) __glXReadReply(dpy
, 4, params
, GL_FALSE
);
9143 #define X_GLvop_GetTrackMatrixivNV 1300
9145 __indirect_glGetTrackMatrixivNV(GLenum target
, GLuint address
, GLenum pname
,
9148 __GLXcontext
*const gc
= __glXGetCurrentContext();
9149 Display
*const dpy
= gc
->currentDpy
;
9150 const GLuint cmdlen
= 12;
9151 if (__builtin_expect(dpy
!= NULL
, 1)) {
9153 __glXSetupVendorRequest(gc
, X_GLXVendorPrivateWithReply
,
9154 X_GLvop_GetTrackMatrixivNV
, cmdlen
);
9155 (void) memcpy((void *) (pc
+ 0), (void *) (&target
), 4);
9156 (void) memcpy((void *) (pc
+ 4), (void *) (&address
), 4);
9157 (void) memcpy((void *) (pc
+ 8), (void *) (&pname
), 4);
9158 (void) __glXReadReply(dpy
, 4, params
, GL_FALSE
);
9165 #define X_GLvop_GetVertexAttribdvNV 1301
9167 __indirect_glGetVertexAttribdvNV(GLuint index
, GLenum pname
,
9170 __GLXcontext
*const gc
= __glXGetCurrentContext();
9171 Display
*const dpy
= gc
->currentDpy
;
9172 const GLuint cmdlen
= 8;
9173 if (__builtin_expect(dpy
!= NULL
, 1)) {
9175 __glXSetupVendorRequest(gc
, X_GLXVendorPrivateWithReply
,
9176 X_GLvop_GetVertexAttribdvNV
, cmdlen
);
9177 (void) memcpy((void *) (pc
+ 0), (void *) (&index
), 4);
9178 (void) memcpy((void *) (pc
+ 4), (void *) (&pname
), 4);
9179 (void) __glXReadReply(dpy
, 8, params
, GL_FALSE
);
9186 #define X_GLvop_GetVertexAttribfvNV 1302
9188 __indirect_glGetVertexAttribfvNV(GLuint index
, GLenum pname
, GLfloat
* params
)
9190 __GLXcontext
*const gc
= __glXGetCurrentContext();
9191 Display
*const dpy
= gc
->currentDpy
;
9192 const GLuint cmdlen
= 8;
9193 if (__builtin_expect(dpy
!= NULL
, 1)) {
9195 __glXSetupVendorRequest(gc
, X_GLXVendorPrivateWithReply
,
9196 X_GLvop_GetVertexAttribfvNV
, cmdlen
);
9197 (void) memcpy((void *) (pc
+ 0), (void *) (&index
), 4);
9198 (void) memcpy((void *) (pc
+ 4), (void *) (&pname
), 4);
9199 (void) __glXReadReply(dpy
, 4, params
, GL_FALSE
);
9206 #define X_GLvop_GetVertexAttribivNV 1303
9208 __indirect_glGetVertexAttribivNV(GLuint index
, GLenum pname
, GLint
* params
)
9210 __GLXcontext
*const gc
= __glXGetCurrentContext();
9211 Display
*const dpy
= gc
->currentDpy
;
9212 const GLuint cmdlen
= 8;
9213 if (__builtin_expect(dpy
!= NULL
, 1)) {
9215 __glXSetupVendorRequest(gc
, X_GLXVendorPrivateWithReply
,
9216 X_GLvop_GetVertexAttribivNV
, cmdlen
);
9217 (void) memcpy((void *) (pc
+ 0), (void *) (&index
), 4);
9218 (void) memcpy((void *) (pc
+ 4), (void *) (&pname
), 4);
9219 (void) __glXReadReply(dpy
, 4, params
, GL_FALSE
);
9226 #define X_GLvop_IsProgramNV 1304
9228 __indirect_glIsProgramNV(GLuint program
)
9230 __GLXcontext
*const gc
= __glXGetCurrentContext();
9231 Display
*const dpy
= gc
->currentDpy
;
9232 GLboolean retval
= (GLboolean
) 0;
9233 const GLuint cmdlen
= 4;
9234 if (__builtin_expect(dpy
!= NULL
, 1)) {
9236 __glXSetupVendorRequest(gc
, X_GLXVendorPrivateWithReply
,
9237 X_GLvop_IsProgramNV
, cmdlen
);
9238 (void) memcpy((void *) (pc
+ 0), (void *) (&program
), 4);
9239 retval
= (GLboolean
) __glXReadReply(dpy
, 0, NULL
, GL_FALSE
);
9246 #define X_GLrop_LoadProgramNV 4183
9248 __indirect_glLoadProgramNV(GLenum target
, GLuint id
, GLsizei len
,
9249 const GLubyte
*program
)
9251 __GLXcontext
*const gc
= __glXGetCurrentContext();
9252 const GLuint cmdlen
= 16 + __GLX_PAD(len
);
9254 __glXSetError(gc
, GL_INVALID_VALUE
);
9257 if (__builtin_expect(len
>= 0, 1)) {
9258 emit_header(gc
->pc
, X_GLrop_LoadProgramNV
, cmdlen
);
9259 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&target
), 4);
9260 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&id
), 4);
9261 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&len
), 4);
9262 (void) memcpy((void *) (gc
->pc
+ 16), (void *) (program
), len
);
9264 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
9265 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
9270 #define X_GLrop_ProgramParameters4dvNV 4187
9272 __indirect_glProgramParameters4dvNV(GLenum target
, GLuint index
, GLuint num
,
9273 const GLdouble
* params
)
9275 __GLXcontext
*const gc
= __glXGetCurrentContext();
9276 const GLuint cmdlen
= 16 + __GLX_PAD((num
* 32));
9278 __glXSetError(gc
, GL_INVALID_VALUE
);
9281 if (__builtin_expect(num
>= 0, 1)) {
9282 emit_header(gc
->pc
, X_GLrop_ProgramParameters4dvNV
, cmdlen
);
9283 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&target
), 4);
9284 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&index
), 4);
9285 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&num
), 4);
9286 (void) memcpy((void *) (gc
->pc
+ 16), (void *) (params
), (num
* 32));
9288 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
9289 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
9294 #define X_GLrop_ProgramParameters4fvNV 4186
9296 __indirect_glProgramParameters4fvNV(GLenum target
, GLuint index
, GLuint num
,
9297 const GLfloat
* params
)
9299 __GLXcontext
*const gc
= __glXGetCurrentContext();
9300 const GLuint cmdlen
= 16 + __GLX_PAD((num
* 16));
9302 __glXSetError(gc
, GL_INVALID_VALUE
);
9305 if (__builtin_expect(num
>= 0, 1)) {
9306 emit_header(gc
->pc
, X_GLrop_ProgramParameters4fvNV
, cmdlen
);
9307 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&target
), 4);
9308 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&index
), 4);
9309 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&num
), 4);
9310 (void) memcpy((void *) (gc
->pc
+ 16), (void *) (params
), (num
* 16));
9312 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
9313 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
9318 #define X_GLrop_RequestResidentProgramsNV 4182
9320 __indirect_glRequestResidentProgramsNV(GLsizei n
, const GLuint
* ids
)
9322 __GLXcontext
*const gc
= __glXGetCurrentContext();
9323 const GLuint cmdlen
= 8 + __GLX_PAD((n
* 4));
9325 __glXSetError(gc
, GL_INVALID_VALUE
);
9328 if (__builtin_expect(n
>= 0, 1)) {
9329 emit_header(gc
->pc
, X_GLrop_RequestResidentProgramsNV
, cmdlen
);
9330 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&n
), 4);
9331 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (ids
), (n
* 4));
9333 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
9334 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
9339 #define X_GLrop_TrackMatrixNV 4188
9341 __indirect_glTrackMatrixNV(GLenum target
, GLuint address
, GLenum matrix
,
9344 __GLXcontext
*const gc
= __glXGetCurrentContext();
9345 const GLuint cmdlen
= 20;
9346 emit_header(gc
->pc
, X_GLrop_TrackMatrixNV
, cmdlen
);
9347 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&target
), 4);
9348 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&address
), 4);
9349 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&matrix
), 4);
9350 (void) memcpy((void *) (gc
->pc
+ 16), (void *) (&transform
), 4);
9352 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
9353 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
9357 #define X_GLrop_VertexAttrib1dvNV 4273
9359 __indirect_glVertexAttrib1dNV(GLuint index
, GLdouble x
)
9361 __GLXcontext
*const gc
= __glXGetCurrentContext();
9362 const GLuint cmdlen
= 16;
9363 emit_header(gc
->pc
, X_GLrop_VertexAttrib1dvNV
, cmdlen
);
9364 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&index
), 4);
9365 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&x
), 8);
9367 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
9368 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
9372 #define X_GLrop_VertexAttrib1dvNV 4273
9374 __indirect_glVertexAttrib1dvNV(GLuint index
, const GLdouble
* v
)
9376 __GLXcontext
*const gc
= __glXGetCurrentContext();
9377 const GLuint cmdlen
= 16;
9378 emit_header(gc
->pc
, X_GLrop_VertexAttrib1dvNV
, cmdlen
);
9379 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&index
), 4);
9380 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (v
), 8);
9382 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
9383 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
9387 #define X_GLrop_VertexAttrib1fvNV 4269
9389 __indirect_glVertexAttrib1fNV(GLuint index
, GLfloat x
)
9391 __GLXcontext
*const gc
= __glXGetCurrentContext();
9392 const GLuint cmdlen
= 12;
9393 emit_header(gc
->pc
, X_GLrop_VertexAttrib1fvNV
, cmdlen
);
9394 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&index
), 4);
9395 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&x
), 4);
9397 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
9398 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
9402 #define X_GLrop_VertexAttrib1fvNV 4269
9404 __indirect_glVertexAttrib1fvNV(GLuint index
, const GLfloat
* v
)
9406 __GLXcontext
*const gc
= __glXGetCurrentContext();
9407 const GLuint cmdlen
= 12;
9408 emit_header(gc
->pc
, X_GLrop_VertexAttrib1fvNV
, cmdlen
);
9409 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&index
), 4);
9410 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (v
), 4);
9412 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
9413 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
9417 #define X_GLrop_VertexAttrib1svNV 4265
9419 __indirect_glVertexAttrib1sNV(GLuint index
, GLshort x
)
9421 __GLXcontext
*const gc
= __glXGetCurrentContext();
9422 const GLuint cmdlen
= 12;
9423 emit_header(gc
->pc
, X_GLrop_VertexAttrib1svNV
, cmdlen
);
9424 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&index
), 4);
9425 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&x
), 2);
9427 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
9428 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
9432 #define X_GLrop_VertexAttrib1svNV 4265
9434 __indirect_glVertexAttrib1svNV(GLuint index
, const GLshort
* v
)
9436 __GLXcontext
*const gc
= __glXGetCurrentContext();
9437 const GLuint cmdlen
= 12;
9438 emit_header(gc
->pc
, X_GLrop_VertexAttrib1svNV
, cmdlen
);
9439 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&index
), 4);
9440 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (v
), 2);
9442 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
9443 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
9447 #define X_GLrop_VertexAttrib2dvNV 4274
9449 __indirect_glVertexAttrib2dNV(GLuint index
, GLdouble x
, GLdouble y
)
9451 __GLXcontext
*const gc
= __glXGetCurrentContext();
9452 const GLuint cmdlen
= 24;
9453 emit_header(gc
->pc
, X_GLrop_VertexAttrib2dvNV
, cmdlen
);
9454 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&index
), 4);
9455 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&x
), 8);
9456 (void) memcpy((void *) (gc
->pc
+ 16), (void *) (&y
), 8);
9458 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
9459 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
9463 #define X_GLrop_VertexAttrib2dvNV 4274
9465 __indirect_glVertexAttrib2dvNV(GLuint index
, const GLdouble
* v
)
9467 __GLXcontext
*const gc
= __glXGetCurrentContext();
9468 const GLuint cmdlen
= 24;
9469 emit_header(gc
->pc
, X_GLrop_VertexAttrib2dvNV
, cmdlen
);
9470 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&index
), 4);
9471 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (v
), 16);
9473 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
9474 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
9478 #define X_GLrop_VertexAttrib2fvNV 4270
9480 __indirect_glVertexAttrib2fNV(GLuint index
, GLfloat x
, GLfloat y
)
9482 __GLXcontext
*const gc
= __glXGetCurrentContext();
9483 const GLuint cmdlen
= 16;
9484 emit_header(gc
->pc
, X_GLrop_VertexAttrib2fvNV
, cmdlen
);
9485 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&index
), 4);
9486 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&x
), 4);
9487 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&y
), 4);
9489 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
9490 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
9494 #define X_GLrop_VertexAttrib2fvNV 4270
9496 __indirect_glVertexAttrib2fvNV(GLuint index
, const GLfloat
* v
)
9498 __GLXcontext
*const gc
= __glXGetCurrentContext();
9499 const GLuint cmdlen
= 16;
9500 emit_header(gc
->pc
, X_GLrop_VertexAttrib2fvNV
, cmdlen
);
9501 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&index
), 4);
9502 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (v
), 8);
9504 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
9505 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
9509 #define X_GLrop_VertexAttrib2svNV 4266
9511 __indirect_glVertexAttrib2sNV(GLuint index
, GLshort x
, GLshort y
)
9513 __GLXcontext
*const gc
= __glXGetCurrentContext();
9514 const GLuint cmdlen
= 12;
9515 emit_header(gc
->pc
, X_GLrop_VertexAttrib2svNV
, cmdlen
);
9516 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&index
), 4);
9517 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&x
), 2);
9518 (void) memcpy((void *) (gc
->pc
+ 10), (void *) (&y
), 2);
9520 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
9521 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
9525 #define X_GLrop_VertexAttrib2svNV 4266
9527 __indirect_glVertexAttrib2svNV(GLuint index
, const GLshort
* v
)
9529 __GLXcontext
*const gc
= __glXGetCurrentContext();
9530 const GLuint cmdlen
= 12;
9531 emit_header(gc
->pc
, X_GLrop_VertexAttrib2svNV
, cmdlen
);
9532 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&index
), 4);
9533 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (v
), 4);
9535 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
9536 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
9540 #define X_GLrop_VertexAttrib3dvNV 4275
9542 __indirect_glVertexAttrib3dNV(GLuint index
, GLdouble x
, GLdouble y
,
9545 __GLXcontext
*const gc
= __glXGetCurrentContext();
9546 const GLuint cmdlen
= 32;
9547 emit_header(gc
->pc
, X_GLrop_VertexAttrib3dvNV
, cmdlen
);
9548 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&index
), 4);
9549 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&x
), 8);
9550 (void) memcpy((void *) (gc
->pc
+ 16), (void *) (&y
), 8);
9551 (void) memcpy((void *) (gc
->pc
+ 24), (void *) (&z
), 8);
9553 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
9554 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
9558 #define X_GLrop_VertexAttrib3dvNV 4275
9560 __indirect_glVertexAttrib3dvNV(GLuint index
, const GLdouble
* v
)
9562 __GLXcontext
*const gc
= __glXGetCurrentContext();
9563 const GLuint cmdlen
= 32;
9564 emit_header(gc
->pc
, X_GLrop_VertexAttrib3dvNV
, cmdlen
);
9565 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&index
), 4);
9566 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (v
), 24);
9568 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
9569 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
9573 #define X_GLrop_VertexAttrib3fvNV 4271
9575 __indirect_glVertexAttrib3fNV(GLuint index
, GLfloat x
, GLfloat y
, GLfloat z
)
9577 __GLXcontext
*const gc
= __glXGetCurrentContext();
9578 const GLuint cmdlen
= 20;
9579 emit_header(gc
->pc
, X_GLrop_VertexAttrib3fvNV
, cmdlen
);
9580 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&index
), 4);
9581 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&x
), 4);
9582 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&y
), 4);
9583 (void) memcpy((void *) (gc
->pc
+ 16), (void *) (&z
), 4);
9585 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
9586 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
9590 #define X_GLrop_VertexAttrib3fvNV 4271
9592 __indirect_glVertexAttrib3fvNV(GLuint index
, const GLfloat
* v
)
9594 __GLXcontext
*const gc
= __glXGetCurrentContext();
9595 const GLuint cmdlen
= 20;
9596 emit_header(gc
->pc
, X_GLrop_VertexAttrib3fvNV
, cmdlen
);
9597 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&index
), 4);
9598 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (v
), 12);
9600 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
9601 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
9605 #define X_GLrop_VertexAttrib3svNV 4267
9607 __indirect_glVertexAttrib3sNV(GLuint index
, GLshort x
, GLshort y
, GLshort z
)
9609 __GLXcontext
*const gc
= __glXGetCurrentContext();
9610 const GLuint cmdlen
= 16;
9611 emit_header(gc
->pc
, X_GLrop_VertexAttrib3svNV
, cmdlen
);
9612 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&index
), 4);
9613 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&x
), 2);
9614 (void) memcpy((void *) (gc
->pc
+ 10), (void *) (&y
), 2);
9615 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&z
), 2);
9617 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
9618 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
9622 #define X_GLrop_VertexAttrib3svNV 4267
9624 __indirect_glVertexAttrib3svNV(GLuint index
, const GLshort
* v
)
9626 __GLXcontext
*const gc
= __glXGetCurrentContext();
9627 const GLuint cmdlen
= 16;
9628 emit_header(gc
->pc
, X_GLrop_VertexAttrib3svNV
, cmdlen
);
9629 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&index
), 4);
9630 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (v
), 6);
9632 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
9633 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
9637 #define X_GLrop_VertexAttrib4dvNV 4276
9639 __indirect_glVertexAttrib4dNV(GLuint index
, GLdouble x
, GLdouble y
,
9640 GLdouble z
, GLdouble w
)
9642 __GLXcontext
*const gc
= __glXGetCurrentContext();
9643 const GLuint cmdlen
= 40;
9644 emit_header(gc
->pc
, X_GLrop_VertexAttrib4dvNV
, cmdlen
);
9645 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&index
), 4);
9646 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&x
), 8);
9647 (void) memcpy((void *) (gc
->pc
+ 16), (void *) (&y
), 8);
9648 (void) memcpy((void *) (gc
->pc
+ 24), (void *) (&z
), 8);
9649 (void) memcpy((void *) (gc
->pc
+ 32), (void *) (&w
), 8);
9651 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
9652 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
9656 #define X_GLrop_VertexAttrib4dvNV 4276
9658 __indirect_glVertexAttrib4dvNV(GLuint index
, const GLdouble
* v
)
9660 __GLXcontext
*const gc
= __glXGetCurrentContext();
9661 const GLuint cmdlen
= 40;
9662 emit_header(gc
->pc
, X_GLrop_VertexAttrib4dvNV
, cmdlen
);
9663 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&index
), 4);
9664 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (v
), 32);
9666 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
9667 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
9671 #define X_GLrop_VertexAttrib4fvNV 4272
9673 __indirect_glVertexAttrib4fNV(GLuint index
, GLfloat x
, GLfloat y
, GLfloat z
,
9676 __GLXcontext
*const gc
= __glXGetCurrentContext();
9677 const GLuint cmdlen
= 24;
9678 emit_header(gc
->pc
, X_GLrop_VertexAttrib4fvNV
, cmdlen
);
9679 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&index
), 4);
9680 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&x
), 4);
9681 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&y
), 4);
9682 (void) memcpy((void *) (gc
->pc
+ 16), (void *) (&z
), 4);
9683 (void) memcpy((void *) (gc
->pc
+ 20), (void *) (&w
), 4);
9685 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
9686 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
9690 #define X_GLrop_VertexAttrib4fvNV 4272
9692 __indirect_glVertexAttrib4fvNV(GLuint index
, const GLfloat
* v
)
9694 __GLXcontext
*const gc
= __glXGetCurrentContext();
9695 const GLuint cmdlen
= 24;
9696 emit_header(gc
->pc
, X_GLrop_VertexAttrib4fvNV
, cmdlen
);
9697 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&index
), 4);
9698 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (v
), 16);
9700 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
9701 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
9705 #define X_GLrop_VertexAttrib4svNV 4268
9707 __indirect_glVertexAttrib4sNV(GLuint index
, GLshort x
, GLshort y
, GLshort z
,
9710 __GLXcontext
*const gc
= __glXGetCurrentContext();
9711 const GLuint cmdlen
= 16;
9712 emit_header(gc
->pc
, X_GLrop_VertexAttrib4svNV
, cmdlen
);
9713 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&index
), 4);
9714 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&x
), 2);
9715 (void) memcpy((void *) (gc
->pc
+ 10), (void *) (&y
), 2);
9716 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&z
), 2);
9717 (void) memcpy((void *) (gc
->pc
+ 14), (void *) (&w
), 2);
9719 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
9720 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
9724 #define X_GLrop_VertexAttrib4svNV 4268
9726 __indirect_glVertexAttrib4svNV(GLuint index
, const GLshort
* v
)
9728 __GLXcontext
*const gc
= __glXGetCurrentContext();
9729 const GLuint cmdlen
= 16;
9730 emit_header(gc
->pc
, X_GLrop_VertexAttrib4svNV
, cmdlen
);
9731 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&index
), 4);
9732 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (v
), 8);
9734 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
9735 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
9739 #define X_GLrop_VertexAttrib4ubvNV 4277
9741 __indirect_glVertexAttrib4ubNV(GLuint index
, GLubyte x
, GLubyte y
, GLubyte z
,
9744 __GLXcontext
*const gc
= __glXGetCurrentContext();
9745 const GLuint cmdlen
= 12;
9746 emit_header(gc
->pc
, X_GLrop_VertexAttrib4ubvNV
, cmdlen
);
9747 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&index
), 4);
9748 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&x
), 1);
9749 (void) memcpy((void *) (gc
->pc
+ 9), (void *) (&y
), 1);
9750 (void) memcpy((void *) (gc
->pc
+ 10), (void *) (&z
), 1);
9751 (void) memcpy((void *) (gc
->pc
+ 11), (void *) (&w
), 1);
9753 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
9754 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
9758 #define X_GLrop_VertexAttrib4ubvNV 4277
9760 __indirect_glVertexAttrib4ubvNV(GLuint index
, const GLubyte
*v
)
9762 __GLXcontext
*const gc
= __glXGetCurrentContext();
9763 const GLuint cmdlen
= 12;
9764 emit_header(gc
->pc
, X_GLrop_VertexAttrib4ubvNV
, cmdlen
);
9765 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&index
), 4);
9766 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (v
), 4);
9768 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
9769 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
9773 #define X_GLrop_VertexAttribs1dvNV 4210
9775 __indirect_glVertexAttribs1dvNV(GLuint index
, GLsizei n
, const GLdouble
* v
)
9777 __GLXcontext
*const gc
= __glXGetCurrentContext();
9778 const GLuint cmdlen
= 12 + __GLX_PAD((n
* 8));
9780 __glXSetError(gc
, GL_INVALID_VALUE
);
9783 if (__builtin_expect(n
>= 0, 1)) {
9784 emit_header(gc
->pc
, X_GLrop_VertexAttribs1dvNV
, cmdlen
);
9785 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&index
), 4);
9786 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&n
), 4);
9787 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (v
), (n
* 8));
9789 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
9790 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
9795 #define X_GLrop_VertexAttribs1fvNV 4206
9797 __indirect_glVertexAttribs1fvNV(GLuint index
, GLsizei n
, const GLfloat
* v
)
9799 __GLXcontext
*const gc
= __glXGetCurrentContext();
9800 const GLuint cmdlen
= 12 + __GLX_PAD((n
* 4));
9802 __glXSetError(gc
, GL_INVALID_VALUE
);
9805 if (__builtin_expect(n
>= 0, 1)) {
9806 emit_header(gc
->pc
, X_GLrop_VertexAttribs1fvNV
, cmdlen
);
9807 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&index
), 4);
9808 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&n
), 4);
9809 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (v
), (n
* 4));
9811 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
9812 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
9817 #define X_GLrop_VertexAttribs1svNV 4202
9819 __indirect_glVertexAttribs1svNV(GLuint index
, GLsizei n
, const GLshort
* v
)
9821 __GLXcontext
*const gc
= __glXGetCurrentContext();
9822 const GLuint cmdlen
= 12 + __GLX_PAD((n
* 2));
9824 __glXSetError(gc
, GL_INVALID_VALUE
);
9827 if (__builtin_expect(n
>= 0, 1)) {
9828 emit_header(gc
->pc
, X_GLrop_VertexAttribs1svNV
, cmdlen
);
9829 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&index
), 4);
9830 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&n
), 4);
9831 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (v
), (n
* 2));
9833 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
9834 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
9839 #define X_GLrop_VertexAttribs2dvNV 4211
9841 __indirect_glVertexAttribs2dvNV(GLuint index
, GLsizei n
, const GLdouble
* v
)
9843 __GLXcontext
*const gc
= __glXGetCurrentContext();
9844 const GLuint cmdlen
= 12 + __GLX_PAD((n
* 16));
9846 __glXSetError(gc
, GL_INVALID_VALUE
);
9849 if (__builtin_expect(n
>= 0, 1)) {
9850 emit_header(gc
->pc
, X_GLrop_VertexAttribs2dvNV
, cmdlen
);
9851 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&index
), 4);
9852 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&n
), 4);
9853 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (v
), (n
* 16));
9855 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
9856 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
9861 #define X_GLrop_VertexAttribs2fvNV 4207
9863 __indirect_glVertexAttribs2fvNV(GLuint index
, GLsizei n
, const GLfloat
* v
)
9865 __GLXcontext
*const gc
= __glXGetCurrentContext();
9866 const GLuint cmdlen
= 12 + __GLX_PAD((n
* 8));
9868 __glXSetError(gc
, GL_INVALID_VALUE
);
9871 if (__builtin_expect(n
>= 0, 1)) {
9872 emit_header(gc
->pc
, X_GLrop_VertexAttribs2fvNV
, cmdlen
);
9873 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&index
), 4);
9874 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&n
), 4);
9875 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (v
), (n
* 8));
9877 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
9878 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
9883 #define X_GLrop_VertexAttribs2svNV 4203
9885 __indirect_glVertexAttribs2svNV(GLuint index
, GLsizei n
, const GLshort
* v
)
9887 __GLXcontext
*const gc
= __glXGetCurrentContext();
9888 const GLuint cmdlen
= 12 + __GLX_PAD((n
* 4));
9890 __glXSetError(gc
, GL_INVALID_VALUE
);
9893 if (__builtin_expect(n
>= 0, 1)) {
9894 emit_header(gc
->pc
, X_GLrop_VertexAttribs2svNV
, cmdlen
);
9895 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&index
), 4);
9896 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&n
), 4);
9897 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (v
), (n
* 4));
9899 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
9900 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
9905 #define X_GLrop_VertexAttribs3dvNV 4212
9907 __indirect_glVertexAttribs3dvNV(GLuint index
, GLsizei n
, const GLdouble
* v
)
9909 __GLXcontext
*const gc
= __glXGetCurrentContext();
9910 const GLuint cmdlen
= 12 + __GLX_PAD((n
* 24));
9912 __glXSetError(gc
, GL_INVALID_VALUE
);
9915 if (__builtin_expect(n
>= 0, 1)) {
9916 emit_header(gc
->pc
, X_GLrop_VertexAttribs3dvNV
, cmdlen
);
9917 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&index
), 4);
9918 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&n
), 4);
9919 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (v
), (n
* 24));
9921 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
9922 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
9927 #define X_GLrop_VertexAttribs3fvNV 4208
9929 __indirect_glVertexAttribs3fvNV(GLuint index
, GLsizei n
, const GLfloat
* v
)
9931 __GLXcontext
*const gc
= __glXGetCurrentContext();
9932 const GLuint cmdlen
= 12 + __GLX_PAD((n
* 12));
9934 __glXSetError(gc
, GL_INVALID_VALUE
);
9937 if (__builtin_expect(n
>= 0, 1)) {
9938 emit_header(gc
->pc
, X_GLrop_VertexAttribs3fvNV
, cmdlen
);
9939 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&index
), 4);
9940 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&n
), 4);
9941 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (v
), (n
* 12));
9943 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
9944 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
9949 #define X_GLrop_VertexAttribs3svNV 4204
9951 __indirect_glVertexAttribs3svNV(GLuint index
, GLsizei n
, const GLshort
* v
)
9953 __GLXcontext
*const gc
= __glXGetCurrentContext();
9954 const GLuint cmdlen
= 12 + __GLX_PAD((n
* 6));
9956 __glXSetError(gc
, GL_INVALID_VALUE
);
9959 if (__builtin_expect(n
>= 0, 1)) {
9960 emit_header(gc
->pc
, X_GLrop_VertexAttribs3svNV
, cmdlen
);
9961 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&index
), 4);
9962 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&n
), 4);
9963 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (v
), (n
* 6));
9965 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
9966 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
9971 #define X_GLrop_VertexAttribs4dvNV 4213
9973 __indirect_glVertexAttribs4dvNV(GLuint index
, GLsizei n
, const GLdouble
* v
)
9975 __GLXcontext
*const gc
= __glXGetCurrentContext();
9976 const GLuint cmdlen
= 12 + __GLX_PAD((n
* 32));
9978 __glXSetError(gc
, GL_INVALID_VALUE
);
9981 if (__builtin_expect(n
>= 0, 1)) {
9982 emit_header(gc
->pc
, X_GLrop_VertexAttribs4dvNV
, cmdlen
);
9983 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&index
), 4);
9984 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&n
), 4);
9985 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (v
), (n
* 32));
9987 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
9988 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
9993 #define X_GLrop_VertexAttribs4fvNV 4209
9995 __indirect_glVertexAttribs4fvNV(GLuint index
, GLsizei n
, const GLfloat
* v
)
9997 __GLXcontext
*const gc
= __glXGetCurrentContext();
9998 const GLuint cmdlen
= 12 + __GLX_PAD((n
* 16));
10000 __glXSetError(gc
, GL_INVALID_VALUE
);
10003 if (__builtin_expect(n
>= 0, 1)) {
10004 emit_header(gc
->pc
, X_GLrop_VertexAttribs4fvNV
, cmdlen
);
10005 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&index
), 4);
10006 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&n
), 4);
10007 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (v
), (n
* 16));
10009 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
10010 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
10015 #define X_GLrop_VertexAttribs4svNV 4205
10017 __indirect_glVertexAttribs4svNV(GLuint index
, GLsizei n
, const GLshort
* v
)
10019 __GLXcontext
*const gc
= __glXGetCurrentContext();
10020 const GLuint cmdlen
= 12 + __GLX_PAD((n
* 8));
10022 __glXSetError(gc
, GL_INVALID_VALUE
);
10025 if (__builtin_expect(n
>= 0, 1)) {
10026 emit_header(gc
->pc
, X_GLrop_VertexAttribs4svNV
, cmdlen
);
10027 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&index
), 4);
10028 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&n
), 4);
10029 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (v
), (n
* 8));
10031 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
10032 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
10037 #define X_GLrop_VertexAttribs4ubvNV 4214
10039 __indirect_glVertexAttribs4ubvNV(GLuint index
, GLsizei n
, const GLubyte
*v
)
10041 __GLXcontext
*const gc
= __glXGetCurrentContext();
10042 const GLuint cmdlen
= 12 + __GLX_PAD((n
* 4));
10044 __glXSetError(gc
, GL_INVALID_VALUE
);
10047 if (__builtin_expect(n
>= 0, 1)) {
10048 emit_header(gc
->pc
, X_GLrop_VertexAttribs4ubvNV
, cmdlen
);
10049 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&index
), 4);
10050 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&n
), 4);
10051 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (v
), (n
* 4));
10053 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
10054 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
10059 #define X_GLrop_PointParameteriNV 4221
10061 __indirect_glPointParameteriNV(GLenum pname
, GLint param
)
10063 __GLXcontext
*const gc
= __glXGetCurrentContext();
10064 const GLuint cmdlen
= 12;
10065 emit_header(gc
->pc
, X_GLrop_PointParameteriNV
, cmdlen
);
10066 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&pname
), 4);
10067 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (¶m
), 4);
10069 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
10070 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
10074 #define X_GLrop_PointParameterivNV 4222
10076 __indirect_glPointParameterivNV(GLenum pname
, const GLint
* params
)
10078 __GLXcontext
*const gc
= __glXGetCurrentContext();
10079 const GLuint compsize
= __glPointParameterivNV_size(pname
);
10080 const GLuint cmdlen
= 8 + __GLX_PAD((compsize
* 4));
10081 emit_header(gc
->pc
, X_GLrop_PointParameterivNV
, cmdlen
);
10082 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&pname
), 4);
10083 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (params
), (compsize
* 4));
10085 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
10086 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
10090 #define X_GLrop_ActiveStencilFaceEXT 4220
10092 __indirect_glActiveStencilFaceEXT(GLenum face
)
10094 __GLXcontext
*const gc
= __glXGetCurrentContext();
10095 const GLuint cmdlen
= 8;
10096 emit_header(gc
->pc
, X_GLrop_ActiveStencilFaceEXT
, cmdlen
);
10097 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&face
), 4);
10099 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
10100 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
10104 #define X_GLvop_GetProgramNamedParameterdvNV 1311
10106 __indirect_glGetProgramNamedParameterdvNV(GLuint id
, GLsizei len
,
10107 const GLubyte
*name
,
10110 __GLXcontext
*const gc
= __glXGetCurrentContext();
10111 Display
*const dpy
= gc
->currentDpy
;
10112 const GLuint cmdlen
= 8 + __GLX_PAD(len
);
10114 __glXSetError(gc
, GL_INVALID_VALUE
);
10117 if (__builtin_expect((len
>= 0) && (dpy
!= NULL
), 1)) {
10118 GLubyte
const *pc
=
10119 __glXSetupVendorRequest(gc
, X_GLXVendorPrivateWithReply
,
10120 X_GLvop_GetProgramNamedParameterdvNV
,
10122 (void) memcpy((void *) (pc
+ 0), (void *) (&id
), 4);
10123 (void) memcpy((void *) (pc
+ 4), (void *) (&len
), 4);
10124 (void) memcpy((void *) (pc
+ 8), (void *) (name
), len
);
10125 (void) __glXReadReply(dpy
, 8, params
, GL_TRUE
);
10126 UnlockDisplay(dpy
);
10132 #define X_GLvop_GetProgramNamedParameterfvNV 1310
10134 __indirect_glGetProgramNamedParameterfvNV(GLuint id
, GLsizei len
,
10135 const GLubyte
*name
,
10138 __GLXcontext
*const gc
= __glXGetCurrentContext();
10139 Display
*const dpy
= gc
->currentDpy
;
10140 const GLuint cmdlen
= 8 + __GLX_PAD(len
);
10142 __glXSetError(gc
, GL_INVALID_VALUE
);
10145 if (__builtin_expect((len
>= 0) && (dpy
!= NULL
), 1)) {
10146 GLubyte
const *pc
=
10147 __glXSetupVendorRequest(gc
, X_GLXVendorPrivateWithReply
,
10148 X_GLvop_GetProgramNamedParameterfvNV
,
10150 (void) memcpy((void *) (pc
+ 0), (void *) (&id
), 4);
10151 (void) memcpy((void *) (pc
+ 4), (void *) (&len
), 4);
10152 (void) memcpy((void *) (pc
+ 8), (void *) (name
), len
);
10153 (void) __glXReadReply(dpy
, 4, params
, GL_TRUE
);
10154 UnlockDisplay(dpy
);
10160 #define X_GLrop_ProgramNamedParameter4dvNV 4219
10162 __indirect_glProgramNamedParameter4dNV(GLuint id
, GLsizei len
,
10163 const GLubyte
*name
, GLdouble x
,
10164 GLdouble y
, GLdouble z
, GLdouble w
)
10166 __GLXcontext
*const gc
= __glXGetCurrentContext();
10167 const GLuint cmdlen
= 44 + __GLX_PAD(len
);
10169 __glXSetError(gc
, GL_INVALID_VALUE
);
10172 if (__builtin_expect(len
>= 0, 1)) {
10173 emit_header(gc
->pc
, X_GLrop_ProgramNamedParameter4dvNV
, cmdlen
);
10174 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&x
), 8);
10175 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&y
), 8);
10176 (void) memcpy((void *) (gc
->pc
+ 20), (void *) (&z
), 8);
10177 (void) memcpy((void *) (gc
->pc
+ 28), (void *) (&w
), 8);
10178 (void) memcpy((void *) (gc
->pc
+ 36), (void *) (&id
), 4);
10179 (void) memcpy((void *) (gc
->pc
+ 40), (void *) (&len
), 4);
10180 (void) memcpy((void *) (gc
->pc
+ 44), (void *) (name
), len
);
10182 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
10183 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
10188 #define X_GLrop_ProgramNamedParameter4dvNV 4219
10190 __indirect_glProgramNamedParameter4dvNV(GLuint id
, GLsizei len
,
10191 const GLubyte
*name
,
10192 const GLdouble
* v
)
10194 __GLXcontext
*const gc
= __glXGetCurrentContext();
10195 const GLuint cmdlen
= 44 + __GLX_PAD(len
);
10197 __glXSetError(gc
, GL_INVALID_VALUE
);
10200 if (__builtin_expect(len
>= 0, 1)) {
10201 emit_header(gc
->pc
, X_GLrop_ProgramNamedParameter4dvNV
, cmdlen
);
10202 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (v
), 32);
10203 (void) memcpy((void *) (gc
->pc
+ 36), (void *) (&id
), 4);
10204 (void) memcpy((void *) (gc
->pc
+ 40), (void *) (&len
), 4);
10205 (void) memcpy((void *) (gc
->pc
+ 44), (void *) (name
), len
);
10207 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
10208 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
10213 #define X_GLrop_ProgramNamedParameter4fvNV 4218
10215 __indirect_glProgramNamedParameter4fNV(GLuint id
, GLsizei len
,
10216 const GLubyte
*name
, GLfloat x
,
10217 GLfloat y
, GLfloat z
, GLfloat w
)
10219 __GLXcontext
*const gc
= __glXGetCurrentContext();
10220 const GLuint cmdlen
= 28 + __GLX_PAD(len
);
10222 __glXSetError(gc
, GL_INVALID_VALUE
);
10225 if (__builtin_expect(len
>= 0, 1)) {
10226 emit_header(gc
->pc
, X_GLrop_ProgramNamedParameter4fvNV
, cmdlen
);
10227 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&id
), 4);
10228 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&len
), 4);
10229 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&x
), 4);
10230 (void) memcpy((void *) (gc
->pc
+ 16), (void *) (&y
), 4);
10231 (void) memcpy((void *) (gc
->pc
+ 20), (void *) (&z
), 4);
10232 (void) memcpy((void *) (gc
->pc
+ 24), (void *) (&w
), 4);
10233 (void) memcpy((void *) (gc
->pc
+ 28), (void *) (name
), len
);
10235 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
10236 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
10241 #define X_GLrop_ProgramNamedParameter4fvNV 4218
10243 __indirect_glProgramNamedParameter4fvNV(GLuint id
, GLsizei len
,
10244 const GLubyte
*name
,
10247 __GLXcontext
*const gc
= __glXGetCurrentContext();
10248 const GLuint cmdlen
= 28 + __GLX_PAD(len
);
10250 __glXSetError(gc
, GL_INVALID_VALUE
);
10253 if (__builtin_expect(len
>= 0, 1)) {
10254 emit_header(gc
->pc
, X_GLrop_ProgramNamedParameter4fvNV
, cmdlen
);
10255 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&id
), 4);
10256 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&len
), 4);
10257 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (v
), 16);
10258 (void) memcpy((void *) (gc
->pc
+ 28), (void *) (name
), len
);
10260 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
10261 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
10266 #define X_GLrop_BlendEquationSeparateEXT 4228
10268 __indirect_glBlendEquationSeparateEXT(GLenum modeRGB
, GLenum modeA
)
10270 __GLXcontext
*const gc
= __glXGetCurrentContext();
10271 const GLuint cmdlen
= 12;
10272 emit_header(gc
->pc
, X_GLrop_BlendEquationSeparateEXT
, cmdlen
);
10273 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&modeRGB
), 4);
10274 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&modeA
), 4);
10276 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
10277 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
10281 #define X_GLrop_BindFramebufferEXT 4319
10283 __indirect_glBindFramebufferEXT(GLenum target
, GLuint framebuffer
)
10285 __GLXcontext
*const gc
= __glXGetCurrentContext();
10286 const GLuint cmdlen
= 12;
10287 emit_header(gc
->pc
, X_GLrop_BindFramebufferEXT
, cmdlen
);
10288 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&target
), 4);
10289 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&framebuffer
), 4);
10291 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
10292 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
10296 #define X_GLrop_BindRenderbufferEXT 4316
10298 __indirect_glBindRenderbufferEXT(GLenum target
, GLuint renderbuffer
)
10300 __GLXcontext
*const gc
= __glXGetCurrentContext();
10301 const GLuint cmdlen
= 12;
10302 emit_header(gc
->pc
, X_GLrop_BindRenderbufferEXT
, cmdlen
);
10303 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&target
), 4);
10304 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&renderbuffer
), 4);
10306 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
10307 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
10311 #define X_GLvop_CheckFramebufferStatusEXT 1427
10313 __indirect_glCheckFramebufferStatusEXT(GLenum target
)
10315 __GLXcontext
*const gc
= __glXGetCurrentContext();
10316 Display
*const dpy
= gc
->currentDpy
;
10317 GLenum retval
= (GLenum
) 0;
10318 const GLuint cmdlen
= 4;
10319 if (__builtin_expect(dpy
!= NULL
, 1)) {
10320 GLubyte
const *pc
=
10321 __glXSetupVendorRequest(gc
, X_GLXVendorPrivateWithReply
,
10322 X_GLvop_CheckFramebufferStatusEXT
,
10324 (void) memcpy((void *) (pc
+ 0), (void *) (&target
), 4);
10325 retval
= (GLenum
) __glXReadReply(dpy
, 0, NULL
, GL_FALSE
);
10326 UnlockDisplay(dpy
);
10332 #define X_GLrop_DeleteFramebuffersEXT 4320
10334 __indirect_glDeleteFramebuffersEXT(GLsizei n
, const GLuint
* framebuffers
)
10336 __GLXcontext
*const gc
= __glXGetCurrentContext();
10337 const GLuint cmdlen
= 8 + __GLX_PAD((n
* 4));
10339 __glXSetError(gc
, GL_INVALID_VALUE
);
10342 if (__builtin_expect(n
>= 0, 1)) {
10343 emit_header(gc
->pc
, X_GLrop_DeleteFramebuffersEXT
, cmdlen
);
10344 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&n
), 4);
10345 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (framebuffers
),
10348 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
10349 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
10354 #define X_GLrop_DeleteRenderbuffersEXT 4317
10356 __indirect_glDeleteRenderbuffersEXT(GLsizei n
, const GLuint
* renderbuffers
)
10358 __GLXcontext
*const gc
= __glXGetCurrentContext();
10359 const GLuint cmdlen
= 8 + __GLX_PAD((n
* 4));
10361 __glXSetError(gc
, GL_INVALID_VALUE
);
10364 if (__builtin_expect(n
>= 0, 1)) {
10365 emit_header(gc
->pc
, X_GLrop_DeleteRenderbuffersEXT
, cmdlen
);
10366 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&n
), 4);
10367 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (renderbuffers
),
10370 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
10371 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
10376 #define X_GLrop_FramebufferRenderbufferEXT 4324
10378 __indirect_glFramebufferRenderbufferEXT(GLenum target
, GLenum attachment
,
10379 GLenum renderbuffertarget
,
10380 GLuint renderbuffer
)
10382 __GLXcontext
*const gc
= __glXGetCurrentContext();
10383 const GLuint cmdlen
= 20;
10384 emit_header(gc
->pc
, X_GLrop_FramebufferRenderbufferEXT
, cmdlen
);
10385 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&target
), 4);
10386 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&attachment
), 4);
10387 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&renderbuffertarget
), 4);
10388 (void) memcpy((void *) (gc
->pc
+ 16), (void *) (&renderbuffer
), 4);
10390 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
10391 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
10395 #define X_GLrop_FramebufferTexture1DEXT 4321
10397 __indirect_glFramebufferTexture1DEXT(GLenum target
, GLenum attachment
,
10398 GLenum textarget
, GLuint texture
,
10401 __GLXcontext
*const gc
= __glXGetCurrentContext();
10402 const GLuint cmdlen
= 24;
10403 emit_header(gc
->pc
, X_GLrop_FramebufferTexture1DEXT
, cmdlen
);
10404 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&target
), 4);
10405 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&attachment
), 4);
10406 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&textarget
), 4);
10407 (void) memcpy((void *) (gc
->pc
+ 16), (void *) (&texture
), 4);
10408 (void) memcpy((void *) (gc
->pc
+ 20), (void *) (&level
), 4);
10410 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
10411 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
10415 #define X_GLrop_FramebufferTexture2DEXT 4322
10417 __indirect_glFramebufferTexture2DEXT(GLenum target
, GLenum attachment
,
10418 GLenum textarget
, GLuint texture
,
10421 __GLXcontext
*const gc
= __glXGetCurrentContext();
10422 const GLuint cmdlen
= 24;
10423 emit_header(gc
->pc
, X_GLrop_FramebufferTexture2DEXT
, cmdlen
);
10424 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&target
), 4);
10425 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&attachment
), 4);
10426 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&textarget
), 4);
10427 (void) memcpy((void *) (gc
->pc
+ 16), (void *) (&texture
), 4);
10428 (void) memcpy((void *) (gc
->pc
+ 20), (void *) (&level
), 4);
10430 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
10431 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
10435 #define X_GLrop_FramebufferTexture3DEXT 4323
10437 __indirect_glFramebufferTexture3DEXT(GLenum target
, GLenum attachment
,
10438 GLenum textarget
, GLuint texture
,
10439 GLint level
, GLint zoffset
)
10441 __GLXcontext
*const gc
= __glXGetCurrentContext();
10442 const GLuint cmdlen
= 28;
10443 emit_header(gc
->pc
, X_GLrop_FramebufferTexture3DEXT
, cmdlen
);
10444 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&target
), 4);
10445 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&attachment
), 4);
10446 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&textarget
), 4);
10447 (void) memcpy((void *) (gc
->pc
+ 16), (void *) (&texture
), 4);
10448 (void) memcpy((void *) (gc
->pc
+ 20), (void *) (&level
), 4);
10449 (void) memcpy((void *) (gc
->pc
+ 24), (void *) (&zoffset
), 4);
10451 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
10452 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
10456 #define X_GLvop_GenFramebuffersEXT 1426
10458 __indirect_glGenFramebuffersEXT(GLsizei n
, GLuint
* framebuffers
)
10460 __GLXcontext
*const gc
= __glXGetCurrentContext();
10461 Display
*const dpy
= gc
->currentDpy
;
10462 const GLuint cmdlen
= 4;
10464 __glXSetError(gc
, GL_INVALID_VALUE
);
10467 if (__builtin_expect((n
>= 0) && (dpy
!= NULL
), 1)) {
10468 GLubyte
const *pc
=
10469 __glXSetupVendorRequest(gc
, X_GLXVendorPrivateWithReply
,
10470 X_GLvop_GenFramebuffersEXT
, cmdlen
);
10471 (void) memcpy((void *) (pc
+ 0), (void *) (&n
), 4);
10472 (void) __glXReadReply(dpy
, 4, framebuffers
, GL_TRUE
);
10473 UnlockDisplay(dpy
);
10479 #define X_GLvop_GenRenderbuffersEXT 1423
10481 __indirect_glGenRenderbuffersEXT(GLsizei n
, GLuint
* renderbuffers
)
10483 __GLXcontext
*const gc
= __glXGetCurrentContext();
10484 Display
*const dpy
= gc
->currentDpy
;
10485 const GLuint cmdlen
= 4;
10487 __glXSetError(gc
, GL_INVALID_VALUE
);
10490 if (__builtin_expect((n
>= 0) && (dpy
!= NULL
), 1)) {
10491 GLubyte
const *pc
=
10492 __glXSetupVendorRequest(gc
, X_GLXVendorPrivateWithReply
,
10493 X_GLvop_GenRenderbuffersEXT
, cmdlen
);
10494 (void) memcpy((void *) (pc
+ 0), (void *) (&n
), 4);
10495 (void) __glXReadReply(dpy
, 4, renderbuffers
, GL_TRUE
);
10496 UnlockDisplay(dpy
);
10502 #define X_GLrop_GenerateMipmapEXT 4325
10504 __indirect_glGenerateMipmapEXT(GLenum target
)
10506 __GLXcontext
*const gc
= __glXGetCurrentContext();
10507 const GLuint cmdlen
= 8;
10508 emit_header(gc
->pc
, X_GLrop_GenerateMipmapEXT
, cmdlen
);
10509 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&target
), 4);
10511 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
10512 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
10516 #define X_GLvop_GetFramebufferAttachmentParameterivEXT 1428
10518 __indirect_glGetFramebufferAttachmentParameterivEXT(GLenum target
,
10523 __GLXcontext
*const gc
= __glXGetCurrentContext();
10524 Display
*const dpy
= gc
->currentDpy
;
10525 const GLuint cmdlen
= 12;
10526 if (__builtin_expect(dpy
!= NULL
, 1)) {
10527 GLubyte
const *pc
=
10528 __glXSetupVendorRequest(gc
, X_GLXVendorPrivateWithReply
,
10529 X_GLvop_GetFramebufferAttachmentParameterivEXT
,
10531 (void) memcpy((void *) (pc
+ 0), (void *) (&target
), 4);
10532 (void) memcpy((void *) (pc
+ 4), (void *) (&attachment
), 4);
10533 (void) memcpy((void *) (pc
+ 8), (void *) (&pname
), 4);
10534 (void) __glXReadReply(dpy
, 4, params
, GL_FALSE
);
10535 UnlockDisplay(dpy
);
10541 #define X_GLvop_GetRenderbufferParameterivEXT 1424
10543 __indirect_glGetRenderbufferParameterivEXT(GLenum target
, GLenum pname
,
10546 __GLXcontext
*const gc
= __glXGetCurrentContext();
10547 Display
*const dpy
= gc
->currentDpy
;
10548 const GLuint cmdlen
= 8;
10549 if (__builtin_expect(dpy
!= NULL
, 1)) {
10550 GLubyte
const *pc
=
10551 __glXSetupVendorRequest(gc
, X_GLXVendorPrivateWithReply
,
10552 X_GLvop_GetRenderbufferParameterivEXT
,
10554 (void) memcpy((void *) (pc
+ 0), (void *) (&target
), 4);
10555 (void) memcpy((void *) (pc
+ 4), (void *) (&pname
), 4);
10556 (void) __glXReadReply(dpy
, 4, params
, GL_FALSE
);
10557 UnlockDisplay(dpy
);
10563 #define X_GLvop_IsFramebufferEXT 1425
10565 __indirect_glIsFramebufferEXT(GLuint framebuffer
)
10567 __GLXcontext
*const gc
= __glXGetCurrentContext();
10568 Display
*const dpy
= gc
->currentDpy
;
10569 GLboolean retval
= (GLboolean
) 0;
10570 const GLuint cmdlen
= 4;
10571 if (__builtin_expect(dpy
!= NULL
, 1)) {
10572 GLubyte
const *pc
=
10573 __glXSetupVendorRequest(gc
, X_GLXVendorPrivateWithReply
,
10574 X_GLvop_IsFramebufferEXT
, cmdlen
);
10575 (void) memcpy((void *) (pc
+ 0), (void *) (&framebuffer
), 4);
10576 retval
= (GLboolean
) __glXReadReply(dpy
, 0, NULL
, GL_FALSE
);
10577 UnlockDisplay(dpy
);
10583 #define X_GLvop_IsRenderbufferEXT 1422
10585 __indirect_glIsRenderbufferEXT(GLuint renderbuffer
)
10587 __GLXcontext
*const gc
= __glXGetCurrentContext();
10588 Display
*const dpy
= gc
->currentDpy
;
10589 GLboolean retval
= (GLboolean
) 0;
10590 const GLuint cmdlen
= 4;
10591 if (__builtin_expect(dpy
!= NULL
, 1)) {
10592 GLubyte
const *pc
=
10593 __glXSetupVendorRequest(gc
, X_GLXVendorPrivateWithReply
,
10594 X_GLvop_IsRenderbufferEXT
, cmdlen
);
10595 (void) memcpy((void *) (pc
+ 0), (void *) (&renderbuffer
), 4);
10596 retval
= (GLboolean
) __glXReadReply(dpy
, 0, NULL
, GL_FALSE
);
10597 UnlockDisplay(dpy
);
10603 #define X_GLrop_RenderbufferStorageEXT 4318
10605 __indirect_glRenderbufferStorageEXT(GLenum target
, GLenum internalformat
,
10606 GLsizei width
, GLsizei height
)
10608 __GLXcontext
*const gc
= __glXGetCurrentContext();
10609 const GLuint cmdlen
= 20;
10610 emit_header(gc
->pc
, X_GLrop_RenderbufferStorageEXT
, cmdlen
);
10611 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&target
), 4);
10612 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&internalformat
), 4);
10613 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&width
), 4);
10614 (void) memcpy((void *) (gc
->pc
+ 16), (void *) (&height
), 4);
10616 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
10617 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
10621 #define X_GLrop_BlitFramebufferEXT 4330
10623 __indirect_glBlitFramebufferEXT(GLint srcX0
, GLint srcY0
, GLint srcX1
,
10624 GLint srcY1
, GLint dstX0
, GLint dstY0
,
10625 GLint dstX1
, GLint dstY1
, GLbitfield mask
,
10628 __GLXcontext
*const gc
= __glXGetCurrentContext();
10629 const GLuint cmdlen
= 44;
10630 emit_header(gc
->pc
, X_GLrop_BlitFramebufferEXT
, cmdlen
);
10631 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&srcX0
), 4);
10632 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&srcY0
), 4);
10633 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&srcX1
), 4);
10634 (void) memcpy((void *) (gc
->pc
+ 16), (void *) (&srcY1
), 4);
10635 (void) memcpy((void *) (gc
->pc
+ 20), (void *) (&dstX0
), 4);
10636 (void) memcpy((void *) (gc
->pc
+ 24), (void *) (&dstY0
), 4);
10637 (void) memcpy((void *) (gc
->pc
+ 28), (void *) (&dstX1
), 4);
10638 (void) memcpy((void *) (gc
->pc
+ 32), (void *) (&dstY1
), 4);
10639 (void) memcpy((void *) (gc
->pc
+ 36), (void *) (&mask
), 4);
10640 (void) memcpy((void *) (gc
->pc
+ 40), (void *) (&filter
), 4);
10642 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
10643 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
10647 #define X_GLrop_FramebufferTextureLayerEXT 237
10649 __indirect_glFramebufferTextureLayerEXT(GLenum target
, GLenum attachment
,
10650 GLuint texture
, GLint level
,
10653 __GLXcontext
*const gc
= __glXGetCurrentContext();
10654 const GLuint cmdlen
= 24;
10655 emit_header(gc
->pc
, X_GLrop_FramebufferTextureLayerEXT
, cmdlen
);
10656 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&target
), 4);
10657 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&attachment
), 4);
10658 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&texture
), 4);
10659 (void) memcpy((void *) (gc
->pc
+ 16), (void *) (&level
), 4);
10660 (void) memcpy((void *) (gc
->pc
+ 20), (void *) (&layer
), 4);
10662 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
10663 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);