1 /* DO NOT EDIT - This file generated automatically by glX_proto_send.py (from Mesa) script */
4 * (C) Copyright IBM Corporation 2004, 2005
7 * Permission is hereby granted, free of charge, to any person obtaining a
8 * copy of this software and associated documentation files (the "Software"),
9 * to deal in the Software without restriction, including without limitation
10 * the rights to use, copy, modify, merge, publish, distribute, sub license,
11 * and/or sell copies of the Software, and to permit persons to whom the
12 * Software is furnished to do so, subject to the following conditions:
14 * The above copyright notice and this permission notice (including the next
15 * paragraph) shall be included in all copies or substantial portions of the
18 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
19 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
20 * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL
22 * AND/OR THEIR SUPPLIERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
23 * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF
24 * OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
31 #include "glxclient.h"
32 #include "indirect_size.h"
33 #include <GL/glxproto.h>
36 #include <X11/XCB/xcb.h>
37 #include <X11/XCB/glx.h>
40 #define __GLX_PAD(n) (((n) + 3) & ~3)
42 # if defined(__i386__) && defined(__GNUC__)
43 # define FASTCALL __attribute__((fastcall))
47 # if defined(__GNUC__)
48 # define NOINLINE __attribute__((noinline))
53 #if !defined __GNUC__ || __GNUC__ < 3
54 # define __builtin_expect(x, y) x
57 /* If the size and opcode values are known at compile-time, this will, on
58 * x86 at least, emit them with a single instruction.
60 #define emit_header(dest, op, size) \
61 do { union { short s[2]; int i; } temp; \
62 temp.s[0] = (size); temp.s[1] = (op); \
63 *((int *)(dest)) = temp.i; } while(0)
66 __glXReadReply( Display
*dpy
, size_t size
, void * dest
, GLboolean reply_is_always_array
)
68 xGLXSingleReply reply
;
70 (void) _XReply(dpy
, (xReply
*) & reply
, 0, False
);
72 if ((reply
.length
> 0) || reply_is_always_array
) {
73 const GLint bytes
= (reply_is_always_array
)
74 ? (4 * reply
.length
) : (reply
.size
* size
);
75 const GLint extra
= 4 - (bytes
& 3);
77 _XRead(dpy
, dest
, bytes
);
79 _XEatData(dpy
, extra
);
83 (void) memcpy( dest
, &(reply
.pad3
), size
);
91 __glXReadPixelReply( Display
*dpy
, __GLXcontext
* gc
, unsigned max_dim
,
92 GLint width
, GLint height
, GLint depth
, GLenum format
, GLenum type
,
93 void * dest
, GLboolean dimensions_in_reply
)
95 xGLXSingleReply reply
;
98 (void) _XReply(dpy
, (xReply
*) & reply
, 0, False
);
100 if ( dimensions_in_reply
) {
105 if ((height
== 0) || (max_dim
< 2)) { height
= 1; }
106 if ((depth
== 0) || (max_dim
< 3)) { depth
= 1; }
109 size
= reply
.length
* 4;
111 void * buf
= Xmalloc( size
);
114 _XEatData(dpy
, size
);
115 __glXSetError(gc
, GL_OUT_OF_MEMORY
);
118 const GLint extra
= 4 - (size
& 3);
120 _XRead(dpy
, buf
, size
);
122 _XEatData(dpy
, extra
);
125 __glEmptyImage(gc
, 3, width
, height
, depth
, format
, type
,
132 #define X_GLXSingle 0
134 NOINLINE FASTCALL GLubyte
*
135 __glXSetupSingleRequest( __GLXcontext
* gc
, GLint sop
, GLint cmdlen
)
138 Display
* const dpy
= gc
->currentDpy
;
140 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
142 GetReqExtra(GLXSingle
, cmdlen
, req
);
143 req
->reqType
= gc
->majorOpcode
;
144 req
->contextTag
= gc
->currentContextTag
;
146 return (GLubyte
*)(req
) + sz_xGLXSingleReq
;
149 NOINLINE FASTCALL GLubyte
*
150 __glXSetupVendorRequest( __GLXcontext
* gc
, GLint code
, GLint vop
, GLint cmdlen
)
152 xGLXVendorPrivateReq
* req
;
153 Display
* const dpy
= gc
->currentDpy
;
155 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
157 GetReqExtra(GLXVendorPrivate
, cmdlen
, req
);
158 req
->reqType
= gc
->majorOpcode
;
160 req
->vendorCode
= vop
;
161 req
->contextTag
= gc
->currentContextTag
;
162 return (GLubyte
*)(req
) + sz_xGLXVendorPrivateReq
;
165 const GLuint __glXDefaultPixelStore
[9] = { 0, 0, 0, 0, 0, 0, 0, 0, 1 };
167 #define zero (__glXDefaultPixelStore+0)
168 #define one (__glXDefaultPixelStore+8)
169 #define default_pixel_store_1D (__glXDefaultPixelStore+4)
170 #define default_pixel_store_1D_size 20
171 #define default_pixel_store_2D (__glXDefaultPixelStore+4)
172 #define default_pixel_store_2D_size 20
173 #define default_pixel_store_3D (__glXDefaultPixelStore+0)
174 #define default_pixel_store_3D_size 36
175 #define default_pixel_store_4D (__glXDefaultPixelStore+0)
176 #define default_pixel_store_4D_size 36
178 static FASTCALL NOINLINE
void
179 generic_3_byte( GLint rop
, const void * ptr
)
181 __GLXcontext
* const gc
= __glXGetCurrentContext();
182 const GLuint cmdlen
= 8;
184 emit_header(gc
->pc
, rop
, cmdlen
);
185 (void) memcpy((void *)(gc
->pc
+ 4), ptr
, 4);
187 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
190 static FASTCALL NOINLINE
void
191 generic_4_byte( GLint rop
, const void * ptr
)
193 __GLXcontext
* const gc
= __glXGetCurrentContext();
194 const GLuint cmdlen
= 8;
196 emit_header(gc
->pc
, rop
, cmdlen
);
197 (void) memcpy((void *)(gc
->pc
+ 4), ptr
, 4);
199 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
202 static FASTCALL NOINLINE
void
203 generic_6_byte( GLint rop
, const void * ptr
)
205 __GLXcontext
* const gc
= __glXGetCurrentContext();
206 const GLuint cmdlen
= 12;
208 emit_header(gc
->pc
, rop
, cmdlen
);
209 (void) memcpy((void *)(gc
->pc
+ 4), ptr
, 8);
211 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
214 static FASTCALL NOINLINE
void
215 generic_8_byte( GLint rop
, const void * ptr
)
217 __GLXcontext
* const gc
= __glXGetCurrentContext();
218 const GLuint cmdlen
= 12;
220 emit_header(gc
->pc
, rop
, cmdlen
);
221 (void) memcpy((void *)(gc
->pc
+ 4), ptr
, 8);
223 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
226 static FASTCALL NOINLINE
void
227 generic_12_byte( GLint rop
, const void * ptr
)
229 __GLXcontext
* const gc
= __glXGetCurrentContext();
230 const GLuint cmdlen
= 16;
232 emit_header(gc
->pc
, rop
, cmdlen
);
233 (void) memcpy((void *)(gc
->pc
+ 4), ptr
, 12);
235 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
238 static FASTCALL NOINLINE
void
239 generic_16_byte( GLint rop
, const void * ptr
)
241 __GLXcontext
* const gc
= __glXGetCurrentContext();
242 const GLuint cmdlen
= 20;
244 emit_header(gc
->pc
, rop
, cmdlen
);
245 (void) memcpy((void *)(gc
->pc
+ 4), ptr
, 16);
247 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
250 static FASTCALL NOINLINE
void
251 generic_24_byte( GLint rop
, const void * ptr
)
253 __GLXcontext
* const gc
= __glXGetCurrentContext();
254 const GLuint cmdlen
= 28;
256 emit_header(gc
->pc
, rop
, cmdlen
);
257 (void) memcpy((void *)(gc
->pc
+ 4), ptr
, 24);
259 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
262 static FASTCALL NOINLINE
void
263 generic_32_byte( GLint rop
, const void * ptr
)
265 __GLXcontext
* const gc
= __glXGetCurrentContext();
266 const GLuint cmdlen
= 36;
268 emit_header(gc
->pc
, rop
, cmdlen
);
269 (void) memcpy((void *)(gc
->pc
+ 4), ptr
, 32);
271 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
274 #define X_GLsop_NewList 101
276 __indirect_glNewList(GLuint list
, GLenum mode
)
278 __GLXcontext
* const gc
= __glXGetCurrentContext();
279 Display
* const dpy
= gc
->currentDpy
;
280 const GLuint cmdlen
= 8;
281 if (__builtin_expect(dpy
!= NULL
, 1)) {
283 XCBConnection
*c
= XCBConnectionOfDisplay(dpy
);
284 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
285 XCBGlxNewList(c
, gc
->currentContextTag
, list
, mode
);
287 GLubyte
const * pc
= __glXSetupSingleRequest(gc
, X_GLsop_NewList
, cmdlen
);
288 (void) memcpy((void *)(pc
+ 0), (void *)(&list
), 4);
289 (void) memcpy((void *)(pc
+ 4), (void *)(&mode
), 4);
290 UnlockDisplay(dpy
); SyncHandle();
296 #define X_GLsop_EndList 102
298 __indirect_glEndList(void)
300 __GLXcontext
* const gc
= __glXGetCurrentContext();
301 Display
* const dpy
= gc
->currentDpy
;
302 const GLuint cmdlen
= 0;
303 if (__builtin_expect(dpy
!= NULL
, 1)) {
305 XCBConnection
*c
= XCBConnectionOfDisplay(dpy
);
306 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
307 XCBGlxEndList(c
, gc
->currentContextTag
);
309 (void) __glXSetupSingleRequest(gc
, X_GLsop_EndList
, cmdlen
);
310 UnlockDisplay(dpy
); SyncHandle();
316 #define X_GLrop_CallList 1
318 __indirect_glCallList(GLuint list
)
320 __GLXcontext
* const gc
= __glXGetCurrentContext();
321 const GLuint cmdlen
= 8;
322 emit_header(gc
->pc
, X_GLrop_CallList
, cmdlen
);
323 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&list
), 4);
325 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
328 #define X_GLrop_CallLists 2
330 __indirect_glCallLists(GLsizei n
, GLenum type
, const GLvoid
* lists
)
332 __GLXcontext
* const gc
= __glXGetCurrentContext();
333 const GLuint compsize
= __glCallLists_size(type
);
334 const GLuint cmdlen
= 12 + __GLX_PAD((compsize
* n
));
335 if (__builtin_expect((n
>= 0) && (gc
->currentDpy
!= NULL
), 1)) {
336 if (cmdlen
<= gc
->maxSmallRenderCommandSize
) {
337 if ( (gc
->pc
+ cmdlen
) > gc
->bufEnd
) {
338 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
340 emit_header(gc
->pc
, X_GLrop_CallLists
, cmdlen
);
341 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&n
), 4);
342 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(&type
), 4);
343 (void) memcpy((void *)(gc
->pc
+ 12), (void *)(lists
), (compsize
* n
));
345 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
348 const GLint op
= X_GLrop_CallLists
;
349 const GLuint cmdlenLarge
= cmdlen
+ 4;
350 GLubyte
* const pc
= __glXFlushRenderBuffer(gc
, gc
->pc
);
351 (void) memcpy((void *)(pc
+ 0), (void *)(&cmdlenLarge
), 4);
352 (void) memcpy((void *)(pc
+ 4), (void *)(&op
), 4);
353 (void) memcpy((void *)(pc
+ 8), (void *)(&n
), 4);
354 (void) memcpy((void *)(pc
+ 12), (void *)(&type
), 4);
355 __glXSendLargeCommand(gc
, pc
, 16, lists
, (compsize
* n
));
360 #define X_GLsop_DeleteLists 103
362 __indirect_glDeleteLists(GLuint list
, GLsizei range
)
364 __GLXcontext
* const gc
= __glXGetCurrentContext();
365 Display
* const dpy
= gc
->currentDpy
;
366 const GLuint cmdlen
= 8;
367 if (__builtin_expect(dpy
!= NULL
, 1)) {
369 XCBConnection
*c
= XCBConnectionOfDisplay(dpy
);
370 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
371 XCBGlxDeleteLists(c
, gc
->currentContextTag
, list
, range
);
373 GLubyte
const * pc
= __glXSetupSingleRequest(gc
, X_GLsop_DeleteLists
, cmdlen
);
374 (void) memcpy((void *)(pc
+ 0), (void *)(&list
), 4);
375 (void) memcpy((void *)(pc
+ 4), (void *)(&range
), 4);
376 UnlockDisplay(dpy
); SyncHandle();
382 #define X_GLsop_GenLists 104
384 __indirect_glGenLists(GLsizei range
)
386 __GLXcontext
* const gc
= __glXGetCurrentContext();
387 Display
* const dpy
= gc
->currentDpy
;
388 GLuint retval
= (GLuint
) 0;
389 const GLuint cmdlen
= 4;
390 if (__builtin_expect(dpy
!= NULL
, 1)) {
392 XCBConnection
*c
= XCBConnectionOfDisplay(dpy
);
393 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
394 XCBGlxGenListsRep
*reply
= XCBGlxGenListsReply(c
, XCBGlxGenLists(c
, gc
->currentContextTag
, range
), NULL
);
395 retval
= reply
->ret_val
;
398 GLubyte
const * pc
= __glXSetupSingleRequest(gc
, X_GLsop_GenLists
, cmdlen
);
399 (void) memcpy((void *)(pc
+ 0), (void *)(&range
), 4);
400 retval
= (GLuint
) __glXReadReply(dpy
, 0, NULL
, GL_FALSE
);
401 UnlockDisplay(dpy
); SyncHandle();
407 #define X_GLrop_ListBase 3
409 __indirect_glListBase(GLuint base
)
411 __GLXcontext
* const gc
= __glXGetCurrentContext();
412 const GLuint cmdlen
= 8;
413 emit_header(gc
->pc
, X_GLrop_ListBase
, cmdlen
);
414 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&base
), 4);
416 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
419 #define X_GLrop_Begin 4
421 __indirect_glBegin(GLenum mode
)
423 __GLXcontext
* const gc
= __glXGetCurrentContext();
424 const GLuint cmdlen
= 8;
425 emit_header(gc
->pc
, X_GLrop_Begin
, cmdlen
);
426 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&mode
), 4);
428 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
431 #define X_GLrop_Bitmap 5
433 __indirect_glBitmap(GLsizei width
, GLsizei height
, GLfloat xorig
, GLfloat yorig
, GLfloat xmove
, GLfloat ymove
, const GLubyte
* bitmap
)
435 __GLXcontext
* const gc
= __glXGetCurrentContext();
436 const GLuint compsize
= (bitmap
!= NULL
) ? __glImageSize(width
, height
, 1, GL_COLOR_INDEX
, GL_BITMAP
, 0) : 0;
437 const GLuint cmdlen
= 48 + __GLX_PAD(compsize
);
438 if (__builtin_expect(gc
->currentDpy
!= NULL
, 1)) {
439 if (cmdlen
<= gc
->maxSmallRenderCommandSize
) {
440 if ( (gc
->pc
+ cmdlen
) > gc
->bufEnd
) {
441 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
443 emit_header(gc
->pc
, X_GLrop_Bitmap
, cmdlen
);
444 (void) memcpy((void *)(gc
->pc
+ 24), (void *)(&width
), 4);
445 (void) memcpy((void *)(gc
->pc
+ 28), (void *)(&height
), 4);
446 (void) memcpy((void *)(gc
->pc
+ 32), (void *)(&xorig
), 4);
447 (void) memcpy((void *)(gc
->pc
+ 36), (void *)(&yorig
), 4);
448 (void) memcpy((void *)(gc
->pc
+ 40), (void *)(&xmove
), 4);
449 (void) memcpy((void *)(gc
->pc
+ 44), (void *)(&ymove
), 4);
451 (*gc
->fillImage
)(gc
, 2, width
, height
, 1, GL_COLOR_INDEX
, GL_BITMAP
, bitmap
, gc
->pc
+ 48, gc
->pc
+ 4);
454 (void) memcpy( gc
->pc
+ 4, default_pixel_store_2D
, default_pixel_store_2D_size
);
457 if (gc
->pc
> gc
->limit
) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
460 const GLint op
= X_GLrop_Bitmap
;
461 const GLuint cmdlenLarge
= cmdlen
+ 4;
462 GLubyte
* const pc
= __glXFlushRenderBuffer(gc
, gc
->pc
);
463 (void) memcpy((void *)(pc
+ 0), (void *)(&cmdlenLarge
), 4);
464 (void) memcpy((void *)(pc
+ 4), (void *)(&op
), 4);
465 (void) memcpy((void *)(pc
+ 28), (void *)(&width
), 4);
466 (void) memcpy((void *)(pc
+ 32), (void *)(&height
), 4);
467 (void) memcpy((void *)(pc
+ 36), (void *)(&xorig
), 4);
468 (void) memcpy((void *)(pc
+ 40), (void *)(&yorig
), 4);
469 (void) memcpy((void *)(pc
+ 44), (void *)(&xmove
), 4);
470 (void) memcpy((void *)(pc
+ 48), (void *)(&ymove
), 4);
471 __glXSendLargeImage(gc
, compsize
, 2, width
, height
, 1, GL_COLOR_INDEX
, GL_BITMAP
, bitmap
, pc
+ 52, pc
+ 8);
476 #define X_GLrop_Color3bv 6
478 __indirect_glColor3b(GLbyte red
, GLbyte green
, GLbyte blue
)
480 __GLXcontext
* const gc
= __glXGetCurrentContext();
481 const GLuint cmdlen
= 8;
482 emit_header(gc
->pc
, X_GLrop_Color3bv
, cmdlen
);
483 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&red
), 1);
484 (void) memcpy((void *)(gc
->pc
+ 5), (void *)(&green
), 1);
485 (void) memcpy((void *)(gc
->pc
+ 6), (void *)(&blue
), 1);
487 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
490 #define X_GLrop_Color3bv 6
492 __indirect_glColor3bv(const GLbyte
* v
)
494 generic_3_byte( X_GLrop_Color3bv
, v
);
497 #define X_GLrop_Color3dv 7
499 __indirect_glColor3d(GLdouble red
, GLdouble green
, GLdouble blue
)
501 __GLXcontext
* const gc
= __glXGetCurrentContext();
502 const GLuint cmdlen
= 28;
503 emit_header(gc
->pc
, X_GLrop_Color3dv
, cmdlen
);
504 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&red
), 8);
505 (void) memcpy((void *)(gc
->pc
+ 12), (void *)(&green
), 8);
506 (void) memcpy((void *)(gc
->pc
+ 20), (void *)(&blue
), 8);
508 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
511 #define X_GLrop_Color3dv 7
513 __indirect_glColor3dv(const GLdouble
* v
)
515 generic_24_byte( X_GLrop_Color3dv
, v
);
518 #define X_GLrop_Color3fv 8
520 __indirect_glColor3f(GLfloat red
, GLfloat green
, GLfloat blue
)
522 __GLXcontext
* const gc
= __glXGetCurrentContext();
523 const GLuint cmdlen
= 16;
524 emit_header(gc
->pc
, X_GLrop_Color3fv
, cmdlen
);
525 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&red
), 4);
526 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(&green
), 4);
527 (void) memcpy((void *)(gc
->pc
+ 12), (void *)(&blue
), 4);
529 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
532 #define X_GLrop_Color3fv 8
534 __indirect_glColor3fv(const GLfloat
* v
)
536 generic_12_byte( X_GLrop_Color3fv
, v
);
539 #define X_GLrop_Color3iv 9
541 __indirect_glColor3i(GLint red
, GLint green
, GLint blue
)
543 __GLXcontext
* const gc
= __glXGetCurrentContext();
544 const GLuint cmdlen
= 16;
545 emit_header(gc
->pc
, X_GLrop_Color3iv
, cmdlen
);
546 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&red
), 4);
547 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(&green
), 4);
548 (void) memcpy((void *)(gc
->pc
+ 12), (void *)(&blue
), 4);
550 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
553 #define X_GLrop_Color3iv 9
555 __indirect_glColor3iv(const GLint
* v
)
557 generic_12_byte( X_GLrop_Color3iv
, v
);
560 #define X_GLrop_Color3sv 10
562 __indirect_glColor3s(GLshort red
, GLshort green
, GLshort blue
)
564 __GLXcontext
* const gc
= __glXGetCurrentContext();
565 const GLuint cmdlen
= 12;
566 emit_header(gc
->pc
, X_GLrop_Color3sv
, cmdlen
);
567 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&red
), 2);
568 (void) memcpy((void *)(gc
->pc
+ 6), (void *)(&green
), 2);
569 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(&blue
), 2);
571 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
574 #define X_GLrop_Color3sv 10
576 __indirect_glColor3sv(const GLshort
* v
)
578 generic_6_byte( X_GLrop_Color3sv
, v
);
581 #define X_GLrop_Color3ubv 11
583 __indirect_glColor3ub(GLubyte red
, GLubyte green
, GLubyte blue
)
585 __GLXcontext
* const gc
= __glXGetCurrentContext();
586 const GLuint cmdlen
= 8;
587 emit_header(gc
->pc
, X_GLrop_Color3ubv
, cmdlen
);
588 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&red
), 1);
589 (void) memcpy((void *)(gc
->pc
+ 5), (void *)(&green
), 1);
590 (void) memcpy((void *)(gc
->pc
+ 6), (void *)(&blue
), 1);
592 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
595 #define X_GLrop_Color3ubv 11
597 __indirect_glColor3ubv(const GLubyte
* v
)
599 generic_3_byte( X_GLrop_Color3ubv
, v
);
602 #define X_GLrop_Color3uiv 12
604 __indirect_glColor3ui(GLuint red
, GLuint green
, GLuint blue
)
606 __GLXcontext
* const gc
= __glXGetCurrentContext();
607 const GLuint cmdlen
= 16;
608 emit_header(gc
->pc
, X_GLrop_Color3uiv
, cmdlen
);
609 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&red
), 4);
610 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(&green
), 4);
611 (void) memcpy((void *)(gc
->pc
+ 12), (void *)(&blue
), 4);
613 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
616 #define X_GLrop_Color3uiv 12
618 __indirect_glColor3uiv(const GLuint
* v
)
620 generic_12_byte( X_GLrop_Color3uiv
, v
);
623 #define X_GLrop_Color3usv 13
625 __indirect_glColor3us(GLushort red
, GLushort green
, GLushort blue
)
627 __GLXcontext
* const gc
= __glXGetCurrentContext();
628 const GLuint cmdlen
= 12;
629 emit_header(gc
->pc
, X_GLrop_Color3usv
, cmdlen
);
630 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&red
), 2);
631 (void) memcpy((void *)(gc
->pc
+ 6), (void *)(&green
), 2);
632 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(&blue
), 2);
634 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
637 #define X_GLrop_Color3usv 13
639 __indirect_glColor3usv(const GLushort
* v
)
641 generic_6_byte( X_GLrop_Color3usv
, v
);
644 #define X_GLrop_Color4bv 14
646 __indirect_glColor4b(GLbyte red
, GLbyte green
, GLbyte blue
, GLbyte alpha
)
648 __GLXcontext
* const gc
= __glXGetCurrentContext();
649 const GLuint cmdlen
= 8;
650 emit_header(gc
->pc
, X_GLrop_Color4bv
, cmdlen
);
651 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&red
), 1);
652 (void) memcpy((void *)(gc
->pc
+ 5), (void *)(&green
), 1);
653 (void) memcpy((void *)(gc
->pc
+ 6), (void *)(&blue
), 1);
654 (void) memcpy((void *)(gc
->pc
+ 7), (void *)(&alpha
), 1);
656 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
659 #define X_GLrop_Color4bv 14
661 __indirect_glColor4bv(const GLbyte
* v
)
663 generic_4_byte( X_GLrop_Color4bv
, v
);
666 #define X_GLrop_Color4dv 15
668 __indirect_glColor4d(GLdouble red
, GLdouble green
, GLdouble blue
, GLdouble alpha
)
670 __GLXcontext
* const gc
= __glXGetCurrentContext();
671 const GLuint cmdlen
= 36;
672 emit_header(gc
->pc
, X_GLrop_Color4dv
, cmdlen
);
673 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&red
), 8);
674 (void) memcpy((void *)(gc
->pc
+ 12), (void *)(&green
), 8);
675 (void) memcpy((void *)(gc
->pc
+ 20), (void *)(&blue
), 8);
676 (void) memcpy((void *)(gc
->pc
+ 28), (void *)(&alpha
), 8);
678 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
681 #define X_GLrop_Color4dv 15
683 __indirect_glColor4dv(const GLdouble
* v
)
685 generic_32_byte( X_GLrop_Color4dv
, v
);
688 #define X_GLrop_Color4fv 16
690 __indirect_glColor4f(GLfloat red
, GLfloat green
, GLfloat blue
, GLfloat alpha
)
692 __GLXcontext
* const gc
= __glXGetCurrentContext();
693 const GLuint cmdlen
= 20;
694 emit_header(gc
->pc
, X_GLrop_Color4fv
, cmdlen
);
695 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&red
), 4);
696 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(&green
), 4);
697 (void) memcpy((void *)(gc
->pc
+ 12), (void *)(&blue
), 4);
698 (void) memcpy((void *)(gc
->pc
+ 16), (void *)(&alpha
), 4);
700 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
703 #define X_GLrop_Color4fv 16
705 __indirect_glColor4fv(const GLfloat
* v
)
707 generic_16_byte( X_GLrop_Color4fv
, v
);
710 #define X_GLrop_Color4iv 17
712 __indirect_glColor4i(GLint red
, GLint green
, GLint blue
, GLint alpha
)
714 __GLXcontext
* const gc
= __glXGetCurrentContext();
715 const GLuint cmdlen
= 20;
716 emit_header(gc
->pc
, X_GLrop_Color4iv
, cmdlen
);
717 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&red
), 4);
718 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(&green
), 4);
719 (void) memcpy((void *)(gc
->pc
+ 12), (void *)(&blue
), 4);
720 (void) memcpy((void *)(gc
->pc
+ 16), (void *)(&alpha
), 4);
722 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
725 #define X_GLrop_Color4iv 17
727 __indirect_glColor4iv(const GLint
* v
)
729 generic_16_byte( X_GLrop_Color4iv
, v
);
732 #define X_GLrop_Color4sv 18
734 __indirect_glColor4s(GLshort red
, GLshort green
, GLshort blue
, GLshort alpha
)
736 __GLXcontext
* const gc
= __glXGetCurrentContext();
737 const GLuint cmdlen
= 12;
738 emit_header(gc
->pc
, X_GLrop_Color4sv
, cmdlen
);
739 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&red
), 2);
740 (void) memcpy((void *)(gc
->pc
+ 6), (void *)(&green
), 2);
741 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(&blue
), 2);
742 (void) memcpy((void *)(gc
->pc
+ 10), (void *)(&alpha
), 2);
744 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
747 #define X_GLrop_Color4sv 18
749 __indirect_glColor4sv(const GLshort
* v
)
751 generic_8_byte( X_GLrop_Color4sv
, v
);
754 #define X_GLrop_Color4ubv 19
756 __indirect_glColor4ub(GLubyte red
, GLubyte green
, GLubyte blue
, GLubyte alpha
)
758 __GLXcontext
* const gc
= __glXGetCurrentContext();
759 const GLuint cmdlen
= 8;
760 emit_header(gc
->pc
, X_GLrop_Color4ubv
, cmdlen
);
761 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&red
), 1);
762 (void) memcpy((void *)(gc
->pc
+ 5), (void *)(&green
), 1);
763 (void) memcpy((void *)(gc
->pc
+ 6), (void *)(&blue
), 1);
764 (void) memcpy((void *)(gc
->pc
+ 7), (void *)(&alpha
), 1);
766 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
769 #define X_GLrop_Color4ubv 19
771 __indirect_glColor4ubv(const GLubyte
* v
)
773 generic_4_byte( X_GLrop_Color4ubv
, v
);
776 #define X_GLrop_Color4uiv 20
778 __indirect_glColor4ui(GLuint red
, GLuint green
, GLuint blue
, GLuint alpha
)
780 __GLXcontext
* const gc
= __glXGetCurrentContext();
781 const GLuint cmdlen
= 20;
782 emit_header(gc
->pc
, X_GLrop_Color4uiv
, cmdlen
);
783 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&red
), 4);
784 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(&green
), 4);
785 (void) memcpy((void *)(gc
->pc
+ 12), (void *)(&blue
), 4);
786 (void) memcpy((void *)(gc
->pc
+ 16), (void *)(&alpha
), 4);
788 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
791 #define X_GLrop_Color4uiv 20
793 __indirect_glColor4uiv(const GLuint
* v
)
795 generic_16_byte( X_GLrop_Color4uiv
, v
);
798 #define X_GLrop_Color4usv 21
800 __indirect_glColor4us(GLushort red
, GLushort green
, GLushort blue
, GLushort alpha
)
802 __GLXcontext
* const gc
= __glXGetCurrentContext();
803 const GLuint cmdlen
= 12;
804 emit_header(gc
->pc
, X_GLrop_Color4usv
, cmdlen
);
805 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&red
), 2);
806 (void) memcpy((void *)(gc
->pc
+ 6), (void *)(&green
), 2);
807 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(&blue
), 2);
808 (void) memcpy((void *)(gc
->pc
+ 10), (void *)(&alpha
), 2);
810 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
813 #define X_GLrop_Color4usv 21
815 __indirect_glColor4usv(const GLushort
* v
)
817 generic_8_byte( X_GLrop_Color4usv
, v
);
820 #define X_GLrop_EdgeFlagv 22
822 __indirect_glEdgeFlag(GLboolean flag
)
824 __GLXcontext
* const gc
= __glXGetCurrentContext();
825 const GLuint cmdlen
= 8;
826 emit_header(gc
->pc
, X_GLrop_EdgeFlagv
, cmdlen
);
827 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&flag
), 1);
829 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
832 #define X_GLrop_EdgeFlagv 22
834 __indirect_glEdgeFlagv(const GLboolean
* flag
)
836 __GLXcontext
* const gc
= __glXGetCurrentContext();
837 const GLuint cmdlen
= 8;
838 emit_header(gc
->pc
, X_GLrop_EdgeFlagv
, cmdlen
);
839 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(flag
), 1);
841 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
844 #define X_GLrop_End 23
846 __indirect_glEnd(void)
848 __GLXcontext
* const gc
= __glXGetCurrentContext();
849 const GLuint cmdlen
= 4;
850 emit_header(gc
->pc
, X_GLrop_End
, cmdlen
);
852 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
855 #define X_GLrop_Indexdv 24
857 __indirect_glIndexd(GLdouble c
)
859 __GLXcontext
* const gc
= __glXGetCurrentContext();
860 const GLuint cmdlen
= 12;
861 emit_header(gc
->pc
, X_GLrop_Indexdv
, cmdlen
);
862 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&c
), 8);
864 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
867 #define X_GLrop_Indexdv 24
869 __indirect_glIndexdv(const GLdouble
* c
)
871 generic_8_byte( X_GLrop_Indexdv
, c
);
874 #define X_GLrop_Indexfv 25
876 __indirect_glIndexf(GLfloat c
)
878 __GLXcontext
* const gc
= __glXGetCurrentContext();
879 const GLuint cmdlen
= 8;
880 emit_header(gc
->pc
, X_GLrop_Indexfv
, cmdlen
);
881 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&c
), 4);
883 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
886 #define X_GLrop_Indexfv 25
888 __indirect_glIndexfv(const GLfloat
* c
)
890 generic_4_byte( X_GLrop_Indexfv
, c
);
893 #define X_GLrop_Indexiv 26
895 __indirect_glIndexi(GLint c
)
897 __GLXcontext
* const gc
= __glXGetCurrentContext();
898 const GLuint cmdlen
= 8;
899 emit_header(gc
->pc
, X_GLrop_Indexiv
, cmdlen
);
900 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&c
), 4);
902 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
905 #define X_GLrop_Indexiv 26
907 __indirect_glIndexiv(const GLint
* c
)
909 generic_4_byte( X_GLrop_Indexiv
, c
);
912 #define X_GLrop_Indexsv 27
914 __indirect_glIndexs(GLshort c
)
916 __GLXcontext
* const gc
= __glXGetCurrentContext();
917 const GLuint cmdlen
= 8;
918 emit_header(gc
->pc
, X_GLrop_Indexsv
, cmdlen
);
919 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&c
), 2);
921 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
924 #define X_GLrop_Indexsv 27
926 __indirect_glIndexsv(const GLshort
* c
)
928 __GLXcontext
* const gc
= __glXGetCurrentContext();
929 const GLuint cmdlen
= 8;
930 emit_header(gc
->pc
, X_GLrop_Indexsv
, cmdlen
);
931 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(c
), 2);
933 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
936 #define X_GLrop_Normal3bv 28
938 __indirect_glNormal3b(GLbyte nx
, GLbyte ny
, GLbyte nz
)
940 __GLXcontext
* const gc
= __glXGetCurrentContext();
941 const GLuint cmdlen
= 8;
942 emit_header(gc
->pc
, X_GLrop_Normal3bv
, cmdlen
);
943 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&nx
), 1);
944 (void) memcpy((void *)(gc
->pc
+ 5), (void *)(&ny
), 1);
945 (void) memcpy((void *)(gc
->pc
+ 6), (void *)(&nz
), 1);
947 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
950 #define X_GLrop_Normal3bv 28
952 __indirect_glNormal3bv(const GLbyte
* v
)
954 generic_3_byte( X_GLrop_Normal3bv
, v
);
957 #define X_GLrop_Normal3dv 29
959 __indirect_glNormal3d(GLdouble nx
, GLdouble ny
, GLdouble nz
)
961 __GLXcontext
* const gc
= __glXGetCurrentContext();
962 const GLuint cmdlen
= 28;
963 emit_header(gc
->pc
, X_GLrop_Normal3dv
, cmdlen
);
964 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&nx
), 8);
965 (void) memcpy((void *)(gc
->pc
+ 12), (void *)(&ny
), 8);
966 (void) memcpy((void *)(gc
->pc
+ 20), (void *)(&nz
), 8);
968 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
971 #define X_GLrop_Normal3dv 29
973 __indirect_glNormal3dv(const GLdouble
* v
)
975 generic_24_byte( X_GLrop_Normal3dv
, v
);
978 #define X_GLrop_Normal3fv 30
980 __indirect_glNormal3f(GLfloat nx
, GLfloat ny
, GLfloat nz
)
982 __GLXcontext
* const gc
= __glXGetCurrentContext();
983 const GLuint cmdlen
= 16;
984 emit_header(gc
->pc
, X_GLrop_Normal3fv
, cmdlen
);
985 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&nx
), 4);
986 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(&ny
), 4);
987 (void) memcpy((void *)(gc
->pc
+ 12), (void *)(&nz
), 4);
989 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
992 #define X_GLrop_Normal3fv 30
994 __indirect_glNormal3fv(const GLfloat
* v
)
996 generic_12_byte( X_GLrop_Normal3fv
, v
);
999 #define X_GLrop_Normal3iv 31
1001 __indirect_glNormal3i(GLint nx
, GLint ny
, GLint nz
)
1003 __GLXcontext
* const gc
= __glXGetCurrentContext();
1004 const GLuint cmdlen
= 16;
1005 emit_header(gc
->pc
, X_GLrop_Normal3iv
, cmdlen
);
1006 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&nx
), 4);
1007 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(&ny
), 4);
1008 (void) memcpy((void *)(gc
->pc
+ 12), (void *)(&nz
), 4);
1010 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
1013 #define X_GLrop_Normal3iv 31
1015 __indirect_glNormal3iv(const GLint
* v
)
1017 generic_12_byte( X_GLrop_Normal3iv
, v
);
1020 #define X_GLrop_Normal3sv 32
1022 __indirect_glNormal3s(GLshort nx
, GLshort ny
, GLshort nz
)
1024 __GLXcontext
* const gc
= __glXGetCurrentContext();
1025 const GLuint cmdlen
= 12;
1026 emit_header(gc
->pc
, X_GLrop_Normal3sv
, cmdlen
);
1027 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&nx
), 2);
1028 (void) memcpy((void *)(gc
->pc
+ 6), (void *)(&ny
), 2);
1029 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(&nz
), 2);
1031 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
1034 #define X_GLrop_Normal3sv 32
1036 __indirect_glNormal3sv(const GLshort
* v
)
1038 generic_6_byte( X_GLrop_Normal3sv
, v
);
1041 #define X_GLrop_RasterPos2dv 33
1043 __indirect_glRasterPos2d(GLdouble x
, GLdouble y
)
1045 __GLXcontext
* const gc
= __glXGetCurrentContext();
1046 const GLuint cmdlen
= 20;
1047 emit_header(gc
->pc
, X_GLrop_RasterPos2dv
, cmdlen
);
1048 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&x
), 8);
1049 (void) memcpy((void *)(gc
->pc
+ 12), (void *)(&y
), 8);
1051 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
1054 #define X_GLrop_RasterPos2dv 33
1056 __indirect_glRasterPos2dv(const GLdouble
* v
)
1058 generic_16_byte( X_GLrop_RasterPos2dv
, v
);
1061 #define X_GLrop_RasterPos2fv 34
1063 __indirect_glRasterPos2f(GLfloat x
, GLfloat y
)
1065 __GLXcontext
* const gc
= __glXGetCurrentContext();
1066 const GLuint cmdlen
= 12;
1067 emit_header(gc
->pc
, X_GLrop_RasterPos2fv
, cmdlen
);
1068 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&x
), 4);
1069 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(&y
), 4);
1071 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
1074 #define X_GLrop_RasterPos2fv 34
1076 __indirect_glRasterPos2fv(const GLfloat
* v
)
1078 generic_8_byte( X_GLrop_RasterPos2fv
, v
);
1081 #define X_GLrop_RasterPos2iv 35
1083 __indirect_glRasterPos2i(GLint x
, GLint y
)
1085 __GLXcontext
* const gc
= __glXGetCurrentContext();
1086 const GLuint cmdlen
= 12;
1087 emit_header(gc
->pc
, X_GLrop_RasterPos2iv
, cmdlen
);
1088 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&x
), 4);
1089 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(&y
), 4);
1091 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
1094 #define X_GLrop_RasterPos2iv 35
1096 __indirect_glRasterPos2iv(const GLint
* v
)
1098 generic_8_byte( X_GLrop_RasterPos2iv
, v
);
1101 #define X_GLrop_RasterPos2sv 36
1103 __indirect_glRasterPos2s(GLshort x
, GLshort y
)
1105 __GLXcontext
* const gc
= __glXGetCurrentContext();
1106 const GLuint cmdlen
= 8;
1107 emit_header(gc
->pc
, X_GLrop_RasterPos2sv
, cmdlen
);
1108 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&x
), 2);
1109 (void) memcpy((void *)(gc
->pc
+ 6), (void *)(&y
), 2);
1111 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
1114 #define X_GLrop_RasterPos2sv 36
1116 __indirect_glRasterPos2sv(const GLshort
* v
)
1118 generic_4_byte( X_GLrop_RasterPos2sv
, v
);
1121 #define X_GLrop_RasterPos3dv 37
1123 __indirect_glRasterPos3d(GLdouble x
, GLdouble y
, GLdouble z
)
1125 __GLXcontext
* const gc
= __glXGetCurrentContext();
1126 const GLuint cmdlen
= 28;
1127 emit_header(gc
->pc
, X_GLrop_RasterPos3dv
, cmdlen
);
1128 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&x
), 8);
1129 (void) memcpy((void *)(gc
->pc
+ 12), (void *)(&y
), 8);
1130 (void) memcpy((void *)(gc
->pc
+ 20), (void *)(&z
), 8);
1132 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
1135 #define X_GLrop_RasterPos3dv 37
1137 __indirect_glRasterPos3dv(const GLdouble
* v
)
1139 generic_24_byte( X_GLrop_RasterPos3dv
, v
);
1142 #define X_GLrop_RasterPos3fv 38
1144 __indirect_glRasterPos3f(GLfloat x
, GLfloat y
, GLfloat z
)
1146 __GLXcontext
* const gc
= __glXGetCurrentContext();
1147 const GLuint cmdlen
= 16;
1148 emit_header(gc
->pc
, X_GLrop_RasterPos3fv
, cmdlen
);
1149 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&x
), 4);
1150 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(&y
), 4);
1151 (void) memcpy((void *)(gc
->pc
+ 12), (void *)(&z
), 4);
1153 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
1156 #define X_GLrop_RasterPos3fv 38
1158 __indirect_glRasterPos3fv(const GLfloat
* v
)
1160 generic_12_byte( X_GLrop_RasterPos3fv
, v
);
1163 #define X_GLrop_RasterPos3iv 39
1165 __indirect_glRasterPos3i(GLint x
, GLint y
, GLint z
)
1167 __GLXcontext
* const gc
= __glXGetCurrentContext();
1168 const GLuint cmdlen
= 16;
1169 emit_header(gc
->pc
, X_GLrop_RasterPos3iv
, cmdlen
);
1170 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&x
), 4);
1171 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(&y
), 4);
1172 (void) memcpy((void *)(gc
->pc
+ 12), (void *)(&z
), 4);
1174 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
1177 #define X_GLrop_RasterPos3iv 39
1179 __indirect_glRasterPos3iv(const GLint
* v
)
1181 generic_12_byte( X_GLrop_RasterPos3iv
, v
);
1184 #define X_GLrop_RasterPos3sv 40
1186 __indirect_glRasterPos3s(GLshort x
, GLshort y
, GLshort z
)
1188 __GLXcontext
* const gc
= __glXGetCurrentContext();
1189 const GLuint cmdlen
= 12;
1190 emit_header(gc
->pc
, X_GLrop_RasterPos3sv
, cmdlen
);
1191 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&x
), 2);
1192 (void) memcpy((void *)(gc
->pc
+ 6), (void *)(&y
), 2);
1193 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(&z
), 2);
1195 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
1198 #define X_GLrop_RasterPos3sv 40
1200 __indirect_glRasterPos3sv(const GLshort
* v
)
1202 generic_6_byte( X_GLrop_RasterPos3sv
, v
);
1205 #define X_GLrop_RasterPos4dv 41
1207 __indirect_glRasterPos4d(GLdouble x
, GLdouble y
, GLdouble z
, GLdouble w
)
1209 __GLXcontext
* const gc
= __glXGetCurrentContext();
1210 const GLuint cmdlen
= 36;
1211 emit_header(gc
->pc
, X_GLrop_RasterPos4dv
, cmdlen
);
1212 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&x
), 8);
1213 (void) memcpy((void *)(gc
->pc
+ 12), (void *)(&y
), 8);
1214 (void) memcpy((void *)(gc
->pc
+ 20), (void *)(&z
), 8);
1215 (void) memcpy((void *)(gc
->pc
+ 28), (void *)(&w
), 8);
1217 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
1220 #define X_GLrop_RasterPos4dv 41
1222 __indirect_glRasterPos4dv(const GLdouble
* v
)
1224 generic_32_byte( X_GLrop_RasterPos4dv
, v
);
1227 #define X_GLrop_RasterPos4fv 42
1229 __indirect_glRasterPos4f(GLfloat x
, GLfloat y
, GLfloat z
, GLfloat w
)
1231 __GLXcontext
* const gc
= __glXGetCurrentContext();
1232 const GLuint cmdlen
= 20;
1233 emit_header(gc
->pc
, X_GLrop_RasterPos4fv
, cmdlen
);
1234 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&x
), 4);
1235 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(&y
), 4);
1236 (void) memcpy((void *)(gc
->pc
+ 12), (void *)(&z
), 4);
1237 (void) memcpy((void *)(gc
->pc
+ 16), (void *)(&w
), 4);
1239 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
1242 #define X_GLrop_RasterPos4fv 42
1244 __indirect_glRasterPos4fv(const GLfloat
* v
)
1246 generic_16_byte( X_GLrop_RasterPos4fv
, v
);
1249 #define X_GLrop_RasterPos4iv 43
1251 __indirect_glRasterPos4i(GLint x
, GLint y
, GLint z
, GLint w
)
1253 __GLXcontext
* const gc
= __glXGetCurrentContext();
1254 const GLuint cmdlen
= 20;
1255 emit_header(gc
->pc
, X_GLrop_RasterPos4iv
, cmdlen
);
1256 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&x
), 4);
1257 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(&y
), 4);
1258 (void) memcpy((void *)(gc
->pc
+ 12), (void *)(&z
), 4);
1259 (void) memcpy((void *)(gc
->pc
+ 16), (void *)(&w
), 4);
1261 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
1264 #define X_GLrop_RasterPos4iv 43
1266 __indirect_glRasterPos4iv(const GLint
* v
)
1268 generic_16_byte( X_GLrop_RasterPos4iv
, v
);
1271 #define X_GLrop_RasterPos4sv 44
1273 __indirect_glRasterPos4s(GLshort x
, GLshort y
, GLshort z
, GLshort w
)
1275 __GLXcontext
* const gc
= __glXGetCurrentContext();
1276 const GLuint cmdlen
= 12;
1277 emit_header(gc
->pc
, X_GLrop_RasterPos4sv
, cmdlen
);
1278 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&x
), 2);
1279 (void) memcpy((void *)(gc
->pc
+ 6), (void *)(&y
), 2);
1280 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(&z
), 2);
1281 (void) memcpy((void *)(gc
->pc
+ 10), (void *)(&w
), 2);
1283 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
1286 #define X_GLrop_RasterPos4sv 44
1288 __indirect_glRasterPos4sv(const GLshort
* v
)
1290 generic_8_byte( X_GLrop_RasterPos4sv
, v
);
1293 #define X_GLrop_Rectdv 45
1295 __indirect_glRectd(GLdouble x1
, GLdouble y1
, GLdouble x2
, GLdouble y2
)
1297 __GLXcontext
* const gc
= __glXGetCurrentContext();
1298 const GLuint cmdlen
= 36;
1299 emit_header(gc
->pc
, X_GLrop_Rectdv
, cmdlen
);
1300 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&x1
), 8);
1301 (void) memcpy((void *)(gc
->pc
+ 12), (void *)(&y1
), 8);
1302 (void) memcpy((void *)(gc
->pc
+ 20), (void *)(&x2
), 8);
1303 (void) memcpy((void *)(gc
->pc
+ 28), (void *)(&y2
), 8);
1305 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
1308 #define X_GLrop_Rectdv 45
1310 __indirect_glRectdv(const GLdouble
* v1
, const GLdouble
* v2
)
1312 __GLXcontext
* const gc
= __glXGetCurrentContext();
1313 const GLuint cmdlen
= 36;
1314 emit_header(gc
->pc
, X_GLrop_Rectdv
, cmdlen
);
1315 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(v1
), 16);
1316 (void) memcpy((void *)(gc
->pc
+ 20), (void *)(v2
), 16);
1318 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
1321 #define X_GLrop_Rectfv 46
1323 __indirect_glRectf(GLfloat x1
, GLfloat y1
, GLfloat x2
, GLfloat y2
)
1325 __GLXcontext
* const gc
= __glXGetCurrentContext();
1326 const GLuint cmdlen
= 20;
1327 emit_header(gc
->pc
, X_GLrop_Rectfv
, cmdlen
);
1328 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&x1
), 4);
1329 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(&y1
), 4);
1330 (void) memcpy((void *)(gc
->pc
+ 12), (void *)(&x2
), 4);
1331 (void) memcpy((void *)(gc
->pc
+ 16), (void *)(&y2
), 4);
1333 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
1336 #define X_GLrop_Rectfv 46
1338 __indirect_glRectfv(const GLfloat
* v1
, const GLfloat
* v2
)
1340 __GLXcontext
* const gc
= __glXGetCurrentContext();
1341 const GLuint cmdlen
= 20;
1342 emit_header(gc
->pc
, X_GLrop_Rectfv
, cmdlen
);
1343 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(v1
), 8);
1344 (void) memcpy((void *)(gc
->pc
+ 12), (void *)(v2
), 8);
1346 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
1349 #define X_GLrop_Rectiv 47
1351 __indirect_glRecti(GLint x1
, GLint y1
, GLint x2
, GLint y2
)
1353 __GLXcontext
* const gc
= __glXGetCurrentContext();
1354 const GLuint cmdlen
= 20;
1355 emit_header(gc
->pc
, X_GLrop_Rectiv
, cmdlen
);
1356 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&x1
), 4);
1357 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(&y1
), 4);
1358 (void) memcpy((void *)(gc
->pc
+ 12), (void *)(&x2
), 4);
1359 (void) memcpy((void *)(gc
->pc
+ 16), (void *)(&y2
), 4);
1361 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
1364 #define X_GLrop_Rectiv 47
1366 __indirect_glRectiv(const GLint
* v1
, const GLint
* v2
)
1368 __GLXcontext
* const gc
= __glXGetCurrentContext();
1369 const GLuint cmdlen
= 20;
1370 emit_header(gc
->pc
, X_GLrop_Rectiv
, cmdlen
);
1371 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(v1
), 8);
1372 (void) memcpy((void *)(gc
->pc
+ 12), (void *)(v2
), 8);
1374 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
1377 #define X_GLrop_Rectsv 48
1379 __indirect_glRects(GLshort x1
, GLshort y1
, GLshort x2
, GLshort y2
)
1381 __GLXcontext
* const gc
= __glXGetCurrentContext();
1382 const GLuint cmdlen
= 12;
1383 emit_header(gc
->pc
, X_GLrop_Rectsv
, cmdlen
);
1384 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&x1
), 2);
1385 (void) memcpy((void *)(gc
->pc
+ 6), (void *)(&y1
), 2);
1386 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(&x2
), 2);
1387 (void) memcpy((void *)(gc
->pc
+ 10), (void *)(&y2
), 2);
1389 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
1392 #define X_GLrop_Rectsv 48
1394 __indirect_glRectsv(const GLshort
* v1
, const GLshort
* v2
)
1396 __GLXcontext
* const gc
= __glXGetCurrentContext();
1397 const GLuint cmdlen
= 12;
1398 emit_header(gc
->pc
, X_GLrop_Rectsv
, cmdlen
);
1399 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(v1
), 4);
1400 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(v2
), 4);
1402 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
1405 #define X_GLrop_TexCoord1dv 49
1407 __indirect_glTexCoord1d(GLdouble s
)
1409 __GLXcontext
* const gc
= __glXGetCurrentContext();
1410 const GLuint cmdlen
= 12;
1411 emit_header(gc
->pc
, X_GLrop_TexCoord1dv
, cmdlen
);
1412 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&s
), 8);
1414 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
1417 #define X_GLrop_TexCoord1dv 49
1419 __indirect_glTexCoord1dv(const GLdouble
* v
)
1421 generic_8_byte( X_GLrop_TexCoord1dv
, v
);
1424 #define X_GLrop_TexCoord1fv 50
1426 __indirect_glTexCoord1f(GLfloat s
)
1428 __GLXcontext
* const gc
= __glXGetCurrentContext();
1429 const GLuint cmdlen
= 8;
1430 emit_header(gc
->pc
, X_GLrop_TexCoord1fv
, cmdlen
);
1431 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&s
), 4);
1433 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
1436 #define X_GLrop_TexCoord1fv 50
1438 __indirect_glTexCoord1fv(const GLfloat
* v
)
1440 generic_4_byte( X_GLrop_TexCoord1fv
, v
);
1443 #define X_GLrop_TexCoord1iv 51
1445 __indirect_glTexCoord1i(GLint s
)
1447 __GLXcontext
* const gc
= __glXGetCurrentContext();
1448 const GLuint cmdlen
= 8;
1449 emit_header(gc
->pc
, X_GLrop_TexCoord1iv
, cmdlen
);
1450 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&s
), 4);
1452 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
1455 #define X_GLrop_TexCoord1iv 51
1457 __indirect_glTexCoord1iv(const GLint
* v
)
1459 generic_4_byte( X_GLrop_TexCoord1iv
, v
);
1462 #define X_GLrop_TexCoord1sv 52
1464 __indirect_glTexCoord1s(GLshort s
)
1466 __GLXcontext
* const gc
= __glXGetCurrentContext();
1467 const GLuint cmdlen
= 8;
1468 emit_header(gc
->pc
, X_GLrop_TexCoord1sv
, cmdlen
);
1469 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&s
), 2);
1471 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
1474 #define X_GLrop_TexCoord1sv 52
1476 __indirect_glTexCoord1sv(const GLshort
* v
)
1478 __GLXcontext
* const gc
= __glXGetCurrentContext();
1479 const GLuint cmdlen
= 8;
1480 emit_header(gc
->pc
, X_GLrop_TexCoord1sv
, cmdlen
);
1481 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(v
), 2);
1483 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
1486 #define X_GLrop_TexCoord2dv 53
1488 __indirect_glTexCoord2d(GLdouble s
, GLdouble t
)
1490 __GLXcontext
* const gc
= __glXGetCurrentContext();
1491 const GLuint cmdlen
= 20;
1492 emit_header(gc
->pc
, X_GLrop_TexCoord2dv
, cmdlen
);
1493 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&s
), 8);
1494 (void) memcpy((void *)(gc
->pc
+ 12), (void *)(&t
), 8);
1496 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
1499 #define X_GLrop_TexCoord2dv 53
1501 __indirect_glTexCoord2dv(const GLdouble
* v
)
1503 generic_16_byte( X_GLrop_TexCoord2dv
, v
);
1506 #define X_GLrop_TexCoord2fv 54
1508 __indirect_glTexCoord2f(GLfloat s
, GLfloat t
)
1510 __GLXcontext
* const gc
= __glXGetCurrentContext();
1511 const GLuint cmdlen
= 12;
1512 emit_header(gc
->pc
, X_GLrop_TexCoord2fv
, cmdlen
);
1513 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&s
), 4);
1514 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(&t
), 4);
1516 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
1519 #define X_GLrop_TexCoord2fv 54
1521 __indirect_glTexCoord2fv(const GLfloat
* v
)
1523 generic_8_byte( X_GLrop_TexCoord2fv
, v
);
1526 #define X_GLrop_TexCoord2iv 55
1528 __indirect_glTexCoord2i(GLint s
, GLint t
)
1530 __GLXcontext
* const gc
= __glXGetCurrentContext();
1531 const GLuint cmdlen
= 12;
1532 emit_header(gc
->pc
, X_GLrop_TexCoord2iv
, cmdlen
);
1533 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&s
), 4);
1534 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(&t
), 4);
1536 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
1539 #define X_GLrop_TexCoord2iv 55
1541 __indirect_glTexCoord2iv(const GLint
* v
)
1543 generic_8_byte( X_GLrop_TexCoord2iv
, v
);
1546 #define X_GLrop_TexCoord2sv 56
1548 __indirect_glTexCoord2s(GLshort s
, GLshort t
)
1550 __GLXcontext
* const gc
= __glXGetCurrentContext();
1551 const GLuint cmdlen
= 8;
1552 emit_header(gc
->pc
, X_GLrop_TexCoord2sv
, cmdlen
);
1553 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&s
), 2);
1554 (void) memcpy((void *)(gc
->pc
+ 6), (void *)(&t
), 2);
1556 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
1559 #define X_GLrop_TexCoord2sv 56
1561 __indirect_glTexCoord2sv(const GLshort
* v
)
1563 generic_4_byte( X_GLrop_TexCoord2sv
, v
);
1566 #define X_GLrop_TexCoord3dv 57
1568 __indirect_glTexCoord3d(GLdouble s
, GLdouble t
, GLdouble r
)
1570 __GLXcontext
* const gc
= __glXGetCurrentContext();
1571 const GLuint cmdlen
= 28;
1572 emit_header(gc
->pc
, X_GLrop_TexCoord3dv
, cmdlen
);
1573 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&s
), 8);
1574 (void) memcpy((void *)(gc
->pc
+ 12), (void *)(&t
), 8);
1575 (void) memcpy((void *)(gc
->pc
+ 20), (void *)(&r
), 8);
1577 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
1580 #define X_GLrop_TexCoord3dv 57
1582 __indirect_glTexCoord3dv(const GLdouble
* v
)
1584 generic_24_byte( X_GLrop_TexCoord3dv
, v
);
1587 #define X_GLrop_TexCoord3fv 58
1589 __indirect_glTexCoord3f(GLfloat s
, GLfloat t
, GLfloat r
)
1591 __GLXcontext
* const gc
= __glXGetCurrentContext();
1592 const GLuint cmdlen
= 16;
1593 emit_header(gc
->pc
, X_GLrop_TexCoord3fv
, cmdlen
);
1594 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&s
), 4);
1595 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(&t
), 4);
1596 (void) memcpy((void *)(gc
->pc
+ 12), (void *)(&r
), 4);
1598 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
1601 #define X_GLrop_TexCoord3fv 58
1603 __indirect_glTexCoord3fv(const GLfloat
* v
)
1605 generic_12_byte( X_GLrop_TexCoord3fv
, v
);
1608 #define X_GLrop_TexCoord3iv 59
1610 __indirect_glTexCoord3i(GLint s
, GLint t
, GLint r
)
1612 __GLXcontext
* const gc
= __glXGetCurrentContext();
1613 const GLuint cmdlen
= 16;
1614 emit_header(gc
->pc
, X_GLrop_TexCoord3iv
, cmdlen
);
1615 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&s
), 4);
1616 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(&t
), 4);
1617 (void) memcpy((void *)(gc
->pc
+ 12), (void *)(&r
), 4);
1619 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
1622 #define X_GLrop_TexCoord3iv 59
1624 __indirect_glTexCoord3iv(const GLint
* v
)
1626 generic_12_byte( X_GLrop_TexCoord3iv
, v
);
1629 #define X_GLrop_TexCoord3sv 60
1631 __indirect_glTexCoord3s(GLshort s
, GLshort t
, GLshort r
)
1633 __GLXcontext
* const gc
= __glXGetCurrentContext();
1634 const GLuint cmdlen
= 12;
1635 emit_header(gc
->pc
, X_GLrop_TexCoord3sv
, cmdlen
);
1636 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&s
), 2);
1637 (void) memcpy((void *)(gc
->pc
+ 6), (void *)(&t
), 2);
1638 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(&r
), 2);
1640 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
1643 #define X_GLrop_TexCoord3sv 60
1645 __indirect_glTexCoord3sv(const GLshort
* v
)
1647 generic_6_byte( X_GLrop_TexCoord3sv
, v
);
1650 #define X_GLrop_TexCoord4dv 61
1652 __indirect_glTexCoord4d(GLdouble s
, GLdouble t
, GLdouble r
, GLdouble q
)
1654 __GLXcontext
* const gc
= __glXGetCurrentContext();
1655 const GLuint cmdlen
= 36;
1656 emit_header(gc
->pc
, X_GLrop_TexCoord4dv
, cmdlen
);
1657 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&s
), 8);
1658 (void) memcpy((void *)(gc
->pc
+ 12), (void *)(&t
), 8);
1659 (void) memcpy((void *)(gc
->pc
+ 20), (void *)(&r
), 8);
1660 (void) memcpy((void *)(gc
->pc
+ 28), (void *)(&q
), 8);
1662 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
1665 #define X_GLrop_TexCoord4dv 61
1667 __indirect_glTexCoord4dv(const GLdouble
* v
)
1669 generic_32_byte( X_GLrop_TexCoord4dv
, v
);
1672 #define X_GLrop_TexCoord4fv 62
1674 __indirect_glTexCoord4f(GLfloat s
, GLfloat t
, GLfloat r
, GLfloat q
)
1676 __GLXcontext
* const gc
= __glXGetCurrentContext();
1677 const GLuint cmdlen
= 20;
1678 emit_header(gc
->pc
, X_GLrop_TexCoord4fv
, cmdlen
);
1679 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&s
), 4);
1680 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(&t
), 4);
1681 (void) memcpy((void *)(gc
->pc
+ 12), (void *)(&r
), 4);
1682 (void) memcpy((void *)(gc
->pc
+ 16), (void *)(&q
), 4);
1684 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
1687 #define X_GLrop_TexCoord4fv 62
1689 __indirect_glTexCoord4fv(const GLfloat
* v
)
1691 generic_16_byte( X_GLrop_TexCoord4fv
, v
);
1694 #define X_GLrop_TexCoord4iv 63
1696 __indirect_glTexCoord4i(GLint s
, GLint t
, GLint r
, GLint q
)
1698 __GLXcontext
* const gc
= __glXGetCurrentContext();
1699 const GLuint cmdlen
= 20;
1700 emit_header(gc
->pc
, X_GLrop_TexCoord4iv
, cmdlen
);
1701 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&s
), 4);
1702 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(&t
), 4);
1703 (void) memcpy((void *)(gc
->pc
+ 12), (void *)(&r
), 4);
1704 (void) memcpy((void *)(gc
->pc
+ 16), (void *)(&q
), 4);
1706 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
1709 #define X_GLrop_TexCoord4iv 63
1711 __indirect_glTexCoord4iv(const GLint
* v
)
1713 generic_16_byte( X_GLrop_TexCoord4iv
, v
);
1716 #define X_GLrop_TexCoord4sv 64
1718 __indirect_glTexCoord4s(GLshort s
, GLshort t
, GLshort r
, GLshort q
)
1720 __GLXcontext
* const gc
= __glXGetCurrentContext();
1721 const GLuint cmdlen
= 12;
1722 emit_header(gc
->pc
, X_GLrop_TexCoord4sv
, cmdlen
);
1723 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&s
), 2);
1724 (void) memcpy((void *)(gc
->pc
+ 6), (void *)(&t
), 2);
1725 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(&r
), 2);
1726 (void) memcpy((void *)(gc
->pc
+ 10), (void *)(&q
), 2);
1728 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
1731 #define X_GLrop_TexCoord4sv 64
1733 __indirect_glTexCoord4sv(const GLshort
* v
)
1735 generic_8_byte( X_GLrop_TexCoord4sv
, v
);
1738 #define X_GLrop_Vertex2dv 65
1740 __indirect_glVertex2d(GLdouble x
, GLdouble y
)
1742 __GLXcontext
* const gc
= __glXGetCurrentContext();
1743 const GLuint cmdlen
= 20;
1744 emit_header(gc
->pc
, X_GLrop_Vertex2dv
, cmdlen
);
1745 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&x
), 8);
1746 (void) memcpy((void *)(gc
->pc
+ 12), (void *)(&y
), 8);
1748 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
1751 #define X_GLrop_Vertex2dv 65
1753 __indirect_glVertex2dv(const GLdouble
* v
)
1755 generic_16_byte( X_GLrop_Vertex2dv
, v
);
1758 #define X_GLrop_Vertex2fv 66
1760 __indirect_glVertex2f(GLfloat x
, GLfloat y
)
1762 __GLXcontext
* const gc
= __glXGetCurrentContext();
1763 const GLuint cmdlen
= 12;
1764 emit_header(gc
->pc
, X_GLrop_Vertex2fv
, cmdlen
);
1765 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&x
), 4);
1766 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(&y
), 4);
1768 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
1771 #define X_GLrop_Vertex2fv 66
1773 __indirect_glVertex2fv(const GLfloat
* v
)
1775 generic_8_byte( X_GLrop_Vertex2fv
, v
);
1778 #define X_GLrop_Vertex2iv 67
1780 __indirect_glVertex2i(GLint x
, GLint y
)
1782 __GLXcontext
* const gc
= __glXGetCurrentContext();
1783 const GLuint cmdlen
= 12;
1784 emit_header(gc
->pc
, X_GLrop_Vertex2iv
, cmdlen
);
1785 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&x
), 4);
1786 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(&y
), 4);
1788 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
1791 #define X_GLrop_Vertex2iv 67
1793 __indirect_glVertex2iv(const GLint
* v
)
1795 generic_8_byte( X_GLrop_Vertex2iv
, v
);
1798 #define X_GLrop_Vertex2sv 68
1800 __indirect_glVertex2s(GLshort x
, GLshort y
)
1802 __GLXcontext
* const gc
= __glXGetCurrentContext();
1803 const GLuint cmdlen
= 8;
1804 emit_header(gc
->pc
, X_GLrop_Vertex2sv
, cmdlen
);
1805 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&x
), 2);
1806 (void) memcpy((void *)(gc
->pc
+ 6), (void *)(&y
), 2);
1808 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
1811 #define X_GLrop_Vertex2sv 68
1813 __indirect_glVertex2sv(const GLshort
* v
)
1815 generic_4_byte( X_GLrop_Vertex2sv
, v
);
1818 #define X_GLrop_Vertex3dv 69
1820 __indirect_glVertex3d(GLdouble x
, GLdouble y
, GLdouble z
)
1822 __GLXcontext
* const gc
= __glXGetCurrentContext();
1823 const GLuint cmdlen
= 28;
1824 emit_header(gc
->pc
, X_GLrop_Vertex3dv
, cmdlen
);
1825 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&x
), 8);
1826 (void) memcpy((void *)(gc
->pc
+ 12), (void *)(&y
), 8);
1827 (void) memcpy((void *)(gc
->pc
+ 20), (void *)(&z
), 8);
1829 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
1832 #define X_GLrop_Vertex3dv 69
1834 __indirect_glVertex3dv(const GLdouble
* v
)
1836 generic_24_byte( X_GLrop_Vertex3dv
, v
);
1839 #define X_GLrop_Vertex3fv 70
1841 __indirect_glVertex3f(GLfloat x
, GLfloat y
, GLfloat z
)
1843 __GLXcontext
* const gc
= __glXGetCurrentContext();
1844 const GLuint cmdlen
= 16;
1845 emit_header(gc
->pc
, X_GLrop_Vertex3fv
, cmdlen
);
1846 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&x
), 4);
1847 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(&y
), 4);
1848 (void) memcpy((void *)(gc
->pc
+ 12), (void *)(&z
), 4);
1850 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
1853 #define X_GLrop_Vertex3fv 70
1855 __indirect_glVertex3fv(const GLfloat
* v
)
1857 generic_12_byte( X_GLrop_Vertex3fv
, v
);
1860 #define X_GLrop_Vertex3iv 71
1862 __indirect_glVertex3i(GLint x
, GLint y
, GLint z
)
1864 __GLXcontext
* const gc
= __glXGetCurrentContext();
1865 const GLuint cmdlen
= 16;
1866 emit_header(gc
->pc
, X_GLrop_Vertex3iv
, cmdlen
);
1867 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&x
), 4);
1868 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(&y
), 4);
1869 (void) memcpy((void *)(gc
->pc
+ 12), (void *)(&z
), 4);
1871 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
1874 #define X_GLrop_Vertex3iv 71
1876 __indirect_glVertex3iv(const GLint
* v
)
1878 generic_12_byte( X_GLrop_Vertex3iv
, v
);
1881 #define X_GLrop_Vertex3sv 72
1883 __indirect_glVertex3s(GLshort x
, GLshort y
, GLshort z
)
1885 __GLXcontext
* const gc
= __glXGetCurrentContext();
1886 const GLuint cmdlen
= 12;
1887 emit_header(gc
->pc
, X_GLrop_Vertex3sv
, cmdlen
);
1888 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&x
), 2);
1889 (void) memcpy((void *)(gc
->pc
+ 6), (void *)(&y
), 2);
1890 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(&z
), 2);
1892 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
1895 #define X_GLrop_Vertex3sv 72
1897 __indirect_glVertex3sv(const GLshort
* v
)
1899 generic_6_byte( X_GLrop_Vertex3sv
, v
);
1902 #define X_GLrop_Vertex4dv 73
1904 __indirect_glVertex4d(GLdouble x
, GLdouble y
, GLdouble z
, GLdouble w
)
1906 __GLXcontext
* const gc
= __glXGetCurrentContext();
1907 const GLuint cmdlen
= 36;
1908 emit_header(gc
->pc
, X_GLrop_Vertex4dv
, cmdlen
);
1909 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&x
), 8);
1910 (void) memcpy((void *)(gc
->pc
+ 12), (void *)(&y
), 8);
1911 (void) memcpy((void *)(gc
->pc
+ 20), (void *)(&z
), 8);
1912 (void) memcpy((void *)(gc
->pc
+ 28), (void *)(&w
), 8);
1914 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
1917 #define X_GLrop_Vertex4dv 73
1919 __indirect_glVertex4dv(const GLdouble
* v
)
1921 generic_32_byte( X_GLrop_Vertex4dv
, v
);
1924 #define X_GLrop_Vertex4fv 74
1926 __indirect_glVertex4f(GLfloat x
, GLfloat y
, GLfloat z
, GLfloat w
)
1928 __GLXcontext
* const gc
= __glXGetCurrentContext();
1929 const GLuint cmdlen
= 20;
1930 emit_header(gc
->pc
, X_GLrop_Vertex4fv
, cmdlen
);
1931 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&x
), 4);
1932 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(&y
), 4);
1933 (void) memcpy((void *)(gc
->pc
+ 12), (void *)(&z
), 4);
1934 (void) memcpy((void *)(gc
->pc
+ 16), (void *)(&w
), 4);
1936 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
1939 #define X_GLrop_Vertex4fv 74
1941 __indirect_glVertex4fv(const GLfloat
* v
)
1943 generic_16_byte( X_GLrop_Vertex4fv
, v
);
1946 #define X_GLrop_Vertex4iv 75
1948 __indirect_glVertex4i(GLint x
, GLint y
, GLint z
, GLint w
)
1950 __GLXcontext
* const gc
= __glXGetCurrentContext();
1951 const GLuint cmdlen
= 20;
1952 emit_header(gc
->pc
, X_GLrop_Vertex4iv
, cmdlen
);
1953 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&x
), 4);
1954 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(&y
), 4);
1955 (void) memcpy((void *)(gc
->pc
+ 12), (void *)(&z
), 4);
1956 (void) memcpy((void *)(gc
->pc
+ 16), (void *)(&w
), 4);
1958 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
1961 #define X_GLrop_Vertex4iv 75
1963 __indirect_glVertex4iv(const GLint
* v
)
1965 generic_16_byte( X_GLrop_Vertex4iv
, v
);
1968 #define X_GLrop_Vertex4sv 76
1970 __indirect_glVertex4s(GLshort x
, GLshort y
, GLshort z
, GLshort w
)
1972 __GLXcontext
* const gc
= __glXGetCurrentContext();
1973 const GLuint cmdlen
= 12;
1974 emit_header(gc
->pc
, X_GLrop_Vertex4sv
, cmdlen
);
1975 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&x
), 2);
1976 (void) memcpy((void *)(gc
->pc
+ 6), (void *)(&y
), 2);
1977 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(&z
), 2);
1978 (void) memcpy((void *)(gc
->pc
+ 10), (void *)(&w
), 2);
1980 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
1983 #define X_GLrop_Vertex4sv 76
1985 __indirect_glVertex4sv(const GLshort
* v
)
1987 generic_8_byte( X_GLrop_Vertex4sv
, v
);
1990 #define X_GLrop_ClipPlane 77
1992 __indirect_glClipPlane(GLenum plane
, const GLdouble
* equation
)
1994 __GLXcontext
* const gc
= __glXGetCurrentContext();
1995 const GLuint cmdlen
= 40;
1996 emit_header(gc
->pc
, X_GLrop_ClipPlane
, cmdlen
);
1997 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(equation
), 32);
1998 (void) memcpy((void *)(gc
->pc
+ 36), (void *)(&plane
), 4);
2000 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
2003 #define X_GLrop_ColorMaterial 78
2005 __indirect_glColorMaterial(GLenum face
, GLenum mode
)
2007 __GLXcontext
* const gc
= __glXGetCurrentContext();
2008 const GLuint cmdlen
= 12;
2009 emit_header(gc
->pc
, X_GLrop_ColorMaterial
, cmdlen
);
2010 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&face
), 4);
2011 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(&mode
), 4);
2013 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
2016 #define X_GLrop_CullFace 79
2018 __indirect_glCullFace(GLenum mode
)
2020 __GLXcontext
* const gc
= __glXGetCurrentContext();
2021 const GLuint cmdlen
= 8;
2022 emit_header(gc
->pc
, X_GLrop_CullFace
, cmdlen
);
2023 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&mode
), 4);
2025 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
2028 #define X_GLrop_Fogf 80
2030 __indirect_glFogf(GLenum pname
, GLfloat param
)
2032 __GLXcontext
* const gc
= __glXGetCurrentContext();
2033 const GLuint cmdlen
= 12;
2034 emit_header(gc
->pc
, X_GLrop_Fogf
, cmdlen
);
2035 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&pname
), 4);
2036 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(¶m
), 4);
2038 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
2041 #define X_GLrop_Fogfv 81
2043 __indirect_glFogfv(GLenum pname
, const GLfloat
* params
)
2045 __GLXcontext
* const gc
= __glXGetCurrentContext();
2046 const GLuint compsize
= __glFogfv_size(pname
);
2047 const GLuint cmdlen
= 8 + __GLX_PAD((compsize
* 4));
2048 emit_header(gc
->pc
, X_GLrop_Fogfv
, cmdlen
);
2049 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&pname
), 4);
2050 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(params
), (compsize
* 4));
2052 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
2055 #define X_GLrop_Fogi 82
2057 __indirect_glFogi(GLenum pname
, GLint param
)
2059 __GLXcontext
* const gc
= __glXGetCurrentContext();
2060 const GLuint cmdlen
= 12;
2061 emit_header(gc
->pc
, X_GLrop_Fogi
, cmdlen
);
2062 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&pname
), 4);
2063 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(¶m
), 4);
2065 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
2068 #define X_GLrop_Fogiv 83
2070 __indirect_glFogiv(GLenum pname
, const GLint
* params
)
2072 __GLXcontext
* const gc
= __glXGetCurrentContext();
2073 const GLuint compsize
= __glFogiv_size(pname
);
2074 const GLuint cmdlen
= 8 + __GLX_PAD((compsize
* 4));
2075 emit_header(gc
->pc
, X_GLrop_Fogiv
, cmdlen
);
2076 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&pname
), 4);
2077 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(params
), (compsize
* 4));
2079 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
2082 #define X_GLrop_FrontFace 84
2084 __indirect_glFrontFace(GLenum mode
)
2086 __GLXcontext
* const gc
= __glXGetCurrentContext();
2087 const GLuint cmdlen
= 8;
2088 emit_header(gc
->pc
, X_GLrop_FrontFace
, cmdlen
);
2089 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&mode
), 4);
2091 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
2094 #define X_GLrop_Hint 85
2096 __indirect_glHint(GLenum target
, GLenum mode
)
2098 __GLXcontext
* const gc
= __glXGetCurrentContext();
2099 const GLuint cmdlen
= 12;
2100 emit_header(gc
->pc
, X_GLrop_Hint
, cmdlen
);
2101 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&target
), 4);
2102 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(&mode
), 4);
2104 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
2107 #define X_GLrop_Lightf 86
2109 __indirect_glLightf(GLenum light
, GLenum pname
, GLfloat param
)
2111 __GLXcontext
* const gc
= __glXGetCurrentContext();
2112 const GLuint cmdlen
= 16;
2113 emit_header(gc
->pc
, X_GLrop_Lightf
, cmdlen
);
2114 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&light
), 4);
2115 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(&pname
), 4);
2116 (void) memcpy((void *)(gc
->pc
+ 12), (void *)(¶m
), 4);
2118 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
2121 #define X_GLrop_Lightfv 87
2123 __indirect_glLightfv(GLenum light
, GLenum pname
, const GLfloat
* params
)
2125 __GLXcontext
* const gc
= __glXGetCurrentContext();
2126 const GLuint compsize
= __glLightfv_size(pname
);
2127 const GLuint cmdlen
= 12 + __GLX_PAD((compsize
* 4));
2128 emit_header(gc
->pc
, X_GLrop_Lightfv
, cmdlen
);
2129 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&light
), 4);
2130 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(&pname
), 4);
2131 (void) memcpy((void *)(gc
->pc
+ 12), (void *)(params
), (compsize
* 4));
2133 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
2136 #define X_GLrop_Lighti 88
2138 __indirect_glLighti(GLenum light
, GLenum pname
, GLint param
)
2140 __GLXcontext
* const gc
= __glXGetCurrentContext();
2141 const GLuint cmdlen
= 16;
2142 emit_header(gc
->pc
, X_GLrop_Lighti
, cmdlen
);
2143 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&light
), 4);
2144 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(&pname
), 4);
2145 (void) memcpy((void *)(gc
->pc
+ 12), (void *)(¶m
), 4);
2147 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
2150 #define X_GLrop_Lightiv 89
2152 __indirect_glLightiv(GLenum light
, GLenum pname
, const GLint
* params
)
2154 __GLXcontext
* const gc
= __glXGetCurrentContext();
2155 const GLuint compsize
= __glLightiv_size(pname
);
2156 const GLuint cmdlen
= 12 + __GLX_PAD((compsize
* 4));
2157 emit_header(gc
->pc
, X_GLrop_Lightiv
, cmdlen
);
2158 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&light
), 4);
2159 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(&pname
), 4);
2160 (void) memcpy((void *)(gc
->pc
+ 12), (void *)(params
), (compsize
* 4));
2162 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
2165 #define X_GLrop_LightModelf 90
2167 __indirect_glLightModelf(GLenum pname
, GLfloat param
)
2169 __GLXcontext
* const gc
= __glXGetCurrentContext();
2170 const GLuint cmdlen
= 12;
2171 emit_header(gc
->pc
, X_GLrop_LightModelf
, cmdlen
);
2172 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&pname
), 4);
2173 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(¶m
), 4);
2175 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
2178 #define X_GLrop_LightModelfv 91
2180 __indirect_glLightModelfv(GLenum pname
, const GLfloat
* params
)
2182 __GLXcontext
* const gc
= __glXGetCurrentContext();
2183 const GLuint compsize
= __glLightModelfv_size(pname
);
2184 const GLuint cmdlen
= 8 + __GLX_PAD((compsize
* 4));
2185 emit_header(gc
->pc
, X_GLrop_LightModelfv
, cmdlen
);
2186 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&pname
), 4);
2187 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(params
), (compsize
* 4));
2189 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
2192 #define X_GLrop_LightModeli 92
2194 __indirect_glLightModeli(GLenum pname
, GLint param
)
2196 __GLXcontext
* const gc
= __glXGetCurrentContext();
2197 const GLuint cmdlen
= 12;
2198 emit_header(gc
->pc
, X_GLrop_LightModeli
, cmdlen
);
2199 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&pname
), 4);
2200 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(¶m
), 4);
2202 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
2205 #define X_GLrop_LightModeliv 93
2207 __indirect_glLightModeliv(GLenum pname
, const GLint
* params
)
2209 __GLXcontext
* const gc
= __glXGetCurrentContext();
2210 const GLuint compsize
= __glLightModeliv_size(pname
);
2211 const GLuint cmdlen
= 8 + __GLX_PAD((compsize
* 4));
2212 emit_header(gc
->pc
, X_GLrop_LightModeliv
, cmdlen
);
2213 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&pname
), 4);
2214 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(params
), (compsize
* 4));
2216 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
2219 #define X_GLrop_LineStipple 94
2221 __indirect_glLineStipple(GLint factor
, GLushort pattern
)
2223 __GLXcontext
* const gc
= __glXGetCurrentContext();
2224 const GLuint cmdlen
= 12;
2225 emit_header(gc
->pc
, X_GLrop_LineStipple
, cmdlen
);
2226 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&factor
), 4);
2227 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(&pattern
), 2);
2229 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
2232 #define X_GLrop_LineWidth 95
2234 __indirect_glLineWidth(GLfloat width
)
2236 __GLXcontext
* const gc
= __glXGetCurrentContext();
2237 const GLuint cmdlen
= 8;
2238 emit_header(gc
->pc
, X_GLrop_LineWidth
, cmdlen
);
2239 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&width
), 4);
2241 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
2244 #define X_GLrop_Materialf 96
2246 __indirect_glMaterialf(GLenum face
, GLenum pname
, GLfloat param
)
2248 __GLXcontext
* const gc
= __glXGetCurrentContext();
2249 const GLuint cmdlen
= 16;
2250 emit_header(gc
->pc
, X_GLrop_Materialf
, cmdlen
);
2251 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&face
), 4);
2252 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(&pname
), 4);
2253 (void) memcpy((void *)(gc
->pc
+ 12), (void *)(¶m
), 4);
2255 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
2258 #define X_GLrop_Materialfv 97
2260 __indirect_glMaterialfv(GLenum face
, GLenum pname
, const GLfloat
* params
)
2262 __GLXcontext
* const gc
= __glXGetCurrentContext();
2263 const GLuint compsize
= __glMaterialfv_size(pname
);
2264 const GLuint cmdlen
= 12 + __GLX_PAD((compsize
* 4));
2265 emit_header(gc
->pc
, X_GLrop_Materialfv
, cmdlen
);
2266 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&face
), 4);
2267 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(&pname
), 4);
2268 (void) memcpy((void *)(gc
->pc
+ 12), (void *)(params
), (compsize
* 4));
2270 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
2273 #define X_GLrop_Materiali 98
2275 __indirect_glMateriali(GLenum face
, GLenum pname
, GLint param
)
2277 __GLXcontext
* const gc
= __glXGetCurrentContext();
2278 const GLuint cmdlen
= 16;
2279 emit_header(gc
->pc
, X_GLrop_Materiali
, cmdlen
);
2280 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&face
), 4);
2281 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(&pname
), 4);
2282 (void) memcpy((void *)(gc
->pc
+ 12), (void *)(¶m
), 4);
2284 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
2287 #define X_GLrop_Materialiv 99
2289 __indirect_glMaterialiv(GLenum face
, GLenum pname
, const GLint
* params
)
2291 __GLXcontext
* const gc
= __glXGetCurrentContext();
2292 const GLuint compsize
= __glMaterialiv_size(pname
);
2293 const GLuint cmdlen
= 12 + __GLX_PAD((compsize
* 4));
2294 emit_header(gc
->pc
, X_GLrop_Materialiv
, cmdlen
);
2295 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&face
), 4);
2296 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(&pname
), 4);
2297 (void) memcpy((void *)(gc
->pc
+ 12), (void *)(params
), (compsize
* 4));
2299 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
2302 #define X_GLrop_PointSize 100
2304 __indirect_glPointSize(GLfloat size
)
2306 __GLXcontext
* const gc
= __glXGetCurrentContext();
2307 const GLuint cmdlen
= 8;
2308 emit_header(gc
->pc
, X_GLrop_PointSize
, cmdlen
);
2309 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&size
), 4);
2311 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
2314 #define X_GLrop_PolygonMode 101
2316 __indirect_glPolygonMode(GLenum face
, GLenum mode
)
2318 __GLXcontext
* const gc
= __glXGetCurrentContext();
2319 const GLuint cmdlen
= 12;
2320 emit_header(gc
->pc
, X_GLrop_PolygonMode
, cmdlen
);
2321 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&face
), 4);
2322 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(&mode
), 4);
2324 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
2327 #define X_GLrop_PolygonStipple 102
2329 __indirect_glPolygonStipple(const GLubyte
* mask
)
2331 __GLXcontext
* const gc
= __glXGetCurrentContext();
2332 const GLuint compsize
= (mask
!= NULL
) ? __glImageSize(32, 32, 1, GL_COLOR_INDEX
, GL_BITMAP
, 0) : 0;
2333 const GLuint cmdlen
= 24 + __GLX_PAD(compsize
);
2334 emit_header(gc
->pc
, X_GLrop_PolygonStipple
, cmdlen
);
2336 (*gc
->fillImage
)(gc
, 2, 32, 32, 1, GL_COLOR_INDEX
, GL_BITMAP
, mask
, gc
->pc
+ 24, gc
->pc
+ 4);
2339 (void) memcpy( gc
->pc
+ 4, default_pixel_store_2D
, default_pixel_store_2D_size
);
2342 if (gc
->pc
> gc
->limit
) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
2345 #define X_GLrop_Scissor 103
2347 __indirect_glScissor(GLint x
, GLint y
, GLsizei width
, GLsizei height
)
2349 __GLXcontext
* const gc
= __glXGetCurrentContext();
2350 const GLuint cmdlen
= 20;
2351 emit_header(gc
->pc
, X_GLrop_Scissor
, cmdlen
);
2352 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&x
), 4);
2353 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(&y
), 4);
2354 (void) memcpy((void *)(gc
->pc
+ 12), (void *)(&width
), 4);
2355 (void) memcpy((void *)(gc
->pc
+ 16), (void *)(&height
), 4);
2357 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
2360 #define X_GLrop_ShadeModel 104
2362 __indirect_glShadeModel(GLenum mode
)
2364 __GLXcontext
* const gc
= __glXGetCurrentContext();
2365 const GLuint cmdlen
= 8;
2366 emit_header(gc
->pc
, X_GLrop_ShadeModel
, cmdlen
);
2367 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&mode
), 4);
2369 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
2372 #define X_GLrop_TexParameterf 105
2374 __indirect_glTexParameterf(GLenum target
, GLenum pname
, GLfloat param
)
2376 __GLXcontext
* const gc
= __glXGetCurrentContext();
2377 const GLuint cmdlen
= 16;
2378 emit_header(gc
->pc
, X_GLrop_TexParameterf
, cmdlen
);
2379 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&target
), 4);
2380 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(&pname
), 4);
2381 (void) memcpy((void *)(gc
->pc
+ 12), (void *)(¶m
), 4);
2383 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
2386 #define X_GLrop_TexParameterfv 106
2388 __indirect_glTexParameterfv(GLenum target
, GLenum pname
, const GLfloat
* params
)
2390 __GLXcontext
* const gc
= __glXGetCurrentContext();
2391 const GLuint compsize
= __glTexParameterfv_size(pname
);
2392 const GLuint cmdlen
= 12 + __GLX_PAD((compsize
* 4));
2393 emit_header(gc
->pc
, X_GLrop_TexParameterfv
, cmdlen
);
2394 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&target
), 4);
2395 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(&pname
), 4);
2396 (void) memcpy((void *)(gc
->pc
+ 12), (void *)(params
), (compsize
* 4));
2398 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
2401 #define X_GLrop_TexParameteri 107
2403 __indirect_glTexParameteri(GLenum target
, GLenum pname
, GLint param
)
2405 __GLXcontext
* const gc
= __glXGetCurrentContext();
2406 const GLuint cmdlen
= 16;
2407 emit_header(gc
->pc
, X_GLrop_TexParameteri
, cmdlen
);
2408 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&target
), 4);
2409 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(&pname
), 4);
2410 (void) memcpy((void *)(gc
->pc
+ 12), (void *)(¶m
), 4);
2412 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
2415 #define X_GLrop_TexParameteriv 108
2417 __indirect_glTexParameteriv(GLenum target
, GLenum pname
, const GLint
* params
)
2419 __GLXcontext
* const gc
= __glXGetCurrentContext();
2420 const GLuint compsize
= __glTexParameteriv_size(pname
);
2421 const GLuint cmdlen
= 12 + __GLX_PAD((compsize
* 4));
2422 emit_header(gc
->pc
, X_GLrop_TexParameteriv
, cmdlen
);
2423 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&target
), 4);
2424 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(&pname
), 4);
2425 (void) memcpy((void *)(gc
->pc
+ 12), (void *)(params
), (compsize
* 4));
2427 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
2431 __glx_TexImage_1D2D( unsigned opcode
, unsigned dim
, GLenum target
, GLint level
, GLint internalformat
, GLsizei width
, GLsizei height
, GLint border
, GLenum format
, GLenum type
, const GLvoid
* pixels
)
2433 __GLXcontext
* const gc
= __glXGetCurrentContext();
2434 const GLuint compsize
= __glImageSize(width
, height
, 1, format
, type
, target
);
2435 const GLuint cmdlen
= 56 + __GLX_PAD(compsize
);
2436 if (__builtin_expect(gc
->currentDpy
!= NULL
, 1)) {
2437 if (cmdlen
<= gc
->maxSmallRenderCommandSize
) {
2438 if ( (gc
->pc
+ cmdlen
) > gc
->bufEnd
) {
2439 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
2441 emit_header(gc
->pc
, opcode
, cmdlen
);
2442 (void) memcpy((void *)(gc
->pc
+ 24), (void *)(&target
), 4);
2443 (void) memcpy((void *)(gc
->pc
+ 28), (void *)(&level
), 4);
2444 (void) memcpy((void *)(gc
->pc
+ 32), (void *)(&internalformat
), 4);
2445 (void) memcpy((void *)(gc
->pc
+ 36), (void *)(&width
), 4);
2446 (void) memcpy((void *)(gc
->pc
+ 40), (void *)(&height
), 4);
2447 (void) memcpy((void *)(gc
->pc
+ 44), (void *)(&border
), 4);
2448 (void) memcpy((void *)(gc
->pc
+ 48), (void *)(&format
), 4);
2449 (void) memcpy((void *)(gc
->pc
+ 52), (void *)(&type
), 4);
2450 if ((compsize
> 0) && (pixels
!= NULL
)) {
2451 (*gc
->fillImage
)(gc
, dim
, width
, height
, 1, format
, type
, pixels
, gc
->pc
+ 56, gc
->pc
+ 4);
2454 (void) memcpy( gc
->pc
+ 4, default_pixel_store_2D
, default_pixel_store_2D_size
);
2457 if (gc
->pc
> gc
->limit
) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
2460 const GLint op
= opcode
;
2461 const GLuint cmdlenLarge
= cmdlen
+ 4;
2462 GLubyte
* const pc
= __glXFlushRenderBuffer(gc
, gc
->pc
);
2463 (void) memcpy((void *)(pc
+ 0), (void *)(&cmdlenLarge
), 4);
2464 (void) memcpy((void *)(pc
+ 4), (void *)(&op
), 4);
2465 (void) memcpy((void *)(pc
+ 28), (void *)(&target
), 4);
2466 (void) memcpy((void *)(pc
+ 32), (void *)(&level
), 4);
2467 (void) memcpy((void *)(pc
+ 36), (void *)(&internalformat
), 4);
2468 (void) memcpy((void *)(pc
+ 40), (void *)(&width
), 4);
2469 (void) memcpy((void *)(pc
+ 44), (void *)(&height
), 4);
2470 (void) memcpy((void *)(pc
+ 48), (void *)(&border
), 4);
2471 (void) memcpy((void *)(pc
+ 52), (void *)(&format
), 4);
2472 (void) memcpy((void *)(pc
+ 56), (void *)(&type
), 4);
2473 __glXSendLargeImage(gc
, compsize
, dim
, width
, height
, 1, format
, type
, pixels
, pc
+ 60, pc
+ 8);
2478 #define X_GLrop_TexImage1D 109
2480 __indirect_glTexImage1D(GLenum target
, GLint level
, GLint internalformat
, GLsizei width
, GLint border
, GLenum format
, GLenum type
, const GLvoid
* pixels
)
2482 __glx_TexImage_1D2D(X_GLrop_TexImage1D
, 1, target
, level
, internalformat
, width
, 1, border
, format
, type
, pixels
);
2485 #define X_GLrop_TexImage2D 110
2487 __indirect_glTexImage2D(GLenum target
, GLint level
, GLint internalformat
, GLsizei width
, GLsizei height
, GLint border
, GLenum format
, GLenum type
, const GLvoid
* pixels
)
2489 __glx_TexImage_1D2D(X_GLrop_TexImage2D
, 2, target
, level
, internalformat
, width
, height
, border
, format
, type
, pixels
);
2492 #define X_GLrop_TexEnvf 111
2494 __indirect_glTexEnvf(GLenum target
, GLenum pname
, GLfloat param
)
2496 __GLXcontext
* const gc
= __glXGetCurrentContext();
2497 const GLuint cmdlen
= 16;
2498 emit_header(gc
->pc
, X_GLrop_TexEnvf
, cmdlen
);
2499 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&target
), 4);
2500 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(&pname
), 4);
2501 (void) memcpy((void *)(gc
->pc
+ 12), (void *)(¶m
), 4);
2503 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
2506 #define X_GLrop_TexEnvfv 112
2508 __indirect_glTexEnvfv(GLenum target
, GLenum pname
, const GLfloat
* params
)
2510 __GLXcontext
* const gc
= __glXGetCurrentContext();
2511 const GLuint compsize
= __glTexEnvfv_size(pname
);
2512 const GLuint cmdlen
= 12 + __GLX_PAD((compsize
* 4));
2513 emit_header(gc
->pc
, X_GLrop_TexEnvfv
, cmdlen
);
2514 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&target
), 4);
2515 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(&pname
), 4);
2516 (void) memcpy((void *)(gc
->pc
+ 12), (void *)(params
), (compsize
* 4));
2518 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
2521 #define X_GLrop_TexEnvi 113
2523 __indirect_glTexEnvi(GLenum target
, GLenum pname
, GLint param
)
2525 __GLXcontext
* const gc
= __glXGetCurrentContext();
2526 const GLuint cmdlen
= 16;
2527 emit_header(gc
->pc
, X_GLrop_TexEnvi
, cmdlen
);
2528 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&target
), 4);
2529 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(&pname
), 4);
2530 (void) memcpy((void *)(gc
->pc
+ 12), (void *)(¶m
), 4);
2532 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
2535 #define X_GLrop_TexEnviv 114
2537 __indirect_glTexEnviv(GLenum target
, GLenum pname
, const GLint
* params
)
2539 __GLXcontext
* const gc
= __glXGetCurrentContext();
2540 const GLuint compsize
= __glTexEnviv_size(pname
);
2541 const GLuint cmdlen
= 12 + __GLX_PAD((compsize
* 4));
2542 emit_header(gc
->pc
, X_GLrop_TexEnviv
, cmdlen
);
2543 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&target
), 4);
2544 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(&pname
), 4);
2545 (void) memcpy((void *)(gc
->pc
+ 12), (void *)(params
), (compsize
* 4));
2547 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
2550 #define X_GLrop_TexGend 115
2552 __indirect_glTexGend(GLenum coord
, GLenum pname
, GLdouble param
)
2554 __GLXcontext
* const gc
= __glXGetCurrentContext();
2555 const GLuint cmdlen
= 20;
2556 emit_header(gc
->pc
, X_GLrop_TexGend
, cmdlen
);
2557 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(¶m
), 8);
2558 (void) memcpy((void *)(gc
->pc
+ 12), (void *)(&coord
), 4);
2559 (void) memcpy((void *)(gc
->pc
+ 16), (void *)(&pname
), 4);
2561 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
2564 #define X_GLrop_TexGendv 116
2566 __indirect_glTexGendv(GLenum coord
, GLenum pname
, const GLdouble
* params
)
2568 __GLXcontext
* const gc
= __glXGetCurrentContext();
2569 const GLuint compsize
= __glTexGendv_size(pname
);
2570 const GLuint cmdlen
= 12 + __GLX_PAD((compsize
* 8));
2571 emit_header(gc
->pc
, X_GLrop_TexGendv
, cmdlen
);
2572 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&coord
), 4);
2573 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(&pname
), 4);
2574 (void) memcpy((void *)(gc
->pc
+ 12), (void *)(params
), (compsize
* 8));
2576 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
2579 #define X_GLrop_TexGenf 117
2581 __indirect_glTexGenf(GLenum coord
, GLenum pname
, GLfloat param
)
2583 __GLXcontext
* const gc
= __glXGetCurrentContext();
2584 const GLuint cmdlen
= 16;
2585 emit_header(gc
->pc
, X_GLrop_TexGenf
, cmdlen
);
2586 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&coord
), 4);
2587 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(&pname
), 4);
2588 (void) memcpy((void *)(gc
->pc
+ 12), (void *)(¶m
), 4);
2590 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
2593 #define X_GLrop_TexGenfv 118
2595 __indirect_glTexGenfv(GLenum coord
, GLenum pname
, const GLfloat
* params
)
2597 __GLXcontext
* const gc
= __glXGetCurrentContext();
2598 const GLuint compsize
= __glTexGenfv_size(pname
);
2599 const GLuint cmdlen
= 12 + __GLX_PAD((compsize
* 4));
2600 emit_header(gc
->pc
, X_GLrop_TexGenfv
, cmdlen
);
2601 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&coord
), 4);
2602 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(&pname
), 4);
2603 (void) memcpy((void *)(gc
->pc
+ 12), (void *)(params
), (compsize
* 4));
2605 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
2608 #define X_GLrop_TexGeni 119
2610 __indirect_glTexGeni(GLenum coord
, GLenum pname
, GLint param
)
2612 __GLXcontext
* const gc
= __glXGetCurrentContext();
2613 const GLuint cmdlen
= 16;
2614 emit_header(gc
->pc
, X_GLrop_TexGeni
, cmdlen
);
2615 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&coord
), 4);
2616 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(&pname
), 4);
2617 (void) memcpy((void *)(gc
->pc
+ 12), (void *)(¶m
), 4);
2619 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
2622 #define X_GLrop_TexGeniv 120
2624 __indirect_glTexGeniv(GLenum coord
, GLenum pname
, const GLint
* params
)
2626 __GLXcontext
* const gc
= __glXGetCurrentContext();
2627 const GLuint compsize
= __glTexGeniv_size(pname
);
2628 const GLuint cmdlen
= 12 + __GLX_PAD((compsize
* 4));
2629 emit_header(gc
->pc
, X_GLrop_TexGeniv
, cmdlen
);
2630 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&coord
), 4);
2631 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(&pname
), 4);
2632 (void) memcpy((void *)(gc
->pc
+ 12), (void *)(params
), (compsize
* 4));
2634 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
2637 #define X_GLrop_InitNames 121
2639 __indirect_glInitNames(void)
2641 __GLXcontext
* const gc
= __glXGetCurrentContext();
2642 const GLuint cmdlen
= 4;
2643 emit_header(gc
->pc
, X_GLrop_InitNames
, cmdlen
);
2645 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
2648 #define X_GLrop_LoadName 122
2650 __indirect_glLoadName(GLuint name
)
2652 __GLXcontext
* const gc
= __glXGetCurrentContext();
2653 const GLuint cmdlen
= 8;
2654 emit_header(gc
->pc
, X_GLrop_LoadName
, cmdlen
);
2655 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&name
), 4);
2657 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
2660 #define X_GLrop_PassThrough 123
2662 __indirect_glPassThrough(GLfloat token
)
2664 __GLXcontext
* const gc
= __glXGetCurrentContext();
2665 const GLuint cmdlen
= 8;
2666 emit_header(gc
->pc
, X_GLrop_PassThrough
, cmdlen
);
2667 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&token
), 4);
2669 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
2672 #define X_GLrop_PopName 124
2674 __indirect_glPopName(void)
2676 __GLXcontext
* const gc
= __glXGetCurrentContext();
2677 const GLuint cmdlen
= 4;
2678 emit_header(gc
->pc
, X_GLrop_PopName
, cmdlen
);
2680 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
2683 #define X_GLrop_PushName 125
2685 __indirect_glPushName(GLuint name
)
2687 __GLXcontext
* const gc
= __glXGetCurrentContext();
2688 const GLuint cmdlen
= 8;
2689 emit_header(gc
->pc
, X_GLrop_PushName
, cmdlen
);
2690 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&name
), 4);
2692 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
2695 #define X_GLrop_DrawBuffer 126
2697 __indirect_glDrawBuffer(GLenum mode
)
2699 __GLXcontext
* const gc
= __glXGetCurrentContext();
2700 const GLuint cmdlen
= 8;
2701 emit_header(gc
->pc
, X_GLrop_DrawBuffer
, cmdlen
);
2702 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&mode
), 4);
2704 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
2707 #define X_GLrop_Clear 127
2709 __indirect_glClear(GLbitfield mask
)
2711 __GLXcontext
* const gc
= __glXGetCurrentContext();
2712 const GLuint cmdlen
= 8;
2713 emit_header(gc
->pc
, X_GLrop_Clear
, cmdlen
);
2714 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&mask
), 4);
2716 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
2719 #define X_GLrop_ClearAccum 128
2721 __indirect_glClearAccum(GLfloat red
, GLfloat green
, GLfloat blue
, GLfloat alpha
)
2723 __GLXcontext
* const gc
= __glXGetCurrentContext();
2724 const GLuint cmdlen
= 20;
2725 emit_header(gc
->pc
, X_GLrop_ClearAccum
, cmdlen
);
2726 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&red
), 4);
2727 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(&green
), 4);
2728 (void) memcpy((void *)(gc
->pc
+ 12), (void *)(&blue
), 4);
2729 (void) memcpy((void *)(gc
->pc
+ 16), (void *)(&alpha
), 4);
2731 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
2734 #define X_GLrop_ClearIndex 129
2736 __indirect_glClearIndex(GLfloat c
)
2738 __GLXcontext
* const gc
= __glXGetCurrentContext();
2739 const GLuint cmdlen
= 8;
2740 emit_header(gc
->pc
, X_GLrop_ClearIndex
, cmdlen
);
2741 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&c
), 4);
2743 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
2746 #define X_GLrop_ClearColor 130
2748 __indirect_glClearColor(GLclampf red
, GLclampf green
, GLclampf blue
, GLclampf alpha
)
2750 __GLXcontext
* const gc
= __glXGetCurrentContext();
2751 const GLuint cmdlen
= 20;
2752 emit_header(gc
->pc
, X_GLrop_ClearColor
, cmdlen
);
2753 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&red
), 4);
2754 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(&green
), 4);
2755 (void) memcpy((void *)(gc
->pc
+ 12), (void *)(&blue
), 4);
2756 (void) memcpy((void *)(gc
->pc
+ 16), (void *)(&alpha
), 4);
2758 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
2761 #define X_GLrop_ClearStencil 131
2763 __indirect_glClearStencil(GLint s
)
2765 __GLXcontext
* const gc
= __glXGetCurrentContext();
2766 const GLuint cmdlen
= 8;
2767 emit_header(gc
->pc
, X_GLrop_ClearStencil
, cmdlen
);
2768 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&s
), 4);
2770 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
2773 #define X_GLrop_ClearDepth 132
2775 __indirect_glClearDepth(GLclampd depth
)
2777 __GLXcontext
* const gc
= __glXGetCurrentContext();
2778 const GLuint cmdlen
= 12;
2779 emit_header(gc
->pc
, X_GLrop_ClearDepth
, cmdlen
);
2780 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&depth
), 8);
2782 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
2785 #define X_GLrop_StencilMask 133
2787 __indirect_glStencilMask(GLuint mask
)
2789 __GLXcontext
* const gc
= __glXGetCurrentContext();
2790 const GLuint cmdlen
= 8;
2791 emit_header(gc
->pc
, X_GLrop_StencilMask
, cmdlen
);
2792 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&mask
), 4);
2794 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
2797 #define X_GLrop_ColorMask 134
2799 __indirect_glColorMask(GLboolean red
, GLboolean green
, GLboolean blue
, GLboolean alpha
)
2801 __GLXcontext
* const gc
= __glXGetCurrentContext();
2802 const GLuint cmdlen
= 8;
2803 emit_header(gc
->pc
, X_GLrop_ColorMask
, cmdlen
);
2804 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&red
), 1);
2805 (void) memcpy((void *)(gc
->pc
+ 5), (void *)(&green
), 1);
2806 (void) memcpy((void *)(gc
->pc
+ 6), (void *)(&blue
), 1);
2807 (void) memcpy((void *)(gc
->pc
+ 7), (void *)(&alpha
), 1);
2809 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
2812 #define X_GLrop_DepthMask 135
2814 __indirect_glDepthMask(GLboolean flag
)
2816 __GLXcontext
* const gc
= __glXGetCurrentContext();
2817 const GLuint cmdlen
= 8;
2818 emit_header(gc
->pc
, X_GLrop_DepthMask
, cmdlen
);
2819 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&flag
), 1);
2821 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
2824 #define X_GLrop_IndexMask 136
2826 __indirect_glIndexMask(GLuint mask
)
2828 __GLXcontext
* const gc
= __glXGetCurrentContext();
2829 const GLuint cmdlen
= 8;
2830 emit_header(gc
->pc
, X_GLrop_IndexMask
, cmdlen
);
2831 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&mask
), 4);
2833 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
2836 #define X_GLrop_Accum 137
2838 __indirect_glAccum(GLenum op
, GLfloat value
)
2840 __GLXcontext
* const gc
= __glXGetCurrentContext();
2841 const GLuint cmdlen
= 12;
2842 emit_header(gc
->pc
, X_GLrop_Accum
, cmdlen
);
2843 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&op
), 4);
2844 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(&value
), 4);
2846 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
2849 #define X_GLrop_PopAttrib 141
2851 __indirect_glPopAttrib(void)
2853 __GLXcontext
* const gc
= __glXGetCurrentContext();
2854 const GLuint cmdlen
= 4;
2855 emit_header(gc
->pc
, X_GLrop_PopAttrib
, cmdlen
);
2857 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
2860 #define X_GLrop_PushAttrib 142
2862 __indirect_glPushAttrib(GLbitfield mask
)
2864 __GLXcontext
* const gc
= __glXGetCurrentContext();
2865 const GLuint cmdlen
= 8;
2866 emit_header(gc
->pc
, X_GLrop_PushAttrib
, cmdlen
);
2867 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&mask
), 4);
2869 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
2872 #define X_GLrop_MapGrid1d 147
2874 __indirect_glMapGrid1d(GLint un
, GLdouble u1
, GLdouble u2
)
2876 __GLXcontext
* const gc
= __glXGetCurrentContext();
2877 const GLuint cmdlen
= 24;
2878 emit_header(gc
->pc
, X_GLrop_MapGrid1d
, cmdlen
);
2879 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&u1
), 8);
2880 (void) memcpy((void *)(gc
->pc
+ 12), (void *)(&u2
), 8);
2881 (void) memcpy((void *)(gc
->pc
+ 20), (void *)(&un
), 4);
2883 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
2886 #define X_GLrop_MapGrid1f 148
2888 __indirect_glMapGrid1f(GLint un
, GLfloat u1
, GLfloat u2
)
2890 __GLXcontext
* const gc
= __glXGetCurrentContext();
2891 const GLuint cmdlen
= 16;
2892 emit_header(gc
->pc
, X_GLrop_MapGrid1f
, cmdlen
);
2893 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&un
), 4);
2894 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(&u1
), 4);
2895 (void) memcpy((void *)(gc
->pc
+ 12), (void *)(&u2
), 4);
2897 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
2900 #define X_GLrop_MapGrid2d 149
2902 __indirect_glMapGrid2d(GLint un
, GLdouble u1
, GLdouble u2
, GLint vn
, GLdouble v1
, GLdouble v2
)
2904 __GLXcontext
* const gc
= __glXGetCurrentContext();
2905 const GLuint cmdlen
= 44;
2906 emit_header(gc
->pc
, X_GLrop_MapGrid2d
, cmdlen
);
2907 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&u1
), 8);
2908 (void) memcpy((void *)(gc
->pc
+ 12), (void *)(&u2
), 8);
2909 (void) memcpy((void *)(gc
->pc
+ 20), (void *)(&v1
), 8);
2910 (void) memcpy((void *)(gc
->pc
+ 28), (void *)(&v2
), 8);
2911 (void) memcpy((void *)(gc
->pc
+ 36), (void *)(&un
), 4);
2912 (void) memcpy((void *)(gc
->pc
+ 40), (void *)(&vn
), 4);
2914 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
2917 #define X_GLrop_MapGrid2f 150
2919 __indirect_glMapGrid2f(GLint un
, GLfloat u1
, GLfloat u2
, GLint vn
, GLfloat v1
, GLfloat v2
)
2921 __GLXcontext
* const gc
= __glXGetCurrentContext();
2922 const GLuint cmdlen
= 28;
2923 emit_header(gc
->pc
, X_GLrop_MapGrid2f
, cmdlen
);
2924 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&un
), 4);
2925 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(&u1
), 4);
2926 (void) memcpy((void *)(gc
->pc
+ 12), (void *)(&u2
), 4);
2927 (void) memcpy((void *)(gc
->pc
+ 16), (void *)(&vn
), 4);
2928 (void) memcpy((void *)(gc
->pc
+ 20), (void *)(&v1
), 4);
2929 (void) memcpy((void *)(gc
->pc
+ 24), (void *)(&v2
), 4);
2931 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
2934 #define X_GLrop_EvalCoord1dv 151
2936 __indirect_glEvalCoord1d(GLdouble u
)
2938 __GLXcontext
* const gc
= __glXGetCurrentContext();
2939 const GLuint cmdlen
= 12;
2940 emit_header(gc
->pc
, X_GLrop_EvalCoord1dv
, cmdlen
);
2941 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&u
), 8);
2943 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
2946 #define X_GLrop_EvalCoord1dv 151
2948 __indirect_glEvalCoord1dv(const GLdouble
* u
)
2950 generic_8_byte( X_GLrop_EvalCoord1dv
, u
);
2953 #define X_GLrop_EvalCoord1fv 152
2955 __indirect_glEvalCoord1f(GLfloat u
)
2957 __GLXcontext
* const gc
= __glXGetCurrentContext();
2958 const GLuint cmdlen
= 8;
2959 emit_header(gc
->pc
, X_GLrop_EvalCoord1fv
, cmdlen
);
2960 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&u
), 4);
2962 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
2965 #define X_GLrop_EvalCoord1fv 152
2967 __indirect_glEvalCoord1fv(const GLfloat
* u
)
2969 generic_4_byte( X_GLrop_EvalCoord1fv
, u
);
2972 #define X_GLrop_EvalCoord2dv 153
2974 __indirect_glEvalCoord2d(GLdouble u
, GLdouble v
)
2976 __GLXcontext
* const gc
= __glXGetCurrentContext();
2977 const GLuint cmdlen
= 20;
2978 emit_header(gc
->pc
, X_GLrop_EvalCoord2dv
, cmdlen
);
2979 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&u
), 8);
2980 (void) memcpy((void *)(gc
->pc
+ 12), (void *)(&v
), 8);
2982 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
2985 #define X_GLrop_EvalCoord2dv 153
2987 __indirect_glEvalCoord2dv(const GLdouble
* u
)
2989 generic_16_byte( X_GLrop_EvalCoord2dv
, u
);
2992 #define X_GLrop_EvalCoord2fv 154
2994 __indirect_glEvalCoord2f(GLfloat u
, GLfloat v
)
2996 __GLXcontext
* const gc
= __glXGetCurrentContext();
2997 const GLuint cmdlen
= 12;
2998 emit_header(gc
->pc
, X_GLrop_EvalCoord2fv
, cmdlen
);
2999 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&u
), 4);
3000 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(&v
), 4);
3002 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
3005 #define X_GLrop_EvalCoord2fv 154
3007 __indirect_glEvalCoord2fv(const GLfloat
* u
)
3009 generic_8_byte( X_GLrop_EvalCoord2fv
, u
);
3012 #define X_GLrop_EvalMesh1 155
3014 __indirect_glEvalMesh1(GLenum mode
, GLint i1
, GLint i2
)
3016 __GLXcontext
* const gc
= __glXGetCurrentContext();
3017 const GLuint cmdlen
= 16;
3018 emit_header(gc
->pc
, X_GLrop_EvalMesh1
, cmdlen
);
3019 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&mode
), 4);
3020 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(&i1
), 4);
3021 (void) memcpy((void *)(gc
->pc
+ 12), (void *)(&i2
), 4);
3023 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
3026 #define X_GLrop_EvalPoint1 156
3028 __indirect_glEvalPoint1(GLint i
)
3030 __GLXcontext
* const gc
= __glXGetCurrentContext();
3031 const GLuint cmdlen
= 8;
3032 emit_header(gc
->pc
, X_GLrop_EvalPoint1
, cmdlen
);
3033 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&i
), 4);
3035 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
3038 #define X_GLrop_EvalMesh2 157
3040 __indirect_glEvalMesh2(GLenum mode
, GLint i1
, GLint i2
, GLint j1
, GLint j2
)
3042 __GLXcontext
* const gc
= __glXGetCurrentContext();
3043 const GLuint cmdlen
= 24;
3044 emit_header(gc
->pc
, X_GLrop_EvalMesh2
, cmdlen
);
3045 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&mode
), 4);
3046 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(&i1
), 4);
3047 (void) memcpy((void *)(gc
->pc
+ 12), (void *)(&i2
), 4);
3048 (void) memcpy((void *)(gc
->pc
+ 16), (void *)(&j1
), 4);
3049 (void) memcpy((void *)(gc
->pc
+ 20), (void *)(&j2
), 4);
3051 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
3054 #define X_GLrop_EvalPoint2 158
3056 __indirect_glEvalPoint2(GLint i
, GLint j
)
3058 __GLXcontext
* const gc
= __glXGetCurrentContext();
3059 const GLuint cmdlen
= 12;
3060 emit_header(gc
->pc
, X_GLrop_EvalPoint2
, cmdlen
);
3061 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&i
), 4);
3062 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(&j
), 4);
3064 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
3067 #define X_GLrop_AlphaFunc 159
3069 __indirect_glAlphaFunc(GLenum func
, GLclampf ref
)
3071 __GLXcontext
* const gc
= __glXGetCurrentContext();
3072 const GLuint cmdlen
= 12;
3073 emit_header(gc
->pc
, X_GLrop_AlphaFunc
, cmdlen
);
3074 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&func
), 4);
3075 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(&ref
), 4);
3077 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
3080 #define X_GLrop_BlendFunc 160
3082 __indirect_glBlendFunc(GLenum sfactor
, GLenum dfactor
)
3084 __GLXcontext
* const gc
= __glXGetCurrentContext();
3085 const GLuint cmdlen
= 12;
3086 emit_header(gc
->pc
, X_GLrop_BlendFunc
, cmdlen
);
3087 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&sfactor
), 4);
3088 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(&dfactor
), 4);
3090 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
3093 #define X_GLrop_LogicOp 161
3095 __indirect_glLogicOp(GLenum opcode
)
3097 __GLXcontext
* const gc
= __glXGetCurrentContext();
3098 const GLuint cmdlen
= 8;
3099 emit_header(gc
->pc
, X_GLrop_LogicOp
, cmdlen
);
3100 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&opcode
), 4);
3102 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
3105 #define X_GLrop_StencilFunc 162
3107 __indirect_glStencilFunc(GLenum func
, GLint ref
, GLuint mask
)
3109 __GLXcontext
* const gc
= __glXGetCurrentContext();
3110 const GLuint cmdlen
= 16;
3111 emit_header(gc
->pc
, X_GLrop_StencilFunc
, cmdlen
);
3112 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&func
), 4);
3113 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(&ref
), 4);
3114 (void) memcpy((void *)(gc
->pc
+ 12), (void *)(&mask
), 4);
3116 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
3119 #define X_GLrop_StencilOp 163
3121 __indirect_glStencilOp(GLenum fail
, GLenum zfail
, GLenum zpass
)
3123 __GLXcontext
* const gc
= __glXGetCurrentContext();
3124 const GLuint cmdlen
= 16;
3125 emit_header(gc
->pc
, X_GLrop_StencilOp
, cmdlen
);
3126 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&fail
), 4);
3127 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(&zfail
), 4);
3128 (void) memcpy((void *)(gc
->pc
+ 12), (void *)(&zpass
), 4);
3130 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
3133 #define X_GLrop_DepthFunc 164
3135 __indirect_glDepthFunc(GLenum func
)
3137 __GLXcontext
* const gc
= __glXGetCurrentContext();
3138 const GLuint cmdlen
= 8;
3139 emit_header(gc
->pc
, X_GLrop_DepthFunc
, cmdlen
);
3140 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&func
), 4);
3142 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
3145 #define X_GLrop_PixelZoom 165
3147 __indirect_glPixelZoom(GLfloat xfactor
, GLfloat yfactor
)
3149 __GLXcontext
* const gc
= __glXGetCurrentContext();
3150 const GLuint cmdlen
= 12;
3151 emit_header(gc
->pc
, X_GLrop_PixelZoom
, cmdlen
);
3152 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&xfactor
), 4);
3153 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(&yfactor
), 4);
3155 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
3158 #define X_GLrop_PixelTransferf 166
3160 __indirect_glPixelTransferf(GLenum pname
, GLfloat param
)
3162 __GLXcontext
* const gc
= __glXGetCurrentContext();
3163 const GLuint cmdlen
= 12;
3164 emit_header(gc
->pc
, X_GLrop_PixelTransferf
, cmdlen
);
3165 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&pname
), 4);
3166 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(¶m
), 4);
3168 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
3171 #define X_GLrop_PixelTransferi 167
3173 __indirect_glPixelTransferi(GLenum pname
, GLint param
)
3175 __GLXcontext
* const gc
= __glXGetCurrentContext();
3176 const GLuint cmdlen
= 12;
3177 emit_header(gc
->pc
, X_GLrop_PixelTransferi
, cmdlen
);
3178 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&pname
), 4);
3179 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(¶m
), 4);
3181 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
3184 #define X_GLrop_PixelMapfv 168
3186 __indirect_glPixelMapfv(GLenum map
, GLsizei mapsize
, const GLfloat
* values
)
3188 __GLXcontext
* const gc
= __glXGetCurrentContext();
3189 const GLuint cmdlen
= 12 + __GLX_PAD((mapsize
* 4));
3190 if (__builtin_expect((mapsize
>= 0) && (gc
->currentDpy
!= NULL
), 1)) {
3191 if (cmdlen
<= gc
->maxSmallRenderCommandSize
) {
3192 if ( (gc
->pc
+ cmdlen
) > gc
->bufEnd
) {
3193 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
3195 emit_header(gc
->pc
, X_GLrop_PixelMapfv
, cmdlen
);
3196 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&map
), 4);
3197 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(&mapsize
), 4);
3198 (void) memcpy((void *)(gc
->pc
+ 12), (void *)(values
), (mapsize
* 4));
3200 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
3203 const GLint op
= X_GLrop_PixelMapfv
;
3204 const GLuint cmdlenLarge
= cmdlen
+ 4;
3205 GLubyte
* const pc
= __glXFlushRenderBuffer(gc
, gc
->pc
);
3206 (void) memcpy((void *)(pc
+ 0), (void *)(&cmdlenLarge
), 4);
3207 (void) memcpy((void *)(pc
+ 4), (void *)(&op
), 4);
3208 (void) memcpy((void *)(pc
+ 8), (void *)(&map
), 4);
3209 (void) memcpy((void *)(pc
+ 12), (void *)(&mapsize
), 4);
3210 __glXSendLargeCommand(gc
, pc
, 16, values
, (mapsize
* 4));
3215 #define X_GLrop_PixelMapuiv 169
3217 __indirect_glPixelMapuiv(GLenum map
, GLsizei mapsize
, const GLuint
* values
)
3219 __GLXcontext
* const gc
= __glXGetCurrentContext();
3220 const GLuint cmdlen
= 12 + __GLX_PAD((mapsize
* 4));
3221 if (__builtin_expect((mapsize
>= 0) && (gc
->currentDpy
!= NULL
), 1)) {
3222 if (cmdlen
<= gc
->maxSmallRenderCommandSize
) {
3223 if ( (gc
->pc
+ cmdlen
) > gc
->bufEnd
) {
3224 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
3226 emit_header(gc
->pc
, X_GLrop_PixelMapuiv
, cmdlen
);
3227 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&map
), 4);
3228 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(&mapsize
), 4);
3229 (void) memcpy((void *)(gc
->pc
+ 12), (void *)(values
), (mapsize
* 4));
3231 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
3234 const GLint op
= X_GLrop_PixelMapuiv
;
3235 const GLuint cmdlenLarge
= cmdlen
+ 4;
3236 GLubyte
* const pc
= __glXFlushRenderBuffer(gc
, gc
->pc
);
3237 (void) memcpy((void *)(pc
+ 0), (void *)(&cmdlenLarge
), 4);
3238 (void) memcpy((void *)(pc
+ 4), (void *)(&op
), 4);
3239 (void) memcpy((void *)(pc
+ 8), (void *)(&map
), 4);
3240 (void) memcpy((void *)(pc
+ 12), (void *)(&mapsize
), 4);
3241 __glXSendLargeCommand(gc
, pc
, 16, values
, (mapsize
* 4));
3246 #define X_GLrop_PixelMapusv 170
3248 __indirect_glPixelMapusv(GLenum map
, GLsizei mapsize
, const GLushort
* values
)
3250 __GLXcontext
* const gc
= __glXGetCurrentContext();
3251 const GLuint cmdlen
= 12 + __GLX_PAD((mapsize
* 2));
3252 if (__builtin_expect((mapsize
>= 0) && (gc
->currentDpy
!= NULL
), 1)) {
3253 if (cmdlen
<= gc
->maxSmallRenderCommandSize
) {
3254 if ( (gc
->pc
+ cmdlen
) > gc
->bufEnd
) {
3255 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
3257 emit_header(gc
->pc
, X_GLrop_PixelMapusv
, cmdlen
);
3258 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&map
), 4);
3259 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(&mapsize
), 4);
3260 (void) memcpy((void *)(gc
->pc
+ 12), (void *)(values
), (mapsize
* 2));
3262 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
3265 const GLint op
= X_GLrop_PixelMapusv
;
3266 const GLuint cmdlenLarge
= cmdlen
+ 4;
3267 GLubyte
* const pc
= __glXFlushRenderBuffer(gc
, gc
->pc
);
3268 (void) memcpy((void *)(pc
+ 0), (void *)(&cmdlenLarge
), 4);
3269 (void) memcpy((void *)(pc
+ 4), (void *)(&op
), 4);
3270 (void) memcpy((void *)(pc
+ 8), (void *)(&map
), 4);
3271 (void) memcpy((void *)(pc
+ 12), (void *)(&mapsize
), 4);
3272 __glXSendLargeCommand(gc
, pc
, 16, values
, (mapsize
* 2));
3277 #define X_GLrop_ReadBuffer 171
3279 __indirect_glReadBuffer(GLenum mode
)
3281 __GLXcontext
* const gc
= __glXGetCurrentContext();
3282 const GLuint cmdlen
= 8;
3283 emit_header(gc
->pc
, X_GLrop_ReadBuffer
, cmdlen
);
3284 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&mode
), 4);
3286 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
3289 #define X_GLrop_CopyPixels 172
3291 __indirect_glCopyPixels(GLint x
, GLint y
, GLsizei width
, GLsizei height
, GLenum type
)
3293 __GLXcontext
* const gc
= __glXGetCurrentContext();
3294 const GLuint cmdlen
= 24;
3295 emit_header(gc
->pc
, X_GLrop_CopyPixels
, cmdlen
);
3296 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&x
), 4);
3297 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(&y
), 4);
3298 (void) memcpy((void *)(gc
->pc
+ 12), (void *)(&width
), 4);
3299 (void) memcpy((void *)(gc
->pc
+ 16), (void *)(&height
), 4);
3300 (void) memcpy((void *)(gc
->pc
+ 20), (void *)(&type
), 4);
3302 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
3305 #define X_GLsop_ReadPixels 111
3307 __indirect_glReadPixels(GLint x
, GLint y
, GLsizei width
, GLsizei height
, GLenum format
, GLenum type
, GLvoid
* pixels
)
3309 __GLXcontext
* const gc
= __glXGetCurrentContext();
3310 const __GLXattribute
* const state
= gc
->client_state_private
;
3311 Display
* const dpy
= gc
->currentDpy
;
3312 const GLuint cmdlen
= 28;
3313 if (__builtin_expect(dpy
!= NULL
, 1)) {
3315 XCBConnection
*c
= XCBConnectionOfDisplay(dpy
);
3316 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
3317 XCBGlxReadPixelsRep
*reply
= XCBGlxReadPixelsReply(c
, XCBGlxReadPixels(c
, gc
->currentContextTag
, x
, y
, width
, height
, format
, type
, state
->storePack
.swapEndian
, 0), NULL
);
3318 (void)memcpy(pixels
, XCBGlxReadPixelsData(reply
), XCBGlxReadPixelsDataLength(reply
) * sizeof(GLvoid
));
3321 GLubyte
const * pc
= __glXSetupSingleRequest(gc
, X_GLsop_ReadPixels
, cmdlen
);
3322 (void) memcpy((void *)(pc
+ 0), (void *)(&x
), 4);
3323 (void) memcpy((void *)(pc
+ 4), (void *)(&y
), 4);
3324 (void) memcpy((void *)(pc
+ 8), (void *)(&width
), 4);
3325 (void) memcpy((void *)(pc
+ 12), (void *)(&height
), 4);
3326 (void) memcpy((void *)(pc
+ 16), (void *)(&format
), 4);
3327 (void) memcpy((void *)(pc
+ 20), (void *)(&type
), 4);
3328 *(int32_t *)(pc
+ 24) = 0;
3329 * (int8_t *)(pc
+ 24) = state
->storePack
.swapEndian
;
3330 __glXReadPixelReply(dpy
, gc
, 2, width
, height
, 1, format
, type
, pixels
, GL_FALSE
);
3331 UnlockDisplay(dpy
); SyncHandle();
3332 #endif /* USE_XCB */
3337 #define X_GLrop_DrawPixels 173
3339 __indirect_glDrawPixels(GLsizei width
, GLsizei height
, GLenum format
, GLenum type
, const GLvoid
* pixels
)
3341 __GLXcontext
* const gc
= __glXGetCurrentContext();
3342 const GLuint compsize
= (pixels
!= NULL
) ? __glImageSize(width
, height
, 1, format
, type
, 0) : 0;
3343 const GLuint cmdlen
= 40 + __GLX_PAD(compsize
);
3344 if (__builtin_expect(gc
->currentDpy
!= NULL
, 1)) {
3345 if (cmdlen
<= gc
->maxSmallRenderCommandSize
) {
3346 if ( (gc
->pc
+ cmdlen
) > gc
->bufEnd
) {
3347 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
3349 emit_header(gc
->pc
, X_GLrop_DrawPixels
, cmdlen
);
3350 (void) memcpy((void *)(gc
->pc
+ 24), (void *)(&width
), 4);
3351 (void) memcpy((void *)(gc
->pc
+ 28), (void *)(&height
), 4);
3352 (void) memcpy((void *)(gc
->pc
+ 32), (void *)(&format
), 4);
3353 (void) memcpy((void *)(gc
->pc
+ 36), (void *)(&type
), 4);
3355 (*gc
->fillImage
)(gc
, 2, width
, height
, 1, format
, type
, pixels
, gc
->pc
+ 40, gc
->pc
+ 4);
3358 (void) memcpy( gc
->pc
+ 4, default_pixel_store_2D
, default_pixel_store_2D_size
);
3361 if (gc
->pc
> gc
->limit
) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
3364 const GLint op
= X_GLrop_DrawPixels
;
3365 const GLuint cmdlenLarge
= cmdlen
+ 4;
3366 GLubyte
* const pc
= __glXFlushRenderBuffer(gc
, gc
->pc
);
3367 (void) memcpy((void *)(pc
+ 0), (void *)(&cmdlenLarge
), 4);
3368 (void) memcpy((void *)(pc
+ 4), (void *)(&op
), 4);
3369 (void) memcpy((void *)(pc
+ 28), (void *)(&width
), 4);
3370 (void) memcpy((void *)(pc
+ 32), (void *)(&height
), 4);
3371 (void) memcpy((void *)(pc
+ 36), (void *)(&format
), 4);
3372 (void) memcpy((void *)(pc
+ 40), (void *)(&type
), 4);
3373 __glXSendLargeImage(gc
, compsize
, 2, width
, height
, 1, format
, type
, pixels
, pc
+ 44, pc
+ 8);
3378 #define X_GLsop_GetClipPlane 113
3380 __indirect_glGetClipPlane(GLenum plane
, GLdouble
* equation
)
3382 __GLXcontext
* const gc
= __glXGetCurrentContext();
3383 Display
* const dpy
= gc
->currentDpy
;
3384 const GLuint cmdlen
= 4;
3385 if (__builtin_expect(dpy
!= NULL
, 1)) {
3387 XCBConnection
*c
= XCBConnectionOfDisplay(dpy
);
3388 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
3389 XCBGlxGetClipPlaneRep
*reply
= XCBGlxGetClipPlaneReply(c
, XCBGlxGetClipPlane(c
, gc
->currentContextTag
, plane
), NULL
);
3390 (void)memcpy(equation
, XCBGlxGetClipPlaneData(reply
), XCBGlxGetClipPlaneDataLength(reply
) * sizeof(GLdouble
));
3393 GLubyte
const * pc
= __glXSetupSingleRequest(gc
, X_GLsop_GetClipPlane
, cmdlen
);
3394 (void) memcpy((void *)(pc
+ 0), (void *)(&plane
), 4);
3395 (void) __glXReadReply(dpy
, 8, equation
, GL_TRUE
);
3396 UnlockDisplay(dpy
); SyncHandle();
3397 #endif /* USE_XCB */
3402 #define X_GLsop_GetLightfv 118
3404 __indirect_glGetLightfv(GLenum light
, GLenum pname
, GLfloat
* params
)
3406 __GLXcontext
* const gc
= __glXGetCurrentContext();
3407 Display
* const dpy
= gc
->currentDpy
;
3408 const GLuint cmdlen
= 8;
3409 if (__builtin_expect(dpy
!= NULL
, 1)) {
3411 XCBConnection
*c
= XCBConnectionOfDisplay(dpy
);
3412 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
3413 XCBGlxGetLightfvRep
*reply
= XCBGlxGetLightfvReply(c
, XCBGlxGetLightfv(c
, gc
->currentContextTag
, light
, pname
), NULL
);
3414 if (XCBGlxGetLightfvDataLength(reply
) == 0)
3415 (void)memcpy(params
, &reply
->datum
, sizeof(reply
->datum
));
3417 (void)memcpy(params
, XCBGlxGetLightfvData(reply
), XCBGlxGetLightfvDataLength(reply
) * sizeof(GLfloat
));
3420 GLubyte
const * pc
= __glXSetupSingleRequest(gc
, X_GLsop_GetLightfv
, cmdlen
);
3421 (void) memcpy((void *)(pc
+ 0), (void *)(&light
), 4);
3422 (void) memcpy((void *)(pc
+ 4), (void *)(&pname
), 4);
3423 (void) __glXReadReply(dpy
, 4, params
, GL_FALSE
);
3424 UnlockDisplay(dpy
); SyncHandle();
3425 #endif /* USE_XCB */
3430 #define X_GLsop_GetLightiv 119
3432 __indirect_glGetLightiv(GLenum light
, GLenum pname
, GLint
* params
)
3434 __GLXcontext
* const gc
= __glXGetCurrentContext();
3435 Display
* const dpy
= gc
->currentDpy
;
3436 const GLuint cmdlen
= 8;
3437 if (__builtin_expect(dpy
!= NULL
, 1)) {
3439 XCBConnection
*c
= XCBConnectionOfDisplay(dpy
);
3440 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
3441 XCBGlxGetLightivRep
*reply
= XCBGlxGetLightivReply(c
, XCBGlxGetLightiv(c
, gc
->currentContextTag
, light
, pname
), NULL
);
3442 if (XCBGlxGetLightivDataLength(reply
) == 0)
3443 (void)memcpy(params
, &reply
->datum
, sizeof(reply
->datum
));
3445 (void)memcpy(params
, XCBGlxGetLightivData(reply
), XCBGlxGetLightivDataLength(reply
) * sizeof(GLint
));
3448 GLubyte
const * pc
= __glXSetupSingleRequest(gc
, X_GLsop_GetLightiv
, cmdlen
);
3449 (void) memcpy((void *)(pc
+ 0), (void *)(&light
), 4);
3450 (void) memcpy((void *)(pc
+ 4), (void *)(&pname
), 4);
3451 (void) __glXReadReply(dpy
, 4, params
, GL_FALSE
);
3452 UnlockDisplay(dpy
); SyncHandle();
3453 #endif /* USE_XCB */
3458 #define X_GLsop_GetMapdv 120
3460 __indirect_glGetMapdv(GLenum target
, GLenum query
, GLdouble
* v
)
3462 __GLXcontext
* const gc
= __glXGetCurrentContext();
3463 Display
* const dpy
= gc
->currentDpy
;
3464 const GLuint cmdlen
= 8;
3465 if (__builtin_expect(dpy
!= NULL
, 1)) {
3467 XCBConnection
*c
= XCBConnectionOfDisplay(dpy
);
3468 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
3469 XCBGlxGetMapdvRep
*reply
= XCBGlxGetMapdvReply(c
, XCBGlxGetMapdv(c
, gc
->currentContextTag
, target
, query
), NULL
);
3470 if (XCBGlxGetMapdvDataLength(reply
) == 0)
3471 (void)memcpy(v
, &reply
->datum
, sizeof(reply
->datum
));
3473 (void)memcpy(v
, XCBGlxGetMapdvData(reply
), XCBGlxGetMapdvDataLength(reply
) * sizeof(GLdouble
));
3476 GLubyte
const * pc
= __glXSetupSingleRequest(gc
, X_GLsop_GetMapdv
, cmdlen
);
3477 (void) memcpy((void *)(pc
+ 0), (void *)(&target
), 4);
3478 (void) memcpy((void *)(pc
+ 4), (void *)(&query
), 4);
3479 (void) __glXReadReply(dpy
, 8, v
, GL_FALSE
);
3480 UnlockDisplay(dpy
); SyncHandle();
3481 #endif /* USE_XCB */
3486 #define X_GLsop_GetMapfv 121
3488 __indirect_glGetMapfv(GLenum target
, GLenum query
, GLfloat
* v
)
3490 __GLXcontext
* const gc
= __glXGetCurrentContext();
3491 Display
* const dpy
= gc
->currentDpy
;
3492 const GLuint cmdlen
= 8;
3493 if (__builtin_expect(dpy
!= NULL
, 1)) {
3495 XCBConnection
*c
= XCBConnectionOfDisplay(dpy
);
3496 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
3497 XCBGlxGetMapfvRep
*reply
= XCBGlxGetMapfvReply(c
, XCBGlxGetMapfv(c
, gc
->currentContextTag
, target
, query
), NULL
);
3498 if (XCBGlxGetMapfvDataLength(reply
) == 0)
3499 (void)memcpy(v
, &reply
->datum
, sizeof(reply
->datum
));
3501 (void)memcpy(v
, XCBGlxGetMapfvData(reply
), XCBGlxGetMapfvDataLength(reply
) * sizeof(GLfloat
));
3504 GLubyte
const * pc
= __glXSetupSingleRequest(gc
, X_GLsop_GetMapfv
, cmdlen
);
3505 (void) memcpy((void *)(pc
+ 0), (void *)(&target
), 4);
3506 (void) memcpy((void *)(pc
+ 4), (void *)(&query
), 4);
3507 (void) __glXReadReply(dpy
, 4, v
, GL_FALSE
);
3508 UnlockDisplay(dpy
); SyncHandle();
3509 #endif /* USE_XCB */
3514 #define X_GLsop_GetMapiv 122
3516 __indirect_glGetMapiv(GLenum target
, GLenum query
, GLint
* v
)
3518 __GLXcontext
* const gc
= __glXGetCurrentContext();
3519 Display
* const dpy
= gc
->currentDpy
;
3520 const GLuint cmdlen
= 8;
3521 if (__builtin_expect(dpy
!= NULL
, 1)) {
3523 XCBConnection
*c
= XCBConnectionOfDisplay(dpy
);
3524 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
3525 XCBGlxGetMapivRep
*reply
= XCBGlxGetMapivReply(c
, XCBGlxGetMapiv(c
, gc
->currentContextTag
, target
, query
), NULL
);
3526 if (XCBGlxGetMapivDataLength(reply
) == 0)
3527 (void)memcpy(v
, &reply
->datum
, sizeof(reply
->datum
));
3529 (void)memcpy(v
, XCBGlxGetMapivData(reply
), XCBGlxGetMapivDataLength(reply
) * sizeof(GLint
));
3532 GLubyte
const * pc
= __glXSetupSingleRequest(gc
, X_GLsop_GetMapiv
, cmdlen
);
3533 (void) memcpy((void *)(pc
+ 0), (void *)(&target
), 4);
3534 (void) memcpy((void *)(pc
+ 4), (void *)(&query
), 4);
3535 (void) __glXReadReply(dpy
, 4, v
, GL_FALSE
);
3536 UnlockDisplay(dpy
); SyncHandle();
3537 #endif /* USE_XCB */
3542 #define X_GLsop_GetMaterialfv 123
3544 __indirect_glGetMaterialfv(GLenum face
, GLenum pname
, GLfloat
* params
)
3546 __GLXcontext
* const gc
= __glXGetCurrentContext();
3547 Display
* const dpy
= gc
->currentDpy
;
3548 const GLuint cmdlen
= 8;
3549 if (__builtin_expect(dpy
!= NULL
, 1)) {
3551 XCBConnection
*c
= XCBConnectionOfDisplay(dpy
);
3552 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
3553 XCBGlxGetMaterialfvRep
*reply
= XCBGlxGetMaterialfvReply(c
, XCBGlxGetMaterialfv(c
, gc
->currentContextTag
, face
, pname
), NULL
);
3554 if (XCBGlxGetMaterialfvDataLength(reply
) == 0)
3555 (void)memcpy(params
, &reply
->datum
, sizeof(reply
->datum
));
3557 (void)memcpy(params
, XCBGlxGetMaterialfvData(reply
), XCBGlxGetMaterialfvDataLength(reply
) * sizeof(GLfloat
));
3560 GLubyte
const * pc
= __glXSetupSingleRequest(gc
, X_GLsop_GetMaterialfv
, cmdlen
);
3561 (void) memcpy((void *)(pc
+ 0), (void *)(&face
), 4);
3562 (void) memcpy((void *)(pc
+ 4), (void *)(&pname
), 4);
3563 (void) __glXReadReply(dpy
, 4, params
, GL_FALSE
);
3564 UnlockDisplay(dpy
); SyncHandle();
3565 #endif /* USE_XCB */
3570 #define X_GLsop_GetMaterialiv 124
3572 __indirect_glGetMaterialiv(GLenum face
, GLenum pname
, GLint
* params
)
3574 __GLXcontext
* const gc
= __glXGetCurrentContext();
3575 Display
* const dpy
= gc
->currentDpy
;
3576 const GLuint cmdlen
= 8;
3577 if (__builtin_expect(dpy
!= NULL
, 1)) {
3579 XCBConnection
*c
= XCBConnectionOfDisplay(dpy
);
3580 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
3581 XCBGlxGetMaterialivRep
*reply
= XCBGlxGetMaterialivReply(c
, XCBGlxGetMaterialiv(c
, gc
->currentContextTag
, face
, pname
), NULL
);
3582 if (XCBGlxGetMaterialivDataLength(reply
) == 0)
3583 (void)memcpy(params
, &reply
->datum
, sizeof(reply
->datum
));
3585 (void)memcpy(params
, XCBGlxGetMaterialivData(reply
), XCBGlxGetMaterialivDataLength(reply
) * sizeof(GLint
));
3588 GLubyte
const * pc
= __glXSetupSingleRequest(gc
, X_GLsop_GetMaterialiv
, cmdlen
);
3589 (void) memcpy((void *)(pc
+ 0), (void *)(&face
), 4);
3590 (void) memcpy((void *)(pc
+ 4), (void *)(&pname
), 4);
3591 (void) __glXReadReply(dpy
, 4, params
, GL_FALSE
);
3592 UnlockDisplay(dpy
); SyncHandle();
3593 #endif /* USE_XCB */
3598 #define X_GLsop_GetPixelMapfv 125
3600 __indirect_glGetPixelMapfv(GLenum map
, GLfloat
* values
)
3602 __GLXcontext
* const gc
= __glXGetCurrentContext();
3603 Display
* const dpy
= gc
->currentDpy
;
3604 const GLuint cmdlen
= 4;
3605 if (__builtin_expect(dpy
!= NULL
, 1)) {
3607 XCBConnection
*c
= XCBConnectionOfDisplay(dpy
);
3608 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
3609 XCBGlxGetPixelMapfvRep
*reply
= XCBGlxGetPixelMapfvReply(c
, XCBGlxGetPixelMapfv(c
, gc
->currentContextTag
, map
), NULL
);
3610 if (XCBGlxGetPixelMapfvDataLength(reply
) == 0)
3611 (void)memcpy(values
, &reply
->datum
, sizeof(reply
->datum
));
3613 (void)memcpy(values
, XCBGlxGetPixelMapfvData(reply
), XCBGlxGetPixelMapfvDataLength(reply
) * sizeof(GLfloat
));
3616 GLubyte
const * pc
= __glXSetupSingleRequest(gc
, X_GLsop_GetPixelMapfv
, cmdlen
);
3617 (void) memcpy((void *)(pc
+ 0), (void *)(&map
), 4);
3618 (void) __glXReadReply(dpy
, 4, values
, GL_FALSE
);
3619 UnlockDisplay(dpy
); SyncHandle();
3620 #endif /* USE_XCB */
3625 #define X_GLsop_GetPixelMapuiv 126
3627 __indirect_glGetPixelMapuiv(GLenum map
, GLuint
* values
)
3629 __GLXcontext
* const gc
= __glXGetCurrentContext();
3630 Display
* const dpy
= gc
->currentDpy
;
3631 const GLuint cmdlen
= 4;
3632 if (__builtin_expect(dpy
!= NULL
, 1)) {
3634 XCBConnection
*c
= XCBConnectionOfDisplay(dpy
);
3635 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
3636 XCBGlxGetPixelMapuivRep
*reply
= XCBGlxGetPixelMapuivReply(c
, XCBGlxGetPixelMapuiv(c
, gc
->currentContextTag
, map
), NULL
);
3637 if (XCBGlxGetPixelMapuivDataLength(reply
) == 0)
3638 (void)memcpy(values
, &reply
->datum
, sizeof(reply
->datum
));
3640 (void)memcpy(values
, XCBGlxGetPixelMapuivData(reply
), XCBGlxGetPixelMapuivDataLength(reply
) * sizeof(GLuint
));
3643 GLubyte
const * pc
= __glXSetupSingleRequest(gc
, X_GLsop_GetPixelMapuiv
, cmdlen
);
3644 (void) memcpy((void *)(pc
+ 0), (void *)(&map
), 4);
3645 (void) __glXReadReply(dpy
, 4, values
, GL_FALSE
);
3646 UnlockDisplay(dpy
); SyncHandle();
3647 #endif /* USE_XCB */
3652 #define X_GLsop_GetPixelMapusv 127
3654 __indirect_glGetPixelMapusv(GLenum map
, GLushort
* values
)
3656 __GLXcontext
* const gc
= __glXGetCurrentContext();
3657 Display
* const dpy
= gc
->currentDpy
;
3658 const GLuint cmdlen
= 4;
3659 if (__builtin_expect(dpy
!= NULL
, 1)) {
3661 XCBConnection
*c
= XCBConnectionOfDisplay(dpy
);
3662 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
3663 XCBGlxGetPixelMapusvRep
*reply
= XCBGlxGetPixelMapusvReply(c
, XCBGlxGetPixelMapusv(c
, gc
->currentContextTag
, map
), NULL
);
3664 if (XCBGlxGetPixelMapusvDataLength(reply
) == 0)
3665 (void)memcpy(values
, &reply
->datum
, sizeof(reply
->datum
));
3667 (void)memcpy(values
, XCBGlxGetPixelMapusvData(reply
), XCBGlxGetPixelMapusvDataLength(reply
) * sizeof(GLushort
));
3670 GLubyte
const * pc
= __glXSetupSingleRequest(gc
, X_GLsop_GetPixelMapusv
, cmdlen
);
3671 (void) memcpy((void *)(pc
+ 0), (void *)(&map
), 4);
3672 (void) __glXReadReply(dpy
, 2, values
, GL_FALSE
);
3673 UnlockDisplay(dpy
); SyncHandle();
3674 #endif /* USE_XCB */
3679 #define X_GLsop_GetPolygonStipple 128
3681 __indirect_glGetPolygonStipple(GLubyte
* mask
)
3683 __GLXcontext
* const gc
= __glXGetCurrentContext();
3684 const __GLXattribute
* const state
= gc
->client_state_private
;
3685 Display
* const dpy
= gc
->currentDpy
;
3686 const GLuint cmdlen
= 4;
3687 if (__builtin_expect(dpy
!= NULL
, 1)) {
3689 XCBConnection
*c
= XCBConnectionOfDisplay(dpy
);
3690 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
3691 XCBGlxGetPolygonStippleRep
*reply
= XCBGlxGetPolygonStippleReply(c
, XCBGlxGetPolygonStipple(c
, gc
->currentContextTag
, 0), NULL
);
3692 (void)memcpy(mask
, XCBGlxGetPolygonStippleData(reply
), XCBGlxGetPolygonStippleDataLength(reply
) * sizeof(GLubyte
));
3695 GLubyte
const * pc
= __glXSetupSingleRequest(gc
, X_GLsop_GetPolygonStipple
, cmdlen
);
3696 *(int32_t *)(pc
+ 0) = 0;
3697 __glXReadPixelReply(dpy
, gc
, 2, 32, 32, 1, GL_COLOR_INDEX
, GL_BITMAP
, mask
, GL_FALSE
);
3698 UnlockDisplay(dpy
); SyncHandle();
3699 #endif /* USE_XCB */
3704 #define X_GLsop_GetTexEnvfv 130
3706 __indirect_glGetTexEnvfv(GLenum target
, GLenum pname
, GLfloat
* params
)
3708 __GLXcontext
* const gc
= __glXGetCurrentContext();
3709 Display
* const dpy
= gc
->currentDpy
;
3710 const GLuint cmdlen
= 8;
3711 if (__builtin_expect(dpy
!= NULL
, 1)) {
3713 XCBConnection
*c
= XCBConnectionOfDisplay(dpy
);
3714 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
3715 XCBGlxGetTexEnvfvRep
*reply
= XCBGlxGetTexEnvfvReply(c
, XCBGlxGetTexEnvfv(c
, gc
->currentContextTag
, target
, pname
), NULL
);
3716 if (XCBGlxGetTexEnvfvDataLength(reply
) == 0)
3717 (void)memcpy(params
, &reply
->datum
, sizeof(reply
->datum
));
3719 (void)memcpy(params
, XCBGlxGetTexEnvfvData(reply
), XCBGlxGetTexEnvfvDataLength(reply
) * sizeof(GLfloat
));
3722 GLubyte
const * pc
= __glXSetupSingleRequest(gc
, X_GLsop_GetTexEnvfv
, cmdlen
);
3723 (void) memcpy((void *)(pc
+ 0), (void *)(&target
), 4);
3724 (void) memcpy((void *)(pc
+ 4), (void *)(&pname
), 4);
3725 (void) __glXReadReply(dpy
, 4, params
, GL_FALSE
);
3726 UnlockDisplay(dpy
); SyncHandle();
3727 #endif /* USE_XCB */
3732 #define X_GLsop_GetTexEnviv 131
3734 __indirect_glGetTexEnviv(GLenum target
, GLenum pname
, GLint
* params
)
3736 __GLXcontext
* const gc
= __glXGetCurrentContext();
3737 Display
* const dpy
= gc
->currentDpy
;
3738 const GLuint cmdlen
= 8;
3739 if (__builtin_expect(dpy
!= NULL
, 1)) {
3741 XCBConnection
*c
= XCBConnectionOfDisplay(dpy
);
3742 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
3743 XCBGlxGetTexEnvivRep
*reply
= XCBGlxGetTexEnvivReply(c
, XCBGlxGetTexEnviv(c
, gc
->currentContextTag
, target
, pname
), NULL
);
3744 if (XCBGlxGetTexEnvivDataLength(reply
) == 0)
3745 (void)memcpy(params
, &reply
->datum
, sizeof(reply
->datum
));
3747 (void)memcpy(params
, XCBGlxGetTexEnvivData(reply
), XCBGlxGetTexEnvivDataLength(reply
) * sizeof(GLint
));
3750 GLubyte
const * pc
= __glXSetupSingleRequest(gc
, X_GLsop_GetTexEnviv
, cmdlen
);
3751 (void) memcpy((void *)(pc
+ 0), (void *)(&target
), 4);
3752 (void) memcpy((void *)(pc
+ 4), (void *)(&pname
), 4);
3753 (void) __glXReadReply(dpy
, 4, params
, GL_FALSE
);
3754 UnlockDisplay(dpy
); SyncHandle();
3755 #endif /* USE_XCB */
3760 #define X_GLsop_GetTexGendv 132
3762 __indirect_glGetTexGendv(GLenum coord
, GLenum pname
, GLdouble
* params
)
3764 __GLXcontext
* const gc
= __glXGetCurrentContext();
3765 Display
* const dpy
= gc
->currentDpy
;
3766 const GLuint cmdlen
= 8;
3767 if (__builtin_expect(dpy
!= NULL
, 1)) {
3769 XCBConnection
*c
= XCBConnectionOfDisplay(dpy
);
3770 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
3771 XCBGlxGetTexGendvRep
*reply
= XCBGlxGetTexGendvReply(c
, XCBGlxGetTexGendv(c
, gc
->currentContextTag
, coord
, pname
), NULL
);
3772 if (XCBGlxGetTexGendvDataLength(reply
) == 0)
3773 (void)memcpy(params
, &reply
->datum
, sizeof(reply
->datum
));
3775 (void)memcpy(params
, XCBGlxGetTexGendvData(reply
), XCBGlxGetTexGendvDataLength(reply
) * sizeof(GLdouble
));
3778 GLubyte
const * pc
= __glXSetupSingleRequest(gc
, X_GLsop_GetTexGendv
, cmdlen
);
3779 (void) memcpy((void *)(pc
+ 0), (void *)(&coord
), 4);
3780 (void) memcpy((void *)(pc
+ 4), (void *)(&pname
), 4);
3781 (void) __glXReadReply(dpy
, 8, params
, GL_FALSE
);
3782 UnlockDisplay(dpy
); SyncHandle();
3783 #endif /* USE_XCB */
3788 #define X_GLsop_GetTexGenfv 133
3790 __indirect_glGetTexGenfv(GLenum coord
, GLenum pname
, GLfloat
* params
)
3792 __GLXcontext
* const gc
= __glXGetCurrentContext();
3793 Display
* const dpy
= gc
->currentDpy
;
3794 const GLuint cmdlen
= 8;
3795 if (__builtin_expect(dpy
!= NULL
, 1)) {
3797 XCBConnection
*c
= XCBConnectionOfDisplay(dpy
);
3798 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
3799 XCBGlxGetTexGenfvRep
*reply
= XCBGlxGetTexGenfvReply(c
, XCBGlxGetTexGenfv(c
, gc
->currentContextTag
, coord
, pname
), NULL
);
3800 if (XCBGlxGetTexGenfvDataLength(reply
) == 0)
3801 (void)memcpy(params
, &reply
->datum
, sizeof(reply
->datum
));
3803 (void)memcpy(params
, XCBGlxGetTexGenfvData(reply
), XCBGlxGetTexGenfvDataLength(reply
) * sizeof(GLfloat
));
3806 GLubyte
const * pc
= __glXSetupSingleRequest(gc
, X_GLsop_GetTexGenfv
, cmdlen
);
3807 (void) memcpy((void *)(pc
+ 0), (void *)(&coord
), 4);
3808 (void) memcpy((void *)(pc
+ 4), (void *)(&pname
), 4);
3809 (void) __glXReadReply(dpy
, 4, params
, GL_FALSE
);
3810 UnlockDisplay(dpy
); SyncHandle();
3811 #endif /* USE_XCB */
3816 #define X_GLsop_GetTexGeniv 134
3818 __indirect_glGetTexGeniv(GLenum coord
, GLenum pname
, GLint
* params
)
3820 __GLXcontext
* const gc
= __glXGetCurrentContext();
3821 Display
* const dpy
= gc
->currentDpy
;
3822 const GLuint cmdlen
= 8;
3823 if (__builtin_expect(dpy
!= NULL
, 1)) {
3825 XCBConnection
*c
= XCBConnectionOfDisplay(dpy
);
3826 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
3827 XCBGlxGetTexGenivRep
*reply
= XCBGlxGetTexGenivReply(c
, XCBGlxGetTexGeniv(c
, gc
->currentContextTag
, coord
, pname
), NULL
);
3828 if (XCBGlxGetTexGenivDataLength(reply
) == 0)
3829 (void)memcpy(params
, &reply
->datum
, sizeof(reply
->datum
));
3831 (void)memcpy(params
, XCBGlxGetTexGenivData(reply
), XCBGlxGetTexGenivDataLength(reply
) * sizeof(GLint
));
3834 GLubyte
const * pc
= __glXSetupSingleRequest(gc
, X_GLsop_GetTexGeniv
, cmdlen
);
3835 (void) memcpy((void *)(pc
+ 0), (void *)(&coord
), 4);
3836 (void) memcpy((void *)(pc
+ 4), (void *)(&pname
), 4);
3837 (void) __glXReadReply(dpy
, 4, params
, GL_FALSE
);
3838 UnlockDisplay(dpy
); SyncHandle();
3839 #endif /* USE_XCB */
3844 #define X_GLsop_GetTexImage 135
3846 __indirect_glGetTexImage(GLenum target
, GLint level
, GLenum format
, GLenum type
, GLvoid
* pixels
)
3848 __GLXcontext
* const gc
= __glXGetCurrentContext();
3849 const __GLXattribute
* const state
= gc
->client_state_private
;
3850 Display
* const dpy
= gc
->currentDpy
;
3851 const GLuint cmdlen
= 20;
3852 if (__builtin_expect(dpy
!= NULL
, 1)) {
3854 XCBConnection
*c
= XCBConnectionOfDisplay(dpy
);
3855 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
3856 XCBGlxGetTexImageRep
*reply
= XCBGlxGetTexImageReply(c
, XCBGlxGetTexImage(c
, gc
->currentContextTag
, target
, level
, format
, type
, state
->storePack
.swapEndian
), NULL
);
3857 (void)memcpy(pixels
, XCBGlxGetTexImageData(reply
), XCBGlxGetTexImageDataLength(reply
) * sizeof(GLvoid
));
3860 GLubyte
const * pc
= __glXSetupSingleRequest(gc
, X_GLsop_GetTexImage
, cmdlen
);
3861 (void) memcpy((void *)(pc
+ 0), (void *)(&target
), 4);
3862 (void) memcpy((void *)(pc
+ 4), (void *)(&level
), 4);
3863 (void) memcpy((void *)(pc
+ 8), (void *)(&format
), 4);
3864 (void) memcpy((void *)(pc
+ 12), (void *)(&type
), 4);
3865 *(int32_t *)(pc
+ 16) = 0;
3866 * (int8_t *)(pc
+ 16) = state
->storePack
.swapEndian
;
3867 __glXReadPixelReply(dpy
, gc
, 3, 0, 0, 0, format
, type
, pixels
, GL_TRUE
);
3868 UnlockDisplay(dpy
); SyncHandle();
3869 #endif /* USE_XCB */
3874 #define X_GLsop_GetTexParameterfv 136
3876 __indirect_glGetTexParameterfv(GLenum target
, GLenum pname
, GLfloat
* params
)
3878 __GLXcontext
* const gc
= __glXGetCurrentContext();
3879 Display
* const dpy
= gc
->currentDpy
;
3880 const GLuint cmdlen
= 8;
3881 if (__builtin_expect(dpy
!= NULL
, 1)) {
3883 XCBConnection
*c
= XCBConnectionOfDisplay(dpy
);
3884 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
3885 XCBGlxGetTexParameterfvRep
*reply
= XCBGlxGetTexParameterfvReply(c
, XCBGlxGetTexParameterfv(c
, gc
->currentContextTag
, target
, pname
), NULL
);
3886 if (XCBGlxGetTexParameterfvDataLength(reply
) == 0)
3887 (void)memcpy(params
, &reply
->datum
, sizeof(reply
->datum
));
3889 (void)memcpy(params
, XCBGlxGetTexParameterfvData(reply
), XCBGlxGetTexParameterfvDataLength(reply
) * sizeof(GLfloat
));
3892 GLubyte
const * pc
= __glXSetupSingleRequest(gc
, X_GLsop_GetTexParameterfv
, cmdlen
);
3893 (void) memcpy((void *)(pc
+ 0), (void *)(&target
), 4);
3894 (void) memcpy((void *)(pc
+ 4), (void *)(&pname
), 4);
3895 (void) __glXReadReply(dpy
, 4, params
, GL_FALSE
);
3896 UnlockDisplay(dpy
); SyncHandle();
3897 #endif /* USE_XCB */
3902 #define X_GLsop_GetTexParameteriv 137
3904 __indirect_glGetTexParameteriv(GLenum target
, GLenum pname
, GLint
* params
)
3906 __GLXcontext
* const gc
= __glXGetCurrentContext();
3907 Display
* const dpy
= gc
->currentDpy
;
3908 const GLuint cmdlen
= 8;
3909 if (__builtin_expect(dpy
!= NULL
, 1)) {
3911 XCBConnection
*c
= XCBConnectionOfDisplay(dpy
);
3912 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
3913 XCBGlxGetTexParameterivRep
*reply
= XCBGlxGetTexParameterivReply(c
, XCBGlxGetTexParameteriv(c
, gc
->currentContextTag
, target
, pname
), NULL
);
3914 if (XCBGlxGetTexParameterivDataLength(reply
) == 0)
3915 (void)memcpy(params
, &reply
->datum
, sizeof(reply
->datum
));
3917 (void)memcpy(params
, XCBGlxGetTexParameterivData(reply
), XCBGlxGetTexParameterivDataLength(reply
) * sizeof(GLint
));
3920 GLubyte
const * pc
= __glXSetupSingleRequest(gc
, X_GLsop_GetTexParameteriv
, cmdlen
);
3921 (void) memcpy((void *)(pc
+ 0), (void *)(&target
), 4);
3922 (void) memcpy((void *)(pc
+ 4), (void *)(&pname
), 4);
3923 (void) __glXReadReply(dpy
, 4, params
, GL_FALSE
);
3924 UnlockDisplay(dpy
); SyncHandle();
3925 #endif /* USE_XCB */
3930 #define X_GLsop_GetTexLevelParameterfv 138
3932 __indirect_glGetTexLevelParameterfv(GLenum target
, GLint level
, GLenum pname
, GLfloat
* params
)
3934 __GLXcontext
* const gc
= __glXGetCurrentContext();
3935 Display
* const dpy
= gc
->currentDpy
;
3936 const GLuint cmdlen
= 12;
3937 if (__builtin_expect(dpy
!= NULL
, 1)) {
3939 XCBConnection
*c
= XCBConnectionOfDisplay(dpy
);
3940 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
3941 XCBGlxGetTexLevelParameterfvRep
*reply
= XCBGlxGetTexLevelParameterfvReply(c
, XCBGlxGetTexLevelParameterfv(c
, gc
->currentContextTag
, target
, level
, pname
), NULL
);
3942 if (XCBGlxGetTexLevelParameterfvDataLength(reply
) == 0)
3943 (void)memcpy(params
, &reply
->datum
, sizeof(reply
->datum
));
3945 (void)memcpy(params
, XCBGlxGetTexLevelParameterfvData(reply
), XCBGlxGetTexLevelParameterfvDataLength(reply
) * sizeof(GLfloat
));
3948 GLubyte
const * pc
= __glXSetupSingleRequest(gc
, X_GLsop_GetTexLevelParameterfv
, cmdlen
);
3949 (void) memcpy((void *)(pc
+ 0), (void *)(&target
), 4);
3950 (void) memcpy((void *)(pc
+ 4), (void *)(&level
), 4);
3951 (void) memcpy((void *)(pc
+ 8), (void *)(&pname
), 4);
3952 (void) __glXReadReply(dpy
, 4, params
, GL_FALSE
);
3953 UnlockDisplay(dpy
); SyncHandle();
3954 #endif /* USE_XCB */
3959 #define X_GLsop_GetTexLevelParameteriv 139
3961 __indirect_glGetTexLevelParameteriv(GLenum target
, GLint level
, GLenum pname
, GLint
* params
)
3963 __GLXcontext
* const gc
= __glXGetCurrentContext();
3964 Display
* const dpy
= gc
->currentDpy
;
3965 const GLuint cmdlen
= 12;
3966 if (__builtin_expect(dpy
!= NULL
, 1)) {
3968 XCBConnection
*c
= XCBConnectionOfDisplay(dpy
);
3969 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
3970 XCBGlxGetTexLevelParameterivRep
*reply
= XCBGlxGetTexLevelParameterivReply(c
, XCBGlxGetTexLevelParameteriv(c
, gc
->currentContextTag
, target
, level
, pname
), NULL
);
3971 if (XCBGlxGetTexLevelParameterivDataLength(reply
) == 0)
3972 (void)memcpy(params
, &reply
->datum
, sizeof(reply
->datum
));
3974 (void)memcpy(params
, XCBGlxGetTexLevelParameterivData(reply
), XCBGlxGetTexLevelParameterivDataLength(reply
) * sizeof(GLint
));
3977 GLubyte
const * pc
= __glXSetupSingleRequest(gc
, X_GLsop_GetTexLevelParameteriv
, cmdlen
);
3978 (void) memcpy((void *)(pc
+ 0), (void *)(&target
), 4);
3979 (void) memcpy((void *)(pc
+ 4), (void *)(&level
), 4);
3980 (void) memcpy((void *)(pc
+ 8), (void *)(&pname
), 4);
3981 (void) __glXReadReply(dpy
, 4, params
, GL_FALSE
);
3982 UnlockDisplay(dpy
); SyncHandle();
3983 #endif /* USE_XCB */
3988 #define X_GLsop_IsList 141
3990 __indirect_glIsList(GLuint list
)
3992 __GLXcontext
* const gc
= __glXGetCurrentContext();
3993 Display
* const dpy
= gc
->currentDpy
;
3994 GLboolean retval
= (GLboolean
) 0;
3995 const GLuint cmdlen
= 4;
3996 if (__builtin_expect(dpy
!= NULL
, 1)) {
3998 XCBConnection
*c
= XCBConnectionOfDisplay(dpy
);
3999 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
4000 XCBGlxIsListRep
*reply
= XCBGlxIsListReply(c
, XCBGlxIsList(c
, gc
->currentContextTag
, list
), NULL
);
4001 retval
= reply
->ret_val
;
4004 GLubyte
const * pc
= __glXSetupSingleRequest(gc
, X_GLsop_IsList
, cmdlen
);
4005 (void) memcpy((void *)(pc
+ 0), (void *)(&list
), 4);
4006 retval
= (GLboolean
) __glXReadReply(dpy
, 0, NULL
, GL_FALSE
);
4007 UnlockDisplay(dpy
); SyncHandle();
4008 #endif /* USE_XCB */
4013 #define X_GLrop_DepthRange 174
4015 __indirect_glDepthRange(GLclampd zNear
, GLclampd zFar
)
4017 __GLXcontext
* const gc
= __glXGetCurrentContext();
4018 const GLuint cmdlen
= 20;
4019 emit_header(gc
->pc
, X_GLrop_DepthRange
, cmdlen
);
4020 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&zNear
), 8);
4021 (void) memcpy((void *)(gc
->pc
+ 12), (void *)(&zFar
), 8);
4023 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
4026 #define X_GLrop_Frustum 175
4028 __indirect_glFrustum(GLdouble left
, GLdouble right
, GLdouble bottom
, GLdouble top
, GLdouble zNear
, GLdouble zFar
)
4030 __GLXcontext
* const gc
= __glXGetCurrentContext();
4031 const GLuint cmdlen
= 52;
4032 emit_header(gc
->pc
, X_GLrop_Frustum
, cmdlen
);
4033 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&left
), 8);
4034 (void) memcpy((void *)(gc
->pc
+ 12), (void *)(&right
), 8);
4035 (void) memcpy((void *)(gc
->pc
+ 20), (void *)(&bottom
), 8);
4036 (void) memcpy((void *)(gc
->pc
+ 28), (void *)(&top
), 8);
4037 (void) memcpy((void *)(gc
->pc
+ 36), (void *)(&zNear
), 8);
4038 (void) memcpy((void *)(gc
->pc
+ 44), (void *)(&zFar
), 8);
4040 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
4043 #define X_GLrop_LoadIdentity 176
4045 __indirect_glLoadIdentity(void)
4047 __GLXcontext
* const gc
= __glXGetCurrentContext();
4048 const GLuint cmdlen
= 4;
4049 emit_header(gc
->pc
, X_GLrop_LoadIdentity
, cmdlen
);
4051 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
4054 #define X_GLrop_LoadMatrixf 177
4056 __indirect_glLoadMatrixf(const GLfloat
* m
)
4058 __GLXcontext
* const gc
= __glXGetCurrentContext();
4059 const GLuint cmdlen
= 68;
4060 emit_header(gc
->pc
, X_GLrop_LoadMatrixf
, cmdlen
);
4061 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(m
), 64);
4063 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
4066 #define X_GLrop_LoadMatrixd 178
4068 __indirect_glLoadMatrixd(const GLdouble
* m
)
4070 __GLXcontext
* const gc
= __glXGetCurrentContext();
4071 const GLuint cmdlen
= 132;
4072 emit_header(gc
->pc
, X_GLrop_LoadMatrixd
, cmdlen
);
4073 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(m
), 128);
4075 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
4078 #define X_GLrop_MatrixMode 179
4080 __indirect_glMatrixMode(GLenum mode
)
4082 __GLXcontext
* const gc
= __glXGetCurrentContext();
4083 const GLuint cmdlen
= 8;
4084 emit_header(gc
->pc
, X_GLrop_MatrixMode
, cmdlen
);
4085 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&mode
), 4);
4087 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
4090 #define X_GLrop_MultMatrixf 180
4092 __indirect_glMultMatrixf(const GLfloat
* m
)
4094 __GLXcontext
* const gc
= __glXGetCurrentContext();
4095 const GLuint cmdlen
= 68;
4096 emit_header(gc
->pc
, X_GLrop_MultMatrixf
, cmdlen
);
4097 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(m
), 64);
4099 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
4102 #define X_GLrop_MultMatrixd 181
4104 __indirect_glMultMatrixd(const GLdouble
* m
)
4106 __GLXcontext
* const gc
= __glXGetCurrentContext();
4107 const GLuint cmdlen
= 132;
4108 emit_header(gc
->pc
, X_GLrop_MultMatrixd
, cmdlen
);
4109 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(m
), 128);
4111 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
4114 #define X_GLrop_Ortho 182
4116 __indirect_glOrtho(GLdouble left
, GLdouble right
, GLdouble bottom
, GLdouble top
, GLdouble zNear
, GLdouble zFar
)
4118 __GLXcontext
* const gc
= __glXGetCurrentContext();
4119 const GLuint cmdlen
= 52;
4120 emit_header(gc
->pc
, X_GLrop_Ortho
, cmdlen
);
4121 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&left
), 8);
4122 (void) memcpy((void *)(gc
->pc
+ 12), (void *)(&right
), 8);
4123 (void) memcpy((void *)(gc
->pc
+ 20), (void *)(&bottom
), 8);
4124 (void) memcpy((void *)(gc
->pc
+ 28), (void *)(&top
), 8);
4125 (void) memcpy((void *)(gc
->pc
+ 36), (void *)(&zNear
), 8);
4126 (void) memcpy((void *)(gc
->pc
+ 44), (void *)(&zFar
), 8);
4128 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
4131 #define X_GLrop_PopMatrix 183
4133 __indirect_glPopMatrix(void)
4135 __GLXcontext
* const gc
= __glXGetCurrentContext();
4136 const GLuint cmdlen
= 4;
4137 emit_header(gc
->pc
, X_GLrop_PopMatrix
, cmdlen
);
4139 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
4142 #define X_GLrop_PushMatrix 184
4144 __indirect_glPushMatrix(void)
4146 __GLXcontext
* const gc
= __glXGetCurrentContext();
4147 const GLuint cmdlen
= 4;
4148 emit_header(gc
->pc
, X_GLrop_PushMatrix
, cmdlen
);
4150 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
4153 #define X_GLrop_Rotated 185
4155 __indirect_glRotated(GLdouble angle
, GLdouble x
, GLdouble y
, GLdouble z
)
4157 __GLXcontext
* const gc
= __glXGetCurrentContext();
4158 const GLuint cmdlen
= 36;
4159 emit_header(gc
->pc
, X_GLrop_Rotated
, cmdlen
);
4160 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&angle
), 8);
4161 (void) memcpy((void *)(gc
->pc
+ 12), (void *)(&x
), 8);
4162 (void) memcpy((void *)(gc
->pc
+ 20), (void *)(&y
), 8);
4163 (void) memcpy((void *)(gc
->pc
+ 28), (void *)(&z
), 8);
4165 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
4168 #define X_GLrop_Rotatef 186
4170 __indirect_glRotatef(GLfloat angle
, GLfloat x
, GLfloat y
, GLfloat z
)
4172 __GLXcontext
* const gc
= __glXGetCurrentContext();
4173 const GLuint cmdlen
= 20;
4174 emit_header(gc
->pc
, X_GLrop_Rotatef
, cmdlen
);
4175 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&angle
), 4);
4176 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(&x
), 4);
4177 (void) memcpy((void *)(gc
->pc
+ 12), (void *)(&y
), 4);
4178 (void) memcpy((void *)(gc
->pc
+ 16), (void *)(&z
), 4);
4180 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
4183 #define X_GLrop_Scaled 187
4185 __indirect_glScaled(GLdouble x
, GLdouble y
, GLdouble z
)
4187 __GLXcontext
* const gc
= __glXGetCurrentContext();
4188 const GLuint cmdlen
= 28;
4189 emit_header(gc
->pc
, X_GLrop_Scaled
, cmdlen
);
4190 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&x
), 8);
4191 (void) memcpy((void *)(gc
->pc
+ 12), (void *)(&y
), 8);
4192 (void) memcpy((void *)(gc
->pc
+ 20), (void *)(&z
), 8);
4194 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
4197 #define X_GLrop_Scalef 188
4199 __indirect_glScalef(GLfloat x
, GLfloat y
, GLfloat z
)
4201 __GLXcontext
* const gc
= __glXGetCurrentContext();
4202 const GLuint cmdlen
= 16;
4203 emit_header(gc
->pc
, X_GLrop_Scalef
, cmdlen
);
4204 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&x
), 4);
4205 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(&y
), 4);
4206 (void) memcpy((void *)(gc
->pc
+ 12), (void *)(&z
), 4);
4208 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
4211 #define X_GLrop_Translated 189
4213 __indirect_glTranslated(GLdouble x
, GLdouble y
, GLdouble z
)
4215 __GLXcontext
* const gc
= __glXGetCurrentContext();
4216 const GLuint cmdlen
= 28;
4217 emit_header(gc
->pc
, X_GLrop_Translated
, cmdlen
);
4218 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&x
), 8);
4219 (void) memcpy((void *)(gc
->pc
+ 12), (void *)(&y
), 8);
4220 (void) memcpy((void *)(gc
->pc
+ 20), (void *)(&z
), 8);
4222 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
4225 #define X_GLrop_Translatef 190
4227 __indirect_glTranslatef(GLfloat x
, GLfloat y
, GLfloat z
)
4229 __GLXcontext
* const gc
= __glXGetCurrentContext();
4230 const GLuint cmdlen
= 16;
4231 emit_header(gc
->pc
, X_GLrop_Translatef
, cmdlen
);
4232 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&x
), 4);
4233 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(&y
), 4);
4234 (void) memcpy((void *)(gc
->pc
+ 12), (void *)(&z
), 4);
4236 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
4239 #define X_GLrop_Viewport 191
4241 __indirect_glViewport(GLint x
, GLint y
, GLsizei width
, GLsizei height
)
4243 __GLXcontext
* const gc
= __glXGetCurrentContext();
4244 const GLuint cmdlen
= 20;
4245 emit_header(gc
->pc
, X_GLrop_Viewport
, cmdlen
);
4246 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&x
), 4);
4247 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(&y
), 4);
4248 (void) memcpy((void *)(gc
->pc
+ 12), (void *)(&width
), 4);
4249 (void) memcpy((void *)(gc
->pc
+ 16), (void *)(&height
), 4);
4251 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
4254 #define X_GLrop_BindTexture 4117
4256 __indirect_glBindTexture(GLenum target
, GLuint texture
)
4258 __GLXcontext
* const gc
= __glXGetCurrentContext();
4259 const GLuint cmdlen
= 12;
4260 emit_header(gc
->pc
, X_GLrop_BindTexture
, cmdlen
);
4261 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&target
), 4);
4262 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(&texture
), 4);
4264 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
4267 #define X_GLrop_Indexubv 194
4269 __indirect_glIndexub(GLubyte c
)
4271 __GLXcontext
* const gc
= __glXGetCurrentContext();
4272 const GLuint cmdlen
= 8;
4273 emit_header(gc
->pc
, X_GLrop_Indexubv
, cmdlen
);
4274 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&c
), 1);
4276 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
4279 #define X_GLrop_Indexubv 194
4281 __indirect_glIndexubv(const GLubyte
* c
)
4283 __GLXcontext
* const gc
= __glXGetCurrentContext();
4284 const GLuint cmdlen
= 8;
4285 emit_header(gc
->pc
, X_GLrop_Indexubv
, cmdlen
);
4286 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(c
), 1);
4288 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
4291 #define X_GLrop_PolygonOffset 192
4293 __indirect_glPolygonOffset(GLfloat factor
, GLfloat units
)
4295 __GLXcontext
* const gc
= __glXGetCurrentContext();
4296 const GLuint cmdlen
= 12;
4297 emit_header(gc
->pc
, X_GLrop_PolygonOffset
, cmdlen
);
4298 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&factor
), 4);
4299 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(&units
), 4);
4301 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
4304 #define X_GLsop_AreTexturesResident 143
4306 __indirect_glAreTexturesResident(GLsizei n
, const GLuint
* textures
, GLboolean
* residences
)
4308 __GLXcontext
* const gc
= __glXGetCurrentContext();
4309 Display
* const dpy
= gc
->currentDpy
;
4310 GLboolean retval
= (GLboolean
) 0;
4311 const GLuint cmdlen
= 4 + __GLX_PAD((n
* 4));
4312 if (__builtin_expect((n
>= 0) && (dpy
!= NULL
), 1)) {
4314 XCBConnection
*c
= XCBConnectionOfDisplay(dpy
);
4315 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
4316 XCBGlxAreTexturesResidentRep
*reply
= XCBGlxAreTexturesResidentReply(c
, XCBGlxAreTexturesResident(c
, gc
->currentContextTag
, n
, textures
), NULL
);
4317 (void)memcpy(residences
, XCBGlxAreTexturesResidentData(reply
), XCBGlxAreTexturesResidentDataLength(reply
) * sizeof(GLboolean
));
4318 retval
= reply
->ret_val
;
4321 GLubyte
const * pc
= __glXSetupSingleRequest(gc
, X_GLsop_AreTexturesResident
, cmdlen
);
4322 (void) memcpy((void *)(pc
+ 0), (void *)(&n
), 4);
4323 (void) memcpy((void *)(pc
+ 4), (void *)(textures
), (n
* 4));
4324 retval
= (GLboolean
) __glXReadReply(dpy
, 1, residences
, GL_TRUE
);
4325 UnlockDisplay(dpy
); SyncHandle();
4326 #endif /* USE_XCB */
4331 #define X_GLrop_CopyTexImage1D 4119
4333 __indirect_glCopyTexImage1D(GLenum target
, GLint level
, GLenum internalformat
, GLint x
, GLint y
, GLsizei width
, GLint border
)
4335 __GLXcontext
* const gc
= __glXGetCurrentContext();
4336 const GLuint cmdlen
= 32;
4337 emit_header(gc
->pc
, X_GLrop_CopyTexImage1D
, cmdlen
);
4338 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&target
), 4);
4339 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(&level
), 4);
4340 (void) memcpy((void *)(gc
->pc
+ 12), (void *)(&internalformat
), 4);
4341 (void) memcpy((void *)(gc
->pc
+ 16), (void *)(&x
), 4);
4342 (void) memcpy((void *)(gc
->pc
+ 20), (void *)(&y
), 4);
4343 (void) memcpy((void *)(gc
->pc
+ 24), (void *)(&width
), 4);
4344 (void) memcpy((void *)(gc
->pc
+ 28), (void *)(&border
), 4);
4346 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
4349 #define X_GLrop_CopyTexImage2D 4120
4351 __indirect_glCopyTexImage2D(GLenum target
, GLint level
, GLenum internalformat
, GLint x
, GLint y
, GLsizei width
, GLsizei height
, GLint border
)
4353 __GLXcontext
* const gc
= __glXGetCurrentContext();
4354 const GLuint cmdlen
= 36;
4355 emit_header(gc
->pc
, X_GLrop_CopyTexImage2D
, cmdlen
);
4356 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&target
), 4);
4357 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(&level
), 4);
4358 (void) memcpy((void *)(gc
->pc
+ 12), (void *)(&internalformat
), 4);
4359 (void) memcpy((void *)(gc
->pc
+ 16), (void *)(&x
), 4);
4360 (void) memcpy((void *)(gc
->pc
+ 20), (void *)(&y
), 4);
4361 (void) memcpy((void *)(gc
->pc
+ 24), (void *)(&width
), 4);
4362 (void) memcpy((void *)(gc
->pc
+ 28), (void *)(&height
), 4);
4363 (void) memcpy((void *)(gc
->pc
+ 32), (void *)(&border
), 4);
4365 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
4368 #define X_GLrop_CopyTexSubImage1D 4121
4370 __indirect_glCopyTexSubImage1D(GLenum target
, GLint level
, GLint xoffset
, GLint x
, GLint y
, GLsizei width
)
4372 __GLXcontext
* const gc
= __glXGetCurrentContext();
4373 const GLuint cmdlen
= 28;
4374 emit_header(gc
->pc
, X_GLrop_CopyTexSubImage1D
, cmdlen
);
4375 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&target
), 4);
4376 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(&level
), 4);
4377 (void) memcpy((void *)(gc
->pc
+ 12), (void *)(&xoffset
), 4);
4378 (void) memcpy((void *)(gc
->pc
+ 16), (void *)(&x
), 4);
4379 (void) memcpy((void *)(gc
->pc
+ 20), (void *)(&y
), 4);
4380 (void) memcpy((void *)(gc
->pc
+ 24), (void *)(&width
), 4);
4382 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
4385 #define X_GLrop_CopyTexSubImage2D 4122
4387 __indirect_glCopyTexSubImage2D(GLenum target
, GLint level
, GLint xoffset
, GLint yoffset
, GLint x
, GLint y
, GLsizei width
, GLsizei height
)
4389 __GLXcontext
* const gc
= __glXGetCurrentContext();
4390 const GLuint cmdlen
= 36;
4391 emit_header(gc
->pc
, X_GLrop_CopyTexSubImage2D
, cmdlen
);
4392 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&target
), 4);
4393 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(&level
), 4);
4394 (void) memcpy((void *)(gc
->pc
+ 12), (void *)(&xoffset
), 4);
4395 (void) memcpy((void *)(gc
->pc
+ 16), (void *)(&yoffset
), 4);
4396 (void) memcpy((void *)(gc
->pc
+ 20), (void *)(&x
), 4);
4397 (void) memcpy((void *)(gc
->pc
+ 24), (void *)(&y
), 4);
4398 (void) memcpy((void *)(gc
->pc
+ 28), (void *)(&width
), 4);
4399 (void) memcpy((void *)(gc
->pc
+ 32), (void *)(&height
), 4);
4401 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
4404 #define X_GLvop_DeleteTextures 12
4406 __indirect_glDeleteTextures(GLsizei n
, const GLuint
* textures
)
4408 __GLXcontext
* const gc
= __glXGetCurrentContext();
4409 Display
* const dpy
= gc
->currentDpy
;
4410 const GLuint cmdlen
= 4 + __GLX_PAD((n
* 4));
4411 if (__builtin_expect((n
>= 0) && (dpy
!= NULL
), 1)) {
4412 GLubyte
const * pc
= __glXSetupVendorRequest(gc
, X_GLXVendorPrivate
, X_GLvop_DeleteTextures
, cmdlen
);
4413 (void) memcpy((void *)(pc
+ 0), (void *)(&n
), 4);
4414 (void) memcpy((void *)(pc
+ 4), (void *)(textures
), (n
* 4));
4415 UnlockDisplay(dpy
); SyncHandle();
4420 #define X_GLsop_GenTextures 145
4422 __indirect_glGenTextures(GLsizei n
, GLuint
* textures
)
4424 __GLXcontext
* const gc
= __glXGetCurrentContext();
4425 Display
* const dpy
= gc
->currentDpy
;
4426 const GLuint cmdlen
= 4;
4427 if (__builtin_expect((n
>= 0) && (dpy
!= NULL
), 1)) {
4429 XCBConnection
*c
= XCBConnectionOfDisplay(dpy
);
4430 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
4431 XCBGlxGenTexturesRep
*reply
= XCBGlxGenTexturesReply(c
, XCBGlxGenTextures(c
, gc
->currentContextTag
, n
), NULL
);
4432 (void)memcpy(textures
, XCBGlxGenTexturesData(reply
), XCBGlxGenTexturesDataLength(reply
) * sizeof(GLuint
));
4435 GLubyte
const * pc
= __glXSetupSingleRequest(gc
, X_GLsop_GenTextures
, cmdlen
);
4436 (void) memcpy((void *)(pc
+ 0), (void *)(&n
), 4);
4437 (void) __glXReadReply(dpy
, 4, textures
, GL_TRUE
);
4438 UnlockDisplay(dpy
); SyncHandle();
4439 #endif /* USE_XCB */
4444 #define X_GLsop_IsTexture 146
4446 __indirect_glIsTexture(GLuint texture
)
4448 __GLXcontext
* const gc
= __glXGetCurrentContext();
4449 Display
* const dpy
= gc
->currentDpy
;
4450 GLboolean retval
= (GLboolean
) 0;
4451 const GLuint cmdlen
= 4;
4452 if (__builtin_expect(dpy
!= NULL
, 1)) {
4454 XCBConnection
*c
= XCBConnectionOfDisplay(dpy
);
4455 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
4456 XCBGlxIsTextureRep
*reply
= XCBGlxIsTextureReply(c
, XCBGlxIsTexture(c
, gc
->currentContextTag
, texture
), NULL
);
4457 retval
= reply
->ret_val
;
4460 GLubyte
const * pc
= __glXSetupSingleRequest(gc
, X_GLsop_IsTexture
, cmdlen
);
4461 (void) memcpy((void *)(pc
+ 0), (void *)(&texture
), 4);
4462 retval
= (GLboolean
) __glXReadReply(dpy
, 0, NULL
, GL_FALSE
);
4463 UnlockDisplay(dpy
); SyncHandle();
4464 #endif /* USE_XCB */
4469 #define X_GLrop_PrioritizeTextures 4118
4471 __indirect_glPrioritizeTextures(GLsizei n
, const GLuint
* textures
, const GLclampf
* priorities
)
4473 __GLXcontext
* const gc
= __glXGetCurrentContext();
4474 const GLuint cmdlen
= 8 + __GLX_PAD((n
* 4)) + __GLX_PAD((n
* 4));
4475 if (__builtin_expect(n
>= 0, 1)) {
4476 emit_header(gc
->pc
, X_GLrop_PrioritizeTextures
, cmdlen
);
4477 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&n
), 4);
4478 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(textures
), (n
* 4));
4479 (void) memcpy((void *)(gc
->pc
+ 8 + (n
* 4)), (void *)(priorities
), (n
* 4));
4481 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
4486 __glx_TexSubImage_1D2D( unsigned opcode
, unsigned dim
, GLenum target
, GLint level
, GLint xoffset
, GLint yoffset
, GLsizei width
, GLsizei height
, GLenum format
, GLenum type
, const GLvoid
* pixels
)
4488 __GLXcontext
* const gc
= __glXGetCurrentContext();
4489 const GLuint compsize
= (pixels
!= NULL
) ? __glImageSize(width
, height
, 1, format
, type
, target
) : 0;
4490 const GLuint cmdlen
= 60 + __GLX_PAD(compsize
);
4491 if (__builtin_expect(gc
->currentDpy
!= NULL
, 1)) {
4492 if (cmdlen
<= gc
->maxSmallRenderCommandSize
) {
4493 if ( (gc
->pc
+ cmdlen
) > gc
->bufEnd
) {
4494 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
4496 emit_header(gc
->pc
, opcode
, cmdlen
);
4497 (void) memcpy((void *)(gc
->pc
+ 24), (void *)(&target
), 4);
4498 (void) memcpy((void *)(gc
->pc
+ 28), (void *)(&level
), 4);
4499 (void) memcpy((void *)(gc
->pc
+ 32), (void *)(&xoffset
), 4);
4500 (void) memcpy((void *)(gc
->pc
+ 36), (void *)(&yoffset
), 4);
4501 (void) memcpy((void *)(gc
->pc
+ 40), (void *)(&width
), 4);
4502 (void) memcpy((void *)(gc
->pc
+ 44), (void *)(&height
), 4);
4503 (void) memcpy((void *)(gc
->pc
+ 48), (void *)(&format
), 4);
4504 (void) memcpy((void *)(gc
->pc
+ 52), (void *)(&type
), 4);
4505 (void) memcpy((void *)(gc
->pc
+ 56), (void *)((pixels
== NULL
) ? one
: zero
), 4);
4507 (*gc
->fillImage
)(gc
, dim
, width
, height
, 1, format
, type
, pixels
, gc
->pc
+ 60, gc
->pc
+ 4);
4510 (void) memcpy( gc
->pc
+ 4, default_pixel_store_2D
, default_pixel_store_2D_size
);
4513 if (gc
->pc
> gc
->limit
) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
4516 const GLint op
= opcode
;
4517 const GLuint cmdlenLarge
= cmdlen
+ 4;
4518 GLubyte
* const pc
= __glXFlushRenderBuffer(gc
, gc
->pc
);
4519 (void) memcpy((void *)(pc
+ 0), (void *)(&cmdlenLarge
), 4);
4520 (void) memcpy((void *)(pc
+ 4), (void *)(&op
), 4);
4521 (void) memcpy((void *)(pc
+ 28), (void *)(&target
), 4);
4522 (void) memcpy((void *)(pc
+ 32), (void *)(&level
), 4);
4523 (void) memcpy((void *)(pc
+ 36), (void *)(&xoffset
), 4);
4524 (void) memcpy((void *)(pc
+ 40), (void *)(&yoffset
), 4);
4525 (void) memcpy((void *)(pc
+ 44), (void *)(&width
), 4);
4526 (void) memcpy((void *)(pc
+ 48), (void *)(&height
), 4);
4527 (void) memcpy((void *)(pc
+ 52), (void *)(&format
), 4);
4528 (void) memcpy((void *)(pc
+ 56), (void *)(&type
), 4);
4529 (void) memcpy((void *)(pc
+ 60), zero
, 4);
4530 __glXSendLargeImage(gc
, compsize
, dim
, width
, height
, 1, format
, type
, pixels
, pc
+ 64, pc
+ 8);
4535 #define X_GLrop_TexSubImage1D 4099
4537 __indirect_glTexSubImage1D(GLenum target
, GLint level
, GLint xoffset
, GLsizei width
, GLenum format
, GLenum type
, const GLvoid
* pixels
)
4539 __glx_TexSubImage_1D2D(X_GLrop_TexSubImage1D
, 1, target
, level
, xoffset
, 1, width
, 1, format
, type
, pixels
);
4542 #define X_GLrop_TexSubImage2D 4100
4544 __indirect_glTexSubImage2D(GLenum target
, GLint level
, GLint xoffset
, GLint yoffset
, GLsizei width
, GLsizei height
, GLenum format
, GLenum type
, const GLvoid
* pixels
)
4546 __glx_TexSubImage_1D2D(X_GLrop_TexSubImage2D
, 2, target
, level
, xoffset
, yoffset
, width
, height
, format
, type
, pixels
);
4549 #define X_GLrop_BlendColor 4096
4551 __indirect_glBlendColor(GLclampf red
, GLclampf green
, GLclampf blue
, GLclampf alpha
)
4553 __GLXcontext
* const gc
= __glXGetCurrentContext();
4554 const GLuint cmdlen
= 20;
4555 emit_header(gc
->pc
, X_GLrop_BlendColor
, cmdlen
);
4556 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&red
), 4);
4557 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(&green
), 4);
4558 (void) memcpy((void *)(gc
->pc
+ 12), (void *)(&blue
), 4);
4559 (void) memcpy((void *)(gc
->pc
+ 16), (void *)(&alpha
), 4);
4561 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
4564 #define X_GLrop_BlendEquation 4097
4566 __indirect_glBlendEquation(GLenum mode
)
4568 __GLXcontext
* const gc
= __glXGetCurrentContext();
4569 const GLuint cmdlen
= 8;
4570 emit_header(gc
->pc
, X_GLrop_BlendEquation
, cmdlen
);
4571 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&mode
), 4);
4573 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
4576 #define X_GLrop_ColorTable 2053
4578 __indirect_glColorTable(GLenum target
, GLenum internalformat
, GLsizei width
, GLenum format
, GLenum type
, const GLvoid
* table
)
4580 __GLXcontext
* const gc
= __glXGetCurrentContext();
4581 const GLuint compsize
= (table
!= NULL
) ? __glImageSize(width
, 1, 1, format
, type
, target
) : 0;
4582 const GLuint cmdlen
= 44 + __GLX_PAD(compsize
);
4583 if (__builtin_expect(gc
->currentDpy
!= NULL
, 1)) {
4584 if (cmdlen
<= gc
->maxSmallRenderCommandSize
) {
4585 if ( (gc
->pc
+ cmdlen
) > gc
->bufEnd
) {
4586 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
4588 emit_header(gc
->pc
, X_GLrop_ColorTable
, cmdlen
);
4589 (void) memcpy((void *)(gc
->pc
+ 24), (void *)(&target
), 4);
4590 (void) memcpy((void *)(gc
->pc
+ 28), (void *)(&internalformat
), 4);
4591 (void) memcpy((void *)(gc
->pc
+ 32), (void *)(&width
), 4);
4592 (void) memcpy((void *)(gc
->pc
+ 36), (void *)(&format
), 4);
4593 (void) memcpy((void *)(gc
->pc
+ 40), (void *)(&type
), 4);
4595 (*gc
->fillImage
)(gc
, 1, width
, 1, 1, format
, type
, table
, gc
->pc
+ 44, gc
->pc
+ 4);
4598 (void) memcpy( gc
->pc
+ 4, default_pixel_store_1D
, default_pixel_store_1D_size
);
4601 if (gc
->pc
> gc
->limit
) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
4604 const GLint op
= X_GLrop_ColorTable
;
4605 const GLuint cmdlenLarge
= cmdlen
+ 4;
4606 GLubyte
* const pc
= __glXFlushRenderBuffer(gc
, gc
->pc
);
4607 (void) memcpy((void *)(pc
+ 0), (void *)(&cmdlenLarge
), 4);
4608 (void) memcpy((void *)(pc
+ 4), (void *)(&op
), 4);
4609 (void) memcpy((void *)(pc
+ 28), (void *)(&target
), 4);
4610 (void) memcpy((void *)(pc
+ 32), (void *)(&internalformat
), 4);
4611 (void) memcpy((void *)(pc
+ 36), (void *)(&width
), 4);
4612 (void) memcpy((void *)(pc
+ 40), (void *)(&format
), 4);
4613 (void) memcpy((void *)(pc
+ 44), (void *)(&type
), 4);
4614 __glXSendLargeImage(gc
, compsize
, 1, width
, 1, 1, format
, type
, table
, pc
+ 48, pc
+ 8);
4619 #define X_GLrop_ColorTableParameterfv 2054
4621 __indirect_glColorTableParameterfv(GLenum target
, GLenum pname
, const GLfloat
* params
)
4623 __GLXcontext
* const gc
= __glXGetCurrentContext();
4624 const GLuint compsize
= __glColorTableParameterfv_size(pname
);
4625 const GLuint cmdlen
= 12 + __GLX_PAD((compsize
* 4));
4626 emit_header(gc
->pc
, X_GLrop_ColorTableParameterfv
, cmdlen
);
4627 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&target
), 4);
4628 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(&pname
), 4);
4629 (void) memcpy((void *)(gc
->pc
+ 12), (void *)(params
), (compsize
* 4));
4631 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
4634 #define X_GLrop_ColorTableParameteriv 2055
4636 __indirect_glColorTableParameteriv(GLenum target
, GLenum pname
, const GLint
* params
)
4638 __GLXcontext
* const gc
= __glXGetCurrentContext();
4639 const GLuint compsize
= __glColorTableParameteriv_size(pname
);
4640 const GLuint cmdlen
= 12 + __GLX_PAD((compsize
* 4));
4641 emit_header(gc
->pc
, X_GLrop_ColorTableParameteriv
, cmdlen
);
4642 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&target
), 4);
4643 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(&pname
), 4);
4644 (void) memcpy((void *)(gc
->pc
+ 12), (void *)(params
), (compsize
* 4));
4646 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
4649 #define X_GLrop_CopyColorTable 2056
4651 __indirect_glCopyColorTable(GLenum target
, GLenum internalformat
, GLint x
, GLint y
, GLsizei width
)
4653 __GLXcontext
* const gc
= __glXGetCurrentContext();
4654 const GLuint cmdlen
= 24;
4655 emit_header(gc
->pc
, X_GLrop_CopyColorTable
, cmdlen
);
4656 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&target
), 4);
4657 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(&internalformat
), 4);
4658 (void) memcpy((void *)(gc
->pc
+ 12), (void *)(&x
), 4);
4659 (void) memcpy((void *)(gc
->pc
+ 16), (void *)(&y
), 4);
4660 (void) memcpy((void *)(gc
->pc
+ 20), (void *)(&width
), 4);
4662 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
4665 #define X_GLsop_GetColorTable 147
4667 __indirect_glGetColorTable(GLenum target
, GLenum format
, GLenum type
, GLvoid
* table
)
4669 __GLXcontext
* const gc
= __glXGetCurrentContext();
4670 const __GLXattribute
* const state
= gc
->client_state_private
;
4671 Display
* const dpy
= gc
->currentDpy
;
4672 const GLuint cmdlen
= 16;
4673 if (__builtin_expect(dpy
!= NULL
, 1)) {
4675 XCBConnection
*c
= XCBConnectionOfDisplay(dpy
);
4676 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
4677 XCBGlxGetColorTableRep
*reply
= XCBGlxGetColorTableReply(c
, XCBGlxGetColorTable(c
, gc
->currentContextTag
, target
, format
, type
, state
->storePack
.swapEndian
), NULL
);
4678 (void)memcpy(table
, XCBGlxGetColorTableData(reply
), XCBGlxGetColorTableDataLength(reply
) * sizeof(GLvoid
));
4681 GLubyte
const * pc
= __glXSetupSingleRequest(gc
, X_GLsop_GetColorTable
, cmdlen
);
4682 (void) memcpy((void *)(pc
+ 0), (void *)(&target
), 4);
4683 (void) memcpy((void *)(pc
+ 4), (void *)(&format
), 4);
4684 (void) memcpy((void *)(pc
+ 8), (void *)(&type
), 4);
4685 *(int32_t *)(pc
+ 12) = 0;
4686 * (int8_t *)(pc
+ 12) = state
->storePack
.swapEndian
;
4687 __glXReadPixelReply(dpy
, gc
, 1, 0, 0, 0, format
, type
, table
, GL_TRUE
);
4688 UnlockDisplay(dpy
); SyncHandle();
4689 #endif /* USE_XCB */
4694 #define X_GLsop_GetColorTableParameterfv 148
4696 __indirect_glGetColorTableParameterfv(GLenum target
, GLenum pname
, GLfloat
* params
)
4698 __GLXcontext
* const gc
= __glXGetCurrentContext();
4699 Display
* const dpy
= gc
->currentDpy
;
4700 const GLuint cmdlen
= 8;
4701 if (__builtin_expect(dpy
!= NULL
, 1)) {
4703 XCBConnection
*c
= XCBConnectionOfDisplay(dpy
);
4704 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
4705 XCBGlxGetColorTableParameterfvRep
*reply
= XCBGlxGetColorTableParameterfvReply(c
, XCBGlxGetColorTableParameterfv(c
, gc
->currentContextTag
, target
, pname
), NULL
);
4706 if (XCBGlxGetColorTableParameterfvDataLength(reply
) == 0)
4707 (void)memcpy(params
, &reply
->datum
, sizeof(reply
->datum
));
4709 (void)memcpy(params
, XCBGlxGetColorTableParameterfvData(reply
), XCBGlxGetColorTableParameterfvDataLength(reply
) * sizeof(GLfloat
));
4712 GLubyte
const * pc
= __glXSetupSingleRequest(gc
, X_GLsop_GetColorTableParameterfv
, cmdlen
);
4713 (void) memcpy((void *)(pc
+ 0), (void *)(&target
), 4);
4714 (void) memcpy((void *)(pc
+ 4), (void *)(&pname
), 4);
4715 (void) __glXReadReply(dpy
, 4, params
, GL_FALSE
);
4716 UnlockDisplay(dpy
); SyncHandle();
4717 #endif /* USE_XCB */
4722 #define X_GLsop_GetColorTableParameteriv 149
4724 __indirect_glGetColorTableParameteriv(GLenum target
, GLenum pname
, GLint
* params
)
4726 __GLXcontext
* const gc
= __glXGetCurrentContext();
4727 Display
* const dpy
= gc
->currentDpy
;
4728 const GLuint cmdlen
= 8;
4729 if (__builtin_expect(dpy
!= NULL
, 1)) {
4731 XCBConnection
*c
= XCBConnectionOfDisplay(dpy
);
4732 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
4733 XCBGlxGetColorTableParameterivRep
*reply
= XCBGlxGetColorTableParameterivReply(c
, XCBGlxGetColorTableParameteriv(c
, gc
->currentContextTag
, target
, pname
), NULL
);
4734 if (XCBGlxGetColorTableParameterivDataLength(reply
) == 0)
4735 (void)memcpy(params
, &reply
->datum
, sizeof(reply
->datum
));
4737 (void)memcpy(params
, XCBGlxGetColorTableParameterivData(reply
), XCBGlxGetColorTableParameterivDataLength(reply
) * sizeof(GLint
));
4740 GLubyte
const * pc
= __glXSetupSingleRequest(gc
, X_GLsop_GetColorTableParameteriv
, cmdlen
);
4741 (void) memcpy((void *)(pc
+ 0), (void *)(&target
), 4);
4742 (void) memcpy((void *)(pc
+ 4), (void *)(&pname
), 4);
4743 (void) __glXReadReply(dpy
, 4, params
, GL_FALSE
);
4744 UnlockDisplay(dpy
); SyncHandle();
4745 #endif /* USE_XCB */
4750 #define X_GLrop_ColorSubTable 195
4752 __indirect_glColorSubTable(GLenum target
, GLsizei start
, GLsizei count
, GLenum format
, GLenum type
, const GLvoid
* data
)
4754 __GLXcontext
* const gc
= __glXGetCurrentContext();
4755 const GLuint compsize
= (data
!= NULL
) ? __glImageSize(count
, 1, 1, format
, type
, target
) : 0;
4756 const GLuint cmdlen
= 44 + __GLX_PAD(compsize
);
4757 if (__builtin_expect(gc
->currentDpy
!= NULL
, 1)) {
4758 if (cmdlen
<= gc
->maxSmallRenderCommandSize
) {
4759 if ( (gc
->pc
+ cmdlen
) > gc
->bufEnd
) {
4760 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
4762 emit_header(gc
->pc
, X_GLrop_ColorSubTable
, cmdlen
);
4763 (void) memcpy((void *)(gc
->pc
+ 24), (void *)(&target
), 4);
4764 (void) memcpy((void *)(gc
->pc
+ 28), (void *)(&start
), 4);
4765 (void) memcpy((void *)(gc
->pc
+ 32), (void *)(&count
), 4);
4766 (void) memcpy((void *)(gc
->pc
+ 36), (void *)(&format
), 4);
4767 (void) memcpy((void *)(gc
->pc
+ 40), (void *)(&type
), 4);
4769 (*gc
->fillImage
)(gc
, 1, count
, 1, 1, format
, type
, data
, gc
->pc
+ 44, gc
->pc
+ 4);
4772 (void) memcpy( gc
->pc
+ 4, default_pixel_store_1D
, default_pixel_store_1D_size
);
4775 if (gc
->pc
> gc
->limit
) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
4778 const GLint op
= X_GLrop_ColorSubTable
;
4779 const GLuint cmdlenLarge
= cmdlen
+ 4;
4780 GLubyte
* const pc
= __glXFlushRenderBuffer(gc
, gc
->pc
);
4781 (void) memcpy((void *)(pc
+ 0), (void *)(&cmdlenLarge
), 4);
4782 (void) memcpy((void *)(pc
+ 4), (void *)(&op
), 4);
4783 (void) memcpy((void *)(pc
+ 28), (void *)(&target
), 4);
4784 (void) memcpy((void *)(pc
+ 32), (void *)(&start
), 4);
4785 (void) memcpy((void *)(pc
+ 36), (void *)(&count
), 4);
4786 (void) memcpy((void *)(pc
+ 40), (void *)(&format
), 4);
4787 (void) memcpy((void *)(pc
+ 44), (void *)(&type
), 4);
4788 __glXSendLargeImage(gc
, compsize
, 1, count
, 1, 1, format
, type
, data
, pc
+ 48, pc
+ 8);
4793 #define X_GLrop_CopyColorSubTable 196
4795 __indirect_glCopyColorSubTable(GLenum target
, GLsizei start
, GLint x
, GLint y
, GLsizei width
)
4797 __GLXcontext
* const gc
= __glXGetCurrentContext();
4798 const GLuint cmdlen
= 24;
4799 emit_header(gc
->pc
, X_GLrop_CopyColorSubTable
, cmdlen
);
4800 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&target
), 4);
4801 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(&start
), 4);
4802 (void) memcpy((void *)(gc
->pc
+ 12), (void *)(&x
), 4);
4803 (void) memcpy((void *)(gc
->pc
+ 16), (void *)(&y
), 4);
4804 (void) memcpy((void *)(gc
->pc
+ 20), (void *)(&width
), 4);
4806 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
4810 __glx_ConvolutionFilter_1D2D( unsigned opcode
, unsigned dim
, GLenum target
, GLenum internalformat
, GLsizei width
, GLsizei height
, GLenum format
, GLenum type
, const GLvoid
* image
)
4812 __GLXcontext
* const gc
= __glXGetCurrentContext();
4813 const GLuint compsize
= (image
!= NULL
) ? __glImageSize(width
, height
, 1, format
, type
, target
) : 0;
4814 const GLuint cmdlen
= 48 + __GLX_PAD(compsize
);
4815 if (__builtin_expect(gc
->currentDpy
!= NULL
, 1)) {
4816 if (cmdlen
<= gc
->maxSmallRenderCommandSize
) {
4817 if ( (gc
->pc
+ cmdlen
) > gc
->bufEnd
) {
4818 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
4820 emit_header(gc
->pc
, opcode
, cmdlen
);
4821 (void) memcpy((void *)(gc
->pc
+ 24), (void *)(&target
), 4);
4822 (void) memcpy((void *)(gc
->pc
+ 28), (void *)(&internalformat
), 4);
4823 (void) memcpy((void *)(gc
->pc
+ 32), (void *)(&width
), 4);
4824 (void) memcpy((void *)(gc
->pc
+ 36), (void *)(&height
), 4);
4825 (void) memcpy((void *)(gc
->pc
+ 40), (void *)(&format
), 4);
4826 (void) memcpy((void *)(gc
->pc
+ 44), (void *)(&type
), 4);
4828 (*gc
->fillImage
)(gc
, dim
, width
, height
, 1, format
, type
, image
, gc
->pc
+ 48, gc
->pc
+ 4);
4831 (void) memcpy( gc
->pc
+ 4, default_pixel_store_2D
, default_pixel_store_2D_size
);
4834 if (gc
->pc
> gc
->limit
) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
4837 const GLint op
= opcode
;
4838 const GLuint cmdlenLarge
= cmdlen
+ 4;
4839 GLubyte
* const pc
= __glXFlushRenderBuffer(gc
, gc
->pc
);
4840 (void) memcpy((void *)(pc
+ 0), (void *)(&cmdlenLarge
), 4);
4841 (void) memcpy((void *)(pc
+ 4), (void *)(&op
), 4);
4842 (void) memcpy((void *)(pc
+ 28), (void *)(&target
), 4);
4843 (void) memcpy((void *)(pc
+ 32), (void *)(&internalformat
), 4);
4844 (void) memcpy((void *)(pc
+ 36), (void *)(&width
), 4);
4845 (void) memcpy((void *)(pc
+ 40), (void *)(&height
), 4);
4846 (void) memcpy((void *)(pc
+ 44), (void *)(&format
), 4);
4847 (void) memcpy((void *)(pc
+ 48), (void *)(&type
), 4);
4848 __glXSendLargeImage(gc
, compsize
, dim
, width
, height
, 1, format
, type
, image
, pc
+ 52, pc
+ 8);
4853 #define X_GLrop_ConvolutionFilter1D 4101
4855 __indirect_glConvolutionFilter1D(GLenum target
, GLenum internalformat
, GLsizei width
, GLenum format
, GLenum type
, const GLvoid
* image
)
4857 __glx_ConvolutionFilter_1D2D(X_GLrop_ConvolutionFilter1D
, 1, target
, internalformat
, width
, 1, format
, type
, image
);
4860 #define X_GLrop_ConvolutionFilter2D 4102
4862 __indirect_glConvolutionFilter2D(GLenum target
, GLenum internalformat
, GLsizei width
, GLsizei height
, GLenum format
, GLenum type
, const GLvoid
* image
)
4864 __glx_ConvolutionFilter_1D2D(X_GLrop_ConvolutionFilter2D
, 2, target
, internalformat
, width
, height
, format
, type
, image
);
4867 #define X_GLrop_ConvolutionParameterf 4103
4869 __indirect_glConvolutionParameterf(GLenum target
, GLenum pname
, GLfloat params
)
4871 __GLXcontext
* const gc
= __glXGetCurrentContext();
4872 const GLuint cmdlen
= 16;
4873 emit_header(gc
->pc
, X_GLrop_ConvolutionParameterf
, cmdlen
);
4874 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&target
), 4);
4875 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(&pname
), 4);
4876 (void) memcpy((void *)(gc
->pc
+ 12), (void *)(¶ms
), 4);
4878 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
4881 #define X_GLrop_ConvolutionParameterfv 4104
4883 __indirect_glConvolutionParameterfv(GLenum target
, GLenum pname
, const GLfloat
* params
)
4885 __GLXcontext
* const gc
= __glXGetCurrentContext();
4886 const GLuint compsize
= __glConvolutionParameterfv_size(pname
);
4887 const GLuint cmdlen
= 12 + __GLX_PAD((compsize
* 4));
4888 emit_header(gc
->pc
, X_GLrop_ConvolutionParameterfv
, cmdlen
);
4889 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&target
), 4);
4890 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(&pname
), 4);
4891 (void) memcpy((void *)(gc
->pc
+ 12), (void *)(params
), (compsize
* 4));
4893 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
4896 #define X_GLrop_ConvolutionParameteri 4105
4898 __indirect_glConvolutionParameteri(GLenum target
, GLenum pname
, GLint params
)
4900 __GLXcontext
* const gc
= __glXGetCurrentContext();
4901 const GLuint cmdlen
= 16;
4902 emit_header(gc
->pc
, X_GLrop_ConvolutionParameteri
, cmdlen
);
4903 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&target
), 4);
4904 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(&pname
), 4);
4905 (void) memcpy((void *)(gc
->pc
+ 12), (void *)(¶ms
), 4);
4907 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
4910 #define X_GLrop_ConvolutionParameteriv 4106
4912 __indirect_glConvolutionParameteriv(GLenum target
, GLenum pname
, const GLint
* params
)
4914 __GLXcontext
* const gc
= __glXGetCurrentContext();
4915 const GLuint compsize
= __glConvolutionParameteriv_size(pname
);
4916 const GLuint cmdlen
= 12 + __GLX_PAD((compsize
* 4));
4917 emit_header(gc
->pc
, X_GLrop_ConvolutionParameteriv
, cmdlen
);
4918 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&target
), 4);
4919 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(&pname
), 4);
4920 (void) memcpy((void *)(gc
->pc
+ 12), (void *)(params
), (compsize
* 4));
4922 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
4925 #define X_GLrop_CopyConvolutionFilter1D 4107
4927 __indirect_glCopyConvolutionFilter1D(GLenum target
, GLenum internalformat
, GLint x
, GLint y
, GLsizei width
)
4929 __GLXcontext
* const gc
= __glXGetCurrentContext();
4930 const GLuint cmdlen
= 24;
4931 emit_header(gc
->pc
, X_GLrop_CopyConvolutionFilter1D
, cmdlen
);
4932 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&target
), 4);
4933 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(&internalformat
), 4);
4934 (void) memcpy((void *)(gc
->pc
+ 12), (void *)(&x
), 4);
4935 (void) memcpy((void *)(gc
->pc
+ 16), (void *)(&y
), 4);
4936 (void) memcpy((void *)(gc
->pc
+ 20), (void *)(&width
), 4);
4938 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
4941 #define X_GLrop_CopyConvolutionFilter2D 4108
4943 __indirect_glCopyConvolutionFilter2D(GLenum target
, GLenum internalformat
, GLint x
, GLint y
, GLsizei width
, GLsizei height
)
4945 __GLXcontext
* const gc
= __glXGetCurrentContext();
4946 const GLuint cmdlen
= 28;
4947 emit_header(gc
->pc
, X_GLrop_CopyConvolutionFilter2D
, cmdlen
);
4948 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&target
), 4);
4949 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(&internalformat
), 4);
4950 (void) memcpy((void *)(gc
->pc
+ 12), (void *)(&x
), 4);
4951 (void) memcpy((void *)(gc
->pc
+ 16), (void *)(&y
), 4);
4952 (void) memcpy((void *)(gc
->pc
+ 20), (void *)(&width
), 4);
4953 (void) memcpy((void *)(gc
->pc
+ 24), (void *)(&height
), 4);
4955 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
4958 #define X_GLsop_GetConvolutionFilter 150
4960 __indirect_glGetConvolutionFilter(GLenum target
, GLenum format
, GLenum type
, GLvoid
* image
)
4962 __GLXcontext
* const gc
= __glXGetCurrentContext();
4963 const __GLXattribute
* const state
= gc
->client_state_private
;
4964 Display
* const dpy
= gc
->currentDpy
;
4965 const GLuint cmdlen
= 16;
4966 if (__builtin_expect(dpy
!= NULL
, 1)) {
4968 XCBConnection
*c
= XCBConnectionOfDisplay(dpy
);
4969 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
4970 XCBGlxGetConvolutionFilterRep
*reply
= XCBGlxGetConvolutionFilterReply(c
, XCBGlxGetConvolutionFilter(c
, gc
->currentContextTag
, target
, format
, type
, state
->storePack
.swapEndian
), NULL
);
4971 (void)memcpy(image
, XCBGlxGetConvolutionFilterData(reply
), XCBGlxGetConvolutionFilterDataLength(reply
) * sizeof(GLvoid
));
4974 GLubyte
const * pc
= __glXSetupSingleRequest(gc
, X_GLsop_GetConvolutionFilter
, cmdlen
);
4975 (void) memcpy((void *)(pc
+ 0), (void *)(&target
), 4);
4976 (void) memcpy((void *)(pc
+ 4), (void *)(&format
), 4);
4977 (void) memcpy((void *)(pc
+ 8), (void *)(&type
), 4);
4978 *(int32_t *)(pc
+ 12) = 0;
4979 * (int8_t *)(pc
+ 12) = state
->storePack
.swapEndian
;
4980 __glXReadPixelReply(dpy
, gc
, 2, 0, 0, 0, format
, type
, image
, GL_TRUE
);
4981 UnlockDisplay(dpy
); SyncHandle();
4982 #endif /* USE_XCB */
4987 #define X_GLsop_GetConvolutionParameterfv 151
4989 __indirect_glGetConvolutionParameterfv(GLenum target
, GLenum pname
, GLfloat
* params
)
4991 __GLXcontext
* const gc
= __glXGetCurrentContext();
4992 Display
* const dpy
= gc
->currentDpy
;
4993 const GLuint cmdlen
= 8;
4994 if (__builtin_expect(dpy
!= NULL
, 1)) {
4996 XCBConnection
*c
= XCBConnectionOfDisplay(dpy
);
4997 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
4998 XCBGlxGetConvolutionParameterfvRep
*reply
= XCBGlxGetConvolutionParameterfvReply(c
, XCBGlxGetConvolutionParameterfv(c
, gc
->currentContextTag
, target
, pname
), NULL
);
4999 if (XCBGlxGetConvolutionParameterfvDataLength(reply
) == 0)
5000 (void)memcpy(params
, &reply
->datum
, sizeof(reply
->datum
));
5002 (void)memcpy(params
, XCBGlxGetConvolutionParameterfvData(reply
), XCBGlxGetConvolutionParameterfvDataLength(reply
) * sizeof(GLfloat
));
5005 GLubyte
const * pc
= __glXSetupSingleRequest(gc
, X_GLsop_GetConvolutionParameterfv
, cmdlen
);
5006 (void) memcpy((void *)(pc
+ 0), (void *)(&target
), 4);
5007 (void) memcpy((void *)(pc
+ 4), (void *)(&pname
), 4);
5008 (void) __glXReadReply(dpy
, 4, params
, GL_FALSE
);
5009 UnlockDisplay(dpy
); SyncHandle();
5010 #endif /* USE_XCB */
5015 #define X_GLsop_GetConvolutionParameteriv 152
5017 __indirect_glGetConvolutionParameteriv(GLenum target
, GLenum pname
, GLint
* params
)
5019 __GLXcontext
* const gc
= __glXGetCurrentContext();
5020 Display
* const dpy
= gc
->currentDpy
;
5021 const GLuint cmdlen
= 8;
5022 if (__builtin_expect(dpy
!= NULL
, 1)) {
5024 XCBConnection
*c
= XCBConnectionOfDisplay(dpy
);
5025 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
5026 XCBGlxGetConvolutionParameterivRep
*reply
= XCBGlxGetConvolutionParameterivReply(c
, XCBGlxGetConvolutionParameteriv(c
, gc
->currentContextTag
, target
, pname
), NULL
);
5027 if (XCBGlxGetConvolutionParameterivDataLength(reply
) == 0)
5028 (void)memcpy(params
, &reply
->datum
, sizeof(reply
->datum
));
5030 (void)memcpy(params
, XCBGlxGetConvolutionParameterivData(reply
), XCBGlxGetConvolutionParameterivDataLength(reply
) * sizeof(GLint
));
5033 GLubyte
const * pc
= __glXSetupSingleRequest(gc
, X_GLsop_GetConvolutionParameteriv
, cmdlen
);
5034 (void) memcpy((void *)(pc
+ 0), (void *)(&target
), 4);
5035 (void) memcpy((void *)(pc
+ 4), (void *)(&pname
), 4);
5036 (void) __glXReadReply(dpy
, 4, params
, GL_FALSE
);
5037 UnlockDisplay(dpy
); SyncHandle();
5038 #endif /* USE_XCB */
5043 #define X_GLsop_GetHistogram 154
5045 __indirect_glGetHistogram(GLenum target
, GLboolean reset
, GLenum format
, GLenum type
, GLvoid
* values
)
5047 __GLXcontext
* const gc
= __glXGetCurrentContext();
5048 const __GLXattribute
* const state
= gc
->client_state_private
;
5049 Display
* const dpy
= gc
->currentDpy
;
5050 const GLuint cmdlen
= 16;
5051 if (__builtin_expect(dpy
!= NULL
, 1)) {
5053 XCBConnection
*c
= XCBConnectionOfDisplay(dpy
);
5054 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
5055 XCBGlxGetHistogramRep
*reply
= XCBGlxGetHistogramReply(c
, XCBGlxGetHistogram(c
, gc
->currentContextTag
, target
, reset
, format
, type
, state
->storePack
.swapEndian
), NULL
);
5056 (void)memcpy(values
, XCBGlxGetHistogramData(reply
), XCBGlxGetHistogramDataLength(reply
) * sizeof(GLvoid
));
5059 GLubyte
const * pc
= __glXSetupSingleRequest(gc
, X_GLsop_GetHistogram
, cmdlen
);
5060 (void) memcpy((void *)(pc
+ 0), (void *)(&target
), 4);
5061 (void) memcpy((void *)(pc
+ 4), (void *)(&format
), 4);
5062 (void) memcpy((void *)(pc
+ 8), (void *)(&type
), 4);
5063 *(int32_t *)(pc
+ 12) = 0;
5064 * (int8_t *)(pc
+ 12) = state
->storePack
.swapEndian
;
5065 * (int8_t *)(pc
+ 13) = reset
;
5066 __glXReadPixelReply(dpy
, gc
, 1, 0, 0, 0, format
, type
, values
, GL_TRUE
);
5067 UnlockDisplay(dpy
); SyncHandle();
5068 #endif /* USE_XCB */
5073 #define X_GLsop_GetHistogramParameterfv 155
5075 __indirect_glGetHistogramParameterfv(GLenum target
, GLenum pname
, GLfloat
* params
)
5077 __GLXcontext
* const gc
= __glXGetCurrentContext();
5078 Display
* const dpy
= gc
->currentDpy
;
5079 const GLuint cmdlen
= 8;
5080 if (__builtin_expect(dpy
!= NULL
, 1)) {
5082 XCBConnection
*c
= XCBConnectionOfDisplay(dpy
);
5083 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
5084 XCBGlxGetHistogramParameterfvRep
*reply
= XCBGlxGetHistogramParameterfvReply(c
, XCBGlxGetHistogramParameterfv(c
, gc
->currentContextTag
, target
, pname
), NULL
);
5085 if (XCBGlxGetHistogramParameterfvDataLength(reply
) == 0)
5086 (void)memcpy(params
, &reply
->datum
, sizeof(reply
->datum
));
5088 (void)memcpy(params
, XCBGlxGetHistogramParameterfvData(reply
), XCBGlxGetHistogramParameterfvDataLength(reply
) * sizeof(GLfloat
));
5091 GLubyte
const * pc
= __glXSetupSingleRequest(gc
, X_GLsop_GetHistogramParameterfv
, cmdlen
);
5092 (void) memcpy((void *)(pc
+ 0), (void *)(&target
), 4);
5093 (void) memcpy((void *)(pc
+ 4), (void *)(&pname
), 4);
5094 (void) __glXReadReply(dpy
, 4, params
, GL_FALSE
);
5095 UnlockDisplay(dpy
); SyncHandle();
5096 #endif /* USE_XCB */
5101 #define X_GLsop_GetHistogramParameteriv 156
5103 __indirect_glGetHistogramParameteriv(GLenum target
, GLenum pname
, GLint
* params
)
5105 __GLXcontext
* const gc
= __glXGetCurrentContext();
5106 Display
* const dpy
= gc
->currentDpy
;
5107 const GLuint cmdlen
= 8;
5108 if (__builtin_expect(dpy
!= NULL
, 1)) {
5110 XCBConnection
*c
= XCBConnectionOfDisplay(dpy
);
5111 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
5112 XCBGlxGetHistogramParameterivRep
*reply
= XCBGlxGetHistogramParameterivReply(c
, XCBGlxGetHistogramParameteriv(c
, gc
->currentContextTag
, target
, pname
), NULL
);
5113 if (XCBGlxGetHistogramParameterivDataLength(reply
) == 0)
5114 (void)memcpy(params
, &reply
->datum
, sizeof(reply
->datum
));
5116 (void)memcpy(params
, XCBGlxGetHistogramParameterivData(reply
), XCBGlxGetHistogramParameterivDataLength(reply
) * sizeof(GLint
));
5119 GLubyte
const * pc
= __glXSetupSingleRequest(gc
, X_GLsop_GetHistogramParameteriv
, cmdlen
);
5120 (void) memcpy((void *)(pc
+ 0), (void *)(&target
), 4);
5121 (void) memcpy((void *)(pc
+ 4), (void *)(&pname
), 4);
5122 (void) __glXReadReply(dpy
, 4, params
, GL_FALSE
);
5123 UnlockDisplay(dpy
); SyncHandle();
5124 #endif /* USE_XCB */
5129 #define X_GLsop_GetMinmax 157
5131 __indirect_glGetMinmax(GLenum target
, GLboolean reset
, GLenum format
, GLenum type
, GLvoid
* values
)
5133 __GLXcontext
* const gc
= __glXGetCurrentContext();
5134 const __GLXattribute
* const state
= gc
->client_state_private
;
5135 Display
* const dpy
= gc
->currentDpy
;
5136 const GLuint cmdlen
= 16;
5137 if (__builtin_expect(dpy
!= NULL
, 1)) {
5139 XCBConnection
*c
= XCBConnectionOfDisplay(dpy
);
5140 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
5141 XCBGlxGetMinmaxRep
*reply
= XCBGlxGetMinmaxReply(c
, XCBGlxGetMinmax(c
, gc
->currentContextTag
, target
, reset
, format
, type
, state
->storePack
.swapEndian
), NULL
);
5142 (void)memcpy(values
, XCBGlxGetMinmaxData(reply
), XCBGlxGetMinmaxDataLength(reply
) * sizeof(GLvoid
));
5145 GLubyte
const * pc
= __glXSetupSingleRequest(gc
, X_GLsop_GetMinmax
, cmdlen
);
5146 (void) memcpy((void *)(pc
+ 0), (void *)(&target
), 4);
5147 (void) memcpy((void *)(pc
+ 4), (void *)(&format
), 4);
5148 (void) memcpy((void *)(pc
+ 8), (void *)(&type
), 4);
5149 *(int32_t *)(pc
+ 12) = 0;
5150 * (int8_t *)(pc
+ 12) = state
->storePack
.swapEndian
;
5151 * (int8_t *)(pc
+ 13) = reset
;
5152 __glXReadPixelReply(dpy
, gc
, 1, 2, 1, 1, format
, type
, values
, GL_FALSE
);
5153 UnlockDisplay(dpy
); SyncHandle();
5154 #endif /* USE_XCB */
5159 #define X_GLsop_GetMinmaxParameterfv 158
5161 __indirect_glGetMinmaxParameterfv(GLenum target
, GLenum pname
, GLfloat
* params
)
5163 __GLXcontext
* const gc
= __glXGetCurrentContext();
5164 Display
* const dpy
= gc
->currentDpy
;
5165 const GLuint cmdlen
= 8;
5166 if (__builtin_expect(dpy
!= NULL
, 1)) {
5168 XCBConnection
*c
= XCBConnectionOfDisplay(dpy
);
5169 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
5170 XCBGlxGetMinmaxParameterfvRep
*reply
= XCBGlxGetMinmaxParameterfvReply(c
, XCBGlxGetMinmaxParameterfv(c
, gc
->currentContextTag
, target
, pname
), NULL
);
5171 if (XCBGlxGetMinmaxParameterfvDataLength(reply
) == 0)
5172 (void)memcpy(params
, &reply
->datum
, sizeof(reply
->datum
));
5174 (void)memcpy(params
, XCBGlxGetMinmaxParameterfvData(reply
), XCBGlxGetMinmaxParameterfvDataLength(reply
) * sizeof(GLfloat
));
5177 GLubyte
const * pc
= __glXSetupSingleRequest(gc
, X_GLsop_GetMinmaxParameterfv
, cmdlen
);
5178 (void) memcpy((void *)(pc
+ 0), (void *)(&target
), 4);
5179 (void) memcpy((void *)(pc
+ 4), (void *)(&pname
), 4);
5180 (void) __glXReadReply(dpy
, 4, params
, GL_FALSE
);
5181 UnlockDisplay(dpy
); SyncHandle();
5182 #endif /* USE_XCB */
5187 #define X_GLsop_GetMinmaxParameteriv 159
5189 __indirect_glGetMinmaxParameteriv(GLenum target
, GLenum pname
, GLint
* params
)
5191 __GLXcontext
* const gc
= __glXGetCurrentContext();
5192 Display
* const dpy
= gc
->currentDpy
;
5193 const GLuint cmdlen
= 8;
5194 if (__builtin_expect(dpy
!= NULL
, 1)) {
5196 XCBConnection
*c
= XCBConnectionOfDisplay(dpy
);
5197 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
5198 XCBGlxGetMinmaxParameterivRep
*reply
= XCBGlxGetMinmaxParameterivReply(c
, XCBGlxGetMinmaxParameteriv(c
, gc
->currentContextTag
, target
, pname
), NULL
);
5199 if (XCBGlxGetMinmaxParameterivDataLength(reply
) == 0)
5200 (void)memcpy(params
, &reply
->datum
, sizeof(reply
->datum
));
5202 (void)memcpy(params
, XCBGlxGetMinmaxParameterivData(reply
), XCBGlxGetMinmaxParameterivDataLength(reply
) * sizeof(GLint
));
5205 GLubyte
const * pc
= __glXSetupSingleRequest(gc
, X_GLsop_GetMinmaxParameteriv
, cmdlen
);
5206 (void) memcpy((void *)(pc
+ 0), (void *)(&target
), 4);
5207 (void) memcpy((void *)(pc
+ 4), (void *)(&pname
), 4);
5208 (void) __glXReadReply(dpy
, 4, params
, GL_FALSE
);
5209 UnlockDisplay(dpy
); SyncHandle();
5210 #endif /* USE_XCB */
5215 #define X_GLrop_Histogram 4110
5217 __indirect_glHistogram(GLenum target
, GLsizei width
, GLenum internalformat
, GLboolean sink
)
5219 __GLXcontext
* const gc
= __glXGetCurrentContext();
5220 const GLuint cmdlen
= 20;
5221 emit_header(gc
->pc
, X_GLrop_Histogram
, cmdlen
);
5222 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&target
), 4);
5223 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(&width
), 4);
5224 (void) memcpy((void *)(gc
->pc
+ 12), (void *)(&internalformat
), 4);
5225 (void) memcpy((void *)(gc
->pc
+ 16), (void *)(&sink
), 1);
5227 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
5230 #define X_GLrop_Minmax 4111
5232 __indirect_glMinmax(GLenum target
, GLenum internalformat
, GLboolean sink
)
5234 __GLXcontext
* const gc
= __glXGetCurrentContext();
5235 const GLuint cmdlen
= 16;
5236 emit_header(gc
->pc
, X_GLrop_Minmax
, cmdlen
);
5237 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&target
), 4);
5238 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(&internalformat
), 4);
5239 (void) memcpy((void *)(gc
->pc
+ 12), (void *)(&sink
), 1);
5241 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
5244 #define X_GLrop_ResetHistogram 4112
5246 __indirect_glResetHistogram(GLenum target
)
5248 __GLXcontext
* const gc
= __glXGetCurrentContext();
5249 const GLuint cmdlen
= 8;
5250 emit_header(gc
->pc
, X_GLrop_ResetHistogram
, cmdlen
);
5251 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&target
), 4);
5253 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
5256 #define X_GLrop_ResetMinmax 4113
5258 __indirect_glResetMinmax(GLenum target
)
5260 __GLXcontext
* const gc
= __glXGetCurrentContext();
5261 const GLuint cmdlen
= 8;
5262 emit_header(gc
->pc
, X_GLrop_ResetMinmax
, cmdlen
);
5263 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&target
), 4);
5265 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
5269 __glx_TexImage_3D4D( unsigned opcode
, unsigned dim
, GLenum target
, GLint level
, GLint internalformat
, GLsizei width
, GLsizei height
, GLsizei depth
, GLsizei extent
, GLint border
, GLenum format
, GLenum type
, const GLvoid
* pixels
)
5271 __GLXcontext
* const gc
= __glXGetCurrentContext();
5272 const GLuint compsize
= (pixels
!= NULL
) ? __glImageSize(width
, height
, depth
, format
, type
, target
) : 0;
5273 const GLuint cmdlen
= 84 + __GLX_PAD(compsize
);
5274 if (__builtin_expect(gc
->currentDpy
!= NULL
, 1)) {
5275 if (cmdlen
<= gc
->maxSmallRenderCommandSize
) {
5276 if ( (gc
->pc
+ cmdlen
) > gc
->bufEnd
) {
5277 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
5279 emit_header(gc
->pc
, opcode
, cmdlen
);
5280 (void) memcpy((void *)(gc
->pc
+ 40), (void *)(&target
), 4);
5281 (void) memcpy((void *)(gc
->pc
+ 44), (void *)(&level
), 4);
5282 (void) memcpy((void *)(gc
->pc
+ 48), (void *)(&internalformat
), 4);
5283 (void) memcpy((void *)(gc
->pc
+ 52), (void *)(&width
), 4);
5284 (void) memcpy((void *)(gc
->pc
+ 56), (void *)(&height
), 4);
5285 (void) memcpy((void *)(gc
->pc
+ 60), (void *)(&depth
), 4);
5286 (void) memcpy((void *)(gc
->pc
+ 64), (void *)(&extent
), 4);
5287 (void) memcpy((void *)(gc
->pc
+ 68), (void *)(&border
), 4);
5288 (void) memcpy((void *)(gc
->pc
+ 72), (void *)(&format
), 4);
5289 (void) memcpy((void *)(gc
->pc
+ 76), (void *)(&type
), 4);
5290 (void) memcpy((void *)(gc
->pc
+ 80), (void *)((pixels
== NULL
) ? one
: zero
), 4);
5292 (*gc
->fillImage
)(gc
, dim
, width
, height
, depth
, format
, type
, pixels
, gc
->pc
+ 84, gc
->pc
+ 4);
5295 (void) memcpy( gc
->pc
+ 4, default_pixel_store_4D
, default_pixel_store_4D_size
);
5298 if (gc
->pc
> gc
->limit
) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
5301 const GLint op
= opcode
;
5302 const GLuint cmdlenLarge
= cmdlen
+ 4;
5303 GLubyte
* const pc
= __glXFlushRenderBuffer(gc
, gc
->pc
);
5304 (void) memcpy((void *)(pc
+ 0), (void *)(&cmdlenLarge
), 4);
5305 (void) memcpy((void *)(pc
+ 4), (void *)(&op
), 4);
5306 (void) memcpy((void *)(pc
+ 44), (void *)(&target
), 4);
5307 (void) memcpy((void *)(pc
+ 48), (void *)(&level
), 4);
5308 (void) memcpy((void *)(pc
+ 52), (void *)(&internalformat
), 4);
5309 (void) memcpy((void *)(pc
+ 56), (void *)(&width
), 4);
5310 (void) memcpy((void *)(pc
+ 60), (void *)(&height
), 4);
5311 (void) memcpy((void *)(pc
+ 64), (void *)(&depth
), 4);
5312 (void) memcpy((void *)(pc
+ 68), (void *)(&extent
), 4);
5313 (void) memcpy((void *)(pc
+ 72), (void *)(&border
), 4);
5314 (void) memcpy((void *)(pc
+ 76), (void *)(&format
), 4);
5315 (void) memcpy((void *)(pc
+ 80), (void *)(&type
), 4);
5316 (void) memcpy((void *)(pc
+ 84), zero
, 4);
5317 __glXSendLargeImage(gc
, compsize
, dim
, width
, height
, depth
, format
, type
, pixels
, pc
+ 88, pc
+ 8);
5322 #define X_GLrop_TexImage3D 4114
5324 __indirect_glTexImage3D(GLenum target
, GLint level
, GLint internalformat
, GLsizei width
, GLsizei height
, GLsizei depth
, GLint border
, GLenum format
, GLenum type
, const GLvoid
* pixels
)
5326 __glx_TexImage_3D4D(X_GLrop_TexImage3D
, 3, target
, level
, internalformat
, width
, height
, depth
, 1, border
, format
, type
, pixels
);
5330 __glx_TexSubImage_3D4D( unsigned opcode
, unsigned dim
, GLenum target
, GLint level
, GLint xoffset
, GLint yoffset
, GLint zoffset
, GLint woffset
, GLsizei width
, GLsizei height
, GLsizei depth
, GLsizei extent
, GLenum format
, GLenum type
, const GLvoid
* pixels
)
5332 __GLXcontext
* const gc
= __glXGetCurrentContext();
5333 const GLuint compsize
= (pixels
!= NULL
) ? __glImageSize(width
, height
, depth
, format
, type
, target
) : 0;
5334 const GLuint cmdlen
= 92 + __GLX_PAD(compsize
);
5335 if (__builtin_expect(gc
->currentDpy
!= NULL
, 1)) {
5336 if (cmdlen
<= gc
->maxSmallRenderCommandSize
) {
5337 if ( (gc
->pc
+ cmdlen
) > gc
->bufEnd
) {
5338 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
5340 emit_header(gc
->pc
, opcode
, cmdlen
);
5341 (void) memcpy((void *)(gc
->pc
+ 40), (void *)(&target
), 4);
5342 (void) memcpy((void *)(gc
->pc
+ 44), (void *)(&level
), 4);
5343 (void) memcpy((void *)(gc
->pc
+ 48), (void *)(&xoffset
), 4);
5344 (void) memcpy((void *)(gc
->pc
+ 52), (void *)(&yoffset
), 4);
5345 (void) memcpy((void *)(gc
->pc
+ 56), (void *)(&zoffset
), 4);
5346 (void) memcpy((void *)(gc
->pc
+ 60), (void *)(&woffset
), 4);
5347 (void) memcpy((void *)(gc
->pc
+ 64), (void *)(&width
), 4);
5348 (void) memcpy((void *)(gc
->pc
+ 68), (void *)(&height
), 4);
5349 (void) memcpy((void *)(gc
->pc
+ 72), (void *)(&depth
), 4);
5350 (void) memcpy((void *)(gc
->pc
+ 76), (void *)(&extent
), 4);
5351 (void) memcpy((void *)(gc
->pc
+ 80), (void *)(&format
), 4);
5352 (void) memcpy((void *)(gc
->pc
+ 84), (void *)(&type
), 4);
5353 (void) memcpy((void *)(gc
->pc
+ 88), (void *)((pixels
== NULL
) ? one
: zero
), 4);
5355 (*gc
->fillImage
)(gc
, dim
, width
, height
, depth
, format
, type
, pixels
, gc
->pc
+ 92, gc
->pc
+ 4);
5358 (void) memcpy( gc
->pc
+ 4, default_pixel_store_4D
, default_pixel_store_4D_size
);
5361 if (gc
->pc
> gc
->limit
) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
5364 const GLint op
= opcode
;
5365 const GLuint cmdlenLarge
= cmdlen
+ 4;
5366 GLubyte
* const pc
= __glXFlushRenderBuffer(gc
, gc
->pc
);
5367 (void) memcpy((void *)(pc
+ 0), (void *)(&cmdlenLarge
), 4);
5368 (void) memcpy((void *)(pc
+ 4), (void *)(&op
), 4);
5369 (void) memcpy((void *)(pc
+ 44), (void *)(&target
), 4);
5370 (void) memcpy((void *)(pc
+ 48), (void *)(&level
), 4);
5371 (void) memcpy((void *)(pc
+ 52), (void *)(&xoffset
), 4);
5372 (void) memcpy((void *)(pc
+ 56), (void *)(&yoffset
), 4);
5373 (void) memcpy((void *)(pc
+ 60), (void *)(&zoffset
), 4);
5374 (void) memcpy((void *)(pc
+ 64), (void *)(&woffset
), 4);
5375 (void) memcpy((void *)(pc
+ 68), (void *)(&width
), 4);
5376 (void) memcpy((void *)(pc
+ 72), (void *)(&height
), 4);
5377 (void) memcpy((void *)(pc
+ 76), (void *)(&depth
), 4);
5378 (void) memcpy((void *)(pc
+ 80), (void *)(&extent
), 4);
5379 (void) memcpy((void *)(pc
+ 84), (void *)(&format
), 4);
5380 (void) memcpy((void *)(pc
+ 88), (void *)(&type
), 4);
5381 (void) memcpy((void *)(pc
+ 92), zero
, 4);
5382 __glXSendLargeImage(gc
, compsize
, dim
, width
, height
, depth
, format
, type
, pixels
, pc
+ 96, pc
+ 8);
5387 #define X_GLrop_TexSubImage3D 4115
5389 __indirect_glTexSubImage3D(GLenum target
, GLint level
, GLint xoffset
, GLint yoffset
, GLint zoffset
, GLsizei width
, GLsizei height
, GLsizei depth
, GLenum format
, GLenum type
, const GLvoid
* pixels
)
5391 __glx_TexSubImage_3D4D(X_GLrop_TexSubImage3D
, 3, target
, level
, xoffset
, yoffset
, zoffset
, 1, width
, height
, depth
, 1, format
, type
, pixels
);
5394 #define X_GLrop_CopyTexSubImage3D 4123
5396 __indirect_glCopyTexSubImage3D(GLenum target
, GLint level
, GLint xoffset
, GLint yoffset
, GLint zoffset
, GLint x
, GLint y
, GLsizei width
, GLsizei height
)
5398 __GLXcontext
* const gc
= __glXGetCurrentContext();
5399 const GLuint cmdlen
= 40;
5400 emit_header(gc
->pc
, X_GLrop_CopyTexSubImage3D
, cmdlen
);
5401 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&target
), 4);
5402 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(&level
), 4);
5403 (void) memcpy((void *)(gc
->pc
+ 12), (void *)(&xoffset
), 4);
5404 (void) memcpy((void *)(gc
->pc
+ 16), (void *)(&yoffset
), 4);
5405 (void) memcpy((void *)(gc
->pc
+ 20), (void *)(&zoffset
), 4);
5406 (void) memcpy((void *)(gc
->pc
+ 24), (void *)(&x
), 4);
5407 (void) memcpy((void *)(gc
->pc
+ 28), (void *)(&y
), 4);
5408 (void) memcpy((void *)(gc
->pc
+ 32), (void *)(&width
), 4);
5409 (void) memcpy((void *)(gc
->pc
+ 36), (void *)(&height
), 4);
5411 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
5414 #define X_GLrop_ActiveTextureARB 197
5416 __indirect_glActiveTextureARB(GLenum texture
)
5418 __GLXcontext
* const gc
= __glXGetCurrentContext();
5419 const GLuint cmdlen
= 8;
5420 emit_header(gc
->pc
, X_GLrop_ActiveTextureARB
, cmdlen
);
5421 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&texture
), 4);
5423 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
5426 #define X_GLrop_MultiTexCoord1dvARB 198
5428 __indirect_glMultiTexCoord1dARB(GLenum target
, GLdouble s
)
5430 __GLXcontext
* const gc
= __glXGetCurrentContext();
5431 const GLuint cmdlen
= 16;
5432 emit_header(gc
->pc
, X_GLrop_MultiTexCoord1dvARB
, cmdlen
);
5433 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&s
), 8);
5434 (void) memcpy((void *)(gc
->pc
+ 12), (void *)(&target
), 4);
5436 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
5439 #define X_GLrop_MultiTexCoord1dvARB 198
5441 __indirect_glMultiTexCoord1dvARB(GLenum target
, const GLdouble
* v
)
5443 __GLXcontext
* const gc
= __glXGetCurrentContext();
5444 const GLuint cmdlen
= 16;
5445 emit_header(gc
->pc
, X_GLrop_MultiTexCoord1dvARB
, cmdlen
);
5446 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(v
), 8);
5447 (void) memcpy((void *)(gc
->pc
+ 12), (void *)(&target
), 4);
5449 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
5452 #define X_GLrop_MultiTexCoord1fvARB 199
5454 __indirect_glMultiTexCoord1fARB(GLenum target
, GLfloat s
)
5456 __GLXcontext
* const gc
= __glXGetCurrentContext();
5457 const GLuint cmdlen
= 12;
5458 emit_header(gc
->pc
, X_GLrop_MultiTexCoord1fvARB
, cmdlen
);
5459 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&target
), 4);
5460 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(&s
), 4);
5462 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
5465 #define X_GLrop_MultiTexCoord1fvARB 199
5467 __indirect_glMultiTexCoord1fvARB(GLenum target
, const GLfloat
* v
)
5469 __GLXcontext
* const gc
= __glXGetCurrentContext();
5470 const GLuint cmdlen
= 12;
5471 emit_header(gc
->pc
, X_GLrop_MultiTexCoord1fvARB
, cmdlen
);
5472 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&target
), 4);
5473 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(v
), 4);
5475 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
5478 #define X_GLrop_MultiTexCoord1ivARB 200
5480 __indirect_glMultiTexCoord1iARB(GLenum target
, GLint s
)
5482 __GLXcontext
* const gc
= __glXGetCurrentContext();
5483 const GLuint cmdlen
= 12;
5484 emit_header(gc
->pc
, X_GLrop_MultiTexCoord1ivARB
, cmdlen
);
5485 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&target
), 4);
5486 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(&s
), 4);
5488 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
5491 #define X_GLrop_MultiTexCoord1ivARB 200
5493 __indirect_glMultiTexCoord1ivARB(GLenum target
, const GLint
* v
)
5495 __GLXcontext
* const gc
= __glXGetCurrentContext();
5496 const GLuint cmdlen
= 12;
5497 emit_header(gc
->pc
, X_GLrop_MultiTexCoord1ivARB
, cmdlen
);
5498 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&target
), 4);
5499 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(v
), 4);
5501 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
5504 #define X_GLrop_MultiTexCoord1svARB 201
5506 __indirect_glMultiTexCoord1sARB(GLenum target
, GLshort s
)
5508 __GLXcontext
* const gc
= __glXGetCurrentContext();
5509 const GLuint cmdlen
= 12;
5510 emit_header(gc
->pc
, X_GLrop_MultiTexCoord1svARB
, cmdlen
);
5511 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&target
), 4);
5512 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(&s
), 2);
5514 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
5517 #define X_GLrop_MultiTexCoord1svARB 201
5519 __indirect_glMultiTexCoord1svARB(GLenum target
, const GLshort
* v
)
5521 __GLXcontext
* const gc
= __glXGetCurrentContext();
5522 const GLuint cmdlen
= 12;
5523 emit_header(gc
->pc
, X_GLrop_MultiTexCoord1svARB
, cmdlen
);
5524 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&target
), 4);
5525 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(v
), 2);
5527 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
5530 #define X_GLrop_MultiTexCoord2dvARB 202
5532 __indirect_glMultiTexCoord2dARB(GLenum target
, GLdouble s
, GLdouble t
)
5534 __GLXcontext
* const gc
= __glXGetCurrentContext();
5535 const GLuint cmdlen
= 24;
5536 emit_header(gc
->pc
, X_GLrop_MultiTexCoord2dvARB
, cmdlen
);
5537 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&s
), 8);
5538 (void) memcpy((void *)(gc
->pc
+ 12), (void *)(&t
), 8);
5539 (void) memcpy((void *)(gc
->pc
+ 20), (void *)(&target
), 4);
5541 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
5544 #define X_GLrop_MultiTexCoord2dvARB 202
5546 __indirect_glMultiTexCoord2dvARB(GLenum target
, const GLdouble
* v
)
5548 __GLXcontext
* const gc
= __glXGetCurrentContext();
5549 const GLuint cmdlen
= 24;
5550 emit_header(gc
->pc
, X_GLrop_MultiTexCoord2dvARB
, cmdlen
);
5551 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(v
), 16);
5552 (void) memcpy((void *)(gc
->pc
+ 20), (void *)(&target
), 4);
5554 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
5557 #define X_GLrop_MultiTexCoord2fvARB 203
5559 __indirect_glMultiTexCoord2fARB(GLenum target
, GLfloat s
, GLfloat t
)
5561 __GLXcontext
* const gc
= __glXGetCurrentContext();
5562 const GLuint cmdlen
= 16;
5563 emit_header(gc
->pc
, X_GLrop_MultiTexCoord2fvARB
, cmdlen
);
5564 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&target
), 4);
5565 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(&s
), 4);
5566 (void) memcpy((void *)(gc
->pc
+ 12), (void *)(&t
), 4);
5568 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
5571 #define X_GLrop_MultiTexCoord2fvARB 203
5573 __indirect_glMultiTexCoord2fvARB(GLenum target
, const GLfloat
* v
)
5575 __GLXcontext
* const gc
= __glXGetCurrentContext();
5576 const GLuint cmdlen
= 16;
5577 emit_header(gc
->pc
, X_GLrop_MultiTexCoord2fvARB
, cmdlen
);
5578 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&target
), 4);
5579 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(v
), 8);
5581 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
5584 #define X_GLrop_MultiTexCoord2ivARB 204
5586 __indirect_glMultiTexCoord2iARB(GLenum target
, GLint s
, GLint t
)
5588 __GLXcontext
* const gc
= __glXGetCurrentContext();
5589 const GLuint cmdlen
= 16;
5590 emit_header(gc
->pc
, X_GLrop_MultiTexCoord2ivARB
, cmdlen
);
5591 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&target
), 4);
5592 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(&s
), 4);
5593 (void) memcpy((void *)(gc
->pc
+ 12), (void *)(&t
), 4);
5595 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
5598 #define X_GLrop_MultiTexCoord2ivARB 204
5600 __indirect_glMultiTexCoord2ivARB(GLenum target
, const GLint
* v
)
5602 __GLXcontext
* const gc
= __glXGetCurrentContext();
5603 const GLuint cmdlen
= 16;
5604 emit_header(gc
->pc
, X_GLrop_MultiTexCoord2ivARB
, cmdlen
);
5605 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&target
), 4);
5606 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(v
), 8);
5608 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
5611 #define X_GLrop_MultiTexCoord2svARB 205
5613 __indirect_glMultiTexCoord2sARB(GLenum target
, GLshort s
, GLshort t
)
5615 __GLXcontext
* const gc
= __glXGetCurrentContext();
5616 const GLuint cmdlen
= 12;
5617 emit_header(gc
->pc
, X_GLrop_MultiTexCoord2svARB
, cmdlen
);
5618 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&target
), 4);
5619 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(&s
), 2);
5620 (void) memcpy((void *)(gc
->pc
+ 10), (void *)(&t
), 2);
5622 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
5625 #define X_GLrop_MultiTexCoord2svARB 205
5627 __indirect_glMultiTexCoord2svARB(GLenum target
, const GLshort
* v
)
5629 __GLXcontext
* const gc
= __glXGetCurrentContext();
5630 const GLuint cmdlen
= 12;
5631 emit_header(gc
->pc
, X_GLrop_MultiTexCoord2svARB
, cmdlen
);
5632 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&target
), 4);
5633 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(v
), 4);
5635 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
5638 #define X_GLrop_MultiTexCoord3dvARB 206
5640 __indirect_glMultiTexCoord3dARB(GLenum target
, GLdouble s
, GLdouble t
, GLdouble r
)
5642 __GLXcontext
* const gc
= __glXGetCurrentContext();
5643 const GLuint cmdlen
= 32;
5644 emit_header(gc
->pc
, X_GLrop_MultiTexCoord3dvARB
, cmdlen
);
5645 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&s
), 8);
5646 (void) memcpy((void *)(gc
->pc
+ 12), (void *)(&t
), 8);
5647 (void) memcpy((void *)(gc
->pc
+ 20), (void *)(&r
), 8);
5648 (void) memcpy((void *)(gc
->pc
+ 28), (void *)(&target
), 4);
5650 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
5653 #define X_GLrop_MultiTexCoord3dvARB 206
5655 __indirect_glMultiTexCoord3dvARB(GLenum target
, const GLdouble
* v
)
5657 __GLXcontext
* const gc
= __glXGetCurrentContext();
5658 const GLuint cmdlen
= 32;
5659 emit_header(gc
->pc
, X_GLrop_MultiTexCoord3dvARB
, cmdlen
);
5660 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(v
), 24);
5661 (void) memcpy((void *)(gc
->pc
+ 28), (void *)(&target
), 4);
5663 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
5666 #define X_GLrop_MultiTexCoord3fvARB 207
5668 __indirect_glMultiTexCoord3fARB(GLenum target
, GLfloat s
, GLfloat t
, GLfloat r
)
5670 __GLXcontext
* const gc
= __glXGetCurrentContext();
5671 const GLuint cmdlen
= 20;
5672 emit_header(gc
->pc
, X_GLrop_MultiTexCoord3fvARB
, cmdlen
);
5673 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&target
), 4);
5674 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(&s
), 4);
5675 (void) memcpy((void *)(gc
->pc
+ 12), (void *)(&t
), 4);
5676 (void) memcpy((void *)(gc
->pc
+ 16), (void *)(&r
), 4);
5678 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
5681 #define X_GLrop_MultiTexCoord3fvARB 207
5683 __indirect_glMultiTexCoord3fvARB(GLenum target
, const GLfloat
* v
)
5685 __GLXcontext
* const gc
= __glXGetCurrentContext();
5686 const GLuint cmdlen
= 20;
5687 emit_header(gc
->pc
, X_GLrop_MultiTexCoord3fvARB
, cmdlen
);
5688 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&target
), 4);
5689 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(v
), 12);
5691 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
5694 #define X_GLrop_MultiTexCoord3ivARB 208
5696 __indirect_glMultiTexCoord3iARB(GLenum target
, GLint s
, GLint t
, GLint r
)
5698 __GLXcontext
* const gc
= __glXGetCurrentContext();
5699 const GLuint cmdlen
= 20;
5700 emit_header(gc
->pc
, X_GLrop_MultiTexCoord3ivARB
, cmdlen
);
5701 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&target
), 4);
5702 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(&s
), 4);
5703 (void) memcpy((void *)(gc
->pc
+ 12), (void *)(&t
), 4);
5704 (void) memcpy((void *)(gc
->pc
+ 16), (void *)(&r
), 4);
5706 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
5709 #define X_GLrop_MultiTexCoord3ivARB 208
5711 __indirect_glMultiTexCoord3ivARB(GLenum target
, const GLint
* v
)
5713 __GLXcontext
* const gc
= __glXGetCurrentContext();
5714 const GLuint cmdlen
= 20;
5715 emit_header(gc
->pc
, X_GLrop_MultiTexCoord3ivARB
, cmdlen
);
5716 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&target
), 4);
5717 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(v
), 12);
5719 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
5722 #define X_GLrop_MultiTexCoord3svARB 209
5724 __indirect_glMultiTexCoord3sARB(GLenum target
, GLshort s
, GLshort t
, GLshort r
)
5726 __GLXcontext
* const gc
= __glXGetCurrentContext();
5727 const GLuint cmdlen
= 16;
5728 emit_header(gc
->pc
, X_GLrop_MultiTexCoord3svARB
, cmdlen
);
5729 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&target
), 4);
5730 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(&s
), 2);
5731 (void) memcpy((void *)(gc
->pc
+ 10), (void *)(&t
), 2);
5732 (void) memcpy((void *)(gc
->pc
+ 12), (void *)(&r
), 2);
5734 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
5737 #define X_GLrop_MultiTexCoord3svARB 209
5739 __indirect_glMultiTexCoord3svARB(GLenum target
, const GLshort
* v
)
5741 __GLXcontext
* const gc
= __glXGetCurrentContext();
5742 const GLuint cmdlen
= 16;
5743 emit_header(gc
->pc
, X_GLrop_MultiTexCoord3svARB
, cmdlen
);
5744 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&target
), 4);
5745 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(v
), 6);
5747 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
5750 #define X_GLrop_MultiTexCoord4dvARB 210
5752 __indirect_glMultiTexCoord4dARB(GLenum target
, GLdouble s
, GLdouble t
, GLdouble r
, GLdouble q
)
5754 __GLXcontext
* const gc
= __glXGetCurrentContext();
5755 const GLuint cmdlen
= 40;
5756 emit_header(gc
->pc
, X_GLrop_MultiTexCoord4dvARB
, cmdlen
);
5757 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&s
), 8);
5758 (void) memcpy((void *)(gc
->pc
+ 12), (void *)(&t
), 8);
5759 (void) memcpy((void *)(gc
->pc
+ 20), (void *)(&r
), 8);
5760 (void) memcpy((void *)(gc
->pc
+ 28), (void *)(&q
), 8);
5761 (void) memcpy((void *)(gc
->pc
+ 36), (void *)(&target
), 4);
5763 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
5766 #define X_GLrop_MultiTexCoord4dvARB 210
5768 __indirect_glMultiTexCoord4dvARB(GLenum target
, const GLdouble
* v
)
5770 __GLXcontext
* const gc
= __glXGetCurrentContext();
5771 const GLuint cmdlen
= 40;
5772 emit_header(gc
->pc
, X_GLrop_MultiTexCoord4dvARB
, cmdlen
);
5773 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(v
), 32);
5774 (void) memcpy((void *)(gc
->pc
+ 36), (void *)(&target
), 4);
5776 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
5779 #define X_GLrop_MultiTexCoord4fvARB 211
5781 __indirect_glMultiTexCoord4fARB(GLenum target
, GLfloat s
, GLfloat t
, GLfloat r
, GLfloat q
)
5783 __GLXcontext
* const gc
= __glXGetCurrentContext();
5784 const GLuint cmdlen
= 24;
5785 emit_header(gc
->pc
, X_GLrop_MultiTexCoord4fvARB
, cmdlen
);
5786 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&target
), 4);
5787 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(&s
), 4);
5788 (void) memcpy((void *)(gc
->pc
+ 12), (void *)(&t
), 4);
5789 (void) memcpy((void *)(gc
->pc
+ 16), (void *)(&r
), 4);
5790 (void) memcpy((void *)(gc
->pc
+ 20), (void *)(&q
), 4);
5792 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
5795 #define X_GLrop_MultiTexCoord4fvARB 211
5797 __indirect_glMultiTexCoord4fvARB(GLenum target
, const GLfloat
* v
)
5799 __GLXcontext
* const gc
= __glXGetCurrentContext();
5800 const GLuint cmdlen
= 24;
5801 emit_header(gc
->pc
, X_GLrop_MultiTexCoord4fvARB
, cmdlen
);
5802 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&target
), 4);
5803 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(v
), 16);
5805 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
5808 #define X_GLrop_MultiTexCoord4ivARB 212
5810 __indirect_glMultiTexCoord4iARB(GLenum target
, GLint s
, GLint t
, GLint r
, GLint q
)
5812 __GLXcontext
* const gc
= __glXGetCurrentContext();
5813 const GLuint cmdlen
= 24;
5814 emit_header(gc
->pc
, X_GLrop_MultiTexCoord4ivARB
, cmdlen
);
5815 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&target
), 4);
5816 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(&s
), 4);
5817 (void) memcpy((void *)(gc
->pc
+ 12), (void *)(&t
), 4);
5818 (void) memcpy((void *)(gc
->pc
+ 16), (void *)(&r
), 4);
5819 (void) memcpy((void *)(gc
->pc
+ 20), (void *)(&q
), 4);
5821 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
5824 #define X_GLrop_MultiTexCoord4ivARB 212
5826 __indirect_glMultiTexCoord4ivARB(GLenum target
, const GLint
* v
)
5828 __GLXcontext
* const gc
= __glXGetCurrentContext();
5829 const GLuint cmdlen
= 24;
5830 emit_header(gc
->pc
, X_GLrop_MultiTexCoord4ivARB
, cmdlen
);
5831 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&target
), 4);
5832 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(v
), 16);
5834 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
5837 #define X_GLrop_MultiTexCoord4svARB 213
5839 __indirect_glMultiTexCoord4sARB(GLenum target
, GLshort s
, GLshort t
, GLshort r
, GLshort q
)
5841 __GLXcontext
* const gc
= __glXGetCurrentContext();
5842 const GLuint cmdlen
= 16;
5843 emit_header(gc
->pc
, X_GLrop_MultiTexCoord4svARB
, cmdlen
);
5844 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&target
), 4);
5845 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(&s
), 2);
5846 (void) memcpy((void *)(gc
->pc
+ 10), (void *)(&t
), 2);
5847 (void) memcpy((void *)(gc
->pc
+ 12), (void *)(&r
), 2);
5848 (void) memcpy((void *)(gc
->pc
+ 14), (void *)(&q
), 2);
5850 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
5853 #define X_GLrop_MultiTexCoord4svARB 213
5855 __indirect_glMultiTexCoord4svARB(GLenum target
, const GLshort
* v
)
5857 __GLXcontext
* const gc
= __glXGetCurrentContext();
5858 const GLuint cmdlen
= 16;
5859 emit_header(gc
->pc
, X_GLrop_MultiTexCoord4svARB
, cmdlen
);
5860 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&target
), 4);
5861 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(v
), 8);
5863 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
5866 #define X_GLrop_SampleCoverageARB 229
5868 __indirect_glSampleCoverageARB(GLclampf value
, GLboolean invert
)
5870 __GLXcontext
* const gc
= __glXGetCurrentContext();
5871 const GLuint cmdlen
= 12;
5872 emit_header(gc
->pc
, X_GLrop_SampleCoverageARB
, cmdlen
);
5873 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&value
), 4);
5874 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(&invert
), 1);
5876 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
5879 #define X_GLrop_DrawBuffersARB 233
5881 __indirect_glDrawBuffersARB(GLsizei n
, const GLenum
* bufs
)
5883 __GLXcontext
* const gc
= __glXGetCurrentContext();
5884 const GLuint cmdlen
= 8 + __GLX_PAD((n
* 4));
5885 if (__builtin_expect((n
>= 0) && (gc
->currentDpy
!= NULL
), 1)) {
5886 if (cmdlen
<= gc
->maxSmallRenderCommandSize
) {
5887 if ( (gc
->pc
+ cmdlen
) > gc
->bufEnd
) {
5888 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
5890 emit_header(gc
->pc
, X_GLrop_DrawBuffersARB
, cmdlen
);
5891 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&n
), 4);
5892 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(bufs
), (n
* 4));
5894 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
5897 const GLint op
= X_GLrop_DrawBuffersARB
;
5898 const GLuint cmdlenLarge
= cmdlen
+ 4;
5899 GLubyte
* const pc
= __glXFlushRenderBuffer(gc
, gc
->pc
);
5900 (void) memcpy((void *)(pc
+ 0), (void *)(&cmdlenLarge
), 4);
5901 (void) memcpy((void *)(pc
+ 4), (void *)(&op
), 4);
5902 (void) memcpy((void *)(pc
+ 8), (void *)(&n
), 4);
5903 __glXSendLargeCommand(gc
, pc
, 12, bufs
, (n
* 4));
5908 #define X_GLvop_AreTexturesResidentEXT 11
5910 __indirect_glAreTexturesResidentEXT(GLsizei n
, const GLuint
* textures
, GLboolean
* residences
)
5912 __GLXcontext
* const gc
= __glXGetCurrentContext();
5913 Display
* const dpy
= gc
->currentDpy
;
5914 GLboolean retval
= (GLboolean
) 0;
5915 const GLuint cmdlen
= 4 + __GLX_PAD((n
* 4));
5916 if (__builtin_expect((n
>= 0) && (dpy
!= NULL
), 1)) {
5917 GLubyte
const * pc
= __glXSetupVendorRequest(gc
, X_GLXVendorPrivateWithReply
, X_GLvop_AreTexturesResidentEXT
, cmdlen
);
5918 (void) memcpy((void *)(pc
+ 0), (void *)(&n
), 4);
5919 (void) memcpy((void *)(pc
+ 4), (void *)(textures
), (n
* 4));
5920 retval
= (GLboolean
) __glXReadReply(dpy
, 1, residences
, GL_TRUE
);
5921 UnlockDisplay(dpy
); SyncHandle();
5926 #define X_GLvop_GenTexturesEXT 13
5928 __indirect_glGenTexturesEXT(GLsizei n
, GLuint
* textures
)
5930 __GLXcontext
* const gc
= __glXGetCurrentContext();
5931 Display
* const dpy
= gc
->currentDpy
;
5932 const GLuint cmdlen
= 4;
5933 if (__builtin_expect((n
>= 0) && (dpy
!= NULL
), 1)) {
5934 GLubyte
const * pc
= __glXSetupVendorRequest(gc
, X_GLXVendorPrivateWithReply
, X_GLvop_GenTexturesEXT
, cmdlen
);
5935 (void) memcpy((void *)(pc
+ 0), (void *)(&n
), 4);
5936 (void) __glXReadReply(dpy
, 4, textures
, GL_TRUE
);
5937 UnlockDisplay(dpy
); SyncHandle();
5942 #define X_GLvop_IsTextureEXT 14
5944 __indirect_glIsTextureEXT(GLuint texture
)
5946 __GLXcontext
* const gc
= __glXGetCurrentContext();
5947 Display
* const dpy
= gc
->currentDpy
;
5948 GLboolean retval
= (GLboolean
) 0;
5949 const GLuint cmdlen
= 4;
5950 if (__builtin_expect(dpy
!= NULL
, 1)) {
5951 GLubyte
const * pc
= __glXSetupVendorRequest(gc
, X_GLXVendorPrivateWithReply
, X_GLvop_IsTextureEXT
, cmdlen
);
5952 (void) memcpy((void *)(pc
+ 0), (void *)(&texture
), 4);
5953 retval
= (GLboolean
) __glXReadReply(dpy
, 0, NULL
, GL_FALSE
);
5954 UnlockDisplay(dpy
); SyncHandle();
5959 #define X_GLrop_SampleMaskSGIS 2048
5961 __indirect_glSampleMaskSGIS(GLclampf value
, GLboolean invert
)
5963 __GLXcontext
* const gc
= __glXGetCurrentContext();
5964 const GLuint cmdlen
= 12;
5965 emit_header(gc
->pc
, X_GLrop_SampleMaskSGIS
, cmdlen
);
5966 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&value
), 4);
5967 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(&invert
), 1);
5969 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
5972 #define X_GLrop_SamplePatternSGIS 2049
5974 __indirect_glSamplePatternSGIS(GLenum pattern
)
5976 __GLXcontext
* const gc
= __glXGetCurrentContext();
5977 const GLuint cmdlen
= 8;
5978 emit_header(gc
->pc
, X_GLrop_SamplePatternSGIS
, cmdlen
);
5979 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&pattern
), 4);
5981 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
5984 #define X_GLrop_PointParameterfEXT 2065
5986 __indirect_glPointParameterfEXT(GLenum pname
, GLfloat param
)
5988 __GLXcontext
* const gc
= __glXGetCurrentContext();
5989 const GLuint cmdlen
= 12;
5990 emit_header(gc
->pc
, X_GLrop_PointParameterfEXT
, cmdlen
);
5991 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&pname
), 4);
5992 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(¶m
), 4);
5994 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
5997 #define X_GLrop_PointParameterfvEXT 2066
5999 __indirect_glPointParameterfvEXT(GLenum pname
, const GLfloat
* params
)
6001 __GLXcontext
* const gc
= __glXGetCurrentContext();
6002 const GLuint compsize
= __glPointParameterfvEXT_size(pname
);
6003 const GLuint cmdlen
= 8 + __GLX_PAD((compsize
* 4));
6004 emit_header(gc
->pc
, X_GLrop_PointParameterfvEXT
, cmdlen
);
6005 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&pname
), 4);
6006 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(params
), (compsize
* 4));
6008 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
6011 #define X_GLrop_WindowPos3fvMESA 230
6013 __indirect_glWindowPos3fMESA(GLfloat x
, GLfloat y
, GLfloat z
)
6015 __GLXcontext
* const gc
= __glXGetCurrentContext();
6016 const GLuint cmdlen
= 16;
6017 emit_header(gc
->pc
, X_GLrop_WindowPos3fvMESA
, cmdlen
);
6018 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&x
), 4);
6019 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(&y
), 4);
6020 (void) memcpy((void *)(gc
->pc
+ 12), (void *)(&z
), 4);
6022 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
6025 #define X_GLrop_WindowPos3fvMESA 230
6027 __indirect_glWindowPos3fvMESA(const GLfloat
* v
)
6029 generic_12_byte( X_GLrop_WindowPos3fvMESA
, v
);
6032 #define X_GLrop_BlendFuncSeparateEXT 4134
6034 __indirect_glBlendFuncSeparateEXT(GLenum sfactorRGB
, GLenum dfactorRGB
, GLenum sfactorAlpha
, GLenum dfactorAlpha
)
6036 __GLXcontext
* const gc
= __glXGetCurrentContext();
6037 const GLuint cmdlen
= 20;
6038 emit_header(gc
->pc
, X_GLrop_BlendFuncSeparateEXT
, cmdlen
);
6039 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&sfactorRGB
), 4);
6040 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(&dfactorRGB
), 4);
6041 (void) memcpy((void *)(gc
->pc
+ 12), (void *)(&sfactorAlpha
), 4);
6042 (void) memcpy((void *)(gc
->pc
+ 16), (void *)(&dfactorAlpha
), 4);
6044 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
6047 #define X_GLrop_FogCoordfvEXT 4124
6049 __indirect_glFogCoordfEXT(GLfloat coord
)
6051 __GLXcontext
* const gc
= __glXGetCurrentContext();
6052 const GLuint cmdlen
= 8;
6053 emit_header(gc
->pc
, X_GLrop_FogCoordfvEXT
, cmdlen
);
6054 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&coord
), 4);
6056 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
6059 #define X_GLrop_FogCoordfvEXT 4124
6061 __indirect_glFogCoordfvEXT(const GLfloat
* coord
)
6063 generic_4_byte( X_GLrop_FogCoordfvEXT
, coord
);
6066 #define X_GLrop_FogCoorddvEXT 4125
6068 __indirect_glFogCoorddEXT(GLdouble coord
)
6070 __GLXcontext
* const gc
= __glXGetCurrentContext();
6071 const GLuint cmdlen
= 12;
6072 emit_header(gc
->pc
, X_GLrop_FogCoorddvEXT
, cmdlen
);
6073 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&coord
), 8);
6075 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
6078 #define X_GLrop_FogCoorddvEXT 4125
6080 __indirect_glFogCoorddvEXT(const GLdouble
* coord
)
6082 generic_8_byte( X_GLrop_FogCoorddvEXT
, coord
);
6085 #define X_GLrop_SecondaryColor3bvEXT 4126
6087 __indirect_glSecondaryColor3bEXT(GLbyte red
, GLbyte green
, GLbyte blue
)
6089 __GLXcontext
* const gc
= __glXGetCurrentContext();
6090 const GLuint cmdlen
= 8;
6091 emit_header(gc
->pc
, X_GLrop_SecondaryColor3bvEXT
, cmdlen
);
6092 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&red
), 1);
6093 (void) memcpy((void *)(gc
->pc
+ 5), (void *)(&green
), 1);
6094 (void) memcpy((void *)(gc
->pc
+ 6), (void *)(&blue
), 1);
6096 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
6099 #define X_GLrop_SecondaryColor3bvEXT 4126
6101 __indirect_glSecondaryColor3bvEXT(const GLbyte
* v
)
6103 generic_3_byte( X_GLrop_SecondaryColor3bvEXT
, v
);
6106 #define X_GLrop_SecondaryColor3dvEXT 4130
6108 __indirect_glSecondaryColor3dEXT(GLdouble red
, GLdouble green
, GLdouble blue
)
6110 __GLXcontext
* const gc
= __glXGetCurrentContext();
6111 const GLuint cmdlen
= 28;
6112 emit_header(gc
->pc
, X_GLrop_SecondaryColor3dvEXT
, cmdlen
);
6113 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&red
), 8);
6114 (void) memcpy((void *)(gc
->pc
+ 12), (void *)(&green
), 8);
6115 (void) memcpy((void *)(gc
->pc
+ 20), (void *)(&blue
), 8);
6117 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
6120 #define X_GLrop_SecondaryColor3dvEXT 4130
6122 __indirect_glSecondaryColor3dvEXT(const GLdouble
* v
)
6124 generic_24_byte( X_GLrop_SecondaryColor3dvEXT
, v
);
6127 #define X_GLrop_SecondaryColor3fvEXT 4129
6129 __indirect_glSecondaryColor3fEXT(GLfloat red
, GLfloat green
, GLfloat blue
)
6131 __GLXcontext
* const gc
= __glXGetCurrentContext();
6132 const GLuint cmdlen
= 16;
6133 emit_header(gc
->pc
, X_GLrop_SecondaryColor3fvEXT
, cmdlen
);
6134 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&red
), 4);
6135 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(&green
), 4);
6136 (void) memcpy((void *)(gc
->pc
+ 12), (void *)(&blue
), 4);
6138 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
6141 #define X_GLrop_SecondaryColor3fvEXT 4129
6143 __indirect_glSecondaryColor3fvEXT(const GLfloat
* v
)
6145 generic_12_byte( X_GLrop_SecondaryColor3fvEXT
, v
);
6148 #define X_GLrop_SecondaryColor3ivEXT 4128
6150 __indirect_glSecondaryColor3iEXT(GLint red
, GLint green
, GLint blue
)
6152 __GLXcontext
* const gc
= __glXGetCurrentContext();
6153 const GLuint cmdlen
= 16;
6154 emit_header(gc
->pc
, X_GLrop_SecondaryColor3ivEXT
, cmdlen
);
6155 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&red
), 4);
6156 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(&green
), 4);
6157 (void) memcpy((void *)(gc
->pc
+ 12), (void *)(&blue
), 4);
6159 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
6162 #define X_GLrop_SecondaryColor3ivEXT 4128
6164 __indirect_glSecondaryColor3ivEXT(const GLint
* v
)
6166 generic_12_byte( X_GLrop_SecondaryColor3ivEXT
, v
);
6169 #define X_GLrop_SecondaryColor3svEXT 4127
6171 __indirect_glSecondaryColor3sEXT(GLshort red
, GLshort green
, GLshort blue
)
6173 __GLXcontext
* const gc
= __glXGetCurrentContext();
6174 const GLuint cmdlen
= 12;
6175 emit_header(gc
->pc
, X_GLrop_SecondaryColor3svEXT
, cmdlen
);
6176 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&red
), 2);
6177 (void) memcpy((void *)(gc
->pc
+ 6), (void *)(&green
), 2);
6178 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(&blue
), 2);
6180 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
6183 #define X_GLrop_SecondaryColor3svEXT 4127
6185 __indirect_glSecondaryColor3svEXT(const GLshort
* v
)
6187 generic_6_byte( X_GLrop_SecondaryColor3svEXT
, v
);
6190 #define X_GLrop_SecondaryColor3ubvEXT 4131
6192 __indirect_glSecondaryColor3ubEXT(GLubyte red
, GLubyte green
, GLubyte blue
)
6194 __GLXcontext
* const gc
= __glXGetCurrentContext();
6195 const GLuint cmdlen
= 8;
6196 emit_header(gc
->pc
, X_GLrop_SecondaryColor3ubvEXT
, cmdlen
);
6197 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&red
), 1);
6198 (void) memcpy((void *)(gc
->pc
+ 5), (void *)(&green
), 1);
6199 (void) memcpy((void *)(gc
->pc
+ 6), (void *)(&blue
), 1);
6201 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
6204 #define X_GLrop_SecondaryColor3ubvEXT 4131
6206 __indirect_glSecondaryColor3ubvEXT(const GLubyte
* v
)
6208 generic_3_byte( X_GLrop_SecondaryColor3ubvEXT
, v
);
6211 #define X_GLrop_SecondaryColor3uivEXT 4133
6213 __indirect_glSecondaryColor3uiEXT(GLuint red
, GLuint green
, GLuint blue
)
6215 __GLXcontext
* const gc
= __glXGetCurrentContext();
6216 const GLuint cmdlen
= 16;
6217 emit_header(gc
->pc
, X_GLrop_SecondaryColor3uivEXT
, cmdlen
);
6218 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&red
), 4);
6219 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(&green
), 4);
6220 (void) memcpy((void *)(gc
->pc
+ 12), (void *)(&blue
), 4);
6222 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
6225 #define X_GLrop_SecondaryColor3uivEXT 4133
6227 __indirect_glSecondaryColor3uivEXT(const GLuint
* v
)
6229 generic_12_byte( X_GLrop_SecondaryColor3uivEXT
, v
);
6232 #define X_GLrop_SecondaryColor3usvEXT 4132
6234 __indirect_glSecondaryColor3usEXT(GLushort red
, GLushort green
, GLushort blue
)
6236 __GLXcontext
* const gc
= __glXGetCurrentContext();
6237 const GLuint cmdlen
= 12;
6238 emit_header(gc
->pc
, X_GLrop_SecondaryColor3usvEXT
, cmdlen
);
6239 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&red
), 2);
6240 (void) memcpy((void *)(gc
->pc
+ 6), (void *)(&green
), 2);
6241 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(&blue
), 2);
6243 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
6246 #define X_GLrop_SecondaryColor3usvEXT 4132
6248 __indirect_glSecondaryColor3usvEXT(const GLushort
* v
)
6250 generic_6_byte( X_GLrop_SecondaryColor3usvEXT
, v
);
6253 #define X_GLvop_AreProgramsResidentNV 1293
6255 __indirect_glAreProgramsResidentNV(GLsizei n
, const GLuint
* ids
, GLboolean
* residences
)
6257 __GLXcontext
* const gc
= __glXGetCurrentContext();
6258 Display
* const dpy
= gc
->currentDpy
;
6259 GLboolean retval
= (GLboolean
) 0;
6260 const GLuint cmdlen
= 4 + __GLX_PAD((n
* 4));
6261 if (__builtin_expect((n
>= 0) && (dpy
!= NULL
), 1)) {
6262 GLubyte
const * pc
= __glXSetupVendorRequest(gc
, X_GLXVendorPrivateWithReply
, X_GLvop_AreProgramsResidentNV
, cmdlen
);
6263 (void) memcpy((void *)(pc
+ 0), (void *)(&n
), 4);
6264 (void) memcpy((void *)(pc
+ 4), (void *)(ids
), (n
* 4));
6265 retval
= (GLboolean
) __glXReadReply(dpy
, 1, residences
, GL_FALSE
);
6266 UnlockDisplay(dpy
); SyncHandle();
6271 #define X_GLrop_BindProgramNV 4180
6273 __indirect_glBindProgramNV(GLenum target
, GLuint program
)
6275 __GLXcontext
* const gc
= __glXGetCurrentContext();
6276 const GLuint cmdlen
= 12;
6277 emit_header(gc
->pc
, X_GLrop_BindProgramNV
, cmdlen
);
6278 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&target
), 4);
6279 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(&program
), 4);
6281 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
6284 #define X_GLvop_DeleteProgramsNV 1294
6286 __indirect_glDeleteProgramsNV(GLsizei n
, const GLuint
* programs
)
6288 __GLXcontext
* const gc
= __glXGetCurrentContext();
6289 Display
* const dpy
= gc
->currentDpy
;
6290 const GLuint cmdlen
= 4 + __GLX_PAD((n
* 4));
6291 if (__builtin_expect((n
>= 0) && (dpy
!= NULL
), 1)) {
6292 GLubyte
const * pc
= __glXSetupVendorRequest(gc
, X_GLXVendorPrivate
, X_GLvop_DeleteProgramsNV
, cmdlen
);
6293 (void) memcpy((void *)(pc
+ 0), (void *)(&n
), 4);
6294 (void) memcpy((void *)(pc
+ 4), (void *)(programs
), (n
* 4));
6295 UnlockDisplay(dpy
); SyncHandle();
6300 #define X_GLrop_ExecuteProgramNV 4181
6302 __indirect_glExecuteProgramNV(GLenum target
, GLuint id
, const GLfloat
* params
)
6304 __GLXcontext
* const gc
= __glXGetCurrentContext();
6305 const GLuint cmdlen
= 28;
6306 emit_header(gc
->pc
, X_GLrop_ExecuteProgramNV
, cmdlen
);
6307 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&target
), 4);
6308 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(&id
), 4);
6309 (void) memcpy((void *)(gc
->pc
+ 12), (void *)(params
), 16);
6311 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
6314 #define X_GLvop_GenProgramsNV 1295
6316 __indirect_glGenProgramsNV(GLsizei n
, GLuint
* programs
)
6318 __GLXcontext
* const gc
= __glXGetCurrentContext();
6319 Display
* const dpy
= gc
->currentDpy
;
6320 const GLuint cmdlen
= 4;
6321 if (__builtin_expect((n
>= 0) && (dpy
!= NULL
), 1)) {
6322 GLubyte
const * pc
= __glXSetupVendorRequest(gc
, X_GLXVendorPrivateWithReply
, X_GLvop_GenProgramsNV
, cmdlen
);
6323 (void) memcpy((void *)(pc
+ 0), (void *)(&n
), 4);
6324 (void) __glXReadReply(dpy
, 4, programs
, GL_FALSE
);
6325 UnlockDisplay(dpy
); SyncHandle();
6330 #define X_GLvop_GetProgramParameterdvNV 1297
6332 __indirect_glGetProgramParameterdvNV(GLenum target
, GLuint index
, GLenum pname
, GLdouble
* params
)
6334 __GLXcontext
* const gc
= __glXGetCurrentContext();
6335 Display
* const dpy
= gc
->currentDpy
;
6336 const GLuint cmdlen
= 12;
6337 if (__builtin_expect(dpy
!= NULL
, 1)) {
6338 GLubyte
const * pc
= __glXSetupVendorRequest(gc
, X_GLXVendorPrivateWithReply
, X_GLvop_GetProgramParameterdvNV
, cmdlen
);
6339 (void) memcpy((void *)(pc
+ 0), (void *)(&target
), 4);
6340 (void) memcpy((void *)(pc
+ 4), (void *)(&index
), 4);
6341 (void) memcpy((void *)(pc
+ 8), (void *)(&pname
), 4);
6342 (void) __glXReadReply(dpy
, 8, params
, GL_FALSE
);
6343 UnlockDisplay(dpy
); SyncHandle();
6348 #define X_GLvop_GetProgramParameterfvNV 1296
6350 __indirect_glGetProgramParameterfvNV(GLenum target
, GLuint index
, GLenum pname
, GLfloat
* params
)
6352 __GLXcontext
* const gc
= __glXGetCurrentContext();
6353 Display
* const dpy
= gc
->currentDpy
;
6354 const GLuint cmdlen
= 12;
6355 if (__builtin_expect(dpy
!= NULL
, 1)) {
6356 GLubyte
const * pc
= __glXSetupVendorRequest(gc
, X_GLXVendorPrivateWithReply
, X_GLvop_GetProgramParameterfvNV
, cmdlen
);
6357 (void) memcpy((void *)(pc
+ 0), (void *)(&target
), 4);
6358 (void) memcpy((void *)(pc
+ 4), (void *)(&index
), 4);
6359 (void) memcpy((void *)(pc
+ 8), (void *)(&pname
), 4);
6360 (void) __glXReadReply(dpy
, 4, params
, GL_FALSE
);
6361 UnlockDisplay(dpy
); SyncHandle();
6366 #define X_GLvop_GetProgramivNV 1298
6368 __indirect_glGetProgramivNV(GLuint id
, GLenum pname
, GLint
* params
)
6370 __GLXcontext
* const gc
= __glXGetCurrentContext();
6371 Display
* const dpy
= gc
->currentDpy
;
6372 const GLuint cmdlen
= 8;
6373 if (__builtin_expect(dpy
!= NULL
, 1)) {
6374 GLubyte
const * pc
= __glXSetupVendorRequest(gc
, X_GLXVendorPrivateWithReply
, X_GLvop_GetProgramivNV
, cmdlen
);
6375 (void) memcpy((void *)(pc
+ 0), (void *)(&id
), 4);
6376 (void) memcpy((void *)(pc
+ 4), (void *)(&pname
), 4);
6377 (void) __glXReadReply(dpy
, 4, params
, GL_FALSE
);
6378 UnlockDisplay(dpy
); SyncHandle();
6383 #define X_GLvop_GetProgramStringNV 1299
6385 __indirect_glGetProgramStringNV(GLuint id
, GLenum pname
, GLubyte
* program
)
6387 __GLXcontext
* const gc
= __glXGetCurrentContext();
6388 Display
* const dpy
= gc
->currentDpy
;
6389 const GLuint cmdlen
= 8;
6390 if (__builtin_expect(dpy
!= NULL
, 1)) {
6391 GLubyte
const * pc
= __glXSetupVendorRequest(gc
, X_GLXVendorPrivateWithReply
, X_GLvop_GetProgramStringNV
, cmdlen
);
6392 (void) memcpy((void *)(pc
+ 0), (void *)(&id
), 4);
6393 (void) memcpy((void *)(pc
+ 4), (void *)(&pname
), 4);
6394 (void) __glXReadReply(dpy
, 1, program
, GL_TRUE
);
6395 UnlockDisplay(dpy
); SyncHandle();
6400 #define X_GLvop_GetTrackMatrixivNV 1300
6402 __indirect_glGetTrackMatrixivNV(GLenum target
, GLuint address
, GLenum pname
, GLint
* params
)
6404 __GLXcontext
* const gc
= __glXGetCurrentContext();
6405 Display
* const dpy
= gc
->currentDpy
;
6406 const GLuint cmdlen
= 12;
6407 if (__builtin_expect(dpy
!= NULL
, 1)) {
6408 GLubyte
const * pc
= __glXSetupVendorRequest(gc
, X_GLXVendorPrivateWithReply
, X_GLvop_GetTrackMatrixivNV
, cmdlen
);
6409 (void) memcpy((void *)(pc
+ 0), (void *)(&target
), 4);
6410 (void) memcpy((void *)(pc
+ 4), (void *)(&address
), 4);
6411 (void) memcpy((void *)(pc
+ 8), (void *)(&pname
), 4);
6412 (void) __glXReadReply(dpy
, 4, params
, GL_FALSE
);
6413 UnlockDisplay(dpy
); SyncHandle();
6418 #define X_GLvop_IsProgramNV 1304
6420 __indirect_glIsProgramNV(GLuint program
)
6422 __GLXcontext
* const gc
= __glXGetCurrentContext();
6423 Display
* const dpy
= gc
->currentDpy
;
6424 GLboolean retval
= (GLboolean
) 0;
6425 const GLuint cmdlen
= 4;
6426 if (__builtin_expect(dpy
!= NULL
, 1)) {
6427 GLubyte
const * pc
= __glXSetupVendorRequest(gc
, X_GLXVendorPrivateWithReply
, X_GLvop_IsProgramNV
, cmdlen
);
6428 (void) memcpy((void *)(pc
+ 0), (void *)(&program
), 4);
6429 retval
= (GLboolean
) __glXReadReply(dpy
, 0, NULL
, GL_FALSE
);
6430 UnlockDisplay(dpy
); SyncHandle();
6435 #define X_GLrop_LoadProgramNV 4183
6437 __indirect_glLoadProgramNV(GLenum target
, GLuint id
, GLsizei len
, const GLubyte
* program
)
6439 __GLXcontext
* const gc
= __glXGetCurrentContext();
6440 const GLuint cmdlen
= 16 + __GLX_PAD(len
);
6441 if (__builtin_expect(len
>= 0, 1)) {
6442 emit_header(gc
->pc
, X_GLrop_LoadProgramNV
, cmdlen
);
6443 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&target
), 4);
6444 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(&id
), 4);
6445 (void) memcpy((void *)(gc
->pc
+ 12), (void *)(&len
), 4);
6446 (void) memcpy((void *)(gc
->pc
+ 16), (void *)(program
), len
);
6448 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
6452 #define X_GLrop_ProgramParameter4dvNV 4185
6454 __indirect_glProgramParameter4dNV(GLenum target
, GLuint index
, GLdouble x
, GLdouble y
, GLdouble z
, GLdouble w
)
6456 __GLXcontext
* const gc
= __glXGetCurrentContext();
6457 const GLuint cmdlen
= 44;
6458 emit_header(gc
->pc
, X_GLrop_ProgramParameter4dvNV
, cmdlen
);
6459 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&target
), 4);
6460 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(&index
), 4);
6461 (void) memcpy((void *)(gc
->pc
+ 12), (void *)(&x
), 8);
6462 (void) memcpy((void *)(gc
->pc
+ 20), (void *)(&y
), 8);
6463 (void) memcpy((void *)(gc
->pc
+ 28), (void *)(&z
), 8);
6464 (void) memcpy((void *)(gc
->pc
+ 36), (void *)(&w
), 8);
6466 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
6469 #define X_GLrop_ProgramParameter4dvNV 4185
6471 __indirect_glProgramParameter4dvNV(GLenum target
, GLuint index
, const GLdouble
* params
)
6473 __GLXcontext
* const gc
= __glXGetCurrentContext();
6474 const GLuint cmdlen
= 44;
6475 emit_header(gc
->pc
, X_GLrop_ProgramParameter4dvNV
, cmdlen
);
6476 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&target
), 4);
6477 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(&index
), 4);
6478 (void) memcpy((void *)(gc
->pc
+ 12), (void *)(params
), 32);
6480 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
6483 #define X_GLrop_ProgramParameter4fvNV 4184
6485 __indirect_glProgramParameter4fNV(GLenum target
, GLuint index
, GLfloat x
, GLfloat y
, GLfloat z
, GLfloat w
)
6487 __GLXcontext
* const gc
= __glXGetCurrentContext();
6488 const GLuint cmdlen
= 28;
6489 emit_header(gc
->pc
, X_GLrop_ProgramParameter4fvNV
, cmdlen
);
6490 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&target
), 4);
6491 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(&index
), 4);
6492 (void) memcpy((void *)(gc
->pc
+ 12), (void *)(&x
), 4);
6493 (void) memcpy((void *)(gc
->pc
+ 16), (void *)(&y
), 4);
6494 (void) memcpy((void *)(gc
->pc
+ 20), (void *)(&z
), 4);
6495 (void) memcpy((void *)(gc
->pc
+ 24), (void *)(&w
), 4);
6497 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
6500 #define X_GLrop_ProgramParameter4fvNV 4184
6502 __indirect_glProgramParameter4fvNV(GLenum target
, GLuint index
, const GLfloat
* params
)
6504 __GLXcontext
* const gc
= __glXGetCurrentContext();
6505 const GLuint cmdlen
= 28;
6506 emit_header(gc
->pc
, X_GLrop_ProgramParameter4fvNV
, cmdlen
);
6507 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&target
), 4);
6508 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(&index
), 4);
6509 (void) memcpy((void *)(gc
->pc
+ 12), (void *)(params
), 16);
6511 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
6514 #define X_GLrop_ProgramParameters4dvNV 4187
6516 __indirect_glProgramParameters4dvNV(GLenum target
, GLuint index
, GLuint num
, const GLdouble
* params
)
6518 __GLXcontext
* const gc
= __glXGetCurrentContext();
6519 const GLuint cmdlen
= 16 + __GLX_PAD((num
* 32));
6520 if (__builtin_expect(num
>= 0, 1)) {
6521 emit_header(gc
->pc
, X_GLrop_ProgramParameters4dvNV
, cmdlen
);
6522 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&target
), 4);
6523 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(&index
), 4);
6524 (void) memcpy((void *)(gc
->pc
+ 12), (void *)(&num
), 4);
6525 (void) memcpy((void *)(gc
->pc
+ 16), (void *)(params
), (num
* 32));
6527 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
6531 #define X_GLrop_ProgramParameters4fvNV 4186
6533 __indirect_glProgramParameters4fvNV(GLenum target
, GLuint index
, GLuint num
, const GLfloat
* params
)
6535 __GLXcontext
* const gc
= __glXGetCurrentContext();
6536 const GLuint cmdlen
= 16 + __GLX_PAD((num
* 16));
6537 if (__builtin_expect(num
>= 0, 1)) {
6538 emit_header(gc
->pc
, X_GLrop_ProgramParameters4fvNV
, cmdlen
);
6539 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&target
), 4);
6540 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(&index
), 4);
6541 (void) memcpy((void *)(gc
->pc
+ 12), (void *)(&num
), 4);
6542 (void) memcpy((void *)(gc
->pc
+ 16), (void *)(params
), (num
* 16));
6544 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
6548 #define X_GLrop_RequestResidentProgramsNV 4182
6550 __indirect_glRequestResidentProgramsNV(GLsizei n
, const GLuint
* ids
)
6552 __GLXcontext
* const gc
= __glXGetCurrentContext();
6553 const GLuint cmdlen
= 8 + __GLX_PAD((n
* 4));
6554 if (__builtin_expect(n
>= 0, 1)) {
6555 emit_header(gc
->pc
, X_GLrop_RequestResidentProgramsNV
, cmdlen
);
6556 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&n
), 4);
6557 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(ids
), (n
* 4));
6559 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
6563 #define X_GLrop_TrackMatrixNV 4188
6565 __indirect_glTrackMatrixNV(GLenum target
, GLuint address
, GLenum matrix
, GLenum transform
)
6567 __GLXcontext
* const gc
= __glXGetCurrentContext();
6568 const GLuint cmdlen
= 20;
6569 emit_header(gc
->pc
, X_GLrop_TrackMatrixNV
, cmdlen
);
6570 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&target
), 4);
6571 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(&address
), 4);
6572 (void) memcpy((void *)(gc
->pc
+ 12), (void *)(&matrix
), 4);
6573 (void) memcpy((void *)(gc
->pc
+ 16), (void *)(&transform
), 4);
6575 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
6578 #define X_GLrop_VertexAttrib1dvARB 4197
6580 __indirect_glVertexAttrib1dARB(GLuint index
, GLdouble x
)
6582 __GLXcontext
* const gc
= __glXGetCurrentContext();
6583 const GLuint cmdlen
= 16;
6584 emit_header(gc
->pc
, X_GLrop_VertexAttrib1dvARB
, cmdlen
);
6585 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&x
), 8);
6586 (void) memcpy((void *)(gc
->pc
+ 12), (void *)(&index
), 4);
6588 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
6591 #define X_GLrop_VertexAttrib1dvARB 4197
6593 __indirect_glVertexAttrib1dvARB(GLuint index
, const GLdouble
* v
)
6595 __GLXcontext
* const gc
= __glXGetCurrentContext();
6596 const GLuint cmdlen
= 16;
6597 emit_header(gc
->pc
, X_GLrop_VertexAttrib1dvARB
, cmdlen
);
6598 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(v
), 8);
6599 (void) memcpy((void *)(gc
->pc
+ 12), (void *)(&index
), 4);
6601 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
6604 #define X_GLrop_VertexAttrib1fvARB 4193
6606 __indirect_glVertexAttrib1fARB(GLuint index
, GLfloat x
)
6608 __GLXcontext
* const gc
= __glXGetCurrentContext();
6609 const GLuint cmdlen
= 12;
6610 emit_header(gc
->pc
, X_GLrop_VertexAttrib1fvARB
, cmdlen
);
6611 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&index
), 4);
6612 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(&x
), 4);
6614 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
6617 #define X_GLrop_VertexAttrib1fvARB 4193
6619 __indirect_glVertexAttrib1fvARB(GLuint index
, const GLfloat
* v
)
6621 __GLXcontext
* const gc
= __glXGetCurrentContext();
6622 const GLuint cmdlen
= 12;
6623 emit_header(gc
->pc
, X_GLrop_VertexAttrib1fvARB
, cmdlen
);
6624 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&index
), 4);
6625 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(v
), 4);
6627 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
6630 #define X_GLrop_VertexAttrib1svARB 4189
6632 __indirect_glVertexAttrib1sARB(GLuint index
, GLshort x
)
6634 __GLXcontext
* const gc
= __glXGetCurrentContext();
6635 const GLuint cmdlen
= 12;
6636 emit_header(gc
->pc
, X_GLrop_VertexAttrib1svARB
, cmdlen
);
6637 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&index
), 4);
6638 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(&x
), 2);
6640 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
6643 #define X_GLrop_VertexAttrib1svARB 4189
6645 __indirect_glVertexAttrib1svARB(GLuint index
, const GLshort
* v
)
6647 __GLXcontext
* const gc
= __glXGetCurrentContext();
6648 const GLuint cmdlen
= 12;
6649 emit_header(gc
->pc
, X_GLrop_VertexAttrib1svARB
, cmdlen
);
6650 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&index
), 4);
6651 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(v
), 2);
6653 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
6656 #define X_GLrop_VertexAttrib2dvARB 4198
6658 __indirect_glVertexAttrib2dARB(GLuint index
, GLdouble x
, GLdouble y
)
6660 __GLXcontext
* const gc
= __glXGetCurrentContext();
6661 const GLuint cmdlen
= 24;
6662 emit_header(gc
->pc
, X_GLrop_VertexAttrib2dvARB
, cmdlen
);
6663 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&x
), 8);
6664 (void) memcpy((void *)(gc
->pc
+ 12), (void *)(&y
), 8);
6665 (void) memcpy((void *)(gc
->pc
+ 20), (void *)(&index
), 4);
6667 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
6670 #define X_GLrop_VertexAttrib2dvARB 4198
6672 __indirect_glVertexAttrib2dvARB(GLuint index
, const GLdouble
* v
)
6674 __GLXcontext
* const gc
= __glXGetCurrentContext();
6675 const GLuint cmdlen
= 24;
6676 emit_header(gc
->pc
, X_GLrop_VertexAttrib2dvARB
, cmdlen
);
6677 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(v
), 16);
6678 (void) memcpy((void *)(gc
->pc
+ 20), (void *)(&index
), 4);
6680 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
6683 #define X_GLrop_VertexAttrib2fvARB 4194
6685 __indirect_glVertexAttrib2fARB(GLuint index
, GLfloat x
, GLfloat y
)
6687 __GLXcontext
* const gc
= __glXGetCurrentContext();
6688 const GLuint cmdlen
= 16;
6689 emit_header(gc
->pc
, X_GLrop_VertexAttrib2fvARB
, cmdlen
);
6690 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&index
), 4);
6691 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(&x
), 4);
6692 (void) memcpy((void *)(gc
->pc
+ 12), (void *)(&y
), 4);
6694 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
6697 #define X_GLrop_VertexAttrib2fvARB 4194
6699 __indirect_glVertexAttrib2fvARB(GLuint index
, const GLfloat
* v
)
6701 __GLXcontext
* const gc
= __glXGetCurrentContext();
6702 const GLuint cmdlen
= 16;
6703 emit_header(gc
->pc
, X_GLrop_VertexAttrib2fvARB
, cmdlen
);
6704 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&index
), 4);
6705 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(v
), 8);
6707 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
6710 #define X_GLrop_VertexAttrib2svARB 4190
6712 __indirect_glVertexAttrib2sARB(GLuint index
, GLshort x
, GLshort y
)
6714 __GLXcontext
* const gc
= __glXGetCurrentContext();
6715 const GLuint cmdlen
= 12;
6716 emit_header(gc
->pc
, X_GLrop_VertexAttrib2svARB
, cmdlen
);
6717 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&index
), 4);
6718 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(&x
), 2);
6719 (void) memcpy((void *)(gc
->pc
+ 10), (void *)(&y
), 2);
6721 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
6724 #define X_GLrop_VertexAttrib2svARB 4190
6726 __indirect_glVertexAttrib2svARB(GLuint index
, const GLshort
* v
)
6728 __GLXcontext
* const gc
= __glXGetCurrentContext();
6729 const GLuint cmdlen
= 12;
6730 emit_header(gc
->pc
, X_GLrop_VertexAttrib2svARB
, cmdlen
);
6731 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&index
), 4);
6732 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(v
), 4);
6734 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
6737 #define X_GLrop_VertexAttrib3dvARB 4199
6739 __indirect_glVertexAttrib3dARB(GLuint index
, GLdouble x
, GLdouble y
, GLdouble z
)
6741 __GLXcontext
* const gc
= __glXGetCurrentContext();
6742 const GLuint cmdlen
= 32;
6743 emit_header(gc
->pc
, X_GLrop_VertexAttrib3dvARB
, cmdlen
);
6744 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&x
), 8);
6745 (void) memcpy((void *)(gc
->pc
+ 12), (void *)(&y
), 8);
6746 (void) memcpy((void *)(gc
->pc
+ 20), (void *)(&z
), 8);
6747 (void) memcpy((void *)(gc
->pc
+ 28), (void *)(&index
), 4);
6749 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
6752 #define X_GLrop_VertexAttrib3dvARB 4199
6754 __indirect_glVertexAttrib3dvARB(GLuint index
, const GLdouble
* v
)
6756 __GLXcontext
* const gc
= __glXGetCurrentContext();
6757 const GLuint cmdlen
= 32;
6758 emit_header(gc
->pc
, X_GLrop_VertexAttrib3dvARB
, cmdlen
);
6759 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(v
), 24);
6760 (void) memcpy((void *)(gc
->pc
+ 28), (void *)(&index
), 4);
6762 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
6765 #define X_GLrop_VertexAttrib3fvARB 4195
6767 __indirect_glVertexAttrib3fARB(GLuint index
, GLfloat x
, GLfloat y
, GLfloat z
)
6769 __GLXcontext
* const gc
= __glXGetCurrentContext();
6770 const GLuint cmdlen
= 20;
6771 emit_header(gc
->pc
, X_GLrop_VertexAttrib3fvARB
, cmdlen
);
6772 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&index
), 4);
6773 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(&x
), 4);
6774 (void) memcpy((void *)(gc
->pc
+ 12), (void *)(&y
), 4);
6775 (void) memcpy((void *)(gc
->pc
+ 16), (void *)(&z
), 4);
6777 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
6780 #define X_GLrop_VertexAttrib3fvARB 4195
6782 __indirect_glVertexAttrib3fvARB(GLuint index
, const GLfloat
* v
)
6784 __GLXcontext
* const gc
= __glXGetCurrentContext();
6785 const GLuint cmdlen
= 20;
6786 emit_header(gc
->pc
, X_GLrop_VertexAttrib3fvARB
, cmdlen
);
6787 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&index
), 4);
6788 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(v
), 12);
6790 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
6793 #define X_GLrop_VertexAttrib3svARB 4191
6795 __indirect_glVertexAttrib3sARB(GLuint index
, GLshort x
, GLshort y
, GLshort z
)
6797 __GLXcontext
* const gc
= __glXGetCurrentContext();
6798 const GLuint cmdlen
= 16;
6799 emit_header(gc
->pc
, X_GLrop_VertexAttrib3svARB
, cmdlen
);
6800 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&index
), 4);
6801 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(&x
), 2);
6802 (void) memcpy((void *)(gc
->pc
+ 10), (void *)(&y
), 2);
6803 (void) memcpy((void *)(gc
->pc
+ 12), (void *)(&z
), 2);
6805 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
6808 #define X_GLrop_VertexAttrib3svARB 4191
6810 __indirect_glVertexAttrib3svARB(GLuint index
, const GLshort
* v
)
6812 __GLXcontext
* const gc
= __glXGetCurrentContext();
6813 const GLuint cmdlen
= 16;
6814 emit_header(gc
->pc
, X_GLrop_VertexAttrib3svARB
, cmdlen
);
6815 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&index
), 4);
6816 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(v
), 6);
6818 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
6821 #define X_GLrop_VertexAttrib4dvARB 4200
6823 __indirect_glVertexAttrib4dARB(GLuint index
, GLdouble x
, GLdouble y
, GLdouble z
, GLdouble w
)
6825 __GLXcontext
* const gc
= __glXGetCurrentContext();
6826 const GLuint cmdlen
= 40;
6827 emit_header(gc
->pc
, X_GLrop_VertexAttrib4dvARB
, cmdlen
);
6828 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&x
), 8);
6829 (void) memcpy((void *)(gc
->pc
+ 12), (void *)(&y
), 8);
6830 (void) memcpy((void *)(gc
->pc
+ 20), (void *)(&z
), 8);
6831 (void) memcpy((void *)(gc
->pc
+ 28), (void *)(&w
), 8);
6832 (void) memcpy((void *)(gc
->pc
+ 36), (void *)(&index
), 4);
6834 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
6837 #define X_GLrop_VertexAttrib4dvARB 4200
6839 __indirect_glVertexAttrib4dvARB(GLuint index
, const GLdouble
* v
)
6841 __GLXcontext
* const gc
= __glXGetCurrentContext();
6842 const GLuint cmdlen
= 40;
6843 emit_header(gc
->pc
, X_GLrop_VertexAttrib4dvARB
, cmdlen
);
6844 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(v
), 32);
6845 (void) memcpy((void *)(gc
->pc
+ 36), (void *)(&index
), 4);
6847 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
6850 #define X_GLrop_VertexAttrib4fvARB 4196
6852 __indirect_glVertexAttrib4fARB(GLuint index
, GLfloat x
, GLfloat y
, GLfloat z
, GLfloat w
)
6854 __GLXcontext
* const gc
= __glXGetCurrentContext();
6855 const GLuint cmdlen
= 24;
6856 emit_header(gc
->pc
, X_GLrop_VertexAttrib4fvARB
, cmdlen
);
6857 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&index
), 4);
6858 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(&x
), 4);
6859 (void) memcpy((void *)(gc
->pc
+ 12), (void *)(&y
), 4);
6860 (void) memcpy((void *)(gc
->pc
+ 16), (void *)(&z
), 4);
6861 (void) memcpy((void *)(gc
->pc
+ 20), (void *)(&w
), 4);
6863 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
6866 #define X_GLrop_VertexAttrib4fvARB 4196
6868 __indirect_glVertexAttrib4fvARB(GLuint index
, const GLfloat
* v
)
6870 __GLXcontext
* const gc
= __glXGetCurrentContext();
6871 const GLuint cmdlen
= 24;
6872 emit_header(gc
->pc
, X_GLrop_VertexAttrib4fvARB
, cmdlen
);
6873 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&index
), 4);
6874 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(v
), 16);
6876 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
6879 #define X_GLrop_VertexAttrib4svARB 4192
6881 __indirect_glVertexAttrib4sARB(GLuint index
, GLshort x
, GLshort y
, GLshort z
, GLshort w
)
6883 __GLXcontext
* const gc
= __glXGetCurrentContext();
6884 const GLuint cmdlen
= 16;
6885 emit_header(gc
->pc
, X_GLrop_VertexAttrib4svARB
, cmdlen
);
6886 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&index
), 4);
6887 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(&x
), 2);
6888 (void) memcpy((void *)(gc
->pc
+ 10), (void *)(&y
), 2);
6889 (void) memcpy((void *)(gc
->pc
+ 12), (void *)(&z
), 2);
6890 (void) memcpy((void *)(gc
->pc
+ 14), (void *)(&w
), 2);
6892 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
6895 #define X_GLrop_VertexAttrib4svARB 4192
6897 __indirect_glVertexAttrib4svARB(GLuint index
, const GLshort
* v
)
6899 __GLXcontext
* const gc
= __glXGetCurrentContext();
6900 const GLuint cmdlen
= 16;
6901 emit_header(gc
->pc
, X_GLrop_VertexAttrib4svARB
, cmdlen
);
6902 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&index
), 4);
6903 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(v
), 8);
6905 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
6908 #define X_GLrop_VertexAttrib4NubvARB 4201
6910 __indirect_glVertexAttrib4NubARB(GLuint index
, GLubyte x
, GLubyte y
, GLubyte z
, GLubyte w
)
6912 __GLXcontext
* const gc
= __glXGetCurrentContext();
6913 const GLuint cmdlen
= 12;
6914 emit_header(gc
->pc
, X_GLrop_VertexAttrib4NubvARB
, cmdlen
);
6915 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&index
), 4);
6916 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(&x
), 1);
6917 (void) memcpy((void *)(gc
->pc
+ 9), (void *)(&y
), 1);
6918 (void) memcpy((void *)(gc
->pc
+ 10), (void *)(&z
), 1);
6919 (void) memcpy((void *)(gc
->pc
+ 11), (void *)(&w
), 1);
6921 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
6924 #define X_GLrop_VertexAttrib4NubvARB 4201
6926 __indirect_glVertexAttrib4NubvARB(GLuint index
, const GLubyte
* v
)
6928 __GLXcontext
* const gc
= __glXGetCurrentContext();
6929 const GLuint cmdlen
= 12;
6930 emit_header(gc
->pc
, X_GLrop_VertexAttrib4NubvARB
, cmdlen
);
6931 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&index
), 4);
6932 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(v
), 4);
6934 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
6937 #define X_GLrop_VertexAttribs1dvNV 4210
6939 __indirect_glVertexAttribs1dvNV(GLuint index
, GLsizei n
, const GLdouble
* v
)
6941 __GLXcontext
* const gc
= __glXGetCurrentContext();
6942 const GLuint cmdlen
= 12 + __GLX_PAD((n
* 8));
6943 if (__builtin_expect(n
>= 0, 1)) {
6944 emit_header(gc
->pc
, X_GLrop_VertexAttribs1dvNV
, cmdlen
);
6945 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&index
), 4);
6946 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(&n
), 4);
6947 (void) memcpy((void *)(gc
->pc
+ 12), (void *)(v
), (n
* 8));
6949 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
6953 #define X_GLrop_VertexAttribs1fvNV 4206
6955 __indirect_glVertexAttribs1fvNV(GLuint index
, GLsizei n
, const GLfloat
* v
)
6957 __GLXcontext
* const gc
= __glXGetCurrentContext();
6958 const GLuint cmdlen
= 12 + __GLX_PAD((n
* 4));
6959 if (__builtin_expect(n
>= 0, 1)) {
6960 emit_header(gc
->pc
, X_GLrop_VertexAttribs1fvNV
, cmdlen
);
6961 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&index
), 4);
6962 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(&n
), 4);
6963 (void) memcpy((void *)(gc
->pc
+ 12), (void *)(v
), (n
* 4));
6965 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
6969 #define X_GLrop_VertexAttribs1svNV 4202
6971 __indirect_glVertexAttribs1svNV(GLuint index
, GLsizei n
, const GLshort
* v
)
6973 __GLXcontext
* const gc
= __glXGetCurrentContext();
6974 const GLuint cmdlen
= 12 + __GLX_PAD((n
* 2));
6975 if (__builtin_expect(n
>= 0, 1)) {
6976 emit_header(gc
->pc
, X_GLrop_VertexAttribs1svNV
, cmdlen
);
6977 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&index
), 4);
6978 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(&n
), 4);
6979 (void) memcpy((void *)(gc
->pc
+ 12), (void *)(v
), (n
* 2));
6981 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
6985 #define X_GLrop_VertexAttribs2dvNV 4211
6987 __indirect_glVertexAttribs2dvNV(GLuint index
, GLsizei n
, const GLdouble
* v
)
6989 __GLXcontext
* const gc
= __glXGetCurrentContext();
6990 const GLuint cmdlen
= 12 + __GLX_PAD((n
* 16));
6991 if (__builtin_expect(n
>= 0, 1)) {
6992 emit_header(gc
->pc
, X_GLrop_VertexAttribs2dvNV
, cmdlen
);
6993 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&index
), 4);
6994 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(&n
), 4);
6995 (void) memcpy((void *)(gc
->pc
+ 12), (void *)(v
), (n
* 16));
6997 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
7001 #define X_GLrop_VertexAttribs2fvNV 4207
7003 __indirect_glVertexAttribs2fvNV(GLuint index
, GLsizei n
, const GLfloat
* v
)
7005 __GLXcontext
* const gc
= __glXGetCurrentContext();
7006 const GLuint cmdlen
= 12 + __GLX_PAD((n
* 8));
7007 if (__builtin_expect(n
>= 0, 1)) {
7008 emit_header(gc
->pc
, X_GLrop_VertexAttribs2fvNV
, cmdlen
);
7009 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&index
), 4);
7010 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(&n
), 4);
7011 (void) memcpy((void *)(gc
->pc
+ 12), (void *)(v
), (n
* 8));
7013 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
7017 #define X_GLrop_VertexAttribs2svNV 4203
7019 __indirect_glVertexAttribs2svNV(GLuint index
, GLsizei n
, const GLshort
* v
)
7021 __GLXcontext
* const gc
= __glXGetCurrentContext();
7022 const GLuint cmdlen
= 12 + __GLX_PAD((n
* 4));
7023 if (__builtin_expect(n
>= 0, 1)) {
7024 emit_header(gc
->pc
, X_GLrop_VertexAttribs2svNV
, cmdlen
);
7025 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&index
), 4);
7026 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(&n
), 4);
7027 (void) memcpy((void *)(gc
->pc
+ 12), (void *)(v
), (n
* 4));
7029 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
7033 #define X_GLrop_VertexAttribs3dvNV 4212
7035 __indirect_glVertexAttribs3dvNV(GLuint index
, GLsizei n
, const GLdouble
* v
)
7037 __GLXcontext
* const gc
= __glXGetCurrentContext();
7038 const GLuint cmdlen
= 12 + __GLX_PAD((n
* 24));
7039 if (__builtin_expect(n
>= 0, 1)) {
7040 emit_header(gc
->pc
, X_GLrop_VertexAttribs3dvNV
, cmdlen
);
7041 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&index
), 4);
7042 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(&n
), 4);
7043 (void) memcpy((void *)(gc
->pc
+ 12), (void *)(v
), (n
* 24));
7045 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
7049 #define X_GLrop_VertexAttribs3fvNV 4208
7051 __indirect_glVertexAttribs3fvNV(GLuint index
, GLsizei n
, const GLfloat
* v
)
7053 __GLXcontext
* const gc
= __glXGetCurrentContext();
7054 const GLuint cmdlen
= 12 + __GLX_PAD((n
* 12));
7055 if (__builtin_expect(n
>= 0, 1)) {
7056 emit_header(gc
->pc
, X_GLrop_VertexAttribs3fvNV
, cmdlen
);
7057 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&index
), 4);
7058 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(&n
), 4);
7059 (void) memcpy((void *)(gc
->pc
+ 12), (void *)(v
), (n
* 12));
7061 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
7065 #define X_GLrop_VertexAttribs3svNV 4204
7067 __indirect_glVertexAttribs3svNV(GLuint index
, GLsizei n
, const GLshort
* v
)
7069 __GLXcontext
* const gc
= __glXGetCurrentContext();
7070 const GLuint cmdlen
= 12 + __GLX_PAD((n
* 6));
7071 if (__builtin_expect(n
>= 0, 1)) {
7072 emit_header(gc
->pc
, X_GLrop_VertexAttribs3svNV
, cmdlen
);
7073 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&index
), 4);
7074 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(&n
), 4);
7075 (void) memcpy((void *)(gc
->pc
+ 12), (void *)(v
), (n
* 6));
7077 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
7081 #define X_GLrop_VertexAttribs4dvNV 4213
7083 __indirect_glVertexAttribs4dvNV(GLuint index
, GLsizei n
, const GLdouble
* v
)
7085 __GLXcontext
* const gc
= __glXGetCurrentContext();
7086 const GLuint cmdlen
= 12 + __GLX_PAD((n
* 32));
7087 if (__builtin_expect(n
>= 0, 1)) {
7088 emit_header(gc
->pc
, X_GLrop_VertexAttribs4dvNV
, cmdlen
);
7089 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&index
), 4);
7090 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(&n
), 4);
7091 (void) memcpy((void *)(gc
->pc
+ 12), (void *)(v
), (n
* 32));
7093 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
7097 #define X_GLrop_VertexAttribs4fvNV 4209
7099 __indirect_glVertexAttribs4fvNV(GLuint index
, GLsizei n
, const GLfloat
* v
)
7101 __GLXcontext
* const gc
= __glXGetCurrentContext();
7102 const GLuint cmdlen
= 12 + __GLX_PAD((n
* 16));
7103 if (__builtin_expect(n
>= 0, 1)) {
7104 emit_header(gc
->pc
, X_GLrop_VertexAttribs4fvNV
, cmdlen
);
7105 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&index
), 4);
7106 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(&n
), 4);
7107 (void) memcpy((void *)(gc
->pc
+ 12), (void *)(v
), (n
* 16));
7109 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
7113 #define X_GLrop_VertexAttribs4svNV 4205
7115 __indirect_glVertexAttribs4svNV(GLuint index
, GLsizei n
, const GLshort
* v
)
7117 __GLXcontext
* const gc
= __glXGetCurrentContext();
7118 const GLuint cmdlen
= 12 + __GLX_PAD((n
* 8));
7119 if (__builtin_expect(n
>= 0, 1)) {
7120 emit_header(gc
->pc
, X_GLrop_VertexAttribs4svNV
, cmdlen
);
7121 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&index
), 4);
7122 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(&n
), 4);
7123 (void) memcpy((void *)(gc
->pc
+ 12), (void *)(v
), (n
* 8));
7125 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
7129 #define X_GLrop_VertexAttribs4ubvNV 4214
7131 __indirect_glVertexAttribs4ubvNV(GLuint index
, GLsizei n
, const GLubyte
* v
)
7133 __GLXcontext
* const gc
= __glXGetCurrentContext();
7134 const GLuint cmdlen
= 12 + __GLX_PAD((n
* 4));
7135 if (__builtin_expect(n
>= 0, 1)) {
7136 emit_header(gc
->pc
, X_GLrop_VertexAttribs4ubvNV
, cmdlen
);
7137 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&index
), 4);
7138 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(&n
), 4);
7139 (void) memcpy((void *)(gc
->pc
+ 12), (void *)(v
), (n
* 4));
7141 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
7145 #define X_GLrop_PointParameteriNV 4221
7147 __indirect_glPointParameteriNV(GLenum pname
, GLint param
)
7149 __GLXcontext
* const gc
= __glXGetCurrentContext();
7150 const GLuint cmdlen
= 12;
7151 emit_header(gc
->pc
, X_GLrop_PointParameteriNV
, cmdlen
);
7152 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&pname
), 4);
7153 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(¶m
), 4);
7155 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
7158 #define X_GLrop_PointParameterivNV 4222
7160 __indirect_glPointParameterivNV(GLenum pname
, const GLint
* params
)
7162 __GLXcontext
* const gc
= __glXGetCurrentContext();
7163 const GLuint compsize
= __glPointParameterivNV_size(pname
);
7164 const GLuint cmdlen
= 8 + __GLX_PAD((compsize
* 4));
7165 emit_header(gc
->pc
, X_GLrop_PointParameterivNV
, cmdlen
);
7166 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&pname
), 4);
7167 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(params
), (compsize
* 4));
7169 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
7172 #define X_GLrop_ActiveStencilFaceEXT 4220
7174 __indirect_glActiveStencilFaceEXT(GLenum face
)
7176 __GLXcontext
* const gc
= __glXGetCurrentContext();
7177 const GLuint cmdlen
= 8;
7178 emit_header(gc
->pc
, X_GLrop_ActiveStencilFaceEXT
, cmdlen
);
7179 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&face
), 4);
7181 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
7184 #define X_GLrop_VertexAttrib4bvARB 4230
7186 __indirect_glVertexAttrib4bvARB(GLuint index
, const GLbyte
* v
)
7188 __GLXcontext
* const gc
= __glXGetCurrentContext();
7189 const GLuint cmdlen
= 12;
7190 emit_header(gc
->pc
, X_GLrop_VertexAttrib4bvARB
, cmdlen
);
7191 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&index
), 4);
7192 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(v
), 4);
7194 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
7197 #define X_GLrop_VertexAttrib4ivARB 4231
7199 __indirect_glVertexAttrib4ivARB(GLuint index
, const GLint
* v
)
7201 __GLXcontext
* const gc
= __glXGetCurrentContext();
7202 const GLuint cmdlen
= 24;
7203 emit_header(gc
->pc
, X_GLrop_VertexAttrib4ivARB
, cmdlen
);
7204 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&index
), 4);
7205 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(v
), 16);
7207 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
7210 #define X_GLrop_VertexAttrib4ubvARB 4232
7212 __indirect_glVertexAttrib4ubvARB(GLuint index
, const GLubyte
* v
)
7214 __GLXcontext
* const gc
= __glXGetCurrentContext();
7215 const GLuint cmdlen
= 12;
7216 emit_header(gc
->pc
, X_GLrop_VertexAttrib4ubvARB
, cmdlen
);
7217 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&index
), 4);
7218 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(v
), 4);
7220 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
7223 #define X_GLrop_VertexAttrib4usvARB 4233
7225 __indirect_glVertexAttrib4usvARB(GLuint index
, const GLushort
* v
)
7227 __GLXcontext
* const gc
= __glXGetCurrentContext();
7228 const GLuint cmdlen
= 16;
7229 emit_header(gc
->pc
, X_GLrop_VertexAttrib4usvARB
, cmdlen
);
7230 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&index
), 4);
7231 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(v
), 8);
7233 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
7236 #define X_GLrop_VertexAttrib4uivARB 4234
7238 __indirect_glVertexAttrib4uivARB(GLuint index
, const GLuint
* v
)
7240 __GLXcontext
* const gc
= __glXGetCurrentContext();
7241 const GLuint cmdlen
= 24;
7242 emit_header(gc
->pc
, X_GLrop_VertexAttrib4uivARB
, cmdlen
);
7243 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&index
), 4);
7244 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(v
), 16);
7246 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
7249 #define X_GLrop_VertexAttrib4NbvARB 4235
7251 __indirect_glVertexAttrib4NbvARB(GLuint index
, const GLbyte
* v
)
7253 __GLXcontext
* const gc
= __glXGetCurrentContext();
7254 const GLuint cmdlen
= 12;
7255 emit_header(gc
->pc
, X_GLrop_VertexAttrib4NbvARB
, cmdlen
);
7256 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&index
), 4);
7257 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(v
), 4);
7259 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
7262 #define X_GLrop_VertexAttrib4NsvARB 4236
7264 __indirect_glVertexAttrib4NsvARB(GLuint index
, const GLshort
* v
)
7266 __GLXcontext
* const gc
= __glXGetCurrentContext();
7267 const GLuint cmdlen
= 16;
7268 emit_header(gc
->pc
, X_GLrop_VertexAttrib4NsvARB
, cmdlen
);
7269 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&index
), 4);
7270 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(v
), 8);
7272 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
7275 #define X_GLrop_VertexAttrib4NivARB 4237
7277 __indirect_glVertexAttrib4NivARB(GLuint index
, const GLint
* v
)
7279 __GLXcontext
* const gc
= __glXGetCurrentContext();
7280 const GLuint cmdlen
= 24;
7281 emit_header(gc
->pc
, X_GLrop_VertexAttrib4NivARB
, cmdlen
);
7282 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&index
), 4);
7283 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(v
), 16);
7285 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
7288 #define X_GLrop_VertexAttrib4NusvARB 4238
7290 __indirect_glVertexAttrib4NusvARB(GLuint index
, const GLushort
* v
)
7292 __GLXcontext
* const gc
= __glXGetCurrentContext();
7293 const GLuint cmdlen
= 16;
7294 emit_header(gc
->pc
, X_GLrop_VertexAttrib4NusvARB
, cmdlen
);
7295 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&index
), 4);
7296 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(v
), 8);
7298 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
7301 #define X_GLrop_VertexAttrib4NuivARB 4239
7303 __indirect_glVertexAttrib4NuivARB(GLuint index
, const GLuint
* v
)
7305 __GLXcontext
* const gc
= __glXGetCurrentContext();
7306 const GLuint cmdlen
= 24;
7307 emit_header(gc
->pc
, X_GLrop_VertexAttrib4NuivARB
, cmdlen
);
7308 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&index
), 4);
7309 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(v
), 16);
7311 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
7314 #define X_GLrop_ProgramStringARB 4217
7316 __indirect_glProgramStringARB(GLenum target
, GLenum format
, GLsizei len
, const GLvoid
* string
)
7318 __GLXcontext
* const gc
= __glXGetCurrentContext();
7319 const GLuint cmdlen
= 16 + __GLX_PAD(len
);
7320 if (__builtin_expect((len
>= 0) && (gc
->currentDpy
!= NULL
), 1)) {
7321 if (cmdlen
<= gc
->maxSmallRenderCommandSize
) {
7322 if ( (gc
->pc
+ cmdlen
) > gc
->bufEnd
) {
7323 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
7325 emit_header(gc
->pc
, X_GLrop_ProgramStringARB
, cmdlen
);
7326 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&target
), 4);
7327 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(&format
), 4);
7328 (void) memcpy((void *)(gc
->pc
+ 12), (void *)(&len
), 4);
7329 (void) memcpy((void *)(gc
->pc
+ 16), (void *)(string
), len
);
7331 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
7334 const GLint op
= X_GLrop_ProgramStringARB
;
7335 const GLuint cmdlenLarge
= cmdlen
+ 4;
7336 GLubyte
* const pc
= __glXFlushRenderBuffer(gc
, gc
->pc
);
7337 (void) memcpy((void *)(pc
+ 0), (void *)(&cmdlenLarge
), 4);
7338 (void) memcpy((void *)(pc
+ 4), (void *)(&op
), 4);
7339 (void) memcpy((void *)(pc
+ 8), (void *)(&target
), 4);
7340 (void) memcpy((void *)(pc
+ 12), (void *)(&format
), 4);
7341 (void) memcpy((void *)(pc
+ 16), (void *)(&len
), 4);
7342 __glXSendLargeCommand(gc
, pc
, 20, string
, len
);
7347 #define X_GLrop_ProgramEnvParameter4dvARB 4185
7349 __indirect_glProgramEnvParameter4dARB(GLenum target
, GLuint index
, GLdouble x
, GLdouble y
, GLdouble z
, GLdouble w
)
7351 __GLXcontext
* const gc
= __glXGetCurrentContext();
7352 const GLuint cmdlen
= 44;
7353 emit_header(gc
->pc
, X_GLrop_ProgramEnvParameter4dvARB
, cmdlen
);
7354 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&target
), 4);
7355 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(&index
), 4);
7356 (void) memcpy((void *)(gc
->pc
+ 12), (void *)(&x
), 8);
7357 (void) memcpy((void *)(gc
->pc
+ 20), (void *)(&y
), 8);
7358 (void) memcpy((void *)(gc
->pc
+ 28), (void *)(&z
), 8);
7359 (void) memcpy((void *)(gc
->pc
+ 36), (void *)(&w
), 8);
7361 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
7364 #define X_GLrop_ProgramEnvParameter4dvARB 4185
7366 __indirect_glProgramEnvParameter4dvARB(GLenum target
, GLuint index
, const GLdouble
* params
)
7368 __GLXcontext
* const gc
= __glXGetCurrentContext();
7369 const GLuint cmdlen
= 44;
7370 emit_header(gc
->pc
, X_GLrop_ProgramEnvParameter4dvARB
, cmdlen
);
7371 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&target
), 4);
7372 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(&index
), 4);
7373 (void) memcpy((void *)(gc
->pc
+ 12), (void *)(params
), 32);
7375 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
7378 #define X_GLrop_ProgramEnvParameter4fvARB 4184
7380 __indirect_glProgramEnvParameter4fARB(GLenum target
, GLuint index
, GLfloat x
, GLfloat y
, GLfloat z
, GLfloat w
)
7382 __GLXcontext
* const gc
= __glXGetCurrentContext();
7383 const GLuint cmdlen
= 28;
7384 emit_header(gc
->pc
, X_GLrop_ProgramEnvParameter4fvARB
, cmdlen
);
7385 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&target
), 4);
7386 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(&index
), 4);
7387 (void) memcpy((void *)(gc
->pc
+ 12), (void *)(&x
), 4);
7388 (void) memcpy((void *)(gc
->pc
+ 16), (void *)(&y
), 4);
7389 (void) memcpy((void *)(gc
->pc
+ 20), (void *)(&z
), 4);
7390 (void) memcpy((void *)(gc
->pc
+ 24), (void *)(&w
), 4);
7392 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
7395 #define X_GLrop_ProgramEnvParameter4fvARB 4184
7397 __indirect_glProgramEnvParameter4fvARB(GLenum target
, GLuint index
, const GLfloat
* params
)
7399 __GLXcontext
* const gc
= __glXGetCurrentContext();
7400 const GLuint cmdlen
= 28;
7401 emit_header(gc
->pc
, X_GLrop_ProgramEnvParameter4fvARB
, cmdlen
);
7402 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&target
), 4);
7403 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(&index
), 4);
7404 (void) memcpy((void *)(gc
->pc
+ 12), (void *)(params
), 16);
7406 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
7409 #define X_GLrop_ProgramLocalParameter4dvARB 4216
7411 __indirect_glProgramLocalParameter4dARB(GLenum target
, GLuint index
, GLdouble x
, GLdouble y
, GLdouble z
, GLdouble w
)
7413 __GLXcontext
* const gc
= __glXGetCurrentContext();
7414 const GLuint cmdlen
= 44;
7415 emit_header(gc
->pc
, X_GLrop_ProgramLocalParameter4dvARB
, cmdlen
);
7416 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&target
), 4);
7417 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(&index
), 4);
7418 (void) memcpy((void *)(gc
->pc
+ 12), (void *)(&x
), 8);
7419 (void) memcpy((void *)(gc
->pc
+ 20), (void *)(&y
), 8);
7420 (void) memcpy((void *)(gc
->pc
+ 28), (void *)(&z
), 8);
7421 (void) memcpy((void *)(gc
->pc
+ 36), (void *)(&w
), 8);
7423 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
7426 #define X_GLrop_ProgramLocalParameter4dvARB 4216
7428 __indirect_glProgramLocalParameter4dvARB(GLenum target
, GLuint index
, const GLdouble
* params
)
7430 __GLXcontext
* const gc
= __glXGetCurrentContext();
7431 const GLuint cmdlen
= 44;
7432 emit_header(gc
->pc
, X_GLrop_ProgramLocalParameter4dvARB
, cmdlen
);
7433 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&target
), 4);
7434 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(&index
), 4);
7435 (void) memcpy((void *)(gc
->pc
+ 12), (void *)(params
), 32);
7437 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
7440 #define X_GLrop_ProgramLocalParameter4fvARB 4215
7442 __indirect_glProgramLocalParameter4fARB(GLenum target
, GLuint index
, GLfloat x
, GLfloat y
, GLfloat z
, GLfloat w
)
7444 __GLXcontext
* const gc
= __glXGetCurrentContext();
7445 const GLuint cmdlen
= 28;
7446 emit_header(gc
->pc
, X_GLrop_ProgramLocalParameter4fvARB
, cmdlen
);
7447 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&target
), 4);
7448 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(&index
), 4);
7449 (void) memcpy((void *)(gc
->pc
+ 12), (void *)(&x
), 4);
7450 (void) memcpy((void *)(gc
->pc
+ 16), (void *)(&y
), 4);
7451 (void) memcpy((void *)(gc
->pc
+ 20), (void *)(&z
), 4);
7452 (void) memcpy((void *)(gc
->pc
+ 24), (void *)(&w
), 4);
7454 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
7457 #define X_GLrop_ProgramLocalParameter4fvARB 4215
7459 __indirect_glProgramLocalParameter4fvARB(GLenum target
, GLuint index
, const GLfloat
* params
)
7461 __GLXcontext
* const gc
= __glXGetCurrentContext();
7462 const GLuint cmdlen
= 28;
7463 emit_header(gc
->pc
, X_GLrop_ProgramLocalParameter4fvARB
, cmdlen
);
7464 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&target
), 4);
7465 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(&index
), 4);
7466 (void) memcpy((void *)(gc
->pc
+ 12), (void *)(params
), 16);
7468 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
7471 #define X_GLvop_GetProgramivARB 1307
7473 __indirect_glGetProgramivARB(GLenum target
, GLenum pname
, GLint
* params
)
7475 __GLXcontext
* const gc
= __glXGetCurrentContext();
7476 Display
* const dpy
= gc
->currentDpy
;
7477 const GLuint cmdlen
= 8;
7478 if (__builtin_expect(dpy
!= NULL
, 1)) {
7479 GLubyte
const * pc
= __glXSetupVendorRequest(gc
, X_GLXVendorPrivateWithReply
, X_GLvop_GetProgramivARB
, cmdlen
);
7480 (void) memcpy((void *)(pc
+ 0), (void *)(&target
), 4);
7481 (void) memcpy((void *)(pc
+ 4), (void *)(&pname
), 4);
7482 (void) __glXReadReply(dpy
, 4, params
, GL_FALSE
);
7483 UnlockDisplay(dpy
); SyncHandle();
7488 #define X_GLvop_GetProgramStringARB 1308
7490 __indirect_glGetProgramStringARB(GLenum target
, GLenum pname
, GLvoid
* string
)
7492 __GLXcontext
* const gc
= __glXGetCurrentContext();
7493 Display
* const dpy
= gc
->currentDpy
;
7494 const GLuint cmdlen
= 8;
7495 if (__builtin_expect(dpy
!= NULL
, 1)) {
7496 GLubyte
const * pc
= __glXSetupVendorRequest(gc
, X_GLXVendorPrivateWithReply
, X_GLvop_GetProgramStringARB
, cmdlen
);
7497 (void) memcpy((void *)(pc
+ 0), (void *)(&target
), 4);
7498 (void) memcpy((void *)(pc
+ 4), (void *)(&pname
), 4);
7499 (void) __glXReadReply(dpy
, 1, string
, GL_TRUE
);
7500 UnlockDisplay(dpy
); SyncHandle();
7505 #define X_GLrop_ProgramNamedParameter4fvNV 4218
7507 __indirect_glProgramNamedParameter4fNV(GLuint id
, GLsizei len
, const GLubyte
* name
, GLfloat x
, GLfloat y
, GLfloat z
, GLfloat w
)
7509 __GLXcontext
* const gc
= __glXGetCurrentContext();
7510 const GLuint cmdlen
= 28 + __GLX_PAD(len
);
7511 if (__builtin_expect(len
>= 0, 1)) {
7512 emit_header(gc
->pc
, X_GLrop_ProgramNamedParameter4fvNV
, cmdlen
);
7513 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&id
), 4);
7514 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(&len
), 4);
7515 (void) memcpy((void *)(gc
->pc
+ 12), (void *)(&x
), 4);
7516 (void) memcpy((void *)(gc
->pc
+ 16), (void *)(&y
), 4);
7517 (void) memcpy((void *)(gc
->pc
+ 20), (void *)(&z
), 4);
7518 (void) memcpy((void *)(gc
->pc
+ 24), (void *)(&w
), 4);
7519 (void) memcpy((void *)(gc
->pc
+ 28), (void *)(name
), len
);
7521 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
7525 #define X_GLrop_ProgramNamedParameter4dvNV 4219
7527 __indirect_glProgramNamedParameter4dNV(GLuint id
, GLsizei len
, const GLubyte
* name
, GLdouble x
, GLdouble y
, GLdouble z
, GLdouble w
)
7529 __GLXcontext
* const gc
= __glXGetCurrentContext();
7530 const GLuint cmdlen
= 44 + __GLX_PAD(len
);
7531 if (__builtin_expect(len
>= 0, 1)) {
7532 emit_header(gc
->pc
, X_GLrop_ProgramNamedParameter4dvNV
, cmdlen
);
7533 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&x
), 8);
7534 (void) memcpy((void *)(gc
->pc
+ 12), (void *)(&y
), 8);
7535 (void) memcpy((void *)(gc
->pc
+ 20), (void *)(&z
), 8);
7536 (void) memcpy((void *)(gc
->pc
+ 28), (void *)(&w
), 8);
7537 (void) memcpy((void *)(gc
->pc
+ 36), (void *)(&id
), 4);
7538 (void) memcpy((void *)(gc
->pc
+ 40), (void *)(&len
), 4);
7539 (void) memcpy((void *)(gc
->pc
+ 44), (void *)(name
), len
);
7541 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
7545 #define X_GLrop_ProgramNamedParameter4fvNV 4218
7547 __indirect_glProgramNamedParameter4fvNV(GLuint id
, GLsizei len
, const GLubyte
* name
, const GLfloat
* v
)
7549 __GLXcontext
* const gc
= __glXGetCurrentContext();
7550 const GLuint cmdlen
= 28 + __GLX_PAD(len
);
7551 if (__builtin_expect(len
>= 0, 1)) {
7552 emit_header(gc
->pc
, X_GLrop_ProgramNamedParameter4fvNV
, cmdlen
);
7553 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&id
), 4);
7554 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(&len
), 4);
7555 (void) memcpy((void *)(gc
->pc
+ 12), (void *)(v
), 16);
7556 (void) memcpy((void *)(gc
->pc
+ 28), (void *)(name
), len
);
7558 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
7562 #define X_GLrop_ProgramNamedParameter4dvNV 4219
7564 __indirect_glProgramNamedParameter4dvNV(GLuint id
, GLsizei len
, const GLubyte
* name
, const GLdouble
* v
)
7566 __GLXcontext
* const gc
= __glXGetCurrentContext();
7567 const GLuint cmdlen
= 44 + __GLX_PAD(len
);
7568 if (__builtin_expect(len
>= 0, 1)) {
7569 emit_header(gc
->pc
, X_GLrop_ProgramNamedParameter4dvNV
, cmdlen
);
7570 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(v
), 32);
7571 (void) memcpy((void *)(gc
->pc
+ 36), (void *)(&id
), 4);
7572 (void) memcpy((void *)(gc
->pc
+ 40), (void *)(&len
), 4);
7573 (void) memcpy((void *)(gc
->pc
+ 44), (void *)(name
), len
);
7575 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
7579 #define X_GLvop_GetProgramNamedParameterfvNV 1310
7581 __indirect_glGetProgramNamedParameterfvNV(GLuint id
, GLsizei len
, const GLubyte
* name
, GLfloat
* params
)
7583 __GLXcontext
* const gc
= __glXGetCurrentContext();
7584 Display
* const dpy
= gc
->currentDpy
;
7585 const GLuint cmdlen
= 8 + __GLX_PAD(len
);
7586 if (__builtin_expect((len
>= 0) && (dpy
!= NULL
), 1)) {
7587 GLubyte
const * pc
= __glXSetupVendorRequest(gc
, X_GLXVendorPrivateWithReply
, X_GLvop_GetProgramNamedParameterfvNV
, cmdlen
);
7588 (void) memcpy((void *)(pc
+ 0), (void *)(&id
), 4);
7589 (void) memcpy((void *)(pc
+ 4), (void *)(&len
), 4);
7590 (void) memcpy((void *)(pc
+ 8), (void *)(name
), len
);
7591 (void) __glXReadReply(dpy
, 4, params
, GL_TRUE
);
7592 UnlockDisplay(dpy
); SyncHandle();
7597 #define X_GLvop_GetProgramNamedParameterdvNV 1311
7599 __indirect_glGetProgramNamedParameterdvNV(GLuint id
, GLsizei len
, const GLubyte
* name
, GLdouble
* params
)
7601 __GLXcontext
* const gc
= __glXGetCurrentContext();
7602 Display
* const dpy
= gc
->currentDpy
;
7603 const GLuint cmdlen
= 8 + __GLX_PAD(len
);
7604 if (__builtin_expect((len
>= 0) && (dpy
!= NULL
), 1)) {
7605 GLubyte
const * pc
= __glXSetupVendorRequest(gc
, X_GLXVendorPrivateWithReply
, X_GLvop_GetProgramNamedParameterdvNV
, cmdlen
);
7606 (void) memcpy((void *)(pc
+ 0), (void *)(&id
), 4);
7607 (void) memcpy((void *)(pc
+ 4), (void *)(&len
), 4);
7608 (void) memcpy((void *)(pc
+ 8), (void *)(name
), len
);
7609 (void) __glXReadReply(dpy
, 8, params
, GL_TRUE
);
7610 UnlockDisplay(dpy
); SyncHandle();
7615 #define X_GLsop_GenQueriesARB 162
7617 __indirect_glGenQueriesARB(GLsizei n
, GLuint
* ids
)
7619 __GLXcontext
* const gc
= __glXGetCurrentContext();
7620 Display
* const dpy
= gc
->currentDpy
;
7621 const GLuint cmdlen
= 4;
7622 if (__builtin_expect((n
>= 0) && (dpy
!= NULL
), 1)) {
7624 XCBConnection
*c
= XCBConnectionOfDisplay(dpy
);
7625 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
7626 XCBGlxGenQueriesARBRep
*reply
= XCBGlxGenQueriesARBReply(c
, XCBGlxGenQueriesARB(c
, gc
->currentContextTag
, n
), NULL
);
7627 (void)memcpy(ids
, XCBGlxGenQueriesARBData(reply
), XCBGlxGenQueriesARBDataLength(reply
) * sizeof(GLuint
));
7630 GLubyte
const * pc
= __glXSetupSingleRequest(gc
, X_GLsop_GenQueriesARB
, cmdlen
);
7631 (void) memcpy((void *)(pc
+ 0), (void *)(&n
), 4);
7632 (void) __glXReadReply(dpy
, 4, ids
, GL_TRUE
);
7633 UnlockDisplay(dpy
); SyncHandle();
7634 #endif /* USE_XCB */
7639 #define X_GLsop_DeleteQueriesARB 161
7641 __indirect_glDeleteQueriesARB(GLsizei n
, const GLuint
* ids
)
7643 __GLXcontext
* const gc
= __glXGetCurrentContext();
7644 Display
* const dpy
= gc
->currentDpy
;
7645 const GLuint cmdlen
= 4 + __GLX_PAD((n
* 4));
7646 if (__builtin_expect((n
>= 0) && (dpy
!= NULL
), 1)) {
7648 XCBConnection
*c
= XCBConnectionOfDisplay(dpy
);
7649 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
7650 XCBGlxDeleteQueriesARB(c
, gc
->currentContextTag
, n
, ids
);
7652 GLubyte
const * pc
= __glXSetupSingleRequest(gc
, X_GLsop_DeleteQueriesARB
, cmdlen
);
7653 (void) memcpy((void *)(pc
+ 0), (void *)(&n
), 4);
7654 (void) memcpy((void *)(pc
+ 4), (void *)(ids
), (n
* 4));
7655 UnlockDisplay(dpy
); SyncHandle();
7656 #endif /* USE_XCB */
7661 #define X_GLsop_IsQueryARB 163
7663 __indirect_glIsQueryARB(GLuint id
)
7665 __GLXcontext
* const gc
= __glXGetCurrentContext();
7666 Display
* const dpy
= gc
->currentDpy
;
7667 GLboolean retval
= (GLboolean
) 0;
7668 const GLuint cmdlen
= 4;
7669 if (__builtin_expect(dpy
!= NULL
, 1)) {
7671 XCBConnection
*c
= XCBConnectionOfDisplay(dpy
);
7672 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
7673 XCBGlxIsQueryARBRep
*reply
= XCBGlxIsQueryARBReply(c
, XCBGlxIsQueryARB(c
, gc
->currentContextTag
, id
), NULL
);
7674 retval
= reply
->ret_val
;
7677 GLubyte
const * pc
= __glXSetupSingleRequest(gc
, X_GLsop_IsQueryARB
, cmdlen
);
7678 (void) memcpy((void *)(pc
+ 0), (void *)(&id
), 4);
7679 retval
= (GLboolean
) __glXReadReply(dpy
, 0, NULL
, GL_FALSE
);
7680 UnlockDisplay(dpy
); SyncHandle();
7681 #endif /* USE_XCB */
7686 #define X_GLrop_BeginQueryARB 231
7688 __indirect_glBeginQueryARB(GLenum target
, GLuint id
)
7690 __GLXcontext
* const gc
= __glXGetCurrentContext();
7691 const GLuint cmdlen
= 12;
7692 emit_header(gc
->pc
, X_GLrop_BeginQueryARB
, cmdlen
);
7693 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&target
), 4);
7694 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(&id
), 4);
7696 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
7699 #define X_GLrop_EndQueryARB 232
7701 __indirect_glEndQueryARB(GLenum target
)
7703 __GLXcontext
* const gc
= __glXGetCurrentContext();
7704 const GLuint cmdlen
= 8;
7705 emit_header(gc
->pc
, X_GLrop_EndQueryARB
, cmdlen
);
7706 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&target
), 4);
7708 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
7711 #define X_GLsop_GetQueryivARB 164
7713 __indirect_glGetQueryivARB(GLenum target
, GLenum pname
, GLint
* params
)
7715 __GLXcontext
* const gc
= __glXGetCurrentContext();
7716 Display
* const dpy
= gc
->currentDpy
;
7717 const GLuint cmdlen
= 8;
7718 if (__builtin_expect(dpy
!= NULL
, 1)) {
7720 XCBConnection
*c
= XCBConnectionOfDisplay(dpy
);
7721 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
7722 XCBGlxGetQueryivARBRep
*reply
= XCBGlxGetQueryivARBReply(c
, XCBGlxGetQueryivARB(c
, gc
->currentContextTag
, target
, pname
), NULL
);
7723 if (XCBGlxGetQueryivARBDataLength(reply
) == 0)
7724 (void)memcpy(params
, &reply
->datum
, sizeof(reply
->datum
));
7726 (void)memcpy(params
, XCBGlxGetQueryivARBData(reply
), XCBGlxGetQueryivARBDataLength(reply
) * sizeof(GLint
));
7729 GLubyte
const * pc
= __glXSetupSingleRequest(gc
, X_GLsop_GetQueryivARB
, cmdlen
);
7730 (void) memcpy((void *)(pc
+ 0), (void *)(&target
), 4);
7731 (void) memcpy((void *)(pc
+ 4), (void *)(&pname
), 4);
7732 (void) __glXReadReply(dpy
, 4, params
, GL_FALSE
);
7733 UnlockDisplay(dpy
); SyncHandle();
7734 #endif /* USE_XCB */
7739 #define X_GLsop_GetQueryObjectivARB 165
7741 __indirect_glGetQueryObjectivARB(GLuint id
, GLenum pname
, GLint
* params
)
7743 __GLXcontext
* const gc
= __glXGetCurrentContext();
7744 Display
* const dpy
= gc
->currentDpy
;
7745 const GLuint cmdlen
= 8;
7746 if (__builtin_expect(dpy
!= NULL
, 1)) {
7748 XCBConnection
*c
= XCBConnectionOfDisplay(dpy
);
7749 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
7750 XCBGlxGetQueryObjectivARBRep
*reply
= XCBGlxGetQueryObjectivARBReply(c
, XCBGlxGetQueryObjectivARB(c
, gc
->currentContextTag
, id
, pname
), NULL
);
7751 if (XCBGlxGetQueryObjectivARBDataLength(reply
) == 0)
7752 (void)memcpy(params
, &reply
->datum
, sizeof(reply
->datum
));
7754 (void)memcpy(params
, XCBGlxGetQueryObjectivARBData(reply
), XCBGlxGetQueryObjectivARBDataLength(reply
) * sizeof(GLint
));
7757 GLubyte
const * pc
= __glXSetupSingleRequest(gc
, X_GLsop_GetQueryObjectivARB
, cmdlen
);
7758 (void) memcpy((void *)(pc
+ 0), (void *)(&id
), 4);
7759 (void) memcpy((void *)(pc
+ 4), (void *)(&pname
), 4);
7760 (void) __glXReadReply(dpy
, 4, params
, GL_FALSE
);
7761 UnlockDisplay(dpy
); SyncHandle();
7762 #endif /* USE_XCB */
7767 #define X_GLsop_GetQueryObjectuivARB 166
7769 __indirect_glGetQueryObjectuivARB(GLuint id
, GLenum pname
, GLuint
* params
)
7771 __GLXcontext
* const gc
= __glXGetCurrentContext();
7772 Display
* const dpy
= gc
->currentDpy
;
7773 const GLuint cmdlen
= 8;
7774 if (__builtin_expect(dpy
!= NULL
, 1)) {
7776 XCBConnection
*c
= XCBConnectionOfDisplay(dpy
);
7777 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
7778 XCBGlxGetQueryObjectuivARBRep
*reply
= XCBGlxGetQueryObjectuivARBReply(c
, XCBGlxGetQueryObjectuivARB(c
, gc
->currentContextTag
, id
, pname
), NULL
);
7779 if (XCBGlxGetQueryObjectuivARBDataLength(reply
) == 0)
7780 (void)memcpy(params
, &reply
->datum
, sizeof(reply
->datum
));
7782 (void)memcpy(params
, XCBGlxGetQueryObjectuivARBData(reply
), XCBGlxGetQueryObjectuivARBDataLength(reply
) * sizeof(GLuint
));
7785 GLubyte
const * pc
= __glXSetupSingleRequest(gc
, X_GLsop_GetQueryObjectuivARB
, cmdlen
);
7786 (void) memcpy((void *)(pc
+ 0), (void *)(&id
), 4);
7787 (void) memcpy((void *)(pc
+ 4), (void *)(&pname
), 4);
7788 (void) __glXReadReply(dpy
, 4, params
, GL_FALSE
);
7789 UnlockDisplay(dpy
); SyncHandle();
7790 #endif /* USE_XCB */
7795 #define X_GLvop_GetVertexAttribdvNV 1301
7797 __indirect_glGetVertexAttribdvNV(GLuint index
, GLenum pname
, GLdouble
* params
)
7799 __GLXcontext
* const gc
= __glXGetCurrentContext();
7800 Display
* const dpy
= gc
->currentDpy
;
7801 const GLuint cmdlen
= 8;
7802 if (__builtin_expect(dpy
!= NULL
, 1)) {
7803 GLubyte
const * pc
= __glXSetupVendorRequest(gc
, X_GLXVendorPrivateWithReply
, X_GLvop_GetVertexAttribdvNV
, cmdlen
);
7804 (void) memcpy((void *)(pc
+ 0), (void *)(&index
), 4);
7805 (void) memcpy((void *)(pc
+ 4), (void *)(&pname
), 4);
7806 (void) __glXReadReply(dpy
, 8, params
, GL_FALSE
);
7807 UnlockDisplay(dpy
); SyncHandle();
7812 #define X_GLvop_GetVertexAttribfvNV 1302
7814 __indirect_glGetVertexAttribfvNV(GLuint index
, GLenum pname
, GLfloat
* params
)
7816 __GLXcontext
* const gc
= __glXGetCurrentContext();
7817 Display
* const dpy
= gc
->currentDpy
;
7818 const GLuint cmdlen
= 8;
7819 if (__builtin_expect(dpy
!= NULL
, 1)) {
7820 GLubyte
const * pc
= __glXSetupVendorRequest(gc
, X_GLXVendorPrivateWithReply
, X_GLvop_GetVertexAttribfvNV
, cmdlen
);
7821 (void) memcpy((void *)(pc
+ 0), (void *)(&index
), 4);
7822 (void) memcpy((void *)(pc
+ 4), (void *)(&pname
), 4);
7823 (void) __glXReadReply(dpy
, 4, params
, GL_FALSE
);
7824 UnlockDisplay(dpy
); SyncHandle();
7829 #define X_GLvop_GetVertexAttribivNV 1303
7831 __indirect_glGetVertexAttribivNV(GLuint index
, GLenum pname
, GLint
* params
)
7833 __GLXcontext
* const gc
= __glXGetCurrentContext();
7834 Display
* const dpy
= gc
->currentDpy
;
7835 const GLuint cmdlen
= 8;
7836 if (__builtin_expect(dpy
!= NULL
, 1)) {
7837 GLubyte
const * pc
= __glXSetupVendorRequest(gc
, X_GLXVendorPrivateWithReply
, X_GLvop_GetVertexAttribivNV
, cmdlen
);
7838 (void) memcpy((void *)(pc
+ 0), (void *)(&index
), 4);
7839 (void) memcpy((void *)(pc
+ 4), (void *)(&pname
), 4);
7840 (void) __glXReadReply(dpy
, 4, params
, GL_FALSE
);
7841 UnlockDisplay(dpy
); SyncHandle();
7846 #define X_GLrop_VertexAttrib1dvNV 4197
7848 __indirect_glVertexAttrib1dNV(GLuint index
, GLdouble x
)
7850 __GLXcontext
* const gc
= __glXGetCurrentContext();
7851 const GLuint cmdlen
= 16;
7852 emit_header(gc
->pc
, X_GLrop_VertexAttrib1dvNV
, cmdlen
);
7853 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&index
), 4);
7854 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(&x
), 8);
7856 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
7859 #define X_GLrop_VertexAttrib1dvNV 4197
7861 __indirect_glVertexAttrib1dvNV(GLuint index
, const GLdouble
* v
)
7863 __GLXcontext
* const gc
= __glXGetCurrentContext();
7864 const GLuint cmdlen
= 16;
7865 emit_header(gc
->pc
, X_GLrop_VertexAttrib1dvNV
, cmdlen
);
7866 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&index
), 4);
7867 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(v
), 8);
7869 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
7872 #define X_GLrop_VertexAttrib1fvNV 4193
7874 __indirect_glVertexAttrib1fNV(GLuint index
, GLfloat x
)
7876 __GLXcontext
* const gc
= __glXGetCurrentContext();
7877 const GLuint cmdlen
= 12;
7878 emit_header(gc
->pc
, X_GLrop_VertexAttrib1fvNV
, cmdlen
);
7879 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&index
), 4);
7880 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(&x
), 4);
7882 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
7885 #define X_GLrop_VertexAttrib1fvNV 4193
7887 __indirect_glVertexAttrib1fvNV(GLuint index
, const GLfloat
* v
)
7889 __GLXcontext
* const gc
= __glXGetCurrentContext();
7890 const GLuint cmdlen
= 12;
7891 emit_header(gc
->pc
, X_GLrop_VertexAttrib1fvNV
, cmdlen
);
7892 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&index
), 4);
7893 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(v
), 4);
7895 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
7898 #define X_GLrop_VertexAttrib1svNV 4189
7900 __indirect_glVertexAttrib1sNV(GLuint index
, GLshort x
)
7902 __GLXcontext
* const gc
= __glXGetCurrentContext();
7903 const GLuint cmdlen
= 12;
7904 emit_header(gc
->pc
, X_GLrop_VertexAttrib1svNV
, cmdlen
);
7905 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&index
), 4);
7906 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(&x
), 2);
7908 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
7911 #define X_GLrop_VertexAttrib1svNV 4189
7913 __indirect_glVertexAttrib1svNV(GLuint index
, const GLshort
* v
)
7915 __GLXcontext
* const gc
= __glXGetCurrentContext();
7916 const GLuint cmdlen
= 12;
7917 emit_header(gc
->pc
, X_GLrop_VertexAttrib1svNV
, cmdlen
);
7918 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&index
), 4);
7919 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(v
), 2);
7921 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
7924 #define X_GLrop_VertexAttrib2dvNV 4198
7926 __indirect_glVertexAttrib2dNV(GLuint index
, GLdouble x
, GLdouble y
)
7928 __GLXcontext
* const gc
= __glXGetCurrentContext();
7929 const GLuint cmdlen
= 24;
7930 emit_header(gc
->pc
, X_GLrop_VertexAttrib2dvNV
, cmdlen
);
7931 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&index
), 4);
7932 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(&x
), 8);
7933 (void) memcpy((void *)(gc
->pc
+ 16), (void *)(&y
), 8);
7935 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
7938 #define X_GLrop_VertexAttrib2dvNV 4198
7940 __indirect_glVertexAttrib2dvNV(GLuint index
, const GLdouble
* v
)
7942 __GLXcontext
* const gc
= __glXGetCurrentContext();
7943 const GLuint cmdlen
= 24;
7944 emit_header(gc
->pc
, X_GLrop_VertexAttrib2dvNV
, cmdlen
);
7945 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&index
), 4);
7946 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(v
), 16);
7948 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
7951 #define X_GLrop_VertexAttrib2fvNV 4194
7953 __indirect_glVertexAttrib2fNV(GLuint index
, GLfloat x
, GLfloat y
)
7955 __GLXcontext
* const gc
= __glXGetCurrentContext();
7956 const GLuint cmdlen
= 16;
7957 emit_header(gc
->pc
, X_GLrop_VertexAttrib2fvNV
, cmdlen
);
7958 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&index
), 4);
7959 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(&x
), 4);
7960 (void) memcpy((void *)(gc
->pc
+ 12), (void *)(&y
), 4);
7962 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
7965 #define X_GLrop_VertexAttrib2fvNV 4194
7967 __indirect_glVertexAttrib2fvNV(GLuint index
, const GLfloat
* v
)
7969 __GLXcontext
* const gc
= __glXGetCurrentContext();
7970 const GLuint cmdlen
= 16;
7971 emit_header(gc
->pc
, X_GLrop_VertexAttrib2fvNV
, cmdlen
);
7972 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&index
), 4);
7973 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(v
), 8);
7975 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
7978 #define X_GLrop_VertexAttrib2svNV 4190
7980 __indirect_glVertexAttrib2sNV(GLuint index
, GLshort x
, GLshort y
)
7982 __GLXcontext
* const gc
= __glXGetCurrentContext();
7983 const GLuint cmdlen
= 12;
7984 emit_header(gc
->pc
, X_GLrop_VertexAttrib2svNV
, cmdlen
);
7985 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&index
), 4);
7986 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(&x
), 2);
7987 (void) memcpy((void *)(gc
->pc
+ 10), (void *)(&y
), 2);
7989 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
7992 #define X_GLrop_VertexAttrib2svNV 4190
7994 __indirect_glVertexAttrib2svNV(GLuint index
, const GLshort
* v
)
7996 __GLXcontext
* const gc
= __glXGetCurrentContext();
7997 const GLuint cmdlen
= 12;
7998 emit_header(gc
->pc
, X_GLrop_VertexAttrib2svNV
, cmdlen
);
7999 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&index
), 4);
8000 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(v
), 4);
8002 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
8005 #define X_GLrop_VertexAttrib3dvNV 4199
8007 __indirect_glVertexAttrib3dNV(GLuint index
, GLdouble x
, GLdouble y
, GLdouble z
)
8009 __GLXcontext
* const gc
= __glXGetCurrentContext();
8010 const GLuint cmdlen
= 32;
8011 emit_header(gc
->pc
, X_GLrop_VertexAttrib3dvNV
, cmdlen
);
8012 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&index
), 4);
8013 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(&x
), 8);
8014 (void) memcpy((void *)(gc
->pc
+ 16), (void *)(&y
), 8);
8015 (void) memcpy((void *)(gc
->pc
+ 24), (void *)(&z
), 8);
8017 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
8020 #define X_GLrop_VertexAttrib3dvNV 4199
8022 __indirect_glVertexAttrib3dvNV(GLuint index
, const GLdouble
* v
)
8024 __GLXcontext
* const gc
= __glXGetCurrentContext();
8025 const GLuint cmdlen
= 32;
8026 emit_header(gc
->pc
, X_GLrop_VertexAttrib3dvNV
, cmdlen
);
8027 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&index
), 4);
8028 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(v
), 24);
8030 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
8033 #define X_GLrop_VertexAttrib3fvNV 4195
8035 __indirect_glVertexAttrib3fNV(GLuint index
, GLfloat x
, GLfloat y
, GLfloat z
)
8037 __GLXcontext
* const gc
= __glXGetCurrentContext();
8038 const GLuint cmdlen
= 20;
8039 emit_header(gc
->pc
, X_GLrop_VertexAttrib3fvNV
, cmdlen
);
8040 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&index
), 4);
8041 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(&x
), 4);
8042 (void) memcpy((void *)(gc
->pc
+ 12), (void *)(&y
), 4);
8043 (void) memcpy((void *)(gc
->pc
+ 16), (void *)(&z
), 4);
8045 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
8048 #define X_GLrop_VertexAttrib3fvNV 4195
8050 __indirect_glVertexAttrib3fvNV(GLuint index
, const GLfloat
* v
)
8052 __GLXcontext
* const gc
= __glXGetCurrentContext();
8053 const GLuint cmdlen
= 20;
8054 emit_header(gc
->pc
, X_GLrop_VertexAttrib3fvNV
, cmdlen
);
8055 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&index
), 4);
8056 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(v
), 12);
8058 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
8061 #define X_GLrop_VertexAttrib3svNV 4191
8063 __indirect_glVertexAttrib3sNV(GLuint index
, GLshort x
, GLshort y
, GLshort z
)
8065 __GLXcontext
* const gc
= __glXGetCurrentContext();
8066 const GLuint cmdlen
= 16;
8067 emit_header(gc
->pc
, X_GLrop_VertexAttrib3svNV
, cmdlen
);
8068 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&index
), 4);
8069 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(&x
), 2);
8070 (void) memcpy((void *)(gc
->pc
+ 10), (void *)(&y
), 2);
8071 (void) memcpy((void *)(gc
->pc
+ 12), (void *)(&z
), 2);
8073 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
8076 #define X_GLrop_VertexAttrib3svNV 4191
8078 __indirect_glVertexAttrib3svNV(GLuint index
, const GLshort
* v
)
8080 __GLXcontext
* const gc
= __glXGetCurrentContext();
8081 const GLuint cmdlen
= 16;
8082 emit_header(gc
->pc
, X_GLrop_VertexAttrib3svNV
, cmdlen
);
8083 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&index
), 4);
8084 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(v
), 6);
8086 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
8089 #define X_GLrop_VertexAttrib4dvNV 4200
8091 __indirect_glVertexAttrib4dNV(GLuint index
, GLdouble x
, GLdouble y
, GLdouble z
, GLdouble w
)
8093 __GLXcontext
* const gc
= __glXGetCurrentContext();
8094 const GLuint cmdlen
= 40;
8095 emit_header(gc
->pc
, X_GLrop_VertexAttrib4dvNV
, cmdlen
);
8096 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&index
), 4);
8097 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(&x
), 8);
8098 (void) memcpy((void *)(gc
->pc
+ 16), (void *)(&y
), 8);
8099 (void) memcpy((void *)(gc
->pc
+ 24), (void *)(&z
), 8);
8100 (void) memcpy((void *)(gc
->pc
+ 32), (void *)(&w
), 8);
8102 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
8105 #define X_GLrop_VertexAttrib4dvNV 4200
8107 __indirect_glVertexAttrib4dvNV(GLuint index
, const GLdouble
* v
)
8109 __GLXcontext
* const gc
= __glXGetCurrentContext();
8110 const GLuint cmdlen
= 40;
8111 emit_header(gc
->pc
, X_GLrop_VertexAttrib4dvNV
, cmdlen
);
8112 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&index
), 4);
8113 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(v
), 32);
8115 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
8118 #define X_GLrop_VertexAttrib4fvNV 4196
8120 __indirect_glVertexAttrib4fNV(GLuint index
, GLfloat x
, GLfloat y
, GLfloat z
, GLfloat w
)
8122 __GLXcontext
* const gc
= __glXGetCurrentContext();
8123 const GLuint cmdlen
= 24;
8124 emit_header(gc
->pc
, X_GLrop_VertexAttrib4fvNV
, cmdlen
);
8125 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&index
), 4);
8126 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(&x
), 4);
8127 (void) memcpy((void *)(gc
->pc
+ 12), (void *)(&y
), 4);
8128 (void) memcpy((void *)(gc
->pc
+ 16), (void *)(&z
), 4);
8129 (void) memcpy((void *)(gc
->pc
+ 20), (void *)(&w
), 4);
8131 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
8134 #define X_GLrop_VertexAttrib4fvNV 4196
8136 __indirect_glVertexAttrib4fvNV(GLuint index
, const GLfloat
* v
)
8138 __GLXcontext
* const gc
= __glXGetCurrentContext();
8139 const GLuint cmdlen
= 24;
8140 emit_header(gc
->pc
, X_GLrop_VertexAttrib4fvNV
, cmdlen
);
8141 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&index
), 4);
8142 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(v
), 16);
8144 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
8147 #define X_GLrop_VertexAttrib4svNV 4192
8149 __indirect_glVertexAttrib4sNV(GLuint index
, GLshort x
, GLshort y
, GLshort z
, GLshort w
)
8151 __GLXcontext
* const gc
= __glXGetCurrentContext();
8152 const GLuint cmdlen
= 16;
8153 emit_header(gc
->pc
, X_GLrop_VertexAttrib4svNV
, cmdlen
);
8154 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&index
), 4);
8155 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(&x
), 2);
8156 (void) memcpy((void *)(gc
->pc
+ 10), (void *)(&y
), 2);
8157 (void) memcpy((void *)(gc
->pc
+ 12), (void *)(&z
), 2);
8158 (void) memcpy((void *)(gc
->pc
+ 14), (void *)(&w
), 2);
8160 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
8163 #define X_GLrop_VertexAttrib4svNV 4192
8165 __indirect_glVertexAttrib4svNV(GLuint index
, const GLshort
* v
)
8167 __GLXcontext
* const gc
= __glXGetCurrentContext();
8168 const GLuint cmdlen
= 16;
8169 emit_header(gc
->pc
, X_GLrop_VertexAttrib4svNV
, cmdlen
);
8170 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&index
), 4);
8171 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(v
), 8);
8173 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
8176 #define X_GLrop_VertexAttrib4ubvNV 4201
8178 __indirect_glVertexAttrib4ubNV(GLuint index
, GLubyte x
, GLubyte y
, GLubyte z
, GLubyte w
)
8180 __GLXcontext
* const gc
= __glXGetCurrentContext();
8181 const GLuint cmdlen
= 12;
8182 emit_header(gc
->pc
, X_GLrop_VertexAttrib4ubvNV
, cmdlen
);
8183 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&index
), 4);
8184 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(&x
), 1);
8185 (void) memcpy((void *)(gc
->pc
+ 9), (void *)(&y
), 1);
8186 (void) memcpy((void *)(gc
->pc
+ 10), (void *)(&z
), 1);
8187 (void) memcpy((void *)(gc
->pc
+ 11), (void *)(&w
), 1);
8189 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
8192 #define X_GLrop_VertexAttrib4ubvNV 4201
8194 __indirect_glVertexAttrib4ubvNV(GLuint index
, const GLubyte
* v
)
8196 __GLXcontext
* const gc
= __glXGetCurrentContext();
8197 const GLuint cmdlen
= 12;
8198 emit_header(gc
->pc
, X_GLrop_VertexAttrib4ubvNV
, cmdlen
);
8199 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&index
), 4);
8200 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(v
), 4);
8202 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
8205 #define X_GLvop_IsRenderbufferEXT 1422
8207 __indirect_glIsRenderbufferEXT(GLuint renderbuffer
)
8209 __GLXcontext
* const gc
= __glXGetCurrentContext();
8210 Display
* const dpy
= gc
->currentDpy
;
8211 GLboolean retval
= (GLboolean
) 0;
8212 const GLuint cmdlen
= 4;
8213 if (__builtin_expect(dpy
!= NULL
, 1)) {
8214 GLubyte
const * pc
= __glXSetupVendorRequest(gc
, X_GLXVendorPrivateWithReply
, X_GLvop_IsRenderbufferEXT
, cmdlen
);
8215 (void) memcpy((void *)(pc
+ 0), (void *)(&renderbuffer
), 4);
8216 retval
= (GLboolean
) __glXReadReply(dpy
, 0, NULL
, GL_FALSE
);
8217 UnlockDisplay(dpy
); SyncHandle();
8222 #define X_GLrop_BindRenderbufferEXT 4316
8224 __indirect_glBindRenderbufferEXT(GLenum target
, GLuint renderbuffer
)
8226 __GLXcontext
* const gc
= __glXGetCurrentContext();
8227 const GLuint cmdlen
= 12;
8228 emit_header(gc
->pc
, X_GLrop_BindRenderbufferEXT
, cmdlen
);
8229 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&target
), 4);
8230 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(&renderbuffer
), 4);
8232 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
8235 #define X_GLrop_DeleteRenderbuffersEXT 4317
8237 __indirect_glDeleteRenderbuffersEXT(GLsizei n
, const GLuint
* renderbuffers
)
8239 __GLXcontext
* const gc
= __glXGetCurrentContext();
8240 const GLuint cmdlen
= 8 + __GLX_PAD((n
* 4));
8241 if (__builtin_expect(n
>= 0, 1)) {
8242 emit_header(gc
->pc
, X_GLrop_DeleteRenderbuffersEXT
, cmdlen
);
8243 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&n
), 4);
8244 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(renderbuffers
), (n
* 4));
8246 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
8250 #define X_GLvop_GenRenderbuffersEXT 1423
8252 __indirect_glGenRenderbuffersEXT(GLsizei n
, GLuint
* renderbuffers
)
8254 __GLXcontext
* const gc
= __glXGetCurrentContext();
8255 Display
* const dpy
= gc
->currentDpy
;
8256 const GLuint cmdlen
= 4;
8257 if (__builtin_expect((n
>= 0) && (dpy
!= NULL
), 1)) {
8258 GLubyte
const * pc
= __glXSetupVendorRequest(gc
, X_GLXVendorPrivateWithReply
, X_GLvop_GenRenderbuffersEXT
, cmdlen
);
8259 (void) memcpy((void *)(pc
+ 0), (void *)(&n
), 4);
8260 (void) __glXReadReply(dpy
, 4, renderbuffers
, GL_TRUE
);
8261 UnlockDisplay(dpy
); SyncHandle();
8266 #define X_GLrop_RenderbufferStorageEXT 4318
8268 __indirect_glRenderbufferStorageEXT(GLenum target
, GLenum internalformat
, GLsizei width
, GLsizei height
)
8270 __GLXcontext
* const gc
= __glXGetCurrentContext();
8271 const GLuint cmdlen
= 20;
8272 emit_header(gc
->pc
, X_GLrop_RenderbufferStorageEXT
, cmdlen
);
8273 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&target
), 4);
8274 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(&internalformat
), 4);
8275 (void) memcpy((void *)(gc
->pc
+ 12), (void *)(&width
), 4);
8276 (void) memcpy((void *)(gc
->pc
+ 16), (void *)(&height
), 4);
8278 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
8281 #define X_GLvop_GetRenderbufferParameterivEXT 1424
8283 __indirect_glGetRenderbufferParameterivEXT(GLenum target
, GLenum pname
, GLint
* params
)
8285 __GLXcontext
* const gc
= __glXGetCurrentContext();
8286 Display
* const dpy
= gc
->currentDpy
;
8287 const GLuint cmdlen
= 8;
8288 if (__builtin_expect(dpy
!= NULL
, 1)) {
8289 GLubyte
const * pc
= __glXSetupVendorRequest(gc
, X_GLXVendorPrivateWithReply
, X_GLvop_GetRenderbufferParameterivEXT
, cmdlen
);
8290 (void) memcpy((void *)(pc
+ 0), (void *)(&target
), 4);
8291 (void) memcpy((void *)(pc
+ 4), (void *)(&pname
), 4);
8292 (void) __glXReadReply(dpy
, 4, params
, GL_FALSE
);
8293 UnlockDisplay(dpy
); SyncHandle();
8298 #define X_GLvop_IsFramebufferEXT 1425
8300 __indirect_glIsFramebufferEXT(GLuint framebuffer
)
8302 __GLXcontext
* const gc
= __glXGetCurrentContext();
8303 Display
* const dpy
= gc
->currentDpy
;
8304 GLboolean retval
= (GLboolean
) 0;
8305 const GLuint cmdlen
= 4;
8306 if (__builtin_expect(dpy
!= NULL
, 1)) {
8307 GLubyte
const * pc
= __glXSetupVendorRequest(gc
, X_GLXVendorPrivateWithReply
, X_GLvop_IsFramebufferEXT
, cmdlen
);
8308 (void) memcpy((void *)(pc
+ 0), (void *)(&framebuffer
), 4);
8309 retval
= (GLboolean
) __glXReadReply(dpy
, 0, NULL
, GL_FALSE
);
8310 UnlockDisplay(dpy
); SyncHandle();
8315 #define X_GLrop_BindFramebufferEXT 4319
8317 __indirect_glBindFramebufferEXT(GLenum target
, GLuint framebuffer
)
8319 __GLXcontext
* const gc
= __glXGetCurrentContext();
8320 const GLuint cmdlen
= 12;
8321 emit_header(gc
->pc
, X_GLrop_BindFramebufferEXT
, cmdlen
);
8322 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&target
), 4);
8323 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(&framebuffer
), 4);
8325 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
8328 #define X_GLrop_DeleteFramebuffersEXT 4320
8330 __indirect_glDeleteFramebuffersEXT(GLsizei n
, const GLuint
* framebuffers
)
8332 __GLXcontext
* const gc
= __glXGetCurrentContext();
8333 const GLuint cmdlen
= 8 + __GLX_PAD((n
* 4));
8334 if (__builtin_expect(n
>= 0, 1)) {
8335 emit_header(gc
->pc
, X_GLrop_DeleteFramebuffersEXT
, cmdlen
);
8336 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&n
), 4);
8337 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(framebuffers
), (n
* 4));
8339 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
8343 #define X_GLvop_GenFramebuffersEXT 1426
8345 __indirect_glGenFramebuffersEXT(GLsizei n
, GLuint
* framebuffers
)
8347 __GLXcontext
* const gc
= __glXGetCurrentContext();
8348 Display
* const dpy
= gc
->currentDpy
;
8349 const GLuint cmdlen
= 4;
8350 if (__builtin_expect((n
>= 0) && (dpy
!= NULL
), 1)) {
8351 GLubyte
const * pc
= __glXSetupVendorRequest(gc
, X_GLXVendorPrivateWithReply
, X_GLvop_GenFramebuffersEXT
, cmdlen
);
8352 (void) memcpy((void *)(pc
+ 0), (void *)(&n
), 4);
8353 (void) __glXReadReply(dpy
, 4, framebuffers
, GL_TRUE
);
8354 UnlockDisplay(dpy
); SyncHandle();
8359 #define X_GLvop_CheckFramebufferStatusEXT 1427
8361 __indirect_glCheckFramebufferStatusEXT(GLenum target
)
8363 __GLXcontext
* const gc
= __glXGetCurrentContext();
8364 Display
* const dpy
= gc
->currentDpy
;
8365 GLenum retval
= (GLenum
) 0;
8366 const GLuint cmdlen
= 4;
8367 if (__builtin_expect(dpy
!= NULL
, 1)) {
8368 GLubyte
const * pc
= __glXSetupVendorRequest(gc
, X_GLXVendorPrivateWithReply
, X_GLvop_CheckFramebufferStatusEXT
, cmdlen
);
8369 (void) memcpy((void *)(pc
+ 0), (void *)(&target
), 4);
8370 retval
= (GLenum
) __glXReadReply(dpy
, 0, NULL
, GL_FALSE
);
8371 UnlockDisplay(dpy
); SyncHandle();
8376 #define X_GLrop_FramebufferTexture1DEXT 4321
8378 __indirect_glFramebufferTexture1DEXT(GLenum target
, GLenum attachment
, GLenum textarget
, GLuint texture
, GLint level
)
8380 __GLXcontext
* const gc
= __glXGetCurrentContext();
8381 const GLuint cmdlen
= 24;
8382 emit_header(gc
->pc
, X_GLrop_FramebufferTexture1DEXT
, cmdlen
);
8383 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&target
), 4);
8384 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(&attachment
), 4);
8385 (void) memcpy((void *)(gc
->pc
+ 12), (void *)(&textarget
), 4);
8386 (void) memcpy((void *)(gc
->pc
+ 16), (void *)(&texture
), 4);
8387 (void) memcpy((void *)(gc
->pc
+ 20), (void *)(&level
), 4);
8389 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
8392 #define X_GLrop_FramebufferTexture2DEXT 4322
8394 __indirect_glFramebufferTexture2DEXT(GLenum target
, GLenum attachment
, GLenum textarget
, GLuint texture
, GLint level
)
8396 __GLXcontext
* const gc
= __glXGetCurrentContext();
8397 const GLuint cmdlen
= 24;
8398 emit_header(gc
->pc
, X_GLrop_FramebufferTexture2DEXT
, cmdlen
);
8399 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&target
), 4);
8400 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(&attachment
), 4);
8401 (void) memcpy((void *)(gc
->pc
+ 12), (void *)(&textarget
), 4);
8402 (void) memcpy((void *)(gc
->pc
+ 16), (void *)(&texture
), 4);
8403 (void) memcpy((void *)(gc
->pc
+ 20), (void *)(&level
), 4);
8405 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
8408 #define X_GLrop_FramebufferTexture3DEXT 4323
8410 __indirect_glFramebufferTexture3DEXT(GLenum target
, GLenum attachment
, GLenum textarget
, GLuint texture
, GLint level
, GLint zoffset
)
8412 __GLXcontext
* const gc
= __glXGetCurrentContext();
8413 const GLuint cmdlen
= 28;
8414 emit_header(gc
->pc
, X_GLrop_FramebufferTexture3DEXT
, cmdlen
);
8415 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&target
), 4);
8416 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(&attachment
), 4);
8417 (void) memcpy((void *)(gc
->pc
+ 12), (void *)(&textarget
), 4);
8418 (void) memcpy((void *)(gc
->pc
+ 16), (void *)(&texture
), 4);
8419 (void) memcpy((void *)(gc
->pc
+ 20), (void *)(&level
), 4);
8420 (void) memcpy((void *)(gc
->pc
+ 24), (void *)(&zoffset
), 4);
8422 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
8425 #define X_GLrop_FramebufferRenderbufferEXT 4324
8427 __indirect_glFramebufferRenderbufferEXT(GLenum target
, GLenum attachment
, GLenum renderbuffertarget
, GLuint renderbuffer
)
8429 __GLXcontext
* const gc
= __glXGetCurrentContext();
8430 const GLuint cmdlen
= 20;
8431 emit_header(gc
->pc
, X_GLrop_FramebufferRenderbufferEXT
, cmdlen
);
8432 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&target
), 4);
8433 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(&attachment
), 4);
8434 (void) memcpy((void *)(gc
->pc
+ 12), (void *)(&renderbuffertarget
), 4);
8435 (void) memcpy((void *)(gc
->pc
+ 16), (void *)(&renderbuffer
), 4);
8437 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
8440 #define X_GLvop_GetFramebufferAttachmentParameterivEXT 1428
8442 __indirect_glGetFramebufferAttachmentParameterivEXT(GLenum target
, GLenum attachment
, GLenum pname
, GLint
* params
)
8444 __GLXcontext
* const gc
= __glXGetCurrentContext();
8445 Display
* const dpy
= gc
->currentDpy
;
8446 const GLuint cmdlen
= 12;
8447 if (__builtin_expect(dpy
!= NULL
, 1)) {
8448 GLubyte
const * pc
= __glXSetupVendorRequest(gc
, X_GLXVendorPrivateWithReply
, X_GLvop_GetFramebufferAttachmentParameterivEXT
, cmdlen
);
8449 (void) memcpy((void *)(pc
+ 0), (void *)(&target
), 4);
8450 (void) memcpy((void *)(pc
+ 4), (void *)(&attachment
), 4);
8451 (void) memcpy((void *)(pc
+ 8), (void *)(&pname
), 4);
8452 (void) __glXReadReply(dpy
, 4, params
, GL_FALSE
);
8453 UnlockDisplay(dpy
); SyncHandle();
8458 #define X_GLrop_GenerateMipmapEXT 4325
8460 __indirect_glGenerateMipmapEXT(GLenum target
)
8462 __GLXcontext
* const gc
= __glXGetCurrentContext();
8463 const GLuint cmdlen
= 8;
8464 emit_header(gc
->pc
, X_GLrop_GenerateMipmapEXT
, cmdlen
);
8465 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&target
), 4);
8467 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }