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>
35 #define __GLX_PAD(n) (((n) + 3) & ~3)
37 # if defined(__i386__) && defined(__GNUC__)
38 # define FASTCALL __attribute__((fastcall))
42 # if defined(__GNUC__)
43 # define NOINLINE __attribute__((noinline))
48 #if !defined __GNUC__ || __GNUC__ < 3
49 # define __builtin_expect(x, y) x
52 /* If the size and opcode values are known at compile-time, this will, on
53 * x86 at least, emit them with a single instruction.
55 #define emit_header(dest, op, size) \
56 do { union { short s[2]; int i; } temp; \
57 temp.s[0] = (size); temp.s[1] = (op); \
58 *((int *)(dest)) = temp.i; } while(0)
60 static NOINLINE CARD32
61 read_reply( Display
*dpy
, size_t size
, void * dest
, GLboolean reply_is_always_array
)
63 xGLXSingleReply reply
;
65 (void) _XReply(dpy
, (xReply
*) & reply
, 0, False
);
67 if ((reply
.length
> 0) || reply_is_always_array
) {
68 const GLint bytes
= (reply_is_always_array
)
69 ? (4 * reply
.length
) : (reply
.size
* size
);
70 const GLint extra
= 4 - (bytes
& 3);
72 _XRead(dpy
, dest
, bytes
);
74 _XEatData(dpy
, extra
);
78 (void) memcpy( dest
, &(reply
.pad3
), size
);
87 static NOINLINE FASTCALL GLubyte
*
88 setup_single_request( __GLXcontext
* gc
, GLint sop
, GLint cmdlen
)
91 Display
* const dpy
= gc
->currentDpy
;
93 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
95 GetReqExtra(GLXSingle
, cmdlen
, req
);
96 req
->reqType
= gc
->majorOpcode
;
97 req
->contextTag
= gc
->currentContextTag
;
99 return (GLubyte
*)(req
) + sz_xGLXSingleReq
;
102 static NOINLINE FASTCALL GLubyte
*
103 setup_vendor_request( __GLXcontext
* gc
, GLint code
, GLint vop
, GLint cmdlen
)
105 xGLXVendorPrivateReq
* req
;
106 Display
* const dpy
= gc
->currentDpy
;
108 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
110 GetReqExtra(GLXVendorPrivate
, cmdlen
, req
);
111 req
->reqType
= gc
->majorOpcode
;
113 req
->vendorCode
= vop
;
114 req
->contextTag
= gc
->currentContextTag
;
115 return (GLubyte
*)(req
) + sz_xGLXVendorPrivateReq
;
118 const GLuint __glXDefaultPixelStore
[9] = { 0, 0, 0, 0, 0, 0, 0, 0, 1 };
120 #define zero (__glXDefaultPixelStore+0)
121 #define one (__glXDefaultPixelStore+8)
122 #define default_pixel_store_1D (__glXDefaultPixelStore+4)
123 #define default_pixel_store_1D_size 20
124 #define default_pixel_store_2D (__glXDefaultPixelStore+4)
125 #define default_pixel_store_2D_size 20
126 #define default_pixel_store_3D (__glXDefaultPixelStore+0)
127 #define default_pixel_store_3D_size 36
128 #define default_pixel_store_4D (__glXDefaultPixelStore+0)
129 #define default_pixel_store_4D_size 36
131 static FASTCALL NOINLINE
void
132 generic_3_byte( GLint rop
, const void * ptr
)
134 __GLXcontext
* const gc
= __glXGetCurrentContext();
135 const GLuint cmdlen
= 8;
137 emit_header(gc
->pc
, rop
, cmdlen
);
138 (void) memcpy((void *)(gc
->pc
+ 4), ptr
, 4);
140 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
143 static FASTCALL NOINLINE
void
144 generic_4_byte( GLint rop
, const void * ptr
)
146 __GLXcontext
* const gc
= __glXGetCurrentContext();
147 const GLuint cmdlen
= 8;
149 emit_header(gc
->pc
, rop
, cmdlen
);
150 (void) memcpy((void *)(gc
->pc
+ 4), ptr
, 4);
152 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
155 static FASTCALL NOINLINE
void
156 generic_6_byte( GLint rop
, const void * ptr
)
158 __GLXcontext
* const gc
= __glXGetCurrentContext();
159 const GLuint cmdlen
= 12;
161 emit_header(gc
->pc
, rop
, cmdlen
);
162 (void) memcpy((void *)(gc
->pc
+ 4), ptr
, 8);
164 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
167 static FASTCALL NOINLINE
void
168 generic_8_byte( GLint rop
, const void * ptr
)
170 __GLXcontext
* const gc
= __glXGetCurrentContext();
171 const GLuint cmdlen
= 12;
173 emit_header(gc
->pc
, rop
, cmdlen
);
174 (void) memcpy((void *)(gc
->pc
+ 4), ptr
, 8);
176 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
179 static FASTCALL NOINLINE
void
180 generic_12_byte( GLint rop
, const void * ptr
)
182 __GLXcontext
* const gc
= __glXGetCurrentContext();
183 const GLuint cmdlen
= 16;
185 emit_header(gc
->pc
, rop
, cmdlen
);
186 (void) memcpy((void *)(gc
->pc
+ 4), ptr
, 12);
188 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
191 static FASTCALL NOINLINE
void
192 generic_16_byte( GLint rop
, const void * ptr
)
194 __GLXcontext
* const gc
= __glXGetCurrentContext();
195 const GLuint cmdlen
= 20;
197 emit_header(gc
->pc
, rop
, cmdlen
);
198 (void) memcpy((void *)(gc
->pc
+ 4), ptr
, 16);
200 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
203 static FASTCALL NOINLINE
void
204 generic_24_byte( GLint rop
, const void * ptr
)
206 __GLXcontext
* const gc
= __glXGetCurrentContext();
207 const GLuint cmdlen
= 28;
209 emit_header(gc
->pc
, rop
, cmdlen
);
210 (void) memcpy((void *)(gc
->pc
+ 4), ptr
, 24);
212 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
215 static FASTCALL NOINLINE
void
216 generic_32_byte( GLint rop
, const void * ptr
)
218 __GLXcontext
* const gc
= __glXGetCurrentContext();
219 const GLuint cmdlen
= 36;
221 emit_header(gc
->pc
, rop
, cmdlen
);
222 (void) memcpy((void *)(gc
->pc
+ 4), ptr
, 32);
224 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
227 #define X_GLsop_NewList 101
229 __indirect_glNewList(GLuint list
, GLenum mode
)
231 __GLXcontext
* const gc
= __glXGetCurrentContext();
232 Display
* const dpy
= gc
->currentDpy
;
233 const GLuint cmdlen
= 8;
234 if (__builtin_expect(dpy
!= NULL
, 1)) {
235 GLubyte
const * pc
= setup_single_request(gc
, X_GLsop_NewList
, cmdlen
);
236 (void) memcpy((void *)(pc
+ 0), (void *)(&list
), 4);
237 (void) memcpy((void *)(pc
+ 4), (void *)(&mode
), 4);
238 UnlockDisplay(dpy
); SyncHandle();
243 #define X_GLsop_EndList 102
245 __indirect_glEndList(void)
247 __GLXcontext
* const gc
= __glXGetCurrentContext();
248 Display
* const dpy
= gc
->currentDpy
;
249 const GLuint cmdlen
= 0;
250 if (__builtin_expect(dpy
!= NULL
, 1)) {
251 (void) setup_single_request(gc
, X_GLsop_EndList
, cmdlen
);
252 UnlockDisplay(dpy
); SyncHandle();
257 #define X_GLrop_CallList 1
259 __indirect_glCallList(GLuint list
)
261 __GLXcontext
* const gc
= __glXGetCurrentContext();
262 const GLuint cmdlen
= 8;
263 emit_header(gc
->pc
, X_GLrop_CallList
, cmdlen
);
264 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&list
), 4);
266 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
269 #define X_GLrop_CallLists 2
271 __indirect_glCallLists(GLsizei n
, GLenum type
, const GLvoid
* lists
)
273 __GLXcontext
* const gc
= __glXGetCurrentContext();
274 const GLuint compsize
= __glCallLists_size(type
);
275 const GLuint cmdlen
= 12 + __GLX_PAD((compsize
* n
));
276 if (__builtin_expect(gc
->currentDpy
!= NULL
, 1)) {
277 if (cmdlen
<= gc
->maxSmallRenderCommandSize
) {
278 if ( (gc
->pc
+ cmdlen
) > gc
->bufEnd
) {
279 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
281 emit_header(gc
->pc
, X_GLrop_CallLists
, cmdlen
);
282 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&n
), 4);
283 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(&type
), 4);
284 (void) memcpy((void *)(gc
->pc
+ 12), (void *)(lists
), (compsize
* n
));
286 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
289 const GLint op
= X_GLrop_CallLists
;
290 const GLuint cmdlenLarge
= cmdlen
+ 4;
291 GLubyte
* const pc
= __glXFlushRenderBuffer(gc
, gc
->pc
);
292 (void) memcpy((void *)(pc
+ 0), (void *)(&cmdlenLarge
), 4);
293 (void) memcpy((void *)(pc
+ 4), (void *)(&op
), 4);
294 (void) memcpy((void *)(pc
+ 8), (void *)(&n
), 4);
295 (void) memcpy((void *)(pc
+ 12), (void *)(&type
), 4);
296 __glXSendLargeCommand(gc
, pc
, 16, lists
, (compsize
* n
));
301 #define X_GLsop_DeleteLists 103
303 __indirect_glDeleteLists(GLuint list
, GLsizei range
)
305 __GLXcontext
* const gc
= __glXGetCurrentContext();
306 Display
* const dpy
= gc
->currentDpy
;
307 const GLuint cmdlen
= 8;
308 if (__builtin_expect(dpy
!= NULL
, 1)) {
309 GLubyte
const * pc
= setup_single_request(gc
, X_GLsop_DeleteLists
, cmdlen
);
310 (void) memcpy((void *)(pc
+ 0), (void *)(&list
), 4);
311 (void) memcpy((void *)(pc
+ 4), (void *)(&range
), 4);
312 UnlockDisplay(dpy
); SyncHandle();
317 #define X_GLsop_GenLists 104
319 __indirect_glGenLists(GLsizei range
)
321 __GLXcontext
* const gc
= __glXGetCurrentContext();
322 Display
* const dpy
= gc
->currentDpy
;
323 GLuint retval
= (GLuint
) 0;
324 const GLuint cmdlen
= 4;
325 if (__builtin_expect(dpy
!= NULL
, 1)) {
326 GLubyte
const * pc
= setup_single_request(gc
, X_GLsop_GenLists
, cmdlen
);
327 (void) memcpy((void *)(pc
+ 0), (void *)(&range
), 4);
328 retval
= (GLuint
) read_reply(dpy
, 0, NULL
, GL_FALSE
);
329 UnlockDisplay(dpy
); SyncHandle();
334 #define X_GLrop_ListBase 3
336 __indirect_glListBase(GLuint base
)
338 __GLXcontext
* const gc
= __glXGetCurrentContext();
339 const GLuint cmdlen
= 8;
340 emit_header(gc
->pc
, X_GLrop_ListBase
, cmdlen
);
341 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&base
), 4);
343 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
346 #define X_GLrop_Begin 4
348 __indirect_glBegin(GLenum mode
)
350 __GLXcontext
* const gc
= __glXGetCurrentContext();
351 const GLuint cmdlen
= 8;
352 emit_header(gc
->pc
, X_GLrop_Begin
, cmdlen
);
353 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&mode
), 4);
355 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
358 #define X_GLrop_Bitmap 5
360 __indirect_glBitmap(GLsizei width
, GLsizei height
, GLfloat xorig
, GLfloat yorig
, GLfloat xmove
, GLfloat ymove
, const GLubyte
* bitmap
)
362 __GLXcontext
* const gc
= __glXGetCurrentContext();
363 const GLuint compsize
= (bitmap
!= NULL
) ? __glImageSize(width
, height
, 1, GL_COLOR_INDEX
, GL_BITMAP
, 0) : 0;
364 const GLuint cmdlen
= 48 + __GLX_PAD(compsize
);
365 if (__builtin_expect(gc
->currentDpy
!= NULL
, 1)) {
366 if (cmdlen
<= gc
->maxSmallRenderCommandSize
) {
367 if ( (gc
->pc
+ cmdlen
) > gc
->bufEnd
) {
368 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
370 emit_header(gc
->pc
, X_GLrop_Bitmap
, cmdlen
);
371 (void) memcpy((void *)(gc
->pc
+ 24), (void *)(&width
), 4);
372 (void) memcpy((void *)(gc
->pc
+ 28), (void *)(&height
), 4);
373 (void) memcpy((void *)(gc
->pc
+ 32), (void *)(&xorig
), 4);
374 (void) memcpy((void *)(gc
->pc
+ 36), (void *)(&yorig
), 4);
375 (void) memcpy((void *)(gc
->pc
+ 40), (void *)(&xmove
), 4);
376 (void) memcpy((void *)(gc
->pc
+ 44), (void *)(&ymove
), 4);
378 (*gc
->fillImage
)(gc
, 2, width
, height
, 1, GL_COLOR_INDEX
, GL_BITMAP
, bitmap
, gc
->pc
+ 48, gc
->pc
+ 4);
381 (void) memcpy( gc
->pc
+ 4, default_pixel_store_2D
, default_pixel_store_2D_size
);
384 if (gc
->pc
> gc
->limit
) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
387 const GLint op
= X_GLrop_Bitmap
;
388 const GLuint cmdlenLarge
= cmdlen
+ 4;
389 GLubyte
* const pc
= __glXFlushRenderBuffer(gc
, gc
->pc
);
390 (void) memcpy((void *)(pc
+ 0), (void *)(&cmdlenLarge
), 4);
391 (void) memcpy((void *)(pc
+ 4), (void *)(&op
), 4);
392 (void) memcpy((void *)(pc
+ 28), (void *)(&width
), 4);
393 (void) memcpy((void *)(pc
+ 32), (void *)(&height
), 4);
394 (void) memcpy((void *)(pc
+ 36), (void *)(&xorig
), 4);
395 (void) memcpy((void *)(pc
+ 40), (void *)(&yorig
), 4);
396 (void) memcpy((void *)(pc
+ 44), (void *)(&xmove
), 4);
397 (void) memcpy((void *)(pc
+ 48), (void *)(&ymove
), 4);
398 __glXSendLargeImage(gc
, compsize
, 2, width
, height
, 1, GL_COLOR_INDEX
, GL_BITMAP
, bitmap
, pc
+ 52, pc
+ 8);
403 #define X_GLrop_Color3bv 6
405 __indirect_glColor3b(GLbyte red
, GLbyte green
, GLbyte blue
)
407 __GLXcontext
* const gc
= __glXGetCurrentContext();
408 const GLuint cmdlen
= 8;
409 emit_header(gc
->pc
, X_GLrop_Color3bv
, cmdlen
);
410 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&red
), 1);
411 (void) memcpy((void *)(gc
->pc
+ 5), (void *)(&green
), 1);
412 (void) memcpy((void *)(gc
->pc
+ 6), (void *)(&blue
), 1);
414 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
417 #define X_GLrop_Color3bv 6
419 __indirect_glColor3bv(const GLbyte
* v
)
421 generic_3_byte( X_GLrop_Color3bv
, v
);
424 #define X_GLrop_Color3dv 7
426 __indirect_glColor3d(GLdouble red
, GLdouble green
, GLdouble blue
)
428 __GLXcontext
* const gc
= __glXGetCurrentContext();
429 const GLuint cmdlen
= 28;
430 emit_header(gc
->pc
, X_GLrop_Color3dv
, cmdlen
);
431 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&red
), 8);
432 (void) memcpy((void *)(gc
->pc
+ 12), (void *)(&green
), 8);
433 (void) memcpy((void *)(gc
->pc
+ 20), (void *)(&blue
), 8);
435 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
438 #define X_GLrop_Color3dv 7
440 __indirect_glColor3dv(const GLdouble
* v
)
442 generic_24_byte( X_GLrop_Color3dv
, v
);
445 #define X_GLrop_Color3fv 8
447 __indirect_glColor3f(GLfloat red
, GLfloat green
, GLfloat blue
)
449 __GLXcontext
* const gc
= __glXGetCurrentContext();
450 const GLuint cmdlen
= 16;
451 emit_header(gc
->pc
, X_GLrop_Color3fv
, cmdlen
);
452 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&red
), 4);
453 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(&green
), 4);
454 (void) memcpy((void *)(gc
->pc
+ 12), (void *)(&blue
), 4);
456 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
459 #define X_GLrop_Color3fv 8
461 __indirect_glColor3fv(const GLfloat
* v
)
463 generic_12_byte( X_GLrop_Color3fv
, v
);
466 #define X_GLrop_Color3iv 9
468 __indirect_glColor3i(GLint red
, GLint green
, GLint blue
)
470 __GLXcontext
* const gc
= __glXGetCurrentContext();
471 const GLuint cmdlen
= 16;
472 emit_header(gc
->pc
, X_GLrop_Color3iv
, cmdlen
);
473 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&red
), 4);
474 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(&green
), 4);
475 (void) memcpy((void *)(gc
->pc
+ 12), (void *)(&blue
), 4);
477 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
480 #define X_GLrop_Color3iv 9
482 __indirect_glColor3iv(const GLint
* v
)
484 generic_12_byte( X_GLrop_Color3iv
, v
);
487 #define X_GLrop_Color3sv 10
489 __indirect_glColor3s(GLshort red
, GLshort green
, GLshort blue
)
491 __GLXcontext
* const gc
= __glXGetCurrentContext();
492 const GLuint cmdlen
= 12;
493 emit_header(gc
->pc
, X_GLrop_Color3sv
, cmdlen
);
494 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&red
), 2);
495 (void) memcpy((void *)(gc
->pc
+ 6), (void *)(&green
), 2);
496 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(&blue
), 2);
498 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
501 #define X_GLrop_Color3sv 10
503 __indirect_glColor3sv(const GLshort
* v
)
505 generic_6_byte( X_GLrop_Color3sv
, v
);
508 #define X_GLrop_Color3ubv 11
510 __indirect_glColor3ub(GLubyte red
, GLubyte green
, GLubyte blue
)
512 __GLXcontext
* const gc
= __glXGetCurrentContext();
513 const GLuint cmdlen
= 8;
514 emit_header(gc
->pc
, X_GLrop_Color3ubv
, cmdlen
);
515 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&red
), 1);
516 (void) memcpy((void *)(gc
->pc
+ 5), (void *)(&green
), 1);
517 (void) memcpy((void *)(gc
->pc
+ 6), (void *)(&blue
), 1);
519 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
522 #define X_GLrop_Color3ubv 11
524 __indirect_glColor3ubv(const GLubyte
* v
)
526 generic_3_byte( X_GLrop_Color3ubv
, v
);
529 #define X_GLrop_Color3uiv 12
531 __indirect_glColor3ui(GLuint red
, GLuint green
, GLuint blue
)
533 __GLXcontext
* const gc
= __glXGetCurrentContext();
534 const GLuint cmdlen
= 16;
535 emit_header(gc
->pc
, X_GLrop_Color3uiv
, cmdlen
);
536 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&red
), 4);
537 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(&green
), 4);
538 (void) memcpy((void *)(gc
->pc
+ 12), (void *)(&blue
), 4);
540 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
543 #define X_GLrop_Color3uiv 12
545 __indirect_glColor3uiv(const GLuint
* v
)
547 generic_12_byte( X_GLrop_Color3uiv
, v
);
550 #define X_GLrop_Color3usv 13
552 __indirect_glColor3us(GLushort red
, GLushort green
, GLushort blue
)
554 __GLXcontext
* const gc
= __glXGetCurrentContext();
555 const GLuint cmdlen
= 12;
556 emit_header(gc
->pc
, X_GLrop_Color3usv
, cmdlen
);
557 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&red
), 2);
558 (void) memcpy((void *)(gc
->pc
+ 6), (void *)(&green
), 2);
559 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(&blue
), 2);
561 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
564 #define X_GLrop_Color3usv 13
566 __indirect_glColor3usv(const GLushort
* v
)
568 generic_6_byte( X_GLrop_Color3usv
, v
);
571 #define X_GLrop_Color4bv 14
573 __indirect_glColor4b(GLbyte red
, GLbyte green
, GLbyte blue
, GLbyte alpha
)
575 __GLXcontext
* const gc
= __glXGetCurrentContext();
576 const GLuint cmdlen
= 8;
577 emit_header(gc
->pc
, X_GLrop_Color4bv
, cmdlen
);
578 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&red
), 1);
579 (void) memcpy((void *)(gc
->pc
+ 5), (void *)(&green
), 1);
580 (void) memcpy((void *)(gc
->pc
+ 6), (void *)(&blue
), 1);
581 (void) memcpy((void *)(gc
->pc
+ 7), (void *)(&alpha
), 1);
583 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
586 #define X_GLrop_Color4bv 14
588 __indirect_glColor4bv(const GLbyte
* v
)
590 generic_4_byte( X_GLrop_Color4bv
, v
);
593 #define X_GLrop_Color4dv 15
595 __indirect_glColor4d(GLdouble red
, GLdouble green
, GLdouble blue
, GLdouble alpha
)
597 __GLXcontext
* const gc
= __glXGetCurrentContext();
598 const GLuint cmdlen
= 36;
599 emit_header(gc
->pc
, X_GLrop_Color4dv
, cmdlen
);
600 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&red
), 8);
601 (void) memcpy((void *)(gc
->pc
+ 12), (void *)(&green
), 8);
602 (void) memcpy((void *)(gc
->pc
+ 20), (void *)(&blue
), 8);
603 (void) memcpy((void *)(gc
->pc
+ 28), (void *)(&alpha
), 8);
605 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
608 #define X_GLrop_Color4dv 15
610 __indirect_glColor4dv(const GLdouble
* v
)
612 generic_32_byte( X_GLrop_Color4dv
, v
);
615 #define X_GLrop_Color4fv 16
617 __indirect_glColor4f(GLfloat red
, GLfloat green
, GLfloat blue
, GLfloat alpha
)
619 __GLXcontext
* const gc
= __glXGetCurrentContext();
620 const GLuint cmdlen
= 20;
621 emit_header(gc
->pc
, X_GLrop_Color4fv
, cmdlen
);
622 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&red
), 4);
623 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(&green
), 4);
624 (void) memcpy((void *)(gc
->pc
+ 12), (void *)(&blue
), 4);
625 (void) memcpy((void *)(gc
->pc
+ 16), (void *)(&alpha
), 4);
627 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
630 #define X_GLrop_Color4fv 16
632 __indirect_glColor4fv(const GLfloat
* v
)
634 generic_16_byte( X_GLrop_Color4fv
, v
);
637 #define X_GLrop_Color4iv 17
639 __indirect_glColor4i(GLint red
, GLint green
, GLint blue
, GLint alpha
)
641 __GLXcontext
* const gc
= __glXGetCurrentContext();
642 const GLuint cmdlen
= 20;
643 emit_header(gc
->pc
, X_GLrop_Color4iv
, cmdlen
);
644 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&red
), 4);
645 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(&green
), 4);
646 (void) memcpy((void *)(gc
->pc
+ 12), (void *)(&blue
), 4);
647 (void) memcpy((void *)(gc
->pc
+ 16), (void *)(&alpha
), 4);
649 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
652 #define X_GLrop_Color4iv 17
654 __indirect_glColor4iv(const GLint
* v
)
656 generic_16_byte( X_GLrop_Color4iv
, v
);
659 #define X_GLrop_Color4sv 18
661 __indirect_glColor4s(GLshort red
, GLshort green
, GLshort blue
, GLshort alpha
)
663 __GLXcontext
* const gc
= __glXGetCurrentContext();
664 const GLuint cmdlen
= 12;
665 emit_header(gc
->pc
, X_GLrop_Color4sv
, cmdlen
);
666 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&red
), 2);
667 (void) memcpy((void *)(gc
->pc
+ 6), (void *)(&green
), 2);
668 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(&blue
), 2);
669 (void) memcpy((void *)(gc
->pc
+ 10), (void *)(&alpha
), 2);
671 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
674 #define X_GLrop_Color4sv 18
676 __indirect_glColor4sv(const GLshort
* v
)
678 generic_8_byte( X_GLrop_Color4sv
, v
);
681 #define X_GLrop_Color4ubv 19
683 __indirect_glColor4ub(GLubyte red
, GLubyte green
, GLubyte blue
, GLubyte alpha
)
685 __GLXcontext
* const gc
= __glXGetCurrentContext();
686 const GLuint cmdlen
= 8;
687 emit_header(gc
->pc
, X_GLrop_Color4ubv
, cmdlen
);
688 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&red
), 1);
689 (void) memcpy((void *)(gc
->pc
+ 5), (void *)(&green
), 1);
690 (void) memcpy((void *)(gc
->pc
+ 6), (void *)(&blue
), 1);
691 (void) memcpy((void *)(gc
->pc
+ 7), (void *)(&alpha
), 1);
693 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
696 #define X_GLrop_Color4ubv 19
698 __indirect_glColor4ubv(const GLubyte
* v
)
700 generic_4_byte( X_GLrop_Color4ubv
, v
);
703 #define X_GLrop_Color4uiv 20
705 __indirect_glColor4ui(GLuint red
, GLuint green
, GLuint blue
, GLuint alpha
)
707 __GLXcontext
* const gc
= __glXGetCurrentContext();
708 const GLuint cmdlen
= 20;
709 emit_header(gc
->pc
, X_GLrop_Color4uiv
, cmdlen
);
710 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&red
), 4);
711 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(&green
), 4);
712 (void) memcpy((void *)(gc
->pc
+ 12), (void *)(&blue
), 4);
713 (void) memcpy((void *)(gc
->pc
+ 16), (void *)(&alpha
), 4);
715 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
718 #define X_GLrop_Color4uiv 20
720 __indirect_glColor4uiv(const GLuint
* v
)
722 generic_16_byte( X_GLrop_Color4uiv
, v
);
725 #define X_GLrop_Color4usv 21
727 __indirect_glColor4us(GLushort red
, GLushort green
, GLushort blue
, GLushort alpha
)
729 __GLXcontext
* const gc
= __glXGetCurrentContext();
730 const GLuint cmdlen
= 12;
731 emit_header(gc
->pc
, X_GLrop_Color4usv
, cmdlen
);
732 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&red
), 2);
733 (void) memcpy((void *)(gc
->pc
+ 6), (void *)(&green
), 2);
734 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(&blue
), 2);
735 (void) memcpy((void *)(gc
->pc
+ 10), (void *)(&alpha
), 2);
737 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
740 #define X_GLrop_Color4usv 21
742 __indirect_glColor4usv(const GLushort
* v
)
744 generic_8_byte( X_GLrop_Color4usv
, v
);
747 #define X_GLrop_EdgeFlagv 22
749 __indirect_glEdgeFlag(GLboolean flag
)
751 __GLXcontext
* const gc
= __glXGetCurrentContext();
752 const GLuint cmdlen
= 8;
753 emit_header(gc
->pc
, X_GLrop_EdgeFlagv
, cmdlen
);
754 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&flag
), 1);
756 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
759 #define X_GLrop_EdgeFlagv 22
761 __indirect_glEdgeFlagv(const GLboolean
* flag
)
763 __GLXcontext
* const gc
= __glXGetCurrentContext();
764 const GLuint cmdlen
= 8;
765 emit_header(gc
->pc
, X_GLrop_EdgeFlagv
, cmdlen
);
766 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(flag
), 1);
768 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
771 #define X_GLrop_End 23
773 __indirect_glEnd(void)
775 __GLXcontext
* const gc
= __glXGetCurrentContext();
776 const GLuint cmdlen
= 4;
777 emit_header(gc
->pc
, X_GLrop_End
, cmdlen
);
779 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
782 #define X_GLrop_Indexdv 24
784 __indirect_glIndexd(GLdouble c
)
786 __GLXcontext
* const gc
= __glXGetCurrentContext();
787 const GLuint cmdlen
= 12;
788 emit_header(gc
->pc
, X_GLrop_Indexdv
, cmdlen
);
789 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&c
), 8);
791 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
794 #define X_GLrop_Indexdv 24
796 __indirect_glIndexdv(const GLdouble
* c
)
798 generic_8_byte( X_GLrop_Indexdv
, c
);
801 #define X_GLrop_Indexfv 25
803 __indirect_glIndexf(GLfloat c
)
805 __GLXcontext
* const gc
= __glXGetCurrentContext();
806 const GLuint cmdlen
= 8;
807 emit_header(gc
->pc
, X_GLrop_Indexfv
, cmdlen
);
808 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&c
), 4);
810 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
813 #define X_GLrop_Indexfv 25
815 __indirect_glIndexfv(const GLfloat
* c
)
817 generic_4_byte( X_GLrop_Indexfv
, c
);
820 #define X_GLrop_Indexiv 26
822 __indirect_glIndexi(GLint c
)
824 __GLXcontext
* const gc
= __glXGetCurrentContext();
825 const GLuint cmdlen
= 8;
826 emit_header(gc
->pc
, X_GLrop_Indexiv
, cmdlen
);
827 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&c
), 4);
829 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
832 #define X_GLrop_Indexiv 26
834 __indirect_glIndexiv(const GLint
* c
)
836 generic_4_byte( X_GLrop_Indexiv
, c
);
839 #define X_GLrop_Indexsv 27
841 __indirect_glIndexs(GLshort c
)
843 __GLXcontext
* const gc
= __glXGetCurrentContext();
844 const GLuint cmdlen
= 8;
845 emit_header(gc
->pc
, X_GLrop_Indexsv
, cmdlen
);
846 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&c
), 2);
848 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
851 #define X_GLrop_Indexsv 27
853 __indirect_glIndexsv(const GLshort
* c
)
855 __GLXcontext
* const gc
= __glXGetCurrentContext();
856 const GLuint cmdlen
= 8;
857 emit_header(gc
->pc
, X_GLrop_Indexsv
, cmdlen
);
858 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(c
), 2);
860 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
863 #define X_GLrop_Normal3bv 28
865 __indirect_glNormal3b(GLbyte nx
, GLbyte ny
, GLbyte nz
)
867 __GLXcontext
* const gc
= __glXGetCurrentContext();
868 const GLuint cmdlen
= 8;
869 emit_header(gc
->pc
, X_GLrop_Normal3bv
, cmdlen
);
870 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&nx
), 1);
871 (void) memcpy((void *)(gc
->pc
+ 5), (void *)(&ny
), 1);
872 (void) memcpy((void *)(gc
->pc
+ 6), (void *)(&nz
), 1);
874 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
877 #define X_GLrop_Normal3bv 28
879 __indirect_glNormal3bv(const GLbyte
* v
)
881 generic_3_byte( X_GLrop_Normal3bv
, v
);
884 #define X_GLrop_Normal3dv 29
886 __indirect_glNormal3d(GLdouble nx
, GLdouble ny
, GLdouble nz
)
888 __GLXcontext
* const gc
= __glXGetCurrentContext();
889 const GLuint cmdlen
= 28;
890 emit_header(gc
->pc
, X_GLrop_Normal3dv
, cmdlen
);
891 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&nx
), 8);
892 (void) memcpy((void *)(gc
->pc
+ 12), (void *)(&ny
), 8);
893 (void) memcpy((void *)(gc
->pc
+ 20), (void *)(&nz
), 8);
895 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
898 #define X_GLrop_Normal3dv 29
900 __indirect_glNormal3dv(const GLdouble
* v
)
902 generic_24_byte( X_GLrop_Normal3dv
, v
);
905 #define X_GLrop_Normal3fv 30
907 __indirect_glNormal3f(GLfloat nx
, GLfloat ny
, GLfloat nz
)
909 __GLXcontext
* const gc
= __glXGetCurrentContext();
910 const GLuint cmdlen
= 16;
911 emit_header(gc
->pc
, X_GLrop_Normal3fv
, cmdlen
);
912 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&nx
), 4);
913 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(&ny
), 4);
914 (void) memcpy((void *)(gc
->pc
+ 12), (void *)(&nz
), 4);
916 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
919 #define X_GLrop_Normal3fv 30
921 __indirect_glNormal3fv(const GLfloat
* v
)
923 generic_12_byte( X_GLrop_Normal3fv
, v
);
926 #define X_GLrop_Normal3iv 31
928 __indirect_glNormal3i(GLint nx
, GLint ny
, GLint nz
)
930 __GLXcontext
* const gc
= __glXGetCurrentContext();
931 const GLuint cmdlen
= 16;
932 emit_header(gc
->pc
, X_GLrop_Normal3iv
, cmdlen
);
933 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&nx
), 4);
934 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(&ny
), 4);
935 (void) memcpy((void *)(gc
->pc
+ 12), (void *)(&nz
), 4);
937 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
940 #define X_GLrop_Normal3iv 31
942 __indirect_glNormal3iv(const GLint
* v
)
944 generic_12_byte( X_GLrop_Normal3iv
, v
);
947 #define X_GLrop_Normal3sv 32
949 __indirect_glNormal3s(GLshort nx
, GLshort ny
, GLshort nz
)
951 __GLXcontext
* const gc
= __glXGetCurrentContext();
952 const GLuint cmdlen
= 12;
953 emit_header(gc
->pc
, X_GLrop_Normal3sv
, cmdlen
);
954 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&nx
), 2);
955 (void) memcpy((void *)(gc
->pc
+ 6), (void *)(&ny
), 2);
956 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(&nz
), 2);
958 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
961 #define X_GLrop_Normal3sv 32
963 __indirect_glNormal3sv(const GLshort
* v
)
965 generic_6_byte( X_GLrop_Normal3sv
, v
);
968 #define X_GLrop_RasterPos2dv 33
970 __indirect_glRasterPos2d(GLdouble x
, GLdouble y
)
972 __GLXcontext
* const gc
= __glXGetCurrentContext();
973 const GLuint cmdlen
= 20;
974 emit_header(gc
->pc
, X_GLrop_RasterPos2dv
, cmdlen
);
975 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&x
), 8);
976 (void) memcpy((void *)(gc
->pc
+ 12), (void *)(&y
), 8);
978 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
981 #define X_GLrop_RasterPos2dv 33
983 __indirect_glRasterPos2dv(const GLdouble
* v
)
985 generic_16_byte( X_GLrop_RasterPos2dv
, v
);
988 #define X_GLrop_RasterPos2fv 34
990 __indirect_glRasterPos2f(GLfloat x
, GLfloat y
)
992 __GLXcontext
* const gc
= __glXGetCurrentContext();
993 const GLuint cmdlen
= 12;
994 emit_header(gc
->pc
, X_GLrop_RasterPos2fv
, cmdlen
);
995 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&x
), 4);
996 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(&y
), 4);
998 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
1001 #define X_GLrop_RasterPos2fv 34
1003 __indirect_glRasterPos2fv(const GLfloat
* v
)
1005 generic_8_byte( X_GLrop_RasterPos2fv
, v
);
1008 #define X_GLrop_RasterPos2iv 35
1010 __indirect_glRasterPos2i(GLint x
, GLint y
)
1012 __GLXcontext
* const gc
= __glXGetCurrentContext();
1013 const GLuint cmdlen
= 12;
1014 emit_header(gc
->pc
, X_GLrop_RasterPos2iv
, cmdlen
);
1015 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&x
), 4);
1016 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(&y
), 4);
1018 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
1021 #define X_GLrop_RasterPos2iv 35
1023 __indirect_glRasterPos2iv(const GLint
* v
)
1025 generic_8_byte( X_GLrop_RasterPos2iv
, v
);
1028 #define X_GLrop_RasterPos2sv 36
1030 __indirect_glRasterPos2s(GLshort x
, GLshort y
)
1032 __GLXcontext
* const gc
= __glXGetCurrentContext();
1033 const GLuint cmdlen
= 8;
1034 emit_header(gc
->pc
, X_GLrop_RasterPos2sv
, cmdlen
);
1035 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&x
), 2);
1036 (void) memcpy((void *)(gc
->pc
+ 6), (void *)(&y
), 2);
1038 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
1041 #define X_GLrop_RasterPos2sv 36
1043 __indirect_glRasterPos2sv(const GLshort
* v
)
1045 generic_4_byte( X_GLrop_RasterPos2sv
, v
);
1048 #define X_GLrop_RasterPos3dv 37
1050 __indirect_glRasterPos3d(GLdouble x
, GLdouble y
, GLdouble z
)
1052 __GLXcontext
* const gc
= __glXGetCurrentContext();
1053 const GLuint cmdlen
= 28;
1054 emit_header(gc
->pc
, X_GLrop_RasterPos3dv
, cmdlen
);
1055 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&x
), 8);
1056 (void) memcpy((void *)(gc
->pc
+ 12), (void *)(&y
), 8);
1057 (void) memcpy((void *)(gc
->pc
+ 20), (void *)(&z
), 8);
1059 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
1062 #define X_GLrop_RasterPos3dv 37
1064 __indirect_glRasterPos3dv(const GLdouble
* v
)
1066 generic_24_byte( X_GLrop_RasterPos3dv
, v
);
1069 #define X_GLrop_RasterPos3fv 38
1071 __indirect_glRasterPos3f(GLfloat x
, GLfloat y
, GLfloat z
)
1073 __GLXcontext
* const gc
= __glXGetCurrentContext();
1074 const GLuint cmdlen
= 16;
1075 emit_header(gc
->pc
, X_GLrop_RasterPos3fv
, cmdlen
);
1076 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&x
), 4);
1077 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(&y
), 4);
1078 (void) memcpy((void *)(gc
->pc
+ 12), (void *)(&z
), 4);
1080 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
1083 #define X_GLrop_RasterPos3fv 38
1085 __indirect_glRasterPos3fv(const GLfloat
* v
)
1087 generic_12_byte( X_GLrop_RasterPos3fv
, v
);
1090 #define X_GLrop_RasterPos3iv 39
1092 __indirect_glRasterPos3i(GLint x
, GLint y
, GLint z
)
1094 __GLXcontext
* const gc
= __glXGetCurrentContext();
1095 const GLuint cmdlen
= 16;
1096 emit_header(gc
->pc
, X_GLrop_RasterPos3iv
, cmdlen
);
1097 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&x
), 4);
1098 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(&y
), 4);
1099 (void) memcpy((void *)(gc
->pc
+ 12), (void *)(&z
), 4);
1101 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
1104 #define X_GLrop_RasterPos3iv 39
1106 __indirect_glRasterPos3iv(const GLint
* v
)
1108 generic_12_byte( X_GLrop_RasterPos3iv
, v
);
1111 #define X_GLrop_RasterPos3sv 40
1113 __indirect_glRasterPos3s(GLshort x
, GLshort y
, GLshort z
)
1115 __GLXcontext
* const gc
= __glXGetCurrentContext();
1116 const GLuint cmdlen
= 12;
1117 emit_header(gc
->pc
, X_GLrop_RasterPos3sv
, cmdlen
);
1118 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&x
), 2);
1119 (void) memcpy((void *)(gc
->pc
+ 6), (void *)(&y
), 2);
1120 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(&z
), 2);
1122 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
1125 #define X_GLrop_RasterPos3sv 40
1127 __indirect_glRasterPos3sv(const GLshort
* v
)
1129 generic_6_byte( X_GLrop_RasterPos3sv
, v
);
1132 #define X_GLrop_RasterPos4dv 41
1134 __indirect_glRasterPos4d(GLdouble x
, GLdouble y
, GLdouble z
, GLdouble w
)
1136 __GLXcontext
* const gc
= __glXGetCurrentContext();
1137 const GLuint cmdlen
= 36;
1138 emit_header(gc
->pc
, X_GLrop_RasterPos4dv
, cmdlen
);
1139 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&x
), 8);
1140 (void) memcpy((void *)(gc
->pc
+ 12), (void *)(&y
), 8);
1141 (void) memcpy((void *)(gc
->pc
+ 20), (void *)(&z
), 8);
1142 (void) memcpy((void *)(gc
->pc
+ 28), (void *)(&w
), 8);
1144 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
1147 #define X_GLrop_RasterPos4dv 41
1149 __indirect_glRasterPos4dv(const GLdouble
* v
)
1151 generic_32_byte( X_GLrop_RasterPos4dv
, v
);
1154 #define X_GLrop_RasterPos4fv 42
1156 __indirect_glRasterPos4f(GLfloat x
, GLfloat y
, GLfloat z
, GLfloat w
)
1158 __GLXcontext
* const gc
= __glXGetCurrentContext();
1159 const GLuint cmdlen
= 20;
1160 emit_header(gc
->pc
, X_GLrop_RasterPos4fv
, cmdlen
);
1161 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&x
), 4);
1162 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(&y
), 4);
1163 (void) memcpy((void *)(gc
->pc
+ 12), (void *)(&z
), 4);
1164 (void) memcpy((void *)(gc
->pc
+ 16), (void *)(&w
), 4);
1166 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
1169 #define X_GLrop_RasterPos4fv 42
1171 __indirect_glRasterPos4fv(const GLfloat
* v
)
1173 generic_16_byte( X_GLrop_RasterPos4fv
, v
);
1176 #define X_GLrop_RasterPos4iv 43
1178 __indirect_glRasterPos4i(GLint x
, GLint y
, GLint z
, GLint w
)
1180 __GLXcontext
* const gc
= __glXGetCurrentContext();
1181 const GLuint cmdlen
= 20;
1182 emit_header(gc
->pc
, X_GLrop_RasterPos4iv
, cmdlen
);
1183 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&x
), 4);
1184 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(&y
), 4);
1185 (void) memcpy((void *)(gc
->pc
+ 12), (void *)(&z
), 4);
1186 (void) memcpy((void *)(gc
->pc
+ 16), (void *)(&w
), 4);
1188 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
1191 #define X_GLrop_RasterPos4iv 43
1193 __indirect_glRasterPos4iv(const GLint
* v
)
1195 generic_16_byte( X_GLrop_RasterPos4iv
, v
);
1198 #define X_GLrop_RasterPos4sv 44
1200 __indirect_glRasterPos4s(GLshort x
, GLshort y
, GLshort z
, GLshort w
)
1202 __GLXcontext
* const gc
= __glXGetCurrentContext();
1203 const GLuint cmdlen
= 12;
1204 emit_header(gc
->pc
, X_GLrop_RasterPos4sv
, cmdlen
);
1205 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&x
), 2);
1206 (void) memcpy((void *)(gc
->pc
+ 6), (void *)(&y
), 2);
1207 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(&z
), 2);
1208 (void) memcpy((void *)(gc
->pc
+ 10), (void *)(&w
), 2);
1210 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
1213 #define X_GLrop_RasterPos4sv 44
1215 __indirect_glRasterPos4sv(const GLshort
* v
)
1217 generic_8_byte( X_GLrop_RasterPos4sv
, v
);
1220 #define X_GLrop_Rectdv 45
1222 __indirect_glRectd(GLdouble x1
, GLdouble y1
, GLdouble x2
, GLdouble y2
)
1224 __GLXcontext
* const gc
= __glXGetCurrentContext();
1225 const GLuint cmdlen
= 36;
1226 emit_header(gc
->pc
, X_GLrop_Rectdv
, cmdlen
);
1227 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&x1
), 8);
1228 (void) memcpy((void *)(gc
->pc
+ 12), (void *)(&y1
), 8);
1229 (void) memcpy((void *)(gc
->pc
+ 20), (void *)(&x2
), 8);
1230 (void) memcpy((void *)(gc
->pc
+ 28), (void *)(&y2
), 8);
1232 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
1235 #define X_GLrop_Rectdv 45
1237 __indirect_glRectdv(const GLdouble
* v1
, const GLdouble
* v2
)
1239 __GLXcontext
* const gc
= __glXGetCurrentContext();
1240 const GLuint cmdlen
= 36;
1241 emit_header(gc
->pc
, X_GLrop_Rectdv
, cmdlen
);
1242 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(v1
), 16);
1243 (void) memcpy((void *)(gc
->pc
+ 20), (void *)(v2
), 16);
1245 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
1248 #define X_GLrop_Rectfv 46
1250 __indirect_glRectf(GLfloat x1
, GLfloat y1
, GLfloat x2
, GLfloat y2
)
1252 __GLXcontext
* const gc
= __glXGetCurrentContext();
1253 const GLuint cmdlen
= 20;
1254 emit_header(gc
->pc
, X_GLrop_Rectfv
, cmdlen
);
1255 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&x1
), 4);
1256 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(&y1
), 4);
1257 (void) memcpy((void *)(gc
->pc
+ 12), (void *)(&x2
), 4);
1258 (void) memcpy((void *)(gc
->pc
+ 16), (void *)(&y2
), 4);
1260 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
1263 #define X_GLrop_Rectfv 46
1265 __indirect_glRectfv(const GLfloat
* v1
, const GLfloat
* v2
)
1267 __GLXcontext
* const gc
= __glXGetCurrentContext();
1268 const GLuint cmdlen
= 20;
1269 emit_header(gc
->pc
, X_GLrop_Rectfv
, cmdlen
);
1270 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(v1
), 8);
1271 (void) memcpy((void *)(gc
->pc
+ 12), (void *)(v2
), 8);
1273 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
1276 #define X_GLrop_Rectiv 47
1278 __indirect_glRecti(GLint x1
, GLint y1
, GLint x2
, GLint y2
)
1280 __GLXcontext
* const gc
= __glXGetCurrentContext();
1281 const GLuint cmdlen
= 20;
1282 emit_header(gc
->pc
, X_GLrop_Rectiv
, cmdlen
);
1283 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&x1
), 4);
1284 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(&y1
), 4);
1285 (void) memcpy((void *)(gc
->pc
+ 12), (void *)(&x2
), 4);
1286 (void) memcpy((void *)(gc
->pc
+ 16), (void *)(&y2
), 4);
1288 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
1291 #define X_GLrop_Rectiv 47
1293 __indirect_glRectiv(const GLint
* v1
, const GLint
* v2
)
1295 __GLXcontext
* const gc
= __glXGetCurrentContext();
1296 const GLuint cmdlen
= 20;
1297 emit_header(gc
->pc
, X_GLrop_Rectiv
, cmdlen
);
1298 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(v1
), 8);
1299 (void) memcpy((void *)(gc
->pc
+ 12), (void *)(v2
), 8);
1301 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
1304 #define X_GLrop_Rectsv 48
1306 __indirect_glRects(GLshort x1
, GLshort y1
, GLshort x2
, GLshort y2
)
1308 __GLXcontext
* const gc
= __glXGetCurrentContext();
1309 const GLuint cmdlen
= 12;
1310 emit_header(gc
->pc
, X_GLrop_Rectsv
, cmdlen
);
1311 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&x1
), 2);
1312 (void) memcpy((void *)(gc
->pc
+ 6), (void *)(&y1
), 2);
1313 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(&x2
), 2);
1314 (void) memcpy((void *)(gc
->pc
+ 10), (void *)(&y2
), 2);
1316 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
1319 #define X_GLrop_Rectsv 48
1321 __indirect_glRectsv(const GLshort
* v1
, const GLshort
* v2
)
1323 __GLXcontext
* const gc
= __glXGetCurrentContext();
1324 const GLuint cmdlen
= 12;
1325 emit_header(gc
->pc
, X_GLrop_Rectsv
, cmdlen
);
1326 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(v1
), 4);
1327 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(v2
), 4);
1329 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
1332 #define X_GLrop_TexCoord1dv 49
1334 __indirect_glTexCoord1d(GLdouble s
)
1336 __GLXcontext
* const gc
= __glXGetCurrentContext();
1337 const GLuint cmdlen
= 12;
1338 emit_header(gc
->pc
, X_GLrop_TexCoord1dv
, cmdlen
);
1339 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&s
), 8);
1341 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
1344 #define X_GLrop_TexCoord1dv 49
1346 __indirect_glTexCoord1dv(const GLdouble
* v
)
1348 generic_8_byte( X_GLrop_TexCoord1dv
, v
);
1351 #define X_GLrop_TexCoord1fv 50
1353 __indirect_glTexCoord1f(GLfloat s
)
1355 __GLXcontext
* const gc
= __glXGetCurrentContext();
1356 const GLuint cmdlen
= 8;
1357 emit_header(gc
->pc
, X_GLrop_TexCoord1fv
, cmdlen
);
1358 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&s
), 4);
1360 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
1363 #define X_GLrop_TexCoord1fv 50
1365 __indirect_glTexCoord1fv(const GLfloat
* v
)
1367 generic_4_byte( X_GLrop_TexCoord1fv
, v
);
1370 #define X_GLrop_TexCoord1iv 51
1372 __indirect_glTexCoord1i(GLint s
)
1374 __GLXcontext
* const gc
= __glXGetCurrentContext();
1375 const GLuint cmdlen
= 8;
1376 emit_header(gc
->pc
, X_GLrop_TexCoord1iv
, cmdlen
);
1377 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&s
), 4);
1379 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
1382 #define X_GLrop_TexCoord1iv 51
1384 __indirect_glTexCoord1iv(const GLint
* v
)
1386 generic_4_byte( X_GLrop_TexCoord1iv
, v
);
1389 #define X_GLrop_TexCoord1sv 52
1391 __indirect_glTexCoord1s(GLshort s
)
1393 __GLXcontext
* const gc
= __glXGetCurrentContext();
1394 const GLuint cmdlen
= 8;
1395 emit_header(gc
->pc
, X_GLrop_TexCoord1sv
, cmdlen
);
1396 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&s
), 2);
1398 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
1401 #define X_GLrop_TexCoord1sv 52
1403 __indirect_glTexCoord1sv(const GLshort
* v
)
1405 __GLXcontext
* const gc
= __glXGetCurrentContext();
1406 const GLuint cmdlen
= 8;
1407 emit_header(gc
->pc
, X_GLrop_TexCoord1sv
, cmdlen
);
1408 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(v
), 2);
1410 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
1413 #define X_GLrop_TexCoord2dv 53
1415 __indirect_glTexCoord2d(GLdouble s
, GLdouble t
)
1417 __GLXcontext
* const gc
= __glXGetCurrentContext();
1418 const GLuint cmdlen
= 20;
1419 emit_header(gc
->pc
, X_GLrop_TexCoord2dv
, cmdlen
);
1420 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&s
), 8);
1421 (void) memcpy((void *)(gc
->pc
+ 12), (void *)(&t
), 8);
1423 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
1426 #define X_GLrop_TexCoord2dv 53
1428 __indirect_glTexCoord2dv(const GLdouble
* v
)
1430 generic_16_byte( X_GLrop_TexCoord2dv
, v
);
1433 #define X_GLrop_TexCoord2fv 54
1435 __indirect_glTexCoord2f(GLfloat s
, GLfloat t
)
1437 __GLXcontext
* const gc
= __glXGetCurrentContext();
1438 const GLuint cmdlen
= 12;
1439 emit_header(gc
->pc
, X_GLrop_TexCoord2fv
, cmdlen
);
1440 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&s
), 4);
1441 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(&t
), 4);
1443 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
1446 #define X_GLrop_TexCoord2fv 54
1448 __indirect_glTexCoord2fv(const GLfloat
* v
)
1450 generic_8_byte( X_GLrop_TexCoord2fv
, v
);
1453 #define X_GLrop_TexCoord2iv 55
1455 __indirect_glTexCoord2i(GLint s
, GLint t
)
1457 __GLXcontext
* const gc
= __glXGetCurrentContext();
1458 const GLuint cmdlen
= 12;
1459 emit_header(gc
->pc
, X_GLrop_TexCoord2iv
, cmdlen
);
1460 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&s
), 4);
1461 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(&t
), 4);
1463 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
1466 #define X_GLrop_TexCoord2iv 55
1468 __indirect_glTexCoord2iv(const GLint
* v
)
1470 generic_8_byte( X_GLrop_TexCoord2iv
, v
);
1473 #define X_GLrop_TexCoord2sv 56
1475 __indirect_glTexCoord2s(GLshort s
, GLshort t
)
1477 __GLXcontext
* const gc
= __glXGetCurrentContext();
1478 const GLuint cmdlen
= 8;
1479 emit_header(gc
->pc
, X_GLrop_TexCoord2sv
, cmdlen
);
1480 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&s
), 2);
1481 (void) memcpy((void *)(gc
->pc
+ 6), (void *)(&t
), 2);
1483 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
1486 #define X_GLrop_TexCoord2sv 56
1488 __indirect_glTexCoord2sv(const GLshort
* v
)
1490 generic_4_byte( X_GLrop_TexCoord2sv
, v
);
1493 #define X_GLrop_TexCoord3dv 57
1495 __indirect_glTexCoord3d(GLdouble s
, GLdouble t
, GLdouble r
)
1497 __GLXcontext
* const gc
= __glXGetCurrentContext();
1498 const GLuint cmdlen
= 28;
1499 emit_header(gc
->pc
, X_GLrop_TexCoord3dv
, cmdlen
);
1500 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&s
), 8);
1501 (void) memcpy((void *)(gc
->pc
+ 12), (void *)(&t
), 8);
1502 (void) memcpy((void *)(gc
->pc
+ 20), (void *)(&r
), 8);
1504 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
1507 #define X_GLrop_TexCoord3dv 57
1509 __indirect_glTexCoord3dv(const GLdouble
* v
)
1511 generic_24_byte( X_GLrop_TexCoord3dv
, v
);
1514 #define X_GLrop_TexCoord3fv 58
1516 __indirect_glTexCoord3f(GLfloat s
, GLfloat t
, GLfloat r
)
1518 __GLXcontext
* const gc
= __glXGetCurrentContext();
1519 const GLuint cmdlen
= 16;
1520 emit_header(gc
->pc
, X_GLrop_TexCoord3fv
, cmdlen
);
1521 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&s
), 4);
1522 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(&t
), 4);
1523 (void) memcpy((void *)(gc
->pc
+ 12), (void *)(&r
), 4);
1525 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
1528 #define X_GLrop_TexCoord3fv 58
1530 __indirect_glTexCoord3fv(const GLfloat
* v
)
1532 generic_12_byte( X_GLrop_TexCoord3fv
, v
);
1535 #define X_GLrop_TexCoord3iv 59
1537 __indirect_glTexCoord3i(GLint s
, GLint t
, GLint r
)
1539 __GLXcontext
* const gc
= __glXGetCurrentContext();
1540 const GLuint cmdlen
= 16;
1541 emit_header(gc
->pc
, X_GLrop_TexCoord3iv
, cmdlen
);
1542 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&s
), 4);
1543 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(&t
), 4);
1544 (void) memcpy((void *)(gc
->pc
+ 12), (void *)(&r
), 4);
1546 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
1549 #define X_GLrop_TexCoord3iv 59
1551 __indirect_glTexCoord3iv(const GLint
* v
)
1553 generic_12_byte( X_GLrop_TexCoord3iv
, v
);
1556 #define X_GLrop_TexCoord3sv 60
1558 __indirect_glTexCoord3s(GLshort s
, GLshort t
, GLshort r
)
1560 __GLXcontext
* const gc
= __glXGetCurrentContext();
1561 const GLuint cmdlen
= 12;
1562 emit_header(gc
->pc
, X_GLrop_TexCoord3sv
, cmdlen
);
1563 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&s
), 2);
1564 (void) memcpy((void *)(gc
->pc
+ 6), (void *)(&t
), 2);
1565 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(&r
), 2);
1567 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
1570 #define X_GLrop_TexCoord3sv 60
1572 __indirect_glTexCoord3sv(const GLshort
* v
)
1574 generic_6_byte( X_GLrop_TexCoord3sv
, v
);
1577 #define X_GLrop_TexCoord4dv 61
1579 __indirect_glTexCoord4d(GLdouble s
, GLdouble t
, GLdouble r
, GLdouble q
)
1581 __GLXcontext
* const gc
= __glXGetCurrentContext();
1582 const GLuint cmdlen
= 36;
1583 emit_header(gc
->pc
, X_GLrop_TexCoord4dv
, cmdlen
);
1584 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&s
), 8);
1585 (void) memcpy((void *)(gc
->pc
+ 12), (void *)(&t
), 8);
1586 (void) memcpy((void *)(gc
->pc
+ 20), (void *)(&r
), 8);
1587 (void) memcpy((void *)(gc
->pc
+ 28), (void *)(&q
), 8);
1589 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
1592 #define X_GLrop_TexCoord4dv 61
1594 __indirect_glTexCoord4dv(const GLdouble
* v
)
1596 generic_32_byte( X_GLrop_TexCoord4dv
, v
);
1599 #define X_GLrop_TexCoord4fv 62
1601 __indirect_glTexCoord4f(GLfloat s
, GLfloat t
, GLfloat r
, GLfloat q
)
1603 __GLXcontext
* const gc
= __glXGetCurrentContext();
1604 const GLuint cmdlen
= 20;
1605 emit_header(gc
->pc
, X_GLrop_TexCoord4fv
, cmdlen
);
1606 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&s
), 4);
1607 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(&t
), 4);
1608 (void) memcpy((void *)(gc
->pc
+ 12), (void *)(&r
), 4);
1609 (void) memcpy((void *)(gc
->pc
+ 16), (void *)(&q
), 4);
1611 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
1614 #define X_GLrop_TexCoord4fv 62
1616 __indirect_glTexCoord4fv(const GLfloat
* v
)
1618 generic_16_byte( X_GLrop_TexCoord4fv
, v
);
1621 #define X_GLrop_TexCoord4iv 63
1623 __indirect_glTexCoord4i(GLint s
, GLint t
, GLint r
, GLint q
)
1625 __GLXcontext
* const gc
= __glXGetCurrentContext();
1626 const GLuint cmdlen
= 20;
1627 emit_header(gc
->pc
, X_GLrop_TexCoord4iv
, cmdlen
);
1628 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&s
), 4);
1629 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(&t
), 4);
1630 (void) memcpy((void *)(gc
->pc
+ 12), (void *)(&r
), 4);
1631 (void) memcpy((void *)(gc
->pc
+ 16), (void *)(&q
), 4);
1633 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
1636 #define X_GLrop_TexCoord4iv 63
1638 __indirect_glTexCoord4iv(const GLint
* v
)
1640 generic_16_byte( X_GLrop_TexCoord4iv
, v
);
1643 #define X_GLrop_TexCoord4sv 64
1645 __indirect_glTexCoord4s(GLshort s
, GLshort t
, GLshort r
, GLshort q
)
1647 __GLXcontext
* const gc
= __glXGetCurrentContext();
1648 const GLuint cmdlen
= 12;
1649 emit_header(gc
->pc
, X_GLrop_TexCoord4sv
, cmdlen
);
1650 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&s
), 2);
1651 (void) memcpy((void *)(gc
->pc
+ 6), (void *)(&t
), 2);
1652 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(&r
), 2);
1653 (void) memcpy((void *)(gc
->pc
+ 10), (void *)(&q
), 2);
1655 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
1658 #define X_GLrop_TexCoord4sv 64
1660 __indirect_glTexCoord4sv(const GLshort
* v
)
1662 generic_8_byte( X_GLrop_TexCoord4sv
, v
);
1665 #define X_GLrop_Vertex2dv 65
1667 __indirect_glVertex2d(GLdouble x
, GLdouble y
)
1669 __GLXcontext
* const gc
= __glXGetCurrentContext();
1670 const GLuint cmdlen
= 20;
1671 emit_header(gc
->pc
, X_GLrop_Vertex2dv
, cmdlen
);
1672 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&x
), 8);
1673 (void) memcpy((void *)(gc
->pc
+ 12), (void *)(&y
), 8);
1675 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
1678 #define X_GLrop_Vertex2dv 65
1680 __indirect_glVertex2dv(const GLdouble
* v
)
1682 generic_16_byte( X_GLrop_Vertex2dv
, v
);
1685 #define X_GLrop_Vertex2fv 66
1687 __indirect_glVertex2f(GLfloat x
, GLfloat y
)
1689 __GLXcontext
* const gc
= __glXGetCurrentContext();
1690 const GLuint cmdlen
= 12;
1691 emit_header(gc
->pc
, X_GLrop_Vertex2fv
, cmdlen
);
1692 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&x
), 4);
1693 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(&y
), 4);
1695 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
1698 #define X_GLrop_Vertex2fv 66
1700 __indirect_glVertex2fv(const GLfloat
* v
)
1702 generic_8_byte( X_GLrop_Vertex2fv
, v
);
1705 #define X_GLrop_Vertex2iv 67
1707 __indirect_glVertex2i(GLint x
, GLint y
)
1709 __GLXcontext
* const gc
= __glXGetCurrentContext();
1710 const GLuint cmdlen
= 12;
1711 emit_header(gc
->pc
, X_GLrop_Vertex2iv
, cmdlen
);
1712 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&x
), 4);
1713 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(&y
), 4);
1715 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
1718 #define X_GLrop_Vertex2iv 67
1720 __indirect_glVertex2iv(const GLint
* v
)
1722 generic_8_byte( X_GLrop_Vertex2iv
, v
);
1725 #define X_GLrop_Vertex2sv 68
1727 __indirect_glVertex2s(GLshort x
, GLshort y
)
1729 __GLXcontext
* const gc
= __glXGetCurrentContext();
1730 const GLuint cmdlen
= 8;
1731 emit_header(gc
->pc
, X_GLrop_Vertex2sv
, cmdlen
);
1732 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&x
), 2);
1733 (void) memcpy((void *)(gc
->pc
+ 6), (void *)(&y
), 2);
1735 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
1738 #define X_GLrop_Vertex2sv 68
1740 __indirect_glVertex2sv(const GLshort
* v
)
1742 generic_4_byte( X_GLrop_Vertex2sv
, v
);
1745 #define X_GLrop_Vertex3dv 69
1747 __indirect_glVertex3d(GLdouble x
, GLdouble y
, GLdouble z
)
1749 __GLXcontext
* const gc
= __glXGetCurrentContext();
1750 const GLuint cmdlen
= 28;
1751 emit_header(gc
->pc
, X_GLrop_Vertex3dv
, cmdlen
);
1752 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&x
), 8);
1753 (void) memcpy((void *)(gc
->pc
+ 12), (void *)(&y
), 8);
1754 (void) memcpy((void *)(gc
->pc
+ 20), (void *)(&z
), 8);
1756 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
1759 #define X_GLrop_Vertex3dv 69
1761 __indirect_glVertex3dv(const GLdouble
* v
)
1763 generic_24_byte( X_GLrop_Vertex3dv
, v
);
1766 #define X_GLrop_Vertex3fv 70
1768 __indirect_glVertex3f(GLfloat x
, GLfloat y
, GLfloat z
)
1770 __GLXcontext
* const gc
= __glXGetCurrentContext();
1771 const GLuint cmdlen
= 16;
1772 emit_header(gc
->pc
, X_GLrop_Vertex3fv
, cmdlen
);
1773 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&x
), 4);
1774 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(&y
), 4);
1775 (void) memcpy((void *)(gc
->pc
+ 12), (void *)(&z
), 4);
1777 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
1780 #define X_GLrop_Vertex3fv 70
1782 __indirect_glVertex3fv(const GLfloat
* v
)
1784 generic_12_byte( X_GLrop_Vertex3fv
, v
);
1787 #define X_GLrop_Vertex3iv 71
1789 __indirect_glVertex3i(GLint x
, GLint y
, GLint z
)
1791 __GLXcontext
* const gc
= __glXGetCurrentContext();
1792 const GLuint cmdlen
= 16;
1793 emit_header(gc
->pc
, X_GLrop_Vertex3iv
, cmdlen
);
1794 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&x
), 4);
1795 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(&y
), 4);
1796 (void) memcpy((void *)(gc
->pc
+ 12), (void *)(&z
), 4);
1798 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
1801 #define X_GLrop_Vertex3iv 71
1803 __indirect_glVertex3iv(const GLint
* v
)
1805 generic_12_byte( X_GLrop_Vertex3iv
, v
);
1808 #define X_GLrop_Vertex3sv 72
1810 __indirect_glVertex3s(GLshort x
, GLshort y
, GLshort z
)
1812 __GLXcontext
* const gc
= __glXGetCurrentContext();
1813 const GLuint cmdlen
= 12;
1814 emit_header(gc
->pc
, X_GLrop_Vertex3sv
, cmdlen
);
1815 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&x
), 2);
1816 (void) memcpy((void *)(gc
->pc
+ 6), (void *)(&y
), 2);
1817 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(&z
), 2);
1819 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
1822 #define X_GLrop_Vertex3sv 72
1824 __indirect_glVertex3sv(const GLshort
* v
)
1826 generic_6_byte( X_GLrop_Vertex3sv
, v
);
1829 #define X_GLrop_Vertex4dv 73
1831 __indirect_glVertex4d(GLdouble x
, GLdouble y
, GLdouble z
, GLdouble w
)
1833 __GLXcontext
* const gc
= __glXGetCurrentContext();
1834 const GLuint cmdlen
= 36;
1835 emit_header(gc
->pc
, X_GLrop_Vertex4dv
, cmdlen
);
1836 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&x
), 8);
1837 (void) memcpy((void *)(gc
->pc
+ 12), (void *)(&y
), 8);
1838 (void) memcpy((void *)(gc
->pc
+ 20), (void *)(&z
), 8);
1839 (void) memcpy((void *)(gc
->pc
+ 28), (void *)(&w
), 8);
1841 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
1844 #define X_GLrop_Vertex4dv 73
1846 __indirect_glVertex4dv(const GLdouble
* v
)
1848 generic_32_byte( X_GLrop_Vertex4dv
, v
);
1851 #define X_GLrop_Vertex4fv 74
1853 __indirect_glVertex4f(GLfloat x
, GLfloat y
, GLfloat z
, GLfloat w
)
1855 __GLXcontext
* const gc
= __glXGetCurrentContext();
1856 const GLuint cmdlen
= 20;
1857 emit_header(gc
->pc
, X_GLrop_Vertex4fv
, cmdlen
);
1858 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&x
), 4);
1859 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(&y
), 4);
1860 (void) memcpy((void *)(gc
->pc
+ 12), (void *)(&z
), 4);
1861 (void) memcpy((void *)(gc
->pc
+ 16), (void *)(&w
), 4);
1863 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
1866 #define X_GLrop_Vertex4fv 74
1868 __indirect_glVertex4fv(const GLfloat
* v
)
1870 generic_16_byte( X_GLrop_Vertex4fv
, v
);
1873 #define X_GLrop_Vertex4iv 75
1875 __indirect_glVertex4i(GLint x
, GLint y
, GLint z
, GLint w
)
1877 __GLXcontext
* const gc
= __glXGetCurrentContext();
1878 const GLuint cmdlen
= 20;
1879 emit_header(gc
->pc
, X_GLrop_Vertex4iv
, cmdlen
);
1880 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&x
), 4);
1881 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(&y
), 4);
1882 (void) memcpy((void *)(gc
->pc
+ 12), (void *)(&z
), 4);
1883 (void) memcpy((void *)(gc
->pc
+ 16), (void *)(&w
), 4);
1885 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
1888 #define X_GLrop_Vertex4iv 75
1890 __indirect_glVertex4iv(const GLint
* v
)
1892 generic_16_byte( X_GLrop_Vertex4iv
, v
);
1895 #define X_GLrop_Vertex4sv 76
1897 __indirect_glVertex4s(GLshort x
, GLshort y
, GLshort z
, GLshort w
)
1899 __GLXcontext
* const gc
= __glXGetCurrentContext();
1900 const GLuint cmdlen
= 12;
1901 emit_header(gc
->pc
, X_GLrop_Vertex4sv
, cmdlen
);
1902 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&x
), 2);
1903 (void) memcpy((void *)(gc
->pc
+ 6), (void *)(&y
), 2);
1904 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(&z
), 2);
1905 (void) memcpy((void *)(gc
->pc
+ 10), (void *)(&w
), 2);
1907 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
1910 #define X_GLrop_Vertex4sv 76
1912 __indirect_glVertex4sv(const GLshort
* v
)
1914 generic_8_byte( X_GLrop_Vertex4sv
, v
);
1917 #define X_GLrop_ClipPlane 77
1919 __indirect_glClipPlane(GLenum plane
, const GLdouble
* equation
)
1921 __GLXcontext
* const gc
= __glXGetCurrentContext();
1922 const GLuint cmdlen
= 40;
1923 emit_header(gc
->pc
, X_GLrop_ClipPlane
, cmdlen
);
1924 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(equation
), 32);
1925 (void) memcpy((void *)(gc
->pc
+ 36), (void *)(&plane
), 4);
1927 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
1930 #define X_GLrop_ColorMaterial 78
1932 __indirect_glColorMaterial(GLenum face
, GLenum mode
)
1934 __GLXcontext
* const gc
= __glXGetCurrentContext();
1935 const GLuint cmdlen
= 12;
1936 emit_header(gc
->pc
, X_GLrop_ColorMaterial
, cmdlen
);
1937 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&face
), 4);
1938 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(&mode
), 4);
1940 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
1943 #define X_GLrop_CullFace 79
1945 __indirect_glCullFace(GLenum mode
)
1947 __GLXcontext
* const gc
= __glXGetCurrentContext();
1948 const GLuint cmdlen
= 8;
1949 emit_header(gc
->pc
, X_GLrop_CullFace
, cmdlen
);
1950 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&mode
), 4);
1952 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
1955 #define X_GLrop_Fogf 80
1957 __indirect_glFogf(GLenum pname
, GLfloat param
)
1959 __GLXcontext
* const gc
= __glXGetCurrentContext();
1960 const GLuint cmdlen
= 12;
1961 emit_header(gc
->pc
, X_GLrop_Fogf
, cmdlen
);
1962 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&pname
), 4);
1963 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(¶m
), 4);
1965 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
1968 #define X_GLrop_Fogfv 81
1970 __indirect_glFogfv(GLenum pname
, const GLfloat
* params
)
1972 __GLXcontext
* const gc
= __glXGetCurrentContext();
1973 const GLuint compsize
= __glFogfv_size(pname
);
1974 const GLuint cmdlen
= 8 + __GLX_PAD((compsize
* 4));
1975 emit_header(gc
->pc
, X_GLrop_Fogfv
, cmdlen
);
1976 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&pname
), 4);
1977 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(params
), (compsize
* 4));
1979 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
1982 #define X_GLrop_Fogi 82
1984 __indirect_glFogi(GLenum pname
, GLint param
)
1986 __GLXcontext
* const gc
= __glXGetCurrentContext();
1987 const GLuint cmdlen
= 12;
1988 emit_header(gc
->pc
, X_GLrop_Fogi
, cmdlen
);
1989 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&pname
), 4);
1990 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(¶m
), 4);
1992 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
1995 #define X_GLrop_Fogiv 83
1997 __indirect_glFogiv(GLenum pname
, const GLint
* params
)
1999 __GLXcontext
* const gc
= __glXGetCurrentContext();
2000 const GLuint compsize
= __glFogiv_size(pname
);
2001 const GLuint cmdlen
= 8 + __GLX_PAD((compsize
* 4));
2002 emit_header(gc
->pc
, X_GLrop_Fogiv
, cmdlen
);
2003 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&pname
), 4);
2004 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(params
), (compsize
* 4));
2006 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
2009 #define X_GLrop_FrontFace 84
2011 __indirect_glFrontFace(GLenum mode
)
2013 __GLXcontext
* const gc
= __glXGetCurrentContext();
2014 const GLuint cmdlen
= 8;
2015 emit_header(gc
->pc
, X_GLrop_FrontFace
, cmdlen
);
2016 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&mode
), 4);
2018 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
2021 #define X_GLrop_Hint 85
2023 __indirect_glHint(GLenum target
, GLenum mode
)
2025 __GLXcontext
* const gc
= __glXGetCurrentContext();
2026 const GLuint cmdlen
= 12;
2027 emit_header(gc
->pc
, X_GLrop_Hint
, cmdlen
);
2028 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&target
), 4);
2029 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(&mode
), 4);
2031 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
2034 #define X_GLrop_Lightf 86
2036 __indirect_glLightf(GLenum light
, GLenum pname
, GLfloat param
)
2038 __GLXcontext
* const gc
= __glXGetCurrentContext();
2039 const GLuint cmdlen
= 16;
2040 emit_header(gc
->pc
, X_GLrop_Lightf
, cmdlen
);
2041 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&light
), 4);
2042 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(&pname
), 4);
2043 (void) memcpy((void *)(gc
->pc
+ 12), (void *)(¶m
), 4);
2045 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
2048 #define X_GLrop_Lightfv 87
2050 __indirect_glLightfv(GLenum light
, GLenum pname
, const GLfloat
* params
)
2052 __GLXcontext
* const gc
= __glXGetCurrentContext();
2053 const GLuint compsize
= __glLightfv_size(pname
);
2054 const GLuint cmdlen
= 12 + __GLX_PAD((compsize
* 4));
2055 emit_header(gc
->pc
, X_GLrop_Lightfv
, cmdlen
);
2056 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&light
), 4);
2057 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(&pname
), 4);
2058 (void) memcpy((void *)(gc
->pc
+ 12), (void *)(params
), (compsize
* 4));
2060 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
2063 #define X_GLrop_Lighti 88
2065 __indirect_glLighti(GLenum light
, GLenum pname
, GLint param
)
2067 __GLXcontext
* const gc
= __glXGetCurrentContext();
2068 const GLuint cmdlen
= 16;
2069 emit_header(gc
->pc
, X_GLrop_Lighti
, cmdlen
);
2070 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&light
), 4);
2071 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(&pname
), 4);
2072 (void) memcpy((void *)(gc
->pc
+ 12), (void *)(¶m
), 4);
2074 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
2077 #define X_GLrop_Lightiv 89
2079 __indirect_glLightiv(GLenum light
, GLenum pname
, const GLint
* params
)
2081 __GLXcontext
* const gc
= __glXGetCurrentContext();
2082 const GLuint compsize
= __glLightiv_size(pname
);
2083 const GLuint cmdlen
= 12 + __GLX_PAD((compsize
* 4));
2084 emit_header(gc
->pc
, X_GLrop_Lightiv
, cmdlen
);
2085 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&light
), 4);
2086 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(&pname
), 4);
2087 (void) memcpy((void *)(gc
->pc
+ 12), (void *)(params
), (compsize
* 4));
2089 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
2092 #define X_GLrop_LightModelf 90
2094 __indirect_glLightModelf(GLenum pname
, GLfloat param
)
2096 __GLXcontext
* const gc
= __glXGetCurrentContext();
2097 const GLuint cmdlen
= 12;
2098 emit_header(gc
->pc
, X_GLrop_LightModelf
, cmdlen
);
2099 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&pname
), 4);
2100 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(¶m
), 4);
2102 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
2105 #define X_GLrop_LightModelfv 91
2107 __indirect_glLightModelfv(GLenum pname
, const GLfloat
* params
)
2109 __GLXcontext
* const gc
= __glXGetCurrentContext();
2110 const GLuint compsize
= __glLightModelfv_size(pname
);
2111 const GLuint cmdlen
= 8 + __GLX_PAD((compsize
* 4));
2112 emit_header(gc
->pc
, X_GLrop_LightModelfv
, cmdlen
);
2113 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&pname
), 4);
2114 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(params
), (compsize
* 4));
2116 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
2119 #define X_GLrop_LightModeli 92
2121 __indirect_glLightModeli(GLenum pname
, GLint param
)
2123 __GLXcontext
* const gc
= __glXGetCurrentContext();
2124 const GLuint cmdlen
= 12;
2125 emit_header(gc
->pc
, X_GLrop_LightModeli
, cmdlen
);
2126 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&pname
), 4);
2127 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(¶m
), 4);
2129 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
2132 #define X_GLrop_LightModeliv 93
2134 __indirect_glLightModeliv(GLenum pname
, const GLint
* params
)
2136 __GLXcontext
* const gc
= __glXGetCurrentContext();
2137 const GLuint compsize
= __glLightModeliv_size(pname
);
2138 const GLuint cmdlen
= 8 + __GLX_PAD((compsize
* 4));
2139 emit_header(gc
->pc
, X_GLrop_LightModeliv
, cmdlen
);
2140 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&pname
), 4);
2141 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(params
), (compsize
* 4));
2143 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
2146 #define X_GLrop_LineStipple 94
2148 __indirect_glLineStipple(GLint factor
, GLushort pattern
)
2150 __GLXcontext
* const gc
= __glXGetCurrentContext();
2151 const GLuint cmdlen
= 12;
2152 emit_header(gc
->pc
, X_GLrop_LineStipple
, cmdlen
);
2153 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&factor
), 4);
2154 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(&pattern
), 2);
2156 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
2159 #define X_GLrop_LineWidth 95
2161 __indirect_glLineWidth(GLfloat width
)
2163 __GLXcontext
* const gc
= __glXGetCurrentContext();
2164 const GLuint cmdlen
= 8;
2165 emit_header(gc
->pc
, X_GLrop_LineWidth
, cmdlen
);
2166 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&width
), 4);
2168 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
2171 #define X_GLrop_Materialf 96
2173 __indirect_glMaterialf(GLenum face
, GLenum pname
, GLfloat param
)
2175 __GLXcontext
* const gc
= __glXGetCurrentContext();
2176 const GLuint cmdlen
= 16;
2177 emit_header(gc
->pc
, X_GLrop_Materialf
, cmdlen
);
2178 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&face
), 4);
2179 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(&pname
), 4);
2180 (void) memcpy((void *)(gc
->pc
+ 12), (void *)(¶m
), 4);
2182 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
2185 #define X_GLrop_Materialfv 97
2187 __indirect_glMaterialfv(GLenum face
, GLenum pname
, const GLfloat
* params
)
2189 __GLXcontext
* const gc
= __glXGetCurrentContext();
2190 const GLuint compsize
= __glMaterialfv_size(pname
);
2191 const GLuint cmdlen
= 12 + __GLX_PAD((compsize
* 4));
2192 emit_header(gc
->pc
, X_GLrop_Materialfv
, cmdlen
);
2193 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&face
), 4);
2194 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(&pname
), 4);
2195 (void) memcpy((void *)(gc
->pc
+ 12), (void *)(params
), (compsize
* 4));
2197 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
2200 #define X_GLrop_Materiali 98
2202 __indirect_glMateriali(GLenum face
, GLenum pname
, GLint param
)
2204 __GLXcontext
* const gc
= __glXGetCurrentContext();
2205 const GLuint cmdlen
= 16;
2206 emit_header(gc
->pc
, X_GLrop_Materiali
, cmdlen
);
2207 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&face
), 4);
2208 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(&pname
), 4);
2209 (void) memcpy((void *)(gc
->pc
+ 12), (void *)(¶m
), 4);
2211 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
2214 #define X_GLrop_Materialiv 99
2216 __indirect_glMaterialiv(GLenum face
, GLenum pname
, const GLint
* params
)
2218 __GLXcontext
* const gc
= __glXGetCurrentContext();
2219 const GLuint compsize
= __glMaterialiv_size(pname
);
2220 const GLuint cmdlen
= 12 + __GLX_PAD((compsize
* 4));
2221 emit_header(gc
->pc
, X_GLrop_Materialiv
, cmdlen
);
2222 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&face
), 4);
2223 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(&pname
), 4);
2224 (void) memcpy((void *)(gc
->pc
+ 12), (void *)(params
), (compsize
* 4));
2226 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
2229 #define X_GLrop_PointSize 100
2231 __indirect_glPointSize(GLfloat size
)
2233 __GLXcontext
* const gc
= __glXGetCurrentContext();
2234 const GLuint cmdlen
= 8;
2235 emit_header(gc
->pc
, X_GLrop_PointSize
, cmdlen
);
2236 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&size
), 4);
2238 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
2241 #define X_GLrop_PolygonMode 101
2243 __indirect_glPolygonMode(GLenum face
, GLenum mode
)
2245 __GLXcontext
* const gc
= __glXGetCurrentContext();
2246 const GLuint cmdlen
= 12;
2247 emit_header(gc
->pc
, X_GLrop_PolygonMode
, cmdlen
);
2248 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&face
), 4);
2249 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(&mode
), 4);
2251 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
2254 #define X_GLrop_PolygonStipple 102
2256 __indirect_glPolygonStipple(const GLubyte
* mask
)
2258 __GLXcontext
* const gc
= __glXGetCurrentContext();
2259 const GLuint compsize
= (mask
!= NULL
) ? __glImageSize(32, 32, 1, GL_COLOR_INDEX
, GL_BITMAP
, 0) : 0;
2260 const GLuint cmdlen
= 24 + __GLX_PAD(compsize
);
2261 emit_header(gc
->pc
, X_GLrop_PolygonStipple
, cmdlen
);
2263 (*gc
->fillImage
)(gc
, 2, 32, 32, 1, GL_COLOR_INDEX
, GL_BITMAP
, mask
, gc
->pc
+ 24, gc
->pc
+ 4);
2266 (void) memcpy( gc
->pc
+ 4, default_pixel_store_2D
, default_pixel_store_2D_size
);
2269 if (gc
->pc
> gc
->limit
) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
2272 #define X_GLrop_Scissor 103
2274 __indirect_glScissor(GLint x
, GLint y
, GLsizei width
, GLsizei height
)
2276 __GLXcontext
* const gc
= __glXGetCurrentContext();
2277 const GLuint cmdlen
= 20;
2278 emit_header(gc
->pc
, X_GLrop_Scissor
, cmdlen
);
2279 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&x
), 4);
2280 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(&y
), 4);
2281 (void) memcpy((void *)(gc
->pc
+ 12), (void *)(&width
), 4);
2282 (void) memcpy((void *)(gc
->pc
+ 16), (void *)(&height
), 4);
2284 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
2287 #define X_GLrop_ShadeModel 104
2289 __indirect_glShadeModel(GLenum mode
)
2291 __GLXcontext
* const gc
= __glXGetCurrentContext();
2292 const GLuint cmdlen
= 8;
2293 emit_header(gc
->pc
, X_GLrop_ShadeModel
, cmdlen
);
2294 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&mode
), 4);
2296 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
2299 #define X_GLrop_TexParameterf 105
2301 __indirect_glTexParameterf(GLenum target
, GLenum pname
, GLfloat param
)
2303 __GLXcontext
* const gc
= __glXGetCurrentContext();
2304 const GLuint cmdlen
= 16;
2305 emit_header(gc
->pc
, X_GLrop_TexParameterf
, cmdlen
);
2306 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&target
), 4);
2307 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(&pname
), 4);
2308 (void) memcpy((void *)(gc
->pc
+ 12), (void *)(¶m
), 4);
2310 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
2313 #define X_GLrop_TexParameterfv 106
2315 __indirect_glTexParameterfv(GLenum target
, GLenum pname
, const GLfloat
* params
)
2317 __GLXcontext
* const gc
= __glXGetCurrentContext();
2318 const GLuint compsize
= __glTexParameterfv_size(pname
);
2319 const GLuint cmdlen
= 12 + __GLX_PAD((compsize
* 4));
2320 emit_header(gc
->pc
, X_GLrop_TexParameterfv
, cmdlen
);
2321 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&target
), 4);
2322 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(&pname
), 4);
2323 (void) memcpy((void *)(gc
->pc
+ 12), (void *)(params
), (compsize
* 4));
2325 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
2328 #define X_GLrop_TexParameteri 107
2330 __indirect_glTexParameteri(GLenum target
, GLenum pname
, GLint param
)
2332 __GLXcontext
* const gc
= __glXGetCurrentContext();
2333 const GLuint cmdlen
= 16;
2334 emit_header(gc
->pc
, X_GLrop_TexParameteri
, cmdlen
);
2335 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&target
), 4);
2336 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(&pname
), 4);
2337 (void) memcpy((void *)(gc
->pc
+ 12), (void *)(¶m
), 4);
2339 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
2342 #define X_GLrop_TexParameteriv 108
2344 __indirect_glTexParameteriv(GLenum target
, GLenum pname
, const GLint
* params
)
2346 __GLXcontext
* const gc
= __glXGetCurrentContext();
2347 const GLuint compsize
= __glTexParameteriv_size(pname
);
2348 const GLuint cmdlen
= 12 + __GLX_PAD((compsize
* 4));
2349 emit_header(gc
->pc
, X_GLrop_TexParameteriv
, cmdlen
);
2350 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&target
), 4);
2351 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(&pname
), 4);
2352 (void) memcpy((void *)(gc
->pc
+ 12), (void *)(params
), (compsize
* 4));
2354 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
2358 __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
)
2360 __GLXcontext
* const gc
= __glXGetCurrentContext();
2361 const GLuint compsize
= __glImageSize(width
, height
, 1, format
, type
, target
);
2362 const GLuint cmdlen
= 56 + __GLX_PAD(compsize
);
2363 if (__builtin_expect(gc
->currentDpy
!= NULL
, 1)) {
2364 if (cmdlen
<= gc
->maxSmallRenderCommandSize
) {
2365 if ( (gc
->pc
+ cmdlen
) > gc
->bufEnd
) {
2366 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
2368 emit_header(gc
->pc
, opcode
, cmdlen
);
2369 (void) memcpy((void *)(gc
->pc
+ 24), (void *)(&target
), 4);
2370 (void) memcpy((void *)(gc
->pc
+ 28), (void *)(&level
), 4);
2371 (void) memcpy((void *)(gc
->pc
+ 32), (void *)(&internalformat
), 4);
2372 (void) memcpy((void *)(gc
->pc
+ 36), (void *)(&width
), 4);
2373 (void) memcpy((void *)(gc
->pc
+ 40), (void *)(&height
), 4);
2374 (void) memcpy((void *)(gc
->pc
+ 44), (void *)(&border
), 4);
2375 (void) memcpy((void *)(gc
->pc
+ 48), (void *)(&format
), 4);
2376 (void) memcpy((void *)(gc
->pc
+ 52), (void *)(&type
), 4);
2377 if ((compsize
> 0) && (pixels
!= NULL
)) {
2378 (*gc
->fillImage
)(gc
, dim
, width
, height
, 1, format
, type
, pixels
, gc
->pc
+ 56, gc
->pc
+ 4);
2381 (void) memcpy( gc
->pc
+ 4, default_pixel_store_2D
, default_pixel_store_2D_size
);
2384 if (gc
->pc
> gc
->limit
) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
2387 const GLint op
= opcode
;
2388 const GLuint cmdlenLarge
= cmdlen
+ 4;
2389 GLubyte
* const pc
= __glXFlushRenderBuffer(gc
, gc
->pc
);
2390 (void) memcpy((void *)(pc
+ 0), (void *)(&cmdlenLarge
), 4);
2391 (void) memcpy((void *)(pc
+ 4), (void *)(&op
), 4);
2392 (void) memcpy((void *)(pc
+ 28), (void *)(&target
), 4);
2393 (void) memcpy((void *)(pc
+ 32), (void *)(&level
), 4);
2394 (void) memcpy((void *)(pc
+ 36), (void *)(&internalformat
), 4);
2395 (void) memcpy((void *)(pc
+ 40), (void *)(&width
), 4);
2396 (void) memcpy((void *)(pc
+ 44), (void *)(&height
), 4);
2397 (void) memcpy((void *)(pc
+ 48), (void *)(&border
), 4);
2398 (void) memcpy((void *)(pc
+ 52), (void *)(&format
), 4);
2399 (void) memcpy((void *)(pc
+ 56), (void *)(&type
), 4);
2400 __glXSendLargeImage(gc
, compsize
, dim
, width
, height
, 1, format
, type
, pixels
, pc
+ 60, pc
+ 8);
2405 #define X_GLrop_TexImage1D 109
2407 __indirect_glTexImage1D(GLenum target
, GLint level
, GLint internalformat
, GLsizei width
, GLint border
, GLenum format
, GLenum type
, const GLvoid
* pixels
)
2409 __glx_TexImage_1D2D(X_GLrop_TexImage1D
, 1, target
, level
, internalformat
, width
, 1, border
, format
, type
, pixels
);
2412 #define X_GLrop_TexImage2D 110
2414 __indirect_glTexImage2D(GLenum target
, GLint level
, GLint internalformat
, GLsizei width
, GLsizei height
, GLint border
, GLenum format
, GLenum type
, const GLvoid
* pixels
)
2416 __glx_TexImage_1D2D(X_GLrop_TexImage2D
, 2, target
, level
, internalformat
, width
, height
, border
, format
, type
, pixels
);
2419 #define X_GLrop_TexEnvf 111
2421 __indirect_glTexEnvf(GLenum target
, GLenum pname
, GLfloat param
)
2423 __GLXcontext
* const gc
= __glXGetCurrentContext();
2424 const GLuint cmdlen
= 16;
2425 emit_header(gc
->pc
, X_GLrop_TexEnvf
, cmdlen
);
2426 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&target
), 4);
2427 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(&pname
), 4);
2428 (void) memcpy((void *)(gc
->pc
+ 12), (void *)(¶m
), 4);
2430 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
2433 #define X_GLrop_TexEnvfv 112
2435 __indirect_glTexEnvfv(GLenum target
, GLenum pname
, const GLfloat
* params
)
2437 __GLXcontext
* const gc
= __glXGetCurrentContext();
2438 const GLuint compsize
= __glTexEnvfv_size(pname
);
2439 const GLuint cmdlen
= 12 + __GLX_PAD((compsize
* 4));
2440 emit_header(gc
->pc
, X_GLrop_TexEnvfv
, cmdlen
);
2441 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&target
), 4);
2442 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(&pname
), 4);
2443 (void) memcpy((void *)(gc
->pc
+ 12), (void *)(params
), (compsize
* 4));
2445 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
2448 #define X_GLrop_TexEnvi 113
2450 __indirect_glTexEnvi(GLenum target
, GLenum pname
, GLint param
)
2452 __GLXcontext
* const gc
= __glXGetCurrentContext();
2453 const GLuint cmdlen
= 16;
2454 emit_header(gc
->pc
, X_GLrop_TexEnvi
, cmdlen
);
2455 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&target
), 4);
2456 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(&pname
), 4);
2457 (void) memcpy((void *)(gc
->pc
+ 12), (void *)(¶m
), 4);
2459 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
2462 #define X_GLrop_TexEnviv 114
2464 __indirect_glTexEnviv(GLenum target
, GLenum pname
, const GLint
* params
)
2466 __GLXcontext
* const gc
= __glXGetCurrentContext();
2467 const GLuint compsize
= __glTexEnviv_size(pname
);
2468 const GLuint cmdlen
= 12 + __GLX_PAD((compsize
* 4));
2469 emit_header(gc
->pc
, X_GLrop_TexEnviv
, cmdlen
);
2470 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&target
), 4);
2471 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(&pname
), 4);
2472 (void) memcpy((void *)(gc
->pc
+ 12), (void *)(params
), (compsize
* 4));
2474 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
2477 #define X_GLrop_TexGend 115
2479 __indirect_glTexGend(GLenum coord
, GLenum pname
, GLdouble param
)
2481 __GLXcontext
* const gc
= __glXGetCurrentContext();
2482 const GLuint cmdlen
= 20;
2483 emit_header(gc
->pc
, X_GLrop_TexGend
, cmdlen
);
2484 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(¶m
), 8);
2485 (void) memcpy((void *)(gc
->pc
+ 12), (void *)(&coord
), 4);
2486 (void) memcpy((void *)(gc
->pc
+ 16), (void *)(&pname
), 4);
2488 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
2491 #define X_GLrop_TexGendv 116
2493 __indirect_glTexGendv(GLenum coord
, GLenum pname
, const GLdouble
* params
)
2495 __GLXcontext
* const gc
= __glXGetCurrentContext();
2496 const GLuint compsize
= __glTexGendv_size(pname
);
2497 const GLuint cmdlen
= 12 + __GLX_PAD((compsize
* 8));
2498 emit_header(gc
->pc
, X_GLrop_TexGendv
, cmdlen
);
2499 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&coord
), 4);
2500 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(&pname
), 4);
2501 (void) memcpy((void *)(gc
->pc
+ 12), (void *)(params
), (compsize
* 8));
2503 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
2506 #define X_GLrop_TexGenf 117
2508 __indirect_glTexGenf(GLenum coord
, GLenum pname
, GLfloat param
)
2510 __GLXcontext
* const gc
= __glXGetCurrentContext();
2511 const GLuint cmdlen
= 16;
2512 emit_header(gc
->pc
, X_GLrop_TexGenf
, cmdlen
);
2513 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&coord
), 4);
2514 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(&pname
), 4);
2515 (void) memcpy((void *)(gc
->pc
+ 12), (void *)(¶m
), 4);
2517 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
2520 #define X_GLrop_TexGenfv 118
2522 __indirect_glTexGenfv(GLenum coord
, GLenum pname
, const GLfloat
* params
)
2524 __GLXcontext
* const gc
= __glXGetCurrentContext();
2525 const GLuint compsize
= __glTexGenfv_size(pname
);
2526 const GLuint cmdlen
= 12 + __GLX_PAD((compsize
* 4));
2527 emit_header(gc
->pc
, X_GLrop_TexGenfv
, cmdlen
);
2528 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&coord
), 4);
2529 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(&pname
), 4);
2530 (void) memcpy((void *)(gc
->pc
+ 12), (void *)(params
), (compsize
* 4));
2532 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
2535 #define X_GLrop_TexGeni 119
2537 __indirect_glTexGeni(GLenum coord
, GLenum pname
, GLint param
)
2539 __GLXcontext
* const gc
= __glXGetCurrentContext();
2540 const GLuint cmdlen
= 16;
2541 emit_header(gc
->pc
, X_GLrop_TexGeni
, cmdlen
);
2542 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&coord
), 4);
2543 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(&pname
), 4);
2544 (void) memcpy((void *)(gc
->pc
+ 12), (void *)(¶m
), 4);
2546 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
2549 #define X_GLrop_TexGeniv 120
2551 __indirect_glTexGeniv(GLenum coord
, GLenum pname
, const GLint
* params
)
2553 __GLXcontext
* const gc
= __glXGetCurrentContext();
2554 const GLuint compsize
= __glTexGeniv_size(pname
);
2555 const GLuint cmdlen
= 12 + __GLX_PAD((compsize
* 4));
2556 emit_header(gc
->pc
, X_GLrop_TexGeniv
, cmdlen
);
2557 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&coord
), 4);
2558 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(&pname
), 4);
2559 (void) memcpy((void *)(gc
->pc
+ 12), (void *)(params
), (compsize
* 4));
2561 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
2564 #define X_GLrop_InitNames 121
2566 __indirect_glInitNames(void)
2568 __GLXcontext
* const gc
= __glXGetCurrentContext();
2569 const GLuint cmdlen
= 4;
2570 emit_header(gc
->pc
, X_GLrop_InitNames
, cmdlen
);
2572 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
2575 #define X_GLrop_LoadName 122
2577 __indirect_glLoadName(GLuint name
)
2579 __GLXcontext
* const gc
= __glXGetCurrentContext();
2580 const GLuint cmdlen
= 8;
2581 emit_header(gc
->pc
, X_GLrop_LoadName
, cmdlen
);
2582 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&name
), 4);
2584 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
2587 #define X_GLrop_PassThrough 123
2589 __indirect_glPassThrough(GLfloat token
)
2591 __GLXcontext
* const gc
= __glXGetCurrentContext();
2592 const GLuint cmdlen
= 8;
2593 emit_header(gc
->pc
, X_GLrop_PassThrough
, cmdlen
);
2594 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&token
), 4);
2596 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
2599 #define X_GLrop_PopName 124
2601 __indirect_glPopName(void)
2603 __GLXcontext
* const gc
= __glXGetCurrentContext();
2604 const GLuint cmdlen
= 4;
2605 emit_header(gc
->pc
, X_GLrop_PopName
, cmdlen
);
2607 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
2610 #define X_GLrop_PushName 125
2612 __indirect_glPushName(GLuint name
)
2614 __GLXcontext
* const gc
= __glXGetCurrentContext();
2615 const GLuint cmdlen
= 8;
2616 emit_header(gc
->pc
, X_GLrop_PushName
, cmdlen
);
2617 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&name
), 4);
2619 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
2622 #define X_GLrop_DrawBuffer 126
2624 __indirect_glDrawBuffer(GLenum mode
)
2626 __GLXcontext
* const gc
= __glXGetCurrentContext();
2627 const GLuint cmdlen
= 8;
2628 emit_header(gc
->pc
, X_GLrop_DrawBuffer
, cmdlen
);
2629 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&mode
), 4);
2631 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
2634 #define X_GLrop_Clear 127
2636 __indirect_glClear(GLbitfield mask
)
2638 __GLXcontext
* const gc
= __glXGetCurrentContext();
2639 const GLuint cmdlen
= 8;
2640 emit_header(gc
->pc
, X_GLrop_Clear
, cmdlen
);
2641 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&mask
), 4);
2643 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
2646 #define X_GLrop_ClearAccum 128
2648 __indirect_glClearAccum(GLfloat red
, GLfloat green
, GLfloat blue
, GLfloat alpha
)
2650 __GLXcontext
* const gc
= __glXGetCurrentContext();
2651 const GLuint cmdlen
= 20;
2652 emit_header(gc
->pc
, X_GLrop_ClearAccum
, cmdlen
);
2653 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&red
), 4);
2654 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(&green
), 4);
2655 (void) memcpy((void *)(gc
->pc
+ 12), (void *)(&blue
), 4);
2656 (void) memcpy((void *)(gc
->pc
+ 16), (void *)(&alpha
), 4);
2658 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
2661 #define X_GLrop_ClearIndex 129
2663 __indirect_glClearIndex(GLfloat c
)
2665 __GLXcontext
* const gc
= __glXGetCurrentContext();
2666 const GLuint cmdlen
= 8;
2667 emit_header(gc
->pc
, X_GLrop_ClearIndex
, cmdlen
);
2668 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&c
), 4);
2670 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
2673 #define X_GLrop_ClearColor 130
2675 __indirect_glClearColor(GLclampf red
, GLclampf green
, GLclampf blue
, GLclampf alpha
)
2677 __GLXcontext
* const gc
= __glXGetCurrentContext();
2678 const GLuint cmdlen
= 20;
2679 emit_header(gc
->pc
, X_GLrop_ClearColor
, cmdlen
);
2680 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&red
), 4);
2681 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(&green
), 4);
2682 (void) memcpy((void *)(gc
->pc
+ 12), (void *)(&blue
), 4);
2683 (void) memcpy((void *)(gc
->pc
+ 16), (void *)(&alpha
), 4);
2685 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
2688 #define X_GLrop_ClearStencil 131
2690 __indirect_glClearStencil(GLint s
)
2692 __GLXcontext
* const gc
= __glXGetCurrentContext();
2693 const GLuint cmdlen
= 8;
2694 emit_header(gc
->pc
, X_GLrop_ClearStencil
, cmdlen
);
2695 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&s
), 4);
2697 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
2700 #define X_GLrop_ClearDepth 132
2702 __indirect_glClearDepth(GLclampd depth
)
2704 __GLXcontext
* const gc
= __glXGetCurrentContext();
2705 const GLuint cmdlen
= 12;
2706 emit_header(gc
->pc
, X_GLrop_ClearDepth
, cmdlen
);
2707 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&depth
), 8);
2709 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
2712 #define X_GLrop_StencilMask 133
2714 __indirect_glStencilMask(GLuint mask
)
2716 __GLXcontext
* const gc
= __glXGetCurrentContext();
2717 const GLuint cmdlen
= 8;
2718 emit_header(gc
->pc
, X_GLrop_StencilMask
, cmdlen
);
2719 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&mask
), 4);
2721 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
2724 #define X_GLrop_ColorMask 134
2726 __indirect_glColorMask(GLboolean red
, GLboolean green
, GLboolean blue
, GLboolean alpha
)
2728 __GLXcontext
* const gc
= __glXGetCurrentContext();
2729 const GLuint cmdlen
= 8;
2730 emit_header(gc
->pc
, X_GLrop_ColorMask
, cmdlen
);
2731 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&red
), 1);
2732 (void) memcpy((void *)(gc
->pc
+ 5), (void *)(&green
), 1);
2733 (void) memcpy((void *)(gc
->pc
+ 6), (void *)(&blue
), 1);
2734 (void) memcpy((void *)(gc
->pc
+ 7), (void *)(&alpha
), 1);
2736 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
2739 #define X_GLrop_DepthMask 135
2741 __indirect_glDepthMask(GLboolean flag
)
2743 __GLXcontext
* const gc
= __glXGetCurrentContext();
2744 const GLuint cmdlen
= 8;
2745 emit_header(gc
->pc
, X_GLrop_DepthMask
, cmdlen
);
2746 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&flag
), 1);
2748 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
2751 #define X_GLrop_IndexMask 136
2753 __indirect_glIndexMask(GLuint mask
)
2755 __GLXcontext
* const gc
= __glXGetCurrentContext();
2756 const GLuint cmdlen
= 8;
2757 emit_header(gc
->pc
, X_GLrop_IndexMask
, cmdlen
);
2758 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&mask
), 4);
2760 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
2763 #define X_GLrop_Accum 137
2765 __indirect_glAccum(GLenum op
, GLfloat value
)
2767 __GLXcontext
* const gc
= __glXGetCurrentContext();
2768 const GLuint cmdlen
= 12;
2769 emit_header(gc
->pc
, X_GLrop_Accum
, cmdlen
);
2770 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&op
), 4);
2771 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(&value
), 4);
2773 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
2776 #define X_GLrop_PopAttrib 141
2778 __indirect_glPopAttrib(void)
2780 __GLXcontext
* const gc
= __glXGetCurrentContext();
2781 const GLuint cmdlen
= 4;
2782 emit_header(gc
->pc
, X_GLrop_PopAttrib
, cmdlen
);
2784 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
2787 #define X_GLrop_PushAttrib 142
2789 __indirect_glPushAttrib(GLbitfield mask
)
2791 __GLXcontext
* const gc
= __glXGetCurrentContext();
2792 const GLuint cmdlen
= 8;
2793 emit_header(gc
->pc
, X_GLrop_PushAttrib
, cmdlen
);
2794 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&mask
), 4);
2796 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
2799 #define X_GLrop_MapGrid1d 147
2801 __indirect_glMapGrid1d(GLint un
, GLdouble u1
, GLdouble u2
)
2803 __GLXcontext
* const gc
= __glXGetCurrentContext();
2804 const GLuint cmdlen
= 24;
2805 emit_header(gc
->pc
, X_GLrop_MapGrid1d
, cmdlen
);
2806 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&u1
), 8);
2807 (void) memcpy((void *)(gc
->pc
+ 12), (void *)(&u2
), 8);
2808 (void) memcpy((void *)(gc
->pc
+ 20), (void *)(&un
), 4);
2810 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
2813 #define X_GLrop_MapGrid1f 148
2815 __indirect_glMapGrid1f(GLint un
, GLfloat u1
, GLfloat u2
)
2817 __GLXcontext
* const gc
= __glXGetCurrentContext();
2818 const GLuint cmdlen
= 16;
2819 emit_header(gc
->pc
, X_GLrop_MapGrid1f
, cmdlen
);
2820 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&un
), 4);
2821 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(&u1
), 4);
2822 (void) memcpy((void *)(gc
->pc
+ 12), (void *)(&u2
), 4);
2824 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
2827 #define X_GLrop_MapGrid2d 149
2829 __indirect_glMapGrid2d(GLint un
, GLdouble u1
, GLdouble u2
, GLint vn
, GLdouble v1
, GLdouble v2
)
2831 __GLXcontext
* const gc
= __glXGetCurrentContext();
2832 const GLuint cmdlen
= 44;
2833 emit_header(gc
->pc
, X_GLrop_MapGrid2d
, cmdlen
);
2834 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&u1
), 8);
2835 (void) memcpy((void *)(gc
->pc
+ 12), (void *)(&u2
), 8);
2836 (void) memcpy((void *)(gc
->pc
+ 20), (void *)(&v1
), 8);
2837 (void) memcpy((void *)(gc
->pc
+ 28), (void *)(&v2
), 8);
2838 (void) memcpy((void *)(gc
->pc
+ 36), (void *)(&un
), 4);
2839 (void) memcpy((void *)(gc
->pc
+ 40), (void *)(&vn
), 4);
2841 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
2844 #define X_GLrop_MapGrid2f 150
2846 __indirect_glMapGrid2f(GLint un
, GLfloat u1
, GLfloat u2
, GLint vn
, GLfloat v1
, GLfloat v2
)
2848 __GLXcontext
* const gc
= __glXGetCurrentContext();
2849 const GLuint cmdlen
= 28;
2850 emit_header(gc
->pc
, X_GLrop_MapGrid2f
, cmdlen
);
2851 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&un
), 4);
2852 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(&u1
), 4);
2853 (void) memcpy((void *)(gc
->pc
+ 12), (void *)(&u2
), 4);
2854 (void) memcpy((void *)(gc
->pc
+ 16), (void *)(&vn
), 4);
2855 (void) memcpy((void *)(gc
->pc
+ 20), (void *)(&v1
), 4);
2856 (void) memcpy((void *)(gc
->pc
+ 24), (void *)(&v2
), 4);
2858 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
2861 #define X_GLrop_EvalCoord1dv 151
2863 __indirect_glEvalCoord1d(GLdouble u
)
2865 __GLXcontext
* const gc
= __glXGetCurrentContext();
2866 const GLuint cmdlen
= 12;
2867 emit_header(gc
->pc
, X_GLrop_EvalCoord1dv
, cmdlen
);
2868 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&u
), 8);
2870 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
2873 #define X_GLrop_EvalCoord1dv 151
2875 __indirect_glEvalCoord1dv(const GLdouble
* u
)
2877 generic_8_byte( X_GLrop_EvalCoord1dv
, u
);
2880 #define X_GLrop_EvalCoord1fv 152
2882 __indirect_glEvalCoord1f(GLfloat u
)
2884 __GLXcontext
* const gc
= __glXGetCurrentContext();
2885 const GLuint cmdlen
= 8;
2886 emit_header(gc
->pc
, X_GLrop_EvalCoord1fv
, cmdlen
);
2887 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&u
), 4);
2889 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
2892 #define X_GLrop_EvalCoord1fv 152
2894 __indirect_glEvalCoord1fv(const GLfloat
* u
)
2896 generic_4_byte( X_GLrop_EvalCoord1fv
, u
);
2899 #define X_GLrop_EvalCoord2dv 153
2901 __indirect_glEvalCoord2d(GLdouble u
, GLdouble v
)
2903 __GLXcontext
* const gc
= __glXGetCurrentContext();
2904 const GLuint cmdlen
= 20;
2905 emit_header(gc
->pc
, X_GLrop_EvalCoord2dv
, cmdlen
);
2906 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&u
), 8);
2907 (void) memcpy((void *)(gc
->pc
+ 12), (void *)(&v
), 8);
2909 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
2912 #define X_GLrop_EvalCoord2dv 153
2914 __indirect_glEvalCoord2dv(const GLdouble
* u
)
2916 generic_16_byte( X_GLrop_EvalCoord2dv
, u
);
2919 #define X_GLrop_EvalCoord2fv 154
2921 __indirect_glEvalCoord2f(GLfloat u
, GLfloat v
)
2923 __GLXcontext
* const gc
= __glXGetCurrentContext();
2924 const GLuint cmdlen
= 12;
2925 emit_header(gc
->pc
, X_GLrop_EvalCoord2fv
, cmdlen
);
2926 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&u
), 4);
2927 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(&v
), 4);
2929 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
2932 #define X_GLrop_EvalCoord2fv 154
2934 __indirect_glEvalCoord2fv(const GLfloat
* u
)
2936 generic_8_byte( X_GLrop_EvalCoord2fv
, u
);
2939 #define X_GLrop_EvalMesh1 155
2941 __indirect_glEvalMesh1(GLenum mode
, GLint i1
, GLint i2
)
2943 __GLXcontext
* const gc
= __glXGetCurrentContext();
2944 const GLuint cmdlen
= 16;
2945 emit_header(gc
->pc
, X_GLrop_EvalMesh1
, cmdlen
);
2946 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&mode
), 4);
2947 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(&i1
), 4);
2948 (void) memcpy((void *)(gc
->pc
+ 12), (void *)(&i2
), 4);
2950 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
2953 #define X_GLrop_EvalPoint1 156
2955 __indirect_glEvalPoint1(GLint i
)
2957 __GLXcontext
* const gc
= __glXGetCurrentContext();
2958 const GLuint cmdlen
= 8;
2959 emit_header(gc
->pc
, X_GLrop_EvalPoint1
, cmdlen
);
2960 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&i
), 4);
2962 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
2965 #define X_GLrop_EvalMesh2 157
2967 __indirect_glEvalMesh2(GLenum mode
, GLint i1
, GLint i2
, GLint j1
, GLint j2
)
2969 __GLXcontext
* const gc
= __glXGetCurrentContext();
2970 const GLuint cmdlen
= 24;
2971 emit_header(gc
->pc
, X_GLrop_EvalMesh2
, cmdlen
);
2972 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&mode
), 4);
2973 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(&i1
), 4);
2974 (void) memcpy((void *)(gc
->pc
+ 12), (void *)(&i2
), 4);
2975 (void) memcpy((void *)(gc
->pc
+ 16), (void *)(&j1
), 4);
2976 (void) memcpy((void *)(gc
->pc
+ 20), (void *)(&j2
), 4);
2978 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
2981 #define X_GLrop_EvalPoint2 158
2983 __indirect_glEvalPoint2(GLint i
, GLint j
)
2985 __GLXcontext
* const gc
= __glXGetCurrentContext();
2986 const GLuint cmdlen
= 12;
2987 emit_header(gc
->pc
, X_GLrop_EvalPoint2
, cmdlen
);
2988 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&i
), 4);
2989 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(&j
), 4);
2991 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
2994 #define X_GLrop_AlphaFunc 159
2996 __indirect_glAlphaFunc(GLenum func
, GLclampf ref
)
2998 __GLXcontext
* const gc
= __glXGetCurrentContext();
2999 const GLuint cmdlen
= 12;
3000 emit_header(gc
->pc
, X_GLrop_AlphaFunc
, cmdlen
);
3001 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&func
), 4);
3002 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(&ref
), 4);
3004 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
3007 #define X_GLrop_BlendFunc 160
3009 __indirect_glBlendFunc(GLenum sfactor
, GLenum dfactor
)
3011 __GLXcontext
* const gc
= __glXGetCurrentContext();
3012 const GLuint cmdlen
= 12;
3013 emit_header(gc
->pc
, X_GLrop_BlendFunc
, cmdlen
);
3014 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&sfactor
), 4);
3015 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(&dfactor
), 4);
3017 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
3020 #define X_GLrop_LogicOp 161
3022 __indirect_glLogicOp(GLenum opcode
)
3024 __GLXcontext
* const gc
= __glXGetCurrentContext();
3025 const GLuint cmdlen
= 8;
3026 emit_header(gc
->pc
, X_GLrop_LogicOp
, cmdlen
);
3027 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&opcode
), 4);
3029 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
3032 #define X_GLrop_StencilFunc 162
3034 __indirect_glStencilFunc(GLenum func
, GLint ref
, GLuint mask
)
3036 __GLXcontext
* const gc
= __glXGetCurrentContext();
3037 const GLuint cmdlen
= 16;
3038 emit_header(gc
->pc
, X_GLrop_StencilFunc
, cmdlen
);
3039 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&func
), 4);
3040 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(&ref
), 4);
3041 (void) memcpy((void *)(gc
->pc
+ 12), (void *)(&mask
), 4);
3043 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
3046 #define X_GLrop_StencilOp 163
3048 __indirect_glStencilOp(GLenum fail
, GLenum zfail
, GLenum zpass
)
3050 __GLXcontext
* const gc
= __glXGetCurrentContext();
3051 const GLuint cmdlen
= 16;
3052 emit_header(gc
->pc
, X_GLrop_StencilOp
, cmdlen
);
3053 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&fail
), 4);
3054 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(&zfail
), 4);
3055 (void) memcpy((void *)(gc
->pc
+ 12), (void *)(&zpass
), 4);
3057 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
3060 #define X_GLrop_DepthFunc 164
3062 __indirect_glDepthFunc(GLenum func
)
3064 __GLXcontext
* const gc
= __glXGetCurrentContext();
3065 const GLuint cmdlen
= 8;
3066 emit_header(gc
->pc
, X_GLrop_DepthFunc
, cmdlen
);
3067 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&func
), 4);
3069 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
3072 #define X_GLrop_PixelZoom 165
3074 __indirect_glPixelZoom(GLfloat xfactor
, GLfloat yfactor
)
3076 __GLXcontext
* const gc
= __glXGetCurrentContext();
3077 const GLuint cmdlen
= 12;
3078 emit_header(gc
->pc
, X_GLrop_PixelZoom
, cmdlen
);
3079 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&xfactor
), 4);
3080 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(&yfactor
), 4);
3082 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
3085 #define X_GLrop_PixelTransferf 166
3087 __indirect_glPixelTransferf(GLenum pname
, GLfloat param
)
3089 __GLXcontext
* const gc
= __glXGetCurrentContext();
3090 const GLuint cmdlen
= 12;
3091 emit_header(gc
->pc
, X_GLrop_PixelTransferf
, cmdlen
);
3092 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&pname
), 4);
3093 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(¶m
), 4);
3095 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
3098 #define X_GLrop_PixelTransferi 167
3100 __indirect_glPixelTransferi(GLenum pname
, GLint param
)
3102 __GLXcontext
* const gc
= __glXGetCurrentContext();
3103 const GLuint cmdlen
= 12;
3104 emit_header(gc
->pc
, X_GLrop_PixelTransferi
, cmdlen
);
3105 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&pname
), 4);
3106 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(¶m
), 4);
3108 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
3111 #define X_GLrop_PixelMapfv 168
3113 __indirect_glPixelMapfv(GLenum map
, GLsizei mapsize
, const GLfloat
* values
)
3115 __GLXcontext
* const gc
= __glXGetCurrentContext();
3116 const GLuint cmdlen
= 12 + __GLX_PAD((mapsize
* 4));
3117 if (__builtin_expect((mapsize
>= 0) && (gc
->currentDpy
!= NULL
), 1)) {
3118 if (cmdlen
<= gc
->maxSmallRenderCommandSize
) {
3119 if ( (gc
->pc
+ cmdlen
) > gc
->bufEnd
) {
3120 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
3122 emit_header(gc
->pc
, X_GLrop_PixelMapfv
, cmdlen
);
3123 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&map
), 4);
3124 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(&mapsize
), 4);
3125 (void) memcpy((void *)(gc
->pc
+ 12), (void *)(values
), (mapsize
* 4));
3127 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
3130 const GLint op
= X_GLrop_PixelMapfv
;
3131 const GLuint cmdlenLarge
= cmdlen
+ 4;
3132 GLubyte
* const pc
= __glXFlushRenderBuffer(gc
, gc
->pc
);
3133 (void) memcpy((void *)(pc
+ 0), (void *)(&cmdlenLarge
), 4);
3134 (void) memcpy((void *)(pc
+ 4), (void *)(&op
), 4);
3135 (void) memcpy((void *)(pc
+ 8), (void *)(&map
), 4);
3136 (void) memcpy((void *)(pc
+ 12), (void *)(&mapsize
), 4);
3137 __glXSendLargeCommand(gc
, pc
, 16, values
, (mapsize
* 4));
3142 #define X_GLrop_PixelMapuiv 169
3144 __indirect_glPixelMapuiv(GLenum map
, GLsizei mapsize
, const GLuint
* values
)
3146 __GLXcontext
* const gc
= __glXGetCurrentContext();
3147 const GLuint cmdlen
= 12 + __GLX_PAD((mapsize
* 4));
3148 if (__builtin_expect((mapsize
>= 0) && (gc
->currentDpy
!= NULL
), 1)) {
3149 if (cmdlen
<= gc
->maxSmallRenderCommandSize
) {
3150 if ( (gc
->pc
+ cmdlen
) > gc
->bufEnd
) {
3151 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
3153 emit_header(gc
->pc
, X_GLrop_PixelMapuiv
, cmdlen
);
3154 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&map
), 4);
3155 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(&mapsize
), 4);
3156 (void) memcpy((void *)(gc
->pc
+ 12), (void *)(values
), (mapsize
* 4));
3158 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
3161 const GLint op
= X_GLrop_PixelMapuiv
;
3162 const GLuint cmdlenLarge
= cmdlen
+ 4;
3163 GLubyte
* const pc
= __glXFlushRenderBuffer(gc
, gc
->pc
);
3164 (void) memcpy((void *)(pc
+ 0), (void *)(&cmdlenLarge
), 4);
3165 (void) memcpy((void *)(pc
+ 4), (void *)(&op
), 4);
3166 (void) memcpy((void *)(pc
+ 8), (void *)(&map
), 4);
3167 (void) memcpy((void *)(pc
+ 12), (void *)(&mapsize
), 4);
3168 __glXSendLargeCommand(gc
, pc
, 16, values
, (mapsize
* 4));
3173 #define X_GLrop_PixelMapusv 170
3175 __indirect_glPixelMapusv(GLenum map
, GLsizei mapsize
, const GLushort
* values
)
3177 __GLXcontext
* const gc
= __glXGetCurrentContext();
3178 const GLuint cmdlen
= 12 + __GLX_PAD((mapsize
* 2));
3179 if (__builtin_expect((mapsize
>= 0) && (gc
->currentDpy
!= NULL
), 1)) {
3180 if (cmdlen
<= gc
->maxSmallRenderCommandSize
) {
3181 if ( (gc
->pc
+ cmdlen
) > gc
->bufEnd
) {
3182 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
3184 emit_header(gc
->pc
, X_GLrop_PixelMapusv
, cmdlen
);
3185 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&map
), 4);
3186 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(&mapsize
), 4);
3187 (void) memcpy((void *)(gc
->pc
+ 12), (void *)(values
), (mapsize
* 2));
3189 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
3192 const GLint op
= X_GLrop_PixelMapusv
;
3193 const GLuint cmdlenLarge
= cmdlen
+ 4;
3194 GLubyte
* const pc
= __glXFlushRenderBuffer(gc
, gc
->pc
);
3195 (void) memcpy((void *)(pc
+ 0), (void *)(&cmdlenLarge
), 4);
3196 (void) memcpy((void *)(pc
+ 4), (void *)(&op
), 4);
3197 (void) memcpy((void *)(pc
+ 8), (void *)(&map
), 4);
3198 (void) memcpy((void *)(pc
+ 12), (void *)(&mapsize
), 4);
3199 __glXSendLargeCommand(gc
, pc
, 16, values
, (mapsize
* 2));
3204 #define X_GLrop_ReadBuffer 171
3206 __indirect_glReadBuffer(GLenum mode
)
3208 __GLXcontext
* const gc
= __glXGetCurrentContext();
3209 const GLuint cmdlen
= 8;
3210 emit_header(gc
->pc
, X_GLrop_ReadBuffer
, cmdlen
);
3211 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&mode
), 4);
3213 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
3216 #define X_GLrop_CopyPixels 172
3218 __indirect_glCopyPixels(GLint x
, GLint y
, GLsizei width
, GLsizei height
, GLenum type
)
3220 __GLXcontext
* const gc
= __glXGetCurrentContext();
3221 const GLuint cmdlen
= 24;
3222 emit_header(gc
->pc
, X_GLrop_CopyPixels
, cmdlen
);
3223 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&x
), 4);
3224 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(&y
), 4);
3225 (void) memcpy((void *)(gc
->pc
+ 12), (void *)(&width
), 4);
3226 (void) memcpy((void *)(gc
->pc
+ 16), (void *)(&height
), 4);
3227 (void) memcpy((void *)(gc
->pc
+ 20), (void *)(&type
), 4);
3229 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
3232 #define X_GLrop_DrawPixels 173
3234 __indirect_glDrawPixels(GLsizei width
, GLsizei height
, GLenum format
, GLenum type
, const GLvoid
* pixels
)
3236 __GLXcontext
* const gc
= __glXGetCurrentContext();
3237 const GLuint compsize
= (pixels
!= NULL
) ? __glImageSize(width
, height
, 1, format
, type
, 0) : 0;
3238 const GLuint cmdlen
= 40 + __GLX_PAD(compsize
);
3239 if (__builtin_expect(gc
->currentDpy
!= NULL
, 1)) {
3240 if (cmdlen
<= gc
->maxSmallRenderCommandSize
) {
3241 if ( (gc
->pc
+ cmdlen
) > gc
->bufEnd
) {
3242 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
3244 emit_header(gc
->pc
, X_GLrop_DrawPixels
, cmdlen
);
3245 (void) memcpy((void *)(gc
->pc
+ 24), (void *)(&width
), 4);
3246 (void) memcpy((void *)(gc
->pc
+ 28), (void *)(&height
), 4);
3247 (void) memcpy((void *)(gc
->pc
+ 32), (void *)(&format
), 4);
3248 (void) memcpy((void *)(gc
->pc
+ 36), (void *)(&type
), 4);
3250 (*gc
->fillImage
)(gc
, 2, width
, height
, 1, format
, type
, pixels
, gc
->pc
+ 40, gc
->pc
+ 4);
3253 (void) memcpy( gc
->pc
+ 4, default_pixel_store_2D
, default_pixel_store_2D_size
);
3256 if (gc
->pc
> gc
->limit
) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
3259 const GLint op
= X_GLrop_DrawPixels
;
3260 const GLuint cmdlenLarge
= cmdlen
+ 4;
3261 GLubyte
* const pc
= __glXFlushRenderBuffer(gc
, gc
->pc
);
3262 (void) memcpy((void *)(pc
+ 0), (void *)(&cmdlenLarge
), 4);
3263 (void) memcpy((void *)(pc
+ 4), (void *)(&op
), 4);
3264 (void) memcpy((void *)(pc
+ 28), (void *)(&width
), 4);
3265 (void) memcpy((void *)(pc
+ 32), (void *)(&height
), 4);
3266 (void) memcpy((void *)(pc
+ 36), (void *)(&format
), 4);
3267 (void) memcpy((void *)(pc
+ 40), (void *)(&type
), 4);
3268 __glXSendLargeImage(gc
, compsize
, 2, width
, height
, 1, format
, type
, pixels
, pc
+ 44, pc
+ 8);
3273 #define X_GLsop_GetClipPlane 113
3275 __indirect_glGetClipPlane(GLenum plane
, GLdouble
* equation
)
3277 __GLXcontext
* const gc
= __glXGetCurrentContext();
3278 Display
* const dpy
= gc
->currentDpy
;
3279 const GLuint cmdlen
= 4;
3280 if (__builtin_expect(dpy
!= NULL
, 1)) {
3281 GLubyte
const * pc
= setup_single_request(gc
, X_GLsop_GetClipPlane
, cmdlen
);
3282 (void) memcpy((void *)(pc
+ 0), (void *)(&plane
), 4);
3283 (void) read_reply(dpy
, 8, equation
, GL_TRUE
);
3284 UnlockDisplay(dpy
); SyncHandle();
3289 #define X_GLsop_GetLightfv 118
3291 __indirect_glGetLightfv(GLenum light
, GLenum pname
, GLfloat
* params
)
3293 __GLXcontext
* const gc
= __glXGetCurrentContext();
3294 Display
* const dpy
= gc
->currentDpy
;
3295 const GLuint cmdlen
= 8;
3296 if (__builtin_expect(dpy
!= NULL
, 1)) {
3297 GLubyte
const * pc
= setup_single_request(gc
, X_GLsop_GetLightfv
, cmdlen
);
3298 (void) memcpy((void *)(pc
+ 0), (void *)(&light
), 4);
3299 (void) memcpy((void *)(pc
+ 4), (void *)(&pname
), 4);
3300 (void) read_reply(dpy
, 4, params
, GL_FALSE
);
3301 UnlockDisplay(dpy
); SyncHandle();
3306 #define X_GLsop_GetLightiv 119
3308 __indirect_glGetLightiv(GLenum light
, GLenum pname
, GLint
* params
)
3310 __GLXcontext
* const gc
= __glXGetCurrentContext();
3311 Display
* const dpy
= gc
->currentDpy
;
3312 const GLuint cmdlen
= 8;
3313 if (__builtin_expect(dpy
!= NULL
, 1)) {
3314 GLubyte
const * pc
= setup_single_request(gc
, X_GLsop_GetLightiv
, cmdlen
);
3315 (void) memcpy((void *)(pc
+ 0), (void *)(&light
), 4);
3316 (void) memcpy((void *)(pc
+ 4), (void *)(&pname
), 4);
3317 (void) read_reply(dpy
, 4, params
, GL_FALSE
);
3318 UnlockDisplay(dpy
); SyncHandle();
3323 #define X_GLsop_GetMapdv 120
3325 __indirect_glGetMapdv(GLenum target
, GLenum query
, GLdouble
* v
)
3327 __GLXcontext
* const gc
= __glXGetCurrentContext();
3328 Display
* const dpy
= gc
->currentDpy
;
3329 const GLuint cmdlen
= 8;
3330 if (__builtin_expect(dpy
!= NULL
, 1)) {
3331 GLubyte
const * pc
= setup_single_request(gc
, X_GLsop_GetMapdv
, cmdlen
);
3332 (void) memcpy((void *)(pc
+ 0), (void *)(&target
), 4);
3333 (void) memcpy((void *)(pc
+ 4), (void *)(&query
), 4);
3334 (void) read_reply(dpy
, 8, v
, GL_FALSE
);
3335 UnlockDisplay(dpy
); SyncHandle();
3340 #define X_GLsop_GetMapfv 121
3342 __indirect_glGetMapfv(GLenum target
, GLenum query
, GLfloat
* v
)
3344 __GLXcontext
* const gc
= __glXGetCurrentContext();
3345 Display
* const dpy
= gc
->currentDpy
;
3346 const GLuint cmdlen
= 8;
3347 if (__builtin_expect(dpy
!= NULL
, 1)) {
3348 GLubyte
const * pc
= setup_single_request(gc
, X_GLsop_GetMapfv
, cmdlen
);
3349 (void) memcpy((void *)(pc
+ 0), (void *)(&target
), 4);
3350 (void) memcpy((void *)(pc
+ 4), (void *)(&query
), 4);
3351 (void) read_reply(dpy
, 4, v
, GL_FALSE
);
3352 UnlockDisplay(dpy
); SyncHandle();
3357 #define X_GLsop_GetMapiv 122
3359 __indirect_glGetMapiv(GLenum target
, GLenum query
, GLint
* v
)
3361 __GLXcontext
* const gc
= __glXGetCurrentContext();
3362 Display
* const dpy
= gc
->currentDpy
;
3363 const GLuint cmdlen
= 8;
3364 if (__builtin_expect(dpy
!= NULL
, 1)) {
3365 GLubyte
const * pc
= setup_single_request(gc
, X_GLsop_GetMapiv
, cmdlen
);
3366 (void) memcpy((void *)(pc
+ 0), (void *)(&target
), 4);
3367 (void) memcpy((void *)(pc
+ 4), (void *)(&query
), 4);
3368 (void) read_reply(dpy
, 4, v
, GL_FALSE
);
3369 UnlockDisplay(dpy
); SyncHandle();
3374 #define X_GLsop_GetMaterialfv 123
3376 __indirect_glGetMaterialfv(GLenum face
, GLenum pname
, GLfloat
* params
)
3378 __GLXcontext
* const gc
= __glXGetCurrentContext();
3379 Display
* const dpy
= gc
->currentDpy
;
3380 const GLuint cmdlen
= 8;
3381 if (__builtin_expect(dpy
!= NULL
, 1)) {
3382 GLubyte
const * pc
= setup_single_request(gc
, X_GLsop_GetMaterialfv
, cmdlen
);
3383 (void) memcpy((void *)(pc
+ 0), (void *)(&face
), 4);
3384 (void) memcpy((void *)(pc
+ 4), (void *)(&pname
), 4);
3385 (void) read_reply(dpy
, 4, params
, GL_FALSE
);
3386 UnlockDisplay(dpy
); SyncHandle();
3391 #define X_GLsop_GetMaterialiv 124
3393 __indirect_glGetMaterialiv(GLenum face
, GLenum pname
, GLint
* params
)
3395 __GLXcontext
* const gc
= __glXGetCurrentContext();
3396 Display
* const dpy
= gc
->currentDpy
;
3397 const GLuint cmdlen
= 8;
3398 if (__builtin_expect(dpy
!= NULL
, 1)) {
3399 GLubyte
const * pc
= setup_single_request(gc
, X_GLsop_GetMaterialiv
, cmdlen
);
3400 (void) memcpy((void *)(pc
+ 0), (void *)(&face
), 4);
3401 (void) memcpy((void *)(pc
+ 4), (void *)(&pname
), 4);
3402 (void) read_reply(dpy
, 4, params
, GL_FALSE
);
3403 UnlockDisplay(dpy
); SyncHandle();
3408 #define X_GLsop_GetPixelMapfv 125
3410 __indirect_glGetPixelMapfv(GLenum map
, GLfloat
* values
)
3412 __GLXcontext
* const gc
= __glXGetCurrentContext();
3413 Display
* const dpy
= gc
->currentDpy
;
3414 const GLuint cmdlen
= 4;
3415 if (__builtin_expect(dpy
!= NULL
, 1)) {
3416 GLubyte
const * pc
= setup_single_request(gc
, X_GLsop_GetPixelMapfv
, cmdlen
);
3417 (void) memcpy((void *)(pc
+ 0), (void *)(&map
), 4);
3418 (void) read_reply(dpy
, 4, values
, GL_FALSE
);
3419 UnlockDisplay(dpy
); SyncHandle();
3424 #define X_GLsop_GetPixelMapuiv 126
3426 __indirect_glGetPixelMapuiv(GLenum map
, GLuint
* values
)
3428 __GLXcontext
* const gc
= __glXGetCurrentContext();
3429 Display
* const dpy
= gc
->currentDpy
;
3430 const GLuint cmdlen
= 4;
3431 if (__builtin_expect(dpy
!= NULL
, 1)) {
3432 GLubyte
const * pc
= setup_single_request(gc
, X_GLsop_GetPixelMapuiv
, cmdlen
);
3433 (void) memcpy((void *)(pc
+ 0), (void *)(&map
), 4);
3434 (void) read_reply(dpy
, 4, values
, GL_FALSE
);
3435 UnlockDisplay(dpy
); SyncHandle();
3440 #define X_GLsop_GetPixelMapusv 127
3442 __indirect_glGetPixelMapusv(GLenum map
, GLushort
* values
)
3444 __GLXcontext
* const gc
= __glXGetCurrentContext();
3445 Display
* const dpy
= gc
->currentDpy
;
3446 const GLuint cmdlen
= 4;
3447 if (__builtin_expect(dpy
!= NULL
, 1)) {
3448 GLubyte
const * pc
= setup_single_request(gc
, X_GLsop_GetPixelMapusv
, cmdlen
);
3449 (void) memcpy((void *)(pc
+ 0), (void *)(&map
), 4);
3450 (void) read_reply(dpy
, 2, values
, GL_FALSE
);
3451 UnlockDisplay(dpy
); SyncHandle();
3456 #define X_GLsop_GetTexEnvfv 130
3458 __indirect_glGetTexEnvfv(GLenum target
, GLenum pname
, GLfloat
* params
)
3460 __GLXcontext
* const gc
= __glXGetCurrentContext();
3461 Display
* const dpy
= gc
->currentDpy
;
3462 const GLuint cmdlen
= 8;
3463 if (__builtin_expect(dpy
!= NULL
, 1)) {
3464 GLubyte
const * pc
= setup_single_request(gc
, X_GLsop_GetTexEnvfv
, cmdlen
);
3465 (void) memcpy((void *)(pc
+ 0), (void *)(&target
), 4);
3466 (void) memcpy((void *)(pc
+ 4), (void *)(&pname
), 4);
3467 (void) read_reply(dpy
, 4, params
, GL_FALSE
);
3468 UnlockDisplay(dpy
); SyncHandle();
3473 #define X_GLsop_GetTexEnviv 131
3475 __indirect_glGetTexEnviv(GLenum target
, GLenum pname
, GLint
* params
)
3477 __GLXcontext
* const gc
= __glXGetCurrentContext();
3478 Display
* const dpy
= gc
->currentDpy
;
3479 const GLuint cmdlen
= 8;
3480 if (__builtin_expect(dpy
!= NULL
, 1)) {
3481 GLubyte
const * pc
= setup_single_request(gc
, X_GLsop_GetTexEnviv
, cmdlen
);
3482 (void) memcpy((void *)(pc
+ 0), (void *)(&target
), 4);
3483 (void) memcpy((void *)(pc
+ 4), (void *)(&pname
), 4);
3484 (void) read_reply(dpy
, 4, params
, GL_FALSE
);
3485 UnlockDisplay(dpy
); SyncHandle();
3490 #define X_GLsop_GetTexGendv 132
3492 __indirect_glGetTexGendv(GLenum coord
, GLenum pname
, GLdouble
* params
)
3494 __GLXcontext
* const gc
= __glXGetCurrentContext();
3495 Display
* const dpy
= gc
->currentDpy
;
3496 const GLuint cmdlen
= 8;
3497 if (__builtin_expect(dpy
!= NULL
, 1)) {
3498 GLubyte
const * pc
= setup_single_request(gc
, X_GLsop_GetTexGendv
, cmdlen
);
3499 (void) memcpy((void *)(pc
+ 0), (void *)(&coord
), 4);
3500 (void) memcpy((void *)(pc
+ 4), (void *)(&pname
), 4);
3501 (void) read_reply(dpy
, 8, params
, GL_FALSE
);
3502 UnlockDisplay(dpy
); SyncHandle();
3507 #define X_GLsop_GetTexGenfv 133
3509 __indirect_glGetTexGenfv(GLenum coord
, GLenum pname
, GLfloat
* params
)
3511 __GLXcontext
* const gc
= __glXGetCurrentContext();
3512 Display
* const dpy
= gc
->currentDpy
;
3513 const GLuint cmdlen
= 8;
3514 if (__builtin_expect(dpy
!= NULL
, 1)) {
3515 GLubyte
const * pc
= setup_single_request(gc
, X_GLsop_GetTexGenfv
, cmdlen
);
3516 (void) memcpy((void *)(pc
+ 0), (void *)(&coord
), 4);
3517 (void) memcpy((void *)(pc
+ 4), (void *)(&pname
), 4);
3518 (void) read_reply(dpy
, 4, params
, GL_FALSE
);
3519 UnlockDisplay(dpy
); SyncHandle();
3524 #define X_GLsop_GetTexGeniv 134
3526 __indirect_glGetTexGeniv(GLenum coord
, GLenum pname
, GLint
* params
)
3528 __GLXcontext
* const gc
= __glXGetCurrentContext();
3529 Display
* const dpy
= gc
->currentDpy
;
3530 const GLuint cmdlen
= 8;
3531 if (__builtin_expect(dpy
!= NULL
, 1)) {
3532 GLubyte
const * pc
= setup_single_request(gc
, X_GLsop_GetTexGeniv
, cmdlen
);
3533 (void) memcpy((void *)(pc
+ 0), (void *)(&coord
), 4);
3534 (void) memcpy((void *)(pc
+ 4), (void *)(&pname
), 4);
3535 (void) read_reply(dpy
, 4, params
, GL_FALSE
);
3536 UnlockDisplay(dpy
); SyncHandle();
3541 #define X_GLsop_GetTexParameterfv 136
3543 __indirect_glGetTexParameterfv(GLenum target
, GLenum pname
, GLfloat
* params
)
3545 __GLXcontext
* const gc
= __glXGetCurrentContext();
3546 Display
* const dpy
= gc
->currentDpy
;
3547 const GLuint cmdlen
= 8;
3548 if (__builtin_expect(dpy
!= NULL
, 1)) {
3549 GLubyte
const * pc
= setup_single_request(gc
, X_GLsop_GetTexParameterfv
, cmdlen
);
3550 (void) memcpy((void *)(pc
+ 0), (void *)(&target
), 4);
3551 (void) memcpy((void *)(pc
+ 4), (void *)(&pname
), 4);
3552 (void) read_reply(dpy
, 4, params
, GL_FALSE
);
3553 UnlockDisplay(dpy
); SyncHandle();
3558 #define X_GLsop_GetTexParameteriv 137
3560 __indirect_glGetTexParameteriv(GLenum target
, GLenum pname
, GLint
* params
)
3562 __GLXcontext
* const gc
= __glXGetCurrentContext();
3563 Display
* const dpy
= gc
->currentDpy
;
3564 const GLuint cmdlen
= 8;
3565 if (__builtin_expect(dpy
!= NULL
, 1)) {
3566 GLubyte
const * pc
= setup_single_request(gc
, X_GLsop_GetTexParameteriv
, cmdlen
);
3567 (void) memcpy((void *)(pc
+ 0), (void *)(&target
), 4);
3568 (void) memcpy((void *)(pc
+ 4), (void *)(&pname
), 4);
3569 (void) read_reply(dpy
, 4, params
, GL_FALSE
);
3570 UnlockDisplay(dpy
); SyncHandle();
3575 #define X_GLsop_GetTexLevelParameterfv 138
3577 __indirect_glGetTexLevelParameterfv(GLenum target
, GLint level
, GLenum pname
, GLfloat
* params
)
3579 __GLXcontext
* const gc
= __glXGetCurrentContext();
3580 Display
* const dpy
= gc
->currentDpy
;
3581 const GLuint cmdlen
= 12;
3582 if (__builtin_expect(dpy
!= NULL
, 1)) {
3583 GLubyte
const * pc
= setup_single_request(gc
, X_GLsop_GetTexLevelParameterfv
, cmdlen
);
3584 (void) memcpy((void *)(pc
+ 0), (void *)(&target
), 4);
3585 (void) memcpy((void *)(pc
+ 4), (void *)(&level
), 4);
3586 (void) memcpy((void *)(pc
+ 8), (void *)(&pname
), 4);
3587 (void) read_reply(dpy
, 4, params
, GL_FALSE
);
3588 UnlockDisplay(dpy
); SyncHandle();
3593 #define X_GLsop_GetTexLevelParameteriv 139
3595 __indirect_glGetTexLevelParameteriv(GLenum target
, GLint level
, GLenum pname
, GLint
* params
)
3597 __GLXcontext
* const gc
= __glXGetCurrentContext();
3598 Display
* const dpy
= gc
->currentDpy
;
3599 const GLuint cmdlen
= 12;
3600 if (__builtin_expect(dpy
!= NULL
, 1)) {
3601 GLubyte
const * pc
= setup_single_request(gc
, X_GLsop_GetTexLevelParameteriv
, cmdlen
);
3602 (void) memcpy((void *)(pc
+ 0), (void *)(&target
), 4);
3603 (void) memcpy((void *)(pc
+ 4), (void *)(&level
), 4);
3604 (void) memcpy((void *)(pc
+ 8), (void *)(&pname
), 4);
3605 (void) read_reply(dpy
, 4, params
, GL_FALSE
);
3606 UnlockDisplay(dpy
); SyncHandle();
3611 #define X_GLsop_IsList 141
3613 __indirect_glIsList(GLuint list
)
3615 __GLXcontext
* const gc
= __glXGetCurrentContext();
3616 Display
* const dpy
= gc
->currentDpy
;
3617 GLboolean retval
= (GLboolean
) 0;
3618 const GLuint cmdlen
= 4;
3619 if (__builtin_expect(dpy
!= NULL
, 1)) {
3620 GLubyte
const * pc
= setup_single_request(gc
, X_GLsop_IsList
, cmdlen
);
3621 (void) memcpy((void *)(pc
+ 0), (void *)(&list
), 4);
3622 retval
= (GLboolean
) read_reply(dpy
, 0, NULL
, GL_FALSE
);
3623 UnlockDisplay(dpy
); SyncHandle();
3628 #define X_GLrop_DepthRange 174
3630 __indirect_glDepthRange(GLclampd zNear
, GLclampd zFar
)
3632 __GLXcontext
* const gc
= __glXGetCurrentContext();
3633 const GLuint cmdlen
= 20;
3634 emit_header(gc
->pc
, X_GLrop_DepthRange
, cmdlen
);
3635 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&zNear
), 8);
3636 (void) memcpy((void *)(gc
->pc
+ 12), (void *)(&zFar
), 8);
3638 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
3641 #define X_GLrop_Frustum 175
3643 __indirect_glFrustum(GLdouble left
, GLdouble right
, GLdouble bottom
, GLdouble top
, GLdouble zNear
, GLdouble zFar
)
3645 __GLXcontext
* const gc
= __glXGetCurrentContext();
3646 const GLuint cmdlen
= 52;
3647 emit_header(gc
->pc
, X_GLrop_Frustum
, cmdlen
);
3648 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&left
), 8);
3649 (void) memcpy((void *)(gc
->pc
+ 12), (void *)(&right
), 8);
3650 (void) memcpy((void *)(gc
->pc
+ 20), (void *)(&bottom
), 8);
3651 (void) memcpy((void *)(gc
->pc
+ 28), (void *)(&top
), 8);
3652 (void) memcpy((void *)(gc
->pc
+ 36), (void *)(&zNear
), 8);
3653 (void) memcpy((void *)(gc
->pc
+ 44), (void *)(&zFar
), 8);
3655 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
3658 #define X_GLrop_LoadIdentity 176
3660 __indirect_glLoadIdentity(void)
3662 __GLXcontext
* const gc
= __glXGetCurrentContext();
3663 const GLuint cmdlen
= 4;
3664 emit_header(gc
->pc
, X_GLrop_LoadIdentity
, cmdlen
);
3666 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
3669 #define X_GLrop_LoadMatrixf 177
3671 __indirect_glLoadMatrixf(const GLfloat
* m
)
3673 __GLXcontext
* const gc
= __glXGetCurrentContext();
3674 const GLuint cmdlen
= 68;
3675 emit_header(gc
->pc
, X_GLrop_LoadMatrixf
, cmdlen
);
3676 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(m
), 64);
3678 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
3681 #define X_GLrop_LoadMatrixd 178
3683 __indirect_glLoadMatrixd(const GLdouble
* m
)
3685 __GLXcontext
* const gc
= __glXGetCurrentContext();
3686 const GLuint cmdlen
= 132;
3687 emit_header(gc
->pc
, X_GLrop_LoadMatrixd
, cmdlen
);
3688 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(m
), 128);
3690 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
3693 #define X_GLrop_MatrixMode 179
3695 __indirect_glMatrixMode(GLenum mode
)
3697 __GLXcontext
* const gc
= __glXGetCurrentContext();
3698 const GLuint cmdlen
= 8;
3699 emit_header(gc
->pc
, X_GLrop_MatrixMode
, cmdlen
);
3700 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&mode
), 4);
3702 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
3705 #define X_GLrop_MultMatrixf 180
3707 __indirect_glMultMatrixf(const GLfloat
* m
)
3709 __GLXcontext
* const gc
= __glXGetCurrentContext();
3710 const GLuint cmdlen
= 68;
3711 emit_header(gc
->pc
, X_GLrop_MultMatrixf
, cmdlen
);
3712 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(m
), 64);
3714 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
3717 #define X_GLrop_MultMatrixd 181
3719 __indirect_glMultMatrixd(const GLdouble
* m
)
3721 __GLXcontext
* const gc
= __glXGetCurrentContext();
3722 const GLuint cmdlen
= 132;
3723 emit_header(gc
->pc
, X_GLrop_MultMatrixd
, cmdlen
);
3724 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(m
), 128);
3726 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
3729 #define X_GLrop_Ortho 182
3731 __indirect_glOrtho(GLdouble left
, GLdouble right
, GLdouble bottom
, GLdouble top
, GLdouble zNear
, GLdouble zFar
)
3733 __GLXcontext
* const gc
= __glXGetCurrentContext();
3734 const GLuint cmdlen
= 52;
3735 emit_header(gc
->pc
, X_GLrop_Ortho
, cmdlen
);
3736 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&left
), 8);
3737 (void) memcpy((void *)(gc
->pc
+ 12), (void *)(&right
), 8);
3738 (void) memcpy((void *)(gc
->pc
+ 20), (void *)(&bottom
), 8);
3739 (void) memcpy((void *)(gc
->pc
+ 28), (void *)(&top
), 8);
3740 (void) memcpy((void *)(gc
->pc
+ 36), (void *)(&zNear
), 8);
3741 (void) memcpy((void *)(gc
->pc
+ 44), (void *)(&zFar
), 8);
3743 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
3746 #define X_GLrop_PopMatrix 183
3748 __indirect_glPopMatrix(void)
3750 __GLXcontext
* const gc
= __glXGetCurrentContext();
3751 const GLuint cmdlen
= 4;
3752 emit_header(gc
->pc
, X_GLrop_PopMatrix
, cmdlen
);
3754 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
3757 #define X_GLrop_PushMatrix 184
3759 __indirect_glPushMatrix(void)
3761 __GLXcontext
* const gc
= __glXGetCurrentContext();
3762 const GLuint cmdlen
= 4;
3763 emit_header(gc
->pc
, X_GLrop_PushMatrix
, cmdlen
);
3765 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
3768 #define X_GLrop_Rotated 185
3770 __indirect_glRotated(GLdouble angle
, GLdouble x
, GLdouble y
, GLdouble z
)
3772 __GLXcontext
* const gc
= __glXGetCurrentContext();
3773 const GLuint cmdlen
= 36;
3774 emit_header(gc
->pc
, X_GLrop_Rotated
, cmdlen
);
3775 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&angle
), 8);
3776 (void) memcpy((void *)(gc
->pc
+ 12), (void *)(&x
), 8);
3777 (void) memcpy((void *)(gc
->pc
+ 20), (void *)(&y
), 8);
3778 (void) memcpy((void *)(gc
->pc
+ 28), (void *)(&z
), 8);
3780 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
3783 #define X_GLrop_Rotatef 186
3785 __indirect_glRotatef(GLfloat angle
, GLfloat x
, GLfloat y
, GLfloat z
)
3787 __GLXcontext
* const gc
= __glXGetCurrentContext();
3788 const GLuint cmdlen
= 20;
3789 emit_header(gc
->pc
, X_GLrop_Rotatef
, cmdlen
);
3790 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&angle
), 4);
3791 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(&x
), 4);
3792 (void) memcpy((void *)(gc
->pc
+ 12), (void *)(&y
), 4);
3793 (void) memcpy((void *)(gc
->pc
+ 16), (void *)(&z
), 4);
3795 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
3798 #define X_GLrop_Scaled 187
3800 __indirect_glScaled(GLdouble x
, GLdouble y
, GLdouble z
)
3802 __GLXcontext
* const gc
= __glXGetCurrentContext();
3803 const GLuint cmdlen
= 28;
3804 emit_header(gc
->pc
, X_GLrop_Scaled
, cmdlen
);
3805 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&x
), 8);
3806 (void) memcpy((void *)(gc
->pc
+ 12), (void *)(&y
), 8);
3807 (void) memcpy((void *)(gc
->pc
+ 20), (void *)(&z
), 8);
3809 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
3812 #define X_GLrop_Scalef 188
3814 __indirect_glScalef(GLfloat x
, GLfloat y
, GLfloat z
)
3816 __GLXcontext
* const gc
= __glXGetCurrentContext();
3817 const GLuint cmdlen
= 16;
3818 emit_header(gc
->pc
, X_GLrop_Scalef
, cmdlen
);
3819 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&x
), 4);
3820 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(&y
), 4);
3821 (void) memcpy((void *)(gc
->pc
+ 12), (void *)(&z
), 4);
3823 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
3826 #define X_GLrop_Translated 189
3828 __indirect_glTranslated(GLdouble x
, GLdouble y
, GLdouble z
)
3830 __GLXcontext
* const gc
= __glXGetCurrentContext();
3831 const GLuint cmdlen
= 28;
3832 emit_header(gc
->pc
, X_GLrop_Translated
, cmdlen
);
3833 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&x
), 8);
3834 (void) memcpy((void *)(gc
->pc
+ 12), (void *)(&y
), 8);
3835 (void) memcpy((void *)(gc
->pc
+ 20), (void *)(&z
), 8);
3837 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
3840 #define X_GLrop_Translatef 190
3842 __indirect_glTranslatef(GLfloat x
, GLfloat y
, GLfloat z
)
3844 __GLXcontext
* const gc
= __glXGetCurrentContext();
3845 const GLuint cmdlen
= 16;
3846 emit_header(gc
->pc
, X_GLrop_Translatef
, cmdlen
);
3847 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&x
), 4);
3848 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(&y
), 4);
3849 (void) memcpy((void *)(gc
->pc
+ 12), (void *)(&z
), 4);
3851 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
3854 #define X_GLrop_Viewport 191
3856 __indirect_glViewport(GLint x
, GLint y
, GLsizei width
, GLsizei height
)
3858 __GLXcontext
* const gc
= __glXGetCurrentContext();
3859 const GLuint cmdlen
= 20;
3860 emit_header(gc
->pc
, X_GLrop_Viewport
, cmdlen
);
3861 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&x
), 4);
3862 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(&y
), 4);
3863 (void) memcpy((void *)(gc
->pc
+ 12), (void *)(&width
), 4);
3864 (void) memcpy((void *)(gc
->pc
+ 16), (void *)(&height
), 4);
3866 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
3869 #define X_GLrop_BindTexture 4117
3871 __indirect_glBindTexture(GLenum target
, GLuint texture
)
3873 __GLXcontext
* const gc
= __glXGetCurrentContext();
3874 const GLuint cmdlen
= 12;
3875 emit_header(gc
->pc
, X_GLrop_BindTexture
, cmdlen
);
3876 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&target
), 4);
3877 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(&texture
), 4);
3879 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
3882 #define X_GLrop_Indexubv 194
3884 __indirect_glIndexub(GLubyte c
)
3886 __GLXcontext
* const gc
= __glXGetCurrentContext();
3887 const GLuint cmdlen
= 8;
3888 emit_header(gc
->pc
, X_GLrop_Indexubv
, cmdlen
);
3889 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&c
), 1);
3891 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
3894 #define X_GLrop_Indexubv 194
3896 __indirect_glIndexubv(const GLubyte
* c
)
3898 __GLXcontext
* const gc
= __glXGetCurrentContext();
3899 const GLuint cmdlen
= 8;
3900 emit_header(gc
->pc
, X_GLrop_Indexubv
, cmdlen
);
3901 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(c
), 1);
3903 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
3906 #define X_GLrop_PolygonOffset 192
3908 __indirect_glPolygonOffset(GLfloat factor
, GLfloat units
)
3910 __GLXcontext
* const gc
= __glXGetCurrentContext();
3911 const GLuint cmdlen
= 12;
3912 emit_header(gc
->pc
, X_GLrop_PolygonOffset
, cmdlen
);
3913 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&factor
), 4);
3914 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(&units
), 4);
3916 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
3919 #define X_GLsop_AreTexturesResident 143
3921 __indirect_glAreTexturesResident(GLsizei n
, const GLuint
* textures
, GLboolean
* residences
)
3923 __GLXcontext
* const gc
= __glXGetCurrentContext();
3924 Display
* const dpy
= gc
->currentDpy
;
3925 GLboolean retval
= (GLboolean
) 0;
3926 const GLuint cmdlen
= 4 + __GLX_PAD((n
* 4));
3927 if (__builtin_expect((n
>= 0) && (dpy
!= NULL
), 1)) {
3928 GLubyte
const * pc
= setup_single_request(gc
, X_GLsop_AreTexturesResident
, cmdlen
);
3929 (void) memcpy((void *)(pc
+ 0), (void *)(&n
), 4);
3930 (void) memcpy((void *)(pc
+ 4), (void *)(textures
), (n
* 4));
3931 retval
= (GLboolean
) read_reply(dpy
, 1, residences
, GL_TRUE
);
3932 UnlockDisplay(dpy
); SyncHandle();
3937 #define X_GLrop_CopyTexImage1D 4119
3939 __indirect_glCopyTexImage1D(GLenum target
, GLint level
, GLenum internalformat
, GLint x
, GLint y
, GLsizei width
, GLint border
)
3941 __GLXcontext
* const gc
= __glXGetCurrentContext();
3942 const GLuint cmdlen
= 32;
3943 emit_header(gc
->pc
, X_GLrop_CopyTexImage1D
, cmdlen
);
3944 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&target
), 4);
3945 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(&level
), 4);
3946 (void) memcpy((void *)(gc
->pc
+ 12), (void *)(&internalformat
), 4);
3947 (void) memcpy((void *)(gc
->pc
+ 16), (void *)(&x
), 4);
3948 (void) memcpy((void *)(gc
->pc
+ 20), (void *)(&y
), 4);
3949 (void) memcpy((void *)(gc
->pc
+ 24), (void *)(&width
), 4);
3950 (void) memcpy((void *)(gc
->pc
+ 28), (void *)(&border
), 4);
3952 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
3955 #define X_GLrop_CopyTexImage2D 4120
3957 __indirect_glCopyTexImage2D(GLenum target
, GLint level
, GLenum internalformat
, GLint x
, GLint y
, GLsizei width
, GLsizei height
, GLint border
)
3959 __GLXcontext
* const gc
= __glXGetCurrentContext();
3960 const GLuint cmdlen
= 36;
3961 emit_header(gc
->pc
, X_GLrop_CopyTexImage2D
, cmdlen
);
3962 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&target
), 4);
3963 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(&level
), 4);
3964 (void) memcpy((void *)(gc
->pc
+ 12), (void *)(&internalformat
), 4);
3965 (void) memcpy((void *)(gc
->pc
+ 16), (void *)(&x
), 4);
3966 (void) memcpy((void *)(gc
->pc
+ 20), (void *)(&y
), 4);
3967 (void) memcpy((void *)(gc
->pc
+ 24), (void *)(&width
), 4);
3968 (void) memcpy((void *)(gc
->pc
+ 28), (void *)(&height
), 4);
3969 (void) memcpy((void *)(gc
->pc
+ 32), (void *)(&border
), 4);
3971 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
3974 #define X_GLrop_CopyTexSubImage1D 4121
3976 __indirect_glCopyTexSubImage1D(GLenum target
, GLint level
, GLint xoffset
, GLint x
, GLint y
, GLsizei width
)
3978 __GLXcontext
* const gc
= __glXGetCurrentContext();
3979 const GLuint cmdlen
= 28;
3980 emit_header(gc
->pc
, X_GLrop_CopyTexSubImage1D
, cmdlen
);
3981 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&target
), 4);
3982 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(&level
), 4);
3983 (void) memcpy((void *)(gc
->pc
+ 12), (void *)(&xoffset
), 4);
3984 (void) memcpy((void *)(gc
->pc
+ 16), (void *)(&x
), 4);
3985 (void) memcpy((void *)(gc
->pc
+ 20), (void *)(&y
), 4);
3986 (void) memcpy((void *)(gc
->pc
+ 24), (void *)(&width
), 4);
3988 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
3991 #define X_GLrop_CopyTexSubImage2D 4122
3993 __indirect_glCopyTexSubImage2D(GLenum target
, GLint level
, GLint xoffset
, GLint yoffset
, GLint x
, GLint y
, GLsizei width
, GLsizei height
)
3995 __GLXcontext
* const gc
= __glXGetCurrentContext();
3996 const GLuint cmdlen
= 36;
3997 emit_header(gc
->pc
, X_GLrop_CopyTexSubImage2D
, cmdlen
);
3998 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&target
), 4);
3999 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(&level
), 4);
4000 (void) memcpy((void *)(gc
->pc
+ 12), (void *)(&xoffset
), 4);
4001 (void) memcpy((void *)(gc
->pc
+ 16), (void *)(&yoffset
), 4);
4002 (void) memcpy((void *)(gc
->pc
+ 20), (void *)(&x
), 4);
4003 (void) memcpy((void *)(gc
->pc
+ 24), (void *)(&y
), 4);
4004 (void) memcpy((void *)(gc
->pc
+ 28), (void *)(&width
), 4);
4005 (void) memcpy((void *)(gc
->pc
+ 32), (void *)(&height
), 4);
4007 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
4010 #define X_GLsop_DeleteTextures 144
4012 __indirect_glDeleteTextures(GLsizei n
, const GLuint
* textures
)
4014 __GLXcontext
* const gc
= __glXGetCurrentContext();
4015 Display
* const dpy
= gc
->currentDpy
;
4016 const GLuint cmdlen
= 4 + __GLX_PAD((n
* 4));
4017 if (__builtin_expect((n
>= 0) && (dpy
!= NULL
), 1)) {
4018 GLubyte
const * pc
= setup_single_request(gc
, X_GLsop_DeleteTextures
, cmdlen
);
4019 (void) memcpy((void *)(pc
+ 0), (void *)(&n
), 4);
4020 (void) memcpy((void *)(pc
+ 4), (void *)(textures
), (n
* 4));
4021 UnlockDisplay(dpy
); SyncHandle();
4026 #define X_GLsop_GenTextures 145
4028 __indirect_glGenTextures(GLsizei n
, GLuint
* textures
)
4030 __GLXcontext
* const gc
= __glXGetCurrentContext();
4031 Display
* const dpy
= gc
->currentDpy
;
4032 const GLuint cmdlen
= 4;
4033 if (__builtin_expect(dpy
!= NULL
, 1)) {
4034 GLubyte
const * pc
= setup_single_request(gc
, X_GLsop_GenTextures
, cmdlen
);
4035 (void) memcpy((void *)(pc
+ 0), (void *)(&n
), 4);
4036 (void) read_reply(dpy
, 4, textures
, GL_TRUE
);
4037 UnlockDisplay(dpy
); SyncHandle();
4042 #define X_GLsop_IsTexture 146
4044 __indirect_glIsTexture(GLuint texture
)
4046 __GLXcontext
* const gc
= __glXGetCurrentContext();
4047 Display
* const dpy
= gc
->currentDpy
;
4048 GLboolean retval
= (GLboolean
) 0;
4049 const GLuint cmdlen
= 4;
4050 if (__builtin_expect(dpy
!= NULL
, 1)) {
4051 GLubyte
const * pc
= setup_single_request(gc
, X_GLsop_IsTexture
, cmdlen
);
4052 (void) memcpy((void *)(pc
+ 0), (void *)(&texture
), 4);
4053 retval
= (GLboolean
) read_reply(dpy
, 0, NULL
, GL_FALSE
);
4054 UnlockDisplay(dpy
); SyncHandle();
4059 #define X_GLrop_PrioritizeTextures 4118
4061 __indirect_glPrioritizeTextures(GLsizei n
, const GLuint
* textures
, const GLclampf
* priorities
)
4063 __GLXcontext
* const gc
= __glXGetCurrentContext();
4064 const GLuint cmdlen
= 8 + __GLX_PAD((n
* 4)) + __GLX_PAD((n
* 4));
4065 if (__builtin_expect(n
>= 0, 1)) {
4066 emit_header(gc
->pc
, X_GLrop_PrioritizeTextures
, cmdlen
);
4067 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&n
), 4);
4068 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(textures
), (n
* 4));
4069 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(priorities
), (n
* 4));
4071 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
4076 __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
)
4078 __GLXcontext
* const gc
= __glXGetCurrentContext();
4079 const GLuint compsize
= (pixels
!= NULL
) ? __glImageSize(width
, height
, 1, format
, type
, target
) : 0;
4080 const GLuint cmdlen
= 60 + __GLX_PAD(compsize
);
4081 if (__builtin_expect(gc
->currentDpy
!= NULL
, 1)) {
4082 if (cmdlen
<= gc
->maxSmallRenderCommandSize
) {
4083 if ( (gc
->pc
+ cmdlen
) > gc
->bufEnd
) {
4084 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
4086 emit_header(gc
->pc
, opcode
, cmdlen
);
4087 (void) memcpy((void *)(gc
->pc
+ 24), (void *)(&target
), 4);
4088 (void) memcpy((void *)(gc
->pc
+ 28), (void *)(&level
), 4);
4089 (void) memcpy((void *)(gc
->pc
+ 32), (void *)(&xoffset
), 4);
4090 (void) memcpy((void *)(gc
->pc
+ 36), (void *)(&yoffset
), 4);
4091 (void) memcpy((void *)(gc
->pc
+ 40), (void *)(&width
), 4);
4092 (void) memcpy((void *)(gc
->pc
+ 44), (void *)(&height
), 4);
4093 (void) memcpy((void *)(gc
->pc
+ 48), (void *)(&format
), 4);
4094 (void) memcpy((void *)(gc
->pc
+ 52), (void *)(&type
), 4);
4095 (void) memcpy((void *)(gc
->pc
+ 56), (void *)((pixels
== NULL
) ? one
: zero
), 4);
4097 (*gc
->fillImage
)(gc
, dim
, width
, height
, 1, format
, type
, pixels
, gc
->pc
+ 60, gc
->pc
+ 4);
4100 (void) memcpy( gc
->pc
+ 4, default_pixel_store_2D
, default_pixel_store_2D_size
);
4103 if (gc
->pc
> gc
->limit
) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
4106 const GLint op
= opcode
;
4107 const GLuint cmdlenLarge
= cmdlen
+ 4;
4108 GLubyte
* const pc
= __glXFlushRenderBuffer(gc
, gc
->pc
);
4109 (void) memcpy((void *)(pc
+ 0), (void *)(&cmdlenLarge
), 4);
4110 (void) memcpy((void *)(pc
+ 4), (void *)(&op
), 4);
4111 (void) memcpy((void *)(pc
+ 28), (void *)(&target
), 4);
4112 (void) memcpy((void *)(pc
+ 32), (void *)(&level
), 4);
4113 (void) memcpy((void *)(pc
+ 36), (void *)(&xoffset
), 4);
4114 (void) memcpy((void *)(pc
+ 40), (void *)(&yoffset
), 4);
4115 (void) memcpy((void *)(pc
+ 44), (void *)(&width
), 4);
4116 (void) memcpy((void *)(pc
+ 48), (void *)(&height
), 4);
4117 (void) memcpy((void *)(pc
+ 52), (void *)(&format
), 4);
4118 (void) memcpy((void *)(pc
+ 56), (void *)(&type
), 4);
4119 (void) memcpy((void *)(pc
+ 60), zero
, 4);
4120 __glXSendLargeImage(gc
, compsize
, dim
, width
, height
, 1, format
, type
, pixels
, pc
+ 64, pc
+ 8);
4125 #define X_GLrop_TexSubImage1D 4099
4127 __indirect_glTexSubImage1D(GLenum target
, GLint level
, GLint xoffset
, GLsizei width
, GLenum format
, GLenum type
, const GLvoid
* pixels
)
4129 __glx_TexSubImage_1D2D(X_GLrop_TexSubImage1D
, 1, target
, level
, xoffset
, 1, width
, 1, format
, type
, pixels
);
4132 #define X_GLrop_TexSubImage2D 4100
4134 __indirect_glTexSubImage2D(GLenum target
, GLint level
, GLint xoffset
, GLint yoffset
, GLsizei width
, GLsizei height
, GLenum format
, GLenum type
, const GLvoid
* pixels
)
4136 __glx_TexSubImage_1D2D(X_GLrop_TexSubImage2D
, 2, target
, level
, xoffset
, yoffset
, width
, height
, format
, type
, pixels
);
4139 #define X_GLrop_BlendColor 4096
4141 __indirect_glBlendColor(GLclampf red
, GLclampf green
, GLclampf blue
, GLclampf alpha
)
4143 __GLXcontext
* const gc
= __glXGetCurrentContext();
4144 const GLuint cmdlen
= 20;
4145 emit_header(gc
->pc
, X_GLrop_BlendColor
, cmdlen
);
4146 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&red
), 4);
4147 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(&green
), 4);
4148 (void) memcpy((void *)(gc
->pc
+ 12), (void *)(&blue
), 4);
4149 (void) memcpy((void *)(gc
->pc
+ 16), (void *)(&alpha
), 4);
4151 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
4154 #define X_GLrop_BlendEquation 4097
4156 __indirect_glBlendEquation(GLenum mode
)
4158 __GLXcontext
* const gc
= __glXGetCurrentContext();
4159 const GLuint cmdlen
= 8;
4160 emit_header(gc
->pc
, X_GLrop_BlendEquation
, cmdlen
);
4161 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&mode
), 4);
4163 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
4166 #define X_GLrop_ColorTable 2053
4168 __indirect_glColorTable(GLenum target
, GLenum internalformat
, GLsizei width
, GLenum format
, GLenum type
, const GLvoid
* table
)
4170 __GLXcontext
* const gc
= __glXGetCurrentContext();
4171 const GLuint compsize
= (table
!= NULL
) ? __glImageSize(width
, 1, 1, format
, type
, target
) : 0;
4172 const GLuint cmdlen
= 44 + __GLX_PAD(compsize
);
4173 if (__builtin_expect(gc
->currentDpy
!= NULL
, 1)) {
4174 if (cmdlen
<= gc
->maxSmallRenderCommandSize
) {
4175 if ( (gc
->pc
+ cmdlen
) > gc
->bufEnd
) {
4176 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
4178 emit_header(gc
->pc
, X_GLrop_ColorTable
, cmdlen
);
4179 (void) memcpy((void *)(gc
->pc
+ 24), (void *)(&target
), 4);
4180 (void) memcpy((void *)(gc
->pc
+ 28), (void *)(&internalformat
), 4);
4181 (void) memcpy((void *)(gc
->pc
+ 32), (void *)(&width
), 4);
4182 (void) memcpy((void *)(gc
->pc
+ 36), (void *)(&format
), 4);
4183 (void) memcpy((void *)(gc
->pc
+ 40), (void *)(&type
), 4);
4185 (*gc
->fillImage
)(gc
, 1, width
, 1, 1, format
, type
, table
, gc
->pc
+ 44, gc
->pc
+ 4);
4188 (void) memcpy( gc
->pc
+ 4, default_pixel_store_1D
, default_pixel_store_1D_size
);
4191 if (gc
->pc
> gc
->limit
) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
4194 const GLint op
= X_GLrop_ColorTable
;
4195 const GLuint cmdlenLarge
= cmdlen
+ 4;
4196 GLubyte
* const pc
= __glXFlushRenderBuffer(gc
, gc
->pc
);
4197 (void) memcpy((void *)(pc
+ 0), (void *)(&cmdlenLarge
), 4);
4198 (void) memcpy((void *)(pc
+ 4), (void *)(&op
), 4);
4199 (void) memcpy((void *)(pc
+ 28), (void *)(&target
), 4);
4200 (void) memcpy((void *)(pc
+ 32), (void *)(&internalformat
), 4);
4201 (void) memcpy((void *)(pc
+ 36), (void *)(&width
), 4);
4202 (void) memcpy((void *)(pc
+ 40), (void *)(&format
), 4);
4203 (void) memcpy((void *)(pc
+ 44), (void *)(&type
), 4);
4204 __glXSendLargeImage(gc
, compsize
, 1, width
, 1, 1, format
, type
, table
, pc
+ 48, pc
+ 8);
4209 #define X_GLrop_ColorTableParameterfv 2054
4211 __indirect_glColorTableParameterfv(GLenum target
, GLenum pname
, const GLfloat
* params
)
4213 __GLXcontext
* const gc
= __glXGetCurrentContext();
4214 const GLuint compsize
= __glColorTableParameterfv_size(pname
);
4215 const GLuint cmdlen
= 12 + __GLX_PAD((compsize
* 4));
4216 emit_header(gc
->pc
, X_GLrop_ColorTableParameterfv
, cmdlen
);
4217 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&target
), 4);
4218 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(&pname
), 4);
4219 (void) memcpy((void *)(gc
->pc
+ 12), (void *)(params
), (compsize
* 4));
4221 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
4224 #define X_GLrop_ColorTableParameteriv 2055
4226 __indirect_glColorTableParameteriv(GLenum target
, GLenum pname
, const GLint
* params
)
4228 __GLXcontext
* const gc
= __glXGetCurrentContext();
4229 const GLuint compsize
= __glColorTableParameteriv_size(pname
);
4230 const GLuint cmdlen
= 12 + __GLX_PAD((compsize
* 4));
4231 emit_header(gc
->pc
, X_GLrop_ColorTableParameteriv
, cmdlen
);
4232 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&target
), 4);
4233 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(&pname
), 4);
4234 (void) memcpy((void *)(gc
->pc
+ 12), (void *)(params
), (compsize
* 4));
4236 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
4239 #define X_GLrop_CopyColorTable 2056
4241 __indirect_glCopyColorTable(GLenum target
, GLenum internalformat
, GLint x
, GLint y
, GLsizei width
)
4243 __GLXcontext
* const gc
= __glXGetCurrentContext();
4244 const GLuint cmdlen
= 24;
4245 emit_header(gc
->pc
, X_GLrop_CopyColorTable
, cmdlen
);
4246 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&target
), 4);
4247 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(&internalformat
), 4);
4248 (void) memcpy((void *)(gc
->pc
+ 12), (void *)(&x
), 4);
4249 (void) memcpy((void *)(gc
->pc
+ 16), (void *)(&y
), 4);
4250 (void) memcpy((void *)(gc
->pc
+ 20), (void *)(&width
), 4);
4252 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
4255 #define X_GLsop_GetColorTableParameterfv 148
4257 __indirect_glGetColorTableParameterfv(GLenum target
, GLenum pname
, GLfloat
* params
)
4259 __GLXcontext
* const gc
= __glXGetCurrentContext();
4260 Display
* const dpy
= gc
->currentDpy
;
4261 const GLuint cmdlen
= 8;
4262 if (__builtin_expect(dpy
!= NULL
, 1)) {
4263 GLubyte
const * pc
= setup_single_request(gc
, X_GLsop_GetColorTableParameterfv
, cmdlen
);
4264 (void) memcpy((void *)(pc
+ 0), (void *)(&target
), 4);
4265 (void) memcpy((void *)(pc
+ 4), (void *)(&pname
), 4);
4266 (void) read_reply(dpy
, 4, params
, GL_FALSE
);
4267 UnlockDisplay(dpy
); SyncHandle();
4272 #define X_GLsop_GetColorTableParameteriv 149
4274 __indirect_glGetColorTableParameteriv(GLenum target
, GLenum pname
, GLint
* params
)
4276 __GLXcontext
* const gc
= __glXGetCurrentContext();
4277 Display
* const dpy
= gc
->currentDpy
;
4278 const GLuint cmdlen
= 8;
4279 if (__builtin_expect(dpy
!= NULL
, 1)) {
4280 GLubyte
const * pc
= setup_single_request(gc
, X_GLsop_GetColorTableParameteriv
, cmdlen
);
4281 (void) memcpy((void *)(pc
+ 0), (void *)(&target
), 4);
4282 (void) memcpy((void *)(pc
+ 4), (void *)(&pname
), 4);
4283 (void) read_reply(dpy
, 4, params
, GL_FALSE
);
4284 UnlockDisplay(dpy
); SyncHandle();
4289 #define X_GLrop_ColorSubTable 195
4291 __indirect_glColorSubTable(GLenum target
, GLsizei start
, GLsizei count
, GLenum format
, GLenum type
, const GLvoid
* data
)
4293 __GLXcontext
* const gc
= __glXGetCurrentContext();
4294 const GLuint compsize
= (data
!= NULL
) ? __glImageSize(count
, 1, 1, format
, type
, target
) : 0;
4295 const GLuint cmdlen
= 44 + __GLX_PAD(compsize
);
4296 if (__builtin_expect(gc
->currentDpy
!= NULL
, 1)) {
4297 if (cmdlen
<= gc
->maxSmallRenderCommandSize
) {
4298 if ( (gc
->pc
+ cmdlen
) > gc
->bufEnd
) {
4299 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
4301 emit_header(gc
->pc
, X_GLrop_ColorSubTable
, cmdlen
);
4302 (void) memcpy((void *)(gc
->pc
+ 24), (void *)(&target
), 4);
4303 (void) memcpy((void *)(gc
->pc
+ 28), (void *)(&start
), 4);
4304 (void) memcpy((void *)(gc
->pc
+ 32), (void *)(&count
), 4);
4305 (void) memcpy((void *)(gc
->pc
+ 36), (void *)(&format
), 4);
4306 (void) memcpy((void *)(gc
->pc
+ 40), (void *)(&type
), 4);
4308 (*gc
->fillImage
)(gc
, 1, count
, 1, 1, format
, type
, data
, gc
->pc
+ 44, gc
->pc
+ 4);
4311 (void) memcpy( gc
->pc
+ 4, default_pixel_store_1D
, default_pixel_store_1D_size
);
4314 if (gc
->pc
> gc
->limit
) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
4317 const GLint op
= X_GLrop_ColorSubTable
;
4318 const GLuint cmdlenLarge
= cmdlen
+ 4;
4319 GLubyte
* const pc
= __glXFlushRenderBuffer(gc
, gc
->pc
);
4320 (void) memcpy((void *)(pc
+ 0), (void *)(&cmdlenLarge
), 4);
4321 (void) memcpy((void *)(pc
+ 4), (void *)(&op
), 4);
4322 (void) memcpy((void *)(pc
+ 28), (void *)(&target
), 4);
4323 (void) memcpy((void *)(pc
+ 32), (void *)(&start
), 4);
4324 (void) memcpy((void *)(pc
+ 36), (void *)(&count
), 4);
4325 (void) memcpy((void *)(pc
+ 40), (void *)(&format
), 4);
4326 (void) memcpy((void *)(pc
+ 44), (void *)(&type
), 4);
4327 __glXSendLargeImage(gc
, compsize
, 1, count
, 1, 1, format
, type
, data
, pc
+ 48, pc
+ 8);
4332 #define X_GLrop_CopyColorSubTable 196
4334 __indirect_glCopyColorSubTable(GLenum target
, GLsizei start
, GLint x
, GLint y
, GLsizei width
)
4336 __GLXcontext
* const gc
= __glXGetCurrentContext();
4337 const GLuint cmdlen
= 24;
4338 emit_header(gc
->pc
, X_GLrop_CopyColorSubTable
, cmdlen
);
4339 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&target
), 4);
4340 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(&start
), 4);
4341 (void) memcpy((void *)(gc
->pc
+ 12), (void *)(&x
), 4);
4342 (void) memcpy((void *)(gc
->pc
+ 16), (void *)(&y
), 4);
4343 (void) memcpy((void *)(gc
->pc
+ 20), (void *)(&width
), 4);
4345 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
4349 __glx_ConvolutionFilter_1D2D( unsigned opcode
, unsigned dim
, GLenum target
, GLenum internalformat
, GLsizei width
, GLsizei height
, GLenum format
, GLenum type
, const GLvoid
* image
)
4351 __GLXcontext
* const gc
= __glXGetCurrentContext();
4352 const GLuint compsize
= (image
!= NULL
) ? __glImageSize(width
, height
, 1, format
, type
, target
) : 0;
4353 const GLuint cmdlen
= 48 + __GLX_PAD(compsize
);
4354 if (__builtin_expect(gc
->currentDpy
!= NULL
, 1)) {
4355 if (cmdlen
<= gc
->maxSmallRenderCommandSize
) {
4356 if ( (gc
->pc
+ cmdlen
) > gc
->bufEnd
) {
4357 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
4359 emit_header(gc
->pc
, opcode
, cmdlen
);
4360 (void) memcpy((void *)(gc
->pc
+ 24), (void *)(&target
), 4);
4361 (void) memcpy((void *)(gc
->pc
+ 28), (void *)(&internalformat
), 4);
4362 (void) memcpy((void *)(gc
->pc
+ 32), (void *)(&width
), 4);
4363 (void) memcpy((void *)(gc
->pc
+ 36), (void *)(&height
), 4);
4364 (void) memcpy((void *)(gc
->pc
+ 40), (void *)(&format
), 4);
4365 (void) memcpy((void *)(gc
->pc
+ 44), (void *)(&type
), 4);
4367 (*gc
->fillImage
)(gc
, dim
, width
, height
, 1, format
, type
, image
, gc
->pc
+ 48, gc
->pc
+ 4);
4370 (void) memcpy( gc
->pc
+ 4, default_pixel_store_2D
, default_pixel_store_2D_size
);
4373 if (gc
->pc
> gc
->limit
) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
4376 const GLint op
= opcode
;
4377 const GLuint cmdlenLarge
= cmdlen
+ 4;
4378 GLubyte
* const pc
= __glXFlushRenderBuffer(gc
, gc
->pc
);
4379 (void) memcpy((void *)(pc
+ 0), (void *)(&cmdlenLarge
), 4);
4380 (void) memcpy((void *)(pc
+ 4), (void *)(&op
), 4);
4381 (void) memcpy((void *)(pc
+ 28), (void *)(&target
), 4);
4382 (void) memcpy((void *)(pc
+ 32), (void *)(&internalformat
), 4);
4383 (void) memcpy((void *)(pc
+ 36), (void *)(&width
), 4);
4384 (void) memcpy((void *)(pc
+ 40), (void *)(&height
), 4);
4385 (void) memcpy((void *)(pc
+ 44), (void *)(&format
), 4);
4386 (void) memcpy((void *)(pc
+ 48), (void *)(&type
), 4);
4387 __glXSendLargeImage(gc
, compsize
, dim
, width
, height
, 1, format
, type
, image
, pc
+ 52, pc
+ 8);
4392 #define X_GLrop_ConvolutionFilter1D 4101
4394 __indirect_glConvolutionFilter1D(GLenum target
, GLenum internalformat
, GLsizei width
, GLenum format
, GLenum type
, const GLvoid
* image
)
4396 __glx_ConvolutionFilter_1D2D(X_GLrop_ConvolutionFilter1D
, 1, target
, internalformat
, width
, 1, format
, type
, image
);
4399 #define X_GLrop_ConvolutionFilter2D 4102
4401 __indirect_glConvolutionFilter2D(GLenum target
, GLenum internalformat
, GLsizei width
, GLsizei height
, GLenum format
, GLenum type
, const GLvoid
* image
)
4403 __glx_ConvolutionFilter_1D2D(X_GLrop_ConvolutionFilter2D
, 2, target
, internalformat
, width
, height
, format
, type
, image
);
4406 #define X_GLrop_ConvolutionParameterf 4103
4408 __indirect_glConvolutionParameterf(GLenum target
, GLenum pname
, GLfloat params
)
4410 __GLXcontext
* const gc
= __glXGetCurrentContext();
4411 const GLuint cmdlen
= 16;
4412 emit_header(gc
->pc
, X_GLrop_ConvolutionParameterf
, cmdlen
);
4413 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&target
), 4);
4414 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(&pname
), 4);
4415 (void) memcpy((void *)(gc
->pc
+ 12), (void *)(¶ms
), 4);
4417 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
4420 #define X_GLrop_ConvolutionParameterfv 4104
4422 __indirect_glConvolutionParameterfv(GLenum target
, GLenum pname
, const GLfloat
* params
)
4424 __GLXcontext
* const gc
= __glXGetCurrentContext();
4425 const GLuint compsize
= __glConvolutionParameterfv_size(pname
);
4426 const GLuint cmdlen
= 12 + __GLX_PAD((compsize
* 4));
4427 emit_header(gc
->pc
, X_GLrop_ConvolutionParameterfv
, cmdlen
);
4428 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&target
), 4);
4429 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(&pname
), 4);
4430 (void) memcpy((void *)(gc
->pc
+ 12), (void *)(params
), (compsize
* 4));
4432 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
4435 #define X_GLrop_ConvolutionParameteri 4105
4437 __indirect_glConvolutionParameteri(GLenum target
, GLenum pname
, GLint params
)
4439 __GLXcontext
* const gc
= __glXGetCurrentContext();
4440 const GLuint cmdlen
= 16;
4441 emit_header(gc
->pc
, X_GLrop_ConvolutionParameteri
, cmdlen
);
4442 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&target
), 4);
4443 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(&pname
), 4);
4444 (void) memcpy((void *)(gc
->pc
+ 12), (void *)(¶ms
), 4);
4446 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
4449 #define X_GLrop_ConvolutionParameteriv 4106
4451 __indirect_glConvolutionParameteriv(GLenum target
, GLenum pname
, const GLint
* params
)
4453 __GLXcontext
* const gc
= __glXGetCurrentContext();
4454 const GLuint compsize
= __glConvolutionParameteriv_size(pname
);
4455 const GLuint cmdlen
= 12 + __GLX_PAD((compsize
* 4));
4456 emit_header(gc
->pc
, X_GLrop_ConvolutionParameteriv
, cmdlen
);
4457 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&target
), 4);
4458 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(&pname
), 4);
4459 (void) memcpy((void *)(gc
->pc
+ 12), (void *)(params
), (compsize
* 4));
4461 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
4464 #define X_GLrop_CopyConvolutionFilter1D 4107
4466 __indirect_glCopyConvolutionFilter1D(GLenum target
, GLenum internalformat
, GLint x
, GLint y
, GLsizei width
)
4468 __GLXcontext
* const gc
= __glXGetCurrentContext();
4469 const GLuint cmdlen
= 24;
4470 emit_header(gc
->pc
, X_GLrop_CopyConvolutionFilter1D
, cmdlen
);
4471 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&target
), 4);
4472 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(&internalformat
), 4);
4473 (void) memcpy((void *)(gc
->pc
+ 12), (void *)(&x
), 4);
4474 (void) memcpy((void *)(gc
->pc
+ 16), (void *)(&y
), 4);
4475 (void) memcpy((void *)(gc
->pc
+ 20), (void *)(&width
), 4);
4477 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
4480 #define X_GLrop_CopyConvolutionFilter2D 4108
4482 __indirect_glCopyConvolutionFilter2D(GLenum target
, GLenum internalformat
, GLint x
, GLint y
, GLsizei width
, GLsizei height
)
4484 __GLXcontext
* const gc
= __glXGetCurrentContext();
4485 const GLuint cmdlen
= 28;
4486 emit_header(gc
->pc
, X_GLrop_CopyConvolutionFilter2D
, cmdlen
);
4487 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&target
), 4);
4488 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(&internalformat
), 4);
4489 (void) memcpy((void *)(gc
->pc
+ 12), (void *)(&x
), 4);
4490 (void) memcpy((void *)(gc
->pc
+ 16), (void *)(&y
), 4);
4491 (void) memcpy((void *)(gc
->pc
+ 20), (void *)(&width
), 4);
4492 (void) memcpy((void *)(gc
->pc
+ 24), (void *)(&height
), 4);
4494 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
4497 #define X_GLsop_GetConvolutionParameterfv 151
4499 __indirect_glGetConvolutionParameterfv(GLenum target
, GLenum pname
, GLfloat
* params
)
4501 __GLXcontext
* const gc
= __glXGetCurrentContext();
4502 Display
* const dpy
= gc
->currentDpy
;
4503 const GLuint cmdlen
= 8;
4504 if (__builtin_expect(dpy
!= NULL
, 1)) {
4505 GLubyte
const * pc
= setup_single_request(gc
, X_GLsop_GetConvolutionParameterfv
, cmdlen
);
4506 (void) memcpy((void *)(pc
+ 0), (void *)(&target
), 4);
4507 (void) memcpy((void *)(pc
+ 4), (void *)(&pname
), 4);
4508 (void) read_reply(dpy
, 4, params
, GL_FALSE
);
4509 UnlockDisplay(dpy
); SyncHandle();
4514 #define X_GLsop_GetConvolutionParameteriv 152
4516 __indirect_glGetConvolutionParameteriv(GLenum target
, GLenum pname
, GLint
* params
)
4518 __GLXcontext
* const gc
= __glXGetCurrentContext();
4519 Display
* const dpy
= gc
->currentDpy
;
4520 const GLuint cmdlen
= 8;
4521 if (__builtin_expect(dpy
!= NULL
, 1)) {
4522 GLubyte
const * pc
= setup_single_request(gc
, X_GLsop_GetConvolutionParameteriv
, cmdlen
);
4523 (void) memcpy((void *)(pc
+ 0), (void *)(&target
), 4);
4524 (void) memcpy((void *)(pc
+ 4), (void *)(&pname
), 4);
4525 (void) read_reply(dpy
, 4, params
, GL_FALSE
);
4526 UnlockDisplay(dpy
); SyncHandle();
4531 #define X_GLsop_GetHistogramParameterfv 155
4533 __indirect_glGetHistogramParameterfv(GLenum target
, GLenum pname
, GLfloat
* params
)
4535 __GLXcontext
* const gc
= __glXGetCurrentContext();
4536 Display
* const dpy
= gc
->currentDpy
;
4537 const GLuint cmdlen
= 8;
4538 if (__builtin_expect(dpy
!= NULL
, 1)) {
4539 GLubyte
const * pc
= setup_single_request(gc
, X_GLsop_GetHistogramParameterfv
, cmdlen
);
4540 (void) memcpy((void *)(pc
+ 0), (void *)(&target
), 4);
4541 (void) memcpy((void *)(pc
+ 4), (void *)(&pname
), 4);
4542 (void) read_reply(dpy
, 4, params
, GL_FALSE
);
4543 UnlockDisplay(dpy
); SyncHandle();
4548 #define X_GLsop_GetHistogramParameteriv 156
4550 __indirect_glGetHistogramParameteriv(GLenum target
, GLenum pname
, GLint
* params
)
4552 __GLXcontext
* const gc
= __glXGetCurrentContext();
4553 Display
* const dpy
= gc
->currentDpy
;
4554 const GLuint cmdlen
= 8;
4555 if (__builtin_expect(dpy
!= NULL
, 1)) {
4556 GLubyte
const * pc
= setup_single_request(gc
, X_GLsop_GetHistogramParameteriv
, cmdlen
);
4557 (void) memcpy((void *)(pc
+ 0), (void *)(&target
), 4);
4558 (void) memcpy((void *)(pc
+ 4), (void *)(&pname
), 4);
4559 (void) read_reply(dpy
, 4, params
, GL_FALSE
);
4560 UnlockDisplay(dpy
); SyncHandle();
4565 #define X_GLsop_GetMinmaxParameterfv 158
4567 __indirect_glGetMinmaxParameterfv(GLenum target
, GLenum pname
, GLfloat
* params
)
4569 __GLXcontext
* const gc
= __glXGetCurrentContext();
4570 Display
* const dpy
= gc
->currentDpy
;
4571 const GLuint cmdlen
= 8;
4572 if (__builtin_expect(dpy
!= NULL
, 1)) {
4573 GLubyte
const * pc
= setup_single_request(gc
, X_GLsop_GetMinmaxParameterfv
, cmdlen
);
4574 (void) memcpy((void *)(pc
+ 0), (void *)(&target
), 4);
4575 (void) memcpy((void *)(pc
+ 4), (void *)(&pname
), 4);
4576 (void) read_reply(dpy
, 4, params
, GL_FALSE
);
4577 UnlockDisplay(dpy
); SyncHandle();
4582 #define X_GLsop_GetMinmaxParameteriv 159
4584 __indirect_glGetMinmaxParameteriv(GLenum target
, GLenum pname
, GLint
* params
)
4586 __GLXcontext
* const gc
= __glXGetCurrentContext();
4587 Display
* const dpy
= gc
->currentDpy
;
4588 const GLuint cmdlen
= 8;
4589 if (__builtin_expect(dpy
!= NULL
, 1)) {
4590 GLubyte
const * pc
= setup_single_request(gc
, X_GLsop_GetMinmaxParameteriv
, cmdlen
);
4591 (void) memcpy((void *)(pc
+ 0), (void *)(&target
), 4);
4592 (void) memcpy((void *)(pc
+ 4), (void *)(&pname
), 4);
4593 (void) read_reply(dpy
, 4, params
, GL_FALSE
);
4594 UnlockDisplay(dpy
); SyncHandle();
4599 #define X_GLrop_Histogram 4110
4601 __indirect_glHistogram(GLenum target
, GLsizei width
, GLenum internalformat
, GLboolean sink
)
4603 __GLXcontext
* const gc
= __glXGetCurrentContext();
4604 const GLuint cmdlen
= 20;
4605 emit_header(gc
->pc
, X_GLrop_Histogram
, cmdlen
);
4606 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&target
), 4);
4607 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(&width
), 4);
4608 (void) memcpy((void *)(gc
->pc
+ 12), (void *)(&internalformat
), 4);
4609 (void) memcpy((void *)(gc
->pc
+ 16), (void *)(&sink
), 1);
4611 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
4614 #define X_GLrop_Minmax 4111
4616 __indirect_glMinmax(GLenum target
, GLenum internalformat
, GLboolean sink
)
4618 __GLXcontext
* const gc
= __glXGetCurrentContext();
4619 const GLuint cmdlen
= 16;
4620 emit_header(gc
->pc
, X_GLrop_Minmax
, cmdlen
);
4621 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&target
), 4);
4622 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(&internalformat
), 4);
4623 (void) memcpy((void *)(gc
->pc
+ 12), (void *)(&sink
), 1);
4625 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
4628 #define X_GLrop_ResetHistogram 4112
4630 __indirect_glResetHistogram(GLenum target
)
4632 __GLXcontext
* const gc
= __glXGetCurrentContext();
4633 const GLuint cmdlen
= 8;
4634 emit_header(gc
->pc
, X_GLrop_ResetHistogram
, cmdlen
);
4635 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&target
), 4);
4637 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
4640 #define X_GLrop_ResetMinmax 4113
4642 __indirect_glResetMinmax(GLenum target
)
4644 __GLXcontext
* const gc
= __glXGetCurrentContext();
4645 const GLuint cmdlen
= 8;
4646 emit_header(gc
->pc
, X_GLrop_ResetMinmax
, cmdlen
);
4647 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&target
), 4);
4649 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
4653 __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
)
4655 __GLXcontext
* const gc
= __glXGetCurrentContext();
4656 const GLuint compsize
= (pixels
!= NULL
) ? __glImageSize(width
, height
, depth
, format
, type
, target
) : 0;
4657 const GLuint cmdlen
= 84 + __GLX_PAD(compsize
);
4658 if (__builtin_expect(gc
->currentDpy
!= NULL
, 1)) {
4659 if (cmdlen
<= gc
->maxSmallRenderCommandSize
) {
4660 if ( (gc
->pc
+ cmdlen
) > gc
->bufEnd
) {
4661 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
4663 emit_header(gc
->pc
, opcode
, cmdlen
);
4664 (void) memcpy((void *)(gc
->pc
+ 40), (void *)(&target
), 4);
4665 (void) memcpy((void *)(gc
->pc
+ 44), (void *)(&level
), 4);
4666 (void) memcpy((void *)(gc
->pc
+ 48), (void *)(&internalformat
), 4);
4667 (void) memcpy((void *)(gc
->pc
+ 52), (void *)(&width
), 4);
4668 (void) memcpy((void *)(gc
->pc
+ 56), (void *)(&height
), 4);
4669 (void) memcpy((void *)(gc
->pc
+ 60), (void *)(&depth
), 4);
4670 (void) memcpy((void *)(gc
->pc
+ 64), (void *)(&extent
), 4);
4671 (void) memcpy((void *)(gc
->pc
+ 68), (void *)(&border
), 4);
4672 (void) memcpy((void *)(gc
->pc
+ 72), (void *)(&format
), 4);
4673 (void) memcpy((void *)(gc
->pc
+ 76), (void *)(&type
), 4);
4674 (void) memcpy((void *)(gc
->pc
+ 80), (void *)((pixels
== NULL
) ? one
: zero
), 4);
4676 (*gc
->fillImage
)(gc
, dim
, width
, height
, depth
, format
, type
, pixels
, gc
->pc
+ 84, gc
->pc
+ 4);
4679 (void) memcpy( gc
->pc
+ 4, default_pixel_store_4D
, default_pixel_store_4D_size
);
4682 if (gc
->pc
> gc
->limit
) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
4685 const GLint op
= opcode
;
4686 const GLuint cmdlenLarge
= cmdlen
+ 4;
4687 GLubyte
* const pc
= __glXFlushRenderBuffer(gc
, gc
->pc
);
4688 (void) memcpy((void *)(pc
+ 0), (void *)(&cmdlenLarge
), 4);
4689 (void) memcpy((void *)(pc
+ 4), (void *)(&op
), 4);
4690 (void) memcpy((void *)(pc
+ 44), (void *)(&target
), 4);
4691 (void) memcpy((void *)(pc
+ 48), (void *)(&level
), 4);
4692 (void) memcpy((void *)(pc
+ 52), (void *)(&internalformat
), 4);
4693 (void) memcpy((void *)(pc
+ 56), (void *)(&width
), 4);
4694 (void) memcpy((void *)(pc
+ 60), (void *)(&height
), 4);
4695 (void) memcpy((void *)(pc
+ 64), (void *)(&depth
), 4);
4696 (void) memcpy((void *)(pc
+ 68), (void *)(&extent
), 4);
4697 (void) memcpy((void *)(pc
+ 72), (void *)(&border
), 4);
4698 (void) memcpy((void *)(pc
+ 76), (void *)(&format
), 4);
4699 (void) memcpy((void *)(pc
+ 80), (void *)(&type
), 4);
4700 (void) memcpy((void *)(pc
+ 84), zero
, 4);
4701 __glXSendLargeImage(gc
, compsize
, dim
, width
, height
, depth
, format
, type
, pixels
, pc
+ 88, pc
+ 8);
4706 #define X_GLrop_TexImage3D 4114
4708 __indirect_glTexImage3D(GLenum target
, GLint level
, GLint internalformat
, GLsizei width
, GLsizei height
, GLsizei depth
, GLint border
, GLenum format
, GLenum type
, const GLvoid
* pixels
)
4710 __glx_TexImage_3D4D(X_GLrop_TexImage3D
, 3, target
, level
, internalformat
, width
, height
, depth
, 1, border
, format
, type
, pixels
);
4714 __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
)
4716 __GLXcontext
* const gc
= __glXGetCurrentContext();
4717 const GLuint compsize
= (pixels
!= NULL
) ? __glImageSize(width
, height
, depth
, format
, type
, target
) : 0;
4718 const GLuint cmdlen
= 92 + __GLX_PAD(compsize
);
4719 if (__builtin_expect(gc
->currentDpy
!= NULL
, 1)) {
4720 if (cmdlen
<= gc
->maxSmallRenderCommandSize
) {
4721 if ( (gc
->pc
+ cmdlen
) > gc
->bufEnd
) {
4722 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
4724 emit_header(gc
->pc
, opcode
, cmdlen
);
4725 (void) memcpy((void *)(gc
->pc
+ 40), (void *)(&target
), 4);
4726 (void) memcpy((void *)(gc
->pc
+ 44), (void *)(&level
), 4);
4727 (void) memcpy((void *)(gc
->pc
+ 48), (void *)(&xoffset
), 4);
4728 (void) memcpy((void *)(gc
->pc
+ 52), (void *)(&yoffset
), 4);
4729 (void) memcpy((void *)(gc
->pc
+ 56), (void *)(&zoffset
), 4);
4730 (void) memcpy((void *)(gc
->pc
+ 60), (void *)(&woffset
), 4);
4731 (void) memcpy((void *)(gc
->pc
+ 64), (void *)(&width
), 4);
4732 (void) memcpy((void *)(gc
->pc
+ 68), (void *)(&height
), 4);
4733 (void) memcpy((void *)(gc
->pc
+ 72), (void *)(&depth
), 4);
4734 (void) memcpy((void *)(gc
->pc
+ 76), (void *)(&extent
), 4);
4735 (void) memcpy((void *)(gc
->pc
+ 80), (void *)(&format
), 4);
4736 (void) memcpy((void *)(gc
->pc
+ 84), (void *)(&type
), 4);
4737 (void) memcpy((void *)(gc
->pc
+ 88), (void *)((pixels
== NULL
) ? one
: zero
), 4);
4739 (*gc
->fillImage
)(gc
, dim
, width
, height
, depth
, format
, type
, pixels
, gc
->pc
+ 92, gc
->pc
+ 4);
4742 (void) memcpy( gc
->pc
+ 4, default_pixel_store_4D
, default_pixel_store_4D_size
);
4745 if (gc
->pc
> gc
->limit
) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
4748 const GLint op
= opcode
;
4749 const GLuint cmdlenLarge
= cmdlen
+ 4;
4750 GLubyte
* const pc
= __glXFlushRenderBuffer(gc
, gc
->pc
);
4751 (void) memcpy((void *)(pc
+ 0), (void *)(&cmdlenLarge
), 4);
4752 (void) memcpy((void *)(pc
+ 4), (void *)(&op
), 4);
4753 (void) memcpy((void *)(pc
+ 44), (void *)(&target
), 4);
4754 (void) memcpy((void *)(pc
+ 48), (void *)(&level
), 4);
4755 (void) memcpy((void *)(pc
+ 52), (void *)(&xoffset
), 4);
4756 (void) memcpy((void *)(pc
+ 56), (void *)(&yoffset
), 4);
4757 (void) memcpy((void *)(pc
+ 60), (void *)(&zoffset
), 4);
4758 (void) memcpy((void *)(pc
+ 64), (void *)(&woffset
), 4);
4759 (void) memcpy((void *)(pc
+ 68), (void *)(&width
), 4);
4760 (void) memcpy((void *)(pc
+ 72), (void *)(&height
), 4);
4761 (void) memcpy((void *)(pc
+ 76), (void *)(&depth
), 4);
4762 (void) memcpy((void *)(pc
+ 80), (void *)(&extent
), 4);
4763 (void) memcpy((void *)(pc
+ 84), (void *)(&format
), 4);
4764 (void) memcpy((void *)(pc
+ 88), (void *)(&type
), 4);
4765 (void) memcpy((void *)(pc
+ 92), zero
, 4);
4766 __glXSendLargeImage(gc
, compsize
, dim
, width
, height
, depth
, format
, type
, pixels
, pc
+ 96, pc
+ 8);
4771 #define X_GLrop_TexSubImage3D 4115
4773 __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
)
4775 __glx_TexSubImage_3D4D(X_GLrop_TexSubImage3D
, 3, target
, level
, xoffset
, yoffset
, zoffset
, 1, width
, height
, depth
, 1, format
, type
, pixels
);
4778 #define X_GLrop_CopyTexSubImage3D 4123
4780 __indirect_glCopyTexSubImage3D(GLenum target
, GLint level
, GLint xoffset
, GLint yoffset
, GLint zoffset
, GLint x
, GLint y
, GLsizei width
, GLsizei height
)
4782 __GLXcontext
* const gc
= __glXGetCurrentContext();
4783 const GLuint cmdlen
= 40;
4784 emit_header(gc
->pc
, X_GLrop_CopyTexSubImage3D
, cmdlen
);
4785 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&target
), 4);
4786 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(&level
), 4);
4787 (void) memcpy((void *)(gc
->pc
+ 12), (void *)(&xoffset
), 4);
4788 (void) memcpy((void *)(gc
->pc
+ 16), (void *)(&yoffset
), 4);
4789 (void) memcpy((void *)(gc
->pc
+ 20), (void *)(&zoffset
), 4);
4790 (void) memcpy((void *)(gc
->pc
+ 24), (void *)(&x
), 4);
4791 (void) memcpy((void *)(gc
->pc
+ 28), (void *)(&y
), 4);
4792 (void) memcpy((void *)(gc
->pc
+ 32), (void *)(&width
), 4);
4793 (void) memcpy((void *)(gc
->pc
+ 36), (void *)(&height
), 4);
4795 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
4798 #define X_GLrop_ActiveTextureARB 197
4800 __indirect_glActiveTextureARB(GLenum texture
)
4802 __GLXcontext
* const gc
= __glXGetCurrentContext();
4803 const GLuint cmdlen
= 8;
4804 emit_header(gc
->pc
, X_GLrop_ActiveTextureARB
, cmdlen
);
4805 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&texture
), 4);
4807 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
4810 #define X_GLrop_MultiTexCoord1dvARB 198
4812 __indirect_glMultiTexCoord1dARB(GLenum target
, GLdouble s
)
4814 __GLXcontext
* const gc
= __glXGetCurrentContext();
4815 const GLuint cmdlen
= 16;
4816 emit_header(gc
->pc
, X_GLrop_MultiTexCoord1dvARB
, cmdlen
);
4817 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&s
), 8);
4818 (void) memcpy((void *)(gc
->pc
+ 12), (void *)(&target
), 4);
4820 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
4823 #define X_GLrop_MultiTexCoord1dvARB 198
4825 __indirect_glMultiTexCoord1dvARB(GLenum target
, const GLdouble
* v
)
4827 __GLXcontext
* const gc
= __glXGetCurrentContext();
4828 const GLuint cmdlen
= 16;
4829 emit_header(gc
->pc
, X_GLrop_MultiTexCoord1dvARB
, cmdlen
);
4830 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(v
), 8);
4831 (void) memcpy((void *)(gc
->pc
+ 12), (void *)(&target
), 4);
4833 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
4836 #define X_GLrop_MultiTexCoord1fvARB 199
4838 __indirect_glMultiTexCoord1fARB(GLenum target
, GLfloat s
)
4840 __GLXcontext
* const gc
= __glXGetCurrentContext();
4841 const GLuint cmdlen
= 12;
4842 emit_header(gc
->pc
, X_GLrop_MultiTexCoord1fvARB
, cmdlen
);
4843 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&target
), 4);
4844 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(&s
), 4);
4846 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
4849 #define X_GLrop_MultiTexCoord1fvARB 199
4851 __indirect_glMultiTexCoord1fvARB(GLenum target
, const GLfloat
* v
)
4853 __GLXcontext
* const gc
= __glXGetCurrentContext();
4854 const GLuint cmdlen
= 12;
4855 emit_header(gc
->pc
, X_GLrop_MultiTexCoord1fvARB
, cmdlen
);
4856 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&target
), 4);
4857 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(v
), 4);
4859 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
4862 #define X_GLrop_MultiTexCoord1ivARB 200
4864 __indirect_glMultiTexCoord1iARB(GLenum target
, GLint s
)
4866 __GLXcontext
* const gc
= __glXGetCurrentContext();
4867 const GLuint cmdlen
= 12;
4868 emit_header(gc
->pc
, X_GLrop_MultiTexCoord1ivARB
, cmdlen
);
4869 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&target
), 4);
4870 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(&s
), 4);
4872 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
4875 #define X_GLrop_MultiTexCoord1ivARB 200
4877 __indirect_glMultiTexCoord1ivARB(GLenum target
, const GLint
* v
)
4879 __GLXcontext
* const gc
= __glXGetCurrentContext();
4880 const GLuint cmdlen
= 12;
4881 emit_header(gc
->pc
, X_GLrop_MultiTexCoord1ivARB
, cmdlen
);
4882 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&target
), 4);
4883 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(v
), 4);
4885 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
4888 #define X_GLrop_MultiTexCoord1svARB 201
4890 __indirect_glMultiTexCoord1sARB(GLenum target
, GLshort s
)
4892 __GLXcontext
* const gc
= __glXGetCurrentContext();
4893 const GLuint cmdlen
= 12;
4894 emit_header(gc
->pc
, X_GLrop_MultiTexCoord1svARB
, cmdlen
);
4895 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&target
), 4);
4896 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(&s
), 2);
4898 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
4901 #define X_GLrop_MultiTexCoord1svARB 201
4903 __indirect_glMultiTexCoord1svARB(GLenum target
, const GLshort
* v
)
4905 __GLXcontext
* const gc
= __glXGetCurrentContext();
4906 const GLuint cmdlen
= 12;
4907 emit_header(gc
->pc
, X_GLrop_MultiTexCoord1svARB
, cmdlen
);
4908 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&target
), 4);
4909 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(v
), 2);
4911 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
4914 #define X_GLrop_MultiTexCoord2dvARB 202
4916 __indirect_glMultiTexCoord2dARB(GLenum target
, GLdouble s
, GLdouble t
)
4918 __GLXcontext
* const gc
= __glXGetCurrentContext();
4919 const GLuint cmdlen
= 24;
4920 emit_header(gc
->pc
, X_GLrop_MultiTexCoord2dvARB
, cmdlen
);
4921 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&s
), 8);
4922 (void) memcpy((void *)(gc
->pc
+ 12), (void *)(&t
), 8);
4923 (void) memcpy((void *)(gc
->pc
+ 20), (void *)(&target
), 4);
4925 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
4928 #define X_GLrop_MultiTexCoord2dvARB 202
4930 __indirect_glMultiTexCoord2dvARB(GLenum target
, const GLdouble
* v
)
4932 __GLXcontext
* const gc
= __glXGetCurrentContext();
4933 const GLuint cmdlen
= 24;
4934 emit_header(gc
->pc
, X_GLrop_MultiTexCoord2dvARB
, cmdlen
);
4935 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(v
), 16);
4936 (void) memcpy((void *)(gc
->pc
+ 20), (void *)(&target
), 4);
4938 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
4941 #define X_GLrop_MultiTexCoord2fvARB 203
4943 __indirect_glMultiTexCoord2fARB(GLenum target
, GLfloat s
, GLfloat t
)
4945 __GLXcontext
* const gc
= __glXGetCurrentContext();
4946 const GLuint cmdlen
= 16;
4947 emit_header(gc
->pc
, X_GLrop_MultiTexCoord2fvARB
, cmdlen
);
4948 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&target
), 4);
4949 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(&s
), 4);
4950 (void) memcpy((void *)(gc
->pc
+ 12), (void *)(&t
), 4);
4952 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
4955 #define X_GLrop_MultiTexCoord2fvARB 203
4957 __indirect_glMultiTexCoord2fvARB(GLenum target
, const GLfloat
* v
)
4959 __GLXcontext
* const gc
= __glXGetCurrentContext();
4960 const GLuint cmdlen
= 16;
4961 emit_header(gc
->pc
, X_GLrop_MultiTexCoord2fvARB
, cmdlen
);
4962 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&target
), 4);
4963 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(v
), 8);
4965 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
4968 #define X_GLrop_MultiTexCoord2ivARB 204
4970 __indirect_glMultiTexCoord2iARB(GLenum target
, GLint s
, GLint t
)
4972 __GLXcontext
* const gc
= __glXGetCurrentContext();
4973 const GLuint cmdlen
= 16;
4974 emit_header(gc
->pc
, X_GLrop_MultiTexCoord2ivARB
, cmdlen
);
4975 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&target
), 4);
4976 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(&s
), 4);
4977 (void) memcpy((void *)(gc
->pc
+ 12), (void *)(&t
), 4);
4979 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
4982 #define X_GLrop_MultiTexCoord2ivARB 204
4984 __indirect_glMultiTexCoord2ivARB(GLenum target
, const GLint
* v
)
4986 __GLXcontext
* const gc
= __glXGetCurrentContext();
4987 const GLuint cmdlen
= 16;
4988 emit_header(gc
->pc
, X_GLrop_MultiTexCoord2ivARB
, cmdlen
);
4989 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&target
), 4);
4990 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(v
), 8);
4992 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
4995 #define X_GLrop_MultiTexCoord2svARB 205
4997 __indirect_glMultiTexCoord2sARB(GLenum target
, GLshort s
, GLshort t
)
4999 __GLXcontext
* const gc
= __glXGetCurrentContext();
5000 const GLuint cmdlen
= 12;
5001 emit_header(gc
->pc
, X_GLrop_MultiTexCoord2svARB
, cmdlen
);
5002 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&target
), 4);
5003 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(&s
), 2);
5004 (void) memcpy((void *)(gc
->pc
+ 10), (void *)(&t
), 2);
5006 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
5009 #define X_GLrop_MultiTexCoord2svARB 205
5011 __indirect_glMultiTexCoord2svARB(GLenum target
, const GLshort
* v
)
5013 __GLXcontext
* const gc
= __glXGetCurrentContext();
5014 const GLuint cmdlen
= 12;
5015 emit_header(gc
->pc
, X_GLrop_MultiTexCoord2svARB
, cmdlen
);
5016 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&target
), 4);
5017 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(v
), 4);
5019 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
5022 #define X_GLrop_MultiTexCoord3dvARB 206
5024 __indirect_glMultiTexCoord3dARB(GLenum target
, GLdouble s
, GLdouble t
, GLdouble r
)
5026 __GLXcontext
* const gc
= __glXGetCurrentContext();
5027 const GLuint cmdlen
= 32;
5028 emit_header(gc
->pc
, X_GLrop_MultiTexCoord3dvARB
, cmdlen
);
5029 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&s
), 8);
5030 (void) memcpy((void *)(gc
->pc
+ 12), (void *)(&t
), 8);
5031 (void) memcpy((void *)(gc
->pc
+ 20), (void *)(&r
), 8);
5032 (void) memcpy((void *)(gc
->pc
+ 28), (void *)(&target
), 4);
5034 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
5037 #define X_GLrop_MultiTexCoord3dvARB 206
5039 __indirect_glMultiTexCoord3dvARB(GLenum target
, const GLdouble
* v
)
5041 __GLXcontext
* const gc
= __glXGetCurrentContext();
5042 const GLuint cmdlen
= 32;
5043 emit_header(gc
->pc
, X_GLrop_MultiTexCoord3dvARB
, cmdlen
);
5044 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(v
), 24);
5045 (void) memcpy((void *)(gc
->pc
+ 28), (void *)(&target
), 4);
5047 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
5050 #define X_GLrop_MultiTexCoord3fvARB 207
5052 __indirect_glMultiTexCoord3fARB(GLenum target
, GLfloat s
, GLfloat t
, GLfloat r
)
5054 __GLXcontext
* const gc
= __glXGetCurrentContext();
5055 const GLuint cmdlen
= 20;
5056 emit_header(gc
->pc
, X_GLrop_MultiTexCoord3fvARB
, cmdlen
);
5057 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&target
), 4);
5058 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(&s
), 4);
5059 (void) memcpy((void *)(gc
->pc
+ 12), (void *)(&t
), 4);
5060 (void) memcpy((void *)(gc
->pc
+ 16), (void *)(&r
), 4);
5062 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
5065 #define X_GLrop_MultiTexCoord3fvARB 207
5067 __indirect_glMultiTexCoord3fvARB(GLenum target
, const GLfloat
* v
)
5069 __GLXcontext
* const gc
= __glXGetCurrentContext();
5070 const GLuint cmdlen
= 20;
5071 emit_header(gc
->pc
, X_GLrop_MultiTexCoord3fvARB
, cmdlen
);
5072 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&target
), 4);
5073 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(v
), 12);
5075 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
5078 #define X_GLrop_MultiTexCoord3ivARB 208
5080 __indirect_glMultiTexCoord3iARB(GLenum target
, GLint s
, GLint t
, GLint r
)
5082 __GLXcontext
* const gc
= __glXGetCurrentContext();
5083 const GLuint cmdlen
= 20;
5084 emit_header(gc
->pc
, X_GLrop_MultiTexCoord3ivARB
, cmdlen
);
5085 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&target
), 4);
5086 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(&s
), 4);
5087 (void) memcpy((void *)(gc
->pc
+ 12), (void *)(&t
), 4);
5088 (void) memcpy((void *)(gc
->pc
+ 16), (void *)(&r
), 4);
5090 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
5093 #define X_GLrop_MultiTexCoord3ivARB 208
5095 __indirect_glMultiTexCoord3ivARB(GLenum target
, const GLint
* v
)
5097 __GLXcontext
* const gc
= __glXGetCurrentContext();
5098 const GLuint cmdlen
= 20;
5099 emit_header(gc
->pc
, X_GLrop_MultiTexCoord3ivARB
, cmdlen
);
5100 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&target
), 4);
5101 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(v
), 12);
5103 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
5106 #define X_GLrop_MultiTexCoord3svARB 209
5108 __indirect_glMultiTexCoord3sARB(GLenum target
, GLshort s
, GLshort t
, GLshort r
)
5110 __GLXcontext
* const gc
= __glXGetCurrentContext();
5111 const GLuint cmdlen
= 16;
5112 emit_header(gc
->pc
, X_GLrop_MultiTexCoord3svARB
, cmdlen
);
5113 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&target
), 4);
5114 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(&s
), 2);
5115 (void) memcpy((void *)(gc
->pc
+ 10), (void *)(&t
), 2);
5116 (void) memcpy((void *)(gc
->pc
+ 12), (void *)(&r
), 2);
5118 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
5121 #define X_GLrop_MultiTexCoord3svARB 209
5123 __indirect_glMultiTexCoord3svARB(GLenum target
, const GLshort
* v
)
5125 __GLXcontext
* const gc
= __glXGetCurrentContext();
5126 const GLuint cmdlen
= 16;
5127 emit_header(gc
->pc
, X_GLrop_MultiTexCoord3svARB
, cmdlen
);
5128 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&target
), 4);
5129 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(v
), 6);
5131 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
5134 #define X_GLrop_MultiTexCoord4dvARB 210
5136 __indirect_glMultiTexCoord4dARB(GLenum target
, GLdouble s
, GLdouble t
, GLdouble r
, GLdouble q
)
5138 __GLXcontext
* const gc
= __glXGetCurrentContext();
5139 const GLuint cmdlen
= 40;
5140 emit_header(gc
->pc
, X_GLrop_MultiTexCoord4dvARB
, cmdlen
);
5141 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&s
), 8);
5142 (void) memcpy((void *)(gc
->pc
+ 12), (void *)(&t
), 8);
5143 (void) memcpy((void *)(gc
->pc
+ 20), (void *)(&r
), 8);
5144 (void) memcpy((void *)(gc
->pc
+ 28), (void *)(&q
), 8);
5145 (void) memcpy((void *)(gc
->pc
+ 36), (void *)(&target
), 4);
5147 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
5150 #define X_GLrop_MultiTexCoord4dvARB 210
5152 __indirect_glMultiTexCoord4dvARB(GLenum target
, const GLdouble
* v
)
5154 __GLXcontext
* const gc
= __glXGetCurrentContext();
5155 const GLuint cmdlen
= 40;
5156 emit_header(gc
->pc
, X_GLrop_MultiTexCoord4dvARB
, cmdlen
);
5157 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(v
), 32);
5158 (void) memcpy((void *)(gc
->pc
+ 36), (void *)(&target
), 4);
5160 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
5163 #define X_GLrop_MultiTexCoord4fvARB 211
5165 __indirect_glMultiTexCoord4fARB(GLenum target
, GLfloat s
, GLfloat t
, GLfloat r
, GLfloat q
)
5167 __GLXcontext
* const gc
= __glXGetCurrentContext();
5168 const GLuint cmdlen
= 24;
5169 emit_header(gc
->pc
, X_GLrop_MultiTexCoord4fvARB
, cmdlen
);
5170 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&target
), 4);
5171 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(&s
), 4);
5172 (void) memcpy((void *)(gc
->pc
+ 12), (void *)(&t
), 4);
5173 (void) memcpy((void *)(gc
->pc
+ 16), (void *)(&r
), 4);
5174 (void) memcpy((void *)(gc
->pc
+ 20), (void *)(&q
), 4);
5176 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
5179 #define X_GLrop_MultiTexCoord4fvARB 211
5181 __indirect_glMultiTexCoord4fvARB(GLenum target
, const GLfloat
* v
)
5183 __GLXcontext
* const gc
= __glXGetCurrentContext();
5184 const GLuint cmdlen
= 24;
5185 emit_header(gc
->pc
, X_GLrop_MultiTexCoord4fvARB
, cmdlen
);
5186 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&target
), 4);
5187 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(v
), 16);
5189 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
5192 #define X_GLrop_MultiTexCoord4ivARB 212
5194 __indirect_glMultiTexCoord4iARB(GLenum target
, GLint s
, GLint t
, GLint r
, GLint q
)
5196 __GLXcontext
* const gc
= __glXGetCurrentContext();
5197 const GLuint cmdlen
= 24;
5198 emit_header(gc
->pc
, X_GLrop_MultiTexCoord4ivARB
, cmdlen
);
5199 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&target
), 4);
5200 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(&s
), 4);
5201 (void) memcpy((void *)(gc
->pc
+ 12), (void *)(&t
), 4);
5202 (void) memcpy((void *)(gc
->pc
+ 16), (void *)(&r
), 4);
5203 (void) memcpy((void *)(gc
->pc
+ 20), (void *)(&q
), 4);
5205 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
5208 #define X_GLrop_MultiTexCoord4ivARB 212
5210 __indirect_glMultiTexCoord4ivARB(GLenum target
, const GLint
* v
)
5212 __GLXcontext
* const gc
= __glXGetCurrentContext();
5213 const GLuint cmdlen
= 24;
5214 emit_header(gc
->pc
, X_GLrop_MultiTexCoord4ivARB
, cmdlen
);
5215 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&target
), 4);
5216 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(v
), 16);
5218 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
5221 #define X_GLrop_MultiTexCoord4svARB 213
5223 __indirect_glMultiTexCoord4sARB(GLenum target
, GLshort s
, GLshort t
, GLshort r
, GLshort q
)
5225 __GLXcontext
* const gc
= __glXGetCurrentContext();
5226 const GLuint cmdlen
= 16;
5227 emit_header(gc
->pc
, X_GLrop_MultiTexCoord4svARB
, cmdlen
);
5228 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&target
), 4);
5229 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(&s
), 2);
5230 (void) memcpy((void *)(gc
->pc
+ 10), (void *)(&t
), 2);
5231 (void) memcpy((void *)(gc
->pc
+ 12), (void *)(&r
), 2);
5232 (void) memcpy((void *)(gc
->pc
+ 14), (void *)(&q
), 2);
5234 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
5237 #define X_GLrop_MultiTexCoord4svARB 213
5239 __indirect_glMultiTexCoord4svARB(GLenum target
, const GLshort
* v
)
5241 __GLXcontext
* const gc
= __glXGetCurrentContext();
5242 const GLuint cmdlen
= 16;
5243 emit_header(gc
->pc
, X_GLrop_MultiTexCoord4svARB
, cmdlen
);
5244 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&target
), 4);
5245 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(v
), 8);
5247 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
5250 #define X_GLrop_SampleCoverageARB 229
5252 __indirect_glSampleCoverageARB(GLclampf value
, GLboolean invert
)
5254 __GLXcontext
* const gc
= __glXGetCurrentContext();
5255 const GLuint cmdlen
= 12;
5256 emit_header(gc
->pc
, X_GLrop_SampleCoverageARB
, cmdlen
);
5257 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&value
), 4);
5258 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(&invert
), 1);
5260 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
5263 #define X_GLvop_AreTexturesResidentEXT 11
5265 __indirect_glAreTexturesResidentEXT(GLsizei n
, const GLuint
* textures
, GLboolean
* residences
)
5267 __GLXcontext
* const gc
= __glXGetCurrentContext();
5268 Display
* const dpy
= gc
->currentDpy
;
5269 GLboolean retval
= (GLboolean
) 0;
5270 const GLuint cmdlen
= 4 + __GLX_PAD((n
* 4));
5271 if (__builtin_expect((n
>= 0) && (dpy
!= NULL
), 1)) {
5272 GLubyte
const * pc
= setup_vendor_request(gc
, X_GLXVendorPrivateWithReply
, X_GLvop_AreTexturesResidentEXT
, cmdlen
);
5273 (void) memcpy((void *)(pc
+ 0), (void *)(&n
), 4);
5274 (void) memcpy((void *)(pc
+ 4), (void *)(textures
), (n
* 4));
5275 retval
= (GLboolean
) read_reply(dpy
, 1, residences
, GL_TRUE
);
5276 UnlockDisplay(dpy
); SyncHandle();
5281 #define X_GLvop_GenTexturesEXT 13
5283 __indirect_glGenTexturesEXT(GLsizei n
, GLuint
* textures
)
5285 __GLXcontext
* const gc
= __glXGetCurrentContext();
5286 Display
* const dpy
= gc
->currentDpy
;
5287 const GLuint cmdlen
= 4;
5288 if (__builtin_expect(dpy
!= NULL
, 1)) {
5289 GLubyte
const * pc
= setup_vendor_request(gc
, X_GLXVendorPrivateWithReply
, X_GLvop_GenTexturesEXT
, cmdlen
);
5290 (void) memcpy((void *)(pc
+ 0), (void *)(&n
), 4);
5291 (void) read_reply(dpy
, 4, textures
, GL_TRUE
);
5292 UnlockDisplay(dpy
); SyncHandle();
5297 #define X_GLvop_IsTextureEXT 14
5299 __indirect_glIsTextureEXT(GLuint texture
)
5301 __GLXcontext
* const gc
= __glXGetCurrentContext();
5302 Display
* const dpy
= gc
->currentDpy
;
5303 GLboolean retval
= (GLboolean
) 0;
5304 const GLuint cmdlen
= 4;
5305 if (__builtin_expect(dpy
!= NULL
, 1)) {
5306 GLubyte
const * pc
= setup_vendor_request(gc
, X_GLXVendorPrivateWithReply
, X_GLvop_IsTextureEXT
, cmdlen
);
5307 (void) memcpy((void *)(pc
+ 0), (void *)(&texture
), 4);
5308 retval
= (GLboolean
) read_reply(dpy
, 0, NULL
, GL_FALSE
);
5309 UnlockDisplay(dpy
); SyncHandle();
5314 #define X_GLrop_SampleMaskSGIS 2048
5316 __indirect_glSampleMaskSGIS(GLclampf value
, GLboolean invert
)
5318 __GLXcontext
* const gc
= __glXGetCurrentContext();
5319 const GLuint cmdlen
= 12;
5320 emit_header(gc
->pc
, X_GLrop_SampleMaskSGIS
, cmdlen
);
5321 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&value
), 4);
5322 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(&invert
), 1);
5324 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
5327 #define X_GLrop_SamplePatternSGIS 2049
5329 __indirect_glSamplePatternSGIS(GLenum pattern
)
5331 __GLXcontext
* const gc
= __glXGetCurrentContext();
5332 const GLuint cmdlen
= 8;
5333 emit_header(gc
->pc
, X_GLrop_SamplePatternSGIS
, cmdlen
);
5334 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&pattern
), 4);
5336 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
5339 #define X_GLrop_PointParameterfEXT 2065
5341 __indirect_glPointParameterfEXT(GLenum pname
, GLfloat param
)
5343 __GLXcontext
* const gc
= __glXGetCurrentContext();
5344 const GLuint cmdlen
= 12;
5345 emit_header(gc
->pc
, X_GLrop_PointParameterfEXT
, cmdlen
);
5346 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&pname
), 4);
5347 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(¶m
), 4);
5349 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
5352 #define X_GLrop_PointParameterfvEXT 2066
5354 __indirect_glPointParameterfvEXT(GLenum pname
, const GLfloat
* params
)
5356 __GLXcontext
* const gc
= __glXGetCurrentContext();
5357 const GLuint compsize
= __glPointParameterfvEXT_size(pname
);
5358 const GLuint cmdlen
= 8 + __GLX_PAD((compsize
* 4));
5359 emit_header(gc
->pc
, X_GLrop_PointParameterfvEXT
, cmdlen
);
5360 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&pname
), 4);
5361 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(params
), (compsize
* 4));
5363 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
5366 #define X_GLrop_WindowPos3fvMESA 230
5368 __indirect_glWindowPos3fMESA(GLfloat x
, GLfloat y
, GLfloat z
)
5370 __GLXcontext
* const gc
= __glXGetCurrentContext();
5371 const GLuint cmdlen
= 16;
5372 emit_header(gc
->pc
, X_GLrop_WindowPos3fvMESA
, cmdlen
);
5373 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&x
), 4);
5374 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(&y
), 4);
5375 (void) memcpy((void *)(gc
->pc
+ 12), (void *)(&z
), 4);
5377 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
5380 #define X_GLrop_WindowPos3fvMESA 230
5382 __indirect_glWindowPos3fvMESA(const GLfloat
* v
)
5384 generic_12_byte( X_GLrop_WindowPos3fvMESA
, v
);
5387 #define X_GLrop_BlendFuncSeparateEXT 4134
5389 __indirect_glBlendFuncSeparateEXT(GLenum sfactorRGB
, GLenum dfactorRGB
, GLenum sfactorAlpha
, GLenum dfactorAlpha
)
5391 __GLXcontext
* const gc
= __glXGetCurrentContext();
5392 const GLuint cmdlen
= 20;
5393 emit_header(gc
->pc
, X_GLrop_BlendFuncSeparateEXT
, cmdlen
);
5394 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&sfactorRGB
), 4);
5395 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(&dfactorRGB
), 4);
5396 (void) memcpy((void *)(gc
->pc
+ 12), (void *)(&sfactorAlpha
), 4);
5397 (void) memcpy((void *)(gc
->pc
+ 16), (void *)(&dfactorAlpha
), 4);
5399 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
5402 #define X_GLrop_FogCoordfvEXT 4124
5404 __indirect_glFogCoordfEXT(GLfloat coord
)
5406 __GLXcontext
* const gc
= __glXGetCurrentContext();
5407 const GLuint cmdlen
= 8;
5408 emit_header(gc
->pc
, X_GLrop_FogCoordfvEXT
, cmdlen
);
5409 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&coord
), 4);
5411 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
5414 #define X_GLrop_FogCoordfvEXT 4124
5416 __indirect_glFogCoordfvEXT(const GLfloat
* coord
)
5418 generic_4_byte( X_GLrop_FogCoordfvEXT
, coord
);
5421 #define X_GLrop_FogCoorddvEXT 4125
5423 __indirect_glFogCoorddEXT(GLdouble coord
)
5425 __GLXcontext
* const gc
= __glXGetCurrentContext();
5426 const GLuint cmdlen
= 12;
5427 emit_header(gc
->pc
, X_GLrop_FogCoorddvEXT
, cmdlen
);
5428 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&coord
), 8);
5430 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
5433 #define X_GLrop_FogCoorddvEXT 4125
5435 __indirect_glFogCoorddvEXT(const GLdouble
* coord
)
5437 generic_8_byte( X_GLrop_FogCoorddvEXT
, coord
);
5440 #define X_GLrop_SecondaryColor3bvEXT 4126
5442 __indirect_glSecondaryColor3bEXT(GLbyte red
, GLbyte green
, GLbyte blue
)
5444 __GLXcontext
* const gc
= __glXGetCurrentContext();
5445 const GLuint cmdlen
= 8;
5446 emit_header(gc
->pc
, X_GLrop_SecondaryColor3bvEXT
, cmdlen
);
5447 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&red
), 1);
5448 (void) memcpy((void *)(gc
->pc
+ 5), (void *)(&green
), 1);
5449 (void) memcpy((void *)(gc
->pc
+ 6), (void *)(&blue
), 1);
5451 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
5454 #define X_GLrop_SecondaryColor3bvEXT 4126
5456 __indirect_glSecondaryColor3bvEXT(const GLbyte
* v
)
5458 generic_3_byte( X_GLrop_SecondaryColor3bvEXT
, v
);
5461 #define X_GLrop_SecondaryColor3dvEXT 4130
5463 __indirect_glSecondaryColor3dEXT(GLdouble red
, GLdouble green
, GLdouble blue
)
5465 __GLXcontext
* const gc
= __glXGetCurrentContext();
5466 const GLuint cmdlen
= 28;
5467 emit_header(gc
->pc
, X_GLrop_SecondaryColor3dvEXT
, cmdlen
);
5468 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&red
), 8);
5469 (void) memcpy((void *)(gc
->pc
+ 12), (void *)(&green
), 8);
5470 (void) memcpy((void *)(gc
->pc
+ 20), (void *)(&blue
), 8);
5472 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
5475 #define X_GLrop_SecondaryColor3dvEXT 4130
5477 __indirect_glSecondaryColor3dvEXT(const GLdouble
* v
)
5479 generic_24_byte( X_GLrop_SecondaryColor3dvEXT
, v
);
5482 #define X_GLrop_SecondaryColor3fvEXT 4129
5484 __indirect_glSecondaryColor3fEXT(GLfloat red
, GLfloat green
, GLfloat blue
)
5486 __GLXcontext
* const gc
= __glXGetCurrentContext();
5487 const GLuint cmdlen
= 16;
5488 emit_header(gc
->pc
, X_GLrop_SecondaryColor3fvEXT
, cmdlen
);
5489 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&red
), 4);
5490 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(&green
), 4);
5491 (void) memcpy((void *)(gc
->pc
+ 12), (void *)(&blue
), 4);
5493 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
5496 #define X_GLrop_SecondaryColor3fvEXT 4129
5498 __indirect_glSecondaryColor3fvEXT(const GLfloat
* v
)
5500 generic_12_byte( X_GLrop_SecondaryColor3fvEXT
, v
);
5503 #define X_GLrop_SecondaryColor3ivEXT 4128
5505 __indirect_glSecondaryColor3iEXT(GLint red
, GLint green
, GLint blue
)
5507 __GLXcontext
* const gc
= __glXGetCurrentContext();
5508 const GLuint cmdlen
= 16;
5509 emit_header(gc
->pc
, X_GLrop_SecondaryColor3ivEXT
, cmdlen
);
5510 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&red
), 4);
5511 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(&green
), 4);
5512 (void) memcpy((void *)(gc
->pc
+ 12), (void *)(&blue
), 4);
5514 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
5517 #define X_GLrop_SecondaryColor3ivEXT 4128
5519 __indirect_glSecondaryColor3ivEXT(const GLint
* v
)
5521 generic_12_byte( X_GLrop_SecondaryColor3ivEXT
, v
);
5524 #define X_GLrop_SecondaryColor3svEXT 4128
5526 __indirect_glSecondaryColor3sEXT(GLshort red
, GLshort green
, GLshort blue
)
5528 __GLXcontext
* const gc
= __glXGetCurrentContext();
5529 const GLuint cmdlen
= 12;
5530 emit_header(gc
->pc
, X_GLrop_SecondaryColor3svEXT
, cmdlen
);
5531 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&red
), 2);
5532 (void) memcpy((void *)(gc
->pc
+ 6), (void *)(&green
), 2);
5533 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(&blue
), 2);
5535 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
5538 #define X_GLrop_SecondaryColor3svEXT 4128
5540 __indirect_glSecondaryColor3svEXT(const GLshort
* v
)
5542 generic_6_byte( X_GLrop_SecondaryColor3svEXT
, v
);
5545 #define X_GLrop_SecondaryColor3ubvEXT 4131
5547 __indirect_glSecondaryColor3ubEXT(GLubyte red
, GLubyte green
, GLubyte blue
)
5549 __GLXcontext
* const gc
= __glXGetCurrentContext();
5550 const GLuint cmdlen
= 8;
5551 emit_header(gc
->pc
, X_GLrop_SecondaryColor3ubvEXT
, cmdlen
);
5552 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&red
), 1);
5553 (void) memcpy((void *)(gc
->pc
+ 5), (void *)(&green
), 1);
5554 (void) memcpy((void *)(gc
->pc
+ 6), (void *)(&blue
), 1);
5556 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
5559 #define X_GLrop_SecondaryColor3ubvEXT 4131
5561 __indirect_glSecondaryColor3ubvEXT(const GLubyte
* v
)
5563 generic_3_byte( X_GLrop_SecondaryColor3ubvEXT
, v
);
5566 #define X_GLrop_SecondaryColor3uivEXT 4133
5568 __indirect_glSecondaryColor3uiEXT(GLuint red
, GLuint green
, GLuint blue
)
5570 __GLXcontext
* const gc
= __glXGetCurrentContext();
5571 const GLuint cmdlen
= 16;
5572 emit_header(gc
->pc
, X_GLrop_SecondaryColor3uivEXT
, cmdlen
);
5573 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&red
), 4);
5574 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(&green
), 4);
5575 (void) memcpy((void *)(gc
->pc
+ 12), (void *)(&blue
), 4);
5577 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
5580 #define X_GLrop_SecondaryColor3uivEXT 4133
5582 __indirect_glSecondaryColor3uivEXT(const GLuint
* v
)
5584 generic_12_byte( X_GLrop_SecondaryColor3uivEXT
, v
);
5587 #define X_GLrop_SecondaryColor3usvEXT 4132
5589 __indirect_glSecondaryColor3usEXT(GLushort red
, GLushort green
, GLushort blue
)
5591 __GLXcontext
* const gc
= __glXGetCurrentContext();
5592 const GLuint cmdlen
= 12;
5593 emit_header(gc
->pc
, X_GLrop_SecondaryColor3usvEXT
, cmdlen
);
5594 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&red
), 2);
5595 (void) memcpy((void *)(gc
->pc
+ 6), (void *)(&green
), 2);
5596 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(&blue
), 2);
5598 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
5601 #define X_GLrop_SecondaryColor3usvEXT 4132
5603 __indirect_glSecondaryColor3usvEXT(const GLushort
* v
)
5605 generic_6_byte( X_GLrop_SecondaryColor3usvEXT
, v
);
5608 #define X_GLrop_PointParameteriNV 4221
5610 __indirect_glPointParameteriNV(GLenum pname
, GLint params
)
5612 __GLXcontext
* const gc
= __glXGetCurrentContext();
5613 const GLuint cmdlen
= 12;
5614 emit_header(gc
->pc
, X_GLrop_PointParameteriNV
, cmdlen
);
5615 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&pname
), 4);
5616 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(¶ms
), 4);
5618 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
5621 #define X_GLrop_PointParameterivNV 4222
5623 __indirect_glPointParameterivNV(GLenum pname
, const GLint
* params
)
5625 __GLXcontext
* const gc
= __glXGetCurrentContext();
5626 const GLuint compsize
= __glPointParameterivNV_size(pname
);
5627 const GLuint cmdlen
= 8 + __GLX_PAD((compsize
* 4));
5628 emit_header(gc
->pc
, X_GLrop_PointParameterivNV
, cmdlen
);
5629 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&pname
), 4);
5630 (void) memcpy((void *)(gc
->pc
+ 8), (void *)(params
), (compsize
* 4));
5632 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }
5635 #define X_GLrop_ActiveStencilFaceEXT 4220
5637 __indirect_glActiveStencilFaceEXT(GLenum face
)
5639 __GLXcontext
* const gc
= __glXGetCurrentContext();
5640 const GLuint cmdlen
= 8;
5641 emit_header(gc
->pc
, X_GLrop_ActiveStencilFaceEXT
, cmdlen
);
5642 (void) memcpy((void *)(gc
->pc
+ 4), (void *)(&face
), 4);
5644 if (__builtin_expect(gc
->pc
> gc
->limit
, 0)) { (void) __glXFlushRenderBuffer(gc
, gc
->pc
); }