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
;
304 const GLuint cmdlen
= 8;
306 if (__builtin_expect(dpy
!= NULL
, 1)) {
308 xcb_connection_t
*c
= XGetXCBConnection(dpy
);
309 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
310 xcb_glx_new_list(c
, gc
->currentContextTag
, list
, mode
);
313 __glXSetupSingleRequest(gc
, X_GLsop_NewList
, cmdlen
);
314 (void) memcpy((void *) (pc
+ 0), (void *) (&list
), 4);
315 (void) memcpy((void *) (pc
+ 4), (void *) (&mode
), 4);
323 #define X_GLsop_EndList 102
325 __indirect_glEndList(void)
327 __GLXcontext
*const gc
= __glXGetCurrentContext();
328 Display
*const dpy
= gc
->currentDpy
;
330 const GLuint cmdlen
= 0;
332 if (__builtin_expect(dpy
!= NULL
, 1)) {
334 xcb_connection_t
*c
= XGetXCBConnection(dpy
);
335 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
336 xcb_glx_end_list(c
, gc
->currentContextTag
);
338 (void) __glXSetupSingleRequest(gc
, X_GLsop_EndList
, cmdlen
);
346 #define X_GLrop_CallList 1
348 __indirect_glCallList(GLuint list
)
350 __GLXcontext
*const gc
= __glXGetCurrentContext();
351 const GLuint cmdlen
= 8;
352 emit_header(gc
->pc
, X_GLrop_CallList
, cmdlen
);
353 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&list
), 4);
355 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
356 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
360 #define X_GLrop_CallLists 2
362 __indirect_glCallLists(GLsizei n
, GLenum type
, const GLvoid
* lists
)
364 __GLXcontext
*const gc
= __glXGetCurrentContext();
365 const GLuint compsize
= __glCallLists_size(type
);
366 const GLuint cmdlen
= 12 + __GLX_PAD((compsize
* n
));
368 __glXSetError(gc
, GL_INVALID_VALUE
);
371 if (__builtin_expect((n
>= 0) && (gc
->currentDpy
!= NULL
), 1)) {
372 if (cmdlen
<= gc
->maxSmallRenderCommandSize
) {
373 if ((gc
->pc
+ cmdlen
) > gc
->bufEnd
) {
374 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
376 emit_header(gc
->pc
, X_GLrop_CallLists
, cmdlen
);
377 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&n
), 4);
378 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&type
), 4);
379 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (lists
),
382 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
383 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
386 const GLint op
= X_GLrop_CallLists
;
387 const GLuint cmdlenLarge
= cmdlen
+ 4;
388 GLubyte
*const pc
= __glXFlushRenderBuffer(gc
, gc
->pc
);
389 (void) memcpy((void *) (pc
+ 0), (void *) (&cmdlenLarge
), 4);
390 (void) memcpy((void *) (pc
+ 4), (void *) (&op
), 4);
391 (void) memcpy((void *) (pc
+ 8), (void *) (&n
), 4);
392 (void) memcpy((void *) (pc
+ 12), (void *) (&type
), 4);
393 __glXSendLargeCommand(gc
, pc
, 16, lists
, (compsize
* n
));
398 #define X_GLsop_DeleteLists 103
400 __indirect_glDeleteLists(GLuint list
, GLsizei range
)
402 __GLXcontext
*const gc
= __glXGetCurrentContext();
403 Display
*const dpy
= gc
->currentDpy
;
405 const GLuint cmdlen
= 8;
407 if (__builtin_expect(dpy
!= NULL
, 1)) {
409 xcb_connection_t
*c
= XGetXCBConnection(dpy
);
410 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
411 xcb_glx_delete_lists(c
, gc
->currentContextTag
, list
, range
);
414 __glXSetupSingleRequest(gc
, X_GLsop_DeleteLists
, cmdlen
);
415 (void) memcpy((void *) (pc
+ 0), (void *) (&list
), 4);
416 (void) memcpy((void *) (pc
+ 4), (void *) (&range
), 4);
424 #define X_GLsop_GenLists 104
426 __indirect_glGenLists(GLsizei range
)
428 __GLXcontext
*const gc
= __glXGetCurrentContext();
429 Display
*const dpy
= gc
->currentDpy
;
430 GLuint retval
= (GLuint
) 0;
432 const GLuint cmdlen
= 4;
434 if (__builtin_expect(dpy
!= NULL
, 1)) {
436 xcb_connection_t
*c
= XGetXCBConnection(dpy
);
437 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
438 xcb_glx_gen_lists_reply_t
*reply
=
439 xcb_glx_gen_lists_reply(c
,
441 gc
->currentContextTag
,
443 retval
= reply
->ret_val
;
447 __glXSetupSingleRequest(gc
, X_GLsop_GenLists
, cmdlen
);
448 (void) memcpy((void *) (pc
+ 0), (void *) (&range
), 4);
449 retval
= (GLuint
) __glXReadReply(dpy
, 0, NULL
, GL_FALSE
);
457 #define X_GLrop_ListBase 3
459 __indirect_glListBase(GLuint base
)
461 __GLXcontext
*const gc
= __glXGetCurrentContext();
462 const GLuint cmdlen
= 8;
463 emit_header(gc
->pc
, X_GLrop_ListBase
, cmdlen
);
464 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&base
), 4);
466 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
467 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
471 #define X_GLrop_Begin 4
473 __indirect_glBegin(GLenum mode
)
475 __GLXcontext
*const gc
= __glXGetCurrentContext();
476 const GLuint cmdlen
= 8;
477 emit_header(gc
->pc
, X_GLrop_Begin
, cmdlen
);
478 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&mode
), 4);
480 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
481 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
485 #define X_GLrop_Bitmap 5
487 __indirect_glBitmap(GLsizei width
, GLsizei height
, GLfloat xorig
,
488 GLfloat yorig
, GLfloat xmove
, GLfloat ymove
,
489 const GLubyte
*bitmap
)
491 __GLXcontext
*const gc
= __glXGetCurrentContext();
492 const GLuint compsize
=
493 (bitmap
!= NULL
) ? __glImageSize(width
, height
, 1, GL_COLOR_INDEX
,
495 const GLuint cmdlen
= 48 + __GLX_PAD(compsize
);
496 if (__builtin_expect(gc
->currentDpy
!= NULL
, 1)) {
497 if (cmdlen
<= gc
->maxSmallRenderCommandSize
) {
498 if ((gc
->pc
+ cmdlen
) > gc
->bufEnd
) {
499 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
501 emit_header(gc
->pc
, X_GLrop_Bitmap
, cmdlen
);
502 (void) memcpy((void *) (gc
->pc
+ 24), (void *) (&width
), 4);
503 (void) memcpy((void *) (gc
->pc
+ 28), (void *) (&height
), 4);
504 (void) memcpy((void *) (gc
->pc
+ 32), (void *) (&xorig
), 4);
505 (void) memcpy((void *) (gc
->pc
+ 36), (void *) (&yorig
), 4);
506 (void) memcpy((void *) (gc
->pc
+ 40), (void *) (&xmove
), 4);
507 (void) memcpy((void *) (gc
->pc
+ 44), (void *) (&ymove
), 4);
509 (*gc
->fillImage
) (gc
, 2, width
, height
, 1, GL_COLOR_INDEX
,
510 GL_BITMAP
, bitmap
, gc
->pc
+ 48, gc
->pc
+ 4);
512 (void) memcpy(gc
->pc
+ 4, default_pixel_store_2D
,
513 default_pixel_store_2D_size
);
516 if (gc
->pc
> gc
->limit
) {
517 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
520 const GLint op
= X_GLrop_Bitmap
;
521 const GLuint cmdlenLarge
= cmdlen
+ 4;
522 GLubyte
*const pc
= __glXFlushRenderBuffer(gc
, gc
->pc
);
523 (void) memcpy((void *) (pc
+ 0), (void *) (&cmdlenLarge
), 4);
524 (void) memcpy((void *) (pc
+ 4), (void *) (&op
), 4);
525 (void) memcpy((void *) (pc
+ 28), (void *) (&width
), 4);
526 (void) memcpy((void *) (pc
+ 32), (void *) (&height
), 4);
527 (void) memcpy((void *) (pc
+ 36), (void *) (&xorig
), 4);
528 (void) memcpy((void *) (pc
+ 40), (void *) (&yorig
), 4);
529 (void) memcpy((void *) (pc
+ 44), (void *) (&xmove
), 4);
530 (void) memcpy((void *) (pc
+ 48), (void *) (&ymove
), 4);
531 __glXSendLargeImage(gc
, compsize
, 2, width
, height
, 1,
532 GL_COLOR_INDEX
, GL_BITMAP
, bitmap
, pc
+ 52,
538 #define X_GLrop_Color3bv 6
540 __indirect_glColor3b(GLbyte red
, GLbyte green
, GLbyte blue
)
542 __GLXcontext
*const gc
= __glXGetCurrentContext();
543 const GLuint cmdlen
= 8;
544 emit_header(gc
->pc
, X_GLrop_Color3bv
, cmdlen
);
545 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&red
), 1);
546 (void) memcpy((void *) (gc
->pc
+ 5), (void *) (&green
), 1);
547 (void) memcpy((void *) (gc
->pc
+ 6), (void *) (&blue
), 1);
549 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
550 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
554 #define X_GLrop_Color3bv 6
556 __indirect_glColor3bv(const GLbyte
*v
)
558 generic_3_byte(X_GLrop_Color3bv
, v
);
561 #define X_GLrop_Color3dv 7
563 __indirect_glColor3d(GLdouble red
, GLdouble green
, GLdouble blue
)
565 __GLXcontext
*const gc
= __glXGetCurrentContext();
566 const GLuint cmdlen
= 28;
567 emit_header(gc
->pc
, X_GLrop_Color3dv
, cmdlen
);
568 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&red
), 8);
569 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&green
), 8);
570 (void) memcpy((void *) (gc
->pc
+ 20), (void *) (&blue
), 8);
572 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
573 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
577 #define X_GLrop_Color3dv 7
579 __indirect_glColor3dv(const GLdouble
* v
)
581 generic_24_byte(X_GLrop_Color3dv
, v
);
584 #define X_GLrop_Color3fv 8
586 __indirect_glColor3f(GLfloat red
, GLfloat green
, GLfloat blue
)
588 __GLXcontext
*const gc
= __glXGetCurrentContext();
589 const GLuint cmdlen
= 16;
590 emit_header(gc
->pc
, X_GLrop_Color3fv
, cmdlen
);
591 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&red
), 4);
592 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&green
), 4);
593 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&blue
), 4);
595 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
596 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
600 #define X_GLrop_Color3fv 8
602 __indirect_glColor3fv(const GLfloat
* v
)
604 generic_12_byte(X_GLrop_Color3fv
, v
);
607 #define X_GLrop_Color3iv 9
609 __indirect_glColor3i(GLint red
, GLint green
, GLint blue
)
611 __GLXcontext
*const gc
= __glXGetCurrentContext();
612 const GLuint cmdlen
= 16;
613 emit_header(gc
->pc
, X_GLrop_Color3iv
, cmdlen
);
614 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&red
), 4);
615 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&green
), 4);
616 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&blue
), 4);
618 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
619 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
623 #define X_GLrop_Color3iv 9
625 __indirect_glColor3iv(const GLint
* v
)
627 generic_12_byte(X_GLrop_Color3iv
, v
);
630 #define X_GLrop_Color3sv 10
632 __indirect_glColor3s(GLshort red
, GLshort green
, GLshort blue
)
634 __GLXcontext
*const gc
= __glXGetCurrentContext();
635 const GLuint cmdlen
= 12;
636 emit_header(gc
->pc
, X_GLrop_Color3sv
, cmdlen
);
637 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&red
), 2);
638 (void) memcpy((void *) (gc
->pc
+ 6), (void *) (&green
), 2);
639 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&blue
), 2);
641 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
642 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
646 #define X_GLrop_Color3sv 10
648 __indirect_glColor3sv(const GLshort
* v
)
650 generic_6_byte(X_GLrop_Color3sv
, v
);
653 #define X_GLrop_Color3ubv 11
655 __indirect_glColor3ub(GLubyte red
, GLubyte green
, GLubyte blue
)
657 __GLXcontext
*const gc
= __glXGetCurrentContext();
658 const GLuint cmdlen
= 8;
659 emit_header(gc
->pc
, X_GLrop_Color3ubv
, cmdlen
);
660 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&red
), 1);
661 (void) memcpy((void *) (gc
->pc
+ 5), (void *) (&green
), 1);
662 (void) memcpy((void *) (gc
->pc
+ 6), (void *) (&blue
), 1);
664 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
665 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
669 #define X_GLrop_Color3ubv 11
671 __indirect_glColor3ubv(const GLubyte
*v
)
673 generic_3_byte(X_GLrop_Color3ubv
, v
);
676 #define X_GLrop_Color3uiv 12
678 __indirect_glColor3ui(GLuint red
, GLuint green
, GLuint blue
)
680 __GLXcontext
*const gc
= __glXGetCurrentContext();
681 const GLuint cmdlen
= 16;
682 emit_header(gc
->pc
, X_GLrop_Color3uiv
, cmdlen
);
683 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&red
), 4);
684 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&green
), 4);
685 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&blue
), 4);
687 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
688 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
692 #define X_GLrop_Color3uiv 12
694 __indirect_glColor3uiv(const GLuint
* v
)
696 generic_12_byte(X_GLrop_Color3uiv
, v
);
699 #define X_GLrop_Color3usv 13
701 __indirect_glColor3us(GLushort red
, GLushort green
, GLushort blue
)
703 __GLXcontext
*const gc
= __glXGetCurrentContext();
704 const GLuint cmdlen
= 12;
705 emit_header(gc
->pc
, X_GLrop_Color3usv
, cmdlen
);
706 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&red
), 2);
707 (void) memcpy((void *) (gc
->pc
+ 6), (void *) (&green
), 2);
708 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&blue
), 2);
710 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
711 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
715 #define X_GLrop_Color3usv 13
717 __indirect_glColor3usv(const GLushort
* v
)
719 generic_6_byte(X_GLrop_Color3usv
, v
);
722 #define X_GLrop_Color4bv 14
724 __indirect_glColor4b(GLbyte red
, GLbyte green
, GLbyte blue
, GLbyte alpha
)
726 __GLXcontext
*const gc
= __glXGetCurrentContext();
727 const GLuint cmdlen
= 8;
728 emit_header(gc
->pc
, X_GLrop_Color4bv
, cmdlen
);
729 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&red
), 1);
730 (void) memcpy((void *) (gc
->pc
+ 5), (void *) (&green
), 1);
731 (void) memcpy((void *) (gc
->pc
+ 6), (void *) (&blue
), 1);
732 (void) memcpy((void *) (gc
->pc
+ 7), (void *) (&alpha
), 1);
734 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
735 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
739 #define X_GLrop_Color4bv 14
741 __indirect_glColor4bv(const GLbyte
*v
)
743 generic_4_byte(X_GLrop_Color4bv
, v
);
746 #define X_GLrop_Color4dv 15
748 __indirect_glColor4d(GLdouble red
, GLdouble green
, GLdouble blue
,
751 __GLXcontext
*const gc
= __glXGetCurrentContext();
752 const GLuint cmdlen
= 36;
753 emit_header(gc
->pc
, X_GLrop_Color4dv
, cmdlen
);
754 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&red
), 8);
755 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&green
), 8);
756 (void) memcpy((void *) (gc
->pc
+ 20), (void *) (&blue
), 8);
757 (void) memcpy((void *) (gc
->pc
+ 28), (void *) (&alpha
), 8);
759 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
760 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
764 #define X_GLrop_Color4dv 15
766 __indirect_glColor4dv(const GLdouble
* v
)
768 generic_32_byte(X_GLrop_Color4dv
, v
);
771 #define X_GLrop_Color4fv 16
773 __indirect_glColor4f(GLfloat red
, GLfloat green
, GLfloat blue
, GLfloat alpha
)
775 __GLXcontext
*const gc
= __glXGetCurrentContext();
776 const GLuint cmdlen
= 20;
777 emit_header(gc
->pc
, X_GLrop_Color4fv
, cmdlen
);
778 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&red
), 4);
779 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&green
), 4);
780 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&blue
), 4);
781 (void) memcpy((void *) (gc
->pc
+ 16), (void *) (&alpha
), 4);
783 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
784 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
788 #define X_GLrop_Color4fv 16
790 __indirect_glColor4fv(const GLfloat
* v
)
792 generic_16_byte(X_GLrop_Color4fv
, v
);
795 #define X_GLrop_Color4iv 17
797 __indirect_glColor4i(GLint red
, GLint green
, GLint blue
, GLint alpha
)
799 __GLXcontext
*const gc
= __glXGetCurrentContext();
800 const GLuint cmdlen
= 20;
801 emit_header(gc
->pc
, X_GLrop_Color4iv
, cmdlen
);
802 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&red
), 4);
803 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&green
), 4);
804 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&blue
), 4);
805 (void) memcpy((void *) (gc
->pc
+ 16), (void *) (&alpha
), 4);
807 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
808 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
812 #define X_GLrop_Color4iv 17
814 __indirect_glColor4iv(const GLint
* v
)
816 generic_16_byte(X_GLrop_Color4iv
, v
);
819 #define X_GLrop_Color4sv 18
821 __indirect_glColor4s(GLshort red
, GLshort green
, GLshort blue
, GLshort alpha
)
823 __GLXcontext
*const gc
= __glXGetCurrentContext();
824 const GLuint cmdlen
= 12;
825 emit_header(gc
->pc
, X_GLrop_Color4sv
, cmdlen
);
826 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&red
), 2);
827 (void) memcpy((void *) (gc
->pc
+ 6), (void *) (&green
), 2);
828 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&blue
), 2);
829 (void) memcpy((void *) (gc
->pc
+ 10), (void *) (&alpha
), 2);
831 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
832 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
836 #define X_GLrop_Color4sv 18
838 __indirect_glColor4sv(const GLshort
* v
)
840 generic_8_byte(X_GLrop_Color4sv
, v
);
843 #define X_GLrop_Color4ubv 19
845 __indirect_glColor4ub(GLubyte red
, GLubyte green
, GLubyte blue
, GLubyte alpha
)
847 __GLXcontext
*const gc
= __glXGetCurrentContext();
848 const GLuint cmdlen
= 8;
849 emit_header(gc
->pc
, X_GLrop_Color4ubv
, cmdlen
);
850 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&red
), 1);
851 (void) memcpy((void *) (gc
->pc
+ 5), (void *) (&green
), 1);
852 (void) memcpy((void *) (gc
->pc
+ 6), (void *) (&blue
), 1);
853 (void) memcpy((void *) (gc
->pc
+ 7), (void *) (&alpha
), 1);
855 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
856 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
860 #define X_GLrop_Color4ubv 19
862 __indirect_glColor4ubv(const GLubyte
*v
)
864 generic_4_byte(X_GLrop_Color4ubv
, v
);
867 #define X_GLrop_Color4uiv 20
869 __indirect_glColor4ui(GLuint red
, GLuint green
, GLuint blue
, GLuint alpha
)
871 __GLXcontext
*const gc
= __glXGetCurrentContext();
872 const GLuint cmdlen
= 20;
873 emit_header(gc
->pc
, X_GLrop_Color4uiv
, cmdlen
);
874 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&red
), 4);
875 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&green
), 4);
876 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&blue
), 4);
877 (void) memcpy((void *) (gc
->pc
+ 16), (void *) (&alpha
), 4);
879 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
880 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
884 #define X_GLrop_Color4uiv 20
886 __indirect_glColor4uiv(const GLuint
* v
)
888 generic_16_byte(X_GLrop_Color4uiv
, v
);
891 #define X_GLrop_Color4usv 21
893 __indirect_glColor4us(GLushort red
, GLushort green
, GLushort blue
,
896 __GLXcontext
*const gc
= __glXGetCurrentContext();
897 const GLuint cmdlen
= 12;
898 emit_header(gc
->pc
, X_GLrop_Color4usv
, cmdlen
);
899 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&red
), 2);
900 (void) memcpy((void *) (gc
->pc
+ 6), (void *) (&green
), 2);
901 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&blue
), 2);
902 (void) memcpy((void *) (gc
->pc
+ 10), (void *) (&alpha
), 2);
904 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
905 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
909 #define X_GLrop_Color4usv 21
911 __indirect_glColor4usv(const GLushort
* v
)
913 generic_8_byte(X_GLrop_Color4usv
, v
);
916 #define X_GLrop_EdgeFlagv 22
918 __indirect_glEdgeFlag(GLboolean flag
)
920 __GLXcontext
*const gc
= __glXGetCurrentContext();
921 const GLuint cmdlen
= 8;
922 emit_header(gc
->pc
, X_GLrop_EdgeFlagv
, cmdlen
);
923 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&flag
), 1);
925 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
926 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
930 #define X_GLrop_EdgeFlagv 22
932 __indirect_glEdgeFlagv(const GLboolean
* flag
)
934 __GLXcontext
*const gc
= __glXGetCurrentContext();
935 const GLuint cmdlen
= 8;
936 emit_header(gc
->pc
, X_GLrop_EdgeFlagv
, cmdlen
);
937 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (flag
), 1);
939 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
940 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
944 #define X_GLrop_End 23
946 __indirect_glEnd(void)
948 __GLXcontext
*const gc
= __glXGetCurrentContext();
949 const GLuint cmdlen
= 4;
950 emit_header(gc
->pc
, X_GLrop_End
, cmdlen
);
952 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
953 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
957 #define X_GLrop_Indexdv 24
959 __indirect_glIndexd(GLdouble c
)
961 __GLXcontext
*const gc
= __glXGetCurrentContext();
962 const GLuint cmdlen
= 12;
963 emit_header(gc
->pc
, X_GLrop_Indexdv
, cmdlen
);
964 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&c
), 8);
966 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
967 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
971 #define X_GLrop_Indexdv 24
973 __indirect_glIndexdv(const GLdouble
* c
)
975 generic_8_byte(X_GLrop_Indexdv
, c
);
978 #define X_GLrop_Indexfv 25
980 __indirect_glIndexf(GLfloat c
)
982 __GLXcontext
*const gc
= __glXGetCurrentContext();
983 const GLuint cmdlen
= 8;
984 emit_header(gc
->pc
, X_GLrop_Indexfv
, cmdlen
);
985 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&c
), 4);
987 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
988 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
992 #define X_GLrop_Indexfv 25
994 __indirect_glIndexfv(const GLfloat
* c
)
996 generic_4_byte(X_GLrop_Indexfv
, c
);
999 #define X_GLrop_Indexiv 26
1001 __indirect_glIndexi(GLint c
)
1003 __GLXcontext
*const gc
= __glXGetCurrentContext();
1004 const GLuint cmdlen
= 8;
1005 emit_header(gc
->pc
, X_GLrop_Indexiv
, cmdlen
);
1006 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&c
), 4);
1008 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
1009 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
1013 #define X_GLrop_Indexiv 26
1015 __indirect_glIndexiv(const GLint
* c
)
1017 generic_4_byte(X_GLrop_Indexiv
, c
);
1020 #define X_GLrop_Indexsv 27
1022 __indirect_glIndexs(GLshort c
)
1024 __GLXcontext
*const gc
= __glXGetCurrentContext();
1025 const GLuint cmdlen
= 8;
1026 emit_header(gc
->pc
, X_GLrop_Indexsv
, cmdlen
);
1027 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&c
), 2);
1029 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
1030 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
1034 #define X_GLrop_Indexsv 27
1036 __indirect_glIndexsv(const GLshort
* c
)
1038 __GLXcontext
*const gc
= __glXGetCurrentContext();
1039 const GLuint cmdlen
= 8;
1040 emit_header(gc
->pc
, X_GLrop_Indexsv
, cmdlen
);
1041 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (c
), 2);
1043 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
1044 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
1048 #define X_GLrop_Normal3bv 28
1050 __indirect_glNormal3b(GLbyte nx
, GLbyte ny
, GLbyte nz
)
1052 __GLXcontext
*const gc
= __glXGetCurrentContext();
1053 const GLuint cmdlen
= 8;
1054 emit_header(gc
->pc
, X_GLrop_Normal3bv
, cmdlen
);
1055 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&nx
), 1);
1056 (void) memcpy((void *) (gc
->pc
+ 5), (void *) (&ny
), 1);
1057 (void) memcpy((void *) (gc
->pc
+ 6), (void *) (&nz
), 1);
1059 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
1060 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
1064 #define X_GLrop_Normal3bv 28
1066 __indirect_glNormal3bv(const GLbyte
*v
)
1068 generic_3_byte(X_GLrop_Normal3bv
, v
);
1071 #define X_GLrop_Normal3dv 29
1073 __indirect_glNormal3d(GLdouble nx
, GLdouble ny
, GLdouble nz
)
1075 __GLXcontext
*const gc
= __glXGetCurrentContext();
1076 const GLuint cmdlen
= 28;
1077 emit_header(gc
->pc
, X_GLrop_Normal3dv
, cmdlen
);
1078 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&nx
), 8);
1079 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&ny
), 8);
1080 (void) memcpy((void *) (gc
->pc
+ 20), (void *) (&nz
), 8);
1082 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
1083 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
1087 #define X_GLrop_Normal3dv 29
1089 __indirect_glNormal3dv(const GLdouble
* v
)
1091 generic_24_byte(X_GLrop_Normal3dv
, v
);
1094 #define X_GLrop_Normal3fv 30
1096 __indirect_glNormal3f(GLfloat nx
, GLfloat ny
, GLfloat nz
)
1098 __GLXcontext
*const gc
= __glXGetCurrentContext();
1099 const GLuint cmdlen
= 16;
1100 emit_header(gc
->pc
, X_GLrop_Normal3fv
, cmdlen
);
1101 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&nx
), 4);
1102 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&ny
), 4);
1103 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&nz
), 4);
1105 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
1106 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
1110 #define X_GLrop_Normal3fv 30
1112 __indirect_glNormal3fv(const GLfloat
* v
)
1114 generic_12_byte(X_GLrop_Normal3fv
, v
);
1117 #define X_GLrop_Normal3iv 31
1119 __indirect_glNormal3i(GLint nx
, GLint ny
, GLint nz
)
1121 __GLXcontext
*const gc
= __glXGetCurrentContext();
1122 const GLuint cmdlen
= 16;
1123 emit_header(gc
->pc
, X_GLrop_Normal3iv
, cmdlen
);
1124 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&nx
), 4);
1125 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&ny
), 4);
1126 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&nz
), 4);
1128 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
1129 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
1133 #define X_GLrop_Normal3iv 31
1135 __indirect_glNormal3iv(const GLint
* v
)
1137 generic_12_byte(X_GLrop_Normal3iv
, v
);
1140 #define X_GLrop_Normal3sv 32
1142 __indirect_glNormal3s(GLshort nx
, GLshort ny
, GLshort nz
)
1144 __GLXcontext
*const gc
= __glXGetCurrentContext();
1145 const GLuint cmdlen
= 12;
1146 emit_header(gc
->pc
, X_GLrop_Normal3sv
, cmdlen
);
1147 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&nx
), 2);
1148 (void) memcpy((void *) (gc
->pc
+ 6), (void *) (&ny
), 2);
1149 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&nz
), 2);
1151 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
1152 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
1156 #define X_GLrop_Normal3sv 32
1158 __indirect_glNormal3sv(const GLshort
* v
)
1160 generic_6_byte(X_GLrop_Normal3sv
, v
);
1163 #define X_GLrop_RasterPos2dv 33
1165 __indirect_glRasterPos2d(GLdouble x
, GLdouble y
)
1167 __GLXcontext
*const gc
= __glXGetCurrentContext();
1168 const GLuint cmdlen
= 20;
1169 emit_header(gc
->pc
, X_GLrop_RasterPos2dv
, cmdlen
);
1170 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&x
), 8);
1171 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&y
), 8);
1173 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
1174 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
1178 #define X_GLrop_RasterPos2dv 33
1180 __indirect_glRasterPos2dv(const GLdouble
* v
)
1182 generic_16_byte(X_GLrop_RasterPos2dv
, v
);
1185 #define X_GLrop_RasterPos2fv 34
1187 __indirect_glRasterPos2f(GLfloat x
, GLfloat y
)
1189 __GLXcontext
*const gc
= __glXGetCurrentContext();
1190 const GLuint cmdlen
= 12;
1191 emit_header(gc
->pc
, X_GLrop_RasterPos2fv
, cmdlen
);
1192 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&x
), 4);
1193 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&y
), 4);
1195 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
1196 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
1200 #define X_GLrop_RasterPos2fv 34
1202 __indirect_glRasterPos2fv(const GLfloat
* v
)
1204 generic_8_byte(X_GLrop_RasterPos2fv
, v
);
1207 #define X_GLrop_RasterPos2iv 35
1209 __indirect_glRasterPos2i(GLint x
, GLint y
)
1211 __GLXcontext
*const gc
= __glXGetCurrentContext();
1212 const GLuint cmdlen
= 12;
1213 emit_header(gc
->pc
, X_GLrop_RasterPos2iv
, cmdlen
);
1214 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&x
), 4);
1215 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&y
), 4);
1217 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
1218 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
1222 #define X_GLrop_RasterPos2iv 35
1224 __indirect_glRasterPos2iv(const GLint
* v
)
1226 generic_8_byte(X_GLrop_RasterPos2iv
, v
);
1229 #define X_GLrop_RasterPos2sv 36
1231 __indirect_glRasterPos2s(GLshort x
, GLshort y
)
1233 __GLXcontext
*const gc
= __glXGetCurrentContext();
1234 const GLuint cmdlen
= 8;
1235 emit_header(gc
->pc
, X_GLrop_RasterPos2sv
, cmdlen
);
1236 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&x
), 2);
1237 (void) memcpy((void *) (gc
->pc
+ 6), (void *) (&y
), 2);
1239 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
1240 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
1244 #define X_GLrop_RasterPos2sv 36
1246 __indirect_glRasterPos2sv(const GLshort
* v
)
1248 generic_4_byte(X_GLrop_RasterPos2sv
, v
);
1251 #define X_GLrop_RasterPos3dv 37
1253 __indirect_glRasterPos3d(GLdouble x
, GLdouble y
, GLdouble z
)
1255 __GLXcontext
*const gc
= __glXGetCurrentContext();
1256 const GLuint cmdlen
= 28;
1257 emit_header(gc
->pc
, X_GLrop_RasterPos3dv
, cmdlen
);
1258 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&x
), 8);
1259 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&y
), 8);
1260 (void) memcpy((void *) (gc
->pc
+ 20), (void *) (&z
), 8);
1262 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
1263 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
1267 #define X_GLrop_RasterPos3dv 37
1269 __indirect_glRasterPos3dv(const GLdouble
* v
)
1271 generic_24_byte(X_GLrop_RasterPos3dv
, v
);
1274 #define X_GLrop_RasterPos3fv 38
1276 __indirect_glRasterPos3f(GLfloat x
, GLfloat y
, GLfloat z
)
1278 __GLXcontext
*const gc
= __glXGetCurrentContext();
1279 const GLuint cmdlen
= 16;
1280 emit_header(gc
->pc
, X_GLrop_RasterPos3fv
, cmdlen
);
1281 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&x
), 4);
1282 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&y
), 4);
1283 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&z
), 4);
1285 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
1286 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
1290 #define X_GLrop_RasterPos3fv 38
1292 __indirect_glRasterPos3fv(const GLfloat
* v
)
1294 generic_12_byte(X_GLrop_RasterPos3fv
, v
);
1297 #define X_GLrop_RasterPos3iv 39
1299 __indirect_glRasterPos3i(GLint x
, GLint y
, GLint z
)
1301 __GLXcontext
*const gc
= __glXGetCurrentContext();
1302 const GLuint cmdlen
= 16;
1303 emit_header(gc
->pc
, X_GLrop_RasterPos3iv
, cmdlen
);
1304 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&x
), 4);
1305 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&y
), 4);
1306 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&z
), 4);
1308 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
1309 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
1313 #define X_GLrop_RasterPos3iv 39
1315 __indirect_glRasterPos3iv(const GLint
* v
)
1317 generic_12_byte(X_GLrop_RasterPos3iv
, v
);
1320 #define X_GLrop_RasterPos3sv 40
1322 __indirect_glRasterPos3s(GLshort x
, GLshort y
, GLshort z
)
1324 __GLXcontext
*const gc
= __glXGetCurrentContext();
1325 const GLuint cmdlen
= 12;
1326 emit_header(gc
->pc
, X_GLrop_RasterPos3sv
, cmdlen
);
1327 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&x
), 2);
1328 (void) memcpy((void *) (gc
->pc
+ 6), (void *) (&y
), 2);
1329 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&z
), 2);
1331 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
1332 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
1336 #define X_GLrop_RasterPos3sv 40
1338 __indirect_glRasterPos3sv(const GLshort
* v
)
1340 generic_6_byte(X_GLrop_RasterPos3sv
, v
);
1343 #define X_GLrop_RasterPos4dv 41
1345 __indirect_glRasterPos4d(GLdouble x
, GLdouble y
, GLdouble z
, GLdouble w
)
1347 __GLXcontext
*const gc
= __glXGetCurrentContext();
1348 const GLuint cmdlen
= 36;
1349 emit_header(gc
->pc
, X_GLrop_RasterPos4dv
, cmdlen
);
1350 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&x
), 8);
1351 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&y
), 8);
1352 (void) memcpy((void *) (gc
->pc
+ 20), (void *) (&z
), 8);
1353 (void) memcpy((void *) (gc
->pc
+ 28), (void *) (&w
), 8);
1355 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
1356 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
1360 #define X_GLrop_RasterPos4dv 41
1362 __indirect_glRasterPos4dv(const GLdouble
* v
)
1364 generic_32_byte(X_GLrop_RasterPos4dv
, v
);
1367 #define X_GLrop_RasterPos4fv 42
1369 __indirect_glRasterPos4f(GLfloat x
, GLfloat y
, GLfloat z
, GLfloat w
)
1371 __GLXcontext
*const gc
= __glXGetCurrentContext();
1372 const GLuint cmdlen
= 20;
1373 emit_header(gc
->pc
, X_GLrop_RasterPos4fv
, cmdlen
);
1374 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&x
), 4);
1375 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&y
), 4);
1376 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&z
), 4);
1377 (void) memcpy((void *) (gc
->pc
+ 16), (void *) (&w
), 4);
1379 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
1380 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
1384 #define X_GLrop_RasterPos4fv 42
1386 __indirect_glRasterPos4fv(const GLfloat
* v
)
1388 generic_16_byte(X_GLrop_RasterPos4fv
, v
);
1391 #define X_GLrop_RasterPos4iv 43
1393 __indirect_glRasterPos4i(GLint x
, GLint y
, GLint z
, GLint w
)
1395 __GLXcontext
*const gc
= __glXGetCurrentContext();
1396 const GLuint cmdlen
= 20;
1397 emit_header(gc
->pc
, X_GLrop_RasterPos4iv
, cmdlen
);
1398 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&x
), 4);
1399 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&y
), 4);
1400 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&z
), 4);
1401 (void) memcpy((void *) (gc
->pc
+ 16), (void *) (&w
), 4);
1403 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
1404 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
1408 #define X_GLrop_RasterPos4iv 43
1410 __indirect_glRasterPos4iv(const GLint
* v
)
1412 generic_16_byte(X_GLrop_RasterPos4iv
, v
);
1415 #define X_GLrop_RasterPos4sv 44
1417 __indirect_glRasterPos4s(GLshort x
, GLshort y
, GLshort z
, GLshort w
)
1419 __GLXcontext
*const gc
= __glXGetCurrentContext();
1420 const GLuint cmdlen
= 12;
1421 emit_header(gc
->pc
, X_GLrop_RasterPos4sv
, cmdlen
);
1422 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&x
), 2);
1423 (void) memcpy((void *) (gc
->pc
+ 6), (void *) (&y
), 2);
1424 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&z
), 2);
1425 (void) memcpy((void *) (gc
->pc
+ 10), (void *) (&w
), 2);
1427 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
1428 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
1432 #define X_GLrop_RasterPos4sv 44
1434 __indirect_glRasterPos4sv(const GLshort
* v
)
1436 generic_8_byte(X_GLrop_RasterPos4sv
, v
);
1439 #define X_GLrop_Rectdv 45
1441 __indirect_glRectd(GLdouble x1
, GLdouble y1
, GLdouble x2
, GLdouble y2
)
1443 __GLXcontext
*const gc
= __glXGetCurrentContext();
1444 const GLuint cmdlen
= 36;
1445 emit_header(gc
->pc
, X_GLrop_Rectdv
, cmdlen
);
1446 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&x1
), 8);
1447 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&y1
), 8);
1448 (void) memcpy((void *) (gc
->pc
+ 20), (void *) (&x2
), 8);
1449 (void) memcpy((void *) (gc
->pc
+ 28), (void *) (&y2
), 8);
1451 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
1452 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
1456 #define X_GLrop_Rectdv 45
1458 __indirect_glRectdv(const GLdouble
* v1
, const GLdouble
* v2
)
1460 __GLXcontext
*const gc
= __glXGetCurrentContext();
1461 const GLuint cmdlen
= 36;
1462 emit_header(gc
->pc
, X_GLrop_Rectdv
, cmdlen
);
1463 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (v1
), 16);
1464 (void) memcpy((void *) (gc
->pc
+ 20), (void *) (v2
), 16);
1466 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
1467 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
1471 #define X_GLrop_Rectfv 46
1473 __indirect_glRectf(GLfloat x1
, GLfloat y1
, GLfloat x2
, GLfloat y2
)
1475 __GLXcontext
*const gc
= __glXGetCurrentContext();
1476 const GLuint cmdlen
= 20;
1477 emit_header(gc
->pc
, X_GLrop_Rectfv
, cmdlen
);
1478 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&x1
), 4);
1479 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&y1
), 4);
1480 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&x2
), 4);
1481 (void) memcpy((void *) (gc
->pc
+ 16), (void *) (&y2
), 4);
1483 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
1484 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
1488 #define X_GLrop_Rectfv 46
1490 __indirect_glRectfv(const GLfloat
* v1
, const GLfloat
* v2
)
1492 __GLXcontext
*const gc
= __glXGetCurrentContext();
1493 const GLuint cmdlen
= 20;
1494 emit_header(gc
->pc
, X_GLrop_Rectfv
, cmdlen
);
1495 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (v1
), 8);
1496 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (v2
), 8);
1498 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
1499 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
1503 #define X_GLrop_Rectiv 47
1505 __indirect_glRecti(GLint x1
, GLint y1
, GLint x2
, GLint y2
)
1507 __GLXcontext
*const gc
= __glXGetCurrentContext();
1508 const GLuint cmdlen
= 20;
1509 emit_header(gc
->pc
, X_GLrop_Rectiv
, cmdlen
);
1510 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&x1
), 4);
1511 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&y1
), 4);
1512 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&x2
), 4);
1513 (void) memcpy((void *) (gc
->pc
+ 16), (void *) (&y2
), 4);
1515 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
1516 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
1520 #define X_GLrop_Rectiv 47
1522 __indirect_glRectiv(const GLint
* v1
, const GLint
* v2
)
1524 __GLXcontext
*const gc
= __glXGetCurrentContext();
1525 const GLuint cmdlen
= 20;
1526 emit_header(gc
->pc
, X_GLrop_Rectiv
, cmdlen
);
1527 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (v1
), 8);
1528 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (v2
), 8);
1530 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
1531 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
1535 #define X_GLrop_Rectsv 48
1537 __indirect_glRects(GLshort x1
, GLshort y1
, GLshort x2
, GLshort y2
)
1539 __GLXcontext
*const gc
= __glXGetCurrentContext();
1540 const GLuint cmdlen
= 12;
1541 emit_header(gc
->pc
, X_GLrop_Rectsv
, cmdlen
);
1542 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&x1
), 2);
1543 (void) memcpy((void *) (gc
->pc
+ 6), (void *) (&y1
), 2);
1544 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&x2
), 2);
1545 (void) memcpy((void *) (gc
->pc
+ 10), (void *) (&y2
), 2);
1547 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
1548 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
1552 #define X_GLrop_Rectsv 48
1554 __indirect_glRectsv(const GLshort
* v1
, const GLshort
* v2
)
1556 __GLXcontext
*const gc
= __glXGetCurrentContext();
1557 const GLuint cmdlen
= 12;
1558 emit_header(gc
->pc
, X_GLrop_Rectsv
, cmdlen
);
1559 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (v1
), 4);
1560 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (v2
), 4);
1562 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
1563 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
1567 #define X_GLrop_TexCoord1dv 49
1569 __indirect_glTexCoord1d(GLdouble s
)
1571 __GLXcontext
*const gc
= __glXGetCurrentContext();
1572 const GLuint cmdlen
= 12;
1573 emit_header(gc
->pc
, X_GLrop_TexCoord1dv
, cmdlen
);
1574 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&s
), 8);
1576 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
1577 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
1581 #define X_GLrop_TexCoord1dv 49
1583 __indirect_glTexCoord1dv(const GLdouble
* v
)
1585 generic_8_byte(X_GLrop_TexCoord1dv
, v
);
1588 #define X_GLrop_TexCoord1fv 50
1590 __indirect_glTexCoord1f(GLfloat s
)
1592 __GLXcontext
*const gc
= __glXGetCurrentContext();
1593 const GLuint cmdlen
= 8;
1594 emit_header(gc
->pc
, X_GLrop_TexCoord1fv
, cmdlen
);
1595 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&s
), 4);
1597 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
1598 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
1602 #define X_GLrop_TexCoord1fv 50
1604 __indirect_glTexCoord1fv(const GLfloat
* v
)
1606 generic_4_byte(X_GLrop_TexCoord1fv
, v
);
1609 #define X_GLrop_TexCoord1iv 51
1611 __indirect_glTexCoord1i(GLint s
)
1613 __GLXcontext
*const gc
= __glXGetCurrentContext();
1614 const GLuint cmdlen
= 8;
1615 emit_header(gc
->pc
, X_GLrop_TexCoord1iv
, cmdlen
);
1616 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&s
), 4);
1618 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
1619 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
1623 #define X_GLrop_TexCoord1iv 51
1625 __indirect_glTexCoord1iv(const GLint
* v
)
1627 generic_4_byte(X_GLrop_TexCoord1iv
, v
);
1630 #define X_GLrop_TexCoord1sv 52
1632 __indirect_glTexCoord1s(GLshort s
)
1634 __GLXcontext
*const gc
= __glXGetCurrentContext();
1635 const GLuint cmdlen
= 8;
1636 emit_header(gc
->pc
, X_GLrop_TexCoord1sv
, cmdlen
);
1637 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&s
), 2);
1639 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
1640 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
1644 #define X_GLrop_TexCoord1sv 52
1646 __indirect_glTexCoord1sv(const GLshort
* v
)
1648 __GLXcontext
*const gc
= __glXGetCurrentContext();
1649 const GLuint cmdlen
= 8;
1650 emit_header(gc
->pc
, X_GLrop_TexCoord1sv
, cmdlen
);
1651 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (v
), 2);
1653 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
1654 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
1658 #define X_GLrop_TexCoord2dv 53
1660 __indirect_glTexCoord2d(GLdouble s
, GLdouble t
)
1662 __GLXcontext
*const gc
= __glXGetCurrentContext();
1663 const GLuint cmdlen
= 20;
1664 emit_header(gc
->pc
, X_GLrop_TexCoord2dv
, cmdlen
);
1665 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&s
), 8);
1666 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&t
), 8);
1668 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
1669 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
1673 #define X_GLrop_TexCoord2dv 53
1675 __indirect_glTexCoord2dv(const GLdouble
* v
)
1677 generic_16_byte(X_GLrop_TexCoord2dv
, v
);
1680 #define X_GLrop_TexCoord2fv 54
1682 __indirect_glTexCoord2f(GLfloat s
, GLfloat t
)
1684 __GLXcontext
*const gc
= __glXGetCurrentContext();
1685 const GLuint cmdlen
= 12;
1686 emit_header(gc
->pc
, X_GLrop_TexCoord2fv
, cmdlen
);
1687 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&s
), 4);
1688 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&t
), 4);
1690 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
1691 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
1695 #define X_GLrop_TexCoord2fv 54
1697 __indirect_glTexCoord2fv(const GLfloat
* v
)
1699 generic_8_byte(X_GLrop_TexCoord2fv
, v
);
1702 #define X_GLrop_TexCoord2iv 55
1704 __indirect_glTexCoord2i(GLint s
, GLint t
)
1706 __GLXcontext
*const gc
= __glXGetCurrentContext();
1707 const GLuint cmdlen
= 12;
1708 emit_header(gc
->pc
, X_GLrop_TexCoord2iv
, cmdlen
);
1709 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&s
), 4);
1710 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&t
), 4);
1712 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
1713 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
1717 #define X_GLrop_TexCoord2iv 55
1719 __indirect_glTexCoord2iv(const GLint
* v
)
1721 generic_8_byte(X_GLrop_TexCoord2iv
, v
);
1724 #define X_GLrop_TexCoord2sv 56
1726 __indirect_glTexCoord2s(GLshort s
, GLshort t
)
1728 __GLXcontext
*const gc
= __glXGetCurrentContext();
1729 const GLuint cmdlen
= 8;
1730 emit_header(gc
->pc
, X_GLrop_TexCoord2sv
, cmdlen
);
1731 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&s
), 2);
1732 (void) memcpy((void *) (gc
->pc
+ 6), (void *) (&t
), 2);
1734 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
1735 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
1739 #define X_GLrop_TexCoord2sv 56
1741 __indirect_glTexCoord2sv(const GLshort
* v
)
1743 generic_4_byte(X_GLrop_TexCoord2sv
, v
);
1746 #define X_GLrop_TexCoord3dv 57
1748 __indirect_glTexCoord3d(GLdouble s
, GLdouble t
, GLdouble r
)
1750 __GLXcontext
*const gc
= __glXGetCurrentContext();
1751 const GLuint cmdlen
= 28;
1752 emit_header(gc
->pc
, X_GLrop_TexCoord3dv
, cmdlen
);
1753 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&s
), 8);
1754 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&t
), 8);
1755 (void) memcpy((void *) (gc
->pc
+ 20), (void *) (&r
), 8);
1757 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
1758 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
1762 #define X_GLrop_TexCoord3dv 57
1764 __indirect_glTexCoord3dv(const GLdouble
* v
)
1766 generic_24_byte(X_GLrop_TexCoord3dv
, v
);
1769 #define X_GLrop_TexCoord3fv 58
1771 __indirect_glTexCoord3f(GLfloat s
, GLfloat t
, GLfloat r
)
1773 __GLXcontext
*const gc
= __glXGetCurrentContext();
1774 const GLuint cmdlen
= 16;
1775 emit_header(gc
->pc
, X_GLrop_TexCoord3fv
, cmdlen
);
1776 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&s
), 4);
1777 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&t
), 4);
1778 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&r
), 4);
1780 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
1781 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
1785 #define X_GLrop_TexCoord3fv 58
1787 __indirect_glTexCoord3fv(const GLfloat
* v
)
1789 generic_12_byte(X_GLrop_TexCoord3fv
, v
);
1792 #define X_GLrop_TexCoord3iv 59
1794 __indirect_glTexCoord3i(GLint s
, GLint t
, GLint r
)
1796 __GLXcontext
*const gc
= __glXGetCurrentContext();
1797 const GLuint cmdlen
= 16;
1798 emit_header(gc
->pc
, X_GLrop_TexCoord3iv
, cmdlen
);
1799 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&s
), 4);
1800 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&t
), 4);
1801 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&r
), 4);
1803 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
1804 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
1808 #define X_GLrop_TexCoord3iv 59
1810 __indirect_glTexCoord3iv(const GLint
* v
)
1812 generic_12_byte(X_GLrop_TexCoord3iv
, v
);
1815 #define X_GLrop_TexCoord3sv 60
1817 __indirect_glTexCoord3s(GLshort s
, GLshort t
, GLshort r
)
1819 __GLXcontext
*const gc
= __glXGetCurrentContext();
1820 const GLuint cmdlen
= 12;
1821 emit_header(gc
->pc
, X_GLrop_TexCoord3sv
, cmdlen
);
1822 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&s
), 2);
1823 (void) memcpy((void *) (gc
->pc
+ 6), (void *) (&t
), 2);
1824 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&r
), 2);
1826 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
1827 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
1831 #define X_GLrop_TexCoord3sv 60
1833 __indirect_glTexCoord3sv(const GLshort
* v
)
1835 generic_6_byte(X_GLrop_TexCoord3sv
, v
);
1838 #define X_GLrop_TexCoord4dv 61
1840 __indirect_glTexCoord4d(GLdouble s
, GLdouble t
, GLdouble r
, GLdouble q
)
1842 __GLXcontext
*const gc
= __glXGetCurrentContext();
1843 const GLuint cmdlen
= 36;
1844 emit_header(gc
->pc
, X_GLrop_TexCoord4dv
, cmdlen
);
1845 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&s
), 8);
1846 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&t
), 8);
1847 (void) memcpy((void *) (gc
->pc
+ 20), (void *) (&r
), 8);
1848 (void) memcpy((void *) (gc
->pc
+ 28), (void *) (&q
), 8);
1850 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
1851 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
1855 #define X_GLrop_TexCoord4dv 61
1857 __indirect_glTexCoord4dv(const GLdouble
* v
)
1859 generic_32_byte(X_GLrop_TexCoord4dv
, v
);
1862 #define X_GLrop_TexCoord4fv 62
1864 __indirect_glTexCoord4f(GLfloat s
, GLfloat t
, GLfloat r
, GLfloat q
)
1866 __GLXcontext
*const gc
= __glXGetCurrentContext();
1867 const GLuint cmdlen
= 20;
1868 emit_header(gc
->pc
, X_GLrop_TexCoord4fv
, cmdlen
);
1869 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&s
), 4);
1870 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&t
), 4);
1871 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&r
), 4);
1872 (void) memcpy((void *) (gc
->pc
+ 16), (void *) (&q
), 4);
1874 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
1875 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
1879 #define X_GLrop_TexCoord4fv 62
1881 __indirect_glTexCoord4fv(const GLfloat
* v
)
1883 generic_16_byte(X_GLrop_TexCoord4fv
, v
);
1886 #define X_GLrop_TexCoord4iv 63
1888 __indirect_glTexCoord4i(GLint s
, GLint t
, GLint r
, GLint q
)
1890 __GLXcontext
*const gc
= __glXGetCurrentContext();
1891 const GLuint cmdlen
= 20;
1892 emit_header(gc
->pc
, X_GLrop_TexCoord4iv
, cmdlen
);
1893 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&s
), 4);
1894 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&t
), 4);
1895 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&r
), 4);
1896 (void) memcpy((void *) (gc
->pc
+ 16), (void *) (&q
), 4);
1898 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
1899 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
1903 #define X_GLrop_TexCoord4iv 63
1905 __indirect_glTexCoord4iv(const GLint
* v
)
1907 generic_16_byte(X_GLrop_TexCoord4iv
, v
);
1910 #define X_GLrop_TexCoord4sv 64
1912 __indirect_glTexCoord4s(GLshort s
, GLshort t
, GLshort r
, GLshort q
)
1914 __GLXcontext
*const gc
= __glXGetCurrentContext();
1915 const GLuint cmdlen
= 12;
1916 emit_header(gc
->pc
, X_GLrop_TexCoord4sv
, cmdlen
);
1917 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&s
), 2);
1918 (void) memcpy((void *) (gc
->pc
+ 6), (void *) (&t
), 2);
1919 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&r
), 2);
1920 (void) memcpy((void *) (gc
->pc
+ 10), (void *) (&q
), 2);
1922 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
1923 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
1927 #define X_GLrop_TexCoord4sv 64
1929 __indirect_glTexCoord4sv(const GLshort
* v
)
1931 generic_8_byte(X_GLrop_TexCoord4sv
, v
);
1934 #define X_GLrop_Vertex2dv 65
1936 __indirect_glVertex2d(GLdouble x
, GLdouble y
)
1938 __GLXcontext
*const gc
= __glXGetCurrentContext();
1939 const GLuint cmdlen
= 20;
1940 emit_header(gc
->pc
, X_GLrop_Vertex2dv
, cmdlen
);
1941 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&x
), 8);
1942 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&y
), 8);
1944 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
1945 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
1949 #define X_GLrop_Vertex2dv 65
1951 __indirect_glVertex2dv(const GLdouble
* v
)
1953 generic_16_byte(X_GLrop_Vertex2dv
, v
);
1956 #define X_GLrop_Vertex2fv 66
1958 __indirect_glVertex2f(GLfloat x
, GLfloat y
)
1960 __GLXcontext
*const gc
= __glXGetCurrentContext();
1961 const GLuint cmdlen
= 12;
1962 emit_header(gc
->pc
, X_GLrop_Vertex2fv
, cmdlen
);
1963 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&x
), 4);
1964 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&y
), 4);
1966 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
1967 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
1971 #define X_GLrop_Vertex2fv 66
1973 __indirect_glVertex2fv(const GLfloat
* v
)
1975 generic_8_byte(X_GLrop_Vertex2fv
, v
);
1978 #define X_GLrop_Vertex2iv 67
1980 __indirect_glVertex2i(GLint x
, GLint y
)
1982 __GLXcontext
*const gc
= __glXGetCurrentContext();
1983 const GLuint cmdlen
= 12;
1984 emit_header(gc
->pc
, X_GLrop_Vertex2iv
, cmdlen
);
1985 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&x
), 4);
1986 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&y
), 4);
1988 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
1989 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
1993 #define X_GLrop_Vertex2iv 67
1995 __indirect_glVertex2iv(const GLint
* v
)
1997 generic_8_byte(X_GLrop_Vertex2iv
, v
);
2000 #define X_GLrop_Vertex2sv 68
2002 __indirect_glVertex2s(GLshort x
, GLshort y
)
2004 __GLXcontext
*const gc
= __glXGetCurrentContext();
2005 const GLuint cmdlen
= 8;
2006 emit_header(gc
->pc
, X_GLrop_Vertex2sv
, cmdlen
);
2007 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&x
), 2);
2008 (void) memcpy((void *) (gc
->pc
+ 6), (void *) (&y
), 2);
2010 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
2011 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
2015 #define X_GLrop_Vertex2sv 68
2017 __indirect_glVertex2sv(const GLshort
* v
)
2019 generic_4_byte(X_GLrop_Vertex2sv
, v
);
2022 #define X_GLrop_Vertex3dv 69
2024 __indirect_glVertex3d(GLdouble x
, GLdouble y
, GLdouble z
)
2026 __GLXcontext
*const gc
= __glXGetCurrentContext();
2027 const GLuint cmdlen
= 28;
2028 emit_header(gc
->pc
, X_GLrop_Vertex3dv
, cmdlen
);
2029 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&x
), 8);
2030 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&y
), 8);
2031 (void) memcpy((void *) (gc
->pc
+ 20), (void *) (&z
), 8);
2033 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
2034 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
2038 #define X_GLrop_Vertex3dv 69
2040 __indirect_glVertex3dv(const GLdouble
* v
)
2042 generic_24_byte(X_GLrop_Vertex3dv
, v
);
2045 #define X_GLrop_Vertex3fv 70
2047 __indirect_glVertex3f(GLfloat x
, GLfloat y
, GLfloat z
)
2049 __GLXcontext
*const gc
= __glXGetCurrentContext();
2050 const GLuint cmdlen
= 16;
2051 emit_header(gc
->pc
, X_GLrop_Vertex3fv
, cmdlen
);
2052 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&x
), 4);
2053 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&y
), 4);
2054 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&z
), 4);
2056 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
2057 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
2061 #define X_GLrop_Vertex3fv 70
2063 __indirect_glVertex3fv(const GLfloat
* v
)
2065 generic_12_byte(X_GLrop_Vertex3fv
, v
);
2068 #define X_GLrop_Vertex3iv 71
2070 __indirect_glVertex3i(GLint x
, GLint y
, GLint z
)
2072 __GLXcontext
*const gc
= __glXGetCurrentContext();
2073 const GLuint cmdlen
= 16;
2074 emit_header(gc
->pc
, X_GLrop_Vertex3iv
, cmdlen
);
2075 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&x
), 4);
2076 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&y
), 4);
2077 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&z
), 4);
2079 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
2080 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
2084 #define X_GLrop_Vertex3iv 71
2086 __indirect_glVertex3iv(const GLint
* v
)
2088 generic_12_byte(X_GLrop_Vertex3iv
, v
);
2091 #define X_GLrop_Vertex3sv 72
2093 __indirect_glVertex3s(GLshort x
, GLshort y
, GLshort z
)
2095 __GLXcontext
*const gc
= __glXGetCurrentContext();
2096 const GLuint cmdlen
= 12;
2097 emit_header(gc
->pc
, X_GLrop_Vertex3sv
, cmdlen
);
2098 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&x
), 2);
2099 (void) memcpy((void *) (gc
->pc
+ 6), (void *) (&y
), 2);
2100 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&z
), 2);
2102 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
2103 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
2107 #define X_GLrop_Vertex3sv 72
2109 __indirect_glVertex3sv(const GLshort
* v
)
2111 generic_6_byte(X_GLrop_Vertex3sv
, v
);
2114 #define X_GLrop_Vertex4dv 73
2116 __indirect_glVertex4d(GLdouble x
, GLdouble y
, GLdouble z
, GLdouble w
)
2118 __GLXcontext
*const gc
= __glXGetCurrentContext();
2119 const GLuint cmdlen
= 36;
2120 emit_header(gc
->pc
, X_GLrop_Vertex4dv
, cmdlen
);
2121 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&x
), 8);
2122 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&y
), 8);
2123 (void) memcpy((void *) (gc
->pc
+ 20), (void *) (&z
), 8);
2124 (void) memcpy((void *) (gc
->pc
+ 28), (void *) (&w
), 8);
2126 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
2127 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
2131 #define X_GLrop_Vertex4dv 73
2133 __indirect_glVertex4dv(const GLdouble
* v
)
2135 generic_32_byte(X_GLrop_Vertex4dv
, v
);
2138 #define X_GLrop_Vertex4fv 74
2140 __indirect_glVertex4f(GLfloat x
, GLfloat y
, GLfloat z
, GLfloat w
)
2142 __GLXcontext
*const gc
= __glXGetCurrentContext();
2143 const GLuint cmdlen
= 20;
2144 emit_header(gc
->pc
, X_GLrop_Vertex4fv
, cmdlen
);
2145 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&x
), 4);
2146 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&y
), 4);
2147 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&z
), 4);
2148 (void) memcpy((void *) (gc
->pc
+ 16), (void *) (&w
), 4);
2150 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
2151 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
2155 #define X_GLrop_Vertex4fv 74
2157 __indirect_glVertex4fv(const GLfloat
* v
)
2159 generic_16_byte(X_GLrop_Vertex4fv
, v
);
2162 #define X_GLrop_Vertex4iv 75
2164 __indirect_glVertex4i(GLint x
, GLint y
, GLint z
, GLint w
)
2166 __GLXcontext
*const gc
= __glXGetCurrentContext();
2167 const GLuint cmdlen
= 20;
2168 emit_header(gc
->pc
, X_GLrop_Vertex4iv
, cmdlen
);
2169 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&x
), 4);
2170 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&y
), 4);
2171 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&z
), 4);
2172 (void) memcpy((void *) (gc
->pc
+ 16), (void *) (&w
), 4);
2174 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
2175 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
2179 #define X_GLrop_Vertex4iv 75
2181 __indirect_glVertex4iv(const GLint
* v
)
2183 generic_16_byte(X_GLrop_Vertex4iv
, v
);
2186 #define X_GLrop_Vertex4sv 76
2188 __indirect_glVertex4s(GLshort x
, GLshort y
, GLshort z
, GLshort w
)
2190 __GLXcontext
*const gc
= __glXGetCurrentContext();
2191 const GLuint cmdlen
= 12;
2192 emit_header(gc
->pc
, X_GLrop_Vertex4sv
, cmdlen
);
2193 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&x
), 2);
2194 (void) memcpy((void *) (gc
->pc
+ 6), (void *) (&y
), 2);
2195 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&z
), 2);
2196 (void) memcpy((void *) (gc
->pc
+ 10), (void *) (&w
), 2);
2198 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
2199 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
2203 #define X_GLrop_Vertex4sv 76
2205 __indirect_glVertex4sv(const GLshort
* v
)
2207 generic_8_byte(X_GLrop_Vertex4sv
, v
);
2210 #define X_GLrop_ClipPlane 77
2212 __indirect_glClipPlane(GLenum plane
, const GLdouble
* equation
)
2214 __GLXcontext
*const gc
= __glXGetCurrentContext();
2215 const GLuint cmdlen
= 40;
2216 emit_header(gc
->pc
, X_GLrop_ClipPlane
, cmdlen
);
2217 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (equation
), 32);
2218 (void) memcpy((void *) (gc
->pc
+ 36), (void *) (&plane
), 4);
2220 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
2221 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
2225 #define X_GLrop_ColorMaterial 78
2227 __indirect_glColorMaterial(GLenum face
, GLenum mode
)
2229 __GLXcontext
*const gc
= __glXGetCurrentContext();
2230 const GLuint cmdlen
= 12;
2231 emit_header(gc
->pc
, X_GLrop_ColorMaterial
, cmdlen
);
2232 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&face
), 4);
2233 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&mode
), 4);
2235 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
2236 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
2240 #define X_GLrop_CullFace 79
2242 __indirect_glCullFace(GLenum mode
)
2244 __GLXcontext
*const gc
= __glXGetCurrentContext();
2245 const GLuint cmdlen
= 8;
2246 emit_header(gc
->pc
, X_GLrop_CullFace
, cmdlen
);
2247 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&mode
), 4);
2249 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
2250 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
2254 #define X_GLrop_Fogf 80
2256 __indirect_glFogf(GLenum pname
, GLfloat param
)
2258 __GLXcontext
*const gc
= __glXGetCurrentContext();
2259 const GLuint cmdlen
= 12;
2260 emit_header(gc
->pc
, X_GLrop_Fogf
, cmdlen
);
2261 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&pname
), 4);
2262 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (¶m
), 4);
2264 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
2265 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
2269 #define X_GLrop_Fogfv 81
2271 __indirect_glFogfv(GLenum pname
, const GLfloat
* params
)
2273 __GLXcontext
*const gc
= __glXGetCurrentContext();
2274 const GLuint compsize
= __glFogfv_size(pname
);
2275 const GLuint cmdlen
= 8 + __GLX_PAD((compsize
* 4));
2276 emit_header(gc
->pc
, X_GLrop_Fogfv
, cmdlen
);
2277 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&pname
), 4);
2278 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (params
), (compsize
* 4));
2280 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
2281 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
2285 #define X_GLrop_Fogi 82
2287 __indirect_glFogi(GLenum pname
, GLint param
)
2289 __GLXcontext
*const gc
= __glXGetCurrentContext();
2290 const GLuint cmdlen
= 12;
2291 emit_header(gc
->pc
, X_GLrop_Fogi
, cmdlen
);
2292 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&pname
), 4);
2293 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (¶m
), 4);
2295 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
2296 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
2300 #define X_GLrop_Fogiv 83
2302 __indirect_glFogiv(GLenum pname
, const GLint
* params
)
2304 __GLXcontext
*const gc
= __glXGetCurrentContext();
2305 const GLuint compsize
= __glFogiv_size(pname
);
2306 const GLuint cmdlen
= 8 + __GLX_PAD((compsize
* 4));
2307 emit_header(gc
->pc
, X_GLrop_Fogiv
, cmdlen
);
2308 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&pname
), 4);
2309 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (params
), (compsize
* 4));
2311 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
2312 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
2316 #define X_GLrop_FrontFace 84
2318 __indirect_glFrontFace(GLenum mode
)
2320 __GLXcontext
*const gc
= __glXGetCurrentContext();
2321 const GLuint cmdlen
= 8;
2322 emit_header(gc
->pc
, X_GLrop_FrontFace
, cmdlen
);
2323 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&mode
), 4);
2325 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
2326 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
2330 #define X_GLrop_Hint 85
2332 __indirect_glHint(GLenum target
, GLenum mode
)
2334 __GLXcontext
*const gc
= __glXGetCurrentContext();
2335 const GLuint cmdlen
= 12;
2336 emit_header(gc
->pc
, X_GLrop_Hint
, cmdlen
);
2337 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&target
), 4);
2338 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&mode
), 4);
2340 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
2341 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
2345 #define X_GLrop_Lightf 86
2347 __indirect_glLightf(GLenum light
, GLenum pname
, GLfloat param
)
2349 __GLXcontext
*const gc
= __glXGetCurrentContext();
2350 const GLuint cmdlen
= 16;
2351 emit_header(gc
->pc
, X_GLrop_Lightf
, cmdlen
);
2352 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&light
), 4);
2353 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&pname
), 4);
2354 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (¶m
), 4);
2356 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
2357 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
2361 #define X_GLrop_Lightfv 87
2363 __indirect_glLightfv(GLenum light
, GLenum pname
, const GLfloat
* params
)
2365 __GLXcontext
*const gc
= __glXGetCurrentContext();
2366 const GLuint compsize
= __glLightfv_size(pname
);
2367 const GLuint cmdlen
= 12 + __GLX_PAD((compsize
* 4));
2368 emit_header(gc
->pc
, X_GLrop_Lightfv
, cmdlen
);
2369 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&light
), 4);
2370 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&pname
), 4);
2371 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (params
), (compsize
* 4));
2373 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
2374 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
2378 #define X_GLrop_Lighti 88
2380 __indirect_glLighti(GLenum light
, GLenum pname
, GLint param
)
2382 __GLXcontext
*const gc
= __glXGetCurrentContext();
2383 const GLuint cmdlen
= 16;
2384 emit_header(gc
->pc
, X_GLrop_Lighti
, cmdlen
);
2385 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&light
), 4);
2386 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&pname
), 4);
2387 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (¶m
), 4);
2389 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
2390 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
2394 #define X_GLrop_Lightiv 89
2396 __indirect_glLightiv(GLenum light
, GLenum pname
, const GLint
* params
)
2398 __GLXcontext
*const gc
= __glXGetCurrentContext();
2399 const GLuint compsize
= __glLightiv_size(pname
);
2400 const GLuint cmdlen
= 12 + __GLX_PAD((compsize
* 4));
2401 emit_header(gc
->pc
, X_GLrop_Lightiv
, cmdlen
);
2402 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&light
), 4);
2403 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&pname
), 4);
2404 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (params
), (compsize
* 4));
2406 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
2407 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
2411 #define X_GLrop_LightModelf 90
2413 __indirect_glLightModelf(GLenum pname
, GLfloat param
)
2415 __GLXcontext
*const gc
= __glXGetCurrentContext();
2416 const GLuint cmdlen
= 12;
2417 emit_header(gc
->pc
, X_GLrop_LightModelf
, cmdlen
);
2418 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&pname
), 4);
2419 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (¶m
), 4);
2421 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
2422 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
2426 #define X_GLrop_LightModelfv 91
2428 __indirect_glLightModelfv(GLenum pname
, const GLfloat
* params
)
2430 __GLXcontext
*const gc
= __glXGetCurrentContext();
2431 const GLuint compsize
= __glLightModelfv_size(pname
);
2432 const GLuint cmdlen
= 8 + __GLX_PAD((compsize
* 4));
2433 emit_header(gc
->pc
, X_GLrop_LightModelfv
, cmdlen
);
2434 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&pname
), 4);
2435 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (params
), (compsize
* 4));
2437 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
2438 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
2442 #define X_GLrop_LightModeli 92
2444 __indirect_glLightModeli(GLenum pname
, GLint param
)
2446 __GLXcontext
*const gc
= __glXGetCurrentContext();
2447 const GLuint cmdlen
= 12;
2448 emit_header(gc
->pc
, X_GLrop_LightModeli
, cmdlen
);
2449 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&pname
), 4);
2450 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (¶m
), 4);
2452 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
2453 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
2457 #define X_GLrop_LightModeliv 93
2459 __indirect_glLightModeliv(GLenum pname
, const GLint
* params
)
2461 __GLXcontext
*const gc
= __glXGetCurrentContext();
2462 const GLuint compsize
= __glLightModeliv_size(pname
);
2463 const GLuint cmdlen
= 8 + __GLX_PAD((compsize
* 4));
2464 emit_header(gc
->pc
, X_GLrop_LightModeliv
, cmdlen
);
2465 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&pname
), 4);
2466 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (params
), (compsize
* 4));
2468 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
2469 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
2473 #define X_GLrop_LineStipple 94
2475 __indirect_glLineStipple(GLint factor
, GLushort pattern
)
2477 __GLXcontext
*const gc
= __glXGetCurrentContext();
2478 const GLuint cmdlen
= 12;
2479 emit_header(gc
->pc
, X_GLrop_LineStipple
, cmdlen
);
2480 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&factor
), 4);
2481 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&pattern
), 2);
2483 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
2484 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
2488 #define X_GLrop_LineWidth 95
2490 __indirect_glLineWidth(GLfloat width
)
2492 __GLXcontext
*const gc
= __glXGetCurrentContext();
2493 const GLuint cmdlen
= 8;
2494 emit_header(gc
->pc
, X_GLrop_LineWidth
, cmdlen
);
2495 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&width
), 4);
2497 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
2498 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
2502 #define X_GLrop_Materialf 96
2504 __indirect_glMaterialf(GLenum face
, GLenum pname
, GLfloat param
)
2506 __GLXcontext
*const gc
= __glXGetCurrentContext();
2507 const GLuint cmdlen
= 16;
2508 emit_header(gc
->pc
, X_GLrop_Materialf
, cmdlen
);
2509 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&face
), 4);
2510 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&pname
), 4);
2511 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (¶m
), 4);
2513 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
2514 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
2518 #define X_GLrop_Materialfv 97
2520 __indirect_glMaterialfv(GLenum face
, GLenum pname
, const GLfloat
* params
)
2522 __GLXcontext
*const gc
= __glXGetCurrentContext();
2523 const GLuint compsize
= __glMaterialfv_size(pname
);
2524 const GLuint cmdlen
= 12 + __GLX_PAD((compsize
* 4));
2525 emit_header(gc
->pc
, X_GLrop_Materialfv
, cmdlen
);
2526 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&face
), 4);
2527 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&pname
), 4);
2528 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (params
), (compsize
* 4));
2530 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
2531 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
2535 #define X_GLrop_Materiali 98
2537 __indirect_glMateriali(GLenum face
, GLenum pname
, GLint param
)
2539 __GLXcontext
*const gc
= __glXGetCurrentContext();
2540 const GLuint cmdlen
= 16;
2541 emit_header(gc
->pc
, X_GLrop_Materiali
, cmdlen
);
2542 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&face
), 4);
2543 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&pname
), 4);
2544 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (¶m
), 4);
2546 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
2547 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
2551 #define X_GLrop_Materialiv 99
2553 __indirect_glMaterialiv(GLenum face
, GLenum pname
, const GLint
* params
)
2555 __GLXcontext
*const gc
= __glXGetCurrentContext();
2556 const GLuint compsize
= __glMaterialiv_size(pname
);
2557 const GLuint cmdlen
= 12 + __GLX_PAD((compsize
* 4));
2558 emit_header(gc
->pc
, X_GLrop_Materialiv
, cmdlen
);
2559 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&face
), 4);
2560 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&pname
), 4);
2561 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (params
), (compsize
* 4));
2563 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
2564 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
2568 #define X_GLrop_PointSize 100
2570 __indirect_glPointSize(GLfloat size
)
2572 __GLXcontext
*const gc
= __glXGetCurrentContext();
2573 const GLuint cmdlen
= 8;
2574 emit_header(gc
->pc
, X_GLrop_PointSize
, cmdlen
);
2575 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&size
), 4);
2577 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
2578 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
2582 #define X_GLrop_PolygonMode 101
2584 __indirect_glPolygonMode(GLenum face
, GLenum mode
)
2586 __GLXcontext
*const gc
= __glXGetCurrentContext();
2587 const GLuint cmdlen
= 12;
2588 emit_header(gc
->pc
, X_GLrop_PolygonMode
, cmdlen
);
2589 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&face
), 4);
2590 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&mode
), 4);
2592 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
2593 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
2597 #define X_GLrop_PolygonStipple 102
2599 __indirect_glPolygonStipple(const GLubyte
*mask
)
2601 __GLXcontext
*const gc
= __glXGetCurrentContext();
2602 const GLuint compsize
=
2603 (mask
!= NULL
) ? __glImageSize(32, 32, 1, GL_COLOR_INDEX
, GL_BITMAP
,
2605 const GLuint cmdlen
= 24 + __GLX_PAD(compsize
);
2606 emit_header(gc
->pc
, X_GLrop_PolygonStipple
, cmdlen
);
2608 (*gc
->fillImage
) (gc
, 2, 32, 32, 1, GL_COLOR_INDEX
, GL_BITMAP
, mask
,
2609 gc
->pc
+ 24, gc
->pc
+ 4);
2611 (void) memcpy(gc
->pc
+ 4, default_pixel_store_2D
,
2612 default_pixel_store_2D_size
);
2615 if (gc
->pc
> gc
->limit
) {
2616 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
2620 #define X_GLrop_Scissor 103
2622 __indirect_glScissor(GLint x
, GLint y
, GLsizei width
, GLsizei height
)
2624 __GLXcontext
*const gc
= __glXGetCurrentContext();
2625 const GLuint cmdlen
= 20;
2626 emit_header(gc
->pc
, X_GLrop_Scissor
, cmdlen
);
2627 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&x
), 4);
2628 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&y
), 4);
2629 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&width
), 4);
2630 (void) memcpy((void *) (gc
->pc
+ 16), (void *) (&height
), 4);
2632 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
2633 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
2637 #define X_GLrop_ShadeModel 104
2639 __indirect_glShadeModel(GLenum mode
)
2641 __GLXcontext
*const gc
= __glXGetCurrentContext();
2642 const GLuint cmdlen
= 8;
2643 emit_header(gc
->pc
, X_GLrop_ShadeModel
, cmdlen
);
2644 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&mode
), 4);
2646 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
2647 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
2651 #define X_GLrop_TexParameterf 105
2653 __indirect_glTexParameterf(GLenum target
, GLenum pname
, GLfloat param
)
2655 __GLXcontext
*const gc
= __glXGetCurrentContext();
2656 const GLuint cmdlen
= 16;
2657 emit_header(gc
->pc
, X_GLrop_TexParameterf
, cmdlen
);
2658 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&target
), 4);
2659 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&pname
), 4);
2660 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (¶m
), 4);
2662 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
2663 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
2667 #define X_GLrop_TexParameterfv 106
2669 __indirect_glTexParameterfv(GLenum target
, GLenum pname
,
2670 const GLfloat
* params
)
2672 __GLXcontext
*const gc
= __glXGetCurrentContext();
2673 const GLuint compsize
= __glTexParameterfv_size(pname
);
2674 const GLuint cmdlen
= 12 + __GLX_PAD((compsize
* 4));
2675 emit_header(gc
->pc
, X_GLrop_TexParameterfv
, cmdlen
);
2676 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&target
), 4);
2677 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&pname
), 4);
2678 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (params
), (compsize
* 4));
2680 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
2681 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
2685 #define X_GLrop_TexParameteri 107
2687 __indirect_glTexParameteri(GLenum target
, GLenum pname
, GLint param
)
2689 __GLXcontext
*const gc
= __glXGetCurrentContext();
2690 const GLuint cmdlen
= 16;
2691 emit_header(gc
->pc
, X_GLrop_TexParameteri
, cmdlen
);
2692 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&target
), 4);
2693 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&pname
), 4);
2694 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (¶m
), 4);
2696 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
2697 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
2701 #define X_GLrop_TexParameteriv 108
2703 __indirect_glTexParameteriv(GLenum target
, GLenum pname
, const GLint
* params
)
2705 __GLXcontext
*const gc
= __glXGetCurrentContext();
2706 const GLuint compsize
= __glTexParameteriv_size(pname
);
2707 const GLuint cmdlen
= 12 + __GLX_PAD((compsize
* 4));
2708 emit_header(gc
->pc
, X_GLrop_TexParameteriv
, cmdlen
);
2709 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&target
), 4);
2710 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&pname
), 4);
2711 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (params
), (compsize
* 4));
2713 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
2714 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
2719 __glx_TexImage_1D2D(unsigned opcode
, unsigned dim
, GLenum target
, GLint level
,
2720 GLint internalformat
, GLsizei width
, GLsizei height
,
2721 GLint border
, GLenum format
, GLenum type
,
2722 const GLvoid
* pixels
)
2724 __GLXcontext
*const gc
= __glXGetCurrentContext();
2725 const GLuint compsize
=
2726 __glImageSize(width
, height
, 1, format
, type
, target
);
2727 const GLuint cmdlen
= 56 + __GLX_PAD(compsize
);
2728 if (__builtin_expect(gc
->currentDpy
!= NULL
, 1)) {
2729 if (cmdlen
<= gc
->maxSmallRenderCommandSize
) {
2730 if ((gc
->pc
+ cmdlen
) > gc
->bufEnd
) {
2731 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
2733 emit_header(gc
->pc
, opcode
, cmdlen
);
2734 (void) memcpy((void *) (gc
->pc
+ 24), (void *) (&target
), 4);
2735 (void) memcpy((void *) (gc
->pc
+ 28), (void *) (&level
), 4);
2736 (void) memcpy((void *) (gc
->pc
+ 32), (void *) (&internalformat
),
2738 (void) memcpy((void *) (gc
->pc
+ 36), (void *) (&width
), 4);
2739 (void) memcpy((void *) (gc
->pc
+ 40), (void *) (&height
), 4);
2740 (void) memcpy((void *) (gc
->pc
+ 44), (void *) (&border
), 4);
2741 (void) memcpy((void *) (gc
->pc
+ 48), (void *) (&format
), 4);
2742 (void) memcpy((void *) (gc
->pc
+ 52), (void *) (&type
), 4);
2743 if ((compsize
> 0) && (pixels
!= NULL
)) {
2744 (*gc
->fillImage
) (gc
, dim
, width
, height
, 1, format
, type
,
2745 pixels
, gc
->pc
+ 56, gc
->pc
+ 4);
2747 (void) memcpy(gc
->pc
+ 4, default_pixel_store_2D
,
2748 default_pixel_store_2D_size
);
2751 if (gc
->pc
> gc
->limit
) {
2752 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
2755 const GLint op
= opcode
;
2756 const GLuint cmdlenLarge
= cmdlen
+ 4;
2757 GLubyte
*const pc
= __glXFlushRenderBuffer(gc
, gc
->pc
);
2758 (void) memcpy((void *) (pc
+ 0), (void *) (&cmdlenLarge
), 4);
2759 (void) memcpy((void *) (pc
+ 4), (void *) (&op
), 4);
2760 (void) memcpy((void *) (pc
+ 28), (void *) (&target
), 4);
2761 (void) memcpy((void *) (pc
+ 32), (void *) (&level
), 4);
2762 (void) memcpy((void *) (pc
+ 36), (void *) (&internalformat
), 4);
2763 (void) memcpy((void *) (pc
+ 40), (void *) (&width
), 4);
2764 (void) memcpy((void *) (pc
+ 44), (void *) (&height
), 4);
2765 (void) memcpy((void *) (pc
+ 48), (void *) (&border
), 4);
2766 (void) memcpy((void *) (pc
+ 52), (void *) (&format
), 4);
2767 (void) memcpy((void *) (pc
+ 56), (void *) (&type
), 4);
2768 __glXSendLargeImage(gc
, compsize
, dim
, width
, height
, 1, format
,
2769 type
, pixels
, pc
+ 60, pc
+ 8);
2774 #define X_GLrop_TexImage1D 109
2776 __indirect_glTexImage1D(GLenum target
, GLint level
, GLint internalformat
,
2777 GLsizei width
, GLint border
, GLenum format
,
2778 GLenum type
, const GLvoid
* pixels
)
2780 __glx_TexImage_1D2D(X_GLrop_TexImage1D
, 1, target
, level
, internalformat
,
2781 width
, 1, border
, format
, type
, pixels
);
2784 #define X_GLrop_TexImage2D 110
2786 __indirect_glTexImage2D(GLenum target
, GLint level
, GLint internalformat
,
2787 GLsizei width
, GLsizei height
, GLint border
,
2788 GLenum format
, GLenum type
, const GLvoid
* pixels
)
2790 __glx_TexImage_1D2D(X_GLrop_TexImage2D
, 2, target
, level
, internalformat
,
2791 width
, height
, border
, format
, type
, pixels
);
2794 #define X_GLrop_TexEnvf 111
2796 __indirect_glTexEnvf(GLenum target
, GLenum pname
, GLfloat param
)
2798 __GLXcontext
*const gc
= __glXGetCurrentContext();
2799 const GLuint cmdlen
= 16;
2800 emit_header(gc
->pc
, X_GLrop_TexEnvf
, cmdlen
);
2801 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&target
), 4);
2802 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&pname
), 4);
2803 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (¶m
), 4);
2805 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
2806 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
2810 #define X_GLrop_TexEnvfv 112
2812 __indirect_glTexEnvfv(GLenum target
, GLenum pname
, const GLfloat
* params
)
2814 __GLXcontext
*const gc
= __glXGetCurrentContext();
2815 const GLuint compsize
= __glTexEnvfv_size(pname
);
2816 const GLuint cmdlen
= 12 + __GLX_PAD((compsize
* 4));
2817 emit_header(gc
->pc
, X_GLrop_TexEnvfv
, cmdlen
);
2818 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&target
), 4);
2819 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&pname
), 4);
2820 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (params
), (compsize
* 4));
2822 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
2823 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
2827 #define X_GLrop_TexEnvi 113
2829 __indirect_glTexEnvi(GLenum target
, GLenum pname
, GLint param
)
2831 __GLXcontext
*const gc
= __glXGetCurrentContext();
2832 const GLuint cmdlen
= 16;
2833 emit_header(gc
->pc
, X_GLrop_TexEnvi
, cmdlen
);
2834 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&target
), 4);
2835 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&pname
), 4);
2836 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (¶m
), 4);
2838 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
2839 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
2843 #define X_GLrop_TexEnviv 114
2845 __indirect_glTexEnviv(GLenum target
, GLenum pname
, const GLint
* params
)
2847 __GLXcontext
*const gc
= __glXGetCurrentContext();
2848 const GLuint compsize
= __glTexEnviv_size(pname
);
2849 const GLuint cmdlen
= 12 + __GLX_PAD((compsize
* 4));
2850 emit_header(gc
->pc
, X_GLrop_TexEnviv
, cmdlen
);
2851 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&target
), 4);
2852 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&pname
), 4);
2853 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (params
), (compsize
* 4));
2855 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
2856 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
2860 #define X_GLrop_TexGend 115
2862 __indirect_glTexGend(GLenum coord
, GLenum pname
, GLdouble param
)
2864 __GLXcontext
*const gc
= __glXGetCurrentContext();
2865 const GLuint cmdlen
= 20;
2866 emit_header(gc
->pc
, X_GLrop_TexGend
, cmdlen
);
2867 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (¶m
), 8);
2868 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&coord
), 4);
2869 (void) memcpy((void *) (gc
->pc
+ 16), (void *) (&pname
), 4);
2871 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
2872 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
2876 #define X_GLrop_TexGendv 116
2878 __indirect_glTexGendv(GLenum coord
, GLenum pname
, const GLdouble
* params
)
2880 __GLXcontext
*const gc
= __glXGetCurrentContext();
2881 const GLuint compsize
= __glTexGendv_size(pname
);
2882 const GLuint cmdlen
= 12 + __GLX_PAD((compsize
* 8));
2883 emit_header(gc
->pc
, X_GLrop_TexGendv
, cmdlen
);
2884 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&coord
), 4);
2885 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&pname
), 4);
2886 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (params
), (compsize
* 8));
2888 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
2889 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
2893 #define X_GLrop_TexGenf 117
2895 __indirect_glTexGenf(GLenum coord
, GLenum pname
, GLfloat param
)
2897 __GLXcontext
*const gc
= __glXGetCurrentContext();
2898 const GLuint cmdlen
= 16;
2899 emit_header(gc
->pc
, X_GLrop_TexGenf
, cmdlen
);
2900 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&coord
), 4);
2901 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&pname
), 4);
2902 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (¶m
), 4);
2904 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
2905 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
2909 #define X_GLrop_TexGenfv 118
2911 __indirect_glTexGenfv(GLenum coord
, GLenum pname
, const GLfloat
* params
)
2913 __GLXcontext
*const gc
= __glXGetCurrentContext();
2914 const GLuint compsize
= __glTexGenfv_size(pname
);
2915 const GLuint cmdlen
= 12 + __GLX_PAD((compsize
* 4));
2916 emit_header(gc
->pc
, X_GLrop_TexGenfv
, cmdlen
);
2917 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&coord
), 4);
2918 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&pname
), 4);
2919 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (params
), (compsize
* 4));
2921 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
2922 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
2926 #define X_GLrop_TexGeni 119
2928 __indirect_glTexGeni(GLenum coord
, GLenum pname
, GLint param
)
2930 __GLXcontext
*const gc
= __glXGetCurrentContext();
2931 const GLuint cmdlen
= 16;
2932 emit_header(gc
->pc
, X_GLrop_TexGeni
, cmdlen
);
2933 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&coord
), 4);
2934 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&pname
), 4);
2935 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (¶m
), 4);
2937 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
2938 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
2942 #define X_GLrop_TexGeniv 120
2944 __indirect_glTexGeniv(GLenum coord
, GLenum pname
, const GLint
* params
)
2946 __GLXcontext
*const gc
= __glXGetCurrentContext();
2947 const GLuint compsize
= __glTexGeniv_size(pname
);
2948 const GLuint cmdlen
= 12 + __GLX_PAD((compsize
* 4));
2949 emit_header(gc
->pc
, X_GLrop_TexGeniv
, cmdlen
);
2950 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&coord
), 4);
2951 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&pname
), 4);
2952 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (params
), (compsize
* 4));
2954 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
2955 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
2959 #define X_GLrop_InitNames 121
2961 __indirect_glInitNames(void)
2963 __GLXcontext
*const gc
= __glXGetCurrentContext();
2964 const GLuint cmdlen
= 4;
2965 emit_header(gc
->pc
, X_GLrop_InitNames
, cmdlen
);
2967 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
2968 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
2972 #define X_GLrop_LoadName 122
2974 __indirect_glLoadName(GLuint name
)
2976 __GLXcontext
*const gc
= __glXGetCurrentContext();
2977 const GLuint cmdlen
= 8;
2978 emit_header(gc
->pc
, X_GLrop_LoadName
, cmdlen
);
2979 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&name
), 4);
2981 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
2982 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
2986 #define X_GLrop_PassThrough 123
2988 __indirect_glPassThrough(GLfloat token
)
2990 __GLXcontext
*const gc
= __glXGetCurrentContext();
2991 const GLuint cmdlen
= 8;
2992 emit_header(gc
->pc
, X_GLrop_PassThrough
, cmdlen
);
2993 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&token
), 4);
2995 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
2996 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
3000 #define X_GLrop_PopName 124
3002 __indirect_glPopName(void)
3004 __GLXcontext
*const gc
= __glXGetCurrentContext();
3005 const GLuint cmdlen
= 4;
3006 emit_header(gc
->pc
, X_GLrop_PopName
, cmdlen
);
3008 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
3009 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
3013 #define X_GLrop_PushName 125
3015 __indirect_glPushName(GLuint name
)
3017 __GLXcontext
*const gc
= __glXGetCurrentContext();
3018 const GLuint cmdlen
= 8;
3019 emit_header(gc
->pc
, X_GLrop_PushName
, cmdlen
);
3020 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&name
), 4);
3022 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
3023 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
3027 #define X_GLrop_DrawBuffer 126
3029 __indirect_glDrawBuffer(GLenum mode
)
3031 __GLXcontext
*const gc
= __glXGetCurrentContext();
3032 const GLuint cmdlen
= 8;
3033 emit_header(gc
->pc
, X_GLrop_DrawBuffer
, cmdlen
);
3034 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&mode
), 4);
3036 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
3037 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
3041 #define X_GLrop_Clear 127
3043 __indirect_glClear(GLbitfield mask
)
3045 __GLXcontext
*const gc
= __glXGetCurrentContext();
3046 const GLuint cmdlen
= 8;
3047 emit_header(gc
->pc
, X_GLrop_Clear
, cmdlen
);
3048 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&mask
), 4);
3050 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
3051 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
3055 #define X_GLrop_ClearAccum 128
3057 __indirect_glClearAccum(GLfloat red
, GLfloat green
, GLfloat blue
,
3060 __GLXcontext
*const gc
= __glXGetCurrentContext();
3061 const GLuint cmdlen
= 20;
3062 emit_header(gc
->pc
, X_GLrop_ClearAccum
, cmdlen
);
3063 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&red
), 4);
3064 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&green
), 4);
3065 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&blue
), 4);
3066 (void) memcpy((void *) (gc
->pc
+ 16), (void *) (&alpha
), 4);
3068 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
3069 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
3073 #define X_GLrop_ClearIndex 129
3075 __indirect_glClearIndex(GLfloat c
)
3077 __GLXcontext
*const gc
= __glXGetCurrentContext();
3078 const GLuint cmdlen
= 8;
3079 emit_header(gc
->pc
, X_GLrop_ClearIndex
, cmdlen
);
3080 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&c
), 4);
3082 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
3083 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
3087 #define X_GLrop_ClearColor 130
3089 __indirect_glClearColor(GLclampf red
, GLclampf green
, GLclampf blue
,
3092 __GLXcontext
*const gc
= __glXGetCurrentContext();
3093 const GLuint cmdlen
= 20;
3094 emit_header(gc
->pc
, X_GLrop_ClearColor
, cmdlen
);
3095 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&red
), 4);
3096 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&green
), 4);
3097 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&blue
), 4);
3098 (void) memcpy((void *) (gc
->pc
+ 16), (void *) (&alpha
), 4);
3100 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
3101 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
3105 #define X_GLrop_ClearStencil 131
3107 __indirect_glClearStencil(GLint s
)
3109 __GLXcontext
*const gc
= __glXGetCurrentContext();
3110 const GLuint cmdlen
= 8;
3111 emit_header(gc
->pc
, X_GLrop_ClearStencil
, cmdlen
);
3112 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&s
), 4);
3114 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
3115 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
3119 #define X_GLrop_ClearDepth 132
3121 __indirect_glClearDepth(GLclampd depth
)
3123 __GLXcontext
*const gc
= __glXGetCurrentContext();
3124 const GLuint cmdlen
= 12;
3125 emit_header(gc
->pc
, X_GLrop_ClearDepth
, cmdlen
);
3126 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&depth
), 8);
3128 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
3129 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
3133 #define X_GLrop_StencilMask 133
3135 __indirect_glStencilMask(GLuint mask
)
3137 __GLXcontext
*const gc
= __glXGetCurrentContext();
3138 const GLuint cmdlen
= 8;
3139 emit_header(gc
->pc
, X_GLrop_StencilMask
, cmdlen
);
3140 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&mask
), 4);
3142 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
3143 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
3147 #define X_GLrop_ColorMask 134
3149 __indirect_glColorMask(GLboolean red
, GLboolean green
, GLboolean blue
,
3152 __GLXcontext
*const gc
= __glXGetCurrentContext();
3153 const GLuint cmdlen
= 8;
3154 emit_header(gc
->pc
, X_GLrop_ColorMask
, cmdlen
);
3155 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&red
), 1);
3156 (void) memcpy((void *) (gc
->pc
+ 5), (void *) (&green
), 1);
3157 (void) memcpy((void *) (gc
->pc
+ 6), (void *) (&blue
), 1);
3158 (void) memcpy((void *) (gc
->pc
+ 7), (void *) (&alpha
), 1);
3160 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
3161 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
3165 #define X_GLrop_DepthMask 135
3167 __indirect_glDepthMask(GLboolean flag
)
3169 __GLXcontext
*const gc
= __glXGetCurrentContext();
3170 const GLuint cmdlen
= 8;
3171 emit_header(gc
->pc
, X_GLrop_DepthMask
, cmdlen
);
3172 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&flag
), 1);
3174 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
3175 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
3179 #define X_GLrop_IndexMask 136
3181 __indirect_glIndexMask(GLuint mask
)
3183 __GLXcontext
*const gc
= __glXGetCurrentContext();
3184 const GLuint cmdlen
= 8;
3185 emit_header(gc
->pc
, X_GLrop_IndexMask
, cmdlen
);
3186 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&mask
), 4);
3188 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
3189 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
3193 #define X_GLrop_Accum 137
3195 __indirect_glAccum(GLenum op
, GLfloat value
)
3197 __GLXcontext
*const gc
= __glXGetCurrentContext();
3198 const GLuint cmdlen
= 12;
3199 emit_header(gc
->pc
, X_GLrop_Accum
, cmdlen
);
3200 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&op
), 4);
3201 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&value
), 4);
3203 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
3204 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
3208 #define X_GLrop_PopAttrib 141
3210 __indirect_glPopAttrib(void)
3212 __GLXcontext
*const gc
= __glXGetCurrentContext();
3213 const GLuint cmdlen
= 4;
3214 emit_header(gc
->pc
, X_GLrop_PopAttrib
, cmdlen
);
3216 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
3217 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
3221 #define X_GLrop_PushAttrib 142
3223 __indirect_glPushAttrib(GLbitfield mask
)
3225 __GLXcontext
*const gc
= __glXGetCurrentContext();
3226 const GLuint cmdlen
= 8;
3227 emit_header(gc
->pc
, X_GLrop_PushAttrib
, cmdlen
);
3228 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&mask
), 4);
3230 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
3231 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
3235 #define X_GLrop_MapGrid1d 147
3237 __indirect_glMapGrid1d(GLint un
, GLdouble u1
, GLdouble u2
)
3239 __GLXcontext
*const gc
= __glXGetCurrentContext();
3240 const GLuint cmdlen
= 24;
3241 emit_header(gc
->pc
, X_GLrop_MapGrid1d
, cmdlen
);
3242 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&u1
), 8);
3243 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&u2
), 8);
3244 (void) memcpy((void *) (gc
->pc
+ 20), (void *) (&un
), 4);
3246 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
3247 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
3251 #define X_GLrop_MapGrid1f 148
3253 __indirect_glMapGrid1f(GLint un
, GLfloat u1
, GLfloat u2
)
3255 __GLXcontext
*const gc
= __glXGetCurrentContext();
3256 const GLuint cmdlen
= 16;
3257 emit_header(gc
->pc
, X_GLrop_MapGrid1f
, cmdlen
);
3258 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&un
), 4);
3259 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&u1
), 4);
3260 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&u2
), 4);
3262 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
3263 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
3267 #define X_GLrop_MapGrid2d 149
3269 __indirect_glMapGrid2d(GLint un
, GLdouble u1
, GLdouble u2
, GLint vn
,
3270 GLdouble v1
, GLdouble v2
)
3272 __GLXcontext
*const gc
= __glXGetCurrentContext();
3273 const GLuint cmdlen
= 44;
3274 emit_header(gc
->pc
, X_GLrop_MapGrid2d
, cmdlen
);
3275 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&u1
), 8);
3276 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&u2
), 8);
3277 (void) memcpy((void *) (gc
->pc
+ 20), (void *) (&v1
), 8);
3278 (void) memcpy((void *) (gc
->pc
+ 28), (void *) (&v2
), 8);
3279 (void) memcpy((void *) (gc
->pc
+ 36), (void *) (&un
), 4);
3280 (void) memcpy((void *) (gc
->pc
+ 40), (void *) (&vn
), 4);
3282 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
3283 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
3287 #define X_GLrop_MapGrid2f 150
3289 __indirect_glMapGrid2f(GLint un
, GLfloat u1
, GLfloat u2
, GLint vn
, GLfloat v1
,
3292 __GLXcontext
*const gc
= __glXGetCurrentContext();
3293 const GLuint cmdlen
= 28;
3294 emit_header(gc
->pc
, X_GLrop_MapGrid2f
, cmdlen
);
3295 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&un
), 4);
3296 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&u1
), 4);
3297 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&u2
), 4);
3298 (void) memcpy((void *) (gc
->pc
+ 16), (void *) (&vn
), 4);
3299 (void) memcpy((void *) (gc
->pc
+ 20), (void *) (&v1
), 4);
3300 (void) memcpy((void *) (gc
->pc
+ 24), (void *) (&v2
), 4);
3302 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
3303 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
3307 #define X_GLrop_EvalCoord1dv 151
3309 __indirect_glEvalCoord1d(GLdouble u
)
3311 __GLXcontext
*const gc
= __glXGetCurrentContext();
3312 const GLuint cmdlen
= 12;
3313 emit_header(gc
->pc
, X_GLrop_EvalCoord1dv
, cmdlen
);
3314 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&u
), 8);
3316 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
3317 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
3321 #define X_GLrop_EvalCoord1dv 151
3323 __indirect_glEvalCoord1dv(const GLdouble
* u
)
3325 generic_8_byte(X_GLrop_EvalCoord1dv
, u
);
3328 #define X_GLrop_EvalCoord1fv 152
3330 __indirect_glEvalCoord1f(GLfloat u
)
3332 __GLXcontext
*const gc
= __glXGetCurrentContext();
3333 const GLuint cmdlen
= 8;
3334 emit_header(gc
->pc
, X_GLrop_EvalCoord1fv
, cmdlen
);
3335 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&u
), 4);
3337 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
3338 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
3342 #define X_GLrop_EvalCoord1fv 152
3344 __indirect_glEvalCoord1fv(const GLfloat
* u
)
3346 generic_4_byte(X_GLrop_EvalCoord1fv
, u
);
3349 #define X_GLrop_EvalCoord2dv 153
3351 __indirect_glEvalCoord2d(GLdouble u
, GLdouble v
)
3353 __GLXcontext
*const gc
= __glXGetCurrentContext();
3354 const GLuint cmdlen
= 20;
3355 emit_header(gc
->pc
, X_GLrop_EvalCoord2dv
, cmdlen
);
3356 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&u
), 8);
3357 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&v
), 8);
3359 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
3360 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
3364 #define X_GLrop_EvalCoord2dv 153
3366 __indirect_glEvalCoord2dv(const GLdouble
* u
)
3368 generic_16_byte(X_GLrop_EvalCoord2dv
, u
);
3371 #define X_GLrop_EvalCoord2fv 154
3373 __indirect_glEvalCoord2f(GLfloat u
, GLfloat v
)
3375 __GLXcontext
*const gc
= __glXGetCurrentContext();
3376 const GLuint cmdlen
= 12;
3377 emit_header(gc
->pc
, X_GLrop_EvalCoord2fv
, cmdlen
);
3378 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&u
), 4);
3379 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&v
), 4);
3381 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
3382 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
3386 #define X_GLrop_EvalCoord2fv 154
3388 __indirect_glEvalCoord2fv(const GLfloat
* u
)
3390 generic_8_byte(X_GLrop_EvalCoord2fv
, u
);
3393 #define X_GLrop_EvalMesh1 155
3395 __indirect_glEvalMesh1(GLenum mode
, GLint i1
, GLint i2
)
3397 __GLXcontext
*const gc
= __glXGetCurrentContext();
3398 const GLuint cmdlen
= 16;
3399 emit_header(gc
->pc
, X_GLrop_EvalMesh1
, cmdlen
);
3400 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&mode
), 4);
3401 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&i1
), 4);
3402 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&i2
), 4);
3404 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
3405 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
3409 #define X_GLrop_EvalPoint1 156
3411 __indirect_glEvalPoint1(GLint i
)
3413 __GLXcontext
*const gc
= __glXGetCurrentContext();
3414 const GLuint cmdlen
= 8;
3415 emit_header(gc
->pc
, X_GLrop_EvalPoint1
, cmdlen
);
3416 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&i
), 4);
3418 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
3419 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
3423 #define X_GLrop_EvalMesh2 157
3425 __indirect_glEvalMesh2(GLenum mode
, GLint i1
, GLint i2
, GLint j1
, GLint j2
)
3427 __GLXcontext
*const gc
= __glXGetCurrentContext();
3428 const GLuint cmdlen
= 24;
3429 emit_header(gc
->pc
, X_GLrop_EvalMesh2
, cmdlen
);
3430 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&mode
), 4);
3431 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&i1
), 4);
3432 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&i2
), 4);
3433 (void) memcpy((void *) (gc
->pc
+ 16), (void *) (&j1
), 4);
3434 (void) memcpy((void *) (gc
->pc
+ 20), (void *) (&j2
), 4);
3436 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
3437 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
3441 #define X_GLrop_EvalPoint2 158
3443 __indirect_glEvalPoint2(GLint i
, GLint j
)
3445 __GLXcontext
*const gc
= __glXGetCurrentContext();
3446 const GLuint cmdlen
= 12;
3447 emit_header(gc
->pc
, X_GLrop_EvalPoint2
, cmdlen
);
3448 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&i
), 4);
3449 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&j
), 4);
3451 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
3452 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
3456 #define X_GLrop_AlphaFunc 159
3458 __indirect_glAlphaFunc(GLenum func
, GLclampf ref
)
3460 __GLXcontext
*const gc
= __glXGetCurrentContext();
3461 const GLuint cmdlen
= 12;
3462 emit_header(gc
->pc
, X_GLrop_AlphaFunc
, cmdlen
);
3463 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&func
), 4);
3464 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&ref
), 4);
3466 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
3467 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
3471 #define X_GLrop_BlendFunc 160
3473 __indirect_glBlendFunc(GLenum sfactor
, GLenum dfactor
)
3475 __GLXcontext
*const gc
= __glXGetCurrentContext();
3476 const GLuint cmdlen
= 12;
3477 emit_header(gc
->pc
, X_GLrop_BlendFunc
, cmdlen
);
3478 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&sfactor
), 4);
3479 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&dfactor
), 4);
3481 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
3482 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
3486 #define X_GLrop_LogicOp 161
3488 __indirect_glLogicOp(GLenum opcode
)
3490 __GLXcontext
*const gc
= __glXGetCurrentContext();
3491 const GLuint cmdlen
= 8;
3492 emit_header(gc
->pc
, X_GLrop_LogicOp
, cmdlen
);
3493 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&opcode
), 4);
3495 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
3496 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
3500 #define X_GLrop_StencilFunc 162
3502 __indirect_glStencilFunc(GLenum func
, GLint ref
, GLuint mask
)
3504 __GLXcontext
*const gc
= __glXGetCurrentContext();
3505 const GLuint cmdlen
= 16;
3506 emit_header(gc
->pc
, X_GLrop_StencilFunc
, cmdlen
);
3507 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&func
), 4);
3508 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&ref
), 4);
3509 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&mask
), 4);
3511 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
3512 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
3516 #define X_GLrop_StencilOp 163
3518 __indirect_glStencilOp(GLenum fail
, GLenum zfail
, GLenum zpass
)
3520 __GLXcontext
*const gc
= __glXGetCurrentContext();
3521 const GLuint cmdlen
= 16;
3522 emit_header(gc
->pc
, X_GLrop_StencilOp
, cmdlen
);
3523 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&fail
), 4);
3524 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&zfail
), 4);
3525 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&zpass
), 4);
3527 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
3528 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
3532 #define X_GLrop_DepthFunc 164
3534 __indirect_glDepthFunc(GLenum func
)
3536 __GLXcontext
*const gc
= __glXGetCurrentContext();
3537 const GLuint cmdlen
= 8;
3538 emit_header(gc
->pc
, X_GLrop_DepthFunc
, cmdlen
);
3539 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&func
), 4);
3541 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
3542 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
3546 #define X_GLrop_PixelZoom 165
3548 __indirect_glPixelZoom(GLfloat xfactor
, GLfloat yfactor
)
3550 __GLXcontext
*const gc
= __glXGetCurrentContext();
3551 const GLuint cmdlen
= 12;
3552 emit_header(gc
->pc
, X_GLrop_PixelZoom
, cmdlen
);
3553 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&xfactor
), 4);
3554 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&yfactor
), 4);
3556 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
3557 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
3561 #define X_GLrop_PixelTransferf 166
3563 __indirect_glPixelTransferf(GLenum pname
, GLfloat param
)
3565 __GLXcontext
*const gc
= __glXGetCurrentContext();
3566 const GLuint cmdlen
= 12;
3567 emit_header(gc
->pc
, X_GLrop_PixelTransferf
, cmdlen
);
3568 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&pname
), 4);
3569 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (¶m
), 4);
3571 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
3572 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
3576 #define X_GLrop_PixelTransferi 167
3578 __indirect_glPixelTransferi(GLenum pname
, GLint param
)
3580 __GLXcontext
*const gc
= __glXGetCurrentContext();
3581 const GLuint cmdlen
= 12;
3582 emit_header(gc
->pc
, X_GLrop_PixelTransferi
, cmdlen
);
3583 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&pname
), 4);
3584 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (¶m
), 4);
3586 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
3587 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
3591 #define X_GLrop_PixelMapfv 168
3593 __indirect_glPixelMapfv(GLenum map
, GLsizei mapsize
, const GLfloat
* values
)
3595 __GLXcontext
*const gc
= __glXGetCurrentContext();
3596 const GLuint cmdlen
= 12 + __GLX_PAD((mapsize
* 4));
3598 __glXSetError(gc
, GL_INVALID_VALUE
);
3601 if (__builtin_expect((mapsize
>= 0) && (gc
->currentDpy
!= NULL
), 1)) {
3602 if (cmdlen
<= gc
->maxSmallRenderCommandSize
) {
3603 if ((gc
->pc
+ cmdlen
) > gc
->bufEnd
) {
3604 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
3606 emit_header(gc
->pc
, X_GLrop_PixelMapfv
, cmdlen
);
3607 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&map
), 4);
3608 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&mapsize
), 4);
3609 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (values
),
3612 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
3613 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
3616 const GLint op
= X_GLrop_PixelMapfv
;
3617 const GLuint cmdlenLarge
= cmdlen
+ 4;
3618 GLubyte
*const pc
= __glXFlushRenderBuffer(gc
, gc
->pc
);
3619 (void) memcpy((void *) (pc
+ 0), (void *) (&cmdlenLarge
), 4);
3620 (void) memcpy((void *) (pc
+ 4), (void *) (&op
), 4);
3621 (void) memcpy((void *) (pc
+ 8), (void *) (&map
), 4);
3622 (void) memcpy((void *) (pc
+ 12), (void *) (&mapsize
), 4);
3623 __glXSendLargeCommand(gc
, pc
, 16, values
, (mapsize
* 4));
3628 #define X_GLrop_PixelMapuiv 169
3630 __indirect_glPixelMapuiv(GLenum map
, GLsizei mapsize
, const GLuint
* values
)
3632 __GLXcontext
*const gc
= __glXGetCurrentContext();
3633 const GLuint cmdlen
= 12 + __GLX_PAD((mapsize
* 4));
3635 __glXSetError(gc
, GL_INVALID_VALUE
);
3638 if (__builtin_expect((mapsize
>= 0) && (gc
->currentDpy
!= NULL
), 1)) {
3639 if (cmdlen
<= gc
->maxSmallRenderCommandSize
) {
3640 if ((gc
->pc
+ cmdlen
) > gc
->bufEnd
) {
3641 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
3643 emit_header(gc
->pc
, X_GLrop_PixelMapuiv
, cmdlen
);
3644 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&map
), 4);
3645 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&mapsize
), 4);
3646 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (values
),
3649 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
3650 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
3653 const GLint op
= X_GLrop_PixelMapuiv
;
3654 const GLuint cmdlenLarge
= cmdlen
+ 4;
3655 GLubyte
*const pc
= __glXFlushRenderBuffer(gc
, gc
->pc
);
3656 (void) memcpy((void *) (pc
+ 0), (void *) (&cmdlenLarge
), 4);
3657 (void) memcpy((void *) (pc
+ 4), (void *) (&op
), 4);
3658 (void) memcpy((void *) (pc
+ 8), (void *) (&map
), 4);
3659 (void) memcpy((void *) (pc
+ 12), (void *) (&mapsize
), 4);
3660 __glXSendLargeCommand(gc
, pc
, 16, values
, (mapsize
* 4));
3665 #define X_GLrop_PixelMapusv 170
3667 __indirect_glPixelMapusv(GLenum map
, GLsizei mapsize
, const GLushort
* values
)
3669 __GLXcontext
*const gc
= __glXGetCurrentContext();
3670 const GLuint cmdlen
= 12 + __GLX_PAD((mapsize
* 2));
3672 __glXSetError(gc
, GL_INVALID_VALUE
);
3675 if (__builtin_expect((mapsize
>= 0) && (gc
->currentDpy
!= NULL
), 1)) {
3676 if (cmdlen
<= gc
->maxSmallRenderCommandSize
) {
3677 if ((gc
->pc
+ cmdlen
) > gc
->bufEnd
) {
3678 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
3680 emit_header(gc
->pc
, X_GLrop_PixelMapusv
, cmdlen
);
3681 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&map
), 4);
3682 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&mapsize
), 4);
3683 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (values
),
3686 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
3687 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
3690 const GLint op
= X_GLrop_PixelMapusv
;
3691 const GLuint cmdlenLarge
= cmdlen
+ 4;
3692 GLubyte
*const pc
= __glXFlushRenderBuffer(gc
, gc
->pc
);
3693 (void) memcpy((void *) (pc
+ 0), (void *) (&cmdlenLarge
), 4);
3694 (void) memcpy((void *) (pc
+ 4), (void *) (&op
), 4);
3695 (void) memcpy((void *) (pc
+ 8), (void *) (&map
), 4);
3696 (void) memcpy((void *) (pc
+ 12), (void *) (&mapsize
), 4);
3697 __glXSendLargeCommand(gc
, pc
, 16, values
, (mapsize
* 2));
3702 #define X_GLrop_ReadBuffer 171
3704 __indirect_glReadBuffer(GLenum mode
)
3706 __GLXcontext
*const gc
= __glXGetCurrentContext();
3707 const GLuint cmdlen
= 8;
3708 emit_header(gc
->pc
, X_GLrop_ReadBuffer
, cmdlen
);
3709 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&mode
), 4);
3711 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
3712 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
3716 #define X_GLrop_CopyPixels 172
3718 __indirect_glCopyPixels(GLint x
, GLint y
, GLsizei width
, GLsizei height
,
3721 __GLXcontext
*const gc
= __glXGetCurrentContext();
3722 const GLuint cmdlen
= 24;
3723 emit_header(gc
->pc
, X_GLrop_CopyPixels
, cmdlen
);
3724 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&x
), 4);
3725 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&y
), 4);
3726 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&width
), 4);
3727 (void) memcpy((void *) (gc
->pc
+ 16), (void *) (&height
), 4);
3728 (void) memcpy((void *) (gc
->pc
+ 20), (void *) (&type
), 4);
3730 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
3731 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
3735 #define X_GLsop_ReadPixels 111
3737 __indirect_glReadPixels(GLint x
, GLint y
, GLsizei width
, GLsizei height
,
3738 GLenum format
, GLenum type
, GLvoid
* pixels
)
3740 __GLXcontext
*const gc
= __glXGetCurrentContext();
3741 const __GLXattribute
*const state
= gc
->client_state_private
;
3742 Display
*const dpy
= gc
->currentDpy
;
3744 const GLuint cmdlen
= 28;
3746 if (__builtin_expect(dpy
!= NULL
, 1)) {
3748 xcb_connection_t
*c
= XGetXCBConnection(dpy
);
3749 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
3750 xcb_glx_read_pixels_reply_t
*reply
=
3751 xcb_glx_read_pixels_reply(c
,
3752 xcb_glx_read_pixels(c
,
3755 x
, y
, width
, height
,
3760 (void) memcpy(pixels
, xcb_glx_read_pixels_data(reply
),
3761 xcb_glx_read_pixels_data_length(reply
) *
3766 __glXSetupSingleRequest(gc
, X_GLsop_ReadPixels
, cmdlen
);
3767 (void) memcpy((void *) (pc
+ 0), (void *) (&x
), 4);
3768 (void) memcpy((void *) (pc
+ 4), (void *) (&y
), 4);
3769 (void) memcpy((void *) (pc
+ 8), (void *) (&width
), 4);
3770 (void) memcpy((void *) (pc
+ 12), (void *) (&height
), 4);
3771 (void) memcpy((void *) (pc
+ 16), (void *) (&format
), 4);
3772 (void) memcpy((void *) (pc
+ 20), (void *) (&type
), 4);
3773 *(int32_t *) (pc
+ 24) = 0;
3774 *(int8_t *) (pc
+ 24) = state
->storePack
.swapEndian
;
3775 __glXReadPixelReply(dpy
, gc
, 2, width
, height
, 1, format
, type
,
3779 #endif /* USE_XCB */
3784 #define X_GLrop_DrawPixels 173
3786 __indirect_glDrawPixels(GLsizei width
, GLsizei height
, GLenum format
,
3787 GLenum type
, const GLvoid
* pixels
)
3789 __GLXcontext
*const gc
= __glXGetCurrentContext();
3790 const GLuint compsize
=
3791 (pixels
!= NULL
) ? __glImageSize(width
, height
, 1, format
, type
,
3793 const GLuint cmdlen
= 40 + __GLX_PAD(compsize
);
3794 if (__builtin_expect(gc
->currentDpy
!= NULL
, 1)) {
3795 if (cmdlen
<= gc
->maxSmallRenderCommandSize
) {
3796 if ((gc
->pc
+ cmdlen
) > gc
->bufEnd
) {
3797 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
3799 emit_header(gc
->pc
, X_GLrop_DrawPixels
, cmdlen
);
3800 (void) memcpy((void *) (gc
->pc
+ 24), (void *) (&width
), 4);
3801 (void) memcpy((void *) (gc
->pc
+ 28), (void *) (&height
), 4);
3802 (void) memcpy((void *) (gc
->pc
+ 32), (void *) (&format
), 4);
3803 (void) memcpy((void *) (gc
->pc
+ 36), (void *) (&type
), 4);
3805 (*gc
->fillImage
) (gc
, 2, width
, height
, 1, format
, type
,
3806 pixels
, gc
->pc
+ 40, gc
->pc
+ 4);
3808 (void) memcpy(gc
->pc
+ 4, default_pixel_store_2D
,
3809 default_pixel_store_2D_size
);
3812 if (gc
->pc
> gc
->limit
) {
3813 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
3816 const GLint op
= X_GLrop_DrawPixels
;
3817 const GLuint cmdlenLarge
= cmdlen
+ 4;
3818 GLubyte
*const pc
= __glXFlushRenderBuffer(gc
, gc
->pc
);
3819 (void) memcpy((void *) (pc
+ 0), (void *) (&cmdlenLarge
), 4);
3820 (void) memcpy((void *) (pc
+ 4), (void *) (&op
), 4);
3821 (void) memcpy((void *) (pc
+ 28), (void *) (&width
), 4);
3822 (void) memcpy((void *) (pc
+ 32), (void *) (&height
), 4);
3823 (void) memcpy((void *) (pc
+ 36), (void *) (&format
), 4);
3824 (void) memcpy((void *) (pc
+ 40), (void *) (&type
), 4);
3825 __glXSendLargeImage(gc
, compsize
, 2, width
, height
, 1, format
,
3826 type
, pixels
, pc
+ 44, pc
+ 8);
3831 #define X_GLsop_GetClipPlane 113
3833 __indirect_glGetClipPlane(GLenum plane
, GLdouble
* equation
)
3835 __GLXcontext
*const gc
= __glXGetCurrentContext();
3836 Display
*const dpy
= gc
->currentDpy
;
3838 const GLuint cmdlen
= 4;
3840 if (__builtin_expect(dpy
!= NULL
, 1)) {
3842 xcb_connection_t
*c
= XGetXCBConnection(dpy
);
3843 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
3844 xcb_glx_get_clip_plane_reply_t
*reply
=
3845 xcb_glx_get_clip_plane_reply(c
,
3846 xcb_glx_get_clip_plane(c
,
3850 (void) memcpy(equation
, xcb_glx_get_clip_plane_data(reply
),
3851 xcb_glx_get_clip_plane_data_length(reply
) *
3856 __glXSetupSingleRequest(gc
, X_GLsop_GetClipPlane
, cmdlen
);
3857 (void) memcpy((void *) (pc
+ 0), (void *) (&plane
), 4);
3858 (void) __glXReadReply(dpy
, 8, equation
, GL_TRUE
);
3861 #endif /* USE_XCB */
3866 #define X_GLsop_GetLightfv 118
3868 __indirect_glGetLightfv(GLenum light
, GLenum pname
, GLfloat
* params
)
3870 __GLXcontext
*const gc
= __glXGetCurrentContext();
3871 Display
*const dpy
= gc
->currentDpy
;
3873 const GLuint cmdlen
= 8;
3875 if (__builtin_expect(dpy
!= NULL
, 1)) {
3877 xcb_connection_t
*c
= XGetXCBConnection(dpy
);
3878 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
3879 xcb_glx_get_lightfv_reply_t
*reply
=
3880 xcb_glx_get_lightfv_reply(c
,
3881 xcb_glx_get_lightfv(c
,
3886 if (xcb_glx_get_lightfv_data_length(reply
) == 0)
3887 (void) memcpy(params
, &reply
->datum
, sizeof(reply
->datum
));
3889 (void) memcpy(params
, xcb_glx_get_lightfv_data(reply
),
3890 xcb_glx_get_lightfv_data_length(reply
) *
3895 __glXSetupSingleRequest(gc
, X_GLsop_GetLightfv
, cmdlen
);
3896 (void) memcpy((void *) (pc
+ 0), (void *) (&light
), 4);
3897 (void) memcpy((void *) (pc
+ 4), (void *) (&pname
), 4);
3898 (void) __glXReadReply(dpy
, 4, params
, GL_FALSE
);
3901 #endif /* USE_XCB */
3906 #define X_GLsop_GetLightiv 119
3908 __indirect_glGetLightiv(GLenum light
, GLenum pname
, GLint
* params
)
3910 __GLXcontext
*const gc
= __glXGetCurrentContext();
3911 Display
*const dpy
= gc
->currentDpy
;
3913 const GLuint cmdlen
= 8;
3915 if (__builtin_expect(dpy
!= NULL
, 1)) {
3917 xcb_connection_t
*c
= XGetXCBConnection(dpy
);
3918 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
3919 xcb_glx_get_lightiv_reply_t
*reply
=
3920 xcb_glx_get_lightiv_reply(c
,
3921 xcb_glx_get_lightiv(c
,
3926 if (xcb_glx_get_lightiv_data_length(reply
) == 0)
3927 (void) memcpy(params
, &reply
->datum
, sizeof(reply
->datum
));
3929 (void) memcpy(params
, xcb_glx_get_lightiv_data(reply
),
3930 xcb_glx_get_lightiv_data_length(reply
) *
3935 __glXSetupSingleRequest(gc
, X_GLsop_GetLightiv
, cmdlen
);
3936 (void) memcpy((void *) (pc
+ 0), (void *) (&light
), 4);
3937 (void) memcpy((void *) (pc
+ 4), (void *) (&pname
), 4);
3938 (void) __glXReadReply(dpy
, 4, params
, GL_FALSE
);
3941 #endif /* USE_XCB */
3946 #define X_GLsop_GetMapdv 120
3948 __indirect_glGetMapdv(GLenum target
, GLenum query
, GLdouble
* v
)
3950 __GLXcontext
*const gc
= __glXGetCurrentContext();
3951 Display
*const dpy
= gc
->currentDpy
;
3953 const GLuint cmdlen
= 8;
3955 if (__builtin_expect(dpy
!= NULL
, 1)) {
3957 xcb_connection_t
*c
= XGetXCBConnection(dpy
);
3958 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
3959 xcb_glx_get_mapdv_reply_t
*reply
=
3960 xcb_glx_get_mapdv_reply(c
,
3961 xcb_glx_get_mapdv(c
,
3962 gc
->currentContextTag
,
3963 target
, query
), NULL
);
3964 if (xcb_glx_get_mapdv_data_length(reply
) == 0)
3965 (void) memcpy(v
, &reply
->datum
, sizeof(reply
->datum
));
3967 (void) memcpy(v
, xcb_glx_get_mapdv_data(reply
),
3968 xcb_glx_get_mapdv_data_length(reply
) *
3973 __glXSetupSingleRequest(gc
, X_GLsop_GetMapdv
, cmdlen
);
3974 (void) memcpy((void *) (pc
+ 0), (void *) (&target
), 4);
3975 (void) memcpy((void *) (pc
+ 4), (void *) (&query
), 4);
3976 (void) __glXReadReply(dpy
, 8, v
, GL_FALSE
);
3979 #endif /* USE_XCB */
3984 #define X_GLsop_GetMapfv 121
3986 __indirect_glGetMapfv(GLenum target
, GLenum query
, GLfloat
* v
)
3988 __GLXcontext
*const gc
= __glXGetCurrentContext();
3989 Display
*const dpy
= gc
->currentDpy
;
3991 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_mapfv_reply_t
*reply
=
3998 xcb_glx_get_mapfv_reply(c
,
3999 xcb_glx_get_mapfv(c
,
4000 gc
->currentContextTag
,
4001 target
, query
), NULL
);
4002 if (xcb_glx_get_mapfv_data_length(reply
) == 0)
4003 (void) memcpy(v
, &reply
->datum
, sizeof(reply
->datum
));
4005 (void) memcpy(v
, xcb_glx_get_mapfv_data(reply
),
4006 xcb_glx_get_mapfv_data_length(reply
) *
4011 __glXSetupSingleRequest(gc
, X_GLsop_GetMapfv
, 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_GetMapiv 122
4024 __indirect_glGetMapiv(GLenum target
, GLenum query
, GLint
* v
)
4026 __GLXcontext
*const gc
= __glXGetCurrentContext();
4027 Display
*const dpy
= gc
->currentDpy
;
4029 const GLuint cmdlen
= 8;
4031 if (__builtin_expect(dpy
!= NULL
, 1)) {
4033 xcb_connection_t
*c
= XGetXCBConnection(dpy
);
4034 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
4035 xcb_glx_get_mapiv_reply_t
*reply
=
4036 xcb_glx_get_mapiv_reply(c
,
4037 xcb_glx_get_mapiv(c
,
4038 gc
->currentContextTag
,
4039 target
, query
), NULL
);
4040 if (xcb_glx_get_mapiv_data_length(reply
) == 0)
4041 (void) memcpy(v
, &reply
->datum
, sizeof(reply
->datum
));
4043 (void) memcpy(v
, xcb_glx_get_mapiv_data(reply
),
4044 xcb_glx_get_mapiv_data_length(reply
) *
4049 __glXSetupSingleRequest(gc
, X_GLsop_GetMapiv
, cmdlen
);
4050 (void) memcpy((void *) (pc
+ 0), (void *) (&target
), 4);
4051 (void) memcpy((void *) (pc
+ 4), (void *) (&query
), 4);
4052 (void) __glXReadReply(dpy
, 4, v
, GL_FALSE
);
4055 #endif /* USE_XCB */
4060 #define X_GLsop_GetMaterialfv 123
4062 __indirect_glGetMaterialfv(GLenum face
, GLenum pname
, GLfloat
* params
)
4064 __GLXcontext
*const gc
= __glXGetCurrentContext();
4065 Display
*const dpy
= gc
->currentDpy
;
4067 const GLuint cmdlen
= 8;
4069 if (__builtin_expect(dpy
!= NULL
, 1)) {
4071 xcb_connection_t
*c
= XGetXCBConnection(dpy
);
4072 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
4073 xcb_glx_get_materialfv_reply_t
*reply
=
4074 xcb_glx_get_materialfv_reply(c
,
4075 xcb_glx_get_materialfv(c
,
4080 if (xcb_glx_get_materialfv_data_length(reply
) == 0)
4081 (void) memcpy(params
, &reply
->datum
, sizeof(reply
->datum
));
4083 (void) memcpy(params
, xcb_glx_get_materialfv_data(reply
),
4084 xcb_glx_get_materialfv_data_length(reply
) *
4089 __glXSetupSingleRequest(gc
, X_GLsop_GetMaterialfv
, cmdlen
);
4090 (void) memcpy((void *) (pc
+ 0), (void *) (&face
), 4);
4091 (void) memcpy((void *) (pc
+ 4), (void *) (&pname
), 4);
4092 (void) __glXReadReply(dpy
, 4, params
, GL_FALSE
);
4095 #endif /* USE_XCB */
4100 #define X_GLsop_GetMaterialiv 124
4102 __indirect_glGetMaterialiv(GLenum face
, GLenum pname
, GLint
* params
)
4104 __GLXcontext
*const gc
= __glXGetCurrentContext();
4105 Display
*const dpy
= gc
->currentDpy
;
4107 const GLuint cmdlen
= 8;
4109 if (__builtin_expect(dpy
!= NULL
, 1)) {
4111 xcb_connection_t
*c
= XGetXCBConnection(dpy
);
4112 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
4113 xcb_glx_get_materialiv_reply_t
*reply
=
4114 xcb_glx_get_materialiv_reply(c
,
4115 xcb_glx_get_materialiv(c
,
4120 if (xcb_glx_get_materialiv_data_length(reply
) == 0)
4121 (void) memcpy(params
, &reply
->datum
, sizeof(reply
->datum
));
4123 (void) memcpy(params
, xcb_glx_get_materialiv_data(reply
),
4124 xcb_glx_get_materialiv_data_length(reply
) *
4129 __glXSetupSingleRequest(gc
, X_GLsop_GetMaterialiv
, cmdlen
);
4130 (void) memcpy((void *) (pc
+ 0), (void *) (&face
), 4);
4131 (void) memcpy((void *) (pc
+ 4), (void *) (&pname
), 4);
4132 (void) __glXReadReply(dpy
, 4, params
, GL_FALSE
);
4135 #endif /* USE_XCB */
4140 #define X_GLsop_GetPixelMapfv 125
4142 __indirect_glGetPixelMapfv(GLenum map
, GLfloat
* values
)
4144 __GLXcontext
*const gc
= __glXGetCurrentContext();
4145 Display
*const dpy
= gc
->currentDpy
;
4147 const GLuint cmdlen
= 4;
4149 if (__builtin_expect(dpy
!= NULL
, 1)) {
4151 xcb_connection_t
*c
= XGetXCBConnection(dpy
);
4152 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
4153 xcb_glx_get_pixel_mapfv_reply_t
*reply
=
4154 xcb_glx_get_pixel_mapfv_reply(c
,
4155 xcb_glx_get_pixel_mapfv(c
,
4159 if (xcb_glx_get_pixel_mapfv_data_length(reply
) == 0)
4160 (void) memcpy(values
, &reply
->datum
, sizeof(reply
->datum
));
4162 (void) memcpy(values
, xcb_glx_get_pixel_mapfv_data(reply
),
4163 xcb_glx_get_pixel_mapfv_data_length(reply
) *
4168 __glXSetupSingleRequest(gc
, X_GLsop_GetPixelMapfv
, cmdlen
);
4169 (void) memcpy((void *) (pc
+ 0), (void *) (&map
), 4);
4170 (void) __glXReadReply(dpy
, 4, values
, GL_FALSE
);
4173 #endif /* USE_XCB */
4178 #define X_GLsop_GetPixelMapuiv 126
4180 __indirect_glGetPixelMapuiv(GLenum map
, GLuint
* values
)
4182 __GLXcontext
*const gc
= __glXGetCurrentContext();
4183 Display
*const dpy
= gc
->currentDpy
;
4185 const GLuint cmdlen
= 4;
4187 if (__builtin_expect(dpy
!= NULL
, 1)) {
4189 xcb_connection_t
*c
= XGetXCBConnection(dpy
);
4190 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
4191 xcb_glx_get_pixel_mapuiv_reply_t
*reply
=
4192 xcb_glx_get_pixel_mapuiv_reply(c
,
4193 xcb_glx_get_pixel_mapuiv(c
,
4198 if (xcb_glx_get_pixel_mapuiv_data_length(reply
) == 0)
4199 (void) memcpy(values
, &reply
->datum
, sizeof(reply
->datum
));
4201 (void) memcpy(values
, xcb_glx_get_pixel_mapuiv_data(reply
),
4202 xcb_glx_get_pixel_mapuiv_data_length(reply
) *
4207 __glXSetupSingleRequest(gc
, X_GLsop_GetPixelMapuiv
, cmdlen
);
4208 (void) memcpy((void *) (pc
+ 0), (void *) (&map
), 4);
4209 (void) __glXReadReply(dpy
, 4, values
, GL_FALSE
);
4212 #endif /* USE_XCB */
4217 #define X_GLsop_GetPixelMapusv 127
4219 __indirect_glGetPixelMapusv(GLenum map
, GLushort
* values
)
4221 __GLXcontext
*const gc
= __glXGetCurrentContext();
4222 Display
*const dpy
= gc
->currentDpy
;
4224 const GLuint cmdlen
= 4;
4226 if (__builtin_expect(dpy
!= NULL
, 1)) {
4228 xcb_connection_t
*c
= XGetXCBConnection(dpy
);
4229 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
4230 xcb_glx_get_pixel_mapusv_reply_t
*reply
=
4231 xcb_glx_get_pixel_mapusv_reply(c
,
4232 xcb_glx_get_pixel_mapusv(c
,
4237 if (xcb_glx_get_pixel_mapusv_data_length(reply
) == 0)
4238 (void) memcpy(values
, &reply
->datum
, sizeof(reply
->datum
));
4240 (void) memcpy(values
, xcb_glx_get_pixel_mapusv_data(reply
),
4241 xcb_glx_get_pixel_mapusv_data_length(reply
) *
4246 __glXSetupSingleRequest(gc
, X_GLsop_GetPixelMapusv
, cmdlen
);
4247 (void) memcpy((void *) (pc
+ 0), (void *) (&map
), 4);
4248 (void) __glXReadReply(dpy
, 2, values
, GL_FALSE
);
4251 #endif /* USE_XCB */
4256 #define X_GLsop_GetPolygonStipple 128
4258 __indirect_glGetPolygonStipple(GLubyte
*mask
)
4260 __GLXcontext
*const gc
= __glXGetCurrentContext();
4261 Display
*const dpy
= gc
->currentDpy
;
4263 const GLuint cmdlen
= 4;
4265 if (__builtin_expect(dpy
!= NULL
, 1)) {
4267 xcb_connection_t
*c
= XGetXCBConnection(dpy
);
4268 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
4269 xcb_glx_get_polygon_stipple_reply_t
*reply
=
4270 xcb_glx_get_polygon_stipple_reply(c
,
4271 xcb_glx_get_polygon_stipple(c
,
4276 (void) memcpy(mask
, xcb_glx_get_polygon_stipple_data(reply
),
4277 xcb_glx_get_polygon_stipple_data_length(reply
) *
4282 __glXSetupSingleRequest(gc
, X_GLsop_GetPolygonStipple
, cmdlen
);
4283 *(int32_t *) (pc
+ 0) = 0;
4284 __glXReadPixelReply(dpy
, gc
, 2, 32, 32, 1, GL_COLOR_INDEX
, GL_BITMAP
,
4288 #endif /* USE_XCB */
4293 #define X_GLsop_GetTexEnvfv 130
4295 __indirect_glGetTexEnvfv(GLenum target
, GLenum pname
, GLfloat
* params
)
4297 __GLXcontext
*const gc
= __glXGetCurrentContext();
4298 Display
*const dpy
= gc
->currentDpy
;
4300 const GLuint cmdlen
= 8;
4302 if (__builtin_expect(dpy
!= NULL
, 1)) {
4304 xcb_connection_t
*c
= XGetXCBConnection(dpy
);
4305 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
4306 xcb_glx_get_tex_envfv_reply_t
*reply
=
4307 xcb_glx_get_tex_envfv_reply(c
,
4308 xcb_glx_get_tex_envfv(c
,
4313 if (xcb_glx_get_tex_envfv_data_length(reply
) == 0)
4314 (void) memcpy(params
, &reply
->datum
, sizeof(reply
->datum
));
4316 (void) memcpy(params
, xcb_glx_get_tex_envfv_data(reply
),
4317 xcb_glx_get_tex_envfv_data_length(reply
) *
4322 __glXSetupSingleRequest(gc
, X_GLsop_GetTexEnvfv
, cmdlen
);
4323 (void) memcpy((void *) (pc
+ 0), (void *) (&target
), 4);
4324 (void) memcpy((void *) (pc
+ 4), (void *) (&pname
), 4);
4325 (void) __glXReadReply(dpy
, 4, params
, GL_FALSE
);
4328 #endif /* USE_XCB */
4333 #define X_GLsop_GetTexEnviv 131
4335 __indirect_glGetTexEnviv(GLenum target
, GLenum pname
, GLint
* params
)
4337 __GLXcontext
*const gc
= __glXGetCurrentContext();
4338 Display
*const dpy
= gc
->currentDpy
;
4340 const GLuint cmdlen
= 8;
4342 if (__builtin_expect(dpy
!= NULL
, 1)) {
4344 xcb_connection_t
*c
= XGetXCBConnection(dpy
);
4345 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
4346 xcb_glx_get_tex_enviv_reply_t
*reply
=
4347 xcb_glx_get_tex_enviv_reply(c
,
4348 xcb_glx_get_tex_enviv(c
,
4353 if (xcb_glx_get_tex_enviv_data_length(reply
) == 0)
4354 (void) memcpy(params
, &reply
->datum
, sizeof(reply
->datum
));
4356 (void) memcpy(params
, xcb_glx_get_tex_enviv_data(reply
),
4357 xcb_glx_get_tex_enviv_data_length(reply
) *
4362 __glXSetupSingleRequest(gc
, X_GLsop_GetTexEnviv
, cmdlen
);
4363 (void) memcpy((void *) (pc
+ 0), (void *) (&target
), 4);
4364 (void) memcpy((void *) (pc
+ 4), (void *) (&pname
), 4);
4365 (void) __glXReadReply(dpy
, 4, params
, GL_FALSE
);
4368 #endif /* USE_XCB */
4373 #define X_GLsop_GetTexGendv 132
4375 __indirect_glGetTexGendv(GLenum coord
, GLenum pname
, GLdouble
* params
)
4377 __GLXcontext
*const gc
= __glXGetCurrentContext();
4378 Display
*const dpy
= gc
->currentDpy
;
4380 const GLuint cmdlen
= 8;
4382 if (__builtin_expect(dpy
!= NULL
, 1)) {
4384 xcb_connection_t
*c
= XGetXCBConnection(dpy
);
4385 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
4386 xcb_glx_get_tex_gendv_reply_t
*reply
=
4387 xcb_glx_get_tex_gendv_reply(c
,
4388 xcb_glx_get_tex_gendv(c
,
4393 if (xcb_glx_get_tex_gendv_data_length(reply
) == 0)
4394 (void) memcpy(params
, &reply
->datum
, sizeof(reply
->datum
));
4396 (void) memcpy(params
, xcb_glx_get_tex_gendv_data(reply
),
4397 xcb_glx_get_tex_gendv_data_length(reply
) *
4402 __glXSetupSingleRequest(gc
, X_GLsop_GetTexGendv
, cmdlen
);
4403 (void) memcpy((void *) (pc
+ 0), (void *) (&coord
), 4);
4404 (void) memcpy((void *) (pc
+ 4), (void *) (&pname
), 4);
4405 (void) __glXReadReply(dpy
, 8, params
, GL_FALSE
);
4408 #endif /* USE_XCB */
4413 #define X_GLsop_GetTexGenfv 133
4415 __indirect_glGetTexGenfv(GLenum coord
, GLenum pname
, GLfloat
* params
)
4417 __GLXcontext
*const gc
= __glXGetCurrentContext();
4418 Display
*const dpy
= gc
->currentDpy
;
4420 const GLuint cmdlen
= 8;
4422 if (__builtin_expect(dpy
!= NULL
, 1)) {
4424 xcb_connection_t
*c
= XGetXCBConnection(dpy
);
4425 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
4426 xcb_glx_get_tex_genfv_reply_t
*reply
=
4427 xcb_glx_get_tex_genfv_reply(c
,
4428 xcb_glx_get_tex_genfv(c
,
4433 if (xcb_glx_get_tex_genfv_data_length(reply
) == 0)
4434 (void) memcpy(params
, &reply
->datum
, sizeof(reply
->datum
));
4436 (void) memcpy(params
, xcb_glx_get_tex_genfv_data(reply
),
4437 xcb_glx_get_tex_genfv_data_length(reply
) *
4442 __glXSetupSingleRequest(gc
, X_GLsop_GetTexGenfv
, cmdlen
);
4443 (void) memcpy((void *) (pc
+ 0), (void *) (&coord
), 4);
4444 (void) memcpy((void *) (pc
+ 4), (void *) (&pname
), 4);
4445 (void) __glXReadReply(dpy
, 4, params
, GL_FALSE
);
4448 #endif /* USE_XCB */
4453 #define X_GLsop_GetTexGeniv 134
4455 __indirect_glGetTexGeniv(GLenum coord
, GLenum pname
, GLint
* params
)
4457 __GLXcontext
*const gc
= __glXGetCurrentContext();
4458 Display
*const dpy
= gc
->currentDpy
;
4460 const GLuint cmdlen
= 8;
4462 if (__builtin_expect(dpy
!= NULL
, 1)) {
4464 xcb_connection_t
*c
= XGetXCBConnection(dpy
);
4465 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
4466 xcb_glx_get_tex_geniv_reply_t
*reply
=
4467 xcb_glx_get_tex_geniv_reply(c
,
4468 xcb_glx_get_tex_geniv(c
,
4473 if (xcb_glx_get_tex_geniv_data_length(reply
) == 0)
4474 (void) memcpy(params
, &reply
->datum
, sizeof(reply
->datum
));
4476 (void) memcpy(params
, xcb_glx_get_tex_geniv_data(reply
),
4477 xcb_glx_get_tex_geniv_data_length(reply
) *
4482 __glXSetupSingleRequest(gc
, X_GLsop_GetTexGeniv
, cmdlen
);
4483 (void) memcpy((void *) (pc
+ 0), (void *) (&coord
), 4);
4484 (void) memcpy((void *) (pc
+ 4), (void *) (&pname
), 4);
4485 (void) __glXReadReply(dpy
, 4, params
, GL_FALSE
);
4488 #endif /* USE_XCB */
4493 #define X_GLsop_GetTexImage 135
4495 __indirect_glGetTexImage(GLenum target
, GLint level
, GLenum format
,
4496 GLenum type
, GLvoid
* pixels
)
4498 __GLXcontext
*const gc
= __glXGetCurrentContext();
4499 const __GLXattribute
*const state
= gc
->client_state_private
;
4500 Display
*const dpy
= gc
->currentDpy
;
4502 const GLuint cmdlen
= 20;
4504 if (__builtin_expect(dpy
!= NULL
, 1)) {
4506 xcb_connection_t
*c
= XGetXCBConnection(dpy
);
4507 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
4508 xcb_glx_get_tex_image_reply_t
*reply
=
4509 xcb_glx_get_tex_image_reply(c
,
4510 xcb_glx_get_tex_image(c
,
4519 (void) memcpy(pixels
, xcb_glx_get_tex_image_data(reply
),
4520 xcb_glx_get_tex_image_data_length(reply
) *
4525 __glXSetupSingleRequest(gc
, X_GLsop_GetTexImage
, cmdlen
);
4526 (void) memcpy((void *) (pc
+ 0), (void *) (&target
), 4);
4527 (void) memcpy((void *) (pc
+ 4), (void *) (&level
), 4);
4528 (void) memcpy((void *) (pc
+ 8), (void *) (&format
), 4);
4529 (void) memcpy((void *) (pc
+ 12), (void *) (&type
), 4);
4530 *(int32_t *) (pc
+ 16) = 0;
4531 *(int8_t *) (pc
+ 16) = state
->storePack
.swapEndian
;
4532 __glXReadPixelReply(dpy
, gc
, 3, 0, 0, 0, format
, type
, pixels
,
4536 #endif /* USE_XCB */
4541 #define X_GLsop_GetTexParameterfv 136
4543 __indirect_glGetTexParameterfv(GLenum target
, GLenum pname
, GLfloat
* params
)
4545 __GLXcontext
*const gc
= __glXGetCurrentContext();
4546 Display
*const dpy
= gc
->currentDpy
;
4548 const GLuint cmdlen
= 8;
4550 if (__builtin_expect(dpy
!= NULL
, 1)) {
4552 xcb_connection_t
*c
= XGetXCBConnection(dpy
);
4553 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
4554 xcb_glx_get_tex_parameterfv_reply_t
*reply
=
4555 xcb_glx_get_tex_parameterfv_reply(c
,
4556 xcb_glx_get_tex_parameterfv(c
,
4562 if (xcb_glx_get_tex_parameterfv_data_length(reply
) == 0)
4563 (void) memcpy(params
, &reply
->datum
, sizeof(reply
->datum
));
4565 (void) memcpy(params
, xcb_glx_get_tex_parameterfv_data(reply
),
4566 xcb_glx_get_tex_parameterfv_data_length(reply
) *
4571 __glXSetupSingleRequest(gc
, X_GLsop_GetTexParameterfv
, cmdlen
);
4572 (void) memcpy((void *) (pc
+ 0), (void *) (&target
), 4);
4573 (void) memcpy((void *) (pc
+ 4), (void *) (&pname
), 4);
4574 (void) __glXReadReply(dpy
, 4, params
, GL_FALSE
);
4577 #endif /* USE_XCB */
4582 #define X_GLsop_GetTexParameteriv 137
4584 __indirect_glGetTexParameteriv(GLenum target
, GLenum pname
, GLint
* params
)
4586 __GLXcontext
*const gc
= __glXGetCurrentContext();
4587 Display
*const dpy
= gc
->currentDpy
;
4589 const GLuint cmdlen
= 8;
4591 if (__builtin_expect(dpy
!= NULL
, 1)) {
4593 xcb_connection_t
*c
= XGetXCBConnection(dpy
);
4594 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
4595 xcb_glx_get_tex_parameteriv_reply_t
*reply
=
4596 xcb_glx_get_tex_parameteriv_reply(c
,
4597 xcb_glx_get_tex_parameteriv(c
,
4603 if (xcb_glx_get_tex_parameteriv_data_length(reply
) == 0)
4604 (void) memcpy(params
, &reply
->datum
, sizeof(reply
->datum
));
4606 (void) memcpy(params
, xcb_glx_get_tex_parameteriv_data(reply
),
4607 xcb_glx_get_tex_parameteriv_data_length(reply
) *
4612 __glXSetupSingleRequest(gc
, X_GLsop_GetTexParameteriv
, cmdlen
);
4613 (void) memcpy((void *) (pc
+ 0), (void *) (&target
), 4);
4614 (void) memcpy((void *) (pc
+ 4), (void *) (&pname
), 4);
4615 (void) __glXReadReply(dpy
, 4, params
, GL_FALSE
);
4618 #endif /* USE_XCB */
4623 #define X_GLsop_GetTexLevelParameterfv 138
4625 __indirect_glGetTexLevelParameterfv(GLenum target
, GLint level
, GLenum pname
,
4628 __GLXcontext
*const gc
= __glXGetCurrentContext();
4629 Display
*const dpy
= gc
->currentDpy
;
4631 const GLuint cmdlen
= 12;
4633 if (__builtin_expect(dpy
!= NULL
, 1)) {
4635 xcb_connection_t
*c
= XGetXCBConnection(dpy
);
4636 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
4637 xcb_glx_get_tex_level_parameterfv_reply_t
*reply
=
4638 xcb_glx_get_tex_level_parameterfv_reply(c
,
4639 xcb_glx_get_tex_level_parameterfv
4640 (c
, gc
->currentContextTag
,
4641 target
, level
, pname
),
4643 if (xcb_glx_get_tex_level_parameterfv_data_length(reply
) == 0)
4644 (void) memcpy(params
, &reply
->datum
, sizeof(reply
->datum
));
4646 (void) memcpy(params
,
4647 xcb_glx_get_tex_level_parameterfv_data(reply
),
4648 xcb_glx_get_tex_level_parameterfv_data_length(reply
)
4653 __glXSetupSingleRequest(gc
, X_GLsop_GetTexLevelParameterfv
,
4655 (void) memcpy((void *) (pc
+ 0), (void *) (&target
), 4);
4656 (void) memcpy((void *) (pc
+ 4), (void *) (&level
), 4);
4657 (void) memcpy((void *) (pc
+ 8), (void *) (&pname
), 4);
4658 (void) __glXReadReply(dpy
, 4, params
, GL_FALSE
);
4661 #endif /* USE_XCB */
4666 #define X_GLsop_GetTexLevelParameteriv 139
4668 __indirect_glGetTexLevelParameteriv(GLenum target
, GLint level
, GLenum pname
,
4671 __GLXcontext
*const gc
= __glXGetCurrentContext();
4672 Display
*const dpy
= gc
->currentDpy
;
4674 const GLuint cmdlen
= 12;
4676 if (__builtin_expect(dpy
!= NULL
, 1)) {
4678 xcb_connection_t
*c
= XGetXCBConnection(dpy
);
4679 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
4680 xcb_glx_get_tex_level_parameteriv_reply_t
*reply
=
4681 xcb_glx_get_tex_level_parameteriv_reply(c
,
4682 xcb_glx_get_tex_level_parameteriv
4683 (c
, gc
->currentContextTag
,
4684 target
, level
, pname
),
4686 if (xcb_glx_get_tex_level_parameteriv_data_length(reply
) == 0)
4687 (void) memcpy(params
, &reply
->datum
, sizeof(reply
->datum
));
4689 (void) memcpy(params
,
4690 xcb_glx_get_tex_level_parameteriv_data(reply
),
4691 xcb_glx_get_tex_level_parameteriv_data_length(reply
)
4696 __glXSetupSingleRequest(gc
, X_GLsop_GetTexLevelParameteriv
,
4698 (void) memcpy((void *) (pc
+ 0), (void *) (&target
), 4);
4699 (void) memcpy((void *) (pc
+ 4), (void *) (&level
), 4);
4700 (void) memcpy((void *) (pc
+ 8), (void *) (&pname
), 4);
4701 (void) __glXReadReply(dpy
, 4, params
, GL_FALSE
);
4704 #endif /* USE_XCB */
4709 #define X_GLsop_IsList 141
4711 __indirect_glIsList(GLuint list
)
4713 __GLXcontext
*const gc
= __glXGetCurrentContext();
4714 Display
*const dpy
= gc
->currentDpy
;
4715 GLboolean retval
= (GLboolean
) 0;
4717 const GLuint cmdlen
= 4;
4719 if (__builtin_expect(dpy
!= NULL
, 1)) {
4721 xcb_connection_t
*c
= XGetXCBConnection(dpy
);
4722 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
4723 xcb_glx_is_list_reply_t
*reply
=
4724 xcb_glx_is_list_reply(c
,
4725 xcb_glx_is_list(c
, gc
->currentContextTag
,
4727 retval
= reply
->ret_val
;
4731 __glXSetupSingleRequest(gc
, X_GLsop_IsList
, cmdlen
);
4732 (void) memcpy((void *) (pc
+ 0), (void *) (&list
), 4);
4733 retval
= (GLboolean
) __glXReadReply(dpy
, 0, NULL
, GL_FALSE
);
4736 #endif /* USE_XCB */
4741 #define X_GLrop_DepthRange 174
4743 __indirect_glDepthRange(GLclampd zNear
, GLclampd zFar
)
4745 __GLXcontext
*const gc
= __glXGetCurrentContext();
4746 const GLuint cmdlen
= 20;
4747 emit_header(gc
->pc
, X_GLrop_DepthRange
, cmdlen
);
4748 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&zNear
), 8);
4749 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&zFar
), 8);
4751 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
4752 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
4756 #define X_GLrop_Frustum 175
4758 __indirect_glFrustum(GLdouble left
, GLdouble right
, GLdouble bottom
,
4759 GLdouble top
, GLdouble zNear
, GLdouble zFar
)
4761 __GLXcontext
*const gc
= __glXGetCurrentContext();
4762 const GLuint cmdlen
= 52;
4763 emit_header(gc
->pc
, X_GLrop_Frustum
, cmdlen
);
4764 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&left
), 8);
4765 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&right
), 8);
4766 (void) memcpy((void *) (gc
->pc
+ 20), (void *) (&bottom
), 8);
4767 (void) memcpy((void *) (gc
->pc
+ 28), (void *) (&top
), 8);
4768 (void) memcpy((void *) (gc
->pc
+ 36), (void *) (&zNear
), 8);
4769 (void) memcpy((void *) (gc
->pc
+ 44), (void *) (&zFar
), 8);
4771 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
4772 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
4776 #define X_GLrop_LoadIdentity 176
4778 __indirect_glLoadIdentity(void)
4780 __GLXcontext
*const gc
= __glXGetCurrentContext();
4781 const GLuint cmdlen
= 4;
4782 emit_header(gc
->pc
, X_GLrop_LoadIdentity
, cmdlen
);
4784 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
4785 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
4789 #define X_GLrop_LoadMatrixf 177
4791 __indirect_glLoadMatrixf(const GLfloat
* m
)
4793 __GLXcontext
*const gc
= __glXGetCurrentContext();
4794 const GLuint cmdlen
= 68;
4795 emit_header(gc
->pc
, X_GLrop_LoadMatrixf
, cmdlen
);
4796 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (m
), 64);
4798 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
4799 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
4803 #define X_GLrop_LoadMatrixd 178
4805 __indirect_glLoadMatrixd(const GLdouble
* m
)
4807 __GLXcontext
*const gc
= __glXGetCurrentContext();
4808 const GLuint cmdlen
= 132;
4809 emit_header(gc
->pc
, X_GLrop_LoadMatrixd
, cmdlen
);
4810 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (m
), 128);
4812 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
4813 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
4817 #define X_GLrop_MatrixMode 179
4819 __indirect_glMatrixMode(GLenum mode
)
4821 __GLXcontext
*const gc
= __glXGetCurrentContext();
4822 const GLuint cmdlen
= 8;
4823 emit_header(gc
->pc
, X_GLrop_MatrixMode
, cmdlen
);
4824 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&mode
), 4);
4826 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
4827 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
4831 #define X_GLrop_MultMatrixf 180
4833 __indirect_glMultMatrixf(const GLfloat
* m
)
4835 __GLXcontext
*const gc
= __glXGetCurrentContext();
4836 const GLuint cmdlen
= 68;
4837 emit_header(gc
->pc
, X_GLrop_MultMatrixf
, cmdlen
);
4838 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (m
), 64);
4840 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
4841 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
4845 #define X_GLrop_MultMatrixd 181
4847 __indirect_glMultMatrixd(const GLdouble
* m
)
4849 __GLXcontext
*const gc
= __glXGetCurrentContext();
4850 const GLuint cmdlen
= 132;
4851 emit_header(gc
->pc
, X_GLrop_MultMatrixd
, cmdlen
);
4852 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (m
), 128);
4854 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
4855 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
4859 #define X_GLrop_Ortho 182
4861 __indirect_glOrtho(GLdouble left
, GLdouble right
, GLdouble bottom
,
4862 GLdouble top
, GLdouble zNear
, GLdouble zFar
)
4864 __GLXcontext
*const gc
= __glXGetCurrentContext();
4865 const GLuint cmdlen
= 52;
4866 emit_header(gc
->pc
, X_GLrop_Ortho
, cmdlen
);
4867 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&left
), 8);
4868 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&right
), 8);
4869 (void) memcpy((void *) (gc
->pc
+ 20), (void *) (&bottom
), 8);
4870 (void) memcpy((void *) (gc
->pc
+ 28), (void *) (&top
), 8);
4871 (void) memcpy((void *) (gc
->pc
+ 36), (void *) (&zNear
), 8);
4872 (void) memcpy((void *) (gc
->pc
+ 44), (void *) (&zFar
), 8);
4874 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
4875 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
4879 #define X_GLrop_PopMatrix 183
4881 __indirect_glPopMatrix(void)
4883 __GLXcontext
*const gc
= __glXGetCurrentContext();
4884 const GLuint cmdlen
= 4;
4885 emit_header(gc
->pc
, X_GLrop_PopMatrix
, cmdlen
);
4887 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
4888 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
4892 #define X_GLrop_PushMatrix 184
4894 __indirect_glPushMatrix(void)
4896 __GLXcontext
*const gc
= __glXGetCurrentContext();
4897 const GLuint cmdlen
= 4;
4898 emit_header(gc
->pc
, X_GLrop_PushMatrix
, cmdlen
);
4900 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
4901 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
4905 #define X_GLrop_Rotated 185
4907 __indirect_glRotated(GLdouble angle
, GLdouble x
, GLdouble y
, GLdouble z
)
4909 __GLXcontext
*const gc
= __glXGetCurrentContext();
4910 const GLuint cmdlen
= 36;
4911 emit_header(gc
->pc
, X_GLrop_Rotated
, cmdlen
);
4912 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&angle
), 8);
4913 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&x
), 8);
4914 (void) memcpy((void *) (gc
->pc
+ 20), (void *) (&y
), 8);
4915 (void) memcpy((void *) (gc
->pc
+ 28), (void *) (&z
), 8);
4917 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
4918 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
4922 #define X_GLrop_Rotatef 186
4924 __indirect_glRotatef(GLfloat angle
, GLfloat x
, GLfloat y
, GLfloat z
)
4926 __GLXcontext
*const gc
= __glXGetCurrentContext();
4927 const GLuint cmdlen
= 20;
4928 emit_header(gc
->pc
, X_GLrop_Rotatef
, cmdlen
);
4929 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&angle
), 4);
4930 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&x
), 4);
4931 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&y
), 4);
4932 (void) memcpy((void *) (gc
->pc
+ 16), (void *) (&z
), 4);
4934 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
4935 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
4939 #define X_GLrop_Scaled 187
4941 __indirect_glScaled(GLdouble x
, GLdouble y
, GLdouble z
)
4943 __GLXcontext
*const gc
= __glXGetCurrentContext();
4944 const GLuint cmdlen
= 28;
4945 emit_header(gc
->pc
, X_GLrop_Scaled
, cmdlen
);
4946 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&x
), 8);
4947 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&y
), 8);
4948 (void) memcpy((void *) (gc
->pc
+ 20), (void *) (&z
), 8);
4950 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
4951 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
4955 #define X_GLrop_Scalef 188
4957 __indirect_glScalef(GLfloat x
, GLfloat y
, GLfloat z
)
4959 __GLXcontext
*const gc
= __glXGetCurrentContext();
4960 const GLuint cmdlen
= 16;
4961 emit_header(gc
->pc
, X_GLrop_Scalef
, cmdlen
);
4962 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&x
), 4);
4963 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&y
), 4);
4964 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&z
), 4);
4966 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
4967 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
4971 #define X_GLrop_Translated 189
4973 __indirect_glTranslated(GLdouble x
, GLdouble y
, GLdouble z
)
4975 __GLXcontext
*const gc
= __glXGetCurrentContext();
4976 const GLuint cmdlen
= 28;
4977 emit_header(gc
->pc
, X_GLrop_Translated
, cmdlen
);
4978 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&x
), 8);
4979 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&y
), 8);
4980 (void) memcpy((void *) (gc
->pc
+ 20), (void *) (&z
), 8);
4982 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
4983 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
4987 #define X_GLrop_Translatef 190
4989 __indirect_glTranslatef(GLfloat x
, GLfloat y
, GLfloat z
)
4991 __GLXcontext
*const gc
= __glXGetCurrentContext();
4992 const GLuint cmdlen
= 16;
4993 emit_header(gc
->pc
, X_GLrop_Translatef
, cmdlen
);
4994 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&x
), 4);
4995 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&y
), 4);
4996 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&z
), 4);
4998 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
4999 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
5003 #define X_GLrop_Viewport 191
5005 __indirect_glViewport(GLint x
, GLint y
, GLsizei width
, GLsizei height
)
5007 __GLXcontext
*const gc
= __glXGetCurrentContext();
5008 const GLuint cmdlen
= 20;
5009 emit_header(gc
->pc
, X_GLrop_Viewport
, cmdlen
);
5010 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&x
), 4);
5011 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&y
), 4);
5012 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&width
), 4);
5013 (void) memcpy((void *) (gc
->pc
+ 16), (void *) (&height
), 4);
5015 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
5016 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
5020 #define X_GLrop_BindTexture 4117
5022 __indirect_glBindTexture(GLenum target
, GLuint texture
)
5024 __GLXcontext
*const gc
= __glXGetCurrentContext();
5025 const GLuint cmdlen
= 12;
5026 emit_header(gc
->pc
, X_GLrop_BindTexture
, cmdlen
);
5027 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&target
), 4);
5028 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&texture
), 4);
5030 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
5031 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
5035 #define X_GLrop_Indexubv 194
5037 __indirect_glIndexub(GLubyte c
)
5039 __GLXcontext
*const gc
= __glXGetCurrentContext();
5040 const GLuint cmdlen
= 8;
5041 emit_header(gc
->pc
, X_GLrop_Indexubv
, cmdlen
);
5042 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&c
), 1);
5044 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
5045 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
5049 #define X_GLrop_Indexubv 194
5051 __indirect_glIndexubv(const GLubyte
*c
)
5053 __GLXcontext
*const gc
= __glXGetCurrentContext();
5054 const GLuint cmdlen
= 8;
5055 emit_header(gc
->pc
, X_GLrop_Indexubv
, cmdlen
);
5056 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (c
), 1);
5058 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
5059 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
5063 #define X_GLrop_PolygonOffset 192
5065 __indirect_glPolygonOffset(GLfloat factor
, GLfloat units
)
5067 __GLXcontext
*const gc
= __glXGetCurrentContext();
5068 const GLuint cmdlen
= 12;
5069 emit_header(gc
->pc
, X_GLrop_PolygonOffset
, cmdlen
);
5070 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&factor
), 4);
5071 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&units
), 4);
5073 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
5074 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
5078 #define X_GLsop_AreTexturesResident 143
5080 __indirect_glAreTexturesResident(GLsizei n
, const GLuint
* textures
,
5081 GLboolean
* residences
)
5083 __GLXcontext
*const gc
= __glXGetCurrentContext();
5084 Display
*const dpy
= gc
->currentDpy
;
5085 GLboolean retval
= (GLboolean
) 0;
5087 const GLuint cmdlen
= 4 + __GLX_PAD((n
* 4));
5090 __glXSetError(gc
, GL_INVALID_VALUE
);
5093 if (__builtin_expect((n
>= 0) && (dpy
!= NULL
), 1)) {
5095 xcb_connection_t
*c
= XGetXCBConnection(dpy
);
5096 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
5097 xcb_glx_are_textures_resident_reply_t
*reply
=
5098 xcb_glx_are_textures_resident_reply(c
,
5099 xcb_glx_are_textures_resident
5100 (c
, gc
->currentContextTag
, n
,
5102 (void) memcpy(residences
, xcb_glx_are_textures_resident_data(reply
),
5103 xcb_glx_are_textures_resident_data_length(reply
) *
5105 retval
= reply
->ret_val
;
5109 __glXSetupSingleRequest(gc
, X_GLsop_AreTexturesResident
, cmdlen
);
5110 (void) memcpy((void *) (pc
+ 0), (void *) (&n
), 4);
5111 (void) memcpy((void *) (pc
+ 4), (void *) (textures
), (n
* 4));
5112 retval
= (GLboolean
) __glXReadReply(dpy
, 1, residences
, GL_TRUE
);
5115 #endif /* USE_XCB */
5120 #define X_GLvop_AreTexturesResidentEXT 11
5122 glAreTexturesResidentEXT(GLsizei n
, const GLuint
* textures
,
5123 GLboolean
* residences
)
5125 __GLXcontext
*const gc
= __glXGetCurrentContext();
5127 if (gc
->driContext
) {
5128 return CALL_AreTexturesResident(GET_DISPATCH(),
5129 (n
, textures
, residences
));
5131 __GLXcontext
*const gc
= __glXGetCurrentContext();
5132 Display
*const dpy
= gc
->currentDpy
;
5133 GLboolean retval
= (GLboolean
) 0;
5134 const GLuint cmdlen
= 4 + __GLX_PAD((n
* 4));
5136 __glXSetError(gc
, GL_INVALID_VALUE
);
5139 if (__builtin_expect((n
>= 0) && (dpy
!= NULL
), 1)) {
5141 __glXSetupVendorRequest(gc
, X_GLXVendorPrivateWithReply
,
5142 X_GLvop_AreTexturesResidentEXT
,
5144 (void) memcpy((void *) (pc
+ 0), (void *) (&n
), 4);
5145 (void) memcpy((void *) (pc
+ 4), (void *) (textures
), (n
* 4));
5146 retval
= (GLboolean
) __glXReadReply(dpy
, 1, residences
, GL_TRUE
);
5154 #define X_GLrop_CopyTexImage1D 4119
5156 __indirect_glCopyTexImage1D(GLenum target
, GLint level
, GLenum internalformat
,
5157 GLint x
, GLint y
, GLsizei width
, GLint border
)
5159 __GLXcontext
*const gc
= __glXGetCurrentContext();
5160 const GLuint cmdlen
= 32;
5161 emit_header(gc
->pc
, X_GLrop_CopyTexImage1D
, cmdlen
);
5162 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&target
), 4);
5163 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&level
), 4);
5164 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&internalformat
), 4);
5165 (void) memcpy((void *) (gc
->pc
+ 16), (void *) (&x
), 4);
5166 (void) memcpy((void *) (gc
->pc
+ 20), (void *) (&y
), 4);
5167 (void) memcpy((void *) (gc
->pc
+ 24), (void *) (&width
), 4);
5168 (void) memcpy((void *) (gc
->pc
+ 28), (void *) (&border
), 4);
5170 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
5171 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
5175 #define X_GLrop_CopyTexImage2D 4120
5177 __indirect_glCopyTexImage2D(GLenum target
, GLint level
, GLenum internalformat
,
5178 GLint x
, GLint y
, GLsizei width
, GLsizei height
,
5181 __GLXcontext
*const gc
= __glXGetCurrentContext();
5182 const GLuint cmdlen
= 36;
5183 emit_header(gc
->pc
, X_GLrop_CopyTexImage2D
, cmdlen
);
5184 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&target
), 4);
5185 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&level
), 4);
5186 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&internalformat
), 4);
5187 (void) memcpy((void *) (gc
->pc
+ 16), (void *) (&x
), 4);
5188 (void) memcpy((void *) (gc
->pc
+ 20), (void *) (&y
), 4);
5189 (void) memcpy((void *) (gc
->pc
+ 24), (void *) (&width
), 4);
5190 (void) memcpy((void *) (gc
->pc
+ 28), (void *) (&height
), 4);
5191 (void) memcpy((void *) (gc
->pc
+ 32), (void *) (&border
), 4);
5193 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
5194 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
5198 #define X_GLrop_CopyTexSubImage1D 4121
5200 __indirect_glCopyTexSubImage1D(GLenum target
, GLint level
, GLint xoffset
,
5201 GLint x
, GLint y
, GLsizei width
)
5203 __GLXcontext
*const gc
= __glXGetCurrentContext();
5204 const GLuint cmdlen
= 28;
5205 emit_header(gc
->pc
, X_GLrop_CopyTexSubImage1D
, cmdlen
);
5206 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&target
), 4);
5207 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&level
), 4);
5208 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&xoffset
), 4);
5209 (void) memcpy((void *) (gc
->pc
+ 16), (void *) (&x
), 4);
5210 (void) memcpy((void *) (gc
->pc
+ 20), (void *) (&y
), 4);
5211 (void) memcpy((void *) (gc
->pc
+ 24), (void *) (&width
), 4);
5213 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
5214 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
5218 #define X_GLrop_CopyTexSubImage2D 4122
5220 __indirect_glCopyTexSubImage2D(GLenum target
, GLint level
, GLint xoffset
,
5221 GLint yoffset
, GLint x
, GLint y
, GLsizei width
,
5224 __GLXcontext
*const gc
= __glXGetCurrentContext();
5225 const GLuint cmdlen
= 36;
5226 emit_header(gc
->pc
, X_GLrop_CopyTexSubImage2D
, cmdlen
);
5227 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&target
), 4);
5228 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&level
), 4);
5229 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&xoffset
), 4);
5230 (void) memcpy((void *) (gc
->pc
+ 16), (void *) (&yoffset
), 4);
5231 (void) memcpy((void *) (gc
->pc
+ 20), (void *) (&x
), 4);
5232 (void) memcpy((void *) (gc
->pc
+ 24), (void *) (&y
), 4);
5233 (void) memcpy((void *) (gc
->pc
+ 28), (void *) (&width
), 4);
5234 (void) memcpy((void *) (gc
->pc
+ 32), (void *) (&height
), 4);
5236 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
5237 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
5241 #define X_GLsop_DeleteTextures 144
5243 __indirect_glDeleteTextures(GLsizei n
, const GLuint
* textures
)
5245 __GLXcontext
*const gc
= __glXGetCurrentContext();
5246 Display
*const dpy
= gc
->currentDpy
;
5248 const GLuint cmdlen
= 4 + __GLX_PAD((n
* 4));
5251 __glXSetError(gc
, GL_INVALID_VALUE
);
5254 if (__builtin_expect((n
>= 0) && (dpy
!= NULL
), 1)) {
5256 xcb_connection_t
*c
= XGetXCBConnection(dpy
);
5257 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
5258 xcb_glx_delete_textures(c
, gc
->currentContextTag
, n
, textures
);
5261 __glXSetupSingleRequest(gc
, X_GLsop_DeleteTextures
, cmdlen
);
5262 (void) memcpy((void *) (pc
+ 0), (void *) (&n
), 4);
5263 (void) memcpy((void *) (pc
+ 4), (void *) (textures
), (n
* 4));
5266 #endif /* USE_XCB */
5271 #define X_GLvop_DeleteTexturesEXT 12
5273 glDeleteTexturesEXT(GLsizei n
, const GLuint
* textures
)
5275 __GLXcontext
*const gc
= __glXGetCurrentContext();
5277 if (gc
->driContext
) {
5278 CALL_DeleteTextures(GET_DISPATCH(), (n
, textures
));
5280 __GLXcontext
*const gc
= __glXGetCurrentContext();
5281 Display
*const dpy
= gc
->currentDpy
;
5282 const GLuint cmdlen
= 4 + __GLX_PAD((n
* 4));
5284 __glXSetError(gc
, GL_INVALID_VALUE
);
5287 if (__builtin_expect((n
>= 0) && (dpy
!= NULL
), 1)) {
5289 __glXSetupVendorRequest(gc
, X_GLXVendorPrivate
,
5290 X_GLvop_DeleteTexturesEXT
, cmdlen
);
5291 (void) memcpy((void *) (pc
+ 0), (void *) (&n
), 4);
5292 (void) memcpy((void *) (pc
+ 4), (void *) (textures
), (n
* 4));
5300 #define X_GLsop_GenTextures 145
5302 __indirect_glGenTextures(GLsizei n
, GLuint
* textures
)
5304 __GLXcontext
*const gc
= __glXGetCurrentContext();
5305 Display
*const dpy
= gc
->currentDpy
;
5307 const GLuint cmdlen
= 4;
5310 __glXSetError(gc
, GL_INVALID_VALUE
);
5313 if (__builtin_expect((n
>= 0) && (dpy
!= NULL
), 1)) {
5315 xcb_connection_t
*c
= XGetXCBConnection(dpy
);
5316 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
5317 xcb_glx_gen_textures_reply_t
*reply
=
5318 xcb_glx_gen_textures_reply(c
,
5319 xcb_glx_gen_textures(c
,
5323 (void) memcpy(textures
, xcb_glx_gen_textures_data(reply
),
5324 xcb_glx_gen_textures_data_length(reply
) *
5329 __glXSetupSingleRequest(gc
, X_GLsop_GenTextures
, cmdlen
);
5330 (void) memcpy((void *) (pc
+ 0), (void *) (&n
), 4);
5331 (void) __glXReadReply(dpy
, 4, textures
, GL_TRUE
);
5334 #endif /* USE_XCB */
5339 #define X_GLvop_GenTexturesEXT 13
5341 glGenTexturesEXT(GLsizei n
, GLuint
* textures
)
5343 __GLXcontext
*const gc
= __glXGetCurrentContext();
5345 if (gc
->driContext
) {
5346 CALL_GenTextures(GET_DISPATCH(), (n
, textures
));
5348 __GLXcontext
*const gc
= __glXGetCurrentContext();
5349 Display
*const dpy
= gc
->currentDpy
;
5350 const GLuint cmdlen
= 4;
5352 __glXSetError(gc
, GL_INVALID_VALUE
);
5355 if (__builtin_expect((n
>= 0) && (dpy
!= NULL
), 1)) {
5357 __glXSetupVendorRequest(gc
, X_GLXVendorPrivateWithReply
,
5358 X_GLvop_GenTexturesEXT
, cmdlen
);
5359 (void) memcpy((void *) (pc
+ 0), (void *) (&n
), 4);
5360 (void) __glXReadReply(dpy
, 4, textures
, GL_TRUE
);
5368 #define X_GLsop_IsTexture 146
5370 __indirect_glIsTexture(GLuint texture
)
5372 __GLXcontext
*const gc
= __glXGetCurrentContext();
5373 Display
*const dpy
= gc
->currentDpy
;
5374 GLboolean retval
= (GLboolean
) 0;
5376 const GLuint cmdlen
= 4;
5378 if (__builtin_expect(dpy
!= NULL
, 1)) {
5380 xcb_connection_t
*c
= XGetXCBConnection(dpy
);
5381 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
5382 xcb_glx_is_texture_reply_t
*reply
=
5383 xcb_glx_is_texture_reply(c
,
5384 xcb_glx_is_texture(c
,
5385 gc
->currentContextTag
,
5387 retval
= reply
->ret_val
;
5391 __glXSetupSingleRequest(gc
, X_GLsop_IsTexture
, cmdlen
);
5392 (void) memcpy((void *) (pc
+ 0), (void *) (&texture
), 4);
5393 retval
= (GLboolean
) __glXReadReply(dpy
, 0, NULL
, GL_FALSE
);
5396 #endif /* USE_XCB */
5401 #define X_GLvop_IsTextureEXT 14
5403 glIsTextureEXT(GLuint texture
)
5405 __GLXcontext
*const gc
= __glXGetCurrentContext();
5407 if (gc
->driContext
) {
5408 return CALL_IsTexture(GET_DISPATCH(), (texture
));
5410 __GLXcontext
*const gc
= __glXGetCurrentContext();
5411 Display
*const dpy
= gc
->currentDpy
;
5412 GLboolean retval
= (GLboolean
) 0;
5413 const GLuint cmdlen
= 4;
5414 if (__builtin_expect(dpy
!= NULL
, 1)) {
5416 __glXSetupVendorRequest(gc
, X_GLXVendorPrivateWithReply
,
5417 X_GLvop_IsTextureEXT
, cmdlen
);
5418 (void) memcpy((void *) (pc
+ 0), (void *) (&texture
), 4);
5419 retval
= (GLboolean
) __glXReadReply(dpy
, 0, NULL
, GL_FALSE
);
5427 #define X_GLrop_PrioritizeTextures 4118
5429 __indirect_glPrioritizeTextures(GLsizei n
, const GLuint
* textures
,
5430 const GLclampf
* priorities
)
5432 __GLXcontext
*const gc
= __glXGetCurrentContext();
5433 const GLuint cmdlen
= 8 + __GLX_PAD((n
* 4)) + __GLX_PAD((n
* 4));
5435 __glXSetError(gc
, GL_INVALID_VALUE
);
5438 if (__builtin_expect(n
>= 0, 1)) {
5439 emit_header(gc
->pc
, X_GLrop_PrioritizeTextures
, cmdlen
);
5440 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&n
), 4);
5441 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (textures
), (n
* 4));
5442 (void) memcpy((void *) (gc
->pc
+ 8 + (n
* 4)), (void *) (priorities
),
5445 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
5446 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
5452 __glx_TexSubImage_1D2D(unsigned opcode
, unsigned dim
, GLenum target
,
5453 GLint level
, GLint xoffset
, GLint yoffset
,
5454 GLsizei width
, GLsizei height
, GLenum format
,
5455 GLenum type
, const GLvoid
* pixels
)
5457 __GLXcontext
*const gc
= __glXGetCurrentContext();
5458 const GLuint compsize
=
5459 (pixels
!= NULL
) ? __glImageSize(width
, height
, 1, format
, type
,
5461 const GLuint cmdlen
= 60 + __GLX_PAD(compsize
);
5462 if (__builtin_expect(gc
->currentDpy
!= NULL
, 1)) {
5463 if (cmdlen
<= gc
->maxSmallRenderCommandSize
) {
5464 if ((gc
->pc
+ cmdlen
) > gc
->bufEnd
) {
5465 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
5467 emit_header(gc
->pc
, opcode
, cmdlen
);
5468 (void) memcpy((void *) (gc
->pc
+ 24), (void *) (&target
), 4);
5469 (void) memcpy((void *) (gc
->pc
+ 28), (void *) (&level
), 4);
5470 (void) memcpy((void *) (gc
->pc
+ 32), (void *) (&xoffset
), 4);
5471 (void) memcpy((void *) (gc
->pc
+ 36), (void *) (&yoffset
), 4);
5472 (void) memcpy((void *) (gc
->pc
+ 40), (void *) (&width
), 4);
5473 (void) memcpy((void *) (gc
->pc
+ 44), (void *) (&height
), 4);
5474 (void) memcpy((void *) (gc
->pc
+ 48), (void *) (&format
), 4);
5475 (void) memcpy((void *) (gc
->pc
+ 52), (void *) (&type
), 4);
5476 (void) memcpy((void *) (gc
->pc
+ 56),
5477 (void *) ((pixels
== NULL
) ? one
: zero
), 4);
5479 (*gc
->fillImage
) (gc
, dim
, width
, height
, 1, format
, type
,
5480 pixels
, gc
->pc
+ 60, gc
->pc
+ 4);
5482 (void) memcpy(gc
->pc
+ 4, default_pixel_store_2D
,
5483 default_pixel_store_2D_size
);
5486 if (gc
->pc
> gc
->limit
) {
5487 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
5490 const GLint op
= opcode
;
5491 const GLuint cmdlenLarge
= cmdlen
+ 4;
5492 GLubyte
*const pc
= __glXFlushRenderBuffer(gc
, gc
->pc
);
5493 (void) memcpy((void *) (pc
+ 0), (void *) (&cmdlenLarge
), 4);
5494 (void) memcpy((void *) (pc
+ 4), (void *) (&op
), 4);
5495 (void) memcpy((void *) (pc
+ 28), (void *) (&target
), 4);
5496 (void) memcpy((void *) (pc
+ 32), (void *) (&level
), 4);
5497 (void) memcpy((void *) (pc
+ 36), (void *) (&xoffset
), 4);
5498 (void) memcpy((void *) (pc
+ 40), (void *) (&yoffset
), 4);
5499 (void) memcpy((void *) (pc
+ 44), (void *) (&width
), 4);
5500 (void) memcpy((void *) (pc
+ 48), (void *) (&height
), 4);
5501 (void) memcpy((void *) (pc
+ 52), (void *) (&format
), 4);
5502 (void) memcpy((void *) (pc
+ 56), (void *) (&type
), 4);
5503 (void) memcpy((void *) (pc
+ 60), zero
, 4);
5504 __glXSendLargeImage(gc
, compsize
, dim
, width
, height
, 1, format
,
5505 type
, pixels
, pc
+ 64, pc
+ 8);
5510 #define X_GLrop_TexSubImage1D 4099
5512 __indirect_glTexSubImage1D(GLenum target
, GLint level
, GLint xoffset
,
5513 GLsizei width
, GLenum format
, GLenum type
,
5514 const GLvoid
* pixels
)
5516 __glx_TexSubImage_1D2D(X_GLrop_TexSubImage1D
, 1, target
, level
, xoffset
,
5517 1, width
, 1, format
, type
, pixels
);
5520 #define X_GLrop_TexSubImage2D 4100
5522 __indirect_glTexSubImage2D(GLenum target
, GLint level
, GLint xoffset
,
5523 GLint yoffset
, GLsizei width
, GLsizei height
,
5524 GLenum format
, GLenum type
, const GLvoid
* pixels
)
5526 __glx_TexSubImage_1D2D(X_GLrop_TexSubImage2D
, 2, target
, level
, xoffset
,
5527 yoffset
, width
, height
, format
, type
, pixels
);
5530 #define X_GLrop_BlendColor 4096
5532 __indirect_glBlendColor(GLclampf red
, GLclampf green
, GLclampf blue
,
5535 __GLXcontext
*const gc
= __glXGetCurrentContext();
5536 const GLuint cmdlen
= 20;
5537 emit_header(gc
->pc
, X_GLrop_BlendColor
, cmdlen
);
5538 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&red
), 4);
5539 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&green
), 4);
5540 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&blue
), 4);
5541 (void) memcpy((void *) (gc
->pc
+ 16), (void *) (&alpha
), 4);
5543 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
5544 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
5548 #define X_GLrop_BlendEquation 4097
5550 __indirect_glBlendEquation(GLenum mode
)
5552 __GLXcontext
*const gc
= __glXGetCurrentContext();
5553 const GLuint cmdlen
= 8;
5554 emit_header(gc
->pc
, X_GLrop_BlendEquation
, cmdlen
);
5555 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&mode
), 4);
5557 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
5558 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
5562 #define X_GLrop_ColorTable 2053
5564 __indirect_glColorTable(GLenum target
, GLenum internalformat
, GLsizei width
,
5565 GLenum format
, GLenum type
, const GLvoid
* table
)
5567 __GLXcontext
*const gc
= __glXGetCurrentContext();
5568 const GLuint compsize
=
5569 (table
!= NULL
) ? __glImageSize(width
, 1, 1, format
, type
,
5571 const GLuint cmdlen
= 44 + __GLX_PAD(compsize
);
5572 if (__builtin_expect(gc
->currentDpy
!= NULL
, 1)) {
5573 if (cmdlen
<= gc
->maxSmallRenderCommandSize
) {
5574 if ((gc
->pc
+ cmdlen
) > gc
->bufEnd
) {
5575 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
5577 emit_header(gc
->pc
, X_GLrop_ColorTable
, cmdlen
);
5578 (void) memcpy((void *) (gc
->pc
+ 24), (void *) (&target
), 4);
5579 (void) memcpy((void *) (gc
->pc
+ 28), (void *) (&internalformat
),
5581 (void) memcpy((void *) (gc
->pc
+ 32), (void *) (&width
), 4);
5582 (void) memcpy((void *) (gc
->pc
+ 36), (void *) (&format
), 4);
5583 (void) memcpy((void *) (gc
->pc
+ 40), (void *) (&type
), 4);
5585 (*gc
->fillImage
) (gc
, 1, width
, 1, 1, format
, type
, table
,
5586 gc
->pc
+ 44, gc
->pc
+ 4);
5588 (void) memcpy(gc
->pc
+ 4, default_pixel_store_1D
,
5589 default_pixel_store_1D_size
);
5592 if (gc
->pc
> gc
->limit
) {
5593 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
5596 const GLint op
= X_GLrop_ColorTable
;
5597 const GLuint cmdlenLarge
= cmdlen
+ 4;
5598 GLubyte
*const pc
= __glXFlushRenderBuffer(gc
, gc
->pc
);
5599 (void) memcpy((void *) (pc
+ 0), (void *) (&cmdlenLarge
), 4);
5600 (void) memcpy((void *) (pc
+ 4), (void *) (&op
), 4);
5601 (void) memcpy((void *) (pc
+ 28), (void *) (&target
), 4);
5602 (void) memcpy((void *) (pc
+ 32), (void *) (&internalformat
), 4);
5603 (void) memcpy((void *) (pc
+ 36), (void *) (&width
), 4);
5604 (void) memcpy((void *) (pc
+ 40), (void *) (&format
), 4);
5605 (void) memcpy((void *) (pc
+ 44), (void *) (&type
), 4);
5606 __glXSendLargeImage(gc
, compsize
, 1, width
, 1, 1, format
, type
,
5607 table
, pc
+ 48, pc
+ 8);
5612 #define X_GLrop_ColorTableParameterfv 2054
5614 __indirect_glColorTableParameterfv(GLenum target
, GLenum pname
,
5615 const GLfloat
* params
)
5617 __GLXcontext
*const gc
= __glXGetCurrentContext();
5618 const GLuint compsize
= __glColorTableParameterfv_size(pname
);
5619 const GLuint cmdlen
= 12 + __GLX_PAD((compsize
* 4));
5620 emit_header(gc
->pc
, X_GLrop_ColorTableParameterfv
, cmdlen
);
5621 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&target
), 4);
5622 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&pname
), 4);
5623 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (params
), (compsize
* 4));
5625 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
5626 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
5630 #define X_GLrop_ColorTableParameteriv 2055
5632 __indirect_glColorTableParameteriv(GLenum target
, GLenum pname
,
5633 const GLint
* params
)
5635 __GLXcontext
*const gc
= __glXGetCurrentContext();
5636 const GLuint compsize
= __glColorTableParameteriv_size(pname
);
5637 const GLuint cmdlen
= 12 + __GLX_PAD((compsize
* 4));
5638 emit_header(gc
->pc
, X_GLrop_ColorTableParameteriv
, cmdlen
);
5639 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&target
), 4);
5640 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&pname
), 4);
5641 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (params
), (compsize
* 4));
5643 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
5644 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
5648 #define X_GLrop_CopyColorTable 2056
5650 __indirect_glCopyColorTable(GLenum target
, GLenum internalformat
, GLint x
,
5651 GLint y
, GLsizei width
)
5653 __GLXcontext
*const gc
= __glXGetCurrentContext();
5654 const GLuint cmdlen
= 24;
5655 emit_header(gc
->pc
, X_GLrop_CopyColorTable
, cmdlen
);
5656 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&target
), 4);
5657 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&internalformat
), 4);
5658 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&x
), 4);
5659 (void) memcpy((void *) (gc
->pc
+ 16), (void *) (&y
), 4);
5660 (void) memcpy((void *) (gc
->pc
+ 20), (void *) (&width
), 4);
5662 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
5663 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
5667 #define X_GLsop_GetColorTable 147
5669 __indirect_glGetColorTable(GLenum target
, GLenum format
, GLenum type
,
5672 __GLXcontext
*const gc
= __glXGetCurrentContext();
5673 const __GLXattribute
*const state
= gc
->client_state_private
;
5674 Display
*const dpy
= gc
->currentDpy
;
5676 const GLuint cmdlen
= 16;
5678 if (__builtin_expect(dpy
!= NULL
, 1)) {
5680 xcb_connection_t
*c
= XGetXCBConnection(dpy
);
5681 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
5682 xcb_glx_get_color_table_reply_t
*reply
=
5683 xcb_glx_get_color_table_reply(c
,
5684 xcb_glx_get_color_table(c
,
5694 (void) memcpy(table
, xcb_glx_get_color_table_data(reply
),
5695 xcb_glx_get_color_table_data_length(reply
) *
5700 __glXSetupSingleRequest(gc
, X_GLsop_GetColorTable
, cmdlen
);
5701 (void) memcpy((void *) (pc
+ 0), (void *) (&target
), 4);
5702 (void) memcpy((void *) (pc
+ 4), (void *) (&format
), 4);
5703 (void) memcpy((void *) (pc
+ 8), (void *) (&type
), 4);
5704 *(int32_t *) (pc
+ 12) = 0;
5705 *(int8_t *) (pc
+ 12) = state
->storePack
.swapEndian
;
5706 __glXReadPixelReply(dpy
, gc
, 1, 0, 0, 0, format
, type
, table
,
5710 #endif /* USE_XCB */
5715 #define X_GLvop_GetColorTableSGI 4098
5717 glGetColorTableEXT(GLenum target
, GLenum format
, GLenum type
, GLvoid
* table
)
5719 __GLXcontext
*const gc
= __glXGetCurrentContext();
5721 if (gc
->driContext
) {
5722 CALL_GetColorTable(GET_DISPATCH(), (target
, format
, type
, table
));
5724 __GLXcontext
*const gc
= __glXGetCurrentContext();
5725 const __GLXattribute
*const state
= gc
->client_state_private
;
5726 Display
*const dpy
= gc
->currentDpy
;
5727 const GLuint cmdlen
= 16;
5728 if (__builtin_expect(dpy
!= NULL
, 1)) {
5730 __glXSetupVendorRequest(gc
, X_GLXVendorPrivateWithReply
,
5731 X_GLvop_GetColorTableSGI
, cmdlen
);
5732 (void) memcpy((void *) (pc
+ 0), (void *) (&target
), 4);
5733 (void) memcpy((void *) (pc
+ 4), (void *) (&format
), 4);
5734 (void) memcpy((void *) (pc
+ 8), (void *) (&type
), 4);
5735 *(int32_t *) (pc
+ 12) = 0;
5736 *(int8_t *) (pc
+ 12) = state
->storePack
.swapEndian
;
5737 __glXReadPixelReply(dpy
, gc
, 1, 0, 0, 0, format
, type
, table
,
5746 #define X_GLsop_GetColorTableParameterfv 148
5748 __indirect_glGetColorTableParameterfv(GLenum target
, GLenum pname
,
5751 __GLXcontext
*const gc
= __glXGetCurrentContext();
5752 Display
*const dpy
= gc
->currentDpy
;
5754 const GLuint cmdlen
= 8;
5756 if (__builtin_expect(dpy
!= NULL
, 1)) {
5758 xcb_connection_t
*c
= XGetXCBConnection(dpy
);
5759 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
5760 xcb_glx_get_color_table_parameterfv_reply_t
*reply
=
5761 xcb_glx_get_color_table_parameterfv_reply(c
,
5762 xcb_glx_get_color_table_parameterfv
5764 gc
->currentContextTag
,
5765 target
, pname
), NULL
);
5766 if (xcb_glx_get_color_table_parameterfv_data_length(reply
) == 0)
5767 (void) memcpy(params
, &reply
->datum
, sizeof(reply
->datum
));
5769 (void) memcpy(params
,
5770 xcb_glx_get_color_table_parameterfv_data(reply
),
5771 xcb_glx_get_color_table_parameterfv_data_length
5772 (reply
) * sizeof(GLfloat
));
5776 __glXSetupSingleRequest(gc
, X_GLsop_GetColorTableParameterfv
,
5778 (void) memcpy((void *) (pc
+ 0), (void *) (&target
), 4);
5779 (void) memcpy((void *) (pc
+ 4), (void *) (&pname
), 4);
5780 (void) __glXReadReply(dpy
, 4, params
, GL_FALSE
);
5783 #endif /* USE_XCB */
5788 #define X_GLvop_GetColorTableParameterfvSGI 4099
5790 glGetColorTableParameterfvEXT(GLenum target
, GLenum pname
, GLfloat
* params
)
5792 __GLXcontext
*const gc
= __glXGetCurrentContext();
5794 if (gc
->driContext
) {
5795 CALL_GetColorTableParameterfv(GET_DISPATCH(),
5796 (target
, pname
, params
));
5798 __GLXcontext
*const gc
= __glXGetCurrentContext();
5799 Display
*const dpy
= gc
->currentDpy
;
5800 const GLuint cmdlen
= 8;
5801 if (__builtin_expect(dpy
!= NULL
, 1)) {
5803 __glXSetupVendorRequest(gc
, X_GLXVendorPrivateWithReply
,
5804 X_GLvop_GetColorTableParameterfvSGI
,
5806 (void) memcpy((void *) (pc
+ 0), (void *) (&target
), 4);
5807 (void) memcpy((void *) (pc
+ 4), (void *) (&pname
), 4);
5808 (void) __glXReadReply(dpy
, 4, params
, GL_FALSE
);
5816 #define X_GLsop_GetColorTableParameteriv 149
5818 __indirect_glGetColorTableParameteriv(GLenum target
, GLenum pname
,
5821 __GLXcontext
*const gc
= __glXGetCurrentContext();
5822 Display
*const dpy
= gc
->currentDpy
;
5824 const GLuint cmdlen
= 8;
5826 if (__builtin_expect(dpy
!= NULL
, 1)) {
5828 xcb_connection_t
*c
= XGetXCBConnection(dpy
);
5829 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
5830 xcb_glx_get_color_table_parameteriv_reply_t
*reply
=
5831 xcb_glx_get_color_table_parameteriv_reply(c
,
5832 xcb_glx_get_color_table_parameteriv
5834 gc
->currentContextTag
,
5835 target
, pname
), NULL
);
5836 if (xcb_glx_get_color_table_parameteriv_data_length(reply
) == 0)
5837 (void) memcpy(params
, &reply
->datum
, sizeof(reply
->datum
));
5839 (void) memcpy(params
,
5840 xcb_glx_get_color_table_parameteriv_data(reply
),
5841 xcb_glx_get_color_table_parameteriv_data_length
5842 (reply
) * sizeof(GLint
));
5846 __glXSetupSingleRequest(gc
, X_GLsop_GetColorTableParameteriv
,
5848 (void) memcpy((void *) (pc
+ 0), (void *) (&target
), 4);
5849 (void) memcpy((void *) (pc
+ 4), (void *) (&pname
), 4);
5850 (void) __glXReadReply(dpy
, 4, params
, GL_FALSE
);
5853 #endif /* USE_XCB */
5858 #define X_GLvop_GetColorTableParameterivSGI 4100
5860 glGetColorTableParameterivEXT(GLenum target
, GLenum pname
, GLint
* params
)
5862 __GLXcontext
*const gc
= __glXGetCurrentContext();
5864 if (gc
->driContext
) {
5865 CALL_GetColorTableParameteriv(GET_DISPATCH(),
5866 (target
, pname
, params
));
5868 __GLXcontext
*const gc
= __glXGetCurrentContext();
5869 Display
*const dpy
= gc
->currentDpy
;
5870 const GLuint cmdlen
= 8;
5871 if (__builtin_expect(dpy
!= NULL
, 1)) {
5873 __glXSetupVendorRequest(gc
, X_GLXVendorPrivateWithReply
,
5874 X_GLvop_GetColorTableParameterivSGI
,
5876 (void) memcpy((void *) (pc
+ 0), (void *) (&target
), 4);
5877 (void) memcpy((void *) (pc
+ 4), (void *) (&pname
), 4);
5878 (void) __glXReadReply(dpy
, 4, params
, GL_FALSE
);
5886 #define X_GLrop_ColorSubTable 195
5888 __indirect_glColorSubTable(GLenum target
, GLsizei start
, GLsizei count
,
5889 GLenum format
, GLenum type
, const GLvoid
* data
)
5891 __GLXcontext
*const gc
= __glXGetCurrentContext();
5892 const GLuint compsize
=
5893 (data
!= NULL
) ? __glImageSize(count
, 1, 1, format
, type
, target
) : 0;
5894 const GLuint cmdlen
= 44 + __GLX_PAD(compsize
);
5895 if (__builtin_expect(gc
->currentDpy
!= NULL
, 1)) {
5896 if (cmdlen
<= gc
->maxSmallRenderCommandSize
) {
5897 if ((gc
->pc
+ cmdlen
) > gc
->bufEnd
) {
5898 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
5900 emit_header(gc
->pc
, X_GLrop_ColorSubTable
, cmdlen
);
5901 (void) memcpy((void *) (gc
->pc
+ 24), (void *) (&target
), 4);
5902 (void) memcpy((void *) (gc
->pc
+ 28), (void *) (&start
), 4);
5903 (void) memcpy((void *) (gc
->pc
+ 32), (void *) (&count
), 4);
5904 (void) memcpy((void *) (gc
->pc
+ 36), (void *) (&format
), 4);
5905 (void) memcpy((void *) (gc
->pc
+ 40), (void *) (&type
), 4);
5907 (*gc
->fillImage
) (gc
, 1, count
, 1, 1, format
, type
, data
,
5908 gc
->pc
+ 44, gc
->pc
+ 4);
5910 (void) memcpy(gc
->pc
+ 4, default_pixel_store_1D
,
5911 default_pixel_store_1D_size
);
5914 if (gc
->pc
> gc
->limit
) {
5915 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
5918 const GLint op
= X_GLrop_ColorSubTable
;
5919 const GLuint cmdlenLarge
= cmdlen
+ 4;
5920 GLubyte
*const pc
= __glXFlushRenderBuffer(gc
, gc
->pc
);
5921 (void) memcpy((void *) (pc
+ 0), (void *) (&cmdlenLarge
), 4);
5922 (void) memcpy((void *) (pc
+ 4), (void *) (&op
), 4);
5923 (void) memcpy((void *) (pc
+ 28), (void *) (&target
), 4);
5924 (void) memcpy((void *) (pc
+ 32), (void *) (&start
), 4);
5925 (void) memcpy((void *) (pc
+ 36), (void *) (&count
), 4);
5926 (void) memcpy((void *) (pc
+ 40), (void *) (&format
), 4);
5927 (void) memcpy((void *) (pc
+ 44), (void *) (&type
), 4);
5928 __glXSendLargeImage(gc
, compsize
, 1, count
, 1, 1, format
, type
,
5929 data
, pc
+ 48, pc
+ 8);
5934 #define X_GLrop_CopyColorSubTable 196
5936 __indirect_glCopyColorSubTable(GLenum target
, GLsizei start
, GLint x
, GLint y
,
5939 __GLXcontext
*const gc
= __glXGetCurrentContext();
5940 const GLuint cmdlen
= 24;
5941 emit_header(gc
->pc
, X_GLrop_CopyColorSubTable
, cmdlen
);
5942 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&target
), 4);
5943 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&start
), 4);
5944 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&x
), 4);
5945 (void) memcpy((void *) (gc
->pc
+ 16), (void *) (&y
), 4);
5946 (void) memcpy((void *) (gc
->pc
+ 20), (void *) (&width
), 4);
5948 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
5949 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
5954 __glx_ConvolutionFilter_1D2D(unsigned opcode
, unsigned dim
, GLenum target
,
5955 GLenum internalformat
, GLsizei width
,
5956 GLsizei height
, GLenum format
, GLenum type
,
5957 const GLvoid
* image
)
5959 __GLXcontext
*const gc
= __glXGetCurrentContext();
5960 const GLuint compsize
=
5961 (image
!= NULL
) ? __glImageSize(width
, height
, 1, format
, type
,
5963 const GLuint cmdlen
= 48 + __GLX_PAD(compsize
);
5964 if (__builtin_expect(gc
->currentDpy
!= NULL
, 1)) {
5965 if (cmdlen
<= gc
->maxSmallRenderCommandSize
) {
5966 if ((gc
->pc
+ cmdlen
) > gc
->bufEnd
) {
5967 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
5969 emit_header(gc
->pc
, opcode
, cmdlen
);
5970 (void) memcpy((void *) (gc
->pc
+ 24), (void *) (&target
), 4);
5971 (void) memcpy((void *) (gc
->pc
+ 28), (void *) (&internalformat
),
5973 (void) memcpy((void *) (gc
->pc
+ 32), (void *) (&width
), 4);
5974 (void) memcpy((void *) (gc
->pc
+ 36), (void *) (&height
), 4);
5975 (void) memcpy((void *) (gc
->pc
+ 40), (void *) (&format
), 4);
5976 (void) memcpy((void *) (gc
->pc
+ 44), (void *) (&type
), 4);
5978 (*gc
->fillImage
) (gc
, dim
, width
, height
, 1, format
, type
,
5979 image
, gc
->pc
+ 48, gc
->pc
+ 4);
5981 (void) memcpy(gc
->pc
+ 4, default_pixel_store_2D
,
5982 default_pixel_store_2D_size
);
5985 if (gc
->pc
> gc
->limit
) {
5986 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
5989 const GLint op
= opcode
;
5990 const GLuint cmdlenLarge
= cmdlen
+ 4;
5991 GLubyte
*const pc
= __glXFlushRenderBuffer(gc
, gc
->pc
);
5992 (void) memcpy((void *) (pc
+ 0), (void *) (&cmdlenLarge
), 4);
5993 (void) memcpy((void *) (pc
+ 4), (void *) (&op
), 4);
5994 (void) memcpy((void *) (pc
+ 28), (void *) (&target
), 4);
5995 (void) memcpy((void *) (pc
+ 32), (void *) (&internalformat
), 4);
5996 (void) memcpy((void *) (pc
+ 36), (void *) (&width
), 4);
5997 (void) memcpy((void *) (pc
+ 40), (void *) (&height
), 4);
5998 (void) memcpy((void *) (pc
+ 44), (void *) (&format
), 4);
5999 (void) memcpy((void *) (pc
+ 48), (void *) (&type
), 4);
6000 __glXSendLargeImage(gc
, compsize
, dim
, width
, height
, 1, format
,
6001 type
, image
, pc
+ 52, pc
+ 8);
6006 #define X_GLrop_ConvolutionFilter1D 4101
6008 __indirect_glConvolutionFilter1D(GLenum target
, GLenum internalformat
,
6009 GLsizei width
, GLenum format
, GLenum type
,
6010 const GLvoid
* image
)
6012 __glx_ConvolutionFilter_1D2D(X_GLrop_ConvolutionFilter1D
, 1, target
,
6013 internalformat
, width
, 1, format
, type
,
6017 #define X_GLrop_ConvolutionFilter2D 4102
6019 __indirect_glConvolutionFilter2D(GLenum target
, GLenum internalformat
,
6020 GLsizei width
, GLsizei height
, GLenum format
,
6021 GLenum type
, const GLvoid
* image
)
6023 __glx_ConvolutionFilter_1D2D(X_GLrop_ConvolutionFilter2D
, 2, target
,
6024 internalformat
, width
, height
, format
, type
,
6028 #define X_GLrop_ConvolutionParameterf 4103
6030 __indirect_glConvolutionParameterf(GLenum target
, GLenum pname
,
6033 __GLXcontext
*const gc
= __glXGetCurrentContext();
6034 const GLuint cmdlen
= 16;
6035 emit_header(gc
->pc
, X_GLrop_ConvolutionParameterf
, cmdlen
);
6036 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&target
), 4);
6037 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&pname
), 4);
6038 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (¶ms
), 4);
6040 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
6041 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
6045 #define X_GLrop_ConvolutionParameterfv 4104
6047 __indirect_glConvolutionParameterfv(GLenum target
, GLenum pname
,
6048 const GLfloat
* params
)
6050 __GLXcontext
*const gc
= __glXGetCurrentContext();
6051 const GLuint compsize
= __glConvolutionParameterfv_size(pname
);
6052 const GLuint cmdlen
= 12 + __GLX_PAD((compsize
* 4));
6053 emit_header(gc
->pc
, X_GLrop_ConvolutionParameterfv
, cmdlen
);
6054 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&target
), 4);
6055 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&pname
), 4);
6056 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (params
), (compsize
* 4));
6058 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
6059 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
6063 #define X_GLrop_ConvolutionParameteri 4105
6065 __indirect_glConvolutionParameteri(GLenum target
, GLenum pname
, GLint params
)
6067 __GLXcontext
*const gc
= __glXGetCurrentContext();
6068 const GLuint cmdlen
= 16;
6069 emit_header(gc
->pc
, X_GLrop_ConvolutionParameteri
, cmdlen
);
6070 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&target
), 4);
6071 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&pname
), 4);
6072 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (¶ms
), 4);
6074 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
6075 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
6079 #define X_GLrop_ConvolutionParameteriv 4106
6081 __indirect_glConvolutionParameteriv(GLenum target
, GLenum pname
,
6082 const GLint
* params
)
6084 __GLXcontext
*const gc
= __glXGetCurrentContext();
6085 const GLuint compsize
= __glConvolutionParameteriv_size(pname
);
6086 const GLuint cmdlen
= 12 + __GLX_PAD((compsize
* 4));
6087 emit_header(gc
->pc
, X_GLrop_ConvolutionParameteriv
, cmdlen
);
6088 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&target
), 4);
6089 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&pname
), 4);
6090 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (params
), (compsize
* 4));
6092 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
6093 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
6097 #define X_GLrop_CopyConvolutionFilter1D 4107
6099 __indirect_glCopyConvolutionFilter1D(GLenum target
, GLenum internalformat
,
6100 GLint x
, GLint y
, GLsizei width
)
6102 __GLXcontext
*const gc
= __glXGetCurrentContext();
6103 const GLuint cmdlen
= 24;
6104 emit_header(gc
->pc
, X_GLrop_CopyConvolutionFilter1D
, cmdlen
);
6105 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&target
), 4);
6106 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&internalformat
), 4);
6107 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&x
), 4);
6108 (void) memcpy((void *) (gc
->pc
+ 16), (void *) (&y
), 4);
6109 (void) memcpy((void *) (gc
->pc
+ 20), (void *) (&width
), 4);
6111 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
6112 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
6116 #define X_GLrop_CopyConvolutionFilter2D 4108
6118 __indirect_glCopyConvolutionFilter2D(GLenum target
, GLenum internalformat
,
6119 GLint x
, GLint y
, GLsizei width
,
6122 __GLXcontext
*const gc
= __glXGetCurrentContext();
6123 const GLuint cmdlen
= 28;
6124 emit_header(gc
->pc
, X_GLrop_CopyConvolutionFilter2D
, cmdlen
);
6125 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&target
), 4);
6126 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&internalformat
), 4);
6127 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&x
), 4);
6128 (void) memcpy((void *) (gc
->pc
+ 16), (void *) (&y
), 4);
6129 (void) memcpy((void *) (gc
->pc
+ 20), (void *) (&width
), 4);
6130 (void) memcpy((void *) (gc
->pc
+ 24), (void *) (&height
), 4);
6132 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
6133 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
6137 #define X_GLsop_GetConvolutionFilter 150
6139 __indirect_glGetConvolutionFilter(GLenum target
, GLenum format
, GLenum type
,
6142 __GLXcontext
*const gc
= __glXGetCurrentContext();
6143 const __GLXattribute
*const state
= gc
->client_state_private
;
6144 Display
*const dpy
= gc
->currentDpy
;
6146 const GLuint cmdlen
= 16;
6148 if (__builtin_expect(dpy
!= NULL
, 1)) {
6150 xcb_connection_t
*c
= XGetXCBConnection(dpy
);
6151 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
6152 xcb_glx_get_convolution_filter_reply_t
*reply
=
6153 xcb_glx_get_convolution_filter_reply(c
,
6154 xcb_glx_get_convolution_filter
6155 (c
, gc
->currentContextTag
,
6156 target
, format
, type
,
6159 (void) memcpy(image
, xcb_glx_get_convolution_filter_data(reply
),
6160 xcb_glx_get_convolution_filter_data_length(reply
) *
6165 __glXSetupSingleRequest(gc
, X_GLsop_GetConvolutionFilter
, cmdlen
);
6166 (void) memcpy((void *) (pc
+ 0), (void *) (&target
), 4);
6167 (void) memcpy((void *) (pc
+ 4), (void *) (&format
), 4);
6168 (void) memcpy((void *) (pc
+ 8), (void *) (&type
), 4);
6169 *(int32_t *) (pc
+ 12) = 0;
6170 *(int8_t *) (pc
+ 12) = state
->storePack
.swapEndian
;
6171 __glXReadPixelReply(dpy
, gc
, 2, 0, 0, 0, format
, type
, image
,
6175 #endif /* USE_XCB */
6180 #define X_GLvop_GetConvolutionFilterEXT 1
6182 gl_dispatch_stub_356(GLenum target
, GLenum format
, GLenum type
,
6185 __GLXcontext
*const gc
= __glXGetCurrentContext();
6187 if (gc
->driContext
) {
6188 CALL_GetConvolutionFilter(GET_DISPATCH(),
6189 (target
, format
, type
, image
));
6191 __GLXcontext
*const gc
= __glXGetCurrentContext();
6192 const __GLXattribute
*const state
= gc
->client_state_private
;
6193 Display
*const dpy
= gc
->currentDpy
;
6194 const GLuint cmdlen
= 16;
6195 if (__builtin_expect(dpy
!= NULL
, 1)) {
6197 __glXSetupVendorRequest(gc
, X_GLXVendorPrivateWithReply
,
6198 X_GLvop_GetConvolutionFilterEXT
,
6200 (void) memcpy((void *) (pc
+ 0), (void *) (&target
), 4);
6201 (void) memcpy((void *) (pc
+ 4), (void *) (&format
), 4);
6202 (void) memcpy((void *) (pc
+ 8), (void *) (&type
), 4);
6203 *(int32_t *) (pc
+ 12) = 0;
6204 *(int8_t *) (pc
+ 12) = state
->storePack
.swapEndian
;
6205 __glXReadPixelReply(dpy
, gc
, 2, 0, 0, 0, format
, type
, image
,
6214 #define X_GLsop_GetConvolutionParameterfv 151
6216 __indirect_glGetConvolutionParameterfv(GLenum target
, GLenum pname
,
6219 __GLXcontext
*const gc
= __glXGetCurrentContext();
6220 Display
*const dpy
= gc
->currentDpy
;
6222 const GLuint cmdlen
= 8;
6224 if (__builtin_expect(dpy
!= NULL
, 1)) {
6226 xcb_connection_t
*c
= XGetXCBConnection(dpy
);
6227 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
6228 xcb_glx_get_convolution_parameterfv_reply_t
*reply
=
6229 xcb_glx_get_convolution_parameterfv_reply(c
,
6230 xcb_glx_get_convolution_parameterfv
6232 gc
->currentContextTag
,
6233 target
, pname
), NULL
);
6234 if (xcb_glx_get_convolution_parameterfv_data_length(reply
) == 0)
6235 (void) memcpy(params
, &reply
->datum
, sizeof(reply
->datum
));
6237 (void) memcpy(params
,
6238 xcb_glx_get_convolution_parameterfv_data(reply
),
6239 xcb_glx_get_convolution_parameterfv_data_length
6240 (reply
) * sizeof(GLfloat
));
6244 __glXSetupSingleRequest(gc
, X_GLsop_GetConvolutionParameterfv
,
6246 (void) memcpy((void *) (pc
+ 0), (void *) (&target
), 4);
6247 (void) memcpy((void *) (pc
+ 4), (void *) (&pname
), 4);
6248 (void) __glXReadReply(dpy
, 4, params
, GL_FALSE
);
6251 #endif /* USE_XCB */
6256 #define X_GLvop_GetConvolutionParameterfvEXT 2
6258 gl_dispatch_stub_357(GLenum target
, GLenum pname
, GLfloat
* params
)
6260 __GLXcontext
*const gc
= __glXGetCurrentContext();
6262 if (gc
->driContext
) {
6263 CALL_GetConvolutionParameterfv(GET_DISPATCH(),
6264 (target
, pname
, params
));
6266 __GLXcontext
*const gc
= __glXGetCurrentContext();
6267 Display
*const dpy
= gc
->currentDpy
;
6268 const GLuint cmdlen
= 8;
6269 if (__builtin_expect(dpy
!= NULL
, 1)) {
6271 __glXSetupVendorRequest(gc
, X_GLXVendorPrivateWithReply
,
6272 X_GLvop_GetConvolutionParameterfvEXT
,
6274 (void) memcpy((void *) (pc
+ 0), (void *) (&target
), 4);
6275 (void) memcpy((void *) (pc
+ 4), (void *) (&pname
), 4);
6276 (void) __glXReadReply(dpy
, 4, params
, GL_FALSE
);
6284 #define X_GLsop_GetConvolutionParameteriv 152
6286 __indirect_glGetConvolutionParameteriv(GLenum target
, GLenum pname
,
6289 __GLXcontext
*const gc
= __glXGetCurrentContext();
6290 Display
*const dpy
= gc
->currentDpy
;
6292 const GLuint cmdlen
= 8;
6294 if (__builtin_expect(dpy
!= NULL
, 1)) {
6296 xcb_connection_t
*c
= XGetXCBConnection(dpy
);
6297 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
6298 xcb_glx_get_convolution_parameteriv_reply_t
*reply
=
6299 xcb_glx_get_convolution_parameteriv_reply(c
,
6300 xcb_glx_get_convolution_parameteriv
6302 gc
->currentContextTag
,
6303 target
, pname
), NULL
);
6304 if (xcb_glx_get_convolution_parameteriv_data_length(reply
) == 0)
6305 (void) memcpy(params
, &reply
->datum
, sizeof(reply
->datum
));
6307 (void) memcpy(params
,
6308 xcb_glx_get_convolution_parameteriv_data(reply
),
6309 xcb_glx_get_convolution_parameteriv_data_length
6310 (reply
) * sizeof(GLint
));
6314 __glXSetupSingleRequest(gc
, X_GLsop_GetConvolutionParameteriv
,
6316 (void) memcpy((void *) (pc
+ 0), (void *) (&target
), 4);
6317 (void) memcpy((void *) (pc
+ 4), (void *) (&pname
), 4);
6318 (void) __glXReadReply(dpy
, 4, params
, GL_FALSE
);
6321 #endif /* USE_XCB */
6326 #define X_GLvop_GetConvolutionParameterivEXT 3
6328 gl_dispatch_stub_358(GLenum target
, GLenum pname
, GLint
* params
)
6330 __GLXcontext
*const gc
= __glXGetCurrentContext();
6332 if (gc
->driContext
) {
6333 CALL_GetConvolutionParameteriv(GET_DISPATCH(),
6334 (target
, pname
, params
));
6336 __GLXcontext
*const gc
= __glXGetCurrentContext();
6337 Display
*const dpy
= gc
->currentDpy
;
6338 const GLuint cmdlen
= 8;
6339 if (__builtin_expect(dpy
!= NULL
, 1)) {
6341 __glXSetupVendorRequest(gc
, X_GLXVendorPrivateWithReply
,
6342 X_GLvop_GetConvolutionParameterivEXT
,
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
);
6354 #define X_GLsop_GetHistogram 154
6356 __indirect_glGetHistogram(GLenum target
, GLboolean reset
, GLenum format
,
6357 GLenum type
, GLvoid
* values
)
6359 __GLXcontext
*const gc
= __glXGetCurrentContext();
6360 const __GLXattribute
*const state
= gc
->client_state_private
;
6361 Display
*const dpy
= gc
->currentDpy
;
6363 const GLuint cmdlen
= 16;
6365 if (__builtin_expect(dpy
!= NULL
, 1)) {
6367 xcb_connection_t
*c
= XGetXCBConnection(dpy
);
6368 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
6369 xcb_glx_get_histogram_reply_t
*reply
=
6370 xcb_glx_get_histogram_reply(c
,
6371 xcb_glx_get_histogram(c
,
6380 (void) memcpy(values
, xcb_glx_get_histogram_data(reply
),
6381 xcb_glx_get_histogram_data_length(reply
) *
6386 __glXSetupSingleRequest(gc
, X_GLsop_GetHistogram
, cmdlen
);
6387 (void) memcpy((void *) (pc
+ 0), (void *) (&target
), 4);
6388 (void) memcpy((void *) (pc
+ 4), (void *) (&format
), 4);
6389 (void) memcpy((void *) (pc
+ 8), (void *) (&type
), 4);
6390 *(int32_t *) (pc
+ 12) = 0;
6391 *(int8_t *) (pc
+ 12) = state
->storePack
.swapEndian
;
6392 *(int8_t *) (pc
+ 13) = reset
;
6393 __glXReadPixelReply(dpy
, gc
, 1, 0, 0, 0, format
, type
, values
,
6397 #endif /* USE_XCB */
6402 #define X_GLvop_GetHistogramEXT 5
6404 gl_dispatch_stub_361(GLenum target
, GLboolean reset
, GLenum format
,
6405 GLenum type
, GLvoid
* values
)
6407 __GLXcontext
*const gc
= __glXGetCurrentContext();
6409 if (gc
->driContext
) {
6410 CALL_GetHistogram(GET_DISPATCH(),
6411 (target
, reset
, format
, type
, values
));
6413 __GLXcontext
*const gc
= __glXGetCurrentContext();
6414 const __GLXattribute
*const state
= gc
->client_state_private
;
6415 Display
*const dpy
= gc
->currentDpy
;
6416 const GLuint cmdlen
= 16;
6417 if (__builtin_expect(dpy
!= NULL
, 1)) {
6419 __glXSetupVendorRequest(gc
, X_GLXVendorPrivateWithReply
,
6420 X_GLvop_GetHistogramEXT
, cmdlen
);
6421 (void) memcpy((void *) (pc
+ 0), (void *) (&target
), 4);
6422 (void) memcpy((void *) (pc
+ 4), (void *) (&format
), 4);
6423 (void) memcpy((void *) (pc
+ 8), (void *) (&type
), 4);
6424 *(int32_t *) (pc
+ 12) = 0;
6425 *(int8_t *) (pc
+ 12) = state
->storePack
.swapEndian
;
6426 *(int8_t *) (pc
+ 13) = reset
;
6427 __glXReadPixelReply(dpy
, gc
, 1, 0, 0, 0, format
, type
, values
,
6436 #define X_GLsop_GetHistogramParameterfv 155
6438 __indirect_glGetHistogramParameterfv(GLenum target
, GLenum pname
,
6441 __GLXcontext
*const gc
= __glXGetCurrentContext();
6442 Display
*const dpy
= gc
->currentDpy
;
6444 const GLuint cmdlen
= 8;
6446 if (__builtin_expect(dpy
!= NULL
, 1)) {
6448 xcb_connection_t
*c
= XGetXCBConnection(dpy
);
6449 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
6450 xcb_glx_get_histogram_parameterfv_reply_t
*reply
=
6451 xcb_glx_get_histogram_parameterfv_reply(c
,
6452 xcb_glx_get_histogram_parameterfv
6453 (c
, gc
->currentContextTag
,
6454 target
, pname
), NULL
);
6455 if (xcb_glx_get_histogram_parameterfv_data_length(reply
) == 0)
6456 (void) memcpy(params
, &reply
->datum
, sizeof(reply
->datum
));
6458 (void) memcpy(params
,
6459 xcb_glx_get_histogram_parameterfv_data(reply
),
6460 xcb_glx_get_histogram_parameterfv_data_length(reply
)
6465 __glXSetupSingleRequest(gc
, X_GLsop_GetHistogramParameterfv
,
6467 (void) memcpy((void *) (pc
+ 0), (void *) (&target
), 4);
6468 (void) memcpy((void *) (pc
+ 4), (void *) (&pname
), 4);
6469 (void) __glXReadReply(dpy
, 4, params
, GL_FALSE
);
6472 #endif /* USE_XCB */
6477 #define X_GLvop_GetHistogramParameterfvEXT 6
6479 gl_dispatch_stub_362(GLenum target
, GLenum pname
, GLfloat
* params
)
6481 __GLXcontext
*const gc
= __glXGetCurrentContext();
6483 if (gc
->driContext
) {
6484 CALL_GetHistogramParameterfv(GET_DISPATCH(), (target
, pname
, params
));
6486 __GLXcontext
*const gc
= __glXGetCurrentContext();
6487 Display
*const dpy
= gc
->currentDpy
;
6488 const GLuint cmdlen
= 8;
6489 if (__builtin_expect(dpy
!= NULL
, 1)) {
6491 __glXSetupVendorRequest(gc
, X_GLXVendorPrivateWithReply
,
6492 X_GLvop_GetHistogramParameterfvEXT
,
6494 (void) memcpy((void *) (pc
+ 0), (void *) (&target
), 4);
6495 (void) memcpy((void *) (pc
+ 4), (void *) (&pname
), 4);
6496 (void) __glXReadReply(dpy
, 4, params
, GL_FALSE
);
6504 #define X_GLsop_GetHistogramParameteriv 156
6506 __indirect_glGetHistogramParameteriv(GLenum target
, GLenum pname
,
6509 __GLXcontext
*const gc
= __glXGetCurrentContext();
6510 Display
*const dpy
= gc
->currentDpy
;
6512 const GLuint cmdlen
= 8;
6514 if (__builtin_expect(dpy
!= NULL
, 1)) {
6516 xcb_connection_t
*c
= XGetXCBConnection(dpy
);
6517 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
6518 xcb_glx_get_histogram_parameteriv_reply_t
*reply
=
6519 xcb_glx_get_histogram_parameteriv_reply(c
,
6520 xcb_glx_get_histogram_parameteriv
6521 (c
, gc
->currentContextTag
,
6522 target
, pname
), NULL
);
6523 if (xcb_glx_get_histogram_parameteriv_data_length(reply
) == 0)
6524 (void) memcpy(params
, &reply
->datum
, sizeof(reply
->datum
));
6526 (void) memcpy(params
,
6527 xcb_glx_get_histogram_parameteriv_data(reply
),
6528 xcb_glx_get_histogram_parameteriv_data_length(reply
)
6533 __glXSetupSingleRequest(gc
, X_GLsop_GetHistogramParameteriv
,
6535 (void) memcpy((void *) (pc
+ 0), (void *) (&target
), 4);
6536 (void) memcpy((void *) (pc
+ 4), (void *) (&pname
), 4);
6537 (void) __glXReadReply(dpy
, 4, params
, GL_FALSE
);
6540 #endif /* USE_XCB */
6545 #define X_GLvop_GetHistogramParameterivEXT 7
6547 gl_dispatch_stub_363(GLenum target
, GLenum pname
, GLint
* params
)
6549 __GLXcontext
*const gc
= __glXGetCurrentContext();
6551 if (gc
->driContext
) {
6552 CALL_GetHistogramParameteriv(GET_DISPATCH(), (target
, pname
, params
));
6554 __GLXcontext
*const gc
= __glXGetCurrentContext();
6555 Display
*const dpy
= gc
->currentDpy
;
6556 const GLuint cmdlen
= 8;
6557 if (__builtin_expect(dpy
!= NULL
, 1)) {
6559 __glXSetupVendorRequest(gc
, X_GLXVendorPrivateWithReply
,
6560 X_GLvop_GetHistogramParameterivEXT
,
6562 (void) memcpy((void *) (pc
+ 0), (void *) (&target
), 4);
6563 (void) memcpy((void *) (pc
+ 4), (void *) (&pname
), 4);
6564 (void) __glXReadReply(dpy
, 4, params
, GL_FALSE
);
6572 #define X_GLsop_GetMinmax 157
6574 __indirect_glGetMinmax(GLenum target
, GLboolean reset
, GLenum format
,
6575 GLenum type
, GLvoid
* values
)
6577 __GLXcontext
*const gc
= __glXGetCurrentContext();
6578 const __GLXattribute
*const state
= gc
->client_state_private
;
6579 Display
*const dpy
= gc
->currentDpy
;
6581 const GLuint cmdlen
= 16;
6583 if (__builtin_expect(dpy
!= NULL
, 1)) {
6585 xcb_connection_t
*c
= XGetXCBConnection(dpy
);
6586 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
6587 xcb_glx_get_minmax_reply_t
*reply
=
6588 xcb_glx_get_minmax_reply(c
,
6589 xcb_glx_get_minmax(c
,
6590 gc
->currentContextTag
,
6591 target
, reset
, format
,
6595 (void) memcpy(values
, xcb_glx_get_minmax_data(reply
),
6596 xcb_glx_get_minmax_data_length(reply
) * sizeof(GLvoid
));
6600 __glXSetupSingleRequest(gc
, X_GLsop_GetMinmax
, cmdlen
);
6601 (void) memcpy((void *) (pc
+ 0), (void *) (&target
), 4);
6602 (void) memcpy((void *) (pc
+ 4), (void *) (&format
), 4);
6603 (void) memcpy((void *) (pc
+ 8), (void *) (&type
), 4);
6604 *(int32_t *) (pc
+ 12) = 0;
6605 *(int8_t *) (pc
+ 12) = state
->storePack
.swapEndian
;
6606 *(int8_t *) (pc
+ 13) = reset
;
6607 __glXReadPixelReply(dpy
, gc
, 1, 2, 1, 1, format
, type
, values
,
6611 #endif /* USE_XCB */
6616 #define X_GLvop_GetMinmaxEXT 8
6618 gl_dispatch_stub_364(GLenum target
, GLboolean reset
, GLenum format
,
6619 GLenum type
, GLvoid
* values
)
6621 __GLXcontext
*const gc
= __glXGetCurrentContext();
6623 if (gc
->driContext
) {
6624 CALL_GetMinmax(GET_DISPATCH(), (target
, reset
, format
, type
, values
));
6626 __GLXcontext
*const gc
= __glXGetCurrentContext();
6627 const __GLXattribute
*const state
= gc
->client_state_private
;
6628 Display
*const dpy
= gc
->currentDpy
;
6629 const GLuint cmdlen
= 16;
6630 if (__builtin_expect(dpy
!= NULL
, 1)) {
6632 __glXSetupVendorRequest(gc
, X_GLXVendorPrivateWithReply
,
6633 X_GLvop_GetMinmaxEXT
, cmdlen
);
6634 (void) memcpy((void *) (pc
+ 0), (void *) (&target
), 4);
6635 (void) memcpy((void *) (pc
+ 4), (void *) (&format
), 4);
6636 (void) memcpy((void *) (pc
+ 8), (void *) (&type
), 4);
6637 *(int32_t *) (pc
+ 12) = 0;
6638 *(int8_t *) (pc
+ 12) = state
->storePack
.swapEndian
;
6639 *(int8_t *) (pc
+ 13) = reset
;
6640 __glXReadPixelReply(dpy
, gc
, 1, 2, 1, 1, format
, type
, values
,
6649 #define X_GLsop_GetMinmaxParameterfv 158
6651 __indirect_glGetMinmaxParameterfv(GLenum target
, GLenum pname
,
6654 __GLXcontext
*const gc
= __glXGetCurrentContext();
6655 Display
*const dpy
= gc
->currentDpy
;
6657 const GLuint cmdlen
= 8;
6659 if (__builtin_expect(dpy
!= NULL
, 1)) {
6661 xcb_connection_t
*c
= XGetXCBConnection(dpy
);
6662 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
6663 xcb_glx_get_minmax_parameterfv_reply_t
*reply
=
6664 xcb_glx_get_minmax_parameterfv_reply(c
,
6665 xcb_glx_get_minmax_parameterfv
6666 (c
, gc
->currentContextTag
,
6667 target
, pname
), NULL
);
6668 if (xcb_glx_get_minmax_parameterfv_data_length(reply
) == 0)
6669 (void) memcpy(params
, &reply
->datum
, sizeof(reply
->datum
));
6671 (void) memcpy(params
, xcb_glx_get_minmax_parameterfv_data(reply
),
6672 xcb_glx_get_minmax_parameterfv_data_length(reply
) *
6677 __glXSetupSingleRequest(gc
, X_GLsop_GetMinmaxParameterfv
, cmdlen
);
6678 (void) memcpy((void *) (pc
+ 0), (void *) (&target
), 4);
6679 (void) memcpy((void *) (pc
+ 4), (void *) (&pname
), 4);
6680 (void) __glXReadReply(dpy
, 4, params
, GL_FALSE
);
6683 #endif /* USE_XCB */
6688 #define X_GLvop_GetMinmaxParameterfvEXT 9
6690 gl_dispatch_stub_365(GLenum target
, GLenum pname
, GLfloat
* params
)
6692 __GLXcontext
*const gc
= __glXGetCurrentContext();
6694 if (gc
->driContext
) {
6695 CALL_GetMinmaxParameterfv(GET_DISPATCH(), (target
, pname
, params
));
6697 __GLXcontext
*const gc
= __glXGetCurrentContext();
6698 Display
*const dpy
= gc
->currentDpy
;
6699 const GLuint cmdlen
= 8;
6700 if (__builtin_expect(dpy
!= NULL
, 1)) {
6702 __glXSetupVendorRequest(gc
, X_GLXVendorPrivateWithReply
,
6703 X_GLvop_GetMinmaxParameterfvEXT
,
6705 (void) memcpy((void *) (pc
+ 0), (void *) (&target
), 4);
6706 (void) memcpy((void *) (pc
+ 4), (void *) (&pname
), 4);
6707 (void) __glXReadReply(dpy
, 4, params
, GL_FALSE
);
6715 #define X_GLsop_GetMinmaxParameteriv 159
6717 __indirect_glGetMinmaxParameteriv(GLenum target
, GLenum pname
, GLint
* params
)
6719 __GLXcontext
*const gc
= __glXGetCurrentContext();
6720 Display
*const dpy
= gc
->currentDpy
;
6722 const GLuint cmdlen
= 8;
6724 if (__builtin_expect(dpy
!= NULL
, 1)) {
6726 xcb_connection_t
*c
= XGetXCBConnection(dpy
);
6727 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
6728 xcb_glx_get_minmax_parameteriv_reply_t
*reply
=
6729 xcb_glx_get_minmax_parameteriv_reply(c
,
6730 xcb_glx_get_minmax_parameteriv
6731 (c
, gc
->currentContextTag
,
6732 target
, pname
), NULL
);
6733 if (xcb_glx_get_minmax_parameteriv_data_length(reply
) == 0)
6734 (void) memcpy(params
, &reply
->datum
, sizeof(reply
->datum
));
6736 (void) memcpy(params
, xcb_glx_get_minmax_parameteriv_data(reply
),
6737 xcb_glx_get_minmax_parameteriv_data_length(reply
) *
6742 __glXSetupSingleRequest(gc
, X_GLsop_GetMinmaxParameteriv
, cmdlen
);
6743 (void) memcpy((void *) (pc
+ 0), (void *) (&target
), 4);
6744 (void) memcpy((void *) (pc
+ 4), (void *) (&pname
), 4);
6745 (void) __glXReadReply(dpy
, 4, params
, GL_FALSE
);
6748 #endif /* USE_XCB */
6753 #define X_GLvop_GetMinmaxParameterivEXT 10
6755 gl_dispatch_stub_366(GLenum target
, GLenum pname
, GLint
* params
)
6757 __GLXcontext
*const gc
= __glXGetCurrentContext();
6759 if (gc
->driContext
) {
6760 CALL_GetMinmaxParameteriv(GET_DISPATCH(), (target
, pname
, params
));
6762 __GLXcontext
*const gc
= __glXGetCurrentContext();
6763 Display
*const dpy
= gc
->currentDpy
;
6764 const GLuint cmdlen
= 8;
6765 if (__builtin_expect(dpy
!= NULL
, 1)) {
6767 __glXSetupVendorRequest(gc
, X_GLXVendorPrivateWithReply
,
6768 X_GLvop_GetMinmaxParameterivEXT
,
6770 (void) memcpy((void *) (pc
+ 0), (void *) (&target
), 4);
6771 (void) memcpy((void *) (pc
+ 4), (void *) (&pname
), 4);
6772 (void) __glXReadReply(dpy
, 4, params
, GL_FALSE
);
6780 #define X_GLrop_Histogram 4110
6782 __indirect_glHistogram(GLenum target
, GLsizei width
, GLenum internalformat
,
6785 __GLXcontext
*const gc
= __glXGetCurrentContext();
6786 const GLuint cmdlen
= 20;
6787 emit_header(gc
->pc
, X_GLrop_Histogram
, cmdlen
);
6788 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&target
), 4);
6789 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&width
), 4);
6790 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&internalformat
), 4);
6791 (void) memcpy((void *) (gc
->pc
+ 16), (void *) (&sink
), 1);
6793 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
6794 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
6798 #define X_GLrop_Minmax 4111
6800 __indirect_glMinmax(GLenum target
, GLenum internalformat
, GLboolean sink
)
6802 __GLXcontext
*const gc
= __glXGetCurrentContext();
6803 const GLuint cmdlen
= 16;
6804 emit_header(gc
->pc
, X_GLrop_Minmax
, cmdlen
);
6805 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&target
), 4);
6806 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&internalformat
), 4);
6807 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&sink
), 1);
6809 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
6810 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
6814 #define X_GLrop_ResetHistogram 4112
6816 __indirect_glResetHistogram(GLenum target
)
6818 __GLXcontext
*const gc
= __glXGetCurrentContext();
6819 const GLuint cmdlen
= 8;
6820 emit_header(gc
->pc
, X_GLrop_ResetHistogram
, cmdlen
);
6821 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&target
), 4);
6823 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
6824 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
6828 #define X_GLrop_ResetMinmax 4113
6830 __indirect_glResetMinmax(GLenum target
)
6832 __GLXcontext
*const gc
= __glXGetCurrentContext();
6833 const GLuint cmdlen
= 8;
6834 emit_header(gc
->pc
, X_GLrop_ResetMinmax
, cmdlen
);
6835 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&target
), 4);
6837 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
6838 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
6843 __glx_TexImage_3D4D(unsigned opcode
, unsigned dim
, GLenum target
, GLint level
,
6844 GLint internalformat
, GLsizei width
, GLsizei height
,
6845 GLsizei depth
, GLsizei extent
, GLint border
,
6846 GLenum format
, GLenum type
, const GLvoid
* pixels
)
6848 __GLXcontext
*const gc
= __glXGetCurrentContext();
6849 const GLuint compsize
=
6850 (pixels
!= NULL
) ? __glImageSize(width
, height
, depth
, format
, type
,
6852 const GLuint cmdlen
= 84 + __GLX_PAD(compsize
);
6853 if (__builtin_expect(gc
->currentDpy
!= NULL
, 1)) {
6854 if (cmdlen
<= gc
->maxSmallRenderCommandSize
) {
6855 if ((gc
->pc
+ cmdlen
) > gc
->bufEnd
) {
6856 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
6858 emit_header(gc
->pc
, opcode
, cmdlen
);
6859 (void) memcpy((void *) (gc
->pc
+ 40), (void *) (&target
), 4);
6860 (void) memcpy((void *) (gc
->pc
+ 44), (void *) (&level
), 4);
6861 (void) memcpy((void *) (gc
->pc
+ 48), (void *) (&internalformat
),
6863 (void) memcpy((void *) (gc
->pc
+ 52), (void *) (&width
), 4);
6864 (void) memcpy((void *) (gc
->pc
+ 56), (void *) (&height
), 4);
6865 (void) memcpy((void *) (gc
->pc
+ 60), (void *) (&depth
), 4);
6866 (void) memcpy((void *) (gc
->pc
+ 64), (void *) (&extent
), 4);
6867 (void) memcpy((void *) (gc
->pc
+ 68), (void *) (&border
), 4);
6868 (void) memcpy((void *) (gc
->pc
+ 72), (void *) (&format
), 4);
6869 (void) memcpy((void *) (gc
->pc
+ 76), (void *) (&type
), 4);
6870 (void) memcpy((void *) (gc
->pc
+ 80),
6871 (void *) ((pixels
== NULL
) ? one
: zero
), 4);
6873 (*gc
->fillImage
) (gc
, dim
, width
, height
, depth
, format
, type
,
6874 pixels
, gc
->pc
+ 84, gc
->pc
+ 4);
6876 (void) memcpy(gc
->pc
+ 4, default_pixel_store_4D
,
6877 default_pixel_store_4D_size
);
6880 if (gc
->pc
> gc
->limit
) {
6881 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
6884 const GLint op
= opcode
;
6885 const GLuint cmdlenLarge
= cmdlen
+ 4;
6886 GLubyte
*const pc
= __glXFlushRenderBuffer(gc
, gc
->pc
);
6887 (void) memcpy((void *) (pc
+ 0), (void *) (&cmdlenLarge
), 4);
6888 (void) memcpy((void *) (pc
+ 4), (void *) (&op
), 4);
6889 (void) memcpy((void *) (pc
+ 44), (void *) (&target
), 4);
6890 (void) memcpy((void *) (pc
+ 48), (void *) (&level
), 4);
6891 (void) memcpy((void *) (pc
+ 52), (void *) (&internalformat
), 4);
6892 (void) memcpy((void *) (pc
+ 56), (void *) (&width
), 4);
6893 (void) memcpy((void *) (pc
+ 60), (void *) (&height
), 4);
6894 (void) memcpy((void *) (pc
+ 64), (void *) (&depth
), 4);
6895 (void) memcpy((void *) (pc
+ 68), (void *) (&extent
), 4);
6896 (void) memcpy((void *) (pc
+ 72), (void *) (&border
), 4);
6897 (void) memcpy((void *) (pc
+ 76), (void *) (&format
), 4);
6898 (void) memcpy((void *) (pc
+ 80), (void *) (&type
), 4);
6899 (void) memcpy((void *) (pc
+ 84), zero
, 4);
6900 __glXSendLargeImage(gc
, compsize
, dim
, width
, height
, depth
,
6901 format
, type
, pixels
, pc
+ 88, pc
+ 8);
6906 #define X_GLrop_TexImage3D 4114
6908 __indirect_glTexImage3D(GLenum target
, GLint level
, GLint internalformat
,
6909 GLsizei width
, GLsizei height
, GLsizei depth
,
6910 GLint border
, GLenum format
, GLenum type
,
6911 const GLvoid
* pixels
)
6913 __glx_TexImage_3D4D(X_GLrop_TexImage3D
, 3, target
, level
, internalformat
,
6914 width
, height
, depth
, 1, border
, format
, type
,
6919 __glx_TexSubImage_3D4D(unsigned opcode
, unsigned dim
, GLenum target
,
6920 GLint level
, GLint xoffset
, GLint yoffset
,
6921 GLint zoffset
, GLint woffset
, GLsizei width
,
6922 GLsizei height
, GLsizei depth
, GLsizei extent
,
6923 GLenum format
, GLenum type
, const GLvoid
* pixels
)
6925 __GLXcontext
*const gc
= __glXGetCurrentContext();
6926 const GLuint compsize
=
6927 (pixels
!= NULL
) ? __glImageSize(width
, height
, depth
, format
, type
,
6929 const GLuint cmdlen
= 92 + __GLX_PAD(compsize
);
6930 if (__builtin_expect(gc
->currentDpy
!= NULL
, 1)) {
6931 if (cmdlen
<= gc
->maxSmallRenderCommandSize
) {
6932 if ((gc
->pc
+ cmdlen
) > gc
->bufEnd
) {
6933 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
6935 emit_header(gc
->pc
, opcode
, cmdlen
);
6936 (void) memcpy((void *) (gc
->pc
+ 40), (void *) (&target
), 4);
6937 (void) memcpy((void *) (gc
->pc
+ 44), (void *) (&level
), 4);
6938 (void) memcpy((void *) (gc
->pc
+ 48), (void *) (&xoffset
), 4);
6939 (void) memcpy((void *) (gc
->pc
+ 52), (void *) (&yoffset
), 4);
6940 (void) memcpy((void *) (gc
->pc
+ 56), (void *) (&zoffset
), 4);
6941 (void) memcpy((void *) (gc
->pc
+ 60), (void *) (&woffset
), 4);
6942 (void) memcpy((void *) (gc
->pc
+ 64), (void *) (&width
), 4);
6943 (void) memcpy((void *) (gc
->pc
+ 68), (void *) (&height
), 4);
6944 (void) memcpy((void *) (gc
->pc
+ 72), (void *) (&depth
), 4);
6945 (void) memcpy((void *) (gc
->pc
+ 76), (void *) (&extent
), 4);
6946 (void) memcpy((void *) (gc
->pc
+ 80), (void *) (&format
), 4);
6947 (void) memcpy((void *) (gc
->pc
+ 84), (void *) (&type
), 4);
6948 (void) memcpy((void *) (gc
->pc
+ 88),
6949 (void *) ((pixels
== NULL
) ? one
: zero
), 4);
6951 (*gc
->fillImage
) (gc
, dim
, width
, height
, depth
, format
, type
,
6952 pixels
, gc
->pc
+ 92, gc
->pc
+ 4);
6954 (void) memcpy(gc
->pc
+ 4, default_pixel_store_4D
,
6955 default_pixel_store_4D_size
);
6958 if (gc
->pc
> gc
->limit
) {
6959 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
6962 const GLint op
= opcode
;
6963 const GLuint cmdlenLarge
= cmdlen
+ 4;
6964 GLubyte
*const pc
= __glXFlushRenderBuffer(gc
, gc
->pc
);
6965 (void) memcpy((void *) (pc
+ 0), (void *) (&cmdlenLarge
), 4);
6966 (void) memcpy((void *) (pc
+ 4), (void *) (&op
), 4);
6967 (void) memcpy((void *) (pc
+ 44), (void *) (&target
), 4);
6968 (void) memcpy((void *) (pc
+ 48), (void *) (&level
), 4);
6969 (void) memcpy((void *) (pc
+ 52), (void *) (&xoffset
), 4);
6970 (void) memcpy((void *) (pc
+ 56), (void *) (&yoffset
), 4);
6971 (void) memcpy((void *) (pc
+ 60), (void *) (&zoffset
), 4);
6972 (void) memcpy((void *) (pc
+ 64), (void *) (&woffset
), 4);
6973 (void) memcpy((void *) (pc
+ 68), (void *) (&width
), 4);
6974 (void) memcpy((void *) (pc
+ 72), (void *) (&height
), 4);
6975 (void) memcpy((void *) (pc
+ 76), (void *) (&depth
), 4);
6976 (void) memcpy((void *) (pc
+ 80), (void *) (&extent
), 4);
6977 (void) memcpy((void *) (pc
+ 84), (void *) (&format
), 4);
6978 (void) memcpy((void *) (pc
+ 88), (void *) (&type
), 4);
6979 (void) memcpy((void *) (pc
+ 92), zero
, 4);
6980 __glXSendLargeImage(gc
, compsize
, dim
, width
, height
, depth
,
6981 format
, type
, pixels
, pc
+ 96, pc
+ 8);
6986 #define X_GLrop_TexSubImage3D 4115
6988 __indirect_glTexSubImage3D(GLenum target
, GLint level
, GLint xoffset
,
6989 GLint yoffset
, GLint zoffset
, GLsizei width
,
6990 GLsizei height
, GLsizei depth
, GLenum format
,
6991 GLenum type
, const GLvoid
* pixels
)
6993 __glx_TexSubImage_3D4D(X_GLrop_TexSubImage3D
, 3, target
, level
, xoffset
,
6994 yoffset
, zoffset
, 1, width
, height
, depth
, 1,
6995 format
, type
, pixels
);
6998 #define X_GLrop_CopyTexSubImage3D 4123
7000 __indirect_glCopyTexSubImage3D(GLenum target
, GLint level
, GLint xoffset
,
7001 GLint yoffset
, GLint zoffset
, GLint x
, GLint y
,
7002 GLsizei width
, GLsizei height
)
7004 __GLXcontext
*const gc
= __glXGetCurrentContext();
7005 const GLuint cmdlen
= 40;
7006 emit_header(gc
->pc
, X_GLrop_CopyTexSubImage3D
, cmdlen
);
7007 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&target
), 4);
7008 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&level
), 4);
7009 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&xoffset
), 4);
7010 (void) memcpy((void *) (gc
->pc
+ 16), (void *) (&yoffset
), 4);
7011 (void) memcpy((void *) (gc
->pc
+ 20), (void *) (&zoffset
), 4);
7012 (void) memcpy((void *) (gc
->pc
+ 24), (void *) (&x
), 4);
7013 (void) memcpy((void *) (gc
->pc
+ 28), (void *) (&y
), 4);
7014 (void) memcpy((void *) (gc
->pc
+ 32), (void *) (&width
), 4);
7015 (void) memcpy((void *) (gc
->pc
+ 36), (void *) (&height
), 4);
7017 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
7018 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
7022 #define X_GLrop_ActiveTextureARB 197
7024 __indirect_glActiveTextureARB(GLenum texture
)
7026 __GLXcontext
*const gc
= __glXGetCurrentContext();
7027 const GLuint cmdlen
= 8;
7028 emit_header(gc
->pc
, X_GLrop_ActiveTextureARB
, cmdlen
);
7029 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&texture
), 4);
7031 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
7032 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
7036 #define X_GLrop_MultiTexCoord1dvARB 198
7038 __indirect_glMultiTexCoord1dARB(GLenum target
, GLdouble s
)
7040 __GLXcontext
*const gc
= __glXGetCurrentContext();
7041 const GLuint cmdlen
= 16;
7042 emit_header(gc
->pc
, X_GLrop_MultiTexCoord1dvARB
, cmdlen
);
7043 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&s
), 8);
7044 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&target
), 4);
7046 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
7047 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
7051 #define X_GLrop_MultiTexCoord1dvARB 198
7053 __indirect_glMultiTexCoord1dvARB(GLenum target
, const GLdouble
* v
)
7055 __GLXcontext
*const gc
= __glXGetCurrentContext();
7056 const GLuint cmdlen
= 16;
7057 emit_header(gc
->pc
, X_GLrop_MultiTexCoord1dvARB
, cmdlen
);
7058 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (v
), 8);
7059 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&target
), 4);
7061 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
7062 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
7066 #define X_GLrop_MultiTexCoord1fvARB 199
7068 __indirect_glMultiTexCoord1fARB(GLenum target
, GLfloat s
)
7070 __GLXcontext
*const gc
= __glXGetCurrentContext();
7071 const GLuint cmdlen
= 12;
7072 emit_header(gc
->pc
, X_GLrop_MultiTexCoord1fvARB
, cmdlen
);
7073 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&target
), 4);
7074 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&s
), 4);
7076 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
7077 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
7081 #define X_GLrop_MultiTexCoord1fvARB 199
7083 __indirect_glMultiTexCoord1fvARB(GLenum target
, const GLfloat
* v
)
7085 __GLXcontext
*const gc
= __glXGetCurrentContext();
7086 const GLuint cmdlen
= 12;
7087 emit_header(gc
->pc
, X_GLrop_MultiTexCoord1fvARB
, cmdlen
);
7088 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&target
), 4);
7089 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (v
), 4);
7091 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
7092 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
7096 #define X_GLrop_MultiTexCoord1ivARB 200
7098 __indirect_glMultiTexCoord1iARB(GLenum target
, GLint s
)
7100 __GLXcontext
*const gc
= __glXGetCurrentContext();
7101 const GLuint cmdlen
= 12;
7102 emit_header(gc
->pc
, X_GLrop_MultiTexCoord1ivARB
, cmdlen
);
7103 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&target
), 4);
7104 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&s
), 4);
7106 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
7107 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
7111 #define X_GLrop_MultiTexCoord1ivARB 200
7113 __indirect_glMultiTexCoord1ivARB(GLenum target
, const GLint
* v
)
7115 __GLXcontext
*const gc
= __glXGetCurrentContext();
7116 const GLuint cmdlen
= 12;
7117 emit_header(gc
->pc
, X_GLrop_MultiTexCoord1ivARB
, cmdlen
);
7118 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&target
), 4);
7119 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (v
), 4);
7121 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
7122 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
7126 #define X_GLrop_MultiTexCoord1svARB 201
7128 __indirect_glMultiTexCoord1sARB(GLenum target
, GLshort s
)
7130 __GLXcontext
*const gc
= __glXGetCurrentContext();
7131 const GLuint cmdlen
= 12;
7132 emit_header(gc
->pc
, X_GLrop_MultiTexCoord1svARB
, cmdlen
);
7133 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&target
), 4);
7134 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&s
), 2);
7136 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
7137 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
7141 #define X_GLrop_MultiTexCoord1svARB 201
7143 __indirect_glMultiTexCoord1svARB(GLenum target
, const GLshort
* v
)
7145 __GLXcontext
*const gc
= __glXGetCurrentContext();
7146 const GLuint cmdlen
= 12;
7147 emit_header(gc
->pc
, X_GLrop_MultiTexCoord1svARB
, cmdlen
);
7148 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&target
), 4);
7149 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (v
), 2);
7151 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
7152 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
7156 #define X_GLrop_MultiTexCoord2dvARB 202
7158 __indirect_glMultiTexCoord2dARB(GLenum target
, GLdouble s
, GLdouble t
)
7160 __GLXcontext
*const gc
= __glXGetCurrentContext();
7161 const GLuint cmdlen
= 24;
7162 emit_header(gc
->pc
, X_GLrop_MultiTexCoord2dvARB
, cmdlen
);
7163 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&s
), 8);
7164 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&t
), 8);
7165 (void) memcpy((void *) (gc
->pc
+ 20), (void *) (&target
), 4);
7167 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
7168 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
7172 #define X_GLrop_MultiTexCoord2dvARB 202
7174 __indirect_glMultiTexCoord2dvARB(GLenum target
, const GLdouble
* v
)
7176 __GLXcontext
*const gc
= __glXGetCurrentContext();
7177 const GLuint cmdlen
= 24;
7178 emit_header(gc
->pc
, X_GLrop_MultiTexCoord2dvARB
, cmdlen
);
7179 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (v
), 16);
7180 (void) memcpy((void *) (gc
->pc
+ 20), (void *) (&target
), 4);
7182 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
7183 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
7187 #define X_GLrop_MultiTexCoord2fvARB 203
7189 __indirect_glMultiTexCoord2fARB(GLenum target
, GLfloat s
, GLfloat t
)
7191 __GLXcontext
*const gc
= __glXGetCurrentContext();
7192 const GLuint cmdlen
= 16;
7193 emit_header(gc
->pc
, X_GLrop_MultiTexCoord2fvARB
, cmdlen
);
7194 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&target
), 4);
7195 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&s
), 4);
7196 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&t
), 4);
7198 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
7199 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
7203 #define X_GLrop_MultiTexCoord2fvARB 203
7205 __indirect_glMultiTexCoord2fvARB(GLenum target
, const GLfloat
* v
)
7207 __GLXcontext
*const gc
= __glXGetCurrentContext();
7208 const GLuint cmdlen
= 16;
7209 emit_header(gc
->pc
, X_GLrop_MultiTexCoord2fvARB
, cmdlen
);
7210 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&target
), 4);
7211 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (v
), 8);
7213 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
7214 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
7218 #define X_GLrop_MultiTexCoord2ivARB 204
7220 __indirect_glMultiTexCoord2iARB(GLenum target
, GLint s
, GLint t
)
7222 __GLXcontext
*const gc
= __glXGetCurrentContext();
7223 const GLuint cmdlen
= 16;
7224 emit_header(gc
->pc
, X_GLrop_MultiTexCoord2ivARB
, cmdlen
);
7225 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&target
), 4);
7226 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&s
), 4);
7227 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&t
), 4);
7229 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
7230 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
7234 #define X_GLrop_MultiTexCoord2ivARB 204
7236 __indirect_glMultiTexCoord2ivARB(GLenum target
, const GLint
* v
)
7238 __GLXcontext
*const gc
= __glXGetCurrentContext();
7239 const GLuint cmdlen
= 16;
7240 emit_header(gc
->pc
, X_GLrop_MultiTexCoord2ivARB
, cmdlen
);
7241 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&target
), 4);
7242 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (v
), 8);
7244 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
7245 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
7249 #define X_GLrop_MultiTexCoord2svARB 205
7251 __indirect_glMultiTexCoord2sARB(GLenum target
, GLshort s
, GLshort t
)
7253 __GLXcontext
*const gc
= __glXGetCurrentContext();
7254 const GLuint cmdlen
= 12;
7255 emit_header(gc
->pc
, X_GLrop_MultiTexCoord2svARB
, cmdlen
);
7256 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&target
), 4);
7257 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&s
), 2);
7258 (void) memcpy((void *) (gc
->pc
+ 10), (void *) (&t
), 2);
7260 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
7261 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
7265 #define X_GLrop_MultiTexCoord2svARB 205
7267 __indirect_glMultiTexCoord2svARB(GLenum target
, const GLshort
* v
)
7269 __GLXcontext
*const gc
= __glXGetCurrentContext();
7270 const GLuint cmdlen
= 12;
7271 emit_header(gc
->pc
, X_GLrop_MultiTexCoord2svARB
, cmdlen
);
7272 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&target
), 4);
7273 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (v
), 4);
7275 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
7276 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
7280 #define X_GLrop_MultiTexCoord3dvARB 206
7282 __indirect_glMultiTexCoord3dARB(GLenum target
, GLdouble s
, GLdouble t
,
7285 __GLXcontext
*const gc
= __glXGetCurrentContext();
7286 const GLuint cmdlen
= 32;
7287 emit_header(gc
->pc
, X_GLrop_MultiTexCoord3dvARB
, 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 *) (&target
), 4);
7293 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
7294 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
7298 #define X_GLrop_MultiTexCoord3dvARB 206
7300 __indirect_glMultiTexCoord3dvARB(GLenum target
, const GLdouble
* v
)
7302 __GLXcontext
*const gc
= __glXGetCurrentContext();
7303 const GLuint cmdlen
= 32;
7304 emit_header(gc
->pc
, X_GLrop_MultiTexCoord3dvARB
, cmdlen
);
7305 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (v
), 24);
7306 (void) memcpy((void *) (gc
->pc
+ 28), (void *) (&target
), 4);
7308 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
7309 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
7313 #define X_GLrop_MultiTexCoord3fvARB 207
7315 __indirect_glMultiTexCoord3fARB(GLenum target
, GLfloat s
, GLfloat t
,
7318 __GLXcontext
*const gc
= __glXGetCurrentContext();
7319 const GLuint cmdlen
= 20;
7320 emit_header(gc
->pc
, X_GLrop_MultiTexCoord3fvARB
, cmdlen
);
7321 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&target
), 4);
7322 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&s
), 4);
7323 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&t
), 4);
7324 (void) memcpy((void *) (gc
->pc
+ 16), (void *) (&r
), 4);
7326 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
7327 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
7331 #define X_GLrop_MultiTexCoord3fvARB 207
7333 __indirect_glMultiTexCoord3fvARB(GLenum target
, const GLfloat
* v
)
7335 __GLXcontext
*const gc
= __glXGetCurrentContext();
7336 const GLuint cmdlen
= 20;
7337 emit_header(gc
->pc
, X_GLrop_MultiTexCoord3fvARB
, cmdlen
);
7338 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&target
), 4);
7339 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (v
), 12);
7341 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
7342 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
7346 #define X_GLrop_MultiTexCoord3ivARB 208
7348 __indirect_glMultiTexCoord3iARB(GLenum target
, GLint s
, GLint t
, GLint r
)
7350 __GLXcontext
*const gc
= __glXGetCurrentContext();
7351 const GLuint cmdlen
= 20;
7352 emit_header(gc
->pc
, X_GLrop_MultiTexCoord3ivARB
, cmdlen
);
7353 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&target
), 4);
7354 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&s
), 4);
7355 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&t
), 4);
7356 (void) memcpy((void *) (gc
->pc
+ 16), (void *) (&r
), 4);
7358 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
7359 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
7363 #define X_GLrop_MultiTexCoord3ivARB 208
7365 __indirect_glMultiTexCoord3ivARB(GLenum target
, const GLint
* v
)
7367 __GLXcontext
*const gc
= __glXGetCurrentContext();
7368 const GLuint cmdlen
= 20;
7369 emit_header(gc
->pc
, X_GLrop_MultiTexCoord3ivARB
, cmdlen
);
7370 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&target
), 4);
7371 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (v
), 12);
7373 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
7374 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
7378 #define X_GLrop_MultiTexCoord3svARB 209
7380 __indirect_glMultiTexCoord3sARB(GLenum target
, GLshort s
, GLshort t
,
7383 __GLXcontext
*const gc
= __glXGetCurrentContext();
7384 const GLuint cmdlen
= 16;
7385 emit_header(gc
->pc
, X_GLrop_MultiTexCoord3svARB
, cmdlen
);
7386 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&target
), 4);
7387 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&s
), 2);
7388 (void) memcpy((void *) (gc
->pc
+ 10), (void *) (&t
), 2);
7389 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&r
), 2);
7391 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
7392 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
7396 #define X_GLrop_MultiTexCoord3svARB 209
7398 __indirect_glMultiTexCoord3svARB(GLenum target
, const GLshort
* v
)
7400 __GLXcontext
*const gc
= __glXGetCurrentContext();
7401 const GLuint cmdlen
= 16;
7402 emit_header(gc
->pc
, X_GLrop_MultiTexCoord3svARB
, cmdlen
);
7403 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&target
), 4);
7404 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (v
), 6);
7406 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
7407 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
7411 #define X_GLrop_MultiTexCoord4dvARB 210
7413 __indirect_glMultiTexCoord4dARB(GLenum target
, GLdouble s
, GLdouble t
,
7414 GLdouble r
, GLdouble q
)
7416 __GLXcontext
*const gc
= __glXGetCurrentContext();
7417 const GLuint cmdlen
= 40;
7418 emit_header(gc
->pc
, X_GLrop_MultiTexCoord4dvARB
, cmdlen
);
7419 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&s
), 8);
7420 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&t
), 8);
7421 (void) memcpy((void *) (gc
->pc
+ 20), (void *) (&r
), 8);
7422 (void) memcpy((void *) (gc
->pc
+ 28), (void *) (&q
), 8);
7423 (void) memcpy((void *) (gc
->pc
+ 36), (void *) (&target
), 4);
7425 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
7426 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
7430 #define X_GLrop_MultiTexCoord4dvARB 210
7432 __indirect_glMultiTexCoord4dvARB(GLenum target
, const GLdouble
* v
)
7434 __GLXcontext
*const gc
= __glXGetCurrentContext();
7435 const GLuint cmdlen
= 40;
7436 emit_header(gc
->pc
, X_GLrop_MultiTexCoord4dvARB
, cmdlen
);
7437 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (v
), 32);
7438 (void) memcpy((void *) (gc
->pc
+ 36), (void *) (&target
), 4);
7440 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
7441 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
7445 #define X_GLrop_MultiTexCoord4fvARB 211
7447 __indirect_glMultiTexCoord4fARB(GLenum target
, GLfloat s
, GLfloat t
,
7448 GLfloat r
, GLfloat q
)
7450 __GLXcontext
*const gc
= __glXGetCurrentContext();
7451 const GLuint cmdlen
= 24;
7452 emit_header(gc
->pc
, X_GLrop_MultiTexCoord4fvARB
, cmdlen
);
7453 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&target
), 4);
7454 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&s
), 4);
7455 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&t
), 4);
7456 (void) memcpy((void *) (gc
->pc
+ 16), (void *) (&r
), 4);
7457 (void) memcpy((void *) (gc
->pc
+ 20), (void *) (&q
), 4);
7459 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
7460 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
7464 #define X_GLrop_MultiTexCoord4fvARB 211
7466 __indirect_glMultiTexCoord4fvARB(GLenum target
, const GLfloat
* v
)
7468 __GLXcontext
*const gc
= __glXGetCurrentContext();
7469 const GLuint cmdlen
= 24;
7470 emit_header(gc
->pc
, X_GLrop_MultiTexCoord4fvARB
, cmdlen
);
7471 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&target
), 4);
7472 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (v
), 16);
7474 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
7475 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
7479 #define X_GLrop_MultiTexCoord4ivARB 212
7481 __indirect_glMultiTexCoord4iARB(GLenum target
, GLint s
, GLint t
, GLint r
,
7484 __GLXcontext
*const gc
= __glXGetCurrentContext();
7485 const GLuint cmdlen
= 24;
7486 emit_header(gc
->pc
, X_GLrop_MultiTexCoord4ivARB
, cmdlen
);
7487 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&target
), 4);
7488 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&s
), 4);
7489 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&t
), 4);
7490 (void) memcpy((void *) (gc
->pc
+ 16), (void *) (&r
), 4);
7491 (void) memcpy((void *) (gc
->pc
+ 20), (void *) (&q
), 4);
7493 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
7494 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
7498 #define X_GLrop_MultiTexCoord4ivARB 212
7500 __indirect_glMultiTexCoord4ivARB(GLenum target
, const GLint
* v
)
7502 __GLXcontext
*const gc
= __glXGetCurrentContext();
7503 const GLuint cmdlen
= 24;
7504 emit_header(gc
->pc
, X_GLrop_MultiTexCoord4ivARB
, cmdlen
);
7505 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&target
), 4);
7506 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (v
), 16);
7508 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
7509 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
7513 #define X_GLrop_MultiTexCoord4svARB 213
7515 __indirect_glMultiTexCoord4sARB(GLenum target
, GLshort s
, GLshort t
,
7516 GLshort r
, GLshort q
)
7518 __GLXcontext
*const gc
= __glXGetCurrentContext();
7519 const GLuint cmdlen
= 16;
7520 emit_header(gc
->pc
, X_GLrop_MultiTexCoord4svARB
, cmdlen
);
7521 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&target
), 4);
7522 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&s
), 2);
7523 (void) memcpy((void *) (gc
->pc
+ 10), (void *) (&t
), 2);
7524 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&r
), 2);
7525 (void) memcpy((void *) (gc
->pc
+ 14), (void *) (&q
), 2);
7527 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
7528 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
7532 #define X_GLrop_MultiTexCoord4svARB 213
7534 __indirect_glMultiTexCoord4svARB(GLenum target
, const GLshort
* v
)
7536 __GLXcontext
*const gc
= __glXGetCurrentContext();
7537 const GLuint cmdlen
= 16;
7538 emit_header(gc
->pc
, X_GLrop_MultiTexCoord4svARB
, cmdlen
);
7539 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&target
), 4);
7540 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (v
), 8);
7542 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
7543 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
7547 #define X_GLrop_SampleCoverageARB 229
7549 __indirect_glSampleCoverageARB(GLclampf value
, GLboolean invert
)
7551 __GLXcontext
*const gc
= __glXGetCurrentContext();
7552 const GLuint cmdlen
= 12;
7553 emit_header(gc
->pc
, X_GLrop_SampleCoverageARB
, cmdlen
);
7554 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&value
), 4);
7555 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&invert
), 1);
7557 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
7558 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
7562 #define X_GLvop_GetProgramStringARB 1308
7564 __indirect_glGetProgramStringARB(GLenum target
, GLenum pname
, GLvoid
* string
)
7566 __GLXcontext
*const gc
= __glXGetCurrentContext();
7567 Display
*const dpy
= gc
->currentDpy
;
7568 const GLuint cmdlen
= 8;
7569 if (__builtin_expect(dpy
!= NULL
, 1)) {
7571 __glXSetupVendorRequest(gc
, X_GLXVendorPrivateWithReply
,
7572 X_GLvop_GetProgramStringARB
, cmdlen
);
7573 (void) memcpy((void *) (pc
+ 0), (void *) (&target
), 4);
7574 (void) memcpy((void *) (pc
+ 4), (void *) (&pname
), 4);
7575 (void) __glXReadReply(dpy
, 1, string
, GL_TRUE
);
7582 #define X_GLvop_GetProgramivARB 1307
7584 __indirect_glGetProgramivARB(GLenum target
, GLenum pname
, GLint
* params
)
7586 __GLXcontext
*const gc
= __glXGetCurrentContext();
7587 Display
*const dpy
= gc
->currentDpy
;
7588 const GLuint cmdlen
= 8;
7589 if (__builtin_expect(dpy
!= NULL
, 1)) {
7591 __glXSetupVendorRequest(gc
, X_GLXVendorPrivateWithReply
,
7592 X_GLvop_GetProgramivARB
, cmdlen
);
7593 (void) memcpy((void *) (pc
+ 0), (void *) (&target
), 4);
7594 (void) memcpy((void *) (pc
+ 4), (void *) (&pname
), 4);
7595 (void) __glXReadReply(dpy
, 4, params
, GL_FALSE
);
7602 #define X_GLrop_ProgramEnvParameter4dvARB 4185
7604 __indirect_glProgramEnvParameter4dARB(GLenum target
, GLuint index
, GLdouble x
,
7605 GLdouble y
, GLdouble z
, GLdouble w
)
7607 __GLXcontext
*const gc
= __glXGetCurrentContext();
7608 const GLuint cmdlen
= 44;
7609 emit_header(gc
->pc
, X_GLrop_ProgramEnvParameter4dvARB
, cmdlen
);
7610 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&target
), 4);
7611 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&index
), 4);
7612 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&x
), 8);
7613 (void) memcpy((void *) (gc
->pc
+ 20), (void *) (&y
), 8);
7614 (void) memcpy((void *) (gc
->pc
+ 28), (void *) (&z
), 8);
7615 (void) memcpy((void *) (gc
->pc
+ 36), (void *) (&w
), 8);
7617 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
7618 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
7622 #define X_GLrop_ProgramEnvParameter4dvARB 4185
7624 __indirect_glProgramEnvParameter4dvARB(GLenum target
, GLuint index
,
7625 const GLdouble
* params
)
7627 __GLXcontext
*const gc
= __glXGetCurrentContext();
7628 const GLuint cmdlen
= 44;
7629 emit_header(gc
->pc
, X_GLrop_ProgramEnvParameter4dvARB
, cmdlen
);
7630 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&target
), 4);
7631 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&index
), 4);
7632 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (params
), 32);
7634 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
7635 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
7639 #define X_GLrop_ProgramEnvParameter4fvARB 4184
7641 __indirect_glProgramEnvParameter4fARB(GLenum target
, GLuint index
, GLfloat x
,
7642 GLfloat y
, GLfloat z
, GLfloat w
)
7644 __GLXcontext
*const gc
= __glXGetCurrentContext();
7645 const GLuint cmdlen
= 28;
7646 emit_header(gc
->pc
, X_GLrop_ProgramEnvParameter4fvARB
, cmdlen
);
7647 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&target
), 4);
7648 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&index
), 4);
7649 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&x
), 4);
7650 (void) memcpy((void *) (gc
->pc
+ 16), (void *) (&y
), 4);
7651 (void) memcpy((void *) (gc
->pc
+ 20), (void *) (&z
), 4);
7652 (void) memcpy((void *) (gc
->pc
+ 24), (void *) (&w
), 4);
7654 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
7655 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
7659 #define X_GLrop_ProgramEnvParameter4fvARB 4184
7661 __indirect_glProgramEnvParameter4fvARB(GLenum target
, GLuint index
,
7662 const GLfloat
* params
)
7664 __GLXcontext
*const gc
= __glXGetCurrentContext();
7665 const GLuint cmdlen
= 28;
7666 emit_header(gc
->pc
, X_GLrop_ProgramEnvParameter4fvARB
, cmdlen
);
7667 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&target
), 4);
7668 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&index
), 4);
7669 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (params
), 16);
7671 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
7672 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
7676 #define X_GLrop_ProgramLocalParameter4dvARB 4216
7678 __indirect_glProgramLocalParameter4dARB(GLenum target
, GLuint index
,
7679 GLdouble x
, GLdouble y
, GLdouble z
,
7682 __GLXcontext
*const gc
= __glXGetCurrentContext();
7683 const GLuint cmdlen
= 44;
7684 emit_header(gc
->pc
, X_GLrop_ProgramLocalParameter4dvARB
, cmdlen
);
7685 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&target
), 4);
7686 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&index
), 4);
7687 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&x
), 8);
7688 (void) memcpy((void *) (gc
->pc
+ 20), (void *) (&y
), 8);
7689 (void) memcpy((void *) (gc
->pc
+ 28), (void *) (&z
), 8);
7690 (void) memcpy((void *) (gc
->pc
+ 36), (void *) (&w
), 8);
7692 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
7693 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
7697 #define X_GLrop_ProgramLocalParameter4dvARB 4216
7699 __indirect_glProgramLocalParameter4dvARB(GLenum target
, GLuint index
,
7700 const GLdouble
* params
)
7702 __GLXcontext
*const gc
= __glXGetCurrentContext();
7703 const GLuint cmdlen
= 44;
7704 emit_header(gc
->pc
, X_GLrop_ProgramLocalParameter4dvARB
, cmdlen
);
7705 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&target
), 4);
7706 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&index
), 4);
7707 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (params
), 32);
7709 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
7710 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
7714 #define X_GLrop_ProgramLocalParameter4fvARB 4215
7716 __indirect_glProgramLocalParameter4fARB(GLenum target
, GLuint index
,
7717 GLfloat x
, GLfloat y
, GLfloat z
,
7720 __GLXcontext
*const gc
= __glXGetCurrentContext();
7721 const GLuint cmdlen
= 28;
7722 emit_header(gc
->pc
, X_GLrop_ProgramLocalParameter4fvARB
, cmdlen
);
7723 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&target
), 4);
7724 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&index
), 4);
7725 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&x
), 4);
7726 (void) memcpy((void *) (gc
->pc
+ 16), (void *) (&y
), 4);
7727 (void) memcpy((void *) (gc
->pc
+ 20), (void *) (&z
), 4);
7728 (void) memcpy((void *) (gc
->pc
+ 24), (void *) (&w
), 4);
7730 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
7731 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
7735 #define X_GLrop_ProgramLocalParameter4fvARB 4215
7737 __indirect_glProgramLocalParameter4fvARB(GLenum target
, GLuint index
,
7738 const GLfloat
* params
)
7740 __GLXcontext
*const gc
= __glXGetCurrentContext();
7741 const GLuint cmdlen
= 28;
7742 emit_header(gc
->pc
, X_GLrop_ProgramLocalParameter4fvARB
, cmdlen
);
7743 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&target
), 4);
7744 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&index
), 4);
7745 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (params
), 16);
7747 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
7748 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
7752 #define X_GLrop_ProgramStringARB 4217
7754 __indirect_glProgramStringARB(GLenum target
, GLenum format
, GLsizei len
,
7755 const GLvoid
* string
)
7757 __GLXcontext
*const gc
= __glXGetCurrentContext();
7758 const GLuint cmdlen
= 16 + __GLX_PAD(len
);
7760 __glXSetError(gc
, GL_INVALID_VALUE
);
7763 if (__builtin_expect((len
>= 0) && (gc
->currentDpy
!= NULL
), 1)) {
7764 if (cmdlen
<= gc
->maxSmallRenderCommandSize
) {
7765 if ((gc
->pc
+ cmdlen
) > gc
->bufEnd
) {
7766 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
7768 emit_header(gc
->pc
, X_GLrop_ProgramStringARB
, cmdlen
);
7769 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&target
), 4);
7770 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&format
), 4);
7771 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&len
), 4);
7772 (void) memcpy((void *) (gc
->pc
+ 16), (void *) (string
), len
);
7774 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
7775 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
7778 const GLint op
= X_GLrop_ProgramStringARB
;
7779 const GLuint cmdlenLarge
= cmdlen
+ 4;
7780 GLubyte
*const pc
= __glXFlushRenderBuffer(gc
, gc
->pc
);
7781 (void) memcpy((void *) (pc
+ 0), (void *) (&cmdlenLarge
), 4);
7782 (void) memcpy((void *) (pc
+ 4), (void *) (&op
), 4);
7783 (void) memcpy((void *) (pc
+ 8), (void *) (&target
), 4);
7784 (void) memcpy((void *) (pc
+ 12), (void *) (&format
), 4);
7785 (void) memcpy((void *) (pc
+ 16), (void *) (&len
), 4);
7786 __glXSendLargeCommand(gc
, pc
, 20, string
, len
);
7791 #define X_GLrop_VertexAttrib1dvARB 4197
7793 __indirect_glVertexAttrib1dARB(GLuint index
, GLdouble x
)
7795 __GLXcontext
*const gc
= __glXGetCurrentContext();
7796 const GLuint cmdlen
= 16;
7797 emit_header(gc
->pc
, X_GLrop_VertexAttrib1dvARB
, cmdlen
);
7798 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&index
), 4);
7799 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&x
), 8);
7801 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
7802 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
7806 #define X_GLrop_VertexAttrib1dvARB 4197
7808 __indirect_glVertexAttrib1dvARB(GLuint index
, const GLdouble
* v
)
7810 __GLXcontext
*const gc
= __glXGetCurrentContext();
7811 const GLuint cmdlen
= 16;
7812 emit_header(gc
->pc
, X_GLrop_VertexAttrib1dvARB
, cmdlen
);
7813 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&index
), 4);
7814 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (v
), 8);
7816 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
7817 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
7821 #define X_GLrop_VertexAttrib1fvARB 4193
7823 __indirect_glVertexAttrib1fARB(GLuint index
, GLfloat x
)
7825 __GLXcontext
*const gc
= __glXGetCurrentContext();
7826 const GLuint cmdlen
= 12;
7827 emit_header(gc
->pc
, X_GLrop_VertexAttrib1fvARB
, cmdlen
);
7828 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&index
), 4);
7829 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&x
), 4);
7831 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
7832 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
7836 #define X_GLrop_VertexAttrib1fvARB 4193
7838 __indirect_glVertexAttrib1fvARB(GLuint index
, const GLfloat
* v
)
7840 __GLXcontext
*const gc
= __glXGetCurrentContext();
7841 const GLuint cmdlen
= 12;
7842 emit_header(gc
->pc
, X_GLrop_VertexAttrib1fvARB
, cmdlen
);
7843 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&index
), 4);
7844 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (v
), 4);
7846 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
7847 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
7851 #define X_GLrop_VertexAttrib1svARB 4189
7853 __indirect_glVertexAttrib1sARB(GLuint index
, GLshort x
)
7855 __GLXcontext
*const gc
= __glXGetCurrentContext();
7856 const GLuint cmdlen
= 12;
7857 emit_header(gc
->pc
, X_GLrop_VertexAttrib1svARB
, cmdlen
);
7858 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&index
), 4);
7859 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&x
), 2);
7861 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
7862 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
7866 #define X_GLrop_VertexAttrib1svARB 4189
7868 __indirect_glVertexAttrib1svARB(GLuint index
, const GLshort
* v
)
7870 __GLXcontext
*const gc
= __glXGetCurrentContext();
7871 const GLuint cmdlen
= 12;
7872 emit_header(gc
->pc
, X_GLrop_VertexAttrib1svARB
, cmdlen
);
7873 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&index
), 4);
7874 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (v
), 2);
7876 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
7877 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
7881 #define X_GLrop_VertexAttrib2dvARB 4198
7883 __indirect_glVertexAttrib2dARB(GLuint index
, GLdouble x
, GLdouble y
)
7885 __GLXcontext
*const gc
= __glXGetCurrentContext();
7886 const GLuint cmdlen
= 24;
7887 emit_header(gc
->pc
, X_GLrop_VertexAttrib2dvARB
, cmdlen
);
7888 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&index
), 4);
7889 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&x
), 8);
7890 (void) memcpy((void *) (gc
->pc
+ 16), (void *) (&y
), 8);
7892 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
7893 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
7897 #define X_GLrop_VertexAttrib2dvARB 4198
7899 __indirect_glVertexAttrib2dvARB(GLuint index
, const GLdouble
* v
)
7901 __GLXcontext
*const gc
= __glXGetCurrentContext();
7902 const GLuint cmdlen
= 24;
7903 emit_header(gc
->pc
, X_GLrop_VertexAttrib2dvARB
, cmdlen
);
7904 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&index
), 4);
7905 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (v
), 16);
7907 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
7908 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
7912 #define X_GLrop_VertexAttrib2fvARB 4194
7914 __indirect_glVertexAttrib2fARB(GLuint index
, GLfloat x
, GLfloat y
)
7916 __GLXcontext
*const gc
= __glXGetCurrentContext();
7917 const GLuint cmdlen
= 16;
7918 emit_header(gc
->pc
, X_GLrop_VertexAttrib2fvARB
, cmdlen
);
7919 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&index
), 4);
7920 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&x
), 4);
7921 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&y
), 4);
7923 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
7924 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
7928 #define X_GLrop_VertexAttrib2fvARB 4194
7930 __indirect_glVertexAttrib2fvARB(GLuint index
, const GLfloat
* v
)
7932 __GLXcontext
*const gc
= __glXGetCurrentContext();
7933 const GLuint cmdlen
= 16;
7934 emit_header(gc
->pc
, X_GLrop_VertexAttrib2fvARB
, cmdlen
);
7935 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&index
), 4);
7936 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (v
), 8);
7938 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
7939 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
7943 #define X_GLrop_VertexAttrib2svARB 4190
7945 __indirect_glVertexAttrib2sARB(GLuint index
, GLshort x
, GLshort y
)
7947 __GLXcontext
*const gc
= __glXGetCurrentContext();
7948 const GLuint cmdlen
= 12;
7949 emit_header(gc
->pc
, X_GLrop_VertexAttrib2svARB
, cmdlen
);
7950 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&index
), 4);
7951 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&x
), 2);
7952 (void) memcpy((void *) (gc
->pc
+ 10), (void *) (&y
), 2);
7954 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
7955 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
7959 #define X_GLrop_VertexAttrib2svARB 4190
7961 __indirect_glVertexAttrib2svARB(GLuint index
, const GLshort
* v
)
7963 __GLXcontext
*const gc
= __glXGetCurrentContext();
7964 const GLuint cmdlen
= 12;
7965 emit_header(gc
->pc
, X_GLrop_VertexAttrib2svARB
, cmdlen
);
7966 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&index
), 4);
7967 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (v
), 4);
7969 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
7970 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
7974 #define X_GLrop_VertexAttrib3dvARB 4199
7976 __indirect_glVertexAttrib3dARB(GLuint index
, GLdouble x
, GLdouble y
,
7979 __GLXcontext
*const gc
= __glXGetCurrentContext();
7980 const GLuint cmdlen
= 32;
7981 emit_header(gc
->pc
, X_GLrop_VertexAttrib3dvARB
, cmdlen
);
7982 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&index
), 4);
7983 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&x
), 8);
7984 (void) memcpy((void *) (gc
->pc
+ 16), (void *) (&y
), 8);
7985 (void) memcpy((void *) (gc
->pc
+ 24), (void *) (&z
), 8);
7987 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
7988 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
7992 #define X_GLrop_VertexAttrib3dvARB 4199
7994 __indirect_glVertexAttrib3dvARB(GLuint index
, const GLdouble
* v
)
7996 __GLXcontext
*const gc
= __glXGetCurrentContext();
7997 const GLuint cmdlen
= 32;
7998 emit_header(gc
->pc
, X_GLrop_VertexAttrib3dvARB
, cmdlen
);
7999 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&index
), 4);
8000 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (v
), 24);
8002 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
8003 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
8007 #define X_GLrop_VertexAttrib3fvARB 4195
8009 __indirect_glVertexAttrib3fARB(GLuint index
, GLfloat x
, GLfloat y
, GLfloat z
)
8011 __GLXcontext
*const gc
= __glXGetCurrentContext();
8012 const GLuint cmdlen
= 20;
8013 emit_header(gc
->pc
, X_GLrop_VertexAttrib3fvARB
, cmdlen
);
8014 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&index
), 4);
8015 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&x
), 4);
8016 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&y
), 4);
8017 (void) memcpy((void *) (gc
->pc
+ 16), (void *) (&z
), 4);
8019 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
8020 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
8024 #define X_GLrop_VertexAttrib3fvARB 4195
8026 __indirect_glVertexAttrib3fvARB(GLuint index
, const GLfloat
* v
)
8028 __GLXcontext
*const gc
= __glXGetCurrentContext();
8029 const GLuint cmdlen
= 20;
8030 emit_header(gc
->pc
, X_GLrop_VertexAttrib3fvARB
, cmdlen
);
8031 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&index
), 4);
8032 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (v
), 12);
8034 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
8035 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
8039 #define X_GLrop_VertexAttrib3svARB 4191
8041 __indirect_glVertexAttrib3sARB(GLuint index
, GLshort x
, GLshort y
, GLshort z
)
8043 __GLXcontext
*const gc
= __glXGetCurrentContext();
8044 const GLuint cmdlen
= 16;
8045 emit_header(gc
->pc
, X_GLrop_VertexAttrib3svARB
, cmdlen
);
8046 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&index
), 4);
8047 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&x
), 2);
8048 (void) memcpy((void *) (gc
->pc
+ 10), (void *) (&y
), 2);
8049 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&z
), 2);
8051 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
8052 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
8056 #define X_GLrop_VertexAttrib3svARB 4191
8058 __indirect_glVertexAttrib3svARB(GLuint index
, const GLshort
* v
)
8060 __GLXcontext
*const gc
= __glXGetCurrentContext();
8061 const GLuint cmdlen
= 16;
8062 emit_header(gc
->pc
, X_GLrop_VertexAttrib3svARB
, cmdlen
);
8063 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&index
), 4);
8064 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (v
), 6);
8066 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
8067 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
8071 #define X_GLrop_VertexAttrib4NbvARB 4235
8073 __indirect_glVertexAttrib4NbvARB(GLuint index
, const GLbyte
*v
)
8075 __GLXcontext
*const gc
= __glXGetCurrentContext();
8076 const GLuint cmdlen
= 12;
8077 emit_header(gc
->pc
, X_GLrop_VertexAttrib4NbvARB
, cmdlen
);
8078 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&index
), 4);
8079 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (v
), 4);
8081 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
8082 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
8086 #define X_GLrop_VertexAttrib4NivARB 4237
8088 __indirect_glVertexAttrib4NivARB(GLuint index
, const GLint
* v
)
8090 __GLXcontext
*const gc
= __glXGetCurrentContext();
8091 const GLuint cmdlen
= 24;
8092 emit_header(gc
->pc
, X_GLrop_VertexAttrib4NivARB
, cmdlen
);
8093 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&index
), 4);
8094 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (v
), 16);
8096 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
8097 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
8101 #define X_GLrop_VertexAttrib4NsvARB 4236
8103 __indirect_glVertexAttrib4NsvARB(GLuint index
, const GLshort
* v
)
8105 __GLXcontext
*const gc
= __glXGetCurrentContext();
8106 const GLuint cmdlen
= 16;
8107 emit_header(gc
->pc
, X_GLrop_VertexAttrib4NsvARB
, cmdlen
);
8108 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&index
), 4);
8109 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (v
), 8);
8111 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
8112 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
8116 #define X_GLrop_VertexAttrib4NubvARB 4201
8118 __indirect_glVertexAttrib4NubARB(GLuint index
, GLubyte x
, GLubyte y
,
8119 GLubyte z
, GLubyte w
)
8121 __GLXcontext
*const gc
= __glXGetCurrentContext();
8122 const GLuint cmdlen
= 12;
8123 emit_header(gc
->pc
, X_GLrop_VertexAttrib4NubvARB
, cmdlen
);
8124 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&index
), 4);
8125 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&x
), 1);
8126 (void) memcpy((void *) (gc
->pc
+ 9), (void *) (&y
), 1);
8127 (void) memcpy((void *) (gc
->pc
+ 10), (void *) (&z
), 1);
8128 (void) memcpy((void *) (gc
->pc
+ 11), (void *) (&w
), 1);
8130 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
8131 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
8135 #define X_GLrop_VertexAttrib4NubvARB 4201
8137 __indirect_glVertexAttrib4NubvARB(GLuint index
, const GLubyte
*v
)
8139 __GLXcontext
*const gc
= __glXGetCurrentContext();
8140 const GLuint cmdlen
= 12;
8141 emit_header(gc
->pc
, X_GLrop_VertexAttrib4NubvARB
, cmdlen
);
8142 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&index
), 4);
8143 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (v
), 4);
8145 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
8146 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
8150 #define X_GLrop_VertexAttrib4NuivARB 4239
8152 __indirect_glVertexAttrib4NuivARB(GLuint index
, const GLuint
* v
)
8154 __GLXcontext
*const gc
= __glXGetCurrentContext();
8155 const GLuint cmdlen
= 24;
8156 emit_header(gc
->pc
, X_GLrop_VertexAttrib4NuivARB
, cmdlen
);
8157 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&index
), 4);
8158 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (v
), 16);
8160 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
8161 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
8165 #define X_GLrop_VertexAttrib4NusvARB 4238
8167 __indirect_glVertexAttrib4NusvARB(GLuint index
, const GLushort
* v
)
8169 __GLXcontext
*const gc
= __glXGetCurrentContext();
8170 const GLuint cmdlen
= 16;
8171 emit_header(gc
->pc
, X_GLrop_VertexAttrib4NusvARB
, cmdlen
);
8172 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&index
), 4);
8173 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (v
), 8);
8175 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
8176 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
8180 #define X_GLrop_VertexAttrib4bvARB 4230
8182 __indirect_glVertexAttrib4bvARB(GLuint index
, const GLbyte
*v
)
8184 __GLXcontext
*const gc
= __glXGetCurrentContext();
8185 const GLuint cmdlen
= 12;
8186 emit_header(gc
->pc
, X_GLrop_VertexAttrib4bvARB
, cmdlen
);
8187 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&index
), 4);
8188 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (v
), 4);
8190 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
8191 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
8195 #define X_GLrop_VertexAttrib4dvARB 4200
8197 __indirect_glVertexAttrib4dARB(GLuint index
, GLdouble x
, GLdouble y
,
8198 GLdouble z
, GLdouble w
)
8200 __GLXcontext
*const gc
= __glXGetCurrentContext();
8201 const GLuint cmdlen
= 40;
8202 emit_header(gc
->pc
, X_GLrop_VertexAttrib4dvARB
, cmdlen
);
8203 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&index
), 4);
8204 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&x
), 8);
8205 (void) memcpy((void *) (gc
->pc
+ 16), (void *) (&y
), 8);
8206 (void) memcpy((void *) (gc
->pc
+ 24), (void *) (&z
), 8);
8207 (void) memcpy((void *) (gc
->pc
+ 32), (void *) (&w
), 8);
8209 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
8210 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
8214 #define X_GLrop_VertexAttrib4dvARB 4200
8216 __indirect_glVertexAttrib4dvARB(GLuint index
, const GLdouble
* v
)
8218 __GLXcontext
*const gc
= __glXGetCurrentContext();
8219 const GLuint cmdlen
= 40;
8220 emit_header(gc
->pc
, X_GLrop_VertexAttrib4dvARB
, cmdlen
);
8221 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&index
), 4);
8222 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (v
), 32);
8224 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
8225 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
8229 #define X_GLrop_VertexAttrib4fvARB 4196
8231 __indirect_glVertexAttrib4fARB(GLuint index
, GLfloat x
, GLfloat y
, GLfloat z
,
8234 __GLXcontext
*const gc
= __glXGetCurrentContext();
8235 const GLuint cmdlen
= 24;
8236 emit_header(gc
->pc
, X_GLrop_VertexAttrib4fvARB
, cmdlen
);
8237 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&index
), 4);
8238 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&x
), 4);
8239 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&y
), 4);
8240 (void) memcpy((void *) (gc
->pc
+ 16), (void *) (&z
), 4);
8241 (void) memcpy((void *) (gc
->pc
+ 20), (void *) (&w
), 4);
8243 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
8244 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
8248 #define X_GLrop_VertexAttrib4fvARB 4196
8250 __indirect_glVertexAttrib4fvARB(GLuint index
, const GLfloat
* v
)
8252 __GLXcontext
*const gc
= __glXGetCurrentContext();
8253 const GLuint cmdlen
= 24;
8254 emit_header(gc
->pc
, X_GLrop_VertexAttrib4fvARB
, cmdlen
);
8255 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&index
), 4);
8256 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (v
), 16);
8258 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
8259 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
8263 #define X_GLrop_VertexAttrib4ivARB 4231
8265 __indirect_glVertexAttrib4ivARB(GLuint index
, const GLint
* v
)
8267 __GLXcontext
*const gc
= __glXGetCurrentContext();
8268 const GLuint cmdlen
= 24;
8269 emit_header(gc
->pc
, X_GLrop_VertexAttrib4ivARB
, cmdlen
);
8270 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&index
), 4);
8271 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (v
), 16);
8273 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
8274 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
8278 #define X_GLrop_VertexAttrib4svARB 4192
8280 __indirect_glVertexAttrib4sARB(GLuint index
, GLshort x
, GLshort y
, GLshort z
,
8283 __GLXcontext
*const gc
= __glXGetCurrentContext();
8284 const GLuint cmdlen
= 16;
8285 emit_header(gc
->pc
, X_GLrop_VertexAttrib4svARB
, cmdlen
);
8286 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&index
), 4);
8287 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&x
), 2);
8288 (void) memcpy((void *) (gc
->pc
+ 10), (void *) (&y
), 2);
8289 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&z
), 2);
8290 (void) memcpy((void *) (gc
->pc
+ 14), (void *) (&w
), 2);
8292 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
8293 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
8297 #define X_GLrop_VertexAttrib4svARB 4192
8299 __indirect_glVertexAttrib4svARB(GLuint index
, const GLshort
* v
)
8301 __GLXcontext
*const gc
= __glXGetCurrentContext();
8302 const GLuint cmdlen
= 16;
8303 emit_header(gc
->pc
, X_GLrop_VertexAttrib4svARB
, cmdlen
);
8304 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&index
), 4);
8305 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (v
), 8);
8307 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
8308 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
8312 #define X_GLrop_VertexAttrib4ubvARB 4232
8314 __indirect_glVertexAttrib4ubvARB(GLuint index
, const GLubyte
*v
)
8316 __GLXcontext
*const gc
= __glXGetCurrentContext();
8317 const GLuint cmdlen
= 12;
8318 emit_header(gc
->pc
, X_GLrop_VertexAttrib4ubvARB
, cmdlen
);
8319 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&index
), 4);
8320 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (v
), 4);
8322 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
8323 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
8327 #define X_GLrop_VertexAttrib4uivARB 4234
8329 __indirect_glVertexAttrib4uivARB(GLuint index
, const GLuint
* v
)
8331 __GLXcontext
*const gc
= __glXGetCurrentContext();
8332 const GLuint cmdlen
= 24;
8333 emit_header(gc
->pc
, X_GLrop_VertexAttrib4uivARB
, cmdlen
);
8334 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&index
), 4);
8335 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (v
), 16);
8337 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
8338 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
8342 #define X_GLrop_VertexAttrib4usvARB 4233
8344 __indirect_glVertexAttrib4usvARB(GLuint index
, const GLushort
* v
)
8346 __GLXcontext
*const gc
= __glXGetCurrentContext();
8347 const GLuint cmdlen
= 16;
8348 emit_header(gc
->pc
, X_GLrop_VertexAttrib4usvARB
, cmdlen
);
8349 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&index
), 4);
8350 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (v
), 8);
8352 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
8353 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
8357 #define X_GLrop_BeginQueryARB 231
8359 __indirect_glBeginQueryARB(GLenum target
, GLuint id
)
8361 __GLXcontext
*const gc
= __glXGetCurrentContext();
8362 const GLuint cmdlen
= 12;
8363 emit_header(gc
->pc
, X_GLrop_BeginQueryARB
, cmdlen
);
8364 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&target
), 4);
8365 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&id
), 4);
8367 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
8368 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
8372 #define X_GLsop_DeleteQueriesARB 161
8374 __indirect_glDeleteQueriesARB(GLsizei n
, const GLuint
* ids
)
8376 __GLXcontext
*const gc
= __glXGetCurrentContext();
8377 Display
*const dpy
= gc
->currentDpy
;
8379 const GLuint cmdlen
= 4 + __GLX_PAD((n
* 4));
8382 __glXSetError(gc
, GL_INVALID_VALUE
);
8385 if (__builtin_expect((n
>= 0) && (dpy
!= NULL
), 1)) {
8387 xcb_connection_t
*c
= XGetXCBConnection(dpy
);
8388 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
8389 xcb_glx_delete_queries_arb(c
, gc
->currentContextTag
, n
, ids
);
8392 __glXSetupSingleRequest(gc
, X_GLsop_DeleteQueriesARB
, cmdlen
);
8393 (void) memcpy((void *) (pc
+ 0), (void *) (&n
), 4);
8394 (void) memcpy((void *) (pc
+ 4), (void *) (ids
), (n
* 4));
8397 #endif /* USE_XCB */
8402 #define X_GLrop_EndQueryARB 232
8404 __indirect_glEndQueryARB(GLenum target
)
8406 __GLXcontext
*const gc
= __glXGetCurrentContext();
8407 const GLuint cmdlen
= 8;
8408 emit_header(gc
->pc
, X_GLrop_EndQueryARB
, cmdlen
);
8409 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&target
), 4);
8411 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
8412 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
8416 #define X_GLsop_GenQueriesARB 162
8418 __indirect_glGenQueriesARB(GLsizei n
, GLuint
* ids
)
8420 __GLXcontext
*const gc
= __glXGetCurrentContext();
8421 Display
*const dpy
= gc
->currentDpy
;
8423 const GLuint cmdlen
= 4;
8426 __glXSetError(gc
, GL_INVALID_VALUE
);
8429 if (__builtin_expect((n
>= 0) && (dpy
!= NULL
), 1)) {
8431 xcb_connection_t
*c
= XGetXCBConnection(dpy
);
8432 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
8433 xcb_glx_gen_queries_arb_reply_t
*reply
=
8434 xcb_glx_gen_queries_arb_reply(c
,
8435 xcb_glx_gen_queries_arb(c
,
8439 (void) memcpy(ids
, xcb_glx_gen_queries_arb_data(reply
),
8440 xcb_glx_gen_queries_arb_data_length(reply
) *
8445 __glXSetupSingleRequest(gc
, X_GLsop_GenQueriesARB
, cmdlen
);
8446 (void) memcpy((void *) (pc
+ 0), (void *) (&n
), 4);
8447 (void) __glXReadReply(dpy
, 4, ids
, GL_TRUE
);
8450 #endif /* USE_XCB */
8455 #define X_GLsop_GetQueryObjectivARB 165
8457 __indirect_glGetQueryObjectivARB(GLuint id
, GLenum pname
, GLint
* params
)
8459 __GLXcontext
*const gc
= __glXGetCurrentContext();
8460 Display
*const dpy
= gc
->currentDpy
;
8462 const GLuint cmdlen
= 8;
8464 if (__builtin_expect(dpy
!= NULL
, 1)) {
8466 xcb_connection_t
*c
= XGetXCBConnection(dpy
);
8467 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
8468 xcb_glx_get_query_objectiv_arb_reply_t
*reply
=
8469 xcb_glx_get_query_objectiv_arb_reply(c
,
8470 xcb_glx_get_query_objectiv_arb
8471 (c
, gc
->currentContextTag
,
8473 if (xcb_glx_get_query_objectiv_arb_data_length(reply
) == 0)
8474 (void) memcpy(params
, &reply
->datum
, sizeof(reply
->datum
));
8476 (void) memcpy(params
, xcb_glx_get_query_objectiv_arb_data(reply
),
8477 xcb_glx_get_query_objectiv_arb_data_length(reply
) *
8482 __glXSetupSingleRequest(gc
, X_GLsop_GetQueryObjectivARB
, cmdlen
);
8483 (void) memcpy((void *) (pc
+ 0), (void *) (&id
), 4);
8484 (void) memcpy((void *) (pc
+ 4), (void *) (&pname
), 4);
8485 (void) __glXReadReply(dpy
, 4, params
, GL_FALSE
);
8488 #endif /* USE_XCB */
8493 #define X_GLsop_GetQueryObjectuivARB 166
8495 __indirect_glGetQueryObjectuivARB(GLuint id
, GLenum pname
, GLuint
* params
)
8497 __GLXcontext
*const gc
= __glXGetCurrentContext();
8498 Display
*const dpy
= gc
->currentDpy
;
8500 const GLuint cmdlen
= 8;
8502 if (__builtin_expect(dpy
!= NULL
, 1)) {
8504 xcb_connection_t
*c
= XGetXCBConnection(dpy
);
8505 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
8506 xcb_glx_get_query_objectuiv_arb_reply_t
*reply
=
8507 xcb_glx_get_query_objectuiv_arb_reply(c
,
8508 xcb_glx_get_query_objectuiv_arb
8509 (c
, gc
->currentContextTag
,
8511 if (xcb_glx_get_query_objectuiv_arb_data_length(reply
) == 0)
8512 (void) memcpy(params
, &reply
->datum
, sizeof(reply
->datum
));
8514 (void) memcpy(params
, xcb_glx_get_query_objectuiv_arb_data(reply
),
8515 xcb_glx_get_query_objectuiv_arb_data_length(reply
) *
8520 __glXSetupSingleRequest(gc
, X_GLsop_GetQueryObjectuivARB
, cmdlen
);
8521 (void) memcpy((void *) (pc
+ 0), (void *) (&id
), 4);
8522 (void) memcpy((void *) (pc
+ 4), (void *) (&pname
), 4);
8523 (void) __glXReadReply(dpy
, 4, params
, GL_FALSE
);
8526 #endif /* USE_XCB */
8531 #define X_GLsop_GetQueryivARB 164
8533 __indirect_glGetQueryivARB(GLenum target
, GLenum pname
, GLint
* params
)
8535 __GLXcontext
*const gc
= __glXGetCurrentContext();
8536 Display
*const dpy
= gc
->currentDpy
;
8538 const GLuint cmdlen
= 8;
8540 if (__builtin_expect(dpy
!= NULL
, 1)) {
8542 xcb_connection_t
*c
= XGetXCBConnection(dpy
);
8543 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
8544 xcb_glx_get_queryiv_arb_reply_t
*reply
=
8545 xcb_glx_get_queryiv_arb_reply(c
,
8546 xcb_glx_get_queryiv_arb(c
,
8552 if (xcb_glx_get_queryiv_arb_data_length(reply
) == 0)
8553 (void) memcpy(params
, &reply
->datum
, sizeof(reply
->datum
));
8555 (void) memcpy(params
, xcb_glx_get_queryiv_arb_data(reply
),
8556 xcb_glx_get_queryiv_arb_data_length(reply
) *
8561 __glXSetupSingleRequest(gc
, X_GLsop_GetQueryivARB
, cmdlen
);
8562 (void) memcpy((void *) (pc
+ 0), (void *) (&target
), 4);
8563 (void) memcpy((void *) (pc
+ 4), (void *) (&pname
), 4);
8564 (void) __glXReadReply(dpy
, 4, params
, GL_FALSE
);
8567 #endif /* USE_XCB */
8572 #define X_GLsop_IsQueryARB 163
8574 __indirect_glIsQueryARB(GLuint id
)
8576 __GLXcontext
*const gc
= __glXGetCurrentContext();
8577 Display
*const dpy
= gc
->currentDpy
;
8578 GLboolean retval
= (GLboolean
) 0;
8580 const GLuint cmdlen
= 4;
8582 if (__builtin_expect(dpy
!= NULL
, 1)) {
8584 xcb_connection_t
*c
= XGetXCBConnection(dpy
);
8585 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
8586 xcb_glx_is_query_arb_reply_t
*reply
=
8587 xcb_glx_is_query_arb_reply(c
,
8588 xcb_glx_is_query_arb(c
,
8592 retval
= reply
->ret_val
;
8596 __glXSetupSingleRequest(gc
, X_GLsop_IsQueryARB
, cmdlen
);
8597 (void) memcpy((void *) (pc
+ 0), (void *) (&id
), 4);
8598 retval
= (GLboolean
) __glXReadReply(dpy
, 0, NULL
, GL_FALSE
);
8601 #endif /* USE_XCB */
8606 #define X_GLrop_DrawBuffersARB 233
8608 __indirect_glDrawBuffersARB(GLsizei n
, const GLenum
* bufs
)
8610 __GLXcontext
*const gc
= __glXGetCurrentContext();
8611 const GLuint cmdlen
= 8 + __GLX_PAD((n
* 4));
8613 __glXSetError(gc
, GL_INVALID_VALUE
);
8616 if (__builtin_expect((n
>= 0) && (gc
->currentDpy
!= NULL
), 1)) {
8617 if (cmdlen
<= gc
->maxSmallRenderCommandSize
) {
8618 if ((gc
->pc
+ cmdlen
) > gc
->bufEnd
) {
8619 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
8621 emit_header(gc
->pc
, X_GLrop_DrawBuffersARB
, cmdlen
);
8622 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&n
), 4);
8623 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (bufs
), (n
* 4));
8625 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
8626 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
8629 const GLint op
= X_GLrop_DrawBuffersARB
;
8630 const GLuint cmdlenLarge
= cmdlen
+ 4;
8631 GLubyte
*const pc
= __glXFlushRenderBuffer(gc
, gc
->pc
);
8632 (void) memcpy((void *) (pc
+ 0), (void *) (&cmdlenLarge
), 4);
8633 (void) memcpy((void *) (pc
+ 4), (void *) (&op
), 4);
8634 (void) memcpy((void *) (pc
+ 8), (void *) (&n
), 4);
8635 __glXSendLargeCommand(gc
, pc
, 12, bufs
, (n
* 4));
8640 #define X_GLrop_SampleMaskSGIS 2048
8642 __indirect_glSampleMaskSGIS(GLclampf value
, GLboolean invert
)
8644 __GLXcontext
*const gc
= __glXGetCurrentContext();
8645 const GLuint cmdlen
= 12;
8646 emit_header(gc
->pc
, X_GLrop_SampleMaskSGIS
, cmdlen
);
8647 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&value
), 4);
8648 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&invert
), 1);
8650 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
8651 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
8655 #define X_GLrop_SamplePatternSGIS 2049
8657 __indirect_glSamplePatternSGIS(GLenum pattern
)
8659 __GLXcontext
*const gc
= __glXGetCurrentContext();
8660 const GLuint cmdlen
= 8;
8661 emit_header(gc
->pc
, X_GLrop_SamplePatternSGIS
, cmdlen
);
8662 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&pattern
), 4);
8664 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
8665 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
8669 #define X_GLrop_PointParameterfEXT 2065
8671 __indirect_glPointParameterfEXT(GLenum pname
, GLfloat param
)
8673 __GLXcontext
*const gc
= __glXGetCurrentContext();
8674 const GLuint cmdlen
= 12;
8675 emit_header(gc
->pc
, X_GLrop_PointParameterfEXT
, cmdlen
);
8676 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&pname
), 4);
8677 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (¶m
), 4);
8679 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
8680 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
8684 #define X_GLrop_PointParameterfvEXT 2066
8686 __indirect_glPointParameterfvEXT(GLenum pname
, const GLfloat
* params
)
8688 __GLXcontext
*const gc
= __glXGetCurrentContext();
8689 const GLuint compsize
= __glPointParameterfvEXT_size(pname
);
8690 const GLuint cmdlen
= 8 + __GLX_PAD((compsize
* 4));
8691 emit_header(gc
->pc
, X_GLrop_PointParameterfvEXT
, cmdlen
);
8692 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&pname
), 4);
8693 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (params
), (compsize
* 4));
8695 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
8696 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
8700 #define X_GLrop_SecondaryColor3bvEXT 4126
8702 __indirect_glSecondaryColor3bEXT(GLbyte red
, GLbyte green
, GLbyte blue
)
8704 __GLXcontext
*const gc
= __glXGetCurrentContext();
8705 const GLuint cmdlen
= 8;
8706 emit_header(gc
->pc
, X_GLrop_SecondaryColor3bvEXT
, cmdlen
);
8707 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&red
), 1);
8708 (void) memcpy((void *) (gc
->pc
+ 5), (void *) (&green
), 1);
8709 (void) memcpy((void *) (gc
->pc
+ 6), (void *) (&blue
), 1);
8711 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
8712 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
8716 #define X_GLrop_SecondaryColor3bvEXT 4126
8718 __indirect_glSecondaryColor3bvEXT(const GLbyte
*v
)
8720 generic_3_byte(X_GLrop_SecondaryColor3bvEXT
, v
);
8723 #define X_GLrop_SecondaryColor3dvEXT 4130
8725 __indirect_glSecondaryColor3dEXT(GLdouble red
, GLdouble green
, GLdouble blue
)
8727 __GLXcontext
*const gc
= __glXGetCurrentContext();
8728 const GLuint cmdlen
= 28;
8729 emit_header(gc
->pc
, X_GLrop_SecondaryColor3dvEXT
, cmdlen
);
8730 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&red
), 8);
8731 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&green
), 8);
8732 (void) memcpy((void *) (gc
->pc
+ 20), (void *) (&blue
), 8);
8734 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
8735 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
8739 #define X_GLrop_SecondaryColor3dvEXT 4130
8741 __indirect_glSecondaryColor3dvEXT(const GLdouble
* v
)
8743 generic_24_byte(X_GLrop_SecondaryColor3dvEXT
, v
);
8746 #define X_GLrop_SecondaryColor3fvEXT 4129
8748 __indirect_glSecondaryColor3fEXT(GLfloat red
, GLfloat green
, GLfloat blue
)
8750 __GLXcontext
*const gc
= __glXGetCurrentContext();
8751 const GLuint cmdlen
= 16;
8752 emit_header(gc
->pc
, X_GLrop_SecondaryColor3fvEXT
, cmdlen
);
8753 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&red
), 4);
8754 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&green
), 4);
8755 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&blue
), 4);
8757 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
8758 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
8762 #define X_GLrop_SecondaryColor3fvEXT 4129
8764 __indirect_glSecondaryColor3fvEXT(const GLfloat
* v
)
8766 generic_12_byte(X_GLrop_SecondaryColor3fvEXT
, v
);
8769 #define X_GLrop_SecondaryColor3ivEXT 4128
8771 __indirect_glSecondaryColor3iEXT(GLint red
, GLint green
, GLint blue
)
8773 __GLXcontext
*const gc
= __glXGetCurrentContext();
8774 const GLuint cmdlen
= 16;
8775 emit_header(gc
->pc
, X_GLrop_SecondaryColor3ivEXT
, cmdlen
);
8776 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&red
), 4);
8777 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&green
), 4);
8778 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&blue
), 4);
8780 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
8781 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
8785 #define X_GLrop_SecondaryColor3ivEXT 4128
8787 __indirect_glSecondaryColor3ivEXT(const GLint
* v
)
8789 generic_12_byte(X_GLrop_SecondaryColor3ivEXT
, v
);
8792 #define X_GLrop_SecondaryColor3svEXT 4127
8794 __indirect_glSecondaryColor3sEXT(GLshort red
, GLshort green
, GLshort blue
)
8796 __GLXcontext
*const gc
= __glXGetCurrentContext();
8797 const GLuint cmdlen
= 12;
8798 emit_header(gc
->pc
, X_GLrop_SecondaryColor3svEXT
, cmdlen
);
8799 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&red
), 2);
8800 (void) memcpy((void *) (gc
->pc
+ 6), (void *) (&green
), 2);
8801 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&blue
), 2);
8803 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
8804 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
8808 #define X_GLrop_SecondaryColor3svEXT 4127
8810 __indirect_glSecondaryColor3svEXT(const GLshort
* v
)
8812 generic_6_byte(X_GLrop_SecondaryColor3svEXT
, v
);
8815 #define X_GLrop_SecondaryColor3ubvEXT 4131
8817 __indirect_glSecondaryColor3ubEXT(GLubyte red
, GLubyte green
, GLubyte blue
)
8819 __GLXcontext
*const gc
= __glXGetCurrentContext();
8820 const GLuint cmdlen
= 8;
8821 emit_header(gc
->pc
, X_GLrop_SecondaryColor3ubvEXT
, cmdlen
);
8822 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&red
), 1);
8823 (void) memcpy((void *) (gc
->pc
+ 5), (void *) (&green
), 1);
8824 (void) memcpy((void *) (gc
->pc
+ 6), (void *) (&blue
), 1);
8826 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
8827 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
8831 #define X_GLrop_SecondaryColor3ubvEXT 4131
8833 __indirect_glSecondaryColor3ubvEXT(const GLubyte
*v
)
8835 generic_3_byte(X_GLrop_SecondaryColor3ubvEXT
, v
);
8838 #define X_GLrop_SecondaryColor3uivEXT 4133
8840 __indirect_glSecondaryColor3uiEXT(GLuint red
, GLuint green
, GLuint blue
)
8842 __GLXcontext
*const gc
= __glXGetCurrentContext();
8843 const GLuint cmdlen
= 16;
8844 emit_header(gc
->pc
, X_GLrop_SecondaryColor3uivEXT
, cmdlen
);
8845 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&red
), 4);
8846 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&green
), 4);
8847 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&blue
), 4);
8849 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
8850 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
8854 #define X_GLrop_SecondaryColor3uivEXT 4133
8856 __indirect_glSecondaryColor3uivEXT(const GLuint
* v
)
8858 generic_12_byte(X_GLrop_SecondaryColor3uivEXT
, v
);
8861 #define X_GLrop_SecondaryColor3usvEXT 4132
8863 __indirect_glSecondaryColor3usEXT(GLushort red
, GLushort green
, GLushort blue
)
8865 __GLXcontext
*const gc
= __glXGetCurrentContext();
8866 const GLuint cmdlen
= 12;
8867 emit_header(gc
->pc
, X_GLrop_SecondaryColor3usvEXT
, cmdlen
);
8868 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&red
), 2);
8869 (void) memcpy((void *) (gc
->pc
+ 6), (void *) (&green
), 2);
8870 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&blue
), 2);
8872 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
8873 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
8877 #define X_GLrop_SecondaryColor3usvEXT 4132
8879 __indirect_glSecondaryColor3usvEXT(const GLushort
* v
)
8881 generic_6_byte(X_GLrop_SecondaryColor3usvEXT
, v
);
8884 #define X_GLrop_FogCoorddvEXT 4125
8886 __indirect_glFogCoorddEXT(GLdouble coord
)
8888 __GLXcontext
*const gc
= __glXGetCurrentContext();
8889 const GLuint cmdlen
= 12;
8890 emit_header(gc
->pc
, X_GLrop_FogCoorddvEXT
, cmdlen
);
8891 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&coord
), 8);
8893 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
8894 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
8898 #define X_GLrop_FogCoorddvEXT 4125
8900 __indirect_glFogCoorddvEXT(const GLdouble
* coord
)
8902 generic_8_byte(X_GLrop_FogCoorddvEXT
, coord
);
8905 #define X_GLrop_FogCoordfvEXT 4124
8907 __indirect_glFogCoordfEXT(GLfloat coord
)
8909 __GLXcontext
*const gc
= __glXGetCurrentContext();
8910 const GLuint cmdlen
= 8;
8911 emit_header(gc
->pc
, X_GLrop_FogCoordfvEXT
, cmdlen
);
8912 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&coord
), 4);
8914 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
8915 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
8919 #define X_GLrop_FogCoordfvEXT 4124
8921 __indirect_glFogCoordfvEXT(const GLfloat
* coord
)
8923 generic_4_byte(X_GLrop_FogCoordfvEXT
, coord
);
8926 #define X_GLrop_BlendFuncSeparateEXT 4134
8928 __indirect_glBlendFuncSeparateEXT(GLenum sfactorRGB
, GLenum dfactorRGB
,
8929 GLenum sfactorAlpha
, GLenum dfactorAlpha
)
8931 __GLXcontext
*const gc
= __glXGetCurrentContext();
8932 const GLuint cmdlen
= 20;
8933 emit_header(gc
->pc
, X_GLrop_BlendFuncSeparateEXT
, cmdlen
);
8934 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&sfactorRGB
), 4);
8935 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&dfactorRGB
), 4);
8936 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&sfactorAlpha
), 4);
8937 (void) memcpy((void *) (gc
->pc
+ 16), (void *) (&dfactorAlpha
), 4);
8939 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
8940 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
8944 #define X_GLrop_WindowPos3fvMESA 230
8946 __indirect_glWindowPos3fMESA(GLfloat x
, GLfloat y
, GLfloat z
)
8948 __GLXcontext
*const gc
= __glXGetCurrentContext();
8949 const GLuint cmdlen
= 16;
8950 emit_header(gc
->pc
, X_GLrop_WindowPos3fvMESA
, cmdlen
);
8951 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&x
), 4);
8952 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&y
), 4);
8953 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&z
), 4);
8955 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
8956 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
8960 #define X_GLrop_WindowPos3fvMESA 230
8962 __indirect_glWindowPos3fvMESA(const GLfloat
* v
)
8964 generic_12_byte(X_GLrop_WindowPos3fvMESA
, v
);
8967 #define X_GLvop_AreProgramsResidentNV 1293
8969 __indirect_glAreProgramsResidentNV(GLsizei n
, const GLuint
* ids
,
8970 GLboolean
* residences
)
8972 __GLXcontext
*const gc
= __glXGetCurrentContext();
8973 Display
*const dpy
= gc
->currentDpy
;
8974 GLboolean retval
= (GLboolean
) 0;
8975 const GLuint cmdlen
= 4 + __GLX_PAD((n
* 4));
8977 __glXSetError(gc
, GL_INVALID_VALUE
);
8980 if (__builtin_expect((n
>= 0) && (dpy
!= NULL
), 1)) {
8982 __glXSetupVendorRequest(gc
, X_GLXVendorPrivateWithReply
,
8983 X_GLvop_AreProgramsResidentNV
, cmdlen
);
8984 (void) memcpy((void *) (pc
+ 0), (void *) (&n
), 4);
8985 (void) memcpy((void *) (pc
+ 4), (void *) (ids
), (n
* 4));
8986 retval
= (GLboolean
) __glXReadReply(dpy
, 1, residences
, GL_FALSE
);
8993 #define X_GLrop_BindProgramNV 4180
8995 __indirect_glBindProgramNV(GLenum target
, GLuint program
)
8997 __GLXcontext
*const gc
= __glXGetCurrentContext();
8998 const GLuint cmdlen
= 12;
8999 emit_header(gc
->pc
, X_GLrop_BindProgramNV
, cmdlen
);
9000 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&target
), 4);
9001 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&program
), 4);
9003 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
9004 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
9008 #define X_GLvop_DeleteProgramsNV 1294
9010 __indirect_glDeleteProgramsNV(GLsizei n
, const GLuint
* programs
)
9012 __GLXcontext
*const gc
= __glXGetCurrentContext();
9013 Display
*const dpy
= gc
->currentDpy
;
9014 const GLuint cmdlen
= 4 + __GLX_PAD((n
* 4));
9016 __glXSetError(gc
, GL_INVALID_VALUE
);
9019 if (__builtin_expect((n
>= 0) && (dpy
!= NULL
), 1)) {
9021 __glXSetupVendorRequest(gc
, X_GLXVendorPrivate
,
9022 X_GLvop_DeleteProgramsNV
, cmdlen
);
9023 (void) memcpy((void *) (pc
+ 0), (void *) (&n
), 4);
9024 (void) memcpy((void *) (pc
+ 4), (void *) (programs
), (n
* 4));
9031 #define X_GLrop_ExecuteProgramNV 4181
9033 __indirect_glExecuteProgramNV(GLenum target
, GLuint id
,
9034 const GLfloat
* params
)
9036 __GLXcontext
*const gc
= __glXGetCurrentContext();
9037 const GLuint cmdlen
= 28;
9038 emit_header(gc
->pc
, X_GLrop_ExecuteProgramNV
, cmdlen
);
9039 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&target
), 4);
9040 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&id
), 4);
9041 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (params
), 16);
9043 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
9044 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
9048 #define X_GLvop_GenProgramsNV 1295
9050 __indirect_glGenProgramsNV(GLsizei n
, GLuint
* programs
)
9052 __GLXcontext
*const gc
= __glXGetCurrentContext();
9053 Display
*const dpy
= gc
->currentDpy
;
9054 const GLuint cmdlen
= 4;
9056 __glXSetError(gc
, GL_INVALID_VALUE
);
9059 if (__builtin_expect((n
>= 0) && (dpy
!= NULL
), 1)) {
9061 __glXSetupVendorRequest(gc
, X_GLXVendorPrivateWithReply
,
9062 X_GLvop_GenProgramsNV
, cmdlen
);
9063 (void) memcpy((void *) (pc
+ 0), (void *) (&n
), 4);
9064 (void) __glXReadReply(dpy
, 4, programs
, GL_TRUE
);
9071 #define X_GLvop_GetProgramParameterdvNV 1297
9073 __indirect_glGetProgramParameterdvNV(GLenum target
, GLuint index
,
9074 GLenum pname
, GLdouble
* params
)
9076 __GLXcontext
*const gc
= __glXGetCurrentContext();
9077 Display
*const dpy
= gc
->currentDpy
;
9078 const GLuint cmdlen
= 12;
9079 if (__builtin_expect(dpy
!= NULL
, 1)) {
9081 __glXSetupVendorRequest(gc
, X_GLXVendorPrivateWithReply
,
9082 X_GLvop_GetProgramParameterdvNV
, cmdlen
);
9083 (void) memcpy((void *) (pc
+ 0), (void *) (&target
), 4);
9084 (void) memcpy((void *) (pc
+ 4), (void *) (&index
), 4);
9085 (void) memcpy((void *) (pc
+ 8), (void *) (&pname
), 4);
9086 (void) __glXReadReply(dpy
, 8, params
, GL_FALSE
);
9093 #define X_GLvop_GetProgramParameterfvNV 1296
9095 __indirect_glGetProgramParameterfvNV(GLenum target
, GLuint index
,
9096 GLenum pname
, GLfloat
* params
)
9098 __GLXcontext
*const gc
= __glXGetCurrentContext();
9099 Display
*const dpy
= gc
->currentDpy
;
9100 const GLuint cmdlen
= 12;
9101 if (__builtin_expect(dpy
!= NULL
, 1)) {
9103 __glXSetupVendorRequest(gc
, X_GLXVendorPrivateWithReply
,
9104 X_GLvop_GetProgramParameterfvNV
, cmdlen
);
9105 (void) memcpy((void *) (pc
+ 0), (void *) (&target
), 4);
9106 (void) memcpy((void *) (pc
+ 4), (void *) (&index
), 4);
9107 (void) memcpy((void *) (pc
+ 8), (void *) (&pname
), 4);
9108 (void) __glXReadReply(dpy
, 4, params
, GL_FALSE
);
9115 #define X_GLvop_GetProgramStringNV 1299
9117 __indirect_glGetProgramStringNV(GLuint id
, GLenum pname
, GLubyte
*program
)
9119 __GLXcontext
*const gc
= __glXGetCurrentContext();
9120 Display
*const dpy
= gc
->currentDpy
;
9121 const GLuint cmdlen
= 8;
9122 if (__builtin_expect(dpy
!= NULL
, 1)) {
9124 __glXSetupVendorRequest(gc
, X_GLXVendorPrivateWithReply
,
9125 X_GLvop_GetProgramStringNV
, cmdlen
);
9126 (void) memcpy((void *) (pc
+ 0), (void *) (&id
), 4);
9127 (void) memcpy((void *) (pc
+ 4), (void *) (&pname
), 4);
9128 (void) __glXReadReply(dpy
, 1, program
, GL_TRUE
);
9135 #define X_GLvop_GetProgramivNV 1298
9137 __indirect_glGetProgramivNV(GLuint id
, GLenum pname
, GLint
* params
)
9139 __GLXcontext
*const gc
= __glXGetCurrentContext();
9140 Display
*const dpy
= gc
->currentDpy
;
9141 const GLuint cmdlen
= 8;
9142 if (__builtin_expect(dpy
!= NULL
, 1)) {
9144 __glXSetupVendorRequest(gc
, X_GLXVendorPrivateWithReply
,
9145 X_GLvop_GetProgramivNV
, cmdlen
);
9146 (void) memcpy((void *) (pc
+ 0), (void *) (&id
), 4);
9147 (void) memcpy((void *) (pc
+ 4), (void *) (&pname
), 4);
9148 (void) __glXReadReply(dpy
, 4, params
, GL_FALSE
);
9155 #define X_GLvop_GetTrackMatrixivNV 1300
9157 __indirect_glGetTrackMatrixivNV(GLenum target
, GLuint address
, GLenum pname
,
9160 __GLXcontext
*const gc
= __glXGetCurrentContext();
9161 Display
*const dpy
= gc
->currentDpy
;
9162 const GLuint cmdlen
= 12;
9163 if (__builtin_expect(dpy
!= NULL
, 1)) {
9165 __glXSetupVendorRequest(gc
, X_GLXVendorPrivateWithReply
,
9166 X_GLvop_GetTrackMatrixivNV
, cmdlen
);
9167 (void) memcpy((void *) (pc
+ 0), (void *) (&target
), 4);
9168 (void) memcpy((void *) (pc
+ 4), (void *) (&address
), 4);
9169 (void) memcpy((void *) (pc
+ 8), (void *) (&pname
), 4);
9170 (void) __glXReadReply(dpy
, 4, params
, GL_FALSE
);
9177 #define X_GLvop_GetVertexAttribdvNV 1301
9179 __indirect_glGetVertexAttribdvNV(GLuint index
, GLenum pname
,
9182 __GLXcontext
*const gc
= __glXGetCurrentContext();
9183 Display
*const dpy
= gc
->currentDpy
;
9184 const GLuint cmdlen
= 8;
9185 if (__builtin_expect(dpy
!= NULL
, 1)) {
9187 __glXSetupVendorRequest(gc
, X_GLXVendorPrivateWithReply
,
9188 X_GLvop_GetVertexAttribdvNV
, cmdlen
);
9189 (void) memcpy((void *) (pc
+ 0), (void *) (&index
), 4);
9190 (void) memcpy((void *) (pc
+ 4), (void *) (&pname
), 4);
9191 (void) __glXReadReply(dpy
, 8, params
, GL_FALSE
);
9198 #define X_GLvop_GetVertexAttribfvNV 1302
9200 __indirect_glGetVertexAttribfvNV(GLuint index
, GLenum pname
, GLfloat
* params
)
9202 __GLXcontext
*const gc
= __glXGetCurrentContext();
9203 Display
*const dpy
= gc
->currentDpy
;
9204 const GLuint cmdlen
= 8;
9205 if (__builtin_expect(dpy
!= NULL
, 1)) {
9207 __glXSetupVendorRequest(gc
, X_GLXVendorPrivateWithReply
,
9208 X_GLvop_GetVertexAttribfvNV
, cmdlen
);
9209 (void) memcpy((void *) (pc
+ 0), (void *) (&index
), 4);
9210 (void) memcpy((void *) (pc
+ 4), (void *) (&pname
), 4);
9211 (void) __glXReadReply(dpy
, 4, params
, GL_FALSE
);
9218 #define X_GLvop_GetVertexAttribivNV 1303
9220 __indirect_glGetVertexAttribivNV(GLuint index
, GLenum pname
, GLint
* params
)
9222 __GLXcontext
*const gc
= __glXGetCurrentContext();
9223 Display
*const dpy
= gc
->currentDpy
;
9224 const GLuint cmdlen
= 8;
9225 if (__builtin_expect(dpy
!= NULL
, 1)) {
9227 __glXSetupVendorRequest(gc
, X_GLXVendorPrivateWithReply
,
9228 X_GLvop_GetVertexAttribivNV
, cmdlen
);
9229 (void) memcpy((void *) (pc
+ 0), (void *) (&index
), 4);
9230 (void) memcpy((void *) (pc
+ 4), (void *) (&pname
), 4);
9231 (void) __glXReadReply(dpy
, 4, params
, GL_FALSE
);
9238 #define X_GLvop_IsProgramNV 1304
9240 __indirect_glIsProgramNV(GLuint program
)
9242 __GLXcontext
*const gc
= __glXGetCurrentContext();
9243 Display
*const dpy
= gc
->currentDpy
;
9244 GLboolean retval
= (GLboolean
) 0;
9245 const GLuint cmdlen
= 4;
9246 if (__builtin_expect(dpy
!= NULL
, 1)) {
9248 __glXSetupVendorRequest(gc
, X_GLXVendorPrivateWithReply
,
9249 X_GLvop_IsProgramNV
, cmdlen
);
9250 (void) memcpy((void *) (pc
+ 0), (void *) (&program
), 4);
9251 retval
= (GLboolean
) __glXReadReply(dpy
, 0, NULL
, GL_FALSE
);
9258 #define X_GLrop_LoadProgramNV 4183
9260 __indirect_glLoadProgramNV(GLenum target
, GLuint id
, GLsizei len
,
9261 const GLubyte
*program
)
9263 __GLXcontext
*const gc
= __glXGetCurrentContext();
9264 const GLuint cmdlen
= 16 + __GLX_PAD(len
);
9266 __glXSetError(gc
, GL_INVALID_VALUE
);
9269 if (__builtin_expect(len
>= 0, 1)) {
9270 emit_header(gc
->pc
, X_GLrop_LoadProgramNV
, cmdlen
);
9271 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&target
), 4);
9272 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&id
), 4);
9273 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&len
), 4);
9274 (void) memcpy((void *) (gc
->pc
+ 16), (void *) (program
), len
);
9276 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
9277 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
9282 #define X_GLrop_ProgramParameters4dvNV 4187
9284 __indirect_glProgramParameters4dvNV(GLenum target
, GLuint index
, GLuint num
,
9285 const GLdouble
* params
)
9287 __GLXcontext
*const gc
= __glXGetCurrentContext();
9288 const GLuint cmdlen
= 16 + __GLX_PAD((num
* 32));
9290 __glXSetError(gc
, GL_INVALID_VALUE
);
9293 if (__builtin_expect(num
>= 0, 1)) {
9294 emit_header(gc
->pc
, X_GLrop_ProgramParameters4dvNV
, cmdlen
);
9295 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&target
), 4);
9296 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&index
), 4);
9297 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&num
), 4);
9298 (void) memcpy((void *) (gc
->pc
+ 16), (void *) (params
), (num
* 32));
9300 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
9301 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
9306 #define X_GLrop_ProgramParameters4fvNV 4186
9308 __indirect_glProgramParameters4fvNV(GLenum target
, GLuint index
, GLuint num
,
9309 const GLfloat
* params
)
9311 __GLXcontext
*const gc
= __glXGetCurrentContext();
9312 const GLuint cmdlen
= 16 + __GLX_PAD((num
* 16));
9314 __glXSetError(gc
, GL_INVALID_VALUE
);
9317 if (__builtin_expect(num
>= 0, 1)) {
9318 emit_header(gc
->pc
, X_GLrop_ProgramParameters4fvNV
, cmdlen
);
9319 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&target
), 4);
9320 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&index
), 4);
9321 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&num
), 4);
9322 (void) memcpy((void *) (gc
->pc
+ 16), (void *) (params
), (num
* 16));
9324 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
9325 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
9330 #define X_GLrop_RequestResidentProgramsNV 4182
9332 __indirect_glRequestResidentProgramsNV(GLsizei n
, const GLuint
* ids
)
9334 __GLXcontext
*const gc
= __glXGetCurrentContext();
9335 const GLuint cmdlen
= 8 + __GLX_PAD((n
* 4));
9337 __glXSetError(gc
, GL_INVALID_VALUE
);
9340 if (__builtin_expect(n
>= 0, 1)) {
9341 emit_header(gc
->pc
, X_GLrop_RequestResidentProgramsNV
, cmdlen
);
9342 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&n
), 4);
9343 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (ids
), (n
* 4));
9345 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
9346 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
9351 #define X_GLrop_TrackMatrixNV 4188
9353 __indirect_glTrackMatrixNV(GLenum target
, GLuint address
, GLenum matrix
,
9356 __GLXcontext
*const gc
= __glXGetCurrentContext();
9357 const GLuint cmdlen
= 20;
9358 emit_header(gc
->pc
, X_GLrop_TrackMatrixNV
, cmdlen
);
9359 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&target
), 4);
9360 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&address
), 4);
9361 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&matrix
), 4);
9362 (void) memcpy((void *) (gc
->pc
+ 16), (void *) (&transform
), 4);
9364 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
9365 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
9369 #define X_GLrop_VertexAttrib1dvNV 4273
9371 __indirect_glVertexAttrib1dNV(GLuint index
, GLdouble x
)
9373 __GLXcontext
*const gc
= __glXGetCurrentContext();
9374 const GLuint cmdlen
= 16;
9375 emit_header(gc
->pc
, X_GLrop_VertexAttrib1dvNV
, cmdlen
);
9376 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&index
), 4);
9377 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&x
), 8);
9379 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
9380 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
9384 #define X_GLrop_VertexAttrib1dvNV 4273
9386 __indirect_glVertexAttrib1dvNV(GLuint index
, const GLdouble
* v
)
9388 __GLXcontext
*const gc
= __glXGetCurrentContext();
9389 const GLuint cmdlen
= 16;
9390 emit_header(gc
->pc
, X_GLrop_VertexAttrib1dvNV
, cmdlen
);
9391 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&index
), 4);
9392 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (v
), 8);
9394 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
9395 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
9399 #define X_GLrop_VertexAttrib1fvNV 4269
9401 __indirect_glVertexAttrib1fNV(GLuint index
, GLfloat x
)
9403 __GLXcontext
*const gc
= __glXGetCurrentContext();
9404 const GLuint cmdlen
= 12;
9405 emit_header(gc
->pc
, X_GLrop_VertexAttrib1fvNV
, cmdlen
);
9406 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&index
), 4);
9407 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&x
), 4);
9409 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
9410 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
9414 #define X_GLrop_VertexAttrib1fvNV 4269
9416 __indirect_glVertexAttrib1fvNV(GLuint index
, const GLfloat
* v
)
9418 __GLXcontext
*const gc
= __glXGetCurrentContext();
9419 const GLuint cmdlen
= 12;
9420 emit_header(gc
->pc
, X_GLrop_VertexAttrib1fvNV
, cmdlen
);
9421 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&index
), 4);
9422 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (v
), 4);
9424 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
9425 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
9429 #define X_GLrop_VertexAttrib1svNV 4265
9431 __indirect_glVertexAttrib1sNV(GLuint index
, GLshort x
)
9433 __GLXcontext
*const gc
= __glXGetCurrentContext();
9434 const GLuint cmdlen
= 12;
9435 emit_header(gc
->pc
, X_GLrop_VertexAttrib1svNV
, cmdlen
);
9436 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&index
), 4);
9437 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&x
), 2);
9439 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
9440 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
9444 #define X_GLrop_VertexAttrib1svNV 4265
9446 __indirect_glVertexAttrib1svNV(GLuint index
, const GLshort
* v
)
9448 __GLXcontext
*const gc
= __glXGetCurrentContext();
9449 const GLuint cmdlen
= 12;
9450 emit_header(gc
->pc
, X_GLrop_VertexAttrib1svNV
, cmdlen
);
9451 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&index
), 4);
9452 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (v
), 2);
9454 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
9455 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
9459 #define X_GLrop_VertexAttrib2dvNV 4274
9461 __indirect_glVertexAttrib2dNV(GLuint index
, GLdouble x
, GLdouble y
)
9463 __GLXcontext
*const gc
= __glXGetCurrentContext();
9464 const GLuint cmdlen
= 24;
9465 emit_header(gc
->pc
, X_GLrop_VertexAttrib2dvNV
, cmdlen
);
9466 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&index
), 4);
9467 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&x
), 8);
9468 (void) memcpy((void *) (gc
->pc
+ 16), (void *) (&y
), 8);
9470 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
9471 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
9475 #define X_GLrop_VertexAttrib2dvNV 4274
9477 __indirect_glVertexAttrib2dvNV(GLuint index
, const GLdouble
* v
)
9479 __GLXcontext
*const gc
= __glXGetCurrentContext();
9480 const GLuint cmdlen
= 24;
9481 emit_header(gc
->pc
, X_GLrop_VertexAttrib2dvNV
, cmdlen
);
9482 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&index
), 4);
9483 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (v
), 16);
9485 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
9486 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
9490 #define X_GLrop_VertexAttrib2fvNV 4270
9492 __indirect_glVertexAttrib2fNV(GLuint index
, GLfloat x
, GLfloat y
)
9494 __GLXcontext
*const gc
= __glXGetCurrentContext();
9495 const GLuint cmdlen
= 16;
9496 emit_header(gc
->pc
, X_GLrop_VertexAttrib2fvNV
, cmdlen
);
9497 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&index
), 4);
9498 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&x
), 4);
9499 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&y
), 4);
9501 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
9502 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
9506 #define X_GLrop_VertexAttrib2fvNV 4270
9508 __indirect_glVertexAttrib2fvNV(GLuint index
, const GLfloat
* v
)
9510 __GLXcontext
*const gc
= __glXGetCurrentContext();
9511 const GLuint cmdlen
= 16;
9512 emit_header(gc
->pc
, X_GLrop_VertexAttrib2fvNV
, cmdlen
);
9513 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&index
), 4);
9514 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (v
), 8);
9516 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
9517 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
9521 #define X_GLrop_VertexAttrib2svNV 4266
9523 __indirect_glVertexAttrib2sNV(GLuint index
, GLshort x
, GLshort y
)
9525 __GLXcontext
*const gc
= __glXGetCurrentContext();
9526 const GLuint cmdlen
= 12;
9527 emit_header(gc
->pc
, X_GLrop_VertexAttrib2svNV
, cmdlen
);
9528 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&index
), 4);
9529 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&x
), 2);
9530 (void) memcpy((void *) (gc
->pc
+ 10), (void *) (&y
), 2);
9532 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
9533 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
9537 #define X_GLrop_VertexAttrib2svNV 4266
9539 __indirect_glVertexAttrib2svNV(GLuint index
, const GLshort
* v
)
9541 __GLXcontext
*const gc
= __glXGetCurrentContext();
9542 const GLuint cmdlen
= 12;
9543 emit_header(gc
->pc
, X_GLrop_VertexAttrib2svNV
, cmdlen
);
9544 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&index
), 4);
9545 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (v
), 4);
9547 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
9548 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
9552 #define X_GLrop_VertexAttrib3dvNV 4275
9554 __indirect_glVertexAttrib3dNV(GLuint index
, GLdouble x
, GLdouble y
,
9557 __GLXcontext
*const gc
= __glXGetCurrentContext();
9558 const GLuint cmdlen
= 32;
9559 emit_header(gc
->pc
, X_GLrop_VertexAttrib3dvNV
, cmdlen
);
9560 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&index
), 4);
9561 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&x
), 8);
9562 (void) memcpy((void *) (gc
->pc
+ 16), (void *) (&y
), 8);
9563 (void) memcpy((void *) (gc
->pc
+ 24), (void *) (&z
), 8);
9565 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
9566 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
9570 #define X_GLrop_VertexAttrib3dvNV 4275
9572 __indirect_glVertexAttrib3dvNV(GLuint index
, const GLdouble
* v
)
9574 __GLXcontext
*const gc
= __glXGetCurrentContext();
9575 const GLuint cmdlen
= 32;
9576 emit_header(gc
->pc
, X_GLrop_VertexAttrib3dvNV
, cmdlen
);
9577 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&index
), 4);
9578 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (v
), 24);
9580 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
9581 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
9585 #define X_GLrop_VertexAttrib3fvNV 4271
9587 __indirect_glVertexAttrib3fNV(GLuint index
, GLfloat x
, GLfloat y
, GLfloat z
)
9589 __GLXcontext
*const gc
= __glXGetCurrentContext();
9590 const GLuint cmdlen
= 20;
9591 emit_header(gc
->pc
, X_GLrop_VertexAttrib3fvNV
, cmdlen
);
9592 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&index
), 4);
9593 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&x
), 4);
9594 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&y
), 4);
9595 (void) memcpy((void *) (gc
->pc
+ 16), (void *) (&z
), 4);
9597 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
9598 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
9602 #define X_GLrop_VertexAttrib3fvNV 4271
9604 __indirect_glVertexAttrib3fvNV(GLuint index
, const GLfloat
* v
)
9606 __GLXcontext
*const gc
= __glXGetCurrentContext();
9607 const GLuint cmdlen
= 20;
9608 emit_header(gc
->pc
, X_GLrop_VertexAttrib3fvNV
, cmdlen
);
9609 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&index
), 4);
9610 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (v
), 12);
9612 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
9613 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
9617 #define X_GLrop_VertexAttrib3svNV 4267
9619 __indirect_glVertexAttrib3sNV(GLuint index
, GLshort x
, GLshort y
, GLshort z
)
9621 __GLXcontext
*const gc
= __glXGetCurrentContext();
9622 const GLuint cmdlen
= 16;
9623 emit_header(gc
->pc
, X_GLrop_VertexAttrib3svNV
, cmdlen
);
9624 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&index
), 4);
9625 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&x
), 2);
9626 (void) memcpy((void *) (gc
->pc
+ 10), (void *) (&y
), 2);
9627 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&z
), 2);
9629 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
9630 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
9634 #define X_GLrop_VertexAttrib3svNV 4267
9636 __indirect_glVertexAttrib3svNV(GLuint index
, const GLshort
* v
)
9638 __GLXcontext
*const gc
= __glXGetCurrentContext();
9639 const GLuint cmdlen
= 16;
9640 emit_header(gc
->pc
, X_GLrop_VertexAttrib3svNV
, cmdlen
);
9641 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&index
), 4);
9642 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (v
), 6);
9644 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
9645 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
9649 #define X_GLrop_VertexAttrib4dvNV 4276
9651 __indirect_glVertexAttrib4dNV(GLuint index
, GLdouble x
, GLdouble y
,
9652 GLdouble z
, GLdouble w
)
9654 __GLXcontext
*const gc
= __glXGetCurrentContext();
9655 const GLuint cmdlen
= 40;
9656 emit_header(gc
->pc
, X_GLrop_VertexAttrib4dvNV
, cmdlen
);
9657 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&index
), 4);
9658 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&x
), 8);
9659 (void) memcpy((void *) (gc
->pc
+ 16), (void *) (&y
), 8);
9660 (void) memcpy((void *) (gc
->pc
+ 24), (void *) (&z
), 8);
9661 (void) memcpy((void *) (gc
->pc
+ 32), (void *) (&w
), 8);
9663 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
9664 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
9668 #define X_GLrop_VertexAttrib4dvNV 4276
9670 __indirect_glVertexAttrib4dvNV(GLuint index
, const GLdouble
* v
)
9672 __GLXcontext
*const gc
= __glXGetCurrentContext();
9673 const GLuint cmdlen
= 40;
9674 emit_header(gc
->pc
, X_GLrop_VertexAttrib4dvNV
, cmdlen
);
9675 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&index
), 4);
9676 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (v
), 32);
9678 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
9679 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
9683 #define X_GLrop_VertexAttrib4fvNV 4272
9685 __indirect_glVertexAttrib4fNV(GLuint index
, GLfloat x
, GLfloat y
, GLfloat z
,
9688 __GLXcontext
*const gc
= __glXGetCurrentContext();
9689 const GLuint cmdlen
= 24;
9690 emit_header(gc
->pc
, X_GLrop_VertexAttrib4fvNV
, cmdlen
);
9691 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&index
), 4);
9692 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&x
), 4);
9693 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&y
), 4);
9694 (void) memcpy((void *) (gc
->pc
+ 16), (void *) (&z
), 4);
9695 (void) memcpy((void *) (gc
->pc
+ 20), (void *) (&w
), 4);
9697 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
9698 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
9702 #define X_GLrop_VertexAttrib4fvNV 4272
9704 __indirect_glVertexAttrib4fvNV(GLuint index
, const GLfloat
* v
)
9706 __GLXcontext
*const gc
= __glXGetCurrentContext();
9707 const GLuint cmdlen
= 24;
9708 emit_header(gc
->pc
, X_GLrop_VertexAttrib4fvNV
, cmdlen
);
9709 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&index
), 4);
9710 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (v
), 16);
9712 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
9713 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
9717 #define X_GLrop_VertexAttrib4svNV 4268
9719 __indirect_glVertexAttrib4sNV(GLuint index
, GLshort x
, GLshort y
, GLshort z
,
9722 __GLXcontext
*const gc
= __glXGetCurrentContext();
9723 const GLuint cmdlen
= 16;
9724 emit_header(gc
->pc
, X_GLrop_VertexAttrib4svNV
, cmdlen
);
9725 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&index
), 4);
9726 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&x
), 2);
9727 (void) memcpy((void *) (gc
->pc
+ 10), (void *) (&y
), 2);
9728 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&z
), 2);
9729 (void) memcpy((void *) (gc
->pc
+ 14), (void *) (&w
), 2);
9731 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
9732 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
9736 #define X_GLrop_VertexAttrib4svNV 4268
9738 __indirect_glVertexAttrib4svNV(GLuint index
, const GLshort
* v
)
9740 __GLXcontext
*const gc
= __glXGetCurrentContext();
9741 const GLuint cmdlen
= 16;
9742 emit_header(gc
->pc
, X_GLrop_VertexAttrib4svNV
, cmdlen
);
9743 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&index
), 4);
9744 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (v
), 8);
9746 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
9747 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
9751 #define X_GLrop_VertexAttrib4ubvNV 4277
9753 __indirect_glVertexAttrib4ubNV(GLuint index
, GLubyte x
, GLubyte y
, GLubyte z
,
9756 __GLXcontext
*const gc
= __glXGetCurrentContext();
9757 const GLuint cmdlen
= 12;
9758 emit_header(gc
->pc
, X_GLrop_VertexAttrib4ubvNV
, cmdlen
);
9759 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&index
), 4);
9760 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&x
), 1);
9761 (void) memcpy((void *) (gc
->pc
+ 9), (void *) (&y
), 1);
9762 (void) memcpy((void *) (gc
->pc
+ 10), (void *) (&z
), 1);
9763 (void) memcpy((void *) (gc
->pc
+ 11), (void *) (&w
), 1);
9765 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
9766 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
9770 #define X_GLrop_VertexAttrib4ubvNV 4277
9772 __indirect_glVertexAttrib4ubvNV(GLuint index
, const GLubyte
*v
)
9774 __GLXcontext
*const gc
= __glXGetCurrentContext();
9775 const GLuint cmdlen
= 12;
9776 emit_header(gc
->pc
, X_GLrop_VertexAttrib4ubvNV
, cmdlen
);
9777 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&index
), 4);
9778 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (v
), 4);
9780 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
9781 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
9785 #define X_GLrop_VertexAttribs1dvNV 4210
9787 __indirect_glVertexAttribs1dvNV(GLuint index
, GLsizei n
, const GLdouble
* v
)
9789 __GLXcontext
*const gc
= __glXGetCurrentContext();
9790 const GLuint cmdlen
= 12 + __GLX_PAD((n
* 8));
9792 __glXSetError(gc
, GL_INVALID_VALUE
);
9795 if (__builtin_expect(n
>= 0, 1)) {
9796 emit_header(gc
->pc
, X_GLrop_VertexAttribs1dvNV
, cmdlen
);
9797 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&index
), 4);
9798 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&n
), 4);
9799 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (v
), (n
* 8));
9801 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
9802 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
9807 #define X_GLrop_VertexAttribs1fvNV 4206
9809 __indirect_glVertexAttribs1fvNV(GLuint index
, GLsizei n
, const GLfloat
* v
)
9811 __GLXcontext
*const gc
= __glXGetCurrentContext();
9812 const GLuint cmdlen
= 12 + __GLX_PAD((n
* 4));
9814 __glXSetError(gc
, GL_INVALID_VALUE
);
9817 if (__builtin_expect(n
>= 0, 1)) {
9818 emit_header(gc
->pc
, X_GLrop_VertexAttribs1fvNV
, cmdlen
);
9819 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&index
), 4);
9820 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&n
), 4);
9821 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (v
), (n
* 4));
9823 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
9824 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
9829 #define X_GLrop_VertexAttribs1svNV 4202
9831 __indirect_glVertexAttribs1svNV(GLuint index
, GLsizei n
, const GLshort
* v
)
9833 __GLXcontext
*const gc
= __glXGetCurrentContext();
9834 const GLuint cmdlen
= 12 + __GLX_PAD((n
* 2));
9836 __glXSetError(gc
, GL_INVALID_VALUE
);
9839 if (__builtin_expect(n
>= 0, 1)) {
9840 emit_header(gc
->pc
, X_GLrop_VertexAttribs1svNV
, cmdlen
);
9841 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&index
), 4);
9842 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&n
), 4);
9843 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (v
), (n
* 2));
9845 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
9846 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
9851 #define X_GLrop_VertexAttribs2dvNV 4211
9853 __indirect_glVertexAttribs2dvNV(GLuint index
, GLsizei n
, const GLdouble
* v
)
9855 __GLXcontext
*const gc
= __glXGetCurrentContext();
9856 const GLuint cmdlen
= 12 + __GLX_PAD((n
* 16));
9858 __glXSetError(gc
, GL_INVALID_VALUE
);
9861 if (__builtin_expect(n
>= 0, 1)) {
9862 emit_header(gc
->pc
, X_GLrop_VertexAttribs2dvNV
, cmdlen
);
9863 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&index
), 4);
9864 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&n
), 4);
9865 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (v
), (n
* 16));
9867 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
9868 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
9873 #define X_GLrop_VertexAttribs2fvNV 4207
9875 __indirect_glVertexAttribs2fvNV(GLuint index
, GLsizei n
, const GLfloat
* v
)
9877 __GLXcontext
*const gc
= __glXGetCurrentContext();
9878 const GLuint cmdlen
= 12 + __GLX_PAD((n
* 8));
9880 __glXSetError(gc
, GL_INVALID_VALUE
);
9883 if (__builtin_expect(n
>= 0, 1)) {
9884 emit_header(gc
->pc
, X_GLrop_VertexAttribs2fvNV
, cmdlen
);
9885 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&index
), 4);
9886 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&n
), 4);
9887 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (v
), (n
* 8));
9889 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
9890 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
9895 #define X_GLrop_VertexAttribs2svNV 4203
9897 __indirect_glVertexAttribs2svNV(GLuint index
, GLsizei n
, const GLshort
* v
)
9899 __GLXcontext
*const gc
= __glXGetCurrentContext();
9900 const GLuint cmdlen
= 12 + __GLX_PAD((n
* 4));
9902 __glXSetError(gc
, GL_INVALID_VALUE
);
9905 if (__builtin_expect(n
>= 0, 1)) {
9906 emit_header(gc
->pc
, X_GLrop_VertexAttribs2svNV
, cmdlen
);
9907 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&index
), 4);
9908 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&n
), 4);
9909 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (v
), (n
* 4));
9911 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
9912 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
9917 #define X_GLrop_VertexAttribs3dvNV 4212
9919 __indirect_glVertexAttribs3dvNV(GLuint index
, GLsizei n
, const GLdouble
* v
)
9921 __GLXcontext
*const gc
= __glXGetCurrentContext();
9922 const GLuint cmdlen
= 12 + __GLX_PAD((n
* 24));
9924 __glXSetError(gc
, GL_INVALID_VALUE
);
9927 if (__builtin_expect(n
>= 0, 1)) {
9928 emit_header(gc
->pc
, X_GLrop_VertexAttribs3dvNV
, cmdlen
);
9929 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&index
), 4);
9930 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&n
), 4);
9931 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (v
), (n
* 24));
9933 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
9934 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
9939 #define X_GLrop_VertexAttribs3fvNV 4208
9941 __indirect_glVertexAttribs3fvNV(GLuint index
, GLsizei n
, const GLfloat
* v
)
9943 __GLXcontext
*const gc
= __glXGetCurrentContext();
9944 const GLuint cmdlen
= 12 + __GLX_PAD((n
* 12));
9946 __glXSetError(gc
, GL_INVALID_VALUE
);
9949 if (__builtin_expect(n
>= 0, 1)) {
9950 emit_header(gc
->pc
, X_GLrop_VertexAttribs3fvNV
, cmdlen
);
9951 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&index
), 4);
9952 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&n
), 4);
9953 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (v
), (n
* 12));
9955 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
9956 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
9961 #define X_GLrop_VertexAttribs3svNV 4204
9963 __indirect_glVertexAttribs3svNV(GLuint index
, GLsizei n
, const GLshort
* v
)
9965 __GLXcontext
*const gc
= __glXGetCurrentContext();
9966 const GLuint cmdlen
= 12 + __GLX_PAD((n
* 6));
9968 __glXSetError(gc
, GL_INVALID_VALUE
);
9971 if (__builtin_expect(n
>= 0, 1)) {
9972 emit_header(gc
->pc
, X_GLrop_VertexAttribs3svNV
, cmdlen
);
9973 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&index
), 4);
9974 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&n
), 4);
9975 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (v
), (n
* 6));
9977 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
9978 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
9983 #define X_GLrop_VertexAttribs4dvNV 4213
9985 __indirect_glVertexAttribs4dvNV(GLuint index
, GLsizei n
, const GLdouble
* v
)
9987 __GLXcontext
*const gc
= __glXGetCurrentContext();
9988 const GLuint cmdlen
= 12 + __GLX_PAD((n
* 32));
9990 __glXSetError(gc
, GL_INVALID_VALUE
);
9993 if (__builtin_expect(n
>= 0, 1)) {
9994 emit_header(gc
->pc
, X_GLrop_VertexAttribs4dvNV
, cmdlen
);
9995 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&index
), 4);
9996 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&n
), 4);
9997 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (v
), (n
* 32));
9999 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
10000 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
10005 #define X_GLrop_VertexAttribs4fvNV 4209
10007 __indirect_glVertexAttribs4fvNV(GLuint index
, GLsizei n
, const GLfloat
* v
)
10009 __GLXcontext
*const gc
= __glXGetCurrentContext();
10010 const GLuint cmdlen
= 12 + __GLX_PAD((n
* 16));
10012 __glXSetError(gc
, GL_INVALID_VALUE
);
10015 if (__builtin_expect(n
>= 0, 1)) {
10016 emit_header(gc
->pc
, X_GLrop_VertexAttribs4fvNV
, cmdlen
);
10017 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&index
), 4);
10018 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&n
), 4);
10019 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (v
), (n
* 16));
10021 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
10022 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
10027 #define X_GLrop_VertexAttribs4svNV 4205
10029 __indirect_glVertexAttribs4svNV(GLuint index
, GLsizei n
, const GLshort
* v
)
10031 __GLXcontext
*const gc
= __glXGetCurrentContext();
10032 const GLuint cmdlen
= 12 + __GLX_PAD((n
* 8));
10034 __glXSetError(gc
, GL_INVALID_VALUE
);
10037 if (__builtin_expect(n
>= 0, 1)) {
10038 emit_header(gc
->pc
, X_GLrop_VertexAttribs4svNV
, cmdlen
);
10039 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&index
), 4);
10040 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&n
), 4);
10041 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (v
), (n
* 8));
10043 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
10044 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
10049 #define X_GLrop_VertexAttribs4ubvNV 4214
10051 __indirect_glVertexAttribs4ubvNV(GLuint index
, GLsizei n
, const GLubyte
*v
)
10053 __GLXcontext
*const gc
= __glXGetCurrentContext();
10054 const GLuint cmdlen
= 12 + __GLX_PAD((n
* 4));
10056 __glXSetError(gc
, GL_INVALID_VALUE
);
10059 if (__builtin_expect(n
>= 0, 1)) {
10060 emit_header(gc
->pc
, X_GLrop_VertexAttribs4ubvNV
, cmdlen
);
10061 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&index
), 4);
10062 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&n
), 4);
10063 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (v
), (n
* 4));
10065 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
10066 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
10071 #define X_GLrop_PointParameteriNV 4221
10073 __indirect_glPointParameteriNV(GLenum pname
, GLint param
)
10075 __GLXcontext
*const gc
= __glXGetCurrentContext();
10076 const GLuint cmdlen
= 12;
10077 emit_header(gc
->pc
, X_GLrop_PointParameteriNV
, cmdlen
);
10078 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&pname
), 4);
10079 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (¶m
), 4);
10081 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
10082 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
10086 #define X_GLrop_PointParameterivNV 4222
10088 __indirect_glPointParameterivNV(GLenum pname
, const GLint
* params
)
10090 __GLXcontext
*const gc
= __glXGetCurrentContext();
10091 const GLuint compsize
= __glPointParameterivNV_size(pname
);
10092 const GLuint cmdlen
= 8 + __GLX_PAD((compsize
* 4));
10093 emit_header(gc
->pc
, X_GLrop_PointParameterivNV
, cmdlen
);
10094 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&pname
), 4);
10095 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (params
), (compsize
* 4));
10097 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
10098 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
10102 #define X_GLrop_ActiveStencilFaceEXT 4220
10104 __indirect_glActiveStencilFaceEXT(GLenum face
)
10106 __GLXcontext
*const gc
= __glXGetCurrentContext();
10107 const GLuint cmdlen
= 8;
10108 emit_header(gc
->pc
, X_GLrop_ActiveStencilFaceEXT
, cmdlen
);
10109 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&face
), 4);
10111 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
10112 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
10116 #define X_GLvop_GetProgramNamedParameterdvNV 1311
10118 __indirect_glGetProgramNamedParameterdvNV(GLuint id
, GLsizei len
,
10119 const GLubyte
*name
,
10122 __GLXcontext
*const gc
= __glXGetCurrentContext();
10123 Display
*const dpy
= gc
->currentDpy
;
10124 const GLuint cmdlen
= 8 + __GLX_PAD(len
);
10126 __glXSetError(gc
, GL_INVALID_VALUE
);
10129 if (__builtin_expect((len
>= 0) && (dpy
!= NULL
), 1)) {
10130 GLubyte
const *pc
=
10131 __glXSetupVendorRequest(gc
, X_GLXVendorPrivateWithReply
,
10132 X_GLvop_GetProgramNamedParameterdvNV
,
10134 (void) memcpy((void *) (pc
+ 0), (void *) (&id
), 4);
10135 (void) memcpy((void *) (pc
+ 4), (void *) (&len
), 4);
10136 (void) memcpy((void *) (pc
+ 8), (void *) (name
), len
);
10137 (void) __glXReadReply(dpy
, 8, params
, GL_TRUE
);
10138 UnlockDisplay(dpy
);
10144 #define X_GLvop_GetProgramNamedParameterfvNV 1310
10146 __indirect_glGetProgramNamedParameterfvNV(GLuint id
, GLsizei len
,
10147 const GLubyte
*name
,
10150 __GLXcontext
*const gc
= __glXGetCurrentContext();
10151 Display
*const dpy
= gc
->currentDpy
;
10152 const GLuint cmdlen
= 8 + __GLX_PAD(len
);
10154 __glXSetError(gc
, GL_INVALID_VALUE
);
10157 if (__builtin_expect((len
>= 0) && (dpy
!= NULL
), 1)) {
10158 GLubyte
const *pc
=
10159 __glXSetupVendorRequest(gc
, X_GLXVendorPrivateWithReply
,
10160 X_GLvop_GetProgramNamedParameterfvNV
,
10162 (void) memcpy((void *) (pc
+ 0), (void *) (&id
), 4);
10163 (void) memcpy((void *) (pc
+ 4), (void *) (&len
), 4);
10164 (void) memcpy((void *) (pc
+ 8), (void *) (name
), len
);
10165 (void) __glXReadReply(dpy
, 4, params
, GL_TRUE
);
10166 UnlockDisplay(dpy
);
10172 #define X_GLrop_ProgramNamedParameter4dvNV 4219
10174 __indirect_glProgramNamedParameter4dNV(GLuint id
, GLsizei len
,
10175 const GLubyte
*name
, GLdouble x
,
10176 GLdouble y
, GLdouble z
, GLdouble w
)
10178 __GLXcontext
*const gc
= __glXGetCurrentContext();
10179 const GLuint cmdlen
= 44 + __GLX_PAD(len
);
10181 __glXSetError(gc
, GL_INVALID_VALUE
);
10184 if (__builtin_expect(len
>= 0, 1)) {
10185 emit_header(gc
->pc
, X_GLrop_ProgramNamedParameter4dvNV
, cmdlen
);
10186 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&x
), 8);
10187 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&y
), 8);
10188 (void) memcpy((void *) (gc
->pc
+ 20), (void *) (&z
), 8);
10189 (void) memcpy((void *) (gc
->pc
+ 28), (void *) (&w
), 8);
10190 (void) memcpy((void *) (gc
->pc
+ 36), (void *) (&id
), 4);
10191 (void) memcpy((void *) (gc
->pc
+ 40), (void *) (&len
), 4);
10192 (void) memcpy((void *) (gc
->pc
+ 44), (void *) (name
), len
);
10194 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
10195 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
10200 #define X_GLrop_ProgramNamedParameter4dvNV 4219
10202 __indirect_glProgramNamedParameter4dvNV(GLuint id
, GLsizei len
,
10203 const GLubyte
*name
,
10204 const GLdouble
* v
)
10206 __GLXcontext
*const gc
= __glXGetCurrentContext();
10207 const GLuint cmdlen
= 44 + __GLX_PAD(len
);
10209 __glXSetError(gc
, GL_INVALID_VALUE
);
10212 if (__builtin_expect(len
>= 0, 1)) {
10213 emit_header(gc
->pc
, X_GLrop_ProgramNamedParameter4dvNV
, cmdlen
);
10214 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (v
), 32);
10215 (void) memcpy((void *) (gc
->pc
+ 36), (void *) (&id
), 4);
10216 (void) memcpy((void *) (gc
->pc
+ 40), (void *) (&len
), 4);
10217 (void) memcpy((void *) (gc
->pc
+ 44), (void *) (name
), len
);
10219 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
10220 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
10225 #define X_GLrop_ProgramNamedParameter4fvNV 4218
10227 __indirect_glProgramNamedParameter4fNV(GLuint id
, GLsizei len
,
10228 const GLubyte
*name
, GLfloat x
,
10229 GLfloat y
, GLfloat z
, GLfloat w
)
10231 __GLXcontext
*const gc
= __glXGetCurrentContext();
10232 const GLuint cmdlen
= 28 + __GLX_PAD(len
);
10234 __glXSetError(gc
, GL_INVALID_VALUE
);
10237 if (__builtin_expect(len
>= 0, 1)) {
10238 emit_header(gc
->pc
, X_GLrop_ProgramNamedParameter4fvNV
, cmdlen
);
10239 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&id
), 4);
10240 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&len
), 4);
10241 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&x
), 4);
10242 (void) memcpy((void *) (gc
->pc
+ 16), (void *) (&y
), 4);
10243 (void) memcpy((void *) (gc
->pc
+ 20), (void *) (&z
), 4);
10244 (void) memcpy((void *) (gc
->pc
+ 24), (void *) (&w
), 4);
10245 (void) memcpy((void *) (gc
->pc
+ 28), (void *) (name
), len
);
10247 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
10248 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
10253 #define X_GLrop_ProgramNamedParameter4fvNV 4218
10255 __indirect_glProgramNamedParameter4fvNV(GLuint id
, GLsizei len
,
10256 const GLubyte
*name
,
10259 __GLXcontext
*const gc
= __glXGetCurrentContext();
10260 const GLuint cmdlen
= 28 + __GLX_PAD(len
);
10262 __glXSetError(gc
, GL_INVALID_VALUE
);
10265 if (__builtin_expect(len
>= 0, 1)) {
10266 emit_header(gc
->pc
, X_GLrop_ProgramNamedParameter4fvNV
, cmdlen
);
10267 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&id
), 4);
10268 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&len
), 4);
10269 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (v
), 16);
10270 (void) memcpy((void *) (gc
->pc
+ 28), (void *) (name
), len
);
10272 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
10273 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
10278 #define X_GLrop_BlendEquationSeparateEXT 4228
10280 __indirect_glBlendEquationSeparateEXT(GLenum modeRGB
, GLenum modeA
)
10282 __GLXcontext
*const gc
= __glXGetCurrentContext();
10283 const GLuint cmdlen
= 12;
10284 emit_header(gc
->pc
, X_GLrop_BlendEquationSeparateEXT
, cmdlen
);
10285 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&modeRGB
), 4);
10286 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&modeA
), 4);
10288 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
10289 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
10293 #define X_GLrop_BindFramebufferEXT 4319
10295 __indirect_glBindFramebufferEXT(GLenum target
, GLuint framebuffer
)
10297 __GLXcontext
*const gc
= __glXGetCurrentContext();
10298 const GLuint cmdlen
= 12;
10299 emit_header(gc
->pc
, X_GLrop_BindFramebufferEXT
, cmdlen
);
10300 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&target
), 4);
10301 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&framebuffer
), 4);
10303 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
10304 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
10308 #define X_GLrop_BindRenderbufferEXT 4316
10310 __indirect_glBindRenderbufferEXT(GLenum target
, GLuint renderbuffer
)
10312 __GLXcontext
*const gc
= __glXGetCurrentContext();
10313 const GLuint cmdlen
= 12;
10314 emit_header(gc
->pc
, X_GLrop_BindRenderbufferEXT
, cmdlen
);
10315 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&target
), 4);
10316 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&renderbuffer
), 4);
10318 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
10319 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
10323 #define X_GLvop_CheckFramebufferStatusEXT 1427
10325 __indirect_glCheckFramebufferStatusEXT(GLenum target
)
10327 __GLXcontext
*const gc
= __glXGetCurrentContext();
10328 Display
*const dpy
= gc
->currentDpy
;
10329 GLenum retval
= (GLenum
) 0;
10330 const GLuint cmdlen
= 4;
10331 if (__builtin_expect(dpy
!= NULL
, 1)) {
10332 GLubyte
const *pc
=
10333 __glXSetupVendorRequest(gc
, X_GLXVendorPrivateWithReply
,
10334 X_GLvop_CheckFramebufferStatusEXT
,
10336 (void) memcpy((void *) (pc
+ 0), (void *) (&target
), 4);
10337 retval
= (GLenum
) __glXReadReply(dpy
, 0, NULL
, GL_FALSE
);
10338 UnlockDisplay(dpy
);
10344 #define X_GLrop_DeleteFramebuffersEXT 4320
10346 __indirect_glDeleteFramebuffersEXT(GLsizei n
, const GLuint
* framebuffers
)
10348 __GLXcontext
*const gc
= __glXGetCurrentContext();
10349 const GLuint cmdlen
= 8 + __GLX_PAD((n
* 4));
10351 __glXSetError(gc
, GL_INVALID_VALUE
);
10354 if (__builtin_expect(n
>= 0, 1)) {
10355 emit_header(gc
->pc
, X_GLrop_DeleteFramebuffersEXT
, cmdlen
);
10356 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&n
), 4);
10357 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (framebuffers
),
10360 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
10361 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
10366 #define X_GLrop_DeleteRenderbuffersEXT 4317
10368 __indirect_glDeleteRenderbuffersEXT(GLsizei n
, const GLuint
* renderbuffers
)
10370 __GLXcontext
*const gc
= __glXGetCurrentContext();
10371 const GLuint cmdlen
= 8 + __GLX_PAD((n
* 4));
10373 __glXSetError(gc
, GL_INVALID_VALUE
);
10376 if (__builtin_expect(n
>= 0, 1)) {
10377 emit_header(gc
->pc
, X_GLrop_DeleteRenderbuffersEXT
, cmdlen
);
10378 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&n
), 4);
10379 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (renderbuffers
),
10382 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
10383 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
10388 #define X_GLrop_FramebufferRenderbufferEXT 4324
10390 __indirect_glFramebufferRenderbufferEXT(GLenum target
, GLenum attachment
,
10391 GLenum renderbuffertarget
,
10392 GLuint renderbuffer
)
10394 __GLXcontext
*const gc
= __glXGetCurrentContext();
10395 const GLuint cmdlen
= 20;
10396 emit_header(gc
->pc
, X_GLrop_FramebufferRenderbufferEXT
, cmdlen
);
10397 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&target
), 4);
10398 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&attachment
), 4);
10399 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&renderbuffertarget
), 4);
10400 (void) memcpy((void *) (gc
->pc
+ 16), (void *) (&renderbuffer
), 4);
10402 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
10403 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
10407 #define X_GLrop_FramebufferTexture1DEXT 4321
10409 __indirect_glFramebufferTexture1DEXT(GLenum target
, GLenum attachment
,
10410 GLenum textarget
, GLuint texture
,
10413 __GLXcontext
*const gc
= __glXGetCurrentContext();
10414 const GLuint cmdlen
= 24;
10415 emit_header(gc
->pc
, X_GLrop_FramebufferTexture1DEXT
, cmdlen
);
10416 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&target
), 4);
10417 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&attachment
), 4);
10418 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&textarget
), 4);
10419 (void) memcpy((void *) (gc
->pc
+ 16), (void *) (&texture
), 4);
10420 (void) memcpy((void *) (gc
->pc
+ 20), (void *) (&level
), 4);
10422 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
10423 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
10427 #define X_GLrop_FramebufferTexture2DEXT 4322
10429 __indirect_glFramebufferTexture2DEXT(GLenum target
, GLenum attachment
,
10430 GLenum textarget
, GLuint texture
,
10433 __GLXcontext
*const gc
= __glXGetCurrentContext();
10434 const GLuint cmdlen
= 24;
10435 emit_header(gc
->pc
, X_GLrop_FramebufferTexture2DEXT
, cmdlen
);
10436 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&target
), 4);
10437 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&attachment
), 4);
10438 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&textarget
), 4);
10439 (void) memcpy((void *) (gc
->pc
+ 16), (void *) (&texture
), 4);
10440 (void) memcpy((void *) (gc
->pc
+ 20), (void *) (&level
), 4);
10442 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
10443 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
10447 #define X_GLrop_FramebufferTexture3DEXT 4323
10449 __indirect_glFramebufferTexture3DEXT(GLenum target
, GLenum attachment
,
10450 GLenum textarget
, GLuint texture
,
10451 GLint level
, GLint zoffset
)
10453 __GLXcontext
*const gc
= __glXGetCurrentContext();
10454 const GLuint cmdlen
= 28;
10455 emit_header(gc
->pc
, X_GLrop_FramebufferTexture3DEXT
, cmdlen
);
10456 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&target
), 4);
10457 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&attachment
), 4);
10458 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&textarget
), 4);
10459 (void) memcpy((void *) (gc
->pc
+ 16), (void *) (&texture
), 4);
10460 (void) memcpy((void *) (gc
->pc
+ 20), (void *) (&level
), 4);
10461 (void) memcpy((void *) (gc
->pc
+ 24), (void *) (&zoffset
), 4);
10463 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
10464 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
10468 #define X_GLvop_GenFramebuffersEXT 1426
10470 __indirect_glGenFramebuffersEXT(GLsizei n
, GLuint
* framebuffers
)
10472 __GLXcontext
*const gc
= __glXGetCurrentContext();
10473 Display
*const dpy
= gc
->currentDpy
;
10474 const GLuint cmdlen
= 4;
10476 __glXSetError(gc
, GL_INVALID_VALUE
);
10479 if (__builtin_expect((n
>= 0) && (dpy
!= NULL
), 1)) {
10480 GLubyte
const *pc
=
10481 __glXSetupVendorRequest(gc
, X_GLXVendorPrivateWithReply
,
10482 X_GLvop_GenFramebuffersEXT
, cmdlen
);
10483 (void) memcpy((void *) (pc
+ 0), (void *) (&n
), 4);
10484 (void) __glXReadReply(dpy
, 4, framebuffers
, GL_TRUE
);
10485 UnlockDisplay(dpy
);
10491 #define X_GLvop_GenRenderbuffersEXT 1423
10493 __indirect_glGenRenderbuffersEXT(GLsizei n
, GLuint
* renderbuffers
)
10495 __GLXcontext
*const gc
= __glXGetCurrentContext();
10496 Display
*const dpy
= gc
->currentDpy
;
10497 const GLuint cmdlen
= 4;
10499 __glXSetError(gc
, GL_INVALID_VALUE
);
10502 if (__builtin_expect((n
>= 0) && (dpy
!= NULL
), 1)) {
10503 GLubyte
const *pc
=
10504 __glXSetupVendorRequest(gc
, X_GLXVendorPrivateWithReply
,
10505 X_GLvop_GenRenderbuffersEXT
, cmdlen
);
10506 (void) memcpy((void *) (pc
+ 0), (void *) (&n
), 4);
10507 (void) __glXReadReply(dpy
, 4, renderbuffers
, GL_TRUE
);
10508 UnlockDisplay(dpy
);
10514 #define X_GLrop_GenerateMipmapEXT 4325
10516 __indirect_glGenerateMipmapEXT(GLenum target
)
10518 __GLXcontext
*const gc
= __glXGetCurrentContext();
10519 const GLuint cmdlen
= 8;
10520 emit_header(gc
->pc
, X_GLrop_GenerateMipmapEXT
, cmdlen
);
10521 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&target
), 4);
10523 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
10524 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
10528 #define X_GLvop_GetFramebufferAttachmentParameterivEXT 1428
10530 __indirect_glGetFramebufferAttachmentParameterivEXT(GLenum target
,
10535 __GLXcontext
*const gc
= __glXGetCurrentContext();
10536 Display
*const dpy
= gc
->currentDpy
;
10537 const GLuint cmdlen
= 12;
10538 if (__builtin_expect(dpy
!= NULL
, 1)) {
10539 GLubyte
const *pc
=
10540 __glXSetupVendorRequest(gc
, X_GLXVendorPrivateWithReply
,
10541 X_GLvop_GetFramebufferAttachmentParameterivEXT
,
10543 (void) memcpy((void *) (pc
+ 0), (void *) (&target
), 4);
10544 (void) memcpy((void *) (pc
+ 4), (void *) (&attachment
), 4);
10545 (void) memcpy((void *) (pc
+ 8), (void *) (&pname
), 4);
10546 (void) __glXReadReply(dpy
, 4, params
, GL_FALSE
);
10547 UnlockDisplay(dpy
);
10553 #define X_GLvop_GetRenderbufferParameterivEXT 1424
10555 __indirect_glGetRenderbufferParameterivEXT(GLenum target
, GLenum pname
,
10558 __GLXcontext
*const gc
= __glXGetCurrentContext();
10559 Display
*const dpy
= gc
->currentDpy
;
10560 const GLuint cmdlen
= 8;
10561 if (__builtin_expect(dpy
!= NULL
, 1)) {
10562 GLubyte
const *pc
=
10563 __glXSetupVendorRequest(gc
, X_GLXVendorPrivateWithReply
,
10564 X_GLvop_GetRenderbufferParameterivEXT
,
10566 (void) memcpy((void *) (pc
+ 0), (void *) (&target
), 4);
10567 (void) memcpy((void *) (pc
+ 4), (void *) (&pname
), 4);
10568 (void) __glXReadReply(dpy
, 4, params
, GL_FALSE
);
10569 UnlockDisplay(dpy
);
10575 #define X_GLvop_IsFramebufferEXT 1425
10577 __indirect_glIsFramebufferEXT(GLuint framebuffer
)
10579 __GLXcontext
*const gc
= __glXGetCurrentContext();
10580 Display
*const dpy
= gc
->currentDpy
;
10581 GLboolean retval
= (GLboolean
) 0;
10582 const GLuint cmdlen
= 4;
10583 if (__builtin_expect(dpy
!= NULL
, 1)) {
10584 GLubyte
const *pc
=
10585 __glXSetupVendorRequest(gc
, X_GLXVendorPrivateWithReply
,
10586 X_GLvop_IsFramebufferEXT
, cmdlen
);
10587 (void) memcpy((void *) (pc
+ 0), (void *) (&framebuffer
), 4);
10588 retval
= (GLboolean
) __glXReadReply(dpy
, 0, NULL
, GL_FALSE
);
10589 UnlockDisplay(dpy
);
10595 #define X_GLvop_IsRenderbufferEXT 1422
10597 __indirect_glIsRenderbufferEXT(GLuint renderbuffer
)
10599 __GLXcontext
*const gc
= __glXGetCurrentContext();
10600 Display
*const dpy
= gc
->currentDpy
;
10601 GLboolean retval
= (GLboolean
) 0;
10602 const GLuint cmdlen
= 4;
10603 if (__builtin_expect(dpy
!= NULL
, 1)) {
10604 GLubyte
const *pc
=
10605 __glXSetupVendorRequest(gc
, X_GLXVendorPrivateWithReply
,
10606 X_GLvop_IsRenderbufferEXT
, cmdlen
);
10607 (void) memcpy((void *) (pc
+ 0), (void *) (&renderbuffer
), 4);
10608 retval
= (GLboolean
) __glXReadReply(dpy
, 0, NULL
, GL_FALSE
);
10609 UnlockDisplay(dpy
);
10615 #define X_GLrop_RenderbufferStorageEXT 4318
10617 __indirect_glRenderbufferStorageEXT(GLenum target
, GLenum internalformat
,
10618 GLsizei width
, GLsizei height
)
10620 __GLXcontext
*const gc
= __glXGetCurrentContext();
10621 const GLuint cmdlen
= 20;
10622 emit_header(gc
->pc
, X_GLrop_RenderbufferStorageEXT
, cmdlen
);
10623 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&target
), 4);
10624 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&internalformat
), 4);
10625 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&width
), 4);
10626 (void) memcpy((void *) (gc
->pc
+ 16), (void *) (&height
), 4);
10628 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
10629 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);