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"
35 #include <GL/glxproto.h>
37 #include <X11/Xlib-xcb.h>
42 #define __GLX_PAD(n) (((n) + 3) & ~3)
44 #if defined(__i386__) && defined(__GNUC__) && !defined(__CYGWIN__) && !defined(__MINGW32__)
45 #define FASTCALL __attribute__((fastcall))
49 #if defined(__GNUC__) || (defined(__SUNPRO_C) && (__SUNPRO_C >= 0x590))
50 #define NOINLINE __attribute__((noinline))
56 #define __builtin_expect(x, y) x
59 /* If the size and opcode values are known at compile-time, this will, on
60 * x86 at least, emit them with a single instruction.
62 #define emit_header(dest, op, size) \
63 do { union { short s[2]; int i; } temp; \
64 temp.s[0] = (size); temp.s[1] = (op); \
65 *((int *)(dest)) = temp.i; } while(0)
68 __glXReadReply(Display
* dpy
, size_t size
, void *dest
,
69 GLboolean reply_is_always_array
)
71 xGLXSingleReply reply
;
73 (void) _XReply(dpy
, (xReply
*) & reply
, 0, False
);
75 if ((reply
.length
> 0) || reply_is_always_array
) {
76 const GLint bytes
= (reply_is_always_array
)
77 ? (4 * reply
.length
) : (reply
.size
* size
);
78 const GLint extra
= 4 - (bytes
& 3);
80 _XRead(dpy
, dest
, bytes
);
82 _XEatData(dpy
, extra
);
85 (void) memcpy(dest
, &(reply
.pad3
), size
);
93 __glXReadPixelReply(Display
* dpy
, struct glx_context
*gc
, unsigned max_dim
,
94 GLint width
, GLint height
, GLint depth
, GLenum format
,
95 GLenum type
, void *dest
, GLboolean dimensions_in_reply
)
97 xGLXSingleReply reply
;
100 (void) _XReply(dpy
, (xReply
*) & reply
, 0, False
);
102 if (dimensions_in_reply
) {
107 if ((height
== 0) || (max_dim
< 2)) {
110 if ((depth
== 0) || (max_dim
< 3)) {
115 size
= reply
.length
* 4;
117 void *buf
= Xmalloc(size
);
120 _XEatData(dpy
, size
);
121 __glXSetError(gc
, GL_OUT_OF_MEMORY
);
123 const GLint extra
= 4 - (size
& 3);
125 _XRead(dpy
, buf
, size
);
127 _XEatData(dpy
, extra
);
130 __glEmptyImage(gc
, 3, width
, height
, depth
, format
, type
,
137 #define X_GLXSingle 0
139 NOINLINE FASTCALL GLubyte
*
140 __glXSetupSingleRequest(struct glx_context
*gc
, GLint sop
, GLint cmdlen
)
143 Display
*const dpy
= gc
->currentDpy
;
145 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
147 GetReqExtra(GLXSingle
, cmdlen
, req
);
148 req
->reqType
= gc
->majorOpcode
;
149 req
->contextTag
= gc
->currentContextTag
;
151 return (GLubyte
*) (req
) + sz_xGLXSingleReq
;
154 NOINLINE FASTCALL GLubyte
*
155 __glXSetupVendorRequest(struct glx_context
*gc
, GLint code
, GLint vop
,
158 xGLXVendorPrivateReq
*req
;
159 Display
*const dpy
= gc
->currentDpy
;
161 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
163 GetReqExtra(GLXVendorPrivate
, cmdlen
, req
);
164 req
->reqType
= gc
->majorOpcode
;
166 req
->vendorCode
= vop
;
167 req
->contextTag
= gc
->currentContextTag
;
168 return (GLubyte
*) (req
) + sz_xGLXVendorPrivateReq
;
171 const GLuint __glXDefaultPixelStore
[9] = { 0, 0, 0, 0, 0, 0, 0, 0, 1 };
173 #define zero (__glXDefaultPixelStore+0)
174 #define one (__glXDefaultPixelStore+8)
175 #define default_pixel_store_1D (__glXDefaultPixelStore+4)
176 #define default_pixel_store_1D_size 20
177 #define default_pixel_store_2D (__glXDefaultPixelStore+4)
178 #define default_pixel_store_2D_size 20
179 #define default_pixel_store_3D (__glXDefaultPixelStore+0)
180 #define default_pixel_store_3D_size 36
181 #define default_pixel_store_4D (__glXDefaultPixelStore+0)
182 #define default_pixel_store_4D_size 36
184 static FASTCALL NOINLINE
void
185 generic_3_byte(GLint rop
, const void *ptr
)
187 struct glx_context
*const gc
= __glXGetCurrentContext();
188 const GLuint cmdlen
= 8;
190 emit_header(gc
->pc
, rop
, cmdlen
);
191 (void) memcpy((void *) (gc
->pc
+ 4), ptr
, 4);
193 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
194 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
198 static FASTCALL NOINLINE
void
199 generic_4_byte(GLint rop
, const void *ptr
)
201 struct glx_context
*const gc
= __glXGetCurrentContext();
202 const GLuint cmdlen
= 8;
204 emit_header(gc
->pc
, rop
, cmdlen
);
205 (void) memcpy((void *) (gc
->pc
+ 4), ptr
, 4);
207 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
208 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
212 static FASTCALL NOINLINE
void
213 generic_6_byte(GLint rop
, const void *ptr
)
215 struct glx_context
*const gc
= __glXGetCurrentContext();
216 const GLuint cmdlen
= 12;
218 emit_header(gc
->pc
, rop
, cmdlen
);
219 (void) memcpy((void *) (gc
->pc
+ 4), ptr
, 8);
221 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
222 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
226 static FASTCALL NOINLINE
void
227 generic_8_byte(GLint rop
, const void *ptr
)
229 struct glx_context
*const gc
= __glXGetCurrentContext();
230 const GLuint cmdlen
= 12;
232 emit_header(gc
->pc
, rop
, cmdlen
);
233 (void) memcpy((void *) (gc
->pc
+ 4), ptr
, 8);
235 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
236 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
240 static FASTCALL NOINLINE
void
241 generic_12_byte(GLint rop
, const void *ptr
)
243 struct glx_context
*const gc
= __glXGetCurrentContext();
244 const GLuint cmdlen
= 16;
246 emit_header(gc
->pc
, rop
, cmdlen
);
247 (void) memcpy((void *) (gc
->pc
+ 4), ptr
, 12);
249 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
250 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
254 static FASTCALL NOINLINE
void
255 generic_16_byte(GLint rop
, const void *ptr
)
257 struct glx_context
*const gc
= __glXGetCurrentContext();
258 const GLuint cmdlen
= 20;
260 emit_header(gc
->pc
, rop
, cmdlen
);
261 (void) memcpy((void *) (gc
->pc
+ 4), ptr
, 16);
263 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
264 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
268 static FASTCALL NOINLINE
void
269 generic_24_byte(GLint rop
, const void *ptr
)
271 struct glx_context
*const gc
= __glXGetCurrentContext();
272 const GLuint cmdlen
= 28;
274 emit_header(gc
->pc
, rop
, cmdlen
);
275 (void) memcpy((void *) (gc
->pc
+ 4), ptr
, 24);
277 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
278 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
282 static FASTCALL NOINLINE
void
283 generic_32_byte(GLint rop
, const void *ptr
)
285 struct glx_context
*const gc
= __glXGetCurrentContext();
286 const GLuint cmdlen
= 36;
288 emit_header(gc
->pc
, rop
, cmdlen
);
289 (void) memcpy((void *) (gc
->pc
+ 4), ptr
, 32);
291 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
292 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
296 #define X_GLsop_NewList 101
298 __indirect_glNewList(GLuint list
, GLenum mode
)
300 struct glx_context
*const gc
= __glXGetCurrentContext();
301 Display
*const dpy
= gc
->currentDpy
;
303 const GLuint cmdlen
= 8;
305 if (__builtin_expect(dpy
!= NULL
, 1)) {
307 xcb_connection_t
*c
= XGetXCBConnection(dpy
);
308 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
309 xcb_glx_new_list(c
, gc
->currentContextTag
, list
, mode
);
312 __glXSetupSingleRequest(gc
, X_GLsop_NewList
, cmdlen
);
313 (void) memcpy((void *) (pc
+ 0), (void *) (&list
), 4);
314 (void) memcpy((void *) (pc
+ 4), (void *) (&mode
), 4);
322 #define X_GLsop_EndList 102
324 __indirect_glEndList(void)
326 struct glx_context
*const gc
= __glXGetCurrentContext();
327 Display
*const dpy
= gc
->currentDpy
;
329 const GLuint cmdlen
= 0;
331 if (__builtin_expect(dpy
!= NULL
, 1)) {
333 xcb_connection_t
*c
= XGetXCBConnection(dpy
);
334 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
335 xcb_glx_end_list(c
, gc
->currentContextTag
);
337 (void) __glXSetupSingleRequest(gc
, X_GLsop_EndList
, cmdlen
);
345 #define X_GLrop_CallList 1
347 __indirect_glCallList(GLuint list
)
349 struct glx_context
*const gc
= __glXGetCurrentContext();
350 const GLuint cmdlen
= 8;
351 emit_header(gc
->pc
, X_GLrop_CallList
, cmdlen
);
352 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&list
), 4);
354 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
355 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
359 #define X_GLrop_CallLists 2
361 __indirect_glCallLists(GLsizei n
, GLenum type
, const GLvoid
* lists
)
363 struct glx_context
*const gc
= __glXGetCurrentContext();
364 const GLuint compsize
= __glCallLists_size(type
);
365 const GLuint cmdlen
= 12 + __GLX_PAD((compsize
* n
));
367 __glXSetError(gc
, GL_INVALID_VALUE
);
370 if (__builtin_expect((n
>= 0) && (gc
->currentDpy
!= NULL
), 1)) {
371 if (cmdlen
<= gc
->maxSmallRenderCommandSize
) {
372 if ((gc
->pc
+ cmdlen
) > gc
->bufEnd
) {
373 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
375 emit_header(gc
->pc
, X_GLrop_CallLists
, cmdlen
);
376 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&n
), 4);
377 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&type
), 4);
378 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (lists
),
381 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
382 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
385 const GLint op
= X_GLrop_CallLists
;
386 const GLuint cmdlenLarge
= cmdlen
+ 4;
387 GLubyte
*const pc
= __glXFlushRenderBuffer(gc
, gc
->pc
);
388 (void) memcpy((void *) (pc
+ 0), (void *) (&cmdlenLarge
), 4);
389 (void) memcpy((void *) (pc
+ 4), (void *) (&op
), 4);
390 (void) memcpy((void *) (pc
+ 8), (void *) (&n
), 4);
391 (void) memcpy((void *) (pc
+ 12), (void *) (&type
), 4);
392 __glXSendLargeCommand(gc
, pc
, 16, lists
, (compsize
* n
));
397 #define X_GLsop_DeleteLists 103
399 __indirect_glDeleteLists(GLuint list
, GLsizei range
)
401 struct glx_context
*const gc
= __glXGetCurrentContext();
402 Display
*const dpy
= gc
->currentDpy
;
404 const GLuint cmdlen
= 8;
406 if (__builtin_expect(dpy
!= NULL
, 1)) {
408 xcb_connection_t
*c
= XGetXCBConnection(dpy
);
409 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
410 xcb_glx_delete_lists(c
, gc
->currentContextTag
, list
, range
);
413 __glXSetupSingleRequest(gc
, X_GLsop_DeleteLists
, cmdlen
);
414 (void) memcpy((void *) (pc
+ 0), (void *) (&list
), 4);
415 (void) memcpy((void *) (pc
+ 4), (void *) (&range
), 4);
423 #define X_GLsop_GenLists 104
425 __indirect_glGenLists(GLsizei range
)
427 struct glx_context
*const gc
= __glXGetCurrentContext();
428 Display
*const dpy
= gc
->currentDpy
;
429 GLuint retval
= (GLuint
) 0;
431 const GLuint cmdlen
= 4;
433 if (__builtin_expect(dpy
!= NULL
, 1)) {
435 xcb_connection_t
*c
= XGetXCBConnection(dpy
);
436 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
437 xcb_glx_gen_lists_reply_t
*reply
=
438 xcb_glx_gen_lists_reply(c
,
440 gc
->currentContextTag
,
442 retval
= reply
->ret_val
;
446 __glXSetupSingleRequest(gc
, X_GLsop_GenLists
, cmdlen
);
447 (void) memcpy((void *) (pc
+ 0), (void *) (&range
), 4);
448 retval
= (GLuint
) __glXReadReply(dpy
, 0, NULL
, GL_FALSE
);
456 #define X_GLrop_ListBase 3
458 __indirect_glListBase(GLuint base
)
460 struct glx_context
*const gc
= __glXGetCurrentContext();
461 const GLuint cmdlen
= 8;
462 emit_header(gc
->pc
, X_GLrop_ListBase
, cmdlen
);
463 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&base
), 4);
465 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
466 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
470 #define X_GLrop_Begin 4
472 __indirect_glBegin(GLenum mode
)
474 struct glx_context
*const gc
= __glXGetCurrentContext();
475 const GLuint cmdlen
= 8;
476 emit_header(gc
->pc
, X_GLrop_Begin
, cmdlen
);
477 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&mode
), 4);
479 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
480 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
484 #define X_GLrop_Bitmap 5
486 __indirect_glBitmap(GLsizei width
, GLsizei height
, GLfloat xorig
,
487 GLfloat yorig
, GLfloat xmove
, GLfloat ymove
,
488 const GLubyte
*bitmap
)
490 struct glx_context
*const gc
= __glXGetCurrentContext();
491 const GLuint compsize
=
492 (bitmap
!= NULL
) ? __glImageSize(width
, height
, 1, GL_COLOR_INDEX
,
494 const GLuint cmdlen
= 48 + __GLX_PAD(compsize
);
495 if (__builtin_expect(gc
->currentDpy
!= NULL
, 1)) {
496 if (cmdlen
<= gc
->maxSmallRenderCommandSize
) {
497 if ((gc
->pc
+ cmdlen
) > gc
->bufEnd
) {
498 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
500 emit_header(gc
->pc
, X_GLrop_Bitmap
, cmdlen
);
501 (void) memcpy((void *) (gc
->pc
+ 24), (void *) (&width
), 4);
502 (void) memcpy((void *) (gc
->pc
+ 28), (void *) (&height
), 4);
503 (void) memcpy((void *) (gc
->pc
+ 32), (void *) (&xorig
), 4);
504 (void) memcpy((void *) (gc
->pc
+ 36), (void *) (&yorig
), 4);
505 (void) memcpy((void *) (gc
->pc
+ 40), (void *) (&xmove
), 4);
506 (void) memcpy((void *) (gc
->pc
+ 44), (void *) (&ymove
), 4);
508 (*gc
->fillImage
) (gc
, 2, width
, height
, 1, GL_COLOR_INDEX
,
509 GL_BITMAP
, bitmap
, gc
->pc
+ 48, gc
->pc
+ 4);
511 (void) memcpy(gc
->pc
+ 4, default_pixel_store_2D
,
512 default_pixel_store_2D_size
);
515 if (gc
->pc
> gc
->limit
) {
516 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
519 const GLint op
= X_GLrop_Bitmap
;
520 const GLuint cmdlenLarge
= cmdlen
+ 4;
521 GLubyte
*const pc
= __glXFlushRenderBuffer(gc
, gc
->pc
);
522 (void) memcpy((void *) (pc
+ 0), (void *) (&cmdlenLarge
), 4);
523 (void) memcpy((void *) (pc
+ 4), (void *) (&op
), 4);
524 (void) memcpy((void *) (pc
+ 28), (void *) (&width
), 4);
525 (void) memcpy((void *) (pc
+ 32), (void *) (&height
), 4);
526 (void) memcpy((void *) (pc
+ 36), (void *) (&xorig
), 4);
527 (void) memcpy((void *) (pc
+ 40), (void *) (&yorig
), 4);
528 (void) memcpy((void *) (pc
+ 44), (void *) (&xmove
), 4);
529 (void) memcpy((void *) (pc
+ 48), (void *) (&ymove
), 4);
530 __glXSendLargeImage(gc
, compsize
, 2, width
, height
, 1,
531 GL_COLOR_INDEX
, GL_BITMAP
, bitmap
, pc
+ 52,
537 #define X_GLrop_Color3bv 6
539 __indirect_glColor3b(GLbyte red
, GLbyte green
, GLbyte blue
)
541 struct glx_context
*const gc
= __glXGetCurrentContext();
542 const GLuint cmdlen
= 8;
543 emit_header(gc
->pc
, X_GLrop_Color3bv
, cmdlen
);
544 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&red
), 1);
545 (void) memcpy((void *) (gc
->pc
+ 5), (void *) (&green
), 1);
546 (void) memcpy((void *) (gc
->pc
+ 6), (void *) (&blue
), 1);
548 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
549 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
553 #define X_GLrop_Color3bv 6
555 __indirect_glColor3bv(const GLbyte
*v
)
557 generic_3_byte(X_GLrop_Color3bv
, v
);
560 #define X_GLrop_Color3dv 7
562 __indirect_glColor3d(GLdouble red
, GLdouble green
, GLdouble blue
)
564 struct glx_context
*const gc
= __glXGetCurrentContext();
565 const GLuint cmdlen
= 28;
566 emit_header(gc
->pc
, X_GLrop_Color3dv
, cmdlen
);
567 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&red
), 8);
568 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&green
), 8);
569 (void) memcpy((void *) (gc
->pc
+ 20), (void *) (&blue
), 8);
571 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
572 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
576 #define X_GLrop_Color3dv 7
578 __indirect_glColor3dv(const GLdouble
* v
)
580 generic_24_byte(X_GLrop_Color3dv
, v
);
583 #define X_GLrop_Color3fv 8
585 __indirect_glColor3f(GLfloat red
, GLfloat green
, GLfloat blue
)
587 struct glx_context
*const gc
= __glXGetCurrentContext();
588 const GLuint cmdlen
= 16;
589 emit_header(gc
->pc
, X_GLrop_Color3fv
, cmdlen
);
590 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&red
), 4);
591 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&green
), 4);
592 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&blue
), 4);
594 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
595 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
599 #define X_GLrop_Color3fv 8
601 __indirect_glColor3fv(const GLfloat
* v
)
603 generic_12_byte(X_GLrop_Color3fv
, v
);
606 #define X_GLrop_Color3iv 9
608 __indirect_glColor3i(GLint red
, GLint green
, GLint blue
)
610 struct glx_context
*const gc
= __glXGetCurrentContext();
611 const GLuint cmdlen
= 16;
612 emit_header(gc
->pc
, X_GLrop_Color3iv
, cmdlen
);
613 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&red
), 4);
614 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&green
), 4);
615 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&blue
), 4);
617 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
618 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
622 #define X_GLrop_Color3iv 9
624 __indirect_glColor3iv(const GLint
* v
)
626 generic_12_byte(X_GLrop_Color3iv
, v
);
629 #define X_GLrop_Color3sv 10
631 __indirect_glColor3s(GLshort red
, GLshort green
, GLshort blue
)
633 struct glx_context
*const gc
= __glXGetCurrentContext();
634 const GLuint cmdlen
= 12;
635 emit_header(gc
->pc
, X_GLrop_Color3sv
, cmdlen
);
636 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&red
), 2);
637 (void) memcpy((void *) (gc
->pc
+ 6), (void *) (&green
), 2);
638 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&blue
), 2);
640 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
641 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
645 #define X_GLrop_Color3sv 10
647 __indirect_glColor3sv(const GLshort
* v
)
649 generic_6_byte(X_GLrop_Color3sv
, v
);
652 #define X_GLrop_Color3ubv 11
654 __indirect_glColor3ub(GLubyte red
, GLubyte green
, GLubyte blue
)
656 struct glx_context
*const gc
= __glXGetCurrentContext();
657 const GLuint cmdlen
= 8;
658 emit_header(gc
->pc
, X_GLrop_Color3ubv
, cmdlen
);
659 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&red
), 1);
660 (void) memcpy((void *) (gc
->pc
+ 5), (void *) (&green
), 1);
661 (void) memcpy((void *) (gc
->pc
+ 6), (void *) (&blue
), 1);
663 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
664 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
668 #define X_GLrop_Color3ubv 11
670 __indirect_glColor3ubv(const GLubyte
*v
)
672 generic_3_byte(X_GLrop_Color3ubv
, v
);
675 #define X_GLrop_Color3uiv 12
677 __indirect_glColor3ui(GLuint red
, GLuint green
, GLuint blue
)
679 struct glx_context
*const gc
= __glXGetCurrentContext();
680 const GLuint cmdlen
= 16;
681 emit_header(gc
->pc
, X_GLrop_Color3uiv
, cmdlen
);
682 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&red
), 4);
683 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&green
), 4);
684 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&blue
), 4);
686 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
687 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
691 #define X_GLrop_Color3uiv 12
693 __indirect_glColor3uiv(const GLuint
* v
)
695 generic_12_byte(X_GLrop_Color3uiv
, v
);
698 #define X_GLrop_Color3usv 13
700 __indirect_glColor3us(GLushort red
, GLushort green
, GLushort blue
)
702 struct glx_context
*const gc
= __glXGetCurrentContext();
703 const GLuint cmdlen
= 12;
704 emit_header(gc
->pc
, X_GLrop_Color3usv
, cmdlen
);
705 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&red
), 2);
706 (void) memcpy((void *) (gc
->pc
+ 6), (void *) (&green
), 2);
707 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&blue
), 2);
709 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
710 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
714 #define X_GLrop_Color3usv 13
716 __indirect_glColor3usv(const GLushort
* v
)
718 generic_6_byte(X_GLrop_Color3usv
, v
);
721 #define X_GLrop_Color4bv 14
723 __indirect_glColor4b(GLbyte red
, GLbyte green
, GLbyte blue
, GLbyte alpha
)
725 struct glx_context
*const gc
= __glXGetCurrentContext();
726 const GLuint cmdlen
= 8;
727 emit_header(gc
->pc
, X_GLrop_Color4bv
, cmdlen
);
728 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&red
), 1);
729 (void) memcpy((void *) (gc
->pc
+ 5), (void *) (&green
), 1);
730 (void) memcpy((void *) (gc
->pc
+ 6), (void *) (&blue
), 1);
731 (void) memcpy((void *) (gc
->pc
+ 7), (void *) (&alpha
), 1);
733 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
734 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
738 #define X_GLrop_Color4bv 14
740 __indirect_glColor4bv(const GLbyte
*v
)
742 generic_4_byte(X_GLrop_Color4bv
, v
);
745 #define X_GLrop_Color4dv 15
747 __indirect_glColor4d(GLdouble red
, GLdouble green
, GLdouble blue
,
750 struct glx_context
*const gc
= __glXGetCurrentContext();
751 const GLuint cmdlen
= 36;
752 emit_header(gc
->pc
, X_GLrop_Color4dv
, cmdlen
);
753 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&red
), 8);
754 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&green
), 8);
755 (void) memcpy((void *) (gc
->pc
+ 20), (void *) (&blue
), 8);
756 (void) memcpy((void *) (gc
->pc
+ 28), (void *) (&alpha
), 8);
758 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
759 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
763 #define X_GLrop_Color4dv 15
765 __indirect_glColor4dv(const GLdouble
* v
)
767 generic_32_byte(X_GLrop_Color4dv
, v
);
770 #define X_GLrop_Color4fv 16
772 __indirect_glColor4f(GLfloat red
, GLfloat green
, GLfloat blue
, GLfloat alpha
)
774 struct glx_context
*const gc
= __glXGetCurrentContext();
775 const GLuint cmdlen
= 20;
776 emit_header(gc
->pc
, X_GLrop_Color4fv
, cmdlen
);
777 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&red
), 4);
778 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&green
), 4);
779 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&blue
), 4);
780 (void) memcpy((void *) (gc
->pc
+ 16), (void *) (&alpha
), 4);
782 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
783 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
787 #define X_GLrop_Color4fv 16
789 __indirect_glColor4fv(const GLfloat
* v
)
791 generic_16_byte(X_GLrop_Color4fv
, v
);
794 #define X_GLrop_Color4iv 17
796 __indirect_glColor4i(GLint red
, GLint green
, GLint blue
, GLint alpha
)
798 struct glx_context
*const gc
= __glXGetCurrentContext();
799 const GLuint cmdlen
= 20;
800 emit_header(gc
->pc
, X_GLrop_Color4iv
, cmdlen
);
801 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&red
), 4);
802 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&green
), 4);
803 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&blue
), 4);
804 (void) memcpy((void *) (gc
->pc
+ 16), (void *) (&alpha
), 4);
806 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
807 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
811 #define X_GLrop_Color4iv 17
813 __indirect_glColor4iv(const GLint
* v
)
815 generic_16_byte(X_GLrop_Color4iv
, v
);
818 #define X_GLrop_Color4sv 18
820 __indirect_glColor4s(GLshort red
, GLshort green
, GLshort blue
, GLshort alpha
)
822 struct glx_context
*const gc
= __glXGetCurrentContext();
823 const GLuint cmdlen
= 12;
824 emit_header(gc
->pc
, X_GLrop_Color4sv
, cmdlen
);
825 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&red
), 2);
826 (void) memcpy((void *) (gc
->pc
+ 6), (void *) (&green
), 2);
827 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&blue
), 2);
828 (void) memcpy((void *) (gc
->pc
+ 10), (void *) (&alpha
), 2);
830 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
831 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
835 #define X_GLrop_Color4sv 18
837 __indirect_glColor4sv(const GLshort
* v
)
839 generic_8_byte(X_GLrop_Color4sv
, v
);
842 #define X_GLrop_Color4ubv 19
844 __indirect_glColor4ub(GLubyte red
, GLubyte green
, GLubyte blue
, GLubyte alpha
)
846 struct glx_context
*const gc
= __glXGetCurrentContext();
847 const GLuint cmdlen
= 8;
848 emit_header(gc
->pc
, X_GLrop_Color4ubv
, cmdlen
);
849 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&red
), 1);
850 (void) memcpy((void *) (gc
->pc
+ 5), (void *) (&green
), 1);
851 (void) memcpy((void *) (gc
->pc
+ 6), (void *) (&blue
), 1);
852 (void) memcpy((void *) (gc
->pc
+ 7), (void *) (&alpha
), 1);
854 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
855 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
859 #define X_GLrop_Color4ubv 19
861 __indirect_glColor4ubv(const GLubyte
*v
)
863 generic_4_byte(X_GLrop_Color4ubv
, v
);
866 #define X_GLrop_Color4uiv 20
868 __indirect_glColor4ui(GLuint red
, GLuint green
, GLuint blue
, GLuint alpha
)
870 struct glx_context
*const gc
= __glXGetCurrentContext();
871 const GLuint cmdlen
= 20;
872 emit_header(gc
->pc
, X_GLrop_Color4uiv
, cmdlen
);
873 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&red
), 4);
874 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&green
), 4);
875 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&blue
), 4);
876 (void) memcpy((void *) (gc
->pc
+ 16), (void *) (&alpha
), 4);
878 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
879 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
883 #define X_GLrop_Color4uiv 20
885 __indirect_glColor4uiv(const GLuint
* v
)
887 generic_16_byte(X_GLrop_Color4uiv
, v
);
890 #define X_GLrop_Color4usv 21
892 __indirect_glColor4us(GLushort red
, GLushort green
, GLushort blue
,
895 struct glx_context
*const gc
= __glXGetCurrentContext();
896 const GLuint cmdlen
= 12;
897 emit_header(gc
->pc
, X_GLrop_Color4usv
, cmdlen
);
898 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&red
), 2);
899 (void) memcpy((void *) (gc
->pc
+ 6), (void *) (&green
), 2);
900 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&blue
), 2);
901 (void) memcpy((void *) (gc
->pc
+ 10), (void *) (&alpha
), 2);
903 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
904 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
908 #define X_GLrop_Color4usv 21
910 __indirect_glColor4usv(const GLushort
* v
)
912 generic_8_byte(X_GLrop_Color4usv
, v
);
915 #define X_GLrop_EdgeFlagv 22
917 __indirect_glEdgeFlag(GLboolean flag
)
919 struct glx_context
*const gc
= __glXGetCurrentContext();
920 const GLuint cmdlen
= 8;
921 emit_header(gc
->pc
, X_GLrop_EdgeFlagv
, cmdlen
);
922 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&flag
), 1);
924 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
925 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
929 #define X_GLrop_EdgeFlagv 22
931 __indirect_glEdgeFlagv(const GLboolean
* flag
)
933 struct glx_context
*const gc
= __glXGetCurrentContext();
934 const GLuint cmdlen
= 8;
935 emit_header(gc
->pc
, X_GLrop_EdgeFlagv
, cmdlen
);
936 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (flag
), 1);
938 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
939 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
943 #define X_GLrop_End 23
945 __indirect_glEnd(void)
947 struct glx_context
*const gc
= __glXGetCurrentContext();
948 const GLuint cmdlen
= 4;
949 emit_header(gc
->pc
, X_GLrop_End
, cmdlen
);
951 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
952 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
956 #define X_GLrop_Indexdv 24
958 __indirect_glIndexd(GLdouble c
)
960 struct glx_context
*const gc
= __glXGetCurrentContext();
961 const GLuint cmdlen
= 12;
962 emit_header(gc
->pc
, X_GLrop_Indexdv
, cmdlen
);
963 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&c
), 8);
965 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
966 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
970 #define X_GLrop_Indexdv 24
972 __indirect_glIndexdv(const GLdouble
* c
)
974 generic_8_byte(X_GLrop_Indexdv
, c
);
977 #define X_GLrop_Indexfv 25
979 __indirect_glIndexf(GLfloat c
)
981 struct glx_context
*const gc
= __glXGetCurrentContext();
982 const GLuint cmdlen
= 8;
983 emit_header(gc
->pc
, X_GLrop_Indexfv
, cmdlen
);
984 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&c
), 4);
986 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
987 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
991 #define X_GLrop_Indexfv 25
993 __indirect_glIndexfv(const GLfloat
* c
)
995 generic_4_byte(X_GLrop_Indexfv
, c
);
998 #define X_GLrop_Indexiv 26
1000 __indirect_glIndexi(GLint c
)
1002 struct glx_context
*const gc
= __glXGetCurrentContext();
1003 const GLuint cmdlen
= 8;
1004 emit_header(gc
->pc
, X_GLrop_Indexiv
, cmdlen
);
1005 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&c
), 4);
1007 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
1008 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
1012 #define X_GLrop_Indexiv 26
1014 __indirect_glIndexiv(const GLint
* c
)
1016 generic_4_byte(X_GLrop_Indexiv
, c
);
1019 #define X_GLrop_Indexsv 27
1021 __indirect_glIndexs(GLshort c
)
1023 struct glx_context
*const gc
= __glXGetCurrentContext();
1024 const GLuint cmdlen
= 8;
1025 emit_header(gc
->pc
, X_GLrop_Indexsv
, cmdlen
);
1026 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&c
), 2);
1028 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
1029 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
1033 #define X_GLrop_Indexsv 27
1035 __indirect_glIndexsv(const GLshort
* c
)
1037 struct glx_context
*const gc
= __glXGetCurrentContext();
1038 const GLuint cmdlen
= 8;
1039 emit_header(gc
->pc
, X_GLrop_Indexsv
, cmdlen
);
1040 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (c
), 2);
1042 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
1043 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
1047 #define X_GLrop_Normal3bv 28
1049 __indirect_glNormal3b(GLbyte nx
, GLbyte ny
, GLbyte nz
)
1051 struct glx_context
*const gc
= __glXGetCurrentContext();
1052 const GLuint cmdlen
= 8;
1053 emit_header(gc
->pc
, X_GLrop_Normal3bv
, cmdlen
);
1054 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&nx
), 1);
1055 (void) memcpy((void *) (gc
->pc
+ 5), (void *) (&ny
), 1);
1056 (void) memcpy((void *) (gc
->pc
+ 6), (void *) (&nz
), 1);
1058 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
1059 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
1063 #define X_GLrop_Normal3bv 28
1065 __indirect_glNormal3bv(const GLbyte
*v
)
1067 generic_3_byte(X_GLrop_Normal3bv
, v
);
1070 #define X_GLrop_Normal3dv 29
1072 __indirect_glNormal3d(GLdouble nx
, GLdouble ny
, GLdouble nz
)
1074 struct glx_context
*const gc
= __glXGetCurrentContext();
1075 const GLuint cmdlen
= 28;
1076 emit_header(gc
->pc
, X_GLrop_Normal3dv
, cmdlen
);
1077 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&nx
), 8);
1078 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&ny
), 8);
1079 (void) memcpy((void *) (gc
->pc
+ 20), (void *) (&nz
), 8);
1081 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
1082 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
1086 #define X_GLrop_Normal3dv 29
1088 __indirect_glNormal3dv(const GLdouble
* v
)
1090 generic_24_byte(X_GLrop_Normal3dv
, v
);
1093 #define X_GLrop_Normal3fv 30
1095 __indirect_glNormal3f(GLfloat nx
, GLfloat ny
, GLfloat nz
)
1097 struct glx_context
*const gc
= __glXGetCurrentContext();
1098 const GLuint cmdlen
= 16;
1099 emit_header(gc
->pc
, X_GLrop_Normal3fv
, cmdlen
);
1100 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&nx
), 4);
1101 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&ny
), 4);
1102 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&nz
), 4);
1104 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
1105 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
1109 #define X_GLrop_Normal3fv 30
1111 __indirect_glNormal3fv(const GLfloat
* v
)
1113 generic_12_byte(X_GLrop_Normal3fv
, v
);
1116 #define X_GLrop_Normal3iv 31
1118 __indirect_glNormal3i(GLint nx
, GLint ny
, GLint nz
)
1120 struct glx_context
*const gc
= __glXGetCurrentContext();
1121 const GLuint cmdlen
= 16;
1122 emit_header(gc
->pc
, X_GLrop_Normal3iv
, cmdlen
);
1123 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&nx
), 4);
1124 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&ny
), 4);
1125 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&nz
), 4);
1127 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
1128 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
1132 #define X_GLrop_Normal3iv 31
1134 __indirect_glNormal3iv(const GLint
* v
)
1136 generic_12_byte(X_GLrop_Normal3iv
, v
);
1139 #define X_GLrop_Normal3sv 32
1141 __indirect_glNormal3s(GLshort nx
, GLshort ny
, GLshort nz
)
1143 struct glx_context
*const gc
= __glXGetCurrentContext();
1144 const GLuint cmdlen
= 12;
1145 emit_header(gc
->pc
, X_GLrop_Normal3sv
, cmdlen
);
1146 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&nx
), 2);
1147 (void) memcpy((void *) (gc
->pc
+ 6), (void *) (&ny
), 2);
1148 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&nz
), 2);
1150 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
1151 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
1155 #define X_GLrop_Normal3sv 32
1157 __indirect_glNormal3sv(const GLshort
* v
)
1159 generic_6_byte(X_GLrop_Normal3sv
, v
);
1162 #define X_GLrop_RasterPos2dv 33
1164 __indirect_glRasterPos2d(GLdouble x
, GLdouble y
)
1166 struct glx_context
*const gc
= __glXGetCurrentContext();
1167 const GLuint cmdlen
= 20;
1168 emit_header(gc
->pc
, X_GLrop_RasterPos2dv
, cmdlen
);
1169 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&x
), 8);
1170 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&y
), 8);
1172 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
1173 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
1177 #define X_GLrop_RasterPos2dv 33
1179 __indirect_glRasterPos2dv(const GLdouble
* v
)
1181 generic_16_byte(X_GLrop_RasterPos2dv
, v
);
1184 #define X_GLrop_RasterPos2fv 34
1186 __indirect_glRasterPos2f(GLfloat x
, GLfloat y
)
1188 struct glx_context
*const gc
= __glXGetCurrentContext();
1189 const GLuint cmdlen
= 12;
1190 emit_header(gc
->pc
, X_GLrop_RasterPos2fv
, cmdlen
);
1191 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&x
), 4);
1192 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&y
), 4);
1194 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
1195 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
1199 #define X_GLrop_RasterPos2fv 34
1201 __indirect_glRasterPos2fv(const GLfloat
* v
)
1203 generic_8_byte(X_GLrop_RasterPos2fv
, v
);
1206 #define X_GLrop_RasterPos2iv 35
1208 __indirect_glRasterPos2i(GLint x
, GLint y
)
1210 struct glx_context
*const gc
= __glXGetCurrentContext();
1211 const GLuint cmdlen
= 12;
1212 emit_header(gc
->pc
, X_GLrop_RasterPos2iv
, cmdlen
);
1213 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&x
), 4);
1214 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&y
), 4);
1216 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
1217 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
1221 #define X_GLrop_RasterPos2iv 35
1223 __indirect_glRasterPos2iv(const GLint
* v
)
1225 generic_8_byte(X_GLrop_RasterPos2iv
, v
);
1228 #define X_GLrop_RasterPos2sv 36
1230 __indirect_glRasterPos2s(GLshort x
, GLshort y
)
1232 struct glx_context
*const gc
= __glXGetCurrentContext();
1233 const GLuint cmdlen
= 8;
1234 emit_header(gc
->pc
, X_GLrop_RasterPos2sv
, cmdlen
);
1235 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&x
), 2);
1236 (void) memcpy((void *) (gc
->pc
+ 6), (void *) (&y
), 2);
1238 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
1239 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
1243 #define X_GLrop_RasterPos2sv 36
1245 __indirect_glRasterPos2sv(const GLshort
* v
)
1247 generic_4_byte(X_GLrop_RasterPos2sv
, v
);
1250 #define X_GLrop_RasterPos3dv 37
1252 __indirect_glRasterPos3d(GLdouble x
, GLdouble y
, GLdouble z
)
1254 struct glx_context
*const gc
= __glXGetCurrentContext();
1255 const GLuint cmdlen
= 28;
1256 emit_header(gc
->pc
, X_GLrop_RasterPos3dv
, cmdlen
);
1257 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&x
), 8);
1258 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&y
), 8);
1259 (void) memcpy((void *) (gc
->pc
+ 20), (void *) (&z
), 8);
1261 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
1262 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
1266 #define X_GLrop_RasterPos3dv 37
1268 __indirect_glRasterPos3dv(const GLdouble
* v
)
1270 generic_24_byte(X_GLrop_RasterPos3dv
, v
);
1273 #define X_GLrop_RasterPos3fv 38
1275 __indirect_glRasterPos3f(GLfloat x
, GLfloat y
, GLfloat z
)
1277 struct glx_context
*const gc
= __glXGetCurrentContext();
1278 const GLuint cmdlen
= 16;
1279 emit_header(gc
->pc
, X_GLrop_RasterPos3fv
, cmdlen
);
1280 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&x
), 4);
1281 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&y
), 4);
1282 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&z
), 4);
1284 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
1285 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
1289 #define X_GLrop_RasterPos3fv 38
1291 __indirect_glRasterPos3fv(const GLfloat
* v
)
1293 generic_12_byte(X_GLrop_RasterPos3fv
, v
);
1296 #define X_GLrop_RasterPos3iv 39
1298 __indirect_glRasterPos3i(GLint x
, GLint y
, GLint z
)
1300 struct glx_context
*const gc
= __glXGetCurrentContext();
1301 const GLuint cmdlen
= 16;
1302 emit_header(gc
->pc
, X_GLrop_RasterPos3iv
, cmdlen
);
1303 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&x
), 4);
1304 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&y
), 4);
1305 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&z
), 4);
1307 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
1308 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
1312 #define X_GLrop_RasterPos3iv 39
1314 __indirect_glRasterPos3iv(const GLint
* v
)
1316 generic_12_byte(X_GLrop_RasterPos3iv
, v
);
1319 #define X_GLrop_RasterPos3sv 40
1321 __indirect_glRasterPos3s(GLshort x
, GLshort y
, GLshort z
)
1323 struct glx_context
*const gc
= __glXGetCurrentContext();
1324 const GLuint cmdlen
= 12;
1325 emit_header(gc
->pc
, X_GLrop_RasterPos3sv
, cmdlen
);
1326 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&x
), 2);
1327 (void) memcpy((void *) (gc
->pc
+ 6), (void *) (&y
), 2);
1328 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&z
), 2);
1330 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
1331 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
1335 #define X_GLrop_RasterPos3sv 40
1337 __indirect_glRasterPos3sv(const GLshort
* v
)
1339 generic_6_byte(X_GLrop_RasterPos3sv
, v
);
1342 #define X_GLrop_RasterPos4dv 41
1344 __indirect_glRasterPos4d(GLdouble x
, GLdouble y
, GLdouble z
, GLdouble w
)
1346 struct glx_context
*const gc
= __glXGetCurrentContext();
1347 const GLuint cmdlen
= 36;
1348 emit_header(gc
->pc
, X_GLrop_RasterPos4dv
, cmdlen
);
1349 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&x
), 8);
1350 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&y
), 8);
1351 (void) memcpy((void *) (gc
->pc
+ 20), (void *) (&z
), 8);
1352 (void) memcpy((void *) (gc
->pc
+ 28), (void *) (&w
), 8);
1354 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
1355 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
1359 #define X_GLrop_RasterPos4dv 41
1361 __indirect_glRasterPos4dv(const GLdouble
* v
)
1363 generic_32_byte(X_GLrop_RasterPos4dv
, v
);
1366 #define X_GLrop_RasterPos4fv 42
1368 __indirect_glRasterPos4f(GLfloat x
, GLfloat y
, GLfloat z
, GLfloat w
)
1370 struct glx_context
*const gc
= __glXGetCurrentContext();
1371 const GLuint cmdlen
= 20;
1372 emit_header(gc
->pc
, X_GLrop_RasterPos4fv
, cmdlen
);
1373 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&x
), 4);
1374 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&y
), 4);
1375 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&z
), 4);
1376 (void) memcpy((void *) (gc
->pc
+ 16), (void *) (&w
), 4);
1378 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
1379 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
1383 #define X_GLrop_RasterPos4fv 42
1385 __indirect_glRasterPos4fv(const GLfloat
* v
)
1387 generic_16_byte(X_GLrop_RasterPos4fv
, v
);
1390 #define X_GLrop_RasterPos4iv 43
1392 __indirect_glRasterPos4i(GLint x
, GLint y
, GLint z
, GLint w
)
1394 struct glx_context
*const gc
= __glXGetCurrentContext();
1395 const GLuint cmdlen
= 20;
1396 emit_header(gc
->pc
, X_GLrop_RasterPos4iv
, cmdlen
);
1397 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&x
), 4);
1398 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&y
), 4);
1399 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&z
), 4);
1400 (void) memcpy((void *) (gc
->pc
+ 16), (void *) (&w
), 4);
1402 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
1403 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
1407 #define X_GLrop_RasterPos4iv 43
1409 __indirect_glRasterPos4iv(const GLint
* v
)
1411 generic_16_byte(X_GLrop_RasterPos4iv
, v
);
1414 #define X_GLrop_RasterPos4sv 44
1416 __indirect_glRasterPos4s(GLshort x
, GLshort y
, GLshort z
, GLshort w
)
1418 struct glx_context
*const gc
= __glXGetCurrentContext();
1419 const GLuint cmdlen
= 12;
1420 emit_header(gc
->pc
, X_GLrop_RasterPos4sv
, cmdlen
);
1421 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&x
), 2);
1422 (void) memcpy((void *) (gc
->pc
+ 6), (void *) (&y
), 2);
1423 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&z
), 2);
1424 (void) memcpy((void *) (gc
->pc
+ 10), (void *) (&w
), 2);
1426 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
1427 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
1431 #define X_GLrop_RasterPos4sv 44
1433 __indirect_glRasterPos4sv(const GLshort
* v
)
1435 generic_8_byte(X_GLrop_RasterPos4sv
, v
);
1438 #define X_GLrop_Rectdv 45
1440 __indirect_glRectd(GLdouble x1
, GLdouble y1
, GLdouble x2
, GLdouble y2
)
1442 struct glx_context
*const gc
= __glXGetCurrentContext();
1443 const GLuint cmdlen
= 36;
1444 emit_header(gc
->pc
, X_GLrop_Rectdv
, cmdlen
);
1445 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&x1
), 8);
1446 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&y1
), 8);
1447 (void) memcpy((void *) (gc
->pc
+ 20), (void *) (&x2
), 8);
1448 (void) memcpy((void *) (gc
->pc
+ 28), (void *) (&y2
), 8);
1450 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
1451 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
1455 #define X_GLrop_Rectdv 45
1457 __indirect_glRectdv(const GLdouble
* v1
, const GLdouble
* v2
)
1459 struct glx_context
*const gc
= __glXGetCurrentContext();
1460 const GLuint cmdlen
= 36;
1461 emit_header(gc
->pc
, X_GLrop_Rectdv
, cmdlen
);
1462 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (v1
), 16);
1463 (void) memcpy((void *) (gc
->pc
+ 20), (void *) (v2
), 16);
1465 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
1466 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
1470 #define X_GLrop_Rectfv 46
1472 __indirect_glRectf(GLfloat x1
, GLfloat y1
, GLfloat x2
, GLfloat y2
)
1474 struct glx_context
*const gc
= __glXGetCurrentContext();
1475 const GLuint cmdlen
= 20;
1476 emit_header(gc
->pc
, X_GLrop_Rectfv
, cmdlen
);
1477 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&x1
), 4);
1478 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&y1
), 4);
1479 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&x2
), 4);
1480 (void) memcpy((void *) (gc
->pc
+ 16), (void *) (&y2
), 4);
1482 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
1483 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
1487 #define X_GLrop_Rectfv 46
1489 __indirect_glRectfv(const GLfloat
* v1
, const GLfloat
* v2
)
1491 struct glx_context
*const gc
= __glXGetCurrentContext();
1492 const GLuint cmdlen
= 20;
1493 emit_header(gc
->pc
, X_GLrop_Rectfv
, cmdlen
);
1494 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (v1
), 8);
1495 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (v2
), 8);
1497 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
1498 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
1502 #define X_GLrop_Rectiv 47
1504 __indirect_glRecti(GLint x1
, GLint y1
, GLint x2
, GLint y2
)
1506 struct glx_context
*const gc
= __glXGetCurrentContext();
1507 const GLuint cmdlen
= 20;
1508 emit_header(gc
->pc
, X_GLrop_Rectiv
, cmdlen
);
1509 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&x1
), 4);
1510 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&y1
), 4);
1511 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&x2
), 4);
1512 (void) memcpy((void *) (gc
->pc
+ 16), (void *) (&y2
), 4);
1514 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
1515 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
1519 #define X_GLrop_Rectiv 47
1521 __indirect_glRectiv(const GLint
* v1
, const GLint
* v2
)
1523 struct glx_context
*const gc
= __glXGetCurrentContext();
1524 const GLuint cmdlen
= 20;
1525 emit_header(gc
->pc
, X_GLrop_Rectiv
, cmdlen
);
1526 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (v1
), 8);
1527 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (v2
), 8);
1529 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
1530 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
1534 #define X_GLrop_Rectsv 48
1536 __indirect_glRects(GLshort x1
, GLshort y1
, GLshort x2
, GLshort y2
)
1538 struct glx_context
*const gc
= __glXGetCurrentContext();
1539 const GLuint cmdlen
= 12;
1540 emit_header(gc
->pc
, X_GLrop_Rectsv
, cmdlen
);
1541 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&x1
), 2);
1542 (void) memcpy((void *) (gc
->pc
+ 6), (void *) (&y1
), 2);
1543 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&x2
), 2);
1544 (void) memcpy((void *) (gc
->pc
+ 10), (void *) (&y2
), 2);
1546 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
1547 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
1551 #define X_GLrop_Rectsv 48
1553 __indirect_glRectsv(const GLshort
* v1
, const GLshort
* v2
)
1555 struct glx_context
*const gc
= __glXGetCurrentContext();
1556 const GLuint cmdlen
= 12;
1557 emit_header(gc
->pc
, X_GLrop_Rectsv
, cmdlen
);
1558 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (v1
), 4);
1559 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (v2
), 4);
1561 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
1562 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
1566 #define X_GLrop_TexCoord1dv 49
1568 __indirect_glTexCoord1d(GLdouble s
)
1570 struct glx_context
*const gc
= __glXGetCurrentContext();
1571 const GLuint cmdlen
= 12;
1572 emit_header(gc
->pc
, X_GLrop_TexCoord1dv
, cmdlen
);
1573 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&s
), 8);
1575 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
1576 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
1580 #define X_GLrop_TexCoord1dv 49
1582 __indirect_glTexCoord1dv(const GLdouble
* v
)
1584 generic_8_byte(X_GLrop_TexCoord1dv
, v
);
1587 #define X_GLrop_TexCoord1fv 50
1589 __indirect_glTexCoord1f(GLfloat s
)
1591 struct glx_context
*const gc
= __glXGetCurrentContext();
1592 const GLuint cmdlen
= 8;
1593 emit_header(gc
->pc
, X_GLrop_TexCoord1fv
, cmdlen
);
1594 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&s
), 4);
1596 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
1597 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
1601 #define X_GLrop_TexCoord1fv 50
1603 __indirect_glTexCoord1fv(const GLfloat
* v
)
1605 generic_4_byte(X_GLrop_TexCoord1fv
, v
);
1608 #define X_GLrop_TexCoord1iv 51
1610 __indirect_glTexCoord1i(GLint s
)
1612 struct glx_context
*const gc
= __glXGetCurrentContext();
1613 const GLuint cmdlen
= 8;
1614 emit_header(gc
->pc
, X_GLrop_TexCoord1iv
, cmdlen
);
1615 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&s
), 4);
1617 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
1618 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
1622 #define X_GLrop_TexCoord1iv 51
1624 __indirect_glTexCoord1iv(const GLint
* v
)
1626 generic_4_byte(X_GLrop_TexCoord1iv
, v
);
1629 #define X_GLrop_TexCoord1sv 52
1631 __indirect_glTexCoord1s(GLshort s
)
1633 struct glx_context
*const gc
= __glXGetCurrentContext();
1634 const GLuint cmdlen
= 8;
1635 emit_header(gc
->pc
, X_GLrop_TexCoord1sv
, cmdlen
);
1636 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&s
), 2);
1638 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
1639 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
1643 #define X_GLrop_TexCoord1sv 52
1645 __indirect_glTexCoord1sv(const GLshort
* v
)
1647 struct glx_context
*const gc
= __glXGetCurrentContext();
1648 const GLuint cmdlen
= 8;
1649 emit_header(gc
->pc
, X_GLrop_TexCoord1sv
, cmdlen
);
1650 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (v
), 2);
1652 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
1653 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
1657 #define X_GLrop_TexCoord2dv 53
1659 __indirect_glTexCoord2d(GLdouble s
, GLdouble t
)
1661 struct glx_context
*const gc
= __glXGetCurrentContext();
1662 const GLuint cmdlen
= 20;
1663 emit_header(gc
->pc
, X_GLrop_TexCoord2dv
, cmdlen
);
1664 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&s
), 8);
1665 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&t
), 8);
1667 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
1668 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
1672 #define X_GLrop_TexCoord2dv 53
1674 __indirect_glTexCoord2dv(const GLdouble
* v
)
1676 generic_16_byte(X_GLrop_TexCoord2dv
, v
);
1679 #define X_GLrop_TexCoord2fv 54
1681 __indirect_glTexCoord2f(GLfloat s
, GLfloat t
)
1683 struct glx_context
*const gc
= __glXGetCurrentContext();
1684 const GLuint cmdlen
= 12;
1685 emit_header(gc
->pc
, X_GLrop_TexCoord2fv
, cmdlen
);
1686 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&s
), 4);
1687 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&t
), 4);
1689 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
1690 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
1694 #define X_GLrop_TexCoord2fv 54
1696 __indirect_glTexCoord2fv(const GLfloat
* v
)
1698 generic_8_byte(X_GLrop_TexCoord2fv
, v
);
1701 #define X_GLrop_TexCoord2iv 55
1703 __indirect_glTexCoord2i(GLint s
, GLint t
)
1705 struct glx_context
*const gc
= __glXGetCurrentContext();
1706 const GLuint cmdlen
= 12;
1707 emit_header(gc
->pc
, X_GLrop_TexCoord2iv
, cmdlen
);
1708 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&s
), 4);
1709 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&t
), 4);
1711 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
1712 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
1716 #define X_GLrop_TexCoord2iv 55
1718 __indirect_glTexCoord2iv(const GLint
* v
)
1720 generic_8_byte(X_GLrop_TexCoord2iv
, v
);
1723 #define X_GLrop_TexCoord2sv 56
1725 __indirect_glTexCoord2s(GLshort s
, GLshort t
)
1727 struct glx_context
*const gc
= __glXGetCurrentContext();
1728 const GLuint cmdlen
= 8;
1729 emit_header(gc
->pc
, X_GLrop_TexCoord2sv
, cmdlen
);
1730 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&s
), 2);
1731 (void) memcpy((void *) (gc
->pc
+ 6), (void *) (&t
), 2);
1733 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
1734 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
1738 #define X_GLrop_TexCoord2sv 56
1740 __indirect_glTexCoord2sv(const GLshort
* v
)
1742 generic_4_byte(X_GLrop_TexCoord2sv
, v
);
1745 #define X_GLrop_TexCoord3dv 57
1747 __indirect_glTexCoord3d(GLdouble s
, GLdouble t
, GLdouble r
)
1749 struct glx_context
*const gc
= __glXGetCurrentContext();
1750 const GLuint cmdlen
= 28;
1751 emit_header(gc
->pc
, X_GLrop_TexCoord3dv
, cmdlen
);
1752 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&s
), 8);
1753 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&t
), 8);
1754 (void) memcpy((void *) (gc
->pc
+ 20), (void *) (&r
), 8);
1756 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
1757 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
1761 #define X_GLrop_TexCoord3dv 57
1763 __indirect_glTexCoord3dv(const GLdouble
* v
)
1765 generic_24_byte(X_GLrop_TexCoord3dv
, v
);
1768 #define X_GLrop_TexCoord3fv 58
1770 __indirect_glTexCoord3f(GLfloat s
, GLfloat t
, GLfloat r
)
1772 struct glx_context
*const gc
= __glXGetCurrentContext();
1773 const GLuint cmdlen
= 16;
1774 emit_header(gc
->pc
, X_GLrop_TexCoord3fv
, cmdlen
);
1775 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&s
), 4);
1776 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&t
), 4);
1777 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&r
), 4);
1779 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
1780 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
1784 #define X_GLrop_TexCoord3fv 58
1786 __indirect_glTexCoord3fv(const GLfloat
* v
)
1788 generic_12_byte(X_GLrop_TexCoord3fv
, v
);
1791 #define X_GLrop_TexCoord3iv 59
1793 __indirect_glTexCoord3i(GLint s
, GLint t
, GLint r
)
1795 struct glx_context
*const gc
= __glXGetCurrentContext();
1796 const GLuint cmdlen
= 16;
1797 emit_header(gc
->pc
, X_GLrop_TexCoord3iv
, cmdlen
);
1798 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&s
), 4);
1799 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&t
), 4);
1800 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&r
), 4);
1802 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
1803 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
1807 #define X_GLrop_TexCoord3iv 59
1809 __indirect_glTexCoord3iv(const GLint
* v
)
1811 generic_12_byte(X_GLrop_TexCoord3iv
, v
);
1814 #define X_GLrop_TexCoord3sv 60
1816 __indirect_glTexCoord3s(GLshort s
, GLshort t
, GLshort r
)
1818 struct glx_context
*const gc
= __glXGetCurrentContext();
1819 const GLuint cmdlen
= 12;
1820 emit_header(gc
->pc
, X_GLrop_TexCoord3sv
, cmdlen
);
1821 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&s
), 2);
1822 (void) memcpy((void *) (gc
->pc
+ 6), (void *) (&t
), 2);
1823 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&r
), 2);
1825 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
1826 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
1830 #define X_GLrop_TexCoord3sv 60
1832 __indirect_glTexCoord3sv(const GLshort
* v
)
1834 generic_6_byte(X_GLrop_TexCoord3sv
, v
);
1837 #define X_GLrop_TexCoord4dv 61
1839 __indirect_glTexCoord4d(GLdouble s
, GLdouble t
, GLdouble r
, GLdouble q
)
1841 struct glx_context
*const gc
= __glXGetCurrentContext();
1842 const GLuint cmdlen
= 36;
1843 emit_header(gc
->pc
, X_GLrop_TexCoord4dv
, cmdlen
);
1844 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&s
), 8);
1845 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&t
), 8);
1846 (void) memcpy((void *) (gc
->pc
+ 20), (void *) (&r
), 8);
1847 (void) memcpy((void *) (gc
->pc
+ 28), (void *) (&q
), 8);
1849 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
1850 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
1854 #define X_GLrop_TexCoord4dv 61
1856 __indirect_glTexCoord4dv(const GLdouble
* v
)
1858 generic_32_byte(X_GLrop_TexCoord4dv
, v
);
1861 #define X_GLrop_TexCoord4fv 62
1863 __indirect_glTexCoord4f(GLfloat s
, GLfloat t
, GLfloat r
, GLfloat q
)
1865 struct glx_context
*const gc
= __glXGetCurrentContext();
1866 const GLuint cmdlen
= 20;
1867 emit_header(gc
->pc
, X_GLrop_TexCoord4fv
, cmdlen
);
1868 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&s
), 4);
1869 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&t
), 4);
1870 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&r
), 4);
1871 (void) memcpy((void *) (gc
->pc
+ 16), (void *) (&q
), 4);
1873 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
1874 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
1878 #define X_GLrop_TexCoord4fv 62
1880 __indirect_glTexCoord4fv(const GLfloat
* v
)
1882 generic_16_byte(X_GLrop_TexCoord4fv
, v
);
1885 #define X_GLrop_TexCoord4iv 63
1887 __indirect_glTexCoord4i(GLint s
, GLint t
, GLint r
, GLint q
)
1889 struct glx_context
*const gc
= __glXGetCurrentContext();
1890 const GLuint cmdlen
= 20;
1891 emit_header(gc
->pc
, X_GLrop_TexCoord4iv
, cmdlen
);
1892 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&s
), 4);
1893 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&t
), 4);
1894 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&r
), 4);
1895 (void) memcpy((void *) (gc
->pc
+ 16), (void *) (&q
), 4);
1897 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
1898 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
1902 #define X_GLrop_TexCoord4iv 63
1904 __indirect_glTexCoord4iv(const GLint
* v
)
1906 generic_16_byte(X_GLrop_TexCoord4iv
, v
);
1909 #define X_GLrop_TexCoord4sv 64
1911 __indirect_glTexCoord4s(GLshort s
, GLshort t
, GLshort r
, GLshort q
)
1913 struct glx_context
*const gc
= __glXGetCurrentContext();
1914 const GLuint cmdlen
= 12;
1915 emit_header(gc
->pc
, X_GLrop_TexCoord4sv
, cmdlen
);
1916 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&s
), 2);
1917 (void) memcpy((void *) (gc
->pc
+ 6), (void *) (&t
), 2);
1918 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&r
), 2);
1919 (void) memcpy((void *) (gc
->pc
+ 10), (void *) (&q
), 2);
1921 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
1922 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
1926 #define X_GLrop_TexCoord4sv 64
1928 __indirect_glTexCoord4sv(const GLshort
* v
)
1930 generic_8_byte(X_GLrop_TexCoord4sv
, v
);
1933 #define X_GLrop_Vertex2dv 65
1935 __indirect_glVertex2d(GLdouble x
, GLdouble y
)
1937 struct glx_context
*const gc
= __glXGetCurrentContext();
1938 const GLuint cmdlen
= 20;
1939 emit_header(gc
->pc
, X_GLrop_Vertex2dv
, cmdlen
);
1940 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&x
), 8);
1941 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&y
), 8);
1943 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
1944 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
1948 #define X_GLrop_Vertex2dv 65
1950 __indirect_glVertex2dv(const GLdouble
* v
)
1952 generic_16_byte(X_GLrop_Vertex2dv
, v
);
1955 #define X_GLrop_Vertex2fv 66
1957 __indirect_glVertex2f(GLfloat x
, GLfloat y
)
1959 struct glx_context
*const gc
= __glXGetCurrentContext();
1960 const GLuint cmdlen
= 12;
1961 emit_header(gc
->pc
, X_GLrop_Vertex2fv
, cmdlen
);
1962 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&x
), 4);
1963 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&y
), 4);
1965 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
1966 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
1970 #define X_GLrop_Vertex2fv 66
1972 __indirect_glVertex2fv(const GLfloat
* v
)
1974 generic_8_byte(X_GLrop_Vertex2fv
, v
);
1977 #define X_GLrop_Vertex2iv 67
1979 __indirect_glVertex2i(GLint x
, GLint y
)
1981 struct glx_context
*const gc
= __glXGetCurrentContext();
1982 const GLuint cmdlen
= 12;
1983 emit_header(gc
->pc
, X_GLrop_Vertex2iv
, cmdlen
);
1984 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&x
), 4);
1985 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&y
), 4);
1987 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
1988 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
1992 #define X_GLrop_Vertex2iv 67
1994 __indirect_glVertex2iv(const GLint
* v
)
1996 generic_8_byte(X_GLrop_Vertex2iv
, v
);
1999 #define X_GLrop_Vertex2sv 68
2001 __indirect_glVertex2s(GLshort x
, GLshort y
)
2003 struct glx_context
*const gc
= __glXGetCurrentContext();
2004 const GLuint cmdlen
= 8;
2005 emit_header(gc
->pc
, X_GLrop_Vertex2sv
, cmdlen
);
2006 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&x
), 2);
2007 (void) memcpy((void *) (gc
->pc
+ 6), (void *) (&y
), 2);
2009 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
2010 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
2014 #define X_GLrop_Vertex2sv 68
2016 __indirect_glVertex2sv(const GLshort
* v
)
2018 generic_4_byte(X_GLrop_Vertex2sv
, v
);
2021 #define X_GLrop_Vertex3dv 69
2023 __indirect_glVertex3d(GLdouble x
, GLdouble y
, GLdouble z
)
2025 struct glx_context
*const gc
= __glXGetCurrentContext();
2026 const GLuint cmdlen
= 28;
2027 emit_header(gc
->pc
, X_GLrop_Vertex3dv
, cmdlen
);
2028 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&x
), 8);
2029 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&y
), 8);
2030 (void) memcpy((void *) (gc
->pc
+ 20), (void *) (&z
), 8);
2032 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
2033 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
2037 #define X_GLrop_Vertex3dv 69
2039 __indirect_glVertex3dv(const GLdouble
* v
)
2041 generic_24_byte(X_GLrop_Vertex3dv
, v
);
2044 #define X_GLrop_Vertex3fv 70
2046 __indirect_glVertex3f(GLfloat x
, GLfloat y
, GLfloat z
)
2048 struct glx_context
*const gc
= __glXGetCurrentContext();
2049 const GLuint cmdlen
= 16;
2050 emit_header(gc
->pc
, X_GLrop_Vertex3fv
, cmdlen
);
2051 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&x
), 4);
2052 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&y
), 4);
2053 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&z
), 4);
2055 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
2056 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
2060 #define X_GLrop_Vertex3fv 70
2062 __indirect_glVertex3fv(const GLfloat
* v
)
2064 generic_12_byte(X_GLrop_Vertex3fv
, v
);
2067 #define X_GLrop_Vertex3iv 71
2069 __indirect_glVertex3i(GLint x
, GLint y
, GLint z
)
2071 struct glx_context
*const gc
= __glXGetCurrentContext();
2072 const GLuint cmdlen
= 16;
2073 emit_header(gc
->pc
, X_GLrop_Vertex3iv
, cmdlen
);
2074 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&x
), 4);
2075 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&y
), 4);
2076 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&z
), 4);
2078 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
2079 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
2083 #define X_GLrop_Vertex3iv 71
2085 __indirect_glVertex3iv(const GLint
* v
)
2087 generic_12_byte(X_GLrop_Vertex3iv
, v
);
2090 #define X_GLrop_Vertex3sv 72
2092 __indirect_glVertex3s(GLshort x
, GLshort y
, GLshort z
)
2094 struct glx_context
*const gc
= __glXGetCurrentContext();
2095 const GLuint cmdlen
= 12;
2096 emit_header(gc
->pc
, X_GLrop_Vertex3sv
, cmdlen
);
2097 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&x
), 2);
2098 (void) memcpy((void *) (gc
->pc
+ 6), (void *) (&y
), 2);
2099 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&z
), 2);
2101 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
2102 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
2106 #define X_GLrop_Vertex3sv 72
2108 __indirect_glVertex3sv(const GLshort
* v
)
2110 generic_6_byte(X_GLrop_Vertex3sv
, v
);
2113 #define X_GLrop_Vertex4dv 73
2115 __indirect_glVertex4d(GLdouble x
, GLdouble y
, GLdouble z
, GLdouble w
)
2117 struct glx_context
*const gc
= __glXGetCurrentContext();
2118 const GLuint cmdlen
= 36;
2119 emit_header(gc
->pc
, X_GLrop_Vertex4dv
, cmdlen
);
2120 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&x
), 8);
2121 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&y
), 8);
2122 (void) memcpy((void *) (gc
->pc
+ 20), (void *) (&z
), 8);
2123 (void) memcpy((void *) (gc
->pc
+ 28), (void *) (&w
), 8);
2125 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
2126 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
2130 #define X_GLrop_Vertex4dv 73
2132 __indirect_glVertex4dv(const GLdouble
* v
)
2134 generic_32_byte(X_GLrop_Vertex4dv
, v
);
2137 #define X_GLrop_Vertex4fv 74
2139 __indirect_glVertex4f(GLfloat x
, GLfloat y
, GLfloat z
, GLfloat w
)
2141 struct glx_context
*const gc
= __glXGetCurrentContext();
2142 const GLuint cmdlen
= 20;
2143 emit_header(gc
->pc
, X_GLrop_Vertex4fv
, cmdlen
);
2144 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&x
), 4);
2145 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&y
), 4);
2146 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&z
), 4);
2147 (void) memcpy((void *) (gc
->pc
+ 16), (void *) (&w
), 4);
2149 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
2150 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
2154 #define X_GLrop_Vertex4fv 74
2156 __indirect_glVertex4fv(const GLfloat
* v
)
2158 generic_16_byte(X_GLrop_Vertex4fv
, v
);
2161 #define X_GLrop_Vertex4iv 75
2163 __indirect_glVertex4i(GLint x
, GLint y
, GLint z
, GLint w
)
2165 struct glx_context
*const gc
= __glXGetCurrentContext();
2166 const GLuint cmdlen
= 20;
2167 emit_header(gc
->pc
, X_GLrop_Vertex4iv
, cmdlen
);
2168 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&x
), 4);
2169 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&y
), 4);
2170 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&z
), 4);
2171 (void) memcpy((void *) (gc
->pc
+ 16), (void *) (&w
), 4);
2173 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
2174 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
2178 #define X_GLrop_Vertex4iv 75
2180 __indirect_glVertex4iv(const GLint
* v
)
2182 generic_16_byte(X_GLrop_Vertex4iv
, v
);
2185 #define X_GLrop_Vertex4sv 76
2187 __indirect_glVertex4s(GLshort x
, GLshort y
, GLshort z
, GLshort w
)
2189 struct glx_context
*const gc
= __glXGetCurrentContext();
2190 const GLuint cmdlen
= 12;
2191 emit_header(gc
->pc
, X_GLrop_Vertex4sv
, cmdlen
);
2192 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&x
), 2);
2193 (void) memcpy((void *) (gc
->pc
+ 6), (void *) (&y
), 2);
2194 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&z
), 2);
2195 (void) memcpy((void *) (gc
->pc
+ 10), (void *) (&w
), 2);
2197 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
2198 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
2202 #define X_GLrop_Vertex4sv 76
2204 __indirect_glVertex4sv(const GLshort
* v
)
2206 generic_8_byte(X_GLrop_Vertex4sv
, v
);
2209 #define X_GLrop_ClipPlane 77
2211 __indirect_glClipPlane(GLenum plane
, const GLdouble
* equation
)
2213 struct glx_context
*const gc
= __glXGetCurrentContext();
2214 const GLuint cmdlen
= 40;
2215 emit_header(gc
->pc
, X_GLrop_ClipPlane
, cmdlen
);
2216 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (equation
), 32);
2217 (void) memcpy((void *) (gc
->pc
+ 36), (void *) (&plane
), 4);
2219 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
2220 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
2224 #define X_GLrop_ColorMaterial 78
2226 __indirect_glColorMaterial(GLenum face
, GLenum mode
)
2228 struct glx_context
*const gc
= __glXGetCurrentContext();
2229 const GLuint cmdlen
= 12;
2230 emit_header(gc
->pc
, X_GLrop_ColorMaterial
, cmdlen
);
2231 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&face
), 4);
2232 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&mode
), 4);
2234 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
2235 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
2239 #define X_GLrop_CullFace 79
2241 __indirect_glCullFace(GLenum mode
)
2243 struct glx_context
*const gc
= __glXGetCurrentContext();
2244 const GLuint cmdlen
= 8;
2245 emit_header(gc
->pc
, X_GLrop_CullFace
, cmdlen
);
2246 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&mode
), 4);
2248 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
2249 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
2253 #define X_GLrop_Fogf 80
2255 __indirect_glFogf(GLenum pname
, GLfloat param
)
2257 struct glx_context
*const gc
= __glXGetCurrentContext();
2258 const GLuint cmdlen
= 12;
2259 emit_header(gc
->pc
, X_GLrop_Fogf
, cmdlen
);
2260 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&pname
), 4);
2261 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (¶m
), 4);
2263 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
2264 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
2268 #define X_GLrop_Fogfv 81
2270 __indirect_glFogfv(GLenum pname
, const GLfloat
* params
)
2272 struct glx_context
*const gc
= __glXGetCurrentContext();
2273 const GLuint compsize
= __glFogfv_size(pname
);
2274 const GLuint cmdlen
= 8 + __GLX_PAD((compsize
* 4));
2275 emit_header(gc
->pc
, X_GLrop_Fogfv
, cmdlen
);
2276 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&pname
), 4);
2277 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (params
), (compsize
* 4));
2279 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
2280 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
2284 #define X_GLrop_Fogi 82
2286 __indirect_glFogi(GLenum pname
, GLint param
)
2288 struct glx_context
*const gc
= __glXGetCurrentContext();
2289 const GLuint cmdlen
= 12;
2290 emit_header(gc
->pc
, X_GLrop_Fogi
, cmdlen
);
2291 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&pname
), 4);
2292 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (¶m
), 4);
2294 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
2295 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
2299 #define X_GLrop_Fogiv 83
2301 __indirect_glFogiv(GLenum pname
, const GLint
* params
)
2303 struct glx_context
*const gc
= __glXGetCurrentContext();
2304 const GLuint compsize
= __glFogiv_size(pname
);
2305 const GLuint cmdlen
= 8 + __GLX_PAD((compsize
* 4));
2306 emit_header(gc
->pc
, X_GLrop_Fogiv
, cmdlen
);
2307 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&pname
), 4);
2308 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (params
), (compsize
* 4));
2310 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
2311 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
2315 #define X_GLrop_FrontFace 84
2317 __indirect_glFrontFace(GLenum mode
)
2319 struct glx_context
*const gc
= __glXGetCurrentContext();
2320 const GLuint cmdlen
= 8;
2321 emit_header(gc
->pc
, X_GLrop_FrontFace
, cmdlen
);
2322 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&mode
), 4);
2324 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
2325 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
2329 #define X_GLrop_Hint 85
2331 __indirect_glHint(GLenum target
, GLenum mode
)
2333 struct glx_context
*const gc
= __glXGetCurrentContext();
2334 const GLuint cmdlen
= 12;
2335 emit_header(gc
->pc
, X_GLrop_Hint
, cmdlen
);
2336 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&target
), 4);
2337 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&mode
), 4);
2339 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
2340 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
2344 #define X_GLrop_Lightf 86
2346 __indirect_glLightf(GLenum light
, GLenum pname
, GLfloat param
)
2348 struct glx_context
*const gc
= __glXGetCurrentContext();
2349 const GLuint cmdlen
= 16;
2350 emit_header(gc
->pc
, X_GLrop_Lightf
, cmdlen
);
2351 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&light
), 4);
2352 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&pname
), 4);
2353 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (¶m
), 4);
2355 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
2356 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
2360 #define X_GLrop_Lightfv 87
2362 __indirect_glLightfv(GLenum light
, GLenum pname
, const GLfloat
* params
)
2364 struct glx_context
*const gc
= __glXGetCurrentContext();
2365 const GLuint compsize
= __glLightfv_size(pname
);
2366 const GLuint cmdlen
= 12 + __GLX_PAD((compsize
* 4));
2367 emit_header(gc
->pc
, X_GLrop_Lightfv
, cmdlen
);
2368 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&light
), 4);
2369 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&pname
), 4);
2370 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (params
), (compsize
* 4));
2372 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
2373 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
2377 #define X_GLrop_Lighti 88
2379 __indirect_glLighti(GLenum light
, GLenum pname
, GLint param
)
2381 struct glx_context
*const gc
= __glXGetCurrentContext();
2382 const GLuint cmdlen
= 16;
2383 emit_header(gc
->pc
, X_GLrop_Lighti
, cmdlen
);
2384 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&light
), 4);
2385 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&pname
), 4);
2386 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (¶m
), 4);
2388 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
2389 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
2393 #define X_GLrop_Lightiv 89
2395 __indirect_glLightiv(GLenum light
, GLenum pname
, const GLint
* params
)
2397 struct glx_context
*const gc
= __glXGetCurrentContext();
2398 const GLuint compsize
= __glLightiv_size(pname
);
2399 const GLuint cmdlen
= 12 + __GLX_PAD((compsize
* 4));
2400 emit_header(gc
->pc
, X_GLrop_Lightiv
, cmdlen
);
2401 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&light
), 4);
2402 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&pname
), 4);
2403 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (params
), (compsize
* 4));
2405 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
2406 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
2410 #define X_GLrop_LightModelf 90
2412 __indirect_glLightModelf(GLenum pname
, GLfloat param
)
2414 struct glx_context
*const gc
= __glXGetCurrentContext();
2415 const GLuint cmdlen
= 12;
2416 emit_header(gc
->pc
, X_GLrop_LightModelf
, cmdlen
);
2417 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&pname
), 4);
2418 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (¶m
), 4);
2420 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
2421 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
2425 #define X_GLrop_LightModelfv 91
2427 __indirect_glLightModelfv(GLenum pname
, const GLfloat
* params
)
2429 struct glx_context
*const gc
= __glXGetCurrentContext();
2430 const GLuint compsize
= __glLightModelfv_size(pname
);
2431 const GLuint cmdlen
= 8 + __GLX_PAD((compsize
* 4));
2432 emit_header(gc
->pc
, X_GLrop_LightModelfv
, cmdlen
);
2433 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&pname
), 4);
2434 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (params
), (compsize
* 4));
2436 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
2437 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
2441 #define X_GLrop_LightModeli 92
2443 __indirect_glLightModeli(GLenum pname
, GLint param
)
2445 struct glx_context
*const gc
= __glXGetCurrentContext();
2446 const GLuint cmdlen
= 12;
2447 emit_header(gc
->pc
, X_GLrop_LightModeli
, cmdlen
);
2448 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&pname
), 4);
2449 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (¶m
), 4);
2451 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
2452 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
2456 #define X_GLrop_LightModeliv 93
2458 __indirect_glLightModeliv(GLenum pname
, const GLint
* params
)
2460 struct glx_context
*const gc
= __glXGetCurrentContext();
2461 const GLuint compsize
= __glLightModeliv_size(pname
);
2462 const GLuint cmdlen
= 8 + __GLX_PAD((compsize
* 4));
2463 emit_header(gc
->pc
, X_GLrop_LightModeliv
, cmdlen
);
2464 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&pname
), 4);
2465 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (params
), (compsize
* 4));
2467 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
2468 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
2472 #define X_GLrop_LineStipple 94
2474 __indirect_glLineStipple(GLint factor
, GLushort pattern
)
2476 struct glx_context
*const gc
= __glXGetCurrentContext();
2477 const GLuint cmdlen
= 12;
2478 emit_header(gc
->pc
, X_GLrop_LineStipple
, cmdlen
);
2479 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&factor
), 4);
2480 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&pattern
), 2);
2482 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
2483 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
2487 #define X_GLrop_LineWidth 95
2489 __indirect_glLineWidth(GLfloat width
)
2491 struct glx_context
*const gc
= __glXGetCurrentContext();
2492 const GLuint cmdlen
= 8;
2493 emit_header(gc
->pc
, X_GLrop_LineWidth
, cmdlen
);
2494 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&width
), 4);
2496 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
2497 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
2501 #define X_GLrop_Materialf 96
2503 __indirect_glMaterialf(GLenum face
, GLenum pname
, GLfloat param
)
2505 struct glx_context
*const gc
= __glXGetCurrentContext();
2506 const GLuint cmdlen
= 16;
2507 emit_header(gc
->pc
, X_GLrop_Materialf
, cmdlen
);
2508 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&face
), 4);
2509 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&pname
), 4);
2510 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (¶m
), 4);
2512 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
2513 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
2517 #define X_GLrop_Materialfv 97
2519 __indirect_glMaterialfv(GLenum face
, GLenum pname
, const GLfloat
* params
)
2521 struct glx_context
*const gc
= __glXGetCurrentContext();
2522 const GLuint compsize
= __glMaterialfv_size(pname
);
2523 const GLuint cmdlen
= 12 + __GLX_PAD((compsize
* 4));
2524 emit_header(gc
->pc
, X_GLrop_Materialfv
, cmdlen
);
2525 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&face
), 4);
2526 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&pname
), 4);
2527 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (params
), (compsize
* 4));
2529 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
2530 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
2534 #define X_GLrop_Materiali 98
2536 __indirect_glMateriali(GLenum face
, GLenum pname
, GLint param
)
2538 struct glx_context
*const gc
= __glXGetCurrentContext();
2539 const GLuint cmdlen
= 16;
2540 emit_header(gc
->pc
, X_GLrop_Materiali
, cmdlen
);
2541 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&face
), 4);
2542 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&pname
), 4);
2543 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (¶m
), 4);
2545 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
2546 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
2550 #define X_GLrop_Materialiv 99
2552 __indirect_glMaterialiv(GLenum face
, GLenum pname
, const GLint
* params
)
2554 struct glx_context
*const gc
= __glXGetCurrentContext();
2555 const GLuint compsize
= __glMaterialiv_size(pname
);
2556 const GLuint cmdlen
= 12 + __GLX_PAD((compsize
* 4));
2557 emit_header(gc
->pc
, X_GLrop_Materialiv
, cmdlen
);
2558 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&face
), 4);
2559 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&pname
), 4);
2560 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (params
), (compsize
* 4));
2562 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
2563 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
2567 #define X_GLrop_PointSize 100
2569 __indirect_glPointSize(GLfloat size
)
2571 struct glx_context
*const gc
= __glXGetCurrentContext();
2572 const GLuint cmdlen
= 8;
2573 emit_header(gc
->pc
, X_GLrop_PointSize
, cmdlen
);
2574 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&size
), 4);
2576 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
2577 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
2581 #define X_GLrop_PolygonMode 101
2583 __indirect_glPolygonMode(GLenum face
, GLenum mode
)
2585 struct glx_context
*const gc
= __glXGetCurrentContext();
2586 const GLuint cmdlen
= 12;
2587 emit_header(gc
->pc
, X_GLrop_PolygonMode
, cmdlen
);
2588 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&face
), 4);
2589 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&mode
), 4);
2591 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
2592 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
2596 #define X_GLrop_PolygonStipple 102
2598 __indirect_glPolygonStipple(const GLubyte
*mask
)
2600 struct glx_context
*const gc
= __glXGetCurrentContext();
2601 const GLuint compsize
=
2602 (mask
!= NULL
) ? __glImageSize(32, 32, 1, GL_COLOR_INDEX
, GL_BITMAP
,
2604 const GLuint cmdlen
= 24 + __GLX_PAD(compsize
);
2605 emit_header(gc
->pc
, X_GLrop_PolygonStipple
, cmdlen
);
2607 (*gc
->fillImage
) (gc
, 2, 32, 32, 1, GL_COLOR_INDEX
, GL_BITMAP
, mask
,
2608 gc
->pc
+ 24, gc
->pc
+ 4);
2610 (void) memcpy(gc
->pc
+ 4, default_pixel_store_2D
,
2611 default_pixel_store_2D_size
);
2614 if (gc
->pc
> gc
->limit
) {
2615 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
2619 #define X_GLrop_Scissor 103
2621 __indirect_glScissor(GLint x
, GLint y
, GLsizei width
, GLsizei height
)
2623 struct glx_context
*const gc
= __glXGetCurrentContext();
2624 const GLuint cmdlen
= 20;
2625 emit_header(gc
->pc
, X_GLrop_Scissor
, cmdlen
);
2626 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&x
), 4);
2627 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&y
), 4);
2628 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&width
), 4);
2629 (void) memcpy((void *) (gc
->pc
+ 16), (void *) (&height
), 4);
2631 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
2632 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
2636 #define X_GLrop_ShadeModel 104
2638 __indirect_glShadeModel(GLenum mode
)
2640 struct glx_context
*const gc
= __glXGetCurrentContext();
2641 const GLuint cmdlen
= 8;
2642 emit_header(gc
->pc
, X_GLrop_ShadeModel
, cmdlen
);
2643 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&mode
), 4);
2645 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
2646 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
2650 #define X_GLrop_TexParameterf 105
2652 __indirect_glTexParameterf(GLenum target
, GLenum pname
, GLfloat param
)
2654 struct glx_context
*const gc
= __glXGetCurrentContext();
2655 const GLuint cmdlen
= 16;
2656 emit_header(gc
->pc
, X_GLrop_TexParameterf
, cmdlen
);
2657 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&target
), 4);
2658 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&pname
), 4);
2659 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (¶m
), 4);
2661 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
2662 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
2666 #define X_GLrop_TexParameterfv 106
2668 __indirect_glTexParameterfv(GLenum target
, GLenum pname
,
2669 const GLfloat
* params
)
2671 struct glx_context
*const gc
= __glXGetCurrentContext();
2672 const GLuint compsize
= __glTexParameterfv_size(pname
);
2673 const GLuint cmdlen
= 12 + __GLX_PAD((compsize
* 4));
2674 emit_header(gc
->pc
, X_GLrop_TexParameterfv
, cmdlen
);
2675 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&target
), 4);
2676 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&pname
), 4);
2677 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (params
), (compsize
* 4));
2679 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
2680 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
2684 #define X_GLrop_TexParameteri 107
2686 __indirect_glTexParameteri(GLenum target
, GLenum pname
, GLint param
)
2688 struct glx_context
*const gc
= __glXGetCurrentContext();
2689 const GLuint cmdlen
= 16;
2690 emit_header(gc
->pc
, X_GLrop_TexParameteri
, cmdlen
);
2691 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&target
), 4);
2692 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&pname
), 4);
2693 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (¶m
), 4);
2695 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
2696 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
2700 #define X_GLrop_TexParameteriv 108
2702 __indirect_glTexParameteriv(GLenum target
, GLenum pname
, const GLint
* params
)
2704 struct glx_context
*const gc
= __glXGetCurrentContext();
2705 const GLuint compsize
= __glTexParameteriv_size(pname
);
2706 const GLuint cmdlen
= 12 + __GLX_PAD((compsize
* 4));
2707 emit_header(gc
->pc
, X_GLrop_TexParameteriv
, cmdlen
);
2708 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&target
), 4);
2709 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&pname
), 4);
2710 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (params
), (compsize
* 4));
2712 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
2713 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
2718 __glx_TexImage_1D2D(unsigned opcode
, unsigned dim
, GLenum target
, GLint level
,
2719 GLint internalformat
, GLsizei width
, GLsizei height
,
2720 GLint border
, GLenum format
, GLenum type
,
2721 const GLvoid
* pixels
)
2723 struct glx_context
*const gc
= __glXGetCurrentContext();
2724 const GLuint compsize
=
2725 __glImageSize(width
, height
, 1, format
, type
, target
);
2726 const GLuint cmdlen
= 56 + __GLX_PAD(compsize
);
2727 if (__builtin_expect(gc
->currentDpy
!= NULL
, 1)) {
2728 if (cmdlen
<= gc
->maxSmallRenderCommandSize
) {
2729 if ((gc
->pc
+ cmdlen
) > gc
->bufEnd
) {
2730 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
2732 emit_header(gc
->pc
, opcode
, cmdlen
);
2733 (void) memcpy((void *) (gc
->pc
+ 24), (void *) (&target
), 4);
2734 (void) memcpy((void *) (gc
->pc
+ 28), (void *) (&level
), 4);
2735 (void) memcpy((void *) (gc
->pc
+ 32), (void *) (&internalformat
),
2737 (void) memcpy((void *) (gc
->pc
+ 36), (void *) (&width
), 4);
2738 (void) memcpy((void *) (gc
->pc
+ 40), (void *) (&height
), 4);
2739 (void) memcpy((void *) (gc
->pc
+ 44), (void *) (&border
), 4);
2740 (void) memcpy((void *) (gc
->pc
+ 48), (void *) (&format
), 4);
2741 (void) memcpy((void *) (gc
->pc
+ 52), (void *) (&type
), 4);
2742 if ((compsize
> 0) && (pixels
!= NULL
)) {
2743 (*gc
->fillImage
) (gc
, dim
, width
, height
, 1, format
, type
,
2744 pixels
, gc
->pc
+ 56, gc
->pc
+ 4);
2746 (void) memcpy(gc
->pc
+ 4, default_pixel_store_2D
,
2747 default_pixel_store_2D_size
);
2750 if (gc
->pc
> gc
->limit
) {
2751 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
2754 const GLint op
= opcode
;
2755 const GLuint cmdlenLarge
= cmdlen
+ 4;
2756 GLubyte
*const pc
= __glXFlushRenderBuffer(gc
, gc
->pc
);
2757 (void) memcpy((void *) (pc
+ 0), (void *) (&cmdlenLarge
), 4);
2758 (void) memcpy((void *) (pc
+ 4), (void *) (&op
), 4);
2759 (void) memcpy((void *) (pc
+ 28), (void *) (&target
), 4);
2760 (void) memcpy((void *) (pc
+ 32), (void *) (&level
), 4);
2761 (void) memcpy((void *) (pc
+ 36), (void *) (&internalformat
), 4);
2762 (void) memcpy((void *) (pc
+ 40), (void *) (&width
), 4);
2763 (void) memcpy((void *) (pc
+ 44), (void *) (&height
), 4);
2764 (void) memcpy((void *) (pc
+ 48), (void *) (&border
), 4);
2765 (void) memcpy((void *) (pc
+ 52), (void *) (&format
), 4);
2766 (void) memcpy((void *) (pc
+ 56), (void *) (&type
), 4);
2767 __glXSendLargeImage(gc
, compsize
, dim
, width
, height
, 1, format
,
2768 type
, pixels
, pc
+ 60, pc
+ 8);
2773 #define X_GLrop_TexImage1D 109
2775 __indirect_glTexImage1D(GLenum target
, GLint level
, GLint internalformat
,
2776 GLsizei width
, GLint border
, GLenum format
,
2777 GLenum type
, const GLvoid
* pixels
)
2779 __glx_TexImage_1D2D(X_GLrop_TexImage1D
, 1, target
, level
, internalformat
,
2780 width
, 1, border
, format
, type
, pixels
);
2783 #define X_GLrop_TexImage2D 110
2785 __indirect_glTexImage2D(GLenum target
, GLint level
, GLint internalformat
,
2786 GLsizei width
, GLsizei height
, GLint border
,
2787 GLenum format
, GLenum type
, const GLvoid
* pixels
)
2789 __glx_TexImage_1D2D(X_GLrop_TexImage2D
, 2, target
, level
, internalformat
,
2790 width
, height
, border
, format
, type
, pixels
);
2793 #define X_GLrop_TexEnvf 111
2795 __indirect_glTexEnvf(GLenum target
, GLenum pname
, GLfloat param
)
2797 struct glx_context
*const gc
= __glXGetCurrentContext();
2798 const GLuint cmdlen
= 16;
2799 emit_header(gc
->pc
, X_GLrop_TexEnvf
, cmdlen
);
2800 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&target
), 4);
2801 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&pname
), 4);
2802 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (¶m
), 4);
2804 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
2805 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
2809 #define X_GLrop_TexEnvfv 112
2811 __indirect_glTexEnvfv(GLenum target
, GLenum pname
, const GLfloat
* params
)
2813 struct glx_context
*const gc
= __glXGetCurrentContext();
2814 const GLuint compsize
= __glTexEnvfv_size(pname
);
2815 const GLuint cmdlen
= 12 + __GLX_PAD((compsize
* 4));
2816 emit_header(gc
->pc
, X_GLrop_TexEnvfv
, cmdlen
);
2817 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&target
), 4);
2818 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&pname
), 4);
2819 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (params
), (compsize
* 4));
2821 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
2822 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
2826 #define X_GLrop_TexEnvi 113
2828 __indirect_glTexEnvi(GLenum target
, GLenum pname
, GLint param
)
2830 struct glx_context
*const gc
= __glXGetCurrentContext();
2831 const GLuint cmdlen
= 16;
2832 emit_header(gc
->pc
, X_GLrop_TexEnvi
, cmdlen
);
2833 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&target
), 4);
2834 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&pname
), 4);
2835 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (¶m
), 4);
2837 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
2838 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
2842 #define X_GLrop_TexEnviv 114
2844 __indirect_glTexEnviv(GLenum target
, GLenum pname
, const GLint
* params
)
2846 struct glx_context
*const gc
= __glXGetCurrentContext();
2847 const GLuint compsize
= __glTexEnviv_size(pname
);
2848 const GLuint cmdlen
= 12 + __GLX_PAD((compsize
* 4));
2849 emit_header(gc
->pc
, X_GLrop_TexEnviv
, cmdlen
);
2850 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&target
), 4);
2851 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&pname
), 4);
2852 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (params
), (compsize
* 4));
2854 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
2855 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
2859 #define X_GLrop_TexGend 115
2861 __indirect_glTexGend(GLenum coord
, GLenum pname
, GLdouble param
)
2863 struct glx_context
*const gc
= __glXGetCurrentContext();
2864 const GLuint cmdlen
= 20;
2865 emit_header(gc
->pc
, X_GLrop_TexGend
, cmdlen
);
2866 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (¶m
), 8);
2867 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&coord
), 4);
2868 (void) memcpy((void *) (gc
->pc
+ 16), (void *) (&pname
), 4);
2870 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
2871 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
2875 #define X_GLrop_TexGendv 116
2877 __indirect_glTexGendv(GLenum coord
, GLenum pname
, const GLdouble
* params
)
2879 struct glx_context
*const gc
= __glXGetCurrentContext();
2880 const GLuint compsize
= __glTexGendv_size(pname
);
2881 const GLuint cmdlen
= 12 + __GLX_PAD((compsize
* 8));
2882 emit_header(gc
->pc
, X_GLrop_TexGendv
, cmdlen
);
2883 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&coord
), 4);
2884 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&pname
), 4);
2885 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (params
), (compsize
* 8));
2887 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
2888 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
2892 #define X_GLrop_TexGenf 117
2894 __indirect_glTexGenf(GLenum coord
, GLenum pname
, GLfloat param
)
2896 struct glx_context
*const gc
= __glXGetCurrentContext();
2897 const GLuint cmdlen
= 16;
2898 emit_header(gc
->pc
, X_GLrop_TexGenf
, cmdlen
);
2899 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&coord
), 4);
2900 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&pname
), 4);
2901 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (¶m
), 4);
2903 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
2904 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
2908 #define X_GLrop_TexGenfv 118
2910 __indirect_glTexGenfv(GLenum coord
, GLenum pname
, const GLfloat
* params
)
2912 struct glx_context
*const gc
= __glXGetCurrentContext();
2913 const GLuint compsize
= __glTexGenfv_size(pname
);
2914 const GLuint cmdlen
= 12 + __GLX_PAD((compsize
* 4));
2915 emit_header(gc
->pc
, X_GLrop_TexGenfv
, cmdlen
);
2916 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&coord
), 4);
2917 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&pname
), 4);
2918 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (params
), (compsize
* 4));
2920 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
2921 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
2925 #define X_GLrop_TexGeni 119
2927 __indirect_glTexGeni(GLenum coord
, GLenum pname
, GLint param
)
2929 struct glx_context
*const gc
= __glXGetCurrentContext();
2930 const GLuint cmdlen
= 16;
2931 emit_header(gc
->pc
, X_GLrop_TexGeni
, cmdlen
);
2932 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&coord
), 4);
2933 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&pname
), 4);
2934 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (¶m
), 4);
2936 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
2937 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
2941 #define X_GLrop_TexGeniv 120
2943 __indirect_glTexGeniv(GLenum coord
, GLenum pname
, const GLint
* params
)
2945 struct glx_context
*const gc
= __glXGetCurrentContext();
2946 const GLuint compsize
= __glTexGeniv_size(pname
);
2947 const GLuint cmdlen
= 12 + __GLX_PAD((compsize
* 4));
2948 emit_header(gc
->pc
, X_GLrop_TexGeniv
, cmdlen
);
2949 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&coord
), 4);
2950 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&pname
), 4);
2951 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (params
), (compsize
* 4));
2953 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
2954 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
2958 #define X_GLrop_InitNames 121
2960 __indirect_glInitNames(void)
2962 struct glx_context
*const gc
= __glXGetCurrentContext();
2963 const GLuint cmdlen
= 4;
2964 emit_header(gc
->pc
, X_GLrop_InitNames
, cmdlen
);
2966 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
2967 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
2971 #define X_GLrop_LoadName 122
2973 __indirect_glLoadName(GLuint name
)
2975 struct glx_context
*const gc
= __glXGetCurrentContext();
2976 const GLuint cmdlen
= 8;
2977 emit_header(gc
->pc
, X_GLrop_LoadName
, cmdlen
);
2978 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&name
), 4);
2980 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
2981 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
2985 #define X_GLrop_PassThrough 123
2987 __indirect_glPassThrough(GLfloat token
)
2989 struct glx_context
*const gc
= __glXGetCurrentContext();
2990 const GLuint cmdlen
= 8;
2991 emit_header(gc
->pc
, X_GLrop_PassThrough
, cmdlen
);
2992 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&token
), 4);
2994 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
2995 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
2999 #define X_GLrop_PopName 124
3001 __indirect_glPopName(void)
3003 struct glx_context
*const gc
= __glXGetCurrentContext();
3004 const GLuint cmdlen
= 4;
3005 emit_header(gc
->pc
, X_GLrop_PopName
, cmdlen
);
3007 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
3008 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
3012 #define X_GLrop_PushName 125
3014 __indirect_glPushName(GLuint name
)
3016 struct glx_context
*const gc
= __glXGetCurrentContext();
3017 const GLuint cmdlen
= 8;
3018 emit_header(gc
->pc
, X_GLrop_PushName
, cmdlen
);
3019 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&name
), 4);
3021 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
3022 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
3026 #define X_GLrop_DrawBuffer 126
3028 __indirect_glDrawBuffer(GLenum mode
)
3030 struct glx_context
*const gc
= __glXGetCurrentContext();
3031 const GLuint cmdlen
= 8;
3032 emit_header(gc
->pc
, X_GLrop_DrawBuffer
, cmdlen
);
3033 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&mode
), 4);
3035 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
3036 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
3040 #define X_GLrop_Clear 127
3042 __indirect_glClear(GLbitfield mask
)
3044 struct glx_context
*const gc
= __glXGetCurrentContext();
3045 const GLuint cmdlen
= 8;
3046 emit_header(gc
->pc
, X_GLrop_Clear
, cmdlen
);
3047 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&mask
), 4);
3049 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
3050 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
3054 #define X_GLrop_ClearAccum 128
3056 __indirect_glClearAccum(GLfloat red
, GLfloat green
, GLfloat blue
,
3059 struct glx_context
*const gc
= __glXGetCurrentContext();
3060 const GLuint cmdlen
= 20;
3061 emit_header(gc
->pc
, X_GLrop_ClearAccum
, cmdlen
);
3062 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&red
), 4);
3063 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&green
), 4);
3064 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&blue
), 4);
3065 (void) memcpy((void *) (gc
->pc
+ 16), (void *) (&alpha
), 4);
3067 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
3068 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
3072 #define X_GLrop_ClearIndex 129
3074 __indirect_glClearIndex(GLfloat c
)
3076 struct glx_context
*const gc
= __glXGetCurrentContext();
3077 const GLuint cmdlen
= 8;
3078 emit_header(gc
->pc
, X_GLrop_ClearIndex
, cmdlen
);
3079 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&c
), 4);
3081 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
3082 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
3086 #define X_GLrop_ClearColor 130
3088 __indirect_glClearColor(GLclampf red
, GLclampf green
, GLclampf blue
,
3091 struct glx_context
*const gc
= __glXGetCurrentContext();
3092 const GLuint cmdlen
= 20;
3093 emit_header(gc
->pc
, X_GLrop_ClearColor
, cmdlen
);
3094 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&red
), 4);
3095 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&green
), 4);
3096 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&blue
), 4);
3097 (void) memcpy((void *) (gc
->pc
+ 16), (void *) (&alpha
), 4);
3099 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
3100 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
3104 #define X_GLrop_ClearStencil 131
3106 __indirect_glClearStencil(GLint s
)
3108 struct glx_context
*const gc
= __glXGetCurrentContext();
3109 const GLuint cmdlen
= 8;
3110 emit_header(gc
->pc
, X_GLrop_ClearStencil
, cmdlen
);
3111 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&s
), 4);
3113 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
3114 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
3118 #define X_GLrop_ClearDepth 132
3120 __indirect_glClearDepth(GLclampd depth
)
3122 struct glx_context
*const gc
= __glXGetCurrentContext();
3123 const GLuint cmdlen
= 12;
3124 emit_header(gc
->pc
, X_GLrop_ClearDepth
, cmdlen
);
3125 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&depth
), 8);
3127 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
3128 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
3132 #define X_GLrop_StencilMask 133
3134 __indirect_glStencilMask(GLuint mask
)
3136 struct glx_context
*const gc
= __glXGetCurrentContext();
3137 const GLuint cmdlen
= 8;
3138 emit_header(gc
->pc
, X_GLrop_StencilMask
, cmdlen
);
3139 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&mask
), 4);
3141 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
3142 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
3146 #define X_GLrop_ColorMask 134
3148 __indirect_glColorMask(GLboolean red
, GLboolean green
, GLboolean blue
,
3151 struct glx_context
*const gc
= __glXGetCurrentContext();
3152 const GLuint cmdlen
= 8;
3153 emit_header(gc
->pc
, X_GLrop_ColorMask
, cmdlen
);
3154 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&red
), 1);
3155 (void) memcpy((void *) (gc
->pc
+ 5), (void *) (&green
), 1);
3156 (void) memcpy((void *) (gc
->pc
+ 6), (void *) (&blue
), 1);
3157 (void) memcpy((void *) (gc
->pc
+ 7), (void *) (&alpha
), 1);
3159 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
3160 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
3164 #define X_GLrop_DepthMask 135
3166 __indirect_glDepthMask(GLboolean flag
)
3168 struct glx_context
*const gc
= __glXGetCurrentContext();
3169 const GLuint cmdlen
= 8;
3170 emit_header(gc
->pc
, X_GLrop_DepthMask
, cmdlen
);
3171 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&flag
), 1);
3173 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
3174 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
3178 #define X_GLrop_IndexMask 136
3180 __indirect_glIndexMask(GLuint mask
)
3182 struct glx_context
*const gc
= __glXGetCurrentContext();
3183 const GLuint cmdlen
= 8;
3184 emit_header(gc
->pc
, X_GLrop_IndexMask
, cmdlen
);
3185 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&mask
), 4);
3187 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
3188 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
3192 #define X_GLrop_Accum 137
3194 __indirect_glAccum(GLenum op
, GLfloat value
)
3196 struct glx_context
*const gc
= __glXGetCurrentContext();
3197 const GLuint cmdlen
= 12;
3198 emit_header(gc
->pc
, X_GLrop_Accum
, cmdlen
);
3199 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&op
), 4);
3200 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&value
), 4);
3202 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
3203 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
3207 #define X_GLrop_PopAttrib 141
3209 __indirect_glPopAttrib(void)
3211 struct glx_context
*const gc
= __glXGetCurrentContext();
3212 const GLuint cmdlen
= 4;
3213 emit_header(gc
->pc
, X_GLrop_PopAttrib
, cmdlen
);
3215 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
3216 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
3220 #define X_GLrop_PushAttrib 142
3222 __indirect_glPushAttrib(GLbitfield mask
)
3224 struct glx_context
*const gc
= __glXGetCurrentContext();
3225 const GLuint cmdlen
= 8;
3226 emit_header(gc
->pc
, X_GLrop_PushAttrib
, cmdlen
);
3227 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&mask
), 4);
3229 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
3230 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
3234 #define X_GLrop_MapGrid1d 147
3236 __indirect_glMapGrid1d(GLint un
, GLdouble u1
, GLdouble u2
)
3238 struct glx_context
*const gc
= __glXGetCurrentContext();
3239 const GLuint cmdlen
= 24;
3240 emit_header(gc
->pc
, X_GLrop_MapGrid1d
, cmdlen
);
3241 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&u1
), 8);
3242 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&u2
), 8);
3243 (void) memcpy((void *) (gc
->pc
+ 20), (void *) (&un
), 4);
3245 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
3246 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
3250 #define X_GLrop_MapGrid1f 148
3252 __indirect_glMapGrid1f(GLint un
, GLfloat u1
, GLfloat u2
)
3254 struct glx_context
*const gc
= __glXGetCurrentContext();
3255 const GLuint cmdlen
= 16;
3256 emit_header(gc
->pc
, X_GLrop_MapGrid1f
, cmdlen
);
3257 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&un
), 4);
3258 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&u1
), 4);
3259 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&u2
), 4);
3261 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
3262 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
3266 #define X_GLrop_MapGrid2d 149
3268 __indirect_glMapGrid2d(GLint un
, GLdouble u1
, GLdouble u2
, GLint vn
,
3269 GLdouble v1
, GLdouble v2
)
3271 struct glx_context
*const gc
= __glXGetCurrentContext();
3272 const GLuint cmdlen
= 44;
3273 emit_header(gc
->pc
, X_GLrop_MapGrid2d
, cmdlen
);
3274 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&u1
), 8);
3275 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&u2
), 8);
3276 (void) memcpy((void *) (gc
->pc
+ 20), (void *) (&v1
), 8);
3277 (void) memcpy((void *) (gc
->pc
+ 28), (void *) (&v2
), 8);
3278 (void) memcpy((void *) (gc
->pc
+ 36), (void *) (&un
), 4);
3279 (void) memcpy((void *) (gc
->pc
+ 40), (void *) (&vn
), 4);
3281 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
3282 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
3286 #define X_GLrop_MapGrid2f 150
3288 __indirect_glMapGrid2f(GLint un
, GLfloat u1
, GLfloat u2
, GLint vn
, GLfloat v1
,
3291 struct glx_context
*const gc
= __glXGetCurrentContext();
3292 const GLuint cmdlen
= 28;
3293 emit_header(gc
->pc
, X_GLrop_MapGrid2f
, cmdlen
);
3294 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&un
), 4);
3295 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&u1
), 4);
3296 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&u2
), 4);
3297 (void) memcpy((void *) (gc
->pc
+ 16), (void *) (&vn
), 4);
3298 (void) memcpy((void *) (gc
->pc
+ 20), (void *) (&v1
), 4);
3299 (void) memcpy((void *) (gc
->pc
+ 24), (void *) (&v2
), 4);
3301 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
3302 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
3306 #define X_GLrop_EvalCoord1dv 151
3308 __indirect_glEvalCoord1d(GLdouble u
)
3310 struct glx_context
*const gc
= __glXGetCurrentContext();
3311 const GLuint cmdlen
= 12;
3312 emit_header(gc
->pc
, X_GLrop_EvalCoord1dv
, cmdlen
);
3313 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&u
), 8);
3315 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
3316 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
3320 #define X_GLrop_EvalCoord1dv 151
3322 __indirect_glEvalCoord1dv(const GLdouble
* u
)
3324 generic_8_byte(X_GLrop_EvalCoord1dv
, u
);
3327 #define X_GLrop_EvalCoord1fv 152
3329 __indirect_glEvalCoord1f(GLfloat u
)
3331 struct glx_context
*const gc
= __glXGetCurrentContext();
3332 const GLuint cmdlen
= 8;
3333 emit_header(gc
->pc
, X_GLrop_EvalCoord1fv
, cmdlen
);
3334 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&u
), 4);
3336 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
3337 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
3341 #define X_GLrop_EvalCoord1fv 152
3343 __indirect_glEvalCoord1fv(const GLfloat
* u
)
3345 generic_4_byte(X_GLrop_EvalCoord1fv
, u
);
3348 #define X_GLrop_EvalCoord2dv 153
3350 __indirect_glEvalCoord2d(GLdouble u
, GLdouble v
)
3352 struct glx_context
*const gc
= __glXGetCurrentContext();
3353 const GLuint cmdlen
= 20;
3354 emit_header(gc
->pc
, X_GLrop_EvalCoord2dv
, cmdlen
);
3355 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&u
), 8);
3356 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&v
), 8);
3358 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
3359 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
3363 #define X_GLrop_EvalCoord2dv 153
3365 __indirect_glEvalCoord2dv(const GLdouble
* u
)
3367 generic_16_byte(X_GLrop_EvalCoord2dv
, u
);
3370 #define X_GLrop_EvalCoord2fv 154
3372 __indirect_glEvalCoord2f(GLfloat u
, GLfloat v
)
3374 struct glx_context
*const gc
= __glXGetCurrentContext();
3375 const GLuint cmdlen
= 12;
3376 emit_header(gc
->pc
, X_GLrop_EvalCoord2fv
, cmdlen
);
3377 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&u
), 4);
3378 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&v
), 4);
3380 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
3381 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
3385 #define X_GLrop_EvalCoord2fv 154
3387 __indirect_glEvalCoord2fv(const GLfloat
* u
)
3389 generic_8_byte(X_GLrop_EvalCoord2fv
, u
);
3392 #define X_GLrop_EvalMesh1 155
3394 __indirect_glEvalMesh1(GLenum mode
, GLint i1
, GLint i2
)
3396 struct glx_context
*const gc
= __glXGetCurrentContext();
3397 const GLuint cmdlen
= 16;
3398 emit_header(gc
->pc
, X_GLrop_EvalMesh1
, cmdlen
);
3399 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&mode
), 4);
3400 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&i1
), 4);
3401 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&i2
), 4);
3403 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
3404 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
3408 #define X_GLrop_EvalPoint1 156
3410 __indirect_glEvalPoint1(GLint i
)
3412 struct glx_context
*const gc
= __glXGetCurrentContext();
3413 const GLuint cmdlen
= 8;
3414 emit_header(gc
->pc
, X_GLrop_EvalPoint1
, cmdlen
);
3415 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&i
), 4);
3417 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
3418 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
3422 #define X_GLrop_EvalMesh2 157
3424 __indirect_glEvalMesh2(GLenum mode
, GLint i1
, GLint i2
, GLint j1
, GLint j2
)
3426 struct glx_context
*const gc
= __glXGetCurrentContext();
3427 const GLuint cmdlen
= 24;
3428 emit_header(gc
->pc
, X_GLrop_EvalMesh2
, cmdlen
);
3429 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&mode
), 4);
3430 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&i1
), 4);
3431 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&i2
), 4);
3432 (void) memcpy((void *) (gc
->pc
+ 16), (void *) (&j1
), 4);
3433 (void) memcpy((void *) (gc
->pc
+ 20), (void *) (&j2
), 4);
3435 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
3436 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
3440 #define X_GLrop_EvalPoint2 158
3442 __indirect_glEvalPoint2(GLint i
, GLint j
)
3444 struct glx_context
*const gc
= __glXGetCurrentContext();
3445 const GLuint cmdlen
= 12;
3446 emit_header(gc
->pc
, X_GLrop_EvalPoint2
, cmdlen
);
3447 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&i
), 4);
3448 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&j
), 4);
3450 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
3451 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
3455 #define X_GLrop_AlphaFunc 159
3457 __indirect_glAlphaFunc(GLenum func
, GLclampf ref
)
3459 struct glx_context
*const gc
= __glXGetCurrentContext();
3460 const GLuint cmdlen
= 12;
3461 emit_header(gc
->pc
, X_GLrop_AlphaFunc
, cmdlen
);
3462 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&func
), 4);
3463 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&ref
), 4);
3465 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
3466 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
3470 #define X_GLrop_BlendFunc 160
3472 __indirect_glBlendFunc(GLenum sfactor
, GLenum dfactor
)
3474 struct glx_context
*const gc
= __glXGetCurrentContext();
3475 const GLuint cmdlen
= 12;
3476 emit_header(gc
->pc
, X_GLrop_BlendFunc
, cmdlen
);
3477 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&sfactor
), 4);
3478 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&dfactor
), 4);
3480 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
3481 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
3485 #define X_GLrop_LogicOp 161
3487 __indirect_glLogicOp(GLenum opcode
)
3489 struct glx_context
*const gc
= __glXGetCurrentContext();
3490 const GLuint cmdlen
= 8;
3491 emit_header(gc
->pc
, X_GLrop_LogicOp
, cmdlen
);
3492 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&opcode
), 4);
3494 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
3495 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
3499 #define X_GLrop_StencilFunc 162
3501 __indirect_glStencilFunc(GLenum func
, GLint ref
, GLuint mask
)
3503 struct glx_context
*const gc
= __glXGetCurrentContext();
3504 const GLuint cmdlen
= 16;
3505 emit_header(gc
->pc
, X_GLrop_StencilFunc
, cmdlen
);
3506 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&func
), 4);
3507 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&ref
), 4);
3508 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&mask
), 4);
3510 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
3511 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
3515 #define X_GLrop_StencilOp 163
3517 __indirect_glStencilOp(GLenum fail
, GLenum zfail
, GLenum zpass
)
3519 struct glx_context
*const gc
= __glXGetCurrentContext();
3520 const GLuint cmdlen
= 16;
3521 emit_header(gc
->pc
, X_GLrop_StencilOp
, cmdlen
);
3522 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&fail
), 4);
3523 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&zfail
), 4);
3524 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&zpass
), 4);
3526 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
3527 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
3531 #define X_GLrop_DepthFunc 164
3533 __indirect_glDepthFunc(GLenum func
)
3535 struct glx_context
*const gc
= __glXGetCurrentContext();
3536 const GLuint cmdlen
= 8;
3537 emit_header(gc
->pc
, X_GLrop_DepthFunc
, cmdlen
);
3538 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&func
), 4);
3540 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
3541 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
3545 #define X_GLrop_PixelZoom 165
3547 __indirect_glPixelZoom(GLfloat xfactor
, GLfloat yfactor
)
3549 struct glx_context
*const gc
= __glXGetCurrentContext();
3550 const GLuint cmdlen
= 12;
3551 emit_header(gc
->pc
, X_GLrop_PixelZoom
, cmdlen
);
3552 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&xfactor
), 4);
3553 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&yfactor
), 4);
3555 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
3556 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
3560 #define X_GLrop_PixelTransferf 166
3562 __indirect_glPixelTransferf(GLenum pname
, GLfloat param
)
3564 struct glx_context
*const gc
= __glXGetCurrentContext();
3565 const GLuint cmdlen
= 12;
3566 emit_header(gc
->pc
, X_GLrop_PixelTransferf
, cmdlen
);
3567 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&pname
), 4);
3568 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (¶m
), 4);
3570 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
3571 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
3575 #define X_GLrop_PixelTransferi 167
3577 __indirect_glPixelTransferi(GLenum pname
, GLint param
)
3579 struct glx_context
*const gc
= __glXGetCurrentContext();
3580 const GLuint cmdlen
= 12;
3581 emit_header(gc
->pc
, X_GLrop_PixelTransferi
, cmdlen
);
3582 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&pname
), 4);
3583 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (¶m
), 4);
3585 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
3586 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
3590 #define X_GLrop_PixelMapfv 168
3592 __indirect_glPixelMapfv(GLenum map
, GLsizei mapsize
, const GLfloat
* values
)
3594 struct glx_context
*const gc
= __glXGetCurrentContext();
3595 const GLuint cmdlen
= 12 + __GLX_PAD((mapsize
* 4));
3597 __glXSetError(gc
, GL_INVALID_VALUE
);
3600 if (__builtin_expect((mapsize
>= 0) && (gc
->currentDpy
!= NULL
), 1)) {
3601 if (cmdlen
<= gc
->maxSmallRenderCommandSize
) {
3602 if ((gc
->pc
+ cmdlen
) > gc
->bufEnd
) {
3603 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
3605 emit_header(gc
->pc
, X_GLrop_PixelMapfv
, cmdlen
);
3606 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&map
), 4);
3607 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&mapsize
), 4);
3608 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (values
),
3611 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
3612 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
3615 const GLint op
= X_GLrop_PixelMapfv
;
3616 const GLuint cmdlenLarge
= cmdlen
+ 4;
3617 GLubyte
*const pc
= __glXFlushRenderBuffer(gc
, gc
->pc
);
3618 (void) memcpy((void *) (pc
+ 0), (void *) (&cmdlenLarge
), 4);
3619 (void) memcpy((void *) (pc
+ 4), (void *) (&op
), 4);
3620 (void) memcpy((void *) (pc
+ 8), (void *) (&map
), 4);
3621 (void) memcpy((void *) (pc
+ 12), (void *) (&mapsize
), 4);
3622 __glXSendLargeCommand(gc
, pc
, 16, values
, (mapsize
* 4));
3627 #define X_GLrop_PixelMapuiv 169
3629 __indirect_glPixelMapuiv(GLenum map
, GLsizei mapsize
, const GLuint
* values
)
3631 struct glx_context
*const gc
= __glXGetCurrentContext();
3632 const GLuint cmdlen
= 12 + __GLX_PAD((mapsize
* 4));
3634 __glXSetError(gc
, GL_INVALID_VALUE
);
3637 if (__builtin_expect((mapsize
>= 0) && (gc
->currentDpy
!= NULL
), 1)) {
3638 if (cmdlen
<= gc
->maxSmallRenderCommandSize
) {
3639 if ((gc
->pc
+ cmdlen
) > gc
->bufEnd
) {
3640 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
3642 emit_header(gc
->pc
, X_GLrop_PixelMapuiv
, cmdlen
);
3643 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&map
), 4);
3644 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&mapsize
), 4);
3645 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (values
),
3648 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
3649 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
3652 const GLint op
= X_GLrop_PixelMapuiv
;
3653 const GLuint cmdlenLarge
= cmdlen
+ 4;
3654 GLubyte
*const pc
= __glXFlushRenderBuffer(gc
, gc
->pc
);
3655 (void) memcpy((void *) (pc
+ 0), (void *) (&cmdlenLarge
), 4);
3656 (void) memcpy((void *) (pc
+ 4), (void *) (&op
), 4);
3657 (void) memcpy((void *) (pc
+ 8), (void *) (&map
), 4);
3658 (void) memcpy((void *) (pc
+ 12), (void *) (&mapsize
), 4);
3659 __glXSendLargeCommand(gc
, pc
, 16, values
, (mapsize
* 4));
3664 #define X_GLrop_PixelMapusv 170
3666 __indirect_glPixelMapusv(GLenum map
, GLsizei mapsize
, const GLushort
* values
)
3668 struct glx_context
*const gc
= __glXGetCurrentContext();
3669 const GLuint cmdlen
= 12 + __GLX_PAD((mapsize
* 2));
3671 __glXSetError(gc
, GL_INVALID_VALUE
);
3674 if (__builtin_expect((mapsize
>= 0) && (gc
->currentDpy
!= NULL
), 1)) {
3675 if (cmdlen
<= gc
->maxSmallRenderCommandSize
) {
3676 if ((gc
->pc
+ cmdlen
) > gc
->bufEnd
) {
3677 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
3679 emit_header(gc
->pc
, X_GLrop_PixelMapusv
, cmdlen
);
3680 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&map
), 4);
3681 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&mapsize
), 4);
3682 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (values
),
3685 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
3686 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
3689 const GLint op
= X_GLrop_PixelMapusv
;
3690 const GLuint cmdlenLarge
= cmdlen
+ 4;
3691 GLubyte
*const pc
= __glXFlushRenderBuffer(gc
, gc
->pc
);
3692 (void) memcpy((void *) (pc
+ 0), (void *) (&cmdlenLarge
), 4);
3693 (void) memcpy((void *) (pc
+ 4), (void *) (&op
), 4);
3694 (void) memcpy((void *) (pc
+ 8), (void *) (&map
), 4);
3695 (void) memcpy((void *) (pc
+ 12), (void *) (&mapsize
), 4);
3696 __glXSendLargeCommand(gc
, pc
, 16, values
, (mapsize
* 2));
3701 #define X_GLrop_ReadBuffer 171
3703 __indirect_glReadBuffer(GLenum mode
)
3705 struct glx_context
*const gc
= __glXGetCurrentContext();
3706 const GLuint cmdlen
= 8;
3707 emit_header(gc
->pc
, X_GLrop_ReadBuffer
, cmdlen
);
3708 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&mode
), 4);
3710 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
3711 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
3715 #define X_GLrop_CopyPixels 172
3717 __indirect_glCopyPixels(GLint x
, GLint y
, GLsizei width
, GLsizei height
,
3720 struct glx_context
*const gc
= __glXGetCurrentContext();
3721 const GLuint cmdlen
= 24;
3722 emit_header(gc
->pc
, X_GLrop_CopyPixels
, cmdlen
);
3723 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&x
), 4);
3724 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&y
), 4);
3725 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&width
), 4);
3726 (void) memcpy((void *) (gc
->pc
+ 16), (void *) (&height
), 4);
3727 (void) memcpy((void *) (gc
->pc
+ 20), (void *) (&type
), 4);
3729 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
3730 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
3734 #define X_GLsop_ReadPixels 111
3736 __indirect_glReadPixels(GLint x
, GLint y
, GLsizei width
, GLsizei height
,
3737 GLenum format
, GLenum type
, GLvoid
* pixels
)
3739 struct glx_context
*const gc
= __glXGetCurrentContext();
3740 const __GLXattribute
*const state
= gc
->client_state_private
;
3741 Display
*const dpy
= gc
->currentDpy
;
3743 const GLuint cmdlen
= 28;
3745 if (__builtin_expect(dpy
!= NULL
, 1)) {
3747 xcb_connection_t
*c
= XGetXCBConnection(dpy
);
3748 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
3749 xcb_glx_read_pixels_reply_t
*reply
=
3750 xcb_glx_read_pixels_reply(c
,
3751 xcb_glx_read_pixels(c
,
3754 x
, y
, width
, height
,
3759 (void) memcpy(pixels
, xcb_glx_read_pixels_data(reply
),
3760 xcb_glx_read_pixels_data_length(reply
) *
3765 __glXSetupSingleRequest(gc
, X_GLsop_ReadPixels
, cmdlen
);
3766 (void) memcpy((void *) (pc
+ 0), (void *) (&x
), 4);
3767 (void) memcpy((void *) (pc
+ 4), (void *) (&y
), 4);
3768 (void) memcpy((void *) (pc
+ 8), (void *) (&width
), 4);
3769 (void) memcpy((void *) (pc
+ 12), (void *) (&height
), 4);
3770 (void) memcpy((void *) (pc
+ 16), (void *) (&format
), 4);
3771 (void) memcpy((void *) (pc
+ 20), (void *) (&type
), 4);
3772 *(int32_t *) (pc
+ 24) = 0;
3773 *(int8_t *) (pc
+ 24) = state
->storePack
.swapEndian
;
3774 __glXReadPixelReply(dpy
, gc
, 2, width
, height
, 1, format
, type
,
3778 #endif /* USE_XCB */
3783 #define X_GLrop_DrawPixels 173
3785 __indirect_glDrawPixels(GLsizei width
, GLsizei height
, GLenum format
,
3786 GLenum type
, const GLvoid
* pixels
)
3788 struct glx_context
*const gc
= __glXGetCurrentContext();
3789 const GLuint compsize
=
3790 (pixels
!= NULL
) ? __glImageSize(width
, height
, 1, format
, type
,
3792 const GLuint cmdlen
= 40 + __GLX_PAD(compsize
);
3793 if (__builtin_expect(gc
->currentDpy
!= NULL
, 1)) {
3794 if (cmdlen
<= gc
->maxSmallRenderCommandSize
) {
3795 if ((gc
->pc
+ cmdlen
) > gc
->bufEnd
) {
3796 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
3798 emit_header(gc
->pc
, X_GLrop_DrawPixels
, cmdlen
);
3799 (void) memcpy((void *) (gc
->pc
+ 24), (void *) (&width
), 4);
3800 (void) memcpy((void *) (gc
->pc
+ 28), (void *) (&height
), 4);
3801 (void) memcpy((void *) (gc
->pc
+ 32), (void *) (&format
), 4);
3802 (void) memcpy((void *) (gc
->pc
+ 36), (void *) (&type
), 4);
3804 (*gc
->fillImage
) (gc
, 2, width
, height
, 1, format
, type
,
3805 pixels
, gc
->pc
+ 40, gc
->pc
+ 4);
3807 (void) memcpy(gc
->pc
+ 4, default_pixel_store_2D
,
3808 default_pixel_store_2D_size
);
3811 if (gc
->pc
> gc
->limit
) {
3812 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
3815 const GLint op
= X_GLrop_DrawPixels
;
3816 const GLuint cmdlenLarge
= cmdlen
+ 4;
3817 GLubyte
*const pc
= __glXFlushRenderBuffer(gc
, gc
->pc
);
3818 (void) memcpy((void *) (pc
+ 0), (void *) (&cmdlenLarge
), 4);
3819 (void) memcpy((void *) (pc
+ 4), (void *) (&op
), 4);
3820 (void) memcpy((void *) (pc
+ 28), (void *) (&width
), 4);
3821 (void) memcpy((void *) (pc
+ 32), (void *) (&height
), 4);
3822 (void) memcpy((void *) (pc
+ 36), (void *) (&format
), 4);
3823 (void) memcpy((void *) (pc
+ 40), (void *) (&type
), 4);
3824 __glXSendLargeImage(gc
, compsize
, 2, width
, height
, 1, format
,
3825 type
, pixels
, pc
+ 44, pc
+ 8);
3830 #define X_GLsop_GetClipPlane 113
3832 __indirect_glGetClipPlane(GLenum plane
, GLdouble
* equation
)
3834 struct glx_context
*const gc
= __glXGetCurrentContext();
3835 Display
*const dpy
= gc
->currentDpy
;
3837 const GLuint cmdlen
= 4;
3839 if (__builtin_expect(dpy
!= NULL
, 1)) {
3841 xcb_connection_t
*c
= XGetXCBConnection(dpy
);
3842 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
3843 xcb_glx_get_clip_plane_reply_t
*reply
=
3844 xcb_glx_get_clip_plane_reply(c
,
3845 xcb_glx_get_clip_plane(c
,
3849 (void) memcpy(equation
, xcb_glx_get_clip_plane_data(reply
),
3850 xcb_glx_get_clip_plane_data_length(reply
) *
3855 __glXSetupSingleRequest(gc
, X_GLsop_GetClipPlane
, cmdlen
);
3856 (void) memcpy((void *) (pc
+ 0), (void *) (&plane
), 4);
3857 (void) __glXReadReply(dpy
, 8, equation
, GL_TRUE
);
3860 #endif /* USE_XCB */
3865 #define X_GLsop_GetLightfv 118
3867 __indirect_glGetLightfv(GLenum light
, GLenum pname
, GLfloat
* params
)
3869 struct glx_context
*const gc
= __glXGetCurrentContext();
3870 Display
*const dpy
= gc
->currentDpy
;
3872 const GLuint cmdlen
= 8;
3874 if (__builtin_expect(dpy
!= NULL
, 1)) {
3876 xcb_connection_t
*c
= XGetXCBConnection(dpy
);
3877 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
3878 xcb_glx_get_lightfv_reply_t
*reply
=
3879 xcb_glx_get_lightfv_reply(c
,
3880 xcb_glx_get_lightfv(c
,
3885 if (xcb_glx_get_lightfv_data_length(reply
) == 0)
3886 (void) memcpy(params
, &reply
->datum
, sizeof(reply
->datum
));
3888 (void) memcpy(params
, xcb_glx_get_lightfv_data(reply
),
3889 xcb_glx_get_lightfv_data_length(reply
) *
3894 __glXSetupSingleRequest(gc
, X_GLsop_GetLightfv
, cmdlen
);
3895 (void) memcpy((void *) (pc
+ 0), (void *) (&light
), 4);
3896 (void) memcpy((void *) (pc
+ 4), (void *) (&pname
), 4);
3897 (void) __glXReadReply(dpy
, 4, params
, GL_FALSE
);
3900 #endif /* USE_XCB */
3905 #define X_GLsop_GetLightiv 119
3907 __indirect_glGetLightiv(GLenum light
, GLenum pname
, GLint
* params
)
3909 struct glx_context
*const gc
= __glXGetCurrentContext();
3910 Display
*const dpy
= gc
->currentDpy
;
3912 const GLuint cmdlen
= 8;
3914 if (__builtin_expect(dpy
!= NULL
, 1)) {
3916 xcb_connection_t
*c
= XGetXCBConnection(dpy
);
3917 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
3918 xcb_glx_get_lightiv_reply_t
*reply
=
3919 xcb_glx_get_lightiv_reply(c
,
3920 xcb_glx_get_lightiv(c
,
3925 if (xcb_glx_get_lightiv_data_length(reply
) == 0)
3926 (void) memcpy(params
, &reply
->datum
, sizeof(reply
->datum
));
3928 (void) memcpy(params
, xcb_glx_get_lightiv_data(reply
),
3929 xcb_glx_get_lightiv_data_length(reply
) *
3934 __glXSetupSingleRequest(gc
, X_GLsop_GetLightiv
, cmdlen
);
3935 (void) memcpy((void *) (pc
+ 0), (void *) (&light
), 4);
3936 (void) memcpy((void *) (pc
+ 4), (void *) (&pname
), 4);
3937 (void) __glXReadReply(dpy
, 4, params
, GL_FALSE
);
3940 #endif /* USE_XCB */
3945 #define X_GLsop_GetMapdv 120
3947 __indirect_glGetMapdv(GLenum target
, GLenum query
, GLdouble
* v
)
3949 struct glx_context
*const gc
= __glXGetCurrentContext();
3950 Display
*const dpy
= gc
->currentDpy
;
3952 const GLuint cmdlen
= 8;
3954 if (__builtin_expect(dpy
!= NULL
, 1)) {
3956 xcb_connection_t
*c
= XGetXCBConnection(dpy
);
3957 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
3958 xcb_glx_get_mapdv_reply_t
*reply
=
3959 xcb_glx_get_mapdv_reply(c
,
3960 xcb_glx_get_mapdv(c
,
3961 gc
->currentContextTag
,
3962 target
, query
), NULL
);
3963 if (xcb_glx_get_mapdv_data_length(reply
) == 0)
3964 (void) memcpy(v
, &reply
->datum
, sizeof(reply
->datum
));
3966 (void) memcpy(v
, xcb_glx_get_mapdv_data(reply
),
3967 xcb_glx_get_mapdv_data_length(reply
) *
3972 __glXSetupSingleRequest(gc
, X_GLsop_GetMapdv
, cmdlen
);
3973 (void) memcpy((void *) (pc
+ 0), (void *) (&target
), 4);
3974 (void) memcpy((void *) (pc
+ 4), (void *) (&query
), 4);
3975 (void) __glXReadReply(dpy
, 8, v
, GL_FALSE
);
3978 #endif /* USE_XCB */
3983 #define X_GLsop_GetMapfv 121
3985 __indirect_glGetMapfv(GLenum target
, GLenum query
, GLfloat
* v
)
3987 struct glx_context
*const gc
= __glXGetCurrentContext();
3988 Display
*const dpy
= gc
->currentDpy
;
3990 const GLuint cmdlen
= 8;
3992 if (__builtin_expect(dpy
!= NULL
, 1)) {
3994 xcb_connection_t
*c
= XGetXCBConnection(dpy
);
3995 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
3996 xcb_glx_get_mapfv_reply_t
*reply
=
3997 xcb_glx_get_mapfv_reply(c
,
3998 xcb_glx_get_mapfv(c
,
3999 gc
->currentContextTag
,
4000 target
, query
), NULL
);
4001 if (xcb_glx_get_mapfv_data_length(reply
) == 0)
4002 (void) memcpy(v
, &reply
->datum
, sizeof(reply
->datum
));
4004 (void) memcpy(v
, xcb_glx_get_mapfv_data(reply
),
4005 xcb_glx_get_mapfv_data_length(reply
) *
4010 __glXSetupSingleRequest(gc
, X_GLsop_GetMapfv
, cmdlen
);
4011 (void) memcpy((void *) (pc
+ 0), (void *) (&target
), 4);
4012 (void) memcpy((void *) (pc
+ 4), (void *) (&query
), 4);
4013 (void) __glXReadReply(dpy
, 4, v
, GL_FALSE
);
4016 #endif /* USE_XCB */
4021 #define X_GLsop_GetMapiv 122
4023 __indirect_glGetMapiv(GLenum target
, GLenum query
, GLint
* v
)
4025 struct glx_context
*const gc
= __glXGetCurrentContext();
4026 Display
*const dpy
= gc
->currentDpy
;
4028 const GLuint cmdlen
= 8;
4030 if (__builtin_expect(dpy
!= NULL
, 1)) {
4032 xcb_connection_t
*c
= XGetXCBConnection(dpy
);
4033 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
4034 xcb_glx_get_mapiv_reply_t
*reply
=
4035 xcb_glx_get_mapiv_reply(c
,
4036 xcb_glx_get_mapiv(c
,
4037 gc
->currentContextTag
,
4038 target
, query
), NULL
);
4039 if (xcb_glx_get_mapiv_data_length(reply
) == 0)
4040 (void) memcpy(v
, &reply
->datum
, sizeof(reply
->datum
));
4042 (void) memcpy(v
, xcb_glx_get_mapiv_data(reply
),
4043 xcb_glx_get_mapiv_data_length(reply
) *
4048 __glXSetupSingleRequest(gc
, X_GLsop_GetMapiv
, cmdlen
);
4049 (void) memcpy((void *) (pc
+ 0), (void *) (&target
), 4);
4050 (void) memcpy((void *) (pc
+ 4), (void *) (&query
), 4);
4051 (void) __glXReadReply(dpy
, 4, v
, GL_FALSE
);
4054 #endif /* USE_XCB */
4059 #define X_GLsop_GetMaterialfv 123
4061 __indirect_glGetMaterialfv(GLenum face
, GLenum pname
, GLfloat
* params
)
4063 struct glx_context
*const gc
= __glXGetCurrentContext();
4064 Display
*const dpy
= gc
->currentDpy
;
4066 const GLuint cmdlen
= 8;
4068 if (__builtin_expect(dpy
!= NULL
, 1)) {
4070 xcb_connection_t
*c
= XGetXCBConnection(dpy
);
4071 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
4072 xcb_glx_get_materialfv_reply_t
*reply
=
4073 xcb_glx_get_materialfv_reply(c
,
4074 xcb_glx_get_materialfv(c
,
4079 if (xcb_glx_get_materialfv_data_length(reply
) == 0)
4080 (void) memcpy(params
, &reply
->datum
, sizeof(reply
->datum
));
4082 (void) memcpy(params
, xcb_glx_get_materialfv_data(reply
),
4083 xcb_glx_get_materialfv_data_length(reply
) *
4088 __glXSetupSingleRequest(gc
, X_GLsop_GetMaterialfv
, cmdlen
);
4089 (void) memcpy((void *) (pc
+ 0), (void *) (&face
), 4);
4090 (void) memcpy((void *) (pc
+ 4), (void *) (&pname
), 4);
4091 (void) __glXReadReply(dpy
, 4, params
, GL_FALSE
);
4094 #endif /* USE_XCB */
4099 #define X_GLsop_GetMaterialiv 124
4101 __indirect_glGetMaterialiv(GLenum face
, GLenum pname
, GLint
* params
)
4103 struct glx_context
*const gc
= __glXGetCurrentContext();
4104 Display
*const dpy
= gc
->currentDpy
;
4106 const GLuint cmdlen
= 8;
4108 if (__builtin_expect(dpy
!= NULL
, 1)) {
4110 xcb_connection_t
*c
= XGetXCBConnection(dpy
);
4111 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
4112 xcb_glx_get_materialiv_reply_t
*reply
=
4113 xcb_glx_get_materialiv_reply(c
,
4114 xcb_glx_get_materialiv(c
,
4119 if (xcb_glx_get_materialiv_data_length(reply
) == 0)
4120 (void) memcpy(params
, &reply
->datum
, sizeof(reply
->datum
));
4122 (void) memcpy(params
, xcb_glx_get_materialiv_data(reply
),
4123 xcb_glx_get_materialiv_data_length(reply
) *
4128 __glXSetupSingleRequest(gc
, X_GLsop_GetMaterialiv
, cmdlen
);
4129 (void) memcpy((void *) (pc
+ 0), (void *) (&face
), 4);
4130 (void) memcpy((void *) (pc
+ 4), (void *) (&pname
), 4);
4131 (void) __glXReadReply(dpy
, 4, params
, GL_FALSE
);
4134 #endif /* USE_XCB */
4139 #define X_GLsop_GetPixelMapfv 125
4141 __indirect_glGetPixelMapfv(GLenum map
, GLfloat
* values
)
4143 struct glx_context
*const gc
= __glXGetCurrentContext();
4144 Display
*const dpy
= gc
->currentDpy
;
4146 const GLuint cmdlen
= 4;
4148 if (__builtin_expect(dpy
!= NULL
, 1)) {
4150 xcb_connection_t
*c
= XGetXCBConnection(dpy
);
4151 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
4152 xcb_glx_get_pixel_mapfv_reply_t
*reply
=
4153 xcb_glx_get_pixel_mapfv_reply(c
,
4154 xcb_glx_get_pixel_mapfv(c
,
4158 if (xcb_glx_get_pixel_mapfv_data_length(reply
) == 0)
4159 (void) memcpy(values
, &reply
->datum
, sizeof(reply
->datum
));
4161 (void) memcpy(values
, xcb_glx_get_pixel_mapfv_data(reply
),
4162 xcb_glx_get_pixel_mapfv_data_length(reply
) *
4167 __glXSetupSingleRequest(gc
, X_GLsop_GetPixelMapfv
, cmdlen
);
4168 (void) memcpy((void *) (pc
+ 0), (void *) (&map
), 4);
4169 (void) __glXReadReply(dpy
, 4, values
, GL_FALSE
);
4172 #endif /* USE_XCB */
4177 #define X_GLsop_GetPixelMapuiv 126
4179 __indirect_glGetPixelMapuiv(GLenum map
, GLuint
* values
)
4181 struct glx_context
*const gc
= __glXGetCurrentContext();
4182 Display
*const dpy
= gc
->currentDpy
;
4184 const GLuint cmdlen
= 4;
4186 if (__builtin_expect(dpy
!= NULL
, 1)) {
4188 xcb_connection_t
*c
= XGetXCBConnection(dpy
);
4189 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
4190 xcb_glx_get_pixel_mapuiv_reply_t
*reply
=
4191 xcb_glx_get_pixel_mapuiv_reply(c
,
4192 xcb_glx_get_pixel_mapuiv(c
,
4197 if (xcb_glx_get_pixel_mapuiv_data_length(reply
) == 0)
4198 (void) memcpy(values
, &reply
->datum
, sizeof(reply
->datum
));
4200 (void) memcpy(values
, xcb_glx_get_pixel_mapuiv_data(reply
),
4201 xcb_glx_get_pixel_mapuiv_data_length(reply
) *
4206 __glXSetupSingleRequest(gc
, X_GLsop_GetPixelMapuiv
, cmdlen
);
4207 (void) memcpy((void *) (pc
+ 0), (void *) (&map
), 4);
4208 (void) __glXReadReply(dpy
, 4, values
, GL_FALSE
);
4211 #endif /* USE_XCB */
4216 #define X_GLsop_GetPixelMapusv 127
4218 __indirect_glGetPixelMapusv(GLenum map
, GLushort
* values
)
4220 struct glx_context
*const gc
= __glXGetCurrentContext();
4221 Display
*const dpy
= gc
->currentDpy
;
4223 const GLuint cmdlen
= 4;
4225 if (__builtin_expect(dpy
!= NULL
, 1)) {
4227 xcb_connection_t
*c
= XGetXCBConnection(dpy
);
4228 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
4229 xcb_glx_get_pixel_mapusv_reply_t
*reply
=
4230 xcb_glx_get_pixel_mapusv_reply(c
,
4231 xcb_glx_get_pixel_mapusv(c
,
4236 if (xcb_glx_get_pixel_mapusv_data_length(reply
) == 0)
4237 (void) memcpy(values
, &reply
->datum
, sizeof(reply
->datum
));
4239 (void) memcpy(values
, xcb_glx_get_pixel_mapusv_data(reply
),
4240 xcb_glx_get_pixel_mapusv_data_length(reply
) *
4245 __glXSetupSingleRequest(gc
, X_GLsop_GetPixelMapusv
, cmdlen
);
4246 (void) memcpy((void *) (pc
+ 0), (void *) (&map
), 4);
4247 (void) __glXReadReply(dpy
, 2, values
, GL_FALSE
);
4250 #endif /* USE_XCB */
4255 #define X_GLsop_GetPolygonStipple 128
4257 __indirect_glGetPolygonStipple(GLubyte
*mask
)
4259 struct glx_context
*const gc
= __glXGetCurrentContext();
4260 Display
*const dpy
= gc
->currentDpy
;
4262 const GLuint cmdlen
= 4;
4264 if (__builtin_expect(dpy
!= NULL
, 1)) {
4266 xcb_connection_t
*c
= XGetXCBConnection(dpy
);
4267 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
4268 xcb_glx_get_polygon_stipple_reply_t
*reply
=
4269 xcb_glx_get_polygon_stipple_reply(c
,
4270 xcb_glx_get_polygon_stipple(c
,
4275 (void) memcpy(mask
, xcb_glx_get_polygon_stipple_data(reply
),
4276 xcb_glx_get_polygon_stipple_data_length(reply
) *
4281 __glXSetupSingleRequest(gc
, X_GLsop_GetPolygonStipple
, cmdlen
);
4282 *(int32_t *) (pc
+ 0) = 0;
4283 __glXReadPixelReply(dpy
, gc
, 2, 32, 32, 1, GL_COLOR_INDEX
, GL_BITMAP
,
4287 #endif /* USE_XCB */
4292 #define X_GLsop_GetTexEnvfv 130
4294 __indirect_glGetTexEnvfv(GLenum target
, GLenum pname
, GLfloat
* params
)
4296 struct glx_context
*const gc
= __glXGetCurrentContext();
4297 Display
*const dpy
= gc
->currentDpy
;
4299 const GLuint cmdlen
= 8;
4301 if (__builtin_expect(dpy
!= NULL
, 1)) {
4303 xcb_connection_t
*c
= XGetXCBConnection(dpy
);
4304 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
4305 xcb_glx_get_tex_envfv_reply_t
*reply
=
4306 xcb_glx_get_tex_envfv_reply(c
,
4307 xcb_glx_get_tex_envfv(c
,
4312 if (xcb_glx_get_tex_envfv_data_length(reply
) == 0)
4313 (void) memcpy(params
, &reply
->datum
, sizeof(reply
->datum
));
4315 (void) memcpy(params
, xcb_glx_get_tex_envfv_data(reply
),
4316 xcb_glx_get_tex_envfv_data_length(reply
) *
4321 __glXSetupSingleRequest(gc
, X_GLsop_GetTexEnvfv
, cmdlen
);
4322 (void) memcpy((void *) (pc
+ 0), (void *) (&target
), 4);
4323 (void) memcpy((void *) (pc
+ 4), (void *) (&pname
), 4);
4324 (void) __glXReadReply(dpy
, 4, params
, GL_FALSE
);
4327 #endif /* USE_XCB */
4332 #define X_GLsop_GetTexEnviv 131
4334 __indirect_glGetTexEnviv(GLenum target
, GLenum pname
, GLint
* params
)
4336 struct glx_context
*const gc
= __glXGetCurrentContext();
4337 Display
*const dpy
= gc
->currentDpy
;
4339 const GLuint cmdlen
= 8;
4341 if (__builtin_expect(dpy
!= NULL
, 1)) {
4343 xcb_connection_t
*c
= XGetXCBConnection(dpy
);
4344 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
4345 xcb_glx_get_tex_enviv_reply_t
*reply
=
4346 xcb_glx_get_tex_enviv_reply(c
,
4347 xcb_glx_get_tex_enviv(c
,
4352 if (xcb_glx_get_tex_enviv_data_length(reply
) == 0)
4353 (void) memcpy(params
, &reply
->datum
, sizeof(reply
->datum
));
4355 (void) memcpy(params
, xcb_glx_get_tex_enviv_data(reply
),
4356 xcb_glx_get_tex_enviv_data_length(reply
) *
4361 __glXSetupSingleRequest(gc
, X_GLsop_GetTexEnviv
, cmdlen
);
4362 (void) memcpy((void *) (pc
+ 0), (void *) (&target
), 4);
4363 (void) memcpy((void *) (pc
+ 4), (void *) (&pname
), 4);
4364 (void) __glXReadReply(dpy
, 4, params
, GL_FALSE
);
4367 #endif /* USE_XCB */
4372 #define X_GLsop_GetTexGendv 132
4374 __indirect_glGetTexGendv(GLenum coord
, GLenum pname
, GLdouble
* params
)
4376 struct glx_context
*const gc
= __glXGetCurrentContext();
4377 Display
*const dpy
= gc
->currentDpy
;
4379 const GLuint cmdlen
= 8;
4381 if (__builtin_expect(dpy
!= NULL
, 1)) {
4383 xcb_connection_t
*c
= XGetXCBConnection(dpy
);
4384 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
4385 xcb_glx_get_tex_gendv_reply_t
*reply
=
4386 xcb_glx_get_tex_gendv_reply(c
,
4387 xcb_glx_get_tex_gendv(c
,
4392 if (xcb_glx_get_tex_gendv_data_length(reply
) == 0)
4393 (void) memcpy(params
, &reply
->datum
, sizeof(reply
->datum
));
4395 (void) memcpy(params
, xcb_glx_get_tex_gendv_data(reply
),
4396 xcb_glx_get_tex_gendv_data_length(reply
) *
4401 __glXSetupSingleRequest(gc
, X_GLsop_GetTexGendv
, cmdlen
);
4402 (void) memcpy((void *) (pc
+ 0), (void *) (&coord
), 4);
4403 (void) memcpy((void *) (pc
+ 4), (void *) (&pname
), 4);
4404 (void) __glXReadReply(dpy
, 8, params
, GL_FALSE
);
4407 #endif /* USE_XCB */
4412 #define X_GLsop_GetTexGenfv 133
4414 __indirect_glGetTexGenfv(GLenum coord
, GLenum pname
, GLfloat
* params
)
4416 struct glx_context
*const gc
= __glXGetCurrentContext();
4417 Display
*const dpy
= gc
->currentDpy
;
4419 const GLuint cmdlen
= 8;
4421 if (__builtin_expect(dpy
!= NULL
, 1)) {
4423 xcb_connection_t
*c
= XGetXCBConnection(dpy
);
4424 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
4425 xcb_glx_get_tex_genfv_reply_t
*reply
=
4426 xcb_glx_get_tex_genfv_reply(c
,
4427 xcb_glx_get_tex_genfv(c
,
4432 if (xcb_glx_get_tex_genfv_data_length(reply
) == 0)
4433 (void) memcpy(params
, &reply
->datum
, sizeof(reply
->datum
));
4435 (void) memcpy(params
, xcb_glx_get_tex_genfv_data(reply
),
4436 xcb_glx_get_tex_genfv_data_length(reply
) *
4441 __glXSetupSingleRequest(gc
, X_GLsop_GetTexGenfv
, cmdlen
);
4442 (void) memcpy((void *) (pc
+ 0), (void *) (&coord
), 4);
4443 (void) memcpy((void *) (pc
+ 4), (void *) (&pname
), 4);
4444 (void) __glXReadReply(dpy
, 4, params
, GL_FALSE
);
4447 #endif /* USE_XCB */
4452 #define X_GLsop_GetTexGeniv 134
4454 __indirect_glGetTexGeniv(GLenum coord
, GLenum pname
, GLint
* params
)
4456 struct glx_context
*const gc
= __glXGetCurrentContext();
4457 Display
*const dpy
= gc
->currentDpy
;
4459 const GLuint cmdlen
= 8;
4461 if (__builtin_expect(dpy
!= NULL
, 1)) {
4463 xcb_connection_t
*c
= XGetXCBConnection(dpy
);
4464 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
4465 xcb_glx_get_tex_geniv_reply_t
*reply
=
4466 xcb_glx_get_tex_geniv_reply(c
,
4467 xcb_glx_get_tex_geniv(c
,
4472 if (xcb_glx_get_tex_geniv_data_length(reply
) == 0)
4473 (void) memcpy(params
, &reply
->datum
, sizeof(reply
->datum
));
4475 (void) memcpy(params
, xcb_glx_get_tex_geniv_data(reply
),
4476 xcb_glx_get_tex_geniv_data_length(reply
) *
4481 __glXSetupSingleRequest(gc
, X_GLsop_GetTexGeniv
, cmdlen
);
4482 (void) memcpy((void *) (pc
+ 0), (void *) (&coord
), 4);
4483 (void) memcpy((void *) (pc
+ 4), (void *) (&pname
), 4);
4484 (void) __glXReadReply(dpy
, 4, params
, GL_FALSE
);
4487 #endif /* USE_XCB */
4492 #define X_GLsop_GetTexImage 135
4494 __indirect_glGetTexImage(GLenum target
, GLint level
, GLenum format
,
4495 GLenum type
, GLvoid
* pixels
)
4497 struct glx_context
*const gc
= __glXGetCurrentContext();
4498 const __GLXattribute
*const state
= gc
->client_state_private
;
4499 Display
*const dpy
= gc
->currentDpy
;
4501 const GLuint cmdlen
= 20;
4503 if (__builtin_expect(dpy
!= NULL
, 1)) {
4505 xcb_connection_t
*c
= XGetXCBConnection(dpy
);
4506 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
4507 xcb_glx_get_tex_image_reply_t
*reply
=
4508 xcb_glx_get_tex_image_reply(c
,
4509 xcb_glx_get_tex_image(c
,
4518 (void) memcpy(pixels
, xcb_glx_get_tex_image_data(reply
),
4519 xcb_glx_get_tex_image_data_length(reply
) *
4524 __glXSetupSingleRequest(gc
, X_GLsop_GetTexImage
, cmdlen
);
4525 (void) memcpy((void *) (pc
+ 0), (void *) (&target
), 4);
4526 (void) memcpy((void *) (pc
+ 4), (void *) (&level
), 4);
4527 (void) memcpy((void *) (pc
+ 8), (void *) (&format
), 4);
4528 (void) memcpy((void *) (pc
+ 12), (void *) (&type
), 4);
4529 *(int32_t *) (pc
+ 16) = 0;
4530 *(int8_t *) (pc
+ 16) = state
->storePack
.swapEndian
;
4531 __glXReadPixelReply(dpy
, gc
, 3, 0, 0, 0, format
, type
, pixels
,
4535 #endif /* USE_XCB */
4540 #define X_GLsop_GetTexParameterfv 136
4542 __indirect_glGetTexParameterfv(GLenum target
, GLenum pname
, GLfloat
* params
)
4544 struct glx_context
*const gc
= __glXGetCurrentContext();
4545 Display
*const dpy
= gc
->currentDpy
;
4547 const GLuint cmdlen
= 8;
4549 if (__builtin_expect(dpy
!= NULL
, 1)) {
4551 xcb_connection_t
*c
= XGetXCBConnection(dpy
);
4552 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
4553 xcb_glx_get_tex_parameterfv_reply_t
*reply
=
4554 xcb_glx_get_tex_parameterfv_reply(c
,
4555 xcb_glx_get_tex_parameterfv(c
,
4561 if (xcb_glx_get_tex_parameterfv_data_length(reply
) == 0)
4562 (void) memcpy(params
, &reply
->datum
, sizeof(reply
->datum
));
4564 (void) memcpy(params
, xcb_glx_get_tex_parameterfv_data(reply
),
4565 xcb_glx_get_tex_parameterfv_data_length(reply
) *
4570 __glXSetupSingleRequest(gc
, X_GLsop_GetTexParameterfv
, cmdlen
);
4571 (void) memcpy((void *) (pc
+ 0), (void *) (&target
), 4);
4572 (void) memcpy((void *) (pc
+ 4), (void *) (&pname
), 4);
4573 (void) __glXReadReply(dpy
, 4, params
, GL_FALSE
);
4576 #endif /* USE_XCB */
4581 #define X_GLsop_GetTexParameteriv 137
4583 __indirect_glGetTexParameteriv(GLenum target
, GLenum pname
, GLint
* params
)
4585 struct glx_context
*const gc
= __glXGetCurrentContext();
4586 Display
*const dpy
= gc
->currentDpy
;
4588 const GLuint cmdlen
= 8;
4590 if (__builtin_expect(dpy
!= NULL
, 1)) {
4592 xcb_connection_t
*c
= XGetXCBConnection(dpy
);
4593 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
4594 xcb_glx_get_tex_parameteriv_reply_t
*reply
=
4595 xcb_glx_get_tex_parameteriv_reply(c
,
4596 xcb_glx_get_tex_parameteriv(c
,
4602 if (xcb_glx_get_tex_parameteriv_data_length(reply
) == 0)
4603 (void) memcpy(params
, &reply
->datum
, sizeof(reply
->datum
));
4605 (void) memcpy(params
, xcb_glx_get_tex_parameteriv_data(reply
),
4606 xcb_glx_get_tex_parameteriv_data_length(reply
) *
4611 __glXSetupSingleRequest(gc
, X_GLsop_GetTexParameteriv
, cmdlen
);
4612 (void) memcpy((void *) (pc
+ 0), (void *) (&target
), 4);
4613 (void) memcpy((void *) (pc
+ 4), (void *) (&pname
), 4);
4614 (void) __glXReadReply(dpy
, 4, params
, GL_FALSE
);
4617 #endif /* USE_XCB */
4622 #define X_GLsop_GetTexLevelParameterfv 138
4624 __indirect_glGetTexLevelParameterfv(GLenum target
, GLint level
, GLenum pname
,
4627 struct glx_context
*const gc
= __glXGetCurrentContext();
4628 Display
*const dpy
= gc
->currentDpy
;
4630 const GLuint cmdlen
= 12;
4632 if (__builtin_expect(dpy
!= NULL
, 1)) {
4634 xcb_connection_t
*c
= XGetXCBConnection(dpy
);
4635 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
4636 xcb_glx_get_tex_level_parameterfv_reply_t
*reply
=
4637 xcb_glx_get_tex_level_parameterfv_reply(c
,
4638 xcb_glx_get_tex_level_parameterfv
4639 (c
, gc
->currentContextTag
,
4640 target
, level
, pname
),
4642 if (xcb_glx_get_tex_level_parameterfv_data_length(reply
) == 0)
4643 (void) memcpy(params
, &reply
->datum
, sizeof(reply
->datum
));
4645 (void) memcpy(params
,
4646 xcb_glx_get_tex_level_parameterfv_data(reply
),
4647 xcb_glx_get_tex_level_parameterfv_data_length(reply
)
4652 __glXSetupSingleRequest(gc
, X_GLsop_GetTexLevelParameterfv
,
4654 (void) memcpy((void *) (pc
+ 0), (void *) (&target
), 4);
4655 (void) memcpy((void *) (pc
+ 4), (void *) (&level
), 4);
4656 (void) memcpy((void *) (pc
+ 8), (void *) (&pname
), 4);
4657 (void) __glXReadReply(dpy
, 4, params
, GL_FALSE
);
4660 #endif /* USE_XCB */
4665 #define X_GLsop_GetTexLevelParameteriv 139
4667 __indirect_glGetTexLevelParameteriv(GLenum target
, GLint level
, GLenum pname
,
4670 struct glx_context
*const gc
= __glXGetCurrentContext();
4671 Display
*const dpy
= gc
->currentDpy
;
4673 const GLuint cmdlen
= 12;
4675 if (__builtin_expect(dpy
!= NULL
, 1)) {
4677 xcb_connection_t
*c
= XGetXCBConnection(dpy
);
4678 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
4679 xcb_glx_get_tex_level_parameteriv_reply_t
*reply
=
4680 xcb_glx_get_tex_level_parameteriv_reply(c
,
4681 xcb_glx_get_tex_level_parameteriv
4682 (c
, gc
->currentContextTag
,
4683 target
, level
, pname
),
4685 if (xcb_glx_get_tex_level_parameteriv_data_length(reply
) == 0)
4686 (void) memcpy(params
, &reply
->datum
, sizeof(reply
->datum
));
4688 (void) memcpy(params
,
4689 xcb_glx_get_tex_level_parameteriv_data(reply
),
4690 xcb_glx_get_tex_level_parameteriv_data_length(reply
)
4695 __glXSetupSingleRequest(gc
, X_GLsop_GetTexLevelParameteriv
,
4697 (void) memcpy((void *) (pc
+ 0), (void *) (&target
), 4);
4698 (void) memcpy((void *) (pc
+ 4), (void *) (&level
), 4);
4699 (void) memcpy((void *) (pc
+ 8), (void *) (&pname
), 4);
4700 (void) __glXReadReply(dpy
, 4, params
, GL_FALSE
);
4703 #endif /* USE_XCB */
4708 #define X_GLsop_IsList 141
4710 __indirect_glIsList(GLuint list
)
4712 struct glx_context
*const gc
= __glXGetCurrentContext();
4713 Display
*const dpy
= gc
->currentDpy
;
4714 GLboolean retval
= (GLboolean
) 0;
4716 const GLuint cmdlen
= 4;
4718 if (__builtin_expect(dpy
!= NULL
, 1)) {
4720 xcb_connection_t
*c
= XGetXCBConnection(dpy
);
4721 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
4722 xcb_glx_is_list_reply_t
*reply
=
4723 xcb_glx_is_list_reply(c
,
4724 xcb_glx_is_list(c
, gc
->currentContextTag
,
4726 retval
= reply
->ret_val
;
4730 __glXSetupSingleRequest(gc
, X_GLsop_IsList
, cmdlen
);
4731 (void) memcpy((void *) (pc
+ 0), (void *) (&list
), 4);
4732 retval
= (GLboolean
) __glXReadReply(dpy
, 0, NULL
, GL_FALSE
);
4735 #endif /* USE_XCB */
4740 #define X_GLrop_DepthRange 174
4742 __indirect_glDepthRange(GLclampd zNear
, GLclampd zFar
)
4744 struct glx_context
*const gc
= __glXGetCurrentContext();
4745 const GLuint cmdlen
= 20;
4746 emit_header(gc
->pc
, X_GLrop_DepthRange
, cmdlen
);
4747 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&zNear
), 8);
4748 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&zFar
), 8);
4750 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
4751 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
4755 #define X_GLrop_Frustum 175
4757 __indirect_glFrustum(GLdouble left
, GLdouble right
, GLdouble bottom
,
4758 GLdouble top
, GLdouble zNear
, GLdouble zFar
)
4760 struct glx_context
*const gc
= __glXGetCurrentContext();
4761 const GLuint cmdlen
= 52;
4762 emit_header(gc
->pc
, X_GLrop_Frustum
, cmdlen
);
4763 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&left
), 8);
4764 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&right
), 8);
4765 (void) memcpy((void *) (gc
->pc
+ 20), (void *) (&bottom
), 8);
4766 (void) memcpy((void *) (gc
->pc
+ 28), (void *) (&top
), 8);
4767 (void) memcpy((void *) (gc
->pc
+ 36), (void *) (&zNear
), 8);
4768 (void) memcpy((void *) (gc
->pc
+ 44), (void *) (&zFar
), 8);
4770 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
4771 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
4775 #define X_GLrop_LoadIdentity 176
4777 __indirect_glLoadIdentity(void)
4779 struct glx_context
*const gc
= __glXGetCurrentContext();
4780 const GLuint cmdlen
= 4;
4781 emit_header(gc
->pc
, X_GLrop_LoadIdentity
, cmdlen
);
4783 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
4784 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
4788 #define X_GLrop_LoadMatrixf 177
4790 __indirect_glLoadMatrixf(const GLfloat
* m
)
4792 struct glx_context
*const gc
= __glXGetCurrentContext();
4793 const GLuint cmdlen
= 68;
4794 emit_header(gc
->pc
, X_GLrop_LoadMatrixf
, cmdlen
);
4795 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (m
), 64);
4797 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
4798 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
4802 #define X_GLrop_LoadMatrixd 178
4804 __indirect_glLoadMatrixd(const GLdouble
* m
)
4806 struct glx_context
*const gc
= __glXGetCurrentContext();
4807 const GLuint cmdlen
= 132;
4808 emit_header(gc
->pc
, X_GLrop_LoadMatrixd
, cmdlen
);
4809 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (m
), 128);
4811 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
4812 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
4816 #define X_GLrop_MatrixMode 179
4818 __indirect_glMatrixMode(GLenum mode
)
4820 struct glx_context
*const gc
= __glXGetCurrentContext();
4821 const GLuint cmdlen
= 8;
4822 emit_header(gc
->pc
, X_GLrop_MatrixMode
, cmdlen
);
4823 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&mode
), 4);
4825 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
4826 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
4830 #define X_GLrop_MultMatrixf 180
4832 __indirect_glMultMatrixf(const GLfloat
* m
)
4834 struct glx_context
*const gc
= __glXGetCurrentContext();
4835 const GLuint cmdlen
= 68;
4836 emit_header(gc
->pc
, X_GLrop_MultMatrixf
, cmdlen
);
4837 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (m
), 64);
4839 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
4840 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
4844 #define X_GLrop_MultMatrixd 181
4846 __indirect_glMultMatrixd(const GLdouble
* m
)
4848 struct glx_context
*const gc
= __glXGetCurrentContext();
4849 const GLuint cmdlen
= 132;
4850 emit_header(gc
->pc
, X_GLrop_MultMatrixd
, cmdlen
);
4851 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (m
), 128);
4853 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
4854 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
4858 #define X_GLrop_Ortho 182
4860 __indirect_glOrtho(GLdouble left
, GLdouble right
, GLdouble bottom
,
4861 GLdouble top
, GLdouble zNear
, GLdouble zFar
)
4863 struct glx_context
*const gc
= __glXGetCurrentContext();
4864 const GLuint cmdlen
= 52;
4865 emit_header(gc
->pc
, X_GLrop_Ortho
, cmdlen
);
4866 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&left
), 8);
4867 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&right
), 8);
4868 (void) memcpy((void *) (gc
->pc
+ 20), (void *) (&bottom
), 8);
4869 (void) memcpy((void *) (gc
->pc
+ 28), (void *) (&top
), 8);
4870 (void) memcpy((void *) (gc
->pc
+ 36), (void *) (&zNear
), 8);
4871 (void) memcpy((void *) (gc
->pc
+ 44), (void *) (&zFar
), 8);
4873 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
4874 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
4878 #define X_GLrop_PopMatrix 183
4880 __indirect_glPopMatrix(void)
4882 struct glx_context
*const gc
= __glXGetCurrentContext();
4883 const GLuint cmdlen
= 4;
4884 emit_header(gc
->pc
, X_GLrop_PopMatrix
, cmdlen
);
4886 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
4887 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
4891 #define X_GLrop_PushMatrix 184
4893 __indirect_glPushMatrix(void)
4895 struct glx_context
*const gc
= __glXGetCurrentContext();
4896 const GLuint cmdlen
= 4;
4897 emit_header(gc
->pc
, X_GLrop_PushMatrix
, cmdlen
);
4899 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
4900 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
4904 #define X_GLrop_Rotated 185
4906 __indirect_glRotated(GLdouble angle
, GLdouble x
, GLdouble y
, GLdouble z
)
4908 struct glx_context
*const gc
= __glXGetCurrentContext();
4909 const GLuint cmdlen
= 36;
4910 emit_header(gc
->pc
, X_GLrop_Rotated
, cmdlen
);
4911 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&angle
), 8);
4912 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&x
), 8);
4913 (void) memcpy((void *) (gc
->pc
+ 20), (void *) (&y
), 8);
4914 (void) memcpy((void *) (gc
->pc
+ 28), (void *) (&z
), 8);
4916 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
4917 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
4921 #define X_GLrop_Rotatef 186
4923 __indirect_glRotatef(GLfloat angle
, GLfloat x
, GLfloat y
, GLfloat z
)
4925 struct glx_context
*const gc
= __glXGetCurrentContext();
4926 const GLuint cmdlen
= 20;
4927 emit_header(gc
->pc
, X_GLrop_Rotatef
, cmdlen
);
4928 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&angle
), 4);
4929 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&x
), 4);
4930 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&y
), 4);
4931 (void) memcpy((void *) (gc
->pc
+ 16), (void *) (&z
), 4);
4933 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
4934 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
4938 #define X_GLrop_Scaled 187
4940 __indirect_glScaled(GLdouble x
, GLdouble y
, GLdouble z
)
4942 struct glx_context
*const gc
= __glXGetCurrentContext();
4943 const GLuint cmdlen
= 28;
4944 emit_header(gc
->pc
, X_GLrop_Scaled
, cmdlen
);
4945 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&x
), 8);
4946 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&y
), 8);
4947 (void) memcpy((void *) (gc
->pc
+ 20), (void *) (&z
), 8);
4949 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
4950 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
4954 #define X_GLrop_Scalef 188
4956 __indirect_glScalef(GLfloat x
, GLfloat y
, GLfloat z
)
4958 struct glx_context
*const gc
= __glXGetCurrentContext();
4959 const GLuint cmdlen
= 16;
4960 emit_header(gc
->pc
, X_GLrop_Scalef
, cmdlen
);
4961 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&x
), 4);
4962 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&y
), 4);
4963 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&z
), 4);
4965 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
4966 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
4970 #define X_GLrop_Translated 189
4972 __indirect_glTranslated(GLdouble x
, GLdouble y
, GLdouble z
)
4974 struct glx_context
*const gc
= __glXGetCurrentContext();
4975 const GLuint cmdlen
= 28;
4976 emit_header(gc
->pc
, X_GLrop_Translated
, cmdlen
);
4977 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&x
), 8);
4978 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&y
), 8);
4979 (void) memcpy((void *) (gc
->pc
+ 20), (void *) (&z
), 8);
4981 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
4982 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
4986 #define X_GLrop_Translatef 190
4988 __indirect_glTranslatef(GLfloat x
, GLfloat y
, GLfloat z
)
4990 struct glx_context
*const gc
= __glXGetCurrentContext();
4991 const GLuint cmdlen
= 16;
4992 emit_header(gc
->pc
, X_GLrop_Translatef
, cmdlen
);
4993 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&x
), 4);
4994 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&y
), 4);
4995 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&z
), 4);
4997 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
4998 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
5002 #define X_GLrop_Viewport 191
5004 __indirect_glViewport(GLint x
, GLint y
, GLsizei width
, GLsizei height
)
5006 struct glx_context
*const gc
= __glXGetCurrentContext();
5007 const GLuint cmdlen
= 20;
5008 emit_header(gc
->pc
, X_GLrop_Viewport
, cmdlen
);
5009 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&x
), 4);
5010 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&y
), 4);
5011 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&width
), 4);
5012 (void) memcpy((void *) (gc
->pc
+ 16), (void *) (&height
), 4);
5014 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
5015 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
5019 #define X_GLrop_BindTexture 4117
5021 __indirect_glBindTexture(GLenum target
, GLuint texture
)
5023 struct glx_context
*const gc
= __glXGetCurrentContext();
5024 const GLuint cmdlen
= 12;
5025 emit_header(gc
->pc
, X_GLrop_BindTexture
, cmdlen
);
5026 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&target
), 4);
5027 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&texture
), 4);
5029 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
5030 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
5034 #define X_GLrop_Indexubv 194
5036 __indirect_glIndexub(GLubyte c
)
5038 struct glx_context
*const gc
= __glXGetCurrentContext();
5039 const GLuint cmdlen
= 8;
5040 emit_header(gc
->pc
, X_GLrop_Indexubv
, cmdlen
);
5041 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&c
), 1);
5043 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
5044 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
5048 #define X_GLrop_Indexubv 194
5050 __indirect_glIndexubv(const GLubyte
*c
)
5052 struct glx_context
*const gc
= __glXGetCurrentContext();
5053 const GLuint cmdlen
= 8;
5054 emit_header(gc
->pc
, X_GLrop_Indexubv
, cmdlen
);
5055 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (c
), 1);
5057 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
5058 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
5062 #define X_GLrop_PolygonOffset 192
5064 __indirect_glPolygonOffset(GLfloat factor
, GLfloat units
)
5066 struct glx_context
*const gc
= __glXGetCurrentContext();
5067 const GLuint cmdlen
= 12;
5068 emit_header(gc
->pc
, X_GLrop_PolygonOffset
, cmdlen
);
5069 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&factor
), 4);
5070 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&units
), 4);
5072 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
5073 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
5077 #define X_GLrop_CopyTexImage1D 4119
5079 __indirect_glCopyTexImage1D(GLenum target
, GLint level
, GLenum internalformat
,
5080 GLint x
, GLint y
, GLsizei width
, GLint border
)
5082 struct glx_context
*const gc
= __glXGetCurrentContext();
5083 const GLuint cmdlen
= 32;
5084 emit_header(gc
->pc
, X_GLrop_CopyTexImage1D
, cmdlen
);
5085 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&target
), 4);
5086 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&level
), 4);
5087 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&internalformat
), 4);
5088 (void) memcpy((void *) (gc
->pc
+ 16), (void *) (&x
), 4);
5089 (void) memcpy((void *) (gc
->pc
+ 20), (void *) (&y
), 4);
5090 (void) memcpy((void *) (gc
->pc
+ 24), (void *) (&width
), 4);
5091 (void) memcpy((void *) (gc
->pc
+ 28), (void *) (&border
), 4);
5093 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
5094 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
5098 #define X_GLrop_CopyTexImage2D 4120
5100 __indirect_glCopyTexImage2D(GLenum target
, GLint level
, GLenum internalformat
,
5101 GLint x
, GLint y
, GLsizei width
, GLsizei height
,
5104 struct glx_context
*const gc
= __glXGetCurrentContext();
5105 const GLuint cmdlen
= 36;
5106 emit_header(gc
->pc
, X_GLrop_CopyTexImage2D
, cmdlen
);
5107 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&target
), 4);
5108 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&level
), 4);
5109 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&internalformat
), 4);
5110 (void) memcpy((void *) (gc
->pc
+ 16), (void *) (&x
), 4);
5111 (void) memcpy((void *) (gc
->pc
+ 20), (void *) (&y
), 4);
5112 (void) memcpy((void *) (gc
->pc
+ 24), (void *) (&width
), 4);
5113 (void) memcpy((void *) (gc
->pc
+ 28), (void *) (&height
), 4);
5114 (void) memcpy((void *) (gc
->pc
+ 32), (void *) (&border
), 4);
5116 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
5117 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
5121 #define X_GLrop_CopyTexSubImage1D 4121
5123 __indirect_glCopyTexSubImage1D(GLenum target
, GLint level
, GLint xoffset
,
5124 GLint x
, GLint y
, GLsizei width
)
5126 struct glx_context
*const gc
= __glXGetCurrentContext();
5127 const GLuint cmdlen
= 28;
5128 emit_header(gc
->pc
, X_GLrop_CopyTexSubImage1D
, cmdlen
);
5129 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&target
), 4);
5130 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&level
), 4);
5131 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&xoffset
), 4);
5132 (void) memcpy((void *) (gc
->pc
+ 16), (void *) (&x
), 4);
5133 (void) memcpy((void *) (gc
->pc
+ 20), (void *) (&y
), 4);
5134 (void) memcpy((void *) (gc
->pc
+ 24), (void *) (&width
), 4);
5136 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
5137 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
5141 #define X_GLrop_CopyTexSubImage2D 4122
5143 __indirect_glCopyTexSubImage2D(GLenum target
, GLint level
, GLint xoffset
,
5144 GLint yoffset
, GLint x
, GLint y
, GLsizei width
,
5147 struct glx_context
*const gc
= __glXGetCurrentContext();
5148 const GLuint cmdlen
= 36;
5149 emit_header(gc
->pc
, X_GLrop_CopyTexSubImage2D
, cmdlen
);
5150 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&target
), 4);
5151 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&level
), 4);
5152 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&xoffset
), 4);
5153 (void) memcpy((void *) (gc
->pc
+ 16), (void *) (&yoffset
), 4);
5154 (void) memcpy((void *) (gc
->pc
+ 20), (void *) (&x
), 4);
5155 (void) memcpy((void *) (gc
->pc
+ 24), (void *) (&y
), 4);
5156 (void) memcpy((void *) (gc
->pc
+ 28), (void *) (&width
), 4);
5157 (void) memcpy((void *) (gc
->pc
+ 32), (void *) (&height
), 4);
5159 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
5160 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
5164 #define X_GLsop_DeleteTextures 144
5166 __indirect_glDeleteTextures(GLsizei n
, const GLuint
* textures
)
5168 struct glx_context
*const gc
= __glXGetCurrentContext();
5169 Display
*const dpy
= gc
->currentDpy
;
5171 const GLuint cmdlen
= 4 + __GLX_PAD((n
* 4));
5174 __glXSetError(gc
, GL_INVALID_VALUE
);
5177 if (__builtin_expect((n
>= 0) && (dpy
!= NULL
), 1)) {
5179 xcb_connection_t
*c
= XGetXCBConnection(dpy
);
5180 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
5181 xcb_glx_delete_textures(c
, gc
->currentContextTag
, n
, textures
);
5184 __glXSetupSingleRequest(gc
, X_GLsop_DeleteTextures
, cmdlen
);
5185 (void) memcpy((void *) (pc
+ 0), (void *) (&n
), 4);
5186 (void) memcpy((void *) (pc
+ 4), (void *) (textures
), (n
* 4));
5189 #endif /* USE_XCB */
5194 #define X_GLvop_DeleteTexturesEXT 12
5196 glDeleteTexturesEXT(GLsizei n
, const GLuint
* textures
)
5198 struct glx_context
*const gc
= __glXGetCurrentContext();
5200 #if defined(GLX_DIRECT_RENDERING) && !defined(GLX_USE_APPLEGL)
5202 GET_DISPATCH()->DeleteTextures(n
, textures
);
5206 struct glx_context
*const gc
= __glXGetCurrentContext();
5207 Display
*const dpy
= gc
->currentDpy
;
5208 const GLuint cmdlen
= 4 + __GLX_PAD((n
* 4));
5210 __glXSetError(gc
, GL_INVALID_VALUE
);
5213 if (__builtin_expect((n
>= 0) && (dpy
!= NULL
), 1)) {
5215 __glXSetupVendorRequest(gc
, X_GLXVendorPrivate
,
5216 X_GLvop_DeleteTexturesEXT
, cmdlen
);
5217 (void) memcpy((void *) (pc
+ 0), (void *) (&n
), 4);
5218 (void) memcpy((void *) (pc
+ 4), (void *) (textures
), (n
* 4));
5226 #define X_GLsop_GenTextures 145
5228 __indirect_glGenTextures(GLsizei n
, GLuint
* textures
)
5230 struct glx_context
*const gc
= __glXGetCurrentContext();
5231 Display
*const dpy
= gc
->currentDpy
;
5233 const GLuint cmdlen
= 4;
5236 __glXSetError(gc
, GL_INVALID_VALUE
);
5239 if (__builtin_expect((n
>= 0) && (dpy
!= NULL
), 1)) {
5241 xcb_connection_t
*c
= XGetXCBConnection(dpy
);
5242 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
5243 xcb_glx_gen_textures_reply_t
*reply
=
5244 xcb_glx_gen_textures_reply(c
,
5245 xcb_glx_gen_textures(c
,
5249 (void) memcpy(textures
, xcb_glx_gen_textures_data(reply
),
5250 xcb_glx_gen_textures_data_length(reply
) *
5255 __glXSetupSingleRequest(gc
, X_GLsop_GenTextures
, cmdlen
);
5256 (void) memcpy((void *) (pc
+ 0), (void *) (&n
), 4);
5257 (void) __glXReadReply(dpy
, 4, textures
, GL_TRUE
);
5260 #endif /* USE_XCB */
5265 #define X_GLvop_GenTexturesEXT 13
5267 glGenTexturesEXT(GLsizei n
, GLuint
* textures
)
5269 struct glx_context
*const gc
= __glXGetCurrentContext();
5271 #if defined(GLX_DIRECT_RENDERING) && !defined(GLX_USE_APPLEGL)
5273 GET_DISPATCH()->GenTextures(n
, textures
);
5277 struct glx_context
*const gc
= __glXGetCurrentContext();
5278 Display
*const dpy
= gc
->currentDpy
;
5279 const GLuint cmdlen
= 4;
5281 __glXSetError(gc
, GL_INVALID_VALUE
);
5284 if (__builtin_expect((n
>= 0) && (dpy
!= NULL
), 1)) {
5286 __glXSetupVendorRequest(gc
, X_GLXVendorPrivateWithReply
,
5287 X_GLvop_GenTexturesEXT
, cmdlen
);
5288 (void) memcpy((void *) (pc
+ 0), (void *) (&n
), 4);
5289 (void) __glXReadReply(dpy
, 4, textures
, GL_TRUE
);
5297 #define X_GLsop_IsTexture 146
5299 __indirect_glIsTexture(GLuint texture
)
5301 struct glx_context
*const gc
= __glXGetCurrentContext();
5302 Display
*const dpy
= gc
->currentDpy
;
5303 GLboolean retval
= (GLboolean
) 0;
5305 const GLuint cmdlen
= 4;
5307 if (__builtin_expect(dpy
!= NULL
, 1)) {
5309 xcb_connection_t
*c
= XGetXCBConnection(dpy
);
5310 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
5311 xcb_glx_is_texture_reply_t
*reply
=
5312 xcb_glx_is_texture_reply(c
,
5313 xcb_glx_is_texture(c
,
5314 gc
->currentContextTag
,
5316 retval
= reply
->ret_val
;
5320 __glXSetupSingleRequest(gc
, X_GLsop_IsTexture
, cmdlen
);
5321 (void) memcpy((void *) (pc
+ 0), (void *) (&texture
), 4);
5322 retval
= (GLboolean
) __glXReadReply(dpy
, 0, NULL
, GL_FALSE
);
5325 #endif /* USE_XCB */
5330 #define X_GLvop_IsTextureEXT 14
5332 glIsTextureEXT(GLuint texture
)
5334 struct glx_context
*const gc
= __glXGetCurrentContext();
5336 #if defined(GLX_DIRECT_RENDERING) && !defined(GLX_USE_APPLEGL)
5338 return GET_DISPATCH()->IsTexture(texture
);
5342 struct glx_context
*const gc
= __glXGetCurrentContext();
5343 Display
*const dpy
= gc
->currentDpy
;
5344 GLboolean retval
= (GLboolean
) 0;
5345 const GLuint cmdlen
= 4;
5346 if (__builtin_expect(dpy
!= NULL
, 1)) {
5348 __glXSetupVendorRequest(gc
, X_GLXVendorPrivateWithReply
,
5349 X_GLvop_IsTextureEXT
, cmdlen
);
5350 (void) memcpy((void *) (pc
+ 0), (void *) (&texture
), 4);
5351 retval
= (GLboolean
) __glXReadReply(dpy
, 0, NULL
, GL_FALSE
);
5359 #define X_GLrop_PrioritizeTextures 4118
5361 __indirect_glPrioritizeTextures(GLsizei n
, const GLuint
* textures
,
5362 const GLclampf
* priorities
)
5364 struct glx_context
*const gc
= __glXGetCurrentContext();
5365 const GLuint cmdlen
= 8 + __GLX_PAD((n
* 4)) + __GLX_PAD((n
* 4));
5367 __glXSetError(gc
, GL_INVALID_VALUE
);
5370 if (__builtin_expect(n
>= 0, 1)) {
5371 emit_header(gc
->pc
, X_GLrop_PrioritizeTextures
, cmdlen
);
5372 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&n
), 4);
5373 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (textures
), (n
* 4));
5374 (void) memcpy((void *) (gc
->pc
+ 8 + (n
* 4)), (void *) (priorities
),
5377 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
5378 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
5384 __glx_TexSubImage_1D2D(unsigned opcode
, unsigned dim
, GLenum target
,
5385 GLint level
, GLint xoffset
, GLint yoffset
,
5386 GLsizei width
, GLsizei height
, GLenum format
,
5387 GLenum type
, const GLvoid
* pixels
)
5389 struct glx_context
*const gc
= __glXGetCurrentContext();
5390 const GLuint compsize
=
5391 (pixels
!= NULL
) ? __glImageSize(width
, height
, 1, format
, type
,
5393 const GLuint cmdlen
= 60 + __GLX_PAD(compsize
);
5394 if (__builtin_expect(gc
->currentDpy
!= NULL
, 1)) {
5395 if (cmdlen
<= gc
->maxSmallRenderCommandSize
) {
5396 if ((gc
->pc
+ cmdlen
) > gc
->bufEnd
) {
5397 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
5399 emit_header(gc
->pc
, opcode
, cmdlen
);
5400 (void) memcpy((void *) (gc
->pc
+ 24), (void *) (&target
), 4);
5401 (void) memcpy((void *) (gc
->pc
+ 28), (void *) (&level
), 4);
5402 (void) memcpy((void *) (gc
->pc
+ 32), (void *) (&xoffset
), 4);
5403 (void) memcpy((void *) (gc
->pc
+ 36), (void *) (&yoffset
), 4);
5404 (void) memcpy((void *) (gc
->pc
+ 40), (void *) (&width
), 4);
5405 (void) memcpy((void *) (gc
->pc
+ 44), (void *) (&height
), 4);
5406 (void) memcpy((void *) (gc
->pc
+ 48), (void *) (&format
), 4);
5407 (void) memcpy((void *) (gc
->pc
+ 52), (void *) (&type
), 4);
5408 (void) memset((void *) (gc
->pc
+ 56), 0, 4);
5410 (*gc
->fillImage
) (gc
, dim
, width
, height
, 1, format
, type
,
5411 pixels
, gc
->pc
+ 60, gc
->pc
+ 4);
5413 (void) memcpy(gc
->pc
+ 4, default_pixel_store_2D
,
5414 default_pixel_store_2D_size
);
5417 if (gc
->pc
> gc
->limit
) {
5418 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
5421 const GLint op
= opcode
;
5422 const GLuint cmdlenLarge
= cmdlen
+ 4;
5423 GLubyte
*const pc
= __glXFlushRenderBuffer(gc
, gc
->pc
);
5424 (void) memcpy((void *) (pc
+ 0), (void *) (&cmdlenLarge
), 4);
5425 (void) memcpy((void *) (pc
+ 4), (void *) (&op
), 4);
5426 (void) memcpy((void *) (pc
+ 28), (void *) (&target
), 4);
5427 (void) memcpy((void *) (pc
+ 32), (void *) (&level
), 4);
5428 (void) memcpy((void *) (pc
+ 36), (void *) (&xoffset
), 4);
5429 (void) memcpy((void *) (pc
+ 40), (void *) (&yoffset
), 4);
5430 (void) memcpy((void *) (pc
+ 44), (void *) (&width
), 4);
5431 (void) memcpy((void *) (pc
+ 48), (void *) (&height
), 4);
5432 (void) memcpy((void *) (pc
+ 52), (void *) (&format
), 4);
5433 (void) memcpy((void *) (pc
+ 56), (void *) (&type
), 4);
5434 (void) memset((void *) (pc
+ 60), 0, 4);
5435 __glXSendLargeImage(gc
, compsize
, dim
, width
, height
, 1, format
,
5436 type
, pixels
, pc
+ 64, pc
+ 8);
5441 #define X_GLrop_TexSubImage1D 4099
5443 __indirect_glTexSubImage1D(GLenum target
, GLint level
, GLint xoffset
,
5444 GLsizei width
, GLenum format
, GLenum type
,
5445 const GLvoid
* pixels
)
5447 __glx_TexSubImage_1D2D(X_GLrop_TexSubImage1D
, 1, target
, level
, xoffset
,
5448 1, width
, 1, format
, type
, pixels
);
5451 #define X_GLrop_TexSubImage2D 4100
5453 __indirect_glTexSubImage2D(GLenum target
, GLint level
, GLint xoffset
,
5454 GLint yoffset
, GLsizei width
, GLsizei height
,
5455 GLenum format
, GLenum type
, const GLvoid
* pixels
)
5457 __glx_TexSubImage_1D2D(X_GLrop_TexSubImage2D
, 2, target
, level
, xoffset
,
5458 yoffset
, width
, height
, format
, type
, pixels
);
5461 #define X_GLrop_BlendColor 4096
5463 __indirect_glBlendColor(GLclampf red
, GLclampf green
, GLclampf blue
,
5466 struct glx_context
*const gc
= __glXGetCurrentContext();
5467 const GLuint cmdlen
= 20;
5468 emit_header(gc
->pc
, X_GLrop_BlendColor
, cmdlen
);
5469 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&red
), 4);
5470 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&green
), 4);
5471 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&blue
), 4);
5472 (void) memcpy((void *) (gc
->pc
+ 16), (void *) (&alpha
), 4);
5474 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
5475 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
5479 #define X_GLrop_BlendEquation 4097
5481 __indirect_glBlendEquation(GLenum mode
)
5483 struct glx_context
*const gc
= __glXGetCurrentContext();
5484 const GLuint cmdlen
= 8;
5485 emit_header(gc
->pc
, X_GLrop_BlendEquation
, cmdlen
);
5486 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&mode
), 4);
5488 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
5489 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
5493 #define X_GLrop_ColorTable 2053
5495 __indirect_glColorTable(GLenum target
, GLenum internalformat
, GLsizei width
,
5496 GLenum format
, GLenum type
, const GLvoid
* table
)
5498 struct glx_context
*const gc
= __glXGetCurrentContext();
5499 const GLuint compsize
=
5500 (table
!= NULL
) ? __glImageSize(width
, 1, 1, format
, type
,
5502 const GLuint cmdlen
= 44 + __GLX_PAD(compsize
);
5503 if (__builtin_expect(gc
->currentDpy
!= NULL
, 1)) {
5504 if (cmdlen
<= gc
->maxSmallRenderCommandSize
) {
5505 if ((gc
->pc
+ cmdlen
) > gc
->bufEnd
) {
5506 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
5508 emit_header(gc
->pc
, X_GLrop_ColorTable
, cmdlen
);
5509 (void) memcpy((void *) (gc
->pc
+ 24), (void *) (&target
), 4);
5510 (void) memcpy((void *) (gc
->pc
+ 28), (void *) (&internalformat
),
5512 (void) memcpy((void *) (gc
->pc
+ 32), (void *) (&width
), 4);
5513 (void) memcpy((void *) (gc
->pc
+ 36), (void *) (&format
), 4);
5514 (void) memcpy((void *) (gc
->pc
+ 40), (void *) (&type
), 4);
5516 (*gc
->fillImage
) (gc
, 1, width
, 1, 1, format
, type
, table
,
5517 gc
->pc
+ 44, gc
->pc
+ 4);
5519 (void) memcpy(gc
->pc
+ 4, default_pixel_store_1D
,
5520 default_pixel_store_1D_size
);
5523 if (gc
->pc
> gc
->limit
) {
5524 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
5527 const GLint op
= X_GLrop_ColorTable
;
5528 const GLuint cmdlenLarge
= cmdlen
+ 4;
5529 GLubyte
*const pc
= __glXFlushRenderBuffer(gc
, gc
->pc
);
5530 (void) memcpy((void *) (pc
+ 0), (void *) (&cmdlenLarge
), 4);
5531 (void) memcpy((void *) (pc
+ 4), (void *) (&op
), 4);
5532 (void) memcpy((void *) (pc
+ 28), (void *) (&target
), 4);
5533 (void) memcpy((void *) (pc
+ 32), (void *) (&internalformat
), 4);
5534 (void) memcpy((void *) (pc
+ 36), (void *) (&width
), 4);
5535 (void) memcpy((void *) (pc
+ 40), (void *) (&format
), 4);
5536 (void) memcpy((void *) (pc
+ 44), (void *) (&type
), 4);
5537 __glXSendLargeImage(gc
, compsize
, 1, width
, 1, 1, format
, type
,
5538 table
, pc
+ 48, pc
+ 8);
5543 #define X_GLrop_ColorTableParameterfv 2054
5545 __indirect_glColorTableParameterfv(GLenum target
, GLenum pname
,
5546 const GLfloat
* params
)
5548 struct glx_context
*const gc
= __glXGetCurrentContext();
5549 const GLuint compsize
= __glColorTableParameterfv_size(pname
);
5550 const GLuint cmdlen
= 12 + __GLX_PAD((compsize
* 4));
5551 emit_header(gc
->pc
, X_GLrop_ColorTableParameterfv
, cmdlen
);
5552 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&target
), 4);
5553 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&pname
), 4);
5554 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (params
), (compsize
* 4));
5556 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
5557 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
5561 #define X_GLrop_ColorTableParameteriv 2055
5563 __indirect_glColorTableParameteriv(GLenum target
, GLenum pname
,
5564 const GLint
* params
)
5566 struct glx_context
*const gc
= __glXGetCurrentContext();
5567 const GLuint compsize
= __glColorTableParameteriv_size(pname
);
5568 const GLuint cmdlen
= 12 + __GLX_PAD((compsize
* 4));
5569 emit_header(gc
->pc
, X_GLrop_ColorTableParameteriv
, cmdlen
);
5570 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&target
), 4);
5571 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&pname
), 4);
5572 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (params
), (compsize
* 4));
5574 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
5575 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
5579 #define X_GLrop_CopyColorTable 2056
5581 __indirect_glCopyColorTable(GLenum target
, GLenum internalformat
, GLint x
,
5582 GLint y
, GLsizei width
)
5584 struct glx_context
*const gc
= __glXGetCurrentContext();
5585 const GLuint cmdlen
= 24;
5586 emit_header(gc
->pc
, X_GLrop_CopyColorTable
, cmdlen
);
5587 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&target
), 4);
5588 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&internalformat
), 4);
5589 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&x
), 4);
5590 (void) memcpy((void *) (gc
->pc
+ 16), (void *) (&y
), 4);
5591 (void) memcpy((void *) (gc
->pc
+ 20), (void *) (&width
), 4);
5593 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
5594 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
5598 #define X_GLsop_GetColorTable 147
5600 __indirect_glGetColorTable(GLenum target
, GLenum format
, GLenum type
,
5603 struct glx_context
*const gc
= __glXGetCurrentContext();
5604 const __GLXattribute
*const state
= gc
->client_state_private
;
5605 Display
*const dpy
= gc
->currentDpy
;
5607 const GLuint cmdlen
= 16;
5609 if (__builtin_expect(dpy
!= NULL
, 1)) {
5611 xcb_connection_t
*c
= XGetXCBConnection(dpy
);
5612 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
5613 xcb_glx_get_color_table_reply_t
*reply
=
5614 xcb_glx_get_color_table_reply(c
,
5615 xcb_glx_get_color_table(c
,
5625 (void) memcpy(table
, xcb_glx_get_color_table_data(reply
),
5626 xcb_glx_get_color_table_data_length(reply
) *
5631 __glXSetupSingleRequest(gc
, X_GLsop_GetColorTable
, cmdlen
);
5632 (void) memcpy((void *) (pc
+ 0), (void *) (&target
), 4);
5633 (void) memcpy((void *) (pc
+ 4), (void *) (&format
), 4);
5634 (void) memcpy((void *) (pc
+ 8), (void *) (&type
), 4);
5635 *(int32_t *) (pc
+ 12) = 0;
5636 *(int8_t *) (pc
+ 12) = state
->storePack
.swapEndian
;
5637 __glXReadPixelReply(dpy
, gc
, 1, 0, 0, 0, format
, type
, table
,
5641 #endif /* USE_XCB */
5646 #define X_GLvop_GetColorTableSGI 4098
5648 glGetColorTableEXT(GLenum target
, GLenum format
, GLenum type
, GLvoid
* table
)
5650 struct glx_context
*const gc
= __glXGetCurrentContext();
5652 #if defined(GLX_DIRECT_RENDERING) && !defined(GLX_USE_APPLEGL)
5654 GET_DISPATCH()->GetColorTable(target
, format
, type
, table
);
5658 struct glx_context
*const gc
= __glXGetCurrentContext();
5659 const __GLXattribute
*const state
= gc
->client_state_private
;
5660 Display
*const dpy
= gc
->currentDpy
;
5661 const GLuint cmdlen
= 16;
5662 if (__builtin_expect(dpy
!= NULL
, 1)) {
5664 __glXSetupVendorRequest(gc
, X_GLXVendorPrivateWithReply
,
5665 X_GLvop_GetColorTableSGI
, cmdlen
);
5666 (void) memcpy((void *) (pc
+ 0), (void *) (&target
), 4);
5667 (void) memcpy((void *) (pc
+ 4), (void *) (&format
), 4);
5668 (void) memcpy((void *) (pc
+ 8), (void *) (&type
), 4);
5669 *(int32_t *) (pc
+ 12) = 0;
5670 *(int8_t *) (pc
+ 12) = state
->storePack
.swapEndian
;
5671 __glXReadPixelReply(dpy
, gc
, 1, 0, 0, 0, format
, type
, table
,
5680 #define X_GLsop_GetColorTableParameterfv 148
5682 __indirect_glGetColorTableParameterfv(GLenum target
, GLenum pname
,
5685 struct glx_context
*const gc
= __glXGetCurrentContext();
5686 Display
*const dpy
= gc
->currentDpy
;
5688 const GLuint cmdlen
= 8;
5690 if (__builtin_expect(dpy
!= NULL
, 1)) {
5692 xcb_connection_t
*c
= XGetXCBConnection(dpy
);
5693 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
5694 xcb_glx_get_color_table_parameterfv_reply_t
*reply
=
5695 xcb_glx_get_color_table_parameterfv_reply(c
,
5696 xcb_glx_get_color_table_parameterfv
5698 gc
->currentContextTag
,
5699 target
, pname
), NULL
);
5700 if (xcb_glx_get_color_table_parameterfv_data_length(reply
) == 0)
5701 (void) memcpy(params
, &reply
->datum
, sizeof(reply
->datum
));
5703 (void) memcpy(params
,
5704 xcb_glx_get_color_table_parameterfv_data(reply
),
5705 xcb_glx_get_color_table_parameterfv_data_length
5706 (reply
) * sizeof(GLfloat
));
5710 __glXSetupSingleRequest(gc
, X_GLsop_GetColorTableParameterfv
,
5712 (void) memcpy((void *) (pc
+ 0), (void *) (&target
), 4);
5713 (void) memcpy((void *) (pc
+ 4), (void *) (&pname
), 4);
5714 (void) __glXReadReply(dpy
, 4, params
, GL_FALSE
);
5717 #endif /* USE_XCB */
5722 #define X_GLvop_GetColorTableParameterfvSGI 4099
5724 glGetColorTableParameterfvEXT(GLenum target
, GLenum pname
, GLfloat
* params
)
5726 struct glx_context
*const gc
= __glXGetCurrentContext();
5728 #if defined(GLX_DIRECT_RENDERING) && !defined(GLX_USE_APPLEGL)
5730 GET_DISPATCH()->GetColorTableParameterfv(target
, pname
, params
);
5734 struct glx_context
*const gc
= __glXGetCurrentContext();
5735 Display
*const dpy
= gc
->currentDpy
;
5736 const GLuint cmdlen
= 8;
5737 if (__builtin_expect(dpy
!= NULL
, 1)) {
5739 __glXSetupVendorRequest(gc
, X_GLXVendorPrivateWithReply
,
5740 X_GLvop_GetColorTableParameterfvSGI
,
5742 (void) memcpy((void *) (pc
+ 0), (void *) (&target
), 4);
5743 (void) memcpy((void *) (pc
+ 4), (void *) (&pname
), 4);
5744 (void) __glXReadReply(dpy
, 4, params
, GL_FALSE
);
5752 #define X_GLsop_GetColorTableParameteriv 149
5754 __indirect_glGetColorTableParameteriv(GLenum target
, GLenum pname
,
5757 struct glx_context
*const gc
= __glXGetCurrentContext();
5758 Display
*const dpy
= gc
->currentDpy
;
5760 const GLuint cmdlen
= 8;
5762 if (__builtin_expect(dpy
!= NULL
, 1)) {
5764 xcb_connection_t
*c
= XGetXCBConnection(dpy
);
5765 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
5766 xcb_glx_get_color_table_parameteriv_reply_t
*reply
=
5767 xcb_glx_get_color_table_parameteriv_reply(c
,
5768 xcb_glx_get_color_table_parameteriv
5770 gc
->currentContextTag
,
5771 target
, pname
), NULL
);
5772 if (xcb_glx_get_color_table_parameteriv_data_length(reply
) == 0)
5773 (void) memcpy(params
, &reply
->datum
, sizeof(reply
->datum
));
5775 (void) memcpy(params
,
5776 xcb_glx_get_color_table_parameteriv_data(reply
),
5777 xcb_glx_get_color_table_parameteriv_data_length
5778 (reply
) * sizeof(GLint
));
5782 __glXSetupSingleRequest(gc
, X_GLsop_GetColorTableParameteriv
,
5784 (void) memcpy((void *) (pc
+ 0), (void *) (&target
), 4);
5785 (void) memcpy((void *) (pc
+ 4), (void *) (&pname
), 4);
5786 (void) __glXReadReply(dpy
, 4, params
, GL_FALSE
);
5789 #endif /* USE_XCB */
5794 #define X_GLvop_GetColorTableParameterivSGI 4100
5796 glGetColorTableParameterivEXT(GLenum target
, GLenum pname
, GLint
* params
)
5798 struct glx_context
*const gc
= __glXGetCurrentContext();
5800 #if defined(GLX_DIRECT_RENDERING) && !defined(GLX_USE_APPLEGL)
5802 GET_DISPATCH()->GetColorTableParameteriv(target
, pname
, params
);
5806 struct glx_context
*const gc
= __glXGetCurrentContext();
5807 Display
*const dpy
= gc
->currentDpy
;
5808 const GLuint cmdlen
= 8;
5809 if (__builtin_expect(dpy
!= NULL
, 1)) {
5811 __glXSetupVendorRequest(gc
, X_GLXVendorPrivateWithReply
,
5812 X_GLvop_GetColorTableParameterivSGI
,
5814 (void) memcpy((void *) (pc
+ 0), (void *) (&target
), 4);
5815 (void) memcpy((void *) (pc
+ 4), (void *) (&pname
), 4);
5816 (void) __glXReadReply(dpy
, 4, params
, GL_FALSE
);
5824 #define X_GLrop_ColorSubTable 195
5826 __indirect_glColorSubTable(GLenum target
, GLsizei start
, GLsizei count
,
5827 GLenum format
, GLenum type
, const GLvoid
* data
)
5829 struct glx_context
*const gc
= __glXGetCurrentContext();
5830 const GLuint compsize
=
5831 (data
!= NULL
) ? __glImageSize(count
, 1, 1, format
, type
, target
) : 0;
5832 const GLuint cmdlen
= 44 + __GLX_PAD(compsize
);
5833 if (__builtin_expect(gc
->currentDpy
!= NULL
, 1)) {
5834 if (cmdlen
<= gc
->maxSmallRenderCommandSize
) {
5835 if ((gc
->pc
+ cmdlen
) > gc
->bufEnd
) {
5836 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
5838 emit_header(gc
->pc
, X_GLrop_ColorSubTable
, cmdlen
);
5839 (void) memcpy((void *) (gc
->pc
+ 24), (void *) (&target
), 4);
5840 (void) memcpy((void *) (gc
->pc
+ 28), (void *) (&start
), 4);
5841 (void) memcpy((void *) (gc
->pc
+ 32), (void *) (&count
), 4);
5842 (void) memcpy((void *) (gc
->pc
+ 36), (void *) (&format
), 4);
5843 (void) memcpy((void *) (gc
->pc
+ 40), (void *) (&type
), 4);
5845 (*gc
->fillImage
) (gc
, 1, count
, 1, 1, format
, type
, data
,
5846 gc
->pc
+ 44, gc
->pc
+ 4);
5848 (void) memcpy(gc
->pc
+ 4, default_pixel_store_1D
,
5849 default_pixel_store_1D_size
);
5852 if (gc
->pc
> gc
->limit
) {
5853 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
5856 const GLint op
= X_GLrop_ColorSubTable
;
5857 const GLuint cmdlenLarge
= cmdlen
+ 4;
5858 GLubyte
*const pc
= __glXFlushRenderBuffer(gc
, gc
->pc
);
5859 (void) memcpy((void *) (pc
+ 0), (void *) (&cmdlenLarge
), 4);
5860 (void) memcpy((void *) (pc
+ 4), (void *) (&op
), 4);
5861 (void) memcpy((void *) (pc
+ 28), (void *) (&target
), 4);
5862 (void) memcpy((void *) (pc
+ 32), (void *) (&start
), 4);
5863 (void) memcpy((void *) (pc
+ 36), (void *) (&count
), 4);
5864 (void) memcpy((void *) (pc
+ 40), (void *) (&format
), 4);
5865 (void) memcpy((void *) (pc
+ 44), (void *) (&type
), 4);
5866 __glXSendLargeImage(gc
, compsize
, 1, count
, 1, 1, format
, type
,
5867 data
, pc
+ 48, pc
+ 8);
5872 #define X_GLrop_CopyColorSubTable 196
5874 __indirect_glCopyColorSubTable(GLenum target
, GLsizei start
, GLint x
, GLint y
,
5877 struct glx_context
*const gc
= __glXGetCurrentContext();
5878 const GLuint cmdlen
= 24;
5879 emit_header(gc
->pc
, X_GLrop_CopyColorSubTable
, cmdlen
);
5880 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&target
), 4);
5881 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&start
), 4);
5882 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&x
), 4);
5883 (void) memcpy((void *) (gc
->pc
+ 16), (void *) (&y
), 4);
5884 (void) memcpy((void *) (gc
->pc
+ 20), (void *) (&width
), 4);
5886 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
5887 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
5892 __glx_ConvolutionFilter_1D2D(unsigned opcode
, unsigned dim
, GLenum target
,
5893 GLenum internalformat
, GLsizei width
,
5894 GLsizei height
, GLenum format
, GLenum type
,
5895 const GLvoid
* image
)
5897 struct glx_context
*const gc
= __glXGetCurrentContext();
5898 const GLuint compsize
=
5899 (image
!= NULL
) ? __glImageSize(width
, height
, 1, format
, type
,
5901 const GLuint cmdlen
= 48 + __GLX_PAD(compsize
);
5902 if (__builtin_expect(gc
->currentDpy
!= NULL
, 1)) {
5903 if (cmdlen
<= gc
->maxSmallRenderCommandSize
) {
5904 if ((gc
->pc
+ cmdlen
) > gc
->bufEnd
) {
5905 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
5907 emit_header(gc
->pc
, opcode
, cmdlen
);
5908 (void) memcpy((void *) (gc
->pc
+ 24), (void *) (&target
), 4);
5909 (void) memcpy((void *) (gc
->pc
+ 28), (void *) (&internalformat
),
5911 (void) memcpy((void *) (gc
->pc
+ 32), (void *) (&width
), 4);
5912 (void) memcpy((void *) (gc
->pc
+ 36), (void *) (&height
), 4);
5913 (void) memcpy((void *) (gc
->pc
+ 40), (void *) (&format
), 4);
5914 (void) memcpy((void *) (gc
->pc
+ 44), (void *) (&type
), 4);
5916 (*gc
->fillImage
) (gc
, dim
, width
, height
, 1, format
, type
,
5917 image
, gc
->pc
+ 48, gc
->pc
+ 4);
5919 (void) memcpy(gc
->pc
+ 4, default_pixel_store_2D
,
5920 default_pixel_store_2D_size
);
5923 if (gc
->pc
> gc
->limit
) {
5924 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
5927 const GLint op
= opcode
;
5928 const GLuint cmdlenLarge
= cmdlen
+ 4;
5929 GLubyte
*const pc
= __glXFlushRenderBuffer(gc
, gc
->pc
);
5930 (void) memcpy((void *) (pc
+ 0), (void *) (&cmdlenLarge
), 4);
5931 (void) memcpy((void *) (pc
+ 4), (void *) (&op
), 4);
5932 (void) memcpy((void *) (pc
+ 28), (void *) (&target
), 4);
5933 (void) memcpy((void *) (pc
+ 32), (void *) (&internalformat
), 4);
5934 (void) memcpy((void *) (pc
+ 36), (void *) (&width
), 4);
5935 (void) memcpy((void *) (pc
+ 40), (void *) (&height
), 4);
5936 (void) memcpy((void *) (pc
+ 44), (void *) (&format
), 4);
5937 (void) memcpy((void *) (pc
+ 48), (void *) (&type
), 4);
5938 __glXSendLargeImage(gc
, compsize
, dim
, width
, height
, 1, format
,
5939 type
, image
, pc
+ 52, pc
+ 8);
5944 #define X_GLrop_ConvolutionFilter1D 4101
5946 __indirect_glConvolutionFilter1D(GLenum target
, GLenum internalformat
,
5947 GLsizei width
, GLenum format
, GLenum type
,
5948 const GLvoid
* image
)
5950 __glx_ConvolutionFilter_1D2D(X_GLrop_ConvolutionFilter1D
, 1, target
,
5951 internalformat
, width
, 1, format
, type
,
5955 #define X_GLrop_ConvolutionFilter2D 4102
5957 __indirect_glConvolutionFilter2D(GLenum target
, GLenum internalformat
,
5958 GLsizei width
, GLsizei height
, GLenum format
,
5959 GLenum type
, const GLvoid
* image
)
5961 __glx_ConvolutionFilter_1D2D(X_GLrop_ConvolutionFilter2D
, 2, target
,
5962 internalformat
, width
, height
, format
, type
,
5966 #define X_GLrop_ConvolutionParameterf 4103
5968 __indirect_glConvolutionParameterf(GLenum target
, GLenum pname
,
5971 struct glx_context
*const gc
= __glXGetCurrentContext();
5972 const GLuint cmdlen
= 16;
5973 emit_header(gc
->pc
, X_GLrop_ConvolutionParameterf
, cmdlen
);
5974 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&target
), 4);
5975 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&pname
), 4);
5976 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (¶ms
), 4);
5978 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
5979 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
5983 #define X_GLrop_ConvolutionParameterfv 4104
5985 __indirect_glConvolutionParameterfv(GLenum target
, GLenum pname
,
5986 const GLfloat
* params
)
5988 struct glx_context
*const gc
= __glXGetCurrentContext();
5989 const GLuint compsize
= __glConvolutionParameterfv_size(pname
);
5990 const GLuint cmdlen
= 12 + __GLX_PAD((compsize
* 4));
5991 emit_header(gc
->pc
, X_GLrop_ConvolutionParameterfv
, cmdlen
);
5992 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&target
), 4);
5993 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&pname
), 4);
5994 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (params
), (compsize
* 4));
5996 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
5997 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
6001 #define X_GLrop_ConvolutionParameteri 4105
6003 __indirect_glConvolutionParameteri(GLenum target
, GLenum pname
, GLint params
)
6005 struct glx_context
*const gc
= __glXGetCurrentContext();
6006 const GLuint cmdlen
= 16;
6007 emit_header(gc
->pc
, X_GLrop_ConvolutionParameteri
, cmdlen
);
6008 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&target
), 4);
6009 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&pname
), 4);
6010 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (¶ms
), 4);
6012 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
6013 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
6017 #define X_GLrop_ConvolutionParameteriv 4106
6019 __indirect_glConvolutionParameteriv(GLenum target
, GLenum pname
,
6020 const GLint
* params
)
6022 struct glx_context
*const gc
= __glXGetCurrentContext();
6023 const GLuint compsize
= __glConvolutionParameteriv_size(pname
);
6024 const GLuint cmdlen
= 12 + __GLX_PAD((compsize
* 4));
6025 emit_header(gc
->pc
, X_GLrop_ConvolutionParameteriv
, cmdlen
);
6026 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&target
), 4);
6027 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&pname
), 4);
6028 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (params
), (compsize
* 4));
6030 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
6031 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
6035 #define X_GLrop_CopyConvolutionFilter1D 4107
6037 __indirect_glCopyConvolutionFilter1D(GLenum target
, GLenum internalformat
,
6038 GLint x
, GLint y
, GLsizei width
)
6040 struct glx_context
*const gc
= __glXGetCurrentContext();
6041 const GLuint cmdlen
= 24;
6042 emit_header(gc
->pc
, X_GLrop_CopyConvolutionFilter1D
, cmdlen
);
6043 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&target
), 4);
6044 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&internalformat
), 4);
6045 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&x
), 4);
6046 (void) memcpy((void *) (gc
->pc
+ 16), (void *) (&y
), 4);
6047 (void) memcpy((void *) (gc
->pc
+ 20), (void *) (&width
), 4);
6049 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
6050 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
6054 #define X_GLrop_CopyConvolutionFilter2D 4108
6056 __indirect_glCopyConvolutionFilter2D(GLenum target
, GLenum internalformat
,
6057 GLint x
, GLint y
, GLsizei width
,
6060 struct glx_context
*const gc
= __glXGetCurrentContext();
6061 const GLuint cmdlen
= 28;
6062 emit_header(gc
->pc
, X_GLrop_CopyConvolutionFilter2D
, cmdlen
);
6063 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&target
), 4);
6064 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&internalformat
), 4);
6065 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&x
), 4);
6066 (void) memcpy((void *) (gc
->pc
+ 16), (void *) (&y
), 4);
6067 (void) memcpy((void *) (gc
->pc
+ 20), (void *) (&width
), 4);
6068 (void) memcpy((void *) (gc
->pc
+ 24), (void *) (&height
), 4);
6070 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
6071 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
6075 #define X_GLsop_GetConvolutionFilter 150
6077 __indirect_glGetConvolutionFilter(GLenum target
, GLenum format
, GLenum type
,
6080 struct glx_context
*const gc
= __glXGetCurrentContext();
6081 const __GLXattribute
*const state
= gc
->client_state_private
;
6082 Display
*const dpy
= gc
->currentDpy
;
6084 const GLuint cmdlen
= 16;
6086 if (__builtin_expect(dpy
!= NULL
, 1)) {
6088 xcb_connection_t
*c
= XGetXCBConnection(dpy
);
6089 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
6090 xcb_glx_get_convolution_filter_reply_t
*reply
=
6091 xcb_glx_get_convolution_filter_reply(c
,
6092 xcb_glx_get_convolution_filter
6093 (c
, gc
->currentContextTag
,
6094 target
, format
, type
,
6097 (void) memcpy(image
, xcb_glx_get_convolution_filter_data(reply
),
6098 xcb_glx_get_convolution_filter_data_length(reply
) *
6103 __glXSetupSingleRequest(gc
, X_GLsop_GetConvolutionFilter
, cmdlen
);
6104 (void) memcpy((void *) (pc
+ 0), (void *) (&target
), 4);
6105 (void) memcpy((void *) (pc
+ 4), (void *) (&format
), 4);
6106 (void) memcpy((void *) (pc
+ 8), (void *) (&type
), 4);
6107 *(int32_t *) (pc
+ 12) = 0;
6108 *(int8_t *) (pc
+ 12) = state
->storePack
.swapEndian
;
6109 __glXReadPixelReply(dpy
, gc
, 2, 0, 0, 0, format
, type
, image
,
6113 #endif /* USE_XCB */
6118 #define X_GLvop_GetConvolutionFilterEXT 1
6120 gl_dispatch_stub_356(GLenum target
, GLenum format
, GLenum type
,
6123 struct glx_context
*const gc
= __glXGetCurrentContext();
6125 #if defined(GLX_DIRECT_RENDERING) && !defined(GLX_USE_APPLEGL)
6127 GET_DISPATCH()->GetConvolutionFilter(target
, format
, type
, image
);
6131 struct glx_context
*const gc
= __glXGetCurrentContext();
6132 const __GLXattribute
*const state
= gc
->client_state_private
;
6133 Display
*const dpy
= gc
->currentDpy
;
6134 const GLuint cmdlen
= 16;
6135 if (__builtin_expect(dpy
!= NULL
, 1)) {
6137 __glXSetupVendorRequest(gc
, X_GLXVendorPrivateWithReply
,
6138 X_GLvop_GetConvolutionFilterEXT
,
6140 (void) memcpy((void *) (pc
+ 0), (void *) (&target
), 4);
6141 (void) memcpy((void *) (pc
+ 4), (void *) (&format
), 4);
6142 (void) memcpy((void *) (pc
+ 8), (void *) (&type
), 4);
6143 *(int32_t *) (pc
+ 12) = 0;
6144 *(int8_t *) (pc
+ 12) = state
->storePack
.swapEndian
;
6145 __glXReadPixelReply(dpy
, gc
, 2, 0, 0, 0, format
, type
, image
,
6154 #define X_GLsop_GetConvolutionParameterfv 151
6156 __indirect_glGetConvolutionParameterfv(GLenum target
, GLenum pname
,
6159 struct glx_context
*const gc
= __glXGetCurrentContext();
6160 Display
*const dpy
= gc
->currentDpy
;
6162 const GLuint cmdlen
= 8;
6164 if (__builtin_expect(dpy
!= NULL
, 1)) {
6166 xcb_connection_t
*c
= XGetXCBConnection(dpy
);
6167 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
6168 xcb_glx_get_convolution_parameterfv_reply_t
*reply
=
6169 xcb_glx_get_convolution_parameterfv_reply(c
,
6170 xcb_glx_get_convolution_parameterfv
6172 gc
->currentContextTag
,
6173 target
, pname
), NULL
);
6174 if (xcb_glx_get_convolution_parameterfv_data_length(reply
) == 0)
6175 (void) memcpy(params
, &reply
->datum
, sizeof(reply
->datum
));
6177 (void) memcpy(params
,
6178 xcb_glx_get_convolution_parameterfv_data(reply
),
6179 xcb_glx_get_convolution_parameterfv_data_length
6180 (reply
) * sizeof(GLfloat
));
6184 __glXSetupSingleRequest(gc
, X_GLsop_GetConvolutionParameterfv
,
6186 (void) memcpy((void *) (pc
+ 0), (void *) (&target
), 4);
6187 (void) memcpy((void *) (pc
+ 4), (void *) (&pname
), 4);
6188 (void) __glXReadReply(dpy
, 4, params
, GL_FALSE
);
6191 #endif /* USE_XCB */
6196 #define X_GLvop_GetConvolutionParameterfvEXT 2
6198 gl_dispatch_stub_357(GLenum target
, GLenum pname
, GLfloat
* params
)
6200 struct glx_context
*const gc
= __glXGetCurrentContext();
6202 #if defined(GLX_DIRECT_RENDERING) && !defined(GLX_USE_APPLEGL)
6204 GET_DISPATCH()->GetConvolutionParameterfv(target
, pname
, params
);
6208 struct glx_context
*const gc
= __glXGetCurrentContext();
6209 Display
*const dpy
= gc
->currentDpy
;
6210 const GLuint cmdlen
= 8;
6211 if (__builtin_expect(dpy
!= NULL
, 1)) {
6213 __glXSetupVendorRequest(gc
, X_GLXVendorPrivateWithReply
,
6214 X_GLvop_GetConvolutionParameterfvEXT
,
6216 (void) memcpy((void *) (pc
+ 0), (void *) (&target
), 4);
6217 (void) memcpy((void *) (pc
+ 4), (void *) (&pname
), 4);
6218 (void) __glXReadReply(dpy
, 4, params
, GL_FALSE
);
6226 #define X_GLsop_GetConvolutionParameteriv 152
6228 __indirect_glGetConvolutionParameteriv(GLenum target
, GLenum pname
,
6231 struct glx_context
*const gc
= __glXGetCurrentContext();
6232 Display
*const dpy
= gc
->currentDpy
;
6234 const GLuint cmdlen
= 8;
6236 if (__builtin_expect(dpy
!= NULL
, 1)) {
6238 xcb_connection_t
*c
= XGetXCBConnection(dpy
);
6239 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
6240 xcb_glx_get_convolution_parameteriv_reply_t
*reply
=
6241 xcb_glx_get_convolution_parameteriv_reply(c
,
6242 xcb_glx_get_convolution_parameteriv
6244 gc
->currentContextTag
,
6245 target
, pname
), NULL
);
6246 if (xcb_glx_get_convolution_parameteriv_data_length(reply
) == 0)
6247 (void) memcpy(params
, &reply
->datum
, sizeof(reply
->datum
));
6249 (void) memcpy(params
,
6250 xcb_glx_get_convolution_parameteriv_data(reply
),
6251 xcb_glx_get_convolution_parameteriv_data_length
6252 (reply
) * sizeof(GLint
));
6256 __glXSetupSingleRequest(gc
, X_GLsop_GetConvolutionParameteriv
,
6258 (void) memcpy((void *) (pc
+ 0), (void *) (&target
), 4);
6259 (void) memcpy((void *) (pc
+ 4), (void *) (&pname
), 4);
6260 (void) __glXReadReply(dpy
, 4, params
, GL_FALSE
);
6263 #endif /* USE_XCB */
6268 #define X_GLvop_GetConvolutionParameterivEXT 3
6270 gl_dispatch_stub_358(GLenum target
, GLenum pname
, GLint
* params
)
6272 struct glx_context
*const gc
= __glXGetCurrentContext();
6274 #if defined(GLX_DIRECT_RENDERING) && !defined(GLX_USE_APPLEGL)
6276 GET_DISPATCH()->GetConvolutionParameteriv(target
, pname
, params
);
6280 struct glx_context
*const gc
= __glXGetCurrentContext();
6281 Display
*const dpy
= gc
->currentDpy
;
6282 const GLuint cmdlen
= 8;
6283 if (__builtin_expect(dpy
!= NULL
, 1)) {
6285 __glXSetupVendorRequest(gc
, X_GLXVendorPrivateWithReply
,
6286 X_GLvop_GetConvolutionParameterivEXT
,
6288 (void) memcpy((void *) (pc
+ 0), (void *) (&target
), 4);
6289 (void) memcpy((void *) (pc
+ 4), (void *) (&pname
), 4);
6290 (void) __glXReadReply(dpy
, 4, params
, GL_FALSE
);
6298 #define X_GLsop_GetHistogram 154
6300 __indirect_glGetHistogram(GLenum target
, GLboolean reset
, GLenum format
,
6301 GLenum type
, GLvoid
* values
)
6303 struct glx_context
*const gc
= __glXGetCurrentContext();
6304 const __GLXattribute
*const state
= gc
->client_state_private
;
6305 Display
*const dpy
= gc
->currentDpy
;
6307 const GLuint cmdlen
= 16;
6309 if (__builtin_expect(dpy
!= NULL
, 1)) {
6311 xcb_connection_t
*c
= XGetXCBConnection(dpy
);
6312 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
6313 xcb_glx_get_histogram_reply_t
*reply
=
6314 xcb_glx_get_histogram_reply(c
,
6315 xcb_glx_get_histogram(c
,
6324 (void) memcpy(values
, xcb_glx_get_histogram_data(reply
),
6325 xcb_glx_get_histogram_data_length(reply
) *
6330 __glXSetupSingleRequest(gc
, X_GLsop_GetHistogram
, cmdlen
);
6331 (void) memcpy((void *) (pc
+ 0), (void *) (&target
), 4);
6332 (void) memcpy((void *) (pc
+ 4), (void *) (&format
), 4);
6333 (void) memcpy((void *) (pc
+ 8), (void *) (&type
), 4);
6334 *(int32_t *) (pc
+ 12) = 0;
6335 *(int8_t *) (pc
+ 12) = state
->storePack
.swapEndian
;
6336 *(int8_t *) (pc
+ 13) = reset
;
6337 __glXReadPixelReply(dpy
, gc
, 1, 0, 0, 0, format
, type
, values
,
6341 #endif /* USE_XCB */
6346 #define X_GLvop_GetHistogramEXT 5
6348 gl_dispatch_stub_361(GLenum target
, GLboolean reset
, GLenum format
,
6349 GLenum type
, GLvoid
* values
)
6351 struct glx_context
*const gc
= __glXGetCurrentContext();
6353 #if defined(GLX_DIRECT_RENDERING) && !defined(GLX_USE_APPLEGL)
6355 GET_DISPATCH()->GetHistogram(target
, reset
, format
, type
, values
);
6359 struct glx_context
*const gc
= __glXGetCurrentContext();
6360 const __GLXattribute
*const state
= gc
->client_state_private
;
6361 Display
*const dpy
= gc
->currentDpy
;
6362 const GLuint cmdlen
= 16;
6363 if (__builtin_expect(dpy
!= NULL
, 1)) {
6365 __glXSetupVendorRequest(gc
, X_GLXVendorPrivateWithReply
,
6366 X_GLvop_GetHistogramEXT
, cmdlen
);
6367 (void) memcpy((void *) (pc
+ 0), (void *) (&target
), 4);
6368 (void) memcpy((void *) (pc
+ 4), (void *) (&format
), 4);
6369 (void) memcpy((void *) (pc
+ 8), (void *) (&type
), 4);
6370 *(int32_t *) (pc
+ 12) = 0;
6371 *(int8_t *) (pc
+ 12) = state
->storePack
.swapEndian
;
6372 *(int8_t *) (pc
+ 13) = reset
;
6373 __glXReadPixelReply(dpy
, gc
, 1, 0, 0, 0, format
, type
, values
,
6382 #define X_GLsop_GetHistogramParameterfv 155
6384 __indirect_glGetHistogramParameterfv(GLenum target
, GLenum pname
,
6387 struct glx_context
*const gc
= __glXGetCurrentContext();
6388 Display
*const dpy
= gc
->currentDpy
;
6390 const GLuint cmdlen
= 8;
6392 if (__builtin_expect(dpy
!= NULL
, 1)) {
6394 xcb_connection_t
*c
= XGetXCBConnection(dpy
);
6395 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
6396 xcb_glx_get_histogram_parameterfv_reply_t
*reply
=
6397 xcb_glx_get_histogram_parameterfv_reply(c
,
6398 xcb_glx_get_histogram_parameterfv
6399 (c
, gc
->currentContextTag
,
6400 target
, pname
), NULL
);
6401 if (xcb_glx_get_histogram_parameterfv_data_length(reply
) == 0)
6402 (void) memcpy(params
, &reply
->datum
, sizeof(reply
->datum
));
6404 (void) memcpy(params
,
6405 xcb_glx_get_histogram_parameterfv_data(reply
),
6406 xcb_glx_get_histogram_parameterfv_data_length(reply
)
6411 __glXSetupSingleRequest(gc
, X_GLsop_GetHistogramParameterfv
,
6413 (void) memcpy((void *) (pc
+ 0), (void *) (&target
), 4);
6414 (void) memcpy((void *) (pc
+ 4), (void *) (&pname
), 4);
6415 (void) __glXReadReply(dpy
, 4, params
, GL_FALSE
);
6418 #endif /* USE_XCB */
6423 #define X_GLvop_GetHistogramParameterfvEXT 6
6425 gl_dispatch_stub_362(GLenum target
, GLenum pname
, GLfloat
* params
)
6427 struct glx_context
*const gc
= __glXGetCurrentContext();
6429 #if defined(GLX_DIRECT_RENDERING) && !defined(GLX_USE_APPLEGL)
6431 GET_DISPATCH()->GetHistogramParameterfv(target
, pname
, params
);
6435 struct glx_context
*const gc
= __glXGetCurrentContext();
6436 Display
*const dpy
= gc
->currentDpy
;
6437 const GLuint cmdlen
= 8;
6438 if (__builtin_expect(dpy
!= NULL
, 1)) {
6440 __glXSetupVendorRequest(gc
, X_GLXVendorPrivateWithReply
,
6441 X_GLvop_GetHistogramParameterfvEXT
,
6443 (void) memcpy((void *) (pc
+ 0), (void *) (&target
), 4);
6444 (void) memcpy((void *) (pc
+ 4), (void *) (&pname
), 4);
6445 (void) __glXReadReply(dpy
, 4, params
, GL_FALSE
);
6453 #define X_GLsop_GetHistogramParameteriv 156
6455 __indirect_glGetHistogramParameteriv(GLenum target
, GLenum pname
,
6458 struct glx_context
*const gc
= __glXGetCurrentContext();
6459 Display
*const dpy
= gc
->currentDpy
;
6461 const GLuint cmdlen
= 8;
6463 if (__builtin_expect(dpy
!= NULL
, 1)) {
6465 xcb_connection_t
*c
= XGetXCBConnection(dpy
);
6466 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
6467 xcb_glx_get_histogram_parameteriv_reply_t
*reply
=
6468 xcb_glx_get_histogram_parameteriv_reply(c
,
6469 xcb_glx_get_histogram_parameteriv
6470 (c
, gc
->currentContextTag
,
6471 target
, pname
), NULL
);
6472 if (xcb_glx_get_histogram_parameteriv_data_length(reply
) == 0)
6473 (void) memcpy(params
, &reply
->datum
, sizeof(reply
->datum
));
6475 (void) memcpy(params
,
6476 xcb_glx_get_histogram_parameteriv_data(reply
),
6477 xcb_glx_get_histogram_parameteriv_data_length(reply
)
6482 __glXSetupSingleRequest(gc
, X_GLsop_GetHistogramParameteriv
,
6484 (void) memcpy((void *) (pc
+ 0), (void *) (&target
), 4);
6485 (void) memcpy((void *) (pc
+ 4), (void *) (&pname
), 4);
6486 (void) __glXReadReply(dpy
, 4, params
, GL_FALSE
);
6489 #endif /* USE_XCB */
6494 #define X_GLvop_GetHistogramParameterivEXT 7
6496 gl_dispatch_stub_363(GLenum target
, GLenum pname
, GLint
* params
)
6498 struct glx_context
*const gc
= __glXGetCurrentContext();
6500 #if defined(GLX_DIRECT_RENDERING) && !defined(GLX_USE_APPLEGL)
6502 GET_DISPATCH()->GetHistogramParameteriv(target
, pname
, params
);
6506 struct glx_context
*const gc
= __glXGetCurrentContext();
6507 Display
*const dpy
= gc
->currentDpy
;
6508 const GLuint cmdlen
= 8;
6509 if (__builtin_expect(dpy
!= NULL
, 1)) {
6511 __glXSetupVendorRequest(gc
, X_GLXVendorPrivateWithReply
,
6512 X_GLvop_GetHistogramParameterivEXT
,
6514 (void) memcpy((void *) (pc
+ 0), (void *) (&target
), 4);
6515 (void) memcpy((void *) (pc
+ 4), (void *) (&pname
), 4);
6516 (void) __glXReadReply(dpy
, 4, params
, GL_FALSE
);
6524 #define X_GLsop_GetMinmax 157
6526 __indirect_glGetMinmax(GLenum target
, GLboolean reset
, GLenum format
,
6527 GLenum type
, GLvoid
* values
)
6529 struct glx_context
*const gc
= __glXGetCurrentContext();
6530 const __GLXattribute
*const state
= gc
->client_state_private
;
6531 Display
*const dpy
= gc
->currentDpy
;
6533 const GLuint cmdlen
= 16;
6535 if (__builtin_expect(dpy
!= NULL
, 1)) {
6537 xcb_connection_t
*c
= XGetXCBConnection(dpy
);
6538 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
6539 xcb_glx_get_minmax_reply_t
*reply
=
6540 xcb_glx_get_minmax_reply(c
,
6541 xcb_glx_get_minmax(c
,
6542 gc
->currentContextTag
,
6543 target
, reset
, format
,
6547 (void) memcpy(values
, xcb_glx_get_minmax_data(reply
),
6548 xcb_glx_get_minmax_data_length(reply
) * sizeof(GLvoid
));
6552 __glXSetupSingleRequest(gc
, X_GLsop_GetMinmax
, cmdlen
);
6553 (void) memcpy((void *) (pc
+ 0), (void *) (&target
), 4);
6554 (void) memcpy((void *) (pc
+ 4), (void *) (&format
), 4);
6555 (void) memcpy((void *) (pc
+ 8), (void *) (&type
), 4);
6556 *(int32_t *) (pc
+ 12) = 0;
6557 *(int8_t *) (pc
+ 12) = state
->storePack
.swapEndian
;
6558 *(int8_t *) (pc
+ 13) = reset
;
6559 __glXReadPixelReply(dpy
, gc
, 1, 2, 1, 1, format
, type
, values
,
6563 #endif /* USE_XCB */
6568 #define X_GLvop_GetMinmaxEXT 8
6570 gl_dispatch_stub_364(GLenum target
, GLboolean reset
, GLenum format
,
6571 GLenum type
, GLvoid
* values
)
6573 struct glx_context
*const gc
= __glXGetCurrentContext();
6575 #if defined(GLX_DIRECT_RENDERING) && !defined(GLX_USE_APPLEGL)
6577 GET_DISPATCH()->GetMinmax(target
, reset
, format
, type
, values
);
6581 struct glx_context
*const gc
= __glXGetCurrentContext();
6582 const __GLXattribute
*const state
= gc
->client_state_private
;
6583 Display
*const dpy
= gc
->currentDpy
;
6584 const GLuint cmdlen
= 16;
6585 if (__builtin_expect(dpy
!= NULL
, 1)) {
6587 __glXSetupVendorRequest(gc
, X_GLXVendorPrivateWithReply
,
6588 X_GLvop_GetMinmaxEXT
, cmdlen
);
6589 (void) memcpy((void *) (pc
+ 0), (void *) (&target
), 4);
6590 (void) memcpy((void *) (pc
+ 4), (void *) (&format
), 4);
6591 (void) memcpy((void *) (pc
+ 8), (void *) (&type
), 4);
6592 *(int32_t *) (pc
+ 12) = 0;
6593 *(int8_t *) (pc
+ 12) = state
->storePack
.swapEndian
;
6594 *(int8_t *) (pc
+ 13) = reset
;
6595 __glXReadPixelReply(dpy
, gc
, 1, 2, 1, 1, format
, type
, values
,
6604 #define X_GLsop_GetMinmaxParameterfv 158
6606 __indirect_glGetMinmaxParameterfv(GLenum target
, GLenum pname
,
6609 struct glx_context
*const gc
= __glXGetCurrentContext();
6610 Display
*const dpy
= gc
->currentDpy
;
6612 const GLuint cmdlen
= 8;
6614 if (__builtin_expect(dpy
!= NULL
, 1)) {
6616 xcb_connection_t
*c
= XGetXCBConnection(dpy
);
6617 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
6618 xcb_glx_get_minmax_parameterfv_reply_t
*reply
=
6619 xcb_glx_get_minmax_parameterfv_reply(c
,
6620 xcb_glx_get_minmax_parameterfv
6621 (c
, gc
->currentContextTag
,
6622 target
, pname
), NULL
);
6623 if (xcb_glx_get_minmax_parameterfv_data_length(reply
) == 0)
6624 (void) memcpy(params
, &reply
->datum
, sizeof(reply
->datum
));
6626 (void) memcpy(params
, xcb_glx_get_minmax_parameterfv_data(reply
),
6627 xcb_glx_get_minmax_parameterfv_data_length(reply
) *
6632 __glXSetupSingleRequest(gc
, X_GLsop_GetMinmaxParameterfv
, cmdlen
);
6633 (void) memcpy((void *) (pc
+ 0), (void *) (&target
), 4);
6634 (void) memcpy((void *) (pc
+ 4), (void *) (&pname
), 4);
6635 (void) __glXReadReply(dpy
, 4, params
, GL_FALSE
);
6638 #endif /* USE_XCB */
6643 #define X_GLvop_GetMinmaxParameterfvEXT 9
6645 gl_dispatch_stub_365(GLenum target
, GLenum pname
, GLfloat
* params
)
6647 struct glx_context
*const gc
= __glXGetCurrentContext();
6649 #if defined(GLX_DIRECT_RENDERING) && !defined(GLX_USE_APPLEGL)
6651 GET_DISPATCH()->GetMinmaxParameterfv(target
, pname
, params
);
6655 struct glx_context
*const gc
= __glXGetCurrentContext();
6656 Display
*const dpy
= gc
->currentDpy
;
6657 const GLuint cmdlen
= 8;
6658 if (__builtin_expect(dpy
!= NULL
, 1)) {
6660 __glXSetupVendorRequest(gc
, X_GLXVendorPrivateWithReply
,
6661 X_GLvop_GetMinmaxParameterfvEXT
,
6663 (void) memcpy((void *) (pc
+ 0), (void *) (&target
), 4);
6664 (void) memcpy((void *) (pc
+ 4), (void *) (&pname
), 4);
6665 (void) __glXReadReply(dpy
, 4, params
, GL_FALSE
);
6673 #define X_GLsop_GetMinmaxParameteriv 159
6675 __indirect_glGetMinmaxParameteriv(GLenum target
, GLenum pname
, GLint
* params
)
6677 struct glx_context
*const gc
= __glXGetCurrentContext();
6678 Display
*const dpy
= gc
->currentDpy
;
6680 const GLuint cmdlen
= 8;
6682 if (__builtin_expect(dpy
!= NULL
, 1)) {
6684 xcb_connection_t
*c
= XGetXCBConnection(dpy
);
6685 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
6686 xcb_glx_get_minmax_parameteriv_reply_t
*reply
=
6687 xcb_glx_get_minmax_parameteriv_reply(c
,
6688 xcb_glx_get_minmax_parameteriv
6689 (c
, gc
->currentContextTag
,
6690 target
, pname
), NULL
);
6691 if (xcb_glx_get_minmax_parameteriv_data_length(reply
) == 0)
6692 (void) memcpy(params
, &reply
->datum
, sizeof(reply
->datum
));
6694 (void) memcpy(params
, xcb_glx_get_minmax_parameteriv_data(reply
),
6695 xcb_glx_get_minmax_parameteriv_data_length(reply
) *
6700 __glXSetupSingleRequest(gc
, X_GLsop_GetMinmaxParameteriv
, cmdlen
);
6701 (void) memcpy((void *) (pc
+ 0), (void *) (&target
), 4);
6702 (void) memcpy((void *) (pc
+ 4), (void *) (&pname
), 4);
6703 (void) __glXReadReply(dpy
, 4, params
, GL_FALSE
);
6706 #endif /* USE_XCB */
6711 #define X_GLvop_GetMinmaxParameterivEXT 10
6713 gl_dispatch_stub_366(GLenum target
, GLenum pname
, GLint
* params
)
6715 struct glx_context
*const gc
= __glXGetCurrentContext();
6717 #if defined(GLX_DIRECT_RENDERING) && !defined(GLX_USE_APPLEGL)
6719 GET_DISPATCH()->GetMinmaxParameteriv(target
, pname
, params
);
6723 struct glx_context
*const gc
= __glXGetCurrentContext();
6724 Display
*const dpy
= gc
->currentDpy
;
6725 const GLuint cmdlen
= 8;
6726 if (__builtin_expect(dpy
!= NULL
, 1)) {
6728 __glXSetupVendorRequest(gc
, X_GLXVendorPrivateWithReply
,
6729 X_GLvop_GetMinmaxParameterivEXT
,
6731 (void) memcpy((void *) (pc
+ 0), (void *) (&target
), 4);
6732 (void) memcpy((void *) (pc
+ 4), (void *) (&pname
), 4);
6733 (void) __glXReadReply(dpy
, 4, params
, GL_FALSE
);
6741 #define X_GLrop_Histogram 4110
6743 __indirect_glHistogram(GLenum target
, GLsizei width
, GLenum internalformat
,
6746 struct glx_context
*const gc
= __glXGetCurrentContext();
6747 const GLuint cmdlen
= 20;
6748 emit_header(gc
->pc
, X_GLrop_Histogram
, cmdlen
);
6749 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&target
), 4);
6750 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&width
), 4);
6751 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&internalformat
), 4);
6752 (void) memcpy((void *) (gc
->pc
+ 16), (void *) (&sink
), 1);
6754 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
6755 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
6759 #define X_GLrop_Minmax 4111
6761 __indirect_glMinmax(GLenum target
, GLenum internalformat
, GLboolean sink
)
6763 struct glx_context
*const gc
= __glXGetCurrentContext();
6764 const GLuint cmdlen
= 16;
6765 emit_header(gc
->pc
, X_GLrop_Minmax
, cmdlen
);
6766 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&target
), 4);
6767 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&internalformat
), 4);
6768 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&sink
), 1);
6770 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
6771 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
6775 #define X_GLrop_ResetHistogram 4112
6777 __indirect_glResetHistogram(GLenum target
)
6779 struct glx_context
*const gc
= __glXGetCurrentContext();
6780 const GLuint cmdlen
= 8;
6781 emit_header(gc
->pc
, X_GLrop_ResetHistogram
, cmdlen
);
6782 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&target
), 4);
6784 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
6785 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
6789 #define X_GLrop_ResetMinmax 4113
6791 __indirect_glResetMinmax(GLenum target
)
6793 struct glx_context
*const gc
= __glXGetCurrentContext();
6794 const GLuint cmdlen
= 8;
6795 emit_header(gc
->pc
, X_GLrop_ResetMinmax
, cmdlen
);
6796 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&target
), 4);
6798 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
6799 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
6804 __glx_TexImage_3D4D(unsigned opcode
, unsigned dim
, GLenum target
, GLint level
,
6805 GLint internalformat
, GLsizei width
, GLsizei height
,
6806 GLsizei depth
, GLsizei extent
, GLint border
,
6807 GLenum format
, GLenum type
, const GLvoid
* pixels
)
6809 struct glx_context
*const gc
= __glXGetCurrentContext();
6810 const GLuint compsize
=
6811 (pixels
!= NULL
) ? __glImageSize(width
, height
, depth
, format
, type
,
6813 const GLuint cmdlen
= 84 + __GLX_PAD(compsize
);
6814 if (__builtin_expect(gc
->currentDpy
!= NULL
, 1)) {
6815 if (cmdlen
<= gc
->maxSmallRenderCommandSize
) {
6816 if ((gc
->pc
+ cmdlen
) > gc
->bufEnd
) {
6817 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
6819 emit_header(gc
->pc
, opcode
, cmdlen
);
6820 (void) memcpy((void *) (gc
->pc
+ 40), (void *) (&target
), 4);
6821 (void) memcpy((void *) (gc
->pc
+ 44), (void *) (&level
), 4);
6822 (void) memcpy((void *) (gc
->pc
+ 48), (void *) (&internalformat
),
6824 (void) memcpy((void *) (gc
->pc
+ 52), (void *) (&width
), 4);
6825 (void) memcpy((void *) (gc
->pc
+ 56), (void *) (&height
), 4);
6826 (void) memcpy((void *) (gc
->pc
+ 60), (void *) (&depth
), 4);
6827 (void) memcpy((void *) (gc
->pc
+ 64), (void *) (&extent
), 4);
6828 (void) memcpy((void *) (gc
->pc
+ 68), (void *) (&border
), 4);
6829 (void) memcpy((void *) (gc
->pc
+ 72), (void *) (&format
), 4);
6830 (void) memcpy((void *) (gc
->pc
+ 76), (void *) (&type
), 4);
6831 (void) memcpy((void *) (gc
->pc
+ 80),
6832 (void *) ((pixels
== NULL
) ? one
: zero
), 4);
6834 (*gc
->fillImage
) (gc
, dim
, width
, height
, depth
, format
, type
,
6835 pixels
, gc
->pc
+ 84, gc
->pc
+ 4);
6837 (void) memcpy(gc
->pc
+ 4, default_pixel_store_4D
,
6838 default_pixel_store_4D_size
);
6841 if (gc
->pc
> gc
->limit
) {
6842 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
6845 const GLint op
= opcode
;
6846 const GLuint cmdlenLarge
= cmdlen
+ 4;
6847 GLubyte
*const pc
= __glXFlushRenderBuffer(gc
, gc
->pc
);
6848 (void) memcpy((void *) (pc
+ 0), (void *) (&cmdlenLarge
), 4);
6849 (void) memcpy((void *) (pc
+ 4), (void *) (&op
), 4);
6850 (void) memcpy((void *) (pc
+ 44), (void *) (&target
), 4);
6851 (void) memcpy((void *) (pc
+ 48), (void *) (&level
), 4);
6852 (void) memcpy((void *) (pc
+ 52), (void *) (&internalformat
), 4);
6853 (void) memcpy((void *) (pc
+ 56), (void *) (&width
), 4);
6854 (void) memcpy((void *) (pc
+ 60), (void *) (&height
), 4);
6855 (void) memcpy((void *) (pc
+ 64), (void *) (&depth
), 4);
6856 (void) memcpy((void *) (pc
+ 68), (void *) (&extent
), 4);
6857 (void) memcpy((void *) (pc
+ 72), (void *) (&border
), 4);
6858 (void) memcpy((void *) (pc
+ 76), (void *) (&format
), 4);
6859 (void) memcpy((void *) (pc
+ 80), (void *) (&type
), 4);
6860 (void) memcpy((void *) (pc
+ 84), zero
, 4);
6861 __glXSendLargeImage(gc
, compsize
, dim
, width
, height
, depth
,
6862 format
, type
, pixels
, pc
+ 88, pc
+ 8);
6867 #define X_GLrop_TexImage3D 4114
6869 __indirect_glTexImage3D(GLenum target
, GLint level
, GLint internalformat
,
6870 GLsizei width
, GLsizei height
, GLsizei depth
,
6871 GLint border
, GLenum format
, GLenum type
,
6872 const GLvoid
* pixels
)
6874 __glx_TexImage_3D4D(X_GLrop_TexImage3D
, 3, target
, level
, internalformat
,
6875 width
, height
, depth
, 1, border
, format
, type
,
6880 __glx_TexSubImage_3D4D(unsigned opcode
, unsigned dim
, GLenum target
,
6881 GLint level
, GLint xoffset
, GLint yoffset
,
6882 GLint zoffset
, GLint woffset
, GLsizei width
,
6883 GLsizei height
, GLsizei depth
, GLsizei extent
,
6884 GLenum format
, GLenum type
, const GLvoid
* pixels
)
6886 struct glx_context
*const gc
= __glXGetCurrentContext();
6887 const GLuint compsize
=
6888 (pixels
!= NULL
) ? __glImageSize(width
, height
, depth
, format
, type
,
6890 const GLuint cmdlen
= 92 + __GLX_PAD(compsize
);
6891 if (__builtin_expect(gc
->currentDpy
!= NULL
, 1)) {
6892 if (cmdlen
<= gc
->maxSmallRenderCommandSize
) {
6893 if ((gc
->pc
+ cmdlen
) > gc
->bufEnd
) {
6894 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
6896 emit_header(gc
->pc
, opcode
, cmdlen
);
6897 (void) memcpy((void *) (gc
->pc
+ 40), (void *) (&target
), 4);
6898 (void) memcpy((void *) (gc
->pc
+ 44), (void *) (&level
), 4);
6899 (void) memcpy((void *) (gc
->pc
+ 48), (void *) (&xoffset
), 4);
6900 (void) memcpy((void *) (gc
->pc
+ 52), (void *) (&yoffset
), 4);
6901 (void) memcpy((void *) (gc
->pc
+ 56), (void *) (&zoffset
), 4);
6902 (void) memcpy((void *) (gc
->pc
+ 60), (void *) (&woffset
), 4);
6903 (void) memcpy((void *) (gc
->pc
+ 64), (void *) (&width
), 4);
6904 (void) memcpy((void *) (gc
->pc
+ 68), (void *) (&height
), 4);
6905 (void) memcpy((void *) (gc
->pc
+ 72), (void *) (&depth
), 4);
6906 (void) memcpy((void *) (gc
->pc
+ 76), (void *) (&extent
), 4);
6907 (void) memcpy((void *) (gc
->pc
+ 80), (void *) (&format
), 4);
6908 (void) memcpy((void *) (gc
->pc
+ 84), (void *) (&type
), 4);
6909 (void) memset((void *) (gc
->pc
+ 88), 0, 4);
6911 (*gc
->fillImage
) (gc
, dim
, width
, height
, depth
, format
, type
,
6912 pixels
, gc
->pc
+ 92, gc
->pc
+ 4);
6914 (void) memcpy(gc
->pc
+ 4, default_pixel_store_4D
,
6915 default_pixel_store_4D_size
);
6918 if (gc
->pc
> gc
->limit
) {
6919 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
6922 const GLint op
= opcode
;
6923 const GLuint cmdlenLarge
= cmdlen
+ 4;
6924 GLubyte
*const pc
= __glXFlushRenderBuffer(gc
, gc
->pc
);
6925 (void) memcpy((void *) (pc
+ 0), (void *) (&cmdlenLarge
), 4);
6926 (void) memcpy((void *) (pc
+ 4), (void *) (&op
), 4);
6927 (void) memcpy((void *) (pc
+ 44), (void *) (&target
), 4);
6928 (void) memcpy((void *) (pc
+ 48), (void *) (&level
), 4);
6929 (void) memcpy((void *) (pc
+ 52), (void *) (&xoffset
), 4);
6930 (void) memcpy((void *) (pc
+ 56), (void *) (&yoffset
), 4);
6931 (void) memcpy((void *) (pc
+ 60), (void *) (&zoffset
), 4);
6932 (void) memcpy((void *) (pc
+ 64), (void *) (&woffset
), 4);
6933 (void) memcpy((void *) (pc
+ 68), (void *) (&width
), 4);
6934 (void) memcpy((void *) (pc
+ 72), (void *) (&height
), 4);
6935 (void) memcpy((void *) (pc
+ 76), (void *) (&depth
), 4);
6936 (void) memcpy((void *) (pc
+ 80), (void *) (&extent
), 4);
6937 (void) memcpy((void *) (pc
+ 84), (void *) (&format
), 4);
6938 (void) memcpy((void *) (pc
+ 88), (void *) (&type
), 4);
6939 (void) memset((void *) (pc
+ 92), 0, 4);
6940 __glXSendLargeImage(gc
, compsize
, dim
, width
, height
, depth
,
6941 format
, type
, pixels
, pc
+ 96, pc
+ 8);
6946 #define X_GLrop_TexSubImage3D 4115
6948 __indirect_glTexSubImage3D(GLenum target
, GLint level
, GLint xoffset
,
6949 GLint yoffset
, GLint zoffset
, GLsizei width
,
6950 GLsizei height
, GLsizei depth
, GLenum format
,
6951 GLenum type
, const GLvoid
* pixels
)
6953 __glx_TexSubImage_3D4D(X_GLrop_TexSubImage3D
, 3, target
, level
, xoffset
,
6954 yoffset
, zoffset
, 1, width
, height
, depth
, 1,
6955 format
, type
, pixels
);
6958 #define X_GLrop_CopyTexSubImage3D 4123
6960 __indirect_glCopyTexSubImage3D(GLenum target
, GLint level
, GLint xoffset
,
6961 GLint yoffset
, GLint zoffset
, GLint x
, GLint y
,
6962 GLsizei width
, GLsizei height
)
6964 struct glx_context
*const gc
= __glXGetCurrentContext();
6965 const GLuint cmdlen
= 40;
6966 emit_header(gc
->pc
, X_GLrop_CopyTexSubImage3D
, cmdlen
);
6967 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&target
), 4);
6968 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&level
), 4);
6969 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&xoffset
), 4);
6970 (void) memcpy((void *) (gc
->pc
+ 16), (void *) (&yoffset
), 4);
6971 (void) memcpy((void *) (gc
->pc
+ 20), (void *) (&zoffset
), 4);
6972 (void) memcpy((void *) (gc
->pc
+ 24), (void *) (&x
), 4);
6973 (void) memcpy((void *) (gc
->pc
+ 28), (void *) (&y
), 4);
6974 (void) memcpy((void *) (gc
->pc
+ 32), (void *) (&width
), 4);
6975 (void) memcpy((void *) (gc
->pc
+ 36), (void *) (&height
), 4);
6977 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
6978 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
6982 #define X_GLrop_ActiveTextureARB 197
6984 __indirect_glActiveTextureARB(GLenum texture
)
6986 struct glx_context
*const gc
= __glXGetCurrentContext();
6987 const GLuint cmdlen
= 8;
6988 emit_header(gc
->pc
, X_GLrop_ActiveTextureARB
, cmdlen
);
6989 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&texture
), 4);
6991 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
6992 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
6996 #define X_GLrop_MultiTexCoord1dvARB 198
6998 __indirect_glMultiTexCoord1dARB(GLenum target
, GLdouble s
)
7000 struct glx_context
*const gc
= __glXGetCurrentContext();
7001 const GLuint cmdlen
= 16;
7002 emit_header(gc
->pc
, X_GLrop_MultiTexCoord1dvARB
, cmdlen
);
7003 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&s
), 8);
7004 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&target
), 4);
7006 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
7007 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
7011 #define X_GLrop_MultiTexCoord1dvARB 198
7013 __indirect_glMultiTexCoord1dvARB(GLenum target
, const GLdouble
* v
)
7015 struct glx_context
*const gc
= __glXGetCurrentContext();
7016 const GLuint cmdlen
= 16;
7017 emit_header(gc
->pc
, X_GLrop_MultiTexCoord1dvARB
, cmdlen
);
7018 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (v
), 8);
7019 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&target
), 4);
7021 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
7022 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
7026 #define X_GLrop_MultiTexCoord1fvARB 199
7028 __indirect_glMultiTexCoord1fARB(GLenum target
, GLfloat s
)
7030 struct glx_context
*const gc
= __glXGetCurrentContext();
7031 const GLuint cmdlen
= 12;
7032 emit_header(gc
->pc
, X_GLrop_MultiTexCoord1fvARB
, cmdlen
);
7033 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&target
), 4);
7034 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&s
), 4);
7036 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
7037 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
7041 #define X_GLrop_MultiTexCoord1fvARB 199
7043 __indirect_glMultiTexCoord1fvARB(GLenum target
, const GLfloat
* v
)
7045 struct glx_context
*const gc
= __glXGetCurrentContext();
7046 const GLuint cmdlen
= 12;
7047 emit_header(gc
->pc
, X_GLrop_MultiTexCoord1fvARB
, cmdlen
);
7048 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&target
), 4);
7049 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (v
), 4);
7051 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
7052 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
7056 #define X_GLrop_MultiTexCoord1ivARB 200
7058 __indirect_glMultiTexCoord1iARB(GLenum target
, GLint s
)
7060 struct glx_context
*const gc
= __glXGetCurrentContext();
7061 const GLuint cmdlen
= 12;
7062 emit_header(gc
->pc
, X_GLrop_MultiTexCoord1ivARB
, cmdlen
);
7063 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&target
), 4);
7064 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&s
), 4);
7066 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
7067 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
7071 #define X_GLrop_MultiTexCoord1ivARB 200
7073 __indirect_glMultiTexCoord1ivARB(GLenum target
, const GLint
* v
)
7075 struct glx_context
*const gc
= __glXGetCurrentContext();
7076 const GLuint cmdlen
= 12;
7077 emit_header(gc
->pc
, X_GLrop_MultiTexCoord1ivARB
, cmdlen
);
7078 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&target
), 4);
7079 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (v
), 4);
7081 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
7082 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
7086 #define X_GLrop_MultiTexCoord1svARB 201
7088 __indirect_glMultiTexCoord1sARB(GLenum target
, GLshort s
)
7090 struct glx_context
*const gc
= __glXGetCurrentContext();
7091 const GLuint cmdlen
= 12;
7092 emit_header(gc
->pc
, X_GLrop_MultiTexCoord1svARB
, cmdlen
);
7093 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&target
), 4);
7094 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&s
), 2);
7096 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
7097 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
7101 #define X_GLrop_MultiTexCoord1svARB 201
7103 __indirect_glMultiTexCoord1svARB(GLenum target
, const GLshort
* v
)
7105 struct glx_context
*const gc
= __glXGetCurrentContext();
7106 const GLuint cmdlen
= 12;
7107 emit_header(gc
->pc
, X_GLrop_MultiTexCoord1svARB
, cmdlen
);
7108 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&target
), 4);
7109 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (v
), 2);
7111 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
7112 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
7116 #define X_GLrop_MultiTexCoord2dvARB 202
7118 __indirect_glMultiTexCoord2dARB(GLenum target
, GLdouble s
, GLdouble t
)
7120 struct glx_context
*const gc
= __glXGetCurrentContext();
7121 const GLuint cmdlen
= 24;
7122 emit_header(gc
->pc
, X_GLrop_MultiTexCoord2dvARB
, cmdlen
);
7123 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&s
), 8);
7124 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&t
), 8);
7125 (void) memcpy((void *) (gc
->pc
+ 20), (void *) (&target
), 4);
7127 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
7128 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
7132 #define X_GLrop_MultiTexCoord2dvARB 202
7134 __indirect_glMultiTexCoord2dvARB(GLenum target
, const GLdouble
* v
)
7136 struct glx_context
*const gc
= __glXGetCurrentContext();
7137 const GLuint cmdlen
= 24;
7138 emit_header(gc
->pc
, X_GLrop_MultiTexCoord2dvARB
, cmdlen
);
7139 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (v
), 16);
7140 (void) memcpy((void *) (gc
->pc
+ 20), (void *) (&target
), 4);
7142 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
7143 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
7147 #define X_GLrop_MultiTexCoord2fvARB 203
7149 __indirect_glMultiTexCoord2fARB(GLenum target
, GLfloat s
, GLfloat t
)
7151 struct glx_context
*const gc
= __glXGetCurrentContext();
7152 const GLuint cmdlen
= 16;
7153 emit_header(gc
->pc
, X_GLrop_MultiTexCoord2fvARB
, cmdlen
);
7154 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&target
), 4);
7155 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&s
), 4);
7156 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&t
), 4);
7158 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
7159 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
7163 #define X_GLrop_MultiTexCoord2fvARB 203
7165 __indirect_glMultiTexCoord2fvARB(GLenum target
, const GLfloat
* v
)
7167 struct glx_context
*const gc
= __glXGetCurrentContext();
7168 const GLuint cmdlen
= 16;
7169 emit_header(gc
->pc
, X_GLrop_MultiTexCoord2fvARB
, cmdlen
);
7170 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&target
), 4);
7171 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (v
), 8);
7173 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
7174 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
7178 #define X_GLrop_MultiTexCoord2ivARB 204
7180 __indirect_glMultiTexCoord2iARB(GLenum target
, GLint s
, GLint t
)
7182 struct glx_context
*const gc
= __glXGetCurrentContext();
7183 const GLuint cmdlen
= 16;
7184 emit_header(gc
->pc
, X_GLrop_MultiTexCoord2ivARB
, cmdlen
);
7185 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&target
), 4);
7186 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&s
), 4);
7187 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&t
), 4);
7189 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
7190 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
7194 #define X_GLrop_MultiTexCoord2ivARB 204
7196 __indirect_glMultiTexCoord2ivARB(GLenum target
, const GLint
* v
)
7198 struct glx_context
*const gc
= __glXGetCurrentContext();
7199 const GLuint cmdlen
= 16;
7200 emit_header(gc
->pc
, X_GLrop_MultiTexCoord2ivARB
, cmdlen
);
7201 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&target
), 4);
7202 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (v
), 8);
7204 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
7205 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
7209 #define X_GLrop_MultiTexCoord2svARB 205
7211 __indirect_glMultiTexCoord2sARB(GLenum target
, GLshort s
, GLshort t
)
7213 struct glx_context
*const gc
= __glXGetCurrentContext();
7214 const GLuint cmdlen
= 12;
7215 emit_header(gc
->pc
, X_GLrop_MultiTexCoord2svARB
, cmdlen
);
7216 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&target
), 4);
7217 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&s
), 2);
7218 (void) memcpy((void *) (gc
->pc
+ 10), (void *) (&t
), 2);
7220 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
7221 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
7225 #define X_GLrop_MultiTexCoord2svARB 205
7227 __indirect_glMultiTexCoord2svARB(GLenum target
, const GLshort
* v
)
7229 struct glx_context
*const gc
= __glXGetCurrentContext();
7230 const GLuint cmdlen
= 12;
7231 emit_header(gc
->pc
, X_GLrop_MultiTexCoord2svARB
, cmdlen
);
7232 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&target
), 4);
7233 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (v
), 4);
7235 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
7236 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
7240 #define X_GLrop_MultiTexCoord3dvARB 206
7242 __indirect_glMultiTexCoord3dARB(GLenum target
, GLdouble s
, GLdouble t
,
7245 struct glx_context
*const gc
= __glXGetCurrentContext();
7246 const GLuint cmdlen
= 32;
7247 emit_header(gc
->pc
, X_GLrop_MultiTexCoord3dvARB
, cmdlen
);
7248 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&s
), 8);
7249 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&t
), 8);
7250 (void) memcpy((void *) (gc
->pc
+ 20), (void *) (&r
), 8);
7251 (void) memcpy((void *) (gc
->pc
+ 28), (void *) (&target
), 4);
7253 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
7254 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
7258 #define X_GLrop_MultiTexCoord3dvARB 206
7260 __indirect_glMultiTexCoord3dvARB(GLenum target
, const GLdouble
* v
)
7262 struct glx_context
*const gc
= __glXGetCurrentContext();
7263 const GLuint cmdlen
= 32;
7264 emit_header(gc
->pc
, X_GLrop_MultiTexCoord3dvARB
, cmdlen
);
7265 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (v
), 24);
7266 (void) memcpy((void *) (gc
->pc
+ 28), (void *) (&target
), 4);
7268 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
7269 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
7273 #define X_GLrop_MultiTexCoord3fvARB 207
7275 __indirect_glMultiTexCoord3fARB(GLenum target
, GLfloat s
, GLfloat t
,
7278 struct glx_context
*const gc
= __glXGetCurrentContext();
7279 const GLuint cmdlen
= 20;
7280 emit_header(gc
->pc
, X_GLrop_MultiTexCoord3fvARB
, cmdlen
);
7281 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&target
), 4);
7282 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&s
), 4);
7283 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&t
), 4);
7284 (void) memcpy((void *) (gc
->pc
+ 16), (void *) (&r
), 4);
7286 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
7287 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
7291 #define X_GLrop_MultiTexCoord3fvARB 207
7293 __indirect_glMultiTexCoord3fvARB(GLenum target
, const GLfloat
* v
)
7295 struct glx_context
*const gc
= __glXGetCurrentContext();
7296 const GLuint cmdlen
= 20;
7297 emit_header(gc
->pc
, X_GLrop_MultiTexCoord3fvARB
, cmdlen
);
7298 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&target
), 4);
7299 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (v
), 12);
7301 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
7302 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
7306 #define X_GLrop_MultiTexCoord3ivARB 208
7308 __indirect_glMultiTexCoord3iARB(GLenum target
, GLint s
, GLint t
, GLint r
)
7310 struct glx_context
*const gc
= __glXGetCurrentContext();
7311 const GLuint cmdlen
= 20;
7312 emit_header(gc
->pc
, X_GLrop_MultiTexCoord3ivARB
, cmdlen
);
7313 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&target
), 4);
7314 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&s
), 4);
7315 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&t
), 4);
7316 (void) memcpy((void *) (gc
->pc
+ 16), (void *) (&r
), 4);
7318 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
7319 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
7323 #define X_GLrop_MultiTexCoord3ivARB 208
7325 __indirect_glMultiTexCoord3ivARB(GLenum target
, const GLint
* v
)
7327 struct glx_context
*const gc
= __glXGetCurrentContext();
7328 const GLuint cmdlen
= 20;
7329 emit_header(gc
->pc
, X_GLrop_MultiTexCoord3ivARB
, cmdlen
);
7330 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&target
), 4);
7331 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (v
), 12);
7333 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
7334 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
7338 #define X_GLrop_MultiTexCoord3svARB 209
7340 __indirect_glMultiTexCoord3sARB(GLenum target
, GLshort s
, GLshort t
,
7343 struct glx_context
*const gc
= __glXGetCurrentContext();
7344 const GLuint cmdlen
= 16;
7345 emit_header(gc
->pc
, X_GLrop_MultiTexCoord3svARB
, cmdlen
);
7346 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&target
), 4);
7347 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&s
), 2);
7348 (void) memcpy((void *) (gc
->pc
+ 10), (void *) (&t
), 2);
7349 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&r
), 2);
7351 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
7352 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
7356 #define X_GLrop_MultiTexCoord3svARB 209
7358 __indirect_glMultiTexCoord3svARB(GLenum target
, const GLshort
* v
)
7360 struct glx_context
*const gc
= __glXGetCurrentContext();
7361 const GLuint cmdlen
= 16;
7362 emit_header(gc
->pc
, X_GLrop_MultiTexCoord3svARB
, cmdlen
);
7363 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&target
), 4);
7364 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (v
), 6);
7366 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
7367 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
7371 #define X_GLrop_MultiTexCoord4dvARB 210
7373 __indirect_glMultiTexCoord4dARB(GLenum target
, GLdouble s
, GLdouble t
,
7374 GLdouble r
, GLdouble q
)
7376 struct glx_context
*const gc
= __glXGetCurrentContext();
7377 const GLuint cmdlen
= 40;
7378 emit_header(gc
->pc
, X_GLrop_MultiTexCoord4dvARB
, cmdlen
);
7379 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&s
), 8);
7380 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&t
), 8);
7381 (void) memcpy((void *) (gc
->pc
+ 20), (void *) (&r
), 8);
7382 (void) memcpy((void *) (gc
->pc
+ 28), (void *) (&q
), 8);
7383 (void) memcpy((void *) (gc
->pc
+ 36), (void *) (&target
), 4);
7385 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
7386 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
7390 #define X_GLrop_MultiTexCoord4dvARB 210
7392 __indirect_glMultiTexCoord4dvARB(GLenum target
, const GLdouble
* v
)
7394 struct glx_context
*const gc
= __glXGetCurrentContext();
7395 const GLuint cmdlen
= 40;
7396 emit_header(gc
->pc
, X_GLrop_MultiTexCoord4dvARB
, cmdlen
);
7397 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (v
), 32);
7398 (void) memcpy((void *) (gc
->pc
+ 36), (void *) (&target
), 4);
7400 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
7401 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
7405 #define X_GLrop_MultiTexCoord4fvARB 211
7407 __indirect_glMultiTexCoord4fARB(GLenum target
, GLfloat s
, GLfloat t
,
7408 GLfloat r
, GLfloat q
)
7410 struct glx_context
*const gc
= __glXGetCurrentContext();
7411 const GLuint cmdlen
= 24;
7412 emit_header(gc
->pc
, X_GLrop_MultiTexCoord4fvARB
, cmdlen
);
7413 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&target
), 4);
7414 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&s
), 4);
7415 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&t
), 4);
7416 (void) memcpy((void *) (gc
->pc
+ 16), (void *) (&r
), 4);
7417 (void) memcpy((void *) (gc
->pc
+ 20), (void *) (&q
), 4);
7419 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
7420 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
7424 #define X_GLrop_MultiTexCoord4fvARB 211
7426 __indirect_glMultiTexCoord4fvARB(GLenum target
, const GLfloat
* v
)
7428 struct glx_context
*const gc
= __glXGetCurrentContext();
7429 const GLuint cmdlen
= 24;
7430 emit_header(gc
->pc
, X_GLrop_MultiTexCoord4fvARB
, cmdlen
);
7431 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&target
), 4);
7432 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (v
), 16);
7434 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
7435 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
7439 #define X_GLrop_MultiTexCoord4ivARB 212
7441 __indirect_glMultiTexCoord4iARB(GLenum target
, GLint s
, GLint t
, GLint r
,
7444 struct glx_context
*const gc
= __glXGetCurrentContext();
7445 const GLuint cmdlen
= 24;
7446 emit_header(gc
->pc
, X_GLrop_MultiTexCoord4ivARB
, cmdlen
);
7447 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&target
), 4);
7448 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&s
), 4);
7449 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&t
), 4);
7450 (void) memcpy((void *) (gc
->pc
+ 16), (void *) (&r
), 4);
7451 (void) memcpy((void *) (gc
->pc
+ 20), (void *) (&q
), 4);
7453 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
7454 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
7458 #define X_GLrop_MultiTexCoord4ivARB 212
7460 __indirect_glMultiTexCoord4ivARB(GLenum target
, const GLint
* v
)
7462 struct glx_context
*const gc
= __glXGetCurrentContext();
7463 const GLuint cmdlen
= 24;
7464 emit_header(gc
->pc
, X_GLrop_MultiTexCoord4ivARB
, cmdlen
);
7465 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&target
), 4);
7466 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (v
), 16);
7468 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
7469 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
7473 #define X_GLrop_MultiTexCoord4svARB 213
7475 __indirect_glMultiTexCoord4sARB(GLenum target
, GLshort s
, GLshort t
,
7476 GLshort r
, GLshort q
)
7478 struct glx_context
*const gc
= __glXGetCurrentContext();
7479 const GLuint cmdlen
= 16;
7480 emit_header(gc
->pc
, X_GLrop_MultiTexCoord4svARB
, cmdlen
);
7481 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&target
), 4);
7482 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&s
), 2);
7483 (void) memcpy((void *) (gc
->pc
+ 10), (void *) (&t
), 2);
7484 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&r
), 2);
7485 (void) memcpy((void *) (gc
->pc
+ 14), (void *) (&q
), 2);
7487 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
7488 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
7492 #define X_GLrop_MultiTexCoord4svARB 213
7494 __indirect_glMultiTexCoord4svARB(GLenum target
, const GLshort
* v
)
7496 struct glx_context
*const gc
= __glXGetCurrentContext();
7497 const GLuint cmdlen
= 16;
7498 emit_header(gc
->pc
, X_GLrop_MultiTexCoord4svARB
, cmdlen
);
7499 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&target
), 4);
7500 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (v
), 8);
7502 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
7503 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
7507 #define X_GLrop_SampleCoverageARB 229
7509 __indirect_glSampleCoverageARB(GLclampf value
, GLboolean invert
)
7511 struct glx_context
*const gc
= __glXGetCurrentContext();
7512 const GLuint cmdlen
= 12;
7513 emit_header(gc
->pc
, X_GLrop_SampleCoverageARB
, cmdlen
);
7514 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&value
), 4);
7515 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&invert
), 1);
7517 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
7518 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
7522 #define X_GLvop_GetProgramStringARB 1308
7524 __indirect_glGetProgramStringARB(GLenum target
, GLenum pname
, GLvoid
* string
)
7526 struct glx_context
*const gc
= __glXGetCurrentContext();
7527 Display
*const dpy
= gc
->currentDpy
;
7528 const GLuint cmdlen
= 8;
7529 if (__builtin_expect(dpy
!= NULL
, 1)) {
7531 __glXSetupVendorRequest(gc
, X_GLXVendorPrivateWithReply
,
7532 X_GLvop_GetProgramStringARB
, cmdlen
);
7533 (void) memcpy((void *) (pc
+ 0), (void *) (&target
), 4);
7534 (void) memcpy((void *) (pc
+ 4), (void *) (&pname
), 4);
7535 (void) __glXReadReply(dpy
, 1, string
, GL_TRUE
);
7542 #define X_GLvop_GetProgramivARB 1307
7544 __indirect_glGetProgramivARB(GLenum target
, GLenum pname
, GLint
* params
)
7546 struct glx_context
*const gc
= __glXGetCurrentContext();
7547 Display
*const dpy
= gc
->currentDpy
;
7548 const GLuint cmdlen
= 8;
7549 if (__builtin_expect(dpy
!= NULL
, 1)) {
7551 __glXSetupVendorRequest(gc
, X_GLXVendorPrivateWithReply
,
7552 X_GLvop_GetProgramivARB
, cmdlen
);
7553 (void) memcpy((void *) (pc
+ 0), (void *) (&target
), 4);
7554 (void) memcpy((void *) (pc
+ 4), (void *) (&pname
), 4);
7555 (void) __glXReadReply(dpy
, 4, params
, GL_FALSE
);
7562 #define X_GLrop_ProgramEnvParameter4dvARB 4185
7564 __indirect_glProgramEnvParameter4dARB(GLenum target
, GLuint index
, GLdouble x
,
7565 GLdouble y
, GLdouble z
, GLdouble w
)
7567 struct glx_context
*const gc
= __glXGetCurrentContext();
7568 const GLuint cmdlen
= 44;
7569 emit_header(gc
->pc
, X_GLrop_ProgramEnvParameter4dvARB
, cmdlen
);
7570 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&target
), 4);
7571 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&index
), 4);
7572 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&x
), 8);
7573 (void) memcpy((void *) (gc
->pc
+ 20), (void *) (&y
), 8);
7574 (void) memcpy((void *) (gc
->pc
+ 28), (void *) (&z
), 8);
7575 (void) memcpy((void *) (gc
->pc
+ 36), (void *) (&w
), 8);
7577 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
7578 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
7582 #define X_GLrop_ProgramEnvParameter4dvARB 4185
7584 __indirect_glProgramEnvParameter4dvARB(GLenum target
, GLuint index
,
7585 const GLdouble
* params
)
7587 struct glx_context
*const gc
= __glXGetCurrentContext();
7588 const GLuint cmdlen
= 44;
7589 emit_header(gc
->pc
, X_GLrop_ProgramEnvParameter4dvARB
, cmdlen
);
7590 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&target
), 4);
7591 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&index
), 4);
7592 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (params
), 32);
7594 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
7595 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
7599 #define X_GLrop_ProgramEnvParameter4fvARB 4184
7601 __indirect_glProgramEnvParameter4fARB(GLenum target
, GLuint index
, GLfloat x
,
7602 GLfloat y
, GLfloat z
, GLfloat w
)
7604 struct glx_context
*const gc
= __glXGetCurrentContext();
7605 const GLuint cmdlen
= 28;
7606 emit_header(gc
->pc
, X_GLrop_ProgramEnvParameter4fvARB
, cmdlen
);
7607 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&target
), 4);
7608 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&index
), 4);
7609 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&x
), 4);
7610 (void) memcpy((void *) (gc
->pc
+ 16), (void *) (&y
), 4);
7611 (void) memcpy((void *) (gc
->pc
+ 20), (void *) (&z
), 4);
7612 (void) memcpy((void *) (gc
->pc
+ 24), (void *) (&w
), 4);
7614 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
7615 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
7619 #define X_GLrop_ProgramEnvParameter4fvARB 4184
7621 __indirect_glProgramEnvParameter4fvARB(GLenum target
, GLuint index
,
7622 const GLfloat
* params
)
7624 struct glx_context
*const gc
= __glXGetCurrentContext();
7625 const GLuint cmdlen
= 28;
7626 emit_header(gc
->pc
, X_GLrop_ProgramEnvParameter4fvARB
, cmdlen
);
7627 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&target
), 4);
7628 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&index
), 4);
7629 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (params
), 16);
7631 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
7632 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
7636 #define X_GLrop_ProgramLocalParameter4dvARB 4216
7638 __indirect_glProgramLocalParameter4dARB(GLenum target
, GLuint index
,
7639 GLdouble x
, GLdouble y
, GLdouble z
,
7642 struct glx_context
*const gc
= __glXGetCurrentContext();
7643 const GLuint cmdlen
= 44;
7644 emit_header(gc
->pc
, X_GLrop_ProgramLocalParameter4dvARB
, cmdlen
);
7645 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&target
), 4);
7646 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&index
), 4);
7647 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&x
), 8);
7648 (void) memcpy((void *) (gc
->pc
+ 20), (void *) (&y
), 8);
7649 (void) memcpy((void *) (gc
->pc
+ 28), (void *) (&z
), 8);
7650 (void) memcpy((void *) (gc
->pc
+ 36), (void *) (&w
), 8);
7652 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
7653 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
7657 #define X_GLrop_ProgramLocalParameter4dvARB 4216
7659 __indirect_glProgramLocalParameter4dvARB(GLenum target
, GLuint index
,
7660 const GLdouble
* params
)
7662 struct glx_context
*const gc
= __glXGetCurrentContext();
7663 const GLuint cmdlen
= 44;
7664 emit_header(gc
->pc
, X_GLrop_ProgramLocalParameter4dvARB
, cmdlen
);
7665 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&target
), 4);
7666 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&index
), 4);
7667 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (params
), 32);
7669 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
7670 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
7674 #define X_GLrop_ProgramLocalParameter4fvARB 4215
7676 __indirect_glProgramLocalParameter4fARB(GLenum target
, GLuint index
,
7677 GLfloat x
, GLfloat y
, GLfloat z
,
7680 struct glx_context
*const gc
= __glXGetCurrentContext();
7681 const GLuint cmdlen
= 28;
7682 emit_header(gc
->pc
, X_GLrop_ProgramLocalParameter4fvARB
, cmdlen
);
7683 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&target
), 4);
7684 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&index
), 4);
7685 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&x
), 4);
7686 (void) memcpy((void *) (gc
->pc
+ 16), (void *) (&y
), 4);
7687 (void) memcpy((void *) (gc
->pc
+ 20), (void *) (&z
), 4);
7688 (void) memcpy((void *) (gc
->pc
+ 24), (void *) (&w
), 4);
7690 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
7691 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
7695 #define X_GLrop_ProgramLocalParameter4fvARB 4215
7697 __indirect_glProgramLocalParameter4fvARB(GLenum target
, GLuint index
,
7698 const GLfloat
* params
)
7700 struct glx_context
*const gc
= __glXGetCurrentContext();
7701 const GLuint cmdlen
= 28;
7702 emit_header(gc
->pc
, X_GLrop_ProgramLocalParameter4fvARB
, cmdlen
);
7703 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&target
), 4);
7704 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&index
), 4);
7705 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (params
), 16);
7707 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
7708 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
7712 #define X_GLrop_ProgramStringARB 4217
7714 __indirect_glProgramStringARB(GLenum target
, GLenum format
, GLsizei len
,
7715 const GLvoid
* string
)
7717 struct glx_context
*const gc
= __glXGetCurrentContext();
7718 const GLuint cmdlen
= 16 + __GLX_PAD(len
);
7720 __glXSetError(gc
, GL_INVALID_VALUE
);
7723 if (__builtin_expect((len
>= 0) && (gc
->currentDpy
!= NULL
), 1)) {
7724 if (cmdlen
<= gc
->maxSmallRenderCommandSize
) {
7725 if ((gc
->pc
+ cmdlen
) > gc
->bufEnd
) {
7726 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
7728 emit_header(gc
->pc
, X_GLrop_ProgramStringARB
, cmdlen
);
7729 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&target
), 4);
7730 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&format
), 4);
7731 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&len
), 4);
7732 (void) memcpy((void *) (gc
->pc
+ 16), (void *) (string
), len
);
7734 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
7735 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
7738 const GLint op
= X_GLrop_ProgramStringARB
;
7739 const GLuint cmdlenLarge
= cmdlen
+ 4;
7740 GLubyte
*const pc
= __glXFlushRenderBuffer(gc
, gc
->pc
);
7741 (void) memcpy((void *) (pc
+ 0), (void *) (&cmdlenLarge
), 4);
7742 (void) memcpy((void *) (pc
+ 4), (void *) (&op
), 4);
7743 (void) memcpy((void *) (pc
+ 8), (void *) (&target
), 4);
7744 (void) memcpy((void *) (pc
+ 12), (void *) (&format
), 4);
7745 (void) memcpy((void *) (pc
+ 16), (void *) (&len
), 4);
7746 __glXSendLargeCommand(gc
, pc
, 20, string
, len
);
7751 #define X_GLrop_VertexAttrib1dvARB 4197
7753 __indirect_glVertexAttrib1dARB(GLuint index
, GLdouble x
)
7755 struct glx_context
*const gc
= __glXGetCurrentContext();
7756 const GLuint cmdlen
= 16;
7757 emit_header(gc
->pc
, X_GLrop_VertexAttrib1dvARB
, cmdlen
);
7758 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&index
), 4);
7759 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&x
), 8);
7761 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
7762 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
7766 #define X_GLrop_VertexAttrib1dvARB 4197
7768 __indirect_glVertexAttrib1dvARB(GLuint index
, const GLdouble
* v
)
7770 struct glx_context
*const gc
= __glXGetCurrentContext();
7771 const GLuint cmdlen
= 16;
7772 emit_header(gc
->pc
, X_GLrop_VertexAttrib1dvARB
, cmdlen
);
7773 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&index
), 4);
7774 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (v
), 8);
7776 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
7777 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
7781 #define X_GLrop_VertexAttrib1fvARB 4193
7783 __indirect_glVertexAttrib1fARB(GLuint index
, GLfloat x
)
7785 struct glx_context
*const gc
= __glXGetCurrentContext();
7786 const GLuint cmdlen
= 12;
7787 emit_header(gc
->pc
, X_GLrop_VertexAttrib1fvARB
, cmdlen
);
7788 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&index
), 4);
7789 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&x
), 4);
7791 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
7792 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
7796 #define X_GLrop_VertexAttrib1fvARB 4193
7798 __indirect_glVertexAttrib1fvARB(GLuint index
, const GLfloat
* v
)
7800 struct glx_context
*const gc
= __glXGetCurrentContext();
7801 const GLuint cmdlen
= 12;
7802 emit_header(gc
->pc
, X_GLrop_VertexAttrib1fvARB
, cmdlen
);
7803 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&index
), 4);
7804 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (v
), 4);
7806 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
7807 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
7811 #define X_GLrop_VertexAttrib1svARB 4189
7813 __indirect_glVertexAttrib1sARB(GLuint index
, GLshort x
)
7815 struct glx_context
*const gc
= __glXGetCurrentContext();
7816 const GLuint cmdlen
= 12;
7817 emit_header(gc
->pc
, X_GLrop_VertexAttrib1svARB
, cmdlen
);
7818 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&index
), 4);
7819 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&x
), 2);
7821 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
7822 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
7826 #define X_GLrop_VertexAttrib1svARB 4189
7828 __indirect_glVertexAttrib1svARB(GLuint index
, const GLshort
* v
)
7830 struct glx_context
*const gc
= __glXGetCurrentContext();
7831 const GLuint cmdlen
= 12;
7832 emit_header(gc
->pc
, X_GLrop_VertexAttrib1svARB
, cmdlen
);
7833 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&index
), 4);
7834 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (v
), 2);
7836 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
7837 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
7841 #define X_GLrop_VertexAttrib2dvARB 4198
7843 __indirect_glVertexAttrib2dARB(GLuint index
, GLdouble x
, GLdouble y
)
7845 struct glx_context
*const gc
= __glXGetCurrentContext();
7846 const GLuint cmdlen
= 24;
7847 emit_header(gc
->pc
, X_GLrop_VertexAttrib2dvARB
, cmdlen
);
7848 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&index
), 4);
7849 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&x
), 8);
7850 (void) memcpy((void *) (gc
->pc
+ 16), (void *) (&y
), 8);
7852 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
7853 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
7857 #define X_GLrop_VertexAttrib2dvARB 4198
7859 __indirect_glVertexAttrib2dvARB(GLuint index
, const GLdouble
* v
)
7861 struct glx_context
*const gc
= __glXGetCurrentContext();
7862 const GLuint cmdlen
= 24;
7863 emit_header(gc
->pc
, X_GLrop_VertexAttrib2dvARB
, cmdlen
);
7864 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&index
), 4);
7865 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (v
), 16);
7867 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
7868 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
7872 #define X_GLrop_VertexAttrib2fvARB 4194
7874 __indirect_glVertexAttrib2fARB(GLuint index
, GLfloat x
, GLfloat y
)
7876 struct glx_context
*const gc
= __glXGetCurrentContext();
7877 const GLuint cmdlen
= 16;
7878 emit_header(gc
->pc
, X_GLrop_VertexAttrib2fvARB
, cmdlen
);
7879 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&index
), 4);
7880 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&x
), 4);
7881 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&y
), 4);
7883 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
7884 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
7888 #define X_GLrop_VertexAttrib2fvARB 4194
7890 __indirect_glVertexAttrib2fvARB(GLuint index
, const GLfloat
* v
)
7892 struct glx_context
*const gc
= __glXGetCurrentContext();
7893 const GLuint cmdlen
= 16;
7894 emit_header(gc
->pc
, X_GLrop_VertexAttrib2fvARB
, cmdlen
);
7895 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&index
), 4);
7896 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (v
), 8);
7898 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
7899 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
7903 #define X_GLrop_VertexAttrib2svARB 4190
7905 __indirect_glVertexAttrib2sARB(GLuint index
, GLshort x
, GLshort y
)
7907 struct glx_context
*const gc
= __glXGetCurrentContext();
7908 const GLuint cmdlen
= 12;
7909 emit_header(gc
->pc
, X_GLrop_VertexAttrib2svARB
, cmdlen
);
7910 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&index
), 4);
7911 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&x
), 2);
7912 (void) memcpy((void *) (gc
->pc
+ 10), (void *) (&y
), 2);
7914 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
7915 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
7919 #define X_GLrop_VertexAttrib2svARB 4190
7921 __indirect_glVertexAttrib2svARB(GLuint index
, const GLshort
* v
)
7923 struct glx_context
*const gc
= __glXGetCurrentContext();
7924 const GLuint cmdlen
= 12;
7925 emit_header(gc
->pc
, X_GLrop_VertexAttrib2svARB
, cmdlen
);
7926 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&index
), 4);
7927 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (v
), 4);
7929 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
7930 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
7934 #define X_GLrop_VertexAttrib3dvARB 4199
7936 __indirect_glVertexAttrib3dARB(GLuint index
, GLdouble x
, GLdouble y
,
7939 struct glx_context
*const gc
= __glXGetCurrentContext();
7940 const GLuint cmdlen
= 32;
7941 emit_header(gc
->pc
, X_GLrop_VertexAttrib3dvARB
, cmdlen
);
7942 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&index
), 4);
7943 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&x
), 8);
7944 (void) memcpy((void *) (gc
->pc
+ 16), (void *) (&y
), 8);
7945 (void) memcpy((void *) (gc
->pc
+ 24), (void *) (&z
), 8);
7947 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
7948 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
7952 #define X_GLrop_VertexAttrib3dvARB 4199
7954 __indirect_glVertexAttrib3dvARB(GLuint index
, const GLdouble
* v
)
7956 struct glx_context
*const gc
= __glXGetCurrentContext();
7957 const GLuint cmdlen
= 32;
7958 emit_header(gc
->pc
, X_GLrop_VertexAttrib3dvARB
, cmdlen
);
7959 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&index
), 4);
7960 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (v
), 24);
7962 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
7963 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
7967 #define X_GLrop_VertexAttrib3fvARB 4195
7969 __indirect_glVertexAttrib3fARB(GLuint index
, GLfloat x
, GLfloat y
, GLfloat z
)
7971 struct glx_context
*const gc
= __glXGetCurrentContext();
7972 const GLuint cmdlen
= 20;
7973 emit_header(gc
->pc
, X_GLrop_VertexAttrib3fvARB
, cmdlen
);
7974 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&index
), 4);
7975 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&x
), 4);
7976 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&y
), 4);
7977 (void) memcpy((void *) (gc
->pc
+ 16), (void *) (&z
), 4);
7979 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
7980 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
7984 #define X_GLrop_VertexAttrib3fvARB 4195
7986 __indirect_glVertexAttrib3fvARB(GLuint index
, const GLfloat
* v
)
7988 struct glx_context
*const gc
= __glXGetCurrentContext();
7989 const GLuint cmdlen
= 20;
7990 emit_header(gc
->pc
, X_GLrop_VertexAttrib3fvARB
, cmdlen
);
7991 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&index
), 4);
7992 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (v
), 12);
7994 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
7995 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
7999 #define X_GLrop_VertexAttrib3svARB 4191
8001 __indirect_glVertexAttrib3sARB(GLuint index
, GLshort x
, GLshort y
, GLshort z
)
8003 struct glx_context
*const gc
= __glXGetCurrentContext();
8004 const GLuint cmdlen
= 16;
8005 emit_header(gc
->pc
, X_GLrop_VertexAttrib3svARB
, cmdlen
);
8006 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&index
), 4);
8007 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&x
), 2);
8008 (void) memcpy((void *) (gc
->pc
+ 10), (void *) (&y
), 2);
8009 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&z
), 2);
8011 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
8012 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
8016 #define X_GLrop_VertexAttrib3svARB 4191
8018 __indirect_glVertexAttrib3svARB(GLuint index
, const GLshort
* v
)
8020 struct glx_context
*const gc
= __glXGetCurrentContext();
8021 const GLuint cmdlen
= 16;
8022 emit_header(gc
->pc
, X_GLrop_VertexAttrib3svARB
, cmdlen
);
8023 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&index
), 4);
8024 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (v
), 6);
8026 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
8027 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
8031 #define X_GLrop_VertexAttrib4NbvARB 4235
8033 __indirect_glVertexAttrib4NbvARB(GLuint index
, const GLbyte
*v
)
8035 struct glx_context
*const gc
= __glXGetCurrentContext();
8036 const GLuint cmdlen
= 12;
8037 emit_header(gc
->pc
, X_GLrop_VertexAttrib4NbvARB
, cmdlen
);
8038 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&index
), 4);
8039 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (v
), 4);
8041 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
8042 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
8046 #define X_GLrop_VertexAttrib4NivARB 4237
8048 __indirect_glVertexAttrib4NivARB(GLuint index
, const GLint
* v
)
8050 struct glx_context
*const gc
= __glXGetCurrentContext();
8051 const GLuint cmdlen
= 24;
8052 emit_header(gc
->pc
, X_GLrop_VertexAttrib4NivARB
, cmdlen
);
8053 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&index
), 4);
8054 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (v
), 16);
8056 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
8057 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
8061 #define X_GLrop_VertexAttrib4NsvARB 4236
8063 __indirect_glVertexAttrib4NsvARB(GLuint index
, const GLshort
* v
)
8065 struct glx_context
*const gc
= __glXGetCurrentContext();
8066 const GLuint cmdlen
= 16;
8067 emit_header(gc
->pc
, X_GLrop_VertexAttrib4NsvARB
, cmdlen
);
8068 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&index
), 4);
8069 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (v
), 8);
8071 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
8072 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
8076 #define X_GLrop_VertexAttrib4NubvARB 4201
8078 __indirect_glVertexAttrib4NubARB(GLuint index
, GLubyte x
, GLubyte y
,
8079 GLubyte z
, GLubyte w
)
8081 struct glx_context
*const gc
= __glXGetCurrentContext();
8082 const GLuint cmdlen
= 12;
8083 emit_header(gc
->pc
, X_GLrop_VertexAttrib4NubvARB
, cmdlen
);
8084 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&index
), 4);
8085 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&x
), 1);
8086 (void) memcpy((void *) (gc
->pc
+ 9), (void *) (&y
), 1);
8087 (void) memcpy((void *) (gc
->pc
+ 10), (void *) (&z
), 1);
8088 (void) memcpy((void *) (gc
->pc
+ 11), (void *) (&w
), 1);
8090 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
8091 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
8095 #define X_GLrop_VertexAttrib4NubvARB 4201
8097 __indirect_glVertexAttrib4NubvARB(GLuint index
, const GLubyte
*v
)
8099 struct glx_context
*const gc
= __glXGetCurrentContext();
8100 const GLuint cmdlen
= 12;
8101 emit_header(gc
->pc
, X_GLrop_VertexAttrib4NubvARB
, cmdlen
);
8102 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&index
), 4);
8103 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (v
), 4);
8105 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
8106 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
8110 #define X_GLrop_VertexAttrib4NuivARB 4239
8112 __indirect_glVertexAttrib4NuivARB(GLuint index
, const GLuint
* v
)
8114 struct glx_context
*const gc
= __glXGetCurrentContext();
8115 const GLuint cmdlen
= 24;
8116 emit_header(gc
->pc
, X_GLrop_VertexAttrib4NuivARB
, cmdlen
);
8117 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&index
), 4);
8118 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (v
), 16);
8120 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
8121 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
8125 #define X_GLrop_VertexAttrib4NusvARB 4238
8127 __indirect_glVertexAttrib4NusvARB(GLuint index
, const GLushort
* v
)
8129 struct glx_context
*const gc
= __glXGetCurrentContext();
8130 const GLuint cmdlen
= 16;
8131 emit_header(gc
->pc
, X_GLrop_VertexAttrib4NusvARB
, cmdlen
);
8132 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&index
), 4);
8133 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (v
), 8);
8135 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
8136 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
8140 #define X_GLrop_VertexAttrib4bvARB 4230
8142 __indirect_glVertexAttrib4bvARB(GLuint index
, const GLbyte
*v
)
8144 struct glx_context
*const gc
= __glXGetCurrentContext();
8145 const GLuint cmdlen
= 12;
8146 emit_header(gc
->pc
, X_GLrop_VertexAttrib4bvARB
, cmdlen
);
8147 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&index
), 4);
8148 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (v
), 4);
8150 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
8151 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
8155 #define X_GLrop_VertexAttrib4dvARB 4200
8157 __indirect_glVertexAttrib4dARB(GLuint index
, GLdouble x
, GLdouble y
,
8158 GLdouble z
, GLdouble w
)
8160 struct glx_context
*const gc
= __glXGetCurrentContext();
8161 const GLuint cmdlen
= 40;
8162 emit_header(gc
->pc
, X_GLrop_VertexAttrib4dvARB
, cmdlen
);
8163 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&index
), 4);
8164 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&x
), 8);
8165 (void) memcpy((void *) (gc
->pc
+ 16), (void *) (&y
), 8);
8166 (void) memcpy((void *) (gc
->pc
+ 24), (void *) (&z
), 8);
8167 (void) memcpy((void *) (gc
->pc
+ 32), (void *) (&w
), 8);
8169 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
8170 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
8174 #define X_GLrop_VertexAttrib4dvARB 4200
8176 __indirect_glVertexAttrib4dvARB(GLuint index
, const GLdouble
* v
)
8178 struct glx_context
*const gc
= __glXGetCurrentContext();
8179 const GLuint cmdlen
= 40;
8180 emit_header(gc
->pc
, X_GLrop_VertexAttrib4dvARB
, cmdlen
);
8181 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&index
), 4);
8182 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (v
), 32);
8184 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
8185 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
8189 #define X_GLrop_VertexAttrib4fvARB 4196
8191 __indirect_glVertexAttrib4fARB(GLuint index
, GLfloat x
, GLfloat y
, GLfloat z
,
8194 struct glx_context
*const gc
= __glXGetCurrentContext();
8195 const GLuint cmdlen
= 24;
8196 emit_header(gc
->pc
, X_GLrop_VertexAttrib4fvARB
, cmdlen
);
8197 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&index
), 4);
8198 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&x
), 4);
8199 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&y
), 4);
8200 (void) memcpy((void *) (gc
->pc
+ 16), (void *) (&z
), 4);
8201 (void) memcpy((void *) (gc
->pc
+ 20), (void *) (&w
), 4);
8203 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
8204 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
8208 #define X_GLrop_VertexAttrib4fvARB 4196
8210 __indirect_glVertexAttrib4fvARB(GLuint index
, const GLfloat
* v
)
8212 struct glx_context
*const gc
= __glXGetCurrentContext();
8213 const GLuint cmdlen
= 24;
8214 emit_header(gc
->pc
, X_GLrop_VertexAttrib4fvARB
, cmdlen
);
8215 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&index
), 4);
8216 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (v
), 16);
8218 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
8219 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
8223 #define X_GLrop_VertexAttrib4ivARB 4231
8225 __indirect_glVertexAttrib4ivARB(GLuint index
, const GLint
* v
)
8227 struct glx_context
*const gc
= __glXGetCurrentContext();
8228 const GLuint cmdlen
= 24;
8229 emit_header(gc
->pc
, X_GLrop_VertexAttrib4ivARB
, cmdlen
);
8230 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&index
), 4);
8231 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (v
), 16);
8233 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
8234 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
8238 #define X_GLrop_VertexAttrib4svARB 4192
8240 __indirect_glVertexAttrib4sARB(GLuint index
, GLshort x
, GLshort y
, GLshort z
,
8243 struct glx_context
*const gc
= __glXGetCurrentContext();
8244 const GLuint cmdlen
= 16;
8245 emit_header(gc
->pc
, X_GLrop_VertexAttrib4svARB
, cmdlen
);
8246 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&index
), 4);
8247 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&x
), 2);
8248 (void) memcpy((void *) (gc
->pc
+ 10), (void *) (&y
), 2);
8249 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&z
), 2);
8250 (void) memcpy((void *) (gc
->pc
+ 14), (void *) (&w
), 2);
8252 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
8253 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
8257 #define X_GLrop_VertexAttrib4svARB 4192
8259 __indirect_glVertexAttrib4svARB(GLuint index
, const GLshort
* v
)
8261 struct glx_context
*const gc
= __glXGetCurrentContext();
8262 const GLuint cmdlen
= 16;
8263 emit_header(gc
->pc
, X_GLrop_VertexAttrib4svARB
, cmdlen
);
8264 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&index
), 4);
8265 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (v
), 8);
8267 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
8268 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
8272 #define X_GLrop_VertexAttrib4ubvARB 4232
8274 __indirect_glVertexAttrib4ubvARB(GLuint index
, const GLubyte
*v
)
8276 struct glx_context
*const gc
= __glXGetCurrentContext();
8277 const GLuint cmdlen
= 12;
8278 emit_header(gc
->pc
, X_GLrop_VertexAttrib4ubvARB
, cmdlen
);
8279 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&index
), 4);
8280 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (v
), 4);
8282 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
8283 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
8287 #define X_GLrop_VertexAttrib4uivARB 4234
8289 __indirect_glVertexAttrib4uivARB(GLuint index
, const GLuint
* v
)
8291 struct glx_context
*const gc
= __glXGetCurrentContext();
8292 const GLuint cmdlen
= 24;
8293 emit_header(gc
->pc
, X_GLrop_VertexAttrib4uivARB
, cmdlen
);
8294 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&index
), 4);
8295 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (v
), 16);
8297 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
8298 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
8302 #define X_GLrop_VertexAttrib4usvARB 4233
8304 __indirect_glVertexAttrib4usvARB(GLuint index
, const GLushort
* v
)
8306 struct glx_context
*const gc
= __glXGetCurrentContext();
8307 const GLuint cmdlen
= 16;
8308 emit_header(gc
->pc
, X_GLrop_VertexAttrib4usvARB
, cmdlen
);
8309 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&index
), 4);
8310 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (v
), 8);
8312 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
8313 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
8317 #define X_GLrop_BeginQueryARB 231
8319 __indirect_glBeginQueryARB(GLenum target
, GLuint id
)
8321 struct glx_context
*const gc
= __glXGetCurrentContext();
8322 const GLuint cmdlen
= 12;
8323 emit_header(gc
->pc
, X_GLrop_BeginQueryARB
, cmdlen
);
8324 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&target
), 4);
8325 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&id
), 4);
8327 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
8328 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
8332 #define X_GLsop_DeleteQueriesARB 161
8334 __indirect_glDeleteQueriesARB(GLsizei n
, const GLuint
* ids
)
8336 struct glx_context
*const gc
= __glXGetCurrentContext();
8337 Display
*const dpy
= gc
->currentDpy
;
8339 const GLuint cmdlen
= 4 + __GLX_PAD((n
* 4));
8342 __glXSetError(gc
, GL_INVALID_VALUE
);
8345 if (__builtin_expect((n
>= 0) && (dpy
!= NULL
), 1)) {
8347 xcb_connection_t
*c
= XGetXCBConnection(dpy
);
8348 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
8349 xcb_glx_delete_queries_arb(c
, gc
->currentContextTag
, n
, ids
);
8352 __glXSetupSingleRequest(gc
, X_GLsop_DeleteQueriesARB
, cmdlen
);
8353 (void) memcpy((void *) (pc
+ 0), (void *) (&n
), 4);
8354 (void) memcpy((void *) (pc
+ 4), (void *) (ids
), (n
* 4));
8357 #endif /* USE_XCB */
8362 #define X_GLrop_EndQueryARB 232
8364 __indirect_glEndQueryARB(GLenum target
)
8366 struct glx_context
*const gc
= __glXGetCurrentContext();
8367 const GLuint cmdlen
= 8;
8368 emit_header(gc
->pc
, X_GLrop_EndQueryARB
, cmdlen
);
8369 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&target
), 4);
8371 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
8372 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
8376 #define X_GLsop_GenQueriesARB 162
8378 __indirect_glGenQueriesARB(GLsizei n
, GLuint
* ids
)
8380 struct glx_context
*const gc
= __glXGetCurrentContext();
8381 Display
*const dpy
= gc
->currentDpy
;
8383 const GLuint cmdlen
= 4;
8386 __glXSetError(gc
, GL_INVALID_VALUE
);
8389 if (__builtin_expect((n
>= 0) && (dpy
!= NULL
), 1)) {
8391 xcb_connection_t
*c
= XGetXCBConnection(dpy
);
8392 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
8393 xcb_glx_gen_queries_arb_reply_t
*reply
=
8394 xcb_glx_gen_queries_arb_reply(c
,
8395 xcb_glx_gen_queries_arb(c
,
8399 (void) memcpy(ids
, xcb_glx_gen_queries_arb_data(reply
),
8400 xcb_glx_gen_queries_arb_data_length(reply
) *
8405 __glXSetupSingleRequest(gc
, X_GLsop_GenQueriesARB
, cmdlen
);
8406 (void) memcpy((void *) (pc
+ 0), (void *) (&n
), 4);
8407 (void) __glXReadReply(dpy
, 4, ids
, GL_TRUE
);
8410 #endif /* USE_XCB */
8415 #define X_GLsop_GetQueryObjectivARB 165
8417 __indirect_glGetQueryObjectivARB(GLuint id
, GLenum pname
, GLint
* params
)
8419 struct glx_context
*const gc
= __glXGetCurrentContext();
8420 Display
*const dpy
= gc
->currentDpy
;
8422 const GLuint cmdlen
= 8;
8424 if (__builtin_expect(dpy
!= NULL
, 1)) {
8426 xcb_connection_t
*c
= XGetXCBConnection(dpy
);
8427 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
8428 xcb_glx_get_query_objectiv_arb_reply_t
*reply
=
8429 xcb_glx_get_query_objectiv_arb_reply(c
,
8430 xcb_glx_get_query_objectiv_arb
8431 (c
, gc
->currentContextTag
,
8433 if (xcb_glx_get_query_objectiv_arb_data_length(reply
) == 0)
8434 (void) memcpy(params
, &reply
->datum
, sizeof(reply
->datum
));
8436 (void) memcpy(params
, xcb_glx_get_query_objectiv_arb_data(reply
),
8437 xcb_glx_get_query_objectiv_arb_data_length(reply
) *
8442 __glXSetupSingleRequest(gc
, X_GLsop_GetQueryObjectivARB
, cmdlen
);
8443 (void) memcpy((void *) (pc
+ 0), (void *) (&id
), 4);
8444 (void) memcpy((void *) (pc
+ 4), (void *) (&pname
), 4);
8445 (void) __glXReadReply(dpy
, 4, params
, GL_FALSE
);
8448 #endif /* USE_XCB */
8453 #define X_GLsop_GetQueryObjectuivARB 166
8455 __indirect_glGetQueryObjectuivARB(GLuint id
, GLenum pname
, GLuint
* params
)
8457 struct glx_context
*const gc
= __glXGetCurrentContext();
8458 Display
*const dpy
= gc
->currentDpy
;
8460 const GLuint cmdlen
= 8;
8462 if (__builtin_expect(dpy
!= NULL
, 1)) {
8464 xcb_connection_t
*c
= XGetXCBConnection(dpy
);
8465 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
8466 xcb_glx_get_query_objectuiv_arb_reply_t
*reply
=
8467 xcb_glx_get_query_objectuiv_arb_reply(c
,
8468 xcb_glx_get_query_objectuiv_arb
8469 (c
, gc
->currentContextTag
,
8471 if (xcb_glx_get_query_objectuiv_arb_data_length(reply
) == 0)
8472 (void) memcpy(params
, &reply
->datum
, sizeof(reply
->datum
));
8474 (void) memcpy(params
, xcb_glx_get_query_objectuiv_arb_data(reply
),
8475 xcb_glx_get_query_objectuiv_arb_data_length(reply
) *
8480 __glXSetupSingleRequest(gc
, X_GLsop_GetQueryObjectuivARB
, cmdlen
);
8481 (void) memcpy((void *) (pc
+ 0), (void *) (&id
), 4);
8482 (void) memcpy((void *) (pc
+ 4), (void *) (&pname
), 4);
8483 (void) __glXReadReply(dpy
, 4, params
, GL_FALSE
);
8486 #endif /* USE_XCB */
8491 #define X_GLsop_GetQueryivARB 164
8493 __indirect_glGetQueryivARB(GLenum target
, GLenum pname
, GLint
* params
)
8495 struct glx_context
*const gc
= __glXGetCurrentContext();
8496 Display
*const dpy
= gc
->currentDpy
;
8498 const GLuint cmdlen
= 8;
8500 if (__builtin_expect(dpy
!= NULL
, 1)) {
8502 xcb_connection_t
*c
= XGetXCBConnection(dpy
);
8503 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
8504 xcb_glx_get_queryiv_arb_reply_t
*reply
=
8505 xcb_glx_get_queryiv_arb_reply(c
,
8506 xcb_glx_get_queryiv_arb(c
,
8512 if (xcb_glx_get_queryiv_arb_data_length(reply
) == 0)
8513 (void) memcpy(params
, &reply
->datum
, sizeof(reply
->datum
));
8515 (void) memcpy(params
, xcb_glx_get_queryiv_arb_data(reply
),
8516 xcb_glx_get_queryiv_arb_data_length(reply
) *
8521 __glXSetupSingleRequest(gc
, X_GLsop_GetQueryivARB
, cmdlen
);
8522 (void) memcpy((void *) (pc
+ 0), (void *) (&target
), 4);
8523 (void) memcpy((void *) (pc
+ 4), (void *) (&pname
), 4);
8524 (void) __glXReadReply(dpy
, 4, params
, GL_FALSE
);
8527 #endif /* USE_XCB */
8532 #define X_GLsop_IsQueryARB 163
8534 __indirect_glIsQueryARB(GLuint id
)
8536 struct glx_context
*const gc
= __glXGetCurrentContext();
8537 Display
*const dpy
= gc
->currentDpy
;
8538 GLboolean retval
= (GLboolean
) 0;
8540 const GLuint cmdlen
= 4;
8542 if (__builtin_expect(dpy
!= NULL
, 1)) {
8544 xcb_connection_t
*c
= XGetXCBConnection(dpy
);
8545 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
8546 xcb_glx_is_query_arb_reply_t
*reply
=
8547 xcb_glx_is_query_arb_reply(c
,
8548 xcb_glx_is_query_arb(c
,
8552 retval
= reply
->ret_val
;
8556 __glXSetupSingleRequest(gc
, X_GLsop_IsQueryARB
, cmdlen
);
8557 (void) memcpy((void *) (pc
+ 0), (void *) (&id
), 4);
8558 retval
= (GLboolean
) __glXReadReply(dpy
, 0, NULL
, GL_FALSE
);
8561 #endif /* USE_XCB */
8566 #define X_GLrop_DrawBuffersARB 233
8568 __indirect_glDrawBuffersARB(GLsizei n
, const GLenum
* bufs
)
8570 struct glx_context
*const gc
= __glXGetCurrentContext();
8571 const GLuint cmdlen
= 8 + __GLX_PAD((n
* 4));
8573 __glXSetError(gc
, GL_INVALID_VALUE
);
8576 if (__builtin_expect((n
>= 0) && (gc
->currentDpy
!= NULL
), 1)) {
8577 if (cmdlen
<= gc
->maxSmallRenderCommandSize
) {
8578 if ((gc
->pc
+ cmdlen
) > gc
->bufEnd
) {
8579 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
8581 emit_header(gc
->pc
, X_GLrop_DrawBuffersARB
, cmdlen
);
8582 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&n
), 4);
8583 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (bufs
), (n
* 4));
8585 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
8586 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
8589 const GLint op
= X_GLrop_DrawBuffersARB
;
8590 const GLuint cmdlenLarge
= cmdlen
+ 4;
8591 GLubyte
*const pc
= __glXFlushRenderBuffer(gc
, gc
->pc
);
8592 (void) memcpy((void *) (pc
+ 0), (void *) (&cmdlenLarge
), 4);
8593 (void) memcpy((void *) (pc
+ 4), (void *) (&op
), 4);
8594 (void) memcpy((void *) (pc
+ 8), (void *) (&n
), 4);
8595 __glXSendLargeCommand(gc
, pc
, 12, bufs
, (n
* 4));
8600 #define X_GLrop_ClampColorARB 234
8602 __indirect_glClampColorARB(GLenum target
, GLenum clamp
)
8604 struct glx_context
*const gc
= __glXGetCurrentContext();
8605 const GLuint cmdlen
= 12;
8606 emit_header(gc
->pc
, X_GLrop_ClampColorARB
, cmdlen
);
8607 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&target
), 4);
8608 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&clamp
), 4);
8610 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
8611 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
8615 #define X_GLrop_RenderbufferStorageMultisample 4331
8617 __indirect_glRenderbufferStorageMultisample(GLenum target
, GLsizei samples
,
8618 GLenum internalformat
,
8619 GLsizei width
, GLsizei height
)
8621 struct glx_context
*const gc
= __glXGetCurrentContext();
8622 const GLuint cmdlen
= 24;
8623 emit_header(gc
->pc
, X_GLrop_RenderbufferStorageMultisample
, cmdlen
);
8624 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&target
), 4);
8625 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&samples
), 4);
8626 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&internalformat
), 4);
8627 (void) memcpy((void *) (gc
->pc
+ 16), (void *) (&width
), 4);
8628 (void) memcpy((void *) (gc
->pc
+ 20), (void *) (&height
), 4);
8630 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
8631 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
8635 #define X_GLrop_SampleMaskSGIS 2048
8637 __indirect_glSampleMaskSGIS(GLclampf value
, GLboolean invert
)
8639 struct glx_context
*const gc
= __glXGetCurrentContext();
8640 const GLuint cmdlen
= 12;
8641 emit_header(gc
->pc
, X_GLrop_SampleMaskSGIS
, cmdlen
);
8642 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&value
), 4);
8643 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&invert
), 1);
8645 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
8646 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
8650 #define X_GLrop_SamplePatternSGIS 2049
8652 __indirect_glSamplePatternSGIS(GLenum pattern
)
8654 struct glx_context
*const gc
= __glXGetCurrentContext();
8655 const GLuint cmdlen
= 8;
8656 emit_header(gc
->pc
, X_GLrop_SamplePatternSGIS
, cmdlen
);
8657 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&pattern
), 4);
8659 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
8660 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
8664 #define X_GLrop_PointParameterfEXT 2065
8666 __indirect_glPointParameterfEXT(GLenum pname
, GLfloat param
)
8668 struct glx_context
*const gc
= __glXGetCurrentContext();
8669 const GLuint cmdlen
= 12;
8670 emit_header(gc
->pc
, X_GLrop_PointParameterfEXT
, cmdlen
);
8671 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&pname
), 4);
8672 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (¶m
), 4);
8674 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
8675 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
8679 #define X_GLrop_PointParameterfvEXT 2066
8681 __indirect_glPointParameterfvEXT(GLenum pname
, const GLfloat
* params
)
8683 struct glx_context
*const gc
= __glXGetCurrentContext();
8684 const GLuint compsize
= __glPointParameterfvEXT_size(pname
);
8685 const GLuint cmdlen
= 8 + __GLX_PAD((compsize
* 4));
8686 emit_header(gc
->pc
, X_GLrop_PointParameterfvEXT
, cmdlen
);
8687 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&pname
), 4);
8688 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (params
), (compsize
* 4));
8690 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
8691 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
8695 #define X_GLrop_SecondaryColor3bvEXT 4126
8697 __indirect_glSecondaryColor3bEXT(GLbyte red
, GLbyte green
, GLbyte blue
)
8699 struct glx_context
*const gc
= __glXGetCurrentContext();
8700 const GLuint cmdlen
= 8;
8701 emit_header(gc
->pc
, X_GLrop_SecondaryColor3bvEXT
, cmdlen
);
8702 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&red
), 1);
8703 (void) memcpy((void *) (gc
->pc
+ 5), (void *) (&green
), 1);
8704 (void) memcpy((void *) (gc
->pc
+ 6), (void *) (&blue
), 1);
8706 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
8707 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
8711 #define X_GLrop_SecondaryColor3bvEXT 4126
8713 __indirect_glSecondaryColor3bvEXT(const GLbyte
*v
)
8715 generic_3_byte(X_GLrop_SecondaryColor3bvEXT
, v
);
8718 #define X_GLrop_SecondaryColor3dvEXT 4130
8720 __indirect_glSecondaryColor3dEXT(GLdouble red
, GLdouble green
, GLdouble blue
)
8722 struct glx_context
*const gc
= __glXGetCurrentContext();
8723 const GLuint cmdlen
= 28;
8724 emit_header(gc
->pc
, X_GLrop_SecondaryColor3dvEXT
, cmdlen
);
8725 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&red
), 8);
8726 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&green
), 8);
8727 (void) memcpy((void *) (gc
->pc
+ 20), (void *) (&blue
), 8);
8729 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
8730 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
8734 #define X_GLrop_SecondaryColor3dvEXT 4130
8736 __indirect_glSecondaryColor3dvEXT(const GLdouble
* v
)
8738 generic_24_byte(X_GLrop_SecondaryColor3dvEXT
, v
);
8741 #define X_GLrop_SecondaryColor3fvEXT 4129
8743 __indirect_glSecondaryColor3fEXT(GLfloat red
, GLfloat green
, GLfloat blue
)
8745 struct glx_context
*const gc
= __glXGetCurrentContext();
8746 const GLuint cmdlen
= 16;
8747 emit_header(gc
->pc
, X_GLrop_SecondaryColor3fvEXT
, cmdlen
);
8748 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&red
), 4);
8749 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&green
), 4);
8750 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&blue
), 4);
8752 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
8753 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
8757 #define X_GLrop_SecondaryColor3fvEXT 4129
8759 __indirect_glSecondaryColor3fvEXT(const GLfloat
* v
)
8761 generic_12_byte(X_GLrop_SecondaryColor3fvEXT
, v
);
8764 #define X_GLrop_SecondaryColor3ivEXT 4128
8766 __indirect_glSecondaryColor3iEXT(GLint red
, GLint green
, GLint blue
)
8768 struct glx_context
*const gc
= __glXGetCurrentContext();
8769 const GLuint cmdlen
= 16;
8770 emit_header(gc
->pc
, X_GLrop_SecondaryColor3ivEXT
, cmdlen
);
8771 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&red
), 4);
8772 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&green
), 4);
8773 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&blue
), 4);
8775 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
8776 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
8780 #define X_GLrop_SecondaryColor3ivEXT 4128
8782 __indirect_glSecondaryColor3ivEXT(const GLint
* v
)
8784 generic_12_byte(X_GLrop_SecondaryColor3ivEXT
, v
);
8787 #define X_GLrop_SecondaryColor3svEXT 4127
8789 __indirect_glSecondaryColor3sEXT(GLshort red
, GLshort green
, GLshort blue
)
8791 struct glx_context
*const gc
= __glXGetCurrentContext();
8792 const GLuint cmdlen
= 12;
8793 emit_header(gc
->pc
, X_GLrop_SecondaryColor3svEXT
, cmdlen
);
8794 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&red
), 2);
8795 (void) memcpy((void *) (gc
->pc
+ 6), (void *) (&green
), 2);
8796 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&blue
), 2);
8798 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
8799 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
8803 #define X_GLrop_SecondaryColor3svEXT 4127
8805 __indirect_glSecondaryColor3svEXT(const GLshort
* v
)
8807 generic_6_byte(X_GLrop_SecondaryColor3svEXT
, v
);
8810 #define X_GLrop_SecondaryColor3ubvEXT 4131
8812 __indirect_glSecondaryColor3ubEXT(GLubyte red
, GLubyte green
, GLubyte blue
)
8814 struct glx_context
*const gc
= __glXGetCurrentContext();
8815 const GLuint cmdlen
= 8;
8816 emit_header(gc
->pc
, X_GLrop_SecondaryColor3ubvEXT
, cmdlen
);
8817 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&red
), 1);
8818 (void) memcpy((void *) (gc
->pc
+ 5), (void *) (&green
), 1);
8819 (void) memcpy((void *) (gc
->pc
+ 6), (void *) (&blue
), 1);
8821 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
8822 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
8826 #define X_GLrop_SecondaryColor3ubvEXT 4131
8828 __indirect_glSecondaryColor3ubvEXT(const GLubyte
*v
)
8830 generic_3_byte(X_GLrop_SecondaryColor3ubvEXT
, v
);
8833 #define X_GLrop_SecondaryColor3uivEXT 4133
8835 __indirect_glSecondaryColor3uiEXT(GLuint red
, GLuint green
, GLuint blue
)
8837 struct glx_context
*const gc
= __glXGetCurrentContext();
8838 const GLuint cmdlen
= 16;
8839 emit_header(gc
->pc
, X_GLrop_SecondaryColor3uivEXT
, cmdlen
);
8840 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&red
), 4);
8841 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&green
), 4);
8842 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&blue
), 4);
8844 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
8845 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
8849 #define X_GLrop_SecondaryColor3uivEXT 4133
8851 __indirect_glSecondaryColor3uivEXT(const GLuint
* v
)
8853 generic_12_byte(X_GLrop_SecondaryColor3uivEXT
, v
);
8856 #define X_GLrop_SecondaryColor3usvEXT 4132
8858 __indirect_glSecondaryColor3usEXT(GLushort red
, GLushort green
, GLushort blue
)
8860 struct glx_context
*const gc
= __glXGetCurrentContext();
8861 const GLuint cmdlen
= 12;
8862 emit_header(gc
->pc
, X_GLrop_SecondaryColor3usvEXT
, cmdlen
);
8863 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&red
), 2);
8864 (void) memcpy((void *) (gc
->pc
+ 6), (void *) (&green
), 2);
8865 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&blue
), 2);
8867 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
8868 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
8872 #define X_GLrop_SecondaryColor3usvEXT 4132
8874 __indirect_glSecondaryColor3usvEXT(const GLushort
* v
)
8876 generic_6_byte(X_GLrop_SecondaryColor3usvEXT
, v
);
8879 #define X_GLrop_FogCoorddvEXT 4125
8881 __indirect_glFogCoorddEXT(GLdouble coord
)
8883 struct glx_context
*const gc
= __glXGetCurrentContext();
8884 const GLuint cmdlen
= 12;
8885 emit_header(gc
->pc
, X_GLrop_FogCoorddvEXT
, cmdlen
);
8886 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&coord
), 8);
8888 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
8889 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
8893 #define X_GLrop_FogCoorddvEXT 4125
8895 __indirect_glFogCoorddvEXT(const GLdouble
* coord
)
8897 generic_8_byte(X_GLrop_FogCoorddvEXT
, coord
);
8900 #define X_GLrop_FogCoordfvEXT 4124
8902 __indirect_glFogCoordfEXT(GLfloat coord
)
8904 struct glx_context
*const gc
= __glXGetCurrentContext();
8905 const GLuint cmdlen
= 8;
8906 emit_header(gc
->pc
, X_GLrop_FogCoordfvEXT
, cmdlen
);
8907 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&coord
), 4);
8909 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
8910 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
8914 #define X_GLrop_FogCoordfvEXT 4124
8916 __indirect_glFogCoordfvEXT(const GLfloat
* coord
)
8918 generic_4_byte(X_GLrop_FogCoordfvEXT
, coord
);
8921 #define X_GLrop_BlendFuncSeparateEXT 4134
8923 __indirect_glBlendFuncSeparateEXT(GLenum sfactorRGB
, GLenum dfactorRGB
,
8924 GLenum sfactorAlpha
, GLenum dfactorAlpha
)
8926 struct glx_context
*const gc
= __glXGetCurrentContext();
8927 const GLuint cmdlen
= 20;
8928 emit_header(gc
->pc
, X_GLrop_BlendFuncSeparateEXT
, cmdlen
);
8929 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&sfactorRGB
), 4);
8930 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&dfactorRGB
), 4);
8931 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&sfactorAlpha
), 4);
8932 (void) memcpy((void *) (gc
->pc
+ 16), (void *) (&dfactorAlpha
), 4);
8934 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
8935 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
8939 #define X_GLrop_WindowPos3fvMESA 230
8941 __indirect_glWindowPos3fMESA(GLfloat x
, GLfloat y
, GLfloat z
)
8943 struct glx_context
*const gc
= __glXGetCurrentContext();
8944 const GLuint cmdlen
= 16;
8945 emit_header(gc
->pc
, X_GLrop_WindowPos3fvMESA
, cmdlen
);
8946 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&x
), 4);
8947 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&y
), 4);
8948 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&z
), 4);
8950 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
8951 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
8955 #define X_GLrop_WindowPos3fvMESA 230
8957 __indirect_glWindowPos3fvMESA(const GLfloat
* v
)
8959 generic_12_byte(X_GLrop_WindowPos3fvMESA
, v
);
8962 #define X_GLvop_AreProgramsResidentNV 1293
8964 __indirect_glAreProgramsResidentNV(GLsizei n
, const GLuint
* ids
,
8965 GLboolean
* residences
)
8967 struct glx_context
*const gc
= __glXGetCurrentContext();
8968 Display
*const dpy
= gc
->currentDpy
;
8969 GLboolean retval
= (GLboolean
) 0;
8970 const GLuint cmdlen
= 4 + __GLX_PAD((n
* 4));
8972 __glXSetError(gc
, GL_INVALID_VALUE
);
8975 if (__builtin_expect((n
>= 0) && (dpy
!= NULL
), 1)) {
8977 __glXSetupVendorRequest(gc
, X_GLXVendorPrivateWithReply
,
8978 X_GLvop_AreProgramsResidentNV
, cmdlen
);
8979 (void) memcpy((void *) (pc
+ 0), (void *) (&n
), 4);
8980 (void) memcpy((void *) (pc
+ 4), (void *) (ids
), (n
* 4));
8981 retval
= (GLboolean
) __glXReadReply(dpy
, 1, residences
, GL_FALSE
);
8988 #define X_GLrop_BindProgramNV 4180
8990 __indirect_glBindProgramNV(GLenum target
, GLuint program
)
8992 struct glx_context
*const gc
= __glXGetCurrentContext();
8993 const GLuint cmdlen
= 12;
8994 emit_header(gc
->pc
, X_GLrop_BindProgramNV
, cmdlen
);
8995 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&target
), 4);
8996 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&program
), 4);
8998 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
8999 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
9003 #define X_GLvop_DeleteProgramsNV 1294
9005 __indirect_glDeleteProgramsNV(GLsizei n
, const GLuint
* programs
)
9007 struct glx_context
*const gc
= __glXGetCurrentContext();
9008 Display
*const dpy
= gc
->currentDpy
;
9009 const GLuint cmdlen
= 4 + __GLX_PAD((n
* 4));
9011 __glXSetError(gc
, GL_INVALID_VALUE
);
9014 if (__builtin_expect((n
>= 0) && (dpy
!= NULL
), 1)) {
9016 __glXSetupVendorRequest(gc
, X_GLXVendorPrivate
,
9017 X_GLvop_DeleteProgramsNV
, cmdlen
);
9018 (void) memcpy((void *) (pc
+ 0), (void *) (&n
), 4);
9019 (void) memcpy((void *) (pc
+ 4), (void *) (programs
), (n
* 4));
9026 #define X_GLrop_ExecuteProgramNV 4181
9028 __indirect_glExecuteProgramNV(GLenum target
, GLuint id
,
9029 const GLfloat
* params
)
9031 struct glx_context
*const gc
= __glXGetCurrentContext();
9032 const GLuint cmdlen
= 28;
9033 emit_header(gc
->pc
, X_GLrop_ExecuteProgramNV
, cmdlen
);
9034 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&target
), 4);
9035 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&id
), 4);
9036 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (params
), 16);
9038 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
9039 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
9043 #define X_GLvop_GenProgramsNV 1295
9045 __indirect_glGenProgramsNV(GLsizei n
, GLuint
* programs
)
9047 struct glx_context
*const gc
= __glXGetCurrentContext();
9048 Display
*const dpy
= gc
->currentDpy
;
9049 const GLuint cmdlen
= 4;
9051 __glXSetError(gc
, GL_INVALID_VALUE
);
9054 if (__builtin_expect((n
>= 0) && (dpy
!= NULL
), 1)) {
9056 __glXSetupVendorRequest(gc
, X_GLXVendorPrivateWithReply
,
9057 X_GLvop_GenProgramsNV
, cmdlen
);
9058 (void) memcpy((void *) (pc
+ 0), (void *) (&n
), 4);
9059 (void) __glXReadReply(dpy
, 4, programs
, GL_TRUE
);
9066 #define X_GLvop_GetProgramParameterdvNV 1297
9068 __indirect_glGetProgramParameterdvNV(GLenum target
, GLuint index
,
9069 GLenum pname
, GLdouble
* params
)
9071 struct glx_context
*const gc
= __glXGetCurrentContext();
9072 Display
*const dpy
= gc
->currentDpy
;
9073 const GLuint cmdlen
= 12;
9074 if (__builtin_expect(dpy
!= NULL
, 1)) {
9076 __glXSetupVendorRequest(gc
, X_GLXVendorPrivateWithReply
,
9077 X_GLvop_GetProgramParameterdvNV
, cmdlen
);
9078 (void) memcpy((void *) (pc
+ 0), (void *) (&target
), 4);
9079 (void) memcpy((void *) (pc
+ 4), (void *) (&index
), 4);
9080 (void) memcpy((void *) (pc
+ 8), (void *) (&pname
), 4);
9081 (void) __glXReadReply(dpy
, 8, params
, GL_FALSE
);
9088 #define X_GLvop_GetProgramParameterfvNV 1296
9090 __indirect_glGetProgramParameterfvNV(GLenum target
, GLuint index
,
9091 GLenum pname
, GLfloat
* params
)
9093 struct glx_context
*const gc
= __glXGetCurrentContext();
9094 Display
*const dpy
= gc
->currentDpy
;
9095 const GLuint cmdlen
= 12;
9096 if (__builtin_expect(dpy
!= NULL
, 1)) {
9098 __glXSetupVendorRequest(gc
, X_GLXVendorPrivateWithReply
,
9099 X_GLvop_GetProgramParameterfvNV
, cmdlen
);
9100 (void) memcpy((void *) (pc
+ 0), (void *) (&target
), 4);
9101 (void) memcpy((void *) (pc
+ 4), (void *) (&index
), 4);
9102 (void) memcpy((void *) (pc
+ 8), (void *) (&pname
), 4);
9103 (void) __glXReadReply(dpy
, 4, params
, GL_FALSE
);
9110 #define X_GLvop_GetProgramStringNV 1299
9112 __indirect_glGetProgramStringNV(GLuint id
, GLenum pname
, GLubyte
*program
)
9114 struct glx_context
*const gc
= __glXGetCurrentContext();
9115 Display
*const dpy
= gc
->currentDpy
;
9116 const GLuint cmdlen
= 8;
9117 if (__builtin_expect(dpy
!= NULL
, 1)) {
9119 __glXSetupVendorRequest(gc
, X_GLXVendorPrivateWithReply
,
9120 X_GLvop_GetProgramStringNV
, cmdlen
);
9121 (void) memcpy((void *) (pc
+ 0), (void *) (&id
), 4);
9122 (void) memcpy((void *) (pc
+ 4), (void *) (&pname
), 4);
9123 (void) __glXReadReply(dpy
, 1, program
, GL_TRUE
);
9130 #define X_GLvop_GetProgramivNV 1298
9132 __indirect_glGetProgramivNV(GLuint id
, GLenum pname
, GLint
* params
)
9134 struct glx_context
*const gc
= __glXGetCurrentContext();
9135 Display
*const dpy
= gc
->currentDpy
;
9136 const GLuint cmdlen
= 8;
9137 if (__builtin_expect(dpy
!= NULL
, 1)) {
9139 __glXSetupVendorRequest(gc
, X_GLXVendorPrivateWithReply
,
9140 X_GLvop_GetProgramivNV
, cmdlen
);
9141 (void) memcpy((void *) (pc
+ 0), (void *) (&id
), 4);
9142 (void) memcpy((void *) (pc
+ 4), (void *) (&pname
), 4);
9143 (void) __glXReadReply(dpy
, 4, params
, GL_FALSE
);
9150 #define X_GLvop_GetTrackMatrixivNV 1300
9152 __indirect_glGetTrackMatrixivNV(GLenum target
, GLuint address
, GLenum pname
,
9155 struct glx_context
*const gc
= __glXGetCurrentContext();
9156 Display
*const dpy
= gc
->currentDpy
;
9157 const GLuint cmdlen
= 12;
9158 if (__builtin_expect(dpy
!= NULL
, 1)) {
9160 __glXSetupVendorRequest(gc
, X_GLXVendorPrivateWithReply
,
9161 X_GLvop_GetTrackMatrixivNV
, cmdlen
);
9162 (void) memcpy((void *) (pc
+ 0), (void *) (&target
), 4);
9163 (void) memcpy((void *) (pc
+ 4), (void *) (&address
), 4);
9164 (void) memcpy((void *) (pc
+ 8), (void *) (&pname
), 4);
9165 (void) __glXReadReply(dpy
, 4, params
, GL_FALSE
);
9172 #define X_GLvop_GetVertexAttribdvNV 1301
9174 __indirect_glGetVertexAttribdvNV(GLuint index
, GLenum pname
,
9177 struct glx_context
*const gc
= __glXGetCurrentContext();
9178 Display
*const dpy
= gc
->currentDpy
;
9179 const GLuint cmdlen
= 8;
9180 if (__builtin_expect(dpy
!= NULL
, 1)) {
9182 __glXSetupVendorRequest(gc
, X_GLXVendorPrivateWithReply
,
9183 X_GLvop_GetVertexAttribdvNV
, cmdlen
);
9184 (void) memcpy((void *) (pc
+ 0), (void *) (&index
), 4);
9185 (void) memcpy((void *) (pc
+ 4), (void *) (&pname
), 4);
9186 (void) __glXReadReply(dpy
, 8, params
, GL_FALSE
);
9193 #define X_GLvop_GetVertexAttribfvNV 1302
9195 __indirect_glGetVertexAttribfvNV(GLuint index
, GLenum pname
, GLfloat
* params
)
9197 struct glx_context
*const gc
= __glXGetCurrentContext();
9198 Display
*const dpy
= gc
->currentDpy
;
9199 const GLuint cmdlen
= 8;
9200 if (__builtin_expect(dpy
!= NULL
, 1)) {
9202 __glXSetupVendorRequest(gc
, X_GLXVendorPrivateWithReply
,
9203 X_GLvop_GetVertexAttribfvNV
, cmdlen
);
9204 (void) memcpy((void *) (pc
+ 0), (void *) (&index
), 4);
9205 (void) memcpy((void *) (pc
+ 4), (void *) (&pname
), 4);
9206 (void) __glXReadReply(dpy
, 4, params
, GL_FALSE
);
9213 #define X_GLvop_GetVertexAttribivNV 1303
9215 __indirect_glGetVertexAttribivNV(GLuint index
, GLenum pname
, GLint
* params
)
9217 struct glx_context
*const gc
= __glXGetCurrentContext();
9218 Display
*const dpy
= gc
->currentDpy
;
9219 const GLuint cmdlen
= 8;
9220 if (__builtin_expect(dpy
!= NULL
, 1)) {
9222 __glXSetupVendorRequest(gc
, X_GLXVendorPrivateWithReply
,
9223 X_GLvop_GetVertexAttribivNV
, cmdlen
);
9224 (void) memcpy((void *) (pc
+ 0), (void *) (&index
), 4);
9225 (void) memcpy((void *) (pc
+ 4), (void *) (&pname
), 4);
9226 (void) __glXReadReply(dpy
, 4, params
, GL_FALSE
);
9233 #define X_GLvop_IsProgramNV 1304
9235 __indirect_glIsProgramNV(GLuint program
)
9237 struct glx_context
*const gc
= __glXGetCurrentContext();
9238 Display
*const dpy
= gc
->currentDpy
;
9239 GLboolean retval
= (GLboolean
) 0;
9240 const GLuint cmdlen
= 4;
9241 if (__builtin_expect(dpy
!= NULL
, 1)) {
9243 __glXSetupVendorRequest(gc
, X_GLXVendorPrivateWithReply
,
9244 X_GLvop_IsProgramNV
, cmdlen
);
9245 (void) memcpy((void *) (pc
+ 0), (void *) (&program
), 4);
9246 retval
= (GLboolean
) __glXReadReply(dpy
, 0, NULL
, GL_FALSE
);
9253 #define X_GLrop_LoadProgramNV 4183
9255 __indirect_glLoadProgramNV(GLenum target
, GLuint id
, GLsizei len
,
9256 const GLubyte
*program
)
9258 struct glx_context
*const gc
= __glXGetCurrentContext();
9259 const GLuint cmdlen
= 16 + __GLX_PAD(len
);
9261 __glXSetError(gc
, GL_INVALID_VALUE
);
9264 if (__builtin_expect(len
>= 0, 1)) {
9265 emit_header(gc
->pc
, X_GLrop_LoadProgramNV
, cmdlen
);
9266 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&target
), 4);
9267 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&id
), 4);
9268 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&len
), 4);
9269 (void) memcpy((void *) (gc
->pc
+ 16), (void *) (program
), len
);
9271 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
9272 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
9277 #define X_GLrop_ProgramParameters4dvNV 4187
9279 __indirect_glProgramParameters4dvNV(GLenum target
, GLuint index
, GLsizei num
,
9280 const GLdouble
* params
)
9282 struct glx_context
*const gc
= __glXGetCurrentContext();
9283 const GLuint cmdlen
= 16 + __GLX_PAD((num
* 32));
9285 __glXSetError(gc
, GL_INVALID_VALUE
);
9288 if (__builtin_expect(num
>= 0, 1)) {
9289 emit_header(gc
->pc
, X_GLrop_ProgramParameters4dvNV
, cmdlen
);
9290 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&target
), 4);
9291 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&index
), 4);
9292 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&num
), 4);
9293 (void) memcpy((void *) (gc
->pc
+ 16), (void *) (params
), (num
* 32));
9295 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
9296 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
9301 #define X_GLrop_ProgramParameters4fvNV 4186
9303 __indirect_glProgramParameters4fvNV(GLenum target
, GLuint index
, GLsizei num
,
9304 const GLfloat
* params
)
9306 struct glx_context
*const gc
= __glXGetCurrentContext();
9307 const GLuint cmdlen
= 16 + __GLX_PAD((num
* 16));
9309 __glXSetError(gc
, GL_INVALID_VALUE
);
9312 if (__builtin_expect(num
>= 0, 1)) {
9313 emit_header(gc
->pc
, X_GLrop_ProgramParameters4fvNV
, cmdlen
);
9314 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&target
), 4);
9315 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&index
), 4);
9316 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&num
), 4);
9317 (void) memcpy((void *) (gc
->pc
+ 16), (void *) (params
), (num
* 16));
9319 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
9320 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
9325 #define X_GLrop_RequestResidentProgramsNV 4182
9327 __indirect_glRequestResidentProgramsNV(GLsizei n
, const GLuint
* ids
)
9329 struct glx_context
*const gc
= __glXGetCurrentContext();
9330 const GLuint cmdlen
= 8 + __GLX_PAD((n
* 4));
9332 __glXSetError(gc
, GL_INVALID_VALUE
);
9335 if (__builtin_expect(n
>= 0, 1)) {
9336 emit_header(gc
->pc
, X_GLrop_RequestResidentProgramsNV
, cmdlen
);
9337 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&n
), 4);
9338 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (ids
), (n
* 4));
9340 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
9341 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
9346 #define X_GLrop_TrackMatrixNV 4188
9348 __indirect_glTrackMatrixNV(GLenum target
, GLuint address
, GLenum matrix
,
9351 struct glx_context
*const gc
= __glXGetCurrentContext();
9352 const GLuint cmdlen
= 20;
9353 emit_header(gc
->pc
, X_GLrop_TrackMatrixNV
, cmdlen
);
9354 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&target
), 4);
9355 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&address
), 4);
9356 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&matrix
), 4);
9357 (void) memcpy((void *) (gc
->pc
+ 16), (void *) (&transform
), 4);
9359 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
9360 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
9364 #define X_GLrop_VertexAttrib1dvNV 4273
9366 __indirect_glVertexAttrib1dNV(GLuint index
, GLdouble x
)
9368 struct glx_context
*const gc
= __glXGetCurrentContext();
9369 const GLuint cmdlen
= 16;
9370 emit_header(gc
->pc
, X_GLrop_VertexAttrib1dvNV
, cmdlen
);
9371 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&index
), 4);
9372 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&x
), 8);
9374 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
9375 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
9379 #define X_GLrop_VertexAttrib1dvNV 4273
9381 __indirect_glVertexAttrib1dvNV(GLuint index
, const GLdouble
* v
)
9383 struct glx_context
*const gc
= __glXGetCurrentContext();
9384 const GLuint cmdlen
= 16;
9385 emit_header(gc
->pc
, X_GLrop_VertexAttrib1dvNV
, cmdlen
);
9386 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&index
), 4);
9387 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (v
), 8);
9389 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
9390 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
9394 #define X_GLrop_VertexAttrib1fvNV 4269
9396 __indirect_glVertexAttrib1fNV(GLuint index
, GLfloat x
)
9398 struct glx_context
*const gc
= __glXGetCurrentContext();
9399 const GLuint cmdlen
= 12;
9400 emit_header(gc
->pc
, X_GLrop_VertexAttrib1fvNV
, cmdlen
);
9401 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&index
), 4);
9402 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&x
), 4);
9404 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
9405 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
9409 #define X_GLrop_VertexAttrib1fvNV 4269
9411 __indirect_glVertexAttrib1fvNV(GLuint index
, const GLfloat
* v
)
9413 struct glx_context
*const gc
= __glXGetCurrentContext();
9414 const GLuint cmdlen
= 12;
9415 emit_header(gc
->pc
, X_GLrop_VertexAttrib1fvNV
, cmdlen
);
9416 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&index
), 4);
9417 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (v
), 4);
9419 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
9420 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
9424 #define X_GLrop_VertexAttrib1svNV 4265
9426 __indirect_glVertexAttrib1sNV(GLuint index
, GLshort x
)
9428 struct glx_context
*const gc
= __glXGetCurrentContext();
9429 const GLuint cmdlen
= 12;
9430 emit_header(gc
->pc
, X_GLrop_VertexAttrib1svNV
, cmdlen
);
9431 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&index
), 4);
9432 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&x
), 2);
9434 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
9435 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
9439 #define X_GLrop_VertexAttrib1svNV 4265
9441 __indirect_glVertexAttrib1svNV(GLuint index
, const GLshort
* v
)
9443 struct glx_context
*const gc
= __glXGetCurrentContext();
9444 const GLuint cmdlen
= 12;
9445 emit_header(gc
->pc
, X_GLrop_VertexAttrib1svNV
, cmdlen
);
9446 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&index
), 4);
9447 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (v
), 2);
9449 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
9450 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
9454 #define X_GLrop_VertexAttrib2dvNV 4274
9456 __indirect_glVertexAttrib2dNV(GLuint index
, GLdouble x
, GLdouble y
)
9458 struct glx_context
*const gc
= __glXGetCurrentContext();
9459 const GLuint cmdlen
= 24;
9460 emit_header(gc
->pc
, X_GLrop_VertexAttrib2dvNV
, cmdlen
);
9461 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&index
), 4);
9462 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&x
), 8);
9463 (void) memcpy((void *) (gc
->pc
+ 16), (void *) (&y
), 8);
9465 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
9466 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
9470 #define X_GLrop_VertexAttrib2dvNV 4274
9472 __indirect_glVertexAttrib2dvNV(GLuint index
, const GLdouble
* v
)
9474 struct glx_context
*const gc
= __glXGetCurrentContext();
9475 const GLuint cmdlen
= 24;
9476 emit_header(gc
->pc
, X_GLrop_VertexAttrib2dvNV
, cmdlen
);
9477 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&index
), 4);
9478 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (v
), 16);
9480 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
9481 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
9485 #define X_GLrop_VertexAttrib2fvNV 4270
9487 __indirect_glVertexAttrib2fNV(GLuint index
, GLfloat x
, GLfloat y
)
9489 struct glx_context
*const gc
= __glXGetCurrentContext();
9490 const GLuint cmdlen
= 16;
9491 emit_header(gc
->pc
, X_GLrop_VertexAttrib2fvNV
, cmdlen
);
9492 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&index
), 4);
9493 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&x
), 4);
9494 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&y
), 4);
9496 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
9497 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
9501 #define X_GLrop_VertexAttrib2fvNV 4270
9503 __indirect_glVertexAttrib2fvNV(GLuint index
, const GLfloat
* v
)
9505 struct glx_context
*const gc
= __glXGetCurrentContext();
9506 const GLuint cmdlen
= 16;
9507 emit_header(gc
->pc
, X_GLrop_VertexAttrib2fvNV
, cmdlen
);
9508 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&index
), 4);
9509 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (v
), 8);
9511 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
9512 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
9516 #define X_GLrop_VertexAttrib2svNV 4266
9518 __indirect_glVertexAttrib2sNV(GLuint index
, GLshort x
, GLshort y
)
9520 struct glx_context
*const gc
= __glXGetCurrentContext();
9521 const GLuint cmdlen
= 12;
9522 emit_header(gc
->pc
, X_GLrop_VertexAttrib2svNV
, cmdlen
);
9523 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&index
), 4);
9524 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&x
), 2);
9525 (void) memcpy((void *) (gc
->pc
+ 10), (void *) (&y
), 2);
9527 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
9528 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
9532 #define X_GLrop_VertexAttrib2svNV 4266
9534 __indirect_glVertexAttrib2svNV(GLuint index
, const GLshort
* v
)
9536 struct glx_context
*const gc
= __glXGetCurrentContext();
9537 const GLuint cmdlen
= 12;
9538 emit_header(gc
->pc
, X_GLrop_VertexAttrib2svNV
, cmdlen
);
9539 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&index
), 4);
9540 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (v
), 4);
9542 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
9543 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
9547 #define X_GLrop_VertexAttrib3dvNV 4275
9549 __indirect_glVertexAttrib3dNV(GLuint index
, GLdouble x
, GLdouble y
,
9552 struct glx_context
*const gc
= __glXGetCurrentContext();
9553 const GLuint cmdlen
= 32;
9554 emit_header(gc
->pc
, X_GLrop_VertexAttrib3dvNV
, cmdlen
);
9555 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&index
), 4);
9556 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&x
), 8);
9557 (void) memcpy((void *) (gc
->pc
+ 16), (void *) (&y
), 8);
9558 (void) memcpy((void *) (gc
->pc
+ 24), (void *) (&z
), 8);
9560 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
9561 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
9565 #define X_GLrop_VertexAttrib3dvNV 4275
9567 __indirect_glVertexAttrib3dvNV(GLuint index
, const GLdouble
* v
)
9569 struct glx_context
*const gc
= __glXGetCurrentContext();
9570 const GLuint cmdlen
= 32;
9571 emit_header(gc
->pc
, X_GLrop_VertexAttrib3dvNV
, cmdlen
);
9572 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&index
), 4);
9573 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (v
), 24);
9575 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
9576 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
9580 #define X_GLrop_VertexAttrib3fvNV 4271
9582 __indirect_glVertexAttrib3fNV(GLuint index
, GLfloat x
, GLfloat y
, GLfloat z
)
9584 struct glx_context
*const gc
= __glXGetCurrentContext();
9585 const GLuint cmdlen
= 20;
9586 emit_header(gc
->pc
, X_GLrop_VertexAttrib3fvNV
, cmdlen
);
9587 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&index
), 4);
9588 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&x
), 4);
9589 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&y
), 4);
9590 (void) memcpy((void *) (gc
->pc
+ 16), (void *) (&z
), 4);
9592 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
9593 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
9597 #define X_GLrop_VertexAttrib3fvNV 4271
9599 __indirect_glVertexAttrib3fvNV(GLuint index
, const GLfloat
* v
)
9601 struct glx_context
*const gc
= __glXGetCurrentContext();
9602 const GLuint cmdlen
= 20;
9603 emit_header(gc
->pc
, X_GLrop_VertexAttrib3fvNV
, cmdlen
);
9604 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&index
), 4);
9605 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (v
), 12);
9607 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
9608 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
9612 #define X_GLrop_VertexAttrib3svNV 4267
9614 __indirect_glVertexAttrib3sNV(GLuint index
, GLshort x
, GLshort y
, GLshort z
)
9616 struct glx_context
*const gc
= __glXGetCurrentContext();
9617 const GLuint cmdlen
= 16;
9618 emit_header(gc
->pc
, X_GLrop_VertexAttrib3svNV
, cmdlen
);
9619 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&index
), 4);
9620 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&x
), 2);
9621 (void) memcpy((void *) (gc
->pc
+ 10), (void *) (&y
), 2);
9622 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&z
), 2);
9624 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
9625 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
9629 #define X_GLrop_VertexAttrib3svNV 4267
9631 __indirect_glVertexAttrib3svNV(GLuint index
, const GLshort
* v
)
9633 struct glx_context
*const gc
= __glXGetCurrentContext();
9634 const GLuint cmdlen
= 16;
9635 emit_header(gc
->pc
, X_GLrop_VertexAttrib3svNV
, cmdlen
);
9636 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&index
), 4);
9637 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (v
), 6);
9639 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
9640 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
9644 #define X_GLrop_VertexAttrib4dvNV 4276
9646 __indirect_glVertexAttrib4dNV(GLuint index
, GLdouble x
, GLdouble y
,
9647 GLdouble z
, GLdouble w
)
9649 struct glx_context
*const gc
= __glXGetCurrentContext();
9650 const GLuint cmdlen
= 40;
9651 emit_header(gc
->pc
, X_GLrop_VertexAttrib4dvNV
, cmdlen
);
9652 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&index
), 4);
9653 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&x
), 8);
9654 (void) memcpy((void *) (gc
->pc
+ 16), (void *) (&y
), 8);
9655 (void) memcpy((void *) (gc
->pc
+ 24), (void *) (&z
), 8);
9656 (void) memcpy((void *) (gc
->pc
+ 32), (void *) (&w
), 8);
9658 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
9659 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
9663 #define X_GLrop_VertexAttrib4dvNV 4276
9665 __indirect_glVertexAttrib4dvNV(GLuint index
, const GLdouble
* v
)
9667 struct glx_context
*const gc
= __glXGetCurrentContext();
9668 const GLuint cmdlen
= 40;
9669 emit_header(gc
->pc
, X_GLrop_VertexAttrib4dvNV
, cmdlen
);
9670 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&index
), 4);
9671 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (v
), 32);
9673 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
9674 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
9678 #define X_GLrop_VertexAttrib4fvNV 4272
9680 __indirect_glVertexAttrib4fNV(GLuint index
, GLfloat x
, GLfloat y
, GLfloat z
,
9683 struct glx_context
*const gc
= __glXGetCurrentContext();
9684 const GLuint cmdlen
= 24;
9685 emit_header(gc
->pc
, X_GLrop_VertexAttrib4fvNV
, cmdlen
);
9686 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&index
), 4);
9687 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&x
), 4);
9688 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&y
), 4);
9689 (void) memcpy((void *) (gc
->pc
+ 16), (void *) (&z
), 4);
9690 (void) memcpy((void *) (gc
->pc
+ 20), (void *) (&w
), 4);
9692 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
9693 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
9697 #define X_GLrop_VertexAttrib4fvNV 4272
9699 __indirect_glVertexAttrib4fvNV(GLuint index
, const GLfloat
* v
)
9701 struct glx_context
*const gc
= __glXGetCurrentContext();
9702 const GLuint cmdlen
= 24;
9703 emit_header(gc
->pc
, X_GLrop_VertexAttrib4fvNV
, cmdlen
);
9704 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&index
), 4);
9705 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (v
), 16);
9707 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
9708 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
9712 #define X_GLrop_VertexAttrib4svNV 4268
9714 __indirect_glVertexAttrib4sNV(GLuint index
, GLshort x
, GLshort y
, GLshort z
,
9717 struct glx_context
*const gc
= __glXGetCurrentContext();
9718 const GLuint cmdlen
= 16;
9719 emit_header(gc
->pc
, X_GLrop_VertexAttrib4svNV
, cmdlen
);
9720 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&index
), 4);
9721 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&x
), 2);
9722 (void) memcpy((void *) (gc
->pc
+ 10), (void *) (&y
), 2);
9723 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&z
), 2);
9724 (void) memcpy((void *) (gc
->pc
+ 14), (void *) (&w
), 2);
9726 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
9727 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
9731 #define X_GLrop_VertexAttrib4svNV 4268
9733 __indirect_glVertexAttrib4svNV(GLuint index
, const GLshort
* v
)
9735 struct glx_context
*const gc
= __glXGetCurrentContext();
9736 const GLuint cmdlen
= 16;
9737 emit_header(gc
->pc
, X_GLrop_VertexAttrib4svNV
, cmdlen
);
9738 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&index
), 4);
9739 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (v
), 8);
9741 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
9742 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
9746 #define X_GLrop_VertexAttrib4ubvNV 4277
9748 __indirect_glVertexAttrib4ubNV(GLuint index
, GLubyte x
, GLubyte y
, GLubyte z
,
9751 struct glx_context
*const gc
= __glXGetCurrentContext();
9752 const GLuint cmdlen
= 12;
9753 emit_header(gc
->pc
, X_GLrop_VertexAttrib4ubvNV
, cmdlen
);
9754 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&index
), 4);
9755 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&x
), 1);
9756 (void) memcpy((void *) (gc
->pc
+ 9), (void *) (&y
), 1);
9757 (void) memcpy((void *) (gc
->pc
+ 10), (void *) (&z
), 1);
9758 (void) memcpy((void *) (gc
->pc
+ 11), (void *) (&w
), 1);
9760 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
9761 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
9765 #define X_GLrop_VertexAttrib4ubvNV 4277
9767 __indirect_glVertexAttrib4ubvNV(GLuint index
, const GLubyte
*v
)
9769 struct glx_context
*const gc
= __glXGetCurrentContext();
9770 const GLuint cmdlen
= 12;
9771 emit_header(gc
->pc
, X_GLrop_VertexAttrib4ubvNV
, cmdlen
);
9772 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&index
), 4);
9773 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (v
), 4);
9775 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
9776 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
9780 #define X_GLrop_VertexAttribs1dvNV 4210
9782 __indirect_glVertexAttribs1dvNV(GLuint index
, GLsizei n
, const GLdouble
* v
)
9784 struct glx_context
*const gc
= __glXGetCurrentContext();
9785 const GLuint cmdlen
= 12 + __GLX_PAD((n
* 8));
9787 __glXSetError(gc
, GL_INVALID_VALUE
);
9790 if (__builtin_expect(n
>= 0, 1)) {
9791 emit_header(gc
->pc
, X_GLrop_VertexAttribs1dvNV
, cmdlen
);
9792 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&index
), 4);
9793 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&n
), 4);
9794 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (v
), (n
* 8));
9796 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
9797 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
9802 #define X_GLrop_VertexAttribs1fvNV 4206
9804 __indirect_glVertexAttribs1fvNV(GLuint index
, GLsizei n
, const GLfloat
* v
)
9806 struct glx_context
*const gc
= __glXGetCurrentContext();
9807 const GLuint cmdlen
= 12 + __GLX_PAD((n
* 4));
9809 __glXSetError(gc
, GL_INVALID_VALUE
);
9812 if (__builtin_expect(n
>= 0, 1)) {
9813 emit_header(gc
->pc
, X_GLrop_VertexAttribs1fvNV
, cmdlen
);
9814 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&index
), 4);
9815 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&n
), 4);
9816 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (v
), (n
* 4));
9818 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
9819 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
9824 #define X_GLrop_VertexAttribs1svNV 4202
9826 __indirect_glVertexAttribs1svNV(GLuint index
, GLsizei n
, const GLshort
* v
)
9828 struct glx_context
*const gc
= __glXGetCurrentContext();
9829 const GLuint cmdlen
= 12 + __GLX_PAD((n
* 2));
9831 __glXSetError(gc
, GL_INVALID_VALUE
);
9834 if (__builtin_expect(n
>= 0, 1)) {
9835 emit_header(gc
->pc
, X_GLrop_VertexAttribs1svNV
, cmdlen
);
9836 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&index
), 4);
9837 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&n
), 4);
9838 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (v
), (n
* 2));
9840 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
9841 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
9846 #define X_GLrop_VertexAttribs2dvNV 4211
9848 __indirect_glVertexAttribs2dvNV(GLuint index
, GLsizei n
, const GLdouble
* v
)
9850 struct glx_context
*const gc
= __glXGetCurrentContext();
9851 const GLuint cmdlen
= 12 + __GLX_PAD((n
* 16));
9853 __glXSetError(gc
, GL_INVALID_VALUE
);
9856 if (__builtin_expect(n
>= 0, 1)) {
9857 emit_header(gc
->pc
, X_GLrop_VertexAttribs2dvNV
, cmdlen
);
9858 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&index
), 4);
9859 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&n
), 4);
9860 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (v
), (n
* 16));
9862 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
9863 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
9868 #define X_GLrop_VertexAttribs2fvNV 4207
9870 __indirect_glVertexAttribs2fvNV(GLuint index
, GLsizei n
, const GLfloat
* v
)
9872 struct glx_context
*const gc
= __glXGetCurrentContext();
9873 const GLuint cmdlen
= 12 + __GLX_PAD((n
* 8));
9875 __glXSetError(gc
, GL_INVALID_VALUE
);
9878 if (__builtin_expect(n
>= 0, 1)) {
9879 emit_header(gc
->pc
, X_GLrop_VertexAttribs2fvNV
, cmdlen
);
9880 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&index
), 4);
9881 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&n
), 4);
9882 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (v
), (n
* 8));
9884 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
9885 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
9890 #define X_GLrop_VertexAttribs2svNV 4203
9892 __indirect_glVertexAttribs2svNV(GLuint index
, GLsizei n
, const GLshort
* v
)
9894 struct glx_context
*const gc
= __glXGetCurrentContext();
9895 const GLuint cmdlen
= 12 + __GLX_PAD((n
* 4));
9897 __glXSetError(gc
, GL_INVALID_VALUE
);
9900 if (__builtin_expect(n
>= 0, 1)) {
9901 emit_header(gc
->pc
, X_GLrop_VertexAttribs2svNV
, cmdlen
);
9902 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&index
), 4);
9903 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&n
), 4);
9904 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (v
), (n
* 4));
9906 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
9907 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
9912 #define X_GLrop_VertexAttribs3dvNV 4212
9914 __indirect_glVertexAttribs3dvNV(GLuint index
, GLsizei n
, const GLdouble
* v
)
9916 struct glx_context
*const gc
= __glXGetCurrentContext();
9917 const GLuint cmdlen
= 12 + __GLX_PAD((n
* 24));
9919 __glXSetError(gc
, GL_INVALID_VALUE
);
9922 if (__builtin_expect(n
>= 0, 1)) {
9923 emit_header(gc
->pc
, X_GLrop_VertexAttribs3dvNV
, cmdlen
);
9924 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&index
), 4);
9925 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&n
), 4);
9926 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (v
), (n
* 24));
9928 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
9929 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
9934 #define X_GLrop_VertexAttribs3fvNV 4208
9936 __indirect_glVertexAttribs3fvNV(GLuint index
, GLsizei n
, const GLfloat
* v
)
9938 struct glx_context
*const gc
= __glXGetCurrentContext();
9939 const GLuint cmdlen
= 12 + __GLX_PAD((n
* 12));
9941 __glXSetError(gc
, GL_INVALID_VALUE
);
9944 if (__builtin_expect(n
>= 0, 1)) {
9945 emit_header(gc
->pc
, X_GLrop_VertexAttribs3fvNV
, cmdlen
);
9946 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&index
), 4);
9947 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&n
), 4);
9948 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (v
), (n
* 12));
9950 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
9951 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
9956 #define X_GLrop_VertexAttribs3svNV 4204
9958 __indirect_glVertexAttribs3svNV(GLuint index
, GLsizei n
, const GLshort
* v
)
9960 struct glx_context
*const gc
= __glXGetCurrentContext();
9961 const GLuint cmdlen
= 12 + __GLX_PAD((n
* 6));
9963 __glXSetError(gc
, GL_INVALID_VALUE
);
9966 if (__builtin_expect(n
>= 0, 1)) {
9967 emit_header(gc
->pc
, X_GLrop_VertexAttribs3svNV
, cmdlen
);
9968 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&index
), 4);
9969 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&n
), 4);
9970 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (v
), (n
* 6));
9972 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
9973 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
9978 #define X_GLrop_VertexAttribs4dvNV 4213
9980 __indirect_glVertexAttribs4dvNV(GLuint index
, GLsizei n
, const GLdouble
* v
)
9982 struct glx_context
*const gc
= __glXGetCurrentContext();
9983 const GLuint cmdlen
= 12 + __GLX_PAD((n
* 32));
9985 __glXSetError(gc
, GL_INVALID_VALUE
);
9988 if (__builtin_expect(n
>= 0, 1)) {
9989 emit_header(gc
->pc
, X_GLrop_VertexAttribs4dvNV
, cmdlen
);
9990 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&index
), 4);
9991 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&n
), 4);
9992 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (v
), (n
* 32));
9994 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
9995 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
10000 #define X_GLrop_VertexAttribs4fvNV 4209
10002 __indirect_glVertexAttribs4fvNV(GLuint index
, GLsizei n
, const GLfloat
* v
)
10004 struct glx_context
*const gc
= __glXGetCurrentContext();
10005 const GLuint cmdlen
= 12 + __GLX_PAD((n
* 16));
10007 __glXSetError(gc
, GL_INVALID_VALUE
);
10010 if (__builtin_expect(n
>= 0, 1)) {
10011 emit_header(gc
->pc
, X_GLrop_VertexAttribs4fvNV
, cmdlen
);
10012 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&index
), 4);
10013 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&n
), 4);
10014 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (v
), (n
* 16));
10016 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
10017 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
10022 #define X_GLrop_VertexAttribs4svNV 4205
10024 __indirect_glVertexAttribs4svNV(GLuint index
, GLsizei n
, const GLshort
* v
)
10026 struct glx_context
*const gc
= __glXGetCurrentContext();
10027 const GLuint cmdlen
= 12 + __GLX_PAD((n
* 8));
10029 __glXSetError(gc
, GL_INVALID_VALUE
);
10032 if (__builtin_expect(n
>= 0, 1)) {
10033 emit_header(gc
->pc
, X_GLrop_VertexAttribs4svNV
, cmdlen
);
10034 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&index
), 4);
10035 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&n
), 4);
10036 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (v
), (n
* 8));
10038 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
10039 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
10044 #define X_GLrop_VertexAttribs4ubvNV 4214
10046 __indirect_glVertexAttribs4ubvNV(GLuint index
, GLsizei n
, const GLubyte
*v
)
10048 struct glx_context
*const gc
= __glXGetCurrentContext();
10049 const GLuint cmdlen
= 12 + __GLX_PAD((n
* 4));
10051 __glXSetError(gc
, GL_INVALID_VALUE
);
10054 if (__builtin_expect(n
>= 0, 1)) {
10055 emit_header(gc
->pc
, X_GLrop_VertexAttribs4ubvNV
, cmdlen
);
10056 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&index
), 4);
10057 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&n
), 4);
10058 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (v
), (n
* 4));
10060 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
10061 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
10066 #define X_GLrop_PointParameteriNV 4221
10068 __indirect_glPointParameteriNV(GLenum pname
, GLint param
)
10070 struct glx_context
*const gc
= __glXGetCurrentContext();
10071 const GLuint cmdlen
= 12;
10072 emit_header(gc
->pc
, X_GLrop_PointParameteriNV
, cmdlen
);
10073 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&pname
), 4);
10074 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (¶m
), 4);
10076 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
10077 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
10081 #define X_GLrop_PointParameterivNV 4222
10083 __indirect_glPointParameterivNV(GLenum pname
, const GLint
* params
)
10085 struct glx_context
*const gc
= __glXGetCurrentContext();
10086 const GLuint compsize
= __glPointParameterivNV_size(pname
);
10087 const GLuint cmdlen
= 8 + __GLX_PAD((compsize
* 4));
10088 emit_header(gc
->pc
, X_GLrop_PointParameterivNV
, cmdlen
);
10089 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&pname
), 4);
10090 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (params
), (compsize
* 4));
10092 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
10093 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
10097 #define X_GLrop_ActiveStencilFaceEXT 4220
10099 __indirect_glActiveStencilFaceEXT(GLenum face
)
10101 struct glx_context
*const gc
= __glXGetCurrentContext();
10102 const GLuint cmdlen
= 8;
10103 emit_header(gc
->pc
, X_GLrop_ActiveStencilFaceEXT
, cmdlen
);
10104 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&face
), 4);
10106 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
10107 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
10111 #define X_GLvop_GetProgramNamedParameterdvNV 1311
10113 __indirect_glGetProgramNamedParameterdvNV(GLuint id
, GLsizei len
,
10114 const GLubyte
*name
,
10117 struct glx_context
*const gc
= __glXGetCurrentContext();
10118 Display
*const dpy
= gc
->currentDpy
;
10119 const GLuint cmdlen
= 8 + __GLX_PAD(len
);
10121 __glXSetError(gc
, GL_INVALID_VALUE
);
10124 if (__builtin_expect((len
>= 0) && (dpy
!= NULL
), 1)) {
10125 GLubyte
const *pc
=
10126 __glXSetupVendorRequest(gc
, X_GLXVendorPrivateWithReply
,
10127 X_GLvop_GetProgramNamedParameterdvNV
,
10129 (void) memcpy((void *) (pc
+ 0), (void *) (&id
), 4);
10130 (void) memcpy((void *) (pc
+ 4), (void *) (&len
), 4);
10131 (void) memcpy((void *) (pc
+ 8), (void *) (name
), len
);
10132 (void) __glXReadReply(dpy
, 8, params
, GL_TRUE
);
10133 UnlockDisplay(dpy
);
10139 #define X_GLvop_GetProgramNamedParameterfvNV 1310
10141 __indirect_glGetProgramNamedParameterfvNV(GLuint id
, GLsizei len
,
10142 const GLubyte
*name
,
10145 struct glx_context
*const gc
= __glXGetCurrentContext();
10146 Display
*const dpy
= gc
->currentDpy
;
10147 const GLuint cmdlen
= 8 + __GLX_PAD(len
);
10149 __glXSetError(gc
, GL_INVALID_VALUE
);
10152 if (__builtin_expect((len
>= 0) && (dpy
!= NULL
), 1)) {
10153 GLubyte
const *pc
=
10154 __glXSetupVendorRequest(gc
, X_GLXVendorPrivateWithReply
,
10155 X_GLvop_GetProgramNamedParameterfvNV
,
10157 (void) memcpy((void *) (pc
+ 0), (void *) (&id
), 4);
10158 (void) memcpy((void *) (pc
+ 4), (void *) (&len
), 4);
10159 (void) memcpy((void *) (pc
+ 8), (void *) (name
), len
);
10160 (void) __glXReadReply(dpy
, 4, params
, GL_TRUE
);
10161 UnlockDisplay(dpy
);
10167 #define X_GLrop_ProgramNamedParameter4dvNV 4219
10169 __indirect_glProgramNamedParameter4dNV(GLuint id
, GLsizei len
,
10170 const GLubyte
*name
, GLdouble x
,
10171 GLdouble y
, GLdouble z
, GLdouble w
)
10173 struct glx_context
*const gc
= __glXGetCurrentContext();
10174 const GLuint cmdlen
= 44 + __GLX_PAD(len
);
10176 __glXSetError(gc
, GL_INVALID_VALUE
);
10179 if (__builtin_expect(len
>= 0, 1)) {
10180 emit_header(gc
->pc
, X_GLrop_ProgramNamedParameter4dvNV
, cmdlen
);
10181 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&x
), 8);
10182 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&y
), 8);
10183 (void) memcpy((void *) (gc
->pc
+ 20), (void *) (&z
), 8);
10184 (void) memcpy((void *) (gc
->pc
+ 28), (void *) (&w
), 8);
10185 (void) memcpy((void *) (gc
->pc
+ 36), (void *) (&id
), 4);
10186 (void) memcpy((void *) (gc
->pc
+ 40), (void *) (&len
), 4);
10187 (void) memcpy((void *) (gc
->pc
+ 44), (void *) (name
), len
);
10189 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
10190 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
10195 #define X_GLrop_ProgramNamedParameter4dvNV 4219
10197 __indirect_glProgramNamedParameter4dvNV(GLuint id
, GLsizei len
,
10198 const GLubyte
*name
,
10199 const GLdouble
* v
)
10201 struct glx_context
*const gc
= __glXGetCurrentContext();
10202 const GLuint cmdlen
= 44 + __GLX_PAD(len
);
10204 __glXSetError(gc
, GL_INVALID_VALUE
);
10207 if (__builtin_expect(len
>= 0, 1)) {
10208 emit_header(gc
->pc
, X_GLrop_ProgramNamedParameter4dvNV
, cmdlen
);
10209 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (v
), 32);
10210 (void) memcpy((void *) (gc
->pc
+ 36), (void *) (&id
), 4);
10211 (void) memcpy((void *) (gc
->pc
+ 40), (void *) (&len
), 4);
10212 (void) memcpy((void *) (gc
->pc
+ 44), (void *) (name
), len
);
10214 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
10215 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
10220 #define X_GLrop_ProgramNamedParameter4fvNV 4218
10222 __indirect_glProgramNamedParameter4fNV(GLuint id
, GLsizei len
,
10223 const GLubyte
*name
, GLfloat x
,
10224 GLfloat y
, GLfloat z
, GLfloat w
)
10226 struct glx_context
*const gc
= __glXGetCurrentContext();
10227 const GLuint cmdlen
= 28 + __GLX_PAD(len
);
10229 __glXSetError(gc
, GL_INVALID_VALUE
);
10232 if (__builtin_expect(len
>= 0, 1)) {
10233 emit_header(gc
->pc
, X_GLrop_ProgramNamedParameter4fvNV
, cmdlen
);
10234 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&id
), 4);
10235 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&len
), 4);
10236 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&x
), 4);
10237 (void) memcpy((void *) (gc
->pc
+ 16), (void *) (&y
), 4);
10238 (void) memcpy((void *) (gc
->pc
+ 20), (void *) (&z
), 4);
10239 (void) memcpy((void *) (gc
->pc
+ 24), (void *) (&w
), 4);
10240 (void) memcpy((void *) (gc
->pc
+ 28), (void *) (name
), len
);
10242 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
10243 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
10248 #define X_GLrop_ProgramNamedParameter4fvNV 4218
10250 __indirect_glProgramNamedParameter4fvNV(GLuint id
, GLsizei len
,
10251 const GLubyte
*name
,
10254 struct glx_context
*const gc
= __glXGetCurrentContext();
10255 const GLuint cmdlen
= 28 + __GLX_PAD(len
);
10257 __glXSetError(gc
, GL_INVALID_VALUE
);
10260 if (__builtin_expect(len
>= 0, 1)) {
10261 emit_header(gc
->pc
, X_GLrop_ProgramNamedParameter4fvNV
, cmdlen
);
10262 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&id
), 4);
10263 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&len
), 4);
10264 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (v
), 16);
10265 (void) memcpy((void *) (gc
->pc
+ 28), (void *) (name
), len
);
10267 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
10268 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
10273 #define X_GLrop_BlendEquationSeparateEXT 4228
10275 __indirect_glBlendEquationSeparateEXT(GLenum modeRGB
, GLenum modeA
)
10277 struct glx_context
*const gc
= __glXGetCurrentContext();
10278 const GLuint cmdlen
= 12;
10279 emit_header(gc
->pc
, X_GLrop_BlendEquationSeparateEXT
, cmdlen
);
10280 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&modeRGB
), 4);
10281 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&modeA
), 4);
10283 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
10284 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
10288 #define X_GLrop_BindFramebufferEXT 4319
10290 __indirect_glBindFramebufferEXT(GLenum target
, GLuint framebuffer
)
10292 struct glx_context
*const gc
= __glXGetCurrentContext();
10293 const GLuint cmdlen
= 12;
10294 emit_header(gc
->pc
, X_GLrop_BindFramebufferEXT
, cmdlen
);
10295 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&target
), 4);
10296 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&framebuffer
), 4);
10298 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
10299 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
10303 #define X_GLrop_BindRenderbufferEXT 4316
10305 __indirect_glBindRenderbufferEXT(GLenum target
, GLuint renderbuffer
)
10307 struct glx_context
*const gc
= __glXGetCurrentContext();
10308 const GLuint cmdlen
= 12;
10309 emit_header(gc
->pc
, X_GLrop_BindRenderbufferEXT
, cmdlen
);
10310 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&target
), 4);
10311 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&renderbuffer
), 4);
10313 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
10314 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
10318 #define X_GLvop_CheckFramebufferStatusEXT 1427
10320 __indirect_glCheckFramebufferStatusEXT(GLenum target
)
10322 struct glx_context
*const gc
= __glXGetCurrentContext();
10323 Display
*const dpy
= gc
->currentDpy
;
10324 GLenum retval
= (GLenum
) 0;
10325 const GLuint cmdlen
= 4;
10326 if (__builtin_expect(dpy
!= NULL
, 1)) {
10327 GLubyte
const *pc
=
10328 __glXSetupVendorRequest(gc
, X_GLXVendorPrivateWithReply
,
10329 X_GLvop_CheckFramebufferStatusEXT
,
10331 (void) memcpy((void *) (pc
+ 0), (void *) (&target
), 4);
10332 retval
= (GLenum
) __glXReadReply(dpy
, 0, NULL
, GL_FALSE
);
10333 UnlockDisplay(dpy
);
10339 #define X_GLrop_DeleteFramebuffersEXT 4320
10341 __indirect_glDeleteFramebuffersEXT(GLsizei n
, const GLuint
* framebuffers
)
10343 struct glx_context
*const gc
= __glXGetCurrentContext();
10344 const GLuint cmdlen
= 8 + __GLX_PAD((n
* 4));
10346 __glXSetError(gc
, GL_INVALID_VALUE
);
10349 if (__builtin_expect(n
>= 0, 1)) {
10350 emit_header(gc
->pc
, X_GLrop_DeleteFramebuffersEXT
, cmdlen
);
10351 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&n
), 4);
10352 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (framebuffers
),
10355 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
10356 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
10361 #define X_GLrop_DeleteRenderbuffersEXT 4317
10363 __indirect_glDeleteRenderbuffersEXT(GLsizei n
, const GLuint
* renderbuffers
)
10365 struct glx_context
*const gc
= __glXGetCurrentContext();
10366 const GLuint cmdlen
= 8 + __GLX_PAD((n
* 4));
10368 __glXSetError(gc
, GL_INVALID_VALUE
);
10371 if (__builtin_expect(n
>= 0, 1)) {
10372 emit_header(gc
->pc
, X_GLrop_DeleteRenderbuffersEXT
, cmdlen
);
10373 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&n
), 4);
10374 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (renderbuffers
),
10377 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
10378 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
10383 #define X_GLrop_FramebufferRenderbufferEXT 4324
10385 __indirect_glFramebufferRenderbufferEXT(GLenum target
, GLenum attachment
,
10386 GLenum renderbuffertarget
,
10387 GLuint renderbuffer
)
10389 struct glx_context
*const gc
= __glXGetCurrentContext();
10390 const GLuint cmdlen
= 20;
10391 emit_header(gc
->pc
, X_GLrop_FramebufferRenderbufferEXT
, cmdlen
);
10392 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&target
), 4);
10393 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&attachment
), 4);
10394 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&renderbuffertarget
), 4);
10395 (void) memcpy((void *) (gc
->pc
+ 16), (void *) (&renderbuffer
), 4);
10397 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
10398 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
10402 #define X_GLrop_FramebufferTexture1DEXT 4321
10404 __indirect_glFramebufferTexture1DEXT(GLenum target
, GLenum attachment
,
10405 GLenum textarget
, GLuint texture
,
10408 struct glx_context
*const gc
= __glXGetCurrentContext();
10409 const GLuint cmdlen
= 24;
10410 emit_header(gc
->pc
, X_GLrop_FramebufferTexture1DEXT
, cmdlen
);
10411 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&target
), 4);
10412 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&attachment
), 4);
10413 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&textarget
), 4);
10414 (void) memcpy((void *) (gc
->pc
+ 16), (void *) (&texture
), 4);
10415 (void) memcpy((void *) (gc
->pc
+ 20), (void *) (&level
), 4);
10417 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
10418 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
10422 #define X_GLrop_FramebufferTexture2DEXT 4322
10424 __indirect_glFramebufferTexture2DEXT(GLenum target
, GLenum attachment
,
10425 GLenum textarget
, GLuint texture
,
10428 struct glx_context
*const gc
= __glXGetCurrentContext();
10429 const GLuint cmdlen
= 24;
10430 emit_header(gc
->pc
, X_GLrop_FramebufferTexture2DEXT
, cmdlen
);
10431 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&target
), 4);
10432 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&attachment
), 4);
10433 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&textarget
), 4);
10434 (void) memcpy((void *) (gc
->pc
+ 16), (void *) (&texture
), 4);
10435 (void) memcpy((void *) (gc
->pc
+ 20), (void *) (&level
), 4);
10437 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
10438 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
10442 #define X_GLrop_FramebufferTexture3DEXT 4323
10444 __indirect_glFramebufferTexture3DEXT(GLenum target
, GLenum attachment
,
10445 GLenum textarget
, GLuint texture
,
10446 GLint level
, GLint zoffset
)
10448 struct glx_context
*const gc
= __glXGetCurrentContext();
10449 const GLuint cmdlen
= 28;
10450 emit_header(gc
->pc
, X_GLrop_FramebufferTexture3DEXT
, cmdlen
);
10451 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&target
), 4);
10452 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&attachment
), 4);
10453 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&textarget
), 4);
10454 (void) memcpy((void *) (gc
->pc
+ 16), (void *) (&texture
), 4);
10455 (void) memcpy((void *) (gc
->pc
+ 20), (void *) (&level
), 4);
10456 (void) memcpy((void *) (gc
->pc
+ 24), (void *) (&zoffset
), 4);
10458 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
10459 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
10463 #define X_GLvop_GenFramebuffersEXT 1426
10465 __indirect_glGenFramebuffersEXT(GLsizei n
, GLuint
* framebuffers
)
10467 struct glx_context
*const gc
= __glXGetCurrentContext();
10468 Display
*const dpy
= gc
->currentDpy
;
10469 const GLuint cmdlen
= 4;
10471 __glXSetError(gc
, GL_INVALID_VALUE
);
10474 if (__builtin_expect((n
>= 0) && (dpy
!= NULL
), 1)) {
10475 GLubyte
const *pc
=
10476 __glXSetupVendorRequest(gc
, X_GLXVendorPrivateWithReply
,
10477 X_GLvop_GenFramebuffersEXT
, cmdlen
);
10478 (void) memcpy((void *) (pc
+ 0), (void *) (&n
), 4);
10479 (void) __glXReadReply(dpy
, 4, framebuffers
, GL_TRUE
);
10480 UnlockDisplay(dpy
);
10486 #define X_GLvop_GenRenderbuffersEXT 1423
10488 __indirect_glGenRenderbuffersEXT(GLsizei n
, GLuint
* renderbuffers
)
10490 struct glx_context
*const gc
= __glXGetCurrentContext();
10491 Display
*const dpy
= gc
->currentDpy
;
10492 const GLuint cmdlen
= 4;
10494 __glXSetError(gc
, GL_INVALID_VALUE
);
10497 if (__builtin_expect((n
>= 0) && (dpy
!= NULL
), 1)) {
10498 GLubyte
const *pc
=
10499 __glXSetupVendorRequest(gc
, X_GLXVendorPrivateWithReply
,
10500 X_GLvop_GenRenderbuffersEXT
, cmdlen
);
10501 (void) memcpy((void *) (pc
+ 0), (void *) (&n
), 4);
10502 (void) __glXReadReply(dpy
, 4, renderbuffers
, GL_TRUE
);
10503 UnlockDisplay(dpy
);
10509 #define X_GLrop_GenerateMipmapEXT 4325
10511 __indirect_glGenerateMipmapEXT(GLenum target
)
10513 struct glx_context
*const gc
= __glXGetCurrentContext();
10514 const GLuint cmdlen
= 8;
10515 emit_header(gc
->pc
, X_GLrop_GenerateMipmapEXT
, cmdlen
);
10516 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&target
), 4);
10518 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
10519 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
10523 #define X_GLvop_GetFramebufferAttachmentParameterivEXT 1428
10525 __indirect_glGetFramebufferAttachmentParameterivEXT(GLenum target
,
10530 struct glx_context
*const gc
= __glXGetCurrentContext();
10531 Display
*const dpy
= gc
->currentDpy
;
10532 const GLuint cmdlen
= 12;
10533 if (__builtin_expect(dpy
!= NULL
, 1)) {
10534 GLubyte
const *pc
=
10535 __glXSetupVendorRequest(gc
, X_GLXVendorPrivateWithReply
,
10536 X_GLvop_GetFramebufferAttachmentParameterivEXT
,
10538 (void) memcpy((void *) (pc
+ 0), (void *) (&target
), 4);
10539 (void) memcpy((void *) (pc
+ 4), (void *) (&attachment
), 4);
10540 (void) memcpy((void *) (pc
+ 8), (void *) (&pname
), 4);
10541 (void) __glXReadReply(dpy
, 4, params
, GL_FALSE
);
10542 UnlockDisplay(dpy
);
10548 #define X_GLvop_GetRenderbufferParameterivEXT 1424
10550 __indirect_glGetRenderbufferParameterivEXT(GLenum target
, GLenum pname
,
10553 struct glx_context
*const gc
= __glXGetCurrentContext();
10554 Display
*const dpy
= gc
->currentDpy
;
10555 const GLuint cmdlen
= 8;
10556 if (__builtin_expect(dpy
!= NULL
, 1)) {
10557 GLubyte
const *pc
=
10558 __glXSetupVendorRequest(gc
, X_GLXVendorPrivateWithReply
,
10559 X_GLvop_GetRenderbufferParameterivEXT
,
10561 (void) memcpy((void *) (pc
+ 0), (void *) (&target
), 4);
10562 (void) memcpy((void *) (pc
+ 4), (void *) (&pname
), 4);
10563 (void) __glXReadReply(dpy
, 4, params
, GL_FALSE
);
10564 UnlockDisplay(dpy
);
10570 #define X_GLvop_IsFramebufferEXT 1425
10572 __indirect_glIsFramebufferEXT(GLuint framebuffer
)
10574 struct glx_context
*const gc
= __glXGetCurrentContext();
10575 Display
*const dpy
= gc
->currentDpy
;
10576 GLboolean retval
= (GLboolean
) 0;
10577 const GLuint cmdlen
= 4;
10578 if (__builtin_expect(dpy
!= NULL
, 1)) {
10579 GLubyte
const *pc
=
10580 __glXSetupVendorRequest(gc
, X_GLXVendorPrivateWithReply
,
10581 X_GLvop_IsFramebufferEXT
, cmdlen
);
10582 (void) memcpy((void *) (pc
+ 0), (void *) (&framebuffer
), 4);
10583 retval
= (GLboolean
) __glXReadReply(dpy
, 0, NULL
, GL_FALSE
);
10584 UnlockDisplay(dpy
);
10590 #define X_GLvop_IsRenderbufferEXT 1422
10592 __indirect_glIsRenderbufferEXT(GLuint renderbuffer
)
10594 struct glx_context
*const gc
= __glXGetCurrentContext();
10595 Display
*const dpy
= gc
->currentDpy
;
10596 GLboolean retval
= (GLboolean
) 0;
10597 const GLuint cmdlen
= 4;
10598 if (__builtin_expect(dpy
!= NULL
, 1)) {
10599 GLubyte
const *pc
=
10600 __glXSetupVendorRequest(gc
, X_GLXVendorPrivateWithReply
,
10601 X_GLvop_IsRenderbufferEXT
, cmdlen
);
10602 (void) memcpy((void *) (pc
+ 0), (void *) (&renderbuffer
), 4);
10603 retval
= (GLboolean
) __glXReadReply(dpy
, 0, NULL
, GL_FALSE
);
10604 UnlockDisplay(dpy
);
10610 #define X_GLrop_RenderbufferStorageEXT 4318
10612 __indirect_glRenderbufferStorageEXT(GLenum target
, GLenum internalformat
,
10613 GLsizei width
, GLsizei height
)
10615 struct glx_context
*const gc
= __glXGetCurrentContext();
10616 const GLuint cmdlen
= 20;
10617 emit_header(gc
->pc
, X_GLrop_RenderbufferStorageEXT
, cmdlen
);
10618 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&target
), 4);
10619 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&internalformat
), 4);
10620 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&width
), 4);
10621 (void) memcpy((void *) (gc
->pc
+ 16), (void *) (&height
), 4);
10623 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
10624 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
10628 #define X_GLrop_BlitFramebufferEXT 4330
10630 __indirect_glBlitFramebufferEXT(GLint srcX0
, GLint srcY0
, GLint srcX1
,
10631 GLint srcY1
, GLint dstX0
, GLint dstY0
,
10632 GLint dstX1
, GLint dstY1
, GLbitfield mask
,
10635 struct glx_context
*const gc
= __glXGetCurrentContext();
10636 const GLuint cmdlen
= 44;
10637 emit_header(gc
->pc
, X_GLrop_BlitFramebufferEXT
, cmdlen
);
10638 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&srcX0
), 4);
10639 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&srcY0
), 4);
10640 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&srcX1
), 4);
10641 (void) memcpy((void *) (gc
->pc
+ 16), (void *) (&srcY1
), 4);
10642 (void) memcpy((void *) (gc
->pc
+ 20), (void *) (&dstX0
), 4);
10643 (void) memcpy((void *) (gc
->pc
+ 24), (void *) (&dstY0
), 4);
10644 (void) memcpy((void *) (gc
->pc
+ 28), (void *) (&dstX1
), 4);
10645 (void) memcpy((void *) (gc
->pc
+ 32), (void *) (&dstY1
), 4);
10646 (void) memcpy((void *) (gc
->pc
+ 36), (void *) (&mask
), 4);
10647 (void) memcpy((void *) (gc
->pc
+ 40), (void *) (&filter
), 4);
10649 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
10650 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
10654 #define X_GLrop_FramebufferTextureLayerEXT 237
10656 __indirect_glFramebufferTextureLayerEXT(GLenum target
, GLenum attachment
,
10657 GLuint texture
, GLint level
,
10660 struct glx_context
*const gc
= __glXGetCurrentContext();
10661 const GLuint cmdlen
= 24;
10662 emit_header(gc
->pc
, X_GLrop_FramebufferTextureLayerEXT
, cmdlen
);
10663 (void) memcpy((void *) (gc
->pc
+ 4), (void *) (&target
), 4);
10664 (void) memcpy((void *) (gc
->pc
+ 8), (void *) (&attachment
), 4);
10665 (void) memcpy((void *) (gc
->pc
+ 12), (void *) (&texture
), 4);
10666 (void) memcpy((void *) (gc
->pc
+ 16), (void *) (&level
), 4);
10667 (void) memcpy((void *) (gc
->pc
+ 20), (void *) (&layer
), 4);
10669 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) {
10670 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
10675 #ifdef GLX_SHARED_GLAPI
10677 static const struct proc_pair
{
10680 } proc_pairs
[20] = {
10682 "AreTexturesResidentEXT", (_glapi_proc
) glAreTexturesResidentEXT
}, {
10683 "DeleteTexturesEXT", (_glapi_proc
) glDeleteTexturesEXT
}, {
10684 "GenTexturesEXT", (_glapi_proc
) glGenTexturesEXT
}, {
10685 "GetColorTableEXT", (_glapi_proc
) glGetColorTableEXT
}, {
10686 "GetColorTableParameterfvEXT",
10687 (_glapi_proc
) glGetColorTableParameterfvEXT
}, {
10688 "GetColorTableParameterfvSGI",
10689 (_glapi_proc
) glGetColorTableParameterfvEXT
}, {
10690 "GetColorTableParameterivEXT",
10691 (_glapi_proc
) glGetColorTableParameterivEXT
}, {
10692 "GetColorTableParameterivSGI",
10693 (_glapi_proc
) glGetColorTableParameterivEXT
}, {
10694 "GetColorTableSGI", (_glapi_proc
) glGetColorTableEXT
}, {
10695 "GetConvolutionFilterEXT", (_glapi_proc
) gl_dispatch_stub_356
}, {
10696 "GetConvolutionParameterfvEXT", (_glapi_proc
) gl_dispatch_stub_357
}, {
10697 "GetConvolutionParameterivEXT", (_glapi_proc
) gl_dispatch_stub_358
}, {
10698 "GetHistogramEXT", (_glapi_proc
) gl_dispatch_stub_361
}, {
10699 "GetHistogramParameterfvEXT", (_glapi_proc
) gl_dispatch_stub_362
}, {
10700 "GetHistogramParameterivEXT", (_glapi_proc
) gl_dispatch_stub_363
}, {
10701 "GetMinmaxEXT", (_glapi_proc
) gl_dispatch_stub_364
}, {
10702 "GetMinmaxParameterfvEXT", (_glapi_proc
) gl_dispatch_stub_365
}, {
10703 "GetMinmaxParameterivEXT", (_glapi_proc
) gl_dispatch_stub_366
}, {
10704 "GetSeparableFilterEXT", (_glapi_proc
) gl_dispatch_stub_359
}, {
10705 "IsTextureEXT", (_glapi_proc
) glIsTextureEXT
}
10709 __indirect_get_proc_compare(const void *key
, const void *memb
)
10711 const struct proc_pair
*pair
= (const struct proc_pair
*) memb
;
10712 return strcmp((const char *) key
, pair
->name
);
10716 __indirect_get_proc_address(const char *name
)
10718 const struct proc_pair
*pair
;
10723 pair
= (const struct proc_pair
*) bsearch((const void *) name
,
10724 (const void *) proc_pairs
,
10725 ARRAY_SIZE(proc_pairs
),
10726 sizeof(proc_pairs
[0]),
10727 __indirect_get_proc_compare
);
10729 return (pair
) ? pair
->proc
: NULL
;
10732 #endif /* GLX_SHARED_GLAPI */