projects / mesa.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
Merge commit 'origin/master' into gallium-0.2
[mesa.git] / src / glx / x11 / indirect.c
1 /* DO NOT EDIT - This file generated automatically by glX_proto_send.py (from Mesa) script */
2
3 /*
4 * (C) Copyright IBM Corporation 2004, 2005
5 * All Rights Reserved.
6 *
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:
13 *
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
16 * Software.
17 *
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
21 * IBM,
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
25 * SOFTWARE.
26 */
27
28
29 #include <GL/gl.h>
30 #include "indirect.h"
31 #include "glxclient.h"
32 #include "indirect_size.h"
33 #include "dispatch.h"
34 #include "glapi.h"
35 #include "glthread.h"
36 #include <GL/glxproto.h>
37 #ifdef USE_XCB
38 #include <X11/Xlib-xcb.h>
39 #include <xcb/xcb.h>
40 #include <xcb/glx.h>
41 #endif /* USE_XCB */
42
43 #define __GLX_PAD(n) (((n) + 3) & ~3)
44
45 # if defined(__i386__) && defined(__GNUC__) && !defined(__CYGWIN__) && !defined(__MINGW32__)
46 # define FASTCALL __attribute__((fastcall))
47 # else
48 # define FASTCALL
49 # endif
50 # if defined(__GNUC__)
51 # define NOINLINE __attribute__((noinline))
52 # else
53 # define NOINLINE
54 # endif
55
56 #if !defined __GNUC__ || __GNUC__ < 3
57 # define __builtin_expect(x, y) x
58 #endif
59
60 /* If the size and opcode values are known at compile-time, this will, on
61 * x86 at least, emit them with a single instruction.
62 */
63 #define emit_header(dest, op, size) \
64 do { union { short s[2]; int i; } temp; \
65 temp.s[0] = (size); temp.s[1] = (op); \
66 *((int *)(dest)) = temp.i; } while(0)
67
68 NOINLINE CARD32
69 __glXReadReply(Display * dpy, size_t size, void *dest,
70 GLboolean reply_is_always_array)
71 {
72 xGLXSingleReply reply;
73
74 (void) _XReply(dpy, (xReply *) & reply, 0, False);
75 if (size != 0) {
76 if ((reply.length > 0) || reply_is_always_array) {
77 const GLint bytes = (reply_is_always_array)
78 ? (4 * reply.length) : (reply.size * size);
79 const GLint extra = 4 - (bytes & 3);
80
81 _XRead(dpy, dest, bytes);
82 if (extra < 4) {
83 _XEatData(dpy, extra);
84 }
85 } else {
86 (void) memcpy(dest, &(reply.pad3), size);
87 }
88 }
89
90 return reply.retval;
91 }
92
93 NOINLINE void
94 __glXReadPixelReply(Display * dpy, __GLXcontext * gc, unsigned max_dim,
95 GLint width, GLint height, GLint depth, GLenum format,
96 GLenum type, void *dest, GLboolean dimensions_in_reply)
97 {
98 xGLXSingleReply reply;
99 GLint size;
100
101 (void) _XReply(dpy, (xReply *) & reply, 0, False);
102
103 if (dimensions_in_reply) {
104 width = reply.pad3;
105 height = reply.pad4;
106 depth = reply.pad5;
107
108 if ((height == 0) || (max_dim < 2)) {
109 height = 1;
110 }
111 if ((depth == 0) || (max_dim < 3)) {
112 depth = 1;
113 }
114 }
115
116 size = reply.length * 4;
117 if (size != 0) {
118 void *buf = Xmalloc(size);
119
120 if (buf == NULL) {
121 _XEatData(dpy, size);
122 __glXSetError(gc, GL_OUT_OF_MEMORY);
123 } else {
124 const GLint extra = 4 - (size & 3);
125
126 _XRead(dpy, buf, size);
127 if (extra < 4) {
128 _XEatData(dpy, extra);
129 }
130
131 __glEmptyImage(gc, 3, width, height, depth, format, type,
132 buf, dest);
133 Xfree(buf);
134 }
135 }
136 }
137
138 #define X_GLXSingle 0
139
140 NOINLINE FASTCALL GLubyte *
141 __glXSetupSingleRequest(__GLXcontext * gc, GLint sop, GLint cmdlen)
142 {
143 xGLXSingleReq *req;
144 Display *const dpy = gc->currentDpy;
145
146 (void) __glXFlushRenderBuffer(gc, gc->pc);
147 LockDisplay(dpy);
148 GetReqExtra(GLXSingle, cmdlen, req);
149 req->reqType = gc->majorOpcode;
150 req->contextTag = gc->currentContextTag;
151 req->glxCode = sop;
152 return (GLubyte *) (req) + sz_xGLXSingleReq;
153 }
154
155 NOINLINE FASTCALL GLubyte *
156 __glXSetupVendorRequest(__GLXcontext * gc, GLint code, GLint vop,
157 GLint cmdlen)
158 {
159 xGLXVendorPrivateReq *req;
160 Display *const dpy = gc->currentDpy;
161
162 (void) __glXFlushRenderBuffer(gc, gc->pc);
163 LockDisplay(dpy);
164 GetReqExtra(GLXVendorPrivate, cmdlen, req);
165 req->reqType = gc->majorOpcode;
166 req->glxCode = code;
167 req->vendorCode = vop;
168 req->contextTag = gc->currentContextTag;
169 return (GLubyte *) (req) + sz_xGLXVendorPrivateReq;
170 }
171
172 const GLuint __glXDefaultPixelStore[9] = { 0, 0, 0, 0, 0, 0, 0, 0, 1 };
173
174 #define zero (__glXDefaultPixelStore+0)
175 #define one (__glXDefaultPixelStore+8)
176 #define default_pixel_store_1D (__glXDefaultPixelStore+4)
177 #define default_pixel_store_1D_size 20
178 #define default_pixel_store_2D (__glXDefaultPixelStore+4)
179 #define default_pixel_store_2D_size 20
180 #define default_pixel_store_3D (__glXDefaultPixelStore+0)
181 #define default_pixel_store_3D_size 36
182 #define default_pixel_store_4D (__glXDefaultPixelStore+0)
183 #define default_pixel_store_4D_size 36
184
185 static FASTCALL NOINLINE void
186 generic_3_byte(GLint rop, const void *ptr)
187 {
188 __GLXcontext *const gc = __glXGetCurrentContext();
189 const GLuint cmdlen = 8;
190
191 emit_header(gc->pc, rop, cmdlen);
192 (void) memcpy((void *) (gc->pc + 4), ptr, 4);
193 gc->pc += cmdlen;
194 if (__builtin_expect(gc->pc > gc->limit, 0)) {
195 (void) __glXFlushRenderBuffer(gc, gc->pc);
196 }
197 }
198
199 static FASTCALL NOINLINE void
200 generic_4_byte(GLint rop, const void *ptr)
201 {
202 __GLXcontext *const gc = __glXGetCurrentContext();
203 const GLuint cmdlen = 8;
204
205 emit_header(gc->pc, rop, cmdlen);
206 (void) memcpy((void *) (gc->pc + 4), ptr, 4);
207 gc->pc += cmdlen;
208 if (__builtin_expect(gc->pc > gc->limit, 0)) {
209 (void) __glXFlushRenderBuffer(gc, gc->pc);
210 }
211 }
212
213 static FASTCALL NOINLINE void
214 generic_6_byte(GLint rop, const void *ptr)
215 {
216 __GLXcontext *const gc = __glXGetCurrentContext();
217 const GLuint cmdlen = 12;
218
219 emit_header(gc->pc, rop, cmdlen);
220 (void) memcpy((void *) (gc->pc + 4), ptr, 8);
221 gc->pc += cmdlen;
222 if (__builtin_expect(gc->pc > gc->limit, 0)) {
223 (void) __glXFlushRenderBuffer(gc, gc->pc);
224 }
225 }
226
227 static FASTCALL NOINLINE void
228 generic_8_byte(GLint rop, const void *ptr)
229 {
230 __GLXcontext *const gc = __glXGetCurrentContext();
231 const GLuint cmdlen = 12;
232
233 emit_header(gc->pc, rop, cmdlen);
234 (void) memcpy((void *) (gc->pc + 4), ptr, 8);
235 gc->pc += cmdlen;
236 if (__builtin_expect(gc->pc > gc->limit, 0)) {
237 (void) __glXFlushRenderBuffer(gc, gc->pc);
238 }
239 }
240
241 static FASTCALL NOINLINE void
242 generic_12_byte(GLint rop, const void *ptr)
243 {
244 __GLXcontext *const gc = __glXGetCurrentContext();
245 const GLuint cmdlen = 16;
246
247 emit_header(gc->pc, rop, cmdlen);
248 (void) memcpy((void *) (gc->pc + 4), ptr, 12);
249 gc->pc += cmdlen;
250 if (__builtin_expect(gc->pc > gc->limit, 0)) {
251 (void) __glXFlushRenderBuffer(gc, gc->pc);
252 }
253 }
254
255 static FASTCALL NOINLINE void
256 generic_16_byte(GLint rop, const void *ptr)
257 {
258 __GLXcontext *const gc = __glXGetCurrentContext();
259 const GLuint cmdlen = 20;
260
261 emit_header(gc->pc, rop, cmdlen);
262 (void) memcpy((void *) (gc->pc + 4), ptr, 16);
263 gc->pc += cmdlen;
264 if (__builtin_expect(gc->pc > gc->limit, 0)) {
265 (void) __glXFlushRenderBuffer(gc, gc->pc);
266 }
267 }
268
269 static FASTCALL NOINLINE void
270 generic_24_byte(GLint rop, const void *ptr)
271 {
272 __GLXcontext *const gc = __glXGetCurrentContext();
273 const GLuint cmdlen = 28;
274
275 emit_header(gc->pc, rop, cmdlen);
276 (void) memcpy((void *) (gc->pc + 4), ptr, 24);
277 gc->pc += cmdlen;
278 if (__builtin_expect(gc->pc > gc->limit, 0)) {
279 (void) __glXFlushRenderBuffer(gc, gc->pc);
280 }
281 }
282
283 static FASTCALL NOINLINE void
284 generic_32_byte(GLint rop, const void *ptr)
285 {
286 __GLXcontext *const gc = __glXGetCurrentContext();
287 const GLuint cmdlen = 36;
288
289 emit_header(gc->pc, rop, cmdlen);
290 (void) memcpy((void *) (gc->pc + 4), ptr, 32);
291 gc->pc += cmdlen;
292 if (__builtin_expect(gc->pc > gc->limit, 0)) {
293 (void) __glXFlushRenderBuffer(gc, gc->pc);
294 }
295 }
296
297 #define X_GLsop_NewList 101
298 void
299 __indirect_glNewList(GLuint list, GLenum mode)
300 {
301 __GLXcontext *const gc = __glXGetCurrentContext();
302 Display *const dpy = gc->currentDpy;
303 #ifndef USE_XCB
304 const GLuint cmdlen = 8;
305 #endif
306 if (__builtin_expect(dpy != NULL, 1)) {
307 #ifdef USE_XCB
308 xcb_connection_t *c = XGetXCBConnection(dpy);
309 (void) __glXFlushRenderBuffer(gc, gc->pc);
310 xcb_glx_new_list(c, gc->currentContextTag, list, mode);
311 #else
312 GLubyte const *pc =
313 __glXSetupSingleRequest(gc, X_GLsop_NewList, cmdlen);
314 (void) memcpy((void *) (pc + 0), (void *) (&list), 4);
315 (void) memcpy((void *) (pc + 4), (void *) (&mode), 4);
316 UnlockDisplay(dpy);
317 SyncHandle();
318 #endif /* USE_XCB */
319 }
320 return;
321 }
322
323 #define X_GLsop_EndList 102
324 void
325 __indirect_glEndList(void)
326 {
327 __GLXcontext *const gc = __glXGetCurrentContext();
328 Display *const dpy = gc->currentDpy;
329 #ifndef USE_XCB
330 const GLuint cmdlen = 0;
331 #endif
332 if (__builtin_expect(dpy != NULL, 1)) {
333 #ifdef USE_XCB
334 xcb_connection_t *c = XGetXCBConnection(dpy);
335 (void) __glXFlushRenderBuffer(gc, gc->pc);
336 xcb_glx_end_list(c, gc->currentContextTag);
337 #else
338 (void) __glXSetupSingleRequest(gc, X_GLsop_EndList, cmdlen);
339 UnlockDisplay(dpy);
340 SyncHandle();
341 #endif /* USE_XCB */
342 }
343 return;
344 }
345
346 #define X_GLrop_CallList 1
347 void
348 __indirect_glCallList(GLuint list)
349 {
350 __GLXcontext *const gc = __glXGetCurrentContext();
351 const GLuint cmdlen = 8;
352 emit_header(gc->pc, X_GLrop_CallList, cmdlen);
353 (void) memcpy((void *) (gc->pc + 4), (void *) (&list), 4);
354 gc->pc += cmdlen;
355 if (__builtin_expect(gc->pc > gc->limit, 0)) {
356 (void) __glXFlushRenderBuffer(gc, gc->pc);
357 }
358 }
359
360 #define X_GLrop_CallLists 2
361 void
362 __indirect_glCallLists(GLsizei n, GLenum type, const GLvoid * lists)
363 {
364 __GLXcontext *const gc = __glXGetCurrentContext();
365 const GLuint compsize = __glCallLists_size(type);
366 const GLuint cmdlen = 12 + __GLX_PAD((compsize * n));
367 if (n < 0) {
368 __glXSetError(gc, GL_INVALID_VALUE);
369 return;
370 }
371 if (__builtin_expect((n >= 0) && (gc->currentDpy != NULL), 1)) {
372 if (cmdlen <= gc->maxSmallRenderCommandSize) {
373 if ((gc->pc + cmdlen) > gc->bufEnd) {
374 (void) __glXFlushRenderBuffer(gc, gc->pc);
375 }
376 emit_header(gc->pc, X_GLrop_CallLists, cmdlen);
377 (void) memcpy((void *) (gc->pc + 4), (void *) (&n), 4);
378 (void) memcpy((void *) (gc->pc + 8), (void *) (&type), 4);
379 (void) memcpy((void *) (gc->pc + 12), (void *) (lists),
380 (compsize * n));
381 gc->pc += cmdlen;
382 if (__builtin_expect(gc->pc > gc->limit, 0)) {
383 (void) __glXFlushRenderBuffer(gc, gc->pc);
384 }
385 } else {
386 const GLint op = X_GLrop_CallLists;
387 const GLuint cmdlenLarge = cmdlen + 4;
388 GLubyte *const pc = __glXFlushRenderBuffer(gc, gc->pc);
389 (void) memcpy((void *) (pc + 0), (void *) (&cmdlenLarge), 4);
390 (void) memcpy((void *) (pc + 4), (void *) (&op), 4);
391 (void) memcpy((void *) (pc + 8), (void *) (&n), 4);
392 (void) memcpy((void *) (pc + 12), (void *) (&type), 4);
393 __glXSendLargeCommand(gc, pc, 16, lists, (compsize * n));
394 }
395 }
396 }
397
398 #define X_GLsop_DeleteLists 103
399 void
400 __indirect_glDeleteLists(GLuint list, GLsizei range)
401 {
402 __GLXcontext *const gc = __glXGetCurrentContext();
403 Display *const dpy = gc->currentDpy;
404 #ifndef USE_XCB
405 const GLuint cmdlen = 8;
406 #endif
407 if (__builtin_expect(dpy != NULL, 1)) {
408 #ifdef USE_XCB
409 xcb_connection_t *c = XGetXCBConnection(dpy);
410 (void) __glXFlushRenderBuffer(gc, gc->pc);
411 xcb_glx_delete_lists(c, gc->currentContextTag, list, range);
412 #else
413 GLubyte const *pc =
414 __glXSetupSingleRequest(gc, X_GLsop_DeleteLists, cmdlen);
415 (void) memcpy((void *) (pc + 0), (void *) (&list), 4);
416 (void) memcpy((void *) (pc + 4), (void *) (&range), 4);
417 UnlockDisplay(dpy);
418 SyncHandle();
419 #endif /* USE_XCB */
420 }
421 return;
422 }
423
424 #define X_GLsop_GenLists 104
425 GLuint
426 __indirect_glGenLists(GLsizei range)
427 {
428 __GLXcontext *const gc = __glXGetCurrentContext();
429 Display *const dpy = gc->currentDpy;
430 GLuint retval = (GLuint) 0;
431 #ifndef USE_XCB
432 const GLuint cmdlen = 4;
433 #endif
434 if (__builtin_expect(dpy != NULL, 1)) {
435 #ifdef USE_XCB
436 xcb_connection_t *c = XGetXCBConnection(dpy);
437 (void) __glXFlushRenderBuffer(gc, gc->pc);
438 xcb_glx_gen_lists_reply_t *reply =
439 xcb_glx_gen_lists_reply(c,
440 xcb_glx_gen_lists(c,
441 gc->currentContextTag,
442 range), NULL);
443 retval = reply->ret_val;
444 free(reply);
445 #else
446 GLubyte const *pc =
447 __glXSetupSingleRequest(gc, X_GLsop_GenLists, cmdlen);
448 (void) memcpy((void *) (pc + 0), (void *) (&range), 4);
449 retval = (GLuint) __glXReadReply(dpy, 0, NULL, GL_FALSE);
450 UnlockDisplay(dpy);
451 SyncHandle();
452 #endif /* USE_XCB */
453 }
454 return retval;
455 }
456
457 #define X_GLrop_ListBase 3
458 void
459 __indirect_glListBase(GLuint base)
460 {
461 __GLXcontext *const gc = __glXGetCurrentContext();
462 const GLuint cmdlen = 8;
463 emit_header(gc->pc, X_GLrop_ListBase, cmdlen);
464 (void) memcpy((void *) (gc->pc + 4), (void *) (&base), 4);
465 gc->pc += cmdlen;
466 if (__builtin_expect(gc->pc > gc->limit, 0)) {
467 (void) __glXFlushRenderBuffer(gc, gc->pc);
468 }
469 }
470
471 #define X_GLrop_Begin 4
472 void
473 __indirect_glBegin(GLenum mode)
474 {
475 __GLXcontext *const gc = __glXGetCurrentContext();
476 const GLuint cmdlen = 8;
477 emit_header(gc->pc, X_GLrop_Begin, cmdlen);
478 (void) memcpy((void *) (gc->pc + 4), (void *) (&mode), 4);
479 gc->pc += cmdlen;
480 if (__builtin_expect(gc->pc > gc->limit, 0)) {
481 (void) __glXFlushRenderBuffer(gc, gc->pc);
482 }
483 }
484
485 #define X_GLrop_Bitmap 5
486 void
487 __indirect_glBitmap(GLsizei width, GLsizei height, GLfloat xorig,
488 GLfloat yorig, GLfloat xmove, GLfloat ymove,
489 const GLubyte *bitmap)
490 {
491 __GLXcontext *const gc = __glXGetCurrentContext();
492 const GLuint compsize =
493 (bitmap != NULL) ? __glImageSize(width, height, 1, GL_COLOR_INDEX,
494 GL_BITMAP, 0) : 0;
495 const GLuint cmdlen = 48 + __GLX_PAD(compsize);
496 if (__builtin_expect(gc->currentDpy != NULL, 1)) {
497 if (cmdlen <= gc->maxSmallRenderCommandSize) {
498 if ((gc->pc + cmdlen) > gc->bufEnd) {
499 (void) __glXFlushRenderBuffer(gc, gc->pc);
500 }
501 emit_header(gc->pc, X_GLrop_Bitmap, cmdlen);
502 (void) memcpy((void *) (gc->pc + 24), (void *) (&width), 4);
503 (void) memcpy((void *) (gc->pc + 28), (void *) (&height), 4);
504 (void) memcpy((void *) (gc->pc + 32), (void *) (&xorig), 4);
505 (void) memcpy((void *) (gc->pc + 36), (void *) (&yorig), 4);
506 (void) memcpy((void *) (gc->pc + 40), (void *) (&xmove), 4);
507 (void) memcpy((void *) (gc->pc + 44), (void *) (&ymove), 4);
508 if (compsize > 0) {
509 (*gc->fillImage) (gc, 2, width, height, 1, GL_COLOR_INDEX,
510 GL_BITMAP, bitmap, gc->pc + 48, gc->pc + 4);
511 } else {
512 (void) memcpy(gc->pc + 4, default_pixel_store_2D,
513 default_pixel_store_2D_size);
514 }
515 gc->pc += cmdlen;
516 if (gc->pc > gc->limit) {
517 (void) __glXFlushRenderBuffer(gc, gc->pc);
518 }
519 } else {
520 const GLint op = X_GLrop_Bitmap;
521 const GLuint cmdlenLarge = cmdlen + 4;
522 GLubyte *const pc = __glXFlushRenderBuffer(gc, gc->pc);
523 (void) memcpy((void *) (pc + 0), (void *) (&cmdlenLarge), 4);
524 (void) memcpy((void *) (pc + 4), (void *) (&op), 4);
525 (void) memcpy((void *) (pc + 28), (void *) (&width), 4);
526 (void) memcpy((void *) (pc + 32), (void *) (&height), 4);
527 (void) memcpy((void *) (pc + 36), (void *) (&xorig), 4);
528 (void) memcpy((void *) (pc + 40), (void *) (&yorig), 4);
529 (void) memcpy((void *) (pc + 44), (void *) (&xmove), 4);
530 (void) memcpy((void *) (pc + 48), (void *) (&ymove), 4);
531 __glXSendLargeImage(gc, compsize, 2, width, height, 1,
532 GL_COLOR_INDEX, GL_BITMAP, bitmap, pc + 52,
533 pc + 8);
534 }
535 }
536 }
537
538 #define X_GLrop_Color3bv 6
539 void
540 __indirect_glColor3b(GLbyte red, GLbyte green, GLbyte blue)
541 {
542 __GLXcontext *const gc = __glXGetCurrentContext();
543 const GLuint cmdlen = 8;
544 emit_header(gc->pc, X_GLrop_Color3bv, cmdlen);
545 (void) memcpy((void *) (gc->pc + 4), (void *) (&red), 1);
546 (void) memcpy((void *) (gc->pc + 5), (void *) (&green), 1);
547 (void) memcpy((void *) (gc->pc + 6), (void *) (&blue), 1);
548 gc->pc += cmdlen;
549 if (__builtin_expect(gc->pc > gc->limit, 0)) {
550 (void) __glXFlushRenderBuffer(gc, gc->pc);
551 }
552 }
553
554 #define X_GLrop_Color3bv 6
555 void
556 __indirect_glColor3bv(const GLbyte *v)
557 {
558 generic_3_byte(X_GLrop_Color3bv, v);
559 }
560
561 #define X_GLrop_Color3dv 7
562 void
563 __indirect_glColor3d(GLdouble red, GLdouble green, GLdouble blue)
564 {
565 __GLXcontext *const gc = __glXGetCurrentContext();
566 const GLuint cmdlen = 28;
567 emit_header(gc->pc, X_GLrop_Color3dv, cmdlen);
568 (void) memcpy((void *) (gc->pc + 4), (void *) (&red), 8);
569 (void) memcpy((void *) (gc->pc + 12), (void *) (&green), 8);
570 (void) memcpy((void *) (gc->pc + 20), (void *) (&blue), 8);
571 gc->pc += cmdlen;
572 if (__builtin_expect(gc->pc > gc->limit, 0)) {
573 (void) __glXFlushRenderBuffer(gc, gc->pc);
574 }
575 }
576
577 #define X_GLrop_Color3dv 7
578 void
579 __indirect_glColor3dv(const GLdouble * v)
580 {
581 generic_24_byte(X_GLrop_Color3dv, v);
582 }
583
584 #define X_GLrop_Color3fv 8
585 void
586 __indirect_glColor3f(GLfloat red, GLfloat green, GLfloat blue)
587 {
588 __GLXcontext *const gc = __glXGetCurrentContext();
589 const GLuint cmdlen = 16;
590 emit_header(gc->pc, X_GLrop_Color3fv, cmdlen);
591 (void) memcpy((void *) (gc->pc + 4), (void *) (&red), 4);
592 (void) memcpy((void *) (gc->pc + 8), (void *) (&green), 4);
593 (void) memcpy((void *) (gc->pc + 12), (void *) (&blue), 4);
594 gc->pc += cmdlen;
595 if (__builtin_expect(gc->pc > gc->limit, 0)) {
596 (void) __glXFlushRenderBuffer(gc, gc->pc);
597 }
598 }
599
600 #define X_GLrop_Color3fv 8
601 void
602 __indirect_glColor3fv(const GLfloat * v)
603 {
604 generic_12_byte(X_GLrop_Color3fv, v);
605 }
606
607 #define X_GLrop_Color3iv 9
608 void
609 __indirect_glColor3i(GLint red, GLint green, GLint blue)
610 {
611 __GLXcontext *const gc = __glXGetCurrentContext();
612 const GLuint cmdlen = 16;
613 emit_header(gc->pc, X_GLrop_Color3iv, cmdlen);
614 (void) memcpy((void *) (gc->pc + 4), (void *) (&red), 4);
615 (void) memcpy((void *) (gc->pc + 8), (void *) (&green), 4);
616 (void) memcpy((void *) (gc->pc + 12), (void *) (&blue), 4);
617 gc->pc += cmdlen;
618 if (__builtin_expect(gc->pc > gc->limit, 0)) {
619 (void) __glXFlushRenderBuffer(gc, gc->pc);
620 }
621 }
622
623 #define X_GLrop_Color3iv 9
624 void
625 __indirect_glColor3iv(const GLint * v)
626 {
627 generic_12_byte(X_GLrop_Color3iv, v);
628 }
629
630 #define X_GLrop_Color3sv 10
631 void
632 __indirect_glColor3s(GLshort red, GLshort green, GLshort blue)
633 {
634 __GLXcontext *const gc = __glXGetCurrentContext();
635 const GLuint cmdlen = 12;
636 emit_header(gc->pc, X_GLrop_Color3sv, cmdlen);
637 (void) memcpy((void *) (gc->pc + 4), (void *) (&red), 2);
638 (void) memcpy((void *) (gc->pc + 6), (void *) (&green), 2);
639 (void) memcpy((void *) (gc->pc + 8), (void *) (&blue), 2);
640 gc->pc += cmdlen;
641 if (__builtin_expect(gc->pc > gc->limit, 0)) {
642 (void) __glXFlushRenderBuffer(gc, gc->pc);
643 }
644 }
645
646 #define X_GLrop_Color3sv 10
647 void
648 __indirect_glColor3sv(const GLshort * v)
649 {
650 generic_6_byte(X_GLrop_Color3sv, v);
651 }
652
653 #define X_GLrop_Color3ubv 11
654 void
655 __indirect_glColor3ub(GLubyte red, GLubyte green, GLubyte blue)
656 {
657 __GLXcontext *const gc = __glXGetCurrentContext();
658 const GLuint cmdlen = 8;
659 emit_header(gc->pc, X_GLrop_Color3ubv, cmdlen);
660 (void) memcpy((void *) (gc->pc + 4), (void *) (&red), 1);
661 (void) memcpy((void *) (gc->pc + 5), (void *) (&green), 1);
662 (void) memcpy((void *) (gc->pc + 6), (void *) (&blue), 1);
663 gc->pc += cmdlen;
664 if (__builtin_expect(gc->pc > gc->limit, 0)) {
665 (void) __glXFlushRenderBuffer(gc, gc->pc);
666 }
667 }
668
669 #define X_GLrop_Color3ubv 11
670 void
671 __indirect_glColor3ubv(const GLubyte *v)
672 {
673 generic_3_byte(X_GLrop_Color3ubv, v);
674 }
675
676 #define X_GLrop_Color3uiv 12
677 void
678 __indirect_glColor3ui(GLuint red, GLuint green, GLuint blue)
679 {
680 __GLXcontext *const gc = __glXGetCurrentContext();
681 const GLuint cmdlen = 16;
682 emit_header(gc->pc, X_GLrop_Color3uiv, cmdlen);
683 (void) memcpy((void *) (gc->pc + 4), (void *) (&red), 4);
684 (void) memcpy((void *) (gc->pc + 8), (void *) (&green), 4);
685 (void) memcpy((void *) (gc->pc + 12), (void *) (&blue), 4);
686 gc->pc += cmdlen;
687 if (__builtin_expect(gc->pc > gc->limit, 0)) {
688 (void) __glXFlushRenderBuffer(gc, gc->pc);
689 }
690 }
691
692 #define X_GLrop_Color3uiv 12
693 void
694 __indirect_glColor3uiv(const GLuint * v)
695 {
696 generic_12_byte(X_GLrop_Color3uiv, v);
697 }
698
699 #define X_GLrop_Color3usv 13
700 void
701 __indirect_glColor3us(GLushort red, GLushort green, GLushort blue)
702 {
703 __GLXcontext *const gc = __glXGetCurrentContext();
704 const GLuint cmdlen = 12;
705 emit_header(gc->pc, X_GLrop_Color3usv, cmdlen);
706 (void) memcpy((void *) (gc->pc + 4), (void *) (&red), 2);
707 (void) memcpy((void *) (gc->pc + 6), (void *) (&green), 2);
708 (void) memcpy((void *) (gc->pc + 8), (void *) (&blue), 2);
709 gc->pc += cmdlen;
710 if (__builtin_expect(gc->pc > gc->limit, 0)) {
711 (void) __glXFlushRenderBuffer(gc, gc->pc);
712 }
713 }
714
715 #define X_GLrop_Color3usv 13
716 void
717 __indirect_glColor3usv(const GLushort * v)
718 {
719 generic_6_byte(X_GLrop_Color3usv, v);
720 }
721
722 #define X_GLrop_Color4bv 14
723 void
724 __indirect_glColor4b(GLbyte red, GLbyte green, GLbyte blue, GLbyte alpha)
725 {
726 __GLXcontext *const gc = __glXGetCurrentContext();
727 const GLuint cmdlen = 8;
728 emit_header(gc->pc, X_GLrop_Color4bv, cmdlen);
729 (void) memcpy((void *) (gc->pc + 4), (void *) (&red), 1);
730 (void) memcpy((void *) (gc->pc + 5), (void *) (&green), 1);
731 (void) memcpy((void *) (gc->pc + 6), (void *) (&blue), 1);
732 (void) memcpy((void *) (gc->pc + 7), (void *) (&alpha), 1);
733 gc->pc += cmdlen;
734 if (__builtin_expect(gc->pc > gc->limit, 0)) {
735 (void) __glXFlushRenderBuffer(gc, gc->pc);
736 }
737 }
738
739 #define X_GLrop_Color4bv 14
740 void
741 __indirect_glColor4bv(const GLbyte *v)
742 {
743 generic_4_byte(X_GLrop_Color4bv, v);
744 }
745
746 #define X_GLrop_Color4dv 15
747 void
748 __indirect_glColor4d(GLdouble red, GLdouble green, GLdouble blue,
749 GLdouble alpha)
750 {
751 __GLXcontext *const gc = __glXGetCurrentContext();
752 const GLuint cmdlen = 36;
753 emit_header(gc->pc, X_GLrop_Color4dv, cmdlen);
754 (void) memcpy((void *) (gc->pc + 4), (void *) (&red), 8);
755 (void) memcpy((void *) (gc->pc + 12), (void *) (&green), 8);
756 (void) memcpy((void *) (gc->pc + 20), (void *) (&blue), 8);
757 (void) memcpy((void *) (gc->pc + 28), (void *) (&alpha), 8);
758 gc->pc += cmdlen;
759 if (__builtin_expect(gc->pc > gc->limit, 0)) {
760 (void) __glXFlushRenderBuffer(gc, gc->pc);
761 }
762 }
763
764 #define X_GLrop_Color4dv 15
765 void
766 __indirect_glColor4dv(const GLdouble * v)
767 {
768 generic_32_byte(X_GLrop_Color4dv, v);
769 }
770
771 #define X_GLrop_Color4fv 16
772 void
773 __indirect_glColor4f(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)
774 {
775 __GLXcontext *const gc = __glXGetCurrentContext();
776 const GLuint cmdlen = 20;
777 emit_header(gc->pc, X_GLrop_Color4fv, cmdlen);
778 (void) memcpy((void *) (gc->pc + 4), (void *) (&red), 4);
779 (void) memcpy((void *) (gc->pc + 8), (void *) (&green), 4);
780 (void) memcpy((void *) (gc->pc + 12), (void *) (&blue), 4);
781 (void) memcpy((void *) (gc->pc + 16), (void *) (&alpha), 4);
782 gc->pc += cmdlen;
783 if (__builtin_expect(gc->pc > gc->limit, 0)) {
784 (void) __glXFlushRenderBuffer(gc, gc->pc);
785 }
786 }
787
788 #define X_GLrop_Color4fv 16
789 void
790 __indirect_glColor4fv(const GLfloat * v)
791 {
792 generic_16_byte(X_GLrop_Color4fv, v);
793 }
794
795 #define X_GLrop_Color4iv 17
796 void
797 __indirect_glColor4i(GLint red, GLint green, GLint blue, GLint alpha)
798 {
799 __GLXcontext *const gc = __glXGetCurrentContext();
800 const GLuint cmdlen = 20;
801 emit_header(gc->pc, X_GLrop_Color4iv, cmdlen);
802 (void) memcpy((void *) (gc->pc + 4), (void *) (&red), 4);
803 (void) memcpy((void *) (gc->pc + 8), (void *) (&green), 4);
804 (void) memcpy((void *) (gc->pc + 12), (void *) (&blue), 4);
805 (void) memcpy((void *) (gc->pc + 16), (void *) (&alpha), 4);
806 gc->pc += cmdlen;
807 if (__builtin_expect(gc->pc > gc->limit, 0)) {
808 (void) __glXFlushRenderBuffer(gc, gc->pc);
809 }
810 }
811
812 #define X_GLrop_Color4iv 17
813 void
814 __indirect_glColor4iv(const GLint * v)
815 {
816 generic_16_byte(X_GLrop_Color4iv, v);
817 }
818
819 #define X_GLrop_Color4sv 18
820 void
821 __indirect_glColor4s(GLshort red, GLshort green, GLshort blue, GLshort alpha)
822 {
823 __GLXcontext *const gc = __glXGetCurrentContext();
824 const GLuint cmdlen = 12;
825 emit_header(gc->pc, X_GLrop_Color4sv, cmdlen);
826 (void) memcpy((void *) (gc->pc + 4), (void *) (&red), 2);
827 (void) memcpy((void *) (gc->pc + 6), (void *) (&green), 2);
828 (void) memcpy((void *) (gc->pc + 8), (void *) (&blue), 2);
829 (void) memcpy((void *) (gc->pc + 10), (void *) (&alpha), 2);
830 gc->pc += cmdlen;
831 if (__builtin_expect(gc->pc > gc->limit, 0)) {
832 (void) __glXFlushRenderBuffer(gc, gc->pc);
833 }
834 }
835
836 #define X_GLrop_Color4sv 18
837 void
838 __indirect_glColor4sv(const GLshort * v)
839 {
840 generic_8_byte(X_GLrop_Color4sv, v);
841 }
842
843 #define X_GLrop_Color4ubv 19
844 void
845 __indirect_glColor4ub(GLubyte red, GLubyte green, GLubyte blue, GLubyte alpha)
846 {
847 __GLXcontext *const gc = __glXGetCurrentContext();
848 const GLuint cmdlen = 8;
849 emit_header(gc->pc, X_GLrop_Color4ubv, cmdlen);
850 (void) memcpy((void *) (gc->pc + 4), (void *) (&red), 1);
851 (void) memcpy((void *) (gc->pc + 5), (void *) (&green), 1);
852 (void) memcpy((void *) (gc->pc + 6), (void *) (&blue), 1);
853 (void) memcpy((void *) (gc->pc + 7), (void *) (&alpha), 1);
854 gc->pc += cmdlen;
855 if (__builtin_expect(gc->pc > gc->limit, 0)) {
856 (void) __glXFlushRenderBuffer(gc, gc->pc);
857 }
858 }
859
860 #define X_GLrop_Color4ubv 19
861 void
862 __indirect_glColor4ubv(const GLubyte *v)
863 {
864 generic_4_byte(X_GLrop_Color4ubv, v);
865 }
866
867 #define X_GLrop_Color4uiv 20
868 void
869 __indirect_glColor4ui(GLuint red, GLuint green, GLuint blue, GLuint alpha)
870 {
871 __GLXcontext *const gc = __glXGetCurrentContext();
872 const GLuint cmdlen = 20;
873 emit_header(gc->pc, X_GLrop_Color4uiv, cmdlen);
874 (void) memcpy((void *) (gc->pc + 4), (void *) (&red), 4);
875 (void) memcpy((void *) (gc->pc + 8), (void *) (&green), 4);
876 (void) memcpy((void *) (gc->pc + 12), (void *) (&blue), 4);
877 (void) memcpy((void *) (gc->pc + 16), (void *) (&alpha), 4);
878 gc->pc += cmdlen;
879 if (__builtin_expect(gc->pc > gc->limit, 0)) {
880 (void) __glXFlushRenderBuffer(gc, gc->pc);
881 }
882 }
883
884 #define X_GLrop_Color4uiv 20
885 void
886 __indirect_glColor4uiv(const GLuint * v)
887 {
888 generic_16_byte(X_GLrop_Color4uiv, v);
889 }
890
891 #define X_GLrop_Color4usv 21
892 void
893 __indirect_glColor4us(GLushort red, GLushort green, GLushort blue,
894 GLushort alpha)
895 {
896 __GLXcontext *const gc = __glXGetCurrentContext();
897 const GLuint cmdlen = 12;
898 emit_header(gc->pc, X_GLrop_Color4usv, cmdlen);
899 (void) memcpy((void *) (gc->pc + 4), (void *) (&red), 2);
900 (void) memcpy((void *) (gc->pc + 6), (void *) (&green), 2);
901 (void) memcpy((void *) (gc->pc + 8), (void *) (&blue), 2);
902 (void) memcpy((void *) (gc->pc + 10), (void *) (&alpha), 2);
903 gc->pc += cmdlen;
904 if (__builtin_expect(gc->pc > gc->limit, 0)) {
905 (void) __glXFlushRenderBuffer(gc, gc->pc);
906 }
907 }
908
909 #define X_GLrop_Color4usv 21
910 void
911 __indirect_glColor4usv(const GLushort * v)
912 {
913 generic_8_byte(X_GLrop_Color4usv, v);
914 }
915
916 #define X_GLrop_EdgeFlagv 22
917 void
918 __indirect_glEdgeFlag(GLboolean flag)
919 {
920 __GLXcontext *const gc = __glXGetCurrentContext();
921 const GLuint cmdlen = 8;
922 emit_header(gc->pc, X_GLrop_EdgeFlagv, cmdlen);
923 (void) memcpy((void *) (gc->pc + 4), (void *) (&flag), 1);
924 gc->pc += cmdlen;
925 if (__builtin_expect(gc->pc > gc->limit, 0)) {
926 (void) __glXFlushRenderBuffer(gc, gc->pc);
927 }
928 }
929
930 #define X_GLrop_EdgeFlagv 22
931 void
932 __indirect_glEdgeFlagv(const GLboolean * flag)
933 {
934 __GLXcontext *const gc = __glXGetCurrentContext();
935 const GLuint cmdlen = 8;
936 emit_header(gc->pc, X_GLrop_EdgeFlagv, cmdlen);
937 (void) memcpy((void *) (gc->pc + 4), (void *) (flag), 1);
938 gc->pc += cmdlen;
939 if (__builtin_expect(gc->pc > gc->limit, 0)) {
940 (void) __glXFlushRenderBuffer(gc, gc->pc);
941 }
942 }
943
944 #define X_GLrop_End 23
945 void
946 __indirect_glEnd(void)
947 {
948 __GLXcontext *const gc = __glXGetCurrentContext();
949 const GLuint cmdlen = 4;
950 emit_header(gc->pc, X_GLrop_End, cmdlen);
951 gc->pc += cmdlen;
952 if (__builtin_expect(gc->pc > gc->limit, 0)) {
953 (void) __glXFlushRenderBuffer(gc, gc->pc);
954 }
955 }
956
957 #define X_GLrop_Indexdv 24
958 void
959 __indirect_glIndexd(GLdouble c)
960 {
961 __GLXcontext *const gc = __glXGetCurrentContext();
962 const GLuint cmdlen = 12;
963 emit_header(gc->pc, X_GLrop_Indexdv, cmdlen);
964 (void) memcpy((void *) (gc->pc + 4), (void *) (&c), 8);
965 gc->pc += cmdlen;
966 if (__builtin_expect(gc->pc > gc->limit, 0)) {
967 (void) __glXFlushRenderBuffer(gc, gc->pc);
968 }
969 }
970
971 #define X_GLrop_Indexdv 24
972 void
973 __indirect_glIndexdv(const GLdouble * c)
974 {
975 generic_8_byte(X_GLrop_Indexdv, c);
976 }
977
978 #define X_GLrop_Indexfv 25
979 void
980 __indirect_glIndexf(GLfloat c)
981 {
982 __GLXcontext *const gc = __glXGetCurrentContext();
983 const GLuint cmdlen = 8;
984 emit_header(gc->pc, X_GLrop_Indexfv, cmdlen);
985 (void) memcpy((void *) (gc->pc + 4), (void *) (&c), 4);
986 gc->pc += cmdlen;
987 if (__builtin_expect(gc->pc > gc->limit, 0)) {
988 (void) __glXFlushRenderBuffer(gc, gc->pc);
989 }
990 }
991
992 #define X_GLrop_Indexfv 25
993 void
994 __indirect_glIndexfv(const GLfloat * c)
995 {
996 generic_4_byte(X_GLrop_Indexfv, c);
997 }
998
999 #define X_GLrop_Indexiv 26
1000 void
1001 __indirect_glIndexi(GLint c)
1002 {
1003 __GLXcontext *const gc = __glXGetCurrentContext();
1004 const GLuint cmdlen = 8;
1005 emit_header(gc->pc, X_GLrop_Indexiv, cmdlen);
1006 (void) memcpy((void *) (gc->pc + 4), (void *) (&c), 4);
1007 gc->pc += cmdlen;
1008 if (__builtin_expect(gc->pc > gc->limit, 0)) {
1009 (void) __glXFlushRenderBuffer(gc, gc->pc);
1010 }
1011 }
1012
1013 #define X_GLrop_Indexiv 26
1014 void
1015 __indirect_glIndexiv(const GLint * c)
1016 {
1017 generic_4_byte(X_GLrop_Indexiv, c);
1018 }
1019
1020 #define X_GLrop_Indexsv 27
1021 void
1022 __indirect_glIndexs(GLshort c)
1023 {
1024 __GLXcontext *const gc = __glXGetCurrentContext();
1025 const GLuint cmdlen = 8;
1026 emit_header(gc->pc, X_GLrop_Indexsv, cmdlen);
1027 (void) memcpy((void *) (gc->pc + 4), (void *) (&c), 2);
1028 gc->pc += cmdlen;
1029 if (__builtin_expect(gc->pc > gc->limit, 0)) {
1030 (void) __glXFlushRenderBuffer(gc, gc->pc);
1031 }
1032 }
1033
1034 #define X_GLrop_Indexsv 27
1035 void
1036 __indirect_glIndexsv(const GLshort * c)
1037 {
1038 __GLXcontext *const gc = __glXGetCurrentContext();
1039 const GLuint cmdlen = 8;
1040 emit_header(gc->pc, X_GLrop_Indexsv, cmdlen);
1041 (void) memcpy((void *) (gc->pc + 4), (void *) (c), 2);
1042 gc->pc += cmdlen;
1043 if (__builtin_expect(gc->pc > gc->limit, 0)) {
1044 (void) __glXFlushRenderBuffer(gc, gc->pc);
1045 }
1046 }
1047
1048 #define X_GLrop_Normal3bv 28
1049 void
1050 __indirect_glNormal3b(GLbyte nx, GLbyte ny, GLbyte nz)
1051 {
1052 __GLXcontext *const gc = __glXGetCurrentContext();
1053 const GLuint cmdlen = 8;
1054 emit_header(gc->pc, X_GLrop_Normal3bv, cmdlen);
1055 (void) memcpy((void *) (gc->pc + 4), (void *) (&nx), 1);
1056 (void) memcpy((void *) (gc->pc + 5), (void *) (&ny), 1);
1057 (void) memcpy((void *) (gc->pc + 6), (void *) (&nz), 1);
1058 gc->pc += cmdlen;
1059 if (__builtin_expect(gc->pc > gc->limit, 0)) {
1060 (void) __glXFlushRenderBuffer(gc, gc->pc);
1061 }
1062 }
1063
1064 #define X_GLrop_Normal3bv 28
1065 void
1066 __indirect_glNormal3bv(const GLbyte *v)
1067 {
1068 generic_3_byte(X_GLrop_Normal3bv, v);
1069 }
1070
1071 #define X_GLrop_Normal3dv 29
1072 void
1073 __indirect_glNormal3d(GLdouble nx, GLdouble ny, GLdouble nz)
1074 {
1075 __GLXcontext *const gc = __glXGetCurrentContext();
1076 const GLuint cmdlen = 28;
1077 emit_header(gc->pc, X_GLrop_Normal3dv, cmdlen);
1078 (void) memcpy((void *) (gc->pc + 4), (void *) (&nx), 8);
1079 (void) memcpy((void *) (gc->pc + 12), (void *) (&ny), 8);
1080 (void) memcpy((void *) (gc->pc + 20), (void *) (&nz), 8);
1081 gc->pc += cmdlen;
1082 if (__builtin_expect(gc->pc > gc->limit, 0)) {
1083 (void) __glXFlushRenderBuffer(gc, gc->pc);
1084 }
1085 }
1086
1087 #define X_GLrop_Normal3dv 29
1088 void
1089 __indirect_glNormal3dv(const GLdouble * v)
1090 {
1091 generic_24_byte(X_GLrop_Normal3dv, v);
1092 }
1093
1094 #define X_GLrop_Normal3fv 30
1095 void
1096 __indirect_glNormal3f(GLfloat nx, GLfloat ny, GLfloat nz)
1097 {
1098 __GLXcontext *const gc = __glXGetCurrentContext();
1099 const GLuint cmdlen = 16;
1100 emit_header(gc->pc, X_GLrop_Normal3fv, cmdlen);
1101 (void) memcpy((void *) (gc->pc + 4), (void *) (&nx), 4);
1102 (void) memcpy((void *) (gc->pc + 8), (void *) (&ny), 4);
1103 (void) memcpy((void *) (gc->pc + 12), (void *) (&nz), 4);
1104 gc->pc += cmdlen;
1105 if (__builtin_expect(gc->pc > gc->limit, 0)) {
1106 (void) __glXFlushRenderBuffer(gc, gc->pc);
1107 }
1108 }
1109
1110 #define X_GLrop_Normal3fv 30
1111 void
1112 __indirect_glNormal3fv(const GLfloat * v)
1113 {
1114 generic_12_byte(X_GLrop_Normal3fv, v);
1115 }
1116
1117 #define X_GLrop_Normal3iv 31
1118 void
1119 __indirect_glNormal3i(GLint nx, GLint ny, GLint nz)
1120 {
1121 __GLXcontext *const gc = __glXGetCurrentContext();
1122 const GLuint cmdlen = 16;
1123 emit_header(gc->pc, X_GLrop_Normal3iv, cmdlen);
1124 (void) memcpy((void *) (gc->pc + 4), (void *) (&nx), 4);
1125 (void) memcpy((void *) (gc->pc + 8), (void *) (&ny), 4);
1126 (void) memcpy((void *) (gc->pc + 12), (void *) (&nz), 4);
1127 gc->pc += cmdlen;
1128 if (__builtin_expect(gc->pc > gc->limit, 0)) {
1129 (void) __glXFlushRenderBuffer(gc, gc->pc);
1130 }
1131 }
1132
1133 #define X_GLrop_Normal3iv 31
1134 void
1135 __indirect_glNormal3iv(const GLint * v)
1136 {
1137 generic_12_byte(X_GLrop_Normal3iv, v);
1138 }
1139
1140 #define X_GLrop_Normal3sv 32
1141 void
1142 __indirect_glNormal3s(GLshort nx, GLshort ny, GLshort nz)
1143 {
1144 __GLXcontext *const gc = __glXGetCurrentContext();
1145 const GLuint cmdlen = 12;
1146 emit_header(gc->pc, X_GLrop_Normal3sv, cmdlen);
1147 (void) memcpy((void *) (gc->pc + 4), (void *) (&nx), 2);
1148 (void) memcpy((void *) (gc->pc + 6), (void *) (&ny), 2);
1149 (void) memcpy((void *) (gc->pc + 8), (void *) (&nz), 2);
1150 gc->pc += cmdlen;
1151 if (__builtin_expect(gc->pc > gc->limit, 0)) {
1152 (void) __glXFlushRenderBuffer(gc, gc->pc);
1153 }
1154 }
1155
1156 #define X_GLrop_Normal3sv 32
1157 void
1158 __indirect_glNormal3sv(const GLshort * v)
1159 {
1160 generic_6_byte(X_GLrop_Normal3sv, v);
1161 }
1162
1163 #define X_GLrop_RasterPos2dv 33
1164 void
1165 __indirect_glRasterPos2d(GLdouble x, GLdouble y)
1166 {
1167 __GLXcontext *const gc = __glXGetCurrentContext();
1168 const GLuint cmdlen = 20;
1169 emit_header(gc->pc, X_GLrop_RasterPos2dv, cmdlen);
1170 (void) memcpy((void *) (gc->pc + 4), (void *) (&x), 8);
1171 (void) memcpy((void *) (gc->pc + 12), (void *) (&y), 8);
1172 gc->pc += cmdlen;
1173 if (__builtin_expect(gc->pc > gc->limit, 0)) {
1174 (void) __glXFlushRenderBuffer(gc, gc->pc);
1175 }
1176 }
1177
1178 #define X_GLrop_RasterPos2dv 33
1179 void
1180 __indirect_glRasterPos2dv(const GLdouble * v)
1181 {
1182 generic_16_byte(X_GLrop_RasterPos2dv, v);
1183 }
1184
1185 #define X_GLrop_RasterPos2fv 34
1186 void
1187 __indirect_glRasterPos2f(GLfloat x, GLfloat y)
1188 {
1189 __GLXcontext *const gc = __glXGetCurrentContext();
1190 const GLuint cmdlen = 12;
1191 emit_header(gc->pc, X_GLrop_RasterPos2fv, cmdlen);
1192 (void) memcpy((void *) (gc->pc + 4), (void *) (&x), 4);
1193 (void) memcpy((void *) (gc->pc + 8), (void *) (&y), 4);
1194 gc->pc += cmdlen;
1195 if (__builtin_expect(gc->pc > gc->limit, 0)) {
1196 (void) __glXFlushRenderBuffer(gc, gc->pc);
1197 }
1198 }
1199
1200 #define X_GLrop_RasterPos2fv 34
1201 void
1202 __indirect_glRasterPos2fv(const GLfloat * v)
1203 {
1204 generic_8_byte(X_GLrop_RasterPos2fv, v);
1205 }
1206
1207 #define X_GLrop_RasterPos2iv 35
1208 void
1209 __indirect_glRasterPos2i(GLint x, GLint y)
1210 {
1211 __GLXcontext *const gc = __glXGetCurrentContext();
1212 const GLuint cmdlen = 12;
1213 emit_header(gc->pc, X_GLrop_RasterPos2iv, cmdlen);
1214 (void) memcpy((void *) (gc->pc + 4), (void *) (&x), 4);
1215 (void) memcpy((void *) (gc->pc + 8), (void *) (&y), 4);
1216 gc->pc += cmdlen;
1217 if (__builtin_expect(gc->pc > gc->limit, 0)) {
1218 (void) __glXFlushRenderBuffer(gc, gc->pc);
1219 }
1220 }
1221
1222 #define X_GLrop_RasterPos2iv 35
1223 void
1224 __indirect_glRasterPos2iv(const GLint * v)
1225 {
1226 generic_8_byte(X_GLrop_RasterPos2iv, v);
1227 }
1228
1229 #define X_GLrop_RasterPos2sv 36
1230 void
1231 __indirect_glRasterPos2s(GLshort x, GLshort y)
1232 {
1233 __GLXcontext *const gc = __glXGetCurrentContext();
1234 const GLuint cmdlen = 8;
1235 emit_header(gc->pc, X_GLrop_RasterPos2sv, cmdlen);
1236 (void) memcpy((void *) (gc->pc + 4), (void *) (&x), 2);
1237 (void) memcpy((void *) (gc->pc + 6), (void *) (&y), 2);
1238 gc->pc += cmdlen;
1239 if (__builtin_expect(gc->pc > gc->limit, 0)) {
1240 (void) __glXFlushRenderBuffer(gc, gc->pc);
1241 }
1242 }
1243
1244 #define X_GLrop_RasterPos2sv 36
1245 void
1246 __indirect_glRasterPos2sv(const GLshort * v)
1247 {
1248 generic_4_byte(X_GLrop_RasterPos2sv, v);
1249 }
1250
1251 #define X_GLrop_RasterPos3dv 37
1252 void
1253 __indirect_glRasterPos3d(GLdouble x, GLdouble y, GLdouble z)
1254 {
1255 __GLXcontext *const gc = __glXGetCurrentContext();
1256 const GLuint cmdlen = 28;
1257 emit_header(gc->pc, X_GLrop_RasterPos3dv, cmdlen);
1258 (void) memcpy((void *) (gc->pc + 4), (void *) (&x), 8);
1259 (void) memcpy((void *) (gc->pc + 12), (void *) (&y), 8);
1260 (void) memcpy((void *) (gc->pc + 20), (void *) (&z), 8);
1261 gc->pc += cmdlen;
1262 if (__builtin_expect(gc->pc > gc->limit, 0)) {
1263 (void) __glXFlushRenderBuffer(gc, gc->pc);
1264 }
1265 }
1266
1267 #define X_GLrop_RasterPos3dv 37
1268 void
1269 __indirect_glRasterPos3dv(const GLdouble * v)
1270 {
1271 generic_24_byte(X_GLrop_RasterPos3dv, v);
1272 }
1273
1274 #define X_GLrop_RasterPos3fv 38
1275 void
1276 __indirect_glRasterPos3f(GLfloat x, GLfloat y, GLfloat z)
1277 {
1278 __GLXcontext *const gc = __glXGetCurrentContext();
1279 const GLuint cmdlen = 16;
1280 emit_header(gc->pc, X_GLrop_RasterPos3fv, cmdlen);
1281 (void) memcpy((void *) (gc->pc + 4), (void *) (&x), 4);
1282 (void) memcpy((void *) (gc->pc + 8), (void *) (&y), 4);
1283 (void) memcpy((void *) (gc->pc + 12), (void *) (&z), 4);
1284 gc->pc += cmdlen;
1285 if (__builtin_expect(gc->pc > gc->limit, 0)) {
1286 (void) __glXFlushRenderBuffer(gc, gc->pc);
1287 }
1288 }
1289
1290 #define X_GLrop_RasterPos3fv 38
1291 void
1292 __indirect_glRasterPos3fv(const GLfloat * v)
1293 {
1294 generic_12_byte(X_GLrop_RasterPos3fv, v);
1295 }
1296
1297 #define X_GLrop_RasterPos3iv 39
1298 void
1299 __indirect_glRasterPos3i(GLint x, GLint y, GLint z)
1300 {
1301 __GLXcontext *const gc = __glXGetCurrentContext();
1302 const GLuint cmdlen = 16;
1303 emit_header(gc->pc, X_GLrop_RasterPos3iv, cmdlen);
1304 (void) memcpy((void *) (gc->pc + 4), (void *) (&x), 4);
1305 (void) memcpy((void *) (gc->pc + 8), (void *) (&y), 4);
1306 (void) memcpy((void *) (gc->pc + 12), (void *) (&z), 4);
1307 gc->pc += cmdlen;
1308 if (__builtin_expect(gc->pc > gc->limit, 0)) {
1309 (void) __glXFlushRenderBuffer(gc, gc->pc);
1310 }
1311 }
1312
1313 #define X_GLrop_RasterPos3iv 39
1314 void
1315 __indirect_glRasterPos3iv(const GLint * v)
1316 {
1317 generic_12_byte(X_GLrop_RasterPos3iv, v);
1318 }
1319
1320 #define X_GLrop_RasterPos3sv 40
1321 void
1322 __indirect_glRasterPos3s(GLshort x, GLshort y, GLshort z)
1323 {
1324 __GLXcontext *const gc = __glXGetCurrentContext();
1325 const GLuint cmdlen = 12;
1326 emit_header(gc->pc, X_GLrop_RasterPos3sv, cmdlen);
1327 (void) memcpy((void *) (gc->pc + 4), (void *) (&x), 2);
1328 (void) memcpy((void *) (gc->pc + 6), (void *) (&y), 2);
1329 (void) memcpy((void *) (gc->pc + 8), (void *) (&z), 2);
1330 gc->pc += cmdlen;
1331 if (__builtin_expect(gc->pc > gc->limit, 0)) {
1332 (void) __glXFlushRenderBuffer(gc, gc->pc);
1333 }
1334 }
1335
1336 #define X_GLrop_RasterPos3sv 40
1337 void
1338 __indirect_glRasterPos3sv(const GLshort * v)
1339 {
1340 generic_6_byte(X_GLrop_RasterPos3sv, v);
1341 }
1342
1343 #define X_GLrop_RasterPos4dv 41
1344 void
1345 __indirect_glRasterPos4d(GLdouble x, GLdouble y, GLdouble z, GLdouble w)
1346 {
1347 __GLXcontext *const gc = __glXGetCurrentContext();
1348 const GLuint cmdlen = 36;
1349 emit_header(gc->pc, X_GLrop_RasterPos4dv, cmdlen);
1350 (void) memcpy((void *) (gc->pc + 4), (void *) (&x), 8);
1351 (void) memcpy((void *) (gc->pc + 12), (void *) (&y), 8);
1352 (void) memcpy((void *) (gc->pc + 20), (void *) (&z), 8);
1353 (void) memcpy((void *) (gc->pc + 28), (void *) (&w), 8);
1354 gc->pc += cmdlen;
1355 if (__builtin_expect(gc->pc > gc->limit, 0)) {
1356 (void) __glXFlushRenderBuffer(gc, gc->pc);
1357 }
1358 }
1359
1360 #define X_GLrop_RasterPos4dv 41
1361 void
1362 __indirect_glRasterPos4dv(const GLdouble * v)
1363 {
1364 generic_32_byte(X_GLrop_RasterPos4dv, v);
1365 }
1366
1367 #define X_GLrop_RasterPos4fv 42
1368 void
1369 __indirect_glRasterPos4f(GLfloat x, GLfloat y, GLfloat z, GLfloat w)
1370 {
1371 __GLXcontext *const gc = __glXGetCurrentContext();
1372 const GLuint cmdlen = 20;
1373 emit_header(gc->pc, X_GLrop_RasterPos4fv, cmdlen);
1374 (void) memcpy((void *) (gc->pc + 4), (void *) (&x), 4);
1375 (void) memcpy((void *) (gc->pc + 8), (void *) (&y), 4);
1376 (void) memcpy((void *) (gc->pc + 12), (void *) (&z), 4);
1377 (void) memcpy((void *) (gc->pc + 16), (void *) (&w), 4);
1378 gc->pc += cmdlen;
1379 if (__builtin_expect(gc->pc > gc->limit, 0)) {
1380 (void) __glXFlushRenderBuffer(gc, gc->pc);
1381 }
1382 }
1383
1384 #define X_GLrop_RasterPos4fv 42
1385 void
1386 __indirect_glRasterPos4fv(const GLfloat * v)
1387 {
1388 generic_16_byte(X_GLrop_RasterPos4fv, v);
1389 }
1390
1391 #define X_GLrop_RasterPos4iv 43
1392 void
1393 __indirect_glRasterPos4i(GLint x, GLint y, GLint z, GLint w)
1394 {
1395 __GLXcontext *const gc = __glXGetCurrentContext();
1396 const GLuint cmdlen = 20;
1397 emit_header(gc->pc, X_GLrop_RasterPos4iv, cmdlen);
1398 (void) memcpy((void *) (gc->pc + 4), (void *) (&x), 4);
1399 (void) memcpy((void *) (gc->pc + 8), (void *) (&y), 4);
1400 (void) memcpy((void *) (gc->pc + 12), (void *) (&z), 4);
1401 (void) memcpy((void *) (gc->pc + 16), (void *) (&w), 4);
1402 gc->pc += cmdlen;
1403 if (__builtin_expect(gc->pc > gc->limit, 0)) {
1404 (void) __glXFlushRenderBuffer(gc, gc->pc);
1405 }
1406 }
1407
1408 #define X_GLrop_RasterPos4iv 43
1409 void
1410 __indirect_glRasterPos4iv(const GLint * v)
1411 {
1412 generic_16_byte(X_GLrop_RasterPos4iv, v);
1413 }
1414
1415 #define X_GLrop_RasterPos4sv 44
1416 void
1417 __indirect_glRasterPos4s(GLshort x, GLshort y, GLshort z, GLshort w)
1418 {
1419 __GLXcontext *const gc = __glXGetCurrentContext();
1420 const GLuint cmdlen = 12;
1421 emit_header(gc->pc, X_GLrop_RasterPos4sv, cmdlen);
1422 (void) memcpy((void *) (gc->pc + 4), (void *) (&x), 2);
1423 (void) memcpy((void *) (gc->pc + 6), (void *) (&y), 2);
1424 (void) memcpy((void *) (gc->pc + 8), (void *) (&z), 2);
1425 (void) memcpy((void *) (gc->pc + 10), (void *) (&w), 2);
1426 gc->pc += cmdlen;
1427 if (__builtin_expect(gc->pc > gc->limit, 0)) {
1428 (void) __glXFlushRenderBuffer(gc, gc->pc);
1429 }
1430 }
1431
1432 #define X_GLrop_RasterPos4sv 44
1433 void
1434 __indirect_glRasterPos4sv(const GLshort * v)
1435 {
1436 generic_8_byte(X_GLrop_RasterPos4sv, v);
1437 }
1438
1439 #define X_GLrop_Rectdv 45
1440 void
1441 __indirect_glRectd(GLdouble x1, GLdouble y1, GLdouble x2, GLdouble y2)
1442 {
1443 __GLXcontext *const gc = __glXGetCurrentContext();
1444 const GLuint cmdlen = 36;
1445 emit_header(gc->pc, X_GLrop_Rectdv, cmdlen);
1446 (void) memcpy((void *) (gc->pc + 4), (void *) (&x1), 8);
1447 (void) memcpy((void *) (gc->pc + 12), (void *) (&y1), 8);
1448 (void) memcpy((void *) (gc->pc + 20), (void *) (&x2), 8);
1449 (void) memcpy((void *) (gc->pc + 28), (void *) (&y2), 8);
1450 gc->pc += cmdlen;
1451 if (__builtin_expect(gc->pc > gc->limit, 0)) {
1452 (void) __glXFlushRenderBuffer(gc, gc->pc);
1453 }
1454 }
1455
1456 #define X_GLrop_Rectdv 45
1457 void
1458 __indirect_glRectdv(const GLdouble * v1, const GLdouble * v2)
1459 {
1460 __GLXcontext *const gc = __glXGetCurrentContext();
1461 const GLuint cmdlen = 36;
1462 emit_header(gc->pc, X_GLrop_Rectdv, cmdlen);
1463 (void) memcpy((void *) (gc->pc + 4), (void *) (v1), 16);
1464 (void) memcpy((void *) (gc->pc + 20), (void *) (v2), 16);
1465 gc->pc += cmdlen;
1466 if (__builtin_expect(gc->pc > gc->limit, 0)) {
1467 (void) __glXFlushRenderBuffer(gc, gc->pc);
1468 }
1469 }
1470
1471 #define X_GLrop_Rectfv 46
1472 void
1473 __indirect_glRectf(GLfloat x1, GLfloat y1, GLfloat x2, GLfloat y2)
1474 {
1475 __GLXcontext *const gc = __glXGetCurrentContext();
1476 const GLuint cmdlen = 20;
1477 emit_header(gc->pc, X_GLrop_Rectfv, cmdlen);
1478 (void) memcpy((void *) (gc->pc + 4), (void *) (&x1), 4);
1479 (void) memcpy((void *) (gc->pc + 8), (void *) (&y1), 4);
1480 (void) memcpy((void *) (gc->pc + 12), (void *) (&x2), 4);
1481 (void) memcpy((void *) (gc->pc + 16), (void *) (&y2), 4);
1482 gc->pc += cmdlen;
1483 if (__builtin_expect(gc->pc > gc->limit, 0)) {
1484 (void) __glXFlushRenderBuffer(gc, gc->pc);
1485 }
1486 }
1487
1488 #define X_GLrop_Rectfv 46
1489 void
1490 __indirect_glRectfv(const GLfloat * v1, const GLfloat * v2)
1491 {
1492 __GLXcontext *const gc = __glXGetCurrentContext();
1493 const GLuint cmdlen = 20;
1494 emit_header(gc->pc, X_GLrop_Rectfv, cmdlen);
1495 (void) memcpy((void *) (gc->pc + 4), (void *) (v1), 8);
1496 (void) memcpy((void *) (gc->pc + 12), (void *) (v2), 8);
1497 gc->pc += cmdlen;
1498 if (__builtin_expect(gc->pc > gc->limit, 0)) {
1499 (void) __glXFlushRenderBuffer(gc, gc->pc);
1500 }
1501 }
1502
1503 #define X_GLrop_Rectiv 47
1504 void
1505 __indirect_glRecti(GLint x1, GLint y1, GLint x2, GLint y2)
1506 {
1507 __GLXcontext *const gc = __glXGetCurrentContext();
1508 const GLuint cmdlen = 20;
1509 emit_header(gc->pc, X_GLrop_Rectiv, cmdlen);
1510 (void) memcpy((void *) (gc->pc + 4), (void *) (&x1), 4);
1511 (void) memcpy((void *) (gc->pc + 8), (void *) (&y1), 4);
1512 (void) memcpy((void *) (gc->pc + 12), (void *) (&x2), 4);
1513 (void) memcpy((void *) (gc->pc + 16), (void *) (&y2), 4);
1514 gc->pc += cmdlen;
1515 if (__builtin_expect(gc->pc > gc->limit, 0)) {
1516 (void) __glXFlushRenderBuffer(gc, gc->pc);
1517 }
1518 }
1519
1520 #define X_GLrop_Rectiv 47
1521 void
1522 __indirect_glRectiv(const GLint * v1, const GLint * v2)
1523 {
1524 __GLXcontext *const gc = __glXGetCurrentContext();
1525 const GLuint cmdlen = 20;
1526 emit_header(gc->pc, X_GLrop_Rectiv, cmdlen);
1527 (void) memcpy((void *) (gc->pc + 4), (void *) (v1), 8);
1528 (void) memcpy((void *) (gc->pc + 12), (void *) (v2), 8);
1529 gc->pc += cmdlen;
1530 if (__builtin_expect(gc->pc > gc->limit, 0)) {
1531 (void) __glXFlushRenderBuffer(gc, gc->pc);
1532 }
1533 }
1534
1535 #define X_GLrop_Rectsv 48
1536 void
1537 __indirect_glRects(GLshort x1, GLshort y1, GLshort x2, GLshort y2)
1538 {
1539 __GLXcontext *const gc = __glXGetCurrentContext();
1540 const GLuint cmdlen = 12;
1541 emit_header(gc->pc, X_GLrop_Rectsv, cmdlen);
1542 (void) memcpy((void *) (gc->pc + 4), (void *) (&x1), 2);
1543 (void) memcpy((void *) (gc->pc + 6), (void *) (&y1), 2);
1544 (void) memcpy((void *) (gc->pc + 8), (void *) (&x2), 2);
1545 (void) memcpy((void *) (gc->pc + 10), (void *) (&y2), 2);
1546 gc->pc += cmdlen;
1547 if (__builtin_expect(gc->pc > gc->limit, 0)) {
1548 (void) __glXFlushRenderBuffer(gc, gc->pc);
1549 }
1550 }
1551
1552 #define X_GLrop_Rectsv 48
1553 void
1554 __indirect_glRectsv(const GLshort * v1, const GLshort * v2)
1555 {
1556 __GLXcontext *const gc = __glXGetCurrentContext();
1557 const GLuint cmdlen = 12;
1558 emit_header(gc->pc, X_GLrop_Rectsv, cmdlen);
1559 (void) memcpy((void *) (gc->pc + 4), (void *) (v1), 4);
1560 (void) memcpy((void *) (gc->pc + 8), (void *) (v2), 4);
1561 gc->pc += cmdlen;
1562 if (__builtin_expect(gc->pc > gc->limit, 0)) {
1563 (void) __glXFlushRenderBuffer(gc, gc->pc);
1564 }
1565 }
1566
1567 #define X_GLrop_TexCoord1dv 49
1568 void
1569 __indirect_glTexCoord1d(GLdouble s)
1570 {
1571 __GLXcontext *const gc = __glXGetCurrentContext();
1572 const GLuint cmdlen = 12;
1573 emit_header(gc->pc, X_GLrop_TexCoord1dv, cmdlen);
1574 (void) memcpy((void *) (gc->pc + 4), (void *) (&s), 8);
1575 gc->pc += cmdlen;
1576 if (__builtin_expect(gc->pc > gc->limit, 0)) {
1577 (void) __glXFlushRenderBuffer(gc, gc->pc);
1578 }
1579 }
1580
1581 #define X_GLrop_TexCoord1dv 49
1582 void
1583 __indirect_glTexCoord1dv(const GLdouble * v)
1584 {
1585 generic_8_byte(X_GLrop_TexCoord1dv, v);
1586 }
1587
1588 #define X_GLrop_TexCoord1fv 50
1589 void
1590 __indirect_glTexCoord1f(GLfloat s)
1591 {
1592 __GLXcontext *const gc = __glXGetCurrentContext();
1593 const GLuint cmdlen = 8;
1594 emit_header(gc->pc, X_GLrop_TexCoord1fv, cmdlen);
1595 (void) memcpy((void *) (gc->pc + 4), (void *) (&s), 4);
1596 gc->pc += cmdlen;
1597 if (__builtin_expect(gc->pc > gc->limit, 0)) {
1598 (void) __glXFlushRenderBuffer(gc, gc->pc);
1599 }
1600 }
1601
1602 #define X_GLrop_TexCoord1fv 50
1603 void
1604 __indirect_glTexCoord1fv(const GLfloat * v)
1605 {
1606 generic_4_byte(X_GLrop_TexCoord1fv, v);
1607 }
1608
1609 #define X_GLrop_TexCoord1iv 51
1610 void
1611 __indirect_glTexCoord1i(GLint s)
1612 {
1613 __GLXcontext *const gc = __glXGetCurrentContext();
1614 const GLuint cmdlen = 8;
1615 emit_header(gc->pc, X_GLrop_TexCoord1iv, cmdlen);
1616 (void) memcpy((void *) (gc->pc + 4), (void *) (&s), 4);
1617 gc->pc += cmdlen;
1618 if (__builtin_expect(gc->pc > gc->limit, 0)) {
1619 (void) __glXFlushRenderBuffer(gc, gc->pc);
1620 }
1621 }
1622
1623 #define X_GLrop_TexCoord1iv 51
1624 void
1625 __indirect_glTexCoord1iv(const GLint * v)
1626 {
1627 generic_4_byte(X_GLrop_TexCoord1iv, v);
1628 }
1629
1630 #define X_GLrop_TexCoord1sv 52
1631 void
1632 __indirect_glTexCoord1s(GLshort s)
1633 {
1634 __GLXcontext *const gc = __glXGetCurrentContext();
1635 const GLuint cmdlen = 8;
1636 emit_header(gc->pc, X_GLrop_TexCoord1sv, cmdlen);
1637 (void) memcpy((void *) (gc->pc + 4), (void *) (&s), 2);
1638 gc->pc += cmdlen;
1639 if (__builtin_expect(gc->pc > gc->limit, 0)) {
1640 (void) __glXFlushRenderBuffer(gc, gc->pc);
1641 }
1642 }
1643
1644 #define X_GLrop_TexCoord1sv 52
1645 void
1646 __indirect_glTexCoord1sv(const GLshort * v)
1647 {
1648 __GLXcontext *const gc = __glXGetCurrentContext();
1649 const GLuint cmdlen = 8;
1650 emit_header(gc->pc, X_GLrop_TexCoord1sv, cmdlen);
1651 (void) memcpy((void *) (gc->pc + 4), (void *) (v), 2);
1652 gc->pc += cmdlen;
1653 if (__builtin_expect(gc->pc > gc->limit, 0)) {
1654 (void) __glXFlushRenderBuffer(gc, gc->pc);
1655 }
1656 }
1657
1658 #define X_GLrop_TexCoord2dv 53
1659 void
1660 __indirect_glTexCoord2d(GLdouble s, GLdouble t)
1661 {
1662 __GLXcontext *const gc = __glXGetCurrentContext();
1663 const GLuint cmdlen = 20;
1664 emit_header(gc->pc, X_GLrop_TexCoord2dv, cmdlen);
1665 (void) memcpy((void *) (gc->pc + 4), (void *) (&s), 8);
1666 (void) memcpy((void *) (gc->pc + 12), (void *) (&t), 8);
1667 gc->pc += cmdlen;
1668 if (__builtin_expect(gc->pc > gc->limit, 0)) {
1669 (void) __glXFlushRenderBuffer(gc, gc->pc);
1670 }
1671 }
1672
1673 #define X_GLrop_TexCoord2dv 53
1674 void
1675 __indirect_glTexCoord2dv(const GLdouble * v)
1676 {
1677 generic_16_byte(X_GLrop_TexCoord2dv, v);
1678 }
1679
1680 #define X_GLrop_TexCoord2fv 54
1681 void
1682 __indirect_glTexCoord2f(GLfloat s, GLfloat t)
1683 {
1684 __GLXcontext *const gc = __glXGetCurrentContext();
1685 const GLuint cmdlen = 12;
1686 emit_header(gc->pc, X_GLrop_TexCoord2fv, cmdlen);
1687 (void) memcpy((void *) (gc->pc + 4), (void *) (&s), 4);
1688 (void) memcpy((void *) (gc->pc + 8), (void *) (&t), 4);
1689 gc->pc += cmdlen;
1690 if (__builtin_expect(gc->pc > gc->limit, 0)) {
1691 (void) __glXFlushRenderBuffer(gc, gc->pc);
1692 }
1693 }
1694
1695 #define X_GLrop_TexCoord2fv 54
1696 void
1697 __indirect_glTexCoord2fv(const GLfloat * v)
1698 {
1699 generic_8_byte(X_GLrop_TexCoord2fv, v);
1700 }
1701
1702 #define X_GLrop_TexCoord2iv 55
1703 void
1704 __indirect_glTexCoord2i(GLint s, GLint t)
1705 {
1706 __GLXcontext *const gc = __glXGetCurrentContext();
1707 const GLuint cmdlen = 12;
1708 emit_header(gc->pc, X_GLrop_TexCoord2iv, cmdlen);
1709 (void) memcpy((void *) (gc->pc + 4), (void *) (&s), 4);
1710 (void) memcpy((void *) (gc->pc + 8), (void *) (&t), 4);
1711 gc->pc += cmdlen;
1712 if (__builtin_expect(gc->pc > gc->limit, 0)) {
1713 (void) __glXFlushRenderBuffer(gc, gc->pc);
1714 }
1715 }
1716
1717 #define X_GLrop_TexCoord2iv 55
1718 void
1719 __indirect_glTexCoord2iv(const GLint * v)
1720 {
1721 generic_8_byte(X_GLrop_TexCoord2iv, v);
1722 }
1723
1724 #define X_GLrop_TexCoord2sv 56
1725 void
1726 __indirect_glTexCoord2s(GLshort s, GLshort t)
1727 {
1728 __GLXcontext *const gc = __glXGetCurrentContext();
1729 const GLuint cmdlen = 8;
1730 emit_header(gc->pc, X_GLrop_TexCoord2sv, cmdlen);
1731 (void) memcpy((void *) (gc->pc + 4), (void *) (&s), 2);
1732 (void) memcpy((void *) (gc->pc + 6), (void *) (&t), 2);
1733 gc->pc += cmdlen;
1734 if (__builtin_expect(gc->pc > gc->limit, 0)) {
1735 (void) __glXFlushRenderBuffer(gc, gc->pc);
1736 }
1737 }
1738
1739 #define X_GLrop_TexCoord2sv 56
1740 void
1741 __indirect_glTexCoord2sv(const GLshort * v)
1742 {
1743 generic_4_byte(X_GLrop_TexCoord2sv, v);
1744 }
1745
1746 #define X_GLrop_TexCoord3dv 57
1747 void
1748 __indirect_glTexCoord3d(GLdouble s, GLdouble t, GLdouble r)
1749 {
1750 __GLXcontext *const gc = __glXGetCurrentContext();
1751 const GLuint cmdlen = 28;
1752 emit_header(gc->pc, X_GLrop_TexCoord3dv, cmdlen);
1753 (void) memcpy((void *) (gc->pc + 4), (void *) (&s), 8);
1754 (void) memcpy((void *) (gc->pc + 12), (void *) (&t), 8);
1755 (void) memcpy((void *) (gc->pc + 20), (void *) (&r), 8);
1756 gc->pc += cmdlen;
1757 if (__builtin_expect(gc->pc > gc->limit, 0)) {
1758 (void) __glXFlushRenderBuffer(gc, gc->pc);
1759 }
1760 }
1761
1762 #define X_GLrop_TexCoord3dv 57
1763 void
1764 __indirect_glTexCoord3dv(const GLdouble * v)
1765 {
1766 generic_24_byte(X_GLrop_TexCoord3dv, v);
1767 }
1768
1769 #define X_GLrop_TexCoord3fv 58
1770 void
1771 __indirect_glTexCoord3f(GLfloat s, GLfloat t, GLfloat r)
1772 {
1773 __GLXcontext *const gc = __glXGetCurrentContext();
1774 const GLuint cmdlen = 16;
1775 emit_header(gc->pc, X_GLrop_TexCoord3fv, cmdlen);
1776 (void) memcpy((void *) (gc->pc + 4), (void *) (&s), 4);
1777 (void) memcpy((void *) (gc->pc + 8), (void *) (&t), 4);
1778 (void) memcpy((void *) (gc->pc + 12), (void *) (&r), 4);
1779 gc->pc += cmdlen;
1780 if (__builtin_expect(gc->pc > gc->limit, 0)) {
1781 (void) __glXFlushRenderBuffer(gc, gc->pc);
1782 }
1783 }
1784
1785 #define X_GLrop_TexCoord3fv 58
1786 void
1787 __indirect_glTexCoord3fv(const GLfloat * v)
1788 {
1789 generic_12_byte(X_GLrop_TexCoord3fv, v);
1790 }
1791
1792 #define X_GLrop_TexCoord3iv 59
1793 void
1794 __indirect_glTexCoord3i(GLint s, GLint t, GLint r)
1795 {
1796 __GLXcontext *const gc = __glXGetCurrentContext();
1797 const GLuint cmdlen = 16;
1798 emit_header(gc->pc, X_GLrop_TexCoord3iv, cmdlen);
1799 (void) memcpy((void *) (gc->pc + 4), (void *) (&s), 4);
1800 (void) memcpy((void *) (gc->pc + 8), (void *) (&t), 4);
1801 (void) memcpy((void *) (gc->pc + 12), (void *) (&r), 4);
1802 gc->pc += cmdlen;
1803 if (__builtin_expect(gc->pc > gc->limit, 0)) {
1804 (void) __glXFlushRenderBuffer(gc, gc->pc);
1805 }
1806 }
1807
1808 #define X_GLrop_TexCoord3iv 59
1809 void
1810 __indirect_glTexCoord3iv(const GLint * v)
1811 {
1812 generic_12_byte(X_GLrop_TexCoord3iv, v);
1813 }
1814
1815 #define X_GLrop_TexCoord3sv 60
1816 void
1817 __indirect_glTexCoord3s(GLshort s, GLshort t, GLshort r)
1818 {
1819 __GLXcontext *const gc = __glXGetCurrentContext();
1820 const GLuint cmdlen = 12;
1821 emit_header(gc->pc, X_GLrop_TexCoord3sv, cmdlen);
1822 (void) memcpy((void *) (gc->pc + 4), (void *) (&s), 2);
1823 (void) memcpy((void *) (gc->pc + 6), (void *) (&t), 2);
1824 (void) memcpy((void *) (gc->pc + 8), (void *) (&r), 2);
1825 gc->pc += cmdlen;
1826 if (__builtin_expect(gc->pc > gc->limit, 0)) {
1827 (void) __glXFlushRenderBuffer(gc, gc->pc);
1828 }
1829 }
1830
1831 #define X_GLrop_TexCoord3sv 60
1832 void
1833 __indirect_glTexCoord3sv(const GLshort * v)
1834 {
1835 generic_6_byte(X_GLrop_TexCoord3sv, v);
1836 }
1837
1838 #define X_GLrop_TexCoord4dv 61
1839 void
1840 __indirect_glTexCoord4d(GLdouble s, GLdouble t, GLdouble r, GLdouble q)
1841 {
1842 __GLXcontext *const gc = __glXGetCurrentContext();
1843 const GLuint cmdlen = 36;
1844 emit_header(gc->pc, X_GLrop_TexCoord4dv, cmdlen);
1845 (void) memcpy((void *) (gc->pc + 4), (void *) (&s), 8);
1846 (void) memcpy((void *) (gc->pc + 12), (void *) (&t), 8);
1847 (void) memcpy((void *) (gc->pc + 20), (void *) (&r), 8);
1848 (void) memcpy((void *) (gc->pc + 28), (void *) (&q), 8);
1849 gc->pc += cmdlen;
1850 if (__builtin_expect(gc->pc > gc->limit, 0)) {
1851 (void) __glXFlushRenderBuffer(gc, gc->pc);
1852 }
1853 }
1854
1855 #define X_GLrop_TexCoord4dv 61
1856 void
1857 __indirect_glTexCoord4dv(const GLdouble * v)
1858 {
1859 generic_32_byte(X_GLrop_TexCoord4dv, v);
1860 }
1861
1862 #define X_GLrop_TexCoord4fv 62
1863 void
1864 __indirect_glTexCoord4f(GLfloat s, GLfloat t, GLfloat r, GLfloat q)
1865 {
1866 __GLXcontext *const gc = __glXGetCurrentContext();
1867 const GLuint cmdlen = 20;
1868 emit_header(gc->pc, X_GLrop_TexCoord4fv, cmdlen);
1869 (void) memcpy((void *) (gc->pc + 4), (void *) (&s), 4);
1870 (void) memcpy((void *) (gc->pc + 8), (void *) (&t), 4);
1871 (void) memcpy((void *) (gc->pc + 12), (void *) (&r), 4);
1872 (void) memcpy((void *) (gc->pc + 16), (void *) (&q), 4);
1873 gc->pc += cmdlen;
1874 if (__builtin_expect(gc->pc > gc->limit, 0)) {
1875 (void) __glXFlushRenderBuffer(gc, gc->pc);
1876 }
1877 }
1878
1879 #define X_GLrop_TexCoord4fv 62
1880 void
1881 __indirect_glTexCoord4fv(const GLfloat * v)
1882 {
1883 generic_16_byte(X_GLrop_TexCoord4fv, v);
1884 }
1885
1886 #define X_GLrop_TexCoord4iv 63
1887 void
1888 __indirect_glTexCoord4i(GLint s, GLint t, GLint r, GLint q)
1889 {
1890 __GLXcontext *const gc = __glXGetCurrentContext();
1891 const GLuint cmdlen = 20;
1892 emit_header(gc->pc, X_GLrop_TexCoord4iv, cmdlen);
1893 (void) memcpy((void *) (gc->pc + 4), (void *) (&s), 4);
1894 (void) memcpy((void *) (gc->pc + 8), (void *) (&t), 4);
1895 (void) memcpy((void *) (gc->pc + 12), (void *) (&r), 4);
1896 (void) memcpy((void *) (gc->pc + 16), (void *) (&q), 4);
1897 gc->pc += cmdlen;
1898 if (__builtin_expect(gc->pc > gc->limit, 0)) {
1899 (void) __glXFlushRenderBuffer(gc, gc->pc);
1900 }
1901 }
1902
1903 #define X_GLrop_TexCoord4iv 63
1904 void
1905 __indirect_glTexCoord4iv(const GLint * v)
1906 {
1907 generic_16_byte(X_GLrop_TexCoord4iv, v);
1908 }
1909
1910 #define X_GLrop_TexCoord4sv 64
1911 void
1912 __indirect_glTexCoord4s(GLshort s, GLshort t, GLshort r, GLshort q)
1913 {
1914 __GLXcontext *const gc = __glXGetCurrentContext();
1915 const GLuint cmdlen = 12;
1916 emit_header(gc->pc, X_GLrop_TexCoord4sv, cmdlen);
1917 (void) memcpy((void *) (gc->pc + 4), (void *) (&s), 2);
1918 (void) memcpy((void *) (gc->pc + 6), (void *) (&t), 2);
1919 (void) memcpy((void *) (gc->pc + 8), (void *) (&r), 2);
1920 (void) memcpy((void *) (gc->pc + 10), (void *) (&q), 2);
1921 gc->pc += cmdlen;
1922 if (__builtin_expect(gc->pc > gc->limit, 0)) {
1923 (void) __glXFlushRenderBuffer(gc, gc->pc);
1924 }
1925 }
1926
1927 #define X_GLrop_TexCoord4sv 64
1928 void
1929 __indirect_glTexCoord4sv(const GLshort * v)
1930 {
1931 generic_8_byte(X_GLrop_TexCoord4sv, v);
1932 }
1933
1934 #define X_GLrop_Vertex2dv 65
1935 void
1936 __indirect_glVertex2d(GLdouble x, GLdouble y)
1937 {
1938 __GLXcontext *const gc = __glXGetCurrentContext();
1939 const GLuint cmdlen = 20;
1940 emit_header(gc->pc, X_GLrop_Vertex2dv, cmdlen);
1941 (void) memcpy((void *) (gc->pc + 4), (void *) (&x), 8);
1942 (void) memcpy((void *) (gc->pc + 12), (void *) (&y), 8);
1943 gc->pc += cmdlen;
1944 if (__builtin_expect(gc->pc > gc->limit, 0)) {
1945 (void) __glXFlushRenderBuffer(gc, gc->pc);
1946 }
1947 }
1948
1949 #define X_GLrop_Vertex2dv 65
1950 void
1951 __indirect_glVertex2dv(const GLdouble * v)
1952 {
1953 generic_16_byte(X_GLrop_Vertex2dv, v);
1954 }
1955
1956 #define X_GLrop_Vertex2fv 66
1957 void
1958 __indirect_glVertex2f(GLfloat x, GLfloat y)
1959 {
1960 __GLXcontext *const gc = __glXGetCurrentContext();
1961 const GLuint cmdlen = 12;
1962 emit_header(gc->pc, X_GLrop_Vertex2fv, cmdlen);
1963 (void) memcpy((void *) (gc->pc + 4), (void *) (&x), 4);
1964 (void) memcpy((void *) (gc->pc + 8), (void *) (&y), 4);
1965 gc->pc += cmdlen;
1966 if (__builtin_expect(gc->pc > gc->limit, 0)) {
1967 (void) __glXFlushRenderBuffer(gc, gc->pc);
1968 }
1969 }
1970
1971 #define X_GLrop_Vertex2fv 66
1972 void
1973 __indirect_glVertex2fv(const GLfloat * v)
1974 {
1975 generic_8_byte(X_GLrop_Vertex2fv, v);
1976 }
1977
1978 #define X_GLrop_Vertex2iv 67
1979 void
1980 __indirect_glVertex2i(GLint x, GLint y)
1981 {
1982 __GLXcontext *const gc = __glXGetCurrentContext();
1983 const GLuint cmdlen = 12;
1984 emit_header(gc->pc, X_GLrop_Vertex2iv, cmdlen);
1985 (void) memcpy((void *) (gc->pc + 4), (void *) (&x), 4);
1986 (void) memcpy((void *) (gc->pc + 8), (void *) (&y), 4);
1987 gc->pc += cmdlen;
1988 if (__builtin_expect(gc->pc > gc->limit, 0)) {
1989 (void) __glXFlushRenderBuffer(gc, gc->pc);
1990 }
1991 }
1992
1993 #define X_GLrop_Vertex2iv 67
1994 void
1995 __indirect_glVertex2iv(const GLint * v)
1996 {
1997 generic_8_byte(X_GLrop_Vertex2iv, v);
1998 }
1999
2000 #define X_GLrop_Vertex2sv 68
2001 void
2002 __indirect_glVertex2s(GLshort x, GLshort y)
2003 {
2004 __GLXcontext *const gc = __glXGetCurrentContext();
2005 const GLuint cmdlen = 8;
2006 emit_header(gc->pc, X_GLrop_Vertex2sv, cmdlen);
2007 (void) memcpy((void *) (gc->pc + 4), (void *) (&x), 2);
2008 (void) memcpy((void *) (gc->pc + 6), (void *) (&y), 2);
2009 gc->pc += cmdlen;
2010 if (__builtin_expect(gc->pc > gc->limit, 0)) {
2011 (void) __glXFlushRenderBuffer(gc, gc->pc);
2012 }
2013 }
2014
2015 #define X_GLrop_Vertex2sv 68
2016 void
2017 __indirect_glVertex2sv(const GLshort * v)
2018 {
2019 generic_4_byte(X_GLrop_Vertex2sv, v);
2020 }
2021
2022 #define X_GLrop_Vertex3dv 69
2023 void
2024 __indirect_glVertex3d(GLdouble x, GLdouble y, GLdouble z)
2025 {
2026 __GLXcontext *const gc = __glXGetCurrentContext();
2027 const GLuint cmdlen = 28;
2028 emit_header(gc->pc, X_GLrop_Vertex3dv, cmdlen);
2029 (void) memcpy((void *) (gc->pc + 4), (void *) (&x), 8);
2030 (void) memcpy((void *) (gc->pc + 12), (void *) (&y), 8);
2031 (void) memcpy((void *) (gc->pc + 20), (void *) (&z), 8);
2032 gc->pc += cmdlen;
2033 if (__builtin_expect(gc->pc > gc->limit, 0)) {
2034 (void) __glXFlushRenderBuffer(gc, gc->pc);
2035 }
2036 }
2037
2038 #define X_GLrop_Vertex3dv 69
2039 void
2040 __indirect_glVertex3dv(const GLdouble * v)
2041 {
2042 generic_24_byte(X_GLrop_Vertex3dv, v);
2043 }
2044
2045 #define X_GLrop_Vertex3fv 70
2046 void
2047 __indirect_glVertex3f(GLfloat x, GLfloat y, GLfloat z)
2048 {
2049 __GLXcontext *const gc = __glXGetCurrentContext();
2050 const GLuint cmdlen = 16;
2051 emit_header(gc->pc, X_GLrop_Vertex3fv, cmdlen);
2052 (void) memcpy((void *) (gc->pc + 4), (void *) (&x), 4);
2053 (void) memcpy((void *) (gc->pc + 8), (void *) (&y), 4);
2054 (void) memcpy((void *) (gc->pc + 12), (void *) (&z), 4);
2055 gc->pc += cmdlen;
2056 if (__builtin_expect(gc->pc > gc->limit, 0)) {
2057 (void) __glXFlushRenderBuffer(gc, gc->pc);
2058 }
2059 }
2060
2061 #define X_GLrop_Vertex3fv 70
2062 void
2063 __indirect_glVertex3fv(const GLfloat * v)
2064 {
2065 generic_12_byte(X_GLrop_Vertex3fv, v);
2066 }
2067
2068 #define X_GLrop_Vertex3iv 71
2069 void
2070 __indirect_glVertex3i(GLint x, GLint y, GLint z)
2071 {
2072 __GLXcontext *const gc = __glXGetCurrentContext();
2073 const GLuint cmdlen = 16;
2074 emit_header(gc->pc, X_GLrop_Vertex3iv, cmdlen);
2075 (void) memcpy((void *) (gc->pc + 4), (void *) (&x), 4);
2076 (void) memcpy((void *) (gc->pc + 8), (void *) (&y), 4);
2077 (void) memcpy((void *) (gc->pc + 12), (void *) (&z), 4);
2078 gc->pc += cmdlen;
2079 if (__builtin_expect(gc->pc > gc->limit, 0)) {
2080 (void) __glXFlushRenderBuffer(gc, gc->pc);
2081 }
2082 }
2083
2084 #define X_GLrop_Vertex3iv 71
2085 void
2086 __indirect_glVertex3iv(const GLint * v)
2087 {
2088 generic_12_byte(X_GLrop_Vertex3iv, v);
2089 }
2090
2091 #define X_GLrop_Vertex3sv 72
2092 void
2093 __indirect_glVertex3s(GLshort x, GLshort y, GLshort z)
2094 {
2095 __GLXcontext *const gc = __glXGetCurrentContext();
2096 const GLuint cmdlen = 12;
2097 emit_header(gc->pc, X_GLrop_Vertex3sv, cmdlen);
2098 (void) memcpy((void *) (gc->pc + 4), (void *) (&x), 2);
2099 (void) memcpy((void *) (gc->pc + 6), (void *) (&y), 2);
2100 (void) memcpy((void *) (gc->pc + 8), (void *) (&z), 2);
2101 gc->pc += cmdlen;
2102 if (__builtin_expect(gc->pc > gc->limit, 0)) {
2103 (void) __glXFlushRenderBuffer(gc, gc->pc);
2104 }
2105 }
2106
2107 #define X_GLrop_Vertex3sv 72
2108 void
2109 __indirect_glVertex3sv(const GLshort * v)
2110 {
2111 generic_6_byte(X_GLrop_Vertex3sv, v);
2112 }
2113
2114 #define X_GLrop_Vertex4dv 73
2115 void
2116 __indirect_glVertex4d(GLdouble x, GLdouble y, GLdouble z, GLdouble w)
2117 {
2118 __GLXcontext *const gc = __glXGetCurrentContext();
2119 const GLuint cmdlen = 36;
2120 emit_header(gc->pc, X_GLrop_Vertex4dv, cmdlen);
2121 (void) memcpy((void *) (gc->pc + 4), (void *) (&x), 8);
2122 (void) memcpy((void *) (gc->pc + 12), (void *) (&y), 8);
2123 (void) memcpy((void *) (gc->pc + 20), (void *) (&z), 8);
2124 (void) memcpy((void *) (gc->pc + 28), (void *) (&w), 8);
2125 gc->pc += cmdlen;
2126 if (__builtin_expect(gc->pc > gc->limit, 0)) {
2127 (void) __glXFlushRenderBuffer(gc, gc->pc);
2128 }
2129 }
2130
2131 #define X_GLrop_Vertex4dv 73
2132 void
2133 __indirect_glVertex4dv(const GLdouble * v)
2134 {
2135 generic_32_byte(X_GLrop_Vertex4dv, v);
2136 }
2137
2138 #define X_GLrop_Vertex4fv 74
2139 void
2140 __indirect_glVertex4f(GLfloat x, GLfloat y, GLfloat z, GLfloat w)
2141 {
2142 __GLXcontext *const gc = __glXGetCurrentContext();
2143 const GLuint cmdlen = 20;
2144 emit_header(gc->pc, X_GLrop_Vertex4fv, cmdlen);
2145 (void) memcpy((void *) (gc->pc + 4), (void *) (&x), 4);
2146 (void) memcpy((void *) (gc->pc + 8), (void *) (&y), 4);
2147 (void) memcpy((void *) (gc->pc + 12), (void *) (&z), 4);
2148 (void) memcpy((void *) (gc->pc + 16), (void *) (&w), 4);
2149 gc->pc += cmdlen;
2150 if (__builtin_expect(gc->pc > gc->limit, 0)) {
2151 (void) __glXFlushRenderBuffer(gc, gc->pc);
2152 }
2153 }
2154
2155 #define X_GLrop_Vertex4fv 74
2156 void
2157 __indirect_glVertex4fv(const GLfloat * v)
2158 {
2159 generic_16_byte(X_GLrop_Vertex4fv, v);
2160 }
2161
2162 #define X_GLrop_Vertex4iv 75
2163 void
2164 __indirect_glVertex4i(GLint x, GLint y, GLint z, GLint w)
2165 {
2166 __GLXcontext *const gc = __glXGetCurrentContext();
2167 const GLuint cmdlen = 20;
2168 emit_header(gc->pc, X_GLrop_Vertex4iv, cmdlen);
2169 (void) memcpy((void *) (gc->pc + 4), (void *) (&x), 4);
2170 (void) memcpy((void *) (gc->pc + 8), (void *) (&y), 4);
2171 (void) memcpy((void *) (gc->pc + 12), (void *) (&z), 4);
2172 (void) memcpy((void *) (gc->pc + 16), (void *) (&w), 4);
2173 gc->pc += cmdlen;
2174 if (__builtin_expect(gc->pc > gc->limit, 0)) {
2175 (void) __glXFlushRenderBuffer(gc, gc->pc);
2176 }
2177 }
2178
2179 #define X_GLrop_Vertex4iv 75
2180 void
2181 __indirect_glVertex4iv(const GLint * v)
2182 {
2183 generic_16_byte(X_GLrop_Vertex4iv, v);
2184 }
2185
2186 #define X_GLrop_Vertex4sv 76
2187 void
2188 __indirect_glVertex4s(GLshort x, GLshort y, GLshort z, GLshort w)
2189 {
2190 __GLXcontext *const gc = __glXGetCurrentContext();
2191 const GLuint cmdlen = 12;
2192 emit_header(gc->pc, X_GLrop_Vertex4sv, cmdlen);
2193 (void) memcpy((void *) (gc->pc + 4), (void *) (&x), 2);
2194 (void) memcpy((void *) (gc->pc + 6), (void *) (&y), 2);
2195 (void) memcpy((void *) (gc->pc + 8), (void *) (&z), 2);
2196 (void) memcpy((void *) (gc->pc + 10), (void *) (&w), 2);
2197 gc->pc += cmdlen;
2198 if (__builtin_expect(gc->pc > gc->limit, 0)) {
2199 (void) __glXFlushRenderBuffer(gc, gc->pc);
2200 }
2201 }
2202
2203 #define X_GLrop_Vertex4sv 76
2204 void
2205 __indirect_glVertex4sv(const GLshort * v)
2206 {
2207 generic_8_byte(X_GLrop_Vertex4sv, v);
2208 }
2209
2210 #define X_GLrop_ClipPlane 77
2211 void
2212 __indirect_glClipPlane(GLenum plane, const GLdouble * equation)
2213 {
2214 __GLXcontext *const gc = __glXGetCurrentContext();
2215 const GLuint cmdlen = 40;
2216 emit_header(gc->pc, X_GLrop_ClipPlane, cmdlen);
2217 (void) memcpy((void *) (gc->pc + 4), (void *) (equation), 32);
2218 (void) memcpy((void *) (gc->pc + 36), (void *) (&plane), 4);
2219 gc->pc += cmdlen;
2220 if (__builtin_expect(gc->pc > gc->limit, 0)) {
2221 (void) __glXFlushRenderBuffer(gc, gc->pc);
2222 }
2223 }
2224
2225 #define X_GLrop_ColorMaterial 78
2226 void
2227 __indirect_glColorMaterial(GLenum face, GLenum mode)
2228 {
2229 __GLXcontext *const gc = __glXGetCurrentContext();
2230 const GLuint cmdlen = 12;
2231 emit_header(gc->pc, X_GLrop_ColorMaterial, cmdlen);
2232 (void) memcpy((void *) (gc->pc + 4), (void *) (&face), 4);
2233 (void) memcpy((void *) (gc->pc + 8), (void *) (&mode), 4);
2234 gc->pc += cmdlen;
2235 if (__builtin_expect(gc->pc > gc->limit, 0)) {
2236 (void) __glXFlushRenderBuffer(gc, gc->pc);
2237 }
2238 }
2239
2240 #define X_GLrop_CullFace 79
2241 void
2242 __indirect_glCullFace(GLenum mode)
2243 {
2244 __GLXcontext *const gc = __glXGetCurrentContext();
2245 const GLuint cmdlen = 8;
2246 emit_header(gc->pc, X_GLrop_CullFace, cmdlen);
2247 (void) memcpy((void *) (gc->pc + 4), (void *) (&mode), 4);
2248 gc->pc += cmdlen;
2249 if (__builtin_expect(gc->pc > gc->limit, 0)) {
2250 (void) __glXFlushRenderBuffer(gc, gc->pc);
2251 }
2252 }
2253
2254 #define X_GLrop_Fogf 80
2255 void
2256 __indirect_glFogf(GLenum pname, GLfloat param)
2257 {
2258 __GLXcontext *const gc = __glXGetCurrentContext();
2259 const GLuint cmdlen = 12;
2260 emit_header(gc->pc, X_GLrop_Fogf, cmdlen);
2261 (void) memcpy((void *) (gc->pc + 4), (void *) (&pname), 4);
2262 (void) memcpy((void *) (gc->pc + 8), (void *) (&param), 4);
2263 gc->pc += cmdlen;
2264 if (__builtin_expect(gc->pc > gc->limit, 0)) {
2265 (void) __glXFlushRenderBuffer(gc, gc->pc);
2266 }
2267 }
2268
2269 #define X_GLrop_Fogfv 81
2270 void
2271 __indirect_glFogfv(GLenum pname, const GLfloat * params)
2272 {
2273 __GLXcontext *const gc = __glXGetCurrentContext();
2274 const GLuint compsize = __glFogfv_size(pname);
2275 const GLuint cmdlen = 8 + __GLX_PAD((compsize * 4));
2276 emit_header(gc->pc, X_GLrop_Fogfv, cmdlen);
2277 (void) memcpy((void *) (gc->pc + 4), (void *) (&pname), 4);
2278 (void) memcpy((void *) (gc->pc + 8), (void *) (params), (compsize * 4));
2279 gc->pc += cmdlen;
2280 if (__builtin_expect(gc->pc > gc->limit, 0)) {
2281 (void) __glXFlushRenderBuffer(gc, gc->pc);
2282 }
2283 }
2284
2285 #define X_GLrop_Fogi 82
2286 void
2287 __indirect_glFogi(GLenum pname, GLint param)
2288 {
2289 __GLXcontext *const gc = __glXGetCurrentContext();
2290 const GLuint cmdlen = 12;
2291 emit_header(gc->pc, X_GLrop_Fogi, cmdlen);
2292 (void) memcpy((void *) (gc->pc + 4), (void *) (&pname), 4);
2293 (void) memcpy((void *) (gc->pc + 8), (void *) (&param), 4);
2294 gc->pc += cmdlen;
2295 if (__builtin_expect(gc->pc > gc->limit, 0)) {
2296 (void) __glXFlushRenderBuffer(gc, gc->pc);
2297 }
2298 }
2299
2300 #define X_GLrop_Fogiv 83
2301 void
2302 __indirect_glFogiv(GLenum pname, const GLint * params)
2303 {
2304 __GLXcontext *const gc = __glXGetCurrentContext();
2305 const GLuint compsize = __glFogiv_size(pname);
2306 const GLuint cmdlen = 8 + __GLX_PAD((compsize * 4));
2307 emit_header(gc->pc, X_GLrop_Fogiv, cmdlen);
2308 (void) memcpy((void *) (gc->pc + 4), (void *) (&pname), 4);
2309 (void) memcpy((void *) (gc->pc + 8), (void *) (params), (compsize * 4));
2310 gc->pc += cmdlen;
2311 if (__builtin_expect(gc->pc > gc->limit, 0)) {
2312 (void) __glXFlushRenderBuffer(gc, gc->pc);
2313 }
2314 }
2315
2316 #define X_GLrop_FrontFace 84
2317 void
2318 __indirect_glFrontFace(GLenum mode)
2319 {
2320 __GLXcontext *const gc = __glXGetCurrentContext();
2321 const GLuint cmdlen = 8;
2322 emit_header(gc->pc, X_GLrop_FrontFace, cmdlen);
2323 (void) memcpy((void *) (gc->pc + 4), (void *) (&mode), 4);
2324 gc->pc += cmdlen;
2325 if (__builtin_expect(gc->pc > gc->limit, 0)) {
2326 (void) __glXFlushRenderBuffer(gc, gc->pc);
2327 }
2328 }
2329
2330 #define X_GLrop_Hint 85
2331 void
2332 __indirect_glHint(GLenum target, GLenum mode)
2333 {
2334 __GLXcontext *const gc = __glXGetCurrentContext();
2335 const GLuint cmdlen = 12;
2336 emit_header(gc->pc, X_GLrop_Hint, cmdlen);
2337 (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4);
2338 (void) memcpy((void *) (gc->pc + 8), (void *) (&mode), 4);
2339 gc->pc += cmdlen;
2340 if (__builtin_expect(gc->pc > gc->limit, 0)) {
2341 (void) __glXFlushRenderBuffer(gc, gc->pc);
2342 }
2343 }
2344
2345 #define X_GLrop_Lightf 86
2346 void
2347 __indirect_glLightf(GLenum light, GLenum pname, GLfloat param)
2348 {
2349 __GLXcontext *const gc = __glXGetCurrentContext();
2350 const GLuint cmdlen = 16;
2351 emit_header(gc->pc, X_GLrop_Lightf, cmdlen);
2352 (void) memcpy((void *) (gc->pc + 4), (void *) (&light), 4);
2353 (void) memcpy((void *) (gc->pc + 8), (void *) (&pname), 4);
2354 (void) memcpy((void *) (gc->pc + 12), (void *) (&param), 4);
2355 gc->pc += cmdlen;
2356 if (__builtin_expect(gc->pc > gc->limit, 0)) {
2357 (void) __glXFlushRenderBuffer(gc, gc->pc);
2358 }
2359 }
2360
2361 #define X_GLrop_Lightfv 87
2362 void
2363 __indirect_glLightfv(GLenum light, GLenum pname, const GLfloat * params)
2364 {
2365 __GLXcontext *const gc = __glXGetCurrentContext();
2366 const GLuint compsize = __glLightfv_size(pname);
2367 const GLuint cmdlen = 12 + __GLX_PAD((compsize * 4));
2368 emit_header(gc->pc, X_GLrop_Lightfv, cmdlen);
2369 (void) memcpy((void *) (gc->pc + 4), (void *) (&light), 4);
2370 (void) memcpy((void *) (gc->pc + 8), (void *) (&pname), 4);
2371 (void) memcpy((void *) (gc->pc + 12), (void *) (params), (compsize * 4));
2372 gc->pc += cmdlen;
2373 if (__builtin_expect(gc->pc > gc->limit, 0)) {
2374 (void) __glXFlushRenderBuffer(gc, gc->pc);
2375 }
2376 }
2377
2378 #define X_GLrop_Lighti 88
2379 void
2380 __indirect_glLighti(GLenum light, GLenum pname, GLint param)
2381 {
2382 __GLXcontext *const gc = __glXGetCurrentContext();
2383 const GLuint cmdlen = 16;
2384 emit_header(gc->pc, X_GLrop_Lighti, cmdlen);
2385 (void) memcpy((void *) (gc->pc + 4), (void *) (&light), 4);
2386 (void) memcpy((void *) (gc->pc + 8), (void *) (&pname), 4);
2387 (void) memcpy((void *) (gc->pc + 12), (void *) (&param), 4);
2388 gc->pc += cmdlen;
2389 if (__builtin_expect(gc->pc > gc->limit, 0)) {
2390 (void) __glXFlushRenderBuffer(gc, gc->pc);
2391 }
2392 }
2393
2394 #define X_GLrop_Lightiv 89
2395 void
2396 __indirect_glLightiv(GLenum light, GLenum pname, const GLint * params)
2397 {
2398 __GLXcontext *const gc = __glXGetCurrentContext();
2399 const GLuint compsize = __glLightiv_size(pname);
2400 const GLuint cmdlen = 12 + __GLX_PAD((compsize * 4));
2401 emit_header(gc->pc, X_GLrop_Lightiv, cmdlen);
2402 (void) memcpy((void *) (gc->pc + 4), (void *) (&light), 4);
2403 (void) memcpy((void *) (gc->pc + 8), (void *) (&pname), 4);
2404 (void) memcpy((void *) (gc->pc + 12), (void *) (params), (compsize * 4));
2405 gc->pc += cmdlen;
2406 if (__builtin_expect(gc->pc > gc->limit, 0)) {
2407 (void) __glXFlushRenderBuffer(gc, gc->pc);
2408 }
2409 }
2410
2411 #define X_GLrop_LightModelf 90
2412 void
2413 __indirect_glLightModelf(GLenum pname, GLfloat param)
2414 {
2415 __GLXcontext *const gc = __glXGetCurrentContext();
2416 const GLuint cmdlen = 12;
2417 emit_header(gc->pc, X_GLrop_LightModelf, cmdlen);
2418 (void) memcpy((void *) (gc->pc + 4), (void *) (&pname), 4);
2419 (void) memcpy((void *) (gc->pc + 8), (void *) (&param), 4);
2420 gc->pc += cmdlen;
2421 if (__builtin_expect(gc->pc > gc->limit, 0)) {
2422 (void) __glXFlushRenderBuffer(gc, gc->pc);
2423 }
2424 }
2425
2426 #define X_GLrop_LightModelfv 91
2427 void
2428 __indirect_glLightModelfv(GLenum pname, const GLfloat * params)
2429 {
2430 __GLXcontext *const gc = __glXGetCurrentContext();
2431 const GLuint compsize = __glLightModelfv_size(pname);
2432 const GLuint cmdlen = 8 + __GLX_PAD((compsize * 4));
2433 emit_header(gc->pc, X_GLrop_LightModelfv, cmdlen);
2434 (void) memcpy((void *) (gc->pc + 4), (void *) (&pname), 4);
2435 (void) memcpy((void *) (gc->pc + 8), (void *) (params), (compsize * 4));
2436 gc->pc += cmdlen;
2437 if (__builtin_expect(gc->pc > gc->limit, 0)) {
2438 (void) __glXFlushRenderBuffer(gc, gc->pc);
2439 }
2440 }
2441
2442 #define X_GLrop_LightModeli 92
2443 void
2444 __indirect_glLightModeli(GLenum pname, GLint param)
2445 {
2446 __GLXcontext *const gc = __glXGetCurrentContext();
2447 const GLuint cmdlen = 12;
2448 emit_header(gc->pc, X_GLrop_LightModeli, cmdlen);
2449 (void) memcpy((void *) (gc->pc + 4), (void *) (&pname), 4);
2450 (void) memcpy((void *) (gc->pc + 8), (void *) (&param), 4);
2451 gc->pc += cmdlen;
2452 if (__builtin_expect(gc->pc > gc->limit, 0)) {
2453 (void) __glXFlushRenderBuffer(gc, gc->pc);
2454 }
2455 }
2456
2457 #define X_GLrop_LightModeliv 93
2458 void
2459 __indirect_glLightModeliv(GLenum pname, const GLint * params)
2460 {
2461 __GLXcontext *const gc = __glXGetCurrentContext();
2462 const GLuint compsize = __glLightModeliv_size(pname);
2463 const GLuint cmdlen = 8 + __GLX_PAD((compsize * 4));
2464 emit_header(gc->pc, X_GLrop_LightModeliv, cmdlen);
2465 (void) memcpy((void *) (gc->pc + 4), (void *) (&pname), 4);
2466 (void) memcpy((void *) (gc->pc + 8), (void *) (params), (compsize * 4));
2467 gc->pc += cmdlen;
2468 if (__builtin_expect(gc->pc > gc->limit, 0)) {
2469 (void) __glXFlushRenderBuffer(gc, gc->pc);
2470 }
2471 }
2472
2473 #define X_GLrop_LineStipple 94
2474 void
2475 __indirect_glLineStipple(GLint factor, GLushort pattern)
2476 {
2477 __GLXcontext *const gc = __glXGetCurrentContext();
2478 const GLuint cmdlen = 12;
2479 emit_header(gc->pc, X_GLrop_LineStipple, cmdlen);
2480 (void) memcpy((void *) (gc->pc + 4), (void *) (&factor), 4);
2481 (void) memcpy((void *) (gc->pc + 8), (void *) (&pattern), 2);
2482 gc->pc += cmdlen;
2483 if (__builtin_expect(gc->pc > gc->limit, 0)) {
2484 (void) __glXFlushRenderBuffer(gc, gc->pc);
2485 }
2486 }
2487
2488 #define X_GLrop_LineWidth 95
2489 void
2490 __indirect_glLineWidth(GLfloat width)
2491 {
2492 __GLXcontext *const gc = __glXGetCurrentContext();
2493 const GLuint cmdlen = 8;
2494 emit_header(gc->pc, X_GLrop_LineWidth, cmdlen);
2495 (void) memcpy((void *) (gc->pc + 4), (void *) (&width), 4);
2496 gc->pc += cmdlen;
2497 if (__builtin_expect(gc->pc > gc->limit, 0)) {
2498 (void) __glXFlushRenderBuffer(gc, gc->pc);
2499 }
2500 }
2501
2502 #define X_GLrop_Materialf 96
2503 void
2504 __indirect_glMaterialf(GLenum face, GLenum pname, GLfloat param)
2505 {
2506 __GLXcontext *const gc = __glXGetCurrentContext();
2507 const GLuint cmdlen = 16;
2508 emit_header(gc->pc, X_GLrop_Materialf, cmdlen);
2509 (void) memcpy((void *) (gc->pc + 4), (void *) (&face), 4);
2510 (void) memcpy((void *) (gc->pc + 8), (void *) (&pname), 4);
2511 (void) memcpy((void *) (gc->pc + 12), (void *) (&param), 4);
2512 gc->pc += cmdlen;
2513 if (__builtin_expect(gc->pc > gc->limit, 0)) {
2514 (void) __glXFlushRenderBuffer(gc, gc->pc);
2515 }
2516 }
2517
2518 #define X_GLrop_Materialfv 97
2519 void
2520 __indirect_glMaterialfv(GLenum face, GLenum pname, const GLfloat * params)
2521 {
2522 __GLXcontext *const gc = __glXGetCurrentContext();
2523 const GLuint compsize = __glMaterialfv_size(pname);
2524 const GLuint cmdlen = 12 + __GLX_PAD((compsize * 4));
2525 emit_header(gc->pc, X_GLrop_Materialfv, cmdlen);
2526 (void) memcpy((void *) (gc->pc + 4), (void *) (&face), 4);
2527 (void) memcpy((void *) (gc->pc + 8), (void *) (&pname), 4);
2528 (void) memcpy((void *) (gc->pc + 12), (void *) (params), (compsize * 4));
2529 gc->pc += cmdlen;
2530 if (__builtin_expect(gc->pc > gc->limit, 0)) {
2531 (void) __glXFlushRenderBuffer(gc, gc->pc);
2532 }
2533 }
2534
2535 #define X_GLrop_Materiali 98
2536 void
2537 __indirect_glMateriali(GLenum face, GLenum pname, GLint param)
2538 {
2539 __GLXcontext *const gc = __glXGetCurrentContext();
2540 const GLuint cmdlen = 16;
2541 emit_header(gc->pc, X_GLrop_Materiali, cmdlen);
2542 (void) memcpy((void *) (gc->pc + 4), (void *) (&face), 4);
2543 (void) memcpy((void *) (gc->pc + 8), (void *) (&pname), 4);
2544 (void) memcpy((void *) (gc->pc + 12), (void *) (&param), 4);
2545 gc->pc += cmdlen;
2546 if (__builtin_expect(gc->pc > gc->limit, 0)) {
2547 (void) __glXFlushRenderBuffer(gc, gc->pc);
2548 }
2549 }
2550
2551 #define X_GLrop_Materialiv 99
2552 void
2553 __indirect_glMaterialiv(GLenum face, GLenum pname, const GLint * params)
2554 {
2555 __GLXcontext *const gc = __glXGetCurrentContext();
2556 const GLuint compsize = __glMaterialiv_size(pname);
2557 const GLuint cmdlen = 12 + __GLX_PAD((compsize * 4));
2558 emit_header(gc->pc, X_GLrop_Materialiv, cmdlen);
2559 (void) memcpy((void *) (gc->pc + 4), (void *) (&face), 4);
2560 (void) memcpy((void *) (gc->pc + 8), (void *) (&pname), 4);
2561 (void) memcpy((void *) (gc->pc + 12), (void *) (params), (compsize * 4));
2562 gc->pc += cmdlen;
2563 if (__builtin_expect(gc->pc > gc->limit, 0)) {
2564 (void) __glXFlushRenderBuffer(gc, gc->pc);
2565 }
2566 }
2567
2568 #define X_GLrop_PointSize 100
2569 void
2570 __indirect_glPointSize(GLfloat size)
2571 {
2572 __GLXcontext *const gc = __glXGetCurrentContext();
2573 const GLuint cmdlen = 8;
2574 emit_header(gc->pc, X_GLrop_PointSize, cmdlen);
2575 (void) memcpy((void *) (gc->pc + 4), (void *) (&size), 4);
2576 gc->pc += cmdlen;
2577 if (__builtin_expect(gc->pc > gc->limit, 0)) {
2578 (void) __glXFlushRenderBuffer(gc, gc->pc);
2579 }
2580 }
2581
2582 #define X_GLrop_PolygonMode 101
2583 void
2584 __indirect_glPolygonMode(GLenum face, GLenum mode)
2585 {
2586 __GLXcontext *const gc = __glXGetCurrentContext();
2587 const GLuint cmdlen = 12;
2588 emit_header(gc->pc, X_GLrop_PolygonMode, cmdlen);
2589 (void) memcpy((void *) (gc->pc + 4), (void *) (&face), 4);
2590 (void) memcpy((void *) (gc->pc + 8), (void *) (&mode), 4);
2591 gc->pc += cmdlen;
2592 if (__builtin_expect(gc->pc > gc->limit, 0)) {
2593 (void) __glXFlushRenderBuffer(gc, gc->pc);
2594 }
2595 }
2596
2597 #define X_GLrop_PolygonStipple 102
2598 void
2599 __indirect_glPolygonStipple(const GLubyte *mask)
2600 {
2601 __GLXcontext *const gc = __glXGetCurrentContext();
2602 const GLuint compsize =
2603 (mask != NULL) ? __glImageSize(32, 32, 1, GL_COLOR_INDEX, GL_BITMAP,
2604 0) : 0;
2605 const GLuint cmdlen = 24 + __GLX_PAD(compsize);
2606 emit_header(gc->pc, X_GLrop_PolygonStipple, cmdlen);
2607 if (compsize > 0) {
2608 (*gc->fillImage) (gc, 2, 32, 32, 1, GL_COLOR_INDEX, GL_BITMAP, mask,
2609 gc->pc + 24, gc->pc + 4);
2610 } else {
2611 (void) memcpy(gc->pc + 4, default_pixel_store_2D,
2612 default_pixel_store_2D_size);
2613 }
2614 gc->pc += cmdlen;
2615 if (gc->pc > gc->limit) {
2616 (void) __glXFlushRenderBuffer(gc, gc->pc);
2617 }
2618 }
2619
2620 #define X_GLrop_Scissor 103
2621 void
2622 __indirect_glScissor(GLint x, GLint y, GLsizei width, GLsizei height)
2623 {
2624 __GLXcontext *const gc = __glXGetCurrentContext();
2625 const GLuint cmdlen = 20;
2626 emit_header(gc->pc, X_GLrop_Scissor, cmdlen);
2627 (void) memcpy((void *) (gc->pc + 4), (void *) (&x), 4);
2628 (void) memcpy((void *) (gc->pc + 8), (void *) (&y), 4);
2629 (void) memcpy((void *) (gc->pc + 12), (void *) (&width), 4);
2630 (void) memcpy((void *) (gc->pc + 16), (void *) (&height), 4);
2631 gc->pc += cmdlen;
2632 if (__builtin_expect(gc->pc > gc->limit, 0)) {
2633 (void) __glXFlushRenderBuffer(gc, gc->pc);
2634 }
2635 }
2636
2637 #define X_GLrop_ShadeModel 104
2638 void
2639 __indirect_glShadeModel(GLenum mode)
2640 {
2641 __GLXcontext *const gc = __glXGetCurrentContext();
2642 const GLuint cmdlen = 8;
2643 emit_header(gc->pc, X_GLrop_ShadeModel, cmdlen);
2644 (void) memcpy((void *) (gc->pc + 4), (void *) (&mode), 4);
2645 gc->pc += cmdlen;
2646 if (__builtin_expect(gc->pc > gc->limit, 0)) {
2647 (void) __glXFlushRenderBuffer(gc, gc->pc);
2648 }
2649 }
2650
2651 #define X_GLrop_TexParameterf 105
2652 void
2653 __indirect_glTexParameterf(GLenum target, GLenum pname, GLfloat param)
2654 {
2655 __GLXcontext *const gc = __glXGetCurrentContext();
2656 const GLuint cmdlen = 16;
2657 emit_header(gc->pc, X_GLrop_TexParameterf, cmdlen);
2658 (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4);
2659 (void) memcpy((void *) (gc->pc + 8), (void *) (&pname), 4);
2660 (void) memcpy((void *) (gc->pc + 12), (void *) (&param), 4);
2661 gc->pc += cmdlen;
2662 if (__builtin_expect(gc->pc > gc->limit, 0)) {
2663 (void) __glXFlushRenderBuffer(gc, gc->pc);
2664 }
2665 }
2666
2667 #define X_GLrop_TexParameterfv 106
2668 void
2669 __indirect_glTexParameterfv(GLenum target, GLenum pname,
2670 const GLfloat * params)
2671 {
2672 __GLXcontext *const gc = __glXGetCurrentContext();
2673 const GLuint compsize = __glTexParameterfv_size(pname);
2674 const GLuint cmdlen = 12 + __GLX_PAD((compsize * 4));
2675 emit_header(gc->pc, X_GLrop_TexParameterfv, cmdlen);
2676 (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4);
2677 (void) memcpy((void *) (gc->pc + 8), (void *) (&pname), 4);
2678 (void) memcpy((void *) (gc->pc + 12), (void *) (params), (compsize * 4));
2679 gc->pc += cmdlen;
2680 if (__builtin_expect(gc->pc > gc->limit, 0)) {
2681 (void) __glXFlushRenderBuffer(gc, gc->pc);
2682 }
2683 }
2684
2685 #define X_GLrop_TexParameteri 107
2686 void
2687 __indirect_glTexParameteri(GLenum target, GLenum pname, GLint param)
2688 {
2689 __GLXcontext *const gc = __glXGetCurrentContext();
2690 const GLuint cmdlen = 16;
2691 emit_header(gc->pc, X_GLrop_TexParameteri, cmdlen);
2692 (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4);
2693 (void) memcpy((void *) (gc->pc + 8), (void *) (&pname), 4);
2694 (void) memcpy((void *) (gc->pc + 12), (void *) (&param), 4);
2695 gc->pc += cmdlen;
2696 if (__builtin_expect(gc->pc > gc->limit, 0)) {
2697 (void) __glXFlushRenderBuffer(gc, gc->pc);
2698 }
2699 }
2700
2701 #define X_GLrop_TexParameteriv 108
2702 void
2703 __indirect_glTexParameteriv(GLenum target, GLenum pname, const GLint * params)
2704 {
2705 __GLXcontext *const gc = __glXGetCurrentContext();
2706 const GLuint compsize = __glTexParameteriv_size(pname);
2707 const GLuint cmdlen = 12 + __GLX_PAD((compsize * 4));
2708 emit_header(gc->pc, X_GLrop_TexParameteriv, cmdlen);
2709 (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4);
2710 (void) memcpy((void *) (gc->pc + 8), (void *) (&pname), 4);
2711 (void) memcpy((void *) (gc->pc + 12), (void *) (params), (compsize * 4));
2712 gc->pc += cmdlen;
2713 if (__builtin_expect(gc->pc > gc->limit, 0)) {
2714 (void) __glXFlushRenderBuffer(gc, gc->pc);
2715 }
2716 }
2717
2718 static void
2719 __glx_TexImage_1D2D(unsigned opcode, unsigned dim, GLenum target, GLint level,
2720 GLint internalformat, GLsizei width, GLsizei height,
2721 GLint border, GLenum format, GLenum type,
2722 const GLvoid * pixels)
2723 {
2724 __GLXcontext *const gc = __glXGetCurrentContext();
2725 const GLuint compsize =
2726 __glImageSize(width, height, 1, format, type, target);
2727 const GLuint cmdlen = 56 + __GLX_PAD(compsize);
2728 if (__builtin_expect(gc->currentDpy != NULL, 1)) {
2729 if (cmdlen <= gc->maxSmallRenderCommandSize) {
2730 if ((gc->pc + cmdlen) > gc->bufEnd) {
2731 (void) __glXFlushRenderBuffer(gc, gc->pc);
2732 }
2733 emit_header(gc->pc, opcode, cmdlen);
2734 (void) memcpy((void *) (gc->pc + 24), (void *) (&target), 4);
2735 (void) memcpy((void *) (gc->pc + 28), (void *) (&level), 4);
2736 (void) memcpy((void *) (gc->pc + 32), (void *) (&internalformat),
2737 4);
2738 (void) memcpy((void *) (gc->pc + 36), (void *) (&width), 4);
2739 (void) memcpy((void *) (gc->pc + 40), (void *) (&height), 4);
2740 (void) memcpy((void *) (gc->pc + 44), (void *) (&border), 4);
2741 (void) memcpy((void *) (gc->pc + 48), (void *) (&format), 4);
2742 (void) memcpy((void *) (gc->pc + 52), (void *) (&type), 4);
2743 if ((compsize > 0) && (pixels != NULL)) {
2744 (*gc->fillImage) (gc, dim, width, height, 1, format, type,
2745 pixels, gc->pc + 56, gc->pc + 4);
2746 } else {
2747 (void) memcpy(gc->pc + 4, default_pixel_store_2D,
2748 default_pixel_store_2D_size);
2749 }
2750 gc->pc += cmdlen;
2751 if (gc->pc > gc->limit) {
2752 (void) __glXFlushRenderBuffer(gc, gc->pc);
2753 }
2754 } else {
2755 const GLint op = opcode;
2756 const GLuint cmdlenLarge = cmdlen + 4;
2757 GLubyte *const pc = __glXFlushRenderBuffer(gc, gc->pc);
2758 (void) memcpy((void *) (pc + 0), (void *) (&cmdlenLarge), 4);
2759 (void) memcpy((void *) (pc + 4), (void *) (&op), 4);
2760 (void) memcpy((void *) (pc + 28), (void *) (&target), 4);
2761 (void) memcpy((void *) (pc + 32), (void *) (&level), 4);
2762 (void) memcpy((void *) (pc + 36), (void *) (&internalformat), 4);
2763 (void) memcpy((void *) (pc + 40), (void *) (&width), 4);
2764 (void) memcpy((void *) (pc + 44), (void *) (&height), 4);
2765 (void) memcpy((void *) (pc + 48), (void *) (&border), 4);
2766 (void) memcpy((void *) (pc + 52), (void *) (&format), 4);
2767 (void) memcpy((void *) (pc + 56), (void *) (&type), 4);
2768 __glXSendLargeImage(gc, compsize, dim, width, height, 1, format,
2769 type, pixels, pc + 60, pc + 8);
2770 }
2771 }
2772 }
2773
2774 #define X_GLrop_TexImage1D 109
2775 void
2776 __indirect_glTexImage1D(GLenum target, GLint level, GLint internalformat,
2777 GLsizei width, GLint border, GLenum format,
2778 GLenum type, const GLvoid * pixels)
2779 {
2780 __glx_TexImage_1D2D(X_GLrop_TexImage1D, 1, target, level, internalformat,
2781 width, 1, border, format, type, pixels);
2782 }
2783
2784 #define X_GLrop_TexImage2D 110
2785 void
2786 __indirect_glTexImage2D(GLenum target, GLint level, GLint internalformat,
2787 GLsizei width, GLsizei height, GLint border,
2788 GLenum format, GLenum type, const GLvoid * pixels)
2789 {
2790 __glx_TexImage_1D2D(X_GLrop_TexImage2D, 2, target, level, internalformat,
2791 width, height, border, format, type, pixels);
2792 }
2793
2794 #define X_GLrop_TexEnvf 111
2795 void
2796 __indirect_glTexEnvf(GLenum target, GLenum pname, GLfloat param)
2797 {
2798 __GLXcontext *const gc = __glXGetCurrentContext();
2799 const GLuint cmdlen = 16;
2800 emit_header(gc->pc, X_GLrop_TexEnvf, cmdlen);
2801 (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4);
2802 (void) memcpy((void *) (gc->pc + 8), (void *) (&pname), 4);
2803 (void) memcpy((void *) (gc->pc + 12), (void *) (&param), 4);
2804 gc->pc += cmdlen;
2805 if (__builtin_expect(gc->pc > gc->limit, 0)) {
2806 (void) __glXFlushRenderBuffer(gc, gc->pc);
2807 }
2808 }
2809
2810 #define X_GLrop_TexEnvfv 112
2811 void
2812 __indirect_glTexEnvfv(GLenum target, GLenum pname, const GLfloat * params)
2813 {
2814 __GLXcontext *const gc = __glXGetCurrentContext();
2815 const GLuint compsize = __glTexEnvfv_size(pname);
2816 const GLuint cmdlen = 12 + __GLX_PAD((compsize * 4));
2817 emit_header(gc->pc, X_GLrop_TexEnvfv, cmdlen);
2818 (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4);
2819 (void) memcpy((void *) (gc->pc + 8), (void *) (&pname), 4);
2820 (void) memcpy((void *) (gc->pc + 12), (void *) (params), (compsize * 4));
2821 gc->pc += cmdlen;
2822 if (__builtin_expect(gc->pc > gc->limit, 0)) {
2823 (void) __glXFlushRenderBuffer(gc, gc->pc);
2824 }
2825 }
2826
2827 #define X_GLrop_TexEnvi 113
2828 void
2829 __indirect_glTexEnvi(GLenum target, GLenum pname, GLint param)
2830 {
2831 __GLXcontext *const gc = __glXGetCurrentContext();
2832 const GLuint cmdlen = 16;
2833 emit_header(gc->pc, X_GLrop_TexEnvi, cmdlen);
2834 (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4);
2835 (void) memcpy((void *) (gc->pc + 8), (void *) (&pname), 4);
2836 (void) memcpy((void *) (gc->pc + 12), (void *) (&param), 4);
2837 gc->pc += cmdlen;
2838 if (__builtin_expect(gc->pc > gc->limit, 0)) {
2839 (void) __glXFlushRenderBuffer(gc, gc->pc);
2840 }
2841 }
2842
2843 #define X_GLrop_TexEnviv 114
2844 void
2845 __indirect_glTexEnviv(GLenum target, GLenum pname, const GLint * params)
2846 {
2847 __GLXcontext *const gc = __glXGetCurrentContext();
2848 const GLuint compsize = __glTexEnviv_size(pname);
2849 const GLuint cmdlen = 12 + __GLX_PAD((compsize * 4));
2850 emit_header(gc->pc, X_GLrop_TexEnviv, cmdlen);
2851 (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4);
2852 (void) memcpy((void *) (gc->pc + 8), (void *) (&pname), 4);
2853 (void) memcpy((void *) (gc->pc + 12), (void *) (params), (compsize * 4));
2854 gc->pc += cmdlen;
2855 if (__builtin_expect(gc->pc > gc->limit, 0)) {
2856 (void) __glXFlushRenderBuffer(gc, gc->pc);
2857 }
2858 }
2859
2860 #define X_GLrop_TexGend 115
2861 void
2862 __indirect_glTexGend(GLenum coord, GLenum pname, GLdouble param)
2863 {
2864 __GLXcontext *const gc = __glXGetCurrentContext();
2865 const GLuint cmdlen = 20;
2866 emit_header(gc->pc, X_GLrop_TexGend, cmdlen);
2867 (void) memcpy((void *) (gc->pc + 4), (void *) (&param), 8);
2868 (void) memcpy((void *) (gc->pc + 12), (void *) (&coord), 4);
2869 (void) memcpy((void *) (gc->pc + 16), (void *) (&pname), 4);
2870 gc->pc += cmdlen;
2871 if (__builtin_expect(gc->pc > gc->limit, 0)) {
2872 (void) __glXFlushRenderBuffer(gc, gc->pc);
2873 }
2874 }
2875
2876 #define X_GLrop_TexGendv 116
2877 void
2878 __indirect_glTexGendv(GLenum coord, GLenum pname, const GLdouble * params)
2879 {
2880 __GLXcontext *const gc = __glXGetCurrentContext();
2881 const GLuint compsize = __glTexGendv_size(pname);
2882 const GLuint cmdlen = 12 + __GLX_PAD((compsize * 8));
2883 emit_header(gc->pc, X_GLrop_TexGendv, cmdlen);
2884 (void) memcpy((void *) (gc->pc + 4), (void *) (&coord), 4);
2885 (void) memcpy((void *) (gc->pc + 8), (void *) (&pname), 4);
2886 (void) memcpy((void *) (gc->pc + 12), (void *) (params), (compsize * 8));
2887 gc->pc += cmdlen;
2888 if (__builtin_expect(gc->pc > gc->limit, 0)) {
2889 (void) __glXFlushRenderBuffer(gc, gc->pc);
2890 }
2891 }
2892
2893 #define X_GLrop_TexGenf 117
2894 void
2895 __indirect_glTexGenf(GLenum coord, GLenum pname, GLfloat param)
2896 {
2897 __GLXcontext *const gc = __glXGetCurrentContext();
2898 const GLuint cmdlen = 16;
2899 emit_header(gc->pc, X_GLrop_TexGenf, cmdlen);
2900 (void) memcpy((void *) (gc->pc + 4), (void *) (&coord), 4);
2901 (void) memcpy((void *) (gc->pc + 8), (void *) (&pname), 4);
2902 (void) memcpy((void *) (gc->pc + 12), (void *) (&param), 4);
2903 gc->pc += cmdlen;
2904 if (__builtin_expect(gc->pc > gc->limit, 0)) {
2905 (void) __glXFlushRenderBuffer(gc, gc->pc);
2906 }
2907 }
2908
2909 #define X_GLrop_TexGenfv 118
2910 void
2911 __indirect_glTexGenfv(GLenum coord, GLenum pname, const GLfloat * params)
2912 {
2913 __GLXcontext *const gc = __glXGetCurrentContext();
2914 const GLuint compsize = __glTexGenfv_size(pname);
2915 const GLuint cmdlen = 12 + __GLX_PAD((compsize * 4));
2916 emit_header(gc->pc, X_GLrop_TexGenfv, cmdlen);
2917 (void) memcpy((void *) (gc->pc + 4), (void *) (&coord), 4);
2918 (void) memcpy((void *) (gc->pc + 8), (void *) (&pname), 4);
2919 (void) memcpy((void *) (gc->pc + 12), (void *) (params), (compsize * 4));
2920 gc->pc += cmdlen;
2921 if (__builtin_expect(gc->pc > gc->limit, 0)) {
2922 (void) __glXFlushRenderBuffer(gc, gc->pc);
2923 }
2924 }
2925
2926 #define X_GLrop_TexGeni 119
2927 void
2928 __indirect_glTexGeni(GLenum coord, GLenum pname, GLint param)
2929 {
2930 __GLXcontext *const gc = __glXGetCurrentContext();
2931 const GLuint cmdlen = 16;
2932 emit_header(gc->pc, X_GLrop_TexGeni, cmdlen);
2933 (void) memcpy((void *) (gc->pc + 4), (void *) (&coord), 4);
2934 (void) memcpy((void *) (gc->pc + 8), (void *) (&pname), 4);
2935 (void) memcpy((void *) (gc->pc + 12), (void *) (&param), 4);
2936 gc->pc += cmdlen;
2937 if (__builtin_expect(gc->pc > gc->limit, 0)) {
2938 (void) __glXFlushRenderBuffer(gc, gc->pc);
2939 }
2940 }
2941
2942 #define X_GLrop_TexGeniv 120
2943 void
2944 __indirect_glTexGeniv(GLenum coord, GLenum pname, const GLint * params)
2945 {
2946 __GLXcontext *const gc = __glXGetCurrentContext();
2947 const GLuint compsize = __glTexGeniv_size(pname);
2948 const GLuint cmdlen = 12 + __GLX_PAD((compsize * 4));
2949 emit_header(gc->pc, X_GLrop_TexGeniv, cmdlen);
2950 (void) memcpy((void *) (gc->pc + 4), (void *) (&coord), 4);
2951 (void) memcpy((void *) (gc->pc + 8), (void *) (&pname), 4);
2952 (void) memcpy((void *) (gc->pc + 12), (void *) (params), (compsize * 4));
2953 gc->pc += cmdlen;
2954 if (__builtin_expect(gc->pc > gc->limit, 0)) {
2955 (void) __glXFlushRenderBuffer(gc, gc->pc);
2956 }
2957 }
2958
2959 #define X_GLrop_InitNames 121
2960 void
2961 __indirect_glInitNames(void)
2962 {
2963 __GLXcontext *const gc = __glXGetCurrentContext();
2964 const GLuint cmdlen = 4;
2965 emit_header(gc->pc, X_GLrop_InitNames, cmdlen);
2966 gc->pc += cmdlen;
2967 if (__builtin_expect(gc->pc > gc->limit, 0)) {
2968 (void) __glXFlushRenderBuffer(gc, gc->pc);
2969 }
2970 }
2971
2972 #define X_GLrop_LoadName 122
2973 void
2974 __indirect_glLoadName(GLuint name)
2975 {
2976 __GLXcontext *const gc = __glXGetCurrentContext();
2977 const GLuint cmdlen = 8;
2978 emit_header(gc->pc, X_GLrop_LoadName, cmdlen);
2979 (void) memcpy((void *) (gc->pc + 4), (void *) (&name), 4);
2980 gc->pc += cmdlen;
2981 if (__builtin_expect(gc->pc > gc->limit, 0)) {
2982 (void) __glXFlushRenderBuffer(gc, gc->pc);
2983 }
2984 }
2985
2986 #define X_GLrop_PassThrough 123
2987 void
2988 __indirect_glPassThrough(GLfloat token)
2989 {
2990 __GLXcontext *const gc = __glXGetCurrentContext();
2991 const GLuint cmdlen = 8;
2992 emit_header(gc->pc, X_GLrop_PassThrough, cmdlen);
2993 (void) memcpy((void *) (gc->pc + 4), (void *) (&token), 4);
2994 gc->pc += cmdlen;
2995 if (__builtin_expect(gc->pc > gc->limit, 0)) {
2996 (void) __glXFlushRenderBuffer(gc, gc->pc);
2997 }
2998 }
2999
3000 #define X_GLrop_PopName 124
3001 void
3002 __indirect_glPopName(void)
3003 {
3004 __GLXcontext *const gc = __glXGetCurrentContext();
3005 const GLuint cmdlen = 4;
3006 emit_header(gc->pc, X_GLrop_PopName, cmdlen);
3007 gc->pc += cmdlen;
3008 if (__builtin_expect(gc->pc > gc->limit, 0)) {
3009 (void) __glXFlushRenderBuffer(gc, gc->pc);
3010 }
3011 }
3012
3013 #define X_GLrop_PushName 125
3014 void
3015 __indirect_glPushName(GLuint name)
3016 {
3017 __GLXcontext *const gc = __glXGetCurrentContext();
3018 const GLuint cmdlen = 8;
3019 emit_header(gc->pc, X_GLrop_PushName, cmdlen);
3020 (void) memcpy((void *) (gc->pc + 4), (void *) (&name), 4);
3021 gc->pc += cmdlen;
3022 if (__builtin_expect(gc->pc > gc->limit, 0)) {
3023 (void) __glXFlushRenderBuffer(gc, gc->pc);
3024 }
3025 }
3026
3027 #define X_GLrop_DrawBuffer 126
3028 void
3029 __indirect_glDrawBuffer(GLenum mode)
3030 {
3031 __GLXcontext *const gc = __glXGetCurrentContext();
3032 const GLuint cmdlen = 8;
3033 emit_header(gc->pc, X_GLrop_DrawBuffer, cmdlen);
3034 (void) memcpy((void *) (gc->pc + 4), (void *) (&mode), 4);
3035 gc->pc += cmdlen;
3036 if (__builtin_expect(gc->pc > gc->limit, 0)) {
3037 (void) __glXFlushRenderBuffer(gc, gc->pc);
3038 }
3039 }
3040
3041 #define X_GLrop_Clear 127
3042 void
3043 __indirect_glClear(GLbitfield mask)
3044 {
3045 __GLXcontext *const gc = __glXGetCurrentContext();
3046 const GLuint cmdlen = 8;
3047 emit_header(gc->pc, X_GLrop_Clear, cmdlen);
3048 (void) memcpy((void *) (gc->pc + 4), (void *) (&mask), 4);
3049 gc->pc += cmdlen;
3050 if (__builtin_expect(gc->pc > gc->limit, 0)) {
3051 (void) __glXFlushRenderBuffer(gc, gc->pc);
3052 }
3053 }
3054
3055 #define X_GLrop_ClearAccum 128
3056 void
3057 __indirect_glClearAccum(GLfloat red, GLfloat green, GLfloat blue,
3058 GLfloat alpha)
3059 {
3060 __GLXcontext *const gc = __glXGetCurrentContext();
3061 const GLuint cmdlen = 20;
3062 emit_header(gc->pc, X_GLrop_ClearAccum, cmdlen);
3063 (void) memcpy((void *) (gc->pc + 4), (void *) (&red), 4);
3064 (void) memcpy((void *) (gc->pc + 8), (void *) (&green), 4);
3065 (void) memcpy((void *) (gc->pc + 12), (void *) (&blue), 4);
3066 (void) memcpy((void *) (gc->pc + 16), (void *) (&alpha), 4);
3067 gc->pc += cmdlen;
3068 if (__builtin_expect(gc->pc > gc->limit, 0)) {
3069 (void) __glXFlushRenderBuffer(gc, gc->pc);
3070 }
3071 }
3072
3073 #define X_GLrop_ClearIndex 129
3074 void
3075 __indirect_glClearIndex(GLfloat c)
3076 {
3077 __GLXcontext *const gc = __glXGetCurrentContext();
3078 const GLuint cmdlen = 8;
3079 emit_header(gc->pc, X_GLrop_ClearIndex, cmdlen);
3080 (void) memcpy((void *) (gc->pc + 4), (void *) (&c), 4);
3081 gc->pc += cmdlen;
3082 if (__builtin_expect(gc->pc > gc->limit, 0)) {
3083 (void) __glXFlushRenderBuffer(gc, gc->pc);
3084 }
3085 }
3086
3087 #define X_GLrop_ClearColor 130
3088 void
3089 __indirect_glClearColor(GLclampf red, GLclampf green, GLclampf blue,
3090 GLclampf alpha)
3091 {
3092 __GLXcontext *const gc = __glXGetCurrentContext();
3093 const GLuint cmdlen = 20;
3094 emit_header(gc->pc, X_GLrop_ClearColor, cmdlen);
3095 (void) memcpy((void *) (gc->pc + 4), (void *) (&red), 4);
3096 (void) memcpy((void *) (gc->pc + 8), (void *) (&green), 4);
3097 (void) memcpy((void *) (gc->pc + 12), (void *) (&blue), 4);
3098 (void) memcpy((void *) (gc->pc + 16), (void *) (&alpha), 4);
3099 gc->pc += cmdlen;
3100 if (__builtin_expect(gc->pc > gc->limit, 0)) {
3101 (void) __glXFlushRenderBuffer(gc, gc->pc);
3102 }
3103 }
3104
3105 #define X_GLrop_ClearStencil 131
3106 void
3107 __indirect_glClearStencil(GLint s)
3108 {
3109 __GLXcontext *const gc = __glXGetCurrentContext();
3110 const GLuint cmdlen = 8;
3111 emit_header(gc->pc, X_GLrop_ClearStencil, cmdlen);
3112 (void) memcpy((void *) (gc->pc + 4), (void *) (&s), 4);
3113 gc->pc += cmdlen;
3114 if (__builtin_expect(gc->pc > gc->limit, 0)) {
3115 (void) __glXFlushRenderBuffer(gc, gc->pc);
3116 }
3117 }
3118
3119 #define X_GLrop_ClearDepth 132
3120 void
3121 __indirect_glClearDepth(GLclampd depth)
3122 {
3123 __GLXcontext *const gc = __glXGetCurrentContext();
3124 const GLuint cmdlen = 12;
3125 emit_header(gc->pc, X_GLrop_ClearDepth, cmdlen);
3126 (void) memcpy((void *) (gc->pc + 4), (void *) (&depth), 8);
3127 gc->pc += cmdlen;
3128 if (__builtin_expect(gc->pc > gc->limit, 0)) {
3129 (void) __glXFlushRenderBuffer(gc, gc->pc);
3130 }
3131 }
3132
3133 #define X_GLrop_StencilMask 133
3134 void
3135 __indirect_glStencilMask(GLuint mask)
3136 {
3137 __GLXcontext *const gc = __glXGetCurrentContext();
3138 const GLuint cmdlen = 8;
3139 emit_header(gc->pc, X_GLrop_StencilMask, cmdlen);
3140 (void) memcpy((void *) (gc->pc + 4), (void *) (&mask), 4);
3141 gc->pc += cmdlen;
3142 if (__builtin_expect(gc->pc > gc->limit, 0)) {
3143 (void) __glXFlushRenderBuffer(gc, gc->pc);
3144 }
3145 }
3146
3147 #define X_GLrop_ColorMask 134
3148 void
3149 __indirect_glColorMask(GLboolean red, GLboolean green, GLboolean blue,
3150 GLboolean alpha)
3151 {
3152 __GLXcontext *const gc = __glXGetCurrentContext();
3153 const GLuint cmdlen = 8;
3154 emit_header(gc->pc, X_GLrop_ColorMask, cmdlen);
3155 (void) memcpy((void *) (gc->pc + 4), (void *) (&red), 1);
3156 (void) memcpy((void *) (gc->pc + 5), (void *) (&green), 1);
3157 (void) memcpy((void *) (gc->pc + 6), (void *) (&blue), 1);
3158 (void) memcpy((void *) (gc->pc + 7), (void *) (&alpha), 1);
3159 gc->pc += cmdlen;
3160 if (__builtin_expect(gc->pc > gc->limit, 0)) {
3161 (void) __glXFlushRenderBuffer(gc, gc->pc);
3162 }
3163 }
3164
3165 #define X_GLrop_DepthMask 135
3166 void
3167 __indirect_glDepthMask(GLboolean flag)
3168 {
3169 __GLXcontext *const gc = __glXGetCurrentContext();
3170 const GLuint cmdlen = 8;
3171 emit_header(gc->pc, X_GLrop_DepthMask, cmdlen);
3172 (void) memcpy((void *) (gc->pc + 4), (void *) (&flag), 1);
3173 gc->pc += cmdlen;
3174 if (__builtin_expect(gc->pc > gc->limit, 0)) {
3175 (void) __glXFlushRenderBuffer(gc, gc->pc);
3176 }
3177 }
3178
3179 #define X_GLrop_IndexMask 136
3180 void
3181 __indirect_glIndexMask(GLuint mask)
3182 {
3183 __GLXcontext *const gc = __glXGetCurrentContext();
3184 const GLuint cmdlen = 8;
3185 emit_header(gc->pc, X_GLrop_IndexMask, cmdlen);
3186 (void) memcpy((void *) (gc->pc + 4), (void *) (&mask), 4);
3187 gc->pc += cmdlen;
3188 if (__builtin_expect(gc->pc > gc->limit, 0)) {
3189 (void) __glXFlushRenderBuffer(gc, gc->pc);
3190 }
3191 }
3192
3193 #define X_GLrop_Accum 137
3194 void
3195 __indirect_glAccum(GLenum op, GLfloat value)
3196 {
3197 __GLXcontext *const gc = __glXGetCurrentContext();
3198 const GLuint cmdlen = 12;
3199 emit_header(gc->pc, X_GLrop_Accum, cmdlen);
3200 (void) memcpy((void *) (gc->pc + 4), (void *) (&op), 4);
3201 (void) memcpy((void *) (gc->pc + 8), (void *) (&value), 4);
3202 gc->pc += cmdlen;
3203 if (__builtin_expect(gc->pc > gc->limit, 0)) {
3204 (void) __glXFlushRenderBuffer(gc, gc->pc);
3205 }
3206 }
3207
3208 #define X_GLrop_PopAttrib 141
3209 void
3210 __indirect_glPopAttrib(void)
3211 {
3212 __GLXcontext *const gc = __glXGetCurrentContext();
3213 const GLuint cmdlen = 4;
3214 emit_header(gc->pc, X_GLrop_PopAttrib, cmdlen);
3215 gc->pc += cmdlen;
3216 if (__builtin_expect(gc->pc > gc->limit, 0)) {
3217 (void) __glXFlushRenderBuffer(gc, gc->pc);
3218 }
3219 }
3220
3221 #define X_GLrop_PushAttrib 142
3222 void
3223 __indirect_glPushAttrib(GLbitfield mask)
3224 {
3225 __GLXcontext *const gc = __glXGetCurrentContext();
3226 const GLuint cmdlen = 8;
3227 emit_header(gc->pc, X_GLrop_PushAttrib, cmdlen);
3228 (void) memcpy((void *) (gc->pc + 4), (void *) (&mask), 4);
3229 gc->pc += cmdlen;
3230 if (__builtin_expect(gc->pc > gc->limit, 0)) {
3231 (void) __glXFlushRenderBuffer(gc, gc->pc);
3232 }
3233 }
3234
3235 #define X_GLrop_MapGrid1d 147
3236 void
3237 __indirect_glMapGrid1d(GLint un, GLdouble u1, GLdouble u2)
3238 {
3239 __GLXcontext *const gc = __glXGetCurrentContext();
3240 const GLuint cmdlen = 24;
3241 emit_header(gc->pc, X_GLrop_MapGrid1d, cmdlen);
3242 (void) memcpy((void *) (gc->pc + 4), (void *) (&u1), 8);
3243 (void) memcpy((void *) (gc->pc + 12), (void *) (&u2), 8);
3244 (void) memcpy((void *) (gc->pc + 20), (void *) (&un), 4);
3245 gc->pc += cmdlen;
3246 if (__builtin_expect(gc->pc > gc->limit, 0)) {
3247 (void) __glXFlushRenderBuffer(gc, gc->pc);
3248 }
3249 }
3250
3251 #define X_GLrop_MapGrid1f 148
3252 void
3253 __indirect_glMapGrid1f(GLint un, GLfloat u1, GLfloat u2)
3254 {
3255 __GLXcontext *const gc = __glXGetCurrentContext();
3256 const GLuint cmdlen = 16;
3257 emit_header(gc->pc, X_GLrop_MapGrid1f, cmdlen);
3258 (void) memcpy((void *) (gc->pc + 4), (void *) (&un), 4);
3259 (void) memcpy((void *) (gc->pc + 8), (void *) (&u1), 4);
3260 (void) memcpy((void *) (gc->pc + 12), (void *) (&u2), 4);
3261 gc->pc += cmdlen;
3262 if (__builtin_expect(gc->pc > gc->limit, 0)) {
3263 (void) __glXFlushRenderBuffer(gc, gc->pc);
3264 }
3265 }
3266
3267 #define X_GLrop_MapGrid2d 149
3268 void
3269 __indirect_glMapGrid2d(GLint un, GLdouble u1, GLdouble u2, GLint vn,
3270 GLdouble v1, GLdouble v2)
3271 {
3272 __GLXcontext *const gc = __glXGetCurrentContext();
3273 const GLuint cmdlen = 44;
3274 emit_header(gc->pc, X_GLrop_MapGrid2d, cmdlen);
3275 (void) memcpy((void *) (gc->pc + 4), (void *) (&u1), 8);
3276 (void) memcpy((void *) (gc->pc + 12), (void *) (&u2), 8);
3277 (void) memcpy((void *) (gc->pc + 20), (void *) (&v1), 8);
3278 (void) memcpy((void *) (gc->pc + 28), (void *) (&v2), 8);
3279 (void) memcpy((void *) (gc->pc + 36), (void *) (&un), 4);
3280 (void) memcpy((void *) (gc->pc + 40), (void *) (&vn), 4);
3281 gc->pc += cmdlen;
3282 if (__builtin_expect(gc->pc > gc->limit, 0)) {
3283 (void) __glXFlushRenderBuffer(gc, gc->pc);
3284 }
3285 }
3286
3287 #define X_GLrop_MapGrid2f 150
3288 void
3289 __indirect_glMapGrid2f(GLint un, GLfloat u1, GLfloat u2, GLint vn, GLfloat v1,
3290 GLfloat v2)
3291 {
3292 __GLXcontext *const gc = __glXGetCurrentContext();
3293 const GLuint cmdlen = 28;
3294 emit_header(gc->pc, X_GLrop_MapGrid2f, cmdlen);
3295 (void) memcpy((void *) (gc->pc + 4), (void *) (&un), 4);
3296 (void) memcpy((void *) (gc->pc + 8), (void *) (&u1), 4);
3297 (void) memcpy((void *) (gc->pc + 12), (void *) (&u2), 4);
3298 (void) memcpy((void *) (gc->pc + 16), (void *) (&vn), 4);
3299 (void) memcpy((void *) (gc->pc + 20), (void *) (&v1), 4);
3300 (void) memcpy((void *) (gc->pc + 24), (void *) (&v2), 4);
3301 gc->pc += cmdlen;
3302 if (__builtin_expect(gc->pc > gc->limit, 0)) {
3303 (void) __glXFlushRenderBuffer(gc, gc->pc);
3304 }
3305 }
3306
3307 #define X_GLrop_EvalCoord1dv 151
3308 void
3309 __indirect_glEvalCoord1d(GLdouble u)
3310 {
3311 __GLXcontext *const gc = __glXGetCurrentContext();
3312 const GLuint cmdlen = 12;
3313 emit_header(gc->pc, X_GLrop_EvalCoord1dv, cmdlen);
3314 (void) memcpy((void *) (gc->pc + 4), (void *) (&u), 8);
3315 gc->pc += cmdlen;
3316 if (__builtin_expect(gc->pc > gc->limit, 0)) {
3317 (void) __glXFlushRenderBuffer(gc, gc->pc);
3318 }
3319 }
3320
3321 #define X_GLrop_EvalCoord1dv 151
3322 void
3323 __indirect_glEvalCoord1dv(const GLdouble * u)
3324 {
3325 generic_8_byte(X_GLrop_EvalCoord1dv, u);
3326 }
3327
3328 #define X_GLrop_EvalCoord1fv 152
3329 void
3330 __indirect_glEvalCoord1f(GLfloat u)
3331 {
3332 __GLXcontext *const gc = __glXGetCurrentContext();
3333 const GLuint cmdlen = 8;
3334 emit_header(gc->pc, X_GLrop_EvalCoord1fv, cmdlen);
3335 (void) memcpy((void *) (gc->pc + 4), (void *) (&u), 4);
3336 gc->pc += cmdlen;
3337 if (__builtin_expect(gc->pc > gc->limit, 0)) {
3338 (void) __glXFlushRenderBuffer(gc, gc->pc);
3339 }
3340 }
3341
3342 #define X_GLrop_EvalCoord1fv 152
3343 void
3344 __indirect_glEvalCoord1fv(const GLfloat * u)
3345 {
3346 generic_4_byte(X_GLrop_EvalCoord1fv, u);
3347 }
3348
3349 #define X_GLrop_EvalCoord2dv 153
3350 void
3351 __indirect_glEvalCoord2d(GLdouble u, GLdouble v)
3352 {
3353 __GLXcontext *const gc = __glXGetCurrentContext();
3354 const GLuint cmdlen = 20;
3355 emit_header(gc->pc, X_GLrop_EvalCoord2dv, cmdlen);
3356 (void) memcpy((void *) (gc->pc + 4), (void *) (&u), 8);
3357 (void) memcpy((void *) (gc->pc + 12), (void *) (&v), 8);
3358 gc->pc += cmdlen;
3359 if (__builtin_expect(gc->pc > gc->limit, 0)) {
3360 (void) __glXFlushRenderBuffer(gc, gc->pc);
3361 }
3362 }
3363
3364 #define X_GLrop_EvalCoord2dv 153
3365 void
3366 __indirect_glEvalCoord2dv(const GLdouble * u)
3367 {
3368 generic_16_byte(X_GLrop_EvalCoord2dv, u);
3369 }
3370
3371 #define X_GLrop_EvalCoord2fv 154
3372 void
3373 __indirect_glEvalCoord2f(GLfloat u, GLfloat v)
3374 {
3375 __GLXcontext *const gc = __glXGetCurrentContext();
3376 const GLuint cmdlen = 12;
3377 emit_header(gc->pc, X_GLrop_EvalCoord2fv, cmdlen);
3378 (void) memcpy((void *) (gc->pc + 4), (void *) (&u), 4);
3379 (void) memcpy((void *) (gc->pc + 8), (void *) (&v), 4);
3380 gc->pc += cmdlen;
3381 if (__builtin_expect(gc->pc > gc->limit, 0)) {
3382 (void) __glXFlushRenderBuffer(gc, gc->pc);
3383 }
3384 }
3385
3386 #define X_GLrop_EvalCoord2fv 154
3387 void
3388 __indirect_glEvalCoord2fv(const GLfloat * u)
3389 {
3390 generic_8_byte(X_GLrop_EvalCoord2fv, u);
3391 }
3392
3393 #define X_GLrop_EvalMesh1 155
3394 void
3395 __indirect_glEvalMesh1(GLenum mode, GLint i1, GLint i2)
3396 {
3397 __GLXcontext *const gc = __glXGetCurrentContext();
3398 const GLuint cmdlen = 16;
3399 emit_header(gc->pc, X_GLrop_EvalMesh1, cmdlen);
3400 (void) memcpy((void *) (gc->pc + 4), (void *) (&mode), 4);
3401 (void) memcpy((void *) (gc->pc + 8), (void *) (&i1), 4);
3402 (void) memcpy((void *) (gc->pc + 12), (void *) (&i2), 4);
3403 gc->pc += cmdlen;
3404 if (__builtin_expect(gc->pc > gc->limit, 0)) {
3405 (void) __glXFlushRenderBuffer(gc, gc->pc);
3406 }
3407 }
3408
3409 #define X_GLrop_EvalPoint1 156
3410 void
3411 __indirect_glEvalPoint1(GLint i)
3412 {
3413 __GLXcontext *const gc = __glXGetCurrentContext();
3414 const GLuint cmdlen = 8;
3415 emit_header(gc->pc, X_GLrop_EvalPoint1, cmdlen);
3416 (void) memcpy((void *) (gc->pc + 4), (void *) (&i), 4);
3417 gc->pc += cmdlen;
3418 if (__builtin_expect(gc->pc > gc->limit, 0)) {
3419 (void) __glXFlushRenderBuffer(gc, gc->pc);
3420 }
3421 }
3422
3423 #define X_GLrop_EvalMesh2 157
3424 void
3425 __indirect_glEvalMesh2(GLenum mode, GLint i1, GLint i2, GLint j1, GLint j2)
3426 {
3427 __GLXcontext *const gc = __glXGetCurrentContext();
3428 const GLuint cmdlen = 24;
3429 emit_header(gc->pc, X_GLrop_EvalMesh2, cmdlen);
3430 (void) memcpy((void *) (gc->pc + 4), (void *) (&mode), 4);
3431 (void) memcpy((void *) (gc->pc + 8), (void *) (&i1), 4);
3432 (void) memcpy((void *) (gc->pc + 12), (void *) (&i2), 4);
3433 (void) memcpy((void *) (gc->pc + 16), (void *) (&j1), 4);
3434 (void) memcpy((void *) (gc->pc + 20), (void *) (&j2), 4);
3435 gc->pc += cmdlen;
3436 if (__builtin_expect(gc->pc > gc->limit, 0)) {
3437 (void) __glXFlushRenderBuffer(gc, gc->pc);
3438 }
3439 }
3440
3441 #define X_GLrop_EvalPoint2 158
3442 void
3443 __indirect_glEvalPoint2(GLint i, GLint j)
3444 {
3445 __GLXcontext *const gc = __glXGetCurrentContext();
3446 const GLuint cmdlen = 12;
3447 emit_header(gc->pc, X_GLrop_EvalPoint2, cmdlen);
3448 (void) memcpy((void *) (gc->pc + 4), (void *) (&i), 4);
3449 (void) memcpy((void *) (gc->pc + 8), (void *) (&j), 4);
3450 gc->pc += cmdlen;
3451 if (__builtin_expect(gc->pc > gc->limit, 0)) {
3452 (void) __glXFlushRenderBuffer(gc, gc->pc);
3453 }
3454 }
3455
3456 #define X_GLrop_AlphaFunc 159
3457 void
3458 __indirect_glAlphaFunc(GLenum func, GLclampf ref)
3459 {
3460 __GLXcontext *const gc = __glXGetCurrentContext();
3461 const GLuint cmdlen = 12;
3462 emit_header(gc->pc, X_GLrop_AlphaFunc, cmdlen);
3463 (void) memcpy((void *) (gc->pc + 4), (void *) (&func), 4);
3464 (void) memcpy((void *) (gc->pc + 8), (void *) (&ref), 4);
3465 gc->pc += cmdlen;
3466 if (__builtin_expect(gc->pc > gc->limit, 0)) {
3467 (void) __glXFlushRenderBuffer(gc, gc->pc);
3468 }
3469 }
3470
3471 #define X_GLrop_BlendFunc 160
3472 void
3473 __indirect_glBlendFunc(GLenum sfactor, GLenum dfactor)
3474 {
3475 __GLXcontext *const gc = __glXGetCurrentContext();
3476 const GLuint cmdlen = 12;
3477 emit_header(gc->pc, X_GLrop_BlendFunc, cmdlen);
3478 (void) memcpy((void *) (gc->pc + 4), (void *) (&sfactor), 4);
3479 (void) memcpy((void *) (gc->pc + 8), (void *) (&dfactor), 4);
3480 gc->pc += cmdlen;
3481 if (__builtin_expect(gc->pc > gc->limit, 0)) {
3482 (void) __glXFlushRenderBuffer(gc, gc->pc);
3483 }
3484 }
3485
3486 #define X_GLrop_LogicOp 161
3487 void
3488 __indirect_glLogicOp(GLenum opcode)
3489 {
3490 __GLXcontext *const gc = __glXGetCurrentContext();
3491 const GLuint cmdlen = 8;
3492 emit_header(gc->pc, X_GLrop_LogicOp, cmdlen);
3493 (void) memcpy((void *) (gc->pc + 4), (void *) (&opcode), 4);
3494 gc->pc += cmdlen;
3495 if (__builtin_expect(gc->pc > gc->limit, 0)) {
3496 (void) __glXFlushRenderBuffer(gc, gc->pc);
3497 }
3498 }
3499
3500 #define X_GLrop_StencilFunc 162
3501 void
3502 __indirect_glStencilFunc(GLenum func, GLint ref, GLuint mask)
3503 {
3504 __GLXcontext *const gc = __glXGetCurrentContext();
3505 const GLuint cmdlen = 16;
3506 emit_header(gc->pc, X_GLrop_StencilFunc, cmdlen);
3507 (void) memcpy((void *) (gc->pc + 4), (void *) (&func), 4);
3508 (void) memcpy((void *) (gc->pc + 8), (void *) (&ref), 4);
3509 (void) memcpy((void *) (gc->pc + 12), (void *) (&mask), 4);
3510 gc->pc += cmdlen;
3511 if (__builtin_expect(gc->pc > gc->limit, 0)) {
3512 (void) __glXFlushRenderBuffer(gc, gc->pc);
3513 }
3514 }
3515
3516 #define X_GLrop_StencilOp 163
3517 void
3518 __indirect_glStencilOp(GLenum fail, GLenum zfail, GLenum zpass)
3519 {
3520 __GLXcontext *const gc = __glXGetCurrentContext();
3521 const GLuint cmdlen = 16;
3522 emit_header(gc->pc, X_GLrop_StencilOp, cmdlen);
3523 (void) memcpy((void *) (gc->pc + 4), (void *) (&fail), 4);
3524 (void) memcpy((void *) (gc->pc + 8), (void *) (&zfail), 4);
3525 (void) memcpy((void *) (gc->pc + 12), (void *) (&zpass), 4);
3526 gc->pc += cmdlen;
3527 if (__builtin_expect(gc->pc > gc->limit, 0)) {
3528 (void) __glXFlushRenderBuffer(gc, gc->pc);
3529 }
3530 }
3531
3532 #define X_GLrop_DepthFunc 164
3533 void
3534 __indirect_glDepthFunc(GLenum func)
3535 {
3536 __GLXcontext *const gc = __glXGetCurrentContext();
3537 const GLuint cmdlen = 8;
3538 emit_header(gc->pc, X_GLrop_DepthFunc, cmdlen);
3539 (void) memcpy((void *) (gc->pc + 4), (void *) (&func), 4);
3540 gc->pc += cmdlen;
3541 if (__builtin_expect(gc->pc > gc->limit, 0)) {
3542 (void) __glXFlushRenderBuffer(gc, gc->pc);
3543 }
3544 }
3545
3546 #define X_GLrop_PixelZoom 165
3547 void
3548 __indirect_glPixelZoom(GLfloat xfactor, GLfloat yfactor)
3549 {
3550 __GLXcontext *const gc = __glXGetCurrentContext();
3551 const GLuint cmdlen = 12;
3552 emit_header(gc->pc, X_GLrop_PixelZoom, cmdlen);
3553 (void) memcpy((void *) (gc->pc + 4), (void *) (&xfactor), 4);
3554 (void) memcpy((void *) (gc->pc + 8), (void *) (&yfactor), 4);
3555 gc->pc += cmdlen;
3556 if (__builtin_expect(gc->pc > gc->limit, 0)) {
3557 (void) __glXFlushRenderBuffer(gc, gc->pc);
3558 }
3559 }
3560
3561 #define X_GLrop_PixelTransferf 166
3562 void
3563 __indirect_glPixelTransferf(GLenum pname, GLfloat param)
3564 {
3565 __GLXcontext *const gc = __glXGetCurrentContext();
3566 const GLuint cmdlen = 12;
3567 emit_header(gc->pc, X_GLrop_PixelTransferf, cmdlen);
3568 (void) memcpy((void *) (gc->pc + 4), (void *) (&pname), 4);
3569 (void) memcpy((void *) (gc->pc + 8), (void *) (&param), 4);
3570 gc->pc += cmdlen;
3571 if (__builtin_expect(gc->pc > gc->limit, 0)) {
3572 (void) __glXFlushRenderBuffer(gc, gc->pc);
3573 }
3574 }
3575
3576 #define X_GLrop_PixelTransferi 167
3577 void
3578 __indirect_glPixelTransferi(GLenum pname, GLint param)
3579 {
3580 __GLXcontext *const gc = __glXGetCurrentContext();
3581 const GLuint cmdlen = 12;
3582 emit_header(gc->pc, X_GLrop_PixelTransferi, cmdlen);
3583 (void) memcpy((void *) (gc->pc + 4), (void *) (&pname), 4);
3584 (void) memcpy((void *) (gc->pc + 8), (void *) (&param), 4);
3585 gc->pc += cmdlen;
3586 if (__builtin_expect(gc->pc > gc->limit, 0)) {
3587 (void) __glXFlushRenderBuffer(gc, gc->pc);
3588 }
3589 }
3590
3591 #define X_GLrop_PixelMapfv 168
3592 void
3593 __indirect_glPixelMapfv(GLenum map, GLsizei mapsize, const GLfloat * values)
3594 {
3595 __GLXcontext *const gc = __glXGetCurrentContext();
3596 const GLuint cmdlen = 12 + __GLX_PAD((mapsize * 4));
3597 if (mapsize < 0) {
3598 __glXSetError(gc, GL_INVALID_VALUE);
3599 return;
3600 }
3601 if (__builtin_expect((mapsize >= 0) && (gc->currentDpy != NULL), 1)) {
3602 if (cmdlen <= gc->maxSmallRenderCommandSize) {
3603 if ((gc->pc + cmdlen) > gc->bufEnd) {
3604 (void) __glXFlushRenderBuffer(gc, gc->pc);
3605 }
3606 emit_header(gc->pc, X_GLrop_PixelMapfv, cmdlen);
3607 (void) memcpy((void *) (gc->pc + 4), (void *) (&map), 4);
3608 (void) memcpy((void *) (gc->pc + 8), (void *) (&mapsize), 4);
3609 (void) memcpy((void *) (gc->pc + 12), (void *) (values),
3610 (mapsize * 4));
3611 gc->pc += cmdlen;
3612 if (__builtin_expect(gc->pc > gc->limit, 0)) {
3613 (void) __glXFlushRenderBuffer(gc, gc->pc);
3614 }
3615 } else {
3616 const GLint op = X_GLrop_PixelMapfv;
3617 const GLuint cmdlenLarge = cmdlen + 4;
3618 GLubyte *const pc = __glXFlushRenderBuffer(gc, gc->pc);
3619 (void) memcpy((void *) (pc + 0), (void *) (&cmdlenLarge), 4);
3620 (void) memcpy((void *) (pc + 4), (void *) (&op), 4);
3621 (void) memcpy((void *) (pc + 8), (void *) (&map), 4);
3622 (void) memcpy((void *) (pc + 12), (void *) (&mapsize), 4);
3623 __glXSendLargeCommand(gc, pc, 16, values, (mapsize * 4));
3624 }
3625 }
3626 }
3627
3628 #define X_GLrop_PixelMapuiv 169
3629 void
3630 __indirect_glPixelMapuiv(GLenum map, GLsizei mapsize, const GLuint * values)
3631 {
3632 __GLXcontext *const gc = __glXGetCurrentContext();
3633 const GLuint cmdlen = 12 + __GLX_PAD((mapsize * 4));
3634 if (mapsize < 0) {
3635 __glXSetError(gc, GL_INVALID_VALUE);
3636 return;
3637 }
3638 if (__builtin_expect((mapsize >= 0) && (gc->currentDpy != NULL), 1)) {
3639 if (cmdlen <= gc->maxSmallRenderCommandSize) {
3640 if ((gc->pc + cmdlen) > gc->bufEnd) {
3641 (void) __glXFlushRenderBuffer(gc, gc->pc);
3642 }
3643 emit_header(gc->pc, X_GLrop_PixelMapuiv, cmdlen);
3644 (void) memcpy((void *) (gc->pc + 4), (void *) (&map), 4);
3645 (void) memcpy((void *) (gc->pc + 8), (void *) (&mapsize), 4);
3646 (void) memcpy((void *) (gc->pc + 12), (void *) (values),
3647 (mapsize * 4));
3648 gc->pc += cmdlen;
3649 if (__builtin_expect(gc->pc > gc->limit, 0)) {
3650 (void) __glXFlushRenderBuffer(gc, gc->pc);
3651 }
3652 } else {
3653 const GLint op = X_GLrop_PixelMapuiv;
3654 const GLuint cmdlenLarge = cmdlen + 4;
3655 GLubyte *const pc = __glXFlushRenderBuffer(gc, gc->pc);
3656 (void) memcpy((void *) (pc + 0), (void *) (&cmdlenLarge), 4);
3657 (void) memcpy((void *) (pc + 4), (void *) (&op), 4);
3658 (void) memcpy((void *) (pc + 8), (void *) (&map), 4);
3659 (void) memcpy((void *) (pc + 12), (void *) (&mapsize), 4);
3660 __glXSendLargeCommand(gc, pc, 16, values, (mapsize * 4));
3661 }
3662 }
3663 }
3664
3665 #define X_GLrop_PixelMapusv 170
3666 void
3667 __indirect_glPixelMapusv(GLenum map, GLsizei mapsize, const GLushort * values)
3668 {
3669 __GLXcontext *const gc = __glXGetCurrentContext();
3670 const GLuint cmdlen = 12 + __GLX_PAD((mapsize * 2));
3671 if (mapsize < 0) {
3672 __glXSetError(gc, GL_INVALID_VALUE);
3673 return;
3674 }
3675 if (__builtin_expect((mapsize >= 0) && (gc->currentDpy != NULL), 1)) {
3676 if (cmdlen <= gc->maxSmallRenderCommandSize) {
3677 if ((gc->pc + cmdlen) > gc->bufEnd) {
3678 (void) __glXFlushRenderBuffer(gc, gc->pc);
3679 }
3680 emit_header(gc->pc, X_GLrop_PixelMapusv, cmdlen);
3681 (void) memcpy((void *) (gc->pc + 4), (void *) (&map), 4);
3682 (void) memcpy((void *) (gc->pc + 8), (void *) (&mapsize), 4);
3683 (void) memcpy((void *) (gc->pc + 12), (void *) (values),
3684 (mapsize * 2));
3685 gc->pc += cmdlen;
3686 if (__builtin_expect(gc->pc > gc->limit, 0)) {
3687 (void) __glXFlushRenderBuffer(gc, gc->pc);
3688 }
3689 } else {
3690 const GLint op = X_GLrop_PixelMapusv;
3691 const GLuint cmdlenLarge = cmdlen + 4;
3692 GLubyte *const pc = __glXFlushRenderBuffer(gc, gc->pc);
3693 (void) memcpy((void *) (pc + 0), (void *) (&cmdlenLarge), 4);
3694 (void) memcpy((void *) (pc + 4), (void *) (&op), 4);
3695 (void) memcpy((void *) (pc + 8), (void *) (&map), 4);
3696 (void) memcpy((void *) (pc + 12), (void *) (&mapsize), 4);
3697 __glXSendLargeCommand(gc, pc, 16, values, (mapsize * 2));
3698 }
3699 }
3700 }
3701
3702 #define X_GLrop_ReadBuffer 171
3703 void
3704 __indirect_glReadBuffer(GLenum mode)
3705 {
3706 __GLXcontext *const gc = __glXGetCurrentContext();
3707 const GLuint cmdlen = 8;
3708 emit_header(gc->pc, X_GLrop_ReadBuffer, cmdlen);
3709 (void) memcpy((void *) (gc->pc + 4), (void *) (&mode), 4);
3710 gc->pc += cmdlen;
3711 if (__builtin_expect(gc->pc > gc->limit, 0)) {
3712 (void) __glXFlushRenderBuffer(gc, gc->pc);
3713 }
3714 }
3715
3716 #define X_GLrop_CopyPixels 172
3717 void
3718 __indirect_glCopyPixels(GLint x, GLint y, GLsizei width, GLsizei height,
3719 GLenum type)
3720 {
3721 __GLXcontext *const gc = __glXGetCurrentContext();
3722 const GLuint cmdlen = 24;
3723 emit_header(gc->pc, X_GLrop_CopyPixels, cmdlen);
3724 (void) memcpy((void *) (gc->pc + 4), (void *) (&x), 4);
3725 (void) memcpy((void *) (gc->pc + 8), (void *) (&y), 4);
3726 (void) memcpy((void *) (gc->pc + 12), (void *) (&width), 4);
3727 (void) memcpy((void *) (gc->pc + 16), (void *) (&height), 4);
3728 (void) memcpy((void *) (gc->pc + 20), (void *) (&type), 4);
3729 gc->pc += cmdlen;
3730 if (__builtin_expect(gc->pc > gc->limit, 0)) {
3731 (void) __glXFlushRenderBuffer(gc, gc->pc);
3732 }
3733 }
3734
3735 #define X_GLsop_ReadPixels 111
3736 void
3737 __indirect_glReadPixels(GLint x, GLint y, GLsizei width, GLsizei height,
3738 GLenum format, GLenum type, GLvoid * pixels)
3739 {
3740 __GLXcontext *const gc = __glXGetCurrentContext();
3741 const __GLXattribute *const state = gc->client_state_private;
3742 Display *const dpy = gc->currentDpy;
3743 #ifndef USE_XCB
3744 const GLuint cmdlen = 28;
3745 #endif
3746 if (__builtin_expect(dpy != NULL, 1)) {
3747 #ifdef USE_XCB
3748 xcb_connection_t *c = XGetXCBConnection(dpy);
3749 (void) __glXFlushRenderBuffer(gc, gc->pc);
3750 xcb_glx_read_pixels_reply_t *reply =
3751 xcb_glx_read_pixels_reply(c,
3752 xcb_glx_read_pixels(c,
3753 gc->
3754 currentContextTag,
3755 x, y, width, height,
3756 format, type,
3757 state->storePack.
3758 swapEndian, 0),
3759 NULL);
3760 (void) memcpy(pixels, xcb_glx_read_pixels_data(reply),
3761 xcb_glx_read_pixels_data_length(reply) *
3762 sizeof(GLvoid));
3763 free(reply);
3764 #else
3765 GLubyte const *pc =
3766 __glXSetupSingleRequest(gc, X_GLsop_ReadPixels, cmdlen);
3767 (void) memcpy((void *) (pc + 0), (void *) (&x), 4);
3768 (void) memcpy((void *) (pc + 4), (void *) (&y), 4);
3769 (void) memcpy((void *) (pc + 8), (void *) (&width), 4);
3770 (void) memcpy((void *) (pc + 12), (void *) (&height), 4);
3771 (void) memcpy((void *) (pc + 16), (void *) (&format), 4);
3772 (void) memcpy((void *) (pc + 20), (void *) (&type), 4);
3773 *(int32_t *) (pc + 24) = 0;
3774 *(int8_t *) (pc + 24) = state->storePack.swapEndian;
3775 __glXReadPixelReply(dpy, gc, 2, width, height, 1, format, type,
3776 pixels, GL_FALSE);
3777 UnlockDisplay(dpy);
3778 SyncHandle();
3779 #endif /* USE_XCB */
3780 }
3781 return;
3782 }
3783
3784 #define X_GLrop_DrawPixels 173
3785 void
3786 __indirect_glDrawPixels(GLsizei width, GLsizei height, GLenum format,
3787 GLenum type, const GLvoid * pixels)
3788 {
3789 __GLXcontext *const gc = __glXGetCurrentContext();
3790 const GLuint compsize =
3791 (pixels != NULL) ? __glImageSize(width, height, 1, format, type,
3792 0) : 0;
3793 const GLuint cmdlen = 40 + __GLX_PAD(compsize);
3794 if (__builtin_expect(gc->currentDpy != NULL, 1)) {
3795 if (cmdlen <= gc->maxSmallRenderCommandSize) {
3796 if ((gc->pc + cmdlen) > gc->bufEnd) {
3797 (void) __glXFlushRenderBuffer(gc, gc->pc);
3798 }
3799 emit_header(gc->pc, X_GLrop_DrawPixels, cmdlen);
3800 (void) memcpy((void *) (gc->pc + 24), (void *) (&width), 4);
3801 (void) memcpy((void *) (gc->pc + 28), (void *) (&height), 4);
3802 (void) memcpy((void *) (gc->pc + 32), (void *) (&format), 4);
3803 (void) memcpy((void *) (gc->pc + 36), (void *) (&type), 4);
3804 if (compsize > 0) {
3805 (*gc->fillImage) (gc, 2, width, height, 1, format, type,
3806 pixels, gc->pc + 40, gc->pc + 4);
3807 } else {
3808 (void) memcpy(gc->pc + 4, default_pixel_store_2D,
3809 default_pixel_store_2D_size);
3810 }
3811 gc->pc += cmdlen;
3812 if (gc->pc > gc->limit) {
3813 (void) __glXFlushRenderBuffer(gc, gc->pc);
3814 }
3815 } else {
3816 const GLint op = X_GLrop_DrawPixels;
3817 const GLuint cmdlenLarge = cmdlen + 4;
3818 GLubyte *const pc = __glXFlushRenderBuffer(gc, gc->pc);
3819 (void) memcpy((void *) (pc + 0), (void *) (&cmdlenLarge), 4);
3820 (void) memcpy((void *) (pc + 4), (void *) (&op), 4);
3821 (void) memcpy((void *) (pc + 28), (void *) (&width), 4);
3822 (void) memcpy((void *) (pc + 32), (void *) (&height), 4);
3823 (void) memcpy((void *) (pc + 36), (void *) (&format), 4);
3824 (void) memcpy((void *) (pc + 40), (void *) (&type), 4);
3825 __glXSendLargeImage(gc, compsize, 2, width, height, 1, format,
3826 type, pixels, pc + 44, pc + 8);
3827 }
3828 }
3829 }
3830
3831 #define X_GLsop_GetClipPlane 113
3832 void
3833 __indirect_glGetClipPlane(GLenum plane, GLdouble * equation)
3834 {
3835 __GLXcontext *const gc = __glXGetCurrentContext();
3836 Display *const dpy = gc->currentDpy;
3837 #ifndef USE_XCB
3838 const GLuint cmdlen = 4;
3839 #endif
3840 if (__builtin_expect(dpy != NULL, 1)) {
3841 #ifdef USE_XCB
3842 xcb_connection_t *c = XGetXCBConnection(dpy);
3843 (void) __glXFlushRenderBuffer(gc, gc->pc);
3844 xcb_glx_get_clip_plane_reply_t *reply =
3845 xcb_glx_get_clip_plane_reply(c,
3846 xcb_glx_get_clip_plane(c,
3847 gc->
3848 currentContextTag,
3849 plane), NULL);
3850 (void) memcpy(equation, xcb_glx_get_clip_plane_data(reply),
3851 xcb_glx_get_clip_plane_data_length(reply) *
3852 sizeof(GLdouble));
3853 free(reply);
3854 #else
3855 GLubyte const *pc =
3856 __glXSetupSingleRequest(gc, X_GLsop_GetClipPlane, cmdlen);
3857 (void) memcpy((void *) (pc + 0), (void *) (&plane), 4);
3858 (void) __glXReadReply(dpy, 8, equation, GL_TRUE);
3859 UnlockDisplay(dpy);
3860 SyncHandle();
3861 #endif /* USE_XCB */
3862 }
3863 return;
3864 }
3865
3866 #define X_GLsop_GetLightfv 118
3867 void
3868 __indirect_glGetLightfv(GLenum light, GLenum pname, GLfloat * params)
3869 {
3870 __GLXcontext *const gc = __glXGetCurrentContext();
3871 Display *const dpy = gc->currentDpy;
3872 #ifndef USE_XCB
3873 const GLuint cmdlen = 8;
3874 #endif
3875 if (__builtin_expect(dpy != NULL, 1)) {
3876 #ifdef USE_XCB
3877 xcb_connection_t *c = XGetXCBConnection(dpy);
3878 (void) __glXFlushRenderBuffer(gc, gc->pc);
3879 xcb_glx_get_lightfv_reply_t *reply =
3880 xcb_glx_get_lightfv_reply(c,
3881 xcb_glx_get_lightfv(c,
3882 gc->
3883 currentContextTag,
3884 light, pname),
3885 NULL);
3886 if (xcb_glx_get_lightfv_data_length(reply) == 0)
3887 (void) memcpy(params, &reply->datum, sizeof(reply->datum));
3888 else
3889 (void) memcpy(params, xcb_glx_get_lightfv_data(reply),
3890 xcb_glx_get_lightfv_data_length(reply) *
3891 sizeof(GLfloat));
3892 free(reply);
3893 #else
3894 GLubyte const *pc =
3895 __glXSetupSingleRequest(gc, X_GLsop_GetLightfv, cmdlen);
3896 (void) memcpy((void *) (pc + 0), (void *) (&light), 4);
3897 (void) memcpy((void *) (pc + 4), (void *) (&pname), 4);
3898 (void) __glXReadReply(dpy, 4, params, GL_FALSE);
3899 UnlockDisplay(dpy);
3900 SyncHandle();
3901 #endif /* USE_XCB */
3902 }
3903 return;
3904 }
3905
3906 #define X_GLsop_GetLightiv 119
3907 void
3908 __indirect_glGetLightiv(GLenum light, GLenum pname, GLint * params)
3909 {
3910 __GLXcontext *const gc = __glXGetCurrentContext();
3911 Display *const dpy = gc->currentDpy;
3912 #ifndef USE_XCB
3913 const GLuint cmdlen = 8;
3914 #endif
3915 if (__builtin_expect(dpy != NULL, 1)) {
3916 #ifdef USE_XCB
3917 xcb_connection_t *c = XGetXCBConnection(dpy);
3918 (void) __glXFlushRenderBuffer(gc, gc->pc);
3919 xcb_glx_get_lightiv_reply_t *reply =
3920 xcb_glx_get_lightiv_reply(c,
3921 xcb_glx_get_lightiv(c,
3922 gc->
3923 currentContextTag,
3924 light, pname),
3925 NULL);
3926 if (xcb_glx_get_lightiv_data_length(reply) == 0)
3927 (void) memcpy(params, &reply->datum, sizeof(reply->datum));
3928 else
3929 (void) memcpy(params, xcb_glx_get_lightiv_data(reply),
3930 xcb_glx_get_lightiv_data_length(reply) *
3931 sizeof(GLint));
3932 free(reply);
3933 #else
3934 GLubyte const *pc =
3935 __glXSetupSingleRequest(gc, X_GLsop_GetLightiv, cmdlen);
3936 (void) memcpy((void *) (pc + 0), (void *) (&light), 4);
3937 (void) memcpy((void *) (pc + 4), (void *) (&pname), 4);
3938 (void) __glXReadReply(dpy, 4, params, GL_FALSE);
3939 UnlockDisplay(dpy);
3940 SyncHandle();
3941 #endif /* USE_XCB */
3942 }
3943 return;
3944 }
3945
3946 #define X_GLsop_GetMapdv 120
3947 void
3948 __indirect_glGetMapdv(GLenum target, GLenum query, GLdouble * v)
3949 {
3950 __GLXcontext *const gc = __glXGetCurrentContext();
3951 Display *const dpy = gc->currentDpy;
3952 #ifndef USE_XCB
3953 const GLuint cmdlen = 8;
3954 #endif
3955 if (__builtin_expect(dpy != NULL, 1)) {
3956 #ifdef USE_XCB
3957 xcb_connection_t *c = XGetXCBConnection(dpy);
3958 (void) __glXFlushRenderBuffer(gc, gc->pc);
3959 xcb_glx_get_mapdv_reply_t *reply =
3960 xcb_glx_get_mapdv_reply(c,
3961 xcb_glx_get_mapdv(c,
3962 gc->currentContextTag,
3963 target, query), NULL);
3964 if (xcb_glx_get_mapdv_data_length(reply) == 0)
3965 (void) memcpy(v, &reply->datum, sizeof(reply->datum));
3966 else
3967 (void) memcpy(v, xcb_glx_get_mapdv_data(reply),
3968 xcb_glx_get_mapdv_data_length(reply) *
3969 sizeof(GLdouble));
3970 free(reply);
3971 #else
3972 GLubyte const *pc =
3973 __glXSetupSingleRequest(gc, X_GLsop_GetMapdv, cmdlen);
3974 (void) memcpy((void *) (pc + 0), (void *) (&target), 4);
3975 (void) memcpy((void *) (pc + 4), (void *) (&query), 4);
3976 (void) __glXReadReply(dpy, 8, v, GL_FALSE);
3977 UnlockDisplay(dpy);
3978 SyncHandle();
3979 #endif /* USE_XCB */
3980 }
3981 return;
3982 }
3983
3984 #define X_GLsop_GetMapfv 121
3985 void
3986 __indirect_glGetMapfv(GLenum target, GLenum query, GLfloat * v)
3987 {
3988 __GLXcontext *const gc = __glXGetCurrentContext();
3989 Display *const dpy = gc->currentDpy;
3990 #ifndef USE_XCB
3991 const GLuint cmdlen = 8;
3992 #endif
3993 if (__builtin_expect(dpy != NULL, 1)) {
3994 #ifdef USE_XCB
3995 xcb_connection_t *c = XGetXCBConnection(dpy);
3996 (void) __glXFlushRenderBuffer(gc, gc->pc);
3997 xcb_glx_get_mapfv_reply_t *reply =
3998 xcb_glx_get_mapfv_reply(c,
3999 xcb_glx_get_mapfv(c,
4000 gc->currentContextTag,
4001 target, query), NULL);
4002 if (xcb_glx_get_mapfv_data_length(reply) == 0)
4003 (void) memcpy(v, &reply->datum, sizeof(reply->datum));
4004 else
4005 (void) memcpy(v, xcb_glx_get_mapfv_data(reply),
4006 xcb_glx_get_mapfv_data_length(reply) *
4007 sizeof(GLfloat));
4008 free(reply);
4009 #else
4010 GLubyte const *pc =
4011 __glXSetupSingleRequest(gc, X_GLsop_GetMapfv, cmdlen);
4012 (void) memcpy((void *) (pc + 0), (void *) (&target), 4);
4013 (void) memcpy((void *) (pc + 4), (void *) (&query), 4);
4014 (void) __glXReadReply(dpy, 4, v, GL_FALSE);
4015 UnlockDisplay(dpy);
4016 SyncHandle();
4017 #endif /* USE_XCB */
4018 }
4019 return;
4020 }
4021
4022 #define X_GLsop_GetMapiv 122
4023 void
4024 __indirect_glGetMapiv(GLenum target, GLenum query, GLint * v)
4025 {
4026 __GLXcontext *const gc = __glXGetCurrentContext();
4027 Display *const dpy = gc->currentDpy;
4028 #ifndef USE_XCB
4029 const GLuint cmdlen = 8;
4030 #endif
4031 if (__builtin_expect(dpy != NULL, 1)) {
4032 #ifdef USE_XCB
4033 xcb_connection_t *c = XGetXCBConnection(dpy);
4034 (void) __glXFlushRenderBuffer(gc, gc->pc);
4035 xcb_glx_get_mapiv_reply_t *reply =
4036 xcb_glx_get_mapiv_reply(c,
4037 xcb_glx_get_mapiv(c,
4038 gc->currentContextTag,
4039 target, query), NULL);
4040 if (xcb_glx_get_mapiv_data_length(reply) == 0)
4041 (void) memcpy(v, &reply->datum, sizeof(reply->datum));
4042 else
4043 (void) memcpy(v, xcb_glx_get_mapiv_data(reply),
4044 xcb_glx_get_mapiv_data_length(reply) *
4045 sizeof(GLint));
4046 free(reply);
4047 #else
4048 GLubyte const *pc =
4049 __glXSetupSingleRequest(gc, X_GLsop_GetMapiv, cmdlen);
4050 (void) memcpy((void *) (pc + 0), (void *) (&target), 4);
4051 (void) memcpy((void *) (pc + 4), (void *) (&query), 4);
4052 (void) __glXReadReply(dpy, 4, v, GL_FALSE);
4053 UnlockDisplay(dpy);
4054 SyncHandle();
4055 #endif /* USE_XCB */
4056 }
4057 return;
4058 }
4059
4060 #define X_GLsop_GetMaterialfv 123
4061 void
4062 __indirect_glGetMaterialfv(GLenum face, GLenum pname, GLfloat * params)
4063 {
4064 __GLXcontext *const gc = __glXGetCurrentContext();
4065 Display *const dpy = gc->currentDpy;
4066 #ifndef USE_XCB
4067 const GLuint cmdlen = 8;
4068 #endif
4069 if (__builtin_expect(dpy != NULL, 1)) {
4070 #ifdef USE_XCB
4071 xcb_connection_t *c = XGetXCBConnection(dpy);
4072 (void) __glXFlushRenderBuffer(gc, gc->pc);
4073 xcb_glx_get_materialfv_reply_t *reply =
4074 xcb_glx_get_materialfv_reply(c,
4075 xcb_glx_get_materialfv(c,
4076 gc->
4077 currentContextTag,
4078 face, pname),
4079 NULL);
4080 if (xcb_glx_get_materialfv_data_length(reply) == 0)
4081 (void) memcpy(params, &reply->datum, sizeof(reply->datum));
4082 else
4083 (void) memcpy(params, xcb_glx_get_materialfv_data(reply),
4084 xcb_glx_get_materialfv_data_length(reply) *
4085 sizeof(GLfloat));
4086 free(reply);
4087 #else
4088 GLubyte const *pc =
4089 __glXSetupSingleRequest(gc, X_GLsop_GetMaterialfv, cmdlen);
4090 (void) memcpy((void *) (pc + 0), (void *) (&face), 4);
4091 (void) memcpy((void *) (pc + 4), (void *) (&pname), 4);
4092 (void) __glXReadReply(dpy, 4, params, GL_FALSE);
4093 UnlockDisplay(dpy);
4094 SyncHandle();
4095 #endif /* USE_XCB */
4096 }
4097 return;
4098 }
4099
4100 #define X_GLsop_GetMaterialiv 124
4101 void
4102 __indirect_glGetMaterialiv(GLenum face, GLenum pname, GLint * params)
4103 {
4104 __GLXcontext *const gc = __glXGetCurrentContext();
4105 Display *const dpy = gc->currentDpy;
4106 #ifndef USE_XCB
4107 const GLuint cmdlen = 8;
4108 #endif
4109 if (__builtin_expect(dpy != NULL, 1)) {
4110 #ifdef USE_XCB
4111 xcb_connection_t *c = XGetXCBConnection(dpy);
4112 (void) __glXFlushRenderBuffer(gc, gc->pc);
4113 xcb_glx_get_materialiv_reply_t *reply =
4114 xcb_glx_get_materialiv_reply(c,
4115 xcb_glx_get_materialiv(c,
4116 gc->
4117 currentContextTag,
4118 face, pname),
4119 NULL);
4120 if (xcb_glx_get_materialiv_data_length(reply) == 0)
4121 (void) memcpy(params, &reply->datum, sizeof(reply->datum));
4122 else
4123 (void) memcpy(params, xcb_glx_get_materialiv_data(reply),
4124 xcb_glx_get_materialiv_data_length(reply) *
4125 sizeof(GLint));
4126 free(reply);
4127 #else
4128 GLubyte const *pc =
4129 __glXSetupSingleRequest(gc, X_GLsop_GetMaterialiv, cmdlen);
4130 (void) memcpy((void *) (pc + 0), (void *) (&face), 4);
4131 (void) memcpy((void *) (pc + 4), (void *) (&pname), 4);
4132 (void) __glXReadReply(dpy, 4, params, GL_FALSE);
4133 UnlockDisplay(dpy);
4134 SyncHandle();
4135 #endif /* USE_XCB */
4136 }
4137 return;
4138 }
4139
4140 #define X_GLsop_GetPixelMapfv 125
4141 void
4142 __indirect_glGetPixelMapfv(GLenum map, GLfloat * values)
4143 {
4144 __GLXcontext *const gc = __glXGetCurrentContext();
4145 Display *const dpy = gc->currentDpy;
4146 #ifndef USE_XCB
4147 const GLuint cmdlen = 4;
4148 #endif
4149 if (__builtin_expect(dpy != NULL, 1)) {
4150 #ifdef USE_XCB
4151 xcb_connection_t *c = XGetXCBConnection(dpy);
4152 (void) __glXFlushRenderBuffer(gc, gc->pc);
4153 xcb_glx_get_pixel_mapfv_reply_t *reply =
4154 xcb_glx_get_pixel_mapfv_reply(c,
4155 xcb_glx_get_pixel_mapfv(c,
4156 gc->
4157 currentContextTag,
4158 map), NULL);
4159 if (xcb_glx_get_pixel_mapfv_data_length(reply) == 0)
4160 (void) memcpy(values, &reply->datum, sizeof(reply->datum));
4161 else
4162 (void) memcpy(values, xcb_glx_get_pixel_mapfv_data(reply),
4163 xcb_glx_get_pixel_mapfv_data_length(reply) *
4164 sizeof(GLfloat));
4165 free(reply);
4166 #else
4167 GLubyte const *pc =
4168 __glXSetupSingleRequest(gc, X_GLsop_GetPixelMapfv, cmdlen);
4169 (void) memcpy((void *) (pc + 0), (void *) (&map), 4);
4170 (void) __glXReadReply(dpy, 4, values, GL_FALSE);
4171 UnlockDisplay(dpy);
4172 SyncHandle();
4173 #endif /* USE_XCB */
4174 }
4175 return;
4176 }
4177
4178 #define X_GLsop_GetPixelMapuiv 126
4179 void
4180 __indirect_glGetPixelMapuiv(GLenum map, GLuint * values)
4181 {
4182 __GLXcontext *const gc = __glXGetCurrentContext();
4183 Display *const dpy = gc->currentDpy;
4184 #ifndef USE_XCB
4185 const GLuint cmdlen = 4;
4186 #endif
4187 if (__builtin_expect(dpy != NULL, 1)) {
4188 #ifdef USE_XCB
4189 xcb_connection_t *c = XGetXCBConnection(dpy);
4190 (void) __glXFlushRenderBuffer(gc, gc->pc);
4191 xcb_glx_get_pixel_mapuiv_reply_t *reply =
4192 xcb_glx_get_pixel_mapuiv_reply(c,
4193 xcb_glx_get_pixel_mapuiv(c,
4194 gc->
4195 currentContextTag,
4196 map),
4197 NULL);
4198 if (xcb_glx_get_pixel_mapuiv_data_length(reply) == 0)
4199 (void) memcpy(values, &reply->datum, sizeof(reply->datum));
4200 else
4201 (void) memcpy(values, xcb_glx_get_pixel_mapuiv_data(reply),
4202 xcb_glx_get_pixel_mapuiv_data_length(reply) *
4203 sizeof(GLuint));
4204 free(reply);
4205 #else
4206 GLubyte const *pc =
4207 __glXSetupSingleRequest(gc, X_GLsop_GetPixelMapuiv, cmdlen);
4208 (void) memcpy((void *) (pc + 0), (void *) (&map), 4);
4209 (void) __glXReadReply(dpy, 4, values, GL_FALSE);
4210 UnlockDisplay(dpy);
4211 SyncHandle();
4212 #endif /* USE_XCB */
4213 }
4214 return;
4215 }
4216
4217 #define X_GLsop_GetPixelMapusv 127
4218 void
4219 __indirect_glGetPixelMapusv(GLenum map, GLushort * values)
4220 {
4221 __GLXcontext *const gc = __glXGetCurrentContext();
4222 Display *const dpy = gc->currentDpy;
4223 #ifndef USE_XCB
4224 const GLuint cmdlen = 4;
4225 #endif
4226 if (__builtin_expect(dpy != NULL, 1)) {
4227 #ifdef USE_XCB
4228 xcb_connection_t *c = XGetXCBConnection(dpy);
4229 (void) __glXFlushRenderBuffer(gc, gc->pc);
4230 xcb_glx_get_pixel_mapusv_reply_t *reply =
4231 xcb_glx_get_pixel_mapusv_reply(c,
4232 xcb_glx_get_pixel_mapusv(c,
4233 gc->
4234 currentContextTag,
4235 map),
4236 NULL);
4237 if (xcb_glx_get_pixel_mapusv_data_length(reply) == 0)
4238 (void) memcpy(values, &reply->datum, sizeof(reply->datum));
4239 else
4240 (void) memcpy(values, xcb_glx_get_pixel_mapusv_data(reply),
4241 xcb_glx_get_pixel_mapusv_data_length(reply) *
4242 sizeof(GLushort));
4243 free(reply);
4244 #else
4245 GLubyte const *pc =
4246 __glXSetupSingleRequest(gc, X_GLsop_GetPixelMapusv, cmdlen);
4247 (void) memcpy((void *) (pc + 0), (void *) (&map), 4);
4248 (void) __glXReadReply(dpy, 2, values, GL_FALSE);
4249 UnlockDisplay(dpy);
4250 SyncHandle();
4251 #endif /* USE_XCB */
4252 }
4253 return;
4254 }
4255
4256 #define X_GLsop_GetPolygonStipple 128
4257 void
4258 __indirect_glGetPolygonStipple(GLubyte *mask)
4259 {
4260 __GLXcontext *const gc = __glXGetCurrentContext();
4261 Display *const dpy = gc->currentDpy;
4262 #ifndef USE_XCB
4263 const GLuint cmdlen = 4;
4264 #endif
4265 if (__builtin_expect(dpy != NULL, 1)) {
4266 #ifdef USE_XCB
4267 xcb_connection_t *c = XGetXCBConnection(dpy);
4268 (void) __glXFlushRenderBuffer(gc, gc->pc);
4269 xcb_glx_get_polygon_stipple_reply_t *reply =
4270 xcb_glx_get_polygon_stipple_reply(c,
4271 xcb_glx_get_polygon_stipple(c,
4272 gc->
4273 currentContextTag,
4274 0),
4275 NULL);
4276 (void) memcpy(mask, xcb_glx_get_polygon_stipple_data(reply),
4277 xcb_glx_get_polygon_stipple_data_length(reply) *
4278 sizeof(GLubyte));
4279 free(reply);
4280 #else
4281 GLubyte const *pc =
4282 __glXSetupSingleRequest(gc, X_GLsop_GetPolygonStipple, cmdlen);
4283 *(int32_t *) (pc + 0) = 0;
4284 __glXReadPixelReply(dpy, gc, 2, 32, 32, 1, GL_COLOR_INDEX, GL_BITMAP,
4285 mask, GL_FALSE);
4286 UnlockDisplay(dpy);
4287 SyncHandle();
4288 #endif /* USE_XCB */
4289 }
4290 return;
4291 }
4292
4293 #define X_GLsop_GetTexEnvfv 130
4294 void
4295 __indirect_glGetTexEnvfv(GLenum target, GLenum pname, GLfloat * params)
4296 {
4297 __GLXcontext *const gc = __glXGetCurrentContext();
4298 Display *const dpy = gc->currentDpy;
4299 #ifndef USE_XCB
4300 const GLuint cmdlen = 8;
4301 #endif
4302 if (__builtin_expect(dpy != NULL, 1)) {
4303 #ifdef USE_XCB
4304 xcb_connection_t *c = XGetXCBConnection(dpy);
4305 (void) __glXFlushRenderBuffer(gc, gc->pc);
4306 xcb_glx_get_tex_envfv_reply_t *reply =
4307 xcb_glx_get_tex_envfv_reply(c,
4308 xcb_glx_get_tex_envfv(c,
4309 gc->
4310 currentContextTag,
4311 target, pname),
4312 NULL);
4313 if (xcb_glx_get_tex_envfv_data_length(reply) == 0)
4314 (void) memcpy(params, &reply->datum, sizeof(reply->datum));
4315 else
4316 (void) memcpy(params, xcb_glx_get_tex_envfv_data(reply),
4317 xcb_glx_get_tex_envfv_data_length(reply) *
4318 sizeof(GLfloat));
4319 free(reply);
4320 #else
4321 GLubyte const *pc =
4322 __glXSetupSingleRequest(gc, X_GLsop_GetTexEnvfv, cmdlen);
4323 (void) memcpy((void *) (pc + 0), (void *) (&target), 4);
4324 (void) memcpy((void *) (pc + 4), (void *) (&pname), 4);
4325 (void) __glXReadReply(dpy, 4, params, GL_FALSE);
4326 UnlockDisplay(dpy);
4327 SyncHandle();
4328 #endif /* USE_XCB */
4329 }
4330 return;
4331 }
4332
4333 #define X_GLsop_GetTexEnviv 131
4334 void
4335 __indirect_glGetTexEnviv(GLenum target, GLenum pname, GLint * params)
4336 {
4337 __GLXcontext *const gc = __glXGetCurrentContext();
4338 Display *const dpy = gc->currentDpy;
4339 #ifndef USE_XCB
4340 const GLuint cmdlen = 8;
4341 #endif
4342 if (__builtin_expect(dpy != NULL, 1)) {
4343 #ifdef USE_XCB
4344 xcb_connection_t *c = XGetXCBConnection(dpy);
4345 (void) __glXFlushRenderBuffer(gc, gc->pc);
4346 xcb_glx_get_tex_enviv_reply_t *reply =
4347 xcb_glx_get_tex_enviv_reply(c,
4348 xcb_glx_get_tex_enviv(c,
4349 gc->
4350 currentContextTag,
4351 target, pname),
4352 NULL);
4353 if (xcb_glx_get_tex_enviv_data_length(reply) == 0)
4354 (void) memcpy(params, &reply->datum, sizeof(reply->datum));
4355 else
4356 (void) memcpy(params, xcb_glx_get_tex_enviv_data(reply),
4357 xcb_glx_get_tex_enviv_data_length(reply) *
4358 sizeof(GLint));
4359 free(reply);
4360 #else
4361 GLubyte const *pc =
4362 __glXSetupSingleRequest(gc, X_GLsop_GetTexEnviv, cmdlen);
4363 (void) memcpy((void *) (pc + 0), (void *) (&target), 4);
4364 (void) memcpy((void *) (pc + 4), (void *) (&pname), 4);
4365 (void) __glXReadReply(dpy, 4, params, GL_FALSE);
4366 UnlockDisplay(dpy);
4367 SyncHandle();
4368 #endif /* USE_XCB */
4369 }
4370 return;
4371 }
4372
4373 #define X_GLsop_GetTexGendv 132
4374 void
4375 __indirect_glGetTexGendv(GLenum coord, GLenum pname, GLdouble * params)
4376 {
4377 __GLXcontext *const gc = __glXGetCurrentContext();
4378 Display *const dpy = gc->currentDpy;
4379 #ifndef USE_XCB
4380 const GLuint cmdlen = 8;
4381 #endif
4382 if (__builtin_expect(dpy != NULL, 1)) {
4383 #ifdef USE_XCB
4384 xcb_connection_t *c = XGetXCBConnection(dpy);
4385 (void) __glXFlushRenderBuffer(gc, gc->pc);
4386 xcb_glx_get_tex_gendv_reply_t *reply =
4387 xcb_glx_get_tex_gendv_reply(c,
4388 xcb_glx_get_tex_gendv(c,
4389 gc->
4390 currentContextTag,
4391 coord, pname),
4392 NULL);
4393 if (xcb_glx_get_tex_gendv_data_length(reply) == 0)
4394 (void) memcpy(params, &reply->datum, sizeof(reply->datum));
4395 else
4396 (void) memcpy(params, xcb_glx_get_tex_gendv_data(reply),
4397 xcb_glx_get_tex_gendv_data_length(reply) *
4398 sizeof(GLdouble));
4399 free(reply);
4400 #else
4401 GLubyte const *pc =
4402 __glXSetupSingleRequest(gc, X_GLsop_GetTexGendv, cmdlen);
4403 (void) memcpy((void *) (pc + 0), (void *) (&coord), 4);
4404 (void) memcpy((void *) (pc + 4), (void *) (&pname), 4);
4405 (void) __glXReadReply(dpy, 8, params, GL_FALSE);
4406 UnlockDisplay(dpy);
4407 SyncHandle();
4408 #endif /* USE_XCB */
4409 }
4410 return;
4411 }
4412
4413 #define X_GLsop_GetTexGenfv 133
4414 void
4415 __indirect_glGetTexGenfv(GLenum coord, GLenum pname, GLfloat * params)
4416 {
4417 __GLXcontext *const gc = __glXGetCurrentContext();
4418 Display *const dpy = gc->currentDpy;
4419 #ifndef USE_XCB
4420 const GLuint cmdlen = 8;
4421 #endif
4422 if (__builtin_expect(dpy != NULL, 1)) {
4423 #ifdef USE_XCB
4424 xcb_connection_t *c = XGetXCBConnection(dpy);
4425 (void) __glXFlushRenderBuffer(gc, gc->pc);
4426 xcb_glx_get_tex_genfv_reply_t *reply =
4427 xcb_glx_get_tex_genfv_reply(c,
4428 xcb_glx_get_tex_genfv(c,
4429 gc->
4430 currentContextTag,
4431 coord, pname),
4432 NULL);
4433 if (xcb_glx_get_tex_genfv_data_length(reply) == 0)
4434 (void) memcpy(params, &reply->datum, sizeof(reply->datum));
4435 else
4436 (void) memcpy(params, xcb_glx_get_tex_genfv_data(reply),
4437 xcb_glx_get_tex_genfv_data_length(reply) *
4438 sizeof(GLfloat));
4439 free(reply);
4440 #else
4441 GLubyte const *pc =
4442 __glXSetupSingleRequest(gc, X_GLsop_GetTexGenfv, cmdlen);
4443 (void) memcpy((void *) (pc + 0), (void *) (&coord), 4);
4444 (void) memcpy((void *) (pc + 4), (void *) (&pname), 4);
4445 (void) __glXReadReply(dpy, 4, params, GL_FALSE);
4446 UnlockDisplay(dpy);
4447 SyncHandle();
4448 #endif /* USE_XCB */
4449 }
4450 return;
4451 }
4452
4453 #define X_GLsop_GetTexGeniv 134
4454 void
4455 __indirect_glGetTexGeniv(GLenum coord, GLenum pname, GLint * params)
4456 {
4457 __GLXcontext *const gc = __glXGetCurrentContext();
4458 Display *const dpy = gc->currentDpy;
4459 #ifndef USE_XCB
4460 const GLuint cmdlen = 8;
4461 #endif
4462 if (__builtin_expect(dpy != NULL, 1)) {
4463 #ifdef USE_XCB
4464 xcb_connection_t *c = XGetXCBConnection(dpy);
4465 (void) __glXFlushRenderBuffer(gc, gc->pc);
4466 xcb_glx_get_tex_geniv_reply_t *reply =
4467 xcb_glx_get_tex_geniv_reply(c,
4468 xcb_glx_get_tex_geniv(c,
4469 gc->
4470 currentContextTag,
4471 coord, pname),
4472 NULL);
4473 if (xcb_glx_get_tex_geniv_data_length(reply) == 0)
4474 (void) memcpy(params, &reply->datum, sizeof(reply->datum));
4475 else
4476 (void) memcpy(params, xcb_glx_get_tex_geniv_data(reply),
4477 xcb_glx_get_tex_geniv_data_length(reply) *
4478 sizeof(GLint));
4479 free(reply);
4480 #else
4481 GLubyte const *pc =
4482 __glXSetupSingleRequest(gc, X_GLsop_GetTexGeniv, cmdlen);
4483 (void) memcpy((void *) (pc + 0), (void *) (&coord), 4);
4484 (void) memcpy((void *) (pc + 4), (void *) (&pname), 4);
4485 (void) __glXReadReply(dpy, 4, params, GL_FALSE);
4486 UnlockDisplay(dpy);
4487 SyncHandle();
4488 #endif /* USE_XCB */
4489 }
4490 return;
4491 }
4492
4493 #define X_GLsop_GetTexImage 135
4494 void
4495 __indirect_glGetTexImage(GLenum target, GLint level, GLenum format,
4496 GLenum type, GLvoid * pixels)
4497 {
4498 __GLXcontext *const gc = __glXGetCurrentContext();
4499 const __GLXattribute *const state = gc->client_state_private;
4500 Display *const dpy = gc->currentDpy;
4501 #ifndef USE_XCB
4502 const GLuint cmdlen = 20;
4503 #endif
4504 if (__builtin_expect(dpy != NULL, 1)) {
4505 #ifdef USE_XCB
4506 xcb_connection_t *c = XGetXCBConnection(dpy);
4507 (void) __glXFlushRenderBuffer(gc, gc->pc);
4508 xcb_glx_get_tex_image_reply_t *reply =
4509 xcb_glx_get_tex_image_reply(c,
4510 xcb_glx_get_tex_image(c,
4511 gc->
4512 currentContextTag,
4513 target, level,
4514 format, type,
4515 state->
4516 storePack.
4517 swapEndian),
4518 NULL);
4519 (void) memcpy(pixels, xcb_glx_get_tex_image_data(reply),
4520 xcb_glx_get_tex_image_data_length(reply) *
4521 sizeof(GLvoid));
4522 free(reply);
4523 #else
4524 GLubyte const *pc =
4525 __glXSetupSingleRequest(gc, X_GLsop_GetTexImage, cmdlen);
4526 (void) memcpy((void *) (pc + 0), (void *) (&target), 4);
4527 (void) memcpy((void *) (pc + 4), (void *) (&level), 4);
4528 (void) memcpy((void *) (pc + 8), (void *) (&format), 4);
4529 (void) memcpy((void *) (pc + 12), (void *) (&type), 4);
4530 *(int32_t *) (pc + 16) = 0;
4531 *(int8_t *) (pc + 16) = state->storePack.swapEndian;
4532 __glXReadPixelReply(dpy, gc, 3, 0, 0, 0, format, type, pixels,
4533 GL_TRUE);
4534 UnlockDisplay(dpy);
4535 SyncHandle();
4536 #endif /* USE_XCB */
4537 }
4538 return;
4539 }
4540
4541 #define X_GLsop_GetTexParameterfv 136
4542 void
4543 __indirect_glGetTexParameterfv(GLenum target, GLenum pname, GLfloat * params)
4544 {
4545 __GLXcontext *const gc = __glXGetCurrentContext();
4546 Display *const dpy = gc->currentDpy;
4547 #ifndef USE_XCB
4548 const GLuint cmdlen = 8;
4549 #endif
4550 if (__builtin_expect(dpy != NULL, 1)) {
4551 #ifdef USE_XCB
4552 xcb_connection_t *c = XGetXCBConnection(dpy);
4553 (void) __glXFlushRenderBuffer(gc, gc->pc);
4554 xcb_glx_get_tex_parameterfv_reply_t *reply =
4555 xcb_glx_get_tex_parameterfv_reply(c,
4556 xcb_glx_get_tex_parameterfv(c,
4557 gc->
4558 currentContextTag,
4559 target,
4560 pname),
4561 NULL);
4562 if (xcb_glx_get_tex_parameterfv_data_length(reply) == 0)
4563 (void) memcpy(params, &reply->datum, sizeof(reply->datum));
4564 else
4565 (void) memcpy(params, xcb_glx_get_tex_parameterfv_data(reply),
4566 xcb_glx_get_tex_parameterfv_data_length(reply) *
4567 sizeof(GLfloat));
4568 free(reply);
4569 #else
4570 GLubyte const *pc =
4571 __glXSetupSingleRequest(gc, X_GLsop_GetTexParameterfv, cmdlen);
4572 (void) memcpy((void *) (pc + 0), (void *) (&target), 4);
4573 (void) memcpy((void *) (pc + 4), (void *) (&pname), 4);
4574 (void) __glXReadReply(dpy, 4, params, GL_FALSE);
4575 UnlockDisplay(dpy);
4576 SyncHandle();
4577 #endif /* USE_XCB */
4578 }
4579 return;
4580 }
4581
4582 #define X_GLsop_GetTexParameteriv 137
4583 void
4584 __indirect_glGetTexParameteriv(GLenum target, GLenum pname, GLint * params)
4585 {
4586 __GLXcontext *const gc = __glXGetCurrentContext();
4587 Display *const dpy = gc->currentDpy;
4588 #ifndef USE_XCB
4589 const GLuint cmdlen = 8;
4590 #endif
4591 if (__builtin_expect(dpy != NULL, 1)) {
4592 #ifdef USE_XCB
4593 xcb_connection_t *c = XGetXCBConnection(dpy);
4594 (void) __glXFlushRenderBuffer(gc, gc->pc);
4595 xcb_glx_get_tex_parameteriv_reply_t *reply =
4596 xcb_glx_get_tex_parameteriv_reply(c,
4597 xcb_glx_get_tex_parameteriv(c,
4598 gc->
4599 currentContextTag,
4600 target,
4601 pname),
4602 NULL);
4603 if (xcb_glx_get_tex_parameteriv_data_length(reply) == 0)
4604 (void) memcpy(params, &reply->datum, sizeof(reply->datum));
4605 else
4606 (void) memcpy(params, xcb_glx_get_tex_parameteriv_data(reply),
4607 xcb_glx_get_tex_parameteriv_data_length(reply) *
4608 sizeof(GLint));
4609 free(reply);
4610 #else
4611 GLubyte const *pc =
4612 __glXSetupSingleRequest(gc, X_GLsop_GetTexParameteriv, cmdlen);
4613 (void) memcpy((void *) (pc + 0), (void *) (&target), 4);
4614 (void) memcpy((void *) (pc + 4), (void *) (&pname), 4);
4615 (void) __glXReadReply(dpy, 4, params, GL_FALSE);
4616 UnlockDisplay(dpy);
4617 SyncHandle();
4618 #endif /* USE_XCB */
4619 }
4620 return;
4621 }
4622
4623 #define X_GLsop_GetTexLevelParameterfv 138
4624 void
4625 __indirect_glGetTexLevelParameterfv(GLenum target, GLint level, GLenum pname,
4626 GLfloat * params)
4627 {
4628 __GLXcontext *const gc = __glXGetCurrentContext();
4629 Display *const dpy = gc->currentDpy;
4630 #ifndef USE_XCB
4631 const GLuint cmdlen = 12;
4632 #endif
4633 if (__builtin_expect(dpy != NULL, 1)) {
4634 #ifdef USE_XCB
4635 xcb_connection_t *c = XGetXCBConnection(dpy);
4636 (void) __glXFlushRenderBuffer(gc, gc->pc);
4637 xcb_glx_get_tex_level_parameterfv_reply_t *reply =
4638 xcb_glx_get_tex_level_parameterfv_reply(c,
4639 xcb_glx_get_tex_level_parameterfv
4640 (c, gc->currentContextTag,
4641 target, level, pname),
4642 NULL);
4643 if (xcb_glx_get_tex_level_parameterfv_data_length(reply) == 0)
4644 (void) memcpy(params, &reply->datum, sizeof(reply->datum));
4645 else
4646 (void) memcpy(params,
4647 xcb_glx_get_tex_level_parameterfv_data(reply),
4648 xcb_glx_get_tex_level_parameterfv_data_length(reply)
4649 * sizeof(GLfloat));
4650 free(reply);
4651 #else
4652 GLubyte const *pc =
4653 __glXSetupSingleRequest(gc, X_GLsop_GetTexLevelParameterfv,
4654 cmdlen);
4655 (void) memcpy((void *) (pc + 0), (void *) (&target), 4);
4656 (void) memcpy((void *) (pc + 4), (void *) (&level), 4);
4657 (void) memcpy((void *) (pc + 8), (void *) (&pname), 4);
4658 (void) __glXReadReply(dpy, 4, params, GL_FALSE);
4659 UnlockDisplay(dpy);
4660 SyncHandle();
4661 #endif /* USE_XCB */
4662 }
4663 return;
4664 }
4665
4666 #define X_GLsop_GetTexLevelParameteriv 139
4667 void
4668 __indirect_glGetTexLevelParameteriv(GLenum target, GLint level, GLenum pname,
4669 GLint * params)
4670 {
4671 __GLXcontext *const gc = __glXGetCurrentContext();
4672 Display *const dpy = gc->currentDpy;
4673 #ifndef USE_XCB
4674 const GLuint cmdlen = 12;
4675 #endif
4676 if (__builtin_expect(dpy != NULL, 1)) {
4677 #ifdef USE_XCB
4678 xcb_connection_t *c = XGetXCBConnection(dpy);
4679 (void) __glXFlushRenderBuffer(gc, gc->pc);
4680 xcb_glx_get_tex_level_parameteriv_reply_t *reply =
4681 xcb_glx_get_tex_level_parameteriv_reply(c,
4682 xcb_glx_get_tex_level_parameteriv
4683 (c, gc->currentContextTag,
4684 target, level, pname),
4685 NULL);
4686 if (xcb_glx_get_tex_level_parameteriv_data_length(reply) == 0)
4687 (void) memcpy(params, &reply->datum, sizeof(reply->datum));
4688 else
4689 (void) memcpy(params,
4690 xcb_glx_get_tex_level_parameteriv_data(reply),
4691 xcb_glx_get_tex_level_parameteriv_data_length(reply)
4692 * sizeof(GLint));
4693 free(reply);
4694 #else
4695 GLubyte const *pc =
4696 __glXSetupSingleRequest(gc, X_GLsop_GetTexLevelParameteriv,
4697 cmdlen);
4698 (void) memcpy((void *) (pc + 0), (void *) (&target), 4);
4699 (void) memcpy((void *) (pc + 4), (void *) (&level), 4);
4700 (void) memcpy((void *) (pc + 8), (void *) (&pname), 4);
4701 (void) __glXReadReply(dpy, 4, params, GL_FALSE);
4702 UnlockDisplay(dpy);
4703 SyncHandle();
4704 #endif /* USE_XCB */
4705 }
4706 return;
4707 }
4708
4709 #define X_GLsop_IsList 141
4710 GLboolean
4711 __indirect_glIsList(GLuint list)
4712 {
4713 __GLXcontext *const gc = __glXGetCurrentContext();
4714 Display *const dpy = gc->currentDpy;
4715 GLboolean retval = (GLboolean) 0;
4716 #ifndef USE_XCB
4717 const GLuint cmdlen = 4;
4718 #endif
4719 if (__builtin_expect(dpy != NULL, 1)) {
4720 #ifdef USE_XCB
4721 xcb_connection_t *c = XGetXCBConnection(dpy);
4722 (void) __glXFlushRenderBuffer(gc, gc->pc);
4723 xcb_glx_is_list_reply_t *reply =
4724 xcb_glx_is_list_reply(c,
4725 xcb_glx_is_list(c, gc->currentContextTag,
4726 list), NULL);
4727 retval = reply->ret_val;
4728 free(reply);
4729 #else
4730 GLubyte const *pc =
4731 __glXSetupSingleRequest(gc, X_GLsop_IsList, cmdlen);
4732 (void) memcpy((void *) (pc + 0), (void *) (&list), 4);
4733 retval = (GLboolean) __glXReadReply(dpy, 0, NULL, GL_FALSE);
4734 UnlockDisplay(dpy);
4735 SyncHandle();
4736 #endif /* USE_XCB */
4737 }
4738 return retval;
4739 }
4740
4741 #define X_GLrop_DepthRange 174
4742 void
4743 __indirect_glDepthRange(GLclampd zNear, GLclampd zFar)
4744 {
4745 __GLXcontext *const gc = __glXGetCurrentContext();
4746 const GLuint cmdlen = 20;
4747 emit_header(gc->pc, X_GLrop_DepthRange, cmdlen);
4748 (void) memcpy((void *) (gc->pc + 4), (void *) (&zNear), 8);
4749 (void) memcpy((void *) (gc->pc + 12), (void *) (&zFar), 8);
4750 gc->pc += cmdlen;
4751 if (__builtin_expect(gc->pc > gc->limit, 0)) {
4752 (void) __glXFlushRenderBuffer(gc, gc->pc);
4753 }
4754 }
4755
4756 #define X_GLrop_Frustum 175
4757 void
4758 __indirect_glFrustum(GLdouble left, GLdouble right, GLdouble bottom,
4759 GLdouble top, GLdouble zNear, GLdouble zFar)
4760 {
4761 __GLXcontext *const gc = __glXGetCurrentContext();
4762 const GLuint cmdlen = 52;
4763 emit_header(gc->pc, X_GLrop_Frustum, cmdlen);
4764 (void) memcpy((void *) (gc->pc + 4), (void *) (&left), 8);
4765 (void) memcpy((void *) (gc->pc + 12), (void *) (&right), 8);
4766 (void) memcpy((void *) (gc->pc + 20), (void *) (&bottom), 8);
4767 (void) memcpy((void *) (gc->pc + 28), (void *) (&top), 8);
4768 (void) memcpy((void *) (gc->pc + 36), (void *) (&zNear), 8);
4769 (void) memcpy((void *) (gc->pc + 44), (void *) (&zFar), 8);
4770 gc->pc += cmdlen;
4771 if (__builtin_expect(gc->pc > gc->limit, 0)) {
4772 (void) __glXFlushRenderBuffer(gc, gc->pc);
4773 }
4774 }
4775
4776 #define X_GLrop_LoadIdentity 176
4777 void
4778 __indirect_glLoadIdentity(void)
4779 {
4780 __GLXcontext *const gc = __glXGetCurrentContext();
4781 const GLuint cmdlen = 4;
4782 emit_header(gc->pc, X_GLrop_LoadIdentity, cmdlen);
4783 gc->pc += cmdlen;
4784 if (__builtin_expect(gc->pc > gc->limit, 0)) {
4785 (void) __glXFlushRenderBuffer(gc, gc->pc);
4786 }
4787 }
4788
4789 #define X_GLrop_LoadMatrixf 177
4790 void
4791 __indirect_glLoadMatrixf(const GLfloat * m)
4792 {
4793 __GLXcontext *const gc = __glXGetCurrentContext();
4794 const GLuint cmdlen = 68;
4795 emit_header(gc->pc, X_GLrop_LoadMatrixf, cmdlen);
4796 (void) memcpy((void *) (gc->pc + 4), (void *) (m), 64);
4797 gc->pc += cmdlen;
4798 if (__builtin_expect(gc->pc > gc->limit, 0)) {
4799 (void) __glXFlushRenderBuffer(gc, gc->pc);
4800 }
4801 }
4802
4803 #define X_GLrop_LoadMatrixd 178
4804 void
4805 __indirect_glLoadMatrixd(const GLdouble * m)
4806 {
4807 __GLXcontext *const gc = __glXGetCurrentContext();
4808 const GLuint cmdlen = 132;
4809 emit_header(gc->pc, X_GLrop_LoadMatrixd, cmdlen);
4810 (void) memcpy((void *) (gc->pc + 4), (void *) (m), 128);
4811 gc->pc += cmdlen;
4812 if (__builtin_expect(gc->pc > gc->limit, 0)) {
4813 (void) __glXFlushRenderBuffer(gc, gc->pc);
4814 }
4815 }
4816
4817 #define X_GLrop_MatrixMode 179
4818 void
4819 __indirect_glMatrixMode(GLenum mode)
4820 {
4821 __GLXcontext *const gc = __glXGetCurrentContext();
4822 const GLuint cmdlen = 8;
4823 emit_header(gc->pc, X_GLrop_MatrixMode, cmdlen);
4824 (void) memcpy((void *) (gc->pc + 4), (void *) (&mode), 4);
4825 gc->pc += cmdlen;
4826 if (__builtin_expect(gc->pc > gc->limit, 0)) {
4827 (void) __glXFlushRenderBuffer(gc, gc->pc);
4828 }
4829 }
4830
4831 #define X_GLrop_MultMatrixf 180
4832 void
4833 __indirect_glMultMatrixf(const GLfloat * m)
4834 {
4835 __GLXcontext *const gc = __glXGetCurrentContext();
4836 const GLuint cmdlen = 68;
4837 emit_header(gc->pc, X_GLrop_MultMatrixf, cmdlen);
4838 (void) memcpy((void *) (gc->pc + 4), (void *) (m), 64);
4839 gc->pc += cmdlen;
4840 if (__builtin_expect(gc->pc > gc->limit, 0)) {
4841 (void) __glXFlushRenderBuffer(gc, gc->pc);
4842 }
4843 }
4844
4845 #define X_GLrop_MultMatrixd 181
4846 void
4847 __indirect_glMultMatrixd(const GLdouble * m)
4848 {
4849 __GLXcontext *const gc = __glXGetCurrentContext();
4850 const GLuint cmdlen = 132;
4851 emit_header(gc->pc, X_GLrop_MultMatrixd, cmdlen);
4852 (void) memcpy((void *) (gc->pc + 4), (void *) (m), 128);
4853 gc->pc += cmdlen;
4854 if (__builtin_expect(gc->pc > gc->limit, 0)) {
4855 (void) __glXFlushRenderBuffer(gc, gc->pc);
4856 }
4857 }
4858
4859 #define X_GLrop_Ortho 182
4860 void
4861 __indirect_glOrtho(GLdouble left, GLdouble right, GLdouble bottom,
4862 GLdouble top, GLdouble zNear, GLdouble zFar)
4863 {
4864 __GLXcontext *const gc = __glXGetCurrentContext();
4865 const GLuint cmdlen = 52;
4866 emit_header(gc->pc, X_GLrop_Ortho, cmdlen);
4867 (void) memcpy((void *) (gc->pc + 4), (void *) (&left), 8);
4868 (void) memcpy((void *) (gc->pc + 12), (void *) (&right), 8);
4869 (void) memcpy((void *) (gc->pc + 20), (void *) (&bottom), 8);
4870 (void) memcpy((void *) (gc->pc + 28), (void *) (&top), 8);
4871 (void) memcpy((void *) (gc->pc + 36), (void *) (&zNear), 8);
4872 (void) memcpy((void *) (gc->pc + 44), (void *) (&zFar), 8);
4873 gc->pc += cmdlen;
4874 if (__builtin_expect(gc->pc > gc->limit, 0)) {
4875 (void) __glXFlushRenderBuffer(gc, gc->pc);
4876 }
4877 }
4878
4879 #define X_GLrop_PopMatrix 183
4880 void
4881 __indirect_glPopMatrix(void)
4882 {
4883 __GLXcontext *const gc = __glXGetCurrentContext();
4884 const GLuint cmdlen = 4;
4885 emit_header(gc->pc, X_GLrop_PopMatrix, cmdlen);
4886 gc->pc += cmdlen;
4887 if (__builtin_expect(gc->pc > gc->limit, 0)) {
4888 (void) __glXFlushRenderBuffer(gc, gc->pc);
4889 }
4890 }
4891
4892 #define X_GLrop_PushMatrix 184
4893 void
4894 __indirect_glPushMatrix(void)
4895 {
4896 __GLXcontext *const gc = __glXGetCurrentContext();
4897 const GLuint cmdlen = 4;
4898 emit_header(gc->pc, X_GLrop_PushMatrix, cmdlen);
4899 gc->pc += cmdlen;
4900 if (__builtin_expect(gc->pc > gc->limit, 0)) {
4901 (void) __glXFlushRenderBuffer(gc, gc->pc);
4902 }
4903 }
4904
4905 #define X_GLrop_Rotated 185
4906 void
4907 __indirect_glRotated(GLdouble angle, GLdouble x, GLdouble y, GLdouble z)
4908 {
4909 __GLXcontext *const gc = __glXGetCurrentContext();
4910 const GLuint cmdlen = 36;
4911 emit_header(gc->pc, X_GLrop_Rotated, cmdlen);
4912 (void) memcpy((void *) (gc->pc + 4), (void *) (&angle), 8);
4913 (void) memcpy((void *) (gc->pc + 12), (void *) (&x), 8);
4914 (void) memcpy((void *) (gc->pc + 20), (void *) (&y), 8);
4915 (void) memcpy((void *) (gc->pc + 28), (void *) (&z), 8);
4916 gc->pc += cmdlen;
4917 if (__builtin_expect(gc->pc > gc->limit, 0)) {
4918 (void) __glXFlushRenderBuffer(gc, gc->pc);
4919 }
4920 }
4921
4922 #define X_GLrop_Rotatef 186
4923 void
4924 __indirect_glRotatef(GLfloat angle, GLfloat x, GLfloat y, GLfloat z)
4925 {
4926 __GLXcontext *const gc = __glXGetCurrentContext();
4927 const GLuint cmdlen = 20;
4928 emit_header(gc->pc, X_GLrop_Rotatef, cmdlen);
4929 (void) memcpy((void *) (gc->pc + 4), (void *) (&angle), 4);
4930 (void) memcpy((void *) (gc->pc + 8), (void *) (&x), 4);
4931 (void) memcpy((void *) (gc->pc + 12), (void *) (&y), 4);
4932 (void) memcpy((void *) (gc->pc + 16), (void *) (&z), 4);
4933 gc->pc += cmdlen;
4934 if (__builtin_expect(gc->pc > gc->limit, 0)) {
4935 (void) __glXFlushRenderBuffer(gc, gc->pc);
4936 }
4937 }
4938
4939 #define X_GLrop_Scaled 187
4940 void
4941 __indirect_glScaled(GLdouble x, GLdouble y, GLdouble z)
4942 {
4943 __GLXcontext *const gc = __glXGetCurrentContext();
4944 const GLuint cmdlen = 28;
4945 emit_header(gc->pc, X_GLrop_Scaled, cmdlen);
4946 (void) memcpy((void *) (gc->pc + 4), (void *) (&x), 8);
4947 (void) memcpy((void *) (gc->pc + 12), (void *) (&y), 8);
4948 (void) memcpy((void *) (gc->pc + 20), (void *) (&z), 8);
4949 gc->pc += cmdlen;
4950 if (__builtin_expect(gc->pc > gc->limit, 0)) {
4951 (void) __glXFlushRenderBuffer(gc, gc->pc);
4952 }
4953 }
4954
4955 #define X_GLrop_Scalef 188
4956 void
4957 __indirect_glScalef(GLfloat x, GLfloat y, GLfloat z)
4958 {
4959 __GLXcontext *const gc = __glXGetCurrentContext();
4960 const GLuint cmdlen = 16;
4961 emit_header(gc->pc, X_GLrop_Scalef, cmdlen);
4962 (void) memcpy((void *) (gc->pc + 4), (void *) (&x), 4);
4963 (void) memcpy((void *) (gc->pc + 8), (void *) (&y), 4);
4964 (void) memcpy((void *) (gc->pc + 12), (void *) (&z), 4);
4965 gc->pc += cmdlen;
4966 if (__builtin_expect(gc->pc > gc->limit, 0)) {
4967 (void) __glXFlushRenderBuffer(gc, gc->pc);
4968 }
4969 }
4970
4971 #define X_GLrop_Translated 189
4972 void
4973 __indirect_glTranslated(GLdouble x, GLdouble y, GLdouble z)
4974 {
4975 __GLXcontext *const gc = __glXGetCurrentContext();
4976 const GLuint cmdlen = 28;
4977 emit_header(gc->pc, X_GLrop_Translated, cmdlen);
4978 (void) memcpy((void *) (gc->pc + 4), (void *) (&x), 8);
4979 (void) memcpy((void *) (gc->pc + 12), (void *) (&y), 8);
4980 (void) memcpy((void *) (gc->pc + 20), (void *) (&z), 8);
4981 gc->pc += cmdlen;
4982 if (__builtin_expect(gc->pc > gc->limit, 0)) {
4983 (void) __glXFlushRenderBuffer(gc, gc->pc);
4984 }
4985 }
4986
4987 #define X_GLrop_Translatef 190
4988 void
4989 __indirect_glTranslatef(GLfloat x, GLfloat y, GLfloat z)
4990 {
4991 __GLXcontext *const gc = __glXGetCurrentContext();
4992 const GLuint cmdlen = 16;
4993 emit_header(gc->pc, X_GLrop_Translatef, cmdlen);
4994 (void) memcpy((void *) (gc->pc + 4), (void *) (&x), 4);
4995 (void) memcpy((void *) (gc->pc + 8), (void *) (&y), 4);
4996 (void) memcpy((void *) (gc->pc + 12), (void *) (&z), 4);
4997 gc->pc += cmdlen;
4998 if (__builtin_expect(gc->pc > gc->limit, 0)) {
4999 (void) __glXFlushRenderBuffer(gc, gc->pc);
5000 }
5001 }
5002
5003 #define X_GLrop_Viewport 191
5004 void
5005 __indirect_glViewport(GLint x, GLint y, GLsizei width, GLsizei height)
5006 {
5007 __GLXcontext *const gc = __glXGetCurrentContext();
5008 const GLuint cmdlen = 20;
5009 emit_header(gc->pc, X_GLrop_Viewport, cmdlen);
5010 (void) memcpy((void *) (gc->pc + 4), (void *) (&x), 4);
5011 (void) memcpy((void *) (gc->pc + 8), (void *) (&y), 4);
5012 (void) memcpy((void *) (gc->pc + 12), (void *) (&width), 4);
5013 (void) memcpy((void *) (gc->pc + 16), (void *) (&height), 4);
5014 gc->pc += cmdlen;
5015 if (__builtin_expect(gc->pc > gc->limit, 0)) {
5016 (void) __glXFlushRenderBuffer(gc, gc->pc);
5017 }
5018 }
5019
5020 #define X_GLrop_BindTexture 4117
5021 void
5022 __indirect_glBindTexture(GLenum target, GLuint texture)
5023 {
5024 __GLXcontext *const gc = __glXGetCurrentContext();
5025 const GLuint cmdlen = 12;
5026 emit_header(gc->pc, X_GLrop_BindTexture, cmdlen);
5027 (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4);
5028 (void) memcpy((void *) (gc->pc + 8), (void *) (&texture), 4);
5029 gc->pc += cmdlen;
5030 if (__builtin_expect(gc->pc > gc->limit, 0)) {
5031 (void) __glXFlushRenderBuffer(gc, gc->pc);
5032 }
5033 }
5034
5035 #define X_GLrop_Indexubv 194
5036 void
5037 __indirect_glIndexub(GLubyte c)
5038 {
5039 __GLXcontext *const gc = __glXGetCurrentContext();
5040 const GLuint cmdlen = 8;
5041 emit_header(gc->pc, X_GLrop_Indexubv, cmdlen);
5042 (void) memcpy((void *) (gc->pc + 4), (void *) (&c), 1);
5043 gc->pc += cmdlen;
5044 if (__builtin_expect(gc->pc > gc->limit, 0)) {
5045 (void) __glXFlushRenderBuffer(gc, gc->pc);
5046 }
5047 }
5048
5049 #define X_GLrop_Indexubv 194
5050 void
5051 __indirect_glIndexubv(const GLubyte *c)
5052 {
5053 __GLXcontext *const gc = __glXGetCurrentContext();
5054 const GLuint cmdlen = 8;
5055 emit_header(gc->pc, X_GLrop_Indexubv, cmdlen);
5056 (void) memcpy((void *) (gc->pc + 4), (void *) (c), 1);
5057 gc->pc += cmdlen;
5058 if (__builtin_expect(gc->pc > gc->limit, 0)) {
5059 (void) __glXFlushRenderBuffer(gc, gc->pc);
5060 }
5061 }
5062
5063 #define X_GLrop_PolygonOffset 192
5064 void
5065 __indirect_glPolygonOffset(GLfloat factor, GLfloat units)
5066 {
5067 __GLXcontext *const gc = __glXGetCurrentContext();
5068 const GLuint cmdlen = 12;
5069 emit_header(gc->pc, X_GLrop_PolygonOffset, cmdlen);
5070 (void) memcpy((void *) (gc->pc + 4), (void *) (&factor), 4);
5071 (void) memcpy((void *) (gc->pc + 8), (void *) (&units), 4);
5072 gc->pc += cmdlen;
5073 if (__builtin_expect(gc->pc > gc->limit, 0)) {
5074 (void) __glXFlushRenderBuffer(gc, gc->pc);
5075 }
5076 }
5077
5078 #define X_GLsop_AreTexturesResident 143
5079 GLboolean
5080 __indirect_glAreTexturesResident(GLsizei n, const GLuint * textures,
5081 GLboolean * residences)
5082 {
5083 __GLXcontext *const gc = __glXGetCurrentContext();
5084 Display *const dpy = gc->currentDpy;
5085 GLboolean retval = (GLboolean) 0;
5086 #ifndef USE_XCB
5087 const GLuint cmdlen = 4 + __GLX_PAD((n * 4));
5088 #endif
5089 if (n < 0) {
5090 __glXSetError(gc, GL_INVALID_VALUE);
5091 return 0;
5092 }
5093 if (__builtin_expect((n >= 0) && (dpy != NULL), 1)) {
5094 #ifdef USE_XCB
5095 xcb_connection_t *c = XGetXCBConnection(dpy);
5096 (void) __glXFlushRenderBuffer(gc, gc->pc);
5097 xcb_glx_are_textures_resident_reply_t *reply =
5098 xcb_glx_are_textures_resident_reply(c,
5099 xcb_glx_are_textures_resident
5100 (c, gc->currentContextTag, n,
5101 textures), NULL);
5102 (void) memcpy(residences, xcb_glx_are_textures_resident_data(reply),
5103 xcb_glx_are_textures_resident_data_length(reply) *
5104 sizeof(GLboolean));
5105 retval = reply->ret_val;
5106 free(reply);
5107 #else
5108 GLubyte const *pc =
5109 __glXSetupSingleRequest(gc, X_GLsop_AreTexturesResident, cmdlen);
5110 (void) memcpy((void *) (pc + 0), (void *) (&n), 4);
5111 (void) memcpy((void *) (pc + 4), (void *) (textures), (n * 4));
5112 retval = (GLboolean) __glXReadReply(dpy, 1, residences, GL_TRUE);
5113 UnlockDisplay(dpy);
5114 SyncHandle();
5115 #endif /* USE_XCB */
5116 }
5117 return retval;
5118 }
5119
5120 #define X_GLvop_AreTexturesResidentEXT 11
5121 GLboolean
5122 glAreTexturesResidentEXT(GLsizei n, const GLuint * textures,
5123 GLboolean * residences)
5124 {
5125 __GLXcontext *const gc = __glXGetCurrentContext();
5126
5127 #ifdef GLX_DIRECT_RENDERING
5128 if (gc->driContext) {
5129 return CALL_AreTexturesResident(GET_DISPATCH(),
5130 (n, textures, residences));
5131 } else
5132 #endif
5133 {
5134 __GLXcontext *const gc = __glXGetCurrentContext();
5135 Display *const dpy = gc->currentDpy;
5136 GLboolean retval = (GLboolean) 0;
5137 const GLuint cmdlen = 4 + __GLX_PAD((n * 4));
5138 if (n < 0) {
5139 __glXSetError(gc, GL_INVALID_VALUE);
5140 return 0;
5141 }
5142 if (__builtin_expect((n >= 0) && (dpy != NULL), 1)) {
5143 GLubyte const *pc =
5144 __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithReply,
5145 X_GLvop_AreTexturesResidentEXT,
5146 cmdlen);
5147 (void) memcpy((void *) (pc + 0), (void *) (&n), 4);
5148 (void) memcpy((void *) (pc + 4), (void *) (textures), (n * 4));
5149 retval = (GLboolean) __glXReadReply(dpy, 1, residences, GL_TRUE);
5150 UnlockDisplay(dpy);
5151 SyncHandle();
5152 }
5153 return retval;
5154 }
5155 }
5156
5157 #define X_GLrop_CopyTexImage1D 4119
5158 void
5159 __indirect_glCopyTexImage1D(GLenum target, GLint level, GLenum internalformat,
5160 GLint x, GLint y, GLsizei width, GLint border)
5161 {
5162 __GLXcontext *const gc = __glXGetCurrentContext();
5163 const GLuint cmdlen = 32;
5164 emit_header(gc->pc, X_GLrop_CopyTexImage1D, cmdlen);
5165 (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4);
5166 (void) memcpy((void *) (gc->pc + 8), (void *) (&level), 4);
5167 (void) memcpy((void *) (gc->pc + 12), (void *) (&internalformat), 4);
5168 (void) memcpy((void *) (gc->pc + 16), (void *) (&x), 4);
5169 (void) memcpy((void *) (gc->pc + 20), (void *) (&y), 4);
5170 (void) memcpy((void *) (gc->pc + 24), (void *) (&width), 4);
5171 (void) memcpy((void *) (gc->pc + 28), (void *) (&border), 4);
5172 gc->pc += cmdlen;
5173 if (__builtin_expect(gc->pc > gc->limit, 0)) {
5174 (void) __glXFlushRenderBuffer(gc, gc->pc);
5175 }
5176 }
5177
5178 #define X_GLrop_CopyTexImage2D 4120
5179 void
5180 __indirect_glCopyTexImage2D(GLenum target, GLint level, GLenum internalformat,
5181 GLint x, GLint y, GLsizei width, GLsizei height,
5182 GLint border)
5183 {
5184 __GLXcontext *const gc = __glXGetCurrentContext();
5185 const GLuint cmdlen = 36;
5186 emit_header(gc->pc, X_GLrop_CopyTexImage2D, cmdlen);
5187 (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4);
5188 (void) memcpy((void *) (gc->pc + 8), (void *) (&level), 4);
5189 (void) memcpy((void *) (gc->pc + 12), (void *) (&internalformat), 4);
5190 (void) memcpy((void *) (gc->pc + 16), (void *) (&x), 4);
5191 (void) memcpy((void *) (gc->pc + 20), (void *) (&y), 4);
5192 (void) memcpy((void *) (gc->pc + 24), (void *) (&width), 4);
5193 (void) memcpy((void *) (gc->pc + 28), (void *) (&height), 4);
5194 (void) memcpy((void *) (gc->pc + 32), (void *) (&border), 4);
5195 gc->pc += cmdlen;
5196 if (__builtin_expect(gc->pc > gc->limit, 0)) {
5197 (void) __glXFlushRenderBuffer(gc, gc->pc);
5198 }
5199 }
5200
5201 #define X_GLrop_CopyTexSubImage1D 4121
5202 void
5203 __indirect_glCopyTexSubImage1D(GLenum target, GLint level, GLint xoffset,
5204 GLint x, GLint y, GLsizei width)
5205 {
5206 __GLXcontext *const gc = __glXGetCurrentContext();
5207 const GLuint cmdlen = 28;
5208 emit_header(gc->pc, X_GLrop_CopyTexSubImage1D, cmdlen);
5209 (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4);
5210 (void) memcpy((void *) (gc->pc + 8), (void *) (&level), 4);
5211 (void) memcpy((void *) (gc->pc + 12), (void *) (&xoffset), 4);
5212 (void) memcpy((void *) (gc->pc + 16), (void *) (&x), 4);
5213 (void) memcpy((void *) (gc->pc + 20), (void *) (&y), 4);
5214 (void) memcpy((void *) (gc->pc + 24), (void *) (&width), 4);
5215 gc->pc += cmdlen;
5216 if (__builtin_expect(gc->pc > gc->limit, 0)) {
5217 (void) __glXFlushRenderBuffer(gc, gc->pc);
5218 }
5219 }
5220
5221 #define X_GLrop_CopyTexSubImage2D 4122
5222 void
5223 __indirect_glCopyTexSubImage2D(GLenum target, GLint level, GLint xoffset,
5224 GLint yoffset, GLint x, GLint y, GLsizei width,
5225 GLsizei height)
5226 {
5227 __GLXcontext *const gc = __glXGetCurrentContext();
5228 const GLuint cmdlen = 36;
5229 emit_header(gc->pc, X_GLrop_CopyTexSubImage2D, cmdlen);
5230 (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4);
5231 (void) memcpy((void *) (gc->pc + 8), (void *) (&level), 4);
5232 (void) memcpy((void *) (gc->pc + 12), (void *) (&xoffset), 4);
5233 (void) memcpy((void *) (gc->pc + 16), (void *) (&yoffset), 4);
5234 (void) memcpy((void *) (gc->pc + 20), (void *) (&x), 4);
5235 (void) memcpy((void *) (gc->pc + 24), (void *) (&y), 4);
5236 (void) memcpy((void *) (gc->pc + 28), (void *) (&width), 4);
5237 (void) memcpy((void *) (gc->pc + 32), (void *) (&height), 4);
5238 gc->pc += cmdlen;
5239 if (__builtin_expect(gc->pc > gc->limit, 0)) {
5240 (void) __glXFlushRenderBuffer(gc, gc->pc);
5241 }
5242 }
5243
5244 #define X_GLsop_DeleteTextures 144
5245 void
5246 __indirect_glDeleteTextures(GLsizei n, const GLuint * textures)
5247 {
5248 __GLXcontext *const gc = __glXGetCurrentContext();
5249 Display *const dpy = gc->currentDpy;
5250 #ifndef USE_XCB
5251 const GLuint cmdlen = 4 + __GLX_PAD((n * 4));
5252 #endif
5253 if (n < 0) {
5254 __glXSetError(gc, GL_INVALID_VALUE);
5255 return;
5256 }
5257 if (__builtin_expect((n >= 0) && (dpy != NULL), 1)) {
5258 #ifdef USE_XCB
5259 xcb_connection_t *c = XGetXCBConnection(dpy);
5260 (void) __glXFlushRenderBuffer(gc, gc->pc);
5261 xcb_glx_delete_textures(c, gc->currentContextTag, n, textures);
5262 #else
5263 GLubyte const *pc =
5264 __glXSetupSingleRequest(gc, X_GLsop_DeleteTextures, cmdlen);
5265 (void) memcpy((void *) (pc + 0), (void *) (&n), 4);
5266 (void) memcpy((void *) (pc + 4), (void *) (textures), (n * 4));
5267 UnlockDisplay(dpy);
5268 SyncHandle();
5269 #endif /* USE_XCB */
5270 }
5271 return;
5272 }
5273
5274 #define X_GLvop_DeleteTexturesEXT 12
5275 void
5276 glDeleteTexturesEXT(GLsizei n, const GLuint * textures)
5277 {
5278 __GLXcontext *const gc = __glXGetCurrentContext();
5279
5280 #ifdef GLX_DIRECT_RENDERING
5281 if (gc->driContext) {
5282 CALL_DeleteTextures(GET_DISPATCH(), (n, textures));
5283 } else
5284 #endif
5285 {
5286 __GLXcontext *const gc = __glXGetCurrentContext();
5287 Display *const dpy = gc->currentDpy;
5288 const GLuint cmdlen = 4 + __GLX_PAD((n * 4));
5289 if (n < 0) {
5290 __glXSetError(gc, GL_INVALID_VALUE);
5291 return;
5292 }
5293 if (__builtin_expect((n >= 0) && (dpy != NULL), 1)) {
5294 GLubyte const *pc =
5295 __glXSetupVendorRequest(gc, X_GLXVendorPrivate,
5296 X_GLvop_DeleteTexturesEXT, cmdlen);
5297 (void) memcpy((void *) (pc + 0), (void *) (&n), 4);
5298 (void) memcpy((void *) (pc + 4), (void *) (textures), (n * 4));
5299 UnlockDisplay(dpy);
5300 SyncHandle();
5301 }
5302 return;
5303 }
5304 }
5305
5306 #define X_GLsop_GenTextures 145
5307 void
5308 __indirect_glGenTextures(GLsizei n, GLuint * textures)
5309 {
5310 __GLXcontext *const gc = __glXGetCurrentContext();
5311 Display *const dpy = gc->currentDpy;
5312 #ifndef USE_XCB
5313 const GLuint cmdlen = 4;
5314 #endif
5315 if (n < 0) {
5316 __glXSetError(gc, GL_INVALID_VALUE);
5317 return;
5318 }
5319 if (__builtin_expect((n >= 0) && (dpy != NULL), 1)) {
5320 #ifdef USE_XCB
5321 xcb_connection_t *c = XGetXCBConnection(dpy);
5322 (void) __glXFlushRenderBuffer(gc, gc->pc);
5323 xcb_glx_gen_textures_reply_t *reply =
5324 xcb_glx_gen_textures_reply(c,
5325 xcb_glx_gen_textures(c,
5326 gc->
5327 currentContextTag,
5328 n), NULL);
5329 (void) memcpy(textures, xcb_glx_gen_textures_data(reply),
5330 xcb_glx_gen_textures_data_length(reply) *
5331 sizeof(GLuint));
5332 free(reply);
5333 #else
5334 GLubyte const *pc =
5335 __glXSetupSingleRequest(gc, X_GLsop_GenTextures, cmdlen);
5336 (void) memcpy((void *) (pc + 0), (void *) (&n), 4);
5337 (void) __glXReadReply(dpy, 4, textures, GL_TRUE);
5338 UnlockDisplay(dpy);
5339 SyncHandle();
5340 #endif /* USE_XCB */
5341 }
5342 return;
5343 }
5344
5345 #define X_GLvop_GenTexturesEXT 13
5346 void
5347 glGenTexturesEXT(GLsizei n, GLuint * textures)
5348 {
5349 __GLXcontext *const gc = __glXGetCurrentContext();
5350
5351 #ifdef GLX_DIRECT_RENDERING
5352 if (gc->driContext) {
5353 CALL_GenTextures(GET_DISPATCH(), (n, textures));
5354 } else
5355 #endif
5356 {
5357 __GLXcontext *const gc = __glXGetCurrentContext();
5358 Display *const dpy = gc->currentDpy;
5359 const GLuint cmdlen = 4;
5360 if (n < 0) {
5361 __glXSetError(gc, GL_INVALID_VALUE);
5362 return;
5363 }
5364 if (__builtin_expect((n >= 0) && (dpy != NULL), 1)) {
5365 GLubyte const *pc =
5366 __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithReply,
5367 X_GLvop_GenTexturesEXT, cmdlen);
5368 (void) memcpy((void *) (pc + 0), (void *) (&n), 4);
5369 (void) __glXReadReply(dpy, 4, textures, GL_TRUE);
5370 UnlockDisplay(dpy);
5371 SyncHandle();
5372 }
5373 return;
5374 }
5375 }
5376
5377 #define X_GLsop_IsTexture 146
5378 GLboolean
5379 __indirect_glIsTexture(GLuint texture)
5380 {
5381 __GLXcontext *const gc = __glXGetCurrentContext();
5382 Display *const dpy = gc->currentDpy;
5383 GLboolean retval = (GLboolean) 0;
5384 #ifndef USE_XCB
5385 const GLuint cmdlen = 4;
5386 #endif
5387 if (__builtin_expect(dpy != NULL, 1)) {
5388 #ifdef USE_XCB
5389 xcb_connection_t *c = XGetXCBConnection(dpy);
5390 (void) __glXFlushRenderBuffer(gc, gc->pc);
5391 xcb_glx_is_texture_reply_t *reply =
5392 xcb_glx_is_texture_reply(c,
5393 xcb_glx_is_texture(c,
5394 gc->currentContextTag,
5395 texture), NULL);
5396 retval = reply->ret_val;
5397 free(reply);
5398 #else
5399 GLubyte const *pc =
5400 __glXSetupSingleRequest(gc, X_GLsop_IsTexture, cmdlen);
5401 (void) memcpy((void *) (pc + 0), (void *) (&texture), 4);
5402 retval = (GLboolean) __glXReadReply(dpy, 0, NULL, GL_FALSE);
5403 UnlockDisplay(dpy);
5404 SyncHandle();
5405 #endif /* USE_XCB */
5406 }
5407 return retval;
5408 }
5409
5410 #define X_GLvop_IsTextureEXT 14
5411 GLboolean
5412 glIsTextureEXT(GLuint texture)
5413 {
5414 __GLXcontext *const gc = __glXGetCurrentContext();
5415
5416 #ifdef GLX_DIRECT_RENDERING
5417 if (gc->driContext) {
5418 return CALL_IsTexture(GET_DISPATCH(), (texture));
5419 } else
5420 #endif
5421 {
5422 __GLXcontext *const gc = __glXGetCurrentContext();
5423 Display *const dpy = gc->currentDpy;
5424 GLboolean retval = (GLboolean) 0;
5425 const GLuint cmdlen = 4;
5426 if (__builtin_expect(dpy != NULL, 1)) {
5427 GLubyte const *pc =
5428 __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithReply,
5429 X_GLvop_IsTextureEXT, cmdlen);
5430 (void) memcpy((void *) (pc + 0), (void *) (&texture), 4);
5431 retval = (GLboolean) __glXReadReply(dpy, 0, NULL, GL_FALSE);
5432 UnlockDisplay(dpy);
5433 SyncHandle();
5434 }
5435 return retval;
5436 }
5437 }
5438
5439 #define X_GLrop_PrioritizeTextures 4118
5440 void
5441 __indirect_glPrioritizeTextures(GLsizei n, const GLuint * textures,
5442 const GLclampf * priorities)
5443 {
5444 __GLXcontext *const gc = __glXGetCurrentContext();
5445 const GLuint cmdlen = 8 + __GLX_PAD((n * 4)) + __GLX_PAD((n * 4));
5446 if (n < 0) {
5447 __glXSetError(gc, GL_INVALID_VALUE);
5448 return;
5449 }
5450 if (__builtin_expect(n >= 0, 1)) {
5451 emit_header(gc->pc, X_GLrop_PrioritizeTextures, cmdlen);
5452 (void) memcpy((void *) (gc->pc + 4), (void *) (&n), 4);
5453 (void) memcpy((void *) (gc->pc + 8), (void *) (textures), (n * 4));
5454 (void) memcpy((void *) (gc->pc + 8 + (n * 4)), (void *) (priorities),
5455 (n * 4));
5456 gc->pc += cmdlen;
5457 if (__builtin_expect(gc->pc > gc->limit, 0)) {
5458 (void) __glXFlushRenderBuffer(gc, gc->pc);
5459 }
5460 }
5461 }
5462
5463 static void
5464 __glx_TexSubImage_1D2D(unsigned opcode, unsigned dim, GLenum target,
5465 GLint level, GLint xoffset, GLint yoffset,
5466 GLsizei width, GLsizei height, GLenum format,
5467 GLenum type, const GLvoid * pixels)
5468 {
5469 __GLXcontext *const gc = __glXGetCurrentContext();
5470 const GLuint compsize =
5471 (pixels != NULL) ? __glImageSize(width, height, 1, format, type,
5472 target) : 0;
5473 const GLuint cmdlen = 60 + __GLX_PAD(compsize);
5474 if (__builtin_expect(gc->currentDpy != NULL, 1)) {
5475 if (cmdlen <= gc->maxSmallRenderCommandSize) {
5476 if ((gc->pc + cmdlen) > gc->bufEnd) {
5477 (void) __glXFlushRenderBuffer(gc, gc->pc);
5478 }
5479 emit_header(gc->pc, opcode, cmdlen);
5480 (void) memcpy((void *) (gc->pc + 24), (void *) (&target), 4);
5481 (void) memcpy((void *) (gc->pc + 28), (void *) (&level), 4);
5482 (void) memcpy((void *) (gc->pc + 32), (void *) (&xoffset), 4);
5483 (void) memcpy((void *) (gc->pc + 36), (void *) (&yoffset), 4);
5484 (void) memcpy((void *) (gc->pc + 40), (void *) (&width), 4);
5485 (void) memcpy((void *) (gc->pc + 44), (void *) (&height), 4);
5486 (void) memcpy((void *) (gc->pc + 48), (void *) (&format), 4);
5487 (void) memcpy((void *) (gc->pc + 52), (void *) (&type), 4);
5488 (void) memcpy((void *) (gc->pc + 56),
5489 (void *) ((pixels == NULL) ? one : zero), 4);
5490 if (compsize > 0) {
5491 (*gc->fillImage) (gc, dim, width, height, 1, format, type,
5492 pixels, gc->pc + 60, gc->pc + 4);
5493 } else {
5494 (void) memcpy(gc->pc + 4, default_pixel_store_2D,
5495 default_pixel_store_2D_size);
5496 }
5497 gc->pc += cmdlen;
5498 if (gc->pc > gc->limit) {
5499 (void) __glXFlushRenderBuffer(gc, gc->pc);
5500 }
5501 } else {
5502 const GLint op = opcode;
5503 const GLuint cmdlenLarge = cmdlen + 4;
5504 GLubyte *const pc = __glXFlushRenderBuffer(gc, gc->pc);
5505 (void) memcpy((void *) (pc + 0), (void *) (&cmdlenLarge), 4);
5506 (void) memcpy((void *) (pc + 4), (void *) (&op), 4);
5507 (void) memcpy((void *) (pc + 28), (void *) (&target), 4);
5508 (void) memcpy((void *) (pc + 32), (void *) (&level), 4);
5509 (void) memcpy((void *) (pc + 36), (void *) (&xoffset), 4);
5510 (void) memcpy((void *) (pc + 40), (void *) (&yoffset), 4);
5511 (void) memcpy((void *) (pc + 44), (void *) (&width), 4);
5512 (void) memcpy((void *) (pc + 48), (void *) (&height), 4);
5513 (void) memcpy((void *) (pc + 52), (void *) (&format), 4);
5514 (void) memcpy((void *) (pc + 56), (void *) (&type), 4);
5515 (void) memcpy((void *) (pc + 60), zero, 4);
5516 __glXSendLargeImage(gc, compsize, dim, width, height, 1, format,
5517 type, pixels, pc + 64, pc + 8);
5518 }
5519 }
5520 }
5521
5522 #define X_GLrop_TexSubImage1D 4099
5523 void
5524 __indirect_glTexSubImage1D(GLenum target, GLint level, GLint xoffset,
5525 GLsizei width, GLenum format, GLenum type,
5526 const GLvoid * pixels)
5527 {
5528 __glx_TexSubImage_1D2D(X_GLrop_TexSubImage1D, 1, target, level, xoffset,
5529 1, width, 1, format, type, pixels);
5530 }
5531
5532 #define X_GLrop_TexSubImage2D 4100
5533 void
5534 __indirect_glTexSubImage2D(GLenum target, GLint level, GLint xoffset,
5535 GLint yoffset, GLsizei width, GLsizei height,
5536 GLenum format, GLenum type, const GLvoid * pixels)
5537 {
5538 __glx_TexSubImage_1D2D(X_GLrop_TexSubImage2D, 2, target, level, xoffset,
5539 yoffset, width, height, format, type, pixels);
5540 }
5541
5542 #define X_GLrop_BlendColor 4096
5543 void
5544 __indirect_glBlendColor(GLclampf red, GLclampf green, GLclampf blue,
5545 GLclampf alpha)
5546 {
5547 __GLXcontext *const gc = __glXGetCurrentContext();
5548 const GLuint cmdlen = 20;
5549 emit_header(gc->pc, X_GLrop_BlendColor, cmdlen);
5550 (void) memcpy((void *) (gc->pc + 4), (void *) (&red), 4);
5551 (void) memcpy((void *) (gc->pc + 8), (void *) (&green), 4);
5552 (void) memcpy((void *) (gc->pc + 12), (void *) (&blue), 4);
5553 (void) memcpy((void *) (gc->pc + 16), (void *) (&alpha), 4);
5554 gc->pc += cmdlen;
5555 if (__builtin_expect(gc->pc > gc->limit, 0)) {
5556 (void) __glXFlushRenderBuffer(gc, gc->pc);
5557 }
5558 }
5559
5560 #define X_GLrop_BlendEquation 4097
5561 void
5562 __indirect_glBlendEquation(GLenum mode)
5563 {
5564 __GLXcontext *const gc = __glXGetCurrentContext();
5565 const GLuint cmdlen = 8;
5566 emit_header(gc->pc, X_GLrop_BlendEquation, cmdlen);
5567 (void) memcpy((void *) (gc->pc + 4), (void *) (&mode), 4);
5568 gc->pc += cmdlen;
5569 if (__builtin_expect(gc->pc > gc->limit, 0)) {
5570 (void) __glXFlushRenderBuffer(gc, gc->pc);
5571 }
5572 }
5573
5574 #define X_GLrop_ColorTable 2053
5575 void
5576 __indirect_glColorTable(GLenum target, GLenum internalformat, GLsizei width,
5577 GLenum format, GLenum type, const GLvoid * table)
5578 {
5579 __GLXcontext *const gc = __glXGetCurrentContext();
5580 const GLuint compsize =
5581 (table != NULL) ? __glImageSize(width, 1, 1, format, type,
5582 target) : 0;
5583 const GLuint cmdlen = 44 + __GLX_PAD(compsize);
5584 if (__builtin_expect(gc->currentDpy != NULL, 1)) {
5585 if (cmdlen <= gc->maxSmallRenderCommandSize) {
5586 if ((gc->pc + cmdlen) > gc->bufEnd) {
5587 (void) __glXFlushRenderBuffer(gc, gc->pc);
5588 }
5589 emit_header(gc->pc, X_GLrop_ColorTable, cmdlen);
5590 (void) memcpy((void *) (gc->pc + 24), (void *) (&target), 4);
5591 (void) memcpy((void *) (gc->pc + 28), (void *) (&internalformat),
5592 4);
5593 (void) memcpy((void *) (gc->pc + 32), (void *) (&width), 4);
5594 (void) memcpy((void *) (gc->pc + 36), (void *) (&format), 4);
5595 (void) memcpy((void *) (gc->pc + 40), (void *) (&type), 4);
5596 if (compsize > 0) {
5597 (*gc->fillImage) (gc, 1, width, 1, 1, format, type, table,
5598 gc->pc + 44, gc->pc + 4);
5599 } else {
5600 (void) memcpy(gc->pc + 4, default_pixel_store_1D,
5601 default_pixel_store_1D_size);
5602 }
5603 gc->pc += cmdlen;
5604 if (gc->pc > gc->limit) {
5605 (void) __glXFlushRenderBuffer(gc, gc->pc);
5606 }
5607 } else {
5608 const GLint op = X_GLrop_ColorTable;
5609 const GLuint cmdlenLarge = cmdlen + 4;
5610 GLubyte *const pc = __glXFlushRenderBuffer(gc, gc->pc);
5611 (void) memcpy((void *) (pc + 0), (void *) (&cmdlenLarge), 4);
5612 (void) memcpy((void *) (pc + 4), (void *) (&op), 4);
5613 (void) memcpy((void *) (pc + 28), (void *) (&target), 4);
5614 (void) memcpy((void *) (pc + 32), (void *) (&internalformat), 4);
5615 (void) memcpy((void *) (pc + 36), (void *) (&width), 4);
5616 (void) memcpy((void *) (pc + 40), (void *) (&format), 4);
5617 (void) memcpy((void *) (pc + 44), (void *) (&type), 4);
5618 __glXSendLargeImage(gc, compsize, 1, width, 1, 1, format, type,
5619 table, pc + 48, pc + 8);
5620 }
5621 }
5622 }
5623
5624 #define X_GLrop_ColorTableParameterfv 2054
5625 void
5626 __indirect_glColorTableParameterfv(GLenum target, GLenum pname,
5627 const GLfloat * params)
5628 {
5629 __GLXcontext *const gc = __glXGetCurrentContext();
5630 const GLuint compsize = __glColorTableParameterfv_size(pname);
5631 const GLuint cmdlen = 12 + __GLX_PAD((compsize * 4));
5632 emit_header(gc->pc, X_GLrop_ColorTableParameterfv, cmdlen);
5633 (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4);
5634 (void) memcpy((void *) (gc->pc + 8), (void *) (&pname), 4);
5635 (void) memcpy((void *) (gc->pc + 12), (void *) (params), (compsize * 4));
5636 gc->pc += cmdlen;
5637 if (__builtin_expect(gc->pc > gc->limit, 0)) {
5638 (void) __glXFlushRenderBuffer(gc, gc->pc);
5639 }
5640 }
5641
5642 #define X_GLrop_ColorTableParameteriv 2055
5643 void
5644 __indirect_glColorTableParameteriv(GLenum target, GLenum pname,
5645 const GLint * params)
5646 {
5647 __GLXcontext *const gc = __glXGetCurrentContext();
5648 const GLuint compsize = __glColorTableParameteriv_size(pname);
5649 const GLuint cmdlen = 12 + __GLX_PAD((compsize * 4));
5650 emit_header(gc->pc, X_GLrop_ColorTableParameteriv, cmdlen);
5651 (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4);
5652 (void) memcpy((void *) (gc->pc + 8), (void *) (&pname), 4);
5653 (void) memcpy((void *) (gc->pc + 12), (void *) (params), (compsize * 4));
5654 gc->pc += cmdlen;
5655 if (__builtin_expect(gc->pc > gc->limit, 0)) {
5656 (void) __glXFlushRenderBuffer(gc, gc->pc);
5657 }
5658 }
5659
5660 #define X_GLrop_CopyColorTable 2056
5661 void
5662 __indirect_glCopyColorTable(GLenum target, GLenum internalformat, GLint x,
5663 GLint y, GLsizei width)
5664 {
5665 __GLXcontext *const gc = __glXGetCurrentContext();
5666 const GLuint cmdlen = 24;
5667 emit_header(gc->pc, X_GLrop_CopyColorTable, cmdlen);
5668 (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4);
5669 (void) memcpy((void *) (gc->pc + 8), (void *) (&internalformat), 4);
5670 (void) memcpy((void *) (gc->pc + 12), (void *) (&x), 4);
5671 (void) memcpy((void *) (gc->pc + 16), (void *) (&y), 4);
5672 (void) memcpy((void *) (gc->pc + 20), (void *) (&width), 4);
5673 gc->pc += cmdlen;
5674 if (__builtin_expect(gc->pc > gc->limit, 0)) {
5675 (void) __glXFlushRenderBuffer(gc, gc->pc);
5676 }
5677 }
5678
5679 #define X_GLsop_GetColorTable 147
5680 void
5681 __indirect_glGetColorTable(GLenum target, GLenum format, GLenum type,
5682 GLvoid * table)
5683 {
5684 __GLXcontext *const gc = __glXGetCurrentContext();
5685 const __GLXattribute *const state = gc->client_state_private;
5686 Display *const dpy = gc->currentDpy;
5687 #ifndef USE_XCB
5688 const GLuint cmdlen = 16;
5689 #endif
5690 if (__builtin_expect(dpy != NULL, 1)) {
5691 #ifdef USE_XCB
5692 xcb_connection_t *c = XGetXCBConnection(dpy);
5693 (void) __glXFlushRenderBuffer(gc, gc->pc);
5694 xcb_glx_get_color_table_reply_t *reply =
5695 xcb_glx_get_color_table_reply(c,
5696 xcb_glx_get_color_table(c,
5697 gc->
5698 currentContextTag,
5699 target,
5700 format,
5701 type,
5702 state->
5703 storePack.
5704 swapEndian),
5705 NULL);
5706 (void) memcpy(table, xcb_glx_get_color_table_data(reply),
5707 xcb_glx_get_color_table_data_length(reply) *
5708 sizeof(GLvoid));
5709 free(reply);
5710 #else
5711 GLubyte const *pc =
5712 __glXSetupSingleRequest(gc, X_GLsop_GetColorTable, cmdlen);
5713 (void) memcpy((void *) (pc + 0), (void *) (&target), 4);
5714 (void) memcpy((void *) (pc + 4), (void *) (&format), 4);
5715 (void) memcpy((void *) (pc + 8), (void *) (&type), 4);
5716 *(int32_t *) (pc + 12) = 0;
5717 *(int8_t *) (pc + 12) = state->storePack.swapEndian;
5718 __glXReadPixelReply(dpy, gc, 1, 0, 0, 0, format, type, table,
5719 GL_TRUE);
5720 UnlockDisplay(dpy);
5721 SyncHandle();
5722 #endif /* USE_XCB */
5723 }
5724 return;
5725 }
5726
5727 #define X_GLvop_GetColorTableSGI 4098
5728 void
5729 glGetColorTableEXT(GLenum target, GLenum format, GLenum type, GLvoid * table)
5730 {
5731 __GLXcontext *const gc = __glXGetCurrentContext();
5732
5733 #ifdef GLX_DIRECT_RENDERING
5734 if (gc->driContext) {
5735 CALL_GetColorTable(GET_DISPATCH(), (target, format, type, table));
5736 } else
5737 #endif
5738 {
5739 __GLXcontext *const gc = __glXGetCurrentContext();
5740 const __GLXattribute *const state = gc->client_state_private;
5741 Display *const dpy = gc->currentDpy;
5742 const GLuint cmdlen = 16;
5743 if (__builtin_expect(dpy != NULL, 1)) {
5744 GLubyte const *pc =
5745 __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithReply,
5746 X_GLvop_GetColorTableSGI, cmdlen);
5747 (void) memcpy((void *) (pc + 0), (void *) (&target), 4);
5748 (void) memcpy((void *) (pc + 4), (void *) (&format), 4);
5749 (void) memcpy((void *) (pc + 8), (void *) (&type), 4);
5750 *(int32_t *) (pc + 12) = 0;
5751 *(int8_t *) (pc + 12) = state->storePack.swapEndian;
5752 __glXReadPixelReply(dpy, gc, 1, 0, 0, 0, format, type, table,
5753 GL_TRUE);
5754 UnlockDisplay(dpy);
5755 SyncHandle();
5756 }
5757 return;
5758 }
5759 }
5760
5761 #define X_GLsop_GetColorTableParameterfv 148
5762 void
5763 __indirect_glGetColorTableParameterfv(GLenum target, GLenum pname,
5764 GLfloat * params)
5765 {
5766 __GLXcontext *const gc = __glXGetCurrentContext();
5767 Display *const dpy = gc->currentDpy;
5768 #ifndef USE_XCB
5769 const GLuint cmdlen = 8;
5770 #endif
5771 if (__builtin_expect(dpy != NULL, 1)) {
5772 #ifdef USE_XCB
5773 xcb_connection_t *c = XGetXCBConnection(dpy);
5774 (void) __glXFlushRenderBuffer(gc, gc->pc);
5775 xcb_glx_get_color_table_parameterfv_reply_t *reply =
5776 xcb_glx_get_color_table_parameterfv_reply(c,
5777 xcb_glx_get_color_table_parameterfv
5778 (c,
5779 gc->currentContextTag,
5780 target, pname), NULL);
5781 if (xcb_glx_get_color_table_parameterfv_data_length(reply) == 0)
5782 (void) memcpy(params, &reply->datum, sizeof(reply->datum));
5783 else
5784 (void) memcpy(params,
5785 xcb_glx_get_color_table_parameterfv_data(reply),
5786 xcb_glx_get_color_table_parameterfv_data_length
5787 (reply) * sizeof(GLfloat));
5788 free(reply);
5789 #else
5790 GLubyte const *pc =
5791 __glXSetupSingleRequest(gc, X_GLsop_GetColorTableParameterfv,
5792 cmdlen);
5793 (void) memcpy((void *) (pc + 0), (void *) (&target), 4);
5794 (void) memcpy((void *) (pc + 4), (void *) (&pname), 4);
5795 (void) __glXReadReply(dpy, 4, params, GL_FALSE);
5796 UnlockDisplay(dpy);
5797 SyncHandle();
5798 #endif /* USE_XCB */
5799 }
5800 return;
5801 }
5802
5803 #define X_GLvop_GetColorTableParameterfvSGI 4099
5804 void
5805 glGetColorTableParameterfvEXT(GLenum target, GLenum pname, GLfloat * params)
5806 {
5807 __GLXcontext *const gc = __glXGetCurrentContext();
5808
5809 #ifdef GLX_DIRECT_RENDERING
5810 if (gc->driContext) {
5811 CALL_GetColorTableParameterfv(GET_DISPATCH(),
5812 (target, pname, params));
5813 } else
5814 #endif
5815 {
5816 __GLXcontext *const gc = __glXGetCurrentContext();
5817 Display *const dpy = gc->currentDpy;
5818 const GLuint cmdlen = 8;
5819 if (__builtin_expect(dpy != NULL, 1)) {
5820 GLubyte const *pc =
5821 __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithReply,
5822 X_GLvop_GetColorTableParameterfvSGI,
5823 cmdlen);
5824 (void) memcpy((void *) (pc + 0), (void *) (&target), 4);
5825 (void) memcpy((void *) (pc + 4), (void *) (&pname), 4);
5826 (void) __glXReadReply(dpy, 4, params, GL_FALSE);
5827 UnlockDisplay(dpy);
5828 SyncHandle();
5829 }
5830 return;
5831 }
5832 }
5833
5834 #define X_GLsop_GetColorTableParameteriv 149
5835 void
5836 __indirect_glGetColorTableParameteriv(GLenum target, GLenum pname,
5837 GLint * params)
5838 {
5839 __GLXcontext *const gc = __glXGetCurrentContext();
5840 Display *const dpy = gc->currentDpy;
5841 #ifndef USE_XCB
5842 const GLuint cmdlen = 8;
5843 #endif
5844 if (__builtin_expect(dpy != NULL, 1)) {
5845 #ifdef USE_XCB
5846 xcb_connection_t *c = XGetXCBConnection(dpy);
5847 (void) __glXFlushRenderBuffer(gc, gc->pc);
5848 xcb_glx_get_color_table_parameteriv_reply_t *reply =
5849 xcb_glx_get_color_table_parameteriv_reply(c,
5850 xcb_glx_get_color_table_parameteriv
5851 (c,
5852 gc->currentContextTag,
5853 target, pname), NULL);
5854 if (xcb_glx_get_color_table_parameteriv_data_length(reply) == 0)
5855 (void) memcpy(params, &reply->datum, sizeof(reply->datum));
5856 else
5857 (void) memcpy(params,
5858 xcb_glx_get_color_table_parameteriv_data(reply),
5859 xcb_glx_get_color_table_parameteriv_data_length
5860 (reply) * sizeof(GLint));
5861 free(reply);
5862 #else
5863 GLubyte const *pc =
5864 __glXSetupSingleRequest(gc, X_GLsop_GetColorTableParameteriv,
5865 cmdlen);
5866 (void) memcpy((void *) (pc + 0), (void *) (&target), 4);
5867 (void) memcpy((void *) (pc + 4), (void *) (&pname), 4);
5868 (void) __glXReadReply(dpy, 4, params, GL_FALSE);
5869 UnlockDisplay(dpy);
5870 SyncHandle();
5871 #endif /* USE_XCB */
5872 }
5873 return;
5874 }
5875
5876 #define X_GLvop_GetColorTableParameterivSGI 4100
5877 void
5878 glGetColorTableParameterivEXT(GLenum target, GLenum pname, GLint * params)
5879 {
5880 __GLXcontext *const gc = __glXGetCurrentContext();
5881
5882 #ifdef GLX_DIRECT_RENDERING
5883 if (gc->driContext) {
5884 CALL_GetColorTableParameteriv(GET_DISPATCH(),
5885 (target, pname, params));
5886 } else
5887 #endif
5888 {
5889 __GLXcontext *const gc = __glXGetCurrentContext();
5890 Display *const dpy = gc->currentDpy;
5891 const GLuint cmdlen = 8;
5892 if (__builtin_expect(dpy != NULL, 1)) {
5893 GLubyte const *pc =
5894 __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithReply,
5895 X_GLvop_GetColorTableParameterivSGI,
5896 cmdlen);
5897 (void) memcpy((void *) (pc + 0), (void *) (&target), 4);
5898 (void) memcpy((void *) (pc + 4), (void *) (&pname), 4);
5899 (void) __glXReadReply(dpy, 4, params, GL_FALSE);
5900 UnlockDisplay(dpy);
5901 SyncHandle();
5902 }
5903 return;
5904 }
5905 }
5906
5907 #define X_GLrop_ColorSubTable 195
5908 void
5909 __indirect_glColorSubTable(GLenum target, GLsizei start, GLsizei count,
5910 GLenum format, GLenum type, const GLvoid * data)
5911 {
5912 __GLXcontext *const gc = __glXGetCurrentContext();
5913 const GLuint compsize =
5914 (data != NULL) ? __glImageSize(count, 1, 1, format, type, target) : 0;
5915 const GLuint cmdlen = 44 + __GLX_PAD(compsize);
5916 if (__builtin_expect(gc->currentDpy != NULL, 1)) {
5917 if (cmdlen <= gc->maxSmallRenderCommandSize) {
5918 if ((gc->pc + cmdlen) > gc->bufEnd) {
5919 (void) __glXFlushRenderBuffer(gc, gc->pc);
5920 }
5921 emit_header(gc->pc, X_GLrop_ColorSubTable, cmdlen);
5922 (void) memcpy((void *) (gc->pc + 24), (void *) (&target), 4);
5923 (void) memcpy((void *) (gc->pc + 28), (void *) (&start), 4);
5924 (void) memcpy((void *) (gc->pc + 32), (void *) (&count), 4);
5925 (void) memcpy((void *) (gc->pc + 36), (void *) (&format), 4);
5926 (void) memcpy((void *) (gc->pc + 40), (void *) (&type), 4);
5927 if (compsize > 0) {
5928 (*gc->fillImage) (gc, 1, count, 1, 1, format, type, data,
5929 gc->pc + 44, gc->pc + 4);
5930 } else {
5931 (void) memcpy(gc->pc + 4, default_pixel_store_1D,
5932 default_pixel_store_1D_size);
5933 }
5934 gc->pc += cmdlen;
5935 if (gc->pc > gc->limit) {
5936 (void) __glXFlushRenderBuffer(gc, gc->pc);
5937 }
5938 } else {
5939 const GLint op = X_GLrop_ColorSubTable;
5940 const GLuint cmdlenLarge = cmdlen + 4;
5941 GLubyte *const pc = __glXFlushRenderBuffer(gc, gc->pc);
5942 (void) memcpy((void *) (pc + 0), (void *) (&cmdlenLarge), 4);
5943 (void) memcpy((void *) (pc + 4), (void *) (&op), 4);
5944 (void) memcpy((void *) (pc + 28), (void *) (&target), 4);
5945 (void) memcpy((void *) (pc + 32), (void *) (&start), 4);
5946 (void) memcpy((void *) (pc + 36), (void *) (&count), 4);
5947 (void) memcpy((void *) (pc + 40), (void *) (&format), 4);
5948 (void) memcpy((void *) (pc + 44), (void *) (&type), 4);
5949 __glXSendLargeImage(gc, compsize, 1, count, 1, 1, format, type,
5950 data, pc + 48, pc + 8);
5951 }
5952 }
5953 }
5954
5955 #define X_GLrop_CopyColorSubTable 196
5956 void
5957 __indirect_glCopyColorSubTable(GLenum target, GLsizei start, GLint x, GLint y,
5958 GLsizei width)
5959 {
5960 __GLXcontext *const gc = __glXGetCurrentContext();
5961 const GLuint cmdlen = 24;
5962 emit_header(gc->pc, X_GLrop_CopyColorSubTable, cmdlen);
5963 (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4);
5964 (void) memcpy((void *) (gc->pc + 8), (void *) (&start), 4);
5965 (void) memcpy((void *) (gc->pc + 12), (void *) (&x), 4);
5966 (void) memcpy((void *) (gc->pc + 16), (void *) (&y), 4);
5967 (void) memcpy((void *) (gc->pc + 20), (void *) (&width), 4);
5968 gc->pc += cmdlen;
5969 if (__builtin_expect(gc->pc > gc->limit, 0)) {
5970 (void) __glXFlushRenderBuffer(gc, gc->pc);
5971 }
5972 }
5973
5974 static void
5975 __glx_ConvolutionFilter_1D2D(unsigned opcode, unsigned dim, GLenum target,
5976 GLenum internalformat, GLsizei width,
5977 GLsizei height, GLenum format, GLenum type,
5978 const GLvoid * image)
5979 {
5980 __GLXcontext *const gc = __glXGetCurrentContext();
5981 const GLuint compsize =
5982 (image != NULL) ? __glImageSize(width, height, 1, format, type,
5983 target) : 0;
5984 const GLuint cmdlen = 48 + __GLX_PAD(compsize);
5985 if (__builtin_expect(gc->currentDpy != NULL, 1)) {
5986 if (cmdlen <= gc->maxSmallRenderCommandSize) {
5987 if ((gc->pc + cmdlen) > gc->bufEnd) {
5988 (void) __glXFlushRenderBuffer(gc, gc->pc);
5989 }
5990 emit_header(gc->pc, opcode, cmdlen);
5991 (void) memcpy((void *) (gc->pc + 24), (void *) (&target), 4);
5992 (void) memcpy((void *) (gc->pc + 28), (void *) (&internalformat),
5993 4);
5994 (void) memcpy((void *) (gc->pc + 32), (void *) (&width), 4);
5995 (void) memcpy((void *) (gc->pc + 36), (void *) (&height), 4);
5996 (void) memcpy((void *) (gc->pc + 40), (void *) (&format), 4);
5997 (void) memcpy((void *) (gc->pc + 44), (void *) (&type), 4);
5998 if (compsize > 0) {
5999 (*gc->fillImage) (gc, dim, width, height, 1, format, type,
6000 image, gc->pc + 48, gc->pc + 4);
6001 } else {
6002 (void) memcpy(gc->pc + 4, default_pixel_store_2D,
6003 default_pixel_store_2D_size);
6004 }
6005 gc->pc += cmdlen;
6006 if (gc->pc > gc->limit) {
6007 (void) __glXFlushRenderBuffer(gc, gc->pc);
6008 }
6009 } else {
6010 const GLint op = opcode;
6011 const GLuint cmdlenLarge = cmdlen + 4;
6012 GLubyte *const pc = __glXFlushRenderBuffer(gc, gc->pc);
6013 (void) memcpy((void *) (pc + 0), (void *) (&cmdlenLarge), 4);
6014 (void) memcpy((void *) (pc + 4), (void *) (&op), 4);
6015 (void) memcpy((void *) (pc + 28), (void *) (&target), 4);
6016 (void) memcpy((void *) (pc + 32), (void *) (&internalformat), 4);
6017 (void) memcpy((void *) (pc + 36), (void *) (&width), 4);
6018 (void) memcpy((void *) (pc + 40), (void *) (&height), 4);
6019 (void) memcpy((void *) (pc + 44), (void *) (&format), 4);
6020 (void) memcpy((void *) (pc + 48), (void *) (&type), 4);
6021 __glXSendLargeImage(gc, compsize, dim, width, height, 1, format,
6022 type, image, pc + 52, pc + 8);
6023 }
6024 }
6025 }
6026
6027 #define X_GLrop_ConvolutionFilter1D 4101
6028 void
6029 __indirect_glConvolutionFilter1D(GLenum target, GLenum internalformat,
6030 GLsizei width, GLenum format, GLenum type,
6031 const GLvoid * image)
6032 {
6033 __glx_ConvolutionFilter_1D2D(X_GLrop_ConvolutionFilter1D, 1, target,
6034 internalformat, width, 1, format, type,
6035 image);
6036 }
6037
6038 #define X_GLrop_ConvolutionFilter2D 4102
6039 void
6040 __indirect_glConvolutionFilter2D(GLenum target, GLenum internalformat,
6041 GLsizei width, GLsizei height, GLenum format,
6042 GLenum type, const GLvoid * image)
6043 {
6044 __glx_ConvolutionFilter_1D2D(X_GLrop_ConvolutionFilter2D, 2, target,
6045 internalformat, width, height, format, type,
6046 image);
6047 }
6048
6049 #define X_GLrop_ConvolutionParameterf 4103
6050 void
6051 __indirect_glConvolutionParameterf(GLenum target, GLenum pname,
6052 GLfloat params)
6053 {
6054 __GLXcontext *const gc = __glXGetCurrentContext();
6055 const GLuint cmdlen = 16;
6056 emit_header(gc->pc, X_GLrop_ConvolutionParameterf, cmdlen);
6057 (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4);
6058 (void) memcpy((void *) (gc->pc + 8), (void *) (&pname), 4);
6059 (void) memcpy((void *) (gc->pc + 12), (void *) (&params), 4);
6060 gc->pc += cmdlen;
6061 if (__builtin_expect(gc->pc > gc->limit, 0)) {
6062 (void) __glXFlushRenderBuffer(gc, gc->pc);
6063 }
6064 }
6065
6066 #define X_GLrop_ConvolutionParameterfv 4104
6067 void
6068 __indirect_glConvolutionParameterfv(GLenum target, GLenum pname,
6069 const GLfloat * params)
6070 {
6071 __GLXcontext *const gc = __glXGetCurrentContext();
6072 const GLuint compsize = __glConvolutionParameterfv_size(pname);
6073 const GLuint cmdlen = 12 + __GLX_PAD((compsize * 4));
6074 emit_header(gc->pc, X_GLrop_ConvolutionParameterfv, cmdlen);
6075 (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4);
6076 (void) memcpy((void *) (gc->pc + 8), (void *) (&pname), 4);
6077 (void) memcpy((void *) (gc->pc + 12), (void *) (params), (compsize * 4));
6078 gc->pc += cmdlen;
6079 if (__builtin_expect(gc->pc > gc->limit, 0)) {
6080 (void) __glXFlushRenderBuffer(gc, gc->pc);
6081 }
6082 }
6083
6084 #define X_GLrop_ConvolutionParameteri 4105
6085 void
6086 __indirect_glConvolutionParameteri(GLenum target, GLenum pname, GLint params)
6087 {
6088 __GLXcontext *const gc = __glXGetCurrentContext();
6089 const GLuint cmdlen = 16;
6090 emit_header(gc->pc, X_GLrop_ConvolutionParameteri, cmdlen);
6091 (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4);
6092 (void) memcpy((void *) (gc->pc + 8), (void *) (&pname), 4);
6093 (void) memcpy((void *) (gc->pc + 12), (void *) (&params), 4);
6094 gc->pc += cmdlen;
6095 if (__builtin_expect(gc->pc > gc->limit, 0)) {
6096 (void) __glXFlushRenderBuffer(gc, gc->pc);
6097 }
6098 }
6099
6100 #define X_GLrop_ConvolutionParameteriv 4106
6101 void
6102 __indirect_glConvolutionParameteriv(GLenum target, GLenum pname,
6103 const GLint * params)
6104 {
6105 __GLXcontext *const gc = __glXGetCurrentContext();
6106 const GLuint compsize = __glConvolutionParameteriv_size(pname);
6107 const GLuint cmdlen = 12 + __GLX_PAD((compsize * 4));
6108 emit_header(gc->pc, X_GLrop_ConvolutionParameteriv, cmdlen);
6109 (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4);
6110 (void) memcpy((void *) (gc->pc + 8), (void *) (&pname), 4);
6111 (void) memcpy((void *) (gc->pc + 12), (void *) (params), (compsize * 4));
6112 gc->pc += cmdlen;
6113 if (__builtin_expect(gc->pc > gc->limit, 0)) {
6114 (void) __glXFlushRenderBuffer(gc, gc->pc);
6115 }
6116 }
6117
6118 #define X_GLrop_CopyConvolutionFilter1D 4107
6119 void
6120 __indirect_glCopyConvolutionFilter1D(GLenum target, GLenum internalformat,
6121 GLint x, GLint y, GLsizei width)
6122 {
6123 __GLXcontext *const gc = __glXGetCurrentContext();
6124 const GLuint cmdlen = 24;
6125 emit_header(gc->pc, X_GLrop_CopyConvolutionFilter1D, cmdlen);
6126 (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4);
6127 (void) memcpy((void *) (gc->pc + 8), (void *) (&internalformat), 4);
6128 (void) memcpy((void *) (gc->pc + 12), (void *) (&x), 4);
6129 (void) memcpy((void *) (gc->pc + 16), (void *) (&y), 4);
6130 (void) memcpy((void *) (gc->pc + 20), (void *) (&width), 4);
6131 gc->pc += cmdlen;
6132 if (__builtin_expect(gc->pc > gc->limit, 0)) {
6133 (void) __glXFlushRenderBuffer(gc, gc->pc);
6134 }
6135 }
6136
6137 #define X_GLrop_CopyConvolutionFilter2D 4108
6138 void
6139 __indirect_glCopyConvolutionFilter2D(GLenum target, GLenum internalformat,
6140 GLint x, GLint y, GLsizei width,
6141 GLsizei height)
6142 {
6143 __GLXcontext *const gc = __glXGetCurrentContext();
6144 const GLuint cmdlen = 28;
6145 emit_header(gc->pc, X_GLrop_CopyConvolutionFilter2D, cmdlen);
6146 (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4);
6147 (void) memcpy((void *) (gc->pc + 8), (void *) (&internalformat), 4);
6148 (void) memcpy((void *) (gc->pc + 12), (void *) (&x), 4);
6149 (void) memcpy((void *) (gc->pc + 16), (void *) (&y), 4);
6150 (void) memcpy((void *) (gc->pc + 20), (void *) (&width), 4);
6151 (void) memcpy((void *) (gc->pc + 24), (void *) (&height), 4);
6152 gc->pc += cmdlen;
6153 if (__builtin_expect(gc->pc > gc->limit, 0)) {
6154 (void) __glXFlushRenderBuffer(gc, gc->pc);
6155 }
6156 }
6157
6158 #define X_GLsop_GetConvolutionFilter 150
6159 void
6160 __indirect_glGetConvolutionFilter(GLenum target, GLenum format, GLenum type,
6161 GLvoid * image)
6162 {
6163 __GLXcontext *const gc = __glXGetCurrentContext();
6164 const __GLXattribute *const state = gc->client_state_private;
6165 Display *const dpy = gc->currentDpy;
6166 #ifndef USE_XCB
6167 const GLuint cmdlen = 16;
6168 #endif
6169 if (__builtin_expect(dpy != NULL, 1)) {
6170 #ifdef USE_XCB
6171 xcb_connection_t *c = XGetXCBConnection(dpy);
6172 (void) __glXFlushRenderBuffer(gc, gc->pc);
6173 xcb_glx_get_convolution_filter_reply_t *reply =
6174 xcb_glx_get_convolution_filter_reply(c,
6175 xcb_glx_get_convolution_filter
6176 (c, gc->currentContextTag,
6177 target, format, type,
6178 state->storePack.
6179 swapEndian), NULL);
6180 (void) memcpy(image, xcb_glx_get_convolution_filter_data(reply),
6181 xcb_glx_get_convolution_filter_data_length(reply) *
6182 sizeof(GLvoid));
6183 free(reply);
6184 #else
6185 GLubyte const *pc =
6186 __glXSetupSingleRequest(gc, X_GLsop_GetConvolutionFilter, cmdlen);
6187 (void) memcpy((void *) (pc + 0), (void *) (&target), 4);
6188 (void) memcpy((void *) (pc + 4), (void *) (&format), 4);
6189 (void) memcpy((void *) (pc + 8), (void *) (&type), 4);
6190 *(int32_t *) (pc + 12) = 0;
6191 *(int8_t *) (pc + 12) = state->storePack.swapEndian;
6192 __glXReadPixelReply(dpy, gc, 2, 0, 0, 0, format, type, image,
6193 GL_TRUE);
6194 UnlockDisplay(dpy);
6195 SyncHandle();
6196 #endif /* USE_XCB */
6197 }
6198 return;
6199 }
6200
6201 #define X_GLvop_GetConvolutionFilterEXT 1
6202 void
6203 gl_dispatch_stub_356(GLenum target, GLenum format, GLenum type,
6204 GLvoid * image)
6205 {
6206 __GLXcontext *const gc = __glXGetCurrentContext();
6207
6208 #ifdef GLX_DIRECT_RENDERING
6209 if (gc->driContext) {
6210 CALL_GetConvolutionFilter(GET_DISPATCH(),
6211 (target, format, type, image));
6212 } else
6213 #endif
6214 {
6215 __GLXcontext *const gc = __glXGetCurrentContext();
6216 const __GLXattribute *const state = gc->client_state_private;
6217 Display *const dpy = gc->currentDpy;
6218 const GLuint cmdlen = 16;
6219 if (__builtin_expect(dpy != NULL, 1)) {
6220 GLubyte const *pc =
6221 __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithReply,
6222 X_GLvop_GetConvolutionFilterEXT,
6223 cmdlen);
6224 (void) memcpy((void *) (pc + 0), (void *) (&target), 4);
6225 (void) memcpy((void *) (pc + 4), (void *) (&format), 4);
6226 (void) memcpy((void *) (pc + 8), (void *) (&type), 4);
6227 *(int32_t *) (pc + 12) = 0;
6228 *(int8_t *) (pc + 12) = state->storePack.swapEndian;
6229 __glXReadPixelReply(dpy, gc, 2, 0, 0, 0, format, type, image,
6230 GL_TRUE);
6231 UnlockDisplay(dpy);
6232 SyncHandle();
6233 }
6234 return;
6235 }
6236 }
6237
6238 #define X_GLsop_GetConvolutionParameterfv 151
6239 void
6240 __indirect_glGetConvolutionParameterfv(GLenum target, GLenum pname,
6241 GLfloat * params)
6242 {
6243 __GLXcontext *const gc = __glXGetCurrentContext();
6244 Display *const dpy = gc->currentDpy;
6245 #ifndef USE_XCB
6246 const GLuint cmdlen = 8;
6247 #endif
6248 if (__builtin_expect(dpy != NULL, 1)) {
6249 #ifdef USE_XCB
6250 xcb_connection_t *c = XGetXCBConnection(dpy);
6251 (void) __glXFlushRenderBuffer(gc, gc->pc);
6252 xcb_glx_get_convolution_parameterfv_reply_t *reply =
6253 xcb_glx_get_convolution_parameterfv_reply(c,
6254 xcb_glx_get_convolution_parameterfv
6255 (c,
6256 gc->currentContextTag,
6257 target, pname), NULL);
6258 if (xcb_glx_get_convolution_parameterfv_data_length(reply) == 0)
6259 (void) memcpy(params, &reply->datum, sizeof(reply->datum));
6260 else
6261 (void) memcpy(params,
6262 xcb_glx_get_convolution_parameterfv_data(reply),
6263 xcb_glx_get_convolution_parameterfv_data_length
6264 (reply) * sizeof(GLfloat));
6265 free(reply);
6266 #else
6267 GLubyte const *pc =
6268 __glXSetupSingleRequest(gc, X_GLsop_GetConvolutionParameterfv,
6269 cmdlen);
6270 (void) memcpy((void *) (pc + 0), (void *) (&target), 4);
6271 (void) memcpy((void *) (pc + 4), (void *) (&pname), 4);
6272 (void) __glXReadReply(dpy, 4, params, GL_FALSE);
6273 UnlockDisplay(dpy);
6274 SyncHandle();
6275 #endif /* USE_XCB */
6276 }
6277 return;
6278 }
6279
6280 #define X_GLvop_GetConvolutionParameterfvEXT 2
6281 void
6282 gl_dispatch_stub_357(GLenum target, GLenum pname, GLfloat * params)
6283 {
6284 __GLXcontext *const gc = __glXGetCurrentContext();
6285
6286 #ifdef GLX_DIRECT_RENDERING
6287 if (gc->driContext) {
6288 CALL_GetConvolutionParameterfv(GET_DISPATCH(),
6289 (target, pname, params));
6290 } else
6291 #endif
6292 {
6293 __GLXcontext *const gc = __glXGetCurrentContext();
6294 Display *const dpy = gc->currentDpy;
6295 const GLuint cmdlen = 8;
6296 if (__builtin_expect(dpy != NULL, 1)) {
6297 GLubyte const *pc =
6298 __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithReply,
6299 X_GLvop_GetConvolutionParameterfvEXT,
6300 cmdlen);
6301 (void) memcpy((void *) (pc + 0), (void *) (&target), 4);
6302 (void) memcpy((void *) (pc + 4), (void *) (&pname), 4);
6303 (void) __glXReadReply(dpy, 4, params, GL_FALSE);
6304 UnlockDisplay(dpy);
6305 SyncHandle();
6306 }
6307 return;
6308 }
6309 }
6310
6311 #define X_GLsop_GetConvolutionParameteriv 152
6312 void
6313 __indirect_glGetConvolutionParameteriv(GLenum target, GLenum pname,
6314 GLint * params)
6315 {
6316 __GLXcontext *const gc = __glXGetCurrentContext();
6317 Display *const dpy = gc->currentDpy;
6318 #ifndef USE_XCB
6319 const GLuint cmdlen = 8;
6320 #endif
6321 if (__builtin_expect(dpy != NULL, 1)) {
6322 #ifdef USE_XCB
6323 xcb_connection_t *c = XGetXCBConnection(dpy);
6324 (void) __glXFlushRenderBuffer(gc, gc->pc);
6325 xcb_glx_get_convolution_parameteriv_reply_t *reply =
6326 xcb_glx_get_convolution_parameteriv_reply(c,
6327 xcb_glx_get_convolution_parameteriv
6328 (c,
6329 gc->currentContextTag,
6330 target, pname), NULL);
6331 if (xcb_glx_get_convolution_parameteriv_data_length(reply) == 0)
6332 (void) memcpy(params, &reply->datum, sizeof(reply->datum));
6333 else
6334 (void) memcpy(params,
6335 xcb_glx_get_convolution_parameteriv_data(reply),
6336 xcb_glx_get_convolution_parameteriv_data_length
6337 (reply) * sizeof(GLint));
6338 free(reply);
6339 #else
6340 GLubyte const *pc =
6341 __glXSetupSingleRequest(gc, X_GLsop_GetConvolutionParameteriv,
6342 cmdlen);
6343 (void) memcpy((void *) (pc + 0), (void *) (&target), 4);
6344 (void) memcpy((void *) (pc + 4), (void *) (&pname), 4);
6345 (void) __glXReadReply(dpy, 4, params, GL_FALSE);
6346 UnlockDisplay(dpy);
6347 SyncHandle();
6348 #endif /* USE_XCB */
6349 }
6350 return;
6351 }
6352
6353 #define X_GLvop_GetConvolutionParameterivEXT 3
6354 void
6355 gl_dispatch_stub_358(GLenum target, GLenum pname, GLint * params)
6356 {
6357 __GLXcontext *const gc = __glXGetCurrentContext();
6358
6359 #ifdef GLX_DIRECT_RENDERING
6360 if (gc->driContext) {
6361 CALL_GetConvolutionParameteriv(GET_DISPATCH(),
6362 (target, pname, params));
6363 } else
6364 #endif
6365 {
6366 __GLXcontext *const gc = __glXGetCurrentContext();
6367 Display *const dpy = gc->currentDpy;
6368 const GLuint cmdlen = 8;
6369 if (__builtin_expect(dpy != NULL, 1)) {
6370 GLubyte const *pc =
6371 __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithReply,
6372 X_GLvop_GetConvolutionParameterivEXT,
6373 cmdlen);
6374 (void) memcpy((void *) (pc + 0), (void *) (&target), 4);
6375 (void) memcpy((void *) (pc + 4), (void *) (&pname), 4);
6376 (void) __glXReadReply(dpy, 4, params, GL_FALSE);
6377 UnlockDisplay(dpy);
6378 SyncHandle();
6379 }
6380 return;
6381 }
6382 }
6383
6384 #define X_GLsop_GetHistogram 154
6385 void
6386 __indirect_glGetHistogram(GLenum target, GLboolean reset, GLenum format,
6387 GLenum type, GLvoid * values)
6388 {
6389 __GLXcontext *const gc = __glXGetCurrentContext();
6390 const __GLXattribute *const state = gc->client_state_private;
6391 Display *const dpy = gc->currentDpy;
6392 #ifndef USE_XCB
6393 const GLuint cmdlen = 16;
6394 #endif
6395 if (__builtin_expect(dpy != NULL, 1)) {
6396 #ifdef USE_XCB
6397 xcb_connection_t *c = XGetXCBConnection(dpy);
6398 (void) __glXFlushRenderBuffer(gc, gc->pc);
6399 xcb_glx_get_histogram_reply_t *reply =
6400 xcb_glx_get_histogram_reply(c,
6401 xcb_glx_get_histogram(c,
6402 gc->
6403 currentContextTag,
6404 target, reset,
6405 format, type,
6406 state->
6407 storePack.
6408 swapEndian),
6409 NULL);
6410 (void) memcpy(values, xcb_glx_get_histogram_data(reply),
6411 xcb_glx_get_histogram_data_length(reply) *
6412 sizeof(GLvoid));
6413 free(reply);
6414 #else
6415 GLubyte const *pc =
6416 __glXSetupSingleRequest(gc, X_GLsop_GetHistogram, cmdlen);
6417 (void) memcpy((void *) (pc + 0), (void *) (&target), 4);
6418 (void) memcpy((void *) (pc + 4), (void *) (&format), 4);
6419 (void) memcpy((void *) (pc + 8), (void *) (&type), 4);
6420 *(int32_t *) (pc + 12) = 0;
6421 *(int8_t *) (pc + 12) = state->storePack.swapEndian;
6422 *(int8_t *) (pc + 13) = reset;
6423 __glXReadPixelReply(dpy, gc, 1, 0, 0, 0, format, type, values,
6424 GL_TRUE);
6425 UnlockDisplay(dpy);
6426 SyncHandle();
6427 #endif /* USE_XCB */
6428 }
6429 return;
6430 }
6431
6432 #define X_GLvop_GetHistogramEXT 5
6433 void
6434 gl_dispatch_stub_361(GLenum target, GLboolean reset, GLenum format,
6435 GLenum type, GLvoid * values)
6436 {
6437 __GLXcontext *const gc = __glXGetCurrentContext();
6438
6439 #ifdef GLX_DIRECT_RENDERING
6440 if (gc->driContext) {
6441 CALL_GetHistogram(GET_DISPATCH(),
6442 (target, reset, format, type, values));
6443 } else
6444 #endif
6445 {
6446 __GLXcontext *const gc = __glXGetCurrentContext();
6447 const __GLXattribute *const state = gc->client_state_private;
6448 Display *const dpy = gc->currentDpy;
6449 const GLuint cmdlen = 16;
6450 if (__builtin_expect(dpy != NULL, 1)) {
6451 GLubyte const *pc =
6452 __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithReply,
6453 X_GLvop_GetHistogramEXT, cmdlen);
6454 (void) memcpy((void *) (pc + 0), (void *) (&target), 4);
6455 (void) memcpy((void *) (pc + 4), (void *) (&format), 4);
6456 (void) memcpy((void *) (pc + 8), (void *) (&type), 4);
6457 *(int32_t *) (pc + 12) = 0;
6458 *(int8_t *) (pc + 12) = state->storePack.swapEndian;
6459 *(int8_t *) (pc + 13) = reset;
6460 __glXReadPixelReply(dpy, gc, 1, 0, 0, 0, format, type, values,
6461 GL_TRUE);
6462 UnlockDisplay(dpy);
6463 SyncHandle();
6464 }
6465 return;
6466 }
6467 }
6468
6469 #define X_GLsop_GetHistogramParameterfv 155
6470 void
6471 __indirect_glGetHistogramParameterfv(GLenum target, GLenum pname,
6472 GLfloat * params)
6473 {
6474 __GLXcontext *const gc = __glXGetCurrentContext();
6475 Display *const dpy = gc->currentDpy;
6476 #ifndef USE_XCB
6477 const GLuint cmdlen = 8;
6478 #endif
6479 if (__builtin_expect(dpy != NULL, 1)) {
6480 #ifdef USE_XCB
6481 xcb_connection_t *c = XGetXCBConnection(dpy);
6482 (void) __glXFlushRenderBuffer(gc, gc->pc);
6483 xcb_glx_get_histogram_parameterfv_reply_t *reply =
6484 xcb_glx_get_histogram_parameterfv_reply(c,
6485 xcb_glx_get_histogram_parameterfv
6486 (c, gc->currentContextTag,
6487 target, pname), NULL);
6488 if (xcb_glx_get_histogram_parameterfv_data_length(reply) == 0)
6489 (void) memcpy(params, &reply->datum, sizeof(reply->datum));
6490 else
6491 (void) memcpy(params,
6492 xcb_glx_get_histogram_parameterfv_data(reply),
6493 xcb_glx_get_histogram_parameterfv_data_length(reply)
6494 * sizeof(GLfloat));
6495 free(reply);
6496 #else
6497 GLubyte const *pc =
6498 __glXSetupSingleRequest(gc, X_GLsop_GetHistogramParameterfv,
6499 cmdlen);
6500 (void) memcpy((void *) (pc + 0), (void *) (&target), 4);
6501 (void) memcpy((void *) (pc + 4), (void *) (&pname), 4);
6502 (void) __glXReadReply(dpy, 4, params, GL_FALSE);
6503 UnlockDisplay(dpy);
6504 SyncHandle();
6505 #endif /* USE_XCB */
6506 }
6507 return;
6508 }
6509
6510 #define X_GLvop_GetHistogramParameterfvEXT 6
6511 void
6512 gl_dispatch_stub_362(GLenum target, GLenum pname, GLfloat * params)
6513 {
6514 __GLXcontext *const gc = __glXGetCurrentContext();
6515
6516 #ifdef GLX_DIRECT_RENDERING
6517 if (gc->driContext) {
6518 CALL_GetHistogramParameterfv(GET_DISPATCH(), (target, pname, params));
6519 } else
6520 #endif
6521 {
6522 __GLXcontext *const gc = __glXGetCurrentContext();
6523 Display *const dpy = gc->currentDpy;
6524 const GLuint cmdlen = 8;
6525 if (__builtin_expect(dpy != NULL, 1)) {
6526 GLubyte const *pc =
6527 __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithReply,
6528 X_GLvop_GetHistogramParameterfvEXT,
6529 cmdlen);
6530 (void) memcpy((void *) (pc + 0), (void *) (&target), 4);
6531 (void) memcpy((void *) (pc + 4), (void *) (&pname), 4);
6532 (void) __glXReadReply(dpy, 4, params, GL_FALSE);
6533 UnlockDisplay(dpy);
6534 SyncHandle();
6535 }
6536 return;
6537 }
6538 }
6539
6540 #define X_GLsop_GetHistogramParameteriv 156
6541 void
6542 __indirect_glGetHistogramParameteriv(GLenum target, GLenum pname,
6543 GLint * params)
6544 {
6545 __GLXcontext *const gc = __glXGetCurrentContext();
6546 Display *const dpy = gc->currentDpy;
6547 #ifndef USE_XCB
6548 const GLuint cmdlen = 8;
6549 #endif
6550 if (__builtin_expect(dpy != NULL, 1)) {
6551 #ifdef USE_XCB
6552 xcb_connection_t *c = XGetXCBConnection(dpy);
6553 (void) __glXFlushRenderBuffer(gc, gc->pc);
6554 xcb_glx_get_histogram_parameteriv_reply_t *reply =
6555 xcb_glx_get_histogram_parameteriv_reply(c,
6556 xcb_glx_get_histogram_parameteriv
6557 (c, gc->currentContextTag,
6558 target, pname), NULL);
6559 if (xcb_glx_get_histogram_parameteriv_data_length(reply) == 0)
6560 (void) memcpy(params, &reply->datum, sizeof(reply->datum));
6561 else
6562 (void) memcpy(params,
6563 xcb_glx_get_histogram_parameteriv_data(reply),
6564 xcb_glx_get_histogram_parameteriv_data_length(reply)
6565 * sizeof(GLint));
6566 free(reply);
6567 #else
6568 GLubyte const *pc =
6569 __glXSetupSingleRequest(gc, X_GLsop_GetHistogramParameteriv,
6570 cmdlen);
6571 (void) memcpy((void *) (pc + 0), (void *) (&target), 4);
6572 (void) memcpy((void *) (pc + 4), (void *) (&pname), 4);
6573 (void) __glXReadReply(dpy, 4, params, GL_FALSE);
6574 UnlockDisplay(dpy);
6575 SyncHandle();
6576 #endif /* USE_XCB */
6577 }
6578 return;
6579 }
6580
6581 #define X_GLvop_GetHistogramParameterivEXT 7
6582 void
6583 gl_dispatch_stub_363(GLenum target, GLenum pname, GLint * params)
6584 {
6585 __GLXcontext *const gc = __glXGetCurrentContext();
6586
6587 #ifdef GLX_DIRECT_RENDERING
6588 if (gc->driContext) {
6589 CALL_GetHistogramParameteriv(GET_DISPATCH(), (target, pname, params));
6590 } else
6591 #endif
6592 {
6593 __GLXcontext *const gc = __glXGetCurrentContext();
6594 Display *const dpy = gc->currentDpy;
6595 const GLuint cmdlen = 8;
6596 if (__builtin_expect(dpy != NULL, 1)) {
6597 GLubyte const *pc =
6598 __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithReply,
6599 X_GLvop_GetHistogramParameterivEXT,
6600 cmdlen);
6601 (void) memcpy((void *) (pc + 0), (void *) (&target), 4);
6602 (void) memcpy((void *) (pc + 4), (void *) (&pname), 4);
6603 (void) __glXReadReply(dpy, 4, params, GL_FALSE);
6604 UnlockDisplay(dpy);
6605 SyncHandle();
6606 }
6607 return;
6608 }
6609 }
6610
6611 #define X_GLsop_GetMinmax 157
6612 void
6613 __indirect_glGetMinmax(GLenum target, GLboolean reset, GLenum format,
6614 GLenum type, GLvoid * values)
6615 {
6616 __GLXcontext *const gc = __glXGetCurrentContext();
6617 const __GLXattribute *const state = gc->client_state_private;
6618 Display *const dpy = gc->currentDpy;
6619 #ifndef USE_XCB
6620 const GLuint cmdlen = 16;
6621 #endif
6622 if (__builtin_expect(dpy != NULL, 1)) {
6623 #ifdef USE_XCB
6624 xcb_connection_t *c = XGetXCBConnection(dpy);
6625 (void) __glXFlushRenderBuffer(gc, gc->pc);
6626 xcb_glx_get_minmax_reply_t *reply =
6627 xcb_glx_get_minmax_reply(c,
6628 xcb_glx_get_minmax(c,
6629 gc->currentContextTag,
6630 target, reset, format,
6631 type,
6632 state->storePack.
6633 swapEndian), NULL);
6634 (void) memcpy(values, xcb_glx_get_minmax_data(reply),
6635 xcb_glx_get_minmax_data_length(reply) * sizeof(GLvoid));
6636 free(reply);
6637 #else
6638 GLubyte const *pc =
6639 __glXSetupSingleRequest(gc, X_GLsop_GetMinmax, cmdlen);
6640 (void) memcpy((void *) (pc + 0), (void *) (&target), 4);
6641 (void) memcpy((void *) (pc + 4), (void *) (&format), 4);
6642 (void) memcpy((void *) (pc + 8), (void *) (&type), 4);
6643 *(int32_t *) (pc + 12) = 0;
6644 *(int8_t *) (pc + 12) = state->storePack.swapEndian;
6645 *(int8_t *) (pc + 13) = reset;
6646 __glXReadPixelReply(dpy, gc, 1, 2, 1, 1, format, type, values,
6647 GL_FALSE);
6648 UnlockDisplay(dpy);
6649 SyncHandle();
6650 #endif /* USE_XCB */
6651 }
6652 return;
6653 }
6654
6655 #define X_GLvop_GetMinmaxEXT 8
6656 void
6657 gl_dispatch_stub_364(GLenum target, GLboolean reset, GLenum format,
6658 GLenum type, GLvoid * values)
6659 {
6660 __GLXcontext *const gc = __glXGetCurrentContext();
6661
6662 #ifdef GLX_DIRECT_RENDERING
6663 if (gc->driContext) {
6664 CALL_GetMinmax(GET_DISPATCH(), (target, reset, format, type, values));
6665 } else
6666 #endif
6667 {
6668 __GLXcontext *const gc = __glXGetCurrentContext();
6669 const __GLXattribute *const state = gc->client_state_private;
6670 Display *const dpy = gc->currentDpy;
6671 const GLuint cmdlen = 16;
6672 if (__builtin_expect(dpy != NULL, 1)) {
6673 GLubyte const *pc =
6674 __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithReply,
6675 X_GLvop_GetMinmaxEXT, cmdlen);
6676 (void) memcpy((void *) (pc + 0), (void *) (&target), 4);
6677 (void) memcpy((void *) (pc + 4), (void *) (&format), 4);
6678 (void) memcpy((void *) (pc + 8), (void *) (&type), 4);
6679 *(int32_t *) (pc + 12) = 0;
6680 *(int8_t *) (pc + 12) = state->storePack.swapEndian;
6681 *(int8_t *) (pc + 13) = reset;
6682 __glXReadPixelReply(dpy, gc, 1, 2, 1, 1, format, type, values,
6683 GL_FALSE);
6684 UnlockDisplay(dpy);
6685 SyncHandle();
6686 }
6687 return;
6688 }
6689 }
6690
6691 #define X_GLsop_GetMinmaxParameterfv 158
6692 void
6693 __indirect_glGetMinmaxParameterfv(GLenum target, GLenum pname,
6694 GLfloat * params)
6695 {
6696 __GLXcontext *const gc = __glXGetCurrentContext();
6697 Display *const dpy = gc->currentDpy;
6698 #ifndef USE_XCB
6699 const GLuint cmdlen = 8;
6700 #endif
6701 if (__builtin_expect(dpy != NULL, 1)) {
6702 #ifdef USE_XCB
6703 xcb_connection_t *c = XGetXCBConnection(dpy);
6704 (void) __glXFlushRenderBuffer(gc, gc->pc);
6705 xcb_glx_get_minmax_parameterfv_reply_t *reply =
6706 xcb_glx_get_minmax_parameterfv_reply(c,
6707 xcb_glx_get_minmax_parameterfv
6708 (c, gc->currentContextTag,
6709 target, pname), NULL);
6710 if (xcb_glx_get_minmax_parameterfv_data_length(reply) == 0)
6711 (void) memcpy(params, &reply->datum, sizeof(reply->datum));
6712 else
6713 (void) memcpy(params, xcb_glx_get_minmax_parameterfv_data(reply),
6714 xcb_glx_get_minmax_parameterfv_data_length(reply) *
6715 sizeof(GLfloat));
6716 free(reply);
6717 #else
6718 GLubyte const *pc =
6719 __glXSetupSingleRequest(gc, X_GLsop_GetMinmaxParameterfv, cmdlen);
6720 (void) memcpy((void *) (pc + 0), (void *) (&target), 4);
6721 (void) memcpy((void *) (pc + 4), (void *) (&pname), 4);
6722 (void) __glXReadReply(dpy, 4, params, GL_FALSE);
6723 UnlockDisplay(dpy);
6724 SyncHandle();
6725 #endif /* USE_XCB */
6726 }
6727 return;
6728 }
6729
6730 #define X_GLvop_GetMinmaxParameterfvEXT 9
6731 void
6732 gl_dispatch_stub_365(GLenum target, GLenum pname, GLfloat * params)
6733 {
6734 __GLXcontext *const gc = __glXGetCurrentContext();
6735
6736 #ifdef GLX_DIRECT_RENDERING
6737 if (gc->driContext) {
6738 CALL_GetMinmaxParameterfv(GET_DISPATCH(), (target, pname, params));
6739 } else
6740 #endif
6741 {
6742 __GLXcontext *const gc = __glXGetCurrentContext();
6743 Display *const dpy = gc->currentDpy;
6744 const GLuint cmdlen = 8;
6745 if (__builtin_expect(dpy != NULL, 1)) {
6746 GLubyte const *pc =
6747 __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithReply,
6748 X_GLvop_GetMinmaxParameterfvEXT,
6749 cmdlen);
6750 (void) memcpy((void *) (pc + 0), (void *) (&target), 4);
6751 (void) memcpy((void *) (pc + 4), (void *) (&pname), 4);
6752 (void) __glXReadReply(dpy, 4, params, GL_FALSE);
6753 UnlockDisplay(dpy);
6754 SyncHandle();
6755 }
6756 return;
6757 }
6758 }
6759
6760 #define X_GLsop_GetMinmaxParameteriv 159
6761 void
6762 __indirect_glGetMinmaxParameteriv(GLenum target, GLenum pname, GLint * params)
6763 {
6764 __GLXcontext *const gc = __glXGetCurrentContext();
6765 Display *const dpy = gc->currentDpy;
6766 #ifndef USE_XCB
6767 const GLuint cmdlen = 8;
6768 #endif
6769 if (__builtin_expect(dpy != NULL, 1)) {
6770 #ifdef USE_XCB
6771 xcb_connection_t *c = XGetXCBConnection(dpy);
6772 (void) __glXFlushRenderBuffer(gc, gc->pc);
6773 xcb_glx_get_minmax_parameteriv_reply_t *reply =
6774 xcb_glx_get_minmax_parameteriv_reply(c,
6775 xcb_glx_get_minmax_parameteriv
6776 (c, gc->currentContextTag,
6777 target, pname), NULL);
6778 if (xcb_glx_get_minmax_parameteriv_data_length(reply) == 0)
6779 (void) memcpy(params, &reply->datum, sizeof(reply->datum));
6780 else
6781 (void) memcpy(params, xcb_glx_get_minmax_parameteriv_data(reply),
6782 xcb_glx_get_minmax_parameteriv_data_length(reply) *
6783 sizeof(GLint));
6784 free(reply);
6785 #else
6786 GLubyte const *pc =
6787 __glXSetupSingleRequest(gc, X_GLsop_GetMinmaxParameteriv, cmdlen);
6788 (void) memcpy((void *) (pc + 0), (void *) (&target), 4);
6789 (void) memcpy((void *) (pc + 4), (void *) (&pname), 4);
6790 (void) __glXReadReply(dpy, 4, params, GL_FALSE);
6791 UnlockDisplay(dpy);
6792 SyncHandle();
6793 #endif /* USE_XCB */
6794 }
6795 return;
6796 }
6797
6798 #define X_GLvop_GetMinmaxParameterivEXT 10
6799 void
6800 gl_dispatch_stub_366(GLenum target, GLenum pname, GLint * params)
6801 {
6802 __GLXcontext *const gc = __glXGetCurrentContext();
6803
6804 #ifdef GLX_DIRECT_RENDERING
6805 if (gc->driContext) {
6806 CALL_GetMinmaxParameteriv(GET_DISPATCH(), (target, pname, params));
6807 } else
6808 #endif
6809 {
6810 __GLXcontext *const gc = __glXGetCurrentContext();
6811 Display *const dpy = gc->currentDpy;
6812 const GLuint cmdlen = 8;
6813 if (__builtin_expect(dpy != NULL, 1)) {
6814 GLubyte const *pc =
6815 __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithReply,
6816 X_GLvop_GetMinmaxParameterivEXT,
6817 cmdlen);
6818 (void) memcpy((void *) (pc + 0), (void *) (&target), 4);
6819 (void) memcpy((void *) (pc + 4), (void *) (&pname), 4);
6820 (void) __glXReadReply(dpy, 4, params, GL_FALSE);
6821 UnlockDisplay(dpy);
6822 SyncHandle();
6823 }
6824 return;
6825 }
6826 }
6827
6828 #define X_GLrop_Histogram 4110
6829 void
6830 __indirect_glHistogram(GLenum target, GLsizei width, GLenum internalformat,
6831 GLboolean sink)
6832 {
6833 __GLXcontext *const gc = __glXGetCurrentContext();
6834 const GLuint cmdlen = 20;
6835 emit_header(gc->pc, X_GLrop_Histogram, cmdlen);
6836 (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4);
6837 (void) memcpy((void *) (gc->pc + 8), (void *) (&width), 4);
6838 (void) memcpy((void *) (gc->pc + 12), (void *) (&internalformat), 4);
6839 (void) memcpy((void *) (gc->pc + 16), (void *) (&sink), 1);
6840 gc->pc += cmdlen;
6841 if (__builtin_expect(gc->pc > gc->limit, 0)) {
6842 (void) __glXFlushRenderBuffer(gc, gc->pc);
6843 }
6844 }
6845
6846 #define X_GLrop_Minmax 4111
6847 void
6848 __indirect_glMinmax(GLenum target, GLenum internalformat, GLboolean sink)
6849 {
6850 __GLXcontext *const gc = __glXGetCurrentContext();
6851 const GLuint cmdlen = 16;
6852 emit_header(gc->pc, X_GLrop_Minmax, cmdlen);
6853 (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4);
6854 (void) memcpy((void *) (gc->pc + 8), (void *) (&internalformat), 4);
6855 (void) memcpy((void *) (gc->pc + 12), (void *) (&sink), 1);
6856 gc->pc += cmdlen;
6857 if (__builtin_expect(gc->pc > gc->limit, 0)) {
6858 (void) __glXFlushRenderBuffer(gc, gc->pc);
6859 }
6860 }
6861
6862 #define X_GLrop_ResetHistogram 4112
6863 void
6864 __indirect_glResetHistogram(GLenum target)
6865 {
6866 __GLXcontext *const gc = __glXGetCurrentContext();
6867 const GLuint cmdlen = 8;
6868 emit_header(gc->pc, X_GLrop_ResetHistogram, cmdlen);
6869 (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4);
6870 gc->pc += cmdlen;
6871 if (__builtin_expect(gc->pc > gc->limit, 0)) {
6872 (void) __glXFlushRenderBuffer(gc, gc->pc);
6873 }
6874 }
6875
6876 #define X_GLrop_ResetMinmax 4113
6877 void
6878 __indirect_glResetMinmax(GLenum target)
6879 {
6880 __GLXcontext *const gc = __glXGetCurrentContext();
6881 const GLuint cmdlen = 8;
6882 emit_header(gc->pc, X_GLrop_ResetMinmax, cmdlen);
6883 (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4);
6884 gc->pc += cmdlen;
6885 if (__builtin_expect(gc->pc > gc->limit, 0)) {
6886 (void) __glXFlushRenderBuffer(gc, gc->pc);
6887 }
6888 }
6889
6890 static void
6891 __glx_TexImage_3D4D(unsigned opcode, unsigned dim, GLenum target, GLint level,
6892 GLint internalformat, GLsizei width, GLsizei height,
6893 GLsizei depth, GLsizei extent, GLint border,
6894 GLenum format, GLenum type, const GLvoid * pixels)
6895 {
6896 __GLXcontext *const gc = __glXGetCurrentContext();
6897 const GLuint compsize =
6898 (pixels != NULL) ? __glImageSize(width, height, depth, format, type,
6899 target) : 0;
6900 const GLuint cmdlen = 84 + __GLX_PAD(compsize);
6901 if (__builtin_expect(gc->currentDpy != NULL, 1)) {
6902 if (cmdlen <= gc->maxSmallRenderCommandSize) {
6903 if ((gc->pc + cmdlen) > gc->bufEnd) {
6904 (void) __glXFlushRenderBuffer(gc, gc->pc);
6905 }
6906 emit_header(gc->pc, opcode, cmdlen);
6907 (void) memcpy((void *) (gc->pc + 40), (void *) (&target), 4);
6908 (void) memcpy((void *) (gc->pc + 44), (void *) (&level), 4);
6909 (void) memcpy((void *) (gc->pc + 48), (void *) (&internalformat),
6910 4);
6911 (void) memcpy((void *) (gc->pc + 52), (void *) (&width), 4);
6912 (void) memcpy((void *) (gc->pc + 56), (void *) (&height), 4);
6913 (void) memcpy((void *) (gc->pc + 60), (void *) (&depth), 4);
6914 (void) memcpy((void *) (gc->pc + 64), (void *) (&extent), 4);
6915 (void) memcpy((void *) (gc->pc + 68), (void *) (&border), 4);
6916 (void) memcpy((void *) (gc->pc + 72), (void *) (&format), 4);
6917 (void) memcpy((void *) (gc->pc + 76), (void *) (&type), 4);
6918 (void) memcpy((void *) (gc->pc + 80),
6919 (void *) ((pixels == NULL) ? one : zero), 4);
6920 if (compsize > 0) {
6921 (*gc->fillImage) (gc, dim, width, height, depth, format, type,
6922 pixels, gc->pc + 84, gc->pc + 4);
6923 } else {
6924 (void) memcpy(gc->pc + 4, default_pixel_store_4D,
6925 default_pixel_store_4D_size);
6926 }
6927 gc->pc += cmdlen;
6928 if (gc->pc > gc->limit) {
6929 (void) __glXFlushRenderBuffer(gc, gc->pc);
6930 }
6931 } else {
6932 const GLint op = opcode;
6933 const GLuint cmdlenLarge = cmdlen + 4;
6934 GLubyte *const pc = __glXFlushRenderBuffer(gc, gc->pc);
6935 (void) memcpy((void *) (pc + 0), (void *) (&cmdlenLarge), 4);
6936 (void) memcpy((void *) (pc + 4), (void *) (&op), 4);
6937 (void) memcpy((void *) (pc + 44), (void *) (&target), 4);
6938 (void) memcpy((void *) (pc + 48), (void *) (&level), 4);
6939 (void) memcpy((void *) (pc + 52), (void *) (&internalformat), 4);
6940 (void) memcpy((void *) (pc + 56), (void *) (&width), 4);
6941 (void) memcpy((void *) (pc + 60), (void *) (&height), 4);
6942 (void) memcpy((void *) (pc + 64), (void *) (&depth), 4);
6943 (void) memcpy((void *) (pc + 68), (void *) (&extent), 4);
6944 (void) memcpy((void *) (pc + 72), (void *) (&border), 4);
6945 (void) memcpy((void *) (pc + 76), (void *) (&format), 4);
6946 (void) memcpy((void *) (pc + 80), (void *) (&type), 4);
6947 (void) memcpy((void *) (pc + 84), zero, 4);
6948 __glXSendLargeImage(gc, compsize, dim, width, height, depth,
6949 format, type, pixels, pc + 88, pc + 8);
6950 }
6951 }
6952 }
6953
6954 #define X_GLrop_TexImage3D 4114
6955 void
6956 __indirect_glTexImage3D(GLenum target, GLint level, GLint internalformat,
6957 GLsizei width, GLsizei height, GLsizei depth,
6958 GLint border, GLenum format, GLenum type,
6959 const GLvoid * pixels)
6960 {
6961 __glx_TexImage_3D4D(X_GLrop_TexImage3D, 3, target, level, internalformat,
6962 width, height, depth, 1, border, format, type,
6963 pixels);
6964 }
6965
6966 static void
6967 __glx_TexSubImage_3D4D(unsigned opcode, unsigned dim, GLenum target,
6968 GLint level, GLint xoffset, GLint yoffset,
6969 GLint zoffset, GLint woffset, GLsizei width,
6970 GLsizei height, GLsizei depth, GLsizei extent,
6971 GLenum format, GLenum type, const GLvoid * pixels)
6972 {
6973 __GLXcontext *const gc = __glXGetCurrentContext();
6974 const GLuint compsize =
6975 (pixels != NULL) ? __glImageSize(width, height, depth, format, type,
6976 target) : 0;
6977 const GLuint cmdlen = 92 + __GLX_PAD(compsize);
6978 if (__builtin_expect(gc->currentDpy != NULL, 1)) {
6979 if (cmdlen <= gc->maxSmallRenderCommandSize) {
6980 if ((gc->pc + cmdlen) > gc->bufEnd) {
6981 (void) __glXFlushRenderBuffer(gc, gc->pc);
6982 }
6983 emit_header(gc->pc, opcode, cmdlen);
6984 (void) memcpy((void *) (gc->pc + 40), (void *) (&target), 4);
6985 (void) memcpy((void *) (gc->pc + 44), (void *) (&level), 4);
6986 (void) memcpy((void *) (gc->pc + 48), (void *) (&xoffset), 4);
6987 (void) memcpy((void *) (gc->pc + 52), (void *) (&yoffset), 4);
6988 (void) memcpy((void *) (gc->pc + 56), (void *) (&zoffset), 4);
6989 (void) memcpy((void *) (gc->pc + 60), (void *) (&woffset), 4);
6990 (void) memcpy((void *) (gc->pc + 64), (void *) (&width), 4);
6991 (void) memcpy((void *) (gc->pc + 68), (void *) (&height), 4);
6992 (void) memcpy((void *) (gc->pc + 72), (void *) (&depth), 4);
6993 (void) memcpy((void *) (gc->pc + 76), (void *) (&extent), 4);
6994 (void) memcpy((void *) (gc->pc + 80), (void *) (&format), 4);
6995 (void) memcpy((void *) (gc->pc + 84), (void *) (&type), 4);
6996 (void) memcpy((void *) (gc->pc + 88),
6997 (void *) ((pixels == NULL) ? one : zero), 4);
6998 if (compsize > 0) {
6999 (*gc->fillImage) (gc, dim, width, height, depth, format, type,
7000 pixels, gc->pc + 92, gc->pc + 4);
7001 } else {
7002 (void) memcpy(gc->pc + 4, default_pixel_store_4D,
7003 default_pixel_store_4D_size);
7004 }
7005 gc->pc += cmdlen;
7006 if (gc->pc > gc->limit) {
7007 (void) __glXFlushRenderBuffer(gc, gc->pc);
7008 }
7009 } else {
7010 const GLint op = opcode;
7011 const GLuint cmdlenLarge = cmdlen + 4;
7012 GLubyte *const pc = __glXFlushRenderBuffer(gc, gc->pc);
7013 (void) memcpy((void *) (pc + 0), (void *) (&cmdlenLarge), 4);
7014 (void) memcpy((void *) (pc + 4), (void *) (&op), 4);
7015 (void) memcpy((void *) (pc + 44), (void *) (&target), 4);
7016 (void) memcpy((void *) (pc + 48), (void *) (&level), 4);
7017 (void) memcpy((void *) (pc + 52), (void *) (&xoffset), 4);
7018 (void) memcpy((void *) (pc + 56), (void *) (&yoffset), 4);
7019 (void) memcpy((void *) (pc + 60), (void *) (&zoffset), 4);
7020 (void) memcpy((void *) (pc + 64), (void *) (&woffset), 4);
7021 (void) memcpy((void *) (pc + 68), (void *) (&width), 4);
7022 (void) memcpy((void *) (pc + 72), (void *) (&height), 4);
7023 (void) memcpy((void *) (pc + 76), (void *) (&depth), 4);
7024 (void) memcpy((void *) (pc + 80), (void *) (&extent), 4);
7025 (void) memcpy((void *) (pc + 84), (void *) (&format), 4);
7026 (void) memcpy((void *) (pc + 88), (void *) (&type), 4);
7027 (void) memcpy((void *) (pc + 92), zero, 4);
7028 __glXSendLargeImage(gc, compsize, dim, width, height, depth,
7029 format, type, pixels, pc + 96, pc + 8);
7030 }
7031 }
7032 }
7033
7034 #define X_GLrop_TexSubImage3D 4115
7035 void
7036 __indirect_glTexSubImage3D(GLenum target, GLint level, GLint xoffset,
7037 GLint yoffset, GLint zoffset, GLsizei width,
7038 GLsizei height, GLsizei depth, GLenum format,
7039 GLenum type, const GLvoid * pixels)
7040 {
7041 __glx_TexSubImage_3D4D(X_GLrop_TexSubImage3D, 3, target, level, xoffset,
7042 yoffset, zoffset, 1, width, height, depth, 1,
7043 format, type, pixels);
7044 }
7045
7046 #define X_GLrop_CopyTexSubImage3D 4123
7047 void
7048 __indirect_glCopyTexSubImage3D(GLenum target, GLint level, GLint xoffset,
7049 GLint yoffset, GLint zoffset, GLint x, GLint y,
7050 GLsizei width, GLsizei height)
7051 {
7052 __GLXcontext *const gc = __glXGetCurrentContext();
7053 const GLuint cmdlen = 40;
7054 emit_header(gc->pc, X_GLrop_CopyTexSubImage3D, cmdlen);
7055 (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4);
7056 (void) memcpy((void *) (gc->pc + 8), (void *) (&level), 4);
7057 (void) memcpy((void *) (gc->pc + 12), (void *) (&xoffset), 4);
7058 (void) memcpy((void *) (gc->pc + 16), (void *) (&yoffset), 4);
7059 (void) memcpy((void *) (gc->pc + 20), (void *) (&zoffset), 4);
7060 (void) memcpy((void *) (gc->pc + 24), (void *) (&x), 4);
7061 (void) memcpy((void *) (gc->pc + 28), (void *) (&y), 4);
7062 (void) memcpy((void *) (gc->pc + 32), (void *) (&width), 4);
7063 (void) memcpy((void *) (gc->pc + 36), (void *) (&height), 4);
7064 gc->pc += cmdlen;
7065 if (__builtin_expect(gc->pc > gc->limit, 0)) {
7066 (void) __glXFlushRenderBuffer(gc, gc->pc);
7067 }
7068 }
7069
7070 #define X_GLrop_ActiveTextureARB 197
7071 void
7072 __indirect_glActiveTextureARB(GLenum texture)
7073 {
7074 __GLXcontext *const gc = __glXGetCurrentContext();
7075 const GLuint cmdlen = 8;
7076 emit_header(gc->pc, X_GLrop_ActiveTextureARB, cmdlen);
7077 (void) memcpy((void *) (gc->pc + 4), (void *) (&texture), 4);
7078 gc->pc += cmdlen;
7079 if (__builtin_expect(gc->pc > gc->limit, 0)) {
7080 (void) __glXFlushRenderBuffer(gc, gc->pc);
7081 }
7082 }
7083
7084 #define X_GLrop_MultiTexCoord1dvARB 198
7085 void
7086 __indirect_glMultiTexCoord1dARB(GLenum target, GLdouble s)
7087 {
7088 __GLXcontext *const gc = __glXGetCurrentContext();
7089 const GLuint cmdlen = 16;
7090 emit_header(gc->pc, X_GLrop_MultiTexCoord1dvARB, cmdlen);
7091 (void) memcpy((void *) (gc->pc + 4), (void *) (&s), 8);
7092 (void) memcpy((void *) (gc->pc + 12), (void *) (&target), 4);
7093 gc->pc += cmdlen;
7094 if (__builtin_expect(gc->pc > gc->limit, 0)) {
7095 (void) __glXFlushRenderBuffer(gc, gc->pc);
7096 }
7097 }
7098
7099 #define X_GLrop_MultiTexCoord1dvARB 198
7100 void
7101 __indirect_glMultiTexCoord1dvARB(GLenum target, const GLdouble * v)
7102 {
7103 __GLXcontext *const gc = __glXGetCurrentContext();
7104 const GLuint cmdlen = 16;
7105 emit_header(gc->pc, X_GLrop_MultiTexCoord1dvARB, cmdlen);
7106 (void) memcpy((void *) (gc->pc + 4), (void *) (v), 8);
7107 (void) memcpy((void *) (gc->pc + 12), (void *) (&target), 4);
7108 gc->pc += cmdlen;
7109 if (__builtin_expect(gc->pc > gc->limit, 0)) {
7110 (void) __glXFlushRenderBuffer(gc, gc->pc);
7111 }
7112 }
7113
7114 #define X_GLrop_MultiTexCoord1fvARB 199
7115 void
7116 __indirect_glMultiTexCoord1fARB(GLenum target, GLfloat s)
7117 {
7118 __GLXcontext *const gc = __glXGetCurrentContext();
7119 const GLuint cmdlen = 12;
7120 emit_header(gc->pc, X_GLrop_MultiTexCoord1fvARB, cmdlen);
7121 (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4);
7122 (void) memcpy((void *) (gc->pc + 8), (void *) (&s), 4);
7123 gc->pc += cmdlen;
7124 if (__builtin_expect(gc->pc > gc->limit, 0)) {
7125 (void) __glXFlushRenderBuffer(gc, gc->pc);
7126 }
7127 }
7128
7129 #define X_GLrop_MultiTexCoord1fvARB 199
7130 void
7131 __indirect_glMultiTexCoord1fvARB(GLenum target, const GLfloat * v)
7132 {
7133 __GLXcontext *const gc = __glXGetCurrentContext();
7134 const GLuint cmdlen = 12;
7135 emit_header(gc->pc, X_GLrop_MultiTexCoord1fvARB, cmdlen);
7136 (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4);
7137 (void) memcpy((void *) (gc->pc + 8), (void *) (v), 4);
7138 gc->pc += cmdlen;
7139 if (__builtin_expect(gc->pc > gc->limit, 0)) {
7140 (void) __glXFlushRenderBuffer(gc, gc->pc);
7141 }
7142 }
7143
7144 #define X_GLrop_MultiTexCoord1ivARB 200
7145 void
7146 __indirect_glMultiTexCoord1iARB(GLenum target, GLint s)
7147 {
7148 __GLXcontext *const gc = __glXGetCurrentContext();
7149 const GLuint cmdlen = 12;
7150 emit_header(gc->pc, X_GLrop_MultiTexCoord1ivARB, cmdlen);
7151 (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4);
7152 (void) memcpy((void *) (gc->pc + 8), (void *) (&s), 4);
7153 gc->pc += cmdlen;
7154 if (__builtin_expect(gc->pc > gc->limit, 0)) {
7155 (void) __glXFlushRenderBuffer(gc, gc->pc);
7156 }
7157 }
7158
7159 #define X_GLrop_MultiTexCoord1ivARB 200
7160 void
7161 __indirect_glMultiTexCoord1ivARB(GLenum target, const GLint * v)
7162 {
7163 __GLXcontext *const gc = __glXGetCurrentContext();
7164 const GLuint cmdlen = 12;
7165 emit_header(gc->pc, X_GLrop_MultiTexCoord1ivARB, cmdlen);
7166 (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4);
7167 (void) memcpy((void *) (gc->pc + 8), (void *) (v), 4);
7168 gc->pc += cmdlen;
7169 if (__builtin_expect(gc->pc > gc->limit, 0)) {
7170 (void) __glXFlushRenderBuffer(gc, gc->pc);
7171 }
7172 }
7173
7174 #define X_GLrop_MultiTexCoord1svARB 201
7175 void
7176 __indirect_glMultiTexCoord1sARB(GLenum target, GLshort s)
7177 {
7178 __GLXcontext *const gc = __glXGetCurrentContext();
7179 const GLuint cmdlen = 12;
7180 emit_header(gc->pc, X_GLrop_MultiTexCoord1svARB, cmdlen);
7181 (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4);
7182 (void) memcpy((void *) (gc->pc + 8), (void *) (&s), 2);
7183 gc->pc += cmdlen;
7184 if (__builtin_expect(gc->pc > gc->limit, 0)) {
7185 (void) __glXFlushRenderBuffer(gc, gc->pc);
7186 }
7187 }
7188
7189 #define X_GLrop_MultiTexCoord1svARB 201
7190 void
7191 __indirect_glMultiTexCoord1svARB(GLenum target, const GLshort * v)
7192 {
7193 __GLXcontext *const gc = __glXGetCurrentContext();
7194 const GLuint cmdlen = 12;
7195 emit_header(gc->pc, X_GLrop_MultiTexCoord1svARB, cmdlen);
7196 (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4);
7197 (void) memcpy((void *) (gc->pc + 8), (void *) (v), 2);
7198 gc->pc += cmdlen;
7199 if (__builtin_expect(gc->pc > gc->limit, 0)) {
7200 (void) __glXFlushRenderBuffer(gc, gc->pc);
7201 }
7202 }
7203
7204 #define X_GLrop_MultiTexCoord2dvARB 202
7205 void
7206 __indirect_glMultiTexCoord2dARB(GLenum target, GLdouble s, GLdouble t)
7207 {
7208 __GLXcontext *const gc = __glXGetCurrentContext();
7209 const GLuint cmdlen = 24;
7210 emit_header(gc->pc, X_GLrop_MultiTexCoord2dvARB, cmdlen);
7211 (void) memcpy((void *) (gc->pc + 4), (void *) (&s), 8);
7212 (void) memcpy((void *) (gc->pc + 12), (void *) (&t), 8);
7213 (void) memcpy((void *) (gc->pc + 20), (void *) (&target), 4);
7214 gc->pc += cmdlen;
7215 if (__builtin_expect(gc->pc > gc->limit, 0)) {
7216 (void) __glXFlushRenderBuffer(gc, gc->pc);
7217 }
7218 }
7219
7220 #define X_GLrop_MultiTexCoord2dvARB 202
7221 void
7222 __indirect_glMultiTexCoord2dvARB(GLenum target, const GLdouble * v)
7223 {
7224 __GLXcontext *const gc = __glXGetCurrentContext();
7225 const GLuint cmdlen = 24;
7226 emit_header(gc->pc, X_GLrop_MultiTexCoord2dvARB, cmdlen);
7227 (void) memcpy((void *) (gc->pc + 4), (void *) (v), 16);
7228 (void) memcpy((void *) (gc->pc + 20), (void *) (&target), 4);
7229 gc->pc += cmdlen;
7230 if (__builtin_expect(gc->pc > gc->limit, 0)) {
7231 (void) __glXFlushRenderBuffer(gc, gc->pc);
7232 }
7233 }
7234
7235 #define X_GLrop_MultiTexCoord2fvARB 203
7236 void
7237 __indirect_glMultiTexCoord2fARB(GLenum target, GLfloat s, GLfloat t)
7238 {
7239 __GLXcontext *const gc = __glXGetCurrentContext();
7240 const GLuint cmdlen = 16;
7241 emit_header(gc->pc, X_GLrop_MultiTexCoord2fvARB, cmdlen);
7242 (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4);
7243 (void) memcpy((void *) (gc->pc + 8), (void *) (&s), 4);
7244 (void) memcpy((void *) (gc->pc + 12), (void *) (&t), 4);
7245 gc->pc += cmdlen;
7246 if (__builtin_expect(gc->pc > gc->limit, 0)) {
7247 (void) __glXFlushRenderBuffer(gc, gc->pc);
7248 }
7249 }
7250
7251 #define X_GLrop_MultiTexCoord2fvARB 203
7252 void
7253 __indirect_glMultiTexCoord2fvARB(GLenum target, const GLfloat * v)
7254 {
7255 __GLXcontext *const gc = __glXGetCurrentContext();
7256 const GLuint cmdlen = 16;
7257 emit_header(gc->pc, X_GLrop_MultiTexCoord2fvARB, cmdlen);
7258 (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4);
7259 (void) memcpy((void *) (gc->pc + 8), (void *) (v), 8);
7260 gc->pc += cmdlen;
7261 if (__builtin_expect(gc->pc > gc->limit, 0)) {
7262 (void) __glXFlushRenderBuffer(gc, gc->pc);
7263 }
7264 }
7265
7266 #define X_GLrop_MultiTexCoord2ivARB 204
7267 void
7268 __indirect_glMultiTexCoord2iARB(GLenum target, GLint s, GLint t)
7269 {
7270 __GLXcontext *const gc = __glXGetCurrentContext();
7271 const GLuint cmdlen = 16;
7272 emit_header(gc->pc, X_GLrop_MultiTexCoord2ivARB, cmdlen);
7273 (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4);
7274 (void) memcpy((void *) (gc->pc + 8), (void *) (&s), 4);
7275 (void) memcpy((void *) (gc->pc + 12), (void *) (&t), 4);
7276 gc->pc += cmdlen;
7277 if (__builtin_expect(gc->pc > gc->limit, 0)) {
7278 (void) __glXFlushRenderBuffer(gc, gc->pc);
7279 }
7280 }
7281
7282 #define X_GLrop_MultiTexCoord2ivARB 204
7283 void
7284 __indirect_glMultiTexCoord2ivARB(GLenum target, const GLint * v)
7285 {
7286 __GLXcontext *const gc = __glXGetCurrentContext();
7287 const GLuint cmdlen = 16;
7288 emit_header(gc->pc, X_GLrop_MultiTexCoord2ivARB, cmdlen);
7289 (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4);
7290 (void) memcpy((void *) (gc->pc + 8), (void *) (v), 8);
7291 gc->pc += cmdlen;
7292 if (__builtin_expect(gc->pc > gc->limit, 0)) {
7293 (void) __glXFlushRenderBuffer(gc, gc->pc);
7294 }
7295 }
7296
7297 #define X_GLrop_MultiTexCoord2svARB 205
7298 void
7299 __indirect_glMultiTexCoord2sARB(GLenum target, GLshort s, GLshort t)
7300 {
7301 __GLXcontext *const gc = __glXGetCurrentContext();
7302 const GLuint cmdlen = 12;
7303 emit_header(gc->pc, X_GLrop_MultiTexCoord2svARB, cmdlen);
7304 (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4);
7305 (void) memcpy((void *) (gc->pc + 8), (void *) (&s), 2);
7306 (void) memcpy((void *) (gc->pc + 10), (void *) (&t), 2);
7307 gc->pc += cmdlen;
7308 if (__builtin_expect(gc->pc > gc->limit, 0)) {
7309 (void) __glXFlushRenderBuffer(gc, gc->pc);
7310 }
7311 }
7312
7313 #define X_GLrop_MultiTexCoord2svARB 205
7314 void
7315 __indirect_glMultiTexCoord2svARB(GLenum target, const GLshort * v)
7316 {
7317 __GLXcontext *const gc = __glXGetCurrentContext();
7318 const GLuint cmdlen = 12;
7319 emit_header(gc->pc, X_GLrop_MultiTexCoord2svARB, cmdlen);
7320 (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4);
7321 (void) memcpy((void *) (gc->pc + 8), (void *) (v), 4);
7322 gc->pc += cmdlen;
7323 if (__builtin_expect(gc->pc > gc->limit, 0)) {
7324 (void) __glXFlushRenderBuffer(gc, gc->pc);
7325 }
7326 }
7327
7328 #define X_GLrop_MultiTexCoord3dvARB 206
7329 void
7330 __indirect_glMultiTexCoord3dARB(GLenum target, GLdouble s, GLdouble t,
7331 GLdouble r)
7332 {
7333 __GLXcontext *const gc = __glXGetCurrentContext();
7334 const GLuint cmdlen = 32;
7335 emit_header(gc->pc, X_GLrop_MultiTexCoord3dvARB, cmdlen);
7336 (void) memcpy((void *) (gc->pc + 4), (void *) (&s), 8);
7337 (void) memcpy((void *) (gc->pc + 12), (void *) (&t), 8);
7338 (void) memcpy((void *) (gc->pc + 20), (void *) (&r), 8);
7339 (void) memcpy((void *) (gc->pc + 28), (void *) (&target), 4);
7340 gc->pc += cmdlen;
7341 if (__builtin_expect(gc->pc > gc->limit, 0)) {
7342 (void) __glXFlushRenderBuffer(gc, gc->pc);
7343 }
7344 }
7345
7346 #define X_GLrop_MultiTexCoord3dvARB 206
7347 void
7348 __indirect_glMultiTexCoord3dvARB(GLenum target, const GLdouble * v)
7349 {
7350 __GLXcontext *const gc = __glXGetCurrentContext();
7351 const GLuint cmdlen = 32;
7352 emit_header(gc->pc, X_GLrop_MultiTexCoord3dvARB, cmdlen);
7353 (void) memcpy((void *) (gc->pc + 4), (void *) (v), 24);
7354 (void) memcpy((void *) (gc->pc + 28), (void *) (&target), 4);
7355 gc->pc += cmdlen;
7356 if (__builtin_expect(gc->pc > gc->limit, 0)) {
7357 (void) __glXFlushRenderBuffer(gc, gc->pc);
7358 }
7359 }
7360
7361 #define X_GLrop_MultiTexCoord3fvARB 207
7362 void
7363 __indirect_glMultiTexCoord3fARB(GLenum target, GLfloat s, GLfloat t,
7364 GLfloat r)
7365 {
7366 __GLXcontext *const gc = __glXGetCurrentContext();
7367 const GLuint cmdlen = 20;
7368 emit_header(gc->pc, X_GLrop_MultiTexCoord3fvARB, cmdlen);
7369 (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4);
7370 (void) memcpy((void *) (gc->pc + 8), (void *) (&s), 4);
7371 (void) memcpy((void *) (gc->pc + 12), (void *) (&t), 4);
7372 (void) memcpy((void *) (gc->pc + 16), (void *) (&r), 4);
7373 gc->pc += cmdlen;
7374 if (__builtin_expect(gc->pc > gc->limit, 0)) {
7375 (void) __glXFlushRenderBuffer(gc, gc->pc);
7376 }
7377 }
7378
7379 #define X_GLrop_MultiTexCoord3fvARB 207
7380 void
7381 __indirect_glMultiTexCoord3fvARB(GLenum target, const GLfloat * v)
7382 {
7383 __GLXcontext *const gc = __glXGetCurrentContext();
7384 const GLuint cmdlen = 20;
7385 emit_header(gc->pc, X_GLrop_MultiTexCoord3fvARB, cmdlen);
7386 (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4);
7387 (void) memcpy((void *) (gc->pc + 8), (void *) (v), 12);
7388 gc->pc += cmdlen;
7389 if (__builtin_expect(gc->pc > gc->limit, 0)) {
7390 (void) __glXFlushRenderBuffer(gc, gc->pc);
7391 }
7392 }
7393
7394 #define X_GLrop_MultiTexCoord3ivARB 208
7395 void
7396 __indirect_glMultiTexCoord3iARB(GLenum target, GLint s, GLint t, GLint r)
7397 {
7398 __GLXcontext *const gc = __glXGetCurrentContext();
7399 const GLuint cmdlen = 20;
7400 emit_header(gc->pc, X_GLrop_MultiTexCoord3ivARB, cmdlen);
7401 (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4);
7402 (void) memcpy((void *) (gc->pc + 8), (void *) (&s), 4);
7403 (void) memcpy((void *) (gc->pc + 12), (void *) (&t), 4);
7404 (void) memcpy((void *) (gc->pc + 16), (void *) (&r), 4);
7405 gc->pc += cmdlen;
7406 if (__builtin_expect(gc->pc > gc->limit, 0)) {
7407 (void) __glXFlushRenderBuffer(gc, gc->pc);
7408 }
7409 }
7410
7411 #define X_GLrop_MultiTexCoord3ivARB 208
7412 void
7413 __indirect_glMultiTexCoord3ivARB(GLenum target, const GLint * v)
7414 {
7415 __GLXcontext *const gc = __glXGetCurrentContext();
7416 const GLuint cmdlen = 20;
7417 emit_header(gc->pc, X_GLrop_MultiTexCoord3ivARB, cmdlen);
7418 (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4);
7419 (void) memcpy((void *) (gc->pc + 8), (void *) (v), 12);
7420 gc->pc += cmdlen;
7421 if (__builtin_expect(gc->pc > gc->limit, 0)) {
7422 (void) __glXFlushRenderBuffer(gc, gc->pc);
7423 }
7424 }
7425
7426 #define X_GLrop_MultiTexCoord3svARB 209
7427 void
7428 __indirect_glMultiTexCoord3sARB(GLenum target, GLshort s, GLshort t,
7429 GLshort r)
7430 {
7431 __GLXcontext *const gc = __glXGetCurrentContext();
7432 const GLuint cmdlen = 16;
7433 emit_header(gc->pc, X_GLrop_MultiTexCoord3svARB, cmdlen);
7434 (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4);
7435 (void) memcpy((void *) (gc->pc + 8), (void *) (&s), 2);
7436 (void) memcpy((void *) (gc->pc + 10), (void *) (&t), 2);
7437 (void) memcpy((void *) (gc->pc + 12), (void *) (&r), 2);
7438 gc->pc += cmdlen;
7439 if (__builtin_expect(gc->pc > gc->limit, 0)) {
7440 (void) __glXFlushRenderBuffer(gc, gc->pc);
7441 }
7442 }
7443
7444 #define X_GLrop_MultiTexCoord3svARB 209
7445 void
7446 __indirect_glMultiTexCoord3svARB(GLenum target, const GLshort * v)
7447 {
7448 __GLXcontext *const gc = __glXGetCurrentContext();
7449 const GLuint cmdlen = 16;
7450 emit_header(gc->pc, X_GLrop_MultiTexCoord3svARB, cmdlen);
7451 (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4);
7452 (void) memcpy((void *) (gc->pc + 8), (void *) (v), 6);
7453 gc->pc += cmdlen;
7454 if (__builtin_expect(gc->pc > gc->limit, 0)) {
7455 (void) __glXFlushRenderBuffer(gc, gc->pc);
7456 }
7457 }
7458
7459 #define X_GLrop_MultiTexCoord4dvARB 210
7460 void
7461 __indirect_glMultiTexCoord4dARB(GLenum target, GLdouble s, GLdouble t,
7462 GLdouble r, GLdouble q)
7463 {
7464 __GLXcontext *const gc = __glXGetCurrentContext();
7465 const GLuint cmdlen = 40;
7466 emit_header(gc->pc, X_GLrop_MultiTexCoord4dvARB, cmdlen);
7467 (void) memcpy((void *) (gc->pc + 4), (void *) (&s), 8);
7468 (void) memcpy((void *) (gc->pc + 12), (void *) (&t), 8);
7469 (void) memcpy((void *) (gc->pc + 20), (void *) (&r), 8);
7470 (void) memcpy((void *) (gc->pc + 28), (void *) (&q), 8);
7471 (void) memcpy((void *) (gc->pc + 36), (void *) (&target), 4);
7472 gc->pc += cmdlen;
7473 if (__builtin_expect(gc->pc > gc->limit, 0)) {
7474 (void) __glXFlushRenderBuffer(gc, gc->pc);
7475 }
7476 }
7477
7478 #define X_GLrop_MultiTexCoord4dvARB 210
7479 void
7480 __indirect_glMultiTexCoord4dvARB(GLenum target, const GLdouble * v)
7481 {
7482 __GLXcontext *const gc = __glXGetCurrentContext();
7483 const GLuint cmdlen = 40;
7484 emit_header(gc->pc, X_GLrop_MultiTexCoord4dvARB, cmdlen);
7485 (void) memcpy((void *) (gc->pc + 4), (void *) (v), 32);
7486 (void) memcpy((void *) (gc->pc + 36), (void *) (&target), 4);
7487 gc->pc += cmdlen;
7488 if (__builtin_expect(gc->pc > gc->limit, 0)) {
7489 (void) __glXFlushRenderBuffer(gc, gc->pc);
7490 }
7491 }
7492
7493 #define X_GLrop_MultiTexCoord4fvARB 211
7494 void
7495 __indirect_glMultiTexCoord4fARB(GLenum target, GLfloat s, GLfloat t,
7496 GLfloat r, GLfloat q)
7497 {
7498 __GLXcontext *const gc = __glXGetCurrentContext();
7499 const GLuint cmdlen = 24;
7500 emit_header(gc->pc, X_GLrop_MultiTexCoord4fvARB, cmdlen);
7501 (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4);
7502 (void) memcpy((void *) (gc->pc + 8), (void *) (&s), 4);
7503 (void) memcpy((void *) (gc->pc + 12), (void *) (&t), 4);
7504 (void) memcpy((void *) (gc->pc + 16), (void *) (&r), 4);
7505 (void) memcpy((void *) (gc->pc + 20), (void *) (&q), 4);
7506 gc->pc += cmdlen;
7507 if (__builtin_expect(gc->pc > gc->limit, 0)) {
7508 (void) __glXFlushRenderBuffer(gc, gc->pc);
7509 }
7510 }
7511
7512 #define X_GLrop_MultiTexCoord4fvARB 211
7513 void
7514 __indirect_glMultiTexCoord4fvARB(GLenum target, const GLfloat * v)
7515 {
7516 __GLXcontext *const gc = __glXGetCurrentContext();
7517 const GLuint cmdlen = 24;
7518 emit_header(gc->pc, X_GLrop_MultiTexCoord4fvARB, cmdlen);
7519 (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4);
7520 (void) memcpy((void *) (gc->pc + 8), (void *) (v), 16);
7521 gc->pc += cmdlen;
7522 if (__builtin_expect(gc->pc > gc->limit, 0)) {
7523 (void) __glXFlushRenderBuffer(gc, gc->pc);
7524 }
7525 }
7526
7527 #define X_GLrop_MultiTexCoord4ivARB 212
7528 void
7529 __indirect_glMultiTexCoord4iARB(GLenum target, GLint s, GLint t, GLint r,
7530 GLint q)
7531 {
7532 __GLXcontext *const gc = __glXGetCurrentContext();
7533 const GLuint cmdlen = 24;
7534 emit_header(gc->pc, X_GLrop_MultiTexCoord4ivARB, cmdlen);
7535 (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4);
7536 (void) memcpy((void *) (gc->pc + 8), (void *) (&s), 4);
7537 (void) memcpy((void *) (gc->pc + 12), (void *) (&t), 4);
7538 (void) memcpy((void *) (gc->pc + 16), (void *) (&r), 4);
7539 (void) memcpy((void *) (gc->pc + 20), (void *) (&q), 4);
7540 gc->pc += cmdlen;
7541 if (__builtin_expect(gc->pc > gc->limit, 0)) {
7542 (void) __glXFlushRenderBuffer(gc, gc->pc);
7543 }
7544 }
7545
7546 #define X_GLrop_MultiTexCoord4ivARB 212
7547 void
7548 __indirect_glMultiTexCoord4ivARB(GLenum target, const GLint * v)
7549 {
7550 __GLXcontext *const gc = __glXGetCurrentContext();
7551 const GLuint cmdlen = 24;
7552 emit_header(gc->pc, X_GLrop_MultiTexCoord4ivARB, cmdlen);
7553 (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4);
7554 (void) memcpy((void *) (gc->pc + 8), (void *) (v), 16);
7555 gc->pc += cmdlen;
7556 if (__builtin_expect(gc->pc > gc->limit, 0)) {
7557 (void) __glXFlushRenderBuffer(gc, gc->pc);
7558 }
7559 }
7560
7561 #define X_GLrop_MultiTexCoord4svARB 213
7562 void
7563 __indirect_glMultiTexCoord4sARB(GLenum target, GLshort s, GLshort t,
7564 GLshort r, GLshort q)
7565 {
7566 __GLXcontext *const gc = __glXGetCurrentContext();
7567 const GLuint cmdlen = 16;
7568 emit_header(gc->pc, X_GLrop_MultiTexCoord4svARB, cmdlen);
7569 (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4);
7570 (void) memcpy((void *) (gc->pc + 8), (void *) (&s), 2);
7571 (void) memcpy((void *) (gc->pc + 10), (void *) (&t), 2);
7572 (void) memcpy((void *) (gc->pc + 12), (void *) (&r), 2);
7573 (void) memcpy((void *) (gc->pc + 14), (void *) (&q), 2);
7574 gc->pc += cmdlen;
7575 if (__builtin_expect(gc->pc > gc->limit, 0)) {
7576 (void) __glXFlushRenderBuffer(gc, gc->pc);
7577 }
7578 }
7579
7580 #define X_GLrop_MultiTexCoord4svARB 213
7581 void
7582 __indirect_glMultiTexCoord4svARB(GLenum target, const GLshort * v)
7583 {
7584 __GLXcontext *const gc = __glXGetCurrentContext();
7585 const GLuint cmdlen = 16;
7586 emit_header(gc->pc, X_GLrop_MultiTexCoord4svARB, cmdlen);
7587 (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4);
7588 (void) memcpy((void *) (gc->pc + 8), (void *) (v), 8);
7589 gc->pc += cmdlen;
7590 if (__builtin_expect(gc->pc > gc->limit, 0)) {
7591 (void) __glXFlushRenderBuffer(gc, gc->pc);
7592 }
7593 }
7594
7595 #define X_GLrop_SampleCoverageARB 229
7596 void
7597 __indirect_glSampleCoverageARB(GLclampf value, GLboolean invert)
7598 {
7599 __GLXcontext *const gc = __glXGetCurrentContext();
7600 const GLuint cmdlen = 12;
7601 emit_header(gc->pc, X_GLrop_SampleCoverageARB, cmdlen);
7602 (void) memcpy((void *) (gc->pc + 4), (void *) (&value), 4);
7603 (void) memcpy((void *) (gc->pc + 8), (void *) (&invert), 1);
7604 gc->pc += cmdlen;
7605 if (__builtin_expect(gc->pc > gc->limit, 0)) {
7606 (void) __glXFlushRenderBuffer(gc, gc->pc);
7607 }
7608 }
7609
7610 #define X_GLvop_GetProgramStringARB 1308
7611 void
7612 __indirect_glGetProgramStringARB(GLenum target, GLenum pname, GLvoid * string)
7613 {
7614 __GLXcontext *const gc = __glXGetCurrentContext();
7615 Display *const dpy = gc->currentDpy;
7616 const GLuint cmdlen = 8;
7617 if (__builtin_expect(dpy != NULL, 1)) {
7618 GLubyte const *pc =
7619 __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithReply,
7620 X_GLvop_GetProgramStringARB, cmdlen);
7621 (void) memcpy((void *) (pc + 0), (void *) (&target), 4);
7622 (void) memcpy((void *) (pc + 4), (void *) (&pname), 4);
7623 (void) __glXReadReply(dpy, 1, string, GL_TRUE);
7624 UnlockDisplay(dpy);
7625 SyncHandle();
7626 }
7627 return;
7628 }
7629
7630 #define X_GLvop_GetProgramivARB 1307
7631 void
7632 __indirect_glGetProgramivARB(GLenum target, GLenum pname, GLint * params)
7633 {
7634 __GLXcontext *const gc = __glXGetCurrentContext();
7635 Display *const dpy = gc->currentDpy;
7636 const GLuint cmdlen = 8;
7637 if (__builtin_expect(dpy != NULL, 1)) {
7638 GLubyte const *pc =
7639 __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithReply,
7640 X_GLvop_GetProgramivARB, cmdlen);
7641 (void) memcpy((void *) (pc + 0), (void *) (&target), 4);
7642 (void) memcpy((void *) (pc + 4), (void *) (&pname), 4);
7643 (void) __glXReadReply(dpy, 4, params, GL_FALSE);
7644 UnlockDisplay(dpy);
7645 SyncHandle();
7646 }
7647 return;
7648 }
7649
7650 #define X_GLrop_ProgramEnvParameter4dvARB 4185
7651 void
7652 __indirect_glProgramEnvParameter4dvARB(GLenum target, GLuint index,
7653 const GLdouble * params)
7654 {
7655 __GLXcontext *const gc = __glXGetCurrentContext();
7656 const GLuint cmdlen = 44;
7657 emit_header(gc->pc, X_GLrop_ProgramEnvParameter4dvARB, cmdlen);
7658 (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4);
7659 (void) memcpy((void *) (gc->pc + 8), (void *) (&index), 4);
7660 (void) memcpy((void *) (gc->pc + 12), (void *) (params), 32);
7661 gc->pc += cmdlen;
7662 if (__builtin_expect(gc->pc > gc->limit, 0)) {
7663 (void) __glXFlushRenderBuffer(gc, gc->pc);
7664 }
7665 }
7666
7667 #define X_GLrop_ProgramEnvParameter4fvARB 4184
7668 void
7669 __indirect_glProgramEnvParameter4fvARB(GLenum target, GLuint index,
7670 const GLfloat * params)
7671 {
7672 __GLXcontext *const gc = __glXGetCurrentContext();
7673 const GLuint cmdlen = 28;
7674 emit_header(gc->pc, X_GLrop_ProgramEnvParameter4fvARB, cmdlen);
7675 (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4);
7676 (void) memcpy((void *) (gc->pc + 8), (void *) (&index), 4);
7677 (void) memcpy((void *) (gc->pc + 12), (void *) (params), 16);
7678 gc->pc += cmdlen;
7679 if (__builtin_expect(gc->pc > gc->limit, 0)) {
7680 (void) __glXFlushRenderBuffer(gc, gc->pc);
7681 }
7682 }
7683
7684 #define X_GLrop_ProgramLocalParameter4dvARB 4216
7685 void
7686 __indirect_glProgramLocalParameter4dARB(GLenum target, GLuint index,
7687 GLdouble x, GLdouble y, GLdouble z,
7688 GLdouble w)
7689 {
7690 __GLXcontext *const gc = __glXGetCurrentContext();
7691 const GLuint cmdlen = 44;
7692 emit_header(gc->pc, X_GLrop_ProgramLocalParameter4dvARB, cmdlen);
7693 (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4);
7694 (void) memcpy((void *) (gc->pc + 8), (void *) (&index), 4);
7695 (void) memcpy((void *) (gc->pc + 12), (void *) (&x), 8);
7696 (void) memcpy((void *) (gc->pc + 20), (void *) (&y), 8);
7697 (void) memcpy((void *) (gc->pc + 28), (void *) (&z), 8);
7698 (void) memcpy((void *) (gc->pc + 36), (void *) (&w), 8);
7699 gc->pc += cmdlen;
7700 if (__builtin_expect(gc->pc > gc->limit, 0)) {
7701 (void) __glXFlushRenderBuffer(gc, gc->pc);
7702 }
7703 }
7704
7705 #define X_GLrop_ProgramLocalParameter4dvARB 4216
7706 void
7707 __indirect_glProgramLocalParameter4dvARB(GLenum target, GLuint index,
7708 const GLdouble * params)
7709 {
7710 __GLXcontext *const gc = __glXGetCurrentContext();
7711 const GLuint cmdlen = 44;
7712 emit_header(gc->pc, X_GLrop_ProgramLocalParameter4dvARB, cmdlen);
7713 (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4);
7714 (void) memcpy((void *) (gc->pc + 8), (void *) (&index), 4);
7715 (void) memcpy((void *) (gc->pc + 12), (void *) (params), 32);
7716 gc->pc += cmdlen;
7717 if (__builtin_expect(gc->pc > gc->limit, 0)) {
7718 (void) __glXFlushRenderBuffer(gc, gc->pc);
7719 }
7720 }
7721
7722 #define X_GLrop_ProgramLocalParameter4fvARB 4215
7723 void
7724 __indirect_glProgramLocalParameter4fARB(GLenum target, GLuint index,
7725 GLfloat x, GLfloat y, GLfloat z,
7726 GLfloat w)
7727 {
7728 __GLXcontext *const gc = __glXGetCurrentContext();
7729 const GLuint cmdlen = 28;
7730 emit_header(gc->pc, X_GLrop_ProgramLocalParameter4fvARB, cmdlen);
7731 (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4);
7732 (void) memcpy((void *) (gc->pc + 8), (void *) (&index), 4);
7733 (void) memcpy((void *) (gc->pc + 12), (void *) (&x), 4);
7734 (void) memcpy((void *) (gc->pc + 16), (void *) (&y), 4);
7735 (void) memcpy((void *) (gc->pc + 20), (void *) (&z), 4);
7736 (void) memcpy((void *) (gc->pc + 24), (void *) (&w), 4);
7737 gc->pc += cmdlen;
7738 if (__builtin_expect(gc->pc > gc->limit, 0)) {
7739 (void) __glXFlushRenderBuffer(gc, gc->pc);
7740 }
7741 }
7742
7743 #define X_GLrop_ProgramLocalParameter4fvARB 4215
7744 void
7745 __indirect_glProgramLocalParameter4fvARB(GLenum target, GLuint index,
7746 const GLfloat * params)
7747 {
7748 __GLXcontext *const gc = __glXGetCurrentContext();
7749 const GLuint cmdlen = 28;
7750 emit_header(gc->pc, X_GLrop_ProgramLocalParameter4fvARB, cmdlen);
7751 (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4);
7752 (void) memcpy((void *) (gc->pc + 8), (void *) (&index), 4);
7753 (void) memcpy((void *) (gc->pc + 12), (void *) (params), 16);
7754 gc->pc += cmdlen;
7755 if (__builtin_expect(gc->pc > gc->limit, 0)) {
7756 (void) __glXFlushRenderBuffer(gc, gc->pc);
7757 }
7758 }
7759
7760 #define X_GLrop_ProgramStringARB 4217
7761 void
7762 __indirect_glProgramStringARB(GLenum target, GLenum format, GLsizei len,
7763 const GLvoid * string)
7764 {
7765 __GLXcontext *const gc = __glXGetCurrentContext();
7766 const GLuint cmdlen = 16 + __GLX_PAD(len);
7767 if (len < 0) {
7768 __glXSetError(gc, GL_INVALID_VALUE);
7769 return;
7770 }
7771 if (__builtin_expect((len >= 0) && (gc->currentDpy != NULL), 1)) {
7772 if (cmdlen <= gc->maxSmallRenderCommandSize) {
7773 if ((gc->pc + cmdlen) > gc->bufEnd) {
7774 (void) __glXFlushRenderBuffer(gc, gc->pc);
7775 }
7776 emit_header(gc->pc, X_GLrop_ProgramStringARB, cmdlen);
7777 (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4);
7778 (void) memcpy((void *) (gc->pc + 8), (void *) (&format), 4);
7779 (void) memcpy((void *) (gc->pc + 12), (void *) (&len), 4);
7780 (void) memcpy((void *) (gc->pc + 16), (void *) (string), len);
7781 gc->pc += cmdlen;
7782 if (__builtin_expect(gc->pc > gc->limit, 0)) {
7783 (void) __glXFlushRenderBuffer(gc, gc->pc);
7784 }
7785 } else {
7786 const GLint op = X_GLrop_ProgramStringARB;
7787 const GLuint cmdlenLarge = cmdlen + 4;
7788 GLubyte *const pc = __glXFlushRenderBuffer(gc, gc->pc);
7789 (void) memcpy((void *) (pc + 0), (void *) (&cmdlenLarge), 4);
7790 (void) memcpy((void *) (pc + 4), (void *) (&op), 4);
7791 (void) memcpy((void *) (pc + 8), (void *) (&target), 4);
7792 (void) memcpy((void *) (pc + 12), (void *) (&format), 4);
7793 (void) memcpy((void *) (pc + 16), (void *) (&len), 4);
7794 __glXSendLargeCommand(gc, pc, 20, string, len);
7795 }
7796 }
7797 }
7798
7799 #define X_GLrop_VertexAttrib1dvARB 4197
7800 void
7801 __indirect_glVertexAttrib1dARB(GLuint index, GLdouble x)
7802 {
7803 __GLXcontext *const gc = __glXGetCurrentContext();
7804 const GLuint cmdlen = 16;
7805 emit_header(gc->pc, X_GLrop_VertexAttrib1dvARB, cmdlen);
7806 (void) memcpy((void *) (gc->pc + 4), (void *) (&index), 4);
7807 (void) memcpy((void *) (gc->pc + 8), (void *) (&x), 8);
7808 gc->pc += cmdlen;
7809 if (__builtin_expect(gc->pc > gc->limit, 0)) {
7810 (void) __glXFlushRenderBuffer(gc, gc->pc);
7811 }
7812 }
7813
7814 #define X_GLrop_VertexAttrib1dvARB 4197
7815 void
7816 __indirect_glVertexAttrib1dvARB(GLuint index, const GLdouble * v)
7817 {
7818 __GLXcontext *const gc = __glXGetCurrentContext();
7819 const GLuint cmdlen = 16;
7820 emit_header(gc->pc, X_GLrop_VertexAttrib1dvARB, cmdlen);
7821 (void) memcpy((void *) (gc->pc + 4), (void *) (&index), 4);
7822 (void) memcpy((void *) (gc->pc + 8), (void *) (v), 8);
7823 gc->pc += cmdlen;
7824 if (__builtin_expect(gc->pc > gc->limit, 0)) {
7825 (void) __glXFlushRenderBuffer(gc, gc->pc);
7826 }
7827 }
7828
7829 #define X_GLrop_VertexAttrib1fvARB 4193
7830 void
7831 __indirect_glVertexAttrib1fARB(GLuint index, GLfloat x)
7832 {
7833 __GLXcontext *const gc = __glXGetCurrentContext();
7834 const GLuint cmdlen = 12;
7835 emit_header(gc->pc, X_GLrop_VertexAttrib1fvARB, cmdlen);
7836 (void) memcpy((void *) (gc->pc + 4), (void *) (&index), 4);
7837 (void) memcpy((void *) (gc->pc + 8), (void *) (&x), 4);
7838 gc->pc += cmdlen;
7839 if (__builtin_expect(gc->pc > gc->limit, 0)) {
7840 (void) __glXFlushRenderBuffer(gc, gc->pc);
7841 }
7842 }
7843
7844 #define X_GLrop_VertexAttrib1fvARB 4193
7845 void
7846 __indirect_glVertexAttrib1fvARB(GLuint index, const GLfloat * v)
7847 {
7848 __GLXcontext *const gc = __glXGetCurrentContext();
7849 const GLuint cmdlen = 12;
7850 emit_header(gc->pc, X_GLrop_VertexAttrib1fvARB, cmdlen);
7851 (void) memcpy((void *) (gc->pc + 4), (void *) (&index), 4);
7852 (void) memcpy((void *) (gc->pc + 8), (void *) (v), 4);
7853 gc->pc += cmdlen;
7854 if (__builtin_expect(gc->pc > gc->limit, 0)) {
7855 (void) __glXFlushRenderBuffer(gc, gc->pc);
7856 }
7857 }
7858
7859 #define X_GLrop_VertexAttrib1svARB 4189
7860 void
7861 __indirect_glVertexAttrib1sARB(GLuint index, GLshort x)
7862 {
7863 __GLXcontext *const gc = __glXGetCurrentContext();
7864 const GLuint cmdlen = 12;
7865 emit_header(gc->pc, X_GLrop_VertexAttrib1svARB, cmdlen);
7866 (void) memcpy((void *) (gc->pc + 4), (void *) (&index), 4);
7867 (void) memcpy((void *) (gc->pc + 8), (void *) (&x), 2);
7868 gc->pc += cmdlen;
7869 if (__builtin_expect(gc->pc > gc->limit, 0)) {
7870 (void) __glXFlushRenderBuffer(gc, gc->pc);
7871 }
7872 }
7873
7874 #define X_GLrop_VertexAttrib1svARB 4189
7875 void
7876 __indirect_glVertexAttrib1svARB(GLuint index, const GLshort * v)
7877 {
7878 __GLXcontext *const gc = __glXGetCurrentContext();
7879 const GLuint cmdlen = 12;
7880 emit_header(gc->pc, X_GLrop_VertexAttrib1svARB, cmdlen);
7881 (void) memcpy((void *) (gc->pc + 4), (void *) (&index), 4);
7882 (void) memcpy((void *) (gc->pc + 8), (void *) (v), 2);
7883 gc->pc += cmdlen;
7884 if (__builtin_expect(gc->pc > gc->limit, 0)) {
7885 (void) __glXFlushRenderBuffer(gc, gc->pc);
7886 }
7887 }
7888
7889 #define X_GLrop_VertexAttrib2dvARB 4198
7890 void
7891 __indirect_glVertexAttrib2dARB(GLuint index, GLdouble x, GLdouble y)
7892 {
7893 __GLXcontext *const gc = __glXGetCurrentContext();
7894 const GLuint cmdlen = 24;
7895 emit_header(gc->pc, X_GLrop_VertexAttrib2dvARB, cmdlen);
7896 (void) memcpy((void *) (gc->pc + 4), (void *) (&index), 4);
7897 (void) memcpy((void *) (gc->pc + 8), (void *) (&x), 8);
7898 (void) memcpy((void *) (gc->pc + 16), (void *) (&y), 8);
7899 gc->pc += cmdlen;
7900 if (__builtin_expect(gc->pc > gc->limit, 0)) {
7901 (void) __glXFlushRenderBuffer(gc, gc->pc);
7902 }
7903 }
7904
7905 #define X_GLrop_VertexAttrib2dvARB 4198
7906 void
7907 __indirect_glVertexAttrib2dvARB(GLuint index, const GLdouble * v)
7908 {
7909 __GLXcontext *const gc = __glXGetCurrentContext();
7910 const GLuint cmdlen = 24;
7911 emit_header(gc->pc, X_GLrop_VertexAttrib2dvARB, cmdlen);
7912 (void) memcpy((void *) (gc->pc + 4), (void *) (&index), 4);
7913 (void) memcpy((void *) (gc->pc + 8), (void *) (v), 16);
7914 gc->pc += cmdlen;
7915 if (__builtin_expect(gc->pc > gc->limit, 0)) {
7916 (void) __glXFlushRenderBuffer(gc, gc->pc);
7917 }
7918 }
7919
7920 #define X_GLrop_VertexAttrib2fvARB 4194
7921 void
7922 __indirect_glVertexAttrib2fARB(GLuint index, GLfloat x, GLfloat y)
7923 {
7924 __GLXcontext *const gc = __glXGetCurrentContext();
7925 const GLuint cmdlen = 16;
7926 emit_header(gc->pc, X_GLrop_VertexAttrib2fvARB, cmdlen);
7927 (void) memcpy((void *) (gc->pc + 4), (void *) (&index), 4);
7928 (void) memcpy((void *) (gc->pc + 8), (void *) (&x), 4);
7929 (void) memcpy((void *) (gc->pc + 12), (void *) (&y), 4);
7930 gc->pc += cmdlen;
7931 if (__builtin_expect(gc->pc > gc->limit, 0)) {
7932 (void) __glXFlushRenderBuffer(gc, gc->pc);
7933 }
7934 }
7935
7936 #define X_GLrop_VertexAttrib2fvARB 4194
7937 void
7938 __indirect_glVertexAttrib2fvARB(GLuint index, const GLfloat * v)
7939 {
7940 __GLXcontext *const gc = __glXGetCurrentContext();
7941 const GLuint cmdlen = 16;
7942 emit_header(gc->pc, X_GLrop_VertexAttrib2fvARB, cmdlen);
7943 (void) memcpy((void *) (gc->pc + 4), (void *) (&index), 4);
7944 (void) memcpy((void *) (gc->pc + 8), (void *) (v), 8);
7945 gc->pc += cmdlen;
7946 if (__builtin_expect(gc->pc > gc->limit, 0)) {
7947 (void) __glXFlushRenderBuffer(gc, gc->pc);
7948 }
7949 }
7950
7951 #define X_GLrop_VertexAttrib2svARB 4190
7952 void
7953 __indirect_glVertexAttrib2sARB(GLuint index, GLshort x, GLshort y)
7954 {
7955 __GLXcontext *const gc = __glXGetCurrentContext();
7956 const GLuint cmdlen = 12;
7957 emit_header(gc->pc, X_GLrop_VertexAttrib2svARB, cmdlen);
7958 (void) memcpy((void *) (gc->pc + 4), (void *) (&index), 4);
7959 (void) memcpy((void *) (gc->pc + 8), (void *) (&x), 2);
7960 (void) memcpy((void *) (gc->pc + 10), (void *) (&y), 2);
7961 gc->pc += cmdlen;
7962 if (__builtin_expect(gc->pc > gc->limit, 0)) {
7963 (void) __glXFlushRenderBuffer(gc, gc->pc);
7964 }
7965 }
7966
7967 #define X_GLrop_VertexAttrib2svARB 4190
7968 void
7969 __indirect_glVertexAttrib2svARB(GLuint index, const GLshort * v)
7970 {
7971 __GLXcontext *const gc = __glXGetCurrentContext();
7972 const GLuint cmdlen = 12;
7973 emit_header(gc->pc, X_GLrop_VertexAttrib2svARB, cmdlen);
7974 (void) memcpy((void *) (gc->pc + 4), (void *) (&index), 4);
7975 (void) memcpy((void *) (gc->pc + 8), (void *) (v), 4);
7976 gc->pc += cmdlen;
7977 if (__builtin_expect(gc->pc > gc->limit, 0)) {
7978 (void) __glXFlushRenderBuffer(gc, gc->pc);
7979 }
7980 }
7981
7982 #define X_GLrop_VertexAttrib3dvARB 4199
7983 void
7984 __indirect_glVertexAttrib3dARB(GLuint index, GLdouble x, GLdouble y,
7985 GLdouble z)
7986 {
7987 __GLXcontext *const gc = __glXGetCurrentContext();
7988 const GLuint cmdlen = 32;
7989 emit_header(gc->pc, X_GLrop_VertexAttrib3dvARB, cmdlen);
7990 (void) memcpy((void *) (gc->pc + 4), (void *) (&index), 4);
7991 (void) memcpy((void *) (gc->pc + 8), (void *) (&x), 8);
7992 (void) memcpy((void *) (gc->pc + 16), (void *) (&y), 8);
7993 (void) memcpy((void *) (gc->pc + 24), (void *) (&z), 8);
7994 gc->pc += cmdlen;
7995 if (__builtin_expect(gc->pc > gc->limit, 0)) {
7996 (void) __glXFlushRenderBuffer(gc, gc->pc);
7997 }
7998 }
7999
8000 #define X_GLrop_VertexAttrib3dvARB 4199
8001 void
8002 __indirect_glVertexAttrib3dvARB(GLuint index, const GLdouble * v)
8003 {
8004 __GLXcontext *const gc = __glXGetCurrentContext();
8005 const GLuint cmdlen = 32;
8006 emit_header(gc->pc, X_GLrop_VertexAttrib3dvARB, cmdlen);
8007 (void) memcpy((void *) (gc->pc + 4), (void *) (&index), 4);
8008 (void) memcpy((void *) (gc->pc + 8), (void *) (v), 24);
8009 gc->pc += cmdlen;
8010 if (__builtin_expect(gc->pc > gc->limit, 0)) {
8011 (void) __glXFlushRenderBuffer(gc, gc->pc);
8012 }
8013 }
8014
8015 #define X_GLrop_VertexAttrib3fvARB 4195
8016 void
8017 __indirect_glVertexAttrib3fARB(GLuint index, GLfloat x, GLfloat y, GLfloat z)
8018 {
8019 __GLXcontext *const gc = __glXGetCurrentContext();
8020 const GLuint cmdlen = 20;
8021 emit_header(gc->pc, X_GLrop_VertexAttrib3fvARB, cmdlen);
8022 (void) memcpy((void *) (gc->pc + 4), (void *) (&index), 4);
8023 (void) memcpy((void *) (gc->pc + 8), (void *) (&x), 4);
8024 (void) memcpy((void *) (gc->pc + 12), (void *) (&y), 4);
8025 (void) memcpy((void *) (gc->pc + 16), (void *) (&z), 4);
8026 gc->pc += cmdlen;
8027 if (__builtin_expect(gc->pc > gc->limit, 0)) {
8028 (void) __glXFlushRenderBuffer(gc, gc->pc);
8029 }
8030 }
8031
8032 #define X_GLrop_VertexAttrib3fvARB 4195
8033 void
8034 __indirect_glVertexAttrib3fvARB(GLuint index, const GLfloat * v)
8035 {
8036 __GLXcontext *const gc = __glXGetCurrentContext();
8037 const GLuint cmdlen = 20;
8038 emit_header(gc->pc, X_GLrop_VertexAttrib3fvARB, cmdlen);
8039 (void) memcpy((void *) (gc->pc + 4), (void *) (&index), 4);
8040 (void) memcpy((void *) (gc->pc + 8), (void *) (v), 12);
8041 gc->pc += cmdlen;
8042 if (__builtin_expect(gc->pc > gc->limit, 0)) {
8043 (void) __glXFlushRenderBuffer(gc, gc->pc);
8044 }
8045 }
8046
8047 #define X_GLrop_VertexAttrib3svARB 4191
8048 void
8049 __indirect_glVertexAttrib3sARB(GLuint index, GLshort x, GLshort y, GLshort z)
8050 {
8051 __GLXcontext *const gc = __glXGetCurrentContext();
8052 const GLuint cmdlen = 16;
8053 emit_header(gc->pc, X_GLrop_VertexAttrib3svARB, cmdlen);
8054 (void) memcpy((void *) (gc->pc + 4), (void *) (&index), 4);
8055 (void) memcpy((void *) (gc->pc + 8), (void *) (&x), 2);
8056 (void) memcpy((void *) (gc->pc + 10), (void *) (&y), 2);
8057 (void) memcpy((void *) (gc->pc + 12), (void *) (&z), 2);
8058 gc->pc += cmdlen;
8059 if (__builtin_expect(gc->pc > gc->limit, 0)) {
8060 (void) __glXFlushRenderBuffer(gc, gc->pc);
8061 }
8062 }
8063
8064 #define X_GLrop_VertexAttrib3svARB 4191
8065 void
8066 __indirect_glVertexAttrib3svARB(GLuint index, const GLshort * v)
8067 {
8068 __GLXcontext *const gc = __glXGetCurrentContext();
8069 const GLuint cmdlen = 16;
8070 emit_header(gc->pc, X_GLrop_VertexAttrib3svARB, cmdlen);
8071 (void) memcpy((void *) (gc->pc + 4), (void *) (&index), 4);
8072 (void) memcpy((void *) (gc->pc + 8), (void *) (v), 6);
8073 gc->pc += cmdlen;
8074 if (__builtin_expect(gc->pc > gc->limit, 0)) {
8075 (void) __glXFlushRenderBuffer(gc, gc->pc);
8076 }
8077 }
8078
8079 #define X_GLrop_VertexAttrib4NbvARB 4235
8080 void
8081 __indirect_glVertexAttrib4NbvARB(GLuint index, const GLbyte *v)
8082 {
8083 __GLXcontext *const gc = __glXGetCurrentContext();
8084 const GLuint cmdlen = 12;
8085 emit_header(gc->pc, X_GLrop_VertexAttrib4NbvARB, cmdlen);
8086 (void) memcpy((void *) (gc->pc + 4), (void *) (&index), 4);
8087 (void) memcpy((void *) (gc->pc + 8), (void *) (v), 4);
8088 gc->pc += cmdlen;
8089 if (__builtin_expect(gc->pc > gc->limit, 0)) {
8090 (void) __glXFlushRenderBuffer(gc, gc->pc);
8091 }
8092 }
8093
8094 #define X_GLrop_VertexAttrib4NivARB 4237
8095 void
8096 __indirect_glVertexAttrib4NivARB(GLuint index, const GLint * v)
8097 {
8098 __GLXcontext *const gc = __glXGetCurrentContext();
8099 const GLuint cmdlen = 24;
8100 emit_header(gc->pc, X_GLrop_VertexAttrib4NivARB, cmdlen);
8101 (void) memcpy((void *) (gc->pc + 4), (void *) (&index), 4);
8102 (void) memcpy((void *) (gc->pc + 8), (void *) (v), 16);
8103 gc->pc += cmdlen;
8104 if (__builtin_expect(gc->pc > gc->limit, 0)) {
8105 (void) __glXFlushRenderBuffer(gc, gc->pc);
8106 }
8107 }
8108
8109 #define X_GLrop_VertexAttrib4NsvARB 4236
8110 void
8111 __indirect_glVertexAttrib4NsvARB(GLuint index, const GLshort * v)
8112 {
8113 __GLXcontext *const gc = __glXGetCurrentContext();
8114 const GLuint cmdlen = 16;
8115 emit_header(gc->pc, X_GLrop_VertexAttrib4NsvARB, cmdlen);
8116 (void) memcpy((void *) (gc->pc + 4), (void *) (&index), 4);
8117 (void) memcpy((void *) (gc->pc + 8), (void *) (v), 8);
8118 gc->pc += cmdlen;
8119 if (__builtin_expect(gc->pc > gc->limit, 0)) {
8120 (void) __glXFlushRenderBuffer(gc, gc->pc);
8121 }
8122 }
8123
8124 #define X_GLrop_VertexAttrib4NubvARB 4201
8125 void
8126 __indirect_glVertexAttrib4NubARB(GLuint index, GLubyte x, GLubyte y,
8127 GLubyte z, GLubyte w)
8128 {
8129 __GLXcontext *const gc = __glXGetCurrentContext();
8130 const GLuint cmdlen = 12;
8131 emit_header(gc->pc, X_GLrop_VertexAttrib4NubvARB, cmdlen);
8132 (void) memcpy((void *) (gc->pc + 4), (void *) (&index), 4);
8133 (void) memcpy((void *) (gc->pc + 8), (void *) (&x), 1);
8134 (void) memcpy((void *) (gc->pc + 9), (void *) (&y), 1);
8135 (void) memcpy((void *) (gc->pc + 10), (void *) (&z), 1);
8136 (void) memcpy((void *) (gc->pc + 11), (void *) (&w), 1);
8137 gc->pc += cmdlen;
8138 if (__builtin_expect(gc->pc > gc->limit, 0)) {
8139 (void) __glXFlushRenderBuffer(gc, gc->pc);
8140 }
8141 }
8142
8143 #define X_GLrop_VertexAttrib4NubvARB 4201
8144 void
8145 __indirect_glVertexAttrib4NubvARB(GLuint index, const GLubyte *v)
8146 {
8147 __GLXcontext *const gc = __glXGetCurrentContext();
8148 const GLuint cmdlen = 12;
8149 emit_header(gc->pc, X_GLrop_VertexAttrib4NubvARB, cmdlen);
8150 (void) memcpy((void *) (gc->pc + 4), (void *) (&index), 4);
8151 (void) memcpy((void *) (gc->pc + 8), (void *) (v), 4);
8152 gc->pc += cmdlen;
8153 if (__builtin_expect(gc->pc > gc->limit, 0)) {
8154 (void) __glXFlushRenderBuffer(gc, gc->pc);
8155 }
8156 }
8157
8158 #define X_GLrop_VertexAttrib4NuivARB 4239
8159 void
8160 __indirect_glVertexAttrib4NuivARB(GLuint index, const GLuint * v)
8161 {
8162 __GLXcontext *const gc = __glXGetCurrentContext();
8163 const GLuint cmdlen = 24;
8164 emit_header(gc->pc, X_GLrop_VertexAttrib4NuivARB, cmdlen);
8165 (void) memcpy((void *) (gc->pc + 4), (void *) (&index), 4);
8166 (void) memcpy((void *) (gc->pc + 8), (void *) (v), 16);
8167 gc->pc += cmdlen;
8168 if (__builtin_expect(gc->pc > gc->limit, 0)) {
8169 (void) __glXFlushRenderBuffer(gc, gc->pc);
8170 }
8171 }
8172
8173 #define X_GLrop_VertexAttrib4NusvARB 4238
8174 void
8175 __indirect_glVertexAttrib4NusvARB(GLuint index, const GLushort * v)
8176 {
8177 __GLXcontext *const gc = __glXGetCurrentContext();
8178 const GLuint cmdlen = 16;
8179 emit_header(gc->pc, X_GLrop_VertexAttrib4NusvARB, cmdlen);
8180 (void) memcpy((void *) (gc->pc + 4), (void *) (&index), 4);
8181 (void) memcpy((void *) (gc->pc + 8), (void *) (v), 8);
8182 gc->pc += cmdlen;
8183 if (__builtin_expect(gc->pc > gc->limit, 0)) {
8184 (void) __glXFlushRenderBuffer(gc, gc->pc);
8185 }
8186 }
8187
8188 #define X_GLrop_VertexAttrib4bvARB 4230
8189 void
8190 __indirect_glVertexAttrib4bvARB(GLuint index, const GLbyte *v)
8191 {
8192 __GLXcontext *const gc = __glXGetCurrentContext();
8193 const GLuint cmdlen = 12;
8194 emit_header(gc->pc, X_GLrop_VertexAttrib4bvARB, cmdlen);
8195 (void) memcpy((void *) (gc->pc + 4), (void *) (&index), 4);
8196 (void) memcpy((void *) (gc->pc + 8), (void *) (v), 4);
8197 gc->pc += cmdlen;
8198 if (__builtin_expect(gc->pc > gc->limit, 0)) {
8199 (void) __glXFlushRenderBuffer(gc, gc->pc);
8200 }
8201 }
8202
8203 #define X_GLrop_VertexAttrib4dvARB 4200
8204 void
8205 __indirect_glVertexAttrib4dARB(GLuint index, GLdouble x, GLdouble y,
8206 GLdouble z, GLdouble w)
8207 {
8208 __GLXcontext *const gc = __glXGetCurrentContext();
8209 const GLuint cmdlen = 40;
8210 emit_header(gc->pc, X_GLrop_VertexAttrib4dvARB, cmdlen);
8211 (void) memcpy((void *) (gc->pc + 4), (void *) (&index), 4);
8212 (void) memcpy((void *) (gc->pc + 8), (void *) (&x), 8);
8213 (void) memcpy((void *) (gc->pc + 16), (void *) (&y), 8);
8214 (void) memcpy((void *) (gc->pc + 24), (void *) (&z), 8);
8215 (void) memcpy((void *) (gc->pc + 32), (void *) (&w), 8);
8216 gc->pc += cmdlen;
8217 if (__builtin_expect(gc->pc > gc->limit, 0)) {
8218 (void) __glXFlushRenderBuffer(gc, gc->pc);
8219 }
8220 }
8221
8222 #define X_GLrop_VertexAttrib4dvARB 4200
8223 void
8224 __indirect_glVertexAttrib4dvARB(GLuint index, const GLdouble * v)
8225 {
8226 __GLXcontext *const gc = __glXGetCurrentContext();
8227 const GLuint cmdlen = 40;
8228 emit_header(gc->pc, X_GLrop_VertexAttrib4dvARB, cmdlen);
8229 (void) memcpy((void *) (gc->pc + 4), (void *) (&index), 4);
8230 (void) memcpy((void *) (gc->pc + 8), (void *) (v), 32);
8231 gc->pc += cmdlen;
8232 if (__builtin_expect(gc->pc > gc->limit, 0)) {
8233 (void) __glXFlushRenderBuffer(gc, gc->pc);
8234 }
8235 }
8236
8237 #define X_GLrop_VertexAttrib4fvARB 4196
8238 void
8239 __indirect_glVertexAttrib4fARB(GLuint index, GLfloat x, GLfloat y, GLfloat z,
8240 GLfloat w)
8241 {
8242 __GLXcontext *const gc = __glXGetCurrentContext();
8243 const GLuint cmdlen = 24;
8244 emit_header(gc->pc, X_GLrop_VertexAttrib4fvARB, cmdlen);
8245 (void) memcpy((void *) (gc->pc + 4), (void *) (&index), 4);
8246 (void) memcpy((void *) (gc->pc + 8), (void *) (&x), 4);
8247 (void) memcpy((void *) (gc->pc + 12), (void *) (&y), 4);
8248 (void) memcpy((void *) (gc->pc + 16), (void *) (&z), 4);
8249 (void) memcpy((void *) (gc->pc + 20), (void *) (&w), 4);
8250 gc->pc += cmdlen;
8251 if (__builtin_expect(gc->pc > gc->limit, 0)) {
8252 (void) __glXFlushRenderBuffer(gc, gc->pc);
8253 }
8254 }
8255
8256 #define X_GLrop_VertexAttrib4fvARB 4196
8257 void
8258 __indirect_glVertexAttrib4fvARB(GLuint index, const GLfloat * v)
8259 {
8260 __GLXcontext *const gc = __glXGetCurrentContext();
8261 const GLuint cmdlen = 24;
8262 emit_header(gc->pc, X_GLrop_VertexAttrib4fvARB, cmdlen);
8263 (void) memcpy((void *) (gc->pc + 4), (void *) (&index), 4);
8264 (void) memcpy((void *) (gc->pc + 8), (void *) (v), 16);
8265 gc->pc += cmdlen;
8266 if (__builtin_expect(gc->pc > gc->limit, 0)) {
8267 (void) __glXFlushRenderBuffer(gc, gc->pc);
8268 }
8269 }
8270
8271 #define X_GLrop_VertexAttrib4ivARB 4231
8272 void
8273 __indirect_glVertexAttrib4ivARB(GLuint index, const GLint * v)
8274 {
8275 __GLXcontext *const gc = __glXGetCurrentContext();
8276 const GLuint cmdlen = 24;
8277 emit_header(gc->pc, X_GLrop_VertexAttrib4ivARB, cmdlen);
8278 (void) memcpy((void *) (gc->pc + 4), (void *) (&index), 4);
8279 (void) memcpy((void *) (gc->pc + 8), (void *) (v), 16);
8280 gc->pc += cmdlen;
8281 if (__builtin_expect(gc->pc > gc->limit, 0)) {
8282 (void) __glXFlushRenderBuffer(gc, gc->pc);
8283 }
8284 }
8285
8286 #define X_GLrop_VertexAttrib4svARB 4192
8287 void
8288 __indirect_glVertexAttrib4sARB(GLuint index, GLshort x, GLshort y, GLshort z,
8289 GLshort w)
8290 {
8291 __GLXcontext *const gc = __glXGetCurrentContext();
8292 const GLuint cmdlen = 16;
8293 emit_header(gc->pc, X_GLrop_VertexAttrib4svARB, cmdlen);
8294 (void) memcpy((void *) (gc->pc + 4), (void *) (&index), 4);
8295 (void) memcpy((void *) (gc->pc + 8), (void *) (&x), 2);
8296 (void) memcpy((void *) (gc->pc + 10), (void *) (&y), 2);
8297 (void) memcpy((void *) (gc->pc + 12), (void *) (&z), 2);
8298 (void) memcpy((void *) (gc->pc + 14), (void *) (&w), 2);
8299 gc->pc += cmdlen;
8300 if (__builtin_expect(gc->pc > gc->limit, 0)) {
8301 (void) __glXFlushRenderBuffer(gc, gc->pc);
8302 }
8303 }
8304
8305 #define X_GLrop_VertexAttrib4svARB 4192
8306 void
8307 __indirect_glVertexAttrib4svARB(GLuint index, const GLshort * v)
8308 {
8309 __GLXcontext *const gc = __glXGetCurrentContext();
8310 const GLuint cmdlen = 16;
8311 emit_header(gc->pc, X_GLrop_VertexAttrib4svARB, cmdlen);
8312 (void) memcpy((void *) (gc->pc + 4), (void *) (&index), 4);
8313 (void) memcpy((void *) (gc->pc + 8), (void *) (v), 8);
8314 gc->pc += cmdlen;
8315 if (__builtin_expect(gc->pc > gc->limit, 0)) {
8316 (void) __glXFlushRenderBuffer(gc, gc->pc);
8317 }
8318 }
8319
8320 #define X_GLrop_VertexAttrib4ubvARB 4232
8321 void
8322 __indirect_glVertexAttrib4ubvARB(GLuint index, const GLubyte *v)
8323 {
8324 __GLXcontext *const gc = __glXGetCurrentContext();
8325 const GLuint cmdlen = 12;
8326 emit_header(gc->pc, X_GLrop_VertexAttrib4ubvARB, cmdlen);
8327 (void) memcpy((void *) (gc->pc + 4), (void *) (&index), 4);
8328 (void) memcpy((void *) (gc->pc + 8), (void *) (v), 4);
8329 gc->pc += cmdlen;
8330 if (__builtin_expect(gc->pc > gc->limit, 0)) {
8331 (void) __glXFlushRenderBuffer(gc, gc->pc);
8332 }
8333 }
8334
8335 #define X_GLrop_VertexAttrib4uivARB 4234
8336 void
8337 __indirect_glVertexAttrib4uivARB(GLuint index, const GLuint * v)
8338 {
8339 __GLXcontext *const gc = __glXGetCurrentContext();
8340 const GLuint cmdlen = 24;
8341 emit_header(gc->pc, X_GLrop_VertexAttrib4uivARB, cmdlen);
8342 (void) memcpy((void *) (gc->pc + 4), (void *) (&index), 4);
8343 (void) memcpy((void *) (gc->pc + 8), (void *) (v), 16);
8344 gc->pc += cmdlen;
8345 if (__builtin_expect(gc->pc > gc->limit, 0)) {
8346 (void) __glXFlushRenderBuffer(gc, gc->pc);
8347 }
8348 }
8349
8350 #define X_GLrop_VertexAttrib4usvARB 4233
8351 void
8352 __indirect_glVertexAttrib4usvARB(GLuint index, const GLushort * v)
8353 {
8354 __GLXcontext *const gc = __glXGetCurrentContext();
8355 const GLuint cmdlen = 16;
8356 emit_header(gc->pc, X_GLrop_VertexAttrib4usvARB, cmdlen);
8357 (void) memcpy((void *) (gc->pc + 4), (void *) (&index), 4);
8358 (void) memcpy((void *) (gc->pc + 8), (void *) (v), 8);
8359 gc->pc += cmdlen;
8360 if (__builtin_expect(gc->pc > gc->limit, 0)) {
8361 (void) __glXFlushRenderBuffer(gc, gc->pc);
8362 }
8363 }
8364
8365 #define X_GLrop_BeginQueryARB 231
8366 void
8367 __indirect_glBeginQueryARB(GLenum target, GLuint id)
8368 {
8369 __GLXcontext *const gc = __glXGetCurrentContext();
8370 const GLuint cmdlen = 12;
8371 emit_header(gc->pc, X_GLrop_BeginQueryARB, cmdlen);
8372 (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4);
8373 (void) memcpy((void *) (gc->pc + 8), (void *) (&id), 4);
8374 gc->pc += cmdlen;
8375 if (__builtin_expect(gc->pc > gc->limit, 0)) {
8376 (void) __glXFlushRenderBuffer(gc, gc->pc);
8377 }
8378 }
8379
8380 #define X_GLsop_DeleteQueriesARB 161
8381 void
8382 __indirect_glDeleteQueriesARB(GLsizei n, const GLuint * ids)
8383 {
8384 __GLXcontext *const gc = __glXGetCurrentContext();
8385 Display *const dpy = gc->currentDpy;
8386 #ifndef USE_XCB
8387 const GLuint cmdlen = 4 + __GLX_PAD((n * 4));
8388 #endif
8389 if (n < 0) {
8390 __glXSetError(gc, GL_INVALID_VALUE);
8391 return;
8392 }
8393 if (__builtin_expect((n >= 0) && (dpy != NULL), 1)) {
8394 #ifdef USE_XCB
8395 xcb_connection_t *c = XGetXCBConnection(dpy);
8396 (void) __glXFlushRenderBuffer(gc, gc->pc);
8397 xcb_glx_delete_queries_arb(c, gc->currentContextTag, n, ids);
8398 #else
8399 GLubyte const *pc =
8400 __glXSetupSingleRequest(gc, X_GLsop_DeleteQueriesARB, cmdlen);
8401 (void) memcpy((void *) (pc + 0), (void *) (&n), 4);
8402 (void) memcpy((void *) (pc + 4), (void *) (ids), (n * 4));
8403 UnlockDisplay(dpy);
8404 SyncHandle();
8405 #endif /* USE_XCB */
8406 }
8407 return;
8408 }
8409
8410 #define X_GLrop_EndQueryARB 232
8411 void
8412 __indirect_glEndQueryARB(GLenum target)
8413 {
8414 __GLXcontext *const gc = __glXGetCurrentContext();
8415 const GLuint cmdlen = 8;
8416 emit_header(gc->pc, X_GLrop_EndQueryARB, cmdlen);
8417 (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4);
8418 gc->pc += cmdlen;
8419 if (__builtin_expect(gc->pc > gc->limit, 0)) {
8420 (void) __glXFlushRenderBuffer(gc, gc->pc);
8421 }
8422 }
8423
8424 #define X_GLsop_GenQueriesARB 162
8425 void
8426 __indirect_glGenQueriesARB(GLsizei n, GLuint * ids)
8427 {
8428 __GLXcontext *const gc = __glXGetCurrentContext();
8429 Display *const dpy = gc->currentDpy;
8430 #ifndef USE_XCB
8431 const GLuint cmdlen = 4;
8432 #endif
8433 if (n < 0) {
8434 __glXSetError(gc, GL_INVALID_VALUE);
8435 return;
8436 }
8437 if (__builtin_expect((n >= 0) && (dpy != NULL), 1)) {
8438 #ifdef USE_XCB
8439 xcb_connection_t *c = XGetXCBConnection(dpy);
8440 (void) __glXFlushRenderBuffer(gc, gc->pc);
8441 xcb_glx_gen_queries_arb_reply_t *reply =
8442 xcb_glx_gen_queries_arb_reply(c,
8443 xcb_glx_gen_queries_arb(c,
8444 gc->
8445 currentContextTag,
8446 n), NULL);
8447 (void) memcpy(ids, xcb_glx_gen_queries_arb_data(reply),
8448 xcb_glx_gen_queries_arb_data_length(reply) *
8449 sizeof(GLuint));
8450 free(reply);
8451 #else
8452 GLubyte const *pc =
8453 __glXSetupSingleRequest(gc, X_GLsop_GenQueriesARB, cmdlen);
8454 (void) memcpy((void *) (pc + 0), (void *) (&n), 4);
8455 (void) __glXReadReply(dpy, 4, ids, GL_TRUE);
8456 UnlockDisplay(dpy);
8457 SyncHandle();
8458 #endif /* USE_XCB */
8459 }
8460 return;
8461 }
8462
8463 #define X_GLsop_GetQueryObjectivARB 165
8464 void
8465 __indirect_glGetQueryObjectivARB(GLuint id, GLenum pname, GLint * params)
8466 {
8467 __GLXcontext *const gc = __glXGetCurrentContext();
8468 Display *const dpy = gc->currentDpy;
8469 #ifndef USE_XCB
8470 const GLuint cmdlen = 8;
8471 #endif
8472 if (__builtin_expect(dpy != NULL, 1)) {
8473 #ifdef USE_XCB
8474 xcb_connection_t *c = XGetXCBConnection(dpy);
8475 (void) __glXFlushRenderBuffer(gc, gc->pc);
8476 xcb_glx_get_query_objectiv_arb_reply_t *reply =
8477 xcb_glx_get_query_objectiv_arb_reply(c,
8478 xcb_glx_get_query_objectiv_arb
8479 (c, gc->currentContextTag,
8480 id, pname), NULL);
8481 if (xcb_glx_get_query_objectiv_arb_data_length(reply) == 0)
8482 (void) memcpy(params, &reply->datum, sizeof(reply->datum));
8483 else
8484 (void) memcpy(params, xcb_glx_get_query_objectiv_arb_data(reply),
8485 xcb_glx_get_query_objectiv_arb_data_length(reply) *
8486 sizeof(GLint));
8487 free(reply);
8488 #else
8489 GLubyte const *pc =
8490 __glXSetupSingleRequest(gc, X_GLsop_GetQueryObjectivARB, cmdlen);
8491 (void) memcpy((void *) (pc + 0), (void *) (&id), 4);
8492 (void) memcpy((void *) (pc + 4), (void *) (&pname), 4);
8493 (void) __glXReadReply(dpy, 4, params, GL_FALSE);
8494 UnlockDisplay(dpy);
8495 SyncHandle();
8496 #endif /* USE_XCB */
8497 }
8498 return;
8499 }
8500
8501 #define X_GLsop_GetQueryObjectuivARB 166
8502 void
8503 __indirect_glGetQueryObjectuivARB(GLuint id, GLenum pname, GLuint * params)
8504 {
8505 __GLXcontext *const gc = __glXGetCurrentContext();
8506 Display *const dpy = gc->currentDpy;
8507 #ifndef USE_XCB
8508 const GLuint cmdlen = 8;
8509 #endif
8510 if (__builtin_expect(dpy != NULL, 1)) {
8511 #ifdef USE_XCB
8512 xcb_connection_t *c = XGetXCBConnection(dpy);
8513 (void) __glXFlushRenderBuffer(gc, gc->pc);
8514 xcb_glx_get_query_objectuiv_arb_reply_t *reply =
8515 xcb_glx_get_query_objectuiv_arb_reply(c,
8516 xcb_glx_get_query_objectuiv_arb
8517 (c, gc->currentContextTag,
8518 id, pname), NULL);
8519 if (xcb_glx_get_query_objectuiv_arb_data_length(reply) == 0)
8520 (void) memcpy(params, &reply->datum, sizeof(reply->datum));
8521 else
8522 (void) memcpy(params, xcb_glx_get_query_objectuiv_arb_data(reply),
8523 xcb_glx_get_query_objectuiv_arb_data_length(reply) *
8524 sizeof(GLuint));
8525 free(reply);
8526 #else
8527 GLubyte const *pc =
8528 __glXSetupSingleRequest(gc, X_GLsop_GetQueryObjectuivARB, cmdlen);
8529 (void) memcpy((void *) (pc + 0), (void *) (&id), 4);
8530 (void) memcpy((void *) (pc + 4), (void *) (&pname), 4);
8531 (void) __glXReadReply(dpy, 4, params, GL_FALSE);
8532 UnlockDisplay(dpy);
8533 SyncHandle();
8534 #endif /* USE_XCB */
8535 }
8536 return;
8537 }
8538
8539 #define X_GLsop_GetQueryivARB 164
8540 void
8541 __indirect_glGetQueryivARB(GLenum target, GLenum pname, GLint * params)
8542 {
8543 __GLXcontext *const gc = __glXGetCurrentContext();
8544 Display *const dpy = gc->currentDpy;
8545 #ifndef USE_XCB
8546 const GLuint cmdlen = 8;
8547 #endif
8548 if (__builtin_expect(dpy != NULL, 1)) {
8549 #ifdef USE_XCB
8550 xcb_connection_t *c = XGetXCBConnection(dpy);
8551 (void) __glXFlushRenderBuffer(gc, gc->pc);
8552 xcb_glx_get_queryiv_arb_reply_t *reply =
8553 xcb_glx_get_queryiv_arb_reply(c,
8554 xcb_glx_get_queryiv_arb(c,
8555 gc->
8556 currentContextTag,
8557 target,
8558 pname),
8559 NULL);
8560 if (xcb_glx_get_queryiv_arb_data_length(reply) == 0)
8561 (void) memcpy(params, &reply->datum, sizeof(reply->datum));
8562 else
8563 (void) memcpy(params, xcb_glx_get_queryiv_arb_data(reply),
8564 xcb_glx_get_queryiv_arb_data_length(reply) *
8565 sizeof(GLint));
8566 free(reply);
8567 #else
8568 GLubyte const *pc =
8569 __glXSetupSingleRequest(gc, X_GLsop_GetQueryivARB, cmdlen);
8570 (void) memcpy((void *) (pc + 0), (void *) (&target), 4);
8571 (void) memcpy((void *) (pc + 4), (void *) (&pname), 4);
8572 (void) __glXReadReply(dpy, 4, params, GL_FALSE);
8573 UnlockDisplay(dpy);
8574 SyncHandle();
8575 #endif /* USE_XCB */
8576 }
8577 return;
8578 }
8579
8580 #define X_GLsop_IsQueryARB 163
8581 GLboolean
8582 __indirect_glIsQueryARB(GLuint id)
8583 {
8584 __GLXcontext *const gc = __glXGetCurrentContext();
8585 Display *const dpy = gc->currentDpy;
8586 GLboolean retval = (GLboolean) 0;
8587 #ifndef USE_XCB
8588 const GLuint cmdlen = 4;
8589 #endif
8590 if (__builtin_expect(dpy != NULL, 1)) {
8591 #ifdef USE_XCB
8592 xcb_connection_t *c = XGetXCBConnection(dpy);
8593 (void) __glXFlushRenderBuffer(gc, gc->pc);
8594 xcb_glx_is_query_arb_reply_t *reply =
8595 xcb_glx_is_query_arb_reply(c,
8596 xcb_glx_is_query_arb(c,
8597 gc->
8598 currentContextTag,
8599 id), NULL);
8600 retval = reply->ret_val;
8601 free(reply);
8602 #else
8603 GLubyte const *pc =
8604 __glXSetupSingleRequest(gc, X_GLsop_IsQueryARB, cmdlen);
8605 (void) memcpy((void *) (pc + 0), (void *) (&id), 4);
8606 retval = (GLboolean) __glXReadReply(dpy, 0, NULL, GL_FALSE);
8607 UnlockDisplay(dpy);
8608 SyncHandle();
8609 #endif /* USE_XCB */
8610 }
8611 return retval;
8612 }
8613
8614 #define X_GLrop_DrawBuffersARB 233
8615 void
8616 __indirect_glDrawBuffersARB(GLsizei n, const GLenum * bufs)
8617 {
8618 __GLXcontext *const gc = __glXGetCurrentContext();
8619 const GLuint cmdlen = 8 + __GLX_PAD((n * 4));
8620 if (n < 0) {
8621 __glXSetError(gc, GL_INVALID_VALUE);
8622 return;
8623 }
8624 if (__builtin_expect((n >= 0) && (gc->currentDpy != NULL), 1)) {
8625 if (cmdlen <= gc->maxSmallRenderCommandSize) {
8626 if ((gc->pc + cmdlen) > gc->bufEnd) {
8627 (void) __glXFlushRenderBuffer(gc, gc->pc);
8628 }
8629 emit_header(gc->pc, X_GLrop_DrawBuffersARB, cmdlen);
8630 (void) memcpy((void *) (gc->pc + 4), (void *) (&n), 4);
8631 (void) memcpy((void *) (gc->pc + 8), (void *) (bufs), (n * 4));
8632 gc->pc += cmdlen;
8633 if (__builtin_expect(gc->pc > gc->limit, 0)) {
8634 (void) __glXFlushRenderBuffer(gc, gc->pc);
8635 }
8636 } else {
8637 const GLint op = X_GLrop_DrawBuffersARB;
8638 const GLuint cmdlenLarge = cmdlen + 4;
8639 GLubyte *const pc = __glXFlushRenderBuffer(gc, gc->pc);
8640 (void) memcpy((void *) (pc + 0), (void *) (&cmdlenLarge), 4);
8641 (void) memcpy((void *) (pc + 4), (void *) (&op), 4);
8642 (void) memcpy((void *) (pc + 8), (void *) (&n), 4);
8643 __glXSendLargeCommand(gc, pc, 12, bufs, (n * 4));
8644 }
8645 }
8646 }
8647
8648 #define X_GLrop_SampleMaskSGIS 2048
8649 void
8650 __indirect_glSampleMaskSGIS(GLclampf value, GLboolean invert)
8651 {
8652 __GLXcontext *const gc = __glXGetCurrentContext();
8653 const GLuint cmdlen = 12;
8654 emit_header(gc->pc, X_GLrop_SampleMaskSGIS, cmdlen);
8655 (void) memcpy((void *) (gc->pc + 4), (void *) (&value), 4);
8656 (void) memcpy((void *) (gc->pc + 8), (void *) (&invert), 1);
8657 gc->pc += cmdlen;
8658 if (__builtin_expect(gc->pc > gc->limit, 0)) {
8659 (void) __glXFlushRenderBuffer(gc, gc->pc);
8660 }
8661 }
8662
8663 #define X_GLrop_SamplePatternSGIS 2049
8664 void
8665 __indirect_glSamplePatternSGIS(GLenum pattern)
8666 {
8667 __GLXcontext *const gc = __glXGetCurrentContext();
8668 const GLuint cmdlen = 8;
8669 emit_header(gc->pc, X_GLrop_SamplePatternSGIS, cmdlen);
8670 (void) memcpy((void *) (gc->pc + 4), (void *) (&pattern), 4);
8671 gc->pc += cmdlen;
8672 if (__builtin_expect(gc->pc > gc->limit, 0)) {
8673 (void) __glXFlushRenderBuffer(gc, gc->pc);
8674 }
8675 }
8676
8677 #define X_GLrop_PointParameterfEXT 2065
8678 void
8679 __indirect_glPointParameterfEXT(GLenum pname, GLfloat param)
8680 {
8681 __GLXcontext *const gc = __glXGetCurrentContext();
8682 const GLuint cmdlen = 12;
8683 emit_header(gc->pc, X_GLrop_PointParameterfEXT, cmdlen);
8684 (void) memcpy((void *) (gc->pc + 4), (void *) (&pname), 4);
8685 (void) memcpy((void *) (gc->pc + 8), (void *) (&param), 4);
8686 gc->pc += cmdlen;
8687 if (__builtin_expect(gc->pc > gc->limit, 0)) {
8688 (void) __glXFlushRenderBuffer(gc, gc->pc);
8689 }
8690 }
8691
8692 #define X_GLrop_PointParameterfvEXT 2066
8693 void
8694 __indirect_glPointParameterfvEXT(GLenum pname, const GLfloat * params)
8695 {
8696 __GLXcontext *const gc = __glXGetCurrentContext();
8697 const GLuint compsize = __glPointParameterfvEXT_size(pname);
8698 const GLuint cmdlen = 8 + __GLX_PAD((compsize * 4));
8699 emit_header(gc->pc, X_GLrop_PointParameterfvEXT, cmdlen);
8700 (void) memcpy((void *) (gc->pc + 4), (void *) (&pname), 4);
8701 (void) memcpy((void *) (gc->pc + 8), (void *) (params), (compsize * 4));
8702 gc->pc += cmdlen;
8703 if (__builtin_expect(gc->pc > gc->limit, 0)) {
8704 (void) __glXFlushRenderBuffer(gc, gc->pc);
8705 }
8706 }
8707
8708 #define X_GLrop_SecondaryColor3bvEXT 4126
8709 void
8710 __indirect_glSecondaryColor3bEXT(GLbyte red, GLbyte green, GLbyte blue)
8711 {
8712 __GLXcontext *const gc = __glXGetCurrentContext();
8713 const GLuint cmdlen = 8;
8714 emit_header(gc->pc, X_GLrop_SecondaryColor3bvEXT, cmdlen);
8715 (void) memcpy((void *) (gc->pc + 4), (void *) (&red), 1);
8716 (void) memcpy((void *) (gc->pc + 5), (void *) (&green), 1);
8717 (void) memcpy((void *) (gc->pc + 6), (void *) (&blue), 1);
8718 gc->pc += cmdlen;
8719 if (__builtin_expect(gc->pc > gc->limit, 0)) {
8720 (void) __glXFlushRenderBuffer(gc, gc->pc);
8721 }
8722 }
8723
8724 #define X_GLrop_SecondaryColor3bvEXT 4126
8725 void
8726 __indirect_glSecondaryColor3bvEXT(const GLbyte *v)
8727 {
8728 generic_3_byte(X_GLrop_SecondaryColor3bvEXT, v);
8729 }
8730
8731 #define X_GLrop_SecondaryColor3dvEXT 4130
8732 void
8733 __indirect_glSecondaryColor3dEXT(GLdouble red, GLdouble green, GLdouble blue)
8734 {
8735 __GLXcontext *const gc = __glXGetCurrentContext();
8736 const GLuint cmdlen = 28;
8737 emit_header(gc->pc, X_GLrop_SecondaryColor3dvEXT, cmdlen);
8738 (void) memcpy((void *) (gc->pc + 4), (void *) (&red), 8);
8739 (void) memcpy((void *) (gc->pc + 12), (void *) (&green), 8);
8740 (void) memcpy((void *) (gc->pc + 20), (void *) (&blue), 8);
8741 gc->pc += cmdlen;
8742 if (__builtin_expect(gc->pc > gc->limit, 0)) {
8743 (void) __glXFlushRenderBuffer(gc, gc->pc);
8744 }
8745 }
8746
8747 #define X_GLrop_SecondaryColor3dvEXT 4130
8748 void
8749 __indirect_glSecondaryColor3dvEXT(const GLdouble * v)
8750 {
8751 generic_24_byte(X_GLrop_SecondaryColor3dvEXT, v);
8752 }
8753
8754 #define X_GLrop_SecondaryColor3fvEXT 4129
8755 void
8756 __indirect_glSecondaryColor3fEXT(GLfloat red, GLfloat green, GLfloat blue)
8757 {
8758 __GLXcontext *const gc = __glXGetCurrentContext();
8759 const GLuint cmdlen = 16;
8760 emit_header(gc->pc, X_GLrop_SecondaryColor3fvEXT, cmdlen);
8761 (void) memcpy((void *) (gc->pc + 4), (void *) (&red), 4);
8762 (void) memcpy((void *) (gc->pc + 8), (void *) (&green), 4);
8763 (void) memcpy((void *) (gc->pc + 12), (void *) (&blue), 4);
8764 gc->pc += cmdlen;
8765 if (__builtin_expect(gc->pc > gc->limit, 0)) {
8766 (void) __glXFlushRenderBuffer(gc, gc->pc);
8767 }
8768 }
8769
8770 #define X_GLrop_SecondaryColor3fvEXT 4129
8771 void
8772 __indirect_glSecondaryColor3fvEXT(const GLfloat * v)
8773 {
8774 generic_12_byte(X_GLrop_SecondaryColor3fvEXT, v);
8775 }
8776
8777 #define X_GLrop_SecondaryColor3ivEXT 4128
8778 void
8779 __indirect_glSecondaryColor3iEXT(GLint red, GLint green, GLint blue)
8780 {
8781 __GLXcontext *const gc = __glXGetCurrentContext();
8782 const GLuint cmdlen = 16;
8783 emit_header(gc->pc, X_GLrop_SecondaryColor3ivEXT, cmdlen);
8784 (void) memcpy((void *) (gc->pc + 4), (void *) (&red), 4);
8785 (void) memcpy((void *) (gc->pc + 8), (void *) (&green), 4);
8786 (void) memcpy((void *) (gc->pc + 12), (void *) (&blue), 4);
8787 gc->pc += cmdlen;
8788 if (__builtin_expect(gc->pc > gc->limit, 0)) {
8789 (void) __glXFlushRenderBuffer(gc, gc->pc);
8790 }
8791 }
8792
8793 #define X_GLrop_SecondaryColor3ivEXT 4128
8794 void
8795 __indirect_glSecondaryColor3ivEXT(const GLint * v)
8796 {
8797 generic_12_byte(X_GLrop_SecondaryColor3ivEXT, v);
8798 }
8799
8800 #define X_GLrop_SecondaryColor3svEXT 4127
8801 void
8802 __indirect_glSecondaryColor3sEXT(GLshort red, GLshort green, GLshort blue)
8803 {
8804 __GLXcontext *const gc = __glXGetCurrentContext();
8805 const GLuint cmdlen = 12;
8806 emit_header(gc->pc, X_GLrop_SecondaryColor3svEXT, cmdlen);
8807 (void) memcpy((void *) (gc->pc + 4), (void *) (&red), 2);
8808 (void) memcpy((void *) (gc->pc + 6), (void *) (&green), 2);
8809 (void) memcpy((void *) (gc->pc + 8), (void *) (&blue), 2);
8810 gc->pc += cmdlen;
8811 if (__builtin_expect(gc->pc > gc->limit, 0)) {
8812 (void) __glXFlushRenderBuffer(gc, gc->pc);
8813 }
8814 }
8815
8816 #define X_GLrop_SecondaryColor3svEXT 4127
8817 void
8818 __indirect_glSecondaryColor3svEXT(const GLshort * v)
8819 {
8820 generic_6_byte(X_GLrop_SecondaryColor3svEXT, v);
8821 }
8822
8823 #define X_GLrop_SecondaryColor3ubvEXT 4131
8824 void
8825 __indirect_glSecondaryColor3ubEXT(GLubyte red, GLubyte green, GLubyte blue)
8826 {
8827 __GLXcontext *const gc = __glXGetCurrentContext();
8828 const GLuint cmdlen = 8;
8829 emit_header(gc->pc, X_GLrop_SecondaryColor3ubvEXT, cmdlen);
8830 (void) memcpy((void *) (gc->pc + 4), (void *) (&red), 1);
8831 (void) memcpy((void *) (gc->pc + 5), (void *) (&green), 1);
8832 (void) memcpy((void *) (gc->pc + 6), (void *) (&blue), 1);
8833 gc->pc += cmdlen;
8834 if (__builtin_expect(gc->pc > gc->limit, 0)) {
8835 (void) __glXFlushRenderBuffer(gc, gc->pc);
8836 }
8837 }
8838
8839 #define X_GLrop_SecondaryColor3ubvEXT 4131
8840 void
8841 __indirect_glSecondaryColor3ubvEXT(const GLubyte *v)
8842 {
8843 generic_3_byte(X_GLrop_SecondaryColor3ubvEXT, v);
8844 }
8845
8846 #define X_GLrop_SecondaryColor3uivEXT 4133
8847 void
8848 __indirect_glSecondaryColor3uiEXT(GLuint red, GLuint green, GLuint blue)
8849 {
8850 __GLXcontext *const gc = __glXGetCurrentContext();
8851 const GLuint cmdlen = 16;
8852 emit_header(gc->pc, X_GLrop_SecondaryColor3uivEXT, cmdlen);
8853 (void) memcpy((void *) (gc->pc + 4), (void *) (&red), 4);
8854 (void) memcpy((void *) (gc->pc + 8), (void *) (&green), 4);
8855 (void) memcpy((void *) (gc->pc + 12), (void *) (&blue), 4);
8856 gc->pc += cmdlen;
8857 if (__builtin_expect(gc->pc > gc->limit, 0)) {
8858 (void) __glXFlushRenderBuffer(gc, gc->pc);
8859 }
8860 }
8861
8862 #define X_GLrop_SecondaryColor3uivEXT 4133
8863 void
8864 __indirect_glSecondaryColor3uivEXT(const GLuint * v)
8865 {
8866 generic_12_byte(X_GLrop_SecondaryColor3uivEXT, v);
8867 }
8868
8869 #define X_GLrop_SecondaryColor3usvEXT 4132
8870 void
8871 __indirect_glSecondaryColor3usEXT(GLushort red, GLushort green, GLushort blue)
8872 {
8873 __GLXcontext *const gc = __glXGetCurrentContext();
8874 const GLuint cmdlen = 12;
8875 emit_header(gc->pc, X_GLrop_SecondaryColor3usvEXT, cmdlen);
8876 (void) memcpy((void *) (gc->pc + 4), (void *) (&red), 2);
8877 (void) memcpy((void *) (gc->pc + 6), (void *) (&green), 2);
8878 (void) memcpy((void *) (gc->pc + 8), (void *) (&blue), 2);
8879 gc->pc += cmdlen;
8880 if (__builtin_expect(gc->pc > gc->limit, 0)) {
8881 (void) __glXFlushRenderBuffer(gc, gc->pc);
8882 }
8883 }
8884
8885 #define X_GLrop_SecondaryColor3usvEXT 4132
8886 void
8887 __indirect_glSecondaryColor3usvEXT(const GLushort * v)
8888 {
8889 generic_6_byte(X_GLrop_SecondaryColor3usvEXT, v);
8890 }
8891
8892 #define X_GLrop_FogCoorddvEXT 4125
8893 void
8894 __indirect_glFogCoorddEXT(GLdouble coord)
8895 {
8896 __GLXcontext *const gc = __glXGetCurrentContext();
8897 const GLuint cmdlen = 12;
8898 emit_header(gc->pc, X_GLrop_FogCoorddvEXT, cmdlen);
8899 (void) memcpy((void *) (gc->pc + 4), (void *) (&coord), 8);
8900 gc->pc += cmdlen;
8901 if (__builtin_expect(gc->pc > gc->limit, 0)) {
8902 (void) __glXFlushRenderBuffer(gc, gc->pc);
8903 }
8904 }
8905
8906 #define X_GLrop_FogCoorddvEXT 4125
8907 void
8908 __indirect_glFogCoorddvEXT(const GLdouble * coord)
8909 {
8910 generic_8_byte(X_GLrop_FogCoorddvEXT, coord);
8911 }
8912
8913 #define X_GLrop_FogCoordfvEXT 4124
8914 void
8915 __indirect_glFogCoordfEXT(GLfloat coord)
8916 {
8917 __GLXcontext *const gc = __glXGetCurrentContext();
8918 const GLuint cmdlen = 8;
8919 emit_header(gc->pc, X_GLrop_FogCoordfvEXT, cmdlen);
8920 (void) memcpy((void *) (gc->pc + 4), (void *) (&coord), 4);
8921 gc->pc += cmdlen;
8922 if (__builtin_expect(gc->pc > gc->limit, 0)) {
8923 (void) __glXFlushRenderBuffer(gc, gc->pc);
8924 }
8925 }
8926
8927 #define X_GLrop_FogCoordfvEXT 4124
8928 void
8929 __indirect_glFogCoordfvEXT(const GLfloat * coord)
8930 {
8931 generic_4_byte(X_GLrop_FogCoordfvEXT, coord);
8932 }
8933
8934 #define X_GLrop_BlendFuncSeparateEXT 4134
8935 void
8936 __indirect_glBlendFuncSeparateEXT(GLenum sfactorRGB, GLenum dfactorRGB,
8937 GLenum sfactorAlpha, GLenum dfactorAlpha)
8938 {
8939 __GLXcontext *const gc = __glXGetCurrentContext();
8940 const GLuint cmdlen = 20;
8941 emit_header(gc->pc, X_GLrop_BlendFuncSeparateEXT, cmdlen);
8942 (void) memcpy((void *) (gc->pc + 4), (void *) (&sfactorRGB), 4);
8943 (void) memcpy((void *) (gc->pc + 8), (void *) (&dfactorRGB), 4);
8944 (void) memcpy((void *) (gc->pc + 12), (void *) (&sfactorAlpha), 4);
8945 (void) memcpy((void *) (gc->pc + 16), (void *) (&dfactorAlpha), 4);
8946 gc->pc += cmdlen;
8947 if (__builtin_expect(gc->pc > gc->limit, 0)) {
8948 (void) __glXFlushRenderBuffer(gc, gc->pc);
8949 }
8950 }
8951
8952 #define X_GLrop_WindowPos3fvMESA 230
8953 void
8954 __indirect_glWindowPos3fMESA(GLfloat x, GLfloat y, GLfloat z)
8955 {
8956 __GLXcontext *const gc = __glXGetCurrentContext();
8957 const GLuint cmdlen = 16;
8958 emit_header(gc->pc, X_GLrop_WindowPos3fvMESA, cmdlen);
8959 (void) memcpy((void *) (gc->pc + 4), (void *) (&x), 4);
8960 (void) memcpy((void *) (gc->pc + 8), (void *) (&y), 4);
8961 (void) memcpy((void *) (gc->pc + 12), (void *) (&z), 4);
8962 gc->pc += cmdlen;
8963 if (__builtin_expect(gc->pc > gc->limit, 0)) {
8964 (void) __glXFlushRenderBuffer(gc, gc->pc);
8965 }
8966 }
8967
8968 #define X_GLrop_WindowPos3fvMESA 230
8969 void
8970 __indirect_glWindowPos3fvMESA(const GLfloat * v)
8971 {
8972 generic_12_byte(X_GLrop_WindowPos3fvMESA, v);
8973 }
8974
8975 #define X_GLvop_AreProgramsResidentNV 1293
8976 GLboolean
8977 __indirect_glAreProgramsResidentNV(GLsizei n, const GLuint * ids,
8978 GLboolean * residences)
8979 {
8980 __GLXcontext *const gc = __glXGetCurrentContext();
8981 Display *const dpy = gc->currentDpy;
8982 GLboolean retval = (GLboolean) 0;
8983 const GLuint cmdlen = 4 + __GLX_PAD((n * 4));
8984 if (n < 0) {
8985 __glXSetError(gc, GL_INVALID_VALUE);
8986 return 0;
8987 }
8988 if (__builtin_expect((n >= 0) && (dpy != NULL), 1)) {
8989 GLubyte const *pc =
8990 __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithReply,
8991 X_GLvop_AreProgramsResidentNV, cmdlen);
8992 (void) memcpy((void *) (pc + 0), (void *) (&n), 4);
8993 (void) memcpy((void *) (pc + 4), (void *) (ids), (n * 4));
8994 retval = (GLboolean) __glXReadReply(dpy, 1, residences, GL_FALSE);
8995 UnlockDisplay(dpy);
8996 SyncHandle();
8997 }
8998 return retval;
8999 }
9000
9001 #define X_GLrop_BindProgramNV 4180
9002 void
9003 __indirect_glBindProgramNV(GLenum target, GLuint program)
9004 {
9005 __GLXcontext *const gc = __glXGetCurrentContext();
9006 const GLuint cmdlen = 12;
9007 emit_header(gc->pc, X_GLrop_BindProgramNV, cmdlen);
9008 (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4);
9009 (void) memcpy((void *) (gc->pc + 8), (void *) (&program), 4);
9010 gc->pc += cmdlen;
9011 if (__builtin_expect(gc->pc > gc->limit, 0)) {
9012 (void) __glXFlushRenderBuffer(gc, gc->pc);
9013 }
9014 }
9015
9016 #define X_GLvop_DeleteProgramsNV 1294
9017 void
9018 __indirect_glDeleteProgramsNV(GLsizei n, const GLuint * programs)
9019 {
9020 __GLXcontext *const gc = __glXGetCurrentContext();
9021 Display *const dpy = gc->currentDpy;
9022 const GLuint cmdlen = 4 + __GLX_PAD((n * 4));
9023 if (n < 0) {
9024 __glXSetError(gc, GL_INVALID_VALUE);
9025 return;
9026 }
9027 if (__builtin_expect((n >= 0) && (dpy != NULL), 1)) {
9028 GLubyte const *pc =
9029 __glXSetupVendorRequest(gc, X_GLXVendorPrivate,
9030 X_GLvop_DeleteProgramsNV, cmdlen);
9031 (void) memcpy((void *) (pc + 0), (void *) (&n), 4);
9032 (void) memcpy((void *) (pc + 4), (void *) (programs), (n * 4));
9033 UnlockDisplay(dpy);
9034 SyncHandle();
9035 }
9036 return;
9037 }
9038
9039 #define X_GLrop_ExecuteProgramNV 4181
9040 void
9041 __indirect_glExecuteProgramNV(GLenum target, GLuint id,
9042 const GLfloat * params)
9043 {
9044 __GLXcontext *const gc = __glXGetCurrentContext();
9045 const GLuint cmdlen = 28;
9046 emit_header(gc->pc, X_GLrop_ExecuteProgramNV, cmdlen);
9047 (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4);
9048 (void) memcpy((void *) (gc->pc + 8), (void *) (&id), 4);
9049 (void) memcpy((void *) (gc->pc + 12), (void *) (params), 16);
9050 gc->pc += cmdlen;
9051 if (__builtin_expect(gc->pc > gc->limit, 0)) {
9052 (void) __glXFlushRenderBuffer(gc, gc->pc);
9053 }
9054 }
9055
9056 #define X_GLvop_GenProgramsNV 1295
9057 void
9058 __indirect_glGenProgramsNV(GLsizei n, GLuint * programs)
9059 {
9060 __GLXcontext *const gc = __glXGetCurrentContext();
9061 Display *const dpy = gc->currentDpy;
9062 const GLuint cmdlen = 4;
9063 if (n < 0) {
9064 __glXSetError(gc, GL_INVALID_VALUE);
9065 return;
9066 }
9067 if (__builtin_expect((n >= 0) && (dpy != NULL), 1)) {
9068 GLubyte const *pc =
9069 __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithReply,
9070 X_GLvop_GenProgramsNV, cmdlen);
9071 (void) memcpy((void *) (pc + 0), (void *) (&n), 4);
9072 (void) __glXReadReply(dpy, 4, programs, GL_TRUE);
9073 UnlockDisplay(dpy);
9074 SyncHandle();
9075 }
9076 return;
9077 }
9078
9079 #define X_GLvop_GetProgramParameterdvNV 1297
9080 void
9081 __indirect_glGetProgramParameterdvNV(GLenum target, GLuint index,
9082 GLenum pname, GLdouble * params)
9083 {
9084 __GLXcontext *const gc = __glXGetCurrentContext();
9085 Display *const dpy = gc->currentDpy;
9086 const GLuint cmdlen = 12;
9087 if (__builtin_expect(dpy != NULL, 1)) {
9088 GLubyte const *pc =
9089 __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithReply,
9090 X_GLvop_GetProgramParameterdvNV, cmdlen);
9091 (void) memcpy((void *) (pc + 0), (void *) (&target), 4);
9092 (void) memcpy((void *) (pc + 4), (void *) (&index), 4);
9093 (void) memcpy((void *) (pc + 8), (void *) (&pname), 4);
9094 (void) __glXReadReply(dpy, 8, params, GL_FALSE);
9095 UnlockDisplay(dpy);
9096 SyncHandle();
9097 }
9098 return;
9099 }
9100
9101 #define X_GLvop_GetProgramParameterfvNV 1296
9102 void
9103 __indirect_glGetProgramParameterfvNV(GLenum target, GLuint index,
9104 GLenum pname, GLfloat * params)
9105 {
9106 __GLXcontext *const gc = __glXGetCurrentContext();
9107 Display *const dpy = gc->currentDpy;
9108 const GLuint cmdlen = 12;
9109 if (__builtin_expect(dpy != NULL, 1)) {
9110 GLubyte const *pc =
9111 __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithReply,
9112 X_GLvop_GetProgramParameterfvNV, cmdlen);
9113 (void) memcpy((void *) (pc + 0), (void *) (&target), 4);
9114 (void) memcpy((void *) (pc + 4), (void *) (&index), 4);
9115 (void) memcpy((void *) (pc + 8), (void *) (&pname), 4);
9116 (void) __glXReadReply(dpy, 4, params, GL_FALSE);
9117 UnlockDisplay(dpy);
9118 SyncHandle();
9119 }
9120 return;
9121 }
9122
9123 #define X_GLvop_GetProgramStringNV 1299
9124 void
9125 __indirect_glGetProgramStringNV(GLuint id, GLenum pname, GLubyte *program)
9126 {
9127 __GLXcontext *const gc = __glXGetCurrentContext();
9128 Display *const dpy = gc->currentDpy;
9129 const GLuint cmdlen = 8;
9130 if (__builtin_expect(dpy != NULL, 1)) {
9131 GLubyte const *pc =
9132 __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithReply,
9133 X_GLvop_GetProgramStringNV, cmdlen);
9134 (void) memcpy((void *) (pc + 0), (void *) (&id), 4);
9135 (void) memcpy((void *) (pc + 4), (void *) (&pname), 4);
9136 (void) __glXReadReply(dpy, 1, program, GL_TRUE);
9137 UnlockDisplay(dpy);
9138 SyncHandle();
9139 }
9140 return;
9141 }
9142
9143 #define X_GLvop_GetProgramivNV 1298
9144 void
9145 __indirect_glGetProgramivNV(GLuint id, GLenum pname, GLint * params)
9146 {
9147 __GLXcontext *const gc = __glXGetCurrentContext();
9148 Display *const dpy = gc->currentDpy;
9149 const GLuint cmdlen = 8;
9150 if (__builtin_expect(dpy != NULL, 1)) {
9151 GLubyte const *pc =
9152 __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithReply,
9153 X_GLvop_GetProgramivNV, cmdlen);
9154 (void) memcpy((void *) (pc + 0), (void *) (&id), 4);
9155 (void) memcpy((void *) (pc + 4), (void *) (&pname), 4);
9156 (void) __glXReadReply(dpy, 4, params, GL_FALSE);
9157 UnlockDisplay(dpy);
9158 SyncHandle();
9159 }
9160 return;
9161 }
9162
9163 #define X_GLvop_GetTrackMatrixivNV 1300
9164 void
9165 __indirect_glGetTrackMatrixivNV(GLenum target, GLuint address, GLenum pname,
9166 GLint * params)
9167 {
9168 __GLXcontext *const gc = __glXGetCurrentContext();
9169 Display *const dpy = gc->currentDpy;
9170 const GLuint cmdlen = 12;
9171 if (__builtin_expect(dpy != NULL, 1)) {
9172 GLubyte const *pc =
9173 __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithReply,
9174 X_GLvop_GetTrackMatrixivNV, cmdlen);
9175 (void) memcpy((void *) (pc + 0), (void *) (&target), 4);
9176 (void) memcpy((void *) (pc + 4), (void *) (&address), 4);
9177 (void) memcpy((void *) (pc + 8), (void *) (&pname), 4);
9178 (void) __glXReadReply(dpy, 4, params, GL_FALSE);
9179 UnlockDisplay(dpy);
9180 SyncHandle();
9181 }
9182 return;
9183 }
9184
9185 #define X_GLvop_GetVertexAttribdvNV 1301
9186 void
9187 __indirect_glGetVertexAttribdvNV(GLuint index, GLenum pname,
9188 GLdouble * params)
9189 {
9190 __GLXcontext *const gc = __glXGetCurrentContext();
9191 Display *const dpy = gc->currentDpy;
9192 const GLuint cmdlen = 8;
9193 if (__builtin_expect(dpy != NULL, 1)) {
9194 GLubyte const *pc =
9195 __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithReply,
9196 X_GLvop_GetVertexAttribdvNV, cmdlen);
9197 (void) memcpy((void *) (pc + 0), (void *) (&index), 4);
9198 (void) memcpy((void *) (pc + 4), (void *) (&pname), 4);
9199 (void) __glXReadReply(dpy, 8, params, GL_FALSE);
9200 UnlockDisplay(dpy);
9201 SyncHandle();
9202 }
9203 return;
9204 }
9205
9206 #define X_GLvop_GetVertexAttribfvNV 1302
9207 void
9208 __indirect_glGetVertexAttribfvNV(GLuint index, GLenum pname, GLfloat * params)
9209 {
9210 __GLXcontext *const gc = __glXGetCurrentContext();
9211 Display *const dpy = gc->currentDpy;
9212 const GLuint cmdlen = 8;
9213 if (__builtin_expect(dpy != NULL, 1)) {
9214 GLubyte const *pc =
9215 __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithReply,
9216 X_GLvop_GetVertexAttribfvNV, cmdlen);
9217 (void) memcpy((void *) (pc + 0), (void *) (&index), 4);
9218 (void) memcpy((void *) (pc + 4), (void *) (&pname), 4);
9219 (void) __glXReadReply(dpy, 4, params, GL_FALSE);
9220 UnlockDisplay(dpy);
9221 SyncHandle();
9222 }
9223 return;
9224 }
9225
9226 #define X_GLvop_GetVertexAttribivNV 1303
9227 void
9228 __indirect_glGetVertexAttribivNV(GLuint index, GLenum pname, GLint * params)
9229 {
9230 __GLXcontext *const gc = __glXGetCurrentContext();
9231 Display *const dpy = gc->currentDpy;
9232 const GLuint cmdlen = 8;
9233 if (__builtin_expect(dpy != NULL, 1)) {
9234 GLubyte const *pc =
9235 __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithReply,
9236 X_GLvop_GetVertexAttribivNV, cmdlen);
9237 (void) memcpy((void *) (pc + 0), (void *) (&index), 4);
9238 (void) memcpy((void *) (pc + 4), (void *) (&pname), 4);
9239 (void) __glXReadReply(dpy, 4, params, GL_FALSE);
9240 UnlockDisplay(dpy);
9241 SyncHandle();
9242 }
9243 return;
9244 }
9245
9246 #define X_GLvop_IsProgramNV 1304
9247 GLboolean
9248 __indirect_glIsProgramNV(GLuint program)
9249 {
9250 __GLXcontext *const gc = __glXGetCurrentContext();
9251 Display *const dpy = gc->currentDpy;
9252 GLboolean retval = (GLboolean) 0;
9253 const GLuint cmdlen = 4;
9254 if (__builtin_expect(dpy != NULL, 1)) {
9255 GLubyte const *pc =
9256 __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithReply,
9257 X_GLvop_IsProgramNV, cmdlen);
9258 (void) memcpy((void *) (pc + 0), (void *) (&program), 4);
9259 retval = (GLboolean) __glXReadReply(dpy, 0, NULL, GL_FALSE);
9260 UnlockDisplay(dpy);
9261 SyncHandle();
9262 }
9263 return retval;
9264 }
9265
9266 #define X_GLrop_LoadProgramNV 4183
9267 void
9268 __indirect_glLoadProgramNV(GLenum target, GLuint id, GLsizei len,
9269 const GLubyte *program)
9270 {
9271 __GLXcontext *const gc = __glXGetCurrentContext();
9272 const GLuint cmdlen = 16 + __GLX_PAD(len);
9273 if (len < 0) {
9274 __glXSetError(gc, GL_INVALID_VALUE);
9275 return;
9276 }
9277 if (__builtin_expect(len >= 0, 1)) {
9278 emit_header(gc->pc, X_GLrop_LoadProgramNV, cmdlen);
9279 (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4);
9280 (void) memcpy((void *) (gc->pc + 8), (void *) (&id), 4);
9281 (void) memcpy((void *) (gc->pc + 12), (void *) (&len), 4);
9282 (void) memcpy((void *) (gc->pc + 16), (void *) (program), len);
9283 gc->pc += cmdlen;
9284 if (__builtin_expect(gc->pc > gc->limit, 0)) {
9285 (void) __glXFlushRenderBuffer(gc, gc->pc);
9286 }
9287 }
9288 }
9289
9290 #define X_GLrop_ProgramParameters4dvNV 4187
9291 void
9292 __indirect_glProgramParameters4dvNV(GLenum target, GLuint index, GLuint num,
9293 const GLdouble * params)
9294 {
9295 __GLXcontext *const gc = __glXGetCurrentContext();
9296 const GLuint cmdlen = 16 + __GLX_PAD((num * 32));
9297 if (num < 0) {
9298 __glXSetError(gc, GL_INVALID_VALUE);
9299 return;
9300 }
9301 if (__builtin_expect(num >= 0, 1)) {
9302 emit_header(gc->pc, X_GLrop_ProgramParameters4dvNV, cmdlen);
9303 (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4);
9304 (void) memcpy((void *) (gc->pc + 8), (void *) (&index), 4);
9305 (void) memcpy((void *) (gc->pc + 12), (void *) (&num), 4);
9306 (void) memcpy((void *) (gc->pc + 16), (void *) (params), (num * 32));
9307 gc->pc += cmdlen;
9308 if (__builtin_expect(gc->pc > gc->limit, 0)) {
9309 (void) __glXFlushRenderBuffer(gc, gc->pc);
9310 }
9311 }
9312 }
9313
9314 #define X_GLrop_ProgramParameters4fvNV 4186
9315 void
9316 __indirect_glProgramParameters4fvNV(GLenum target, GLuint index, GLuint num,
9317 const GLfloat * params)
9318 {
9319 __GLXcontext *const gc = __glXGetCurrentContext();
9320 const GLuint cmdlen = 16 + __GLX_PAD((num * 16));
9321 if (num < 0) {
9322 __glXSetError(gc, GL_INVALID_VALUE);
9323 return;
9324 }
9325 if (__builtin_expect(num >= 0, 1)) {
9326 emit_header(gc->pc, X_GLrop_ProgramParameters4fvNV, cmdlen);
9327 (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4);
9328 (void) memcpy((void *) (gc->pc + 8), (void *) (&index), 4);
9329 (void) memcpy((void *) (gc->pc + 12), (void *) (&num), 4);
9330 (void) memcpy((void *) (gc->pc + 16), (void *) (params), (num * 16));
9331 gc->pc += cmdlen;
9332 if (__builtin_expect(gc->pc > gc->limit, 0)) {
9333 (void) __glXFlushRenderBuffer(gc, gc->pc);
9334 }
9335 }
9336 }
9337
9338 #define X_GLrop_RequestResidentProgramsNV 4182
9339 void
9340 __indirect_glRequestResidentProgramsNV(GLsizei n, const GLuint * ids)
9341 {
9342 __GLXcontext *const gc = __glXGetCurrentContext();
9343 const GLuint cmdlen = 8 + __GLX_PAD((n * 4));
9344 if (n < 0) {
9345 __glXSetError(gc, GL_INVALID_VALUE);
9346 return;
9347 }
9348 if (__builtin_expect(n >= 0, 1)) {
9349 emit_header(gc->pc, X_GLrop_RequestResidentProgramsNV, cmdlen);
9350 (void) memcpy((void *) (gc->pc + 4), (void *) (&n), 4);
9351 (void) memcpy((void *) (gc->pc + 8), (void *) (ids), (n * 4));
9352 gc->pc += cmdlen;
9353 if (__builtin_expect(gc->pc > gc->limit, 0)) {
9354 (void) __glXFlushRenderBuffer(gc, gc->pc);
9355 }
9356 }
9357 }
9358
9359 #define X_GLrop_TrackMatrixNV 4188
9360 void
9361 __indirect_glTrackMatrixNV(GLenum target, GLuint address, GLenum matrix,
9362 GLenum transform)
9363 {
9364 __GLXcontext *const gc = __glXGetCurrentContext();
9365 const GLuint cmdlen = 20;
9366 emit_header(gc->pc, X_GLrop_TrackMatrixNV, cmdlen);
9367 (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4);
9368 (void) memcpy((void *) (gc->pc + 8), (void *) (&address), 4);
9369 (void) memcpy((void *) (gc->pc + 12), (void *) (&matrix), 4);
9370 (void) memcpy((void *) (gc->pc + 16), (void *) (&transform), 4);
9371 gc->pc += cmdlen;
9372 if (__builtin_expect(gc->pc > gc->limit, 0)) {
9373 (void) __glXFlushRenderBuffer(gc, gc->pc);
9374 }
9375 }
9376
9377 #define X_GLrop_VertexAttrib1dvNV 4273
9378 void
9379 __indirect_glVertexAttrib1dNV(GLuint index, GLdouble x)
9380 {
9381 __GLXcontext *const gc = __glXGetCurrentContext();
9382 const GLuint cmdlen = 16;
9383 emit_header(gc->pc, X_GLrop_VertexAttrib1dvNV, cmdlen);
9384 (void) memcpy((void *) (gc->pc + 4), (void *) (&index), 4);
9385 (void) memcpy((void *) (gc->pc + 8), (void *) (&x), 8);
9386 gc->pc += cmdlen;
9387 if (__builtin_expect(gc->pc > gc->limit, 0)) {
9388 (void) __glXFlushRenderBuffer(gc, gc->pc);
9389 }
9390 }
9391
9392 #define X_GLrop_VertexAttrib1dvNV 4273
9393 void
9394 __indirect_glVertexAttrib1dvNV(GLuint index, const GLdouble * v)
9395 {
9396 __GLXcontext *const gc = __glXGetCurrentContext();
9397 const GLuint cmdlen = 16;
9398 emit_header(gc->pc, X_GLrop_VertexAttrib1dvNV, cmdlen);
9399 (void) memcpy((void *) (gc->pc + 4), (void *) (&index), 4);
9400 (void) memcpy((void *) (gc->pc + 8), (void *) (v), 8);
9401 gc->pc += cmdlen;
9402 if (__builtin_expect(gc->pc > gc->limit, 0)) {
9403 (void) __glXFlushRenderBuffer(gc, gc->pc);
9404 }
9405 }
9406
9407 #define X_GLrop_VertexAttrib1fvNV 4269
9408 void
9409 __indirect_glVertexAttrib1fNV(GLuint index, GLfloat x)
9410 {
9411 __GLXcontext *const gc = __glXGetCurrentContext();
9412 const GLuint cmdlen = 12;
9413 emit_header(gc->pc, X_GLrop_VertexAttrib1fvNV, cmdlen);
9414 (void) memcpy((void *) (gc->pc + 4), (void *) (&index), 4);
9415 (void) memcpy((void *) (gc->pc + 8), (void *) (&x), 4);
9416 gc->pc += cmdlen;
9417 if (__builtin_expect(gc->pc > gc->limit, 0)) {
9418 (void) __glXFlushRenderBuffer(gc, gc->pc);
9419 }
9420 }
9421
9422 #define X_GLrop_VertexAttrib1fvNV 4269
9423 void
9424 __indirect_glVertexAttrib1fvNV(GLuint index, const GLfloat * v)
9425 {
9426 __GLXcontext *const gc = __glXGetCurrentContext();
9427 const GLuint cmdlen = 12;
9428 emit_header(gc->pc, X_GLrop_VertexAttrib1fvNV, cmdlen);
9429 (void) memcpy((void *) (gc->pc + 4), (void *) (&index), 4);
9430 (void) memcpy((void *) (gc->pc + 8), (void *) (v), 4);
9431 gc->pc += cmdlen;
9432 if (__builtin_expect(gc->pc > gc->limit, 0)) {
9433 (void) __glXFlushRenderBuffer(gc, gc->pc);
9434 }
9435 }
9436
9437 #define X_GLrop_VertexAttrib1svNV 4265
9438 void
9439 __indirect_glVertexAttrib1sNV(GLuint index, GLshort x)
9440 {
9441 __GLXcontext *const gc = __glXGetCurrentContext();
9442 const GLuint cmdlen = 12;
9443 emit_header(gc->pc, X_GLrop_VertexAttrib1svNV, cmdlen);
9444 (void) memcpy((void *) (gc->pc + 4), (void *) (&index), 4);
9445 (void) memcpy((void *) (gc->pc + 8), (void *) (&x), 2);
9446 gc->pc += cmdlen;
9447 if (__builtin_expect(gc->pc > gc->limit, 0)) {
9448 (void) __glXFlushRenderBuffer(gc, gc->pc);
9449 }
9450 }
9451
9452 #define X_GLrop_VertexAttrib1svNV 4265
9453 void
9454 __indirect_glVertexAttrib1svNV(GLuint index, const GLshort * v)
9455 {
9456 __GLXcontext *const gc = __glXGetCurrentContext();
9457 const GLuint cmdlen = 12;
9458 emit_header(gc->pc, X_GLrop_VertexAttrib1svNV, cmdlen);
9459 (void) memcpy((void *) (gc->pc + 4), (void *) (&index), 4);
9460 (void) memcpy((void *) (gc->pc + 8), (void *) (v), 2);
9461 gc->pc += cmdlen;
9462 if (__builtin_expect(gc->pc > gc->limit, 0)) {
9463 (void) __glXFlushRenderBuffer(gc, gc->pc);
9464 }
9465 }
9466
9467 #define X_GLrop_VertexAttrib2dvNV 4274
9468 void
9469 __indirect_glVertexAttrib2dNV(GLuint index, GLdouble x, GLdouble y)
9470 {
9471 __GLXcontext *const gc = __glXGetCurrentContext();
9472 const GLuint cmdlen = 24;
9473 emit_header(gc->pc, X_GLrop_VertexAttrib2dvNV, cmdlen);
9474 (void) memcpy((void *) (gc->pc + 4), (void *) (&index), 4);
9475 (void) memcpy((void *) (gc->pc + 8), (void *) (&x), 8);
9476 (void) memcpy((void *) (gc->pc + 16), (void *) (&y), 8);
9477 gc->pc += cmdlen;
9478 if (__builtin_expect(gc->pc > gc->limit, 0)) {
9479 (void) __glXFlushRenderBuffer(gc, gc->pc);
9480 }
9481 }
9482
9483 #define X_GLrop_VertexAttrib2dvNV 4274
9484 void
9485 __indirect_glVertexAttrib2dvNV(GLuint index, const GLdouble * v)
9486 {
9487 __GLXcontext *const gc = __glXGetCurrentContext();
9488 const GLuint cmdlen = 24;
9489 emit_header(gc->pc, X_GLrop_VertexAttrib2dvNV, cmdlen);
9490 (void) memcpy((void *) (gc->pc + 4), (void *) (&index), 4);
9491 (void) memcpy((void *) (gc->pc + 8), (void *) (v), 16);
9492 gc->pc += cmdlen;
9493 if (__builtin_expect(gc->pc > gc->limit, 0)) {
9494 (void) __glXFlushRenderBuffer(gc, gc->pc);
9495 }
9496 }
9497
9498 #define X_GLrop_VertexAttrib2fvNV 4270
9499 void
9500 __indirect_glVertexAttrib2fNV(GLuint index, GLfloat x, GLfloat y)
9501 {
9502 __GLXcontext *const gc = __glXGetCurrentContext();
9503 const GLuint cmdlen = 16;
9504 emit_header(gc->pc, X_GLrop_VertexAttrib2fvNV, cmdlen);
9505 (void) memcpy((void *) (gc->pc + 4), (void *) (&index), 4);
9506 (void) memcpy((void *) (gc->pc + 8), (void *) (&x), 4);
9507 (void) memcpy((void *) (gc->pc + 12), (void *) (&y), 4);
9508 gc->pc += cmdlen;
9509 if (__builtin_expect(gc->pc > gc->limit, 0)) {
9510 (void) __glXFlushRenderBuffer(gc, gc->pc);
9511 }
9512 }
9513
9514 #define X_GLrop_VertexAttrib2fvNV 4270
9515 void
9516 __indirect_glVertexAttrib2fvNV(GLuint index, const GLfloat * v)
9517 {
9518 __GLXcontext *const gc = __glXGetCurrentContext();
9519 const GLuint cmdlen = 16;
9520 emit_header(gc->pc, X_GLrop_VertexAttrib2fvNV, cmdlen);
9521 (void) memcpy((void *) (gc->pc + 4), (void *) (&index), 4);
9522 (void) memcpy((void *) (gc->pc + 8), (void *) (v), 8);
9523 gc->pc += cmdlen;
9524 if (__builtin_expect(gc->pc > gc->limit, 0)) {
9525 (void) __glXFlushRenderBuffer(gc, gc->pc);
9526 }
9527 }
9528
9529 #define X_GLrop_VertexAttrib2svNV 4266
9530 void
9531 __indirect_glVertexAttrib2sNV(GLuint index, GLshort x, GLshort y)
9532 {
9533 __GLXcontext *const gc = __glXGetCurrentContext();
9534 const GLuint cmdlen = 12;
9535 emit_header(gc->pc, X_GLrop_VertexAttrib2svNV, cmdlen);
9536 (void) memcpy((void *) (gc->pc + 4), (void *) (&index), 4);
9537 (void) memcpy((void *) (gc->pc + 8), (void *) (&x), 2);
9538 (void) memcpy((void *) (gc->pc + 10), (void *) (&y), 2);
9539 gc->pc += cmdlen;
9540 if (__builtin_expect(gc->pc > gc->limit, 0)) {
9541 (void) __glXFlushRenderBuffer(gc, gc->pc);
9542 }
9543 }
9544
9545 #define X_GLrop_VertexAttrib2svNV 4266
9546 void
9547 __indirect_glVertexAttrib2svNV(GLuint index, const GLshort * v)
9548 {
9549 __GLXcontext *const gc = __glXGetCurrentContext();
9550 const GLuint cmdlen = 12;
9551 emit_header(gc->pc, X_GLrop_VertexAttrib2svNV, cmdlen);
9552 (void) memcpy((void *) (gc->pc + 4), (void *) (&index), 4);
9553 (void) memcpy((void *) (gc->pc + 8), (void *) (v), 4);
9554 gc->pc += cmdlen;
9555 if (__builtin_expect(gc->pc > gc->limit, 0)) {
9556 (void) __glXFlushRenderBuffer(gc, gc->pc);
9557 }
9558 }
9559
9560 #define X_GLrop_VertexAttrib3dvNV 4275
9561 void
9562 __indirect_glVertexAttrib3dNV(GLuint index, GLdouble x, GLdouble y,
9563 GLdouble z)
9564 {
9565 __GLXcontext *const gc = __glXGetCurrentContext();
9566 const GLuint cmdlen = 32;
9567 emit_header(gc->pc, X_GLrop_VertexAttrib3dvNV, cmdlen);
9568 (void) memcpy((void *) (gc->pc + 4), (void *) (&index), 4);
9569 (void) memcpy((void *) (gc->pc + 8), (void *) (&x), 8);
9570 (void) memcpy((void *) (gc->pc + 16), (void *) (&y), 8);
9571 (void) memcpy((void *) (gc->pc + 24), (void *) (&z), 8);
9572 gc->pc += cmdlen;
9573 if (__builtin_expect(gc->pc > gc->limit, 0)) {
9574 (void) __glXFlushRenderBuffer(gc, gc->pc);
9575 }
9576 }
9577
9578 #define X_GLrop_VertexAttrib3dvNV 4275
9579 void
9580 __indirect_glVertexAttrib3dvNV(GLuint index, const GLdouble * v)
9581 {
9582 __GLXcontext *const gc = __glXGetCurrentContext();
9583 const GLuint cmdlen = 32;
9584 emit_header(gc->pc, X_GLrop_VertexAttrib3dvNV, cmdlen);
9585 (void) memcpy((void *) (gc->pc + 4), (void *) (&index), 4);
9586 (void) memcpy((void *) (gc->pc + 8), (void *) (v), 24);
9587 gc->pc += cmdlen;
9588 if (__builtin_expect(gc->pc > gc->limit, 0)) {
9589 (void) __glXFlushRenderBuffer(gc, gc->pc);
9590 }
9591 }
9592
9593 #define X_GLrop_VertexAttrib3fvNV 4271
9594 void
9595 __indirect_glVertexAttrib3fNV(GLuint index, GLfloat x, GLfloat y, GLfloat z)
9596 {
9597 __GLXcontext *const gc = __glXGetCurrentContext();
9598 const GLuint cmdlen = 20;
9599 emit_header(gc->pc, X_GLrop_VertexAttrib3fvNV, cmdlen);
9600 (void) memcpy((void *) (gc->pc + 4), (void *) (&index), 4);
9601 (void) memcpy((void *) (gc->pc + 8), (void *) (&x), 4);
9602 (void) memcpy((void *) (gc->pc + 12), (void *) (&y), 4);
9603 (void) memcpy((void *) (gc->pc + 16), (void *) (&z), 4);
9604 gc->pc += cmdlen;
9605 if (__builtin_expect(gc->pc > gc->limit, 0)) {
9606 (void) __glXFlushRenderBuffer(gc, gc->pc);
9607 }
9608 }
9609
9610 #define X_GLrop_VertexAttrib3fvNV 4271
9611 void
9612 __indirect_glVertexAttrib3fvNV(GLuint index, const GLfloat * v)
9613 {
9614 __GLXcontext *const gc = __glXGetCurrentContext();
9615 const GLuint cmdlen = 20;
9616 emit_header(gc->pc, X_GLrop_VertexAttrib3fvNV, cmdlen);
9617 (void) memcpy((void *) (gc->pc + 4), (void *) (&index), 4);
9618 (void) memcpy((void *) (gc->pc + 8), (void *) (v), 12);
9619 gc->pc += cmdlen;
9620 if (__builtin_expect(gc->pc > gc->limit, 0)) {
9621 (void) __glXFlushRenderBuffer(gc, gc->pc);
9622 }
9623 }
9624
9625 #define X_GLrop_VertexAttrib3svNV 4267
9626 void
9627 __indirect_glVertexAttrib3sNV(GLuint index, GLshort x, GLshort y, GLshort z)
9628 {
9629 __GLXcontext *const gc = __glXGetCurrentContext();
9630 const GLuint cmdlen = 16;
9631 emit_header(gc->pc, X_GLrop_VertexAttrib3svNV, cmdlen);
9632 (void) memcpy((void *) (gc->pc + 4), (void *) (&index), 4);
9633 (void) memcpy((void *) (gc->pc + 8), (void *) (&x), 2);
9634 (void) memcpy((void *) (gc->pc + 10), (void *) (&y), 2);
9635 (void) memcpy((void *) (gc->pc + 12), (void *) (&z), 2);
9636 gc->pc += cmdlen;
9637 if (__builtin_expect(gc->pc > gc->limit, 0)) {
9638 (void) __glXFlushRenderBuffer(gc, gc->pc);
9639 }
9640 }
9641
9642 #define X_GLrop_VertexAttrib3svNV 4267
9643 void
9644 __indirect_glVertexAttrib3svNV(GLuint index, const GLshort * v)
9645 {
9646 __GLXcontext *const gc = __glXGetCurrentContext();
9647 const GLuint cmdlen = 16;
9648 emit_header(gc->pc, X_GLrop_VertexAttrib3svNV, cmdlen);
9649 (void) memcpy((void *) (gc->pc + 4), (void *) (&index), 4);
9650 (void) memcpy((void *) (gc->pc + 8), (void *) (v), 6);
9651 gc->pc += cmdlen;
9652 if (__builtin_expect(gc->pc > gc->limit, 0)) {
9653 (void) __glXFlushRenderBuffer(gc, gc->pc);
9654 }
9655 }
9656
9657 #define X_GLrop_VertexAttrib4dvNV 4276
9658 void
9659 __indirect_glVertexAttrib4dNV(GLuint index, GLdouble x, GLdouble y,
9660 GLdouble z, GLdouble w)
9661 {
9662 __GLXcontext *const gc = __glXGetCurrentContext();
9663 const GLuint cmdlen = 40;
9664 emit_header(gc->pc, X_GLrop_VertexAttrib4dvNV, cmdlen);
9665 (void) memcpy((void *) (gc->pc + 4), (void *) (&index), 4);
9666 (void) memcpy((void *) (gc->pc + 8), (void *) (&x), 8);
9667 (void) memcpy((void *) (gc->pc + 16), (void *) (&y), 8);
9668 (void) memcpy((void *) (gc->pc + 24), (void *) (&z), 8);
9669 (void) memcpy((void *) (gc->pc + 32), (void *) (&w), 8);
9670 gc->pc += cmdlen;
9671 if (__builtin_expect(gc->pc > gc->limit, 0)) {
9672 (void) __glXFlushRenderBuffer(gc, gc->pc);
9673 }
9674 }
9675
9676 #define X_GLrop_VertexAttrib4dvNV 4276
9677 void
9678 __indirect_glVertexAttrib4dvNV(GLuint index, const GLdouble * v)
9679 {
9680 __GLXcontext *const gc = __glXGetCurrentContext();
9681 const GLuint cmdlen = 40;
9682 emit_header(gc->pc, X_GLrop_VertexAttrib4dvNV, cmdlen);
9683 (void) memcpy((void *) (gc->pc + 4), (void *) (&index), 4);
9684 (void) memcpy((void *) (gc->pc + 8), (void *) (v), 32);
9685 gc->pc += cmdlen;
9686 if (__builtin_expect(gc->pc > gc->limit, 0)) {
9687 (void) __glXFlushRenderBuffer(gc, gc->pc);
9688 }
9689 }
9690
9691 #define X_GLrop_VertexAttrib4fvNV 4272
9692 void
9693 __indirect_glVertexAttrib4fNV(GLuint index, GLfloat x, GLfloat y, GLfloat z,
9694 GLfloat w)
9695 {
9696 __GLXcontext *const gc = __glXGetCurrentContext();
9697 const GLuint cmdlen = 24;
9698 emit_header(gc->pc, X_GLrop_VertexAttrib4fvNV, cmdlen);
9699 (void) memcpy((void *) (gc->pc + 4), (void *) (&index), 4);
9700 (void) memcpy((void *) (gc->pc + 8), (void *) (&x), 4);
9701 (void) memcpy((void *) (gc->pc + 12), (void *) (&y), 4);
9702 (void) memcpy((void *) (gc->pc + 16), (void *) (&z), 4);
9703 (void) memcpy((void *) (gc->pc + 20), (void *) (&w), 4);
9704 gc->pc += cmdlen;
9705 if (__builtin_expect(gc->pc > gc->limit, 0)) {
9706 (void) __glXFlushRenderBuffer(gc, gc->pc);
9707 }
9708 }
9709
9710 #define X_GLrop_VertexAttrib4fvNV 4272
9711 void
9712 __indirect_glVertexAttrib4fvNV(GLuint index, const GLfloat * v)
9713 {
9714 __GLXcontext *const gc = __glXGetCurrentContext();
9715 const GLuint cmdlen = 24;
9716 emit_header(gc->pc, X_GLrop_VertexAttrib4fvNV, cmdlen);
9717 (void) memcpy((void *) (gc->pc + 4), (void *) (&index), 4);
9718 (void) memcpy((void *) (gc->pc + 8), (void *) (v), 16);
9719 gc->pc += cmdlen;
9720 if (__builtin_expect(gc->pc > gc->limit, 0)) {
9721 (void) __glXFlushRenderBuffer(gc, gc->pc);
9722 }
9723 }
9724
9725 #define X_GLrop_VertexAttrib4svNV 4268
9726 void
9727 __indirect_glVertexAttrib4sNV(GLuint index, GLshort x, GLshort y, GLshort z,
9728 GLshort w)
9729 {
9730 __GLXcontext *const gc = __glXGetCurrentContext();
9731 const GLuint cmdlen = 16;
9732 emit_header(gc->pc, X_GLrop_VertexAttrib4svNV, cmdlen);
9733 (void) memcpy((void *) (gc->pc + 4), (void *) (&index), 4);
9734 (void) memcpy((void *) (gc->pc + 8), (void *) (&x), 2);
9735 (void) memcpy((void *) (gc->pc + 10), (void *) (&y), 2);
9736 (void) memcpy((void *) (gc->pc + 12), (void *) (&z), 2);
9737 (void) memcpy((void *) (gc->pc + 14), (void *) (&w), 2);
9738 gc->pc += cmdlen;
9739 if (__builtin_expect(gc->pc > gc->limit, 0)) {
9740 (void) __glXFlushRenderBuffer(gc, gc->pc);
9741 }
9742 }
9743
9744 #define X_GLrop_VertexAttrib4svNV 4268
9745 void
9746 __indirect_glVertexAttrib4svNV(GLuint index, const GLshort * v)
9747 {
9748 __GLXcontext *const gc = __glXGetCurrentContext();
9749 const GLuint cmdlen = 16;
9750 emit_header(gc->pc, X_GLrop_VertexAttrib4svNV, cmdlen);
9751 (void) memcpy((void *) (gc->pc + 4), (void *) (&index), 4);
9752 (void) memcpy((void *) (gc->pc + 8), (void *) (v), 8);
9753 gc->pc += cmdlen;
9754 if (__builtin_expect(gc->pc > gc->limit, 0)) {
9755 (void) __glXFlushRenderBuffer(gc, gc->pc);
9756 }
9757 }
9758
9759 #define X_GLrop_VertexAttrib4ubvNV 4277
9760 void
9761 __indirect_glVertexAttrib4ubNV(GLuint index, GLubyte x, GLubyte y, GLubyte z,
9762 GLubyte w)
9763 {
9764 __GLXcontext *const gc = __glXGetCurrentContext();
9765 const GLuint cmdlen = 12;
9766 emit_header(gc->pc, X_GLrop_VertexAttrib4ubvNV, cmdlen);
9767 (void) memcpy((void *) (gc->pc + 4), (void *) (&index), 4);
9768 (void) memcpy((void *) (gc->pc + 8), (void *) (&x), 1);
9769 (void) memcpy((void *) (gc->pc + 9), (void *) (&y), 1);
9770 (void) memcpy((void *) (gc->pc + 10), (void *) (&z), 1);
9771 (void) memcpy((void *) (gc->pc + 11), (void *) (&w), 1);
9772 gc->pc += cmdlen;
9773 if (__builtin_expect(gc->pc > gc->limit, 0)) {
9774 (void) __glXFlushRenderBuffer(gc, gc->pc);
9775 }
9776 }
9777
9778 #define X_GLrop_VertexAttrib4ubvNV 4277
9779 void
9780 __indirect_glVertexAttrib4ubvNV(GLuint index, const GLubyte *v)
9781 {
9782 __GLXcontext *const gc = __glXGetCurrentContext();
9783 const GLuint cmdlen = 12;
9784 emit_header(gc->pc, X_GLrop_VertexAttrib4ubvNV, cmdlen);
9785 (void) memcpy((void *) (gc->pc + 4), (void *) (&index), 4);
9786 (void) memcpy((void *) (gc->pc + 8), (void *) (v), 4);
9787 gc->pc += cmdlen;
9788 if (__builtin_expect(gc->pc > gc->limit, 0)) {
9789 (void) __glXFlushRenderBuffer(gc, gc->pc);
9790 }
9791 }
9792
9793 #define X_GLrop_VertexAttribs1dvNV 4210
9794 void
9795 __indirect_glVertexAttribs1dvNV(GLuint index, GLsizei n, const GLdouble * v)
9796 {
9797 __GLXcontext *const gc = __glXGetCurrentContext();
9798 const GLuint cmdlen = 12 + __GLX_PAD((n * 8));
9799 if (n < 0) {
9800 __glXSetError(gc, GL_INVALID_VALUE);
9801 return;
9802 }
9803 if (__builtin_expect(n >= 0, 1)) {
9804 emit_header(gc->pc, X_GLrop_VertexAttribs1dvNV, cmdlen);
9805 (void) memcpy((void *) (gc->pc + 4), (void *) (&index), 4);
9806 (void) memcpy((void *) (gc->pc + 8), (void *) (&n), 4);
9807 (void) memcpy((void *) (gc->pc + 12), (void *) (v), (n * 8));
9808 gc->pc += cmdlen;
9809 if (__builtin_expect(gc->pc > gc->limit, 0)) {
9810 (void) __glXFlushRenderBuffer(gc, gc->pc);
9811 }
9812 }
9813 }
9814
9815 #define X_GLrop_VertexAttribs1fvNV 4206
9816 void
9817 __indirect_glVertexAttribs1fvNV(GLuint index, GLsizei n, const GLfloat * v)
9818 {
9819 __GLXcontext *const gc = __glXGetCurrentContext();
9820 const GLuint cmdlen = 12 + __GLX_PAD((n * 4));
9821 if (n < 0) {
9822 __glXSetError(gc, GL_INVALID_VALUE);
9823 return;
9824 }
9825 if (__builtin_expect(n >= 0, 1)) {
9826 emit_header(gc->pc, X_GLrop_VertexAttribs1fvNV, cmdlen);
9827 (void) memcpy((void *) (gc->pc + 4), (void *) (&index), 4);
9828 (void) memcpy((void *) (gc->pc + 8), (void *) (&n), 4);
9829 (void) memcpy((void *) (gc->pc + 12), (void *) (v), (n * 4));
9830 gc->pc += cmdlen;
9831 if (__builtin_expect(gc->pc > gc->limit, 0)) {
9832 (void) __glXFlushRenderBuffer(gc, gc->pc);
9833 }
9834 }
9835 }
9836
9837 #define X_GLrop_VertexAttribs1svNV 4202
9838 void
9839 __indirect_glVertexAttribs1svNV(GLuint index, GLsizei n, const GLshort * v)
9840 {
9841 __GLXcontext *const gc = __glXGetCurrentContext();
9842 const GLuint cmdlen = 12 + __GLX_PAD((n * 2));
9843 if (n < 0) {
9844 __glXSetError(gc, GL_INVALID_VALUE);
9845 return;
9846 }
9847 if (__builtin_expect(n >= 0, 1)) {
9848 emit_header(gc->pc, X_GLrop_VertexAttribs1svNV, cmdlen);
9849 (void) memcpy((void *) (gc->pc + 4), (void *) (&index), 4);
9850 (void) memcpy((void *) (gc->pc + 8), (void *) (&n), 4);
9851 (void) memcpy((void *) (gc->pc + 12), (void *) (v), (n * 2));
9852 gc->pc += cmdlen;
9853 if (__builtin_expect(gc->pc > gc->limit, 0)) {
9854 (void) __glXFlushRenderBuffer(gc, gc->pc);
9855 }
9856 }
9857 }
9858
9859 #define X_GLrop_VertexAttribs2dvNV 4211
9860 void
9861 __indirect_glVertexAttribs2dvNV(GLuint index, GLsizei n, const GLdouble * v)
9862 {
9863 __GLXcontext *const gc = __glXGetCurrentContext();
9864 const GLuint cmdlen = 12 + __GLX_PAD((n * 16));
9865 if (n < 0) {
9866 __glXSetError(gc, GL_INVALID_VALUE);
9867 return;
9868 }
9869 if (__builtin_expect(n >= 0, 1)) {
9870 emit_header(gc->pc, X_GLrop_VertexAttribs2dvNV, cmdlen);
9871 (void) memcpy((void *) (gc->pc + 4), (void *) (&index), 4);
9872 (void) memcpy((void *) (gc->pc + 8), (void *) (&n), 4);
9873 (void) memcpy((void *) (gc->pc + 12), (void *) (v), (n * 16));
9874 gc->pc += cmdlen;
9875 if (__builtin_expect(gc->pc > gc->limit, 0)) {
9876 (void) __glXFlushRenderBuffer(gc, gc->pc);
9877 }
9878 }
9879 }
9880
9881 #define X_GLrop_VertexAttribs2fvNV 4207
9882 void
9883 __indirect_glVertexAttribs2fvNV(GLuint index, GLsizei n, const GLfloat * v)
9884 {
9885 __GLXcontext *const gc = __glXGetCurrentContext();
9886 const GLuint cmdlen = 12 + __GLX_PAD((n * 8));
9887 if (n < 0) {
9888 __glXSetError(gc, GL_INVALID_VALUE);
9889 return;
9890 }
9891 if (__builtin_expect(n >= 0, 1)) {
9892 emit_header(gc->pc, X_GLrop_VertexAttribs2fvNV, cmdlen);
9893 (void) memcpy((void *) (gc->pc + 4), (void *) (&index), 4);
9894 (void) memcpy((void *) (gc->pc + 8), (void *) (&n), 4);
9895 (void) memcpy((void *) (gc->pc + 12), (void *) (v), (n * 8));
9896 gc->pc += cmdlen;
9897 if (__builtin_expect(gc->pc > gc->limit, 0)) {
9898 (void) __glXFlushRenderBuffer(gc, gc->pc);
9899 }
9900 }
9901 }
9902
9903 #define X_GLrop_VertexAttribs2svNV 4203
9904 void
9905 __indirect_glVertexAttribs2svNV(GLuint index, GLsizei n, const GLshort * v)
9906 {
9907 __GLXcontext *const gc = __glXGetCurrentContext();
9908 const GLuint cmdlen = 12 + __GLX_PAD((n * 4));
9909 if (n < 0) {
9910 __glXSetError(gc, GL_INVALID_VALUE);
9911 return;
9912 }
9913 if (__builtin_expect(n >= 0, 1)) {
9914 emit_header(gc->pc, X_GLrop_VertexAttribs2svNV, cmdlen);
9915 (void) memcpy((void *) (gc->pc + 4), (void *) (&index), 4);
9916 (void) memcpy((void *) (gc->pc + 8), (void *) (&n), 4);
9917 (void) memcpy((void *) (gc->pc + 12), (void *) (v), (n * 4));
9918 gc->pc += cmdlen;
9919 if (__builtin_expect(gc->pc > gc->limit, 0)) {
9920 (void) __glXFlushRenderBuffer(gc, gc->pc);
9921 }
9922 }
9923 }
9924
9925 #define X_GLrop_VertexAttribs3dvNV 4212
9926 void
9927 __indirect_glVertexAttribs3dvNV(GLuint index, GLsizei n, const GLdouble * v)
9928 {
9929 __GLXcontext *const gc = __glXGetCurrentContext();
9930 const GLuint cmdlen = 12 + __GLX_PAD((n * 24));
9931 if (n < 0) {
9932 __glXSetError(gc, GL_INVALID_VALUE);
9933 return;
9934 }
9935 if (__builtin_expect(n >= 0, 1)) {
9936 emit_header(gc->pc, X_GLrop_VertexAttribs3dvNV, cmdlen);
9937 (void) memcpy((void *) (gc->pc + 4), (void *) (&index), 4);
9938 (void) memcpy((void *) (gc->pc + 8), (void *) (&n), 4);
9939 (void) memcpy((void *) (gc->pc + 12), (void *) (v), (n * 24));
9940 gc->pc += cmdlen;
9941 if (__builtin_expect(gc->pc > gc->limit, 0)) {
9942 (void) __glXFlushRenderBuffer(gc, gc->pc);
9943 }
9944 }
9945 }
9946
9947 #define X_GLrop_VertexAttribs3fvNV 4208
9948 void
9949 __indirect_glVertexAttribs3fvNV(GLuint index, GLsizei n, const GLfloat * v)
9950 {
9951 __GLXcontext *const gc = __glXGetCurrentContext();
9952 const GLuint cmdlen = 12 + __GLX_PAD((n * 12));
9953 if (n < 0) {
9954 __glXSetError(gc, GL_INVALID_VALUE);
9955 return;
9956 }
9957 if (__builtin_expect(n >= 0, 1)) {
9958 emit_header(gc->pc, X_GLrop_VertexAttribs3fvNV, cmdlen);
9959 (void) memcpy((void *) (gc->pc + 4), (void *) (&index), 4);
9960 (void) memcpy((void *) (gc->pc + 8), (void *) (&n), 4);
9961 (void) memcpy((void *) (gc->pc + 12), (void *) (v), (n * 12));
9962 gc->pc += cmdlen;
9963 if (__builtin_expect(gc->pc > gc->limit, 0)) {
9964 (void) __glXFlushRenderBuffer(gc, gc->pc);
9965 }
9966 }
9967 }
9968
9969 #define X_GLrop_VertexAttribs3svNV 4204
9970 void
9971 __indirect_glVertexAttribs3svNV(GLuint index, GLsizei n, const GLshort * v)
9972 {
9973 __GLXcontext *const gc = __glXGetCurrentContext();
9974 const GLuint cmdlen = 12 + __GLX_PAD((n * 6));
9975 if (n < 0) {
9976 __glXSetError(gc, GL_INVALID_VALUE);
9977 return;
9978 }
9979 if (__builtin_expect(n >= 0, 1)) {
9980 emit_header(gc->pc, X_GLrop_VertexAttribs3svNV, cmdlen);
9981 (void) memcpy((void *) (gc->pc + 4), (void *) (&index), 4);
9982 (void) memcpy((void *) (gc->pc + 8), (void *) (&n), 4);
9983 (void) memcpy((void *) (gc->pc + 12), (void *) (v), (n * 6));
9984 gc->pc += cmdlen;
9985 if (__builtin_expect(gc->pc > gc->limit, 0)) {
9986 (void) __glXFlushRenderBuffer(gc, gc->pc);
9987 }
9988 }
9989 }
9990
9991 #define X_GLrop_VertexAttribs4dvNV 4213
9992 void
9993 __indirect_glVertexAttribs4dvNV(GLuint index, GLsizei n, const GLdouble * v)
9994 {
9995 __GLXcontext *const gc = __glXGetCurrentContext();
9996 const GLuint cmdlen = 12 + __GLX_PAD((n * 32));
9997 if (n < 0) {
9998 __glXSetError(gc, GL_INVALID_VALUE);
9999 return;
10000 }
10001 if (__builtin_expect(n >= 0, 1)) {
10002 emit_header(gc->pc, X_GLrop_VertexAttribs4dvNV, cmdlen);
10003 (void) memcpy((void *) (gc->pc + 4), (void *) (&index), 4);
10004 (void) memcpy((void *) (gc->pc + 8), (void *) (&n), 4);
10005 (void) memcpy((void *) (gc->pc + 12), (void *) (v), (n * 32));
10006 gc->pc += cmdlen;
10007 if (__builtin_expect(gc->pc > gc->limit, 0)) {
10008 (void) __glXFlushRenderBuffer(gc, gc->pc);
10009 }
10010 }
10011 }
10012
10013 #define X_GLrop_VertexAttribs4fvNV 4209
10014 void
10015 __indirect_glVertexAttribs4fvNV(GLuint index, GLsizei n, const GLfloat * v)
10016 {
10017 __GLXcontext *const gc = __glXGetCurrentContext();
10018 const GLuint cmdlen = 12 + __GLX_PAD((n * 16));
10019 if (n < 0) {
10020 __glXSetError(gc, GL_INVALID_VALUE);
10021 return;
10022 }
10023 if (__builtin_expect(n >= 0, 1)) {
10024 emit_header(gc->pc, X_GLrop_VertexAttribs4fvNV, cmdlen);
10025 (void) memcpy((void *) (gc->pc + 4), (void *) (&index), 4);
10026 (void) memcpy((void *) (gc->pc + 8), (void *) (&n), 4);
10027 (void) memcpy((void *) (gc->pc + 12), (void *) (v), (n * 16));
10028 gc->pc += cmdlen;
10029 if (__builtin_expect(gc->pc > gc->limit, 0)) {
10030 (void) __glXFlushRenderBuffer(gc, gc->pc);
10031 }
10032 }
10033 }
10034
10035 #define X_GLrop_VertexAttribs4svNV 4205
10036 void
10037 __indirect_glVertexAttribs4svNV(GLuint index, GLsizei n, const GLshort * v)
10038 {
10039 __GLXcontext *const gc = __glXGetCurrentContext();
10040 const GLuint cmdlen = 12 + __GLX_PAD((n * 8));
10041 if (n < 0) {
10042 __glXSetError(gc, GL_INVALID_VALUE);
10043 return;
10044 }
10045 if (__builtin_expect(n >= 0, 1)) {
10046 emit_header(gc->pc, X_GLrop_VertexAttribs4svNV, cmdlen);
10047 (void) memcpy((void *) (gc->pc + 4), (void *) (&index), 4);
10048 (void) memcpy((void *) (gc->pc + 8), (void *) (&n), 4);
10049 (void) memcpy((void *) (gc->pc + 12), (void *) (v), (n * 8));
10050 gc->pc += cmdlen;
10051 if (__builtin_expect(gc->pc > gc->limit, 0)) {
10052 (void) __glXFlushRenderBuffer(gc, gc->pc);
10053 }
10054 }
10055 }
10056
10057 #define X_GLrop_VertexAttribs4ubvNV 4214
10058 void
10059 __indirect_glVertexAttribs4ubvNV(GLuint index, GLsizei n, const GLubyte *v)
10060 {
10061 __GLXcontext *const gc = __glXGetCurrentContext();
10062 const GLuint cmdlen = 12 + __GLX_PAD((n * 4));
10063 if (n < 0) {
10064 __glXSetError(gc, GL_INVALID_VALUE);
10065 return;
10066 }
10067 if (__builtin_expect(n >= 0, 1)) {
10068 emit_header(gc->pc, X_GLrop_VertexAttribs4ubvNV, cmdlen);
10069 (void) memcpy((void *) (gc->pc + 4), (void *) (&index), 4);
10070 (void) memcpy((void *) (gc->pc + 8), (void *) (&n), 4);
10071 (void) memcpy((void *) (gc->pc + 12), (void *) (v), (n * 4));
10072 gc->pc += cmdlen;
10073 if (__builtin_expect(gc->pc > gc->limit, 0)) {
10074 (void) __glXFlushRenderBuffer(gc, gc->pc);
10075 }
10076 }
10077 }
10078
10079 #define X_GLrop_PointParameteriNV 4221
10080 void
10081 __indirect_glPointParameteriNV(GLenum pname, GLint param)
10082 {
10083 __GLXcontext *const gc = __glXGetCurrentContext();
10084 const GLuint cmdlen = 12;
10085 emit_header(gc->pc, X_GLrop_PointParameteriNV, cmdlen);
10086 (void) memcpy((void *) (gc->pc + 4), (void *) (&pname), 4);
10087 (void) memcpy((void *) (gc->pc + 8), (void *) (&param), 4);
10088 gc->pc += cmdlen;
10089 if (__builtin_expect(gc->pc > gc->limit, 0)) {
10090 (void) __glXFlushRenderBuffer(gc, gc->pc);
10091 }
10092 }
10093
10094 #define X_GLrop_PointParameterivNV 4222
10095 void
10096 __indirect_glPointParameterivNV(GLenum pname, const GLint * params)
10097 {
10098 __GLXcontext *const gc = __glXGetCurrentContext();
10099 const GLuint compsize = __glPointParameterivNV_size(pname);
10100 const GLuint cmdlen = 8 + __GLX_PAD((compsize * 4));
10101 emit_header(gc->pc, X_GLrop_PointParameterivNV, cmdlen);
10102 (void) memcpy((void *) (gc->pc + 4), (void *) (&pname), 4);
10103 (void) memcpy((void *) (gc->pc + 8), (void *) (params), (compsize * 4));
10104 gc->pc += cmdlen;
10105 if (__builtin_expect(gc->pc > gc->limit, 0)) {
10106 (void) __glXFlushRenderBuffer(gc, gc->pc);
10107 }
10108 }
10109
10110 #define X_GLrop_ActiveStencilFaceEXT 4220
10111 void
10112 __indirect_glActiveStencilFaceEXT(GLenum face)
10113 {
10114 __GLXcontext *const gc = __glXGetCurrentContext();
10115 const GLuint cmdlen = 8;
10116 emit_header(gc->pc, X_GLrop_ActiveStencilFaceEXT, cmdlen);
10117 (void) memcpy((void *) (gc->pc + 4), (void *) (&face), 4);
10118 gc->pc += cmdlen;
10119 if (__builtin_expect(gc->pc > gc->limit, 0)) {
10120 (void) __glXFlushRenderBuffer(gc, gc->pc);
10121 }
10122 }
10123
10124 #define X_GLvop_GetProgramNamedParameterdvNV 1311
10125 void
10126 __indirect_glGetProgramNamedParameterdvNV(GLuint id, GLsizei len,
10127 const GLubyte *name,
10128 GLdouble * params)
10129 {
10130 __GLXcontext *const gc = __glXGetCurrentContext();
10131 Display *const dpy = gc->currentDpy;
10132 const GLuint cmdlen = 8 + __GLX_PAD(len);
10133 if (len < 0) {
10134 __glXSetError(gc, GL_INVALID_VALUE);
10135 return;
10136 }
10137 if (__builtin_expect((len >= 0) && (dpy != NULL), 1)) {
10138 GLubyte const *pc =
10139 __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithReply,
10140 X_GLvop_GetProgramNamedParameterdvNV,
10141 cmdlen);
10142 (void) memcpy((void *) (pc + 0), (void *) (&id), 4);
10143 (void) memcpy((void *) (pc + 4), (void *) (&len), 4);
10144 (void) memcpy((void *) (pc + 8), (void *) (name), len);
10145 (void) __glXReadReply(dpy, 8, params, GL_TRUE);
10146 UnlockDisplay(dpy);
10147 SyncHandle();
10148 }
10149 return;
10150 }
10151
10152 #define X_GLvop_GetProgramNamedParameterfvNV 1310
10153 void
10154 __indirect_glGetProgramNamedParameterfvNV(GLuint id, GLsizei len,
10155 const GLubyte *name,
10156 GLfloat * params)
10157 {
10158 __GLXcontext *const gc = __glXGetCurrentContext();
10159 Display *const dpy = gc->currentDpy;
10160 const GLuint cmdlen = 8 + __GLX_PAD(len);
10161 if (len < 0) {
10162 __glXSetError(gc, GL_INVALID_VALUE);
10163 return;
10164 }
10165 if (__builtin_expect((len >= 0) && (dpy != NULL), 1)) {
10166 GLubyte const *pc =
10167 __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithReply,
10168 X_GLvop_GetProgramNamedParameterfvNV,
10169 cmdlen);
10170 (void) memcpy((void *) (pc + 0), (void *) (&id), 4);
10171 (void) memcpy((void *) (pc + 4), (void *) (&len), 4);
10172 (void) memcpy((void *) (pc + 8), (void *) (name), len);
10173 (void) __glXReadReply(dpy, 4, params, GL_TRUE);
10174 UnlockDisplay(dpy);
10175 SyncHandle();
10176 }
10177 return;
10178 }
10179
10180 #define X_GLrop_ProgramNamedParameter4dvNV 4219
10181 void
10182 __indirect_glProgramNamedParameter4dNV(GLuint id, GLsizei len,
10183 const GLubyte *name, GLdouble x,
10184 GLdouble y, GLdouble z, GLdouble w)
10185 {
10186 __GLXcontext *const gc = __glXGetCurrentContext();
10187 const GLuint cmdlen = 44 + __GLX_PAD(len);
10188 if (len < 0) {
10189 __glXSetError(gc, GL_INVALID_VALUE);
10190 return;
10191 }
10192 if (__builtin_expect(len >= 0, 1)) {
10193 emit_header(gc->pc, X_GLrop_ProgramNamedParameter4dvNV, cmdlen);
10194 (void) memcpy((void *) (gc->pc + 4), (void *) (&x), 8);
10195 (void) memcpy((void *) (gc->pc + 12), (void *) (&y), 8);
10196 (void) memcpy((void *) (gc->pc + 20), (void *) (&z), 8);
10197 (void) memcpy((void *) (gc->pc + 28), (void *) (&w), 8);
10198 (void) memcpy((void *) (gc->pc + 36), (void *) (&id), 4);
10199 (void) memcpy((void *) (gc->pc + 40), (void *) (&len), 4);
10200 (void) memcpy((void *) (gc->pc + 44), (void *) (name), len);
10201 gc->pc += cmdlen;
10202 if (__builtin_expect(gc->pc > gc->limit, 0)) {
10203 (void) __glXFlushRenderBuffer(gc, gc->pc);
10204 }
10205 }
10206 }
10207
10208 #define X_GLrop_ProgramNamedParameter4dvNV 4219
10209 void
10210 __indirect_glProgramNamedParameter4dvNV(GLuint id, GLsizei len,
10211 const GLubyte *name,
10212 const GLdouble * v)
10213 {
10214 __GLXcontext *const gc = __glXGetCurrentContext();
10215 const GLuint cmdlen = 44 + __GLX_PAD(len);
10216 if (len < 0) {
10217 __glXSetError(gc, GL_INVALID_VALUE);
10218 return;
10219 }
10220 if (__builtin_expect(len >= 0, 1)) {
10221 emit_header(gc->pc, X_GLrop_ProgramNamedParameter4dvNV, cmdlen);
10222 (void) memcpy((void *) (gc->pc + 4), (void *) (v), 32);
10223 (void) memcpy((void *) (gc->pc + 36), (void *) (&id), 4);
10224 (void) memcpy((void *) (gc->pc + 40), (void *) (&len), 4);
10225 (void) memcpy((void *) (gc->pc + 44), (void *) (name), len);
10226 gc->pc += cmdlen;
10227 if (__builtin_expect(gc->pc > gc->limit, 0)) {
10228 (void) __glXFlushRenderBuffer(gc, gc->pc);
10229 }
10230 }
10231 }
10232
10233 #define X_GLrop_ProgramNamedParameter4fvNV 4218
10234 void
10235 __indirect_glProgramNamedParameter4fNV(GLuint id, GLsizei len,
10236 const GLubyte *name, GLfloat x,
10237 GLfloat y, GLfloat z, GLfloat w)
10238 {
10239 __GLXcontext *const gc = __glXGetCurrentContext();
10240 const GLuint cmdlen = 28 + __GLX_PAD(len);
10241 if (len < 0) {
10242 __glXSetError(gc, GL_INVALID_VALUE);
10243 return;
10244 }
10245 if (__builtin_expect(len >= 0, 1)) {
10246 emit_header(gc->pc, X_GLrop_ProgramNamedParameter4fvNV, cmdlen);
10247 (void) memcpy((void *) (gc->pc + 4), (void *) (&id), 4);
10248 (void) memcpy((void *) (gc->pc + 8), (void *) (&len), 4);
10249 (void) memcpy((void *) (gc->pc + 12), (void *) (&x), 4);
10250 (void) memcpy((void *) (gc->pc + 16), (void *) (&y), 4);
10251 (void) memcpy((void *) (gc->pc + 20), (void *) (&z), 4);
10252 (void) memcpy((void *) (gc->pc + 24), (void *) (&w), 4);
10253 (void) memcpy((void *) (gc->pc + 28), (void *) (name), len);
10254 gc->pc += cmdlen;
10255 if (__builtin_expect(gc->pc > gc->limit, 0)) {
10256 (void) __glXFlushRenderBuffer(gc, gc->pc);
10257 }
10258 }
10259 }
10260
10261 #define X_GLrop_ProgramNamedParameter4fvNV 4218
10262 void
10263 __indirect_glProgramNamedParameter4fvNV(GLuint id, GLsizei len,
10264 const GLubyte *name,
10265 const GLfloat * v)
10266 {
10267 __GLXcontext *const gc = __glXGetCurrentContext();
10268 const GLuint cmdlen = 28 + __GLX_PAD(len);
10269 if (len < 0) {
10270 __glXSetError(gc, GL_INVALID_VALUE);
10271 return;
10272 }
10273 if (__builtin_expect(len >= 0, 1)) {
10274 emit_header(gc->pc, X_GLrop_ProgramNamedParameter4fvNV, cmdlen);
10275 (void) memcpy((void *) (gc->pc + 4), (void *) (&id), 4);
10276 (void) memcpy((void *) (gc->pc + 8), (void *) (&len), 4);
10277 (void) memcpy((void *) (gc->pc + 12), (void *) (v), 16);
10278 (void) memcpy((void *) (gc->pc + 28), (void *) (name), len);
10279 gc->pc += cmdlen;
10280 if (__builtin_expect(gc->pc > gc->limit, 0)) {
10281 (void) __glXFlushRenderBuffer(gc, gc->pc);
10282 }
10283 }
10284 }
10285
10286 #define X_GLrop_BlendEquationSeparateEXT 4228
10287 void
10288 __indirect_glBlendEquationSeparateEXT(GLenum modeRGB, GLenum modeA)
10289 {
10290 __GLXcontext *const gc = __glXGetCurrentContext();
10291 const GLuint cmdlen = 12;
10292 emit_header(gc->pc, X_GLrop_BlendEquationSeparateEXT, cmdlen);
10293 (void) memcpy((void *) (gc->pc + 4), (void *) (&modeRGB), 4);
10294 (void) memcpy((void *) (gc->pc + 8), (void *) (&modeA), 4);
10295 gc->pc += cmdlen;
10296 if (__builtin_expect(gc->pc > gc->limit, 0)) {
10297 (void) __glXFlushRenderBuffer(gc, gc->pc);
10298 }
10299 }
10300
10301 #define X_GLrop_BindFramebufferEXT 4319
10302 void
10303 __indirect_glBindFramebufferEXT(GLenum target, GLuint framebuffer)
10304 {
10305 __GLXcontext *const gc = __glXGetCurrentContext();
10306 const GLuint cmdlen = 12;
10307 emit_header(gc->pc, X_GLrop_BindFramebufferEXT, cmdlen);
10308 (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4);
10309 (void) memcpy((void *) (gc->pc + 8), (void *) (&framebuffer), 4);
10310 gc->pc += cmdlen;
10311 if (__builtin_expect(gc->pc > gc->limit, 0)) {
10312 (void) __glXFlushRenderBuffer(gc, gc->pc);
10313 }
10314 }
10315
10316 #define X_GLrop_BindRenderbufferEXT 4316
10317 void
10318 __indirect_glBindRenderbufferEXT(GLenum target, GLuint renderbuffer)
10319 {
10320 __GLXcontext *const gc = __glXGetCurrentContext();
10321 const GLuint cmdlen = 12;
10322 emit_header(gc->pc, X_GLrop_BindRenderbufferEXT, cmdlen);
10323 (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4);
10324 (void) memcpy((void *) (gc->pc + 8), (void *) (&renderbuffer), 4);
10325 gc->pc += cmdlen;
10326 if (__builtin_expect(gc->pc > gc->limit, 0)) {
10327 (void) __glXFlushRenderBuffer(gc, gc->pc);
10328 }
10329 }
10330
10331 #define X_GLvop_CheckFramebufferStatusEXT 1427
10332 GLenum
10333 __indirect_glCheckFramebufferStatusEXT(GLenum target)
10334 {
10335 __GLXcontext *const gc = __glXGetCurrentContext();
10336 Display *const dpy = gc->currentDpy;
10337 GLenum retval = (GLenum) 0;
10338 const GLuint cmdlen = 4;
10339 if (__builtin_expect(dpy != NULL, 1)) {
10340 GLubyte const *pc =
10341 __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithReply,
10342 X_GLvop_CheckFramebufferStatusEXT,
10343 cmdlen);
10344 (void) memcpy((void *) (pc + 0), (void *) (&target), 4);
10345 retval = (GLenum) __glXReadReply(dpy, 0, NULL, GL_FALSE);
10346 UnlockDisplay(dpy);
10347 SyncHandle();
10348 }
10349 return retval;
10350 }
10351
10352 #define X_GLrop_DeleteFramebuffersEXT 4320
10353 void
10354 __indirect_glDeleteFramebuffersEXT(GLsizei n, const GLuint * framebuffers)
10355 {
10356 __GLXcontext *const gc = __glXGetCurrentContext();
10357 const GLuint cmdlen = 8 + __GLX_PAD((n * 4));
10358 if (n < 0) {
10359 __glXSetError(gc, GL_INVALID_VALUE);
10360 return;
10361 }
10362 if (__builtin_expect(n >= 0, 1)) {
10363 emit_header(gc->pc, X_GLrop_DeleteFramebuffersEXT, cmdlen);
10364 (void) memcpy((void *) (gc->pc + 4), (void *) (&n), 4);
10365 (void) memcpy((void *) (gc->pc + 8), (void *) (framebuffers),
10366 (n * 4));
10367 gc->pc += cmdlen;
10368 if (__builtin_expect(gc->pc > gc->limit, 0)) {
10369 (void) __glXFlushRenderBuffer(gc, gc->pc);
10370 }
10371 }
10372 }
10373
10374 #define X_GLrop_DeleteRenderbuffersEXT 4317
10375 void
10376 __indirect_glDeleteRenderbuffersEXT(GLsizei n, const GLuint * renderbuffers)
10377 {
10378 __GLXcontext *const gc = __glXGetCurrentContext();
10379 const GLuint cmdlen = 8 + __GLX_PAD((n * 4));
10380 if (n < 0) {
10381 __glXSetError(gc, GL_INVALID_VALUE);
10382 return;
10383 }
10384 if (__builtin_expect(n >= 0, 1)) {
10385 emit_header(gc->pc, X_GLrop_DeleteRenderbuffersEXT, cmdlen);
10386 (void) memcpy((void *) (gc->pc + 4), (void *) (&n), 4);
10387 (void) memcpy((void *) (gc->pc + 8), (void *) (renderbuffers),
10388 (n * 4));
10389 gc->pc += cmdlen;
10390 if (__builtin_expect(gc->pc > gc->limit, 0)) {
10391 (void) __glXFlushRenderBuffer(gc, gc->pc);
10392 }
10393 }
10394 }
10395
10396 #define X_GLrop_FramebufferRenderbufferEXT 4324
10397 void
10398 __indirect_glFramebufferRenderbufferEXT(GLenum target, GLenum attachment,
10399 GLenum renderbuffertarget,
10400 GLuint renderbuffer)
10401 {
10402 __GLXcontext *const gc = __glXGetCurrentContext();
10403 const GLuint cmdlen = 20;
10404 emit_header(gc->pc, X_GLrop_FramebufferRenderbufferEXT, cmdlen);
10405 (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4);
10406 (void) memcpy((void *) (gc->pc + 8), (void *) (&attachment), 4);
10407 (void) memcpy((void *) (gc->pc + 12), (void *) (&renderbuffertarget), 4);
10408 (void) memcpy((void *) (gc->pc + 16), (void *) (&renderbuffer), 4);
10409 gc->pc += cmdlen;
10410 if (__builtin_expect(gc->pc > gc->limit, 0)) {
10411 (void) __glXFlushRenderBuffer(gc, gc->pc);
10412 }
10413 }
10414
10415 #define X_GLrop_FramebufferTexture1DEXT 4321
10416 void
10417 __indirect_glFramebufferTexture1DEXT(GLenum target, GLenum attachment,
10418 GLenum textarget, GLuint texture,
10419 GLint level)
10420 {
10421 __GLXcontext *const gc = __glXGetCurrentContext();
10422 const GLuint cmdlen = 24;
10423 emit_header(gc->pc, X_GLrop_FramebufferTexture1DEXT, cmdlen);
10424 (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4);
10425 (void) memcpy((void *) (gc->pc + 8), (void *) (&attachment), 4);
10426 (void) memcpy((void *) (gc->pc + 12), (void *) (&textarget), 4);
10427 (void) memcpy((void *) (gc->pc + 16), (void *) (&texture), 4);
10428 (void) memcpy((void *) (gc->pc + 20), (void *) (&level), 4);
10429 gc->pc += cmdlen;
10430 if (__builtin_expect(gc->pc > gc->limit, 0)) {
10431 (void) __glXFlushRenderBuffer(gc, gc->pc);
10432 }
10433 }
10434
10435 #define X_GLrop_FramebufferTexture2DEXT 4322
10436 void
10437 __indirect_glFramebufferTexture2DEXT(GLenum target, GLenum attachment,
10438 GLenum textarget, GLuint texture,
10439 GLint level)
10440 {
10441 __GLXcontext *const gc = __glXGetCurrentContext();
10442 const GLuint cmdlen = 24;
10443 emit_header(gc->pc, X_GLrop_FramebufferTexture2DEXT, cmdlen);
10444 (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4);
10445 (void) memcpy((void *) (gc->pc + 8), (void *) (&attachment), 4);
10446 (void) memcpy((void *) (gc->pc + 12), (void *) (&textarget), 4);
10447 (void) memcpy((void *) (gc->pc + 16), (void *) (&texture), 4);
10448 (void) memcpy((void *) (gc->pc + 20), (void *) (&level), 4);
10449 gc->pc += cmdlen;
10450 if (__builtin_expect(gc->pc > gc->limit, 0)) {
10451 (void) __glXFlushRenderBuffer(gc, gc->pc);
10452 }
10453 }
10454
10455 #define X_GLrop_FramebufferTexture3DEXT 4323
10456 void
10457 __indirect_glFramebufferTexture3DEXT(GLenum target, GLenum attachment,
10458 GLenum textarget, GLuint texture,
10459 GLint level, GLint zoffset)
10460 {
10461 __GLXcontext *const gc = __glXGetCurrentContext();
10462 const GLuint cmdlen = 28;
10463 emit_header(gc->pc, X_GLrop_FramebufferTexture3DEXT, cmdlen);
10464 (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4);
10465 (void) memcpy((void *) (gc->pc + 8), (void *) (&attachment), 4);
10466 (void) memcpy((void *) (gc->pc + 12), (void *) (&textarget), 4);
10467 (void) memcpy((void *) (gc->pc + 16), (void *) (&texture), 4);
10468 (void) memcpy((void *) (gc->pc + 20), (void *) (&level), 4);
10469 (void) memcpy((void *) (gc->pc + 24), (void *) (&zoffset), 4);
10470 gc->pc += cmdlen;
10471 if (__builtin_expect(gc->pc > gc->limit, 0)) {
10472 (void) __glXFlushRenderBuffer(gc, gc->pc);
10473 }
10474 }
10475
10476 #define X_GLvop_GenFramebuffersEXT 1426
10477 void
10478 __indirect_glGenFramebuffersEXT(GLsizei n, GLuint * framebuffers)
10479 {
10480 __GLXcontext *const gc = __glXGetCurrentContext();
10481 Display *const dpy = gc->currentDpy;
10482 const GLuint cmdlen = 4;
10483 if (n < 0) {
10484 __glXSetError(gc, GL_INVALID_VALUE);
10485 return;
10486 }
10487 if (__builtin_expect((n >= 0) && (dpy != NULL), 1)) {
10488 GLubyte const *pc =
10489 __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithReply,
10490 X_GLvop_GenFramebuffersEXT, cmdlen);
10491 (void) memcpy((void *) (pc + 0), (void *) (&n), 4);
10492 (void) __glXReadReply(dpy, 4, framebuffers, GL_TRUE);
10493 UnlockDisplay(dpy);
10494 SyncHandle();
10495 }
10496 return;
10497 }
10498
10499 #define X_GLvop_GenRenderbuffersEXT 1423
10500 void
10501 __indirect_glGenRenderbuffersEXT(GLsizei n, GLuint * renderbuffers)
10502 {
10503 __GLXcontext *const gc = __glXGetCurrentContext();
10504 Display *const dpy = gc->currentDpy;
10505 const GLuint cmdlen = 4;
10506 if (n < 0) {
10507 __glXSetError(gc, GL_INVALID_VALUE);
10508 return;
10509 }
10510 if (__builtin_expect((n >= 0) && (dpy != NULL), 1)) {
10511 GLubyte const *pc =
10512 __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithReply,
10513 X_GLvop_GenRenderbuffersEXT, cmdlen);
10514 (void) memcpy((void *) (pc + 0), (void *) (&n), 4);
10515 (void) __glXReadReply(dpy, 4, renderbuffers, GL_TRUE);
10516 UnlockDisplay(dpy);
10517 SyncHandle();
10518 }
10519 return;
10520 }
10521
10522 #define X_GLrop_GenerateMipmapEXT 4325
10523 void
10524 __indirect_glGenerateMipmapEXT(GLenum target)
10525 {
10526 __GLXcontext *const gc = __glXGetCurrentContext();
10527 const GLuint cmdlen = 8;
10528 emit_header(gc->pc, X_GLrop_GenerateMipmapEXT, cmdlen);
10529 (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4);
10530 gc->pc += cmdlen;
10531 if (__builtin_expect(gc->pc > gc->limit, 0)) {
10532 (void) __glXFlushRenderBuffer(gc, gc->pc);
10533 }
10534 }
10535
10536 #define X_GLvop_GetFramebufferAttachmentParameterivEXT 1428
10537 void
10538 __indirect_glGetFramebufferAttachmentParameterivEXT(GLenum target,
10539 GLenum attachment,
10540 GLenum pname,
10541 GLint * params)
10542 {
10543 __GLXcontext *const gc = __glXGetCurrentContext();
10544 Display *const dpy = gc->currentDpy;
10545 const GLuint cmdlen = 12;
10546 if (__builtin_expect(dpy != NULL, 1)) {
10547 GLubyte const *pc =
10548 __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithReply,
10549 X_GLvop_GetFramebufferAttachmentParameterivEXT,
10550 cmdlen);
10551 (void) memcpy((void *) (pc + 0), (void *) (&target), 4);
10552 (void) memcpy((void *) (pc + 4), (void *) (&attachment), 4);
10553 (void) memcpy((void *) (pc + 8), (void *) (&pname), 4);
10554 (void) __glXReadReply(dpy, 4, params, GL_FALSE);
10555 UnlockDisplay(dpy);
10556 SyncHandle();
10557 }
10558 return;
10559 }
10560
10561 #define X_GLvop_GetRenderbufferParameterivEXT 1424
10562 void
10563 __indirect_glGetRenderbufferParameterivEXT(GLenum target, GLenum pname,
10564 GLint * params)
10565 {
10566 __GLXcontext *const gc = __glXGetCurrentContext();
10567 Display *const dpy = gc->currentDpy;
10568 const GLuint cmdlen = 8;
10569 if (__builtin_expect(dpy != NULL, 1)) {
10570 GLubyte const *pc =
10571 __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithReply,
10572 X_GLvop_GetRenderbufferParameterivEXT,
10573 cmdlen);
10574 (void) memcpy((void *) (pc + 0), (void *) (&target), 4);
10575 (void) memcpy((void *) (pc + 4), (void *) (&pname), 4);
10576 (void) __glXReadReply(dpy, 4, params, GL_FALSE);
10577 UnlockDisplay(dpy);
10578 SyncHandle();
10579 }
10580 return;
10581 }
10582
10583 #define X_GLvop_IsFramebufferEXT 1425
10584 GLboolean
10585 __indirect_glIsFramebufferEXT(GLuint framebuffer)
10586 {
10587 __GLXcontext *const gc = __glXGetCurrentContext();
10588 Display *const dpy = gc->currentDpy;
10589 GLboolean retval = (GLboolean) 0;
10590 const GLuint cmdlen = 4;
10591 if (__builtin_expect(dpy != NULL, 1)) {
10592 GLubyte const *pc =
10593 __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithReply,
10594 X_GLvop_IsFramebufferEXT, cmdlen);
10595 (void) memcpy((void *) (pc + 0), (void *) (&framebuffer), 4);
10596 retval = (GLboolean) __glXReadReply(dpy, 0, NULL, GL_FALSE);
10597 UnlockDisplay(dpy);
10598 SyncHandle();
10599 }
10600 return retval;
10601 }
10602
10603 #define X_GLvop_IsRenderbufferEXT 1422
10604 GLboolean
10605 __indirect_glIsRenderbufferEXT(GLuint renderbuffer)
10606 {
10607 __GLXcontext *const gc = __glXGetCurrentContext();
10608 Display *const dpy = gc->currentDpy;
10609 GLboolean retval = (GLboolean) 0;
10610 const GLuint cmdlen = 4;
10611 if (__builtin_expect(dpy != NULL, 1)) {
10612 GLubyte const *pc =
10613 __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithReply,
10614 X_GLvop_IsRenderbufferEXT, cmdlen);
10615 (void) memcpy((void *) (pc + 0), (void *) (&renderbuffer), 4);
10616 retval = (GLboolean) __glXReadReply(dpy, 0, NULL, GL_FALSE);
10617 UnlockDisplay(dpy);
10618 SyncHandle();
10619 }
10620 return retval;
10621 }
10622
10623 #define X_GLrop_RenderbufferStorageEXT 4318
10624 void
10625 __indirect_glRenderbufferStorageEXT(GLenum target, GLenum internalformat,
10626 GLsizei width, GLsizei height)
10627 {
10628 __GLXcontext *const gc = __glXGetCurrentContext();
10629 const GLuint cmdlen = 20;
10630 emit_header(gc->pc, X_GLrop_RenderbufferStorageEXT, cmdlen);
10631 (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4);
10632 (void) memcpy((void *) (gc->pc + 8), (void *) (&internalformat), 4);
10633 (void) memcpy((void *) (gc->pc + 12), (void *) (&width), 4);
10634 (void) memcpy((void *) (gc->pc + 16), (void *) (&height), 4);
10635 gc->pc += cmdlen;
10636 if (__builtin_expect(gc->pc > gc->limit, 0)) {
10637 (void) __glXFlushRenderBuffer(gc, gc->pc);
10638 }
10639 }
10640
10641
10642 # undef FASTCALL
10643 # undef NOINLINE