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"
36 #include <GL/glxproto.h>
38 #include <X11/Xlib-xcb.h>
43 #define __GLX_PAD(n) (((n) + 3) & ~3)
45 # if defined(__i386__) && defined(__GNUC__) && !defined(__CYGWIN__) && !defined(__MINGW32__)
46 # define FASTCALL __attribute__((fastcall))
50 # if defined(__GNUC__)
51 # define NOINLINE __attribute__((noinline))
56 #if !defined __GNUC__ || __GNUC__ < 3
57 # define __builtin_expect(x, y) x
60 /* If the size and opcode values are known at compile-time, this will, on
61 * x86 at least, emit them with a single instruction.
63 #define emit_header(dest, op, size) \
64 do { union { short s[2]; int i; } temp; \
65 temp.s[0] = (size); temp.s[1] = (op); \
66 *((int *)(dest)) = temp.i; } while(0)
69 __glXReadReply(Display
* dpy
, size_t size
, void *dest
,
70 GLboolean reply_is_always_array
)
72 xGLXSingleReply reply
;
74 (void) _XReply(dpy
, (xReply
*) & reply
, 0, False
);
76 if ((reply
.length
> 0) || reply_is_always_array
) {
77 const GLint bytes
= (reply_is_always_array
)
78 ? (4 * reply
.length
) : (reply
.size
* size
);
79 const GLint extra
= 4 - (bytes
& 3);
81 _XRead(dpy
, dest
, bytes
);
83 _XEatData(dpy
, extra
);
86 (void) memcpy(dest
, &(reply
.pad3
), size
);
94 __glXReadPixelReply(Display
* dpy
, __GLXcontext
* gc
, unsigned max_dim
,
95 GLint width
, GLint height
, GLint depth
, GLenum format
,
96 GLenum type
, void *dest
, GLboolean dimensions_in_reply
)
98 xGLXSingleReply reply
;
101 (void) _XReply(dpy
, (xReply
*) & reply
, 0, False
);
103 if (dimensions_in_reply
) {
108 if ((height
== 0) || (max_dim
< 2)) {
111 if ((depth
== 0) || (max_dim
< 3)) {
116 size
= reply
.length
* 4;
118 void *buf
= Xmalloc(size
);
121 _XEatData(dpy
, size
);
122 __glXSetError(gc
, GL_OUT_OF_MEMORY
);
124 const GLint extra
= 4 - (size
& 3);
126 _XRead(dpy
, buf
, size
);
128 _XEatData(dpy
, extra
);
131 __glEmptyImage(gc
, 3, width
, height
, depth
, format
, type
,
138 #define X_GLXSingle 0
140 NOINLINE FASTCALL GLubyte
*
141 __glXSetupSingleRequest(__GLXcontext
* gc
, GLint sop
, GLint cmdlen
)
144 Display
*const dpy
= gc
->currentDpy
;
146 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
148 GetReqExtra(GLXSingle
, cmdlen
, req
);
149 req
->reqType
= gc
->majorOpcode
;
150 req
->contextTag
= gc
->currentContextTag
;
152 return (GLubyte
*) (req
) + sz_xGLXSingleReq
;
155 NOINLINE FASTCALL GLubyte
*
156 __glXSetupVendorRequest(__GLXcontext
* gc
, GLint code
, GLint vop
,
159 xGLXVendorPrivateReq
*req
;
160 Display
*const dpy
= gc
->currentDpy
;
162 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
164 GetReqExtra(GLXVendorPrivate
, cmdlen
, req
);
165 req
->reqType
= gc
->majorOpcode
;
167 req
->vendorCode
= vop
;
168 req
->contextTag
= gc
->currentContextTag
;
169 return (GLubyte
*) (req
) + sz_xGLXVendorPrivateReq
;
172 const GLuint __glXDefaultPixelStore
[9] = { 0, 0, 0, 0, 0, 0, 0, 0, 1 };
174 #define zero (__glXDefaultPixelStore+0)
175 #define one (__glXDefaultPixelStore+8)
176 #define default_pixel_store_1D (__glXDefaultPixelStore+4)
177 #define default_pixel_store_1D_size 20
178 #define default_pixel_store_2D (__glXDefaultPixelStore+4)
179 #define default_pixel_store_2D_size 20
180 #define default_pixel_store_3D (__glXDefaultPixelStore+0)
181 #define default_pixel_store_3D_size 36
182 #define default_pixel_store_4D (__glXDefaultPixelStore+0)
183 #define default_pixel_store_4D_size 36
185 static FASTCALL NOINLINE
void
186 generic_3_byte(GLint rop
, const void *ptr
)
188 __GLXcontext
*const gc
= __glXGetCurrentContext();
189 const GLuint cmdlen
= 8;
191 emit_header(gc
->pc
, rop
, cmdlen
);
192 (void) memcpy((void *) (gc
->pc
+ 4), ptr
, 4);
194 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
195 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
199 static FASTCALL NOINLINE
void
200 generic_4_byte(GLint rop
, const void *ptr
)
202 __GLXcontext
*const gc
= __glXGetCurrentContext();
203 const GLuint cmdlen
= 8;
205 emit_header(gc
->pc
, rop
, cmdlen
);
206 (void) memcpy((void *) (gc
->pc
+ 4), ptr
, 4);
208 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
209 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
213 static FASTCALL NOINLINE
void
214 generic_6_byte(GLint rop
, const void *ptr
)
216 __GLXcontext
*const gc
= __glXGetCurrentContext();
217 const GLuint cmdlen
= 12;
219 emit_header(gc
->pc
, rop
, cmdlen
);
220 (void) memcpy((void *) (gc
->pc
+ 4), ptr
, 8);
222 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
223 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
227 static FASTCALL NOINLINE
void
228 generic_8_byte(GLint rop
, const void *ptr
)
230 __GLXcontext
*const gc
= __glXGetCurrentContext();
231 const GLuint cmdlen
= 12;
233 emit_header(gc
->pc
, rop
, cmdlen
);
234 (void) memcpy((void *) (gc
->pc
+ 4), ptr
, 8);
236 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
237 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
241 static FASTCALL NOINLINE
void
242 generic_12_byte(GLint rop
, const void *ptr
)
244 __GLXcontext
*const gc
= __glXGetCurrentContext();
245 const GLuint cmdlen
= 16;
247 emit_header(gc
->pc
, rop
, cmdlen
);
248 (void) memcpy((void *) (gc
->pc
+ 4), ptr
, 12);
250 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
251 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
255 static FASTCALL NOINLINE
void
256 generic_16_byte(GLint rop
, const void *ptr
)
258 __GLXcontext
*const gc
= __glXGetCurrentContext();
259 const GLuint cmdlen
= 20;
261 emit_header(gc
->pc
, rop
, cmdlen
);
262 (void) memcpy((void *) (gc
->pc
+ 4), ptr
, 16);
264 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
265 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
269 static FASTCALL NOINLINE
void
270 generic_24_byte(GLint rop
, const void *ptr
)
272 __GLXcontext
*const gc
= __glXGetCurrentContext();
273 const GLuint cmdlen
= 28;
275 emit_header(gc
->pc
, rop
, cmdlen
);
276 (void) memcpy((void *) (gc
->pc
+ 4), ptr
, 24);
278 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
279 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
283 static FASTCALL NOINLINE
void
284 generic_32_byte(GLint rop
, const void *ptr
)
286 __GLXcontext
*const gc
= __glXGetCurrentContext();
287 const GLuint cmdlen
= 36;
289 emit_header(gc
->pc
, rop
, cmdlen
);
290 (void) memcpy((void *) (gc
->pc
+ 4), ptr
, 32);
292 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
293 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
297 #define X_GLsop_NewList 101
299 __indirect_glNewList(GLuint list
, GLenum mode
)
301 __GLXcontext
*const gc
= __glXGetCurrentContext();
302 Display
*const dpy
= gc
->currentDpy
;
303 const GLuint cmdlen
= 8;
304 if (__builtin_expect(dpy
!= NULL
, 1)) {
306 xcb_connection_t
*c
= XGetXCBConnection(dpy
);
307 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
308 xcb_glx_new_list(c
, gc
->currentContextTag
, list
, mode
);
311 __glXSetupSingleRequest(gc
, X_GLsop_NewList
, cmdlen
);
312 (void) memcpy((void *) (pc
+ 0), (void *) (&list
), 4);
313 (void) memcpy((void *) (pc
+ 4), (void *) (&mode
), 4);
321 #define X_GLsop_EndList 102
323 __indirect_glEndList(void)
325 __GLXcontext
*const gc
= __glXGetCurrentContext();
326 Display
*const dpy
= gc
->currentDpy
;
327 const GLuint cmdlen
= 0;
328 if (__builtin_expect(dpy
!= NULL
, 1)) {
330 xcb_connection_t
*c
= XGetXCBConnection(dpy
);
331 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
332 xcb_glx_end_list(c
, gc
->currentContextTag
);
334 (void) __glXSetupSingleRequest(gc
, X_GLsop_EndList
, cmdlen
);
342 #define X_GLrop_CallList 1
344 __indirect_glCallList(GLuint list
)
346 __GLXcontext
*const gc
= __glXGetCurrentContext();
347 const GLuint cmdlen
= 8;
348 emit_header(gc
->pc
, X_GLrop_CallList
, cmdlen
);
349 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&list
), 4);
351 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
352 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
356 #define X_GLrop_CallLists 2
358 __indirect_glCallLists(GLsizei n
, GLenum type
, const GLvoid
* lists
)
360 __GLXcontext
*const gc
= __glXGetCurrentContext();
361 const GLuint compsize
= __glCallLists_size(type
);
362 const GLuint cmdlen
= 12 + __GLX_PAD((compsize
* n
));
363 if (__builtin_expect((n
>= 0) && (gc
->currentDpy
!= NULL
), 1)) {
364 if (cmdlen
<= gc
->maxSmallRenderCommandSize
) {
365 if ((gc
->pc
+ cmdlen
) > gc
->bufEnd
) {
366 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
368 emit_header(gc
->pc
, X_GLrop_CallLists
, cmdlen
);
369 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&n
), 4);
370 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&type
), 4);
371 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (lists
),
374 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
375 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
378 const GLint op
= X_GLrop_CallLists
;
379 const GLuint cmdlenLarge
= cmdlen
+ 4;
380 GLubyte
*const pc
= __glXFlushRenderBuffer(gc
, gc
->pc
);
381 (void) memcpy((void *) (pc
+ 0), (void *) (&cmdlenLarge
), 4);
382 (void) memcpy((void *) (pc
+ 4), (void *) (&op
), 4);
383 (void) memcpy((void *) (pc
+ 8), (void *) (&n
), 4);
384 (void) memcpy((void *) (pc
+ 12), (void *) (&type
), 4);
385 __glXSendLargeCommand(gc
, pc
, 16, lists
, (compsize
* n
));
390 #define X_GLsop_DeleteLists 103
392 __indirect_glDeleteLists(GLuint list
, GLsizei range
)
394 __GLXcontext
*const gc
= __glXGetCurrentContext();
395 Display
*const dpy
= gc
->currentDpy
;
396 const GLuint cmdlen
= 8;
397 if (__builtin_expect(dpy
!= NULL
, 1)) {
399 xcb_connection_t
*c
= XGetXCBConnection(dpy
);
400 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
401 xcb_glx_delete_lists(c
, gc
->currentContextTag
, list
, range
);
404 __glXSetupSingleRequest(gc
, X_GLsop_DeleteLists
, cmdlen
);
405 (void) memcpy((void *) (pc
+ 0), (void *) (&list
), 4);
406 (void) memcpy((void *) (pc
+ 4), (void *) (&range
), 4);
414 #define X_GLsop_GenLists 104
416 __indirect_glGenLists(GLsizei range
)
418 __GLXcontext
*const gc
= __glXGetCurrentContext();
419 Display
*const dpy
= gc
->currentDpy
;
420 GLuint retval
= (GLuint
) 0;
421 const GLuint cmdlen
= 4;
422 if (__builtin_expect(dpy
!= NULL
, 1)) {
424 xcb_connection_t
*c
= XGetXCBConnection(dpy
);
425 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
426 xcb_glx_gen_lists_reply_t
*reply
=
427 xcb_glx_gen_lists_reply(c
,
429 gc
->currentContextTag
,
431 retval
= reply
->ret_val
;
435 __glXSetupSingleRequest(gc
, X_GLsop_GenLists
, cmdlen
);
436 (void) memcpy((void *) (pc
+ 0), (void *) (&range
), 4);
437 retval
= (GLuint
) __glXReadReply(dpy
, 0, NULL
, GL_FALSE
);
445 #define X_GLrop_ListBase 3
447 __indirect_glListBase(GLuint base
)
449 __GLXcontext
*const gc
= __glXGetCurrentContext();
450 const GLuint cmdlen
= 8;
451 emit_header(gc
->pc
, X_GLrop_ListBase
, cmdlen
);
452 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&base
), 4);
454 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
455 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
459 #define X_GLrop_Begin 4
461 __indirect_glBegin(GLenum mode
)
463 __GLXcontext
*const gc
= __glXGetCurrentContext();
464 const GLuint cmdlen
= 8;
465 emit_header(gc
->pc
, X_GLrop_Begin
, cmdlen
);
466 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&mode
), 4);
468 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
469 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
473 #define X_GLrop_Bitmap 5
475 __indirect_glBitmap(GLsizei width
, GLsizei height
, GLfloat xorig
,
476 GLfloat yorig
, GLfloat xmove
, GLfloat ymove
,
477 const GLubyte
* bitmap
)
479 __GLXcontext
*const gc
= __glXGetCurrentContext();
480 const GLuint compsize
=
481 (bitmap
!= NULL
) ? __glImageSize(width
, height
, 1, GL_COLOR_INDEX
,
483 const GLuint cmdlen
= 48 + __GLX_PAD(compsize
);
484 if (__builtin_expect(gc
->currentDpy
!= NULL
, 1)) {
485 if (cmdlen
<= gc
->maxSmallRenderCommandSize
) {
486 if ((gc
->pc
+ cmdlen
) > gc
->bufEnd
) {
487 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
489 emit_header(gc
->pc
, X_GLrop_Bitmap
, cmdlen
);
490 (void) memcpy((void *) (gc
->pc
+ 24), (void *) (&width
), 4);
491 (void) memcpy((void *) (gc
->pc
+ 28), (void *) (&height
), 4);
492 (void) memcpy((void *) (gc
->pc
+ 32), (void *) (&xorig
), 4);
493 (void) memcpy((void *) (gc
->pc
+ 36), (void *) (&yorig
), 4);
494 (void) memcpy((void *) (gc
->pc
+ 40), (void *) (&xmove
), 4);
495 (void) memcpy((void *) (gc
->pc
+ 44), (void *) (&ymove
), 4);
497 (*gc
->fillImage
) (gc
, 2, width
, height
, 1, GL_COLOR_INDEX
,
498 GL_BITMAP
, bitmap
, gc
->pc
+ 48, gc
->pc
+ 4);
500 (void) memcpy(gc
->pc
+ 4, default_pixel_store_2D
,
501 default_pixel_store_2D_size
);
504 if (gc
->pc
> gc
->limit
) {
505 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
508 const GLint op
= X_GLrop_Bitmap
;
509 const GLuint cmdlenLarge
= cmdlen
+ 4;
510 GLubyte
*const pc
= __glXFlushRenderBuffer(gc
, gc
->pc
);
511 (void) memcpy((void *) (pc
+ 0), (void *) (&cmdlenLarge
), 4);
512 (void) memcpy((void *) (pc
+ 4), (void *) (&op
), 4);
513 (void) memcpy((void *) (pc
+ 28), (void *) (&width
), 4);
514 (void) memcpy((void *) (pc
+ 32), (void *) (&height
), 4);
515 (void) memcpy((void *) (pc
+ 36), (void *) (&xorig
), 4);
516 (void) memcpy((void *) (pc
+ 40), (void *) (&yorig
), 4);
517 (void) memcpy((void *) (pc
+ 44), (void *) (&xmove
), 4);
518 (void) memcpy((void *) (pc
+ 48), (void *) (&ymove
), 4);
519 __glXSendLargeImage(gc
, compsize
, 2, width
, height
, 1,
520 GL_COLOR_INDEX
, GL_BITMAP
, bitmap
, pc
+ 52,
526 #define X_GLrop_Color3bv 6
528 __indirect_glColor3b(GLbyte red
, GLbyte green
, GLbyte blue
)
530 __GLXcontext
*const gc
= __glXGetCurrentContext();
531 const GLuint cmdlen
= 8;
532 emit_header(gc
->pc
, X_GLrop_Color3bv
, cmdlen
);
533 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&red
), 1);
534 (void) memcpy((void *) (gc
->pc
+ 5), (void *) (&green
), 1);
535 (void) memcpy((void *) (gc
->pc
+ 6), (void *) (&blue
), 1);
537 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
538 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
542 #define X_GLrop_Color3bv 6
544 __indirect_glColor3bv(const GLbyte
* v
)
546 generic_3_byte(X_GLrop_Color3bv
, v
);
549 #define X_GLrop_Color3dv 7
551 __indirect_glColor3d(GLdouble red
, GLdouble green
, GLdouble blue
)
553 __GLXcontext
*const gc
= __glXGetCurrentContext();
554 const GLuint cmdlen
= 28;
555 emit_header(gc
->pc
, X_GLrop_Color3dv
, cmdlen
);
556 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&red
), 8);
557 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&green
), 8);
558 (void) memcpy((void *) (gc
->pc
+ 20), (void *) (&blue
), 8);
560 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
561 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
565 #define X_GLrop_Color3dv 7
567 __indirect_glColor3dv(const GLdouble
* v
)
569 generic_24_byte(X_GLrop_Color3dv
, v
);
572 #define X_GLrop_Color3fv 8
574 __indirect_glColor3f(GLfloat red
, GLfloat green
, GLfloat blue
)
576 __GLXcontext
*const gc
= __glXGetCurrentContext();
577 const GLuint cmdlen
= 16;
578 emit_header(gc
->pc
, X_GLrop_Color3fv
, cmdlen
);
579 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&red
), 4);
580 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&green
), 4);
581 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&blue
), 4);
583 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
584 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
588 #define X_GLrop_Color3fv 8
590 __indirect_glColor3fv(const GLfloat
* v
)
592 generic_12_byte(X_GLrop_Color3fv
, v
);
595 #define X_GLrop_Color3iv 9
597 __indirect_glColor3i(GLint red
, GLint green
, GLint blue
)
599 __GLXcontext
*const gc
= __glXGetCurrentContext();
600 const GLuint cmdlen
= 16;
601 emit_header(gc
->pc
, X_GLrop_Color3iv
, cmdlen
);
602 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&red
), 4);
603 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&green
), 4);
604 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&blue
), 4);
606 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
607 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
611 #define X_GLrop_Color3iv 9
613 __indirect_glColor3iv(const GLint
* v
)
615 generic_12_byte(X_GLrop_Color3iv
, v
);
618 #define X_GLrop_Color3sv 10
620 __indirect_glColor3s(GLshort red
, GLshort green
, GLshort blue
)
622 __GLXcontext
*const gc
= __glXGetCurrentContext();
623 const GLuint cmdlen
= 12;
624 emit_header(gc
->pc
, X_GLrop_Color3sv
, cmdlen
);
625 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&red
), 2);
626 (void) memcpy((void *) (gc
->pc
+ 6), (void *) (&green
), 2);
627 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&blue
), 2);
629 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
630 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
634 #define X_GLrop_Color3sv 10
636 __indirect_glColor3sv(const GLshort
* v
)
638 generic_6_byte(X_GLrop_Color3sv
, v
);
641 #define X_GLrop_Color3ubv 11
643 __indirect_glColor3ub(GLubyte red
, GLubyte green
, GLubyte blue
)
645 __GLXcontext
*const gc
= __glXGetCurrentContext();
646 const GLuint cmdlen
= 8;
647 emit_header(gc
->pc
, X_GLrop_Color3ubv
, cmdlen
);
648 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&red
), 1);
649 (void) memcpy((void *) (gc
->pc
+ 5), (void *) (&green
), 1);
650 (void) memcpy((void *) (gc
->pc
+ 6), (void *) (&blue
), 1);
652 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
653 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
657 #define X_GLrop_Color3ubv 11
659 __indirect_glColor3ubv(const GLubyte
* v
)
661 generic_3_byte(X_GLrop_Color3ubv
, v
);
664 #define X_GLrop_Color3uiv 12
666 __indirect_glColor3ui(GLuint red
, GLuint green
, GLuint blue
)
668 __GLXcontext
*const gc
= __glXGetCurrentContext();
669 const GLuint cmdlen
= 16;
670 emit_header(gc
->pc
, X_GLrop_Color3uiv
, cmdlen
);
671 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&red
), 4);
672 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&green
), 4);
673 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&blue
), 4);
675 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
676 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
680 #define X_GLrop_Color3uiv 12
682 __indirect_glColor3uiv(const GLuint
* v
)
684 generic_12_byte(X_GLrop_Color3uiv
, v
);
687 #define X_GLrop_Color3usv 13
689 __indirect_glColor3us(GLushort red
, GLushort green
, GLushort blue
)
691 __GLXcontext
*const gc
= __glXGetCurrentContext();
692 const GLuint cmdlen
= 12;
693 emit_header(gc
->pc
, X_GLrop_Color3usv
, cmdlen
);
694 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&red
), 2);
695 (void) memcpy((void *) (gc
->pc
+ 6), (void *) (&green
), 2);
696 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&blue
), 2);
698 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
699 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
703 #define X_GLrop_Color3usv 13
705 __indirect_glColor3usv(const GLushort
* v
)
707 generic_6_byte(X_GLrop_Color3usv
, v
);
710 #define X_GLrop_Color4bv 14
712 __indirect_glColor4b(GLbyte red
, GLbyte green
, GLbyte blue
, GLbyte alpha
)
714 __GLXcontext
*const gc
= __glXGetCurrentContext();
715 const GLuint cmdlen
= 8;
716 emit_header(gc
->pc
, X_GLrop_Color4bv
, cmdlen
);
717 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&red
), 1);
718 (void) memcpy((void *) (gc
->pc
+ 5), (void *) (&green
), 1);
719 (void) memcpy((void *) (gc
->pc
+ 6), (void *) (&blue
), 1);
720 (void) memcpy((void *) (gc
->pc
+ 7), (void *) (&alpha
), 1);
722 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
723 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
727 #define X_GLrop_Color4bv 14
729 __indirect_glColor4bv(const GLbyte
* v
)
731 generic_4_byte(X_GLrop_Color4bv
, v
);
734 #define X_GLrop_Color4dv 15
736 __indirect_glColor4d(GLdouble red
, GLdouble green
, GLdouble blue
,
739 __GLXcontext
*const gc
= __glXGetCurrentContext();
740 const GLuint cmdlen
= 36;
741 emit_header(gc
->pc
, X_GLrop_Color4dv
, cmdlen
);
742 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&red
), 8);
743 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&green
), 8);
744 (void) memcpy((void *) (gc
->pc
+ 20), (void *) (&blue
), 8);
745 (void) memcpy((void *) (gc
->pc
+ 28), (void *) (&alpha
), 8);
747 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
748 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
752 #define X_GLrop_Color4dv 15
754 __indirect_glColor4dv(const GLdouble
* v
)
756 generic_32_byte(X_GLrop_Color4dv
, v
);
759 #define X_GLrop_Color4fv 16
761 __indirect_glColor4f(GLfloat red
, GLfloat green
, GLfloat blue
, GLfloat alpha
)
763 __GLXcontext
*const gc
= __glXGetCurrentContext();
764 const GLuint cmdlen
= 20;
765 emit_header(gc
->pc
, X_GLrop_Color4fv
, cmdlen
);
766 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&red
), 4);
767 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&green
), 4);
768 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&blue
), 4);
769 (void) memcpy((void *) (gc
->pc
+ 16), (void *) (&alpha
), 4);
771 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
772 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
776 #define X_GLrop_Color4fv 16
778 __indirect_glColor4fv(const GLfloat
* v
)
780 generic_16_byte(X_GLrop_Color4fv
, v
);
783 #define X_GLrop_Color4iv 17
785 __indirect_glColor4i(GLint red
, GLint green
, GLint blue
, GLint alpha
)
787 __GLXcontext
*const gc
= __glXGetCurrentContext();
788 const GLuint cmdlen
= 20;
789 emit_header(gc
->pc
, X_GLrop_Color4iv
, cmdlen
);
790 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&red
), 4);
791 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&green
), 4);
792 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&blue
), 4);
793 (void) memcpy((void *) (gc
->pc
+ 16), (void *) (&alpha
), 4);
795 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
796 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
800 #define X_GLrop_Color4iv 17
802 __indirect_glColor4iv(const GLint
* v
)
804 generic_16_byte(X_GLrop_Color4iv
, v
);
807 #define X_GLrop_Color4sv 18
809 __indirect_glColor4s(GLshort red
, GLshort green
, GLshort blue
, GLshort alpha
)
811 __GLXcontext
*const gc
= __glXGetCurrentContext();
812 const GLuint cmdlen
= 12;
813 emit_header(gc
->pc
, X_GLrop_Color4sv
, cmdlen
);
814 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&red
), 2);
815 (void) memcpy((void *) (gc
->pc
+ 6), (void *) (&green
), 2);
816 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&blue
), 2);
817 (void) memcpy((void *) (gc
->pc
+ 10), (void *) (&alpha
), 2);
819 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
820 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
824 #define X_GLrop_Color4sv 18
826 __indirect_glColor4sv(const GLshort
* v
)
828 generic_8_byte(X_GLrop_Color4sv
, v
);
831 #define X_GLrop_Color4ubv 19
833 __indirect_glColor4ub(GLubyte red
, GLubyte green
, GLubyte blue
, GLubyte alpha
)
835 __GLXcontext
*const gc
= __glXGetCurrentContext();
836 const GLuint cmdlen
= 8;
837 emit_header(gc
->pc
, X_GLrop_Color4ubv
, cmdlen
);
838 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&red
), 1);
839 (void) memcpy((void *) (gc
->pc
+ 5), (void *) (&green
), 1);
840 (void) memcpy((void *) (gc
->pc
+ 6), (void *) (&blue
), 1);
841 (void) memcpy((void *) (gc
->pc
+ 7), (void *) (&alpha
), 1);
843 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
844 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
848 #define X_GLrop_Color4ubv 19
850 __indirect_glColor4ubv(const GLubyte
* v
)
852 generic_4_byte(X_GLrop_Color4ubv
, v
);
855 #define X_GLrop_Color4uiv 20
857 __indirect_glColor4ui(GLuint red
, GLuint green
, GLuint blue
, GLuint alpha
)
859 __GLXcontext
*const gc
= __glXGetCurrentContext();
860 const GLuint cmdlen
= 20;
861 emit_header(gc
->pc
, X_GLrop_Color4uiv
, cmdlen
);
862 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&red
), 4);
863 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&green
), 4);
864 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&blue
), 4);
865 (void) memcpy((void *) (gc
->pc
+ 16), (void *) (&alpha
), 4);
867 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
868 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
872 #define X_GLrop_Color4uiv 20
874 __indirect_glColor4uiv(const GLuint
* v
)
876 generic_16_byte(X_GLrop_Color4uiv
, v
);
879 #define X_GLrop_Color4usv 21
881 __indirect_glColor4us(GLushort red
, GLushort green
, GLushort blue
,
884 __GLXcontext
*const gc
= __glXGetCurrentContext();
885 const GLuint cmdlen
= 12;
886 emit_header(gc
->pc
, X_GLrop_Color4usv
, cmdlen
);
887 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&red
), 2);
888 (void) memcpy((void *) (gc
->pc
+ 6), (void *) (&green
), 2);
889 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&blue
), 2);
890 (void) memcpy((void *) (gc
->pc
+ 10), (void *) (&alpha
), 2);
892 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
893 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
897 #define X_GLrop_Color4usv 21
899 __indirect_glColor4usv(const GLushort
* v
)
901 generic_8_byte(X_GLrop_Color4usv
, v
);
904 #define X_GLrop_EdgeFlagv 22
906 __indirect_glEdgeFlag(GLboolean flag
)
908 __GLXcontext
*const gc
= __glXGetCurrentContext();
909 const GLuint cmdlen
= 8;
910 emit_header(gc
->pc
, X_GLrop_EdgeFlagv
, cmdlen
);
911 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&flag
), 1);
913 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
914 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
918 #define X_GLrop_EdgeFlagv 22
920 __indirect_glEdgeFlagv(const GLboolean
* flag
)
922 __GLXcontext
*const gc
= __glXGetCurrentContext();
923 const GLuint cmdlen
= 8;
924 emit_header(gc
->pc
, X_GLrop_EdgeFlagv
, cmdlen
);
925 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (flag
), 1);
927 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
928 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
932 #define X_GLrop_End 23
934 __indirect_glEnd(void)
936 __GLXcontext
*const gc
= __glXGetCurrentContext();
937 const GLuint cmdlen
= 4;
938 emit_header(gc
->pc
, X_GLrop_End
, cmdlen
);
940 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
941 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
945 #define X_GLrop_Indexdv 24
947 __indirect_glIndexd(GLdouble c
)
949 __GLXcontext
*const gc
= __glXGetCurrentContext();
950 const GLuint cmdlen
= 12;
951 emit_header(gc
->pc
, X_GLrop_Indexdv
, cmdlen
);
952 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&c
), 8);
954 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
955 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
959 #define X_GLrop_Indexdv 24
961 __indirect_glIndexdv(const GLdouble
* c
)
963 generic_8_byte(X_GLrop_Indexdv
, c
);
966 #define X_GLrop_Indexfv 25
968 __indirect_glIndexf(GLfloat c
)
970 __GLXcontext
*const gc
= __glXGetCurrentContext();
971 const GLuint cmdlen
= 8;
972 emit_header(gc
->pc
, X_GLrop_Indexfv
, cmdlen
);
973 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&c
), 4);
975 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
976 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
980 #define X_GLrop_Indexfv 25
982 __indirect_glIndexfv(const GLfloat
* c
)
984 generic_4_byte(X_GLrop_Indexfv
, c
);
987 #define X_GLrop_Indexiv 26
989 __indirect_glIndexi(GLint c
)
991 __GLXcontext
*const gc
= __glXGetCurrentContext();
992 const GLuint cmdlen
= 8;
993 emit_header(gc
->pc
, X_GLrop_Indexiv
, cmdlen
);
994 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&c
), 4);
996 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
997 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
1001 #define X_GLrop_Indexiv 26
1003 __indirect_glIndexiv(const GLint
* c
)
1005 generic_4_byte(X_GLrop_Indexiv
, c
);
1008 #define X_GLrop_Indexsv 27
1010 __indirect_glIndexs(GLshort c
)
1012 __GLXcontext
*const gc
= __glXGetCurrentContext();
1013 const GLuint cmdlen
= 8;
1014 emit_header(gc
->pc
, X_GLrop_Indexsv
, cmdlen
);
1015 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&c
), 2);
1017 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
1018 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
1022 #define X_GLrop_Indexsv 27
1024 __indirect_glIndexsv(const GLshort
* c
)
1026 __GLXcontext
*const gc
= __glXGetCurrentContext();
1027 const GLuint cmdlen
= 8;
1028 emit_header(gc
->pc
, X_GLrop_Indexsv
, cmdlen
);
1029 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (c
), 2);
1031 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
1032 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
1036 #define X_GLrop_Normal3bv 28
1038 __indirect_glNormal3b(GLbyte nx
, GLbyte ny
, GLbyte nz
)
1040 __GLXcontext
*const gc
= __glXGetCurrentContext();
1041 const GLuint cmdlen
= 8;
1042 emit_header(gc
->pc
, X_GLrop_Normal3bv
, cmdlen
);
1043 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&nx
), 1);
1044 (void) memcpy((void *) (gc
->pc
+ 5), (void *) (&ny
), 1);
1045 (void) memcpy((void *) (gc
->pc
+ 6), (void *) (&nz
), 1);
1047 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
1048 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
1052 #define X_GLrop_Normal3bv 28
1054 __indirect_glNormal3bv(const GLbyte
* v
)
1056 generic_3_byte(X_GLrop_Normal3bv
, v
);
1059 #define X_GLrop_Normal3dv 29
1061 __indirect_glNormal3d(GLdouble nx
, GLdouble ny
, GLdouble nz
)
1063 __GLXcontext
*const gc
= __glXGetCurrentContext();
1064 const GLuint cmdlen
= 28;
1065 emit_header(gc
->pc
, X_GLrop_Normal3dv
, cmdlen
);
1066 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&nx
), 8);
1067 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&ny
), 8);
1068 (void) memcpy((void *) (gc
->pc
+ 20), (void *) (&nz
), 8);
1070 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
1071 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
1075 #define X_GLrop_Normal3dv 29
1077 __indirect_glNormal3dv(const GLdouble
* v
)
1079 generic_24_byte(X_GLrop_Normal3dv
, v
);
1082 #define X_GLrop_Normal3fv 30
1084 __indirect_glNormal3f(GLfloat nx
, GLfloat ny
, GLfloat nz
)
1086 __GLXcontext
*const gc
= __glXGetCurrentContext();
1087 const GLuint cmdlen
= 16;
1088 emit_header(gc
->pc
, X_GLrop_Normal3fv
, cmdlen
);
1089 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&nx
), 4);
1090 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&ny
), 4);
1091 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&nz
), 4);
1093 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
1094 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
1098 #define X_GLrop_Normal3fv 30
1100 __indirect_glNormal3fv(const GLfloat
* v
)
1102 generic_12_byte(X_GLrop_Normal3fv
, v
);
1105 #define X_GLrop_Normal3iv 31
1107 __indirect_glNormal3i(GLint nx
, GLint ny
, GLint nz
)
1109 __GLXcontext
*const gc
= __glXGetCurrentContext();
1110 const GLuint cmdlen
= 16;
1111 emit_header(gc
->pc
, X_GLrop_Normal3iv
, cmdlen
);
1112 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&nx
), 4);
1113 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&ny
), 4);
1114 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&nz
), 4);
1116 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
1117 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
1121 #define X_GLrop_Normal3iv 31
1123 __indirect_glNormal3iv(const GLint
* v
)
1125 generic_12_byte(X_GLrop_Normal3iv
, v
);
1128 #define X_GLrop_Normal3sv 32
1130 __indirect_glNormal3s(GLshort nx
, GLshort ny
, GLshort nz
)
1132 __GLXcontext
*const gc
= __glXGetCurrentContext();
1133 const GLuint cmdlen
= 12;
1134 emit_header(gc
->pc
, X_GLrop_Normal3sv
, cmdlen
);
1135 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&nx
), 2);
1136 (void) memcpy((void *) (gc
->pc
+ 6), (void *) (&ny
), 2);
1137 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&nz
), 2);
1139 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
1140 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
1144 #define X_GLrop_Normal3sv 32
1146 __indirect_glNormal3sv(const GLshort
* v
)
1148 generic_6_byte(X_GLrop_Normal3sv
, v
);
1151 #define X_GLrop_RasterPos2dv 33
1153 __indirect_glRasterPos2d(GLdouble x
, GLdouble y
)
1155 __GLXcontext
*const gc
= __glXGetCurrentContext();
1156 const GLuint cmdlen
= 20;
1157 emit_header(gc
->pc
, X_GLrop_RasterPos2dv
, cmdlen
);
1158 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&x
), 8);
1159 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&y
), 8);
1161 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
1162 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
1166 #define X_GLrop_RasterPos2dv 33
1168 __indirect_glRasterPos2dv(const GLdouble
* v
)
1170 generic_16_byte(X_GLrop_RasterPos2dv
, v
);
1173 #define X_GLrop_RasterPos2fv 34
1175 __indirect_glRasterPos2f(GLfloat x
, GLfloat y
)
1177 __GLXcontext
*const gc
= __glXGetCurrentContext();
1178 const GLuint cmdlen
= 12;
1179 emit_header(gc
->pc
, X_GLrop_RasterPos2fv
, cmdlen
);
1180 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&x
), 4);
1181 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&y
), 4);
1183 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
1184 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
1188 #define X_GLrop_RasterPos2fv 34
1190 __indirect_glRasterPos2fv(const GLfloat
* v
)
1192 generic_8_byte(X_GLrop_RasterPos2fv
, v
);
1195 #define X_GLrop_RasterPos2iv 35
1197 __indirect_glRasterPos2i(GLint x
, GLint y
)
1199 __GLXcontext
*const gc
= __glXGetCurrentContext();
1200 const GLuint cmdlen
= 12;
1201 emit_header(gc
->pc
, X_GLrop_RasterPos2iv
, cmdlen
);
1202 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&x
), 4);
1203 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&y
), 4);
1205 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
1206 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
1210 #define X_GLrop_RasterPos2iv 35
1212 __indirect_glRasterPos2iv(const GLint
* v
)
1214 generic_8_byte(X_GLrop_RasterPos2iv
, v
);
1217 #define X_GLrop_RasterPos2sv 36
1219 __indirect_glRasterPos2s(GLshort x
, GLshort y
)
1221 __GLXcontext
*const gc
= __glXGetCurrentContext();
1222 const GLuint cmdlen
= 8;
1223 emit_header(gc
->pc
, X_GLrop_RasterPos2sv
, cmdlen
);
1224 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&x
), 2);
1225 (void) memcpy((void *) (gc
->pc
+ 6), (void *) (&y
), 2);
1227 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
1228 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
1232 #define X_GLrop_RasterPos2sv 36
1234 __indirect_glRasterPos2sv(const GLshort
* v
)
1236 generic_4_byte(X_GLrop_RasterPos2sv
, v
);
1239 #define X_GLrop_RasterPos3dv 37
1241 __indirect_glRasterPos3d(GLdouble x
, GLdouble y
, GLdouble z
)
1243 __GLXcontext
*const gc
= __glXGetCurrentContext();
1244 const GLuint cmdlen
= 28;
1245 emit_header(gc
->pc
, X_GLrop_RasterPos3dv
, cmdlen
);
1246 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&x
), 8);
1247 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&y
), 8);
1248 (void) memcpy((void *) (gc
->pc
+ 20), (void *) (&z
), 8);
1250 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
1251 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
1255 #define X_GLrop_RasterPos3dv 37
1257 __indirect_glRasterPos3dv(const GLdouble
* v
)
1259 generic_24_byte(X_GLrop_RasterPos3dv
, v
);
1262 #define X_GLrop_RasterPos3fv 38
1264 __indirect_glRasterPos3f(GLfloat x
, GLfloat y
, GLfloat z
)
1266 __GLXcontext
*const gc
= __glXGetCurrentContext();
1267 const GLuint cmdlen
= 16;
1268 emit_header(gc
->pc
, X_GLrop_RasterPos3fv
, cmdlen
);
1269 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&x
), 4);
1270 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&y
), 4);
1271 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&z
), 4);
1273 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
1274 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
1278 #define X_GLrop_RasterPos3fv 38
1280 __indirect_glRasterPos3fv(const GLfloat
* v
)
1282 generic_12_byte(X_GLrop_RasterPos3fv
, v
);
1285 #define X_GLrop_RasterPos3iv 39
1287 __indirect_glRasterPos3i(GLint x
, GLint y
, GLint z
)
1289 __GLXcontext
*const gc
= __glXGetCurrentContext();
1290 const GLuint cmdlen
= 16;
1291 emit_header(gc
->pc
, X_GLrop_RasterPos3iv
, cmdlen
);
1292 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&x
), 4);
1293 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&y
), 4);
1294 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&z
), 4);
1296 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
1297 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
1301 #define X_GLrop_RasterPos3iv 39
1303 __indirect_glRasterPos3iv(const GLint
* v
)
1305 generic_12_byte(X_GLrop_RasterPos3iv
, v
);
1308 #define X_GLrop_RasterPos3sv 40
1310 __indirect_glRasterPos3s(GLshort x
, GLshort y
, GLshort z
)
1312 __GLXcontext
*const gc
= __glXGetCurrentContext();
1313 const GLuint cmdlen
= 12;
1314 emit_header(gc
->pc
, X_GLrop_RasterPos3sv
, cmdlen
);
1315 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&x
), 2);
1316 (void) memcpy((void *) (gc
->pc
+ 6), (void *) (&y
), 2);
1317 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&z
), 2);
1319 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
1320 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
1324 #define X_GLrop_RasterPos3sv 40
1326 __indirect_glRasterPos3sv(const GLshort
* v
)
1328 generic_6_byte(X_GLrop_RasterPos3sv
, v
);
1331 #define X_GLrop_RasterPos4dv 41
1333 __indirect_glRasterPos4d(GLdouble x
, GLdouble y
, GLdouble z
, GLdouble w
)
1335 __GLXcontext
*const gc
= __glXGetCurrentContext();
1336 const GLuint cmdlen
= 36;
1337 emit_header(gc
->pc
, X_GLrop_RasterPos4dv
, cmdlen
);
1338 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&x
), 8);
1339 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&y
), 8);
1340 (void) memcpy((void *) (gc
->pc
+ 20), (void *) (&z
), 8);
1341 (void) memcpy((void *) (gc
->pc
+ 28), (void *) (&w
), 8);
1343 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
1344 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
1348 #define X_GLrop_RasterPos4dv 41
1350 __indirect_glRasterPos4dv(const GLdouble
* v
)
1352 generic_32_byte(X_GLrop_RasterPos4dv
, v
);
1355 #define X_GLrop_RasterPos4fv 42
1357 __indirect_glRasterPos4f(GLfloat x
, GLfloat y
, GLfloat z
, GLfloat w
)
1359 __GLXcontext
*const gc
= __glXGetCurrentContext();
1360 const GLuint cmdlen
= 20;
1361 emit_header(gc
->pc
, X_GLrop_RasterPos4fv
, cmdlen
);
1362 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&x
), 4);
1363 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&y
), 4);
1364 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&z
), 4);
1365 (void) memcpy((void *) (gc
->pc
+ 16), (void *) (&w
), 4);
1367 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
1368 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
1372 #define X_GLrop_RasterPos4fv 42
1374 __indirect_glRasterPos4fv(const GLfloat
* v
)
1376 generic_16_byte(X_GLrop_RasterPos4fv
, v
);
1379 #define X_GLrop_RasterPos4iv 43
1381 __indirect_glRasterPos4i(GLint x
, GLint y
, GLint z
, GLint w
)
1383 __GLXcontext
*const gc
= __glXGetCurrentContext();
1384 const GLuint cmdlen
= 20;
1385 emit_header(gc
->pc
, X_GLrop_RasterPos4iv
, cmdlen
);
1386 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&x
), 4);
1387 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&y
), 4);
1388 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&z
), 4);
1389 (void) memcpy((void *) (gc
->pc
+ 16), (void *) (&w
), 4);
1391 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
1392 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
1396 #define X_GLrop_RasterPos4iv 43
1398 __indirect_glRasterPos4iv(const GLint
* v
)
1400 generic_16_byte(X_GLrop_RasterPos4iv
, v
);
1403 #define X_GLrop_RasterPos4sv 44
1405 __indirect_glRasterPos4s(GLshort x
, GLshort y
, GLshort z
, GLshort w
)
1407 __GLXcontext
*const gc
= __glXGetCurrentContext();
1408 const GLuint cmdlen
= 12;
1409 emit_header(gc
->pc
, X_GLrop_RasterPos4sv
, cmdlen
);
1410 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&x
), 2);
1411 (void) memcpy((void *) (gc
->pc
+ 6), (void *) (&y
), 2);
1412 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&z
), 2);
1413 (void) memcpy((void *) (gc
->pc
+ 10), (void *) (&w
), 2);
1415 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
1416 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
1420 #define X_GLrop_RasterPos4sv 44
1422 __indirect_glRasterPos4sv(const GLshort
* v
)
1424 generic_8_byte(X_GLrop_RasterPos4sv
, v
);
1427 #define X_GLrop_Rectdv 45
1429 __indirect_glRectd(GLdouble x1
, GLdouble y1
, GLdouble x2
, GLdouble y2
)
1431 __GLXcontext
*const gc
= __glXGetCurrentContext();
1432 const GLuint cmdlen
= 36;
1433 emit_header(gc
->pc
, X_GLrop_Rectdv
, cmdlen
);
1434 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&x1
), 8);
1435 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&y1
), 8);
1436 (void) memcpy((void *) (gc
->pc
+ 20), (void *) (&x2
), 8);
1437 (void) memcpy((void *) (gc
->pc
+ 28), (void *) (&y2
), 8);
1439 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
1440 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
1444 #define X_GLrop_Rectdv 45
1446 __indirect_glRectdv(const GLdouble
* v1
, const GLdouble
* v2
)
1448 __GLXcontext
*const gc
= __glXGetCurrentContext();
1449 const GLuint cmdlen
= 36;
1450 emit_header(gc
->pc
, X_GLrop_Rectdv
, cmdlen
);
1451 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (v1
), 16);
1452 (void) memcpy((void *) (gc
->pc
+ 20), (void *) (v2
), 16);
1454 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
1455 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
1459 #define X_GLrop_Rectfv 46
1461 __indirect_glRectf(GLfloat x1
, GLfloat y1
, GLfloat x2
, GLfloat y2
)
1463 __GLXcontext
*const gc
= __glXGetCurrentContext();
1464 const GLuint cmdlen
= 20;
1465 emit_header(gc
->pc
, X_GLrop_Rectfv
, cmdlen
);
1466 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&x1
), 4);
1467 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&y1
), 4);
1468 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&x2
), 4);
1469 (void) memcpy((void *) (gc
->pc
+ 16), (void *) (&y2
), 4);
1471 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
1472 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
1476 #define X_GLrop_Rectfv 46
1478 __indirect_glRectfv(const GLfloat
* v1
, const GLfloat
* v2
)
1480 __GLXcontext
*const gc
= __glXGetCurrentContext();
1481 const GLuint cmdlen
= 20;
1482 emit_header(gc
->pc
, X_GLrop_Rectfv
, cmdlen
);
1483 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (v1
), 8);
1484 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (v2
), 8);
1486 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
1487 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
1491 #define X_GLrop_Rectiv 47
1493 __indirect_glRecti(GLint x1
, GLint y1
, GLint x2
, GLint y2
)
1495 __GLXcontext
*const gc
= __glXGetCurrentContext();
1496 const GLuint cmdlen
= 20;
1497 emit_header(gc
->pc
, X_GLrop_Rectiv
, cmdlen
);
1498 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&x1
), 4);
1499 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&y1
), 4);
1500 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&x2
), 4);
1501 (void) memcpy((void *) (gc
->pc
+ 16), (void *) (&y2
), 4);
1503 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
1504 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
1508 #define X_GLrop_Rectiv 47
1510 __indirect_glRectiv(const GLint
* v1
, const GLint
* v2
)
1512 __GLXcontext
*const gc
= __glXGetCurrentContext();
1513 const GLuint cmdlen
= 20;
1514 emit_header(gc
->pc
, X_GLrop_Rectiv
, cmdlen
);
1515 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (v1
), 8);
1516 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (v2
), 8);
1518 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
1519 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
1523 #define X_GLrop_Rectsv 48
1525 __indirect_glRects(GLshort x1
, GLshort y1
, GLshort x2
, GLshort y2
)
1527 __GLXcontext
*const gc
= __glXGetCurrentContext();
1528 const GLuint cmdlen
= 12;
1529 emit_header(gc
->pc
, X_GLrop_Rectsv
, cmdlen
);
1530 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&x1
), 2);
1531 (void) memcpy((void *) (gc
->pc
+ 6), (void *) (&y1
), 2);
1532 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&x2
), 2);
1533 (void) memcpy((void *) (gc
->pc
+ 10), (void *) (&y2
), 2);
1535 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
1536 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
1540 #define X_GLrop_Rectsv 48
1542 __indirect_glRectsv(const GLshort
* v1
, const GLshort
* v2
)
1544 __GLXcontext
*const gc
= __glXGetCurrentContext();
1545 const GLuint cmdlen
= 12;
1546 emit_header(gc
->pc
, X_GLrop_Rectsv
, cmdlen
);
1547 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (v1
), 4);
1548 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (v2
), 4);
1550 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
1551 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
1555 #define X_GLrop_TexCoord1dv 49
1557 __indirect_glTexCoord1d(GLdouble s
)
1559 __GLXcontext
*const gc
= __glXGetCurrentContext();
1560 const GLuint cmdlen
= 12;
1561 emit_header(gc
->pc
, X_GLrop_TexCoord1dv
, cmdlen
);
1562 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&s
), 8);
1564 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
1565 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
1569 #define X_GLrop_TexCoord1dv 49
1571 __indirect_glTexCoord1dv(const GLdouble
* v
)
1573 generic_8_byte(X_GLrop_TexCoord1dv
, v
);
1576 #define X_GLrop_TexCoord1fv 50
1578 __indirect_glTexCoord1f(GLfloat s
)
1580 __GLXcontext
*const gc
= __glXGetCurrentContext();
1581 const GLuint cmdlen
= 8;
1582 emit_header(gc
->pc
, X_GLrop_TexCoord1fv
, cmdlen
);
1583 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&s
), 4);
1585 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
1586 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
1590 #define X_GLrop_TexCoord1fv 50
1592 __indirect_glTexCoord1fv(const GLfloat
* v
)
1594 generic_4_byte(X_GLrop_TexCoord1fv
, v
);
1597 #define X_GLrop_TexCoord1iv 51
1599 __indirect_glTexCoord1i(GLint s
)
1601 __GLXcontext
*const gc
= __glXGetCurrentContext();
1602 const GLuint cmdlen
= 8;
1603 emit_header(gc
->pc
, X_GLrop_TexCoord1iv
, cmdlen
);
1604 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&s
), 4);
1606 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
1607 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
1611 #define X_GLrop_TexCoord1iv 51
1613 __indirect_glTexCoord1iv(const GLint
* v
)
1615 generic_4_byte(X_GLrop_TexCoord1iv
, v
);
1618 #define X_GLrop_TexCoord1sv 52
1620 __indirect_glTexCoord1s(GLshort s
)
1622 __GLXcontext
*const gc
= __glXGetCurrentContext();
1623 const GLuint cmdlen
= 8;
1624 emit_header(gc
->pc
, X_GLrop_TexCoord1sv
, cmdlen
);
1625 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&s
), 2);
1627 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
1628 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
1632 #define X_GLrop_TexCoord1sv 52
1634 __indirect_glTexCoord1sv(const GLshort
* v
)
1636 __GLXcontext
*const gc
= __glXGetCurrentContext();
1637 const GLuint cmdlen
= 8;
1638 emit_header(gc
->pc
, X_GLrop_TexCoord1sv
, cmdlen
);
1639 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (v
), 2);
1641 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
1642 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
1646 #define X_GLrop_TexCoord2dv 53
1648 __indirect_glTexCoord2d(GLdouble s
, GLdouble t
)
1650 __GLXcontext
*const gc
= __glXGetCurrentContext();
1651 const GLuint cmdlen
= 20;
1652 emit_header(gc
->pc
, X_GLrop_TexCoord2dv
, cmdlen
);
1653 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&s
), 8);
1654 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&t
), 8);
1656 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
1657 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
1661 #define X_GLrop_TexCoord2dv 53
1663 __indirect_glTexCoord2dv(const GLdouble
* v
)
1665 generic_16_byte(X_GLrop_TexCoord2dv
, v
);
1668 #define X_GLrop_TexCoord2fv 54
1670 __indirect_glTexCoord2f(GLfloat s
, GLfloat t
)
1672 __GLXcontext
*const gc
= __glXGetCurrentContext();
1673 const GLuint cmdlen
= 12;
1674 emit_header(gc
->pc
, X_GLrop_TexCoord2fv
, cmdlen
);
1675 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&s
), 4);
1676 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&t
), 4);
1678 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
1679 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
1683 #define X_GLrop_TexCoord2fv 54
1685 __indirect_glTexCoord2fv(const GLfloat
* v
)
1687 generic_8_byte(X_GLrop_TexCoord2fv
, v
);
1690 #define X_GLrop_TexCoord2iv 55
1692 __indirect_glTexCoord2i(GLint s
, GLint t
)
1694 __GLXcontext
*const gc
= __glXGetCurrentContext();
1695 const GLuint cmdlen
= 12;
1696 emit_header(gc
->pc
, X_GLrop_TexCoord2iv
, cmdlen
);
1697 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&s
), 4);
1698 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&t
), 4);
1700 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
1701 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
1705 #define X_GLrop_TexCoord2iv 55
1707 __indirect_glTexCoord2iv(const GLint
* v
)
1709 generic_8_byte(X_GLrop_TexCoord2iv
, v
);
1712 #define X_GLrop_TexCoord2sv 56
1714 __indirect_glTexCoord2s(GLshort s
, GLshort t
)
1716 __GLXcontext
*const gc
= __glXGetCurrentContext();
1717 const GLuint cmdlen
= 8;
1718 emit_header(gc
->pc
, X_GLrop_TexCoord2sv
, cmdlen
);
1719 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&s
), 2);
1720 (void) memcpy((void *) (gc
->pc
+ 6), (void *) (&t
), 2);
1722 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
1723 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
1727 #define X_GLrop_TexCoord2sv 56
1729 __indirect_glTexCoord2sv(const GLshort
* v
)
1731 generic_4_byte(X_GLrop_TexCoord2sv
, v
);
1734 #define X_GLrop_TexCoord3dv 57
1736 __indirect_glTexCoord3d(GLdouble s
, GLdouble t
, GLdouble r
)
1738 __GLXcontext
*const gc
= __glXGetCurrentContext();
1739 const GLuint cmdlen
= 28;
1740 emit_header(gc
->pc
, X_GLrop_TexCoord3dv
, cmdlen
);
1741 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&s
), 8);
1742 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&t
), 8);
1743 (void) memcpy((void *) (gc
->pc
+ 20), (void *) (&r
), 8);
1745 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
1746 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
1750 #define X_GLrop_TexCoord3dv 57
1752 __indirect_glTexCoord3dv(const GLdouble
* v
)
1754 generic_24_byte(X_GLrop_TexCoord3dv
, v
);
1757 #define X_GLrop_TexCoord3fv 58
1759 __indirect_glTexCoord3f(GLfloat s
, GLfloat t
, GLfloat r
)
1761 __GLXcontext
*const gc
= __glXGetCurrentContext();
1762 const GLuint cmdlen
= 16;
1763 emit_header(gc
->pc
, X_GLrop_TexCoord3fv
, cmdlen
);
1764 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&s
), 4);
1765 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&t
), 4);
1766 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&r
), 4);
1768 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
1769 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
1773 #define X_GLrop_TexCoord3fv 58
1775 __indirect_glTexCoord3fv(const GLfloat
* v
)
1777 generic_12_byte(X_GLrop_TexCoord3fv
, v
);
1780 #define X_GLrop_TexCoord3iv 59
1782 __indirect_glTexCoord3i(GLint s
, GLint t
, GLint r
)
1784 __GLXcontext
*const gc
= __glXGetCurrentContext();
1785 const GLuint cmdlen
= 16;
1786 emit_header(gc
->pc
, X_GLrop_TexCoord3iv
, cmdlen
);
1787 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&s
), 4);
1788 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&t
), 4);
1789 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&r
), 4);
1791 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
1792 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
1796 #define X_GLrop_TexCoord3iv 59
1798 __indirect_glTexCoord3iv(const GLint
* v
)
1800 generic_12_byte(X_GLrop_TexCoord3iv
, v
);
1803 #define X_GLrop_TexCoord3sv 60
1805 __indirect_glTexCoord3s(GLshort s
, GLshort t
, GLshort r
)
1807 __GLXcontext
*const gc
= __glXGetCurrentContext();
1808 const GLuint cmdlen
= 12;
1809 emit_header(gc
->pc
, X_GLrop_TexCoord3sv
, cmdlen
);
1810 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&s
), 2);
1811 (void) memcpy((void *) (gc
->pc
+ 6), (void *) (&t
), 2);
1812 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&r
), 2);
1814 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
1815 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
1819 #define X_GLrop_TexCoord3sv 60
1821 __indirect_glTexCoord3sv(const GLshort
* v
)
1823 generic_6_byte(X_GLrop_TexCoord3sv
, v
);
1826 #define X_GLrop_TexCoord4dv 61
1828 __indirect_glTexCoord4d(GLdouble s
, GLdouble t
, GLdouble r
, GLdouble q
)
1830 __GLXcontext
*const gc
= __glXGetCurrentContext();
1831 const GLuint cmdlen
= 36;
1832 emit_header(gc
->pc
, X_GLrop_TexCoord4dv
, cmdlen
);
1833 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&s
), 8);
1834 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&t
), 8);
1835 (void) memcpy((void *) (gc
->pc
+ 20), (void *) (&r
), 8);
1836 (void) memcpy((void *) (gc
->pc
+ 28), (void *) (&q
), 8);
1838 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
1839 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
1843 #define X_GLrop_TexCoord4dv 61
1845 __indirect_glTexCoord4dv(const GLdouble
* v
)
1847 generic_32_byte(X_GLrop_TexCoord4dv
, v
);
1850 #define X_GLrop_TexCoord4fv 62
1852 __indirect_glTexCoord4f(GLfloat s
, GLfloat t
, GLfloat r
, GLfloat q
)
1854 __GLXcontext
*const gc
= __glXGetCurrentContext();
1855 const GLuint cmdlen
= 20;
1856 emit_header(gc
->pc
, X_GLrop_TexCoord4fv
, cmdlen
);
1857 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&s
), 4);
1858 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&t
), 4);
1859 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&r
), 4);
1860 (void) memcpy((void *) (gc
->pc
+ 16), (void *) (&q
), 4);
1862 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
1863 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
1867 #define X_GLrop_TexCoord4fv 62
1869 __indirect_glTexCoord4fv(const GLfloat
* v
)
1871 generic_16_byte(X_GLrop_TexCoord4fv
, v
);
1874 #define X_GLrop_TexCoord4iv 63
1876 __indirect_glTexCoord4i(GLint s
, GLint t
, GLint r
, GLint q
)
1878 __GLXcontext
*const gc
= __glXGetCurrentContext();
1879 const GLuint cmdlen
= 20;
1880 emit_header(gc
->pc
, X_GLrop_TexCoord4iv
, cmdlen
);
1881 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&s
), 4);
1882 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&t
), 4);
1883 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&r
), 4);
1884 (void) memcpy((void *) (gc
->pc
+ 16), (void *) (&q
), 4);
1886 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
1887 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
1891 #define X_GLrop_TexCoord4iv 63
1893 __indirect_glTexCoord4iv(const GLint
* v
)
1895 generic_16_byte(X_GLrop_TexCoord4iv
, v
);
1898 #define X_GLrop_TexCoord4sv 64
1900 __indirect_glTexCoord4s(GLshort s
, GLshort t
, GLshort r
, GLshort q
)
1902 __GLXcontext
*const gc
= __glXGetCurrentContext();
1903 const GLuint cmdlen
= 12;
1904 emit_header(gc
->pc
, X_GLrop_TexCoord4sv
, cmdlen
);
1905 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&s
), 2);
1906 (void) memcpy((void *) (gc
->pc
+ 6), (void *) (&t
), 2);
1907 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&r
), 2);
1908 (void) memcpy((void *) (gc
->pc
+ 10), (void *) (&q
), 2);
1910 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
1911 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
1915 #define X_GLrop_TexCoord4sv 64
1917 __indirect_glTexCoord4sv(const GLshort
* v
)
1919 generic_8_byte(X_GLrop_TexCoord4sv
, v
);
1922 #define X_GLrop_Vertex2dv 65
1924 __indirect_glVertex2d(GLdouble x
, GLdouble y
)
1926 __GLXcontext
*const gc
= __glXGetCurrentContext();
1927 const GLuint cmdlen
= 20;
1928 emit_header(gc
->pc
, X_GLrop_Vertex2dv
, cmdlen
);
1929 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&x
), 8);
1930 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&y
), 8);
1932 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
1933 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
1937 #define X_GLrop_Vertex2dv 65
1939 __indirect_glVertex2dv(const GLdouble
* v
)
1941 generic_16_byte(X_GLrop_Vertex2dv
, v
);
1944 #define X_GLrop_Vertex2fv 66
1946 __indirect_glVertex2f(GLfloat x
, GLfloat y
)
1948 __GLXcontext
*const gc
= __glXGetCurrentContext();
1949 const GLuint cmdlen
= 12;
1950 emit_header(gc
->pc
, X_GLrop_Vertex2fv
, cmdlen
);
1951 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&x
), 4);
1952 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&y
), 4);
1954 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
1955 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
1959 #define X_GLrop_Vertex2fv 66
1961 __indirect_glVertex2fv(const GLfloat
* v
)
1963 generic_8_byte(X_GLrop_Vertex2fv
, v
);
1966 #define X_GLrop_Vertex2iv 67
1968 __indirect_glVertex2i(GLint x
, GLint y
)
1970 __GLXcontext
*const gc
= __glXGetCurrentContext();
1971 const GLuint cmdlen
= 12;
1972 emit_header(gc
->pc
, X_GLrop_Vertex2iv
, cmdlen
);
1973 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&x
), 4);
1974 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&y
), 4);
1976 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
1977 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
1981 #define X_GLrop_Vertex2iv 67
1983 __indirect_glVertex2iv(const GLint
* v
)
1985 generic_8_byte(X_GLrop_Vertex2iv
, v
);
1988 #define X_GLrop_Vertex2sv 68
1990 __indirect_glVertex2s(GLshort x
, GLshort y
)
1992 __GLXcontext
*const gc
= __glXGetCurrentContext();
1993 const GLuint cmdlen
= 8;
1994 emit_header(gc
->pc
, X_GLrop_Vertex2sv
, cmdlen
);
1995 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&x
), 2);
1996 (void) memcpy((void *) (gc
->pc
+ 6), (void *) (&y
), 2);
1998 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
1999 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
2003 #define X_GLrop_Vertex2sv 68
2005 __indirect_glVertex2sv(const GLshort
* v
)
2007 generic_4_byte(X_GLrop_Vertex2sv
, v
);
2010 #define X_GLrop_Vertex3dv 69
2012 __indirect_glVertex3d(GLdouble x
, GLdouble y
, GLdouble z
)
2014 __GLXcontext
*const gc
= __glXGetCurrentContext();
2015 const GLuint cmdlen
= 28;
2016 emit_header(gc
->pc
, X_GLrop_Vertex3dv
, cmdlen
);
2017 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&x
), 8);
2018 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&y
), 8);
2019 (void) memcpy((void *) (gc
->pc
+ 20), (void *) (&z
), 8);
2021 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
2022 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
2026 #define X_GLrop_Vertex3dv 69
2028 __indirect_glVertex3dv(const GLdouble
* v
)
2030 generic_24_byte(X_GLrop_Vertex3dv
, v
);
2033 #define X_GLrop_Vertex3fv 70
2035 __indirect_glVertex3f(GLfloat x
, GLfloat y
, GLfloat z
)
2037 __GLXcontext
*const gc
= __glXGetCurrentContext();
2038 const GLuint cmdlen
= 16;
2039 emit_header(gc
->pc
, X_GLrop_Vertex3fv
, cmdlen
);
2040 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&x
), 4);
2041 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&y
), 4);
2042 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&z
), 4);
2044 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
2045 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
2049 #define X_GLrop_Vertex3fv 70
2051 __indirect_glVertex3fv(const GLfloat
* v
)
2053 generic_12_byte(X_GLrop_Vertex3fv
, v
);
2056 #define X_GLrop_Vertex3iv 71
2058 __indirect_glVertex3i(GLint x
, GLint y
, GLint z
)
2060 __GLXcontext
*const gc
= __glXGetCurrentContext();
2061 const GLuint cmdlen
= 16;
2062 emit_header(gc
->pc
, X_GLrop_Vertex3iv
, cmdlen
);
2063 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&x
), 4);
2064 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&y
), 4);
2065 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&z
), 4);
2067 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
2068 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
2072 #define X_GLrop_Vertex3iv 71
2074 __indirect_glVertex3iv(const GLint
* v
)
2076 generic_12_byte(X_GLrop_Vertex3iv
, v
);
2079 #define X_GLrop_Vertex3sv 72
2081 __indirect_glVertex3s(GLshort x
, GLshort y
, GLshort z
)
2083 __GLXcontext
*const gc
= __glXGetCurrentContext();
2084 const GLuint cmdlen
= 12;
2085 emit_header(gc
->pc
, X_GLrop_Vertex3sv
, cmdlen
);
2086 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&x
), 2);
2087 (void) memcpy((void *) (gc
->pc
+ 6), (void *) (&y
), 2);
2088 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&z
), 2);
2090 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
2091 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
2095 #define X_GLrop_Vertex3sv 72
2097 __indirect_glVertex3sv(const GLshort
* v
)
2099 generic_6_byte(X_GLrop_Vertex3sv
, v
);
2102 #define X_GLrop_Vertex4dv 73
2104 __indirect_glVertex4d(GLdouble x
, GLdouble y
, GLdouble z
, GLdouble w
)
2106 __GLXcontext
*const gc
= __glXGetCurrentContext();
2107 const GLuint cmdlen
= 36;
2108 emit_header(gc
->pc
, X_GLrop_Vertex4dv
, cmdlen
);
2109 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&x
), 8);
2110 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&y
), 8);
2111 (void) memcpy((void *) (gc
->pc
+ 20), (void *) (&z
), 8);
2112 (void) memcpy((void *) (gc
->pc
+ 28), (void *) (&w
), 8);
2114 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
2115 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
2119 #define X_GLrop_Vertex4dv 73
2121 __indirect_glVertex4dv(const GLdouble
* v
)
2123 generic_32_byte(X_GLrop_Vertex4dv
, v
);
2126 #define X_GLrop_Vertex4fv 74
2128 __indirect_glVertex4f(GLfloat x
, GLfloat y
, GLfloat z
, GLfloat w
)
2130 __GLXcontext
*const gc
= __glXGetCurrentContext();
2131 const GLuint cmdlen
= 20;
2132 emit_header(gc
->pc
, X_GLrop_Vertex4fv
, cmdlen
);
2133 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&x
), 4);
2134 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&y
), 4);
2135 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&z
), 4);
2136 (void) memcpy((void *) (gc
->pc
+ 16), (void *) (&w
), 4);
2138 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
2139 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
2143 #define X_GLrop_Vertex4fv 74
2145 __indirect_glVertex4fv(const GLfloat
* v
)
2147 generic_16_byte(X_GLrop_Vertex4fv
, v
);
2150 #define X_GLrop_Vertex4iv 75
2152 __indirect_glVertex4i(GLint x
, GLint y
, GLint z
, GLint w
)
2154 __GLXcontext
*const gc
= __glXGetCurrentContext();
2155 const GLuint cmdlen
= 20;
2156 emit_header(gc
->pc
, X_GLrop_Vertex4iv
, cmdlen
);
2157 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&x
), 4);
2158 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&y
), 4);
2159 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&z
), 4);
2160 (void) memcpy((void *) (gc
->pc
+ 16), (void *) (&w
), 4);
2162 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
2163 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
2167 #define X_GLrop_Vertex4iv 75
2169 __indirect_glVertex4iv(const GLint
* v
)
2171 generic_16_byte(X_GLrop_Vertex4iv
, v
);
2174 #define X_GLrop_Vertex4sv 76
2176 __indirect_glVertex4s(GLshort x
, GLshort y
, GLshort z
, GLshort w
)
2178 __GLXcontext
*const gc
= __glXGetCurrentContext();
2179 const GLuint cmdlen
= 12;
2180 emit_header(gc
->pc
, X_GLrop_Vertex4sv
, cmdlen
);
2181 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&x
), 2);
2182 (void) memcpy((void *) (gc
->pc
+ 6), (void *) (&y
), 2);
2183 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&z
), 2);
2184 (void) memcpy((void *) (gc
->pc
+ 10), (void *) (&w
), 2);
2186 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
2187 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
2191 #define X_GLrop_Vertex4sv 76
2193 __indirect_glVertex4sv(const GLshort
* v
)
2195 generic_8_byte(X_GLrop_Vertex4sv
, v
);
2198 #define X_GLrop_ClipPlane 77
2200 __indirect_glClipPlane(GLenum plane
, const GLdouble
* equation
)
2202 __GLXcontext
*const gc
= __glXGetCurrentContext();
2203 const GLuint cmdlen
= 40;
2204 emit_header(gc
->pc
, X_GLrop_ClipPlane
, cmdlen
);
2205 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (equation
), 32);
2206 (void) memcpy((void *) (gc
->pc
+ 36), (void *) (&plane
), 4);
2208 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
2209 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
2213 #define X_GLrop_ColorMaterial 78
2215 __indirect_glColorMaterial(GLenum face
, GLenum mode
)
2217 __GLXcontext
*const gc
= __glXGetCurrentContext();
2218 const GLuint cmdlen
= 12;
2219 emit_header(gc
->pc
, X_GLrop_ColorMaterial
, cmdlen
);
2220 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&face
), 4);
2221 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&mode
), 4);
2223 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
2224 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
2228 #define X_GLrop_CullFace 79
2230 __indirect_glCullFace(GLenum mode
)
2232 __GLXcontext
*const gc
= __glXGetCurrentContext();
2233 const GLuint cmdlen
= 8;
2234 emit_header(gc
->pc
, X_GLrop_CullFace
, cmdlen
);
2235 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&mode
), 4);
2237 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
2238 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
2242 #define X_GLrop_Fogf 80
2244 __indirect_glFogf(GLenum pname
, GLfloat param
)
2246 __GLXcontext
*const gc
= __glXGetCurrentContext();
2247 const GLuint cmdlen
= 12;
2248 emit_header(gc
->pc
, X_GLrop_Fogf
, cmdlen
);
2249 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&pname
), 4);
2250 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (¶m
), 4);
2252 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
2253 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
2257 #define X_GLrop_Fogfv 81
2259 __indirect_glFogfv(GLenum pname
, const GLfloat
* params
)
2261 __GLXcontext
*const gc
= __glXGetCurrentContext();
2262 const GLuint compsize
= __glFogfv_size(pname
);
2263 const GLuint cmdlen
= 8 + __GLX_PAD((compsize
* 4));
2264 emit_header(gc
->pc
, X_GLrop_Fogfv
, cmdlen
);
2265 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&pname
), 4);
2266 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (params
), (compsize
* 4));
2268 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
2269 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
2273 #define X_GLrop_Fogi 82
2275 __indirect_glFogi(GLenum pname
, GLint param
)
2277 __GLXcontext
*const gc
= __glXGetCurrentContext();
2278 const GLuint cmdlen
= 12;
2279 emit_header(gc
->pc
, X_GLrop_Fogi
, cmdlen
);
2280 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&pname
), 4);
2281 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (¶m
), 4);
2283 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
2284 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
2288 #define X_GLrop_Fogiv 83
2290 __indirect_glFogiv(GLenum pname
, const GLint
* params
)
2292 __GLXcontext
*const gc
= __glXGetCurrentContext();
2293 const GLuint compsize
= __glFogiv_size(pname
);
2294 const GLuint cmdlen
= 8 + __GLX_PAD((compsize
* 4));
2295 emit_header(gc
->pc
, X_GLrop_Fogiv
, cmdlen
);
2296 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&pname
), 4);
2297 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (params
), (compsize
* 4));
2299 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
2300 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
2304 #define X_GLrop_FrontFace 84
2306 __indirect_glFrontFace(GLenum mode
)
2308 __GLXcontext
*const gc
= __glXGetCurrentContext();
2309 const GLuint cmdlen
= 8;
2310 emit_header(gc
->pc
, X_GLrop_FrontFace
, cmdlen
);
2311 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&mode
), 4);
2313 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
2314 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
2318 #define X_GLrop_Hint 85
2320 __indirect_glHint(GLenum target
, GLenum mode
)
2322 __GLXcontext
*const gc
= __glXGetCurrentContext();
2323 const GLuint cmdlen
= 12;
2324 emit_header(gc
->pc
, X_GLrop_Hint
, cmdlen
);
2325 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&target
), 4);
2326 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&mode
), 4);
2328 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
2329 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
2333 #define X_GLrop_Lightf 86
2335 __indirect_glLightf(GLenum light
, GLenum pname
, GLfloat param
)
2337 __GLXcontext
*const gc
= __glXGetCurrentContext();
2338 const GLuint cmdlen
= 16;
2339 emit_header(gc
->pc
, X_GLrop_Lightf
, cmdlen
);
2340 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&light
), 4);
2341 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&pname
), 4);
2342 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (¶m
), 4);
2344 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
2345 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
2349 #define X_GLrop_Lightfv 87
2351 __indirect_glLightfv(GLenum light
, GLenum pname
, const GLfloat
* params
)
2353 __GLXcontext
*const gc
= __glXGetCurrentContext();
2354 const GLuint compsize
= __glLightfv_size(pname
);
2355 const GLuint cmdlen
= 12 + __GLX_PAD((compsize
* 4));
2356 emit_header(gc
->pc
, X_GLrop_Lightfv
, cmdlen
);
2357 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&light
), 4);
2358 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&pname
), 4);
2359 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (params
), (compsize
* 4));
2361 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
2362 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
2366 #define X_GLrop_Lighti 88
2368 __indirect_glLighti(GLenum light
, GLenum pname
, GLint param
)
2370 __GLXcontext
*const gc
= __glXGetCurrentContext();
2371 const GLuint cmdlen
= 16;
2372 emit_header(gc
->pc
, X_GLrop_Lighti
, cmdlen
);
2373 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&light
), 4);
2374 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&pname
), 4);
2375 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (¶m
), 4);
2377 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
2378 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
2382 #define X_GLrop_Lightiv 89
2384 __indirect_glLightiv(GLenum light
, GLenum pname
, const GLint
* params
)
2386 __GLXcontext
*const gc
= __glXGetCurrentContext();
2387 const GLuint compsize
= __glLightiv_size(pname
);
2388 const GLuint cmdlen
= 12 + __GLX_PAD((compsize
* 4));
2389 emit_header(gc
->pc
, X_GLrop_Lightiv
, cmdlen
);
2390 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&light
), 4);
2391 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&pname
), 4);
2392 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (params
), (compsize
* 4));
2394 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
2395 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
2399 #define X_GLrop_LightModelf 90
2401 __indirect_glLightModelf(GLenum pname
, GLfloat param
)
2403 __GLXcontext
*const gc
= __glXGetCurrentContext();
2404 const GLuint cmdlen
= 12;
2405 emit_header(gc
->pc
, X_GLrop_LightModelf
, cmdlen
);
2406 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&pname
), 4);
2407 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (¶m
), 4);
2409 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
2410 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
2414 #define X_GLrop_LightModelfv 91
2416 __indirect_glLightModelfv(GLenum pname
, const GLfloat
* params
)
2418 __GLXcontext
*const gc
= __glXGetCurrentContext();
2419 const GLuint compsize
= __glLightModelfv_size(pname
);
2420 const GLuint cmdlen
= 8 + __GLX_PAD((compsize
* 4));
2421 emit_header(gc
->pc
, X_GLrop_LightModelfv
, cmdlen
);
2422 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&pname
), 4);
2423 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (params
), (compsize
* 4));
2425 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
2426 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
2430 #define X_GLrop_LightModeli 92
2432 __indirect_glLightModeli(GLenum pname
, GLint param
)
2434 __GLXcontext
*const gc
= __glXGetCurrentContext();
2435 const GLuint cmdlen
= 12;
2436 emit_header(gc
->pc
, X_GLrop_LightModeli
, cmdlen
);
2437 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&pname
), 4);
2438 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (¶m
), 4);
2440 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
2441 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
2445 #define X_GLrop_LightModeliv 93
2447 __indirect_glLightModeliv(GLenum pname
, const GLint
* params
)
2449 __GLXcontext
*const gc
= __glXGetCurrentContext();
2450 const GLuint compsize
= __glLightModeliv_size(pname
);
2451 const GLuint cmdlen
= 8 + __GLX_PAD((compsize
* 4));
2452 emit_header(gc
->pc
, X_GLrop_LightModeliv
, cmdlen
);
2453 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&pname
), 4);
2454 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (params
), (compsize
* 4));
2456 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
2457 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
2461 #define X_GLrop_LineStipple 94
2463 __indirect_glLineStipple(GLint factor
, GLushort pattern
)
2465 __GLXcontext
*const gc
= __glXGetCurrentContext();
2466 const GLuint cmdlen
= 12;
2467 emit_header(gc
->pc
, X_GLrop_LineStipple
, cmdlen
);
2468 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&factor
), 4);
2469 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&pattern
), 2);
2471 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
2472 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
2476 #define X_GLrop_LineWidth 95
2478 __indirect_glLineWidth(GLfloat width
)
2480 __GLXcontext
*const gc
= __glXGetCurrentContext();
2481 const GLuint cmdlen
= 8;
2482 emit_header(gc
->pc
, X_GLrop_LineWidth
, cmdlen
);
2483 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&width
), 4);
2485 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
2486 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
2490 #define X_GLrop_Materialf 96
2492 __indirect_glMaterialf(GLenum face
, GLenum pname
, GLfloat param
)
2494 __GLXcontext
*const gc
= __glXGetCurrentContext();
2495 const GLuint cmdlen
= 16;
2496 emit_header(gc
->pc
, X_GLrop_Materialf
, cmdlen
);
2497 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&face
), 4);
2498 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&pname
), 4);
2499 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (¶m
), 4);
2501 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
2502 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
2506 #define X_GLrop_Materialfv 97
2508 __indirect_glMaterialfv(GLenum face
, GLenum pname
, const GLfloat
* params
)
2510 __GLXcontext
*const gc
= __glXGetCurrentContext();
2511 const GLuint compsize
= __glMaterialfv_size(pname
);
2512 const GLuint cmdlen
= 12 + __GLX_PAD((compsize
* 4));
2513 emit_header(gc
->pc
, X_GLrop_Materialfv
, cmdlen
);
2514 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&face
), 4);
2515 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&pname
), 4);
2516 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (params
), (compsize
* 4));
2518 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
2519 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
2523 #define X_GLrop_Materiali 98
2525 __indirect_glMateriali(GLenum face
, GLenum pname
, GLint param
)
2527 __GLXcontext
*const gc
= __glXGetCurrentContext();
2528 const GLuint cmdlen
= 16;
2529 emit_header(gc
->pc
, X_GLrop_Materiali
, cmdlen
);
2530 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&face
), 4);
2531 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&pname
), 4);
2532 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (¶m
), 4);
2534 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
2535 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
2539 #define X_GLrop_Materialiv 99
2541 __indirect_glMaterialiv(GLenum face
, GLenum pname
, const GLint
* params
)
2543 __GLXcontext
*const gc
= __glXGetCurrentContext();
2544 const GLuint compsize
= __glMaterialiv_size(pname
);
2545 const GLuint cmdlen
= 12 + __GLX_PAD((compsize
* 4));
2546 emit_header(gc
->pc
, X_GLrop_Materialiv
, cmdlen
);
2547 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&face
), 4);
2548 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&pname
), 4);
2549 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (params
), (compsize
* 4));
2551 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
2552 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
2556 #define X_GLrop_PointSize 100
2558 __indirect_glPointSize(GLfloat size
)
2560 __GLXcontext
*const gc
= __glXGetCurrentContext();
2561 const GLuint cmdlen
= 8;
2562 emit_header(gc
->pc
, X_GLrop_PointSize
, cmdlen
);
2563 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&size
), 4);
2565 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
2566 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
2570 #define X_GLrop_PolygonMode 101
2572 __indirect_glPolygonMode(GLenum face
, GLenum mode
)
2574 __GLXcontext
*const gc
= __glXGetCurrentContext();
2575 const GLuint cmdlen
= 12;
2576 emit_header(gc
->pc
, X_GLrop_PolygonMode
, cmdlen
);
2577 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&face
), 4);
2578 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&mode
), 4);
2580 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
2581 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
2585 #define X_GLrop_PolygonStipple 102
2587 __indirect_glPolygonStipple(const GLubyte
* mask
)
2589 __GLXcontext
*const gc
= __glXGetCurrentContext();
2590 const GLuint compsize
=
2591 (mask
!= NULL
) ? __glImageSize(32, 32, 1, GL_COLOR_INDEX
, GL_BITMAP
,
2593 const GLuint cmdlen
= 24 + __GLX_PAD(compsize
);
2594 emit_header(gc
->pc
, X_GLrop_PolygonStipple
, cmdlen
);
2596 (*gc
->fillImage
) (gc
, 2, 32, 32, 1, GL_COLOR_INDEX
, GL_BITMAP
, mask
,
2597 gc
->pc
+ 24, gc
->pc
+ 4);
2599 (void) memcpy(gc
->pc
+ 4, default_pixel_store_2D
,
2600 default_pixel_store_2D_size
);
2603 if (gc
->pc
> gc
->limit
) {
2604 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
2608 #define X_GLrop_Scissor 103
2610 __indirect_glScissor(GLint x
, GLint y
, GLsizei width
, GLsizei height
)
2612 __GLXcontext
*const gc
= __glXGetCurrentContext();
2613 const GLuint cmdlen
= 20;
2614 emit_header(gc
->pc
, X_GLrop_Scissor
, cmdlen
);
2615 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&x
), 4);
2616 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&y
), 4);
2617 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&width
), 4);
2618 (void) memcpy((void *) (gc
->pc
+ 16), (void *) (&height
), 4);
2620 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
2621 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
2625 #define X_GLrop_ShadeModel 104
2627 __indirect_glShadeModel(GLenum mode
)
2629 __GLXcontext
*const gc
= __glXGetCurrentContext();
2630 const GLuint cmdlen
= 8;
2631 emit_header(gc
->pc
, X_GLrop_ShadeModel
, cmdlen
);
2632 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&mode
), 4);
2634 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
2635 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
2639 #define X_GLrop_TexParameterf 105
2641 __indirect_glTexParameterf(GLenum target
, GLenum pname
, GLfloat param
)
2643 __GLXcontext
*const gc
= __glXGetCurrentContext();
2644 const GLuint cmdlen
= 16;
2645 emit_header(gc
->pc
, X_GLrop_TexParameterf
, cmdlen
);
2646 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&target
), 4);
2647 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&pname
), 4);
2648 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (¶m
), 4);
2650 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
2651 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
2655 #define X_GLrop_TexParameterfv 106
2657 __indirect_glTexParameterfv(GLenum target
, GLenum pname
,
2658 const GLfloat
* params
)
2660 __GLXcontext
*const gc
= __glXGetCurrentContext();
2661 const GLuint compsize
= __glTexParameterfv_size(pname
);
2662 const GLuint cmdlen
= 12 + __GLX_PAD((compsize
* 4));
2663 emit_header(gc
->pc
, X_GLrop_TexParameterfv
, cmdlen
);
2664 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&target
), 4);
2665 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&pname
), 4);
2666 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (params
), (compsize
* 4));
2668 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
2669 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
2673 #define X_GLrop_TexParameteri 107
2675 __indirect_glTexParameteri(GLenum target
, GLenum pname
, GLint param
)
2677 __GLXcontext
*const gc
= __glXGetCurrentContext();
2678 const GLuint cmdlen
= 16;
2679 emit_header(gc
->pc
, X_GLrop_TexParameteri
, cmdlen
);
2680 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&target
), 4);
2681 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&pname
), 4);
2682 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (¶m
), 4);
2684 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
2685 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
2689 #define X_GLrop_TexParameteriv 108
2691 __indirect_glTexParameteriv(GLenum target
, GLenum pname
, const GLint
* params
)
2693 __GLXcontext
*const gc
= __glXGetCurrentContext();
2694 const GLuint compsize
= __glTexParameteriv_size(pname
);
2695 const GLuint cmdlen
= 12 + __GLX_PAD((compsize
* 4));
2696 emit_header(gc
->pc
, X_GLrop_TexParameteriv
, cmdlen
);
2697 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&target
), 4);
2698 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&pname
), 4);
2699 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (params
), (compsize
* 4));
2701 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
2702 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
2707 __glx_TexImage_1D2D(unsigned opcode
, unsigned dim
, GLenum target
, GLint level
,
2708 GLint internalformat
, GLsizei width
, GLsizei height
,
2709 GLint border
, GLenum format
, GLenum type
,
2710 const GLvoid
* pixels
)
2712 __GLXcontext
*const gc
= __glXGetCurrentContext();
2713 const GLuint compsize
=
2714 __glImageSize(width
, height
, 1, format
, type
, target
);
2715 const GLuint cmdlen
= 56 + __GLX_PAD(compsize
);
2716 if (__builtin_expect(gc
->currentDpy
!= NULL
, 1)) {
2717 if (cmdlen
<= gc
->maxSmallRenderCommandSize
) {
2718 if ((gc
->pc
+ cmdlen
) > gc
->bufEnd
) {
2719 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
2721 emit_header(gc
->pc
, opcode
, cmdlen
);
2722 (void) memcpy((void *) (gc
->pc
+ 24), (void *) (&target
), 4);
2723 (void) memcpy((void *) (gc
->pc
+ 28), (void *) (&level
), 4);
2724 (void) memcpy((void *) (gc
->pc
+ 32), (void *) (&internalformat
),
2726 (void) memcpy((void *) (gc
->pc
+ 36), (void *) (&width
), 4);
2727 (void) memcpy((void *) (gc
->pc
+ 40), (void *) (&height
), 4);
2728 (void) memcpy((void *) (gc
->pc
+ 44), (void *) (&border
), 4);
2729 (void) memcpy((void *) (gc
->pc
+ 48), (void *) (&format
), 4);
2730 (void) memcpy((void *) (gc
->pc
+ 52), (void *) (&type
), 4);
2731 if ((compsize
> 0) && (pixels
!= NULL
)) {
2732 (*gc
->fillImage
) (gc
, dim
, width
, height
, 1, format
, type
,
2733 pixels
, gc
->pc
+ 56, gc
->pc
+ 4);
2735 (void) memcpy(gc
->pc
+ 4, default_pixel_store_2D
,
2736 default_pixel_store_2D_size
);
2739 if (gc
->pc
> gc
->limit
) {
2740 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
2743 const GLint op
= opcode
;
2744 const GLuint cmdlenLarge
= cmdlen
+ 4;
2745 GLubyte
*const pc
= __glXFlushRenderBuffer(gc
, gc
->pc
);
2746 (void) memcpy((void *) (pc
+ 0), (void *) (&cmdlenLarge
), 4);
2747 (void) memcpy((void *) (pc
+ 4), (void *) (&op
), 4);
2748 (void) memcpy((void *) (pc
+ 28), (void *) (&target
), 4);
2749 (void) memcpy((void *) (pc
+ 32), (void *) (&level
), 4);
2750 (void) memcpy((void *) (pc
+ 36), (void *) (&internalformat
), 4);
2751 (void) memcpy((void *) (pc
+ 40), (void *) (&width
), 4);
2752 (void) memcpy((void *) (pc
+ 44), (void *) (&height
), 4);
2753 (void) memcpy((void *) (pc
+ 48), (void *) (&border
), 4);
2754 (void) memcpy((void *) (pc
+ 52), (void *) (&format
), 4);
2755 (void) memcpy((void *) (pc
+ 56), (void *) (&type
), 4);
2756 __glXSendLargeImage(gc
, compsize
, dim
, width
, height
, 1, format
,
2757 type
, pixels
, pc
+ 60, pc
+ 8);
2762 #define X_GLrop_TexImage1D 109
2764 __indirect_glTexImage1D(GLenum target
, GLint level
, GLint internalformat
,
2765 GLsizei width
, GLint border
, GLenum format
,
2766 GLenum type
, const GLvoid
* pixels
)
2768 __glx_TexImage_1D2D(X_GLrop_TexImage1D
, 1, target
, level
, internalformat
,
2769 width
, 1, border
, format
, type
, pixels
);
2772 #define X_GLrop_TexImage2D 110
2774 __indirect_glTexImage2D(GLenum target
, GLint level
, GLint internalformat
,
2775 GLsizei width
, GLsizei height
, GLint border
,
2776 GLenum format
, GLenum type
, const GLvoid
* pixels
)
2778 __glx_TexImage_1D2D(X_GLrop_TexImage2D
, 2, target
, level
, internalformat
,
2779 width
, height
, border
, format
, type
, pixels
);
2782 #define X_GLrop_TexEnvf 111
2784 __indirect_glTexEnvf(GLenum target
, GLenum pname
, GLfloat param
)
2786 __GLXcontext
*const gc
= __glXGetCurrentContext();
2787 const GLuint cmdlen
= 16;
2788 emit_header(gc
->pc
, X_GLrop_TexEnvf
, cmdlen
);
2789 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&target
), 4);
2790 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&pname
), 4);
2791 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (¶m
), 4);
2793 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
2794 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
2798 #define X_GLrop_TexEnvfv 112
2800 __indirect_glTexEnvfv(GLenum target
, GLenum pname
, const GLfloat
* params
)
2802 __GLXcontext
*const gc
= __glXGetCurrentContext();
2803 const GLuint compsize
= __glTexEnvfv_size(pname
);
2804 const GLuint cmdlen
= 12 + __GLX_PAD((compsize
* 4));
2805 emit_header(gc
->pc
, X_GLrop_TexEnvfv
, cmdlen
);
2806 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&target
), 4);
2807 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&pname
), 4);
2808 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (params
), (compsize
* 4));
2810 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
2811 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
2815 #define X_GLrop_TexEnvi 113
2817 __indirect_glTexEnvi(GLenum target
, GLenum pname
, GLint param
)
2819 __GLXcontext
*const gc
= __glXGetCurrentContext();
2820 const GLuint cmdlen
= 16;
2821 emit_header(gc
->pc
, X_GLrop_TexEnvi
, cmdlen
);
2822 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&target
), 4);
2823 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&pname
), 4);
2824 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (¶m
), 4);
2826 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
2827 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
2831 #define X_GLrop_TexEnviv 114
2833 __indirect_glTexEnviv(GLenum target
, GLenum pname
, const GLint
* params
)
2835 __GLXcontext
*const gc
= __glXGetCurrentContext();
2836 const GLuint compsize
= __glTexEnviv_size(pname
);
2837 const GLuint cmdlen
= 12 + __GLX_PAD((compsize
* 4));
2838 emit_header(gc
->pc
, X_GLrop_TexEnviv
, cmdlen
);
2839 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&target
), 4);
2840 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&pname
), 4);
2841 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (params
), (compsize
* 4));
2843 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
2844 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
2848 #define X_GLrop_TexGend 115
2850 __indirect_glTexGend(GLenum coord
, GLenum pname
, GLdouble param
)
2852 __GLXcontext
*const gc
= __glXGetCurrentContext();
2853 const GLuint cmdlen
= 20;
2854 emit_header(gc
->pc
, X_GLrop_TexGend
, cmdlen
);
2855 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (¶m
), 8);
2856 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&coord
), 4);
2857 (void) memcpy((void *) (gc
->pc
+ 16), (void *) (&pname
), 4);
2859 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
2860 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
2864 #define X_GLrop_TexGendv 116
2866 __indirect_glTexGendv(GLenum coord
, GLenum pname
, const GLdouble
* params
)
2868 __GLXcontext
*const gc
= __glXGetCurrentContext();
2869 const GLuint compsize
= __glTexGendv_size(pname
);
2870 const GLuint cmdlen
= 12 + __GLX_PAD((compsize
* 8));
2871 emit_header(gc
->pc
, X_GLrop_TexGendv
, cmdlen
);
2872 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&coord
), 4);
2873 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&pname
), 4);
2874 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (params
), (compsize
* 8));
2876 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
2877 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
2881 #define X_GLrop_TexGenf 117
2883 __indirect_glTexGenf(GLenum coord
, GLenum pname
, GLfloat param
)
2885 __GLXcontext
*const gc
= __glXGetCurrentContext();
2886 const GLuint cmdlen
= 16;
2887 emit_header(gc
->pc
, X_GLrop_TexGenf
, cmdlen
);
2888 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&coord
), 4);
2889 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&pname
), 4);
2890 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (¶m
), 4);
2892 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
2893 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
2897 #define X_GLrop_TexGenfv 118
2899 __indirect_glTexGenfv(GLenum coord
, GLenum pname
, const GLfloat
* params
)
2901 __GLXcontext
*const gc
= __glXGetCurrentContext();
2902 const GLuint compsize
= __glTexGenfv_size(pname
);
2903 const GLuint cmdlen
= 12 + __GLX_PAD((compsize
* 4));
2904 emit_header(gc
->pc
, X_GLrop_TexGenfv
, cmdlen
);
2905 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&coord
), 4);
2906 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&pname
), 4);
2907 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (params
), (compsize
* 4));
2909 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
2910 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
2914 #define X_GLrop_TexGeni 119
2916 __indirect_glTexGeni(GLenum coord
, GLenum pname
, GLint param
)
2918 __GLXcontext
*const gc
= __glXGetCurrentContext();
2919 const GLuint cmdlen
= 16;
2920 emit_header(gc
->pc
, X_GLrop_TexGeni
, cmdlen
);
2921 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&coord
), 4);
2922 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&pname
), 4);
2923 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (¶m
), 4);
2925 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
2926 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
2930 #define X_GLrop_TexGeniv 120
2932 __indirect_glTexGeniv(GLenum coord
, GLenum pname
, const GLint
* params
)
2934 __GLXcontext
*const gc
= __glXGetCurrentContext();
2935 const GLuint compsize
= __glTexGeniv_size(pname
);
2936 const GLuint cmdlen
= 12 + __GLX_PAD((compsize
* 4));
2937 emit_header(gc
->pc
, X_GLrop_TexGeniv
, cmdlen
);
2938 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&coord
), 4);
2939 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&pname
), 4);
2940 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (params
), (compsize
* 4));
2942 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
2943 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
2947 #define X_GLrop_InitNames 121
2949 __indirect_glInitNames(void)
2951 __GLXcontext
*const gc
= __glXGetCurrentContext();
2952 const GLuint cmdlen
= 4;
2953 emit_header(gc
->pc
, X_GLrop_InitNames
, cmdlen
);
2955 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
2956 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
2960 #define X_GLrop_LoadName 122
2962 __indirect_glLoadName(GLuint name
)
2964 __GLXcontext
*const gc
= __glXGetCurrentContext();
2965 const GLuint cmdlen
= 8;
2966 emit_header(gc
->pc
, X_GLrop_LoadName
, cmdlen
);
2967 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&name
), 4);
2969 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
2970 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
2974 #define X_GLrop_PassThrough 123
2976 __indirect_glPassThrough(GLfloat token
)
2978 __GLXcontext
*const gc
= __glXGetCurrentContext();
2979 const GLuint cmdlen
= 8;
2980 emit_header(gc
->pc
, X_GLrop_PassThrough
, cmdlen
);
2981 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&token
), 4);
2983 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
2984 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
2988 #define X_GLrop_PopName 124
2990 __indirect_glPopName(void)
2992 __GLXcontext
*const gc
= __glXGetCurrentContext();
2993 const GLuint cmdlen
= 4;
2994 emit_header(gc
->pc
, X_GLrop_PopName
, cmdlen
);
2996 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
2997 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
3001 #define X_GLrop_PushName 125
3003 __indirect_glPushName(GLuint name
)
3005 __GLXcontext
*const gc
= __glXGetCurrentContext();
3006 const GLuint cmdlen
= 8;
3007 emit_header(gc
->pc
, X_GLrop_PushName
, cmdlen
);
3008 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&name
), 4);
3010 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
3011 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
3015 #define X_GLrop_DrawBuffer 126
3017 __indirect_glDrawBuffer(GLenum mode
)
3019 __GLXcontext
*const gc
= __glXGetCurrentContext();
3020 const GLuint cmdlen
= 8;
3021 emit_header(gc
->pc
, X_GLrop_DrawBuffer
, cmdlen
);
3022 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&mode
), 4);
3024 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
3025 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
3029 #define X_GLrop_Clear 127
3031 __indirect_glClear(GLbitfield mask
)
3033 __GLXcontext
*const gc
= __glXGetCurrentContext();
3034 const GLuint cmdlen
= 8;
3035 emit_header(gc
->pc
, X_GLrop_Clear
, cmdlen
);
3036 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&mask
), 4);
3038 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
3039 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
3043 #define X_GLrop_ClearAccum 128
3045 __indirect_glClearAccum(GLfloat red
, GLfloat green
, GLfloat blue
,
3048 __GLXcontext
*const gc
= __glXGetCurrentContext();
3049 const GLuint cmdlen
= 20;
3050 emit_header(gc
->pc
, X_GLrop_ClearAccum
, cmdlen
);
3051 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&red
), 4);
3052 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&green
), 4);
3053 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&blue
), 4);
3054 (void) memcpy((void *) (gc
->pc
+ 16), (void *) (&alpha
), 4);
3056 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
3057 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
3061 #define X_GLrop_ClearIndex 129
3063 __indirect_glClearIndex(GLfloat c
)
3065 __GLXcontext
*const gc
= __glXGetCurrentContext();
3066 const GLuint cmdlen
= 8;
3067 emit_header(gc
->pc
, X_GLrop_ClearIndex
, cmdlen
);
3068 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&c
), 4);
3070 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
3071 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
3075 #define X_GLrop_ClearColor 130
3077 __indirect_glClearColor(GLclampf red
, GLclampf green
, GLclampf blue
,
3080 __GLXcontext
*const gc
= __glXGetCurrentContext();
3081 const GLuint cmdlen
= 20;
3082 emit_header(gc
->pc
, X_GLrop_ClearColor
, cmdlen
);
3083 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&red
), 4);
3084 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&green
), 4);
3085 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&blue
), 4);
3086 (void) memcpy((void *) (gc
->pc
+ 16), (void *) (&alpha
), 4);
3088 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
3089 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
3093 #define X_GLrop_ClearStencil 131
3095 __indirect_glClearStencil(GLint s
)
3097 __GLXcontext
*const gc
= __glXGetCurrentContext();
3098 const GLuint cmdlen
= 8;
3099 emit_header(gc
->pc
, X_GLrop_ClearStencil
, cmdlen
);
3100 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&s
), 4);
3102 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
3103 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
3107 #define X_GLrop_ClearDepth 132
3109 __indirect_glClearDepth(GLclampd depth
)
3111 __GLXcontext
*const gc
= __glXGetCurrentContext();
3112 const GLuint cmdlen
= 12;
3113 emit_header(gc
->pc
, X_GLrop_ClearDepth
, cmdlen
);
3114 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&depth
), 8);
3116 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
3117 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
3121 #define X_GLrop_StencilMask 133
3123 __indirect_glStencilMask(GLuint mask
)
3125 __GLXcontext
*const gc
= __glXGetCurrentContext();
3126 const GLuint cmdlen
= 8;
3127 emit_header(gc
->pc
, X_GLrop_StencilMask
, cmdlen
);
3128 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&mask
), 4);
3130 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
3131 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
3135 #define X_GLrop_ColorMask 134
3137 __indirect_glColorMask(GLboolean red
, GLboolean green
, GLboolean blue
,
3140 __GLXcontext
*const gc
= __glXGetCurrentContext();
3141 const GLuint cmdlen
= 8;
3142 emit_header(gc
->pc
, X_GLrop_ColorMask
, cmdlen
);
3143 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&red
), 1);
3144 (void) memcpy((void *) (gc
->pc
+ 5), (void *) (&green
), 1);
3145 (void) memcpy((void *) (gc
->pc
+ 6), (void *) (&blue
), 1);
3146 (void) memcpy((void *) (gc
->pc
+ 7), (void *) (&alpha
), 1);
3148 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
3149 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
3153 #define X_GLrop_DepthMask 135
3155 __indirect_glDepthMask(GLboolean flag
)
3157 __GLXcontext
*const gc
= __glXGetCurrentContext();
3158 const GLuint cmdlen
= 8;
3159 emit_header(gc
->pc
, X_GLrop_DepthMask
, cmdlen
);
3160 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&flag
), 1);
3162 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
3163 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
3167 #define X_GLrop_IndexMask 136
3169 __indirect_glIndexMask(GLuint mask
)
3171 __GLXcontext
*const gc
= __glXGetCurrentContext();
3172 const GLuint cmdlen
= 8;
3173 emit_header(gc
->pc
, X_GLrop_IndexMask
, cmdlen
);
3174 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&mask
), 4);
3176 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
3177 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
3181 #define X_GLrop_Accum 137
3183 __indirect_glAccum(GLenum op
, GLfloat value
)
3185 __GLXcontext
*const gc
= __glXGetCurrentContext();
3186 const GLuint cmdlen
= 12;
3187 emit_header(gc
->pc
, X_GLrop_Accum
, cmdlen
);
3188 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&op
), 4);
3189 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&value
), 4);
3191 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
3192 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
3196 #define X_GLrop_PopAttrib 141
3198 __indirect_glPopAttrib(void)
3200 __GLXcontext
*const gc
= __glXGetCurrentContext();
3201 const GLuint cmdlen
= 4;
3202 emit_header(gc
->pc
, X_GLrop_PopAttrib
, cmdlen
);
3204 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
3205 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
3209 #define X_GLrop_PushAttrib 142
3211 __indirect_glPushAttrib(GLbitfield mask
)
3213 __GLXcontext
*const gc
= __glXGetCurrentContext();
3214 const GLuint cmdlen
= 8;
3215 emit_header(gc
->pc
, X_GLrop_PushAttrib
, cmdlen
);
3216 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&mask
), 4);
3218 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
3219 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
3223 #define X_GLrop_MapGrid1d 147
3225 __indirect_glMapGrid1d(GLint un
, GLdouble u1
, GLdouble u2
)
3227 __GLXcontext
*const gc
= __glXGetCurrentContext();
3228 const GLuint cmdlen
= 24;
3229 emit_header(gc
->pc
, X_GLrop_MapGrid1d
, cmdlen
);
3230 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&u1
), 8);
3231 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&u2
), 8);
3232 (void) memcpy((void *) (gc
->pc
+ 20), (void *) (&un
), 4);
3234 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
3235 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
3239 #define X_GLrop_MapGrid1f 148
3241 __indirect_glMapGrid1f(GLint un
, GLfloat u1
, GLfloat u2
)
3243 __GLXcontext
*const gc
= __glXGetCurrentContext();
3244 const GLuint cmdlen
= 16;
3245 emit_header(gc
->pc
, X_GLrop_MapGrid1f
, cmdlen
);
3246 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&un
), 4);
3247 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&u1
), 4);
3248 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&u2
), 4);
3250 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
3251 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
3255 #define X_GLrop_MapGrid2d 149
3257 __indirect_glMapGrid2d(GLint un
, GLdouble u1
, GLdouble u2
, GLint vn
,
3258 GLdouble v1
, GLdouble v2
)
3260 __GLXcontext
*const gc
= __glXGetCurrentContext();
3261 const GLuint cmdlen
= 44;
3262 emit_header(gc
->pc
, X_GLrop_MapGrid2d
, cmdlen
);
3263 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&u1
), 8);
3264 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&u2
), 8);
3265 (void) memcpy((void *) (gc
->pc
+ 20), (void *) (&v1
), 8);
3266 (void) memcpy((void *) (gc
->pc
+ 28), (void *) (&v2
), 8);
3267 (void) memcpy((void *) (gc
->pc
+ 36), (void *) (&un
), 4);
3268 (void) memcpy((void *) (gc
->pc
+ 40), (void *) (&vn
), 4);
3270 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
3271 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
3275 #define X_GLrop_MapGrid2f 150
3277 __indirect_glMapGrid2f(GLint un
, GLfloat u1
, GLfloat u2
, GLint vn
, GLfloat v1
,
3280 __GLXcontext
*const gc
= __glXGetCurrentContext();
3281 const GLuint cmdlen
= 28;
3282 emit_header(gc
->pc
, X_GLrop_MapGrid2f
, cmdlen
);
3283 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&un
), 4);
3284 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&u1
), 4);
3285 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&u2
), 4);
3286 (void) memcpy((void *) (gc
->pc
+ 16), (void *) (&vn
), 4);
3287 (void) memcpy((void *) (gc
->pc
+ 20), (void *) (&v1
), 4);
3288 (void) memcpy((void *) (gc
->pc
+ 24), (void *) (&v2
), 4);
3290 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
3291 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
3295 #define X_GLrop_EvalCoord1dv 151
3297 __indirect_glEvalCoord1d(GLdouble u
)
3299 __GLXcontext
*const gc
= __glXGetCurrentContext();
3300 const GLuint cmdlen
= 12;
3301 emit_header(gc
->pc
, X_GLrop_EvalCoord1dv
, cmdlen
);
3302 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&u
), 8);
3304 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
3305 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
3309 #define X_GLrop_EvalCoord1dv 151
3311 __indirect_glEvalCoord1dv(const GLdouble
* u
)
3313 generic_8_byte(X_GLrop_EvalCoord1dv
, u
);
3316 #define X_GLrop_EvalCoord1fv 152
3318 __indirect_glEvalCoord1f(GLfloat u
)
3320 __GLXcontext
*const gc
= __glXGetCurrentContext();
3321 const GLuint cmdlen
= 8;
3322 emit_header(gc
->pc
, X_GLrop_EvalCoord1fv
, cmdlen
);
3323 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&u
), 4);
3325 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
3326 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
3330 #define X_GLrop_EvalCoord1fv 152
3332 __indirect_glEvalCoord1fv(const GLfloat
* u
)
3334 generic_4_byte(X_GLrop_EvalCoord1fv
, u
);
3337 #define X_GLrop_EvalCoord2dv 153
3339 __indirect_glEvalCoord2d(GLdouble u
, GLdouble v
)
3341 __GLXcontext
*const gc
= __glXGetCurrentContext();
3342 const GLuint cmdlen
= 20;
3343 emit_header(gc
->pc
, X_GLrop_EvalCoord2dv
, cmdlen
);
3344 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&u
), 8);
3345 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&v
), 8);
3347 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
3348 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
3352 #define X_GLrop_EvalCoord2dv 153
3354 __indirect_glEvalCoord2dv(const GLdouble
* u
)
3356 generic_16_byte(X_GLrop_EvalCoord2dv
, u
);
3359 #define X_GLrop_EvalCoord2fv 154
3361 __indirect_glEvalCoord2f(GLfloat u
, GLfloat v
)
3363 __GLXcontext
*const gc
= __glXGetCurrentContext();
3364 const GLuint cmdlen
= 12;
3365 emit_header(gc
->pc
, X_GLrop_EvalCoord2fv
, cmdlen
);
3366 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&u
), 4);
3367 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&v
), 4);
3369 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
3370 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
3374 #define X_GLrop_EvalCoord2fv 154
3376 __indirect_glEvalCoord2fv(const GLfloat
* u
)
3378 generic_8_byte(X_GLrop_EvalCoord2fv
, u
);
3381 #define X_GLrop_EvalMesh1 155
3383 __indirect_glEvalMesh1(GLenum mode
, GLint i1
, GLint i2
)
3385 __GLXcontext
*const gc
= __glXGetCurrentContext();
3386 const GLuint cmdlen
= 16;
3387 emit_header(gc
->pc
, X_GLrop_EvalMesh1
, cmdlen
);
3388 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&mode
), 4);
3389 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&i1
), 4);
3390 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&i2
), 4);
3392 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
3393 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
3397 #define X_GLrop_EvalPoint1 156
3399 __indirect_glEvalPoint1(GLint i
)
3401 __GLXcontext
*const gc
= __glXGetCurrentContext();
3402 const GLuint cmdlen
= 8;
3403 emit_header(gc
->pc
, X_GLrop_EvalPoint1
, cmdlen
);
3404 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&i
), 4);
3406 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
3407 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
3411 #define X_GLrop_EvalMesh2 157
3413 __indirect_glEvalMesh2(GLenum mode
, GLint i1
, GLint i2
, GLint j1
, GLint j2
)
3415 __GLXcontext
*const gc
= __glXGetCurrentContext();
3416 const GLuint cmdlen
= 24;
3417 emit_header(gc
->pc
, X_GLrop_EvalMesh2
, cmdlen
);
3418 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&mode
), 4);
3419 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&i1
), 4);
3420 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&i2
), 4);
3421 (void) memcpy((void *) (gc
->pc
+ 16), (void *) (&j1
), 4);
3422 (void) memcpy((void *) (gc
->pc
+ 20), (void *) (&j2
), 4);
3424 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
3425 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
3429 #define X_GLrop_EvalPoint2 158
3431 __indirect_glEvalPoint2(GLint i
, GLint j
)
3433 __GLXcontext
*const gc
= __glXGetCurrentContext();
3434 const GLuint cmdlen
= 12;
3435 emit_header(gc
->pc
, X_GLrop_EvalPoint2
, cmdlen
);
3436 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&i
), 4);
3437 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&j
), 4);
3439 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
3440 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
3444 #define X_GLrop_AlphaFunc 159
3446 __indirect_glAlphaFunc(GLenum func
, GLclampf ref
)
3448 __GLXcontext
*const gc
= __glXGetCurrentContext();
3449 const GLuint cmdlen
= 12;
3450 emit_header(gc
->pc
, X_GLrop_AlphaFunc
, cmdlen
);
3451 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&func
), 4);
3452 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&ref
), 4);
3454 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
3455 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
3459 #define X_GLrop_BlendFunc 160
3461 __indirect_glBlendFunc(GLenum sfactor
, GLenum dfactor
)
3463 __GLXcontext
*const gc
= __glXGetCurrentContext();
3464 const GLuint cmdlen
= 12;
3465 emit_header(gc
->pc
, X_GLrop_BlendFunc
, cmdlen
);
3466 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&sfactor
), 4);
3467 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&dfactor
), 4);
3469 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
3470 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
3474 #define X_GLrop_LogicOp 161
3476 __indirect_glLogicOp(GLenum opcode
)
3478 __GLXcontext
*const gc
= __glXGetCurrentContext();
3479 const GLuint cmdlen
= 8;
3480 emit_header(gc
->pc
, X_GLrop_LogicOp
, cmdlen
);
3481 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&opcode
), 4);
3483 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
3484 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
3488 #define X_GLrop_StencilFunc 162
3490 __indirect_glStencilFunc(GLenum func
, GLint ref
, GLuint mask
)
3492 __GLXcontext
*const gc
= __glXGetCurrentContext();
3493 const GLuint cmdlen
= 16;
3494 emit_header(gc
->pc
, X_GLrop_StencilFunc
, cmdlen
);
3495 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&func
), 4);
3496 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&ref
), 4);
3497 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&mask
), 4);
3499 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
3500 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
3504 #define X_GLrop_StencilOp 163
3506 __indirect_glStencilOp(GLenum fail
, GLenum zfail
, GLenum zpass
)
3508 __GLXcontext
*const gc
= __glXGetCurrentContext();
3509 const GLuint cmdlen
= 16;
3510 emit_header(gc
->pc
, X_GLrop_StencilOp
, cmdlen
);
3511 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&fail
), 4);
3512 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&zfail
), 4);
3513 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&zpass
), 4);
3515 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
3516 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
3520 #define X_GLrop_DepthFunc 164
3522 __indirect_glDepthFunc(GLenum func
)
3524 __GLXcontext
*const gc
= __glXGetCurrentContext();
3525 const GLuint cmdlen
= 8;
3526 emit_header(gc
->pc
, X_GLrop_DepthFunc
, cmdlen
);
3527 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&func
), 4);
3529 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
3530 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
3534 #define X_GLrop_PixelZoom 165
3536 __indirect_glPixelZoom(GLfloat xfactor
, GLfloat yfactor
)
3538 __GLXcontext
*const gc
= __glXGetCurrentContext();
3539 const GLuint cmdlen
= 12;
3540 emit_header(gc
->pc
, X_GLrop_PixelZoom
, cmdlen
);
3541 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&xfactor
), 4);
3542 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&yfactor
), 4);
3544 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
3545 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
3549 #define X_GLrop_PixelTransferf 166
3551 __indirect_glPixelTransferf(GLenum pname
, GLfloat param
)
3553 __GLXcontext
*const gc
= __glXGetCurrentContext();
3554 const GLuint cmdlen
= 12;
3555 emit_header(gc
->pc
, X_GLrop_PixelTransferf
, cmdlen
);
3556 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&pname
), 4);
3557 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (¶m
), 4);
3559 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
3560 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
3564 #define X_GLrop_PixelTransferi 167
3566 __indirect_glPixelTransferi(GLenum pname
, GLint param
)
3568 __GLXcontext
*const gc
= __glXGetCurrentContext();
3569 const GLuint cmdlen
= 12;
3570 emit_header(gc
->pc
, X_GLrop_PixelTransferi
, cmdlen
);
3571 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&pname
), 4);
3572 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (¶m
), 4);
3574 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
3575 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
3579 #define X_GLrop_PixelMapfv 168
3581 __indirect_glPixelMapfv(GLenum map
, GLsizei mapsize
, const GLfloat
* values
)
3583 __GLXcontext
*const gc
= __glXGetCurrentContext();
3584 const GLuint cmdlen
= 12 + __GLX_PAD((mapsize
* 4));
3585 if (__builtin_expect((mapsize
>= 0) && (gc
->currentDpy
!= NULL
), 1)) {
3586 if (cmdlen
<= gc
->maxSmallRenderCommandSize
) {
3587 if ((gc
->pc
+ cmdlen
) > gc
->bufEnd
) {
3588 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
3590 emit_header(gc
->pc
, X_GLrop_PixelMapfv
, cmdlen
);
3591 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&map
), 4);
3592 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&mapsize
), 4);
3593 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (values
),
3596 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
3597 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
3600 const GLint op
= X_GLrop_PixelMapfv
;
3601 const GLuint cmdlenLarge
= cmdlen
+ 4;
3602 GLubyte
*const pc
= __glXFlushRenderBuffer(gc
, gc
->pc
);
3603 (void) memcpy((void *) (pc
+ 0), (void *) (&cmdlenLarge
), 4);
3604 (void) memcpy((void *) (pc
+ 4), (void *) (&op
), 4);
3605 (void) memcpy((void *) (pc
+ 8), (void *) (&map
), 4);
3606 (void) memcpy((void *) (pc
+ 12), (void *) (&mapsize
), 4);
3607 __glXSendLargeCommand(gc
, pc
, 16, values
, (mapsize
* 4));
3612 #define X_GLrop_PixelMapuiv 169
3614 __indirect_glPixelMapuiv(GLenum map
, GLsizei mapsize
, const GLuint
* values
)
3616 __GLXcontext
*const gc
= __glXGetCurrentContext();
3617 const GLuint cmdlen
= 12 + __GLX_PAD((mapsize
* 4));
3618 if (__builtin_expect((mapsize
>= 0) && (gc
->currentDpy
!= NULL
), 1)) {
3619 if (cmdlen
<= gc
->maxSmallRenderCommandSize
) {
3620 if ((gc
->pc
+ cmdlen
) > gc
->bufEnd
) {
3621 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
3623 emit_header(gc
->pc
, X_GLrop_PixelMapuiv
, cmdlen
);
3624 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&map
), 4);
3625 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&mapsize
), 4);
3626 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (values
),
3629 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
3630 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
3633 const GLint op
= X_GLrop_PixelMapuiv
;
3634 const GLuint cmdlenLarge
= cmdlen
+ 4;
3635 GLubyte
*const pc
= __glXFlushRenderBuffer(gc
, gc
->pc
);
3636 (void) memcpy((void *) (pc
+ 0), (void *) (&cmdlenLarge
), 4);
3637 (void) memcpy((void *) (pc
+ 4), (void *) (&op
), 4);
3638 (void) memcpy((void *) (pc
+ 8), (void *) (&map
), 4);
3639 (void) memcpy((void *) (pc
+ 12), (void *) (&mapsize
), 4);
3640 __glXSendLargeCommand(gc
, pc
, 16, values
, (mapsize
* 4));
3645 #define X_GLrop_PixelMapusv 170
3647 __indirect_glPixelMapusv(GLenum map
, GLsizei mapsize
, const GLushort
* values
)
3649 __GLXcontext
*const gc
= __glXGetCurrentContext();
3650 const GLuint cmdlen
= 12 + __GLX_PAD((mapsize
* 2));
3651 if (__builtin_expect((mapsize
>= 0) && (gc
->currentDpy
!= NULL
), 1)) {
3652 if (cmdlen
<= gc
->maxSmallRenderCommandSize
) {
3653 if ((gc
->pc
+ cmdlen
) > gc
->bufEnd
) {
3654 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
3656 emit_header(gc
->pc
, X_GLrop_PixelMapusv
, cmdlen
);
3657 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&map
), 4);
3658 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&mapsize
), 4);
3659 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (values
),
3662 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
3663 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
3666 const GLint op
= X_GLrop_PixelMapusv
;
3667 const GLuint cmdlenLarge
= cmdlen
+ 4;
3668 GLubyte
*const pc
= __glXFlushRenderBuffer(gc
, gc
->pc
);
3669 (void) memcpy((void *) (pc
+ 0), (void *) (&cmdlenLarge
), 4);
3670 (void) memcpy((void *) (pc
+ 4), (void *) (&op
), 4);
3671 (void) memcpy((void *) (pc
+ 8), (void *) (&map
), 4);
3672 (void) memcpy((void *) (pc
+ 12), (void *) (&mapsize
), 4);
3673 __glXSendLargeCommand(gc
, pc
, 16, values
, (mapsize
* 2));
3678 #define X_GLrop_ReadBuffer 171
3680 __indirect_glReadBuffer(GLenum mode
)
3682 __GLXcontext
*const gc
= __glXGetCurrentContext();
3683 const GLuint cmdlen
= 8;
3684 emit_header(gc
->pc
, X_GLrop_ReadBuffer
, cmdlen
);
3685 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&mode
), 4);
3687 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
3688 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
3692 #define X_GLrop_CopyPixels 172
3694 __indirect_glCopyPixels(GLint x
, GLint y
, GLsizei width
, GLsizei height
,
3697 __GLXcontext
*const gc
= __glXGetCurrentContext();
3698 const GLuint cmdlen
= 24;
3699 emit_header(gc
->pc
, X_GLrop_CopyPixels
, cmdlen
);
3700 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&x
), 4);
3701 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&y
), 4);
3702 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&width
), 4);
3703 (void) memcpy((void *) (gc
->pc
+ 16), (void *) (&height
), 4);
3704 (void) memcpy((void *) (gc
->pc
+ 20), (void *) (&type
), 4);
3706 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
3707 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
3711 #define X_GLsop_ReadPixels 111
3713 __indirect_glReadPixels(GLint x
, GLint y
, GLsizei width
, GLsizei height
,
3714 GLenum format
, GLenum type
, GLvoid
* pixels
)
3716 __GLXcontext
*const gc
= __glXGetCurrentContext();
3717 const __GLXattribute
*const state
= gc
->client_state_private
;
3718 Display
*const dpy
= gc
->currentDpy
;
3719 const GLuint cmdlen
= 28;
3720 if (__builtin_expect(dpy
!= NULL
, 1)) {
3722 xcb_connection_t
*c
= XGetXCBConnection(dpy
);
3723 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
3724 xcb_glx_read_pixels_reply_t
*reply
=
3725 xcb_glx_read_pixels_reply(c
,
3726 xcb_glx_read_pixels(c
,
3729 x
, y
, width
, height
,
3734 (void) memcpy(pixels
, xcb_glx_read_pixels_data(reply
),
3735 xcb_glx_read_pixels_data_length(reply
) *
3740 __glXSetupSingleRequest(gc
, X_GLsop_ReadPixels
, cmdlen
);
3741 (void) memcpy((void *) (pc
+ 0), (void *) (&x
), 4);
3742 (void) memcpy((void *) (pc
+ 4), (void *) (&y
), 4);
3743 (void) memcpy((void *) (pc
+ 8), (void *) (&width
), 4);
3744 (void) memcpy((void *) (pc
+ 12), (void *) (&height
), 4);
3745 (void) memcpy((void *) (pc
+ 16), (void *) (&format
), 4);
3746 (void) memcpy((void *) (pc
+ 20), (void *) (&type
), 4);
3747 *(int32_t *) (pc
+ 24) = 0;
3748 *(int8_t *) (pc
+ 24) = state
->storePack
.swapEndian
;
3749 __glXReadPixelReply(dpy
, gc
, 2, width
, height
, 1, format
, type
,
3753 #endif /* USE_XCB */
3758 #define X_GLrop_DrawPixels 173
3760 __indirect_glDrawPixels(GLsizei width
, GLsizei height
, GLenum format
,
3761 GLenum type
, const GLvoid
* pixels
)
3763 __GLXcontext
*const gc
= __glXGetCurrentContext();
3764 const GLuint compsize
=
3765 (pixels
!= NULL
) ? __glImageSize(width
, height
, 1, format
, type
,
3767 const GLuint cmdlen
= 40 + __GLX_PAD(compsize
);
3768 if (__builtin_expect(gc
->currentDpy
!= NULL
, 1)) {
3769 if (cmdlen
<= gc
->maxSmallRenderCommandSize
) {
3770 if ((gc
->pc
+ cmdlen
) > gc
->bufEnd
) {
3771 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
3773 emit_header(gc
->pc
, X_GLrop_DrawPixels
, cmdlen
);
3774 (void) memcpy((void *) (gc
->pc
+ 24), (void *) (&width
), 4);
3775 (void) memcpy((void *) (gc
->pc
+ 28), (void *) (&height
), 4);
3776 (void) memcpy((void *) (gc
->pc
+ 32), (void *) (&format
), 4);
3777 (void) memcpy((void *) (gc
->pc
+ 36), (void *) (&type
), 4);
3779 (*gc
->fillImage
) (gc
, 2, width
, height
, 1, format
, type
,
3780 pixels
, gc
->pc
+ 40, gc
->pc
+ 4);
3782 (void) memcpy(gc
->pc
+ 4, default_pixel_store_2D
,
3783 default_pixel_store_2D_size
);
3786 if (gc
->pc
> gc
->limit
) {
3787 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
3790 const GLint op
= X_GLrop_DrawPixels
;
3791 const GLuint cmdlenLarge
= cmdlen
+ 4;
3792 GLubyte
*const pc
= __glXFlushRenderBuffer(gc
, gc
->pc
);
3793 (void) memcpy((void *) (pc
+ 0), (void *) (&cmdlenLarge
), 4);
3794 (void) memcpy((void *) (pc
+ 4), (void *) (&op
), 4);
3795 (void) memcpy((void *) (pc
+ 28), (void *) (&width
), 4);
3796 (void) memcpy((void *) (pc
+ 32), (void *) (&height
), 4);
3797 (void) memcpy((void *) (pc
+ 36), (void *) (&format
), 4);
3798 (void) memcpy((void *) (pc
+ 40), (void *) (&type
), 4);
3799 __glXSendLargeImage(gc
, compsize
, 2, width
, height
, 1, format
,
3800 type
, pixels
, pc
+ 44, pc
+ 8);
3805 #define X_GLsop_GetClipPlane 113
3807 __indirect_glGetClipPlane(GLenum plane
, GLdouble
* equation
)
3809 __GLXcontext
*const gc
= __glXGetCurrentContext();
3810 Display
*const dpy
= gc
->currentDpy
;
3811 const GLuint cmdlen
= 4;
3812 if (__builtin_expect(dpy
!= NULL
, 1)) {
3814 xcb_connection_t
*c
= XGetXCBConnection(dpy
);
3815 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
3816 xcb_glx_get_clip_plane_reply_t
*reply
=
3817 xcb_glx_get_clip_plane_reply(c
,
3818 xcb_glx_get_clip_plane(c
,
3822 (void) memcpy(equation
, xcb_glx_get_clip_plane_data(reply
),
3823 xcb_glx_get_clip_plane_data_length(reply
) *
3828 __glXSetupSingleRequest(gc
, X_GLsop_GetClipPlane
, cmdlen
);
3829 (void) memcpy((void *) (pc
+ 0), (void *) (&plane
), 4);
3830 (void) __glXReadReply(dpy
, 8, equation
, GL_TRUE
);
3833 #endif /* USE_XCB */
3838 #define X_GLsop_GetLightfv 118
3840 __indirect_glGetLightfv(GLenum light
, GLenum pname
, GLfloat
* params
)
3842 __GLXcontext
*const gc
= __glXGetCurrentContext();
3843 Display
*const dpy
= gc
->currentDpy
;
3844 const GLuint cmdlen
= 8;
3845 if (__builtin_expect(dpy
!= NULL
, 1)) {
3847 xcb_connection_t
*c
= XGetXCBConnection(dpy
);
3848 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
3849 xcb_glx_get_lightfv_reply_t
*reply
=
3850 xcb_glx_get_lightfv_reply(c
,
3851 xcb_glx_get_lightfv(c
,
3856 if (xcb_glx_get_lightfv_data_length(reply
) == 0)
3857 (void) memcpy(params
, &reply
->datum
, sizeof(reply
->datum
));
3859 (void) memcpy(params
, xcb_glx_get_lightfv_data(reply
),
3860 xcb_glx_get_lightfv_data_length(reply
) *
3865 __glXSetupSingleRequest(gc
, X_GLsop_GetLightfv
, cmdlen
);
3866 (void) memcpy((void *) (pc
+ 0), (void *) (&light
), 4);
3867 (void) memcpy((void *) (pc
+ 4), (void *) (&pname
), 4);
3868 (void) __glXReadReply(dpy
, 4, params
, GL_FALSE
);
3871 #endif /* USE_XCB */
3876 #define X_GLsop_GetLightiv 119
3878 __indirect_glGetLightiv(GLenum light
, GLenum pname
, GLint
* params
)
3880 __GLXcontext
*const gc
= __glXGetCurrentContext();
3881 Display
*const dpy
= gc
->currentDpy
;
3882 const GLuint cmdlen
= 8;
3883 if (__builtin_expect(dpy
!= NULL
, 1)) {
3885 xcb_connection_t
*c
= XGetXCBConnection(dpy
);
3886 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
3887 xcb_glx_get_lightiv_reply_t
*reply
=
3888 xcb_glx_get_lightiv_reply(c
,
3889 xcb_glx_get_lightiv(c
,
3894 if (xcb_glx_get_lightiv_data_length(reply
) == 0)
3895 (void) memcpy(params
, &reply
->datum
, sizeof(reply
->datum
));
3897 (void) memcpy(params
, xcb_glx_get_lightiv_data(reply
),
3898 xcb_glx_get_lightiv_data_length(reply
) *
3903 __glXSetupSingleRequest(gc
, X_GLsop_GetLightiv
, cmdlen
);
3904 (void) memcpy((void *) (pc
+ 0), (void *) (&light
), 4);
3905 (void) memcpy((void *) (pc
+ 4), (void *) (&pname
), 4);
3906 (void) __glXReadReply(dpy
, 4, params
, GL_FALSE
);
3909 #endif /* USE_XCB */
3914 #define X_GLsop_GetMapdv 120
3916 __indirect_glGetMapdv(GLenum target
, GLenum query
, GLdouble
* v
)
3918 __GLXcontext
*const gc
= __glXGetCurrentContext();
3919 Display
*const dpy
= gc
->currentDpy
;
3920 const GLuint cmdlen
= 8;
3921 if (__builtin_expect(dpy
!= NULL
, 1)) {
3923 xcb_connection_t
*c
= XGetXCBConnection(dpy
);
3924 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
3925 xcb_glx_get_mapdv_reply_t
*reply
=
3926 xcb_glx_get_mapdv_reply(c
,
3927 xcb_glx_get_mapdv(c
,
3928 gc
->currentContextTag
,
3929 target
, query
), NULL
);
3930 if (xcb_glx_get_mapdv_data_length(reply
) == 0)
3931 (void) memcpy(v
, &reply
->datum
, sizeof(reply
->datum
));
3933 (void) memcpy(v
, xcb_glx_get_mapdv_data(reply
),
3934 xcb_glx_get_mapdv_data_length(reply
) *
3939 __glXSetupSingleRequest(gc
, X_GLsop_GetMapdv
, cmdlen
);
3940 (void) memcpy((void *) (pc
+ 0), (void *) (&target
), 4);
3941 (void) memcpy((void *) (pc
+ 4), (void *) (&query
), 4);
3942 (void) __glXReadReply(dpy
, 8, v
, GL_FALSE
);
3945 #endif /* USE_XCB */
3950 #define X_GLsop_GetMapfv 121
3952 __indirect_glGetMapfv(GLenum target
, GLenum query
, GLfloat
* v
)
3954 __GLXcontext
*const gc
= __glXGetCurrentContext();
3955 Display
*const dpy
= gc
->currentDpy
;
3956 const GLuint cmdlen
= 8;
3957 if (__builtin_expect(dpy
!= NULL
, 1)) {
3959 xcb_connection_t
*c
= XGetXCBConnection(dpy
);
3960 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
3961 xcb_glx_get_mapfv_reply_t
*reply
=
3962 xcb_glx_get_mapfv_reply(c
,
3963 xcb_glx_get_mapfv(c
,
3964 gc
->currentContextTag
,
3965 target
, query
), NULL
);
3966 if (xcb_glx_get_mapfv_data_length(reply
) == 0)
3967 (void) memcpy(v
, &reply
->datum
, sizeof(reply
->datum
));
3969 (void) memcpy(v
, xcb_glx_get_mapfv_data(reply
),
3970 xcb_glx_get_mapfv_data_length(reply
) *
3975 __glXSetupSingleRequest(gc
, X_GLsop_GetMapfv
, cmdlen
);
3976 (void) memcpy((void *) (pc
+ 0), (void *) (&target
), 4);
3977 (void) memcpy((void *) (pc
+ 4), (void *) (&query
), 4);
3978 (void) __glXReadReply(dpy
, 4, v
, GL_FALSE
);
3981 #endif /* USE_XCB */
3986 #define X_GLsop_GetMapiv 122
3988 __indirect_glGetMapiv(GLenum target
, GLenum query
, GLint
* v
)
3990 __GLXcontext
*const gc
= __glXGetCurrentContext();
3991 Display
*const dpy
= gc
->currentDpy
;
3992 const GLuint cmdlen
= 8;
3993 if (__builtin_expect(dpy
!= NULL
, 1)) {
3995 xcb_connection_t
*c
= XGetXCBConnection(dpy
);
3996 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
3997 xcb_glx_get_mapiv_reply_t
*reply
=
3998 xcb_glx_get_mapiv_reply(c
,
3999 xcb_glx_get_mapiv(c
,
4000 gc
->currentContextTag
,
4001 target
, query
), NULL
);
4002 if (xcb_glx_get_mapiv_data_length(reply
) == 0)
4003 (void) memcpy(v
, &reply
->datum
, sizeof(reply
->datum
));
4005 (void) memcpy(v
, xcb_glx_get_mapiv_data(reply
),
4006 xcb_glx_get_mapiv_data_length(reply
) *
4011 __glXSetupSingleRequest(gc
, X_GLsop_GetMapiv
, cmdlen
);
4012 (void) memcpy((void *) (pc
+ 0), (void *) (&target
), 4);
4013 (void) memcpy((void *) (pc
+ 4), (void *) (&query
), 4);
4014 (void) __glXReadReply(dpy
, 4, v
, GL_FALSE
);
4017 #endif /* USE_XCB */
4022 #define X_GLsop_GetMaterialfv 123
4024 __indirect_glGetMaterialfv(GLenum face
, GLenum pname
, GLfloat
* params
)
4026 __GLXcontext
*const gc
= __glXGetCurrentContext();
4027 Display
*const dpy
= gc
->currentDpy
;
4028 const GLuint cmdlen
= 8;
4029 if (__builtin_expect(dpy
!= NULL
, 1)) {
4031 xcb_connection_t
*c
= XGetXCBConnection(dpy
);
4032 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
4033 xcb_glx_get_materialfv_reply_t
*reply
=
4034 xcb_glx_get_materialfv_reply(c
,
4035 xcb_glx_get_materialfv(c
,
4040 if (xcb_glx_get_materialfv_data_length(reply
) == 0)
4041 (void) memcpy(params
, &reply
->datum
, sizeof(reply
->datum
));
4043 (void) memcpy(params
, xcb_glx_get_materialfv_data(reply
),
4044 xcb_glx_get_materialfv_data_length(reply
) *
4049 __glXSetupSingleRequest(gc
, X_GLsop_GetMaterialfv
, cmdlen
);
4050 (void) memcpy((void *) (pc
+ 0), (void *) (&face
), 4);
4051 (void) memcpy((void *) (pc
+ 4), (void *) (&pname
), 4);
4052 (void) __glXReadReply(dpy
, 4, params
, GL_FALSE
);
4055 #endif /* USE_XCB */
4060 #define X_GLsop_GetMaterialiv 124
4062 __indirect_glGetMaterialiv(GLenum face
, GLenum pname
, GLint
* params
)
4064 __GLXcontext
*const gc
= __glXGetCurrentContext();
4065 Display
*const dpy
= gc
->currentDpy
;
4066 const GLuint cmdlen
= 8;
4067 if (__builtin_expect(dpy
!= NULL
, 1)) {
4069 xcb_connection_t
*c
= XGetXCBConnection(dpy
);
4070 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
4071 xcb_glx_get_materialiv_reply_t
*reply
=
4072 xcb_glx_get_materialiv_reply(c
,
4073 xcb_glx_get_materialiv(c
,
4078 if (xcb_glx_get_materialiv_data_length(reply
) == 0)
4079 (void) memcpy(params
, &reply
->datum
, sizeof(reply
->datum
));
4081 (void) memcpy(params
, xcb_glx_get_materialiv_data(reply
),
4082 xcb_glx_get_materialiv_data_length(reply
) *
4087 __glXSetupSingleRequest(gc
, X_GLsop_GetMaterialiv
, cmdlen
);
4088 (void) memcpy((void *) (pc
+ 0), (void *) (&face
), 4);
4089 (void) memcpy((void *) (pc
+ 4), (void *) (&pname
), 4);
4090 (void) __glXReadReply(dpy
, 4, params
, GL_FALSE
);
4093 #endif /* USE_XCB */
4098 #define X_GLsop_GetPixelMapfv 125
4100 __indirect_glGetPixelMapfv(GLenum map
, GLfloat
* values
)
4102 __GLXcontext
*const gc
= __glXGetCurrentContext();
4103 Display
*const dpy
= gc
->currentDpy
;
4104 const GLuint cmdlen
= 4;
4105 if (__builtin_expect(dpy
!= NULL
, 1)) {
4107 xcb_connection_t
*c
= XGetXCBConnection(dpy
);
4108 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
4109 xcb_glx_get_pixel_mapfv_reply_t
*reply
=
4110 xcb_glx_get_pixel_mapfv_reply(c
,
4111 xcb_glx_get_pixel_mapfv(c
,
4115 if (xcb_glx_get_pixel_mapfv_data_length(reply
) == 0)
4116 (void) memcpy(values
, &reply
->datum
, sizeof(reply
->datum
));
4118 (void) memcpy(values
, xcb_glx_get_pixel_mapfv_data(reply
),
4119 xcb_glx_get_pixel_mapfv_data_length(reply
) *
4124 __glXSetupSingleRequest(gc
, X_GLsop_GetPixelMapfv
, cmdlen
);
4125 (void) memcpy((void *) (pc
+ 0), (void *) (&map
), 4);
4126 (void) __glXReadReply(dpy
, 4, values
, GL_FALSE
);
4129 #endif /* USE_XCB */
4134 #define X_GLsop_GetPixelMapuiv 126
4136 __indirect_glGetPixelMapuiv(GLenum map
, GLuint
* values
)
4138 __GLXcontext
*const gc
= __glXGetCurrentContext();
4139 Display
*const dpy
= gc
->currentDpy
;
4140 const GLuint cmdlen
= 4;
4141 if (__builtin_expect(dpy
!= NULL
, 1)) {
4143 xcb_connection_t
*c
= XGetXCBConnection(dpy
);
4144 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
4145 xcb_glx_get_pixel_mapuiv_reply_t
*reply
=
4146 xcb_glx_get_pixel_mapuiv_reply(c
,
4147 xcb_glx_get_pixel_mapuiv(c
,
4152 if (xcb_glx_get_pixel_mapuiv_data_length(reply
) == 0)
4153 (void) memcpy(values
, &reply
->datum
, sizeof(reply
->datum
));
4155 (void) memcpy(values
, xcb_glx_get_pixel_mapuiv_data(reply
),
4156 xcb_glx_get_pixel_mapuiv_data_length(reply
) *
4161 __glXSetupSingleRequest(gc
, X_GLsop_GetPixelMapuiv
, cmdlen
);
4162 (void) memcpy((void *) (pc
+ 0), (void *) (&map
), 4);
4163 (void) __glXReadReply(dpy
, 4, values
, GL_FALSE
);
4166 #endif /* USE_XCB */
4171 #define X_GLsop_GetPixelMapusv 127
4173 __indirect_glGetPixelMapusv(GLenum map
, GLushort
* values
)
4175 __GLXcontext
*const gc
= __glXGetCurrentContext();
4176 Display
*const dpy
= gc
->currentDpy
;
4177 const GLuint cmdlen
= 4;
4178 if (__builtin_expect(dpy
!= NULL
, 1)) {
4180 xcb_connection_t
*c
= XGetXCBConnection(dpy
);
4181 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
4182 xcb_glx_get_pixel_mapusv_reply_t
*reply
=
4183 xcb_glx_get_pixel_mapusv_reply(c
,
4184 xcb_glx_get_pixel_mapusv(c
,
4189 if (xcb_glx_get_pixel_mapusv_data_length(reply
) == 0)
4190 (void) memcpy(values
, &reply
->datum
, sizeof(reply
->datum
));
4192 (void) memcpy(values
, xcb_glx_get_pixel_mapusv_data(reply
),
4193 xcb_glx_get_pixel_mapusv_data_length(reply
) *
4198 __glXSetupSingleRequest(gc
, X_GLsop_GetPixelMapusv
, cmdlen
);
4199 (void) memcpy((void *) (pc
+ 0), (void *) (&map
), 4);
4200 (void) __glXReadReply(dpy
, 2, values
, GL_FALSE
);
4203 #endif /* USE_XCB */
4208 #define X_GLsop_GetPolygonStipple 128
4210 __indirect_glGetPolygonStipple(GLubyte
* mask
)
4212 __GLXcontext
*const gc
= __glXGetCurrentContext();
4213 const __GLXattribute
*const state
= gc
->client_state_private
;
4214 Display
*const dpy
= gc
->currentDpy
;
4215 const GLuint cmdlen
= 4;
4216 if (__builtin_expect(dpy
!= NULL
, 1)) {
4218 xcb_connection_t
*c
= XGetXCBConnection(dpy
);
4219 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
4220 xcb_glx_get_polygon_stipple_reply_t
*reply
=
4221 xcb_glx_get_polygon_stipple_reply(c
,
4222 xcb_glx_get_polygon_stipple(c
,
4227 (void) memcpy(mask
, xcb_glx_get_polygon_stipple_data(reply
),
4228 xcb_glx_get_polygon_stipple_data_length(reply
) *
4233 __glXSetupSingleRequest(gc
, X_GLsop_GetPolygonStipple
, cmdlen
);
4234 *(int32_t *) (pc
+ 0) = 0;
4235 __glXReadPixelReply(dpy
, gc
, 2, 32, 32, 1, GL_COLOR_INDEX
, GL_BITMAP
,
4239 #endif /* USE_XCB */
4244 #define X_GLsop_GetTexEnvfv 130
4246 __indirect_glGetTexEnvfv(GLenum target
, GLenum pname
, GLfloat
* params
)
4248 __GLXcontext
*const gc
= __glXGetCurrentContext();
4249 Display
*const dpy
= gc
->currentDpy
;
4250 const GLuint cmdlen
= 8;
4251 if (__builtin_expect(dpy
!= NULL
, 1)) {
4253 xcb_connection_t
*c
= XGetXCBConnection(dpy
);
4254 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
4255 xcb_glx_get_tex_envfv_reply_t
*reply
=
4256 xcb_glx_get_tex_envfv_reply(c
,
4257 xcb_glx_get_tex_envfv(c
,
4262 if (xcb_glx_get_tex_envfv_data_length(reply
) == 0)
4263 (void) memcpy(params
, &reply
->datum
, sizeof(reply
->datum
));
4265 (void) memcpy(params
, xcb_glx_get_tex_envfv_data(reply
),
4266 xcb_glx_get_tex_envfv_data_length(reply
) *
4271 __glXSetupSingleRequest(gc
, X_GLsop_GetTexEnvfv
, cmdlen
);
4272 (void) memcpy((void *) (pc
+ 0), (void *) (&target
), 4);
4273 (void) memcpy((void *) (pc
+ 4), (void *) (&pname
), 4);
4274 (void) __glXReadReply(dpy
, 4, params
, GL_FALSE
);
4277 #endif /* USE_XCB */
4282 #define X_GLsop_GetTexEnviv 131
4284 __indirect_glGetTexEnviv(GLenum target
, GLenum pname
, GLint
* params
)
4286 __GLXcontext
*const gc
= __glXGetCurrentContext();
4287 Display
*const dpy
= gc
->currentDpy
;
4288 const GLuint cmdlen
= 8;
4289 if (__builtin_expect(dpy
!= NULL
, 1)) {
4291 xcb_connection_t
*c
= XGetXCBConnection(dpy
);
4292 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
4293 xcb_glx_get_tex_enviv_reply_t
*reply
=
4294 xcb_glx_get_tex_enviv_reply(c
,
4295 xcb_glx_get_tex_enviv(c
,
4300 if (xcb_glx_get_tex_enviv_data_length(reply
) == 0)
4301 (void) memcpy(params
, &reply
->datum
, sizeof(reply
->datum
));
4303 (void) memcpy(params
, xcb_glx_get_tex_enviv_data(reply
),
4304 xcb_glx_get_tex_enviv_data_length(reply
) *
4309 __glXSetupSingleRequest(gc
, X_GLsop_GetTexEnviv
, cmdlen
);
4310 (void) memcpy((void *) (pc
+ 0), (void *) (&target
), 4);
4311 (void) memcpy((void *) (pc
+ 4), (void *) (&pname
), 4);
4312 (void) __glXReadReply(dpy
, 4, params
, GL_FALSE
);
4315 #endif /* USE_XCB */
4320 #define X_GLsop_GetTexGendv 132
4322 __indirect_glGetTexGendv(GLenum coord
, GLenum pname
, GLdouble
* params
)
4324 __GLXcontext
*const gc
= __glXGetCurrentContext();
4325 Display
*const dpy
= gc
->currentDpy
;
4326 const GLuint cmdlen
= 8;
4327 if (__builtin_expect(dpy
!= NULL
, 1)) {
4329 xcb_connection_t
*c
= XGetXCBConnection(dpy
);
4330 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
4331 xcb_glx_get_tex_gendv_reply_t
*reply
=
4332 xcb_glx_get_tex_gendv_reply(c
,
4333 xcb_glx_get_tex_gendv(c
,
4338 if (xcb_glx_get_tex_gendv_data_length(reply
) == 0)
4339 (void) memcpy(params
, &reply
->datum
, sizeof(reply
->datum
));
4341 (void) memcpy(params
, xcb_glx_get_tex_gendv_data(reply
),
4342 xcb_glx_get_tex_gendv_data_length(reply
) *
4347 __glXSetupSingleRequest(gc
, X_GLsop_GetTexGendv
, cmdlen
);
4348 (void) memcpy((void *) (pc
+ 0), (void *) (&coord
), 4);
4349 (void) memcpy((void *) (pc
+ 4), (void *) (&pname
), 4);
4350 (void) __glXReadReply(dpy
, 8, params
, GL_FALSE
);
4353 #endif /* USE_XCB */
4358 #define X_GLsop_GetTexGenfv 133
4360 __indirect_glGetTexGenfv(GLenum coord
, GLenum pname
, GLfloat
* params
)
4362 __GLXcontext
*const gc
= __glXGetCurrentContext();
4363 Display
*const dpy
= gc
->currentDpy
;
4364 const GLuint cmdlen
= 8;
4365 if (__builtin_expect(dpy
!= NULL
, 1)) {
4367 xcb_connection_t
*c
= XGetXCBConnection(dpy
);
4368 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
4369 xcb_glx_get_tex_genfv_reply_t
*reply
=
4370 xcb_glx_get_tex_genfv_reply(c
,
4371 xcb_glx_get_tex_genfv(c
,
4376 if (xcb_glx_get_tex_genfv_data_length(reply
) == 0)
4377 (void) memcpy(params
, &reply
->datum
, sizeof(reply
->datum
));
4379 (void) memcpy(params
, xcb_glx_get_tex_genfv_data(reply
),
4380 xcb_glx_get_tex_genfv_data_length(reply
) *
4385 __glXSetupSingleRequest(gc
, X_GLsop_GetTexGenfv
, cmdlen
);
4386 (void) memcpy((void *) (pc
+ 0), (void *) (&coord
), 4);
4387 (void) memcpy((void *) (pc
+ 4), (void *) (&pname
), 4);
4388 (void) __glXReadReply(dpy
, 4, params
, GL_FALSE
);
4391 #endif /* USE_XCB */
4396 #define X_GLsop_GetTexGeniv 134
4398 __indirect_glGetTexGeniv(GLenum coord
, GLenum pname
, GLint
* params
)
4400 __GLXcontext
*const gc
= __glXGetCurrentContext();
4401 Display
*const dpy
= gc
->currentDpy
;
4402 const GLuint cmdlen
= 8;
4403 if (__builtin_expect(dpy
!= NULL
, 1)) {
4405 xcb_connection_t
*c
= XGetXCBConnection(dpy
);
4406 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
4407 xcb_glx_get_tex_geniv_reply_t
*reply
=
4408 xcb_glx_get_tex_geniv_reply(c
,
4409 xcb_glx_get_tex_geniv(c
,
4414 if (xcb_glx_get_tex_geniv_data_length(reply
) == 0)
4415 (void) memcpy(params
, &reply
->datum
, sizeof(reply
->datum
));
4417 (void) memcpy(params
, xcb_glx_get_tex_geniv_data(reply
),
4418 xcb_glx_get_tex_geniv_data_length(reply
) *
4423 __glXSetupSingleRequest(gc
, X_GLsop_GetTexGeniv
, cmdlen
);
4424 (void) memcpy((void *) (pc
+ 0), (void *) (&coord
), 4);
4425 (void) memcpy((void *) (pc
+ 4), (void *) (&pname
), 4);
4426 (void) __glXReadReply(dpy
, 4, params
, GL_FALSE
);
4429 #endif /* USE_XCB */
4434 #define X_GLsop_GetTexImage 135
4436 __indirect_glGetTexImage(GLenum target
, GLint level
, GLenum format
,
4437 GLenum type
, GLvoid
* pixels
)
4439 __GLXcontext
*const gc
= __glXGetCurrentContext();
4440 const __GLXattribute
*const state
= gc
->client_state_private
;
4441 Display
*const dpy
= gc
->currentDpy
;
4442 const GLuint cmdlen
= 20;
4443 if (__builtin_expect(dpy
!= NULL
, 1)) {
4445 xcb_connection_t
*c
= XGetXCBConnection(dpy
);
4446 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
4447 xcb_glx_get_tex_image_reply_t
*reply
=
4448 xcb_glx_get_tex_image_reply(c
,
4449 xcb_glx_get_tex_image(c
,
4458 (void) memcpy(pixels
, xcb_glx_get_tex_image_data(reply
),
4459 xcb_glx_get_tex_image_data_length(reply
) *
4464 __glXSetupSingleRequest(gc
, X_GLsop_GetTexImage
, cmdlen
);
4465 (void) memcpy((void *) (pc
+ 0), (void *) (&target
), 4);
4466 (void) memcpy((void *) (pc
+ 4), (void *) (&level
), 4);
4467 (void) memcpy((void *) (pc
+ 8), (void *) (&format
), 4);
4468 (void) memcpy((void *) (pc
+ 12), (void *) (&type
), 4);
4469 *(int32_t *) (pc
+ 16) = 0;
4470 *(int8_t *) (pc
+ 16) = state
->storePack
.swapEndian
;
4471 __glXReadPixelReply(dpy
, gc
, 3, 0, 0, 0, format
, type
, pixels
,
4475 #endif /* USE_XCB */
4480 #define X_GLsop_GetTexParameterfv 136
4482 __indirect_glGetTexParameterfv(GLenum target
, GLenum pname
, GLfloat
* params
)
4484 __GLXcontext
*const gc
= __glXGetCurrentContext();
4485 Display
*const dpy
= gc
->currentDpy
;
4486 const GLuint cmdlen
= 8;
4487 if (__builtin_expect(dpy
!= NULL
, 1)) {
4489 xcb_connection_t
*c
= XGetXCBConnection(dpy
);
4490 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
4491 xcb_glx_get_tex_parameterfv_reply_t
*reply
=
4492 xcb_glx_get_tex_parameterfv_reply(c
,
4493 xcb_glx_get_tex_parameterfv(c
,
4499 if (xcb_glx_get_tex_parameterfv_data_length(reply
) == 0)
4500 (void) memcpy(params
, &reply
->datum
, sizeof(reply
->datum
));
4502 (void) memcpy(params
, xcb_glx_get_tex_parameterfv_data(reply
),
4503 xcb_glx_get_tex_parameterfv_data_length(reply
) *
4508 __glXSetupSingleRequest(gc
, X_GLsop_GetTexParameterfv
, cmdlen
);
4509 (void) memcpy((void *) (pc
+ 0), (void *) (&target
), 4);
4510 (void) memcpy((void *) (pc
+ 4), (void *) (&pname
), 4);
4511 (void) __glXReadReply(dpy
, 4, params
, GL_FALSE
);
4514 #endif /* USE_XCB */
4519 #define X_GLsop_GetTexParameteriv 137
4521 __indirect_glGetTexParameteriv(GLenum target
, GLenum pname
, GLint
* params
)
4523 __GLXcontext
*const gc
= __glXGetCurrentContext();
4524 Display
*const dpy
= gc
->currentDpy
;
4525 const GLuint cmdlen
= 8;
4526 if (__builtin_expect(dpy
!= NULL
, 1)) {
4528 xcb_connection_t
*c
= XGetXCBConnection(dpy
);
4529 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
4530 xcb_glx_get_tex_parameteriv_reply_t
*reply
=
4531 xcb_glx_get_tex_parameteriv_reply(c
,
4532 xcb_glx_get_tex_parameteriv(c
,
4538 if (xcb_glx_get_tex_parameteriv_data_length(reply
) == 0)
4539 (void) memcpy(params
, &reply
->datum
, sizeof(reply
->datum
));
4541 (void) memcpy(params
, xcb_glx_get_tex_parameteriv_data(reply
),
4542 xcb_glx_get_tex_parameteriv_data_length(reply
) *
4547 __glXSetupSingleRequest(gc
, X_GLsop_GetTexParameteriv
, cmdlen
);
4548 (void) memcpy((void *) (pc
+ 0), (void *) (&target
), 4);
4549 (void) memcpy((void *) (pc
+ 4), (void *) (&pname
), 4);
4550 (void) __glXReadReply(dpy
, 4, params
, GL_FALSE
);
4553 #endif /* USE_XCB */
4558 #define X_GLsop_GetTexLevelParameterfv 138
4560 __indirect_glGetTexLevelParameterfv(GLenum target
, GLint level
, GLenum pname
,
4563 __GLXcontext
*const gc
= __glXGetCurrentContext();
4564 Display
*const dpy
= gc
->currentDpy
;
4565 const GLuint cmdlen
= 12;
4566 if (__builtin_expect(dpy
!= NULL
, 1)) {
4568 xcb_connection_t
*c
= XGetXCBConnection(dpy
);
4569 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
4570 xcb_glx_get_tex_level_parameterfv_reply_t
*reply
=
4571 xcb_glx_get_tex_level_parameterfv_reply(c
,
4572 xcb_glx_get_tex_level_parameterfv
4573 (c
, gc
->currentContextTag
,
4574 target
, level
, pname
),
4576 if (xcb_glx_get_tex_level_parameterfv_data_length(reply
) == 0)
4577 (void) memcpy(params
, &reply
->datum
, sizeof(reply
->datum
));
4579 (void) memcpy(params
,
4580 xcb_glx_get_tex_level_parameterfv_data(reply
),
4581 xcb_glx_get_tex_level_parameterfv_data_length(reply
)
4586 __glXSetupSingleRequest(gc
, X_GLsop_GetTexLevelParameterfv
,
4588 (void) memcpy((void *) (pc
+ 0), (void *) (&target
), 4);
4589 (void) memcpy((void *) (pc
+ 4), (void *) (&level
), 4);
4590 (void) memcpy((void *) (pc
+ 8), (void *) (&pname
), 4);
4591 (void) __glXReadReply(dpy
, 4, params
, GL_FALSE
);
4594 #endif /* USE_XCB */
4599 #define X_GLsop_GetTexLevelParameteriv 139
4601 __indirect_glGetTexLevelParameteriv(GLenum target
, GLint level
, GLenum pname
,
4604 __GLXcontext
*const gc
= __glXGetCurrentContext();
4605 Display
*const dpy
= gc
->currentDpy
;
4606 const GLuint cmdlen
= 12;
4607 if (__builtin_expect(dpy
!= NULL
, 1)) {
4609 xcb_connection_t
*c
= XGetXCBConnection(dpy
);
4610 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
4611 xcb_glx_get_tex_level_parameteriv_reply_t
*reply
=
4612 xcb_glx_get_tex_level_parameteriv_reply(c
,
4613 xcb_glx_get_tex_level_parameteriv
4614 (c
, gc
->currentContextTag
,
4615 target
, level
, pname
),
4617 if (xcb_glx_get_tex_level_parameteriv_data_length(reply
) == 0)
4618 (void) memcpy(params
, &reply
->datum
, sizeof(reply
->datum
));
4620 (void) memcpy(params
,
4621 xcb_glx_get_tex_level_parameteriv_data(reply
),
4622 xcb_glx_get_tex_level_parameteriv_data_length(reply
)
4627 __glXSetupSingleRequest(gc
, X_GLsop_GetTexLevelParameteriv
,
4629 (void) memcpy((void *) (pc
+ 0), (void *) (&target
), 4);
4630 (void) memcpy((void *) (pc
+ 4), (void *) (&level
), 4);
4631 (void) memcpy((void *) (pc
+ 8), (void *) (&pname
), 4);
4632 (void) __glXReadReply(dpy
, 4, params
, GL_FALSE
);
4635 #endif /* USE_XCB */
4640 #define X_GLsop_IsList 141
4642 __indirect_glIsList(GLuint list
)
4644 __GLXcontext
*const gc
= __glXGetCurrentContext();
4645 Display
*const dpy
= gc
->currentDpy
;
4646 GLboolean retval
= (GLboolean
) 0;
4647 const GLuint cmdlen
= 4;
4648 if (__builtin_expect(dpy
!= NULL
, 1)) {
4650 xcb_connection_t
*c
= XGetXCBConnection(dpy
);
4651 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
4652 xcb_glx_is_list_reply_t
*reply
=
4653 xcb_glx_is_list_reply(c
,
4654 xcb_glx_is_list(c
, gc
->currentContextTag
,
4656 retval
= reply
->ret_val
;
4660 __glXSetupSingleRequest(gc
, X_GLsop_IsList
, cmdlen
);
4661 (void) memcpy((void *) (pc
+ 0), (void *) (&list
), 4);
4662 retval
= (GLboolean
) __glXReadReply(dpy
, 0, NULL
, GL_FALSE
);
4665 #endif /* USE_XCB */
4670 #define X_GLrop_DepthRange 174
4672 __indirect_glDepthRange(GLclampd zNear
, GLclampd zFar
)
4674 __GLXcontext
*const gc
= __glXGetCurrentContext();
4675 const GLuint cmdlen
= 20;
4676 emit_header(gc
->pc
, X_GLrop_DepthRange
, cmdlen
);
4677 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&zNear
), 8);
4678 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&zFar
), 8);
4680 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
4681 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
4685 #define X_GLrop_Frustum 175
4687 __indirect_glFrustum(GLdouble left
, GLdouble right
, GLdouble bottom
,
4688 GLdouble top
, GLdouble zNear
, GLdouble zFar
)
4690 __GLXcontext
*const gc
= __glXGetCurrentContext();
4691 const GLuint cmdlen
= 52;
4692 emit_header(gc
->pc
, X_GLrop_Frustum
, cmdlen
);
4693 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&left
), 8);
4694 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&right
), 8);
4695 (void) memcpy((void *) (gc
->pc
+ 20), (void *) (&bottom
), 8);
4696 (void) memcpy((void *) (gc
->pc
+ 28), (void *) (&top
), 8);
4697 (void) memcpy((void *) (gc
->pc
+ 36), (void *) (&zNear
), 8);
4698 (void) memcpy((void *) (gc
->pc
+ 44), (void *) (&zFar
), 8);
4700 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
4701 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
4705 #define X_GLrop_LoadIdentity 176
4707 __indirect_glLoadIdentity(void)
4709 __GLXcontext
*const gc
= __glXGetCurrentContext();
4710 const GLuint cmdlen
= 4;
4711 emit_header(gc
->pc
, X_GLrop_LoadIdentity
, cmdlen
);
4713 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
4714 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
4718 #define X_GLrop_LoadMatrixf 177
4720 __indirect_glLoadMatrixf(const GLfloat
* m
)
4722 __GLXcontext
*const gc
= __glXGetCurrentContext();
4723 const GLuint cmdlen
= 68;
4724 emit_header(gc
->pc
, X_GLrop_LoadMatrixf
, cmdlen
);
4725 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (m
), 64);
4727 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
4728 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
4732 #define X_GLrop_LoadMatrixd 178
4734 __indirect_glLoadMatrixd(const GLdouble
* m
)
4736 __GLXcontext
*const gc
= __glXGetCurrentContext();
4737 const GLuint cmdlen
= 132;
4738 emit_header(gc
->pc
, X_GLrop_LoadMatrixd
, cmdlen
);
4739 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (m
), 128);
4741 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
4742 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
4746 #define X_GLrop_MatrixMode 179
4748 __indirect_glMatrixMode(GLenum mode
)
4750 __GLXcontext
*const gc
= __glXGetCurrentContext();
4751 const GLuint cmdlen
= 8;
4752 emit_header(gc
->pc
, X_GLrop_MatrixMode
, cmdlen
);
4753 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&mode
), 4);
4755 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
4756 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
4760 #define X_GLrop_MultMatrixf 180
4762 __indirect_glMultMatrixf(const GLfloat
* m
)
4764 __GLXcontext
*const gc
= __glXGetCurrentContext();
4765 const GLuint cmdlen
= 68;
4766 emit_header(gc
->pc
, X_GLrop_MultMatrixf
, cmdlen
);
4767 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (m
), 64);
4769 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
4770 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
4774 #define X_GLrop_MultMatrixd 181
4776 __indirect_glMultMatrixd(const GLdouble
* m
)
4778 __GLXcontext
*const gc
= __glXGetCurrentContext();
4779 const GLuint cmdlen
= 132;
4780 emit_header(gc
->pc
, X_GLrop_MultMatrixd
, cmdlen
);
4781 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (m
), 128);
4783 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
4784 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
4788 #define X_GLrop_Ortho 182
4790 __indirect_glOrtho(GLdouble left
, GLdouble right
, GLdouble bottom
,
4791 GLdouble top
, GLdouble zNear
, GLdouble zFar
)
4793 __GLXcontext
*const gc
= __glXGetCurrentContext();
4794 const GLuint cmdlen
= 52;
4795 emit_header(gc
->pc
, X_GLrop_Ortho
, cmdlen
);
4796 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&left
), 8);
4797 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&right
), 8);
4798 (void) memcpy((void *) (gc
->pc
+ 20), (void *) (&bottom
), 8);
4799 (void) memcpy((void *) (gc
->pc
+ 28), (void *) (&top
), 8);
4800 (void) memcpy((void *) (gc
->pc
+ 36), (void *) (&zNear
), 8);
4801 (void) memcpy((void *) (gc
->pc
+ 44), (void *) (&zFar
), 8);
4803 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
4804 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
4808 #define X_GLrop_PopMatrix 183
4810 __indirect_glPopMatrix(void)
4812 __GLXcontext
*const gc
= __glXGetCurrentContext();
4813 const GLuint cmdlen
= 4;
4814 emit_header(gc
->pc
, X_GLrop_PopMatrix
, cmdlen
);
4816 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
4817 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
4821 #define X_GLrop_PushMatrix 184
4823 __indirect_glPushMatrix(void)
4825 __GLXcontext
*const gc
= __glXGetCurrentContext();
4826 const GLuint cmdlen
= 4;
4827 emit_header(gc
->pc
, X_GLrop_PushMatrix
, cmdlen
);
4829 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
4830 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
4834 #define X_GLrop_Rotated 185
4836 __indirect_glRotated(GLdouble angle
, GLdouble x
, GLdouble y
, GLdouble z
)
4838 __GLXcontext
*const gc
= __glXGetCurrentContext();
4839 const GLuint cmdlen
= 36;
4840 emit_header(gc
->pc
, X_GLrop_Rotated
, cmdlen
);
4841 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&angle
), 8);
4842 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&x
), 8);
4843 (void) memcpy((void *) (gc
->pc
+ 20), (void *) (&y
), 8);
4844 (void) memcpy((void *) (gc
->pc
+ 28), (void *) (&z
), 8);
4846 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
4847 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
4851 #define X_GLrop_Rotatef 186
4853 __indirect_glRotatef(GLfloat angle
, GLfloat x
, GLfloat y
, GLfloat z
)
4855 __GLXcontext
*const gc
= __glXGetCurrentContext();
4856 const GLuint cmdlen
= 20;
4857 emit_header(gc
->pc
, X_GLrop_Rotatef
, cmdlen
);
4858 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&angle
), 4);
4859 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&x
), 4);
4860 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&y
), 4);
4861 (void) memcpy((void *) (gc
->pc
+ 16), (void *) (&z
), 4);
4863 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
4864 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
4868 #define X_GLrop_Scaled 187
4870 __indirect_glScaled(GLdouble x
, GLdouble y
, GLdouble z
)
4872 __GLXcontext
*const gc
= __glXGetCurrentContext();
4873 const GLuint cmdlen
= 28;
4874 emit_header(gc
->pc
, X_GLrop_Scaled
, cmdlen
);
4875 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&x
), 8);
4876 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&y
), 8);
4877 (void) memcpy((void *) (gc
->pc
+ 20), (void *) (&z
), 8);
4879 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
4880 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
4884 #define X_GLrop_Scalef 188
4886 __indirect_glScalef(GLfloat x
, GLfloat y
, GLfloat z
)
4888 __GLXcontext
*const gc
= __glXGetCurrentContext();
4889 const GLuint cmdlen
= 16;
4890 emit_header(gc
->pc
, X_GLrop_Scalef
, cmdlen
);
4891 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&x
), 4);
4892 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&y
), 4);
4893 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&z
), 4);
4895 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
4896 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
4900 #define X_GLrop_Translated 189
4902 __indirect_glTranslated(GLdouble x
, GLdouble y
, GLdouble z
)
4904 __GLXcontext
*const gc
= __glXGetCurrentContext();
4905 const GLuint cmdlen
= 28;
4906 emit_header(gc
->pc
, X_GLrop_Translated
, cmdlen
);
4907 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&x
), 8);
4908 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&y
), 8);
4909 (void) memcpy((void *) (gc
->pc
+ 20), (void *) (&z
), 8);
4911 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
4912 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
4916 #define X_GLrop_Translatef 190
4918 __indirect_glTranslatef(GLfloat x
, GLfloat y
, GLfloat z
)
4920 __GLXcontext
*const gc
= __glXGetCurrentContext();
4921 const GLuint cmdlen
= 16;
4922 emit_header(gc
->pc
, X_GLrop_Translatef
, cmdlen
);
4923 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&x
), 4);
4924 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&y
), 4);
4925 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&z
), 4);
4927 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
4928 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
4932 #define X_GLrop_Viewport 191
4934 __indirect_glViewport(GLint x
, GLint y
, GLsizei width
, GLsizei height
)
4936 __GLXcontext
*const gc
= __glXGetCurrentContext();
4937 const GLuint cmdlen
= 20;
4938 emit_header(gc
->pc
, X_GLrop_Viewport
, cmdlen
);
4939 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&x
), 4);
4940 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&y
), 4);
4941 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&width
), 4);
4942 (void) memcpy((void *) (gc
->pc
+ 16), (void *) (&height
), 4);
4944 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
4945 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
4949 #define X_GLrop_BindTexture 4117
4951 __indirect_glBindTexture(GLenum target
, GLuint texture
)
4953 __GLXcontext
*const gc
= __glXGetCurrentContext();
4954 const GLuint cmdlen
= 12;
4955 emit_header(gc
->pc
, X_GLrop_BindTexture
, cmdlen
);
4956 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&target
), 4);
4957 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&texture
), 4);
4959 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
4960 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
4964 #define X_GLrop_Indexubv 194
4966 __indirect_glIndexub(GLubyte c
)
4968 __GLXcontext
*const gc
= __glXGetCurrentContext();
4969 const GLuint cmdlen
= 8;
4970 emit_header(gc
->pc
, X_GLrop_Indexubv
, cmdlen
);
4971 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&c
), 1);
4973 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
4974 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
4978 #define X_GLrop_Indexubv 194
4980 __indirect_glIndexubv(const GLubyte
* c
)
4982 __GLXcontext
*const gc
= __glXGetCurrentContext();
4983 const GLuint cmdlen
= 8;
4984 emit_header(gc
->pc
, X_GLrop_Indexubv
, cmdlen
);
4985 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (c
), 1);
4987 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
4988 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
4992 #define X_GLrop_PolygonOffset 192
4994 __indirect_glPolygonOffset(GLfloat factor
, GLfloat units
)
4996 __GLXcontext
*const gc
= __glXGetCurrentContext();
4997 const GLuint cmdlen
= 12;
4998 emit_header(gc
->pc
, X_GLrop_PolygonOffset
, cmdlen
);
4999 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&factor
), 4);
5000 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&units
), 4);
5002 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
5003 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
5007 #define X_GLsop_AreTexturesResident 143
5009 __indirect_glAreTexturesResident(GLsizei n
, const GLuint
* textures
,
5010 GLboolean
* residences
)
5012 __GLXcontext
*const gc
= __glXGetCurrentContext();
5013 Display
*const dpy
= gc
->currentDpy
;
5014 GLboolean retval
= (GLboolean
) 0;
5015 const GLuint cmdlen
= 4 + __GLX_PAD((n
* 4));
5016 if (__builtin_expect((n
>= 0) && (dpy
!= NULL
), 1)) {
5018 xcb_connection_t
*c
= XGetXCBConnection(dpy
);
5019 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
5020 xcb_glx_are_textures_resident_reply_t
*reply
=
5021 xcb_glx_are_textures_resident_reply(c
,
5022 xcb_glx_are_textures_resident
5023 (c
, gc
->currentContextTag
, n
,
5025 (void) memcpy(residences
, xcb_glx_are_textures_resident_data(reply
),
5026 xcb_glx_are_textures_resident_data_length(reply
) *
5028 retval
= reply
->ret_val
;
5032 __glXSetupSingleRequest(gc
, X_GLsop_AreTexturesResident
, cmdlen
);
5033 (void) memcpy((void *) (pc
+ 0), (void *) (&n
), 4);
5034 (void) memcpy((void *) (pc
+ 4), (void *) (textures
), (n
* 4));
5035 retval
= (GLboolean
) __glXReadReply(dpy
, 1, residences
, GL_TRUE
);
5038 #endif /* USE_XCB */
5043 #define X_GLvop_AreTexturesResidentEXT 11
5045 glAreTexturesResidentEXT(GLsizei n
, const GLuint
* textures
,
5046 GLboolean
* residences
)
5048 __GLXcontext
*const gc
= __glXGetCurrentContext();
5051 return CALL_AreTexturesResident(GET_DISPATCH(),
5052 (n
, textures
, residences
));
5054 __GLXcontext
*const gc
= __glXGetCurrentContext();
5055 Display
*const dpy
= gc
->currentDpy
;
5056 GLboolean retval
= (GLboolean
) 0;
5057 const GLuint cmdlen
= 4 + __GLX_PAD((n
* 4));
5058 if (__builtin_expect((n
>= 0) && (dpy
!= NULL
), 1)) {
5060 __glXSetupVendorRequest(gc
, X_GLXVendorPrivateWithReply
,
5061 X_GLvop_AreTexturesResidentEXT
,
5063 (void) memcpy((void *) (pc
+ 0), (void *) (&n
), 4);
5064 (void) memcpy((void *) (pc
+ 4), (void *) (textures
), (n
* 4));
5065 retval
= (GLboolean
) __glXReadReply(dpy
, 1, residences
, GL_TRUE
);
5073 #define X_GLrop_CopyTexImage1D 4119
5075 __indirect_glCopyTexImage1D(GLenum target
, GLint level
, GLenum internalformat
,
5076 GLint x
, GLint y
, GLsizei width
, GLint border
)
5078 __GLXcontext
*const gc
= __glXGetCurrentContext();
5079 const GLuint cmdlen
= 32;
5080 emit_header(gc
->pc
, X_GLrop_CopyTexImage1D
, cmdlen
);
5081 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&target
), 4);
5082 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&level
), 4);
5083 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&internalformat
), 4);
5084 (void) memcpy((void *) (gc
->pc
+ 16), (void *) (&x
), 4);
5085 (void) memcpy((void *) (gc
->pc
+ 20), (void *) (&y
), 4);
5086 (void) memcpy((void *) (gc
->pc
+ 24), (void *) (&width
), 4);
5087 (void) memcpy((void *) (gc
->pc
+ 28), (void *) (&border
), 4);
5089 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
5090 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
5094 #define X_GLrop_CopyTexImage2D 4120
5096 __indirect_glCopyTexImage2D(GLenum target
, GLint level
, GLenum internalformat
,
5097 GLint x
, GLint y
, GLsizei width
, GLsizei height
,
5100 __GLXcontext
*const gc
= __glXGetCurrentContext();
5101 const GLuint cmdlen
= 36;
5102 emit_header(gc
->pc
, X_GLrop_CopyTexImage2D
, cmdlen
);
5103 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&target
), 4);
5104 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&level
), 4);
5105 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&internalformat
), 4);
5106 (void) memcpy((void *) (gc
->pc
+ 16), (void *) (&x
), 4);
5107 (void) memcpy((void *) (gc
->pc
+ 20), (void *) (&y
), 4);
5108 (void) memcpy((void *) (gc
->pc
+ 24), (void *) (&width
), 4);
5109 (void) memcpy((void *) (gc
->pc
+ 28), (void *) (&height
), 4);
5110 (void) memcpy((void *) (gc
->pc
+ 32), (void *) (&border
), 4);
5112 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
5113 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
5117 #define X_GLrop_CopyTexSubImage1D 4121
5119 __indirect_glCopyTexSubImage1D(GLenum target
, GLint level
, GLint xoffset
,
5120 GLint x
, GLint y
, GLsizei width
)
5122 __GLXcontext
*const gc
= __glXGetCurrentContext();
5123 const GLuint cmdlen
= 28;
5124 emit_header(gc
->pc
, X_GLrop_CopyTexSubImage1D
, cmdlen
);
5125 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&target
), 4);
5126 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&level
), 4);
5127 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&xoffset
), 4);
5128 (void) memcpy((void *) (gc
->pc
+ 16), (void *) (&x
), 4);
5129 (void) memcpy((void *) (gc
->pc
+ 20), (void *) (&y
), 4);
5130 (void) memcpy((void *) (gc
->pc
+ 24), (void *) (&width
), 4);
5132 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
5133 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
5137 #define X_GLrop_CopyTexSubImage2D 4122
5139 __indirect_glCopyTexSubImage2D(GLenum target
, GLint level
, GLint xoffset
,
5140 GLint yoffset
, GLint x
, GLint y
, GLsizei width
,
5143 __GLXcontext
*const gc
= __glXGetCurrentContext();
5144 const GLuint cmdlen
= 36;
5145 emit_header(gc
->pc
, X_GLrop_CopyTexSubImage2D
, cmdlen
);
5146 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&target
), 4);
5147 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&level
), 4);
5148 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&xoffset
), 4);
5149 (void) memcpy((void *) (gc
->pc
+ 16), (void *) (&yoffset
), 4);
5150 (void) memcpy((void *) (gc
->pc
+ 20), (void *) (&x
), 4);
5151 (void) memcpy((void *) (gc
->pc
+ 24), (void *) (&y
), 4);
5152 (void) memcpy((void *) (gc
->pc
+ 28), (void *) (&width
), 4);
5153 (void) memcpy((void *) (gc
->pc
+ 32), (void *) (&height
), 4);
5155 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
5156 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
5160 #define X_GLsop_DeleteTextures 144
5162 __indirect_glDeleteTextures(GLsizei n
, const GLuint
* textures
)
5164 __GLXcontext
*const gc
= __glXGetCurrentContext();
5165 Display
*const dpy
= gc
->currentDpy
;
5166 const GLuint cmdlen
= 4 + __GLX_PAD((n
* 4));
5167 if (__builtin_expect((n
>= 0) && (dpy
!= NULL
), 1)) {
5169 xcb_connection_t
*c
= XGetXCBConnection(dpy
);
5170 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
5171 xcb_glx_delete_textures(c
, gc
->currentContextTag
, n
, textures
);
5174 __glXSetupSingleRequest(gc
, X_GLsop_DeleteTextures
, cmdlen
);
5175 (void) memcpy((void *) (pc
+ 0), (void *) (&n
), 4);
5176 (void) memcpy((void *) (pc
+ 4), (void *) (textures
), (n
* 4));
5179 #endif /* USE_XCB */
5184 #define X_GLvop_DeleteTexturesEXT 12
5186 glDeleteTexturesEXT(GLsizei n
, const GLuint
* textures
)
5188 __GLXcontext
*const gc
= __glXGetCurrentContext();
5191 CALL_DeleteTextures(GET_DISPATCH(), (n
, textures
));
5193 __GLXcontext
*const gc
= __glXGetCurrentContext();
5194 Display
*const dpy
= gc
->currentDpy
;
5195 const GLuint cmdlen
= 4 + __GLX_PAD((n
* 4));
5196 if (__builtin_expect((n
>= 0) && (dpy
!= NULL
), 1)) {
5198 __glXSetupVendorRequest(gc
, X_GLXVendorPrivate
,
5199 X_GLvop_DeleteTexturesEXT
, cmdlen
);
5200 (void) memcpy((void *) (pc
+ 0), (void *) (&n
), 4);
5201 (void) memcpy((void *) (pc
+ 4), (void *) (textures
), (n
* 4));
5209 #define X_GLsop_GenTextures 145
5211 __indirect_glGenTextures(GLsizei n
, GLuint
* textures
)
5213 __GLXcontext
*const gc
= __glXGetCurrentContext();
5214 Display
*const dpy
= gc
->currentDpy
;
5215 const GLuint cmdlen
= 4;
5216 if (__builtin_expect((n
>= 0) && (dpy
!= NULL
), 1)) {
5218 xcb_connection_t
*c
= XGetXCBConnection(dpy
);
5219 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
5220 xcb_glx_gen_textures_reply_t
*reply
=
5221 xcb_glx_gen_textures_reply(c
,
5222 xcb_glx_gen_textures(c
,
5226 (void) memcpy(textures
, xcb_glx_gen_textures_data(reply
),
5227 xcb_glx_gen_textures_data_length(reply
) *
5232 __glXSetupSingleRequest(gc
, X_GLsop_GenTextures
, cmdlen
);
5233 (void) memcpy((void *) (pc
+ 0), (void *) (&n
), 4);
5234 (void) __glXReadReply(dpy
, 4, textures
, GL_TRUE
);
5237 #endif /* USE_XCB */
5242 #define X_GLvop_GenTexturesEXT 13
5244 glGenTexturesEXT(GLsizei n
, GLuint
* textures
)
5246 __GLXcontext
*const gc
= __glXGetCurrentContext();
5249 CALL_GenTextures(GET_DISPATCH(), (n
, textures
));
5251 __GLXcontext
*const gc
= __glXGetCurrentContext();
5252 Display
*const dpy
= gc
->currentDpy
;
5253 const GLuint cmdlen
= 4;
5254 if (__builtin_expect((n
>= 0) && (dpy
!= NULL
), 1)) {
5256 __glXSetupVendorRequest(gc
, X_GLXVendorPrivateWithReply
,
5257 X_GLvop_GenTexturesEXT
, cmdlen
);
5258 (void) memcpy((void *) (pc
+ 0), (void *) (&n
), 4);
5259 (void) __glXReadReply(dpy
, 4, textures
, GL_TRUE
);
5267 #define X_GLsop_IsTexture 146
5269 __indirect_glIsTexture(GLuint texture
)
5271 __GLXcontext
*const gc
= __glXGetCurrentContext();
5272 Display
*const dpy
= gc
->currentDpy
;
5273 GLboolean retval
= (GLboolean
) 0;
5274 const GLuint cmdlen
= 4;
5275 if (__builtin_expect(dpy
!= NULL
, 1)) {
5277 xcb_connection_t
*c
= XGetXCBConnection(dpy
);
5278 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
5279 xcb_glx_is_texture_reply_t
*reply
=
5280 xcb_glx_is_texture_reply(c
,
5281 xcb_glx_is_texture(c
,
5282 gc
->currentContextTag
,
5284 retval
= reply
->ret_val
;
5288 __glXSetupSingleRequest(gc
, X_GLsop_IsTexture
, cmdlen
);
5289 (void) memcpy((void *) (pc
+ 0), (void *) (&texture
), 4);
5290 retval
= (GLboolean
) __glXReadReply(dpy
, 0, NULL
, GL_FALSE
);
5293 #endif /* USE_XCB */
5298 #define X_GLvop_IsTextureEXT 14
5300 glIsTextureEXT(GLuint texture
)
5302 __GLXcontext
*const gc
= __glXGetCurrentContext();
5305 return CALL_IsTexture(GET_DISPATCH(), (texture
));
5307 __GLXcontext
*const gc
= __glXGetCurrentContext();
5308 Display
*const dpy
= gc
->currentDpy
;
5309 GLboolean retval
= (GLboolean
) 0;
5310 const GLuint cmdlen
= 4;
5311 if (__builtin_expect(dpy
!= NULL
, 1)) {
5313 __glXSetupVendorRequest(gc
, X_GLXVendorPrivateWithReply
,
5314 X_GLvop_IsTextureEXT
, cmdlen
);
5315 (void) memcpy((void *) (pc
+ 0), (void *) (&texture
), 4);
5316 retval
= (GLboolean
) __glXReadReply(dpy
, 0, NULL
, GL_FALSE
);
5324 #define X_GLrop_PrioritizeTextures 4118
5326 __indirect_glPrioritizeTextures(GLsizei n
, const GLuint
* textures
,
5327 const GLclampf
* priorities
)
5329 __GLXcontext
*const gc
= __glXGetCurrentContext();
5330 const GLuint cmdlen
= 8 + __GLX_PAD((n
* 4)) + __GLX_PAD((n
* 4));
5331 if (__builtin_expect(n
>= 0, 1)) {
5332 emit_header(gc
->pc
, X_GLrop_PrioritizeTextures
, cmdlen
);
5333 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&n
), 4);
5334 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (textures
), (n
* 4));
5335 (void) memcpy((void *) (gc
->pc
+ 8 + (n
* 4)), (void *) (priorities
),
5338 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
5339 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
5345 __glx_TexSubImage_1D2D(unsigned opcode
, unsigned dim
, GLenum target
,
5346 GLint level
, GLint xoffset
, GLint yoffset
,
5347 GLsizei width
, GLsizei height
, GLenum format
,
5348 GLenum type
, const GLvoid
* pixels
)
5350 __GLXcontext
*const gc
= __glXGetCurrentContext();
5351 const GLuint compsize
=
5352 (pixels
!= NULL
) ? __glImageSize(width
, height
, 1, format
, type
,
5354 const GLuint cmdlen
= 60 + __GLX_PAD(compsize
);
5355 if (__builtin_expect(gc
->currentDpy
!= NULL
, 1)) {
5356 if (cmdlen
<= gc
->maxSmallRenderCommandSize
) {
5357 if ((gc
->pc
+ cmdlen
) > gc
->bufEnd
) {
5358 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
5360 emit_header(gc
->pc
, opcode
, cmdlen
);
5361 (void) memcpy((void *) (gc
->pc
+ 24), (void *) (&target
), 4);
5362 (void) memcpy((void *) (gc
->pc
+ 28), (void *) (&level
), 4);
5363 (void) memcpy((void *) (gc
->pc
+ 32), (void *) (&xoffset
), 4);
5364 (void) memcpy((void *) (gc
->pc
+ 36), (void *) (&yoffset
), 4);
5365 (void) memcpy((void *) (gc
->pc
+ 40), (void *) (&width
), 4);
5366 (void) memcpy((void *) (gc
->pc
+ 44), (void *) (&height
), 4);
5367 (void) memcpy((void *) (gc
->pc
+ 48), (void *) (&format
), 4);
5368 (void) memcpy((void *) (gc
->pc
+ 52), (void *) (&type
), 4);
5369 (void) memcpy((void *) (gc
->pc
+ 56),
5370 (void *) ((pixels
== NULL
) ? one
: zero
), 4);
5372 (*gc
->fillImage
) (gc
, dim
, width
, height
, 1, format
, type
,
5373 pixels
, gc
->pc
+ 60, gc
->pc
+ 4);
5375 (void) memcpy(gc
->pc
+ 4, default_pixel_store_2D
,
5376 default_pixel_store_2D_size
);
5379 if (gc
->pc
> gc
->limit
) {
5380 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
5383 const GLint op
= opcode
;
5384 const GLuint cmdlenLarge
= cmdlen
+ 4;
5385 GLubyte
*const pc
= __glXFlushRenderBuffer(gc
, gc
->pc
);
5386 (void) memcpy((void *) (pc
+ 0), (void *) (&cmdlenLarge
), 4);
5387 (void) memcpy((void *) (pc
+ 4), (void *) (&op
), 4);
5388 (void) memcpy((void *) (pc
+ 28), (void *) (&target
), 4);
5389 (void) memcpy((void *) (pc
+ 32), (void *) (&level
), 4);
5390 (void) memcpy((void *) (pc
+ 36), (void *) (&xoffset
), 4);
5391 (void) memcpy((void *) (pc
+ 40), (void *) (&yoffset
), 4);
5392 (void) memcpy((void *) (pc
+ 44), (void *) (&width
), 4);
5393 (void) memcpy((void *) (pc
+ 48), (void *) (&height
), 4);
5394 (void) memcpy((void *) (pc
+ 52), (void *) (&format
), 4);
5395 (void) memcpy((void *) (pc
+ 56), (void *) (&type
), 4);
5396 (void) memcpy((void *) (pc
+ 60), zero
, 4);
5397 __glXSendLargeImage(gc
, compsize
, dim
, width
, height
, 1, format
,
5398 type
, pixels
, pc
+ 64, pc
+ 8);
5403 #define X_GLrop_TexSubImage1D 4099
5405 __indirect_glTexSubImage1D(GLenum target
, GLint level
, GLint xoffset
,
5406 GLsizei width
, GLenum format
, GLenum type
,
5407 const GLvoid
* pixels
)
5409 __glx_TexSubImage_1D2D(X_GLrop_TexSubImage1D
, 1, target
, level
, xoffset
,
5410 1, width
, 1, format
, type
, pixels
);
5413 #define X_GLrop_TexSubImage2D 4100
5415 __indirect_glTexSubImage2D(GLenum target
, GLint level
, GLint xoffset
,
5416 GLint yoffset
, GLsizei width
, GLsizei height
,
5417 GLenum format
, GLenum type
, const GLvoid
* pixels
)
5419 __glx_TexSubImage_1D2D(X_GLrop_TexSubImage2D
, 2, target
, level
, xoffset
,
5420 yoffset
, width
, height
, format
, type
, pixels
);
5423 #define X_GLrop_BlendColor 4096
5425 __indirect_glBlendColor(GLclampf red
, GLclampf green
, GLclampf blue
,
5428 __GLXcontext
*const gc
= __glXGetCurrentContext();
5429 const GLuint cmdlen
= 20;
5430 emit_header(gc
->pc
, X_GLrop_BlendColor
, cmdlen
);
5431 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&red
), 4);
5432 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&green
), 4);
5433 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&blue
), 4);
5434 (void) memcpy((void *) (gc
->pc
+ 16), (void *) (&alpha
), 4);
5436 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
5437 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
5441 #define X_GLrop_BlendEquation 4097
5443 __indirect_glBlendEquation(GLenum mode
)
5445 __GLXcontext
*const gc
= __glXGetCurrentContext();
5446 const GLuint cmdlen
= 8;
5447 emit_header(gc
->pc
, X_GLrop_BlendEquation
, cmdlen
);
5448 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&mode
), 4);
5450 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
5451 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
5455 #define X_GLrop_ColorTable 2053
5457 __indirect_glColorTable(GLenum target
, GLenum internalformat
, GLsizei width
,
5458 GLenum format
, GLenum type
, const GLvoid
* table
)
5460 __GLXcontext
*const gc
= __glXGetCurrentContext();
5461 const GLuint compsize
=
5462 (table
!= NULL
) ? __glImageSize(width
, 1, 1, format
, type
,
5464 const GLuint cmdlen
= 44 + __GLX_PAD(compsize
);
5465 if (__builtin_expect(gc
->currentDpy
!= NULL
, 1)) {
5466 if (cmdlen
<= gc
->maxSmallRenderCommandSize
) {
5467 if ((gc
->pc
+ cmdlen
) > gc
->bufEnd
) {
5468 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
5470 emit_header(gc
->pc
, X_GLrop_ColorTable
, cmdlen
);
5471 (void) memcpy((void *) (gc
->pc
+ 24), (void *) (&target
), 4);
5472 (void) memcpy((void *) (gc
->pc
+ 28), (void *) (&internalformat
),
5474 (void) memcpy((void *) (gc
->pc
+ 32), (void *) (&width
), 4);
5475 (void) memcpy((void *) (gc
->pc
+ 36), (void *) (&format
), 4);
5476 (void) memcpy((void *) (gc
->pc
+ 40), (void *) (&type
), 4);
5478 (*gc
->fillImage
) (gc
, 1, width
, 1, 1, format
, type
, table
,
5479 gc
->pc
+ 44, gc
->pc
+ 4);
5481 (void) memcpy(gc
->pc
+ 4, default_pixel_store_1D
,
5482 default_pixel_store_1D_size
);
5485 if (gc
->pc
> gc
->limit
) {
5486 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
5489 const GLint op
= X_GLrop_ColorTable
;
5490 const GLuint cmdlenLarge
= cmdlen
+ 4;
5491 GLubyte
*const pc
= __glXFlushRenderBuffer(gc
, gc
->pc
);
5492 (void) memcpy((void *) (pc
+ 0), (void *) (&cmdlenLarge
), 4);
5493 (void) memcpy((void *) (pc
+ 4), (void *) (&op
), 4);
5494 (void) memcpy((void *) (pc
+ 28), (void *) (&target
), 4);
5495 (void) memcpy((void *) (pc
+ 32), (void *) (&internalformat
), 4);
5496 (void) memcpy((void *) (pc
+ 36), (void *) (&width
), 4);
5497 (void) memcpy((void *) (pc
+ 40), (void *) (&format
), 4);
5498 (void) memcpy((void *) (pc
+ 44), (void *) (&type
), 4);
5499 __glXSendLargeImage(gc
, compsize
, 1, width
, 1, 1, format
, type
,
5500 table
, pc
+ 48, pc
+ 8);
5505 #define X_GLrop_ColorTableParameterfv 2054
5507 __indirect_glColorTableParameterfv(GLenum target
, GLenum pname
,
5508 const GLfloat
* params
)
5510 __GLXcontext
*const gc
= __glXGetCurrentContext();
5511 const GLuint compsize
= __glColorTableParameterfv_size(pname
);
5512 const GLuint cmdlen
= 12 + __GLX_PAD((compsize
* 4));
5513 emit_header(gc
->pc
, X_GLrop_ColorTableParameterfv
, cmdlen
);
5514 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&target
), 4);
5515 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&pname
), 4);
5516 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (params
), (compsize
* 4));
5518 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
5519 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
5523 #define X_GLrop_ColorTableParameteriv 2055
5525 __indirect_glColorTableParameteriv(GLenum target
, GLenum pname
,
5526 const GLint
* params
)
5528 __GLXcontext
*const gc
= __glXGetCurrentContext();
5529 const GLuint compsize
= __glColorTableParameteriv_size(pname
);
5530 const GLuint cmdlen
= 12 + __GLX_PAD((compsize
* 4));
5531 emit_header(gc
->pc
, X_GLrop_ColorTableParameteriv
, cmdlen
);
5532 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&target
), 4);
5533 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&pname
), 4);
5534 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (params
), (compsize
* 4));
5536 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
5537 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
5541 #define X_GLrop_CopyColorTable 2056
5543 __indirect_glCopyColorTable(GLenum target
, GLenum internalformat
, GLint x
,
5544 GLint y
, GLsizei width
)
5546 __GLXcontext
*const gc
= __glXGetCurrentContext();
5547 const GLuint cmdlen
= 24;
5548 emit_header(gc
->pc
, X_GLrop_CopyColorTable
, cmdlen
);
5549 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&target
), 4);
5550 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&internalformat
), 4);
5551 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&x
), 4);
5552 (void) memcpy((void *) (gc
->pc
+ 16), (void *) (&y
), 4);
5553 (void) memcpy((void *) (gc
->pc
+ 20), (void *) (&width
), 4);
5555 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
5556 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
5560 #define X_GLsop_GetColorTable 147
5562 __indirect_glGetColorTable(GLenum target
, GLenum format
, GLenum type
,
5565 __GLXcontext
*const gc
= __glXGetCurrentContext();
5566 const __GLXattribute
*const state
= gc
->client_state_private
;
5567 Display
*const dpy
= gc
->currentDpy
;
5568 const GLuint cmdlen
= 16;
5569 if (__builtin_expect(dpy
!= NULL
, 1)) {
5571 xcb_connection_t
*c
= XGetXCBConnection(dpy
);
5572 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
5573 xcb_glx_get_color_table_reply_t
*reply
=
5574 xcb_glx_get_color_table_reply(c
,
5575 xcb_glx_get_color_table(c
,
5585 (void) memcpy(table
, xcb_glx_get_color_table_data(reply
),
5586 xcb_glx_get_color_table_data_length(reply
) *
5591 __glXSetupSingleRequest(gc
, X_GLsop_GetColorTable
, cmdlen
);
5592 (void) memcpy((void *) (pc
+ 0), (void *) (&target
), 4);
5593 (void) memcpy((void *) (pc
+ 4), (void *) (&format
), 4);
5594 (void) memcpy((void *) (pc
+ 8), (void *) (&type
), 4);
5595 *(int32_t *) (pc
+ 12) = 0;
5596 *(int8_t *) (pc
+ 12) = state
->storePack
.swapEndian
;
5597 __glXReadPixelReply(dpy
, gc
, 1, 0, 0, 0, format
, type
, table
,
5601 #endif /* USE_XCB */
5606 #define X_GLvop_GetColorTableSGI 4098
5608 glGetColorTableEXT(GLenum target
, GLenum format
, GLenum type
, GLvoid
* table
)
5610 __GLXcontext
*const gc
= __glXGetCurrentContext();
5613 CALL_GetColorTable(GET_DISPATCH(), (target
, format
, type
, table
));
5615 __GLXcontext
*const gc
= __glXGetCurrentContext();
5616 const __GLXattribute
*const state
= gc
->client_state_private
;
5617 Display
*const dpy
= gc
->currentDpy
;
5618 const GLuint cmdlen
= 16;
5619 if (__builtin_expect(dpy
!= NULL
, 1)) {
5621 __glXSetupVendorRequest(gc
, X_GLXVendorPrivateWithReply
,
5622 X_GLvop_GetColorTableSGI
, cmdlen
);
5623 (void) memcpy((void *) (pc
+ 0), (void *) (&target
), 4);
5624 (void) memcpy((void *) (pc
+ 4), (void *) (&format
), 4);
5625 (void) memcpy((void *) (pc
+ 8), (void *) (&type
), 4);
5626 *(int32_t *) (pc
+ 12) = 0;
5627 *(int8_t *) (pc
+ 12) = state
->storePack
.swapEndian
;
5628 __glXReadPixelReply(dpy
, gc
, 1, 0, 0, 0, format
, type
, table
,
5637 #define X_GLsop_GetColorTableParameterfv 148
5639 __indirect_glGetColorTableParameterfv(GLenum target
, GLenum pname
,
5642 __GLXcontext
*const gc
= __glXGetCurrentContext();
5643 Display
*const dpy
= gc
->currentDpy
;
5644 const GLuint cmdlen
= 8;
5645 if (__builtin_expect(dpy
!= NULL
, 1)) {
5647 xcb_connection_t
*c
= XGetXCBConnection(dpy
);
5648 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
5649 xcb_glx_get_color_table_parameterfv_reply_t
*reply
=
5650 xcb_glx_get_color_table_parameterfv_reply(c
,
5651 xcb_glx_get_color_table_parameterfv
5653 gc
->currentContextTag
,
5654 target
, pname
), NULL
);
5655 if (xcb_glx_get_color_table_parameterfv_data_length(reply
) == 0)
5656 (void) memcpy(params
, &reply
->datum
, sizeof(reply
->datum
));
5658 (void) memcpy(params
,
5659 xcb_glx_get_color_table_parameterfv_data(reply
),
5660 xcb_glx_get_color_table_parameterfv_data_length
5661 (reply
) * sizeof(GLfloat
));
5665 __glXSetupSingleRequest(gc
, X_GLsop_GetColorTableParameterfv
,
5667 (void) memcpy((void *) (pc
+ 0), (void *) (&target
), 4);
5668 (void) memcpy((void *) (pc
+ 4), (void *) (&pname
), 4);
5669 (void) __glXReadReply(dpy
, 4, params
, GL_FALSE
);
5672 #endif /* USE_XCB */
5677 #define X_GLvop_GetColorTableParameterfvSGI 4099
5679 glGetColorTableParameterfvEXT(GLenum target
, GLenum pname
, GLfloat
* params
)
5681 __GLXcontext
*const gc
= __glXGetCurrentContext();
5684 CALL_GetColorTableParameterfv(GET_DISPATCH(),
5685 (target
, pname
, params
));
5687 __GLXcontext
*const gc
= __glXGetCurrentContext();
5688 Display
*const dpy
= gc
->currentDpy
;
5689 const GLuint cmdlen
= 8;
5690 if (__builtin_expect(dpy
!= NULL
, 1)) {
5692 __glXSetupVendorRequest(gc
, X_GLXVendorPrivateWithReply
,
5693 X_GLvop_GetColorTableParameterfvSGI
,
5695 (void) memcpy((void *) (pc
+ 0), (void *) (&target
), 4);
5696 (void) memcpy((void *) (pc
+ 4), (void *) (&pname
), 4);
5697 (void) __glXReadReply(dpy
, 4, params
, GL_FALSE
);
5705 #define X_GLsop_GetColorTableParameteriv 149
5707 __indirect_glGetColorTableParameteriv(GLenum target
, GLenum pname
,
5710 __GLXcontext
*const gc
= __glXGetCurrentContext();
5711 Display
*const dpy
= gc
->currentDpy
;
5712 const GLuint cmdlen
= 8;
5713 if (__builtin_expect(dpy
!= NULL
, 1)) {
5715 xcb_connection_t
*c
= XGetXCBConnection(dpy
);
5716 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
5717 xcb_glx_get_color_table_parameteriv_reply_t
*reply
=
5718 xcb_glx_get_color_table_parameteriv_reply(c
,
5719 xcb_glx_get_color_table_parameteriv
5721 gc
->currentContextTag
,
5722 target
, pname
), NULL
);
5723 if (xcb_glx_get_color_table_parameteriv_data_length(reply
) == 0)
5724 (void) memcpy(params
, &reply
->datum
, sizeof(reply
->datum
));
5726 (void) memcpy(params
,
5727 xcb_glx_get_color_table_parameteriv_data(reply
),
5728 xcb_glx_get_color_table_parameteriv_data_length
5729 (reply
) * sizeof(GLint
));
5733 __glXSetupSingleRequest(gc
, X_GLsop_GetColorTableParameteriv
,
5735 (void) memcpy((void *) (pc
+ 0), (void *) (&target
), 4);
5736 (void) memcpy((void *) (pc
+ 4), (void *) (&pname
), 4);
5737 (void) __glXReadReply(dpy
, 4, params
, GL_FALSE
);
5740 #endif /* USE_XCB */
5745 #define X_GLvop_GetColorTableParameterivSGI 4100
5747 glGetColorTableParameterivEXT(GLenum target
, GLenum pname
, GLint
* params
)
5749 __GLXcontext
*const gc
= __glXGetCurrentContext();
5752 CALL_GetColorTableParameteriv(GET_DISPATCH(),
5753 (target
, pname
, params
));
5755 __GLXcontext
*const gc
= __glXGetCurrentContext();
5756 Display
*const dpy
= gc
->currentDpy
;
5757 const GLuint cmdlen
= 8;
5758 if (__builtin_expect(dpy
!= NULL
, 1)) {
5760 __glXSetupVendorRequest(gc
, X_GLXVendorPrivateWithReply
,
5761 X_GLvop_GetColorTableParameterivSGI
,
5763 (void) memcpy((void *) (pc
+ 0), (void *) (&target
), 4);
5764 (void) memcpy((void *) (pc
+ 4), (void *) (&pname
), 4);
5765 (void) __glXReadReply(dpy
, 4, params
, GL_FALSE
);
5773 #define X_GLrop_ColorSubTable 195
5775 __indirect_glColorSubTable(GLenum target
, GLsizei start
, GLsizei count
,
5776 GLenum format
, GLenum type
, const GLvoid
* data
)
5778 __GLXcontext
*const gc
= __glXGetCurrentContext();
5779 const GLuint compsize
=
5780 (data
!= NULL
) ? __glImageSize(count
, 1, 1, format
, type
, target
) : 0;
5781 const GLuint cmdlen
= 44 + __GLX_PAD(compsize
);
5782 if (__builtin_expect(gc
->currentDpy
!= NULL
, 1)) {
5783 if (cmdlen
<= gc
->maxSmallRenderCommandSize
) {
5784 if ((gc
->pc
+ cmdlen
) > gc
->bufEnd
) {
5785 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
5787 emit_header(gc
->pc
, X_GLrop_ColorSubTable
, cmdlen
);
5788 (void) memcpy((void *) (gc
->pc
+ 24), (void *) (&target
), 4);
5789 (void) memcpy((void *) (gc
->pc
+ 28), (void *) (&start
), 4);
5790 (void) memcpy((void *) (gc
->pc
+ 32), (void *) (&count
), 4);
5791 (void) memcpy((void *) (gc
->pc
+ 36), (void *) (&format
), 4);
5792 (void) memcpy((void *) (gc
->pc
+ 40), (void *) (&type
), 4);
5794 (*gc
->fillImage
) (gc
, 1, count
, 1, 1, format
, type
, data
,
5795 gc
->pc
+ 44, gc
->pc
+ 4);
5797 (void) memcpy(gc
->pc
+ 4, default_pixel_store_1D
,
5798 default_pixel_store_1D_size
);
5801 if (gc
->pc
> gc
->limit
) {
5802 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
5805 const GLint op
= X_GLrop_ColorSubTable
;
5806 const GLuint cmdlenLarge
= cmdlen
+ 4;
5807 GLubyte
*const pc
= __glXFlushRenderBuffer(gc
, gc
->pc
);
5808 (void) memcpy((void *) (pc
+ 0), (void *) (&cmdlenLarge
), 4);
5809 (void) memcpy((void *) (pc
+ 4), (void *) (&op
), 4);
5810 (void) memcpy((void *) (pc
+ 28), (void *) (&target
), 4);
5811 (void) memcpy((void *) (pc
+ 32), (void *) (&start
), 4);
5812 (void) memcpy((void *) (pc
+ 36), (void *) (&count
), 4);
5813 (void) memcpy((void *) (pc
+ 40), (void *) (&format
), 4);
5814 (void) memcpy((void *) (pc
+ 44), (void *) (&type
), 4);
5815 __glXSendLargeImage(gc
, compsize
, 1, count
, 1, 1, format
, type
,
5816 data
, pc
+ 48, pc
+ 8);
5821 #define X_GLrop_CopyColorSubTable 196
5823 __indirect_glCopyColorSubTable(GLenum target
, GLsizei start
, GLint x
, GLint y
,
5826 __GLXcontext
*const gc
= __glXGetCurrentContext();
5827 const GLuint cmdlen
= 24;
5828 emit_header(gc
->pc
, X_GLrop_CopyColorSubTable
, cmdlen
);
5829 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&target
), 4);
5830 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&start
), 4);
5831 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&x
), 4);
5832 (void) memcpy((void *) (gc
->pc
+ 16), (void *) (&y
), 4);
5833 (void) memcpy((void *) (gc
->pc
+ 20), (void *) (&width
), 4);
5835 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
5836 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
5841 __glx_ConvolutionFilter_1D2D(unsigned opcode
, unsigned dim
, GLenum target
,
5842 GLenum internalformat
, GLsizei width
,
5843 GLsizei height
, GLenum format
, GLenum type
,
5844 const GLvoid
* image
)
5846 __GLXcontext
*const gc
= __glXGetCurrentContext();
5847 const GLuint compsize
=
5848 (image
!= NULL
) ? __glImageSize(width
, height
, 1, format
, type
,
5850 const GLuint cmdlen
= 48 + __GLX_PAD(compsize
);
5851 if (__builtin_expect(gc
->currentDpy
!= NULL
, 1)) {
5852 if (cmdlen
<= gc
->maxSmallRenderCommandSize
) {
5853 if ((gc
->pc
+ cmdlen
) > gc
->bufEnd
) {
5854 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
5856 emit_header(gc
->pc
, opcode
, cmdlen
);
5857 (void) memcpy((void *) (gc
->pc
+ 24), (void *) (&target
), 4);
5858 (void) memcpy((void *) (gc
->pc
+ 28), (void *) (&internalformat
),
5860 (void) memcpy((void *) (gc
->pc
+ 32), (void *) (&width
), 4);
5861 (void) memcpy((void *) (gc
->pc
+ 36), (void *) (&height
), 4);
5862 (void) memcpy((void *) (gc
->pc
+ 40), (void *) (&format
), 4);
5863 (void) memcpy((void *) (gc
->pc
+ 44), (void *) (&type
), 4);
5865 (*gc
->fillImage
) (gc
, dim
, width
, height
, 1, format
, type
,
5866 image
, gc
->pc
+ 48, gc
->pc
+ 4);
5868 (void) memcpy(gc
->pc
+ 4, default_pixel_store_2D
,
5869 default_pixel_store_2D_size
);
5872 if (gc
->pc
> gc
->limit
) {
5873 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
5876 const GLint op
= opcode
;
5877 const GLuint cmdlenLarge
= cmdlen
+ 4;
5878 GLubyte
*const pc
= __glXFlushRenderBuffer(gc
, gc
->pc
);
5879 (void) memcpy((void *) (pc
+ 0), (void *) (&cmdlenLarge
), 4);
5880 (void) memcpy((void *) (pc
+ 4), (void *) (&op
), 4);
5881 (void) memcpy((void *) (pc
+ 28), (void *) (&target
), 4);
5882 (void) memcpy((void *) (pc
+ 32), (void *) (&internalformat
), 4);
5883 (void) memcpy((void *) (pc
+ 36), (void *) (&width
), 4);
5884 (void) memcpy((void *) (pc
+ 40), (void *) (&height
), 4);
5885 (void) memcpy((void *) (pc
+ 44), (void *) (&format
), 4);
5886 (void) memcpy((void *) (pc
+ 48), (void *) (&type
), 4);
5887 __glXSendLargeImage(gc
, compsize
, dim
, width
, height
, 1, format
,
5888 type
, image
, pc
+ 52, pc
+ 8);
5893 #define X_GLrop_ConvolutionFilter1D 4101
5895 __indirect_glConvolutionFilter1D(GLenum target
, GLenum internalformat
,
5896 GLsizei width
, GLenum format
, GLenum type
,
5897 const GLvoid
* image
)
5899 __glx_ConvolutionFilter_1D2D(X_GLrop_ConvolutionFilter1D
, 1, target
,
5900 internalformat
, width
, 1, format
, type
,
5904 #define X_GLrop_ConvolutionFilter2D 4102
5906 __indirect_glConvolutionFilter2D(GLenum target
, GLenum internalformat
,
5907 GLsizei width
, GLsizei height
, GLenum format
,
5908 GLenum type
, const GLvoid
* image
)
5910 __glx_ConvolutionFilter_1D2D(X_GLrop_ConvolutionFilter2D
, 2, target
,
5911 internalformat
, width
, height
, format
, type
,
5915 #define X_GLrop_ConvolutionParameterf 4103
5917 __indirect_glConvolutionParameterf(GLenum target
, GLenum pname
,
5920 __GLXcontext
*const gc
= __glXGetCurrentContext();
5921 const GLuint cmdlen
= 16;
5922 emit_header(gc
->pc
, X_GLrop_ConvolutionParameterf
, cmdlen
);
5923 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&target
), 4);
5924 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&pname
), 4);
5925 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (¶ms
), 4);
5927 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
5928 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
5932 #define X_GLrop_ConvolutionParameterfv 4104
5934 __indirect_glConvolutionParameterfv(GLenum target
, GLenum pname
,
5935 const GLfloat
* params
)
5937 __GLXcontext
*const gc
= __glXGetCurrentContext();
5938 const GLuint compsize
= __glConvolutionParameterfv_size(pname
);
5939 const GLuint cmdlen
= 12 + __GLX_PAD((compsize
* 4));
5940 emit_header(gc
->pc
, X_GLrop_ConvolutionParameterfv
, cmdlen
);
5941 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&target
), 4);
5942 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&pname
), 4);
5943 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (params
), (compsize
* 4));
5945 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
5946 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
5950 #define X_GLrop_ConvolutionParameteri 4105
5952 __indirect_glConvolutionParameteri(GLenum target
, GLenum pname
, GLint params
)
5954 __GLXcontext
*const gc
= __glXGetCurrentContext();
5955 const GLuint cmdlen
= 16;
5956 emit_header(gc
->pc
, X_GLrop_ConvolutionParameteri
, cmdlen
);
5957 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&target
), 4);
5958 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&pname
), 4);
5959 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (¶ms
), 4);
5961 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
5962 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
5966 #define X_GLrop_ConvolutionParameteriv 4106
5968 __indirect_glConvolutionParameteriv(GLenum target
, GLenum pname
,
5969 const GLint
* params
)
5971 __GLXcontext
*const gc
= __glXGetCurrentContext();
5972 const GLuint compsize
= __glConvolutionParameteriv_size(pname
);
5973 const GLuint cmdlen
= 12 + __GLX_PAD((compsize
* 4));
5974 emit_header(gc
->pc
, X_GLrop_ConvolutionParameteriv
, cmdlen
);
5975 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&target
), 4);
5976 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&pname
), 4);
5977 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (params
), (compsize
* 4));
5979 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
5980 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
5984 #define X_GLrop_CopyConvolutionFilter1D 4107
5986 __indirect_glCopyConvolutionFilter1D(GLenum target
, GLenum internalformat
,
5987 GLint x
, GLint y
, GLsizei width
)
5989 __GLXcontext
*const gc
= __glXGetCurrentContext();
5990 const GLuint cmdlen
= 24;
5991 emit_header(gc
->pc
, X_GLrop_CopyConvolutionFilter1D
, cmdlen
);
5992 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&target
), 4);
5993 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&internalformat
), 4);
5994 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&x
), 4);
5995 (void) memcpy((void *) (gc
->pc
+ 16), (void *) (&y
), 4);
5996 (void) memcpy((void *) (gc
->pc
+ 20), (void *) (&width
), 4);
5998 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
5999 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
6003 #define X_GLrop_CopyConvolutionFilter2D 4108
6005 __indirect_glCopyConvolutionFilter2D(GLenum target
, GLenum internalformat
,
6006 GLint x
, GLint y
, GLsizei width
,
6009 __GLXcontext
*const gc
= __glXGetCurrentContext();
6010 const GLuint cmdlen
= 28;
6011 emit_header(gc
->pc
, X_GLrop_CopyConvolutionFilter2D
, cmdlen
);
6012 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&target
), 4);
6013 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&internalformat
), 4);
6014 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&x
), 4);
6015 (void) memcpy((void *) (gc
->pc
+ 16), (void *) (&y
), 4);
6016 (void) memcpy((void *) (gc
->pc
+ 20), (void *) (&width
), 4);
6017 (void) memcpy((void *) (gc
->pc
+ 24), (void *) (&height
), 4);
6019 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
6020 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
6024 #define X_GLsop_GetConvolutionFilter 150
6026 __indirect_glGetConvolutionFilter(GLenum target
, GLenum format
, GLenum type
,
6029 __GLXcontext
*const gc
= __glXGetCurrentContext();
6030 const __GLXattribute
*const state
= gc
->client_state_private
;
6031 Display
*const dpy
= gc
->currentDpy
;
6032 const GLuint cmdlen
= 16;
6033 if (__builtin_expect(dpy
!= NULL
, 1)) {
6035 xcb_connection_t
*c
= XGetXCBConnection(dpy
);
6036 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
6037 xcb_glx_get_convolution_filter_reply_t
*reply
=
6038 xcb_glx_get_convolution_filter_reply(c
,
6039 xcb_glx_get_convolution_filter
6040 (c
, gc
->currentContextTag
,
6041 target
, format
, type
,
6044 (void) memcpy(image
, xcb_glx_get_convolution_filter_data(reply
),
6045 xcb_glx_get_convolution_filter_data_length(reply
) *
6050 __glXSetupSingleRequest(gc
, X_GLsop_GetConvolutionFilter
, cmdlen
);
6051 (void) memcpy((void *) (pc
+ 0), (void *) (&target
), 4);
6052 (void) memcpy((void *) (pc
+ 4), (void *) (&format
), 4);
6053 (void) memcpy((void *) (pc
+ 8), (void *) (&type
), 4);
6054 *(int32_t *) (pc
+ 12) = 0;
6055 *(int8_t *) (pc
+ 12) = state
->storePack
.swapEndian
;
6056 __glXReadPixelReply(dpy
, gc
, 2, 0, 0, 0, format
, type
, image
,
6060 #endif /* USE_XCB */
6065 #define X_GLvop_GetConvolutionFilterEXT 1
6067 gl_dispatch_stub_356(GLenum target
, GLenum format
, GLenum type
,
6070 __GLXcontext
*const gc
= __glXGetCurrentContext();
6073 CALL_GetConvolutionFilter(GET_DISPATCH(),
6074 (target
, format
, type
, image
));
6076 __GLXcontext
*const gc
= __glXGetCurrentContext();
6077 const __GLXattribute
*const state
= gc
->client_state_private
;
6078 Display
*const dpy
= gc
->currentDpy
;
6079 const GLuint cmdlen
= 16;
6080 if (__builtin_expect(dpy
!= NULL
, 1)) {
6082 __glXSetupVendorRequest(gc
, X_GLXVendorPrivateWithReply
,
6083 X_GLvop_GetConvolutionFilterEXT
,
6085 (void) memcpy((void *) (pc
+ 0), (void *) (&target
), 4);
6086 (void) memcpy((void *) (pc
+ 4), (void *) (&format
), 4);
6087 (void) memcpy((void *) (pc
+ 8), (void *) (&type
), 4);
6088 *(int32_t *) (pc
+ 12) = 0;
6089 *(int8_t *) (pc
+ 12) = state
->storePack
.swapEndian
;
6090 __glXReadPixelReply(dpy
, gc
, 2, 0, 0, 0, format
, type
, image
,
6099 #define X_GLsop_GetConvolutionParameterfv 151
6101 __indirect_glGetConvolutionParameterfv(GLenum target
, GLenum pname
,
6104 __GLXcontext
*const gc
= __glXGetCurrentContext();
6105 Display
*const dpy
= gc
->currentDpy
;
6106 const GLuint cmdlen
= 8;
6107 if (__builtin_expect(dpy
!= NULL
, 1)) {
6109 xcb_connection_t
*c
= XGetXCBConnection(dpy
);
6110 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
6111 xcb_glx_get_convolution_parameterfv_reply_t
*reply
=
6112 xcb_glx_get_convolution_parameterfv_reply(c
,
6113 xcb_glx_get_convolution_parameterfv
6115 gc
->currentContextTag
,
6116 target
, pname
), NULL
);
6117 if (xcb_glx_get_convolution_parameterfv_data_length(reply
) == 0)
6118 (void) memcpy(params
, &reply
->datum
, sizeof(reply
->datum
));
6120 (void) memcpy(params
,
6121 xcb_glx_get_convolution_parameterfv_data(reply
),
6122 xcb_glx_get_convolution_parameterfv_data_length
6123 (reply
) * sizeof(GLfloat
));
6127 __glXSetupSingleRequest(gc
, X_GLsop_GetConvolutionParameterfv
,
6129 (void) memcpy((void *) (pc
+ 0), (void *) (&target
), 4);
6130 (void) memcpy((void *) (pc
+ 4), (void *) (&pname
), 4);
6131 (void) __glXReadReply(dpy
, 4, params
, GL_FALSE
);
6134 #endif /* USE_XCB */
6139 #define X_GLvop_GetConvolutionParameterfvEXT 2
6141 gl_dispatch_stub_357(GLenum target
, GLenum pname
, GLfloat
* params
)
6143 __GLXcontext
*const gc
= __glXGetCurrentContext();
6146 CALL_GetConvolutionParameterfv(GET_DISPATCH(),
6147 (target
, pname
, params
));
6149 __GLXcontext
*const gc
= __glXGetCurrentContext();
6150 Display
*const dpy
= gc
->currentDpy
;
6151 const GLuint cmdlen
= 8;
6152 if (__builtin_expect(dpy
!= NULL
, 1)) {
6154 __glXSetupVendorRequest(gc
, X_GLXVendorPrivateWithReply
,
6155 X_GLvop_GetConvolutionParameterfvEXT
,
6157 (void) memcpy((void *) (pc
+ 0), (void *) (&target
), 4);
6158 (void) memcpy((void *) (pc
+ 4), (void *) (&pname
), 4);
6159 (void) __glXReadReply(dpy
, 4, params
, GL_FALSE
);
6167 #define X_GLsop_GetConvolutionParameteriv 152
6169 __indirect_glGetConvolutionParameteriv(GLenum target
, GLenum pname
,
6172 __GLXcontext
*const gc
= __glXGetCurrentContext();
6173 Display
*const dpy
= gc
->currentDpy
;
6174 const GLuint cmdlen
= 8;
6175 if (__builtin_expect(dpy
!= NULL
, 1)) {
6177 xcb_connection_t
*c
= XGetXCBConnection(dpy
);
6178 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
6179 xcb_glx_get_convolution_parameteriv_reply_t
*reply
=
6180 xcb_glx_get_convolution_parameteriv_reply(c
,
6181 xcb_glx_get_convolution_parameteriv
6183 gc
->currentContextTag
,
6184 target
, pname
), NULL
);
6185 if (xcb_glx_get_convolution_parameteriv_data_length(reply
) == 0)
6186 (void) memcpy(params
, &reply
->datum
, sizeof(reply
->datum
));
6188 (void) memcpy(params
,
6189 xcb_glx_get_convolution_parameteriv_data(reply
),
6190 xcb_glx_get_convolution_parameteriv_data_length
6191 (reply
) * sizeof(GLint
));
6195 __glXSetupSingleRequest(gc
, X_GLsop_GetConvolutionParameteriv
,
6197 (void) memcpy((void *) (pc
+ 0), (void *) (&target
), 4);
6198 (void) memcpy((void *) (pc
+ 4), (void *) (&pname
), 4);
6199 (void) __glXReadReply(dpy
, 4, params
, GL_FALSE
);
6202 #endif /* USE_XCB */
6207 #define X_GLvop_GetConvolutionParameterivEXT 3
6209 gl_dispatch_stub_358(GLenum target
, GLenum pname
, GLint
* params
)
6211 __GLXcontext
*const gc
= __glXGetCurrentContext();
6214 CALL_GetConvolutionParameteriv(GET_DISPATCH(),
6215 (target
, pname
, params
));
6217 __GLXcontext
*const gc
= __glXGetCurrentContext();
6218 Display
*const dpy
= gc
->currentDpy
;
6219 const GLuint cmdlen
= 8;
6220 if (__builtin_expect(dpy
!= NULL
, 1)) {
6222 __glXSetupVendorRequest(gc
, X_GLXVendorPrivateWithReply
,
6223 X_GLvop_GetConvolutionParameterivEXT
,
6225 (void) memcpy((void *) (pc
+ 0), (void *) (&target
), 4);
6226 (void) memcpy((void *) (pc
+ 4), (void *) (&pname
), 4);
6227 (void) __glXReadReply(dpy
, 4, params
, GL_FALSE
);
6235 #define X_GLsop_GetHistogram 154
6237 __indirect_glGetHistogram(GLenum target
, GLboolean reset
, GLenum format
,
6238 GLenum type
, GLvoid
* values
)
6240 __GLXcontext
*const gc
= __glXGetCurrentContext();
6241 const __GLXattribute
*const state
= gc
->client_state_private
;
6242 Display
*const dpy
= gc
->currentDpy
;
6243 const GLuint cmdlen
= 16;
6244 if (__builtin_expect(dpy
!= NULL
, 1)) {
6246 xcb_connection_t
*c
= XGetXCBConnection(dpy
);
6247 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
6248 xcb_glx_get_histogram_reply_t
*reply
=
6249 xcb_glx_get_histogram_reply(c
,
6250 xcb_glx_get_histogram(c
,
6259 (void) memcpy(values
, xcb_glx_get_histogram_data(reply
),
6260 xcb_glx_get_histogram_data_length(reply
) *
6265 __glXSetupSingleRequest(gc
, X_GLsop_GetHistogram
, cmdlen
);
6266 (void) memcpy((void *) (pc
+ 0), (void *) (&target
), 4);
6267 (void) memcpy((void *) (pc
+ 4), (void *) (&format
), 4);
6268 (void) memcpy((void *) (pc
+ 8), (void *) (&type
), 4);
6269 *(int32_t *) (pc
+ 12) = 0;
6270 *(int8_t *) (pc
+ 12) = state
->storePack
.swapEndian
;
6271 *(int8_t *) (pc
+ 13) = reset
;
6272 __glXReadPixelReply(dpy
, gc
, 1, 0, 0, 0, format
, type
, values
,
6276 #endif /* USE_XCB */
6281 #define X_GLvop_GetHistogramEXT 5
6283 gl_dispatch_stub_361(GLenum target
, GLboolean reset
, GLenum format
,
6284 GLenum type
, GLvoid
* values
)
6286 __GLXcontext
*const gc
= __glXGetCurrentContext();
6289 CALL_GetHistogram(GET_DISPATCH(),
6290 (target
, reset
, format
, type
, values
));
6292 __GLXcontext
*const gc
= __glXGetCurrentContext();
6293 const __GLXattribute
*const state
= gc
->client_state_private
;
6294 Display
*const dpy
= gc
->currentDpy
;
6295 const GLuint cmdlen
= 16;
6296 if (__builtin_expect(dpy
!= NULL
, 1)) {
6298 __glXSetupVendorRequest(gc
, X_GLXVendorPrivateWithReply
,
6299 X_GLvop_GetHistogramEXT
, cmdlen
);
6300 (void) memcpy((void *) (pc
+ 0), (void *) (&target
), 4);
6301 (void) memcpy((void *) (pc
+ 4), (void *) (&format
), 4);
6302 (void) memcpy((void *) (pc
+ 8), (void *) (&type
), 4);
6303 *(int32_t *) (pc
+ 12) = 0;
6304 *(int8_t *) (pc
+ 12) = state
->storePack
.swapEndian
;
6305 *(int8_t *) (pc
+ 13) = reset
;
6306 __glXReadPixelReply(dpy
, gc
, 1, 0, 0, 0, format
, type
, values
,
6315 #define X_GLsop_GetHistogramParameterfv 155
6317 __indirect_glGetHistogramParameterfv(GLenum target
, GLenum pname
,
6320 __GLXcontext
*const gc
= __glXGetCurrentContext();
6321 Display
*const dpy
= gc
->currentDpy
;
6322 const GLuint cmdlen
= 8;
6323 if (__builtin_expect(dpy
!= NULL
, 1)) {
6325 xcb_connection_t
*c
= XGetXCBConnection(dpy
);
6326 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
6327 xcb_glx_get_histogram_parameterfv_reply_t
*reply
=
6328 xcb_glx_get_histogram_parameterfv_reply(c
,
6329 xcb_glx_get_histogram_parameterfv
6330 (c
, gc
->currentContextTag
,
6331 target
, pname
), NULL
);
6332 if (xcb_glx_get_histogram_parameterfv_data_length(reply
) == 0)
6333 (void) memcpy(params
, &reply
->datum
, sizeof(reply
->datum
));
6335 (void) memcpy(params
,
6336 xcb_glx_get_histogram_parameterfv_data(reply
),
6337 xcb_glx_get_histogram_parameterfv_data_length(reply
)
6342 __glXSetupSingleRequest(gc
, X_GLsop_GetHistogramParameterfv
,
6344 (void) memcpy((void *) (pc
+ 0), (void *) (&target
), 4);
6345 (void) memcpy((void *) (pc
+ 4), (void *) (&pname
), 4);
6346 (void) __glXReadReply(dpy
, 4, params
, GL_FALSE
);
6349 #endif /* USE_XCB */
6354 #define X_GLvop_GetHistogramParameterfvEXT 6
6356 gl_dispatch_stub_362(GLenum target
, GLenum pname
, GLfloat
* params
)
6358 __GLXcontext
*const gc
= __glXGetCurrentContext();
6361 CALL_GetHistogramParameterfv(GET_DISPATCH(), (target
, pname
, params
));
6363 __GLXcontext
*const gc
= __glXGetCurrentContext();
6364 Display
*const dpy
= gc
->currentDpy
;
6365 const GLuint cmdlen
= 8;
6366 if (__builtin_expect(dpy
!= NULL
, 1)) {
6368 __glXSetupVendorRequest(gc
, X_GLXVendorPrivateWithReply
,
6369 X_GLvop_GetHistogramParameterfvEXT
,
6371 (void) memcpy((void *) (pc
+ 0), (void *) (&target
), 4);
6372 (void) memcpy((void *) (pc
+ 4), (void *) (&pname
), 4);
6373 (void) __glXReadReply(dpy
, 4, params
, GL_FALSE
);
6381 #define X_GLsop_GetHistogramParameteriv 156
6383 __indirect_glGetHistogramParameteriv(GLenum target
, GLenum pname
,
6386 __GLXcontext
*const gc
= __glXGetCurrentContext();
6387 Display
*const dpy
= gc
->currentDpy
;
6388 const GLuint cmdlen
= 8;
6389 if (__builtin_expect(dpy
!= NULL
, 1)) {
6391 xcb_connection_t
*c
= XGetXCBConnection(dpy
);
6392 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
6393 xcb_glx_get_histogram_parameteriv_reply_t
*reply
=
6394 xcb_glx_get_histogram_parameteriv_reply(c
,
6395 xcb_glx_get_histogram_parameteriv
6396 (c
, gc
->currentContextTag
,
6397 target
, pname
), NULL
);
6398 if (xcb_glx_get_histogram_parameteriv_data_length(reply
) == 0)
6399 (void) memcpy(params
, &reply
->datum
, sizeof(reply
->datum
));
6401 (void) memcpy(params
,
6402 xcb_glx_get_histogram_parameteriv_data(reply
),
6403 xcb_glx_get_histogram_parameteriv_data_length(reply
)
6408 __glXSetupSingleRequest(gc
, X_GLsop_GetHistogramParameteriv
,
6410 (void) memcpy((void *) (pc
+ 0), (void *) (&target
), 4);
6411 (void) memcpy((void *) (pc
+ 4), (void *) (&pname
), 4);
6412 (void) __glXReadReply(dpy
, 4, params
, GL_FALSE
);
6415 #endif /* USE_XCB */
6420 #define X_GLvop_GetHistogramParameterivEXT 7
6422 gl_dispatch_stub_363(GLenum target
, GLenum pname
, GLint
* params
)
6424 __GLXcontext
*const gc
= __glXGetCurrentContext();
6427 CALL_GetHistogramParameteriv(GET_DISPATCH(), (target
, pname
, params
));
6429 __GLXcontext
*const gc
= __glXGetCurrentContext();
6430 Display
*const dpy
= gc
->currentDpy
;
6431 const GLuint cmdlen
= 8;
6432 if (__builtin_expect(dpy
!= NULL
, 1)) {
6434 __glXSetupVendorRequest(gc
, X_GLXVendorPrivateWithReply
,
6435 X_GLvop_GetHistogramParameterivEXT
,
6437 (void) memcpy((void *) (pc
+ 0), (void *) (&target
), 4);
6438 (void) memcpy((void *) (pc
+ 4), (void *) (&pname
), 4);
6439 (void) __glXReadReply(dpy
, 4, params
, GL_FALSE
);
6447 #define X_GLsop_GetMinmax 157
6449 __indirect_glGetMinmax(GLenum target
, GLboolean reset
, GLenum format
,
6450 GLenum type
, GLvoid
* values
)
6452 __GLXcontext
*const gc
= __glXGetCurrentContext();
6453 const __GLXattribute
*const state
= gc
->client_state_private
;
6454 Display
*const dpy
= gc
->currentDpy
;
6455 const GLuint cmdlen
= 16;
6456 if (__builtin_expect(dpy
!= NULL
, 1)) {
6458 xcb_connection_t
*c
= XGetXCBConnection(dpy
);
6459 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
6460 xcb_glx_get_minmax_reply_t
*reply
=
6461 xcb_glx_get_minmax_reply(c
,
6462 xcb_glx_get_minmax(c
,
6463 gc
->currentContextTag
,
6464 target
, reset
, format
,
6468 (void) memcpy(values
, xcb_glx_get_minmax_data(reply
),
6469 xcb_glx_get_minmax_data_length(reply
) * sizeof(GLvoid
));
6473 __glXSetupSingleRequest(gc
, X_GLsop_GetMinmax
, cmdlen
);
6474 (void) memcpy((void *) (pc
+ 0), (void *) (&target
), 4);
6475 (void) memcpy((void *) (pc
+ 4), (void *) (&format
), 4);
6476 (void) memcpy((void *) (pc
+ 8), (void *) (&type
), 4);
6477 *(int32_t *) (pc
+ 12) = 0;
6478 *(int8_t *) (pc
+ 12) = state
->storePack
.swapEndian
;
6479 *(int8_t *) (pc
+ 13) = reset
;
6480 __glXReadPixelReply(dpy
, gc
, 1, 2, 1, 1, format
, type
, values
,
6484 #endif /* USE_XCB */
6489 #define X_GLvop_GetMinmaxEXT 8
6491 gl_dispatch_stub_364(GLenum target
, GLboolean reset
, GLenum format
,
6492 GLenum type
, GLvoid
* values
)
6494 __GLXcontext
*const gc
= __glXGetCurrentContext();
6497 CALL_GetMinmax(GET_DISPATCH(), (target
, reset
, format
, type
, values
));
6499 __GLXcontext
*const gc
= __glXGetCurrentContext();
6500 const __GLXattribute
*const state
= gc
->client_state_private
;
6501 Display
*const dpy
= gc
->currentDpy
;
6502 const GLuint cmdlen
= 16;
6503 if (__builtin_expect(dpy
!= NULL
, 1)) {
6505 __glXSetupVendorRequest(gc
, X_GLXVendorPrivateWithReply
,
6506 X_GLvop_GetMinmaxEXT
, cmdlen
);
6507 (void) memcpy((void *) (pc
+ 0), (void *) (&target
), 4);
6508 (void) memcpy((void *) (pc
+ 4), (void *) (&format
), 4);
6509 (void) memcpy((void *) (pc
+ 8), (void *) (&type
), 4);
6510 *(int32_t *) (pc
+ 12) = 0;
6511 *(int8_t *) (pc
+ 12) = state
->storePack
.swapEndian
;
6512 *(int8_t *) (pc
+ 13) = reset
;
6513 __glXReadPixelReply(dpy
, gc
, 1, 2, 1, 1, format
, type
, values
,
6522 #define X_GLsop_GetMinmaxParameterfv 158
6524 __indirect_glGetMinmaxParameterfv(GLenum target
, GLenum pname
,
6527 __GLXcontext
*const gc
= __glXGetCurrentContext();
6528 Display
*const dpy
= gc
->currentDpy
;
6529 const GLuint cmdlen
= 8;
6530 if (__builtin_expect(dpy
!= NULL
, 1)) {
6532 xcb_connection_t
*c
= XGetXCBConnection(dpy
);
6533 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
6534 xcb_glx_get_minmax_parameterfv_reply_t
*reply
=
6535 xcb_glx_get_minmax_parameterfv_reply(c
,
6536 xcb_glx_get_minmax_parameterfv
6537 (c
, gc
->currentContextTag
,
6538 target
, pname
), NULL
);
6539 if (xcb_glx_get_minmax_parameterfv_data_length(reply
) == 0)
6540 (void) memcpy(params
, &reply
->datum
, sizeof(reply
->datum
));
6542 (void) memcpy(params
, xcb_glx_get_minmax_parameterfv_data(reply
),
6543 xcb_glx_get_minmax_parameterfv_data_length(reply
) *
6548 __glXSetupSingleRequest(gc
, X_GLsop_GetMinmaxParameterfv
, cmdlen
);
6549 (void) memcpy((void *) (pc
+ 0), (void *) (&target
), 4);
6550 (void) memcpy((void *) (pc
+ 4), (void *) (&pname
), 4);
6551 (void) __glXReadReply(dpy
, 4, params
, GL_FALSE
);
6554 #endif /* USE_XCB */
6559 #define X_GLvop_GetMinmaxParameterfvEXT 9
6561 gl_dispatch_stub_365(GLenum target
, GLenum pname
, GLfloat
* params
)
6563 __GLXcontext
*const gc
= __glXGetCurrentContext();
6566 CALL_GetMinmaxParameterfv(GET_DISPATCH(), (target
, pname
, params
));
6568 __GLXcontext
*const gc
= __glXGetCurrentContext();
6569 Display
*const dpy
= gc
->currentDpy
;
6570 const GLuint cmdlen
= 8;
6571 if (__builtin_expect(dpy
!= NULL
, 1)) {
6573 __glXSetupVendorRequest(gc
, X_GLXVendorPrivateWithReply
,
6574 X_GLvop_GetMinmaxParameterfvEXT
,
6576 (void) memcpy((void *) (pc
+ 0), (void *) (&target
), 4);
6577 (void) memcpy((void *) (pc
+ 4), (void *) (&pname
), 4);
6578 (void) __glXReadReply(dpy
, 4, params
, GL_FALSE
);
6586 #define X_GLsop_GetMinmaxParameteriv 159
6588 __indirect_glGetMinmaxParameteriv(GLenum target
, GLenum pname
, GLint
* params
)
6590 __GLXcontext
*const gc
= __glXGetCurrentContext();
6591 Display
*const dpy
= gc
->currentDpy
;
6592 const GLuint cmdlen
= 8;
6593 if (__builtin_expect(dpy
!= NULL
, 1)) {
6595 xcb_connection_t
*c
= XGetXCBConnection(dpy
);
6596 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
6597 xcb_glx_get_minmax_parameteriv_reply_t
*reply
=
6598 xcb_glx_get_minmax_parameteriv_reply(c
,
6599 xcb_glx_get_minmax_parameteriv
6600 (c
, gc
->currentContextTag
,
6601 target
, pname
), NULL
);
6602 if (xcb_glx_get_minmax_parameteriv_data_length(reply
) == 0)
6603 (void) memcpy(params
, &reply
->datum
, sizeof(reply
->datum
));
6605 (void) memcpy(params
, xcb_glx_get_minmax_parameteriv_data(reply
),
6606 xcb_glx_get_minmax_parameteriv_data_length(reply
) *
6611 __glXSetupSingleRequest(gc
, X_GLsop_GetMinmaxParameteriv
, cmdlen
);
6612 (void) memcpy((void *) (pc
+ 0), (void *) (&target
), 4);
6613 (void) memcpy((void *) (pc
+ 4), (void *) (&pname
), 4);
6614 (void) __glXReadReply(dpy
, 4, params
, GL_FALSE
);
6617 #endif /* USE_XCB */
6622 #define X_GLvop_GetMinmaxParameterivEXT 10
6624 gl_dispatch_stub_366(GLenum target
, GLenum pname
, GLint
* params
)
6626 __GLXcontext
*const gc
= __glXGetCurrentContext();
6629 CALL_GetMinmaxParameteriv(GET_DISPATCH(), (target
, pname
, params
));
6631 __GLXcontext
*const gc
= __glXGetCurrentContext();
6632 Display
*const dpy
= gc
->currentDpy
;
6633 const GLuint cmdlen
= 8;
6634 if (__builtin_expect(dpy
!= NULL
, 1)) {
6636 __glXSetupVendorRequest(gc
, X_GLXVendorPrivateWithReply
,
6637 X_GLvop_GetMinmaxParameterivEXT
,
6639 (void) memcpy((void *) (pc
+ 0), (void *) (&target
), 4);
6640 (void) memcpy((void *) (pc
+ 4), (void *) (&pname
), 4);
6641 (void) __glXReadReply(dpy
, 4, params
, GL_FALSE
);
6649 #define X_GLrop_Histogram 4110
6651 __indirect_glHistogram(GLenum target
, GLsizei width
, GLenum internalformat
,
6654 __GLXcontext
*const gc
= __glXGetCurrentContext();
6655 const GLuint cmdlen
= 20;
6656 emit_header(gc
->pc
, X_GLrop_Histogram
, cmdlen
);
6657 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&target
), 4);
6658 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&width
), 4);
6659 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&internalformat
), 4);
6660 (void) memcpy((void *) (gc
->pc
+ 16), (void *) (&sink
), 1);
6662 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
6663 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
6667 #define X_GLrop_Minmax 4111
6669 __indirect_glMinmax(GLenum target
, GLenum internalformat
, GLboolean sink
)
6671 __GLXcontext
*const gc
= __glXGetCurrentContext();
6672 const GLuint cmdlen
= 16;
6673 emit_header(gc
->pc
, X_GLrop_Minmax
, cmdlen
);
6674 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&target
), 4);
6675 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&internalformat
), 4);
6676 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&sink
), 1);
6678 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
6679 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
6683 #define X_GLrop_ResetHistogram 4112
6685 __indirect_glResetHistogram(GLenum target
)
6687 __GLXcontext
*const gc
= __glXGetCurrentContext();
6688 const GLuint cmdlen
= 8;
6689 emit_header(gc
->pc
, X_GLrop_ResetHistogram
, cmdlen
);
6690 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&target
), 4);
6692 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
6693 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
6697 #define X_GLrop_ResetMinmax 4113
6699 __indirect_glResetMinmax(GLenum target
)
6701 __GLXcontext
*const gc
= __glXGetCurrentContext();
6702 const GLuint cmdlen
= 8;
6703 emit_header(gc
->pc
, X_GLrop_ResetMinmax
, cmdlen
);
6704 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&target
), 4);
6706 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
6707 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
6712 __glx_TexImage_3D4D(unsigned opcode
, unsigned dim
, GLenum target
, GLint level
,
6713 GLint internalformat
, GLsizei width
, GLsizei height
,
6714 GLsizei depth
, GLsizei extent
, GLint border
,
6715 GLenum format
, GLenum type
, const GLvoid
* pixels
)
6717 __GLXcontext
*const gc
= __glXGetCurrentContext();
6718 const GLuint compsize
=
6719 (pixels
!= NULL
) ? __glImageSize(width
, height
, depth
, format
, type
,
6721 const GLuint cmdlen
= 84 + __GLX_PAD(compsize
);
6722 if (__builtin_expect(gc
->currentDpy
!= NULL
, 1)) {
6723 if (cmdlen
<= gc
->maxSmallRenderCommandSize
) {
6724 if ((gc
->pc
+ cmdlen
) > gc
->bufEnd
) {
6725 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
6727 emit_header(gc
->pc
, opcode
, cmdlen
);
6728 (void) memcpy((void *) (gc
->pc
+ 40), (void *) (&target
), 4);
6729 (void) memcpy((void *) (gc
->pc
+ 44), (void *) (&level
), 4);
6730 (void) memcpy((void *) (gc
->pc
+ 48), (void *) (&internalformat
),
6732 (void) memcpy((void *) (gc
->pc
+ 52), (void *) (&width
), 4);
6733 (void) memcpy((void *) (gc
->pc
+ 56), (void *) (&height
), 4);
6734 (void) memcpy((void *) (gc
->pc
+ 60), (void *) (&depth
), 4);
6735 (void) memcpy((void *) (gc
->pc
+ 64), (void *) (&extent
), 4);
6736 (void) memcpy((void *) (gc
->pc
+ 68), (void *) (&border
), 4);
6737 (void) memcpy((void *) (gc
->pc
+ 72), (void *) (&format
), 4);
6738 (void) memcpy((void *) (gc
->pc
+ 76), (void *) (&type
), 4);
6739 (void) memcpy((void *) (gc
->pc
+ 80),
6740 (void *) ((pixels
== NULL
) ? one
: zero
), 4);
6742 (*gc
->fillImage
) (gc
, dim
, width
, height
, depth
, format
, type
,
6743 pixels
, gc
->pc
+ 84, gc
->pc
+ 4);
6745 (void) memcpy(gc
->pc
+ 4, default_pixel_store_4D
,
6746 default_pixel_store_4D_size
);
6749 if (gc
->pc
> gc
->limit
) {
6750 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
6753 const GLint op
= opcode
;
6754 const GLuint cmdlenLarge
= cmdlen
+ 4;
6755 GLubyte
*const pc
= __glXFlushRenderBuffer(gc
, gc
->pc
);
6756 (void) memcpy((void *) (pc
+ 0), (void *) (&cmdlenLarge
), 4);
6757 (void) memcpy((void *) (pc
+ 4), (void *) (&op
), 4);
6758 (void) memcpy((void *) (pc
+ 44), (void *) (&target
), 4);
6759 (void) memcpy((void *) (pc
+ 48), (void *) (&level
), 4);
6760 (void) memcpy((void *) (pc
+ 52), (void *) (&internalformat
), 4);
6761 (void) memcpy((void *) (pc
+ 56), (void *) (&width
), 4);
6762 (void) memcpy((void *) (pc
+ 60), (void *) (&height
), 4);
6763 (void) memcpy((void *) (pc
+ 64), (void *) (&depth
), 4);
6764 (void) memcpy((void *) (pc
+ 68), (void *) (&extent
), 4);
6765 (void) memcpy((void *) (pc
+ 72), (void *) (&border
), 4);
6766 (void) memcpy((void *) (pc
+ 76), (void *) (&format
), 4);
6767 (void) memcpy((void *) (pc
+ 80), (void *) (&type
), 4);
6768 (void) memcpy((void *) (pc
+ 84), zero
, 4);
6769 __glXSendLargeImage(gc
, compsize
, dim
, width
, height
, depth
,
6770 format
, type
, pixels
, pc
+ 88, pc
+ 8);
6775 #define X_GLrop_TexImage3D 4114
6777 __indirect_glTexImage3D(GLenum target
, GLint level
, GLint internalformat
,
6778 GLsizei width
, GLsizei height
, GLsizei depth
,
6779 GLint border
, GLenum format
, GLenum type
,
6780 const GLvoid
* pixels
)
6782 __glx_TexImage_3D4D(X_GLrop_TexImage3D
, 3, target
, level
, internalformat
,
6783 width
, height
, depth
, 1, border
, format
, type
,
6788 __glx_TexSubImage_3D4D(unsigned opcode
, unsigned dim
, GLenum target
,
6789 GLint level
, GLint xoffset
, GLint yoffset
,
6790 GLint zoffset
, GLint woffset
, GLsizei width
,
6791 GLsizei height
, GLsizei depth
, GLsizei extent
,
6792 GLenum format
, GLenum type
, const GLvoid
* pixels
)
6794 __GLXcontext
*const gc
= __glXGetCurrentContext();
6795 const GLuint compsize
=
6796 (pixels
!= NULL
) ? __glImageSize(width
, height
, depth
, format
, type
,
6798 const GLuint cmdlen
= 92 + __GLX_PAD(compsize
);
6799 if (__builtin_expect(gc
->currentDpy
!= NULL
, 1)) {
6800 if (cmdlen
<= gc
->maxSmallRenderCommandSize
) {
6801 if ((gc
->pc
+ cmdlen
) > gc
->bufEnd
) {
6802 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
6804 emit_header(gc
->pc
, opcode
, cmdlen
);
6805 (void) memcpy((void *) (gc
->pc
+ 40), (void *) (&target
), 4);
6806 (void) memcpy((void *) (gc
->pc
+ 44), (void *) (&level
), 4);
6807 (void) memcpy((void *) (gc
->pc
+ 48), (void *) (&xoffset
), 4);
6808 (void) memcpy((void *) (gc
->pc
+ 52), (void *) (&yoffset
), 4);
6809 (void) memcpy((void *) (gc
->pc
+ 56), (void *) (&zoffset
), 4);
6810 (void) memcpy((void *) (gc
->pc
+ 60), (void *) (&woffset
), 4);
6811 (void) memcpy((void *) (gc
->pc
+ 64), (void *) (&width
), 4);
6812 (void) memcpy((void *) (gc
->pc
+ 68), (void *) (&height
), 4);
6813 (void) memcpy((void *) (gc
->pc
+ 72), (void *) (&depth
), 4);
6814 (void) memcpy((void *) (gc
->pc
+ 76), (void *) (&extent
), 4);
6815 (void) memcpy((void *) (gc
->pc
+ 80), (void *) (&format
), 4);
6816 (void) memcpy((void *) (gc
->pc
+ 84), (void *) (&type
), 4);
6817 (void) memcpy((void *) (gc
->pc
+ 88),
6818 (void *) ((pixels
== NULL
) ? one
: zero
), 4);
6820 (*gc
->fillImage
) (gc
, dim
, width
, height
, depth
, format
, type
,
6821 pixels
, gc
->pc
+ 92, gc
->pc
+ 4);
6823 (void) memcpy(gc
->pc
+ 4, default_pixel_store_4D
,
6824 default_pixel_store_4D_size
);
6827 if (gc
->pc
> gc
->limit
) {
6828 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
6831 const GLint op
= opcode
;
6832 const GLuint cmdlenLarge
= cmdlen
+ 4;
6833 GLubyte
*const pc
= __glXFlushRenderBuffer(gc
, gc
->pc
);
6834 (void) memcpy((void *) (pc
+ 0), (void *) (&cmdlenLarge
), 4);
6835 (void) memcpy((void *) (pc
+ 4), (void *) (&op
), 4);
6836 (void) memcpy((void *) (pc
+ 44), (void *) (&target
), 4);
6837 (void) memcpy((void *) (pc
+ 48), (void *) (&level
), 4);
6838 (void) memcpy((void *) (pc
+ 52), (void *) (&xoffset
), 4);
6839 (void) memcpy((void *) (pc
+ 56), (void *) (&yoffset
), 4);
6840 (void) memcpy((void *) (pc
+ 60), (void *) (&zoffset
), 4);
6841 (void) memcpy((void *) (pc
+ 64), (void *) (&woffset
), 4);
6842 (void) memcpy((void *) (pc
+ 68), (void *) (&width
), 4);
6843 (void) memcpy((void *) (pc
+ 72), (void *) (&height
), 4);
6844 (void) memcpy((void *) (pc
+ 76), (void *) (&depth
), 4);
6845 (void) memcpy((void *) (pc
+ 80), (void *) (&extent
), 4);
6846 (void) memcpy((void *) (pc
+ 84), (void *) (&format
), 4);
6847 (void) memcpy((void *) (pc
+ 88), (void *) (&type
), 4);
6848 (void) memcpy((void *) (pc
+ 92), zero
, 4);
6849 __glXSendLargeImage(gc
, compsize
, dim
, width
, height
, depth
,
6850 format
, type
, pixels
, pc
+ 96, pc
+ 8);
6855 #define X_GLrop_TexSubImage3D 4115
6857 __indirect_glTexSubImage3D(GLenum target
, GLint level
, GLint xoffset
,
6858 GLint yoffset
, GLint zoffset
, GLsizei width
,
6859 GLsizei height
, GLsizei depth
, GLenum format
,
6860 GLenum type
, const GLvoid
* pixels
)
6862 __glx_TexSubImage_3D4D(X_GLrop_TexSubImage3D
, 3, target
, level
, xoffset
,
6863 yoffset
, zoffset
, 1, width
, height
, depth
, 1,
6864 format
, type
, pixels
);
6867 #define X_GLrop_CopyTexSubImage3D 4123
6869 __indirect_glCopyTexSubImage3D(GLenum target
, GLint level
, GLint xoffset
,
6870 GLint yoffset
, GLint zoffset
, GLint x
, GLint y
,
6871 GLsizei width
, GLsizei height
)
6873 __GLXcontext
*const gc
= __glXGetCurrentContext();
6874 const GLuint cmdlen
= 40;
6875 emit_header(gc
->pc
, X_GLrop_CopyTexSubImage3D
, cmdlen
);
6876 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&target
), 4);
6877 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&level
), 4);
6878 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&xoffset
), 4);
6879 (void) memcpy((void *) (gc
->pc
+ 16), (void *) (&yoffset
), 4);
6880 (void) memcpy((void *) (gc
->pc
+ 20), (void *) (&zoffset
), 4);
6881 (void) memcpy((void *) (gc
->pc
+ 24), (void *) (&x
), 4);
6882 (void) memcpy((void *) (gc
->pc
+ 28), (void *) (&y
), 4);
6883 (void) memcpy((void *) (gc
->pc
+ 32), (void *) (&width
), 4);
6884 (void) memcpy((void *) (gc
->pc
+ 36), (void *) (&height
), 4);
6886 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
6887 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
6891 #define X_GLrop_ActiveTextureARB 197
6893 __indirect_glActiveTextureARB(GLenum texture
)
6895 __GLXcontext
*const gc
= __glXGetCurrentContext();
6896 const GLuint cmdlen
= 8;
6897 emit_header(gc
->pc
, X_GLrop_ActiveTextureARB
, cmdlen
);
6898 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&texture
), 4);
6900 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
6901 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
6905 #define X_GLrop_MultiTexCoord1dvARB 198
6907 __indirect_glMultiTexCoord1dARB(GLenum target
, GLdouble s
)
6909 __GLXcontext
*const gc
= __glXGetCurrentContext();
6910 const GLuint cmdlen
= 16;
6911 emit_header(gc
->pc
, X_GLrop_MultiTexCoord1dvARB
, cmdlen
);
6912 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&s
), 8);
6913 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&target
), 4);
6915 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
6916 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
6920 #define X_GLrop_MultiTexCoord1dvARB 198
6922 __indirect_glMultiTexCoord1dvARB(GLenum target
, const GLdouble
* v
)
6924 __GLXcontext
*const gc
= __glXGetCurrentContext();
6925 const GLuint cmdlen
= 16;
6926 emit_header(gc
->pc
, X_GLrop_MultiTexCoord1dvARB
, cmdlen
);
6927 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (v
), 8);
6928 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&target
), 4);
6930 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
6931 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
6935 #define X_GLrop_MultiTexCoord1fvARB 199
6937 __indirect_glMultiTexCoord1fARB(GLenum target
, GLfloat s
)
6939 __GLXcontext
*const gc
= __glXGetCurrentContext();
6940 const GLuint cmdlen
= 12;
6941 emit_header(gc
->pc
, X_GLrop_MultiTexCoord1fvARB
, cmdlen
);
6942 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&target
), 4);
6943 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&s
), 4);
6945 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
6946 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
6950 #define X_GLrop_MultiTexCoord1fvARB 199
6952 __indirect_glMultiTexCoord1fvARB(GLenum target
, const GLfloat
* v
)
6954 __GLXcontext
*const gc
= __glXGetCurrentContext();
6955 const GLuint cmdlen
= 12;
6956 emit_header(gc
->pc
, X_GLrop_MultiTexCoord1fvARB
, cmdlen
);
6957 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&target
), 4);
6958 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (v
), 4);
6960 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
6961 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
6965 #define X_GLrop_MultiTexCoord1ivARB 200
6967 __indirect_glMultiTexCoord1iARB(GLenum target
, GLint s
)
6969 __GLXcontext
*const gc
= __glXGetCurrentContext();
6970 const GLuint cmdlen
= 12;
6971 emit_header(gc
->pc
, X_GLrop_MultiTexCoord1ivARB
, cmdlen
);
6972 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&target
), 4);
6973 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&s
), 4);
6975 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
6976 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
6980 #define X_GLrop_MultiTexCoord1ivARB 200
6982 __indirect_glMultiTexCoord1ivARB(GLenum target
, const GLint
* v
)
6984 __GLXcontext
*const gc
= __glXGetCurrentContext();
6985 const GLuint cmdlen
= 12;
6986 emit_header(gc
->pc
, X_GLrop_MultiTexCoord1ivARB
, cmdlen
);
6987 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&target
), 4);
6988 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (v
), 4);
6990 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
6991 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
6995 #define X_GLrop_MultiTexCoord1svARB 201
6997 __indirect_glMultiTexCoord1sARB(GLenum target
, GLshort s
)
6999 __GLXcontext
*const gc
= __glXGetCurrentContext();
7000 const GLuint cmdlen
= 12;
7001 emit_header(gc
->pc
, X_GLrop_MultiTexCoord1svARB
, cmdlen
);
7002 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&target
), 4);
7003 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&s
), 2);
7005 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
7006 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
7010 #define X_GLrop_MultiTexCoord1svARB 201
7012 __indirect_glMultiTexCoord1svARB(GLenum target
, const GLshort
* v
)
7014 __GLXcontext
*const gc
= __glXGetCurrentContext();
7015 const GLuint cmdlen
= 12;
7016 emit_header(gc
->pc
, X_GLrop_MultiTexCoord1svARB
, cmdlen
);
7017 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&target
), 4);
7018 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (v
), 2);
7020 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
7021 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
7025 #define X_GLrop_MultiTexCoord2dvARB 202
7027 __indirect_glMultiTexCoord2dARB(GLenum target
, GLdouble s
, GLdouble t
)
7029 __GLXcontext
*const gc
= __glXGetCurrentContext();
7030 const GLuint cmdlen
= 24;
7031 emit_header(gc
->pc
, X_GLrop_MultiTexCoord2dvARB
, cmdlen
);
7032 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&s
), 8);
7033 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&t
), 8);
7034 (void) memcpy((void *) (gc
->pc
+ 20), (void *) (&target
), 4);
7036 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
7037 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
7041 #define X_GLrop_MultiTexCoord2dvARB 202
7043 __indirect_glMultiTexCoord2dvARB(GLenum target
, const GLdouble
* v
)
7045 __GLXcontext
*const gc
= __glXGetCurrentContext();
7046 const GLuint cmdlen
= 24;
7047 emit_header(gc
->pc
, X_GLrop_MultiTexCoord2dvARB
, cmdlen
);
7048 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (v
), 16);
7049 (void) memcpy((void *) (gc
->pc
+ 20), (void *) (&target
), 4);
7051 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
7052 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
7056 #define X_GLrop_MultiTexCoord2fvARB 203
7058 __indirect_glMultiTexCoord2fARB(GLenum target
, GLfloat s
, GLfloat t
)
7060 __GLXcontext
*const gc
= __glXGetCurrentContext();
7061 const GLuint cmdlen
= 16;
7062 emit_header(gc
->pc
, X_GLrop_MultiTexCoord2fvARB
, cmdlen
);
7063 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&target
), 4);
7064 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&s
), 4);
7065 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&t
), 4);
7067 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
7068 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
7072 #define X_GLrop_MultiTexCoord2fvARB 203
7074 __indirect_glMultiTexCoord2fvARB(GLenum target
, const GLfloat
* v
)
7076 __GLXcontext
*const gc
= __glXGetCurrentContext();
7077 const GLuint cmdlen
= 16;
7078 emit_header(gc
->pc
, X_GLrop_MultiTexCoord2fvARB
, cmdlen
);
7079 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&target
), 4);
7080 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (v
), 8);
7082 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
7083 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
7087 #define X_GLrop_MultiTexCoord2ivARB 204
7089 __indirect_glMultiTexCoord2iARB(GLenum target
, GLint s
, GLint t
)
7091 __GLXcontext
*const gc
= __glXGetCurrentContext();
7092 const GLuint cmdlen
= 16;
7093 emit_header(gc
->pc
, X_GLrop_MultiTexCoord2ivARB
, cmdlen
);
7094 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&target
), 4);
7095 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&s
), 4);
7096 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&t
), 4);
7098 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
7099 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
7103 #define X_GLrop_MultiTexCoord2ivARB 204
7105 __indirect_glMultiTexCoord2ivARB(GLenum target
, const GLint
* v
)
7107 __GLXcontext
*const gc
= __glXGetCurrentContext();
7108 const GLuint cmdlen
= 16;
7109 emit_header(gc
->pc
, X_GLrop_MultiTexCoord2ivARB
, cmdlen
);
7110 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&target
), 4);
7111 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (v
), 8);
7113 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
7114 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
7118 #define X_GLrop_MultiTexCoord2svARB 205
7120 __indirect_glMultiTexCoord2sARB(GLenum target
, GLshort s
, GLshort t
)
7122 __GLXcontext
*const gc
= __glXGetCurrentContext();
7123 const GLuint cmdlen
= 12;
7124 emit_header(gc
->pc
, X_GLrop_MultiTexCoord2svARB
, cmdlen
);
7125 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&target
), 4);
7126 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&s
), 2);
7127 (void) memcpy((void *) (gc
->pc
+ 10), (void *) (&t
), 2);
7129 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
7130 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
7134 #define X_GLrop_MultiTexCoord2svARB 205
7136 __indirect_glMultiTexCoord2svARB(GLenum target
, const GLshort
* v
)
7138 __GLXcontext
*const gc
= __glXGetCurrentContext();
7139 const GLuint cmdlen
= 12;
7140 emit_header(gc
->pc
, X_GLrop_MultiTexCoord2svARB
, cmdlen
);
7141 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&target
), 4);
7142 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (v
), 4);
7144 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
7145 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
7149 #define X_GLrop_MultiTexCoord3dvARB 206
7151 __indirect_glMultiTexCoord3dARB(GLenum target
, GLdouble s
, GLdouble t
,
7154 __GLXcontext
*const gc
= __glXGetCurrentContext();
7155 const GLuint cmdlen
= 32;
7156 emit_header(gc
->pc
, X_GLrop_MultiTexCoord3dvARB
, cmdlen
);
7157 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&s
), 8);
7158 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&t
), 8);
7159 (void) memcpy((void *) (gc
->pc
+ 20), (void *) (&r
), 8);
7160 (void) memcpy((void *) (gc
->pc
+ 28), (void *) (&target
), 4);
7162 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
7163 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
7167 #define X_GLrop_MultiTexCoord3dvARB 206
7169 __indirect_glMultiTexCoord3dvARB(GLenum target
, const GLdouble
* v
)
7171 __GLXcontext
*const gc
= __glXGetCurrentContext();
7172 const GLuint cmdlen
= 32;
7173 emit_header(gc
->pc
, X_GLrop_MultiTexCoord3dvARB
, cmdlen
);
7174 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (v
), 24);
7175 (void) memcpy((void *) (gc
->pc
+ 28), (void *) (&target
), 4);
7177 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
7178 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
7182 #define X_GLrop_MultiTexCoord3fvARB 207
7184 __indirect_glMultiTexCoord3fARB(GLenum target
, GLfloat s
, GLfloat t
,
7187 __GLXcontext
*const gc
= __glXGetCurrentContext();
7188 const GLuint cmdlen
= 20;
7189 emit_header(gc
->pc
, X_GLrop_MultiTexCoord3fvARB
, cmdlen
);
7190 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&target
), 4);
7191 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&s
), 4);
7192 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&t
), 4);
7193 (void) memcpy((void *) (gc
->pc
+ 16), (void *) (&r
), 4);
7195 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
7196 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
7200 #define X_GLrop_MultiTexCoord3fvARB 207
7202 __indirect_glMultiTexCoord3fvARB(GLenum target
, const GLfloat
* v
)
7204 __GLXcontext
*const gc
= __glXGetCurrentContext();
7205 const GLuint cmdlen
= 20;
7206 emit_header(gc
->pc
, X_GLrop_MultiTexCoord3fvARB
, cmdlen
);
7207 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&target
), 4);
7208 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (v
), 12);
7210 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
7211 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
7215 #define X_GLrop_MultiTexCoord3ivARB 208
7217 __indirect_glMultiTexCoord3iARB(GLenum target
, GLint s
, GLint t
, GLint r
)
7219 __GLXcontext
*const gc
= __glXGetCurrentContext();
7220 const GLuint cmdlen
= 20;
7221 emit_header(gc
->pc
, X_GLrop_MultiTexCoord3ivARB
, cmdlen
);
7222 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&target
), 4);
7223 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&s
), 4);
7224 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&t
), 4);
7225 (void) memcpy((void *) (gc
->pc
+ 16), (void *) (&r
), 4);
7227 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
7228 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
7232 #define X_GLrop_MultiTexCoord3ivARB 208
7234 __indirect_glMultiTexCoord3ivARB(GLenum target
, const GLint
* v
)
7236 __GLXcontext
*const gc
= __glXGetCurrentContext();
7237 const GLuint cmdlen
= 20;
7238 emit_header(gc
->pc
, X_GLrop_MultiTexCoord3ivARB
, cmdlen
);
7239 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&target
), 4);
7240 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (v
), 12);
7242 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
7243 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
7247 #define X_GLrop_MultiTexCoord3svARB 209
7249 __indirect_glMultiTexCoord3sARB(GLenum target
, GLshort s
, GLshort t
,
7252 __GLXcontext
*const gc
= __glXGetCurrentContext();
7253 const GLuint cmdlen
= 16;
7254 emit_header(gc
->pc
, X_GLrop_MultiTexCoord3svARB
, cmdlen
);
7255 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&target
), 4);
7256 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&s
), 2);
7257 (void) memcpy((void *) (gc
->pc
+ 10), (void *) (&t
), 2);
7258 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&r
), 2);
7260 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
7261 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
7265 #define X_GLrop_MultiTexCoord3svARB 209
7267 __indirect_glMultiTexCoord3svARB(GLenum target
, const GLshort
* v
)
7269 __GLXcontext
*const gc
= __glXGetCurrentContext();
7270 const GLuint cmdlen
= 16;
7271 emit_header(gc
->pc
, X_GLrop_MultiTexCoord3svARB
, cmdlen
);
7272 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&target
), 4);
7273 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (v
), 6);
7275 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
7276 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
7280 #define X_GLrop_MultiTexCoord4dvARB 210
7282 __indirect_glMultiTexCoord4dARB(GLenum target
, GLdouble s
, GLdouble t
,
7283 GLdouble r
, GLdouble q
)
7285 __GLXcontext
*const gc
= __glXGetCurrentContext();
7286 const GLuint cmdlen
= 40;
7287 emit_header(gc
->pc
, X_GLrop_MultiTexCoord4dvARB
, cmdlen
);
7288 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&s
), 8);
7289 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&t
), 8);
7290 (void) memcpy((void *) (gc
->pc
+ 20), (void *) (&r
), 8);
7291 (void) memcpy((void *) (gc
->pc
+ 28), (void *) (&q
), 8);
7292 (void) memcpy((void *) (gc
->pc
+ 36), (void *) (&target
), 4);
7294 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
7295 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
7299 #define X_GLrop_MultiTexCoord4dvARB 210
7301 __indirect_glMultiTexCoord4dvARB(GLenum target
, const GLdouble
* v
)
7303 __GLXcontext
*const gc
= __glXGetCurrentContext();
7304 const GLuint cmdlen
= 40;
7305 emit_header(gc
->pc
, X_GLrop_MultiTexCoord4dvARB
, cmdlen
);
7306 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (v
), 32);
7307 (void) memcpy((void *) (gc
->pc
+ 36), (void *) (&target
), 4);
7309 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
7310 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
7314 #define X_GLrop_MultiTexCoord4fvARB 211
7316 __indirect_glMultiTexCoord4fARB(GLenum target
, GLfloat s
, GLfloat t
,
7317 GLfloat r
, GLfloat q
)
7319 __GLXcontext
*const gc
= __glXGetCurrentContext();
7320 const GLuint cmdlen
= 24;
7321 emit_header(gc
->pc
, X_GLrop_MultiTexCoord4fvARB
, cmdlen
);
7322 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&target
), 4);
7323 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&s
), 4);
7324 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&t
), 4);
7325 (void) memcpy((void *) (gc
->pc
+ 16), (void *) (&r
), 4);
7326 (void) memcpy((void *) (gc
->pc
+ 20), (void *) (&q
), 4);
7328 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
7329 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
7333 #define X_GLrop_MultiTexCoord4fvARB 211
7335 __indirect_glMultiTexCoord4fvARB(GLenum target
, const GLfloat
* v
)
7337 __GLXcontext
*const gc
= __glXGetCurrentContext();
7338 const GLuint cmdlen
= 24;
7339 emit_header(gc
->pc
, X_GLrop_MultiTexCoord4fvARB
, cmdlen
);
7340 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&target
), 4);
7341 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (v
), 16);
7343 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
7344 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
7348 #define X_GLrop_MultiTexCoord4ivARB 212
7350 __indirect_glMultiTexCoord4iARB(GLenum target
, GLint s
, GLint t
, GLint r
,
7353 __GLXcontext
*const gc
= __glXGetCurrentContext();
7354 const GLuint cmdlen
= 24;
7355 emit_header(gc
->pc
, X_GLrop_MultiTexCoord4ivARB
, cmdlen
);
7356 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&target
), 4);
7357 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&s
), 4);
7358 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&t
), 4);
7359 (void) memcpy((void *) (gc
->pc
+ 16), (void *) (&r
), 4);
7360 (void) memcpy((void *) (gc
->pc
+ 20), (void *) (&q
), 4);
7362 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
7363 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
7367 #define X_GLrop_MultiTexCoord4ivARB 212
7369 __indirect_glMultiTexCoord4ivARB(GLenum target
, const GLint
* v
)
7371 __GLXcontext
*const gc
= __glXGetCurrentContext();
7372 const GLuint cmdlen
= 24;
7373 emit_header(gc
->pc
, X_GLrop_MultiTexCoord4ivARB
, cmdlen
);
7374 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&target
), 4);
7375 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (v
), 16);
7377 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
7378 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
7382 #define X_GLrop_MultiTexCoord4svARB 213
7384 __indirect_glMultiTexCoord4sARB(GLenum target
, GLshort s
, GLshort t
,
7385 GLshort r
, GLshort q
)
7387 __GLXcontext
*const gc
= __glXGetCurrentContext();
7388 const GLuint cmdlen
= 16;
7389 emit_header(gc
->pc
, X_GLrop_MultiTexCoord4svARB
, cmdlen
);
7390 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&target
), 4);
7391 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&s
), 2);
7392 (void) memcpy((void *) (gc
->pc
+ 10), (void *) (&t
), 2);
7393 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&r
), 2);
7394 (void) memcpy((void *) (gc
->pc
+ 14), (void *) (&q
), 2);
7396 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
7397 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
7401 #define X_GLrop_MultiTexCoord4svARB 213
7403 __indirect_glMultiTexCoord4svARB(GLenum target
, const GLshort
* v
)
7405 __GLXcontext
*const gc
= __glXGetCurrentContext();
7406 const GLuint cmdlen
= 16;
7407 emit_header(gc
->pc
, X_GLrop_MultiTexCoord4svARB
, cmdlen
);
7408 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&target
), 4);
7409 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (v
), 8);
7411 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
7412 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
7416 #define X_GLrop_SampleCoverageARB 229
7418 __indirect_glSampleCoverageARB(GLclampf value
, GLboolean invert
)
7420 __GLXcontext
*const gc
= __glXGetCurrentContext();
7421 const GLuint cmdlen
= 12;
7422 emit_header(gc
->pc
, X_GLrop_SampleCoverageARB
, cmdlen
);
7423 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&value
), 4);
7424 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&invert
), 1);
7426 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
7427 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
7431 #define X_GLvop_GetProgramStringARB 1308
7433 __indirect_glGetProgramStringARB(GLenum target
, GLenum pname
, GLvoid
* string
)
7435 __GLXcontext
*const gc
= __glXGetCurrentContext();
7436 Display
*const dpy
= gc
->currentDpy
;
7437 const GLuint cmdlen
= 8;
7438 if (__builtin_expect(dpy
!= NULL
, 1)) {
7440 __glXSetupVendorRequest(gc
, X_GLXVendorPrivateWithReply
,
7441 X_GLvop_GetProgramStringARB
, cmdlen
);
7442 (void) memcpy((void *) (pc
+ 0), (void *) (&target
), 4);
7443 (void) memcpy((void *) (pc
+ 4), (void *) (&pname
), 4);
7444 (void) __glXReadReply(dpy
, 1, string
, GL_TRUE
);
7451 #define X_GLvop_GetProgramivARB 1307
7453 __indirect_glGetProgramivARB(GLenum target
, GLenum pname
, GLint
* params
)
7455 __GLXcontext
*const gc
= __glXGetCurrentContext();
7456 Display
*const dpy
= gc
->currentDpy
;
7457 const GLuint cmdlen
= 8;
7458 if (__builtin_expect(dpy
!= NULL
, 1)) {
7460 __glXSetupVendorRequest(gc
, X_GLXVendorPrivateWithReply
,
7461 X_GLvop_GetProgramivARB
, cmdlen
);
7462 (void) memcpy((void *) (pc
+ 0), (void *) (&target
), 4);
7463 (void) memcpy((void *) (pc
+ 4), (void *) (&pname
), 4);
7464 (void) __glXReadReply(dpy
, 4, params
, GL_FALSE
);
7471 #define X_GLrop_ProgramEnvParameter4dvARB 4185
7473 __indirect_glProgramEnvParameter4dARB(GLenum target
, GLuint index
, GLdouble x
,
7474 GLdouble y
, GLdouble z
, GLdouble w
)
7476 __GLXcontext
*const gc
= __glXGetCurrentContext();
7477 const GLuint cmdlen
= 44;
7478 emit_header(gc
->pc
, X_GLrop_ProgramEnvParameter4dvARB
, cmdlen
);
7479 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&target
), 4);
7480 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&index
), 4);
7481 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&x
), 8);
7482 (void) memcpy((void *) (gc
->pc
+ 20), (void *) (&y
), 8);
7483 (void) memcpy((void *) (gc
->pc
+ 28), (void *) (&z
), 8);
7484 (void) memcpy((void *) (gc
->pc
+ 36), (void *) (&w
), 8);
7486 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
7487 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
7491 #define X_GLrop_ProgramEnvParameter4dvARB 4185
7493 __indirect_glProgramEnvParameter4dvARB(GLenum target
, GLuint index
,
7494 const GLdouble
* params
)
7496 __GLXcontext
*const gc
= __glXGetCurrentContext();
7497 const GLuint cmdlen
= 44;
7498 emit_header(gc
->pc
, X_GLrop_ProgramEnvParameter4dvARB
, cmdlen
);
7499 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&target
), 4);
7500 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&index
), 4);
7501 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (params
), 32);
7503 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
7504 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
7508 #define X_GLrop_ProgramEnvParameter4fvARB 4184
7510 __indirect_glProgramEnvParameter4fARB(GLenum target
, GLuint index
, GLfloat x
,
7511 GLfloat y
, GLfloat z
, GLfloat w
)
7513 __GLXcontext
*const gc
= __glXGetCurrentContext();
7514 const GLuint cmdlen
= 28;
7515 emit_header(gc
->pc
, X_GLrop_ProgramEnvParameter4fvARB
, cmdlen
);
7516 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&target
), 4);
7517 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&index
), 4);
7518 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&x
), 4);
7519 (void) memcpy((void *) (gc
->pc
+ 16), (void *) (&y
), 4);
7520 (void) memcpy((void *) (gc
->pc
+ 20), (void *) (&z
), 4);
7521 (void) memcpy((void *) (gc
->pc
+ 24), (void *) (&w
), 4);
7523 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
7524 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
7528 #define X_GLrop_ProgramEnvParameter4fvARB 4184
7530 __indirect_glProgramEnvParameter4fvARB(GLenum target
, GLuint index
,
7531 const GLfloat
* params
)
7533 __GLXcontext
*const gc
= __glXGetCurrentContext();
7534 const GLuint cmdlen
= 28;
7535 emit_header(gc
->pc
, X_GLrop_ProgramEnvParameter4fvARB
, cmdlen
);
7536 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&target
), 4);
7537 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&index
), 4);
7538 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (params
), 16);
7540 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
7541 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
7545 #define X_GLrop_ProgramLocalParameter4dvARB 4216
7547 __indirect_glProgramLocalParameter4dARB(GLenum target
, GLuint index
,
7548 GLdouble x
, GLdouble y
, GLdouble z
,
7551 __GLXcontext
*const gc
= __glXGetCurrentContext();
7552 const GLuint cmdlen
= 44;
7553 emit_header(gc
->pc
, X_GLrop_ProgramLocalParameter4dvARB
, cmdlen
);
7554 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&target
), 4);
7555 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&index
), 4);
7556 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&x
), 8);
7557 (void) memcpy((void *) (gc
->pc
+ 20), (void *) (&y
), 8);
7558 (void) memcpy((void *) (gc
->pc
+ 28), (void *) (&z
), 8);
7559 (void) memcpy((void *) (gc
->pc
+ 36), (void *) (&w
), 8);
7561 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
7562 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
7566 #define X_GLrop_ProgramLocalParameter4dvARB 4216
7568 __indirect_glProgramLocalParameter4dvARB(GLenum target
, GLuint index
,
7569 const GLdouble
* params
)
7571 __GLXcontext
*const gc
= __glXGetCurrentContext();
7572 const GLuint cmdlen
= 44;
7573 emit_header(gc
->pc
, X_GLrop_ProgramLocalParameter4dvARB
, cmdlen
);
7574 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&target
), 4);
7575 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&index
), 4);
7576 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (params
), 32);
7578 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
7579 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
7583 #define X_GLrop_ProgramLocalParameter4fvARB 4215
7585 __indirect_glProgramLocalParameter4fARB(GLenum target
, GLuint index
,
7586 GLfloat x
, GLfloat y
, GLfloat z
,
7589 __GLXcontext
*const gc
= __glXGetCurrentContext();
7590 const GLuint cmdlen
= 28;
7591 emit_header(gc
->pc
, X_GLrop_ProgramLocalParameter4fvARB
, cmdlen
);
7592 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&target
), 4);
7593 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&index
), 4);
7594 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&x
), 4);
7595 (void) memcpy((void *) (gc
->pc
+ 16), (void *) (&y
), 4);
7596 (void) memcpy((void *) (gc
->pc
+ 20), (void *) (&z
), 4);
7597 (void) memcpy((void *) (gc
->pc
+ 24), (void *) (&w
), 4);
7599 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
7600 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
7604 #define X_GLrop_ProgramLocalParameter4fvARB 4215
7606 __indirect_glProgramLocalParameter4fvARB(GLenum target
, GLuint index
,
7607 const GLfloat
* params
)
7609 __GLXcontext
*const gc
= __glXGetCurrentContext();
7610 const GLuint cmdlen
= 28;
7611 emit_header(gc
->pc
, X_GLrop_ProgramLocalParameter4fvARB
, cmdlen
);
7612 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&target
), 4);
7613 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&index
), 4);
7614 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (params
), 16);
7616 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
7617 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
7621 #define X_GLrop_ProgramStringARB 4217
7623 __indirect_glProgramStringARB(GLenum target
, GLenum format
, GLsizei len
,
7624 const GLvoid
* string
)
7626 __GLXcontext
*const gc
= __glXGetCurrentContext();
7627 const GLuint cmdlen
= 16 + __GLX_PAD(len
);
7628 if (__builtin_expect((len
>= 0) && (gc
->currentDpy
!= NULL
), 1)) {
7629 if (cmdlen
<= gc
->maxSmallRenderCommandSize
) {
7630 if ((gc
->pc
+ cmdlen
) > gc
->bufEnd
) {
7631 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
7633 emit_header(gc
->pc
, X_GLrop_ProgramStringARB
, cmdlen
);
7634 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&target
), 4);
7635 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&format
), 4);
7636 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&len
), 4);
7637 (void) memcpy((void *) (gc
->pc
+ 16), (void *) (string
), len
);
7639 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
7640 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
7643 const GLint op
= X_GLrop_ProgramStringARB
;
7644 const GLuint cmdlenLarge
= cmdlen
+ 4;
7645 GLubyte
*const pc
= __glXFlushRenderBuffer(gc
, gc
->pc
);
7646 (void) memcpy((void *) (pc
+ 0), (void *) (&cmdlenLarge
), 4);
7647 (void) memcpy((void *) (pc
+ 4), (void *) (&op
), 4);
7648 (void) memcpy((void *) (pc
+ 8), (void *) (&target
), 4);
7649 (void) memcpy((void *) (pc
+ 12), (void *) (&format
), 4);
7650 (void) memcpy((void *) (pc
+ 16), (void *) (&len
), 4);
7651 __glXSendLargeCommand(gc
, pc
, 20, string
, len
);
7656 #define X_GLrop_VertexAttrib1dvARB 4197
7658 __indirect_glVertexAttrib1dARB(GLuint index
, GLdouble x
)
7660 __GLXcontext
*const gc
= __glXGetCurrentContext();
7661 const GLuint cmdlen
= 16;
7662 emit_header(gc
->pc
, X_GLrop_VertexAttrib1dvARB
, cmdlen
);
7663 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&index
), 4);
7664 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&x
), 8);
7666 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
7667 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
7671 #define X_GLrop_VertexAttrib1dvARB 4197
7673 __indirect_glVertexAttrib1dvARB(GLuint index
, const GLdouble
* v
)
7675 __GLXcontext
*const gc
= __glXGetCurrentContext();
7676 const GLuint cmdlen
= 16;
7677 emit_header(gc
->pc
, X_GLrop_VertexAttrib1dvARB
, cmdlen
);
7678 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&index
), 4);
7679 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (v
), 8);
7681 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
7682 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
7686 #define X_GLrop_VertexAttrib1fvARB 4193
7688 __indirect_glVertexAttrib1fARB(GLuint index
, GLfloat x
)
7690 __GLXcontext
*const gc
= __glXGetCurrentContext();
7691 const GLuint cmdlen
= 12;
7692 emit_header(gc
->pc
, X_GLrop_VertexAttrib1fvARB
, cmdlen
);
7693 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&index
), 4);
7694 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&x
), 4);
7696 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
7697 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
7701 #define X_GLrop_VertexAttrib1fvARB 4193
7703 __indirect_glVertexAttrib1fvARB(GLuint index
, const GLfloat
* v
)
7705 __GLXcontext
*const gc
= __glXGetCurrentContext();
7706 const GLuint cmdlen
= 12;
7707 emit_header(gc
->pc
, X_GLrop_VertexAttrib1fvARB
, cmdlen
);
7708 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&index
), 4);
7709 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (v
), 4);
7711 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
7712 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
7716 #define X_GLrop_VertexAttrib1svARB 4189
7718 __indirect_glVertexAttrib1sARB(GLuint index
, GLshort x
)
7720 __GLXcontext
*const gc
= __glXGetCurrentContext();
7721 const GLuint cmdlen
= 12;
7722 emit_header(gc
->pc
, X_GLrop_VertexAttrib1svARB
, cmdlen
);
7723 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&index
), 4);
7724 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&x
), 2);
7726 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
7727 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
7731 #define X_GLrop_VertexAttrib1svARB 4189
7733 __indirect_glVertexAttrib1svARB(GLuint index
, const GLshort
* v
)
7735 __GLXcontext
*const gc
= __glXGetCurrentContext();
7736 const GLuint cmdlen
= 12;
7737 emit_header(gc
->pc
, X_GLrop_VertexAttrib1svARB
, cmdlen
);
7738 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&index
), 4);
7739 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (v
), 2);
7741 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
7742 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
7746 #define X_GLrop_VertexAttrib2dvARB 4198
7748 __indirect_glVertexAttrib2dARB(GLuint index
, GLdouble x
, GLdouble y
)
7750 __GLXcontext
*const gc
= __glXGetCurrentContext();
7751 const GLuint cmdlen
= 24;
7752 emit_header(gc
->pc
, X_GLrop_VertexAttrib2dvARB
, cmdlen
);
7753 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&index
), 4);
7754 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&x
), 8);
7755 (void) memcpy((void *) (gc
->pc
+ 16), (void *) (&y
), 8);
7757 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
7758 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
7762 #define X_GLrop_VertexAttrib2dvARB 4198
7764 __indirect_glVertexAttrib2dvARB(GLuint index
, const GLdouble
* v
)
7766 __GLXcontext
*const gc
= __glXGetCurrentContext();
7767 const GLuint cmdlen
= 24;
7768 emit_header(gc
->pc
, X_GLrop_VertexAttrib2dvARB
, cmdlen
);
7769 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&index
), 4);
7770 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (v
), 16);
7772 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
7773 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
7777 #define X_GLrop_VertexAttrib2fvARB 4194
7779 __indirect_glVertexAttrib2fARB(GLuint index
, GLfloat x
, GLfloat y
)
7781 __GLXcontext
*const gc
= __glXGetCurrentContext();
7782 const GLuint cmdlen
= 16;
7783 emit_header(gc
->pc
, X_GLrop_VertexAttrib2fvARB
, cmdlen
);
7784 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&index
), 4);
7785 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&x
), 4);
7786 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&y
), 4);
7788 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
7789 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
7793 #define X_GLrop_VertexAttrib2fvARB 4194
7795 __indirect_glVertexAttrib2fvARB(GLuint index
, const GLfloat
* v
)
7797 __GLXcontext
*const gc
= __glXGetCurrentContext();
7798 const GLuint cmdlen
= 16;
7799 emit_header(gc
->pc
, X_GLrop_VertexAttrib2fvARB
, cmdlen
);
7800 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&index
), 4);
7801 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (v
), 8);
7803 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
7804 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
7808 #define X_GLrop_VertexAttrib2svARB 4190
7810 __indirect_glVertexAttrib2sARB(GLuint index
, GLshort x
, GLshort y
)
7812 __GLXcontext
*const gc
= __glXGetCurrentContext();
7813 const GLuint cmdlen
= 12;
7814 emit_header(gc
->pc
, X_GLrop_VertexAttrib2svARB
, cmdlen
);
7815 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&index
), 4);
7816 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&x
), 2);
7817 (void) memcpy((void *) (gc
->pc
+ 10), (void *) (&y
), 2);
7819 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
7820 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
7824 #define X_GLrop_VertexAttrib2svARB 4190
7826 __indirect_glVertexAttrib2svARB(GLuint index
, const GLshort
* v
)
7828 __GLXcontext
*const gc
= __glXGetCurrentContext();
7829 const GLuint cmdlen
= 12;
7830 emit_header(gc
->pc
, X_GLrop_VertexAttrib2svARB
, cmdlen
);
7831 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&index
), 4);
7832 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (v
), 4);
7834 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
7835 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
7839 #define X_GLrop_VertexAttrib3dvARB 4199
7841 __indirect_glVertexAttrib3dARB(GLuint index
, GLdouble x
, GLdouble y
,
7844 __GLXcontext
*const gc
= __glXGetCurrentContext();
7845 const GLuint cmdlen
= 32;
7846 emit_header(gc
->pc
, X_GLrop_VertexAttrib3dvARB
, cmdlen
);
7847 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&index
), 4);
7848 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&x
), 8);
7849 (void) memcpy((void *) (gc
->pc
+ 16), (void *) (&y
), 8);
7850 (void) memcpy((void *) (gc
->pc
+ 24), (void *) (&z
), 8);
7852 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
7853 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
7857 #define X_GLrop_VertexAttrib3dvARB 4199
7859 __indirect_glVertexAttrib3dvARB(GLuint index
, const GLdouble
* v
)
7861 __GLXcontext
*const gc
= __glXGetCurrentContext();
7862 const GLuint cmdlen
= 32;
7863 emit_header(gc
->pc
, X_GLrop_VertexAttrib3dvARB
, cmdlen
);
7864 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&index
), 4);
7865 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (v
), 24);
7867 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
7868 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
7872 #define X_GLrop_VertexAttrib3fvARB 4195
7874 __indirect_glVertexAttrib3fARB(GLuint index
, GLfloat x
, GLfloat y
, GLfloat z
)
7876 __GLXcontext
*const gc
= __glXGetCurrentContext();
7877 const GLuint cmdlen
= 20;
7878 emit_header(gc
->pc
, X_GLrop_VertexAttrib3fvARB
, cmdlen
);
7879 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&index
), 4);
7880 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&x
), 4);
7881 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&y
), 4);
7882 (void) memcpy((void *) (gc
->pc
+ 16), (void *) (&z
), 4);
7884 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
7885 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
7889 #define X_GLrop_VertexAttrib3fvARB 4195
7891 __indirect_glVertexAttrib3fvARB(GLuint index
, const GLfloat
* v
)
7893 __GLXcontext
*const gc
= __glXGetCurrentContext();
7894 const GLuint cmdlen
= 20;
7895 emit_header(gc
->pc
, X_GLrop_VertexAttrib3fvARB
, cmdlen
);
7896 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&index
), 4);
7897 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (v
), 12);
7899 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
7900 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
7904 #define X_GLrop_VertexAttrib3svARB 4191
7906 __indirect_glVertexAttrib3sARB(GLuint index
, GLshort x
, GLshort y
, GLshort z
)
7908 __GLXcontext
*const gc
= __glXGetCurrentContext();
7909 const GLuint cmdlen
= 16;
7910 emit_header(gc
->pc
, X_GLrop_VertexAttrib3svARB
, cmdlen
);
7911 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&index
), 4);
7912 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&x
), 2);
7913 (void) memcpy((void *) (gc
->pc
+ 10), (void *) (&y
), 2);
7914 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&z
), 2);
7916 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
7917 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
7921 #define X_GLrop_VertexAttrib3svARB 4191
7923 __indirect_glVertexAttrib3svARB(GLuint index
, const GLshort
* v
)
7925 __GLXcontext
*const gc
= __glXGetCurrentContext();
7926 const GLuint cmdlen
= 16;
7927 emit_header(gc
->pc
, X_GLrop_VertexAttrib3svARB
, cmdlen
);
7928 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&index
), 4);
7929 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (v
), 6);
7931 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
7932 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
7936 #define X_GLrop_VertexAttrib4NbvARB 4235
7938 __indirect_glVertexAttrib4NbvARB(GLuint index
, const GLbyte
* v
)
7940 __GLXcontext
*const gc
= __glXGetCurrentContext();
7941 const GLuint cmdlen
= 12;
7942 emit_header(gc
->pc
, X_GLrop_VertexAttrib4NbvARB
, cmdlen
);
7943 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&index
), 4);
7944 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (v
), 4);
7946 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
7947 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
7951 #define X_GLrop_VertexAttrib4NivARB 4237
7953 __indirect_glVertexAttrib4NivARB(GLuint index
, const GLint
* v
)
7955 __GLXcontext
*const gc
= __glXGetCurrentContext();
7956 const GLuint cmdlen
= 24;
7957 emit_header(gc
->pc
, X_GLrop_VertexAttrib4NivARB
, cmdlen
);
7958 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&index
), 4);
7959 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (v
), 16);
7961 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
7962 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
7966 #define X_GLrop_VertexAttrib4NsvARB 4236
7968 __indirect_glVertexAttrib4NsvARB(GLuint index
, const GLshort
* v
)
7970 __GLXcontext
*const gc
= __glXGetCurrentContext();
7971 const GLuint cmdlen
= 16;
7972 emit_header(gc
->pc
, X_GLrop_VertexAttrib4NsvARB
, cmdlen
);
7973 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&index
), 4);
7974 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (v
), 8);
7976 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
7977 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
7981 #define X_GLrop_VertexAttrib4NubvARB 4201
7983 __indirect_glVertexAttrib4NubARB(GLuint index
, GLubyte x
, GLubyte y
,
7984 GLubyte z
, GLubyte w
)
7986 __GLXcontext
*const gc
= __glXGetCurrentContext();
7987 const GLuint cmdlen
= 12;
7988 emit_header(gc
->pc
, X_GLrop_VertexAttrib4NubvARB
, cmdlen
);
7989 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&index
), 4);
7990 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&x
), 1);
7991 (void) memcpy((void *) (gc
->pc
+ 9), (void *) (&y
), 1);
7992 (void) memcpy((void *) (gc
->pc
+ 10), (void *) (&z
), 1);
7993 (void) memcpy((void *) (gc
->pc
+ 11), (void *) (&w
), 1);
7995 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
7996 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
8000 #define X_GLrop_VertexAttrib4NubvARB 4201
8002 __indirect_glVertexAttrib4NubvARB(GLuint index
, const GLubyte
* v
)
8004 __GLXcontext
*const gc
= __glXGetCurrentContext();
8005 const GLuint cmdlen
= 12;
8006 emit_header(gc
->pc
, X_GLrop_VertexAttrib4NubvARB
, cmdlen
);
8007 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&index
), 4);
8008 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (v
), 4);
8010 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
8011 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
8015 #define X_GLrop_VertexAttrib4NuivARB 4239
8017 __indirect_glVertexAttrib4NuivARB(GLuint index
, const GLuint
* v
)
8019 __GLXcontext
*const gc
= __glXGetCurrentContext();
8020 const GLuint cmdlen
= 24;
8021 emit_header(gc
->pc
, X_GLrop_VertexAttrib4NuivARB
, cmdlen
);
8022 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&index
), 4);
8023 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (v
), 16);
8025 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
8026 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
8030 #define X_GLrop_VertexAttrib4NusvARB 4238
8032 __indirect_glVertexAttrib4NusvARB(GLuint index
, const GLushort
* v
)
8034 __GLXcontext
*const gc
= __glXGetCurrentContext();
8035 const GLuint cmdlen
= 16;
8036 emit_header(gc
->pc
, X_GLrop_VertexAttrib4NusvARB
, cmdlen
);
8037 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&index
), 4);
8038 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (v
), 8);
8040 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
8041 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
8045 #define X_GLrop_VertexAttrib4bvARB 4230
8047 __indirect_glVertexAttrib4bvARB(GLuint index
, const GLbyte
* v
)
8049 __GLXcontext
*const gc
= __glXGetCurrentContext();
8050 const GLuint cmdlen
= 12;
8051 emit_header(gc
->pc
, X_GLrop_VertexAttrib4bvARB
, cmdlen
);
8052 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&index
), 4);
8053 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (v
), 4);
8055 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
8056 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
8060 #define X_GLrop_VertexAttrib4dvARB 4200
8062 __indirect_glVertexAttrib4dARB(GLuint index
, GLdouble x
, GLdouble y
,
8063 GLdouble z
, GLdouble w
)
8065 __GLXcontext
*const gc
= __glXGetCurrentContext();
8066 const GLuint cmdlen
= 40;
8067 emit_header(gc
->pc
, X_GLrop_VertexAttrib4dvARB
, cmdlen
);
8068 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&index
), 4);
8069 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&x
), 8);
8070 (void) memcpy((void *) (gc
->pc
+ 16), (void *) (&y
), 8);
8071 (void) memcpy((void *) (gc
->pc
+ 24), (void *) (&z
), 8);
8072 (void) memcpy((void *) (gc
->pc
+ 32), (void *) (&w
), 8);
8074 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
8075 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
8079 #define X_GLrop_VertexAttrib4dvARB 4200
8081 __indirect_glVertexAttrib4dvARB(GLuint index
, const GLdouble
* v
)
8083 __GLXcontext
*const gc
= __glXGetCurrentContext();
8084 const GLuint cmdlen
= 40;
8085 emit_header(gc
->pc
, X_GLrop_VertexAttrib4dvARB
, cmdlen
);
8086 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&index
), 4);
8087 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (v
), 32);
8089 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
8090 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
8094 #define X_GLrop_VertexAttrib4fvARB 4196
8096 __indirect_glVertexAttrib4fARB(GLuint index
, GLfloat x
, GLfloat y
, GLfloat z
,
8099 __GLXcontext
*const gc
= __glXGetCurrentContext();
8100 const GLuint cmdlen
= 24;
8101 emit_header(gc
->pc
, X_GLrop_VertexAttrib4fvARB
, cmdlen
);
8102 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&index
), 4);
8103 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&x
), 4);
8104 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&y
), 4);
8105 (void) memcpy((void *) (gc
->pc
+ 16), (void *) (&z
), 4);
8106 (void) memcpy((void *) (gc
->pc
+ 20), (void *) (&w
), 4);
8108 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
8109 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
8113 #define X_GLrop_VertexAttrib4fvARB 4196
8115 __indirect_glVertexAttrib4fvARB(GLuint index
, const GLfloat
* v
)
8117 __GLXcontext
*const gc
= __glXGetCurrentContext();
8118 const GLuint cmdlen
= 24;
8119 emit_header(gc
->pc
, X_GLrop_VertexAttrib4fvARB
, cmdlen
);
8120 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&index
), 4);
8121 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (v
), 16);
8123 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
8124 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
8128 #define X_GLrop_VertexAttrib4ivARB 4231
8130 __indirect_glVertexAttrib4ivARB(GLuint index
, const GLint
* v
)
8132 __GLXcontext
*const gc
= __glXGetCurrentContext();
8133 const GLuint cmdlen
= 24;
8134 emit_header(gc
->pc
, X_GLrop_VertexAttrib4ivARB
, cmdlen
);
8135 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&index
), 4);
8136 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (v
), 16);
8138 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
8139 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
8143 #define X_GLrop_VertexAttrib4svARB 4192
8145 __indirect_glVertexAttrib4sARB(GLuint index
, GLshort x
, GLshort y
, GLshort z
,
8148 __GLXcontext
*const gc
= __glXGetCurrentContext();
8149 const GLuint cmdlen
= 16;
8150 emit_header(gc
->pc
, X_GLrop_VertexAttrib4svARB
, cmdlen
);
8151 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&index
), 4);
8152 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&x
), 2);
8153 (void) memcpy((void *) (gc
->pc
+ 10), (void *) (&y
), 2);
8154 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&z
), 2);
8155 (void) memcpy((void *) (gc
->pc
+ 14), (void *) (&w
), 2);
8157 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
8158 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
8162 #define X_GLrop_VertexAttrib4svARB 4192
8164 __indirect_glVertexAttrib4svARB(GLuint index
, const GLshort
* v
)
8166 __GLXcontext
*const gc
= __glXGetCurrentContext();
8167 const GLuint cmdlen
= 16;
8168 emit_header(gc
->pc
, X_GLrop_VertexAttrib4svARB
, cmdlen
);
8169 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&index
), 4);
8170 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (v
), 8);
8172 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
8173 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
8177 #define X_GLrop_VertexAttrib4ubvARB 4232
8179 __indirect_glVertexAttrib4ubvARB(GLuint index
, const GLubyte
* v
)
8181 __GLXcontext
*const gc
= __glXGetCurrentContext();
8182 const GLuint cmdlen
= 12;
8183 emit_header(gc
->pc
, X_GLrop_VertexAttrib4ubvARB
, cmdlen
);
8184 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&index
), 4);
8185 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (v
), 4);
8187 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
8188 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
8192 #define X_GLrop_VertexAttrib4uivARB 4234
8194 __indirect_glVertexAttrib4uivARB(GLuint index
, const GLuint
* v
)
8196 __GLXcontext
*const gc
= __glXGetCurrentContext();
8197 const GLuint cmdlen
= 24;
8198 emit_header(gc
->pc
, X_GLrop_VertexAttrib4uivARB
, cmdlen
);
8199 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&index
), 4);
8200 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (v
), 16);
8202 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
8203 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
8207 #define X_GLrop_VertexAttrib4usvARB 4233
8209 __indirect_glVertexAttrib4usvARB(GLuint index
, const GLushort
* v
)
8211 __GLXcontext
*const gc
= __glXGetCurrentContext();
8212 const GLuint cmdlen
= 16;
8213 emit_header(gc
->pc
, X_GLrop_VertexAttrib4usvARB
, cmdlen
);
8214 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&index
), 4);
8215 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (v
), 8);
8217 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
8218 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
8222 #define X_GLrop_BeginQueryARB 231
8224 __indirect_glBeginQueryARB(GLenum target
, GLuint id
)
8226 __GLXcontext
*const gc
= __glXGetCurrentContext();
8227 const GLuint cmdlen
= 12;
8228 emit_header(gc
->pc
, X_GLrop_BeginQueryARB
, cmdlen
);
8229 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&target
), 4);
8230 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&id
), 4);
8232 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
8233 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
8237 #define X_GLsop_DeleteQueriesARB 161
8239 __indirect_glDeleteQueriesARB(GLsizei n
, const GLuint
* ids
)
8241 __GLXcontext
*const gc
= __glXGetCurrentContext();
8242 Display
*const dpy
= gc
->currentDpy
;
8243 const GLuint cmdlen
= 4 + __GLX_PAD((n
* 4));
8244 if (__builtin_expect((n
>= 0) && (dpy
!= NULL
), 1)) {
8246 xcb_connection_t
*c
= XGetXCBConnection(dpy
);
8247 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
8248 xcb_glx_delete_queries_arb(c
, gc
->currentContextTag
, n
, ids
);
8251 __glXSetupSingleRequest(gc
, X_GLsop_DeleteQueriesARB
, cmdlen
);
8252 (void) memcpy((void *) (pc
+ 0), (void *) (&n
), 4);
8253 (void) memcpy((void *) (pc
+ 4), (void *) (ids
), (n
* 4));
8256 #endif /* USE_XCB */
8261 #define X_GLrop_EndQueryARB 232
8263 __indirect_glEndQueryARB(GLenum target
)
8265 __GLXcontext
*const gc
= __glXGetCurrentContext();
8266 const GLuint cmdlen
= 8;
8267 emit_header(gc
->pc
, X_GLrop_EndQueryARB
, cmdlen
);
8268 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&target
), 4);
8270 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
8271 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
8275 #define X_GLsop_GenQueriesARB 162
8277 __indirect_glGenQueriesARB(GLsizei n
, GLuint
* ids
)
8279 __GLXcontext
*const gc
= __glXGetCurrentContext();
8280 Display
*const dpy
= gc
->currentDpy
;
8281 const GLuint cmdlen
= 4;
8282 if (__builtin_expect((n
>= 0) && (dpy
!= NULL
), 1)) {
8284 xcb_connection_t
*c
= XGetXCBConnection(dpy
);
8285 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
8286 xcb_glx_gen_queries_arb_reply_t
*reply
=
8287 xcb_glx_gen_queries_arb_reply(c
,
8288 xcb_glx_gen_queries_arb(c
,
8292 (void) memcpy(ids
, xcb_glx_gen_queries_arb_data(reply
),
8293 xcb_glx_gen_queries_arb_data_length(reply
) *
8298 __glXSetupSingleRequest(gc
, X_GLsop_GenQueriesARB
, cmdlen
);
8299 (void) memcpy((void *) (pc
+ 0), (void *) (&n
), 4);
8300 (void) __glXReadReply(dpy
, 4, ids
, GL_TRUE
);
8303 #endif /* USE_XCB */
8308 #define X_GLsop_GetQueryObjectivARB 165
8310 __indirect_glGetQueryObjectivARB(GLuint id
, GLenum pname
, GLint
* params
)
8312 __GLXcontext
*const gc
= __glXGetCurrentContext();
8313 Display
*const dpy
= gc
->currentDpy
;
8314 const GLuint cmdlen
= 8;
8315 if (__builtin_expect(dpy
!= NULL
, 1)) {
8317 xcb_connection_t
*c
= XGetXCBConnection(dpy
);
8318 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
8319 xcb_glx_get_query_objectiv_arb_reply_t
*reply
=
8320 xcb_glx_get_query_objectiv_arb_reply(c
,
8321 xcb_glx_get_query_objectiv_arb
8322 (c
, gc
->currentContextTag
,
8324 if (xcb_glx_get_query_objectiv_arb_data_length(reply
) == 0)
8325 (void) memcpy(params
, &reply
->datum
, sizeof(reply
->datum
));
8327 (void) memcpy(params
, xcb_glx_get_query_objectiv_arb_data(reply
),
8328 xcb_glx_get_query_objectiv_arb_data_length(reply
) *
8333 __glXSetupSingleRequest(gc
, X_GLsop_GetQueryObjectivARB
, cmdlen
);
8334 (void) memcpy((void *) (pc
+ 0), (void *) (&id
), 4);
8335 (void) memcpy((void *) (pc
+ 4), (void *) (&pname
), 4);
8336 (void) __glXReadReply(dpy
, 4, params
, GL_FALSE
);
8339 #endif /* USE_XCB */
8344 #define X_GLsop_GetQueryObjectuivARB 166
8346 __indirect_glGetQueryObjectuivARB(GLuint id
, GLenum pname
, GLuint
* params
)
8348 __GLXcontext
*const gc
= __glXGetCurrentContext();
8349 Display
*const dpy
= gc
->currentDpy
;
8350 const GLuint cmdlen
= 8;
8351 if (__builtin_expect(dpy
!= NULL
, 1)) {
8353 xcb_connection_t
*c
= XGetXCBConnection(dpy
);
8354 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
8355 xcb_glx_get_query_objectuiv_arb_reply_t
*reply
=
8356 xcb_glx_get_query_objectuiv_arb_reply(c
,
8357 xcb_glx_get_query_objectuiv_arb
8358 (c
, gc
->currentContextTag
,
8360 if (xcb_glx_get_query_objectuiv_arb_data_length(reply
) == 0)
8361 (void) memcpy(params
, &reply
->datum
, sizeof(reply
->datum
));
8363 (void) memcpy(params
, xcb_glx_get_query_objectuiv_arb_data(reply
),
8364 xcb_glx_get_query_objectuiv_arb_data_length(reply
) *
8369 __glXSetupSingleRequest(gc
, X_GLsop_GetQueryObjectuivARB
, cmdlen
);
8370 (void) memcpy((void *) (pc
+ 0), (void *) (&id
), 4);
8371 (void) memcpy((void *) (pc
+ 4), (void *) (&pname
), 4);
8372 (void) __glXReadReply(dpy
, 4, params
, GL_FALSE
);
8375 #endif /* USE_XCB */
8380 #define X_GLsop_GetQueryivARB 164
8382 __indirect_glGetQueryivARB(GLenum target
, GLenum pname
, GLint
* params
)
8384 __GLXcontext
*const gc
= __glXGetCurrentContext();
8385 Display
*const dpy
= gc
->currentDpy
;
8386 const GLuint cmdlen
= 8;
8387 if (__builtin_expect(dpy
!= NULL
, 1)) {
8389 xcb_connection_t
*c
= XGetXCBConnection(dpy
);
8390 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
8391 xcb_glx_get_queryiv_arb_reply_t
*reply
=
8392 xcb_glx_get_queryiv_arb_reply(c
,
8393 xcb_glx_get_queryiv_arb(c
,
8399 if (xcb_glx_get_queryiv_arb_data_length(reply
) == 0)
8400 (void) memcpy(params
, &reply
->datum
, sizeof(reply
->datum
));
8402 (void) memcpy(params
, xcb_glx_get_queryiv_arb_data(reply
),
8403 xcb_glx_get_queryiv_arb_data_length(reply
) *
8408 __glXSetupSingleRequest(gc
, X_GLsop_GetQueryivARB
, cmdlen
);
8409 (void) memcpy((void *) (pc
+ 0), (void *) (&target
), 4);
8410 (void) memcpy((void *) (pc
+ 4), (void *) (&pname
), 4);
8411 (void) __glXReadReply(dpy
, 4, params
, GL_FALSE
);
8414 #endif /* USE_XCB */
8419 #define X_GLsop_IsQueryARB 163
8421 __indirect_glIsQueryARB(GLuint id
)
8423 __GLXcontext
*const gc
= __glXGetCurrentContext();
8424 Display
*const dpy
= gc
->currentDpy
;
8425 GLboolean retval
= (GLboolean
) 0;
8426 const GLuint cmdlen
= 4;
8427 if (__builtin_expect(dpy
!= NULL
, 1)) {
8429 xcb_connection_t
*c
= XGetXCBConnection(dpy
);
8430 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
8431 xcb_glx_is_query_arb_reply_t
*reply
=
8432 xcb_glx_is_query_arb_reply(c
,
8433 xcb_glx_is_query_arb(c
,
8437 retval
= reply
->ret_val
;
8441 __glXSetupSingleRequest(gc
, X_GLsop_IsQueryARB
, cmdlen
);
8442 (void) memcpy((void *) (pc
+ 0), (void *) (&id
), 4);
8443 retval
= (GLboolean
) __glXReadReply(dpy
, 0, NULL
, GL_FALSE
);
8446 #endif /* USE_XCB */
8451 #define X_GLrop_DrawBuffersARB 233
8453 __indirect_glDrawBuffersARB(GLsizei n
, const GLenum
* bufs
)
8455 __GLXcontext
*const gc
= __glXGetCurrentContext();
8456 const GLuint cmdlen
= 8 + __GLX_PAD((n
* 4));
8457 if (__builtin_expect((n
>= 0) && (gc
->currentDpy
!= NULL
), 1)) {
8458 if (cmdlen
<= gc
->maxSmallRenderCommandSize
) {
8459 if ((gc
->pc
+ cmdlen
) > gc
->bufEnd
) {
8460 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
8462 emit_header(gc
->pc
, X_GLrop_DrawBuffersARB
, cmdlen
);
8463 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&n
), 4);
8464 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (bufs
), (n
* 4));
8466 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
8467 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
8470 const GLint op
= X_GLrop_DrawBuffersARB
;
8471 const GLuint cmdlenLarge
= cmdlen
+ 4;
8472 GLubyte
*const pc
= __glXFlushRenderBuffer(gc
, gc
->pc
);
8473 (void) memcpy((void *) (pc
+ 0), (void *) (&cmdlenLarge
), 4);
8474 (void) memcpy((void *) (pc
+ 4), (void *) (&op
), 4);
8475 (void) memcpy((void *) (pc
+ 8), (void *) (&n
), 4);
8476 __glXSendLargeCommand(gc
, pc
, 12, bufs
, (n
* 4));
8481 #define X_GLrop_SampleMaskSGIS 2048
8483 __indirect_glSampleMaskSGIS(GLclampf value
, GLboolean invert
)
8485 __GLXcontext
*const gc
= __glXGetCurrentContext();
8486 const GLuint cmdlen
= 12;
8487 emit_header(gc
->pc
, X_GLrop_SampleMaskSGIS
, cmdlen
);
8488 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&value
), 4);
8489 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&invert
), 1);
8491 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
8492 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
8496 #define X_GLrop_SamplePatternSGIS 2049
8498 __indirect_glSamplePatternSGIS(GLenum pattern
)
8500 __GLXcontext
*const gc
= __glXGetCurrentContext();
8501 const GLuint cmdlen
= 8;
8502 emit_header(gc
->pc
, X_GLrop_SamplePatternSGIS
, cmdlen
);
8503 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&pattern
), 4);
8505 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
8506 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
8510 #define X_GLrop_PointParameterfEXT 2065
8512 __indirect_glPointParameterfEXT(GLenum pname
, GLfloat param
)
8514 __GLXcontext
*const gc
= __glXGetCurrentContext();
8515 const GLuint cmdlen
= 12;
8516 emit_header(gc
->pc
, X_GLrop_PointParameterfEXT
, cmdlen
);
8517 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&pname
), 4);
8518 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (¶m
), 4);
8520 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
8521 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
8525 #define X_GLrop_PointParameterfvEXT 2066
8527 __indirect_glPointParameterfvEXT(GLenum pname
, const GLfloat
* params
)
8529 __GLXcontext
*const gc
= __glXGetCurrentContext();
8530 const GLuint compsize
= __glPointParameterfvEXT_size(pname
);
8531 const GLuint cmdlen
= 8 + __GLX_PAD((compsize
* 4));
8532 emit_header(gc
->pc
, X_GLrop_PointParameterfvEXT
, cmdlen
);
8533 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&pname
), 4);
8534 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (params
), (compsize
* 4));
8536 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
8537 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
8541 #define X_GLrop_SecondaryColor3bvEXT 4126
8543 __indirect_glSecondaryColor3bEXT(GLbyte red
, GLbyte green
, GLbyte blue
)
8545 __GLXcontext
*const gc
= __glXGetCurrentContext();
8546 const GLuint cmdlen
= 8;
8547 emit_header(gc
->pc
, X_GLrop_SecondaryColor3bvEXT
, cmdlen
);
8548 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&red
), 1);
8549 (void) memcpy((void *) (gc
->pc
+ 5), (void *) (&green
), 1);
8550 (void) memcpy((void *) (gc
->pc
+ 6), (void *) (&blue
), 1);
8552 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
8553 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
8557 #define X_GLrop_SecondaryColor3bvEXT 4126
8559 __indirect_glSecondaryColor3bvEXT(const GLbyte
* v
)
8561 generic_3_byte(X_GLrop_SecondaryColor3bvEXT
, v
);
8564 #define X_GLrop_SecondaryColor3dvEXT 4130
8566 __indirect_glSecondaryColor3dEXT(GLdouble red
, GLdouble green
, GLdouble blue
)
8568 __GLXcontext
*const gc
= __glXGetCurrentContext();
8569 const GLuint cmdlen
= 28;
8570 emit_header(gc
->pc
, X_GLrop_SecondaryColor3dvEXT
, cmdlen
);
8571 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&red
), 8);
8572 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&green
), 8);
8573 (void) memcpy((void *) (gc
->pc
+ 20), (void *) (&blue
), 8);
8575 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
8576 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
8580 #define X_GLrop_SecondaryColor3dvEXT 4130
8582 __indirect_glSecondaryColor3dvEXT(const GLdouble
* v
)
8584 generic_24_byte(X_GLrop_SecondaryColor3dvEXT
, v
);
8587 #define X_GLrop_SecondaryColor3fvEXT 4129
8589 __indirect_glSecondaryColor3fEXT(GLfloat red
, GLfloat green
, GLfloat blue
)
8591 __GLXcontext
*const gc
= __glXGetCurrentContext();
8592 const GLuint cmdlen
= 16;
8593 emit_header(gc
->pc
, X_GLrop_SecondaryColor3fvEXT
, cmdlen
);
8594 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&red
), 4);
8595 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&green
), 4);
8596 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&blue
), 4);
8598 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
8599 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
8603 #define X_GLrop_SecondaryColor3fvEXT 4129
8605 __indirect_glSecondaryColor3fvEXT(const GLfloat
* v
)
8607 generic_12_byte(X_GLrop_SecondaryColor3fvEXT
, v
);
8610 #define X_GLrop_SecondaryColor3ivEXT 4128
8612 __indirect_glSecondaryColor3iEXT(GLint red
, GLint green
, GLint blue
)
8614 __GLXcontext
*const gc
= __glXGetCurrentContext();
8615 const GLuint cmdlen
= 16;
8616 emit_header(gc
->pc
, X_GLrop_SecondaryColor3ivEXT
, cmdlen
);
8617 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&red
), 4);
8618 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&green
), 4);
8619 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&blue
), 4);
8621 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
8622 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
8626 #define X_GLrop_SecondaryColor3ivEXT 4128
8628 __indirect_glSecondaryColor3ivEXT(const GLint
* v
)
8630 generic_12_byte(X_GLrop_SecondaryColor3ivEXT
, v
);
8633 #define X_GLrop_SecondaryColor3svEXT 4127
8635 __indirect_glSecondaryColor3sEXT(GLshort red
, GLshort green
, GLshort blue
)
8637 __GLXcontext
*const gc
= __glXGetCurrentContext();
8638 const GLuint cmdlen
= 12;
8639 emit_header(gc
->pc
, X_GLrop_SecondaryColor3svEXT
, cmdlen
);
8640 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&red
), 2);
8641 (void) memcpy((void *) (gc
->pc
+ 6), (void *) (&green
), 2);
8642 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&blue
), 2);
8644 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
8645 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
8649 #define X_GLrop_SecondaryColor3svEXT 4127
8651 __indirect_glSecondaryColor3svEXT(const GLshort
* v
)
8653 generic_6_byte(X_GLrop_SecondaryColor3svEXT
, v
);
8656 #define X_GLrop_SecondaryColor3ubvEXT 4131
8658 __indirect_glSecondaryColor3ubEXT(GLubyte red
, GLubyte green
, GLubyte blue
)
8660 __GLXcontext
*const gc
= __glXGetCurrentContext();
8661 const GLuint cmdlen
= 8;
8662 emit_header(gc
->pc
, X_GLrop_SecondaryColor3ubvEXT
, cmdlen
);
8663 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&red
), 1);
8664 (void) memcpy((void *) (gc
->pc
+ 5), (void *) (&green
), 1);
8665 (void) memcpy((void *) (gc
->pc
+ 6), (void *) (&blue
), 1);
8667 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
8668 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
8672 #define X_GLrop_SecondaryColor3ubvEXT 4131
8674 __indirect_glSecondaryColor3ubvEXT(const GLubyte
* v
)
8676 generic_3_byte(X_GLrop_SecondaryColor3ubvEXT
, v
);
8679 #define X_GLrop_SecondaryColor3uivEXT 4133
8681 __indirect_glSecondaryColor3uiEXT(GLuint red
, GLuint green
, GLuint blue
)
8683 __GLXcontext
*const gc
= __glXGetCurrentContext();
8684 const GLuint cmdlen
= 16;
8685 emit_header(gc
->pc
, X_GLrop_SecondaryColor3uivEXT
, cmdlen
);
8686 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&red
), 4);
8687 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&green
), 4);
8688 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&blue
), 4);
8690 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
8691 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
8695 #define X_GLrop_SecondaryColor3uivEXT 4133
8697 __indirect_glSecondaryColor3uivEXT(const GLuint
* v
)
8699 generic_12_byte(X_GLrop_SecondaryColor3uivEXT
, v
);
8702 #define X_GLrop_SecondaryColor3usvEXT 4132
8704 __indirect_glSecondaryColor3usEXT(GLushort red
, GLushort green
, GLushort blue
)
8706 __GLXcontext
*const gc
= __glXGetCurrentContext();
8707 const GLuint cmdlen
= 12;
8708 emit_header(gc
->pc
, X_GLrop_SecondaryColor3usvEXT
, cmdlen
);
8709 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&red
), 2);
8710 (void) memcpy((void *) (gc
->pc
+ 6), (void *) (&green
), 2);
8711 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&blue
), 2);
8713 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
8714 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
8718 #define X_GLrop_SecondaryColor3usvEXT 4132
8720 __indirect_glSecondaryColor3usvEXT(const GLushort
* v
)
8722 generic_6_byte(X_GLrop_SecondaryColor3usvEXT
, v
);
8725 #define X_GLrop_FogCoorddvEXT 4125
8727 __indirect_glFogCoorddEXT(GLdouble coord
)
8729 __GLXcontext
*const gc
= __glXGetCurrentContext();
8730 const GLuint cmdlen
= 12;
8731 emit_header(gc
->pc
, X_GLrop_FogCoorddvEXT
, cmdlen
);
8732 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&coord
), 8);
8734 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
8735 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
8739 #define X_GLrop_FogCoorddvEXT 4125
8741 __indirect_glFogCoorddvEXT(const GLdouble
* coord
)
8743 generic_8_byte(X_GLrop_FogCoorddvEXT
, coord
);
8746 #define X_GLrop_FogCoordfvEXT 4124
8748 __indirect_glFogCoordfEXT(GLfloat coord
)
8750 __GLXcontext
*const gc
= __glXGetCurrentContext();
8751 const GLuint cmdlen
= 8;
8752 emit_header(gc
->pc
, X_GLrop_FogCoordfvEXT
, cmdlen
);
8753 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&coord
), 4);
8755 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
8756 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
8760 #define X_GLrop_FogCoordfvEXT 4124
8762 __indirect_glFogCoordfvEXT(const GLfloat
* coord
)
8764 generic_4_byte(X_GLrop_FogCoordfvEXT
, coord
);
8767 #define X_GLrop_BlendFuncSeparateEXT 4134
8769 __indirect_glBlendFuncSeparateEXT(GLenum sfactorRGB
, GLenum dfactorRGB
,
8770 GLenum sfactorAlpha
, GLenum dfactorAlpha
)
8772 __GLXcontext
*const gc
= __glXGetCurrentContext();
8773 const GLuint cmdlen
= 20;
8774 emit_header(gc
->pc
, X_GLrop_BlendFuncSeparateEXT
, cmdlen
);
8775 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&sfactorRGB
), 4);
8776 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&dfactorRGB
), 4);
8777 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&sfactorAlpha
), 4);
8778 (void) memcpy((void *) (gc
->pc
+ 16), (void *) (&dfactorAlpha
), 4);
8780 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
8781 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
8785 #define X_GLrop_WindowPos3fvMESA 230
8787 __indirect_glWindowPos3fMESA(GLfloat x
, GLfloat y
, GLfloat z
)
8789 __GLXcontext
*const gc
= __glXGetCurrentContext();
8790 const GLuint cmdlen
= 16;
8791 emit_header(gc
->pc
, X_GLrop_WindowPos3fvMESA
, cmdlen
);
8792 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&x
), 4);
8793 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&y
), 4);
8794 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&z
), 4);
8796 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
8797 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
8801 #define X_GLrop_WindowPos3fvMESA 230
8803 __indirect_glWindowPos3fvMESA(const GLfloat
* v
)
8805 generic_12_byte(X_GLrop_WindowPos3fvMESA
, v
);
8808 #define X_GLvop_AreProgramsResidentNV 1293
8810 __indirect_glAreProgramsResidentNV(GLsizei n
, const GLuint
* ids
,
8811 GLboolean
* residences
)
8813 __GLXcontext
*const gc
= __glXGetCurrentContext();
8814 Display
*const dpy
= gc
->currentDpy
;
8815 GLboolean retval
= (GLboolean
) 0;
8816 const GLuint cmdlen
= 4 + __GLX_PAD((n
* 4));
8817 if (__builtin_expect((n
>= 0) && (dpy
!= NULL
), 1)) {
8819 __glXSetupVendorRequest(gc
, X_GLXVendorPrivateWithReply
,
8820 X_GLvop_AreProgramsResidentNV
, cmdlen
);
8821 (void) memcpy((void *) (pc
+ 0), (void *) (&n
), 4);
8822 (void) memcpy((void *) (pc
+ 4), (void *) (ids
), (n
* 4));
8823 retval
= (GLboolean
) __glXReadReply(dpy
, 1, residences
, GL_FALSE
);
8830 #define X_GLrop_BindProgramNV 4180
8832 __indirect_glBindProgramNV(GLenum target
, GLuint program
)
8834 __GLXcontext
*const gc
= __glXGetCurrentContext();
8835 const GLuint cmdlen
= 12;
8836 emit_header(gc
->pc
, X_GLrop_BindProgramNV
, cmdlen
);
8837 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&target
), 4);
8838 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&program
), 4);
8840 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
8841 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
8845 #define X_GLvop_DeleteProgramsNV 1294
8847 __indirect_glDeleteProgramsNV(GLsizei n
, const GLuint
* programs
)
8849 __GLXcontext
*const gc
= __glXGetCurrentContext();
8850 Display
*const dpy
= gc
->currentDpy
;
8851 const GLuint cmdlen
= 4 + __GLX_PAD((n
* 4));
8852 if (__builtin_expect((n
>= 0) && (dpy
!= NULL
), 1)) {
8854 __glXSetupVendorRequest(gc
, X_GLXVendorPrivate
,
8855 X_GLvop_DeleteProgramsNV
, cmdlen
);
8856 (void) memcpy((void *) (pc
+ 0), (void *) (&n
), 4);
8857 (void) memcpy((void *) (pc
+ 4), (void *) (programs
), (n
* 4));
8864 #define X_GLrop_ExecuteProgramNV 4181
8866 __indirect_glExecuteProgramNV(GLenum target
, GLuint id
,
8867 const GLfloat
* params
)
8869 __GLXcontext
*const gc
= __glXGetCurrentContext();
8870 const GLuint cmdlen
= 28;
8871 emit_header(gc
->pc
, X_GLrop_ExecuteProgramNV
, cmdlen
);
8872 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&target
), 4);
8873 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&id
), 4);
8874 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (params
), 16);
8876 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
8877 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
8881 #define X_GLvop_GenProgramsNV 1295
8883 __indirect_glGenProgramsNV(GLsizei n
, GLuint
* programs
)
8885 __GLXcontext
*const gc
= __glXGetCurrentContext();
8886 Display
*const dpy
= gc
->currentDpy
;
8887 const GLuint cmdlen
= 4;
8888 if (__builtin_expect((n
>= 0) && (dpy
!= NULL
), 1)) {
8890 __glXSetupVendorRequest(gc
, X_GLXVendorPrivateWithReply
,
8891 X_GLvop_GenProgramsNV
, cmdlen
);
8892 (void) memcpy((void *) (pc
+ 0), (void *) (&n
), 4);
8893 (void) __glXReadReply(dpy
, 4, programs
, GL_TRUE
);
8900 #define X_GLvop_GetProgramParameterdvNV 1297
8902 __indirect_glGetProgramParameterdvNV(GLenum target
, GLuint index
,
8903 GLenum pname
, GLdouble
* params
)
8905 __GLXcontext
*const gc
= __glXGetCurrentContext();
8906 Display
*const dpy
= gc
->currentDpy
;
8907 const GLuint cmdlen
= 12;
8908 if (__builtin_expect(dpy
!= NULL
, 1)) {
8910 __glXSetupVendorRequest(gc
, X_GLXVendorPrivateWithReply
,
8911 X_GLvop_GetProgramParameterdvNV
, cmdlen
);
8912 (void) memcpy((void *) (pc
+ 0), (void *) (&target
), 4);
8913 (void) memcpy((void *) (pc
+ 4), (void *) (&index
), 4);
8914 (void) memcpy((void *) (pc
+ 8), (void *) (&pname
), 4);
8915 (void) __glXReadReply(dpy
, 8, params
, GL_FALSE
);
8922 #define X_GLvop_GetProgramParameterfvNV 1296
8924 __indirect_glGetProgramParameterfvNV(GLenum target
, GLuint index
,
8925 GLenum pname
, GLfloat
* params
)
8927 __GLXcontext
*const gc
= __glXGetCurrentContext();
8928 Display
*const dpy
= gc
->currentDpy
;
8929 const GLuint cmdlen
= 12;
8930 if (__builtin_expect(dpy
!= NULL
, 1)) {
8932 __glXSetupVendorRequest(gc
, X_GLXVendorPrivateWithReply
,
8933 X_GLvop_GetProgramParameterfvNV
, cmdlen
);
8934 (void) memcpy((void *) (pc
+ 0), (void *) (&target
), 4);
8935 (void) memcpy((void *) (pc
+ 4), (void *) (&index
), 4);
8936 (void) memcpy((void *) (pc
+ 8), (void *) (&pname
), 4);
8937 (void) __glXReadReply(dpy
, 4, params
, GL_FALSE
);
8944 #define X_GLvop_GetProgramStringNV 1299
8946 __indirect_glGetProgramStringNV(GLuint id
, GLenum pname
, GLubyte
* program
)
8948 __GLXcontext
*const gc
= __glXGetCurrentContext();
8949 Display
*const dpy
= gc
->currentDpy
;
8950 const GLuint cmdlen
= 8;
8951 if (__builtin_expect(dpy
!= NULL
, 1)) {
8953 __glXSetupVendorRequest(gc
, X_GLXVendorPrivateWithReply
,
8954 X_GLvop_GetProgramStringNV
, cmdlen
);
8955 (void) memcpy((void *) (pc
+ 0), (void *) (&id
), 4);
8956 (void) memcpy((void *) (pc
+ 4), (void *) (&pname
), 4);
8957 (void) __glXReadReply(dpy
, 1, program
, GL_TRUE
);
8964 #define X_GLvop_GetProgramivNV 1298
8966 __indirect_glGetProgramivNV(GLuint id
, GLenum pname
, GLint
* params
)
8968 __GLXcontext
*const gc
= __glXGetCurrentContext();
8969 Display
*const dpy
= gc
->currentDpy
;
8970 const GLuint cmdlen
= 8;
8971 if (__builtin_expect(dpy
!= NULL
, 1)) {
8973 __glXSetupVendorRequest(gc
, X_GLXVendorPrivateWithReply
,
8974 X_GLvop_GetProgramivNV
, cmdlen
);
8975 (void) memcpy((void *) (pc
+ 0), (void *) (&id
), 4);
8976 (void) memcpy((void *) (pc
+ 4), (void *) (&pname
), 4);
8977 (void) __glXReadReply(dpy
, 4, params
, GL_FALSE
);
8984 #define X_GLvop_GetTrackMatrixivNV 1300
8986 __indirect_glGetTrackMatrixivNV(GLenum target
, GLuint address
, GLenum pname
,
8989 __GLXcontext
*const gc
= __glXGetCurrentContext();
8990 Display
*const dpy
= gc
->currentDpy
;
8991 const GLuint cmdlen
= 12;
8992 if (__builtin_expect(dpy
!= NULL
, 1)) {
8994 __glXSetupVendorRequest(gc
, X_GLXVendorPrivateWithReply
,
8995 X_GLvop_GetTrackMatrixivNV
, cmdlen
);
8996 (void) memcpy((void *) (pc
+ 0), (void *) (&target
), 4);
8997 (void) memcpy((void *) (pc
+ 4), (void *) (&address
), 4);
8998 (void) memcpy((void *) (pc
+ 8), (void *) (&pname
), 4);
8999 (void) __glXReadReply(dpy
, 4, params
, GL_FALSE
);
9006 #define X_GLvop_GetVertexAttribdvNV 1301
9008 __indirect_glGetVertexAttribdvNV(GLuint index
, GLenum pname
,
9011 __GLXcontext
*const gc
= __glXGetCurrentContext();
9012 Display
*const dpy
= gc
->currentDpy
;
9013 const GLuint cmdlen
= 8;
9014 if (__builtin_expect(dpy
!= NULL
, 1)) {
9016 __glXSetupVendorRequest(gc
, X_GLXVendorPrivateWithReply
,
9017 X_GLvop_GetVertexAttribdvNV
, cmdlen
);
9018 (void) memcpy((void *) (pc
+ 0), (void *) (&index
), 4);
9019 (void) memcpy((void *) (pc
+ 4), (void *) (&pname
), 4);
9020 (void) __glXReadReply(dpy
, 8, params
, GL_FALSE
);
9027 #define X_GLvop_GetVertexAttribfvNV 1302
9029 __indirect_glGetVertexAttribfvNV(GLuint index
, GLenum pname
, GLfloat
* params
)
9031 __GLXcontext
*const gc
= __glXGetCurrentContext();
9032 Display
*const dpy
= gc
->currentDpy
;
9033 const GLuint cmdlen
= 8;
9034 if (__builtin_expect(dpy
!= NULL
, 1)) {
9036 __glXSetupVendorRequest(gc
, X_GLXVendorPrivateWithReply
,
9037 X_GLvop_GetVertexAttribfvNV
, cmdlen
);
9038 (void) memcpy((void *) (pc
+ 0), (void *) (&index
), 4);
9039 (void) memcpy((void *) (pc
+ 4), (void *) (&pname
), 4);
9040 (void) __glXReadReply(dpy
, 4, params
, GL_FALSE
);
9047 #define X_GLvop_GetVertexAttribivNV 1303
9049 __indirect_glGetVertexAttribivNV(GLuint index
, GLenum pname
, GLint
* params
)
9051 __GLXcontext
*const gc
= __glXGetCurrentContext();
9052 Display
*const dpy
= gc
->currentDpy
;
9053 const GLuint cmdlen
= 8;
9054 if (__builtin_expect(dpy
!= NULL
, 1)) {
9056 __glXSetupVendorRequest(gc
, X_GLXVendorPrivateWithReply
,
9057 X_GLvop_GetVertexAttribivNV
, cmdlen
);
9058 (void) memcpy((void *) (pc
+ 0), (void *) (&index
), 4);
9059 (void) memcpy((void *) (pc
+ 4), (void *) (&pname
), 4);
9060 (void) __glXReadReply(dpy
, 4, params
, GL_FALSE
);
9067 #define X_GLvop_IsProgramNV 1304
9069 __indirect_glIsProgramNV(GLuint program
)
9071 __GLXcontext
*const gc
= __glXGetCurrentContext();
9072 Display
*const dpy
= gc
->currentDpy
;
9073 GLboolean retval
= (GLboolean
) 0;
9074 const GLuint cmdlen
= 4;
9075 if (__builtin_expect(dpy
!= NULL
, 1)) {
9077 __glXSetupVendorRequest(gc
, X_GLXVendorPrivateWithReply
,
9078 X_GLvop_IsProgramNV
, cmdlen
);
9079 (void) memcpy((void *) (pc
+ 0), (void *) (&program
), 4);
9080 retval
= (GLboolean
) __glXReadReply(dpy
, 0, NULL
, GL_FALSE
);
9087 #define X_GLrop_LoadProgramNV 4183
9089 __indirect_glLoadProgramNV(GLenum target
, GLuint id
, GLsizei len
,
9090 const GLubyte
* program
)
9092 __GLXcontext
*const gc
= __glXGetCurrentContext();
9093 const GLuint cmdlen
= 16 + __GLX_PAD(len
);
9094 if (__builtin_expect(len
>= 0, 1)) {
9095 emit_header(gc
->pc
, X_GLrop_LoadProgramNV
, cmdlen
);
9096 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&target
), 4);
9097 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&id
), 4);
9098 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&len
), 4);
9099 (void) memcpy((void *) (gc
->pc
+ 16), (void *) (program
), len
);
9101 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
9102 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
9107 #define X_GLrop_ProgramParameter4dvNV 4185
9109 __indirect_glProgramParameter4dNV(GLenum target
, GLuint index
, GLdouble x
,
9110 GLdouble y
, GLdouble z
, GLdouble w
)
9112 __GLXcontext
*const gc
= __glXGetCurrentContext();
9113 const GLuint cmdlen
= 44;
9114 emit_header(gc
->pc
, X_GLrop_ProgramParameter4dvNV
, cmdlen
);
9115 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&target
), 4);
9116 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&index
), 4);
9117 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&x
), 8);
9118 (void) memcpy((void *) (gc
->pc
+ 20), (void *) (&y
), 8);
9119 (void) memcpy((void *) (gc
->pc
+ 28), (void *) (&z
), 8);
9120 (void) memcpy((void *) (gc
->pc
+ 36), (void *) (&w
), 8);
9122 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
9123 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
9127 #define X_GLrop_ProgramParameter4dvNV 4185
9129 __indirect_glProgramParameter4dvNV(GLenum target
, GLuint index
,
9130 const GLdouble
* params
)
9132 __GLXcontext
*const gc
= __glXGetCurrentContext();
9133 const GLuint cmdlen
= 44;
9134 emit_header(gc
->pc
, X_GLrop_ProgramParameter4dvNV
, cmdlen
);
9135 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&target
), 4);
9136 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&index
), 4);
9137 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (params
), 32);
9139 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
9140 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
9144 #define X_GLrop_ProgramParameter4fvNV 4184
9146 __indirect_glProgramParameter4fNV(GLenum target
, GLuint index
, GLfloat x
,
9147 GLfloat y
, GLfloat z
, GLfloat w
)
9149 __GLXcontext
*const gc
= __glXGetCurrentContext();
9150 const GLuint cmdlen
= 28;
9151 emit_header(gc
->pc
, X_GLrop_ProgramParameter4fvNV
, cmdlen
);
9152 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&target
), 4);
9153 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&index
), 4);
9154 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&x
), 4);
9155 (void) memcpy((void *) (gc
->pc
+ 16), (void *) (&y
), 4);
9156 (void) memcpy((void *) (gc
->pc
+ 20), (void *) (&z
), 4);
9157 (void) memcpy((void *) (gc
->pc
+ 24), (void *) (&w
), 4);
9159 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
9160 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
9164 #define X_GLrop_ProgramParameter4fvNV 4184
9166 __indirect_glProgramParameter4fvNV(GLenum target
, GLuint index
,
9167 const GLfloat
* params
)
9169 __GLXcontext
*const gc
= __glXGetCurrentContext();
9170 const GLuint cmdlen
= 28;
9171 emit_header(gc
->pc
, X_GLrop_ProgramParameter4fvNV
, cmdlen
);
9172 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&target
), 4);
9173 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&index
), 4);
9174 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (params
), 16);
9176 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
9177 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
9181 #define X_GLrop_ProgramParameters4dvNV 4187
9183 __indirect_glProgramParameters4dvNV(GLenum target
, GLuint index
, GLuint num
,
9184 const GLdouble
* params
)
9186 __GLXcontext
*const gc
= __glXGetCurrentContext();
9187 const GLuint cmdlen
= 16 + __GLX_PAD((num
* 32));
9188 if (__builtin_expect(num
>= 0, 1)) {
9189 emit_header(gc
->pc
, X_GLrop_ProgramParameters4dvNV
, cmdlen
);
9190 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&target
), 4);
9191 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&index
), 4);
9192 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&num
), 4);
9193 (void) memcpy((void *) (gc
->pc
+ 16), (void *) (params
), (num
* 32));
9195 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
9196 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
9201 #define X_GLrop_ProgramParameters4fvNV 4186
9203 __indirect_glProgramParameters4fvNV(GLenum target
, GLuint index
, GLuint num
,
9204 const GLfloat
* params
)
9206 __GLXcontext
*const gc
= __glXGetCurrentContext();
9207 const GLuint cmdlen
= 16 + __GLX_PAD((num
* 16));
9208 if (__builtin_expect(num
>= 0, 1)) {
9209 emit_header(gc
->pc
, X_GLrop_ProgramParameters4fvNV
, cmdlen
);
9210 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&target
), 4);
9211 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&index
), 4);
9212 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&num
), 4);
9213 (void) memcpy((void *) (gc
->pc
+ 16), (void *) (params
), (num
* 16));
9215 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
9216 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
9221 #define X_GLrop_RequestResidentProgramsNV 4182
9223 __indirect_glRequestResidentProgramsNV(GLsizei n
, const GLuint
* ids
)
9225 __GLXcontext
*const gc
= __glXGetCurrentContext();
9226 const GLuint cmdlen
= 8 + __GLX_PAD((n
* 4));
9227 if (__builtin_expect(n
>= 0, 1)) {
9228 emit_header(gc
->pc
, X_GLrop_RequestResidentProgramsNV
, cmdlen
);
9229 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&n
), 4);
9230 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (ids
), (n
* 4));
9232 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
9233 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
9238 #define X_GLrop_TrackMatrixNV 4188
9240 __indirect_glTrackMatrixNV(GLenum target
, GLuint address
, GLenum matrix
,
9243 __GLXcontext
*const gc
= __glXGetCurrentContext();
9244 const GLuint cmdlen
= 20;
9245 emit_header(gc
->pc
, X_GLrop_TrackMatrixNV
, cmdlen
);
9246 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&target
), 4);
9247 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&address
), 4);
9248 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&matrix
), 4);
9249 (void) memcpy((void *) (gc
->pc
+ 16), (void *) (&transform
), 4);
9251 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
9252 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
9256 #define X_GLrop_VertexAttrib1dvNV 4273
9258 __indirect_glVertexAttrib1dNV(GLuint index
, GLdouble x
)
9260 __GLXcontext
*const gc
= __glXGetCurrentContext();
9261 const GLuint cmdlen
= 16;
9262 emit_header(gc
->pc
, X_GLrop_VertexAttrib1dvNV
, cmdlen
);
9263 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&index
), 4);
9264 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&x
), 8);
9266 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
9267 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
9271 #define X_GLrop_VertexAttrib1dvNV 4273
9273 __indirect_glVertexAttrib1dvNV(GLuint index
, const GLdouble
* v
)
9275 __GLXcontext
*const gc
= __glXGetCurrentContext();
9276 const GLuint cmdlen
= 16;
9277 emit_header(gc
->pc
, X_GLrop_VertexAttrib1dvNV
, cmdlen
);
9278 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&index
), 4);
9279 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (v
), 8);
9281 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
9282 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
9286 #define X_GLrop_VertexAttrib1fvNV 4269
9288 __indirect_glVertexAttrib1fNV(GLuint index
, GLfloat x
)
9290 __GLXcontext
*const gc
= __glXGetCurrentContext();
9291 const GLuint cmdlen
= 12;
9292 emit_header(gc
->pc
, X_GLrop_VertexAttrib1fvNV
, cmdlen
);
9293 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&index
), 4);
9294 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&x
), 4);
9296 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
9297 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
9301 #define X_GLrop_VertexAttrib1fvNV 4269
9303 __indirect_glVertexAttrib1fvNV(GLuint index
, const GLfloat
* v
)
9305 __GLXcontext
*const gc
= __glXGetCurrentContext();
9306 const GLuint cmdlen
= 12;
9307 emit_header(gc
->pc
, X_GLrop_VertexAttrib1fvNV
, cmdlen
);
9308 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&index
), 4);
9309 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (v
), 4);
9311 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
9312 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
9316 #define X_GLrop_VertexAttrib1svNV 4265
9318 __indirect_glVertexAttrib1sNV(GLuint index
, GLshort x
)
9320 __GLXcontext
*const gc
= __glXGetCurrentContext();
9321 const GLuint cmdlen
= 12;
9322 emit_header(gc
->pc
, X_GLrop_VertexAttrib1svNV
, cmdlen
);
9323 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&index
), 4);
9324 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&x
), 2);
9326 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
9327 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
9331 #define X_GLrop_VertexAttrib1svNV 4265
9333 __indirect_glVertexAttrib1svNV(GLuint index
, const GLshort
* v
)
9335 __GLXcontext
*const gc
= __glXGetCurrentContext();
9336 const GLuint cmdlen
= 12;
9337 emit_header(gc
->pc
, X_GLrop_VertexAttrib1svNV
, cmdlen
);
9338 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&index
), 4);
9339 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (v
), 2);
9341 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
9342 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
9346 #define X_GLrop_VertexAttrib2dvNV 4274
9348 __indirect_glVertexAttrib2dNV(GLuint index
, GLdouble x
, GLdouble y
)
9350 __GLXcontext
*const gc
= __glXGetCurrentContext();
9351 const GLuint cmdlen
= 24;
9352 emit_header(gc
->pc
, X_GLrop_VertexAttrib2dvNV
, cmdlen
);
9353 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&index
), 4);
9354 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&x
), 8);
9355 (void) memcpy((void *) (gc
->pc
+ 16), (void *) (&y
), 8);
9357 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
9358 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
9362 #define X_GLrop_VertexAttrib2dvNV 4274
9364 __indirect_glVertexAttrib2dvNV(GLuint index
, const GLdouble
* v
)
9366 __GLXcontext
*const gc
= __glXGetCurrentContext();
9367 const GLuint cmdlen
= 24;
9368 emit_header(gc
->pc
, X_GLrop_VertexAttrib2dvNV
, cmdlen
);
9369 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&index
), 4);
9370 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (v
), 16);
9372 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
9373 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
9377 #define X_GLrop_VertexAttrib2fvNV 4270
9379 __indirect_glVertexAttrib2fNV(GLuint index
, GLfloat x
, GLfloat y
)
9381 __GLXcontext
*const gc
= __glXGetCurrentContext();
9382 const GLuint cmdlen
= 16;
9383 emit_header(gc
->pc
, X_GLrop_VertexAttrib2fvNV
, cmdlen
);
9384 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&index
), 4);
9385 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&x
), 4);
9386 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&y
), 4);
9388 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
9389 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
9393 #define X_GLrop_VertexAttrib2fvNV 4270
9395 __indirect_glVertexAttrib2fvNV(GLuint index
, const GLfloat
* v
)
9397 __GLXcontext
*const gc
= __glXGetCurrentContext();
9398 const GLuint cmdlen
= 16;
9399 emit_header(gc
->pc
, X_GLrop_VertexAttrib2fvNV
, cmdlen
);
9400 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&index
), 4);
9401 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (v
), 8);
9403 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
9404 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
9408 #define X_GLrop_VertexAttrib2svNV 4266
9410 __indirect_glVertexAttrib2sNV(GLuint index
, GLshort x
, GLshort y
)
9412 __GLXcontext
*const gc
= __glXGetCurrentContext();
9413 const GLuint cmdlen
= 12;
9414 emit_header(gc
->pc
, X_GLrop_VertexAttrib2svNV
, cmdlen
);
9415 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&index
), 4);
9416 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&x
), 2);
9417 (void) memcpy((void *) (gc
->pc
+ 10), (void *) (&y
), 2);
9419 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
9420 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
9424 #define X_GLrop_VertexAttrib2svNV 4266
9426 __indirect_glVertexAttrib2svNV(GLuint index
, const GLshort
* v
)
9428 __GLXcontext
*const gc
= __glXGetCurrentContext();
9429 const GLuint cmdlen
= 12;
9430 emit_header(gc
->pc
, X_GLrop_VertexAttrib2svNV
, cmdlen
);
9431 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&index
), 4);
9432 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (v
), 4);
9434 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
9435 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
9439 #define X_GLrop_VertexAttrib3dvNV 4275
9441 __indirect_glVertexAttrib3dNV(GLuint index
, GLdouble x
, GLdouble y
,
9444 __GLXcontext
*const gc
= __glXGetCurrentContext();
9445 const GLuint cmdlen
= 32;
9446 emit_header(gc
->pc
, X_GLrop_VertexAttrib3dvNV
, cmdlen
);
9447 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&index
), 4);
9448 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&x
), 8);
9449 (void) memcpy((void *) (gc
->pc
+ 16), (void *) (&y
), 8);
9450 (void) memcpy((void *) (gc
->pc
+ 24), (void *) (&z
), 8);
9452 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
9453 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
9457 #define X_GLrop_VertexAttrib3dvNV 4275
9459 __indirect_glVertexAttrib3dvNV(GLuint index
, const GLdouble
* v
)
9461 __GLXcontext
*const gc
= __glXGetCurrentContext();
9462 const GLuint cmdlen
= 32;
9463 emit_header(gc
->pc
, X_GLrop_VertexAttrib3dvNV
, cmdlen
);
9464 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&index
), 4);
9465 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (v
), 24);
9467 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
9468 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
9472 #define X_GLrop_VertexAttrib3fvNV 4271
9474 __indirect_glVertexAttrib3fNV(GLuint index
, GLfloat x
, GLfloat y
, GLfloat z
)
9476 __GLXcontext
*const gc
= __glXGetCurrentContext();
9477 const GLuint cmdlen
= 20;
9478 emit_header(gc
->pc
, X_GLrop_VertexAttrib3fvNV
, cmdlen
);
9479 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&index
), 4);
9480 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&x
), 4);
9481 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&y
), 4);
9482 (void) memcpy((void *) (gc
->pc
+ 16), (void *) (&z
), 4);
9484 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
9485 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
9489 #define X_GLrop_VertexAttrib3fvNV 4271
9491 __indirect_glVertexAttrib3fvNV(GLuint index
, const GLfloat
* v
)
9493 __GLXcontext
*const gc
= __glXGetCurrentContext();
9494 const GLuint cmdlen
= 20;
9495 emit_header(gc
->pc
, X_GLrop_VertexAttrib3fvNV
, cmdlen
);
9496 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&index
), 4);
9497 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (v
), 12);
9499 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
9500 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
9504 #define X_GLrop_VertexAttrib3svNV 4267
9506 __indirect_glVertexAttrib3sNV(GLuint index
, GLshort x
, GLshort y
, GLshort z
)
9508 __GLXcontext
*const gc
= __glXGetCurrentContext();
9509 const GLuint cmdlen
= 16;
9510 emit_header(gc
->pc
, X_GLrop_VertexAttrib3svNV
, cmdlen
);
9511 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&index
), 4);
9512 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&x
), 2);
9513 (void) memcpy((void *) (gc
->pc
+ 10), (void *) (&y
), 2);
9514 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&z
), 2);
9516 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
9517 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
9521 #define X_GLrop_VertexAttrib3svNV 4267
9523 __indirect_glVertexAttrib3svNV(GLuint index
, const GLshort
* v
)
9525 __GLXcontext
*const gc
= __glXGetCurrentContext();
9526 const GLuint cmdlen
= 16;
9527 emit_header(gc
->pc
, X_GLrop_VertexAttrib3svNV
, cmdlen
);
9528 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&index
), 4);
9529 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (v
), 6);
9531 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
9532 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
9536 #define X_GLrop_VertexAttrib4dvNV 4276
9538 __indirect_glVertexAttrib4dNV(GLuint index
, GLdouble x
, GLdouble y
,
9539 GLdouble z
, GLdouble w
)
9541 __GLXcontext
*const gc
= __glXGetCurrentContext();
9542 const GLuint cmdlen
= 40;
9543 emit_header(gc
->pc
, X_GLrop_VertexAttrib4dvNV
, cmdlen
);
9544 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&index
), 4);
9545 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&x
), 8);
9546 (void) memcpy((void *) (gc
->pc
+ 16), (void *) (&y
), 8);
9547 (void) memcpy((void *) (gc
->pc
+ 24), (void *) (&z
), 8);
9548 (void) memcpy((void *) (gc
->pc
+ 32), (void *) (&w
), 8);
9550 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
9551 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
9555 #define X_GLrop_VertexAttrib4dvNV 4276
9557 __indirect_glVertexAttrib4dvNV(GLuint index
, const GLdouble
* v
)
9559 __GLXcontext
*const gc
= __glXGetCurrentContext();
9560 const GLuint cmdlen
= 40;
9561 emit_header(gc
->pc
, X_GLrop_VertexAttrib4dvNV
, cmdlen
);
9562 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&index
), 4);
9563 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (v
), 32);
9565 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
9566 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
9570 #define X_GLrop_VertexAttrib4fvNV 4272
9572 __indirect_glVertexAttrib4fNV(GLuint index
, GLfloat x
, GLfloat y
, GLfloat z
,
9575 __GLXcontext
*const gc
= __glXGetCurrentContext();
9576 const GLuint cmdlen
= 24;
9577 emit_header(gc
->pc
, X_GLrop_VertexAttrib4fvNV
, cmdlen
);
9578 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&index
), 4);
9579 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&x
), 4);
9580 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&y
), 4);
9581 (void) memcpy((void *) (gc
->pc
+ 16), (void *) (&z
), 4);
9582 (void) memcpy((void *) (gc
->pc
+ 20), (void *) (&w
), 4);
9584 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
9585 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
9589 #define X_GLrop_VertexAttrib4fvNV 4272
9591 __indirect_glVertexAttrib4fvNV(GLuint index
, const GLfloat
* v
)
9593 __GLXcontext
*const gc
= __glXGetCurrentContext();
9594 const GLuint cmdlen
= 24;
9595 emit_header(gc
->pc
, X_GLrop_VertexAttrib4fvNV
, cmdlen
);
9596 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&index
), 4);
9597 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (v
), 16);
9599 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
9600 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
9604 #define X_GLrop_VertexAttrib4svNV 4268
9606 __indirect_glVertexAttrib4sNV(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_VertexAttrib4svNV
, 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);
9616 (void) memcpy((void *) (gc
->pc
+ 14), (void *) (&w
), 2);
9618 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
9619 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
9623 #define X_GLrop_VertexAttrib4svNV 4268
9625 __indirect_glVertexAttrib4svNV(GLuint index
, const GLshort
* v
)
9627 __GLXcontext
*const gc
= __glXGetCurrentContext();
9628 const GLuint cmdlen
= 16;
9629 emit_header(gc
->pc
, X_GLrop_VertexAttrib4svNV
, cmdlen
);
9630 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&index
), 4);
9631 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (v
), 8);
9633 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
9634 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
9638 #define X_GLrop_VertexAttrib4ubvNV 4277
9640 __indirect_glVertexAttrib4ubNV(GLuint index
, GLubyte x
, GLubyte y
, GLubyte z
,
9643 __GLXcontext
*const gc
= __glXGetCurrentContext();
9644 const GLuint cmdlen
= 12;
9645 emit_header(gc
->pc
, X_GLrop_VertexAttrib4ubvNV
, cmdlen
);
9646 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&index
), 4);
9647 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&x
), 1);
9648 (void) memcpy((void *) (gc
->pc
+ 9), (void *) (&y
), 1);
9649 (void) memcpy((void *) (gc
->pc
+ 10), (void *) (&z
), 1);
9650 (void) memcpy((void *) (gc
->pc
+ 11), (void *) (&w
), 1);
9652 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
9653 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
9657 #define X_GLrop_VertexAttrib4ubvNV 4277
9659 __indirect_glVertexAttrib4ubvNV(GLuint index
, const GLubyte
* v
)
9661 __GLXcontext
*const gc
= __glXGetCurrentContext();
9662 const GLuint cmdlen
= 12;
9663 emit_header(gc
->pc
, X_GLrop_VertexAttrib4ubvNV
, cmdlen
);
9664 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&index
), 4);
9665 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (v
), 4);
9667 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
9668 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
9672 #define X_GLrop_VertexAttribs1dvNV 4210
9674 __indirect_glVertexAttribs1dvNV(GLuint index
, GLsizei n
, const GLdouble
* v
)
9676 __GLXcontext
*const gc
= __glXGetCurrentContext();
9677 const GLuint cmdlen
= 12 + __GLX_PAD((n
* 8));
9678 if (__builtin_expect(n
>= 0, 1)) {
9679 emit_header(gc
->pc
, X_GLrop_VertexAttribs1dvNV
, cmdlen
);
9680 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&index
), 4);
9681 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&n
), 4);
9682 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (v
), (n
* 8));
9684 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
9685 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
9690 #define X_GLrop_VertexAttribs1fvNV 4206
9692 __indirect_glVertexAttribs1fvNV(GLuint index
, GLsizei n
, const GLfloat
* v
)
9694 __GLXcontext
*const gc
= __glXGetCurrentContext();
9695 const GLuint cmdlen
= 12 + __GLX_PAD((n
* 4));
9696 if (__builtin_expect(n
>= 0, 1)) {
9697 emit_header(gc
->pc
, X_GLrop_VertexAttribs1fvNV
, cmdlen
);
9698 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&index
), 4);
9699 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&n
), 4);
9700 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (v
), (n
* 4));
9702 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
9703 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
9708 #define X_GLrop_VertexAttribs1svNV 4202
9710 __indirect_glVertexAttribs1svNV(GLuint index
, GLsizei n
, const GLshort
* v
)
9712 __GLXcontext
*const gc
= __glXGetCurrentContext();
9713 const GLuint cmdlen
= 12 + __GLX_PAD((n
* 2));
9714 if (__builtin_expect(n
>= 0, 1)) {
9715 emit_header(gc
->pc
, X_GLrop_VertexAttribs1svNV
, cmdlen
);
9716 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&index
), 4);
9717 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&n
), 4);
9718 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (v
), (n
* 2));
9720 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
9721 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
9726 #define X_GLrop_VertexAttribs2dvNV 4211
9728 __indirect_glVertexAttribs2dvNV(GLuint index
, GLsizei n
, const GLdouble
* v
)
9730 __GLXcontext
*const gc
= __glXGetCurrentContext();
9731 const GLuint cmdlen
= 12 + __GLX_PAD((n
* 16));
9732 if (__builtin_expect(n
>= 0, 1)) {
9733 emit_header(gc
->pc
, X_GLrop_VertexAttribs2dvNV
, cmdlen
);
9734 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&index
), 4);
9735 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&n
), 4);
9736 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (v
), (n
* 16));
9738 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
9739 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
9744 #define X_GLrop_VertexAttribs2fvNV 4207
9746 __indirect_glVertexAttribs2fvNV(GLuint index
, GLsizei n
, const GLfloat
* v
)
9748 __GLXcontext
*const gc
= __glXGetCurrentContext();
9749 const GLuint cmdlen
= 12 + __GLX_PAD((n
* 8));
9750 if (__builtin_expect(n
>= 0, 1)) {
9751 emit_header(gc
->pc
, X_GLrop_VertexAttribs2fvNV
, cmdlen
);
9752 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&index
), 4);
9753 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&n
), 4);
9754 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (v
), (n
* 8));
9756 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
9757 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
9762 #define X_GLrop_VertexAttribs2svNV 4203
9764 __indirect_glVertexAttribs2svNV(GLuint index
, GLsizei n
, const GLshort
* v
)
9766 __GLXcontext
*const gc
= __glXGetCurrentContext();
9767 const GLuint cmdlen
= 12 + __GLX_PAD((n
* 4));
9768 if (__builtin_expect(n
>= 0, 1)) {
9769 emit_header(gc
->pc
, X_GLrop_VertexAttribs2svNV
, cmdlen
);
9770 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&index
), 4);
9771 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&n
), 4);
9772 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (v
), (n
* 4));
9774 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
9775 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
9780 #define X_GLrop_VertexAttribs3dvNV 4212
9782 __indirect_glVertexAttribs3dvNV(GLuint index
, GLsizei n
, const GLdouble
* v
)
9784 __GLXcontext
*const gc
= __glXGetCurrentContext();
9785 const GLuint cmdlen
= 12 + __GLX_PAD((n
* 24));
9786 if (__builtin_expect(n
>= 0, 1)) {
9787 emit_header(gc
->pc
, X_GLrop_VertexAttribs3dvNV
, cmdlen
);
9788 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&index
), 4);
9789 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&n
), 4);
9790 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (v
), (n
* 24));
9792 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
9793 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
9798 #define X_GLrop_VertexAttribs3fvNV 4208
9800 __indirect_glVertexAttribs3fvNV(GLuint index
, GLsizei n
, const GLfloat
* v
)
9802 __GLXcontext
*const gc
= __glXGetCurrentContext();
9803 const GLuint cmdlen
= 12 + __GLX_PAD((n
* 12));
9804 if (__builtin_expect(n
>= 0, 1)) {
9805 emit_header(gc
->pc
, X_GLrop_VertexAttribs3fvNV
, cmdlen
);
9806 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&index
), 4);
9807 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&n
), 4);
9808 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (v
), (n
* 12));
9810 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
9811 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
9816 #define X_GLrop_VertexAttribs3svNV 4204
9818 __indirect_glVertexAttribs3svNV(GLuint index
, GLsizei n
, const GLshort
* v
)
9820 __GLXcontext
*const gc
= __glXGetCurrentContext();
9821 const GLuint cmdlen
= 12 + __GLX_PAD((n
* 6));
9822 if (__builtin_expect(n
>= 0, 1)) {
9823 emit_header(gc
->pc
, X_GLrop_VertexAttribs3svNV
, cmdlen
);
9824 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&index
), 4);
9825 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&n
), 4);
9826 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (v
), (n
* 6));
9828 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
9829 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
9834 #define X_GLrop_VertexAttribs4dvNV 4213
9836 __indirect_glVertexAttribs4dvNV(GLuint index
, GLsizei n
, const GLdouble
* v
)
9838 __GLXcontext
*const gc
= __glXGetCurrentContext();
9839 const GLuint cmdlen
= 12 + __GLX_PAD((n
* 32));
9840 if (__builtin_expect(n
>= 0, 1)) {
9841 emit_header(gc
->pc
, X_GLrop_VertexAttribs4dvNV
, cmdlen
);
9842 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&index
), 4);
9843 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&n
), 4);
9844 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (v
), (n
* 32));
9846 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
9847 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
9852 #define X_GLrop_VertexAttribs4fvNV 4209
9854 __indirect_glVertexAttribs4fvNV(GLuint index
, GLsizei n
, const GLfloat
* v
)
9856 __GLXcontext
*const gc
= __glXGetCurrentContext();
9857 const GLuint cmdlen
= 12 + __GLX_PAD((n
* 16));
9858 if (__builtin_expect(n
>= 0, 1)) {
9859 emit_header(gc
->pc
, X_GLrop_VertexAttribs4fvNV
, cmdlen
);
9860 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&index
), 4);
9861 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&n
), 4);
9862 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (v
), (n
* 16));
9864 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
9865 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
9870 #define X_GLrop_VertexAttribs4svNV 4205
9872 __indirect_glVertexAttribs4svNV(GLuint index
, GLsizei n
, const GLshort
* v
)
9874 __GLXcontext
*const gc
= __glXGetCurrentContext();
9875 const GLuint cmdlen
= 12 + __GLX_PAD((n
* 8));
9876 if (__builtin_expect(n
>= 0, 1)) {
9877 emit_header(gc
->pc
, X_GLrop_VertexAttribs4svNV
, cmdlen
);
9878 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&index
), 4);
9879 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&n
), 4);
9880 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (v
), (n
* 8));
9882 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
9883 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
9888 #define X_GLrop_VertexAttribs4ubvNV 4214
9890 __indirect_glVertexAttribs4ubvNV(GLuint index
, GLsizei n
, const GLubyte
* v
)
9892 __GLXcontext
*const gc
= __glXGetCurrentContext();
9893 const GLuint cmdlen
= 12 + __GLX_PAD((n
* 4));
9894 if (__builtin_expect(n
>= 0, 1)) {
9895 emit_header(gc
->pc
, X_GLrop_VertexAttribs4ubvNV
, cmdlen
);
9896 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&index
), 4);
9897 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&n
), 4);
9898 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (v
), (n
* 4));
9900 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
9901 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
9906 #define X_GLrop_PointParameteriNV 4221
9908 __indirect_glPointParameteriNV(GLenum pname
, GLint param
)
9910 __GLXcontext
*const gc
= __glXGetCurrentContext();
9911 const GLuint cmdlen
= 12;
9912 emit_header(gc
->pc
, X_GLrop_PointParameteriNV
, cmdlen
);
9913 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&pname
), 4);
9914 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (¶m
), 4);
9916 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
9917 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
9921 #define X_GLrop_PointParameterivNV 4222
9923 __indirect_glPointParameterivNV(GLenum pname
, const GLint
* params
)
9925 __GLXcontext
*const gc
= __glXGetCurrentContext();
9926 const GLuint compsize
= __glPointParameterivNV_size(pname
);
9927 const GLuint cmdlen
= 8 + __GLX_PAD((compsize
* 4));
9928 emit_header(gc
->pc
, X_GLrop_PointParameterivNV
, cmdlen
);
9929 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&pname
), 4);
9930 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (params
), (compsize
* 4));
9932 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
9933 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
9937 #define X_GLrop_ActiveStencilFaceEXT 4220
9939 __indirect_glActiveStencilFaceEXT(GLenum face
)
9941 __GLXcontext
*const gc
= __glXGetCurrentContext();
9942 const GLuint cmdlen
= 8;
9943 emit_header(gc
->pc
, X_GLrop_ActiveStencilFaceEXT
, cmdlen
);
9944 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&face
), 4);
9946 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
9947 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
9951 #define X_GLvop_GetProgramNamedParameterdvNV 1311
9953 __indirect_glGetProgramNamedParameterdvNV(GLuint id
, GLsizei len
,
9954 const GLubyte
* name
,
9957 __GLXcontext
*const gc
= __glXGetCurrentContext();
9958 Display
*const dpy
= gc
->currentDpy
;
9959 const GLuint cmdlen
= 8 + __GLX_PAD(len
);
9960 if (__builtin_expect((len
>= 0) && (dpy
!= NULL
), 1)) {
9962 __glXSetupVendorRequest(gc
, X_GLXVendorPrivateWithReply
,
9963 X_GLvop_GetProgramNamedParameterdvNV
,
9965 (void) memcpy((void *) (pc
+ 0), (void *) (&id
), 4);
9966 (void) memcpy((void *) (pc
+ 4), (void *) (&len
), 4);
9967 (void) memcpy((void *) (pc
+ 8), (void *) (name
), len
);
9968 (void) __glXReadReply(dpy
, 8, params
, GL_TRUE
);
9975 #define X_GLvop_GetProgramNamedParameterfvNV 1310
9977 __indirect_glGetProgramNamedParameterfvNV(GLuint id
, GLsizei len
,
9978 const GLubyte
* name
,
9981 __GLXcontext
*const gc
= __glXGetCurrentContext();
9982 Display
*const dpy
= gc
->currentDpy
;
9983 const GLuint cmdlen
= 8 + __GLX_PAD(len
);
9984 if (__builtin_expect((len
>= 0) && (dpy
!= NULL
), 1)) {
9986 __glXSetupVendorRequest(gc
, X_GLXVendorPrivateWithReply
,
9987 X_GLvop_GetProgramNamedParameterfvNV
,
9989 (void) memcpy((void *) (pc
+ 0), (void *) (&id
), 4);
9990 (void) memcpy((void *) (pc
+ 4), (void *) (&len
), 4);
9991 (void) memcpy((void *) (pc
+ 8), (void *) (name
), len
);
9992 (void) __glXReadReply(dpy
, 4, params
, GL_TRUE
);
9999 #define X_GLrop_ProgramNamedParameter4dvNV 4219
10001 __indirect_glProgramNamedParameter4dNV(GLuint id
, GLsizei len
,
10002 const GLubyte
* name
, GLdouble x
,
10003 GLdouble y
, GLdouble z
, GLdouble w
)
10005 __GLXcontext
*const gc
= __glXGetCurrentContext();
10006 const GLuint cmdlen
= 44 + __GLX_PAD(len
);
10007 if (__builtin_expect(len
>= 0, 1)) {
10008 emit_header(gc
->pc
, X_GLrop_ProgramNamedParameter4dvNV
, cmdlen
);
10009 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&x
), 8);
10010 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&y
), 8);
10011 (void) memcpy((void *) (gc
->pc
+ 20), (void *) (&z
), 8);
10012 (void) memcpy((void *) (gc
->pc
+ 28), (void *) (&w
), 8);
10013 (void) memcpy((void *) (gc
->pc
+ 36), (void *) (&id
), 4);
10014 (void) memcpy((void *) (gc
->pc
+ 40), (void *) (&len
), 4);
10015 (void) memcpy((void *) (gc
->pc
+ 44), (void *) (name
), len
);
10017 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
10018 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
10023 #define X_GLrop_ProgramNamedParameter4dvNV 4219
10025 __indirect_glProgramNamedParameter4dvNV(GLuint id
, GLsizei len
,
10026 const GLubyte
* name
,
10027 const GLdouble
* v
)
10029 __GLXcontext
*const gc
= __glXGetCurrentContext();
10030 const GLuint cmdlen
= 44 + __GLX_PAD(len
);
10031 if (__builtin_expect(len
>= 0, 1)) {
10032 emit_header(gc
->pc
, X_GLrop_ProgramNamedParameter4dvNV
, cmdlen
);
10033 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (v
), 32);
10034 (void) memcpy((void *) (gc
->pc
+ 36), (void *) (&id
), 4);
10035 (void) memcpy((void *) (gc
->pc
+ 40), (void *) (&len
), 4);
10036 (void) memcpy((void *) (gc
->pc
+ 44), (void *) (name
), len
);
10038 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
10039 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
10044 #define X_GLrop_ProgramNamedParameter4fvNV 4218
10046 __indirect_glProgramNamedParameter4fNV(GLuint id
, GLsizei len
,
10047 const GLubyte
* name
, GLfloat x
,
10048 GLfloat y
, GLfloat z
, GLfloat w
)
10050 __GLXcontext
*const gc
= __glXGetCurrentContext();
10051 const GLuint cmdlen
= 28 + __GLX_PAD(len
);
10052 if (__builtin_expect(len
>= 0, 1)) {
10053 emit_header(gc
->pc
, X_GLrop_ProgramNamedParameter4fvNV
, cmdlen
);
10054 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&id
), 4);
10055 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&len
), 4);
10056 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&x
), 4);
10057 (void) memcpy((void *) (gc
->pc
+ 16), (void *) (&y
), 4);
10058 (void) memcpy((void *) (gc
->pc
+ 20), (void *) (&z
), 4);
10059 (void) memcpy((void *) (gc
->pc
+ 24), (void *) (&w
), 4);
10060 (void) memcpy((void *) (gc
->pc
+ 28), (void *) (name
), len
);
10062 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
10063 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
10068 #define X_GLrop_ProgramNamedParameter4fvNV 4218
10070 __indirect_glProgramNamedParameter4fvNV(GLuint id
, GLsizei len
,
10071 const GLubyte
* name
,
10074 __GLXcontext
*const gc
= __glXGetCurrentContext();
10075 const GLuint cmdlen
= 28 + __GLX_PAD(len
);
10076 if (__builtin_expect(len
>= 0, 1)) {
10077 emit_header(gc
->pc
, X_GLrop_ProgramNamedParameter4fvNV
, cmdlen
);
10078 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&id
), 4);
10079 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&len
), 4);
10080 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (v
), 16);
10081 (void) memcpy((void *) (gc
->pc
+ 28), (void *) (name
), len
);
10083 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
10084 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
10089 #define X_GLrop_BlendEquationSeparateEXT 4228
10091 __indirect_glBlendEquationSeparateEXT(GLenum modeRGB
, GLenum modeA
)
10093 __GLXcontext
*const gc
= __glXGetCurrentContext();
10094 const GLuint cmdlen
= 12;
10095 emit_header(gc
->pc
, X_GLrop_BlendEquationSeparateEXT
, cmdlen
);
10096 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&modeRGB
), 4);
10097 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&modeA
), 4);
10099 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
10100 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
10104 #define X_GLrop_BindFramebufferEXT 4319
10106 __indirect_glBindFramebufferEXT(GLenum target
, GLuint framebuffer
)
10108 __GLXcontext
*const gc
= __glXGetCurrentContext();
10109 const GLuint cmdlen
= 12;
10110 emit_header(gc
->pc
, X_GLrop_BindFramebufferEXT
, cmdlen
);
10111 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&target
), 4);
10112 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&framebuffer
), 4);
10114 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
10115 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
10119 #define X_GLrop_BindRenderbufferEXT 4316
10121 __indirect_glBindRenderbufferEXT(GLenum target
, GLuint renderbuffer
)
10123 __GLXcontext
*const gc
= __glXGetCurrentContext();
10124 const GLuint cmdlen
= 12;
10125 emit_header(gc
->pc
, X_GLrop_BindRenderbufferEXT
, cmdlen
);
10126 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&target
), 4);
10127 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&renderbuffer
), 4);
10129 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
10130 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
10134 #define X_GLvop_CheckFramebufferStatusEXT 1427
10136 __indirect_glCheckFramebufferStatusEXT(GLenum target
)
10138 __GLXcontext
*const gc
= __glXGetCurrentContext();
10139 Display
*const dpy
= gc
->currentDpy
;
10140 GLenum retval
= (GLenum
) 0;
10141 const GLuint cmdlen
= 4;
10142 if (__builtin_expect(dpy
!= NULL
, 1)) {
10143 GLubyte
const *pc
=
10144 __glXSetupVendorRequest(gc
, X_GLXVendorPrivateWithReply
,
10145 X_GLvop_CheckFramebufferStatusEXT
,
10147 (void) memcpy((void *) (pc
+ 0), (void *) (&target
), 4);
10148 retval
= (GLenum
) __glXReadReply(dpy
, 0, NULL
, GL_FALSE
);
10149 UnlockDisplay(dpy
);
10155 #define X_GLrop_DeleteFramebuffersEXT 4320
10157 __indirect_glDeleteFramebuffersEXT(GLsizei n
, const GLuint
* framebuffers
)
10159 __GLXcontext
*const gc
= __glXGetCurrentContext();
10160 const GLuint cmdlen
= 8 + __GLX_PAD((n
* 4));
10161 if (__builtin_expect(n
>= 0, 1)) {
10162 emit_header(gc
->pc
, X_GLrop_DeleteFramebuffersEXT
, cmdlen
);
10163 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&n
), 4);
10164 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (framebuffers
),
10167 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
10168 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
10173 #define X_GLrop_DeleteRenderbuffersEXT 4317
10175 __indirect_glDeleteRenderbuffersEXT(GLsizei n
, const GLuint
* renderbuffers
)
10177 __GLXcontext
*const gc
= __glXGetCurrentContext();
10178 const GLuint cmdlen
= 8 + __GLX_PAD((n
* 4));
10179 if (__builtin_expect(n
>= 0, 1)) {
10180 emit_header(gc
->pc
, X_GLrop_DeleteRenderbuffersEXT
, cmdlen
);
10181 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&n
), 4);
10182 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (renderbuffers
),
10185 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
10186 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
10191 #define X_GLrop_FramebufferRenderbufferEXT 4324
10193 __indirect_glFramebufferRenderbufferEXT(GLenum target
, GLenum attachment
,
10194 GLenum renderbuffertarget
,
10195 GLuint renderbuffer
)
10197 __GLXcontext
*const gc
= __glXGetCurrentContext();
10198 const GLuint cmdlen
= 20;
10199 emit_header(gc
->pc
, X_GLrop_FramebufferRenderbufferEXT
, cmdlen
);
10200 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&target
), 4);
10201 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&attachment
), 4);
10202 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&renderbuffertarget
), 4);
10203 (void) memcpy((void *) (gc
->pc
+ 16), (void *) (&renderbuffer
), 4);
10205 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
10206 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
10210 #define X_GLrop_FramebufferTexture1DEXT 4321
10212 __indirect_glFramebufferTexture1DEXT(GLenum target
, GLenum attachment
,
10213 GLenum textarget
, GLuint texture
,
10216 __GLXcontext
*const gc
= __glXGetCurrentContext();
10217 const GLuint cmdlen
= 24;
10218 emit_header(gc
->pc
, X_GLrop_FramebufferTexture1DEXT
, cmdlen
);
10219 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&target
), 4);
10220 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&attachment
), 4);
10221 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&textarget
), 4);
10222 (void) memcpy((void *) (gc
->pc
+ 16), (void *) (&texture
), 4);
10223 (void) memcpy((void *) (gc
->pc
+ 20), (void *) (&level
), 4);
10225 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
10226 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
10230 #define X_GLrop_FramebufferTexture2DEXT 4322
10232 __indirect_glFramebufferTexture2DEXT(GLenum target
, GLenum attachment
,
10233 GLenum textarget
, GLuint texture
,
10236 __GLXcontext
*const gc
= __glXGetCurrentContext();
10237 const GLuint cmdlen
= 24;
10238 emit_header(gc
->pc
, X_GLrop_FramebufferTexture2DEXT
, cmdlen
);
10239 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&target
), 4);
10240 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&attachment
), 4);
10241 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&textarget
), 4);
10242 (void) memcpy((void *) (gc
->pc
+ 16), (void *) (&texture
), 4);
10243 (void) memcpy((void *) (gc
->pc
+ 20), (void *) (&level
), 4);
10245 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
10246 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
10250 #define X_GLrop_FramebufferTexture3DEXT 4323
10252 __indirect_glFramebufferTexture3DEXT(GLenum target
, GLenum attachment
,
10253 GLenum textarget
, GLuint texture
,
10254 GLint level
, GLint zoffset
)
10256 __GLXcontext
*const gc
= __glXGetCurrentContext();
10257 const GLuint cmdlen
= 28;
10258 emit_header(gc
->pc
, X_GLrop_FramebufferTexture3DEXT
, cmdlen
);
10259 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&target
), 4);
10260 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&attachment
), 4);
10261 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&textarget
), 4);
10262 (void) memcpy((void *) (gc
->pc
+ 16), (void *) (&texture
), 4);
10263 (void) memcpy((void *) (gc
->pc
+ 20), (void *) (&level
), 4);
10264 (void) memcpy((void *) (gc
->pc
+ 24), (void *) (&zoffset
), 4);
10266 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
10267 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
10271 #define X_GLvop_GenFramebuffersEXT 1426
10273 __indirect_glGenFramebuffersEXT(GLsizei n
, GLuint
* framebuffers
)
10275 __GLXcontext
*const gc
= __glXGetCurrentContext();
10276 Display
*const dpy
= gc
->currentDpy
;
10277 const GLuint cmdlen
= 4;
10278 if (__builtin_expect((n
>= 0) && (dpy
!= NULL
), 1)) {
10279 GLubyte
const *pc
=
10280 __glXSetupVendorRequest(gc
, X_GLXVendorPrivateWithReply
,
10281 X_GLvop_GenFramebuffersEXT
, cmdlen
);
10282 (void) memcpy((void *) (pc
+ 0), (void *) (&n
), 4);
10283 (void) __glXReadReply(dpy
, 4, framebuffers
, GL_TRUE
);
10284 UnlockDisplay(dpy
);
10290 #define X_GLvop_GenRenderbuffersEXT 1423
10292 __indirect_glGenRenderbuffersEXT(GLsizei n
, GLuint
* renderbuffers
)
10294 __GLXcontext
*const gc
= __glXGetCurrentContext();
10295 Display
*const dpy
= gc
->currentDpy
;
10296 const GLuint cmdlen
= 4;
10297 if (__builtin_expect((n
>= 0) && (dpy
!= NULL
), 1)) {
10298 GLubyte
const *pc
=
10299 __glXSetupVendorRequest(gc
, X_GLXVendorPrivateWithReply
,
10300 X_GLvop_GenRenderbuffersEXT
, cmdlen
);
10301 (void) memcpy((void *) (pc
+ 0), (void *) (&n
), 4);
10302 (void) __glXReadReply(dpy
, 4, renderbuffers
, GL_TRUE
);
10303 UnlockDisplay(dpy
);
10309 #define X_GLrop_GenerateMipmapEXT 4325
10311 __indirect_glGenerateMipmapEXT(GLenum target
)
10313 __GLXcontext
*const gc
= __glXGetCurrentContext();
10314 const GLuint cmdlen
= 8;
10315 emit_header(gc
->pc
, X_GLrop_GenerateMipmapEXT
, cmdlen
);
10316 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&target
), 4);
10318 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
10319 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
10323 #define X_GLvop_GetFramebufferAttachmentParameterivEXT 1428
10325 __indirect_glGetFramebufferAttachmentParameterivEXT(GLenum target
,
10330 __GLXcontext
*const gc
= __glXGetCurrentContext();
10331 Display
*const dpy
= gc
->currentDpy
;
10332 const GLuint cmdlen
= 12;
10333 if (__builtin_expect(dpy
!= NULL
, 1)) {
10334 GLubyte
const *pc
=
10335 __glXSetupVendorRequest(gc
, X_GLXVendorPrivateWithReply
,
10336 X_GLvop_GetFramebufferAttachmentParameterivEXT
,
10338 (void) memcpy((void *) (pc
+ 0), (void *) (&target
), 4);
10339 (void) memcpy((void *) (pc
+ 4), (void *) (&attachment
), 4);
10340 (void) memcpy((void *) (pc
+ 8), (void *) (&pname
), 4);
10341 (void) __glXReadReply(dpy
, 4, params
, GL_FALSE
);
10342 UnlockDisplay(dpy
);
10348 #define X_GLvop_GetRenderbufferParameterivEXT 1424
10350 __indirect_glGetRenderbufferParameterivEXT(GLenum target
, GLenum pname
,
10353 __GLXcontext
*const gc
= __glXGetCurrentContext();
10354 Display
*const dpy
= gc
->currentDpy
;
10355 const GLuint cmdlen
= 8;
10356 if (__builtin_expect(dpy
!= NULL
, 1)) {
10357 GLubyte
const *pc
=
10358 __glXSetupVendorRequest(gc
, X_GLXVendorPrivateWithReply
,
10359 X_GLvop_GetRenderbufferParameterivEXT
,
10361 (void) memcpy((void *) (pc
+ 0), (void *) (&target
), 4);
10362 (void) memcpy((void *) (pc
+ 4), (void *) (&pname
), 4);
10363 (void) __glXReadReply(dpy
, 4, params
, GL_FALSE
);
10364 UnlockDisplay(dpy
);
10370 #define X_GLvop_IsFramebufferEXT 1425
10372 __indirect_glIsFramebufferEXT(GLuint framebuffer
)
10374 __GLXcontext
*const gc
= __glXGetCurrentContext();
10375 Display
*const dpy
= gc
->currentDpy
;
10376 GLboolean retval
= (GLboolean
) 0;
10377 const GLuint cmdlen
= 4;
10378 if (__builtin_expect(dpy
!= NULL
, 1)) {
10379 GLubyte
const *pc
=
10380 __glXSetupVendorRequest(gc
, X_GLXVendorPrivateWithReply
,
10381 X_GLvop_IsFramebufferEXT
, cmdlen
);
10382 (void) memcpy((void *) (pc
+ 0), (void *) (&framebuffer
), 4);
10383 retval
= (GLboolean
) __glXReadReply(dpy
, 0, NULL
, GL_FALSE
);
10384 UnlockDisplay(dpy
);
10390 #define X_GLvop_IsRenderbufferEXT 1422
10392 __indirect_glIsRenderbufferEXT(GLuint renderbuffer
)
10394 __GLXcontext
*const gc
= __glXGetCurrentContext();
10395 Display
*const dpy
= gc
->currentDpy
;
10396 GLboolean retval
= (GLboolean
) 0;
10397 const GLuint cmdlen
= 4;
10398 if (__builtin_expect(dpy
!= NULL
, 1)) {
10399 GLubyte
const *pc
=
10400 __glXSetupVendorRequest(gc
, X_GLXVendorPrivateWithReply
,
10401 X_GLvop_IsRenderbufferEXT
, cmdlen
);
10402 (void) memcpy((void *) (pc
+ 0), (void *) (&renderbuffer
), 4);
10403 retval
= (GLboolean
) __glXReadReply(dpy
, 0, NULL
, GL_FALSE
);
10404 UnlockDisplay(dpy
);
10410 #define X_GLrop_RenderbufferStorageEXT 4318
10412 __indirect_glRenderbufferStorageEXT(GLenum target
, GLenum internalformat
,
10413 GLsizei width
, GLsizei height
)
10415 __GLXcontext
*const gc
= __glXGetCurrentContext();
10416 const GLuint cmdlen
= 20;
10417 emit_header(gc
->pc
, X_GLrop_RenderbufferStorageEXT
, cmdlen
);
10418 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&target
), 4);
10419 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&internalformat
), 4);
10420 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&width
), 4);
10421 (void) memcpy((void *) (gc
->pc
+ 16), (void *) (&height
), 4);
10423 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
10424 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);