Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(717)

Side by Side Diff: third_party/mesa/chromium_gensrc/mesa/indirect.c

Issue 17028009: Checked in sources which are normally autogenerated during Mesa's build process. (Closed) Base URL: svn://svn.chromium.org/chrome/trunk/deps/
Patch Set: Created 7 years, 6 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View unified diff | Download patch | Annotate | Revision Log
Property Changes:
Added: svn:eol-style
+ LF
OLDNEW
(Empty)
1 /* DO NOT EDIT - This file generated automatically by glX_proto_send.py (from Me sa) 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 "glapi.h"
34 #include "glthread.h"
35 #include <GL/glxproto.h>
36 #ifdef USE_XCB
37 #include <X11/Xlib-xcb.h>
38 #include <xcb/xcb.h>
39 #include <xcb/glx.h>
40 #endif /* USE_XCB */
41
42 #define __GLX_PAD(n) (((n) + 3) & ~3)
43
44 # if defined(__i386__) && defined(__GNUC__) && !defined(__CYGWIN__) && !defined (__MINGW32__)
45 # define FASTCALL __attribute__((fastcall))
46 # else
47 # define FASTCALL
48 # endif
49 # if defined(__GNUC__) || (defined(__SUNPRO_C) && (__SUNPRO_C >= 0x590))
50 # define NOINLINE __attribute__((noinline))
51 # else
52 # define NOINLINE
53 # endif
54
55 #ifndef __GNUC__
56 # define __builtin_expect(x, y) x
57 #endif
58
59 /* If the size and opcode values are known at compile-time, this will, on
60 * x86 at least, emit them with a single instruction.
61 */
62 #define emit_header(dest, op, size) \
63 do { union { short s[2]; int i; } temp; \
64 temp.s[0] = (size); temp.s[1] = (op); \
65 *((int *)(dest)) = temp.i; } while(0)
66
67 NOINLINE CARD32
68 __glXReadReply( Display *dpy, size_t size, void * dest, GLboolean reply_is_alway s_array )
69 {
70 xGLXSingleReply reply;
71
72 (void) _XReply(dpy, (xReply *) & reply, 0, False);
73 if (size != 0) {
74 if ((reply.length > 0) || reply_is_always_array) {
75 const GLint bytes = (reply_is_always_array)
76 ? (4 * reply.length) : (reply.size * size);
77 const GLint extra = 4 - (bytes & 3);
78
79 _XRead(dpy, dest, bytes);
80 if ( extra < 4 ) {
81 _XEatData(dpy, extra);
82 }
83 }
84 else {
85 (void) memcpy( dest, &(reply.pad3), size);
86 }
87 }
88
89 return reply.retval;
90 }
91
92 NOINLINE void
93 __glXReadPixelReply( Display *dpy, struct glx_context * gc, unsigned max_dim,
94 GLint width, GLint height, GLint depth, GLenum format, GLenum type,
95 void * dest, GLboolean dimensions_in_reply )
96 {
97 xGLXSingleReply reply;
98 GLint size;
99
100 (void) _XReply(dpy, (xReply *) & reply, 0, False);
101
102 if ( dimensions_in_reply ) {
103 width = reply.pad3;
104 height = reply.pad4;
105 depth = reply.pad5;
106
107 if ((height == 0) || (max_dim < 2)) { height = 1; }
108 if ((depth == 0) || (max_dim < 3)) { depth = 1; }
109 }
110
111 size = reply.length * 4;
112 if (size != 0) {
113 void * buf = Xmalloc( size );
114
115 if ( buf == NULL ) {
116 _XEatData(dpy, size);
117 __glXSetError(gc, GL_OUT_OF_MEMORY);
118 }
119 else {
120 const GLint extra = 4 - (size & 3);
121
122 _XRead(dpy, buf, size);
123 if ( extra < 4 ) {
124 _XEatData(dpy, extra);
125 }
126
127 __glEmptyImage(gc, 3, width, height, depth, format, type,
128 buf, dest);
129 Xfree(buf);
130 }
131 }
132 }
133
134 #define X_GLXSingle 0
135
136 NOINLINE FASTCALL GLubyte *
137 __glXSetupSingleRequest( struct glx_context * gc, GLint sop, GLint cmdlen )
138 {
139 xGLXSingleReq * req;
140 Display * const dpy = gc->currentDpy;
141
142 (void) __glXFlushRenderBuffer(gc, gc->pc);
143 LockDisplay(dpy);
144 GetReqExtra(GLXSingle, cmdlen, req);
145 req->reqType = gc->majorOpcode;
146 req->contextTag = gc->currentContextTag;
147 req->glxCode = sop;
148 return (GLubyte *)(req) + sz_xGLXSingleReq;
149 }
150
151 NOINLINE FASTCALL GLubyte *
152 __glXSetupVendorRequest( struct glx_context * gc, GLint code, GLint vop, GLint c mdlen )
153 {
154 xGLXVendorPrivateReq * req;
155 Display * const dpy = gc->currentDpy;
156
157 (void) __glXFlushRenderBuffer(gc, gc->pc);
158 LockDisplay(dpy);
159 GetReqExtra(GLXVendorPrivate, cmdlen, req);
160 req->reqType = gc->majorOpcode;
161 req->glxCode = code;
162 req->vendorCode = vop;
163 req->contextTag = gc->currentContextTag;
164 return (GLubyte *)(req) + sz_xGLXVendorPrivateReq;
165 }
166
167 const GLuint __glXDefaultPixelStore[9] = { 0, 0, 0, 0, 0, 0, 0, 0, 1 };
168
169 #define zero (__glXDefaultPixelStore+0)
170 #define one (__glXDefaultPixelStore+8)
171 #define default_pixel_store_1D (__glXDefaultPixelStore+4)
172 #define default_pixel_store_1D_size 20
173 #define default_pixel_store_2D (__glXDefaultPixelStore+4)
174 #define default_pixel_store_2D_size 20
175 #define default_pixel_store_3D (__glXDefaultPixelStore+0)
176 #define default_pixel_store_3D_size 36
177 #define default_pixel_store_4D (__glXDefaultPixelStore+0)
178 #define default_pixel_store_4D_size 36
179
180 static FASTCALL NOINLINE void
181 generic_3_byte( GLint rop, const void * ptr )
182 {
183 struct glx_context * const gc = __glXGetCurrentContext();
184 const GLuint cmdlen = 8;
185
186 emit_header(gc->pc, rop, cmdlen);
187 (void) memcpy((void *)(gc->pc + 4), ptr, 4);
188 gc->pc += cmdlen;
189 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer (gc, gc->pc); }
190 }
191
192 static FASTCALL NOINLINE void
193 generic_4_byte( GLint rop, const void * ptr )
194 {
195 struct glx_context * const gc = __glXGetCurrentContext();
196 const GLuint cmdlen = 8;
197
198 emit_header(gc->pc, rop, cmdlen);
199 (void) memcpy((void *)(gc->pc + 4), ptr, 4);
200 gc->pc += cmdlen;
201 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer (gc, gc->pc); }
202 }
203
204 static FASTCALL NOINLINE void
205 generic_6_byte( GLint rop, const void * ptr )
206 {
207 struct glx_context * const gc = __glXGetCurrentContext();
208 const GLuint cmdlen = 12;
209
210 emit_header(gc->pc, rop, cmdlen);
211 (void) memcpy((void *)(gc->pc + 4), ptr, 8);
212 gc->pc += cmdlen;
213 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer (gc, gc->pc); }
214 }
215
216 static FASTCALL NOINLINE void
217 generic_8_byte( GLint rop, const void * ptr )
218 {
219 struct glx_context * const gc = __glXGetCurrentContext();
220 const GLuint cmdlen = 12;
221
222 emit_header(gc->pc, rop, cmdlen);
223 (void) memcpy((void *)(gc->pc + 4), ptr, 8);
224 gc->pc += cmdlen;
225 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer (gc, gc->pc); }
226 }
227
228 static FASTCALL NOINLINE void
229 generic_12_byte( GLint rop, const void * ptr )
230 {
231 struct glx_context * const gc = __glXGetCurrentContext();
232 const GLuint cmdlen = 16;
233
234 emit_header(gc->pc, rop, cmdlen);
235 (void) memcpy((void *)(gc->pc + 4), ptr, 12);
236 gc->pc += cmdlen;
237 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer (gc, gc->pc); }
238 }
239
240 static FASTCALL NOINLINE void
241 generic_16_byte( GLint rop, const void * ptr )
242 {
243 struct glx_context * const gc = __glXGetCurrentContext();
244 const GLuint cmdlen = 20;
245
246 emit_header(gc->pc, rop, cmdlen);
247 (void) memcpy((void *)(gc->pc + 4), ptr, 16);
248 gc->pc += cmdlen;
249 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer (gc, gc->pc); }
250 }
251
252 static FASTCALL NOINLINE void
253 generic_24_byte( GLint rop, const void * ptr )
254 {
255 struct glx_context * const gc = __glXGetCurrentContext();
256 const GLuint cmdlen = 28;
257
258 emit_header(gc->pc, rop, cmdlen);
259 (void) memcpy((void *)(gc->pc + 4), ptr, 24);
260 gc->pc += cmdlen;
261 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer (gc, gc->pc); }
262 }
263
264 static FASTCALL NOINLINE void
265 generic_32_byte( GLint rop, const void * ptr )
266 {
267 struct glx_context * const gc = __glXGetCurrentContext();
268 const GLuint cmdlen = 36;
269
270 emit_header(gc->pc, rop, cmdlen);
271 (void) memcpy((void *)(gc->pc + 4), ptr, 32);
272 gc->pc += cmdlen;
273 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer (gc, gc->pc); }
274 }
275
276 #define X_GLsop_NewList 101
277 void __indirect_glNewList(GLuint list, GLenum mode)
278 {
279 struct glx_context * const gc = __glXGetCurrentContext();
280 Display * const dpy = gc->currentDpy;
281 #ifndef USE_XCB
282 const GLuint cmdlen = 8;
283 #endif
284 if (__builtin_expect(dpy != NULL, 1)) {
285 #ifdef USE_XCB
286 xcb_connection_t *c = XGetXCBConnection(dpy);
287 (void) __glXFlushRenderBuffer(gc, gc->pc);
288 xcb_glx_new_list(c, gc->currentContextTag, list, mode);
289 #else
290 GLubyte const * pc = __glXSetupSingleRequest(gc, X_GLsop_NewList, cmdlen );
291 (void) memcpy((void *)(pc + 0), (void *)(&list), 4);
292 (void) memcpy((void *)(pc + 4), (void *)(&mode), 4);
293 UnlockDisplay(dpy); SyncHandle();
294 #endif /* USE_XCB */
295 }
296 return;
297 }
298
299 #define X_GLsop_EndList 102
300 void __indirect_glEndList(void)
301 {
302 struct glx_context * const gc = __glXGetCurrentContext();
303 Display * const dpy = gc->currentDpy;
304 #ifndef USE_XCB
305 const GLuint cmdlen = 0;
306 #endif
307 if (__builtin_expect(dpy != NULL, 1)) {
308 #ifdef USE_XCB
309 xcb_connection_t *c = XGetXCBConnection(dpy);
310 (void) __glXFlushRenderBuffer(gc, gc->pc);
311 xcb_glx_end_list(c, gc->currentContextTag);
312 #else
313 (void) __glXSetupSingleRequest(gc, X_GLsop_EndList, cmdlen);
314 UnlockDisplay(dpy); SyncHandle();
315 #endif /* USE_XCB */
316 }
317 return;
318 }
319
320 #define X_GLrop_CallList 1
321 void __indirect_glCallList(GLuint list)
322 {
323 struct glx_context * const gc = __glXGetCurrentContext();
324 const GLuint cmdlen = 8;
325 emit_header(gc->pc, X_GLrop_CallList, cmdlen);
326 (void) memcpy((void *)(gc->pc + 4), (void *)(&list), 4);
327 gc->pc += cmdlen;
328 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
329 }
330
331 #define X_GLrop_CallLists 2
332 void __indirect_glCallLists(GLsizei n, GLenum type, const GLvoid * lists)
333 {
334 struct glx_context * const gc = __glXGetCurrentContext();
335 const GLuint compsize = __glCallLists_size(type);
336 const GLuint cmdlen = 12 + __GLX_PAD((compsize * n));
337 if (n < 0) {
338 __glXSetError(gc, GL_INVALID_VALUE);
339 return;
340 }
341 if (__builtin_expect((n >= 0) && (gc->currentDpy != NULL), 1)) {
342 if (cmdlen <= gc->maxSmallRenderCommandSize) {
343 if ( (gc->pc + cmdlen) > gc->bufEnd ) {
344 (void) __glXFlushRenderBuffer(gc, gc->pc);
345 }
346 emit_header(gc->pc, X_GLrop_CallLists, cmdlen);
347 (void) memcpy((void *)(gc->pc + 4), (void *)(&n), 4);
348 (void) memcpy((void *)(gc->pc + 8), (void *)(&type), 4);
349 (void) memcpy((void *)(gc->pc + 12), (void *)(lists), (compsize * n));
350 gc->pc += cmdlen;
351 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
352 }
353 else {
354 const GLint op = X_GLrop_CallLists;
355 const GLuint cmdlenLarge = cmdlen + 4;
356 GLubyte * const pc = __glXFlushRenderBuffer(gc, gc->pc);
357 (void) memcpy((void *)(pc + 0), (void *)(&cmdlenLarge), 4);
358 (void) memcpy((void *)(pc + 4), (void *)(&op), 4);
359 (void) memcpy((void *)(pc + 8), (void *)(&n), 4);
360 (void) memcpy((void *)(pc + 12), (void *)(&type), 4);
361 __glXSendLargeCommand(gc, pc, 16, lists, (compsize * n));
362 }
363 }
364 }
365
366 #define X_GLsop_DeleteLists 103
367 void __indirect_glDeleteLists(GLuint list, GLsizei range)
368 {
369 struct glx_context * const gc = __glXGetCurrentContext();
370 Display * const dpy = gc->currentDpy;
371 #ifndef USE_XCB
372 const GLuint cmdlen = 8;
373 #endif
374 if (__builtin_expect(dpy != NULL, 1)) {
375 #ifdef USE_XCB
376 xcb_connection_t *c = XGetXCBConnection(dpy);
377 (void) __glXFlushRenderBuffer(gc, gc->pc);
378 xcb_glx_delete_lists(c, gc->currentContextTag, list, range);
379 #else
380 GLubyte const * pc = __glXSetupSingleRequest(gc, X_GLsop_DeleteLists, cm dlen);
381 (void) memcpy((void *)(pc + 0), (void *)(&list), 4);
382 (void) memcpy((void *)(pc + 4), (void *)(&range), 4);
383 UnlockDisplay(dpy); SyncHandle();
384 #endif /* USE_XCB */
385 }
386 return;
387 }
388
389 #define X_GLsop_GenLists 104
390 GLuint __indirect_glGenLists(GLsizei range)
391 {
392 struct glx_context * const gc = __glXGetCurrentContext();
393 Display * const dpy = gc->currentDpy;
394 GLuint retval = (GLuint) 0;
395 #ifndef USE_XCB
396 const GLuint cmdlen = 4;
397 #endif
398 if (__builtin_expect(dpy != NULL, 1)) {
399 #ifdef USE_XCB
400 xcb_connection_t *c = XGetXCBConnection(dpy);
401 (void) __glXFlushRenderBuffer(gc, gc->pc);
402 xcb_glx_gen_lists_reply_t *reply = xcb_glx_gen_lists_reply(c, xcb_glx_ge n_lists(c, gc->currentContextTag, range), NULL);
403 retval = reply->ret_val;
404 free(reply);
405 #else
406 GLubyte const * pc = __glXSetupSingleRequest(gc, X_GLsop_GenLists, cmdle n);
407 (void) memcpy((void *)(pc + 0), (void *)(&range), 4);
408 retval = (GLuint) __glXReadReply(dpy, 0, NULL, GL_FALSE);
409 UnlockDisplay(dpy); SyncHandle();
410 #endif /* USE_XCB */
411 }
412 return retval;
413 }
414
415 #define X_GLrop_ListBase 3
416 void __indirect_glListBase(GLuint base)
417 {
418 struct glx_context * const gc = __glXGetCurrentContext();
419 const GLuint cmdlen = 8;
420 emit_header(gc->pc, X_GLrop_ListBase, cmdlen);
421 (void) memcpy((void *)(gc->pc + 4), (void *)(&base), 4);
422 gc->pc += cmdlen;
423 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
424 }
425
426 #define X_GLrop_Begin 4
427 void __indirect_glBegin(GLenum mode)
428 {
429 struct glx_context * const gc = __glXGetCurrentContext();
430 const GLuint cmdlen = 8;
431 emit_header(gc->pc, X_GLrop_Begin, cmdlen);
432 (void) memcpy((void *)(gc->pc + 4), (void *)(&mode), 4);
433 gc->pc += cmdlen;
434 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
435 }
436
437 #define X_GLrop_Bitmap 5
438 void __indirect_glBitmap(GLsizei width, GLsizei height, GLfloat xorig, GLfloat y orig, GLfloat xmove, GLfloat ymove, const GLubyte * bitmap)
439 {
440 struct glx_context * const gc = __glXGetCurrentContext();
441 const GLuint compsize = (bitmap != NULL) ? __glImageSize(width, height, 1, G L_COLOR_INDEX, GL_BITMAP, 0) : 0;
442 const GLuint cmdlen = 48 + __GLX_PAD(compsize);
443 if (__builtin_expect(gc->currentDpy != NULL, 1)) {
444 if (cmdlen <= gc->maxSmallRenderCommandSize) {
445 if ( (gc->pc + cmdlen) > gc->bufEnd ) {
446 (void) __glXFlushRenderBuffer(gc, gc->pc);
447 }
448 emit_header(gc->pc, X_GLrop_Bitmap, cmdlen);
449 (void) memcpy((void *)(gc->pc + 24), (void *)(&width), 4);
450 (void) memcpy((void *)(gc->pc + 28), (void *)(&height), 4);
451 (void) memcpy((void *)(gc->pc + 32), (void *)(&xorig), 4);
452 (void) memcpy((void *)(gc->pc + 36), (void *)(&yorig), 4);
453 (void) memcpy((void *)(gc->pc + 40), (void *)(&xmove), 4);
454 (void) memcpy((void *)(gc->pc + 44), (void *)(&ymove), 4);
455 if (compsize > 0) {
456 (*gc->fillImage)(gc, 2, width, height, 1, GL_COLOR_INDEX, GL_BITMAP, bitmap, gc->pc + 48, gc->pc + 4);
457 } else {
458 (void) memcpy( gc->pc + 4, default_pixel_store_2D, default_pixel_store_2D_si ze );
459 }
460 gc->pc += cmdlen;
461 if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
462 }
463 else {
464 const GLint op = X_GLrop_Bitmap;
465 const GLuint cmdlenLarge = cmdlen + 4;
466 GLubyte * const pc = __glXFlushRenderBuffer(gc, gc->pc);
467 (void) memcpy((void *)(pc + 0), (void *)(&cmdlenLarge), 4);
468 (void) memcpy((void *)(pc + 4), (void *)(&op), 4);
469 (void) memcpy((void *)(pc + 28), (void *)(&width), 4);
470 (void) memcpy((void *)(pc + 32), (void *)(&height), 4);
471 (void) memcpy((void *)(pc + 36), (void *)(&xorig), 4);
472 (void) memcpy((void *)(pc + 40), (void *)(&yorig), 4);
473 (void) memcpy((void *)(pc + 44), (void *)(&xmove), 4);
474 (void) memcpy((void *)(pc + 48), (void *)(&ymove), 4);
475 __glXSendLargeImage(gc, compsize, 2, width, height, 1, GL_COLOR_INDEX, GL_BITMAP , bitmap, pc + 52, pc + 8);
476 }
477 }
478 }
479
480 #define X_GLrop_Color3bv 6
481 void __indirect_glColor3b(GLbyte red, GLbyte green, GLbyte blue)
482 {
483 struct glx_context * const gc = __glXGetCurrentContext();
484 const GLuint cmdlen = 8;
485 emit_header(gc->pc, X_GLrop_Color3bv, cmdlen);
486 (void) memcpy((void *)(gc->pc + 4), (void *)(&red), 1);
487 (void) memcpy((void *)(gc->pc + 5), (void *)(&green), 1);
488 (void) memcpy((void *)(gc->pc + 6), (void *)(&blue), 1);
489 gc->pc += cmdlen;
490 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
491 }
492
493 #define X_GLrop_Color3bv 6
494 void __indirect_glColor3bv(const GLbyte * v)
495 {
496 generic_3_byte( X_GLrop_Color3bv, v );
497 }
498
499 #define X_GLrop_Color3dv 7
500 void __indirect_glColor3d(GLdouble red, GLdouble green, GLdouble blue)
501 {
502 struct glx_context * const gc = __glXGetCurrentContext();
503 const GLuint cmdlen = 28;
504 emit_header(gc->pc, X_GLrop_Color3dv, cmdlen);
505 (void) memcpy((void *)(gc->pc + 4), (void *)(&red), 8);
506 (void) memcpy((void *)(gc->pc + 12), (void *)(&green), 8);
507 (void) memcpy((void *)(gc->pc + 20), (void *)(&blue), 8);
508 gc->pc += cmdlen;
509 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
510 }
511
512 #define X_GLrop_Color3dv 7
513 void __indirect_glColor3dv(const GLdouble * v)
514 {
515 generic_24_byte( X_GLrop_Color3dv, v );
516 }
517
518 #define X_GLrop_Color3fv 8
519 void __indirect_glColor3f(GLfloat red, GLfloat green, GLfloat blue)
520 {
521 struct glx_context * const gc = __glXGetCurrentContext();
522 const GLuint cmdlen = 16;
523 emit_header(gc->pc, X_GLrop_Color3fv, cmdlen);
524 (void) memcpy((void *)(gc->pc + 4), (void *)(&red), 4);
525 (void) memcpy((void *)(gc->pc + 8), (void *)(&green), 4);
526 (void) memcpy((void *)(gc->pc + 12), (void *)(&blue), 4);
527 gc->pc += cmdlen;
528 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
529 }
530
531 #define X_GLrop_Color3fv 8
532 void __indirect_glColor3fv(const GLfloat * v)
533 {
534 generic_12_byte( X_GLrop_Color3fv, v );
535 }
536
537 #define X_GLrop_Color3iv 9
538 void __indirect_glColor3i(GLint red, GLint green, GLint blue)
539 {
540 struct glx_context * const gc = __glXGetCurrentContext();
541 const GLuint cmdlen = 16;
542 emit_header(gc->pc, X_GLrop_Color3iv, cmdlen);
543 (void) memcpy((void *)(gc->pc + 4), (void *)(&red), 4);
544 (void) memcpy((void *)(gc->pc + 8), (void *)(&green), 4);
545 (void) memcpy((void *)(gc->pc + 12), (void *)(&blue), 4);
546 gc->pc += cmdlen;
547 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
548 }
549
550 #define X_GLrop_Color3iv 9
551 void __indirect_glColor3iv(const GLint * v)
552 {
553 generic_12_byte( X_GLrop_Color3iv, v );
554 }
555
556 #define X_GLrop_Color3sv 10
557 void __indirect_glColor3s(GLshort red, GLshort green, GLshort blue)
558 {
559 struct glx_context * const gc = __glXGetCurrentContext();
560 const GLuint cmdlen = 12;
561 emit_header(gc->pc, X_GLrop_Color3sv, cmdlen);
562 (void) memcpy((void *)(gc->pc + 4), (void *)(&red), 2);
563 (void) memcpy((void *)(gc->pc + 6), (void *)(&green), 2);
564 (void) memcpy((void *)(gc->pc + 8), (void *)(&blue), 2);
565 gc->pc += cmdlen;
566 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
567 }
568
569 #define X_GLrop_Color3sv 10
570 void __indirect_glColor3sv(const GLshort * v)
571 {
572 generic_6_byte( X_GLrop_Color3sv, v );
573 }
574
575 #define X_GLrop_Color3ubv 11
576 void __indirect_glColor3ub(GLubyte red, GLubyte green, GLubyte blue)
577 {
578 struct glx_context * const gc = __glXGetCurrentContext();
579 const GLuint cmdlen = 8;
580 emit_header(gc->pc, X_GLrop_Color3ubv, cmdlen);
581 (void) memcpy((void *)(gc->pc + 4), (void *)(&red), 1);
582 (void) memcpy((void *)(gc->pc + 5), (void *)(&green), 1);
583 (void) memcpy((void *)(gc->pc + 6), (void *)(&blue), 1);
584 gc->pc += cmdlen;
585 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
586 }
587
588 #define X_GLrop_Color3ubv 11
589 void __indirect_glColor3ubv(const GLubyte * v)
590 {
591 generic_3_byte( X_GLrop_Color3ubv, v );
592 }
593
594 #define X_GLrop_Color3uiv 12
595 void __indirect_glColor3ui(GLuint red, GLuint green, GLuint blue)
596 {
597 struct glx_context * const gc = __glXGetCurrentContext();
598 const GLuint cmdlen = 16;
599 emit_header(gc->pc, X_GLrop_Color3uiv, cmdlen);
600 (void) memcpy((void *)(gc->pc + 4), (void *)(&red), 4);
601 (void) memcpy((void *)(gc->pc + 8), (void *)(&green), 4);
602 (void) memcpy((void *)(gc->pc + 12), (void *)(&blue), 4);
603 gc->pc += cmdlen;
604 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
605 }
606
607 #define X_GLrop_Color3uiv 12
608 void __indirect_glColor3uiv(const GLuint * v)
609 {
610 generic_12_byte( X_GLrop_Color3uiv, v );
611 }
612
613 #define X_GLrop_Color3usv 13
614 void __indirect_glColor3us(GLushort red, GLushort green, GLushort blue)
615 {
616 struct glx_context * const gc = __glXGetCurrentContext();
617 const GLuint cmdlen = 12;
618 emit_header(gc->pc, X_GLrop_Color3usv, cmdlen);
619 (void) memcpy((void *)(gc->pc + 4), (void *)(&red), 2);
620 (void) memcpy((void *)(gc->pc + 6), (void *)(&green), 2);
621 (void) memcpy((void *)(gc->pc + 8), (void *)(&blue), 2);
622 gc->pc += cmdlen;
623 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
624 }
625
626 #define X_GLrop_Color3usv 13
627 void __indirect_glColor3usv(const GLushort * v)
628 {
629 generic_6_byte( X_GLrop_Color3usv, v );
630 }
631
632 #define X_GLrop_Color4bv 14
633 void __indirect_glColor4b(GLbyte red, GLbyte green, GLbyte blue, GLbyte alpha)
634 {
635 struct glx_context * const gc = __glXGetCurrentContext();
636 const GLuint cmdlen = 8;
637 emit_header(gc->pc, X_GLrop_Color4bv, cmdlen);
638 (void) memcpy((void *)(gc->pc + 4), (void *)(&red), 1);
639 (void) memcpy((void *)(gc->pc + 5), (void *)(&green), 1);
640 (void) memcpy((void *)(gc->pc + 6), (void *)(&blue), 1);
641 (void) memcpy((void *)(gc->pc + 7), (void *)(&alpha), 1);
642 gc->pc += cmdlen;
643 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
644 }
645
646 #define X_GLrop_Color4bv 14
647 void __indirect_glColor4bv(const GLbyte * v)
648 {
649 generic_4_byte( X_GLrop_Color4bv, v );
650 }
651
652 #define X_GLrop_Color4dv 15
653 void __indirect_glColor4d(GLdouble red, GLdouble green, GLdouble blue, GLdouble alpha)
654 {
655 struct glx_context * const gc = __glXGetCurrentContext();
656 const GLuint cmdlen = 36;
657 emit_header(gc->pc, X_GLrop_Color4dv, cmdlen);
658 (void) memcpy((void *)(gc->pc + 4), (void *)(&red), 8);
659 (void) memcpy((void *)(gc->pc + 12), (void *)(&green), 8);
660 (void) memcpy((void *)(gc->pc + 20), (void *)(&blue), 8);
661 (void) memcpy((void *)(gc->pc + 28), (void *)(&alpha), 8);
662 gc->pc += cmdlen;
663 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
664 }
665
666 #define X_GLrop_Color4dv 15
667 void __indirect_glColor4dv(const GLdouble * v)
668 {
669 generic_32_byte( X_GLrop_Color4dv, v );
670 }
671
672 #define X_GLrop_Color4fv 16
673 void __indirect_glColor4f(GLfloat red, GLfloat green, GLfloat blue, GLfloat alph a)
674 {
675 struct glx_context * const gc = __glXGetCurrentContext();
676 const GLuint cmdlen = 20;
677 emit_header(gc->pc, X_GLrop_Color4fv, cmdlen);
678 (void) memcpy((void *)(gc->pc + 4), (void *)(&red), 4);
679 (void) memcpy((void *)(gc->pc + 8), (void *)(&green), 4);
680 (void) memcpy((void *)(gc->pc + 12), (void *)(&blue), 4);
681 (void) memcpy((void *)(gc->pc + 16), (void *)(&alpha), 4);
682 gc->pc += cmdlen;
683 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
684 }
685
686 #define X_GLrop_Color4fv 16
687 void __indirect_glColor4fv(const GLfloat * v)
688 {
689 generic_16_byte( X_GLrop_Color4fv, v );
690 }
691
692 #define X_GLrop_Color4iv 17
693 void __indirect_glColor4i(GLint red, GLint green, GLint blue, GLint alpha)
694 {
695 struct glx_context * const gc = __glXGetCurrentContext();
696 const GLuint cmdlen = 20;
697 emit_header(gc->pc, X_GLrop_Color4iv, cmdlen);
698 (void) memcpy((void *)(gc->pc + 4), (void *)(&red), 4);
699 (void) memcpy((void *)(gc->pc + 8), (void *)(&green), 4);
700 (void) memcpy((void *)(gc->pc + 12), (void *)(&blue), 4);
701 (void) memcpy((void *)(gc->pc + 16), (void *)(&alpha), 4);
702 gc->pc += cmdlen;
703 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
704 }
705
706 #define X_GLrop_Color4iv 17
707 void __indirect_glColor4iv(const GLint * v)
708 {
709 generic_16_byte( X_GLrop_Color4iv, v );
710 }
711
712 #define X_GLrop_Color4sv 18
713 void __indirect_glColor4s(GLshort red, GLshort green, GLshort blue, GLshort alph a)
714 {
715 struct glx_context * const gc = __glXGetCurrentContext();
716 const GLuint cmdlen = 12;
717 emit_header(gc->pc, X_GLrop_Color4sv, cmdlen);
718 (void) memcpy((void *)(gc->pc + 4), (void *)(&red), 2);
719 (void) memcpy((void *)(gc->pc + 6), (void *)(&green), 2);
720 (void) memcpy((void *)(gc->pc + 8), (void *)(&blue), 2);
721 (void) memcpy((void *)(gc->pc + 10), (void *)(&alpha), 2);
722 gc->pc += cmdlen;
723 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
724 }
725
726 #define X_GLrop_Color4sv 18
727 void __indirect_glColor4sv(const GLshort * v)
728 {
729 generic_8_byte( X_GLrop_Color4sv, v );
730 }
731
732 #define X_GLrop_Color4ubv 19
733 void __indirect_glColor4ub(GLubyte red, GLubyte green, GLubyte blue, GLubyte alp ha)
734 {
735 struct glx_context * const gc = __glXGetCurrentContext();
736 const GLuint cmdlen = 8;
737 emit_header(gc->pc, X_GLrop_Color4ubv, cmdlen);
738 (void) memcpy((void *)(gc->pc + 4), (void *)(&red), 1);
739 (void) memcpy((void *)(gc->pc + 5), (void *)(&green), 1);
740 (void) memcpy((void *)(gc->pc + 6), (void *)(&blue), 1);
741 (void) memcpy((void *)(gc->pc + 7), (void *)(&alpha), 1);
742 gc->pc += cmdlen;
743 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
744 }
745
746 #define X_GLrop_Color4ubv 19
747 void __indirect_glColor4ubv(const GLubyte * v)
748 {
749 generic_4_byte( X_GLrop_Color4ubv, v );
750 }
751
752 #define X_GLrop_Color4uiv 20
753 void __indirect_glColor4ui(GLuint red, GLuint green, GLuint blue, GLuint alpha)
754 {
755 struct glx_context * const gc = __glXGetCurrentContext();
756 const GLuint cmdlen = 20;
757 emit_header(gc->pc, X_GLrop_Color4uiv, cmdlen);
758 (void) memcpy((void *)(gc->pc + 4), (void *)(&red), 4);
759 (void) memcpy((void *)(gc->pc + 8), (void *)(&green), 4);
760 (void) memcpy((void *)(gc->pc + 12), (void *)(&blue), 4);
761 (void) memcpy((void *)(gc->pc + 16), (void *)(&alpha), 4);
762 gc->pc += cmdlen;
763 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
764 }
765
766 #define X_GLrop_Color4uiv 20
767 void __indirect_glColor4uiv(const GLuint * v)
768 {
769 generic_16_byte( X_GLrop_Color4uiv, v );
770 }
771
772 #define X_GLrop_Color4usv 21
773 void __indirect_glColor4us(GLushort red, GLushort green, GLushort blue, GLushort alpha)
774 {
775 struct glx_context * const gc = __glXGetCurrentContext();
776 const GLuint cmdlen = 12;
777 emit_header(gc->pc, X_GLrop_Color4usv, cmdlen);
778 (void) memcpy((void *)(gc->pc + 4), (void *)(&red), 2);
779 (void) memcpy((void *)(gc->pc + 6), (void *)(&green), 2);
780 (void) memcpy((void *)(gc->pc + 8), (void *)(&blue), 2);
781 (void) memcpy((void *)(gc->pc + 10), (void *)(&alpha), 2);
782 gc->pc += cmdlen;
783 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
784 }
785
786 #define X_GLrop_Color4usv 21
787 void __indirect_glColor4usv(const GLushort * v)
788 {
789 generic_8_byte( X_GLrop_Color4usv, v );
790 }
791
792 #define X_GLrop_EdgeFlagv 22
793 void __indirect_glEdgeFlag(GLboolean flag)
794 {
795 struct glx_context * const gc = __glXGetCurrentContext();
796 const GLuint cmdlen = 8;
797 emit_header(gc->pc, X_GLrop_EdgeFlagv, cmdlen);
798 (void) memcpy((void *)(gc->pc + 4), (void *)(&flag), 1);
799 gc->pc += cmdlen;
800 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
801 }
802
803 #define X_GLrop_EdgeFlagv 22
804 void __indirect_glEdgeFlagv(const GLboolean * flag)
805 {
806 struct glx_context * const gc = __glXGetCurrentContext();
807 const GLuint cmdlen = 8;
808 emit_header(gc->pc, X_GLrop_EdgeFlagv, cmdlen);
809 (void) memcpy((void *)(gc->pc + 4), (void *)(flag), 1);
810 gc->pc += cmdlen;
811 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
812 }
813
814 #define X_GLrop_End 23
815 void __indirect_glEnd(void)
816 {
817 struct glx_context * const gc = __glXGetCurrentContext();
818 const GLuint cmdlen = 4;
819 emit_header(gc->pc, X_GLrop_End, cmdlen);
820 gc->pc += cmdlen;
821 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
822 }
823
824 #define X_GLrop_Indexdv 24
825 void __indirect_glIndexd(GLdouble c)
826 {
827 struct glx_context * const gc = __glXGetCurrentContext();
828 const GLuint cmdlen = 12;
829 emit_header(gc->pc, X_GLrop_Indexdv, cmdlen);
830 (void) memcpy((void *)(gc->pc + 4), (void *)(&c), 8);
831 gc->pc += cmdlen;
832 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
833 }
834
835 #define X_GLrop_Indexdv 24
836 void __indirect_glIndexdv(const GLdouble * c)
837 {
838 generic_8_byte( X_GLrop_Indexdv, c );
839 }
840
841 #define X_GLrop_Indexfv 25
842 void __indirect_glIndexf(GLfloat c)
843 {
844 struct glx_context * const gc = __glXGetCurrentContext();
845 const GLuint cmdlen = 8;
846 emit_header(gc->pc, X_GLrop_Indexfv, cmdlen);
847 (void) memcpy((void *)(gc->pc + 4), (void *)(&c), 4);
848 gc->pc += cmdlen;
849 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
850 }
851
852 #define X_GLrop_Indexfv 25
853 void __indirect_glIndexfv(const GLfloat * c)
854 {
855 generic_4_byte( X_GLrop_Indexfv, c );
856 }
857
858 #define X_GLrop_Indexiv 26
859 void __indirect_glIndexi(GLint c)
860 {
861 struct glx_context * const gc = __glXGetCurrentContext();
862 const GLuint cmdlen = 8;
863 emit_header(gc->pc, X_GLrop_Indexiv, cmdlen);
864 (void) memcpy((void *)(gc->pc + 4), (void *)(&c), 4);
865 gc->pc += cmdlen;
866 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
867 }
868
869 #define X_GLrop_Indexiv 26
870 void __indirect_glIndexiv(const GLint * c)
871 {
872 generic_4_byte( X_GLrop_Indexiv, c );
873 }
874
875 #define X_GLrop_Indexsv 27
876 void __indirect_glIndexs(GLshort c)
877 {
878 struct glx_context * const gc = __glXGetCurrentContext();
879 const GLuint cmdlen = 8;
880 emit_header(gc->pc, X_GLrop_Indexsv, cmdlen);
881 (void) memcpy((void *)(gc->pc + 4), (void *)(&c), 2);
882 gc->pc += cmdlen;
883 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
884 }
885
886 #define X_GLrop_Indexsv 27
887 void __indirect_glIndexsv(const GLshort * c)
888 {
889 struct glx_context * const gc = __glXGetCurrentContext();
890 const GLuint cmdlen = 8;
891 emit_header(gc->pc, X_GLrop_Indexsv, cmdlen);
892 (void) memcpy((void *)(gc->pc + 4), (void *)(c), 2);
893 gc->pc += cmdlen;
894 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
895 }
896
897 #define X_GLrop_Normal3bv 28
898 void __indirect_glNormal3b(GLbyte nx, GLbyte ny, GLbyte nz)
899 {
900 struct glx_context * const gc = __glXGetCurrentContext();
901 const GLuint cmdlen = 8;
902 emit_header(gc->pc, X_GLrop_Normal3bv, cmdlen);
903 (void) memcpy((void *)(gc->pc + 4), (void *)(&nx), 1);
904 (void) memcpy((void *)(gc->pc + 5), (void *)(&ny), 1);
905 (void) memcpy((void *)(gc->pc + 6), (void *)(&nz), 1);
906 gc->pc += cmdlen;
907 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
908 }
909
910 #define X_GLrop_Normal3bv 28
911 void __indirect_glNormal3bv(const GLbyte * v)
912 {
913 generic_3_byte( X_GLrop_Normal3bv, v );
914 }
915
916 #define X_GLrop_Normal3dv 29
917 void __indirect_glNormal3d(GLdouble nx, GLdouble ny, GLdouble nz)
918 {
919 struct glx_context * const gc = __glXGetCurrentContext();
920 const GLuint cmdlen = 28;
921 emit_header(gc->pc, X_GLrop_Normal3dv, cmdlen);
922 (void) memcpy((void *)(gc->pc + 4), (void *)(&nx), 8);
923 (void) memcpy((void *)(gc->pc + 12), (void *)(&ny), 8);
924 (void) memcpy((void *)(gc->pc + 20), (void *)(&nz), 8);
925 gc->pc += cmdlen;
926 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
927 }
928
929 #define X_GLrop_Normal3dv 29
930 void __indirect_glNormal3dv(const GLdouble * v)
931 {
932 generic_24_byte( X_GLrop_Normal3dv, v );
933 }
934
935 #define X_GLrop_Normal3fv 30
936 void __indirect_glNormal3f(GLfloat nx, GLfloat ny, GLfloat nz)
937 {
938 struct glx_context * const gc = __glXGetCurrentContext();
939 const GLuint cmdlen = 16;
940 emit_header(gc->pc, X_GLrop_Normal3fv, cmdlen);
941 (void) memcpy((void *)(gc->pc + 4), (void *)(&nx), 4);
942 (void) memcpy((void *)(gc->pc + 8), (void *)(&ny), 4);
943 (void) memcpy((void *)(gc->pc + 12), (void *)(&nz), 4);
944 gc->pc += cmdlen;
945 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
946 }
947
948 #define X_GLrop_Normal3fv 30
949 void __indirect_glNormal3fv(const GLfloat * v)
950 {
951 generic_12_byte( X_GLrop_Normal3fv, v );
952 }
953
954 #define X_GLrop_Normal3iv 31
955 void __indirect_glNormal3i(GLint nx, GLint ny, GLint nz)
956 {
957 struct glx_context * const gc = __glXGetCurrentContext();
958 const GLuint cmdlen = 16;
959 emit_header(gc->pc, X_GLrop_Normal3iv, cmdlen);
960 (void) memcpy((void *)(gc->pc + 4), (void *)(&nx), 4);
961 (void) memcpy((void *)(gc->pc + 8), (void *)(&ny), 4);
962 (void) memcpy((void *)(gc->pc + 12), (void *)(&nz), 4);
963 gc->pc += cmdlen;
964 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
965 }
966
967 #define X_GLrop_Normal3iv 31
968 void __indirect_glNormal3iv(const GLint * v)
969 {
970 generic_12_byte( X_GLrop_Normal3iv, v );
971 }
972
973 #define X_GLrop_Normal3sv 32
974 void __indirect_glNormal3s(GLshort nx, GLshort ny, GLshort nz)
975 {
976 struct glx_context * const gc = __glXGetCurrentContext();
977 const GLuint cmdlen = 12;
978 emit_header(gc->pc, X_GLrop_Normal3sv, cmdlen);
979 (void) memcpy((void *)(gc->pc + 4), (void *)(&nx), 2);
980 (void) memcpy((void *)(gc->pc + 6), (void *)(&ny), 2);
981 (void) memcpy((void *)(gc->pc + 8), (void *)(&nz), 2);
982 gc->pc += cmdlen;
983 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
984 }
985
986 #define X_GLrop_Normal3sv 32
987 void __indirect_glNormal3sv(const GLshort * v)
988 {
989 generic_6_byte( X_GLrop_Normal3sv, v );
990 }
991
992 #define X_GLrop_RasterPos2dv 33
993 void __indirect_glRasterPos2d(GLdouble x, GLdouble y)
994 {
995 struct glx_context * const gc = __glXGetCurrentContext();
996 const GLuint cmdlen = 20;
997 emit_header(gc->pc, X_GLrop_RasterPos2dv, cmdlen);
998 (void) memcpy((void *)(gc->pc + 4), (void *)(&x), 8);
999 (void) memcpy((void *)(gc->pc + 12), (void *)(&y), 8);
1000 gc->pc += cmdlen;
1001 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
1002 }
1003
1004 #define X_GLrop_RasterPos2dv 33
1005 void __indirect_glRasterPos2dv(const GLdouble * v)
1006 {
1007 generic_16_byte( X_GLrop_RasterPos2dv, v );
1008 }
1009
1010 #define X_GLrop_RasterPos2fv 34
1011 void __indirect_glRasterPos2f(GLfloat x, GLfloat y)
1012 {
1013 struct glx_context * const gc = __glXGetCurrentContext();
1014 const GLuint cmdlen = 12;
1015 emit_header(gc->pc, X_GLrop_RasterPos2fv, cmdlen);
1016 (void) memcpy((void *)(gc->pc + 4), (void *)(&x), 4);
1017 (void) memcpy((void *)(gc->pc + 8), (void *)(&y), 4);
1018 gc->pc += cmdlen;
1019 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
1020 }
1021
1022 #define X_GLrop_RasterPos2fv 34
1023 void __indirect_glRasterPos2fv(const GLfloat * v)
1024 {
1025 generic_8_byte( X_GLrop_RasterPos2fv, v );
1026 }
1027
1028 #define X_GLrop_RasterPos2iv 35
1029 void __indirect_glRasterPos2i(GLint x, GLint y)
1030 {
1031 struct glx_context * const gc = __glXGetCurrentContext();
1032 const GLuint cmdlen = 12;
1033 emit_header(gc->pc, X_GLrop_RasterPos2iv, cmdlen);
1034 (void) memcpy((void *)(gc->pc + 4), (void *)(&x), 4);
1035 (void) memcpy((void *)(gc->pc + 8), (void *)(&y), 4);
1036 gc->pc += cmdlen;
1037 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
1038 }
1039
1040 #define X_GLrop_RasterPos2iv 35
1041 void __indirect_glRasterPos2iv(const GLint * v)
1042 {
1043 generic_8_byte( X_GLrop_RasterPos2iv, v );
1044 }
1045
1046 #define X_GLrop_RasterPos2sv 36
1047 void __indirect_glRasterPos2s(GLshort x, GLshort y)
1048 {
1049 struct glx_context * const gc = __glXGetCurrentContext();
1050 const GLuint cmdlen = 8;
1051 emit_header(gc->pc, X_GLrop_RasterPos2sv, cmdlen);
1052 (void) memcpy((void *)(gc->pc + 4), (void *)(&x), 2);
1053 (void) memcpy((void *)(gc->pc + 6), (void *)(&y), 2);
1054 gc->pc += cmdlen;
1055 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
1056 }
1057
1058 #define X_GLrop_RasterPos2sv 36
1059 void __indirect_glRasterPos2sv(const GLshort * v)
1060 {
1061 generic_4_byte( X_GLrop_RasterPos2sv, v );
1062 }
1063
1064 #define X_GLrop_RasterPos3dv 37
1065 void __indirect_glRasterPos3d(GLdouble x, GLdouble y, GLdouble z)
1066 {
1067 struct glx_context * const gc = __glXGetCurrentContext();
1068 const GLuint cmdlen = 28;
1069 emit_header(gc->pc, X_GLrop_RasterPos3dv, cmdlen);
1070 (void) memcpy((void *)(gc->pc + 4), (void *)(&x), 8);
1071 (void) memcpy((void *)(gc->pc + 12), (void *)(&y), 8);
1072 (void) memcpy((void *)(gc->pc + 20), (void *)(&z), 8);
1073 gc->pc += cmdlen;
1074 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
1075 }
1076
1077 #define X_GLrop_RasterPos3dv 37
1078 void __indirect_glRasterPos3dv(const GLdouble * v)
1079 {
1080 generic_24_byte( X_GLrop_RasterPos3dv, v );
1081 }
1082
1083 #define X_GLrop_RasterPos3fv 38
1084 void __indirect_glRasterPos3f(GLfloat x, GLfloat y, GLfloat z)
1085 {
1086 struct glx_context * const gc = __glXGetCurrentContext();
1087 const GLuint cmdlen = 16;
1088 emit_header(gc->pc, X_GLrop_RasterPos3fv, cmdlen);
1089 (void) memcpy((void *)(gc->pc + 4), (void *)(&x), 4);
1090 (void) memcpy((void *)(gc->pc + 8), (void *)(&y), 4);
1091 (void) memcpy((void *)(gc->pc + 12), (void *)(&z), 4);
1092 gc->pc += cmdlen;
1093 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
1094 }
1095
1096 #define X_GLrop_RasterPos3fv 38
1097 void __indirect_glRasterPos3fv(const GLfloat * v)
1098 {
1099 generic_12_byte( X_GLrop_RasterPos3fv, v );
1100 }
1101
1102 #define X_GLrop_RasterPos3iv 39
1103 void __indirect_glRasterPos3i(GLint x, GLint y, GLint z)
1104 {
1105 struct glx_context * const gc = __glXGetCurrentContext();
1106 const GLuint cmdlen = 16;
1107 emit_header(gc->pc, X_GLrop_RasterPos3iv, cmdlen);
1108 (void) memcpy((void *)(gc->pc + 4), (void *)(&x), 4);
1109 (void) memcpy((void *)(gc->pc + 8), (void *)(&y), 4);
1110 (void) memcpy((void *)(gc->pc + 12), (void *)(&z), 4);
1111 gc->pc += cmdlen;
1112 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
1113 }
1114
1115 #define X_GLrop_RasterPos3iv 39
1116 void __indirect_glRasterPos3iv(const GLint * v)
1117 {
1118 generic_12_byte( X_GLrop_RasterPos3iv, v );
1119 }
1120
1121 #define X_GLrop_RasterPos3sv 40
1122 void __indirect_glRasterPos3s(GLshort x, GLshort y, GLshort z)
1123 {
1124 struct glx_context * const gc = __glXGetCurrentContext();
1125 const GLuint cmdlen = 12;
1126 emit_header(gc->pc, X_GLrop_RasterPos3sv, cmdlen);
1127 (void) memcpy((void *)(gc->pc + 4), (void *)(&x), 2);
1128 (void) memcpy((void *)(gc->pc + 6), (void *)(&y), 2);
1129 (void) memcpy((void *)(gc->pc + 8), (void *)(&z), 2);
1130 gc->pc += cmdlen;
1131 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
1132 }
1133
1134 #define X_GLrop_RasterPos3sv 40
1135 void __indirect_glRasterPos3sv(const GLshort * v)
1136 {
1137 generic_6_byte( X_GLrop_RasterPos3sv, v );
1138 }
1139
1140 #define X_GLrop_RasterPos4dv 41
1141 void __indirect_glRasterPos4d(GLdouble x, GLdouble y, GLdouble z, GLdouble w)
1142 {
1143 struct glx_context * const gc = __glXGetCurrentContext();
1144 const GLuint cmdlen = 36;
1145 emit_header(gc->pc, X_GLrop_RasterPos4dv, cmdlen);
1146 (void) memcpy((void *)(gc->pc + 4), (void *)(&x), 8);
1147 (void) memcpy((void *)(gc->pc + 12), (void *)(&y), 8);
1148 (void) memcpy((void *)(gc->pc + 20), (void *)(&z), 8);
1149 (void) memcpy((void *)(gc->pc + 28), (void *)(&w), 8);
1150 gc->pc += cmdlen;
1151 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
1152 }
1153
1154 #define X_GLrop_RasterPos4dv 41
1155 void __indirect_glRasterPos4dv(const GLdouble * v)
1156 {
1157 generic_32_byte( X_GLrop_RasterPos4dv, v );
1158 }
1159
1160 #define X_GLrop_RasterPos4fv 42
1161 void __indirect_glRasterPos4f(GLfloat x, GLfloat y, GLfloat z, GLfloat w)
1162 {
1163 struct glx_context * const gc = __glXGetCurrentContext();
1164 const GLuint cmdlen = 20;
1165 emit_header(gc->pc, X_GLrop_RasterPos4fv, cmdlen);
1166 (void) memcpy((void *)(gc->pc + 4), (void *)(&x), 4);
1167 (void) memcpy((void *)(gc->pc + 8), (void *)(&y), 4);
1168 (void) memcpy((void *)(gc->pc + 12), (void *)(&z), 4);
1169 (void) memcpy((void *)(gc->pc + 16), (void *)(&w), 4);
1170 gc->pc += cmdlen;
1171 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
1172 }
1173
1174 #define X_GLrop_RasterPos4fv 42
1175 void __indirect_glRasterPos4fv(const GLfloat * v)
1176 {
1177 generic_16_byte( X_GLrop_RasterPos4fv, v );
1178 }
1179
1180 #define X_GLrop_RasterPos4iv 43
1181 void __indirect_glRasterPos4i(GLint x, GLint y, GLint z, GLint w)
1182 {
1183 struct glx_context * const gc = __glXGetCurrentContext();
1184 const GLuint cmdlen = 20;
1185 emit_header(gc->pc, X_GLrop_RasterPos4iv, cmdlen);
1186 (void) memcpy((void *)(gc->pc + 4), (void *)(&x), 4);
1187 (void) memcpy((void *)(gc->pc + 8), (void *)(&y), 4);
1188 (void) memcpy((void *)(gc->pc + 12), (void *)(&z), 4);
1189 (void) memcpy((void *)(gc->pc + 16), (void *)(&w), 4);
1190 gc->pc += cmdlen;
1191 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
1192 }
1193
1194 #define X_GLrop_RasterPos4iv 43
1195 void __indirect_glRasterPos4iv(const GLint * v)
1196 {
1197 generic_16_byte( X_GLrop_RasterPos4iv, v );
1198 }
1199
1200 #define X_GLrop_RasterPos4sv 44
1201 void __indirect_glRasterPos4s(GLshort x, GLshort y, GLshort z, GLshort w)
1202 {
1203 struct glx_context * const gc = __glXGetCurrentContext();
1204 const GLuint cmdlen = 12;
1205 emit_header(gc->pc, X_GLrop_RasterPos4sv, cmdlen);
1206 (void) memcpy((void *)(gc->pc + 4), (void *)(&x), 2);
1207 (void) memcpy((void *)(gc->pc + 6), (void *)(&y), 2);
1208 (void) memcpy((void *)(gc->pc + 8), (void *)(&z), 2);
1209 (void) memcpy((void *)(gc->pc + 10), (void *)(&w), 2);
1210 gc->pc += cmdlen;
1211 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
1212 }
1213
1214 #define X_GLrop_RasterPos4sv 44
1215 void __indirect_glRasterPos4sv(const GLshort * v)
1216 {
1217 generic_8_byte( X_GLrop_RasterPos4sv, v );
1218 }
1219
1220 #define X_GLrop_Rectdv 45
1221 void __indirect_glRectd(GLdouble x1, GLdouble y1, GLdouble x2, GLdouble y2)
1222 {
1223 struct glx_context * const gc = __glXGetCurrentContext();
1224 const GLuint cmdlen = 36;
1225 emit_header(gc->pc, X_GLrop_Rectdv, cmdlen);
1226 (void) memcpy((void *)(gc->pc + 4), (void *)(&x1), 8);
1227 (void) memcpy((void *)(gc->pc + 12), (void *)(&y1), 8);
1228 (void) memcpy((void *)(gc->pc + 20), (void *)(&x2), 8);
1229 (void) memcpy((void *)(gc->pc + 28), (void *)(&y2), 8);
1230 gc->pc += cmdlen;
1231 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
1232 }
1233
1234 #define X_GLrop_Rectdv 45
1235 void __indirect_glRectdv(const GLdouble * v1, const GLdouble * v2)
1236 {
1237 struct glx_context * const gc = __glXGetCurrentContext();
1238 const GLuint cmdlen = 36;
1239 emit_header(gc->pc, X_GLrop_Rectdv, cmdlen);
1240 (void) memcpy((void *)(gc->pc + 4), (void *)(v1), 16);
1241 (void) memcpy((void *)(gc->pc + 20), (void *)(v2), 16);
1242 gc->pc += cmdlen;
1243 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
1244 }
1245
1246 #define X_GLrop_Rectfv 46
1247 void __indirect_glRectf(GLfloat x1, GLfloat y1, GLfloat x2, GLfloat y2)
1248 {
1249 struct glx_context * const gc = __glXGetCurrentContext();
1250 const GLuint cmdlen = 20;
1251 emit_header(gc->pc, X_GLrop_Rectfv, cmdlen);
1252 (void) memcpy((void *)(gc->pc + 4), (void *)(&x1), 4);
1253 (void) memcpy((void *)(gc->pc + 8), (void *)(&y1), 4);
1254 (void) memcpy((void *)(gc->pc + 12), (void *)(&x2), 4);
1255 (void) memcpy((void *)(gc->pc + 16), (void *)(&y2), 4);
1256 gc->pc += cmdlen;
1257 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
1258 }
1259
1260 #define X_GLrop_Rectfv 46
1261 void __indirect_glRectfv(const GLfloat * v1, const GLfloat * v2)
1262 {
1263 struct glx_context * const gc = __glXGetCurrentContext();
1264 const GLuint cmdlen = 20;
1265 emit_header(gc->pc, X_GLrop_Rectfv, cmdlen);
1266 (void) memcpy((void *)(gc->pc + 4), (void *)(v1), 8);
1267 (void) memcpy((void *)(gc->pc + 12), (void *)(v2), 8);
1268 gc->pc += cmdlen;
1269 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
1270 }
1271
1272 #define X_GLrop_Rectiv 47
1273 void __indirect_glRecti(GLint x1, GLint y1, GLint x2, GLint y2)
1274 {
1275 struct glx_context * const gc = __glXGetCurrentContext();
1276 const GLuint cmdlen = 20;
1277 emit_header(gc->pc, X_GLrop_Rectiv, cmdlen);
1278 (void) memcpy((void *)(gc->pc + 4), (void *)(&x1), 4);
1279 (void) memcpy((void *)(gc->pc + 8), (void *)(&y1), 4);
1280 (void) memcpy((void *)(gc->pc + 12), (void *)(&x2), 4);
1281 (void) memcpy((void *)(gc->pc + 16), (void *)(&y2), 4);
1282 gc->pc += cmdlen;
1283 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
1284 }
1285
1286 #define X_GLrop_Rectiv 47
1287 void __indirect_glRectiv(const GLint * v1, const GLint * v2)
1288 {
1289 struct glx_context * const gc = __glXGetCurrentContext();
1290 const GLuint cmdlen = 20;
1291 emit_header(gc->pc, X_GLrop_Rectiv, cmdlen);
1292 (void) memcpy((void *)(gc->pc + 4), (void *)(v1), 8);
1293 (void) memcpy((void *)(gc->pc + 12), (void *)(v2), 8);
1294 gc->pc += cmdlen;
1295 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
1296 }
1297
1298 #define X_GLrop_Rectsv 48
1299 void __indirect_glRects(GLshort x1, GLshort y1, GLshort x2, GLshort y2)
1300 {
1301 struct glx_context * const gc = __glXGetCurrentContext();
1302 const GLuint cmdlen = 12;
1303 emit_header(gc->pc, X_GLrop_Rectsv, cmdlen);
1304 (void) memcpy((void *)(gc->pc + 4), (void *)(&x1), 2);
1305 (void) memcpy((void *)(gc->pc + 6), (void *)(&y1), 2);
1306 (void) memcpy((void *)(gc->pc + 8), (void *)(&x2), 2);
1307 (void) memcpy((void *)(gc->pc + 10), (void *)(&y2), 2);
1308 gc->pc += cmdlen;
1309 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
1310 }
1311
1312 #define X_GLrop_Rectsv 48
1313 void __indirect_glRectsv(const GLshort * v1, const GLshort * v2)
1314 {
1315 struct glx_context * const gc = __glXGetCurrentContext();
1316 const GLuint cmdlen = 12;
1317 emit_header(gc->pc, X_GLrop_Rectsv, cmdlen);
1318 (void) memcpy((void *)(gc->pc + 4), (void *)(v1), 4);
1319 (void) memcpy((void *)(gc->pc + 8), (void *)(v2), 4);
1320 gc->pc += cmdlen;
1321 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
1322 }
1323
1324 #define X_GLrop_TexCoord1dv 49
1325 void __indirect_glTexCoord1d(GLdouble s)
1326 {
1327 struct glx_context * const gc = __glXGetCurrentContext();
1328 const GLuint cmdlen = 12;
1329 emit_header(gc->pc, X_GLrop_TexCoord1dv, cmdlen);
1330 (void) memcpy((void *)(gc->pc + 4), (void *)(&s), 8);
1331 gc->pc += cmdlen;
1332 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
1333 }
1334
1335 #define X_GLrop_TexCoord1dv 49
1336 void __indirect_glTexCoord1dv(const GLdouble * v)
1337 {
1338 generic_8_byte( X_GLrop_TexCoord1dv, v );
1339 }
1340
1341 #define X_GLrop_TexCoord1fv 50
1342 void __indirect_glTexCoord1f(GLfloat s)
1343 {
1344 struct glx_context * const gc = __glXGetCurrentContext();
1345 const GLuint cmdlen = 8;
1346 emit_header(gc->pc, X_GLrop_TexCoord1fv, cmdlen);
1347 (void) memcpy((void *)(gc->pc + 4), (void *)(&s), 4);
1348 gc->pc += cmdlen;
1349 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
1350 }
1351
1352 #define X_GLrop_TexCoord1fv 50
1353 void __indirect_glTexCoord1fv(const GLfloat * v)
1354 {
1355 generic_4_byte( X_GLrop_TexCoord1fv, v );
1356 }
1357
1358 #define X_GLrop_TexCoord1iv 51
1359 void __indirect_glTexCoord1i(GLint s)
1360 {
1361 struct glx_context * const gc = __glXGetCurrentContext();
1362 const GLuint cmdlen = 8;
1363 emit_header(gc->pc, X_GLrop_TexCoord1iv, cmdlen);
1364 (void) memcpy((void *)(gc->pc + 4), (void *)(&s), 4);
1365 gc->pc += cmdlen;
1366 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
1367 }
1368
1369 #define X_GLrop_TexCoord1iv 51
1370 void __indirect_glTexCoord1iv(const GLint * v)
1371 {
1372 generic_4_byte( X_GLrop_TexCoord1iv, v );
1373 }
1374
1375 #define X_GLrop_TexCoord1sv 52
1376 void __indirect_glTexCoord1s(GLshort s)
1377 {
1378 struct glx_context * const gc = __glXGetCurrentContext();
1379 const GLuint cmdlen = 8;
1380 emit_header(gc->pc, X_GLrop_TexCoord1sv, cmdlen);
1381 (void) memcpy((void *)(gc->pc + 4), (void *)(&s), 2);
1382 gc->pc += cmdlen;
1383 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
1384 }
1385
1386 #define X_GLrop_TexCoord1sv 52
1387 void __indirect_glTexCoord1sv(const GLshort * v)
1388 {
1389 struct glx_context * const gc = __glXGetCurrentContext();
1390 const GLuint cmdlen = 8;
1391 emit_header(gc->pc, X_GLrop_TexCoord1sv, cmdlen);
1392 (void) memcpy((void *)(gc->pc + 4), (void *)(v), 2);
1393 gc->pc += cmdlen;
1394 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
1395 }
1396
1397 #define X_GLrop_TexCoord2dv 53
1398 void __indirect_glTexCoord2d(GLdouble s, GLdouble t)
1399 {
1400 struct glx_context * const gc = __glXGetCurrentContext();
1401 const GLuint cmdlen = 20;
1402 emit_header(gc->pc, X_GLrop_TexCoord2dv, cmdlen);
1403 (void) memcpy((void *)(gc->pc + 4), (void *)(&s), 8);
1404 (void) memcpy((void *)(gc->pc + 12), (void *)(&t), 8);
1405 gc->pc += cmdlen;
1406 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
1407 }
1408
1409 #define X_GLrop_TexCoord2dv 53
1410 void __indirect_glTexCoord2dv(const GLdouble * v)
1411 {
1412 generic_16_byte( X_GLrop_TexCoord2dv, v );
1413 }
1414
1415 #define X_GLrop_TexCoord2fv 54
1416 void __indirect_glTexCoord2f(GLfloat s, GLfloat t)
1417 {
1418 struct glx_context * const gc = __glXGetCurrentContext();
1419 const GLuint cmdlen = 12;
1420 emit_header(gc->pc, X_GLrop_TexCoord2fv, cmdlen);
1421 (void) memcpy((void *)(gc->pc + 4), (void *)(&s), 4);
1422 (void) memcpy((void *)(gc->pc + 8), (void *)(&t), 4);
1423 gc->pc += cmdlen;
1424 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
1425 }
1426
1427 #define X_GLrop_TexCoord2fv 54
1428 void __indirect_glTexCoord2fv(const GLfloat * v)
1429 {
1430 generic_8_byte( X_GLrop_TexCoord2fv, v );
1431 }
1432
1433 #define X_GLrop_TexCoord2iv 55
1434 void __indirect_glTexCoord2i(GLint s, GLint t)
1435 {
1436 struct glx_context * const gc = __glXGetCurrentContext();
1437 const GLuint cmdlen = 12;
1438 emit_header(gc->pc, X_GLrop_TexCoord2iv, cmdlen);
1439 (void) memcpy((void *)(gc->pc + 4), (void *)(&s), 4);
1440 (void) memcpy((void *)(gc->pc + 8), (void *)(&t), 4);
1441 gc->pc += cmdlen;
1442 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
1443 }
1444
1445 #define X_GLrop_TexCoord2iv 55
1446 void __indirect_glTexCoord2iv(const GLint * v)
1447 {
1448 generic_8_byte( X_GLrop_TexCoord2iv, v );
1449 }
1450
1451 #define X_GLrop_TexCoord2sv 56
1452 void __indirect_glTexCoord2s(GLshort s, GLshort t)
1453 {
1454 struct glx_context * const gc = __glXGetCurrentContext();
1455 const GLuint cmdlen = 8;
1456 emit_header(gc->pc, X_GLrop_TexCoord2sv, cmdlen);
1457 (void) memcpy((void *)(gc->pc + 4), (void *)(&s), 2);
1458 (void) memcpy((void *)(gc->pc + 6), (void *)(&t), 2);
1459 gc->pc += cmdlen;
1460 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
1461 }
1462
1463 #define X_GLrop_TexCoord2sv 56
1464 void __indirect_glTexCoord2sv(const GLshort * v)
1465 {
1466 generic_4_byte( X_GLrop_TexCoord2sv, v );
1467 }
1468
1469 #define X_GLrop_TexCoord3dv 57
1470 void __indirect_glTexCoord3d(GLdouble s, GLdouble t, GLdouble r)
1471 {
1472 struct glx_context * const gc = __glXGetCurrentContext();
1473 const GLuint cmdlen = 28;
1474 emit_header(gc->pc, X_GLrop_TexCoord3dv, cmdlen);
1475 (void) memcpy((void *)(gc->pc + 4), (void *)(&s), 8);
1476 (void) memcpy((void *)(gc->pc + 12), (void *)(&t), 8);
1477 (void) memcpy((void *)(gc->pc + 20), (void *)(&r), 8);
1478 gc->pc += cmdlen;
1479 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
1480 }
1481
1482 #define X_GLrop_TexCoord3dv 57
1483 void __indirect_glTexCoord3dv(const GLdouble * v)
1484 {
1485 generic_24_byte( X_GLrop_TexCoord3dv, v );
1486 }
1487
1488 #define X_GLrop_TexCoord3fv 58
1489 void __indirect_glTexCoord3f(GLfloat s, GLfloat t, GLfloat r)
1490 {
1491 struct glx_context * const gc = __glXGetCurrentContext();
1492 const GLuint cmdlen = 16;
1493 emit_header(gc->pc, X_GLrop_TexCoord3fv, cmdlen);
1494 (void) memcpy((void *)(gc->pc + 4), (void *)(&s), 4);
1495 (void) memcpy((void *)(gc->pc + 8), (void *)(&t), 4);
1496 (void) memcpy((void *)(gc->pc + 12), (void *)(&r), 4);
1497 gc->pc += cmdlen;
1498 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
1499 }
1500
1501 #define X_GLrop_TexCoord3fv 58
1502 void __indirect_glTexCoord3fv(const GLfloat * v)
1503 {
1504 generic_12_byte( X_GLrop_TexCoord3fv, v );
1505 }
1506
1507 #define X_GLrop_TexCoord3iv 59
1508 void __indirect_glTexCoord3i(GLint s, GLint t, GLint r)
1509 {
1510 struct glx_context * const gc = __glXGetCurrentContext();
1511 const GLuint cmdlen = 16;
1512 emit_header(gc->pc, X_GLrop_TexCoord3iv, cmdlen);
1513 (void) memcpy((void *)(gc->pc + 4), (void *)(&s), 4);
1514 (void) memcpy((void *)(gc->pc + 8), (void *)(&t), 4);
1515 (void) memcpy((void *)(gc->pc + 12), (void *)(&r), 4);
1516 gc->pc += cmdlen;
1517 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
1518 }
1519
1520 #define X_GLrop_TexCoord3iv 59
1521 void __indirect_glTexCoord3iv(const GLint * v)
1522 {
1523 generic_12_byte( X_GLrop_TexCoord3iv, v );
1524 }
1525
1526 #define X_GLrop_TexCoord3sv 60
1527 void __indirect_glTexCoord3s(GLshort s, GLshort t, GLshort r)
1528 {
1529 struct glx_context * const gc = __glXGetCurrentContext();
1530 const GLuint cmdlen = 12;
1531 emit_header(gc->pc, X_GLrop_TexCoord3sv, cmdlen);
1532 (void) memcpy((void *)(gc->pc + 4), (void *)(&s), 2);
1533 (void) memcpy((void *)(gc->pc + 6), (void *)(&t), 2);
1534 (void) memcpy((void *)(gc->pc + 8), (void *)(&r), 2);
1535 gc->pc += cmdlen;
1536 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
1537 }
1538
1539 #define X_GLrop_TexCoord3sv 60
1540 void __indirect_glTexCoord3sv(const GLshort * v)
1541 {
1542 generic_6_byte( X_GLrop_TexCoord3sv, v );
1543 }
1544
1545 #define X_GLrop_TexCoord4dv 61
1546 void __indirect_glTexCoord4d(GLdouble s, GLdouble t, GLdouble r, GLdouble q)
1547 {
1548 struct glx_context * const gc = __glXGetCurrentContext();
1549 const GLuint cmdlen = 36;
1550 emit_header(gc->pc, X_GLrop_TexCoord4dv, cmdlen);
1551 (void) memcpy((void *)(gc->pc + 4), (void *)(&s), 8);
1552 (void) memcpy((void *)(gc->pc + 12), (void *)(&t), 8);
1553 (void) memcpy((void *)(gc->pc + 20), (void *)(&r), 8);
1554 (void) memcpy((void *)(gc->pc + 28), (void *)(&q), 8);
1555 gc->pc += cmdlen;
1556 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
1557 }
1558
1559 #define X_GLrop_TexCoord4dv 61
1560 void __indirect_glTexCoord4dv(const GLdouble * v)
1561 {
1562 generic_32_byte( X_GLrop_TexCoord4dv, v );
1563 }
1564
1565 #define X_GLrop_TexCoord4fv 62
1566 void __indirect_glTexCoord4f(GLfloat s, GLfloat t, GLfloat r, GLfloat q)
1567 {
1568 struct glx_context * const gc = __glXGetCurrentContext();
1569 const GLuint cmdlen = 20;
1570 emit_header(gc->pc, X_GLrop_TexCoord4fv, cmdlen);
1571 (void) memcpy((void *)(gc->pc + 4), (void *)(&s), 4);
1572 (void) memcpy((void *)(gc->pc + 8), (void *)(&t), 4);
1573 (void) memcpy((void *)(gc->pc + 12), (void *)(&r), 4);
1574 (void) memcpy((void *)(gc->pc + 16), (void *)(&q), 4);
1575 gc->pc += cmdlen;
1576 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
1577 }
1578
1579 #define X_GLrop_TexCoord4fv 62
1580 void __indirect_glTexCoord4fv(const GLfloat * v)
1581 {
1582 generic_16_byte( X_GLrop_TexCoord4fv, v );
1583 }
1584
1585 #define X_GLrop_TexCoord4iv 63
1586 void __indirect_glTexCoord4i(GLint s, GLint t, GLint r, GLint q)
1587 {
1588 struct glx_context * const gc = __glXGetCurrentContext();
1589 const GLuint cmdlen = 20;
1590 emit_header(gc->pc, X_GLrop_TexCoord4iv, cmdlen);
1591 (void) memcpy((void *)(gc->pc + 4), (void *)(&s), 4);
1592 (void) memcpy((void *)(gc->pc + 8), (void *)(&t), 4);
1593 (void) memcpy((void *)(gc->pc + 12), (void *)(&r), 4);
1594 (void) memcpy((void *)(gc->pc + 16), (void *)(&q), 4);
1595 gc->pc += cmdlen;
1596 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
1597 }
1598
1599 #define X_GLrop_TexCoord4iv 63
1600 void __indirect_glTexCoord4iv(const GLint * v)
1601 {
1602 generic_16_byte( X_GLrop_TexCoord4iv, v );
1603 }
1604
1605 #define X_GLrop_TexCoord4sv 64
1606 void __indirect_glTexCoord4s(GLshort s, GLshort t, GLshort r, GLshort q)
1607 {
1608 struct glx_context * const gc = __glXGetCurrentContext();
1609 const GLuint cmdlen = 12;
1610 emit_header(gc->pc, X_GLrop_TexCoord4sv, cmdlen);
1611 (void) memcpy((void *)(gc->pc + 4), (void *)(&s), 2);
1612 (void) memcpy((void *)(gc->pc + 6), (void *)(&t), 2);
1613 (void) memcpy((void *)(gc->pc + 8), (void *)(&r), 2);
1614 (void) memcpy((void *)(gc->pc + 10), (void *)(&q), 2);
1615 gc->pc += cmdlen;
1616 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
1617 }
1618
1619 #define X_GLrop_TexCoord4sv 64
1620 void __indirect_glTexCoord4sv(const GLshort * v)
1621 {
1622 generic_8_byte( X_GLrop_TexCoord4sv, v );
1623 }
1624
1625 #define X_GLrop_Vertex2dv 65
1626 void __indirect_glVertex2d(GLdouble x, GLdouble y)
1627 {
1628 struct glx_context * const gc = __glXGetCurrentContext();
1629 const GLuint cmdlen = 20;
1630 emit_header(gc->pc, X_GLrop_Vertex2dv, cmdlen);
1631 (void) memcpy((void *)(gc->pc + 4), (void *)(&x), 8);
1632 (void) memcpy((void *)(gc->pc + 12), (void *)(&y), 8);
1633 gc->pc += cmdlen;
1634 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
1635 }
1636
1637 #define X_GLrop_Vertex2dv 65
1638 void __indirect_glVertex2dv(const GLdouble * v)
1639 {
1640 generic_16_byte( X_GLrop_Vertex2dv, v );
1641 }
1642
1643 #define X_GLrop_Vertex2fv 66
1644 void __indirect_glVertex2f(GLfloat x, GLfloat y)
1645 {
1646 struct glx_context * const gc = __glXGetCurrentContext();
1647 const GLuint cmdlen = 12;
1648 emit_header(gc->pc, X_GLrop_Vertex2fv, cmdlen);
1649 (void) memcpy((void *)(gc->pc + 4), (void *)(&x), 4);
1650 (void) memcpy((void *)(gc->pc + 8), (void *)(&y), 4);
1651 gc->pc += cmdlen;
1652 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
1653 }
1654
1655 #define X_GLrop_Vertex2fv 66
1656 void __indirect_glVertex2fv(const GLfloat * v)
1657 {
1658 generic_8_byte( X_GLrop_Vertex2fv, v );
1659 }
1660
1661 #define X_GLrop_Vertex2iv 67
1662 void __indirect_glVertex2i(GLint x, GLint y)
1663 {
1664 struct glx_context * const gc = __glXGetCurrentContext();
1665 const GLuint cmdlen = 12;
1666 emit_header(gc->pc, X_GLrop_Vertex2iv, cmdlen);
1667 (void) memcpy((void *)(gc->pc + 4), (void *)(&x), 4);
1668 (void) memcpy((void *)(gc->pc + 8), (void *)(&y), 4);
1669 gc->pc += cmdlen;
1670 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
1671 }
1672
1673 #define X_GLrop_Vertex2iv 67
1674 void __indirect_glVertex2iv(const GLint * v)
1675 {
1676 generic_8_byte( X_GLrop_Vertex2iv, v );
1677 }
1678
1679 #define X_GLrop_Vertex2sv 68
1680 void __indirect_glVertex2s(GLshort x, GLshort y)
1681 {
1682 struct glx_context * const gc = __glXGetCurrentContext();
1683 const GLuint cmdlen = 8;
1684 emit_header(gc->pc, X_GLrop_Vertex2sv, cmdlen);
1685 (void) memcpy((void *)(gc->pc + 4), (void *)(&x), 2);
1686 (void) memcpy((void *)(gc->pc + 6), (void *)(&y), 2);
1687 gc->pc += cmdlen;
1688 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
1689 }
1690
1691 #define X_GLrop_Vertex2sv 68
1692 void __indirect_glVertex2sv(const GLshort * v)
1693 {
1694 generic_4_byte( X_GLrop_Vertex2sv, v );
1695 }
1696
1697 #define X_GLrop_Vertex3dv 69
1698 void __indirect_glVertex3d(GLdouble x, GLdouble y, GLdouble z)
1699 {
1700 struct glx_context * const gc = __glXGetCurrentContext();
1701 const GLuint cmdlen = 28;
1702 emit_header(gc->pc, X_GLrop_Vertex3dv, cmdlen);
1703 (void) memcpy((void *)(gc->pc + 4), (void *)(&x), 8);
1704 (void) memcpy((void *)(gc->pc + 12), (void *)(&y), 8);
1705 (void) memcpy((void *)(gc->pc + 20), (void *)(&z), 8);
1706 gc->pc += cmdlen;
1707 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
1708 }
1709
1710 #define X_GLrop_Vertex3dv 69
1711 void __indirect_glVertex3dv(const GLdouble * v)
1712 {
1713 generic_24_byte( X_GLrop_Vertex3dv, v );
1714 }
1715
1716 #define X_GLrop_Vertex3fv 70
1717 void __indirect_glVertex3f(GLfloat x, GLfloat y, GLfloat z)
1718 {
1719 struct glx_context * const gc = __glXGetCurrentContext();
1720 const GLuint cmdlen = 16;
1721 emit_header(gc->pc, X_GLrop_Vertex3fv, cmdlen);
1722 (void) memcpy((void *)(gc->pc + 4), (void *)(&x), 4);
1723 (void) memcpy((void *)(gc->pc + 8), (void *)(&y), 4);
1724 (void) memcpy((void *)(gc->pc + 12), (void *)(&z), 4);
1725 gc->pc += cmdlen;
1726 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
1727 }
1728
1729 #define X_GLrop_Vertex3fv 70
1730 void __indirect_glVertex3fv(const GLfloat * v)
1731 {
1732 generic_12_byte( X_GLrop_Vertex3fv, v );
1733 }
1734
1735 #define X_GLrop_Vertex3iv 71
1736 void __indirect_glVertex3i(GLint x, GLint y, GLint z)
1737 {
1738 struct glx_context * const gc = __glXGetCurrentContext();
1739 const GLuint cmdlen = 16;
1740 emit_header(gc->pc, X_GLrop_Vertex3iv, cmdlen);
1741 (void) memcpy((void *)(gc->pc + 4), (void *)(&x), 4);
1742 (void) memcpy((void *)(gc->pc + 8), (void *)(&y), 4);
1743 (void) memcpy((void *)(gc->pc + 12), (void *)(&z), 4);
1744 gc->pc += cmdlen;
1745 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
1746 }
1747
1748 #define X_GLrop_Vertex3iv 71
1749 void __indirect_glVertex3iv(const GLint * v)
1750 {
1751 generic_12_byte( X_GLrop_Vertex3iv, v );
1752 }
1753
1754 #define X_GLrop_Vertex3sv 72
1755 void __indirect_glVertex3s(GLshort x, GLshort y, GLshort z)
1756 {
1757 struct glx_context * const gc = __glXGetCurrentContext();
1758 const GLuint cmdlen = 12;
1759 emit_header(gc->pc, X_GLrop_Vertex3sv, cmdlen);
1760 (void) memcpy((void *)(gc->pc + 4), (void *)(&x), 2);
1761 (void) memcpy((void *)(gc->pc + 6), (void *)(&y), 2);
1762 (void) memcpy((void *)(gc->pc + 8), (void *)(&z), 2);
1763 gc->pc += cmdlen;
1764 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
1765 }
1766
1767 #define X_GLrop_Vertex3sv 72
1768 void __indirect_glVertex3sv(const GLshort * v)
1769 {
1770 generic_6_byte( X_GLrop_Vertex3sv, v );
1771 }
1772
1773 #define X_GLrop_Vertex4dv 73
1774 void __indirect_glVertex4d(GLdouble x, GLdouble y, GLdouble z, GLdouble w)
1775 {
1776 struct glx_context * const gc = __glXGetCurrentContext();
1777 const GLuint cmdlen = 36;
1778 emit_header(gc->pc, X_GLrop_Vertex4dv, cmdlen);
1779 (void) memcpy((void *)(gc->pc + 4), (void *)(&x), 8);
1780 (void) memcpy((void *)(gc->pc + 12), (void *)(&y), 8);
1781 (void) memcpy((void *)(gc->pc + 20), (void *)(&z), 8);
1782 (void) memcpy((void *)(gc->pc + 28), (void *)(&w), 8);
1783 gc->pc += cmdlen;
1784 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
1785 }
1786
1787 #define X_GLrop_Vertex4dv 73
1788 void __indirect_glVertex4dv(const GLdouble * v)
1789 {
1790 generic_32_byte( X_GLrop_Vertex4dv, v );
1791 }
1792
1793 #define X_GLrop_Vertex4fv 74
1794 void __indirect_glVertex4f(GLfloat x, GLfloat y, GLfloat z, GLfloat w)
1795 {
1796 struct glx_context * const gc = __glXGetCurrentContext();
1797 const GLuint cmdlen = 20;
1798 emit_header(gc->pc, X_GLrop_Vertex4fv, cmdlen);
1799 (void) memcpy((void *)(gc->pc + 4), (void *)(&x), 4);
1800 (void) memcpy((void *)(gc->pc + 8), (void *)(&y), 4);
1801 (void) memcpy((void *)(gc->pc + 12), (void *)(&z), 4);
1802 (void) memcpy((void *)(gc->pc + 16), (void *)(&w), 4);
1803 gc->pc += cmdlen;
1804 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
1805 }
1806
1807 #define X_GLrop_Vertex4fv 74
1808 void __indirect_glVertex4fv(const GLfloat * v)
1809 {
1810 generic_16_byte( X_GLrop_Vertex4fv, v );
1811 }
1812
1813 #define X_GLrop_Vertex4iv 75
1814 void __indirect_glVertex4i(GLint x, GLint y, GLint z, GLint w)
1815 {
1816 struct glx_context * const gc = __glXGetCurrentContext();
1817 const GLuint cmdlen = 20;
1818 emit_header(gc->pc, X_GLrop_Vertex4iv, cmdlen);
1819 (void) memcpy((void *)(gc->pc + 4), (void *)(&x), 4);
1820 (void) memcpy((void *)(gc->pc + 8), (void *)(&y), 4);
1821 (void) memcpy((void *)(gc->pc + 12), (void *)(&z), 4);
1822 (void) memcpy((void *)(gc->pc + 16), (void *)(&w), 4);
1823 gc->pc += cmdlen;
1824 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
1825 }
1826
1827 #define X_GLrop_Vertex4iv 75
1828 void __indirect_glVertex4iv(const GLint * v)
1829 {
1830 generic_16_byte( X_GLrop_Vertex4iv, v );
1831 }
1832
1833 #define X_GLrop_Vertex4sv 76
1834 void __indirect_glVertex4s(GLshort x, GLshort y, GLshort z, GLshort w)
1835 {
1836 struct glx_context * const gc = __glXGetCurrentContext();
1837 const GLuint cmdlen = 12;
1838 emit_header(gc->pc, X_GLrop_Vertex4sv, cmdlen);
1839 (void) memcpy((void *)(gc->pc + 4), (void *)(&x), 2);
1840 (void) memcpy((void *)(gc->pc + 6), (void *)(&y), 2);
1841 (void) memcpy((void *)(gc->pc + 8), (void *)(&z), 2);
1842 (void) memcpy((void *)(gc->pc + 10), (void *)(&w), 2);
1843 gc->pc += cmdlen;
1844 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
1845 }
1846
1847 #define X_GLrop_Vertex4sv 76
1848 void __indirect_glVertex4sv(const GLshort * v)
1849 {
1850 generic_8_byte( X_GLrop_Vertex4sv, v );
1851 }
1852
1853 #define X_GLrop_ClipPlane 77
1854 void __indirect_glClipPlane(GLenum plane, const GLdouble * equation)
1855 {
1856 struct glx_context * const gc = __glXGetCurrentContext();
1857 const GLuint cmdlen = 40;
1858 emit_header(gc->pc, X_GLrop_ClipPlane, cmdlen);
1859 (void) memcpy((void *)(gc->pc + 4), (void *)(equation), 32);
1860 (void) memcpy((void *)(gc->pc + 36), (void *)(&plane), 4);
1861 gc->pc += cmdlen;
1862 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
1863 }
1864
1865 #define X_GLrop_ColorMaterial 78
1866 void __indirect_glColorMaterial(GLenum face, GLenum mode)
1867 {
1868 struct glx_context * const gc = __glXGetCurrentContext();
1869 const GLuint cmdlen = 12;
1870 emit_header(gc->pc, X_GLrop_ColorMaterial, cmdlen);
1871 (void) memcpy((void *)(gc->pc + 4), (void *)(&face), 4);
1872 (void) memcpy((void *)(gc->pc + 8), (void *)(&mode), 4);
1873 gc->pc += cmdlen;
1874 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
1875 }
1876
1877 #define X_GLrop_CullFace 79
1878 void __indirect_glCullFace(GLenum mode)
1879 {
1880 struct glx_context * const gc = __glXGetCurrentContext();
1881 const GLuint cmdlen = 8;
1882 emit_header(gc->pc, X_GLrop_CullFace, cmdlen);
1883 (void) memcpy((void *)(gc->pc + 4), (void *)(&mode), 4);
1884 gc->pc += cmdlen;
1885 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
1886 }
1887
1888 #define X_GLrop_Fogf 80
1889 void __indirect_glFogf(GLenum pname, GLfloat param)
1890 {
1891 struct glx_context * const gc = __glXGetCurrentContext();
1892 const GLuint cmdlen = 12;
1893 emit_header(gc->pc, X_GLrop_Fogf, cmdlen);
1894 (void) memcpy((void *)(gc->pc + 4), (void *)(&pname), 4);
1895 (void) memcpy((void *)(gc->pc + 8), (void *)(&param), 4);
1896 gc->pc += cmdlen;
1897 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
1898 }
1899
1900 #define X_GLrop_Fogfv 81
1901 void __indirect_glFogfv(GLenum pname, const GLfloat * params)
1902 {
1903 struct glx_context * const gc = __glXGetCurrentContext();
1904 const GLuint compsize = __glFogfv_size(pname);
1905 const GLuint cmdlen = 8 + __GLX_PAD((compsize * 4));
1906 emit_header(gc->pc, X_GLrop_Fogfv, cmdlen);
1907 (void) memcpy((void *)(gc->pc + 4), (void *)(&pname), 4);
1908 (void) memcpy((void *)(gc->pc + 8), (void *)(params), (compsize * 4));
1909 gc->pc += cmdlen;
1910 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
1911 }
1912
1913 #define X_GLrop_Fogi 82
1914 void __indirect_glFogi(GLenum pname, GLint param)
1915 {
1916 struct glx_context * const gc = __glXGetCurrentContext();
1917 const GLuint cmdlen = 12;
1918 emit_header(gc->pc, X_GLrop_Fogi, cmdlen);
1919 (void) memcpy((void *)(gc->pc + 4), (void *)(&pname), 4);
1920 (void) memcpy((void *)(gc->pc + 8), (void *)(&param), 4);
1921 gc->pc += cmdlen;
1922 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
1923 }
1924
1925 #define X_GLrop_Fogiv 83
1926 void __indirect_glFogiv(GLenum pname, const GLint * params)
1927 {
1928 struct glx_context * const gc = __glXGetCurrentContext();
1929 const GLuint compsize = __glFogiv_size(pname);
1930 const GLuint cmdlen = 8 + __GLX_PAD((compsize * 4));
1931 emit_header(gc->pc, X_GLrop_Fogiv, cmdlen);
1932 (void) memcpy((void *)(gc->pc + 4), (void *)(&pname), 4);
1933 (void) memcpy((void *)(gc->pc + 8), (void *)(params), (compsize * 4));
1934 gc->pc += cmdlen;
1935 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
1936 }
1937
1938 #define X_GLrop_FrontFace 84
1939 void __indirect_glFrontFace(GLenum mode)
1940 {
1941 struct glx_context * const gc = __glXGetCurrentContext();
1942 const GLuint cmdlen = 8;
1943 emit_header(gc->pc, X_GLrop_FrontFace, cmdlen);
1944 (void) memcpy((void *)(gc->pc + 4), (void *)(&mode), 4);
1945 gc->pc += cmdlen;
1946 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
1947 }
1948
1949 #define X_GLrop_Hint 85
1950 void __indirect_glHint(GLenum target, GLenum mode)
1951 {
1952 struct glx_context * const gc = __glXGetCurrentContext();
1953 const GLuint cmdlen = 12;
1954 emit_header(gc->pc, X_GLrop_Hint, cmdlen);
1955 (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
1956 (void) memcpy((void *)(gc->pc + 8), (void *)(&mode), 4);
1957 gc->pc += cmdlen;
1958 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
1959 }
1960
1961 #define X_GLrop_Lightf 86
1962 void __indirect_glLightf(GLenum light, GLenum pname, GLfloat param)
1963 {
1964 struct glx_context * const gc = __glXGetCurrentContext();
1965 const GLuint cmdlen = 16;
1966 emit_header(gc->pc, X_GLrop_Lightf, cmdlen);
1967 (void) memcpy((void *)(gc->pc + 4), (void *)(&light), 4);
1968 (void) memcpy((void *)(gc->pc + 8), (void *)(&pname), 4);
1969 (void) memcpy((void *)(gc->pc + 12), (void *)(&param), 4);
1970 gc->pc += cmdlen;
1971 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
1972 }
1973
1974 #define X_GLrop_Lightfv 87
1975 void __indirect_glLightfv(GLenum light, GLenum pname, const GLfloat * params)
1976 {
1977 struct glx_context * const gc = __glXGetCurrentContext();
1978 const GLuint compsize = __glLightfv_size(pname);
1979 const GLuint cmdlen = 12 + __GLX_PAD((compsize * 4));
1980 emit_header(gc->pc, X_GLrop_Lightfv, cmdlen);
1981 (void) memcpy((void *)(gc->pc + 4), (void *)(&light), 4);
1982 (void) memcpy((void *)(gc->pc + 8), (void *)(&pname), 4);
1983 (void) memcpy((void *)(gc->pc + 12), (void *)(params), (compsize * 4));
1984 gc->pc += cmdlen;
1985 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
1986 }
1987
1988 #define X_GLrop_Lighti 88
1989 void __indirect_glLighti(GLenum light, GLenum pname, GLint param)
1990 {
1991 struct glx_context * const gc = __glXGetCurrentContext();
1992 const GLuint cmdlen = 16;
1993 emit_header(gc->pc, X_GLrop_Lighti, cmdlen);
1994 (void) memcpy((void *)(gc->pc + 4), (void *)(&light), 4);
1995 (void) memcpy((void *)(gc->pc + 8), (void *)(&pname), 4);
1996 (void) memcpy((void *)(gc->pc + 12), (void *)(&param), 4);
1997 gc->pc += cmdlen;
1998 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
1999 }
2000
2001 #define X_GLrop_Lightiv 89
2002 void __indirect_glLightiv(GLenum light, GLenum pname, const GLint * params)
2003 {
2004 struct glx_context * const gc = __glXGetCurrentContext();
2005 const GLuint compsize = __glLightiv_size(pname);
2006 const GLuint cmdlen = 12 + __GLX_PAD((compsize * 4));
2007 emit_header(gc->pc, X_GLrop_Lightiv, cmdlen);
2008 (void) memcpy((void *)(gc->pc + 4), (void *)(&light), 4);
2009 (void) memcpy((void *)(gc->pc + 8), (void *)(&pname), 4);
2010 (void) memcpy((void *)(gc->pc + 12), (void *)(params), (compsize * 4));
2011 gc->pc += cmdlen;
2012 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
2013 }
2014
2015 #define X_GLrop_LightModelf 90
2016 void __indirect_glLightModelf(GLenum pname, GLfloat param)
2017 {
2018 struct glx_context * const gc = __glXGetCurrentContext();
2019 const GLuint cmdlen = 12;
2020 emit_header(gc->pc, X_GLrop_LightModelf, cmdlen);
2021 (void) memcpy((void *)(gc->pc + 4), (void *)(&pname), 4);
2022 (void) memcpy((void *)(gc->pc + 8), (void *)(&param), 4);
2023 gc->pc += cmdlen;
2024 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
2025 }
2026
2027 #define X_GLrop_LightModelfv 91
2028 void __indirect_glLightModelfv(GLenum pname, const GLfloat * params)
2029 {
2030 struct glx_context * const gc = __glXGetCurrentContext();
2031 const GLuint compsize = __glLightModelfv_size(pname);
2032 const GLuint cmdlen = 8 + __GLX_PAD((compsize * 4));
2033 emit_header(gc->pc, X_GLrop_LightModelfv, cmdlen);
2034 (void) memcpy((void *)(gc->pc + 4), (void *)(&pname), 4);
2035 (void) memcpy((void *)(gc->pc + 8), (void *)(params), (compsize * 4));
2036 gc->pc += cmdlen;
2037 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
2038 }
2039
2040 #define X_GLrop_LightModeli 92
2041 void __indirect_glLightModeli(GLenum pname, GLint param)
2042 {
2043 struct glx_context * const gc = __glXGetCurrentContext();
2044 const GLuint cmdlen = 12;
2045 emit_header(gc->pc, X_GLrop_LightModeli, cmdlen);
2046 (void) memcpy((void *)(gc->pc + 4), (void *)(&pname), 4);
2047 (void) memcpy((void *)(gc->pc + 8), (void *)(&param), 4);
2048 gc->pc += cmdlen;
2049 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
2050 }
2051
2052 #define X_GLrop_LightModeliv 93
2053 void __indirect_glLightModeliv(GLenum pname, const GLint * params)
2054 {
2055 struct glx_context * const gc = __glXGetCurrentContext();
2056 const GLuint compsize = __glLightModeliv_size(pname);
2057 const GLuint cmdlen = 8 + __GLX_PAD((compsize * 4));
2058 emit_header(gc->pc, X_GLrop_LightModeliv, cmdlen);
2059 (void) memcpy((void *)(gc->pc + 4), (void *)(&pname), 4);
2060 (void) memcpy((void *)(gc->pc + 8), (void *)(params), (compsize * 4));
2061 gc->pc += cmdlen;
2062 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
2063 }
2064
2065 #define X_GLrop_LineStipple 94
2066 void __indirect_glLineStipple(GLint factor, GLushort pattern)
2067 {
2068 struct glx_context * const gc = __glXGetCurrentContext();
2069 const GLuint cmdlen = 12;
2070 emit_header(gc->pc, X_GLrop_LineStipple, cmdlen);
2071 (void) memcpy((void *)(gc->pc + 4), (void *)(&factor), 4);
2072 (void) memcpy((void *)(gc->pc + 8), (void *)(&pattern), 2);
2073 gc->pc += cmdlen;
2074 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
2075 }
2076
2077 #define X_GLrop_LineWidth 95
2078 void __indirect_glLineWidth(GLfloat width)
2079 {
2080 struct glx_context * const gc = __glXGetCurrentContext();
2081 const GLuint cmdlen = 8;
2082 emit_header(gc->pc, X_GLrop_LineWidth, cmdlen);
2083 (void) memcpy((void *)(gc->pc + 4), (void *)(&width), 4);
2084 gc->pc += cmdlen;
2085 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
2086 }
2087
2088 #define X_GLrop_Materialf 96
2089 void __indirect_glMaterialf(GLenum face, GLenum pname, GLfloat param)
2090 {
2091 struct glx_context * const gc = __glXGetCurrentContext();
2092 const GLuint cmdlen = 16;
2093 emit_header(gc->pc, X_GLrop_Materialf, cmdlen);
2094 (void) memcpy((void *)(gc->pc + 4), (void *)(&face), 4);
2095 (void) memcpy((void *)(gc->pc + 8), (void *)(&pname), 4);
2096 (void) memcpy((void *)(gc->pc + 12), (void *)(&param), 4);
2097 gc->pc += cmdlen;
2098 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
2099 }
2100
2101 #define X_GLrop_Materialfv 97
2102 void __indirect_glMaterialfv(GLenum face, GLenum pname, const GLfloat * params)
2103 {
2104 struct glx_context * const gc = __glXGetCurrentContext();
2105 const GLuint compsize = __glMaterialfv_size(pname);
2106 const GLuint cmdlen = 12 + __GLX_PAD((compsize * 4));
2107 emit_header(gc->pc, X_GLrop_Materialfv, cmdlen);
2108 (void) memcpy((void *)(gc->pc + 4), (void *)(&face), 4);
2109 (void) memcpy((void *)(gc->pc + 8), (void *)(&pname), 4);
2110 (void) memcpy((void *)(gc->pc + 12), (void *)(params), (compsize * 4));
2111 gc->pc += cmdlen;
2112 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
2113 }
2114
2115 #define X_GLrop_Materiali 98
2116 void __indirect_glMateriali(GLenum face, GLenum pname, GLint param)
2117 {
2118 struct glx_context * const gc = __glXGetCurrentContext();
2119 const GLuint cmdlen = 16;
2120 emit_header(gc->pc, X_GLrop_Materiali, cmdlen);
2121 (void) memcpy((void *)(gc->pc + 4), (void *)(&face), 4);
2122 (void) memcpy((void *)(gc->pc + 8), (void *)(&pname), 4);
2123 (void) memcpy((void *)(gc->pc + 12), (void *)(&param), 4);
2124 gc->pc += cmdlen;
2125 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
2126 }
2127
2128 #define X_GLrop_Materialiv 99
2129 void __indirect_glMaterialiv(GLenum face, GLenum pname, const GLint * params)
2130 {
2131 struct glx_context * const gc = __glXGetCurrentContext();
2132 const GLuint compsize = __glMaterialiv_size(pname);
2133 const GLuint cmdlen = 12 + __GLX_PAD((compsize * 4));
2134 emit_header(gc->pc, X_GLrop_Materialiv, cmdlen);
2135 (void) memcpy((void *)(gc->pc + 4), (void *)(&face), 4);
2136 (void) memcpy((void *)(gc->pc + 8), (void *)(&pname), 4);
2137 (void) memcpy((void *)(gc->pc + 12), (void *)(params), (compsize * 4));
2138 gc->pc += cmdlen;
2139 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
2140 }
2141
2142 #define X_GLrop_PointSize 100
2143 void __indirect_glPointSize(GLfloat size)
2144 {
2145 struct glx_context * const gc = __glXGetCurrentContext();
2146 const GLuint cmdlen = 8;
2147 emit_header(gc->pc, X_GLrop_PointSize, cmdlen);
2148 (void) memcpy((void *)(gc->pc + 4), (void *)(&size), 4);
2149 gc->pc += cmdlen;
2150 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
2151 }
2152
2153 #define X_GLrop_PolygonMode 101
2154 void __indirect_glPolygonMode(GLenum face, GLenum mode)
2155 {
2156 struct glx_context * const gc = __glXGetCurrentContext();
2157 const GLuint cmdlen = 12;
2158 emit_header(gc->pc, X_GLrop_PolygonMode, cmdlen);
2159 (void) memcpy((void *)(gc->pc + 4), (void *)(&face), 4);
2160 (void) memcpy((void *)(gc->pc + 8), (void *)(&mode), 4);
2161 gc->pc += cmdlen;
2162 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
2163 }
2164
2165 #define X_GLrop_PolygonStipple 102
2166 void __indirect_glPolygonStipple(const GLubyte * mask)
2167 {
2168 struct glx_context * const gc = __glXGetCurrentContext();
2169 const GLuint compsize = (mask != NULL) ? __glImageSize(32, 32, 1, GL_COLOR_I NDEX, GL_BITMAP, 0) : 0;
2170 const GLuint cmdlen = 24 + __GLX_PAD(compsize);
2171 emit_header(gc->pc, X_GLrop_PolygonStipple, cmdlen);
2172 if (compsize > 0) {
2173 (*gc->fillImage)(gc, 2, 32, 32, 1, GL_COLOR_INDEX, GL_BITMAP, mask, gc->pc + 24, gc->pc + 4);
2174 } else {
2175 (void) memcpy( gc->pc + 4, default_pixel_store_2D, default_pixel_store_2D_si ze );
2176 }
2177 gc->pc += cmdlen;
2178 if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
2179 }
2180
2181 #define X_GLrop_Scissor 103
2182 void __indirect_glScissor(GLint x, GLint y, GLsizei width, GLsizei height)
2183 {
2184 struct glx_context * const gc = __glXGetCurrentContext();
2185 const GLuint cmdlen = 20;
2186 emit_header(gc->pc, X_GLrop_Scissor, cmdlen);
2187 (void) memcpy((void *)(gc->pc + 4), (void *)(&x), 4);
2188 (void) memcpy((void *)(gc->pc + 8), (void *)(&y), 4);
2189 (void) memcpy((void *)(gc->pc + 12), (void *)(&width), 4);
2190 (void) memcpy((void *)(gc->pc + 16), (void *)(&height), 4);
2191 gc->pc += cmdlen;
2192 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
2193 }
2194
2195 #define X_GLrop_ShadeModel 104
2196 void __indirect_glShadeModel(GLenum mode)
2197 {
2198 struct glx_context * const gc = __glXGetCurrentContext();
2199 const GLuint cmdlen = 8;
2200 emit_header(gc->pc, X_GLrop_ShadeModel, cmdlen);
2201 (void) memcpy((void *)(gc->pc + 4), (void *)(&mode), 4);
2202 gc->pc += cmdlen;
2203 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
2204 }
2205
2206 #define X_GLrop_TexParameterf 105
2207 void __indirect_glTexParameterf(GLenum target, GLenum pname, GLfloat param)
2208 {
2209 struct glx_context * const gc = __glXGetCurrentContext();
2210 const GLuint cmdlen = 16;
2211 emit_header(gc->pc, X_GLrop_TexParameterf, cmdlen);
2212 (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
2213 (void) memcpy((void *)(gc->pc + 8), (void *)(&pname), 4);
2214 (void) memcpy((void *)(gc->pc + 12), (void *)(&param), 4);
2215 gc->pc += cmdlen;
2216 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
2217 }
2218
2219 #define X_GLrop_TexParameterfv 106
2220 void __indirect_glTexParameterfv(GLenum target, GLenum pname, const GLfloat * pa rams)
2221 {
2222 struct glx_context * const gc = __glXGetCurrentContext();
2223 const GLuint compsize = __glTexParameterfv_size(pname);
2224 const GLuint cmdlen = 12 + __GLX_PAD((compsize * 4));
2225 emit_header(gc->pc, X_GLrop_TexParameterfv, cmdlen);
2226 (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
2227 (void) memcpy((void *)(gc->pc + 8), (void *)(&pname), 4);
2228 (void) memcpy((void *)(gc->pc + 12), (void *)(params), (compsize * 4));
2229 gc->pc += cmdlen;
2230 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
2231 }
2232
2233 #define X_GLrop_TexParameteri 107
2234 void __indirect_glTexParameteri(GLenum target, GLenum pname, GLint param)
2235 {
2236 struct glx_context * const gc = __glXGetCurrentContext();
2237 const GLuint cmdlen = 16;
2238 emit_header(gc->pc, X_GLrop_TexParameteri, cmdlen);
2239 (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
2240 (void) memcpy((void *)(gc->pc + 8), (void *)(&pname), 4);
2241 (void) memcpy((void *)(gc->pc + 12), (void *)(&param), 4);
2242 gc->pc += cmdlen;
2243 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
2244 }
2245
2246 #define X_GLrop_TexParameteriv 108
2247 void __indirect_glTexParameteriv(GLenum target, GLenum pname, const GLint * para ms)
2248 {
2249 struct glx_context * const gc = __glXGetCurrentContext();
2250 const GLuint compsize = __glTexParameteriv_size(pname);
2251 const GLuint cmdlen = 12 + __GLX_PAD((compsize * 4));
2252 emit_header(gc->pc, X_GLrop_TexParameteriv, cmdlen);
2253 (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
2254 (void) memcpy((void *)(gc->pc + 8), (void *)(&pname), 4);
2255 (void) memcpy((void *)(gc->pc + 12), (void *)(params), (compsize * 4));
2256 gc->pc += cmdlen;
2257 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
2258 }
2259
2260 static void
2261 __glx_TexImage_1D2D( unsigned opcode, unsigned dim, GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format , GLenum type, const GLvoid * pixels )
2262 {
2263 struct glx_context * const gc = __glXGetCurrentContext();
2264 const GLuint compsize = __glImageSize(width, height, 1, format, type, target );
2265 const GLuint cmdlen = 56 + __GLX_PAD(compsize);
2266 if (__builtin_expect(gc->currentDpy != NULL, 1)) {
2267 if (cmdlen <= gc->maxSmallRenderCommandSize) {
2268 if ( (gc->pc + cmdlen) > gc->bufEnd ) {
2269 (void) __glXFlushRenderBuffer(gc, gc->pc);
2270 }
2271 emit_header(gc->pc, opcode, cmdlen);
2272 (void) memcpy((void *)(gc->pc + 24), (void *)(&target), 4);
2273 (void) memcpy((void *)(gc->pc + 28), (void *)(&level), 4);
2274 (void) memcpy((void *)(gc->pc + 32), (void *)(&internalformat), 4);
2275 (void) memcpy((void *)(gc->pc + 36), (void *)(&width), 4);
2276 (void) memcpy((void *)(gc->pc + 40), (void *)(&height), 4);
2277 (void) memcpy((void *)(gc->pc + 44), (void *)(&border), 4);
2278 (void) memcpy((void *)(gc->pc + 48), (void *)(&format), 4);
2279 (void) memcpy((void *)(gc->pc + 52), (void *)(&type), 4);
2280 if ((compsize > 0) && (pixels != NULL)) {
2281 (*gc->fillImage)(gc, dim, width, height, 1, format, type, pixels, gc->pc + 5 6, gc->pc + 4);
2282 } else {
2283 (void) memcpy( gc->pc + 4, default_pixel_store_2D, default_pixel_store_2D_si ze );
2284 }
2285 gc->pc += cmdlen;
2286 if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
2287 }
2288 else {
2289 const GLint op = opcode;
2290 const GLuint cmdlenLarge = cmdlen + 4;
2291 GLubyte * const pc = __glXFlushRenderBuffer(gc, gc->pc);
2292 (void) memcpy((void *)(pc + 0), (void *)(&cmdlenLarge), 4);
2293 (void) memcpy((void *)(pc + 4), (void *)(&op), 4);
2294 (void) memcpy((void *)(pc + 28), (void *)(&target), 4);
2295 (void) memcpy((void *)(pc + 32), (void *)(&level), 4);
2296 (void) memcpy((void *)(pc + 36), (void *)(&internalformat), 4);
2297 (void) memcpy((void *)(pc + 40), (void *)(&width), 4);
2298 (void) memcpy((void *)(pc + 44), (void *)(&height), 4);
2299 (void) memcpy((void *)(pc + 48), (void *)(&border), 4);
2300 (void) memcpy((void *)(pc + 52), (void *)(&format), 4);
2301 (void) memcpy((void *)(pc + 56), (void *)(&type), 4);
2302 __glXSendLargeImage(gc, compsize, dim, width, height, 1, format, type, pixels, p c + 60, pc + 8);
2303 }
2304 }
2305 }
2306
2307 #define X_GLrop_TexImage1D 109
2308 void __indirect_glTexImage1D(GLenum target, GLint level, GLint internalformat, G Lsizei width, GLint border, GLenum format, GLenum type, const GLvoid * pixels)
2309 {
2310 __glx_TexImage_1D2D(X_GLrop_TexImage1D, 1, target, level, internalformat, wi dth, 1, border, format, type, pixels );
2311 }
2312
2313 #define X_GLrop_TexImage2D 110
2314 void __indirect_glTexImage2D(GLenum target, GLint level, GLint internalformat, G Lsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const GL void * pixels)
2315 {
2316 __glx_TexImage_1D2D(X_GLrop_TexImage2D, 2, target, level, internalformat, wi dth, height, border, format, type, pixels );
2317 }
2318
2319 #define X_GLrop_TexEnvf 111
2320 void __indirect_glTexEnvf(GLenum target, GLenum pname, GLfloat param)
2321 {
2322 struct glx_context * const gc = __glXGetCurrentContext();
2323 const GLuint cmdlen = 16;
2324 emit_header(gc->pc, X_GLrop_TexEnvf, cmdlen);
2325 (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
2326 (void) memcpy((void *)(gc->pc + 8), (void *)(&pname), 4);
2327 (void) memcpy((void *)(gc->pc + 12), (void *)(&param), 4);
2328 gc->pc += cmdlen;
2329 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
2330 }
2331
2332 #define X_GLrop_TexEnvfv 112
2333 void __indirect_glTexEnvfv(GLenum target, GLenum pname, const GLfloat * params)
2334 {
2335 struct glx_context * const gc = __glXGetCurrentContext();
2336 const GLuint compsize = __glTexEnvfv_size(pname);
2337 const GLuint cmdlen = 12 + __GLX_PAD((compsize * 4));
2338 emit_header(gc->pc, X_GLrop_TexEnvfv, cmdlen);
2339 (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
2340 (void) memcpy((void *)(gc->pc + 8), (void *)(&pname), 4);
2341 (void) memcpy((void *)(gc->pc + 12), (void *)(params), (compsize * 4));
2342 gc->pc += cmdlen;
2343 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
2344 }
2345
2346 #define X_GLrop_TexEnvi 113
2347 void __indirect_glTexEnvi(GLenum target, GLenum pname, GLint param)
2348 {
2349 struct glx_context * const gc = __glXGetCurrentContext();
2350 const GLuint cmdlen = 16;
2351 emit_header(gc->pc, X_GLrop_TexEnvi, cmdlen);
2352 (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 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)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
2357 }
2358
2359 #define X_GLrop_TexEnviv 114
2360 void __indirect_glTexEnviv(GLenum target, GLenum pname, const GLint * params)
2361 {
2362 struct glx_context * const gc = __glXGetCurrentContext();
2363 const GLuint compsize = __glTexEnviv_size(pname);
2364 const GLuint cmdlen = 12 + __GLX_PAD((compsize * 4));
2365 emit_header(gc->pc, X_GLrop_TexEnviv, cmdlen);
2366 (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
2367 (void) memcpy((void *)(gc->pc + 8), (void *)(&pname), 4);
2368 (void) memcpy((void *)(gc->pc + 12), (void *)(params), (compsize * 4));
2369 gc->pc += cmdlen;
2370 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
2371 }
2372
2373 #define X_GLrop_TexGend 115
2374 void __indirect_glTexGend(GLenum coord, GLenum pname, GLdouble param)
2375 {
2376 struct glx_context * const gc = __glXGetCurrentContext();
2377 const GLuint cmdlen = 20;
2378 emit_header(gc->pc, X_GLrop_TexGend, cmdlen);
2379 (void) memcpy((void *)(gc->pc + 4), (void *)(&param), 8);
2380 (void) memcpy((void *)(gc->pc + 12), (void *)(&coord), 4);
2381 (void) memcpy((void *)(gc->pc + 16), (void *)(&pname), 4);
2382 gc->pc += cmdlen;
2383 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
2384 }
2385
2386 #define X_GLrop_TexGendv 116
2387 void __indirect_glTexGendv(GLenum coord, GLenum pname, const GLdouble * params)
2388 {
2389 struct glx_context * const gc = __glXGetCurrentContext();
2390 const GLuint compsize = __glTexGendv_size(pname);
2391 const GLuint cmdlen = 12 + __GLX_PAD((compsize * 8));
2392 emit_header(gc->pc, X_GLrop_TexGendv, cmdlen);
2393 (void) memcpy((void *)(gc->pc + 4), (void *)(&coord), 4);
2394 (void) memcpy((void *)(gc->pc + 8), (void *)(&pname), 4);
2395 (void) memcpy((void *)(gc->pc + 12), (void *)(params), (compsize * 8));
2396 gc->pc += cmdlen;
2397 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
2398 }
2399
2400 #define X_GLrop_TexGenf 117
2401 void __indirect_glTexGenf(GLenum coord, GLenum pname, GLfloat param)
2402 {
2403 struct glx_context * const gc = __glXGetCurrentContext();
2404 const GLuint cmdlen = 16;
2405 emit_header(gc->pc, X_GLrop_TexGenf, cmdlen);
2406 (void) memcpy((void *)(gc->pc + 4), (void *)(&coord), 4);
2407 (void) memcpy((void *)(gc->pc + 8), (void *)(&pname), 4);
2408 (void) memcpy((void *)(gc->pc + 12), (void *)(&param), 4);
2409 gc->pc += cmdlen;
2410 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
2411 }
2412
2413 #define X_GLrop_TexGenfv 118
2414 void __indirect_glTexGenfv(GLenum coord, GLenum pname, const GLfloat * params)
2415 {
2416 struct glx_context * const gc = __glXGetCurrentContext();
2417 const GLuint compsize = __glTexGenfv_size(pname);
2418 const GLuint cmdlen = 12 + __GLX_PAD((compsize * 4));
2419 emit_header(gc->pc, X_GLrop_TexGenfv, cmdlen);
2420 (void) memcpy((void *)(gc->pc + 4), (void *)(&coord), 4);
2421 (void) memcpy((void *)(gc->pc + 8), (void *)(&pname), 4);
2422 (void) memcpy((void *)(gc->pc + 12), (void *)(params), (compsize * 4));
2423 gc->pc += cmdlen;
2424 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
2425 }
2426
2427 #define X_GLrop_TexGeni 119
2428 void __indirect_glTexGeni(GLenum coord, GLenum pname, GLint param)
2429 {
2430 struct glx_context * const gc = __glXGetCurrentContext();
2431 const GLuint cmdlen = 16;
2432 emit_header(gc->pc, X_GLrop_TexGeni, cmdlen);
2433 (void) memcpy((void *)(gc->pc + 4), (void *)(&coord), 4);
2434 (void) memcpy((void *)(gc->pc + 8), (void *)(&pname), 4);
2435 (void) memcpy((void *)(gc->pc + 12), (void *)(&param), 4);
2436 gc->pc += cmdlen;
2437 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
2438 }
2439
2440 #define X_GLrop_TexGeniv 120
2441 void __indirect_glTexGeniv(GLenum coord, GLenum pname, const GLint * params)
2442 {
2443 struct glx_context * const gc = __glXGetCurrentContext();
2444 const GLuint compsize = __glTexGeniv_size(pname);
2445 const GLuint cmdlen = 12 + __GLX_PAD((compsize * 4));
2446 emit_header(gc->pc, X_GLrop_TexGeniv, cmdlen);
2447 (void) memcpy((void *)(gc->pc + 4), (void *)(&coord), 4);
2448 (void) memcpy((void *)(gc->pc + 8), (void *)(&pname), 4);
2449 (void) memcpy((void *)(gc->pc + 12), (void *)(params), (compsize * 4));
2450 gc->pc += cmdlen;
2451 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
2452 }
2453
2454 #define X_GLrop_InitNames 121
2455 void __indirect_glInitNames(void)
2456 {
2457 struct glx_context * const gc = __glXGetCurrentContext();
2458 const GLuint cmdlen = 4;
2459 emit_header(gc->pc, X_GLrop_InitNames, cmdlen);
2460 gc->pc += cmdlen;
2461 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
2462 }
2463
2464 #define X_GLrop_LoadName 122
2465 void __indirect_glLoadName(GLuint name)
2466 {
2467 struct glx_context * const gc = __glXGetCurrentContext();
2468 const GLuint cmdlen = 8;
2469 emit_header(gc->pc, X_GLrop_LoadName, cmdlen);
2470 (void) memcpy((void *)(gc->pc + 4), (void *)(&name), 4);
2471 gc->pc += cmdlen;
2472 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
2473 }
2474
2475 #define X_GLrop_PassThrough 123
2476 void __indirect_glPassThrough(GLfloat token)
2477 {
2478 struct glx_context * const gc = __glXGetCurrentContext();
2479 const GLuint cmdlen = 8;
2480 emit_header(gc->pc, X_GLrop_PassThrough, cmdlen);
2481 (void) memcpy((void *)(gc->pc + 4), (void *)(&token), 4);
2482 gc->pc += cmdlen;
2483 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
2484 }
2485
2486 #define X_GLrop_PopName 124
2487 void __indirect_glPopName(void)
2488 {
2489 struct glx_context * const gc = __glXGetCurrentContext();
2490 const GLuint cmdlen = 4;
2491 emit_header(gc->pc, X_GLrop_PopName, cmdlen);
2492 gc->pc += cmdlen;
2493 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
2494 }
2495
2496 #define X_GLrop_PushName 125
2497 void __indirect_glPushName(GLuint name)
2498 {
2499 struct glx_context * const gc = __glXGetCurrentContext();
2500 const GLuint cmdlen = 8;
2501 emit_header(gc->pc, X_GLrop_PushName, cmdlen);
2502 (void) memcpy((void *)(gc->pc + 4), (void *)(&name), 4);
2503 gc->pc += cmdlen;
2504 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
2505 }
2506
2507 #define X_GLrop_DrawBuffer 126
2508 void __indirect_glDrawBuffer(GLenum mode)
2509 {
2510 struct glx_context * const gc = __glXGetCurrentContext();
2511 const GLuint cmdlen = 8;
2512 emit_header(gc->pc, X_GLrop_DrawBuffer, cmdlen);
2513 (void) memcpy((void *)(gc->pc + 4), (void *)(&mode), 4);
2514 gc->pc += cmdlen;
2515 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
2516 }
2517
2518 #define X_GLrop_Clear 127
2519 void __indirect_glClear(GLbitfield mask)
2520 {
2521 struct glx_context * const gc = __glXGetCurrentContext();
2522 const GLuint cmdlen = 8;
2523 emit_header(gc->pc, X_GLrop_Clear, cmdlen);
2524 (void) memcpy((void *)(gc->pc + 4), (void *)(&mask), 4);
2525 gc->pc += cmdlen;
2526 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
2527 }
2528
2529 #define X_GLrop_ClearAccum 128
2530 void __indirect_glClearAccum(GLfloat red, GLfloat green, GLfloat blue, GLfloat a lpha)
2531 {
2532 struct glx_context * const gc = __glXGetCurrentContext();
2533 const GLuint cmdlen = 20;
2534 emit_header(gc->pc, X_GLrop_ClearAccum, cmdlen);
2535 (void) memcpy((void *)(gc->pc + 4), (void *)(&red), 4);
2536 (void) memcpy((void *)(gc->pc + 8), (void *)(&green), 4);
2537 (void) memcpy((void *)(gc->pc + 12), (void *)(&blue), 4);
2538 (void) memcpy((void *)(gc->pc + 16), (void *)(&alpha), 4);
2539 gc->pc += cmdlen;
2540 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
2541 }
2542
2543 #define X_GLrop_ClearIndex 129
2544 void __indirect_glClearIndex(GLfloat c)
2545 {
2546 struct glx_context * const gc = __glXGetCurrentContext();
2547 const GLuint cmdlen = 8;
2548 emit_header(gc->pc, X_GLrop_ClearIndex, cmdlen);
2549 (void) memcpy((void *)(gc->pc + 4), (void *)(&c), 4);
2550 gc->pc += cmdlen;
2551 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
2552 }
2553
2554 #define X_GLrop_ClearColor 130
2555 void __indirect_glClearColor(GLclampf red, GLclampf green, GLclampf blue, GLclam pf alpha)
2556 {
2557 struct glx_context * const gc = __glXGetCurrentContext();
2558 const GLuint cmdlen = 20;
2559 emit_header(gc->pc, X_GLrop_ClearColor, cmdlen);
2560 (void) memcpy((void *)(gc->pc + 4), (void *)(&red), 4);
2561 (void) memcpy((void *)(gc->pc + 8), (void *)(&green), 4);
2562 (void) memcpy((void *)(gc->pc + 12), (void *)(&blue), 4);
2563 (void) memcpy((void *)(gc->pc + 16), (void *)(&alpha), 4);
2564 gc->pc += cmdlen;
2565 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
2566 }
2567
2568 #define X_GLrop_ClearStencil 131
2569 void __indirect_glClearStencil(GLint s)
2570 {
2571 struct glx_context * const gc = __glXGetCurrentContext();
2572 const GLuint cmdlen = 8;
2573 emit_header(gc->pc, X_GLrop_ClearStencil, cmdlen);
2574 (void) memcpy((void *)(gc->pc + 4), (void *)(&s), 4);
2575 gc->pc += cmdlen;
2576 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
2577 }
2578
2579 #define X_GLrop_ClearDepth 132
2580 void __indirect_glClearDepth(GLclampd depth)
2581 {
2582 struct glx_context * const gc = __glXGetCurrentContext();
2583 const GLuint cmdlen = 12;
2584 emit_header(gc->pc, X_GLrop_ClearDepth, cmdlen);
2585 (void) memcpy((void *)(gc->pc + 4), (void *)(&depth), 8);
2586 gc->pc += cmdlen;
2587 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
2588 }
2589
2590 #define X_GLrop_StencilMask 133
2591 void __indirect_glStencilMask(GLuint mask)
2592 {
2593 struct glx_context * const gc = __glXGetCurrentContext();
2594 const GLuint cmdlen = 8;
2595 emit_header(gc->pc, X_GLrop_StencilMask, cmdlen);
2596 (void) memcpy((void *)(gc->pc + 4), (void *)(&mask), 4);
2597 gc->pc += cmdlen;
2598 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
2599 }
2600
2601 #define X_GLrop_ColorMask 134
2602 void __indirect_glColorMask(GLboolean red, GLboolean green, GLboolean blue, GLbo olean alpha)
2603 {
2604 struct glx_context * const gc = __glXGetCurrentContext();
2605 const GLuint cmdlen = 8;
2606 emit_header(gc->pc, X_GLrop_ColorMask, cmdlen);
2607 (void) memcpy((void *)(gc->pc + 4), (void *)(&red), 1);
2608 (void) memcpy((void *)(gc->pc + 5), (void *)(&green), 1);
2609 (void) memcpy((void *)(gc->pc + 6), (void *)(&blue), 1);
2610 (void) memcpy((void *)(gc->pc + 7), (void *)(&alpha), 1);
2611 gc->pc += cmdlen;
2612 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
2613 }
2614
2615 #define X_GLrop_DepthMask 135
2616 void __indirect_glDepthMask(GLboolean flag)
2617 {
2618 struct glx_context * const gc = __glXGetCurrentContext();
2619 const GLuint cmdlen = 8;
2620 emit_header(gc->pc, X_GLrop_DepthMask, cmdlen);
2621 (void) memcpy((void *)(gc->pc + 4), (void *)(&flag), 1);
2622 gc->pc += cmdlen;
2623 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
2624 }
2625
2626 #define X_GLrop_IndexMask 136
2627 void __indirect_glIndexMask(GLuint mask)
2628 {
2629 struct glx_context * const gc = __glXGetCurrentContext();
2630 const GLuint cmdlen = 8;
2631 emit_header(gc->pc, X_GLrop_IndexMask, cmdlen);
2632 (void) memcpy((void *)(gc->pc + 4), (void *)(&mask), 4);
2633 gc->pc += cmdlen;
2634 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
2635 }
2636
2637 #define X_GLrop_Accum 137
2638 void __indirect_glAccum(GLenum op, GLfloat value)
2639 {
2640 struct glx_context * const gc = __glXGetCurrentContext();
2641 const GLuint cmdlen = 12;
2642 emit_header(gc->pc, X_GLrop_Accum, cmdlen);
2643 (void) memcpy((void *)(gc->pc + 4), (void *)(&op), 4);
2644 (void) memcpy((void *)(gc->pc + 8), (void *)(&value), 4);
2645 gc->pc += cmdlen;
2646 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
2647 }
2648
2649 #define X_GLrop_PopAttrib 141
2650 void __indirect_glPopAttrib(void)
2651 {
2652 struct glx_context * const gc = __glXGetCurrentContext();
2653 const GLuint cmdlen = 4;
2654 emit_header(gc->pc, X_GLrop_PopAttrib, cmdlen);
2655 gc->pc += cmdlen;
2656 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
2657 }
2658
2659 #define X_GLrop_PushAttrib 142
2660 void __indirect_glPushAttrib(GLbitfield mask)
2661 {
2662 struct glx_context * const gc = __glXGetCurrentContext();
2663 const GLuint cmdlen = 8;
2664 emit_header(gc->pc, X_GLrop_PushAttrib, cmdlen);
2665 (void) memcpy((void *)(gc->pc + 4), (void *)(&mask), 4);
2666 gc->pc += cmdlen;
2667 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
2668 }
2669
2670 #define X_GLrop_MapGrid1d 147
2671 void __indirect_glMapGrid1d(GLint un, GLdouble u1, GLdouble u2)
2672 {
2673 struct glx_context * const gc = __glXGetCurrentContext();
2674 const GLuint cmdlen = 24;
2675 emit_header(gc->pc, X_GLrop_MapGrid1d, cmdlen);
2676 (void) memcpy((void *)(gc->pc + 4), (void *)(&u1), 8);
2677 (void) memcpy((void *)(gc->pc + 12), (void *)(&u2), 8);
2678 (void) memcpy((void *)(gc->pc + 20), (void *)(&un), 4);
2679 gc->pc += cmdlen;
2680 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
2681 }
2682
2683 #define X_GLrop_MapGrid1f 148
2684 void __indirect_glMapGrid1f(GLint un, GLfloat u1, GLfloat u2)
2685 {
2686 struct glx_context * const gc = __glXGetCurrentContext();
2687 const GLuint cmdlen = 16;
2688 emit_header(gc->pc, X_GLrop_MapGrid1f, cmdlen);
2689 (void) memcpy((void *)(gc->pc + 4), (void *)(&un), 4);
2690 (void) memcpy((void *)(gc->pc + 8), (void *)(&u1), 4);
2691 (void) memcpy((void *)(gc->pc + 12), (void *)(&u2), 4);
2692 gc->pc += cmdlen;
2693 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
2694 }
2695
2696 #define X_GLrop_MapGrid2d 149
2697 void __indirect_glMapGrid2d(GLint un, GLdouble u1, GLdouble u2, GLint vn, GLdoub le v1, GLdouble v2)
2698 {
2699 struct glx_context * const gc = __glXGetCurrentContext();
2700 const GLuint cmdlen = 44;
2701 emit_header(gc->pc, X_GLrop_MapGrid2d, cmdlen);
2702 (void) memcpy((void *)(gc->pc + 4), (void *)(&u1), 8);
2703 (void) memcpy((void *)(gc->pc + 12), (void *)(&u2), 8);
2704 (void) memcpy((void *)(gc->pc + 20), (void *)(&v1), 8);
2705 (void) memcpy((void *)(gc->pc + 28), (void *)(&v2), 8);
2706 (void) memcpy((void *)(gc->pc + 36), (void *)(&un), 4);
2707 (void) memcpy((void *)(gc->pc + 40), (void *)(&vn), 4);
2708 gc->pc += cmdlen;
2709 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
2710 }
2711
2712 #define X_GLrop_MapGrid2f 150
2713 void __indirect_glMapGrid2f(GLint un, GLfloat u1, GLfloat u2, GLint vn, GLfloat v1, GLfloat v2)
2714 {
2715 struct glx_context * const gc = __glXGetCurrentContext();
2716 const GLuint cmdlen = 28;
2717 emit_header(gc->pc, X_GLrop_MapGrid2f, cmdlen);
2718 (void) memcpy((void *)(gc->pc + 4), (void *)(&un), 4);
2719 (void) memcpy((void *)(gc->pc + 8), (void *)(&u1), 4);
2720 (void) memcpy((void *)(gc->pc + 12), (void *)(&u2), 4);
2721 (void) memcpy((void *)(gc->pc + 16), (void *)(&vn), 4);
2722 (void) memcpy((void *)(gc->pc + 20), (void *)(&v1), 4);
2723 (void) memcpy((void *)(gc->pc + 24), (void *)(&v2), 4);
2724 gc->pc += cmdlen;
2725 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
2726 }
2727
2728 #define X_GLrop_EvalCoord1dv 151
2729 void __indirect_glEvalCoord1d(GLdouble u)
2730 {
2731 struct glx_context * const gc = __glXGetCurrentContext();
2732 const GLuint cmdlen = 12;
2733 emit_header(gc->pc, X_GLrop_EvalCoord1dv, cmdlen);
2734 (void) memcpy((void *)(gc->pc + 4), (void *)(&u), 8);
2735 gc->pc += cmdlen;
2736 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
2737 }
2738
2739 #define X_GLrop_EvalCoord1dv 151
2740 void __indirect_glEvalCoord1dv(const GLdouble * u)
2741 {
2742 generic_8_byte( X_GLrop_EvalCoord1dv, u );
2743 }
2744
2745 #define X_GLrop_EvalCoord1fv 152
2746 void __indirect_glEvalCoord1f(GLfloat u)
2747 {
2748 struct glx_context * const gc = __glXGetCurrentContext();
2749 const GLuint cmdlen = 8;
2750 emit_header(gc->pc, X_GLrop_EvalCoord1fv, cmdlen);
2751 (void) memcpy((void *)(gc->pc + 4), (void *)(&u), 4);
2752 gc->pc += cmdlen;
2753 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
2754 }
2755
2756 #define X_GLrop_EvalCoord1fv 152
2757 void __indirect_glEvalCoord1fv(const GLfloat * u)
2758 {
2759 generic_4_byte( X_GLrop_EvalCoord1fv, u );
2760 }
2761
2762 #define X_GLrop_EvalCoord2dv 153
2763 void __indirect_glEvalCoord2d(GLdouble u, GLdouble v)
2764 {
2765 struct glx_context * const gc = __glXGetCurrentContext();
2766 const GLuint cmdlen = 20;
2767 emit_header(gc->pc, X_GLrop_EvalCoord2dv, cmdlen);
2768 (void) memcpy((void *)(gc->pc + 4), (void *)(&u), 8);
2769 (void) memcpy((void *)(gc->pc + 12), (void *)(&v), 8);
2770 gc->pc += cmdlen;
2771 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
2772 }
2773
2774 #define X_GLrop_EvalCoord2dv 153
2775 void __indirect_glEvalCoord2dv(const GLdouble * u)
2776 {
2777 generic_16_byte( X_GLrop_EvalCoord2dv, u );
2778 }
2779
2780 #define X_GLrop_EvalCoord2fv 154
2781 void __indirect_glEvalCoord2f(GLfloat u, GLfloat v)
2782 {
2783 struct glx_context * const gc = __glXGetCurrentContext();
2784 const GLuint cmdlen = 12;
2785 emit_header(gc->pc, X_GLrop_EvalCoord2fv, cmdlen);
2786 (void) memcpy((void *)(gc->pc + 4), (void *)(&u), 4);
2787 (void) memcpy((void *)(gc->pc + 8), (void *)(&v), 4);
2788 gc->pc += cmdlen;
2789 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
2790 }
2791
2792 #define X_GLrop_EvalCoord2fv 154
2793 void __indirect_glEvalCoord2fv(const GLfloat * u)
2794 {
2795 generic_8_byte( X_GLrop_EvalCoord2fv, u );
2796 }
2797
2798 #define X_GLrop_EvalMesh1 155
2799 void __indirect_glEvalMesh1(GLenum mode, GLint i1, GLint i2)
2800 {
2801 struct glx_context * const gc = __glXGetCurrentContext();
2802 const GLuint cmdlen = 16;
2803 emit_header(gc->pc, X_GLrop_EvalMesh1, cmdlen);
2804 (void) memcpy((void *)(gc->pc + 4), (void *)(&mode), 4);
2805 (void) memcpy((void *)(gc->pc + 8), (void *)(&i1), 4);
2806 (void) memcpy((void *)(gc->pc + 12), (void *)(&i2), 4);
2807 gc->pc += cmdlen;
2808 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
2809 }
2810
2811 #define X_GLrop_EvalPoint1 156
2812 void __indirect_glEvalPoint1(GLint i)
2813 {
2814 struct glx_context * const gc = __glXGetCurrentContext();
2815 const GLuint cmdlen = 8;
2816 emit_header(gc->pc, X_GLrop_EvalPoint1, cmdlen);
2817 (void) memcpy((void *)(gc->pc + 4), (void *)(&i), 4);
2818 gc->pc += cmdlen;
2819 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
2820 }
2821
2822 #define X_GLrop_EvalMesh2 157
2823 void __indirect_glEvalMesh2(GLenum mode, GLint i1, GLint i2, GLint j1, GLint j2)
2824 {
2825 struct glx_context * const gc = __glXGetCurrentContext();
2826 const GLuint cmdlen = 24;
2827 emit_header(gc->pc, X_GLrop_EvalMesh2, cmdlen);
2828 (void) memcpy((void *)(gc->pc + 4), (void *)(&mode), 4);
2829 (void) memcpy((void *)(gc->pc + 8), (void *)(&i1), 4);
2830 (void) memcpy((void *)(gc->pc + 12), (void *)(&i2), 4);
2831 (void) memcpy((void *)(gc->pc + 16), (void *)(&j1), 4);
2832 (void) memcpy((void *)(gc->pc + 20), (void *)(&j2), 4);
2833 gc->pc += cmdlen;
2834 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
2835 }
2836
2837 #define X_GLrop_EvalPoint2 158
2838 void __indirect_glEvalPoint2(GLint i, GLint j)
2839 {
2840 struct glx_context * const gc = __glXGetCurrentContext();
2841 const GLuint cmdlen = 12;
2842 emit_header(gc->pc, X_GLrop_EvalPoint2, cmdlen);
2843 (void) memcpy((void *)(gc->pc + 4), (void *)(&i), 4);
2844 (void) memcpy((void *)(gc->pc + 8), (void *)(&j), 4);
2845 gc->pc += cmdlen;
2846 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
2847 }
2848
2849 #define X_GLrop_AlphaFunc 159
2850 void __indirect_glAlphaFunc(GLenum func, GLclampf ref)
2851 {
2852 struct glx_context * const gc = __glXGetCurrentContext();
2853 const GLuint cmdlen = 12;
2854 emit_header(gc->pc, X_GLrop_AlphaFunc, cmdlen);
2855 (void) memcpy((void *)(gc->pc + 4), (void *)(&func), 4);
2856 (void) memcpy((void *)(gc->pc + 8), (void *)(&ref), 4);
2857 gc->pc += cmdlen;
2858 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
2859 }
2860
2861 #define X_GLrop_BlendFunc 160
2862 void __indirect_glBlendFunc(GLenum sfactor, GLenum dfactor)
2863 {
2864 struct glx_context * const gc = __glXGetCurrentContext();
2865 const GLuint cmdlen = 12;
2866 emit_header(gc->pc, X_GLrop_BlendFunc, cmdlen);
2867 (void) memcpy((void *)(gc->pc + 4), (void *)(&sfactor), 4);
2868 (void) memcpy((void *)(gc->pc + 8), (void *)(&dfactor), 4);
2869 gc->pc += cmdlen;
2870 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
2871 }
2872
2873 #define X_GLrop_LogicOp 161
2874 void __indirect_glLogicOp(GLenum opcode)
2875 {
2876 struct glx_context * const gc = __glXGetCurrentContext();
2877 const GLuint cmdlen = 8;
2878 emit_header(gc->pc, X_GLrop_LogicOp, cmdlen);
2879 (void) memcpy((void *)(gc->pc + 4), (void *)(&opcode), 4);
2880 gc->pc += cmdlen;
2881 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
2882 }
2883
2884 #define X_GLrop_StencilFunc 162
2885 void __indirect_glStencilFunc(GLenum func, GLint ref, GLuint mask)
2886 {
2887 struct glx_context * const gc = __glXGetCurrentContext();
2888 const GLuint cmdlen = 16;
2889 emit_header(gc->pc, X_GLrop_StencilFunc, cmdlen);
2890 (void) memcpy((void *)(gc->pc + 4), (void *)(&func), 4);
2891 (void) memcpy((void *)(gc->pc + 8), (void *)(&ref), 4);
2892 (void) memcpy((void *)(gc->pc + 12), (void *)(&mask), 4);
2893 gc->pc += cmdlen;
2894 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
2895 }
2896
2897 #define X_GLrop_StencilOp 163
2898 void __indirect_glStencilOp(GLenum fail, GLenum zfail, GLenum zpass)
2899 {
2900 struct glx_context * const gc = __glXGetCurrentContext();
2901 const GLuint cmdlen = 16;
2902 emit_header(gc->pc, X_GLrop_StencilOp, cmdlen);
2903 (void) memcpy((void *)(gc->pc + 4), (void *)(&fail), 4);
2904 (void) memcpy((void *)(gc->pc + 8), (void *)(&zfail), 4);
2905 (void) memcpy((void *)(gc->pc + 12), (void *)(&zpass), 4);
2906 gc->pc += cmdlen;
2907 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
2908 }
2909
2910 #define X_GLrop_DepthFunc 164
2911 void __indirect_glDepthFunc(GLenum func)
2912 {
2913 struct glx_context * const gc = __glXGetCurrentContext();
2914 const GLuint cmdlen = 8;
2915 emit_header(gc->pc, X_GLrop_DepthFunc, cmdlen);
2916 (void) memcpy((void *)(gc->pc + 4), (void *)(&func), 4);
2917 gc->pc += cmdlen;
2918 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
2919 }
2920
2921 #define X_GLrop_PixelZoom 165
2922 void __indirect_glPixelZoom(GLfloat xfactor, GLfloat yfactor)
2923 {
2924 struct glx_context * const gc = __glXGetCurrentContext();
2925 const GLuint cmdlen = 12;
2926 emit_header(gc->pc, X_GLrop_PixelZoom, cmdlen);
2927 (void) memcpy((void *)(gc->pc + 4), (void *)(&xfactor), 4);
2928 (void) memcpy((void *)(gc->pc + 8), (void *)(&yfactor), 4);
2929 gc->pc += cmdlen;
2930 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
2931 }
2932
2933 #define X_GLrop_PixelTransferf 166
2934 void __indirect_glPixelTransferf(GLenum pname, GLfloat param)
2935 {
2936 struct glx_context * const gc = __glXGetCurrentContext();
2937 const GLuint cmdlen = 12;
2938 emit_header(gc->pc, X_GLrop_PixelTransferf, cmdlen);
2939 (void) memcpy((void *)(gc->pc + 4), (void *)(&pname), 4);
2940 (void) memcpy((void *)(gc->pc + 8), (void *)(&param), 4);
2941 gc->pc += cmdlen;
2942 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
2943 }
2944
2945 #define X_GLrop_PixelTransferi 167
2946 void __indirect_glPixelTransferi(GLenum pname, GLint param)
2947 {
2948 struct glx_context * const gc = __glXGetCurrentContext();
2949 const GLuint cmdlen = 12;
2950 emit_header(gc->pc, X_GLrop_PixelTransferi, cmdlen);
2951 (void) memcpy((void *)(gc->pc + 4), (void *)(&pname), 4);
2952 (void) memcpy((void *)(gc->pc + 8), (void *)(&param), 4);
2953 gc->pc += cmdlen;
2954 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
2955 }
2956
2957 #define X_GLrop_PixelMapfv 168
2958 void __indirect_glPixelMapfv(GLenum map, GLsizei mapsize, const GLfloat * values )
2959 {
2960 struct glx_context * const gc = __glXGetCurrentContext();
2961 const GLuint cmdlen = 12 + __GLX_PAD((mapsize * 4));
2962 if (mapsize < 0) {
2963 __glXSetError(gc, GL_INVALID_VALUE);
2964 return;
2965 }
2966 if (__builtin_expect((mapsize >= 0) && (gc->currentDpy != NULL), 1)) {
2967 if (cmdlen <= gc->maxSmallRenderCommandSize) {
2968 if ( (gc->pc + cmdlen) > gc->bufEnd ) {
2969 (void) __glXFlushRenderBuffer(gc, gc->pc);
2970 }
2971 emit_header(gc->pc, X_GLrop_PixelMapfv, cmdlen);
2972 (void) memcpy((void *)(gc->pc + 4), (void *)(&map), 4);
2973 (void) memcpy((void *)(gc->pc + 8), (void *)(&mapsize), 4);
2974 (void) memcpy((void *)(gc->pc + 12), (void *)(values), (mapsize * 4));
2975 gc->pc += cmdlen;
2976 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
2977 }
2978 else {
2979 const GLint op = X_GLrop_PixelMapfv;
2980 const GLuint cmdlenLarge = cmdlen + 4;
2981 GLubyte * const pc = __glXFlushRenderBuffer(gc, gc->pc);
2982 (void) memcpy((void *)(pc + 0), (void *)(&cmdlenLarge), 4);
2983 (void) memcpy((void *)(pc + 4), (void *)(&op), 4);
2984 (void) memcpy((void *)(pc + 8), (void *)(&map), 4);
2985 (void) memcpy((void *)(pc + 12), (void *)(&mapsize), 4);
2986 __glXSendLargeCommand(gc, pc, 16, values, (mapsize * 4));
2987 }
2988 }
2989 }
2990
2991 #define X_GLrop_PixelMapuiv 169
2992 void __indirect_glPixelMapuiv(GLenum map, GLsizei mapsize, const GLuint * values )
2993 {
2994 struct glx_context * const gc = __glXGetCurrentContext();
2995 const GLuint cmdlen = 12 + __GLX_PAD((mapsize * 4));
2996 if (mapsize < 0) {
2997 __glXSetError(gc, GL_INVALID_VALUE);
2998 return;
2999 }
3000 if (__builtin_expect((mapsize >= 0) && (gc->currentDpy != NULL), 1)) {
3001 if (cmdlen <= gc->maxSmallRenderCommandSize) {
3002 if ( (gc->pc + cmdlen) > gc->bufEnd ) {
3003 (void) __glXFlushRenderBuffer(gc, gc->pc);
3004 }
3005 emit_header(gc->pc, X_GLrop_PixelMapuiv, cmdlen);
3006 (void) memcpy((void *)(gc->pc + 4), (void *)(&map), 4);
3007 (void) memcpy((void *)(gc->pc + 8), (void *)(&mapsize), 4);
3008 (void) memcpy((void *)(gc->pc + 12), (void *)(values), (mapsize * 4));
3009 gc->pc += cmdlen;
3010 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
3011 }
3012 else {
3013 const GLint op = X_GLrop_PixelMapuiv;
3014 const GLuint cmdlenLarge = cmdlen + 4;
3015 GLubyte * const pc = __glXFlushRenderBuffer(gc, gc->pc);
3016 (void) memcpy((void *)(pc + 0), (void *)(&cmdlenLarge), 4);
3017 (void) memcpy((void *)(pc + 4), (void *)(&op), 4);
3018 (void) memcpy((void *)(pc + 8), (void *)(&map), 4);
3019 (void) memcpy((void *)(pc + 12), (void *)(&mapsize), 4);
3020 __glXSendLargeCommand(gc, pc, 16, values, (mapsize * 4));
3021 }
3022 }
3023 }
3024
3025 #define X_GLrop_PixelMapusv 170
3026 void __indirect_glPixelMapusv(GLenum map, GLsizei mapsize, const GLushort * valu es)
3027 {
3028 struct glx_context * const gc = __glXGetCurrentContext();
3029 const GLuint cmdlen = 12 + __GLX_PAD((mapsize * 2));
3030 if (mapsize < 0) {
3031 __glXSetError(gc, GL_INVALID_VALUE);
3032 return;
3033 }
3034 if (__builtin_expect((mapsize >= 0) && (gc->currentDpy != NULL), 1)) {
3035 if (cmdlen <= gc->maxSmallRenderCommandSize) {
3036 if ( (gc->pc + cmdlen) > gc->bufEnd ) {
3037 (void) __glXFlushRenderBuffer(gc, gc->pc);
3038 }
3039 emit_header(gc->pc, X_GLrop_PixelMapusv, cmdlen);
3040 (void) memcpy((void *)(gc->pc + 4), (void *)(&map), 4);
3041 (void) memcpy((void *)(gc->pc + 8), (void *)(&mapsize), 4);
3042 (void) memcpy((void *)(gc->pc + 12), (void *)(values), (mapsize * 2));
3043 gc->pc += cmdlen;
3044 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
3045 }
3046 else {
3047 const GLint op = X_GLrop_PixelMapusv;
3048 const GLuint cmdlenLarge = cmdlen + 4;
3049 GLubyte * const pc = __glXFlushRenderBuffer(gc, gc->pc);
3050 (void) memcpy((void *)(pc + 0), (void *)(&cmdlenLarge), 4);
3051 (void) memcpy((void *)(pc + 4), (void *)(&op), 4);
3052 (void) memcpy((void *)(pc + 8), (void *)(&map), 4);
3053 (void) memcpy((void *)(pc + 12), (void *)(&mapsize), 4);
3054 __glXSendLargeCommand(gc, pc, 16, values, (mapsize * 2));
3055 }
3056 }
3057 }
3058
3059 #define X_GLrop_ReadBuffer 171
3060 void __indirect_glReadBuffer(GLenum mode)
3061 {
3062 struct glx_context * const gc = __glXGetCurrentContext();
3063 const GLuint cmdlen = 8;
3064 emit_header(gc->pc, X_GLrop_ReadBuffer, cmdlen);
3065 (void) memcpy((void *)(gc->pc + 4), (void *)(&mode), 4);
3066 gc->pc += cmdlen;
3067 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
3068 }
3069
3070 #define X_GLrop_CopyPixels 172
3071 void __indirect_glCopyPixels(GLint x, GLint y, GLsizei width, GLsizei height, GL enum type)
3072 {
3073 struct glx_context * const gc = __glXGetCurrentContext();
3074 const GLuint cmdlen = 24;
3075 emit_header(gc->pc, X_GLrop_CopyPixels, cmdlen);
3076 (void) memcpy((void *)(gc->pc + 4), (void *)(&x), 4);
3077 (void) memcpy((void *)(gc->pc + 8), (void *)(&y), 4);
3078 (void) memcpy((void *)(gc->pc + 12), (void *)(&width), 4);
3079 (void) memcpy((void *)(gc->pc + 16), (void *)(&height), 4);
3080 (void) memcpy((void *)(gc->pc + 20), (void *)(&type), 4);
3081 gc->pc += cmdlen;
3082 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
3083 }
3084
3085 #define X_GLsop_ReadPixels 111
3086 void __indirect_glReadPixels(GLint x, GLint y, GLsizei width, GLsizei height, GL enum format, GLenum type, GLvoid * pixels)
3087 {
3088 struct glx_context * const gc = __glXGetCurrentContext();
3089 const __GLXattribute * const state = gc->client_state_private;
3090 Display * const dpy = gc->currentDpy;
3091 #ifndef USE_XCB
3092 const GLuint cmdlen = 28;
3093 #endif
3094 if (__builtin_expect(dpy != NULL, 1)) {
3095 #ifdef USE_XCB
3096 xcb_connection_t *c = XGetXCBConnection(dpy);
3097 (void) __glXFlushRenderBuffer(gc, gc->pc);
3098 xcb_glx_read_pixels_reply_t *reply = xcb_glx_read_pixels_reply(c, xcb_gl x_read_pixels(c, gc->currentContextTag, x, y, width, height, format, type, state ->storePack.swapEndian, 0), NULL);
3099 __glEmptyImage(gc, 3, width, height, 1, format, type, xcb_glx_read_pixel s_data(reply), pixels);
3100 free(reply);
3101 #else
3102 GLubyte const * pc = __glXSetupSingleRequest(gc, X_GLsop_ReadPixels, cmd len);
3103 (void) memcpy((void *)(pc + 0), (void *)(&x), 4);
3104 (void) memcpy((void *)(pc + 4), (void *)(&y), 4);
3105 (void) memcpy((void *)(pc + 8), (void *)(&width), 4);
3106 (void) memcpy((void *)(pc + 12), (void *)(&height), 4);
3107 (void) memcpy((void *)(pc + 16), (void *)(&format), 4);
3108 (void) memcpy((void *)(pc + 20), (void *)(&type), 4);
3109 *(int32_t *)(pc + 24) = 0;
3110 * (int8_t *)(pc + 24) = state->storePack.swapEndian;
3111 __glXReadPixelReply(dpy, gc, 2, width, height, 1, format, type, pixels, GL_FALSE);
3112 UnlockDisplay(dpy); SyncHandle();
3113 #endif /* USE_XCB */
3114 }
3115 return;
3116 }
3117
3118 #define X_GLrop_DrawPixels 173
3119 void __indirect_glDrawPixels(GLsizei width, GLsizei height, GLenum format, GLenu m type, const GLvoid * pixels)
3120 {
3121 struct glx_context * const gc = __glXGetCurrentContext();
3122 const GLuint compsize = (pixels != NULL) ? __glImageSize(width, height, 1, f ormat, type, 0) : 0;
3123 const GLuint cmdlen = 40 + __GLX_PAD(compsize);
3124 if (__builtin_expect(gc->currentDpy != NULL, 1)) {
3125 if (cmdlen <= gc->maxSmallRenderCommandSize) {
3126 if ( (gc->pc + cmdlen) > gc->bufEnd ) {
3127 (void) __glXFlushRenderBuffer(gc, gc->pc);
3128 }
3129 emit_header(gc->pc, X_GLrop_DrawPixels, cmdlen);
3130 (void) memcpy((void *)(gc->pc + 24), (void *)(&width), 4);
3131 (void) memcpy((void *)(gc->pc + 28), (void *)(&height), 4);
3132 (void) memcpy((void *)(gc->pc + 32), (void *)(&format), 4);
3133 (void) memcpy((void *)(gc->pc + 36), (void *)(&type), 4);
3134 if (compsize > 0) {
3135 (*gc->fillImage)(gc, 2, width, height, 1, format, type, pixels, gc->pc + 40, gc->pc + 4);
3136 } else {
3137 (void) memcpy( gc->pc + 4, default_pixel_store_2D, default_pixel_store_2D_si ze );
3138 }
3139 gc->pc += cmdlen;
3140 if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
3141 }
3142 else {
3143 const GLint op = X_GLrop_DrawPixels;
3144 const GLuint cmdlenLarge = cmdlen + 4;
3145 GLubyte * const pc = __glXFlushRenderBuffer(gc, gc->pc);
3146 (void) memcpy((void *)(pc + 0), (void *)(&cmdlenLarge), 4);
3147 (void) memcpy((void *)(pc + 4), (void *)(&op), 4);
3148 (void) memcpy((void *)(pc + 28), (void *)(&width), 4);
3149 (void) memcpy((void *)(pc + 32), (void *)(&height), 4);
3150 (void) memcpy((void *)(pc + 36), (void *)(&format), 4);
3151 (void) memcpy((void *)(pc + 40), (void *)(&type), 4);
3152 __glXSendLargeImage(gc, compsize, 2, width, height, 1, format, type, pixels, pc + 44, pc + 8);
3153 }
3154 }
3155 }
3156
3157 #define X_GLsop_GetClipPlane 113
3158 void __indirect_glGetClipPlane(GLenum plane, GLdouble * equation)
3159 {
3160 struct glx_context * const gc = __glXGetCurrentContext();
3161 Display * const dpy = gc->currentDpy;
3162 #ifndef USE_XCB
3163 const GLuint cmdlen = 4;
3164 #endif
3165 if (__builtin_expect(dpy != NULL, 1)) {
3166 #ifdef USE_XCB
3167 xcb_connection_t *c = XGetXCBConnection(dpy);
3168 (void) __glXFlushRenderBuffer(gc, gc->pc);
3169 xcb_glx_get_clip_plane_reply_t *reply = xcb_glx_get_clip_plane_reply(c, xcb_glx_get_clip_plane(c, gc->currentContextTag, plane), NULL);
3170 (void)memcpy(equation, xcb_glx_get_clip_plane_data(reply), xcb_glx_get_c lip_plane_data_length(reply) * sizeof(GLdouble));
3171 free(reply);
3172 #else
3173 GLubyte const * pc = __glXSetupSingleRequest(gc, X_GLsop_GetClipPlane, c mdlen);
3174 (void) memcpy((void *)(pc + 0), (void *)(&plane), 4);
3175 (void) __glXReadReply(dpy, 8, equation, GL_TRUE);
3176 UnlockDisplay(dpy); SyncHandle();
3177 #endif /* USE_XCB */
3178 }
3179 return;
3180 }
3181
3182 #define X_GLsop_GetLightfv 118
3183 void __indirect_glGetLightfv(GLenum light, GLenum pname, GLfloat * params)
3184 {
3185 struct glx_context * const gc = __glXGetCurrentContext();
3186 Display * const dpy = gc->currentDpy;
3187 #ifndef USE_XCB
3188 const GLuint cmdlen = 8;
3189 #endif
3190 if (__builtin_expect(dpy != NULL, 1)) {
3191 #ifdef USE_XCB
3192 xcb_connection_t *c = XGetXCBConnection(dpy);
3193 (void) __glXFlushRenderBuffer(gc, gc->pc);
3194 xcb_glx_get_lightfv_reply_t *reply = xcb_glx_get_lightfv_reply(c, xcb_gl x_get_lightfv(c, gc->currentContextTag, light, pname), NULL);
3195 if (xcb_glx_get_lightfv_data_length(reply) == 0)
3196 (void)memcpy(params, &reply->datum, sizeof(reply->datum));
3197 else
3198 (void)memcpy(params, xcb_glx_get_lightfv_data(reply), xcb_glx_get_li ghtfv_data_length(reply) * sizeof(GLfloat));
3199 free(reply);
3200 #else
3201 GLubyte const * pc = __glXSetupSingleRequest(gc, X_GLsop_GetLightfv, cmd len);
3202 (void) memcpy((void *)(pc + 0), (void *)(&light), 4);
3203 (void) memcpy((void *)(pc + 4), (void *)(&pname), 4);
3204 (void) __glXReadReply(dpy, 4, params, GL_FALSE);
3205 UnlockDisplay(dpy); SyncHandle();
3206 #endif /* USE_XCB */
3207 }
3208 return;
3209 }
3210
3211 #define X_GLsop_GetLightiv 119
3212 void __indirect_glGetLightiv(GLenum light, GLenum pname, GLint * params)
3213 {
3214 struct glx_context * const gc = __glXGetCurrentContext();
3215 Display * const dpy = gc->currentDpy;
3216 #ifndef USE_XCB
3217 const GLuint cmdlen = 8;
3218 #endif
3219 if (__builtin_expect(dpy != NULL, 1)) {
3220 #ifdef USE_XCB
3221 xcb_connection_t *c = XGetXCBConnection(dpy);
3222 (void) __glXFlushRenderBuffer(gc, gc->pc);
3223 xcb_glx_get_lightiv_reply_t *reply = xcb_glx_get_lightiv_reply(c, xcb_gl x_get_lightiv(c, gc->currentContextTag, light, pname), NULL);
3224 if (xcb_glx_get_lightiv_data_length(reply) == 0)
3225 (void)memcpy(params, &reply->datum, sizeof(reply->datum));
3226 else
3227 (void)memcpy(params, xcb_glx_get_lightiv_data(reply), xcb_glx_get_li ghtiv_data_length(reply) * sizeof(GLint));
3228 free(reply);
3229 #else
3230 GLubyte const * pc = __glXSetupSingleRequest(gc, X_GLsop_GetLightiv, cmd len);
3231 (void) memcpy((void *)(pc + 0), (void *)(&light), 4);
3232 (void) memcpy((void *)(pc + 4), (void *)(&pname), 4);
3233 (void) __glXReadReply(dpy, 4, params, GL_FALSE);
3234 UnlockDisplay(dpy); SyncHandle();
3235 #endif /* USE_XCB */
3236 }
3237 return;
3238 }
3239
3240 #define X_GLsop_GetMapdv 120
3241 void __indirect_glGetMapdv(GLenum target, GLenum query, GLdouble * v)
3242 {
3243 struct glx_context * const gc = __glXGetCurrentContext();
3244 Display * const dpy = gc->currentDpy;
3245 #ifndef USE_XCB
3246 const GLuint cmdlen = 8;
3247 #endif
3248 if (__builtin_expect(dpy != NULL, 1)) {
3249 #ifdef USE_XCB
3250 xcb_connection_t *c = XGetXCBConnection(dpy);
3251 (void) __glXFlushRenderBuffer(gc, gc->pc);
3252 xcb_glx_get_mapdv_reply_t *reply = xcb_glx_get_mapdv_reply(c, xcb_glx_ge t_mapdv(c, gc->currentContextTag, target, query), NULL);
3253 if (xcb_glx_get_mapdv_data_length(reply) == 0)
3254 (void)memcpy(v, &reply->datum, sizeof(reply->datum));
3255 else
3256 (void)memcpy(v, xcb_glx_get_mapdv_data(reply), xcb_glx_get_mapdv_dat a_length(reply) * sizeof(GLdouble));
3257 free(reply);
3258 #else
3259 GLubyte const * pc = __glXSetupSingleRequest(gc, X_GLsop_GetMapdv, cmdle n);
3260 (void) memcpy((void *)(pc + 0), (void *)(&target), 4);
3261 (void) memcpy((void *)(pc + 4), (void *)(&query), 4);
3262 (void) __glXReadReply(dpy, 8, v, GL_FALSE);
3263 UnlockDisplay(dpy); SyncHandle();
3264 #endif /* USE_XCB */
3265 }
3266 return;
3267 }
3268
3269 #define X_GLsop_GetMapfv 121
3270 void __indirect_glGetMapfv(GLenum target, GLenum query, GLfloat * v)
3271 {
3272 struct glx_context * const gc = __glXGetCurrentContext();
3273 Display * const dpy = gc->currentDpy;
3274 #ifndef USE_XCB
3275 const GLuint cmdlen = 8;
3276 #endif
3277 if (__builtin_expect(dpy != NULL, 1)) {
3278 #ifdef USE_XCB
3279 xcb_connection_t *c = XGetXCBConnection(dpy);
3280 (void) __glXFlushRenderBuffer(gc, gc->pc);
3281 xcb_glx_get_mapfv_reply_t *reply = xcb_glx_get_mapfv_reply(c, xcb_glx_ge t_mapfv(c, gc->currentContextTag, target, query), NULL);
3282 if (xcb_glx_get_mapfv_data_length(reply) == 0)
3283 (void)memcpy(v, &reply->datum, sizeof(reply->datum));
3284 else
3285 (void)memcpy(v, xcb_glx_get_mapfv_data(reply), xcb_glx_get_mapfv_dat a_length(reply) * sizeof(GLfloat));
3286 free(reply);
3287 #else
3288 GLubyte const * pc = __glXSetupSingleRequest(gc, X_GLsop_GetMapfv, cmdle n);
3289 (void) memcpy((void *)(pc + 0), (void *)(&target), 4);
3290 (void) memcpy((void *)(pc + 4), (void *)(&query), 4);
3291 (void) __glXReadReply(dpy, 4, v, GL_FALSE);
3292 UnlockDisplay(dpy); SyncHandle();
3293 #endif /* USE_XCB */
3294 }
3295 return;
3296 }
3297
3298 #define X_GLsop_GetMapiv 122
3299 void __indirect_glGetMapiv(GLenum target, GLenum query, GLint * v)
3300 {
3301 struct glx_context * const gc = __glXGetCurrentContext();
3302 Display * const dpy = gc->currentDpy;
3303 #ifndef USE_XCB
3304 const GLuint cmdlen = 8;
3305 #endif
3306 if (__builtin_expect(dpy != NULL, 1)) {
3307 #ifdef USE_XCB
3308 xcb_connection_t *c = XGetXCBConnection(dpy);
3309 (void) __glXFlushRenderBuffer(gc, gc->pc);
3310 xcb_glx_get_mapiv_reply_t *reply = xcb_glx_get_mapiv_reply(c, xcb_glx_ge t_mapiv(c, gc->currentContextTag, target, query), NULL);
3311 if (xcb_glx_get_mapiv_data_length(reply) == 0)
3312 (void)memcpy(v, &reply->datum, sizeof(reply->datum));
3313 else
3314 (void)memcpy(v, xcb_glx_get_mapiv_data(reply), xcb_glx_get_mapiv_dat a_length(reply) * sizeof(GLint));
3315 free(reply);
3316 #else
3317 GLubyte const * pc = __glXSetupSingleRequest(gc, X_GLsop_GetMapiv, cmdle n);
3318 (void) memcpy((void *)(pc + 0), (void *)(&target), 4);
3319 (void) memcpy((void *)(pc + 4), (void *)(&query), 4);
3320 (void) __glXReadReply(dpy, 4, v, GL_FALSE);
3321 UnlockDisplay(dpy); SyncHandle();
3322 #endif /* USE_XCB */
3323 }
3324 return;
3325 }
3326
3327 #define X_GLsop_GetMaterialfv 123
3328 void __indirect_glGetMaterialfv(GLenum face, GLenum pname, GLfloat * params)
3329 {
3330 struct glx_context * const gc = __glXGetCurrentContext();
3331 Display * const dpy = gc->currentDpy;
3332 #ifndef USE_XCB
3333 const GLuint cmdlen = 8;
3334 #endif
3335 if (__builtin_expect(dpy != NULL, 1)) {
3336 #ifdef USE_XCB
3337 xcb_connection_t *c = XGetXCBConnection(dpy);
3338 (void) __glXFlushRenderBuffer(gc, gc->pc);
3339 xcb_glx_get_materialfv_reply_t *reply = xcb_glx_get_materialfv_reply(c, xcb_glx_get_materialfv(c, gc->currentContextTag, face, pname), NULL);
3340 if (xcb_glx_get_materialfv_data_length(reply) == 0)
3341 (void)memcpy(params, &reply->datum, sizeof(reply->datum));
3342 else
3343 (void)memcpy(params, xcb_glx_get_materialfv_data(reply), xcb_glx_get _materialfv_data_length(reply) * sizeof(GLfloat));
3344 free(reply);
3345 #else
3346 GLubyte const * pc = __glXSetupSingleRequest(gc, X_GLsop_GetMaterialfv, cmdlen);
3347 (void) memcpy((void *)(pc + 0), (void *)(&face), 4);
3348 (void) memcpy((void *)(pc + 4), (void *)(&pname), 4);
3349 (void) __glXReadReply(dpy, 4, params, GL_FALSE);
3350 UnlockDisplay(dpy); SyncHandle();
3351 #endif /* USE_XCB */
3352 }
3353 return;
3354 }
3355
3356 #define X_GLsop_GetMaterialiv 124
3357 void __indirect_glGetMaterialiv(GLenum face, GLenum pname, GLint * params)
3358 {
3359 struct glx_context * const gc = __glXGetCurrentContext();
3360 Display * const dpy = gc->currentDpy;
3361 #ifndef USE_XCB
3362 const GLuint cmdlen = 8;
3363 #endif
3364 if (__builtin_expect(dpy != NULL, 1)) {
3365 #ifdef USE_XCB
3366 xcb_connection_t *c = XGetXCBConnection(dpy);
3367 (void) __glXFlushRenderBuffer(gc, gc->pc);
3368 xcb_glx_get_materialiv_reply_t *reply = xcb_glx_get_materialiv_reply(c, xcb_glx_get_materialiv(c, gc->currentContextTag, face, pname), NULL);
3369 if (xcb_glx_get_materialiv_data_length(reply) == 0)
3370 (void)memcpy(params, &reply->datum, sizeof(reply->datum));
3371 else
3372 (void)memcpy(params, xcb_glx_get_materialiv_data(reply), xcb_glx_get _materialiv_data_length(reply) * sizeof(GLint));
3373 free(reply);
3374 #else
3375 GLubyte const * pc = __glXSetupSingleRequest(gc, X_GLsop_GetMaterialiv, cmdlen);
3376 (void) memcpy((void *)(pc + 0), (void *)(&face), 4);
3377 (void) memcpy((void *)(pc + 4), (void *)(&pname), 4);
3378 (void) __glXReadReply(dpy, 4, params, GL_FALSE);
3379 UnlockDisplay(dpy); SyncHandle();
3380 #endif /* USE_XCB */
3381 }
3382 return;
3383 }
3384
3385 #define X_GLsop_GetPixelMapfv 125
3386 void __indirect_glGetPixelMapfv(GLenum map, GLfloat * values)
3387 {
3388 struct glx_context * const gc = __glXGetCurrentContext();
3389 Display * const dpy = gc->currentDpy;
3390 #ifndef USE_XCB
3391 const GLuint cmdlen = 4;
3392 #endif
3393 if (__builtin_expect(dpy != NULL, 1)) {
3394 #ifdef USE_XCB
3395 xcb_connection_t *c = XGetXCBConnection(dpy);
3396 (void) __glXFlushRenderBuffer(gc, gc->pc);
3397 xcb_glx_get_pixel_mapfv_reply_t *reply = xcb_glx_get_pixel_mapfv_reply(c , xcb_glx_get_pixel_mapfv(c, gc->currentContextTag, map), NULL);
3398 if (xcb_glx_get_pixel_mapfv_data_length(reply) == 0)
3399 (void)memcpy(values, &reply->datum, sizeof(reply->datum));
3400 else
3401 (void)memcpy(values, xcb_glx_get_pixel_mapfv_data(reply), xcb_glx_ge t_pixel_mapfv_data_length(reply) * sizeof(GLfloat));
3402 free(reply);
3403 #else
3404 GLubyte const * pc = __glXSetupSingleRequest(gc, X_GLsop_GetPixelMapfv, cmdlen);
3405 (void) memcpy((void *)(pc + 0), (void *)(&map), 4);
3406 (void) __glXReadReply(dpy, 4, values, GL_FALSE);
3407 UnlockDisplay(dpy); SyncHandle();
3408 #endif /* USE_XCB */
3409 }
3410 return;
3411 }
3412
3413 #define X_GLsop_GetPixelMapuiv 126
3414 void __indirect_glGetPixelMapuiv(GLenum map, GLuint * values)
3415 {
3416 struct glx_context * const gc = __glXGetCurrentContext();
3417 Display * const dpy = gc->currentDpy;
3418 #ifndef USE_XCB
3419 const GLuint cmdlen = 4;
3420 #endif
3421 if (__builtin_expect(dpy != NULL, 1)) {
3422 #ifdef USE_XCB
3423 xcb_connection_t *c = XGetXCBConnection(dpy);
3424 (void) __glXFlushRenderBuffer(gc, gc->pc);
3425 xcb_glx_get_pixel_mapuiv_reply_t *reply = xcb_glx_get_pixel_mapuiv_reply (c, xcb_glx_get_pixel_mapuiv(c, gc->currentContextTag, map), NULL);
3426 if (xcb_glx_get_pixel_mapuiv_data_length(reply) == 0)
3427 (void)memcpy(values, &reply->datum, sizeof(reply->datum));
3428 else
3429 (void)memcpy(values, xcb_glx_get_pixel_mapuiv_data(reply), xcb_glx_g et_pixel_mapuiv_data_length(reply) * sizeof(GLuint));
3430 free(reply);
3431 #else
3432 GLubyte const * pc = __glXSetupSingleRequest(gc, X_GLsop_GetPixelMapuiv, cmdlen);
3433 (void) memcpy((void *)(pc + 0), (void *)(&map), 4);
3434 (void) __glXReadReply(dpy, 4, values, GL_FALSE);
3435 UnlockDisplay(dpy); SyncHandle();
3436 #endif /* USE_XCB */
3437 }
3438 return;
3439 }
3440
3441 #define X_GLsop_GetPixelMapusv 127
3442 void __indirect_glGetPixelMapusv(GLenum map, GLushort * values)
3443 {
3444 struct glx_context * const gc = __glXGetCurrentContext();
3445 Display * const dpy = gc->currentDpy;
3446 #ifndef USE_XCB
3447 const GLuint cmdlen = 4;
3448 #endif
3449 if (__builtin_expect(dpy != NULL, 1)) {
3450 #ifdef USE_XCB
3451 xcb_connection_t *c = XGetXCBConnection(dpy);
3452 (void) __glXFlushRenderBuffer(gc, gc->pc);
3453 xcb_glx_get_pixel_mapusv_reply_t *reply = xcb_glx_get_pixel_mapusv_reply (c, xcb_glx_get_pixel_mapusv(c, gc->currentContextTag, map), NULL);
3454 if (xcb_glx_get_pixel_mapusv_data_length(reply) == 0)
3455 (void)memcpy(values, &reply->datum, sizeof(reply->datum));
3456 else
3457 (void)memcpy(values, xcb_glx_get_pixel_mapusv_data(reply), xcb_glx_g et_pixel_mapusv_data_length(reply) * sizeof(GLushort));
3458 free(reply);
3459 #else
3460 GLubyte const * pc = __glXSetupSingleRequest(gc, X_GLsop_GetPixelMapusv, cmdlen);
3461 (void) memcpy((void *)(pc + 0), (void *)(&map), 4);
3462 (void) __glXReadReply(dpy, 2, values, GL_FALSE);
3463 UnlockDisplay(dpy); SyncHandle();
3464 #endif /* USE_XCB */
3465 }
3466 return;
3467 }
3468
3469 #define X_GLsop_GetPolygonStipple 128
3470 void __indirect_glGetPolygonStipple(GLubyte * mask)
3471 {
3472 struct glx_context * const gc = __glXGetCurrentContext();
3473 Display * const dpy = gc->currentDpy;
3474 #ifndef USE_XCB
3475 const GLuint cmdlen = 4;
3476 #endif
3477 if (__builtin_expect(dpy != NULL, 1)) {
3478 #ifdef USE_XCB
3479 xcb_connection_t *c = XGetXCBConnection(dpy);
3480 (void) __glXFlushRenderBuffer(gc, gc->pc);
3481 xcb_glx_get_polygon_stipple_reply_t *reply = xcb_glx_get_polygon_stipple _reply(c, xcb_glx_get_polygon_stipple(c, gc->currentContextTag, 0), NULL);
3482 __glEmptyImage(gc, 3, 32, 32, 1, GL_COLOR_INDEX, GL_BITMAP, xcb_glx_get_ polygon_stipple_data(reply), mask);
3483 free(reply);
3484 #else
3485 GLubyte const * pc = __glXSetupSingleRequest(gc, X_GLsop_GetPolygonStipp le, cmdlen);
3486 *(int32_t *)(pc + 0) = 0;
3487 __glXReadPixelReply(dpy, gc, 2, 32, 32, 1, GL_COLOR_INDEX, GL_BITMAP, ma sk, GL_FALSE);
3488 UnlockDisplay(dpy); SyncHandle();
3489 #endif /* USE_XCB */
3490 }
3491 return;
3492 }
3493
3494 #define X_GLsop_GetTexEnvfv 130
3495 void __indirect_glGetTexEnvfv(GLenum target, GLenum pname, GLfloat * params)
3496 {
3497 struct glx_context * const gc = __glXGetCurrentContext();
3498 Display * const dpy = gc->currentDpy;
3499 #ifndef USE_XCB
3500 const GLuint cmdlen = 8;
3501 #endif
3502 if (__builtin_expect(dpy != NULL, 1)) {
3503 #ifdef USE_XCB
3504 xcb_connection_t *c = XGetXCBConnection(dpy);
3505 (void) __glXFlushRenderBuffer(gc, gc->pc);
3506 xcb_glx_get_tex_envfv_reply_t *reply = xcb_glx_get_tex_envfv_reply(c, xc b_glx_get_tex_envfv(c, gc->currentContextTag, target, pname), NULL);
3507 if (xcb_glx_get_tex_envfv_data_length(reply) == 0)
3508 (void)memcpy(params, &reply->datum, sizeof(reply->datum));
3509 else
3510 (void)memcpy(params, xcb_glx_get_tex_envfv_data(reply), xcb_glx_get_ tex_envfv_data_length(reply) * sizeof(GLfloat));
3511 free(reply);
3512 #else
3513 GLubyte const * pc = __glXSetupSingleRequest(gc, X_GLsop_GetTexEnvfv, cm dlen);
3514 (void) memcpy((void *)(pc + 0), (void *)(&target), 4);
3515 (void) memcpy((void *)(pc + 4), (void *)(&pname), 4);
3516 (void) __glXReadReply(dpy, 4, params, GL_FALSE);
3517 UnlockDisplay(dpy); SyncHandle();
3518 #endif /* USE_XCB */
3519 }
3520 return;
3521 }
3522
3523 #define X_GLsop_GetTexEnviv 131
3524 void __indirect_glGetTexEnviv(GLenum target, GLenum pname, GLint * params)
3525 {
3526 struct glx_context * const gc = __glXGetCurrentContext();
3527 Display * const dpy = gc->currentDpy;
3528 #ifndef USE_XCB
3529 const GLuint cmdlen = 8;
3530 #endif
3531 if (__builtin_expect(dpy != NULL, 1)) {
3532 #ifdef USE_XCB
3533 xcb_connection_t *c = XGetXCBConnection(dpy);
3534 (void) __glXFlushRenderBuffer(gc, gc->pc);
3535 xcb_glx_get_tex_enviv_reply_t *reply = xcb_glx_get_tex_enviv_reply(c, xc b_glx_get_tex_enviv(c, gc->currentContextTag, target, pname), NULL);
3536 if (xcb_glx_get_tex_enviv_data_length(reply) == 0)
3537 (void)memcpy(params, &reply->datum, sizeof(reply->datum));
3538 else
3539 (void)memcpy(params, xcb_glx_get_tex_enviv_data(reply), xcb_glx_get_ tex_enviv_data_length(reply) * sizeof(GLint));
3540 free(reply);
3541 #else
3542 GLubyte const * pc = __glXSetupSingleRequest(gc, X_GLsop_GetTexEnviv, cm dlen);
3543 (void) memcpy((void *)(pc + 0), (void *)(&target), 4);
3544 (void) memcpy((void *)(pc + 4), (void *)(&pname), 4);
3545 (void) __glXReadReply(dpy, 4, params, GL_FALSE);
3546 UnlockDisplay(dpy); SyncHandle();
3547 #endif /* USE_XCB */
3548 }
3549 return;
3550 }
3551
3552 #define X_GLsop_GetTexGendv 132
3553 void __indirect_glGetTexGendv(GLenum coord, GLenum pname, GLdouble * params)
3554 {
3555 struct glx_context * const gc = __glXGetCurrentContext();
3556 Display * const dpy = gc->currentDpy;
3557 #ifndef USE_XCB
3558 const GLuint cmdlen = 8;
3559 #endif
3560 if (__builtin_expect(dpy != NULL, 1)) {
3561 #ifdef USE_XCB
3562 xcb_connection_t *c = XGetXCBConnection(dpy);
3563 (void) __glXFlushRenderBuffer(gc, gc->pc);
3564 xcb_glx_get_tex_gendv_reply_t *reply = xcb_glx_get_tex_gendv_reply(c, xc b_glx_get_tex_gendv(c, gc->currentContextTag, coord, pname), NULL);
3565 if (xcb_glx_get_tex_gendv_data_length(reply) == 0)
3566 (void)memcpy(params, &reply->datum, sizeof(reply->datum));
3567 else
3568 (void)memcpy(params, xcb_glx_get_tex_gendv_data(reply), xcb_glx_get_ tex_gendv_data_length(reply) * sizeof(GLdouble));
3569 free(reply);
3570 #else
3571 GLubyte const * pc = __glXSetupSingleRequest(gc, X_GLsop_GetTexGendv, cm dlen);
3572 (void) memcpy((void *)(pc + 0), (void *)(&coord), 4);
3573 (void) memcpy((void *)(pc + 4), (void *)(&pname), 4);
3574 (void) __glXReadReply(dpy, 8, params, GL_FALSE);
3575 UnlockDisplay(dpy); SyncHandle();
3576 #endif /* USE_XCB */
3577 }
3578 return;
3579 }
3580
3581 #define X_GLsop_GetTexGenfv 133
3582 void __indirect_glGetTexGenfv(GLenum coord, GLenum pname, GLfloat * params)
3583 {
3584 struct glx_context * const gc = __glXGetCurrentContext();
3585 Display * const dpy = gc->currentDpy;
3586 #ifndef USE_XCB
3587 const GLuint cmdlen = 8;
3588 #endif
3589 if (__builtin_expect(dpy != NULL, 1)) {
3590 #ifdef USE_XCB
3591 xcb_connection_t *c = XGetXCBConnection(dpy);
3592 (void) __glXFlushRenderBuffer(gc, gc->pc);
3593 xcb_glx_get_tex_genfv_reply_t *reply = xcb_glx_get_tex_genfv_reply(c, xc b_glx_get_tex_genfv(c, gc->currentContextTag, coord, pname), NULL);
3594 if (xcb_glx_get_tex_genfv_data_length(reply) == 0)
3595 (void)memcpy(params, &reply->datum, sizeof(reply->datum));
3596 else
3597 (void)memcpy(params, xcb_glx_get_tex_genfv_data(reply), xcb_glx_get_ tex_genfv_data_length(reply) * sizeof(GLfloat));
3598 free(reply);
3599 #else
3600 GLubyte const * pc = __glXSetupSingleRequest(gc, X_GLsop_GetTexGenfv, cm dlen);
3601 (void) memcpy((void *)(pc + 0), (void *)(&coord), 4);
3602 (void) memcpy((void *)(pc + 4), (void *)(&pname), 4);
3603 (void) __glXReadReply(dpy, 4, params, GL_FALSE);
3604 UnlockDisplay(dpy); SyncHandle();
3605 #endif /* USE_XCB */
3606 }
3607 return;
3608 }
3609
3610 #define X_GLsop_GetTexGeniv 134
3611 void __indirect_glGetTexGeniv(GLenum coord, GLenum pname, GLint * params)
3612 {
3613 struct glx_context * const gc = __glXGetCurrentContext();
3614 Display * const dpy = gc->currentDpy;
3615 #ifndef USE_XCB
3616 const GLuint cmdlen = 8;
3617 #endif
3618 if (__builtin_expect(dpy != NULL, 1)) {
3619 #ifdef USE_XCB
3620 xcb_connection_t *c = XGetXCBConnection(dpy);
3621 (void) __glXFlushRenderBuffer(gc, gc->pc);
3622 xcb_glx_get_tex_geniv_reply_t *reply = xcb_glx_get_tex_geniv_reply(c, xc b_glx_get_tex_geniv(c, gc->currentContextTag, coord, pname), NULL);
3623 if (xcb_glx_get_tex_geniv_data_length(reply) == 0)
3624 (void)memcpy(params, &reply->datum, sizeof(reply->datum));
3625 else
3626 (void)memcpy(params, xcb_glx_get_tex_geniv_data(reply), xcb_glx_get_ tex_geniv_data_length(reply) * sizeof(GLint));
3627 free(reply);
3628 #else
3629 GLubyte const * pc = __glXSetupSingleRequest(gc, X_GLsop_GetTexGeniv, cm dlen);
3630 (void) memcpy((void *)(pc + 0), (void *)(&coord), 4);
3631 (void) memcpy((void *)(pc + 4), (void *)(&pname), 4);
3632 (void) __glXReadReply(dpy, 4, params, GL_FALSE);
3633 UnlockDisplay(dpy); SyncHandle();
3634 #endif /* USE_XCB */
3635 }
3636 return;
3637 }
3638
3639 #define X_GLsop_GetTexImage 135
3640 void __indirect_glGetTexImage(GLenum target, GLint level, GLenum format, GLenum type, GLvoid * pixels)
3641 {
3642 struct glx_context * const gc = __glXGetCurrentContext();
3643 const __GLXattribute * const state = gc->client_state_private;
3644 Display * const dpy = gc->currentDpy;
3645 #ifndef USE_XCB
3646 const GLuint cmdlen = 20;
3647 #endif
3648 if (__builtin_expect(dpy != NULL, 1)) {
3649 #ifdef USE_XCB
3650 xcb_connection_t *c = XGetXCBConnection(dpy);
3651 (void) __glXFlushRenderBuffer(gc, gc->pc);
3652 xcb_glx_get_tex_image_reply_t *reply = xcb_glx_get_tex_image_reply(c, xc b_glx_get_tex_image(c, gc->currentContextTag, target, level, format, type, state ->storePack.swapEndian), NULL);
3653 if (reply->height == 0) { reply->height = 1; }
3654 if (reply->depth == 0) { reply->depth = 1; }
3655 __glEmptyImage(gc, 3, reply->width, reply->height, reply->depth, format, type, xcb_glx_get_tex_image_data(reply), pixels);
3656 free(reply);
3657 #else
3658 GLubyte const * pc = __glXSetupSingleRequest(gc, X_GLsop_GetTexImage, cm dlen);
3659 (void) memcpy((void *)(pc + 0), (void *)(&target), 4);
3660 (void) memcpy((void *)(pc + 4), (void *)(&level), 4);
3661 (void) memcpy((void *)(pc + 8), (void *)(&format), 4);
3662 (void) memcpy((void *)(pc + 12), (void *)(&type), 4);
3663 *(int32_t *)(pc + 16) = 0;
3664 * (int8_t *)(pc + 16) = state->storePack.swapEndian;
3665 __glXReadPixelReply(dpy, gc, 3, 0, 0, 0, format, type, pixels, GL_TRUE);
3666 UnlockDisplay(dpy); SyncHandle();
3667 #endif /* USE_XCB */
3668 }
3669 return;
3670 }
3671
3672 #define X_GLsop_GetTexParameterfv 136
3673 void __indirect_glGetTexParameterfv(GLenum target, GLenum pname, GLfloat * param s)
3674 {
3675 struct glx_context * const gc = __glXGetCurrentContext();
3676 Display * const dpy = gc->currentDpy;
3677 #ifndef USE_XCB
3678 const GLuint cmdlen = 8;
3679 #endif
3680 if (__builtin_expect(dpy != NULL, 1)) {
3681 #ifdef USE_XCB
3682 xcb_connection_t *c = XGetXCBConnection(dpy);
3683 (void) __glXFlushRenderBuffer(gc, gc->pc);
3684 xcb_glx_get_tex_parameterfv_reply_t *reply = xcb_glx_get_tex_parameterfv _reply(c, xcb_glx_get_tex_parameterfv(c, gc->currentContextTag, target, pname), NULL);
3685 if (xcb_glx_get_tex_parameterfv_data_length(reply) == 0)
3686 (void)memcpy(params, &reply->datum, sizeof(reply->datum));
3687 else
3688 (void)memcpy(params, xcb_glx_get_tex_parameterfv_data(reply), xcb_gl x_get_tex_parameterfv_data_length(reply) * sizeof(GLfloat));
3689 free(reply);
3690 #else
3691 GLubyte const * pc = __glXSetupSingleRequest(gc, X_GLsop_GetTexParameter fv, cmdlen);
3692 (void) memcpy((void *)(pc + 0), (void *)(&target), 4);
3693 (void) memcpy((void *)(pc + 4), (void *)(&pname), 4);
3694 (void) __glXReadReply(dpy, 4, params, GL_FALSE);
3695 UnlockDisplay(dpy); SyncHandle();
3696 #endif /* USE_XCB */
3697 }
3698 return;
3699 }
3700
3701 #define X_GLsop_GetTexParameteriv 137
3702 void __indirect_glGetTexParameteriv(GLenum target, GLenum pname, GLint * params)
3703 {
3704 struct glx_context * const gc = __glXGetCurrentContext();
3705 Display * const dpy = gc->currentDpy;
3706 #ifndef USE_XCB
3707 const GLuint cmdlen = 8;
3708 #endif
3709 if (__builtin_expect(dpy != NULL, 1)) {
3710 #ifdef USE_XCB
3711 xcb_connection_t *c = XGetXCBConnection(dpy);
3712 (void) __glXFlushRenderBuffer(gc, gc->pc);
3713 xcb_glx_get_tex_parameteriv_reply_t *reply = xcb_glx_get_tex_parameteriv _reply(c, xcb_glx_get_tex_parameteriv(c, gc->currentContextTag, target, pname), NULL);
3714 if (xcb_glx_get_tex_parameteriv_data_length(reply) == 0)
3715 (void)memcpy(params, &reply->datum, sizeof(reply->datum));
3716 else
3717 (void)memcpy(params, xcb_glx_get_tex_parameteriv_data(reply), xcb_gl x_get_tex_parameteriv_data_length(reply) * sizeof(GLint));
3718 free(reply);
3719 #else
3720 GLubyte const * pc = __glXSetupSingleRequest(gc, X_GLsop_GetTexParameter iv, cmdlen);
3721 (void) memcpy((void *)(pc + 0), (void *)(&target), 4);
3722 (void) memcpy((void *)(pc + 4), (void *)(&pname), 4);
3723 (void) __glXReadReply(dpy, 4, params, GL_FALSE);
3724 UnlockDisplay(dpy); SyncHandle();
3725 #endif /* USE_XCB */
3726 }
3727 return;
3728 }
3729
3730 #define X_GLsop_GetTexLevelParameterfv 138
3731 void __indirect_glGetTexLevelParameterfv(GLenum target, GLint level, GLenum pnam e, GLfloat * params)
3732 {
3733 struct glx_context * const gc = __glXGetCurrentContext();
3734 Display * const dpy = gc->currentDpy;
3735 #ifndef USE_XCB
3736 const GLuint cmdlen = 12;
3737 #endif
3738 if (__builtin_expect(dpy != NULL, 1)) {
3739 #ifdef USE_XCB
3740 xcb_connection_t *c = XGetXCBConnection(dpy);
3741 (void) __glXFlushRenderBuffer(gc, gc->pc);
3742 xcb_glx_get_tex_level_parameterfv_reply_t *reply = xcb_glx_get_tex_level _parameterfv_reply(c, xcb_glx_get_tex_level_parameterfv(c, gc->currentContextTag , target, level, pname), NULL);
3743 if (xcb_glx_get_tex_level_parameterfv_data_length(reply) == 0)
3744 (void)memcpy(params, &reply->datum, sizeof(reply->datum));
3745 else
3746 (void)memcpy(params, xcb_glx_get_tex_level_parameterfv_data(reply), xcb_glx_get_tex_level_parameterfv_data_length(reply) * sizeof(GLfloat));
3747 free(reply);
3748 #else
3749 GLubyte const * pc = __glXSetupSingleRequest(gc, X_GLsop_GetTexLevelPara meterfv, cmdlen);
3750 (void) memcpy((void *)(pc + 0), (void *)(&target), 4);
3751 (void) memcpy((void *)(pc + 4), (void *)(&level), 4);
3752 (void) memcpy((void *)(pc + 8), (void *)(&pname), 4);
3753 (void) __glXReadReply(dpy, 4, params, GL_FALSE);
3754 UnlockDisplay(dpy); SyncHandle();
3755 #endif /* USE_XCB */
3756 }
3757 return;
3758 }
3759
3760 #define X_GLsop_GetTexLevelParameteriv 139
3761 void __indirect_glGetTexLevelParameteriv(GLenum target, GLint level, GLenum pnam e, GLint * params)
3762 {
3763 struct glx_context * const gc = __glXGetCurrentContext();
3764 Display * const dpy = gc->currentDpy;
3765 #ifndef USE_XCB
3766 const GLuint cmdlen = 12;
3767 #endif
3768 if (__builtin_expect(dpy != NULL, 1)) {
3769 #ifdef USE_XCB
3770 xcb_connection_t *c = XGetXCBConnection(dpy);
3771 (void) __glXFlushRenderBuffer(gc, gc->pc);
3772 xcb_glx_get_tex_level_parameteriv_reply_t *reply = xcb_glx_get_tex_level _parameteriv_reply(c, xcb_glx_get_tex_level_parameteriv(c, gc->currentContextTag , target, level, pname), NULL);
3773 if (xcb_glx_get_tex_level_parameteriv_data_length(reply) == 0)
3774 (void)memcpy(params, &reply->datum, sizeof(reply->datum));
3775 else
3776 (void)memcpy(params, xcb_glx_get_tex_level_parameteriv_data(reply), xcb_glx_get_tex_level_parameteriv_data_length(reply) * sizeof(GLint));
3777 free(reply);
3778 #else
3779 GLubyte const * pc = __glXSetupSingleRequest(gc, X_GLsop_GetTexLevelPara meteriv, cmdlen);
3780 (void) memcpy((void *)(pc + 0), (void *)(&target), 4);
3781 (void) memcpy((void *)(pc + 4), (void *)(&level), 4);
3782 (void) memcpy((void *)(pc + 8), (void *)(&pname), 4);
3783 (void) __glXReadReply(dpy, 4, params, GL_FALSE);
3784 UnlockDisplay(dpy); SyncHandle();
3785 #endif /* USE_XCB */
3786 }
3787 return;
3788 }
3789
3790 #define X_GLsop_IsList 141
3791 GLboolean __indirect_glIsList(GLuint list)
3792 {
3793 struct glx_context * const gc = __glXGetCurrentContext();
3794 Display * const dpy = gc->currentDpy;
3795 GLboolean retval = (GLboolean) 0;
3796 #ifndef USE_XCB
3797 const GLuint cmdlen = 4;
3798 #endif
3799 if (__builtin_expect(dpy != NULL, 1)) {
3800 #ifdef USE_XCB
3801 xcb_connection_t *c = XGetXCBConnection(dpy);
3802 (void) __glXFlushRenderBuffer(gc, gc->pc);
3803 xcb_glx_is_list_reply_t *reply = xcb_glx_is_list_reply(c, xcb_glx_is_lis t(c, gc->currentContextTag, list), NULL);
3804 retval = reply->ret_val;
3805 free(reply);
3806 #else
3807 GLubyte const * pc = __glXSetupSingleRequest(gc, X_GLsop_IsList, cmdlen) ;
3808 (void) memcpy((void *)(pc + 0), (void *)(&list), 4);
3809 retval = (GLboolean) __glXReadReply(dpy, 0, NULL, GL_FALSE);
3810 UnlockDisplay(dpy); SyncHandle();
3811 #endif /* USE_XCB */
3812 }
3813 return retval;
3814 }
3815
3816 #define X_GLrop_DepthRange 174
3817 void __indirect_glDepthRange(GLclampd zNear, GLclampd zFar)
3818 {
3819 struct glx_context * const gc = __glXGetCurrentContext();
3820 const GLuint cmdlen = 20;
3821 emit_header(gc->pc, X_GLrop_DepthRange, cmdlen);
3822 (void) memcpy((void *)(gc->pc + 4), (void *)(&zNear), 8);
3823 (void) memcpy((void *)(gc->pc + 12), (void *)(&zFar), 8);
3824 gc->pc += cmdlen;
3825 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
3826 }
3827
3828 #define X_GLrop_Frustum 175
3829 void __indirect_glFrustum(GLdouble left, GLdouble right, GLdouble bottom, GLdoub le top, GLdouble zNear, GLdouble zFar)
3830 {
3831 struct glx_context * const gc = __glXGetCurrentContext();
3832 const GLuint cmdlen = 52;
3833 emit_header(gc->pc, X_GLrop_Frustum, cmdlen);
3834 (void) memcpy((void *)(gc->pc + 4), (void *)(&left), 8);
3835 (void) memcpy((void *)(gc->pc + 12), (void *)(&right), 8);
3836 (void) memcpy((void *)(gc->pc + 20), (void *)(&bottom), 8);
3837 (void) memcpy((void *)(gc->pc + 28), (void *)(&top), 8);
3838 (void) memcpy((void *)(gc->pc + 36), (void *)(&zNear), 8);
3839 (void) memcpy((void *)(gc->pc + 44), (void *)(&zFar), 8);
3840 gc->pc += cmdlen;
3841 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
3842 }
3843
3844 #define X_GLrop_LoadIdentity 176
3845 void __indirect_glLoadIdentity(void)
3846 {
3847 struct glx_context * const gc = __glXGetCurrentContext();
3848 const GLuint cmdlen = 4;
3849 emit_header(gc->pc, X_GLrop_LoadIdentity, cmdlen);
3850 gc->pc += cmdlen;
3851 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
3852 }
3853
3854 #define X_GLrop_LoadMatrixf 177
3855 void __indirect_glLoadMatrixf(const GLfloat * m)
3856 {
3857 struct glx_context * const gc = __glXGetCurrentContext();
3858 const GLuint cmdlen = 68;
3859 emit_header(gc->pc, X_GLrop_LoadMatrixf, cmdlen);
3860 (void) memcpy((void *)(gc->pc + 4), (void *)(m), 64);
3861 gc->pc += cmdlen;
3862 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
3863 }
3864
3865 #define X_GLrop_LoadMatrixd 178
3866 void __indirect_glLoadMatrixd(const GLdouble * m)
3867 {
3868 struct glx_context * const gc = __glXGetCurrentContext();
3869 const GLuint cmdlen = 132;
3870 emit_header(gc->pc, X_GLrop_LoadMatrixd, cmdlen);
3871 (void) memcpy((void *)(gc->pc + 4), (void *)(m), 128);
3872 gc->pc += cmdlen;
3873 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
3874 }
3875
3876 #define X_GLrop_MatrixMode 179
3877 void __indirect_glMatrixMode(GLenum mode)
3878 {
3879 struct glx_context * const gc = __glXGetCurrentContext();
3880 const GLuint cmdlen = 8;
3881 emit_header(gc->pc, X_GLrop_MatrixMode, cmdlen);
3882 (void) memcpy((void *)(gc->pc + 4), (void *)(&mode), 4);
3883 gc->pc += cmdlen;
3884 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
3885 }
3886
3887 #define X_GLrop_MultMatrixf 180
3888 void __indirect_glMultMatrixf(const GLfloat * m)
3889 {
3890 struct glx_context * const gc = __glXGetCurrentContext();
3891 const GLuint cmdlen = 68;
3892 emit_header(gc->pc, X_GLrop_MultMatrixf, cmdlen);
3893 (void) memcpy((void *)(gc->pc + 4), (void *)(m), 64);
3894 gc->pc += cmdlen;
3895 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
3896 }
3897
3898 #define X_GLrop_MultMatrixd 181
3899 void __indirect_glMultMatrixd(const GLdouble * m)
3900 {
3901 struct glx_context * const gc = __glXGetCurrentContext();
3902 const GLuint cmdlen = 132;
3903 emit_header(gc->pc, X_GLrop_MultMatrixd, cmdlen);
3904 (void) memcpy((void *)(gc->pc + 4), (void *)(m), 128);
3905 gc->pc += cmdlen;
3906 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
3907 }
3908
3909 #define X_GLrop_Ortho 182
3910 void __indirect_glOrtho(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar)
3911 {
3912 struct glx_context * const gc = __glXGetCurrentContext();
3913 const GLuint cmdlen = 52;
3914 emit_header(gc->pc, X_GLrop_Ortho, cmdlen);
3915 (void) memcpy((void *)(gc->pc + 4), (void *)(&left), 8);
3916 (void) memcpy((void *)(gc->pc + 12), (void *)(&right), 8);
3917 (void) memcpy((void *)(gc->pc + 20), (void *)(&bottom), 8);
3918 (void) memcpy((void *)(gc->pc + 28), (void *)(&top), 8);
3919 (void) memcpy((void *)(gc->pc + 36), (void *)(&zNear), 8);
3920 (void) memcpy((void *)(gc->pc + 44), (void *)(&zFar), 8);
3921 gc->pc += cmdlen;
3922 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
3923 }
3924
3925 #define X_GLrop_PopMatrix 183
3926 void __indirect_glPopMatrix(void)
3927 {
3928 struct glx_context * const gc = __glXGetCurrentContext();
3929 const GLuint cmdlen = 4;
3930 emit_header(gc->pc, X_GLrop_PopMatrix, cmdlen);
3931 gc->pc += cmdlen;
3932 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
3933 }
3934
3935 #define X_GLrop_PushMatrix 184
3936 void __indirect_glPushMatrix(void)
3937 {
3938 struct glx_context * const gc = __glXGetCurrentContext();
3939 const GLuint cmdlen = 4;
3940 emit_header(gc->pc, X_GLrop_PushMatrix, cmdlen);
3941 gc->pc += cmdlen;
3942 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
3943 }
3944
3945 #define X_GLrop_Rotated 185
3946 void __indirect_glRotated(GLdouble angle, GLdouble x, GLdouble y, GLdouble z)
3947 {
3948 struct glx_context * const gc = __glXGetCurrentContext();
3949 const GLuint cmdlen = 36;
3950 emit_header(gc->pc, X_GLrop_Rotated, cmdlen);
3951 (void) memcpy((void *)(gc->pc + 4), (void *)(&angle), 8);
3952 (void) memcpy((void *)(gc->pc + 12), (void *)(&x), 8);
3953 (void) memcpy((void *)(gc->pc + 20), (void *)(&y), 8);
3954 (void) memcpy((void *)(gc->pc + 28), (void *)(&z), 8);
3955 gc->pc += cmdlen;
3956 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
3957 }
3958
3959 #define X_GLrop_Rotatef 186
3960 void __indirect_glRotatef(GLfloat angle, GLfloat x, GLfloat y, GLfloat z)
3961 {
3962 struct glx_context * const gc = __glXGetCurrentContext();
3963 const GLuint cmdlen = 20;
3964 emit_header(gc->pc, X_GLrop_Rotatef, cmdlen);
3965 (void) memcpy((void *)(gc->pc + 4), (void *)(&angle), 4);
3966 (void) memcpy((void *)(gc->pc + 8), (void *)(&x), 4);
3967 (void) memcpy((void *)(gc->pc + 12), (void *)(&y), 4);
3968 (void) memcpy((void *)(gc->pc + 16), (void *)(&z), 4);
3969 gc->pc += cmdlen;
3970 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
3971 }
3972
3973 #define X_GLrop_Scaled 187
3974 void __indirect_glScaled(GLdouble x, GLdouble y, GLdouble z)
3975 {
3976 struct glx_context * const gc = __glXGetCurrentContext();
3977 const GLuint cmdlen = 28;
3978 emit_header(gc->pc, X_GLrop_Scaled, cmdlen);
3979 (void) memcpy((void *)(gc->pc + 4), (void *)(&x), 8);
3980 (void) memcpy((void *)(gc->pc + 12), (void *)(&y), 8);
3981 (void) memcpy((void *)(gc->pc + 20), (void *)(&z), 8);
3982 gc->pc += cmdlen;
3983 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
3984 }
3985
3986 #define X_GLrop_Scalef 188
3987 void __indirect_glScalef(GLfloat x, GLfloat y, GLfloat z)
3988 {
3989 struct glx_context * const gc = __glXGetCurrentContext();
3990 const GLuint cmdlen = 16;
3991 emit_header(gc->pc, X_GLrop_Scalef, cmdlen);
3992 (void) memcpy((void *)(gc->pc + 4), (void *)(&x), 4);
3993 (void) memcpy((void *)(gc->pc + 8), (void *)(&y), 4);
3994 (void) memcpy((void *)(gc->pc + 12), (void *)(&z), 4);
3995 gc->pc += cmdlen;
3996 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
3997 }
3998
3999 #define X_GLrop_Translated 189
4000 void __indirect_glTranslated(GLdouble x, GLdouble y, GLdouble z)
4001 {
4002 struct glx_context * const gc = __glXGetCurrentContext();
4003 const GLuint cmdlen = 28;
4004 emit_header(gc->pc, X_GLrop_Translated, cmdlen);
4005 (void) memcpy((void *)(gc->pc + 4), (void *)(&x), 8);
4006 (void) memcpy((void *)(gc->pc + 12), (void *)(&y), 8);
4007 (void) memcpy((void *)(gc->pc + 20), (void *)(&z), 8);
4008 gc->pc += cmdlen;
4009 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
4010 }
4011
4012 #define X_GLrop_Translatef 190
4013 void __indirect_glTranslatef(GLfloat x, GLfloat y, GLfloat z)
4014 {
4015 struct glx_context * const gc = __glXGetCurrentContext();
4016 const GLuint cmdlen = 16;
4017 emit_header(gc->pc, X_GLrop_Translatef, cmdlen);
4018 (void) memcpy((void *)(gc->pc + 4), (void *)(&x), 4);
4019 (void) memcpy((void *)(gc->pc + 8), (void *)(&y), 4);
4020 (void) memcpy((void *)(gc->pc + 12), (void *)(&z), 4);
4021 gc->pc += cmdlen;
4022 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
4023 }
4024
4025 #define X_GLrop_Viewport 191
4026 void __indirect_glViewport(GLint x, GLint y, GLsizei width, GLsizei height)
4027 {
4028 struct glx_context * const gc = __glXGetCurrentContext();
4029 const GLuint cmdlen = 20;
4030 emit_header(gc->pc, X_GLrop_Viewport, cmdlen);
4031 (void) memcpy((void *)(gc->pc + 4), (void *)(&x), 4);
4032 (void) memcpy((void *)(gc->pc + 8), (void *)(&y), 4);
4033 (void) memcpy((void *)(gc->pc + 12), (void *)(&width), 4);
4034 (void) memcpy((void *)(gc->pc + 16), (void *)(&height), 4);
4035 gc->pc += cmdlen;
4036 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
4037 }
4038
4039 #define X_GLrop_BindTexture 4117
4040 void __indirect_glBindTexture(GLenum target, GLuint texture)
4041 {
4042 struct glx_context * const gc = __glXGetCurrentContext();
4043 const GLuint cmdlen = 12;
4044 emit_header(gc->pc, X_GLrop_BindTexture, cmdlen);
4045 (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
4046 (void) memcpy((void *)(gc->pc + 8), (void *)(&texture), 4);
4047 gc->pc += cmdlen;
4048 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
4049 }
4050
4051 #define X_GLrop_Indexubv 194
4052 void __indirect_glIndexub(GLubyte c)
4053 {
4054 struct glx_context * const gc = __glXGetCurrentContext();
4055 const GLuint cmdlen = 8;
4056 emit_header(gc->pc, X_GLrop_Indexubv, cmdlen);
4057 (void) memcpy((void *)(gc->pc + 4), (void *)(&c), 1);
4058 gc->pc += cmdlen;
4059 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
4060 }
4061
4062 #define X_GLrop_Indexubv 194
4063 void __indirect_glIndexubv(const GLubyte * c)
4064 {
4065 struct glx_context * const gc = __glXGetCurrentContext();
4066 const GLuint cmdlen = 8;
4067 emit_header(gc->pc, X_GLrop_Indexubv, cmdlen);
4068 (void) memcpy((void *)(gc->pc + 4), (void *)(c), 1);
4069 gc->pc += cmdlen;
4070 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
4071 }
4072
4073 #define X_GLrop_PolygonOffset 192
4074 void __indirect_glPolygonOffset(GLfloat factor, GLfloat units)
4075 {
4076 struct glx_context * const gc = __glXGetCurrentContext();
4077 const GLuint cmdlen = 12;
4078 emit_header(gc->pc, X_GLrop_PolygonOffset, cmdlen);
4079 (void) memcpy((void *)(gc->pc + 4), (void *)(&factor), 4);
4080 (void) memcpy((void *)(gc->pc + 8), (void *)(&units), 4);
4081 gc->pc += cmdlen;
4082 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
4083 }
4084
4085 #define X_GLrop_CopyTexImage1D 4119
4086 void __indirect_glCopyTexImage1D(GLenum target, GLint level, GLenum internalform at, GLint x, GLint y, GLsizei width, GLint border)
4087 {
4088 struct glx_context * const gc = __glXGetCurrentContext();
4089 const GLuint cmdlen = 32;
4090 emit_header(gc->pc, X_GLrop_CopyTexImage1D, cmdlen);
4091 (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
4092 (void) memcpy((void *)(gc->pc + 8), (void *)(&level), 4);
4093 (void) memcpy((void *)(gc->pc + 12), (void *)(&internalformat), 4);
4094 (void) memcpy((void *)(gc->pc + 16), (void *)(&x), 4);
4095 (void) memcpy((void *)(gc->pc + 20), (void *)(&y), 4);
4096 (void) memcpy((void *)(gc->pc + 24), (void *)(&width), 4);
4097 (void) memcpy((void *)(gc->pc + 28), (void *)(&border), 4);
4098 gc->pc += cmdlen;
4099 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
4100 }
4101
4102 #define X_GLrop_CopyTexImage2D 4120
4103 void __indirect_glCopyTexImage2D(GLenum target, GLint level, GLenum internalform at, GLint x, GLint y, GLsizei width, GLsizei height, GLint border)
4104 {
4105 struct glx_context * const gc = __glXGetCurrentContext();
4106 const GLuint cmdlen = 36;
4107 emit_header(gc->pc, X_GLrop_CopyTexImage2D, cmdlen);
4108 (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
4109 (void) memcpy((void *)(gc->pc + 8), (void *)(&level), 4);
4110 (void) memcpy((void *)(gc->pc + 12), (void *)(&internalformat), 4);
4111 (void) memcpy((void *)(gc->pc + 16), (void *)(&x), 4);
4112 (void) memcpy((void *)(gc->pc + 20), (void *)(&y), 4);
4113 (void) memcpy((void *)(gc->pc + 24), (void *)(&width), 4);
4114 (void) memcpy((void *)(gc->pc + 28), (void *)(&height), 4);
4115 (void) memcpy((void *)(gc->pc + 32), (void *)(&border), 4);
4116 gc->pc += cmdlen;
4117 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
4118 }
4119
4120 #define X_GLrop_CopyTexSubImage1D 4121
4121 void __indirect_glCopyTexSubImage1D(GLenum target, GLint level, GLint xoffset, G Lint x, GLint y, GLsizei width)
4122 {
4123 struct glx_context * const gc = __glXGetCurrentContext();
4124 const GLuint cmdlen = 28;
4125 emit_header(gc->pc, X_GLrop_CopyTexSubImage1D, cmdlen);
4126 (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
4127 (void) memcpy((void *)(gc->pc + 8), (void *)(&level), 4);
4128 (void) memcpy((void *)(gc->pc + 12), (void *)(&xoffset), 4);
4129 (void) memcpy((void *)(gc->pc + 16), (void *)(&x), 4);
4130 (void) memcpy((void *)(gc->pc + 20), (void *)(&y), 4);
4131 (void) memcpy((void *)(gc->pc + 24), (void *)(&width), 4);
4132 gc->pc += cmdlen;
4133 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
4134 }
4135
4136 #define X_GLrop_CopyTexSubImage2D 4122
4137 void __indirect_glCopyTexSubImage2D(GLenum target, GLint level, GLint xoffset, G Lint yoffset, GLint x, GLint y, GLsizei width, GLsizei height)
4138 {
4139 struct glx_context * const gc = __glXGetCurrentContext();
4140 const GLuint cmdlen = 36;
4141 emit_header(gc->pc, X_GLrop_CopyTexSubImage2D, cmdlen);
4142 (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
4143 (void) memcpy((void *)(gc->pc + 8), (void *)(&level), 4);
4144 (void) memcpy((void *)(gc->pc + 12), (void *)(&xoffset), 4);
4145 (void) memcpy((void *)(gc->pc + 16), (void *)(&yoffset), 4);
4146 (void) memcpy((void *)(gc->pc + 20), (void *)(&x), 4);
4147 (void) memcpy((void *)(gc->pc + 24), (void *)(&y), 4);
4148 (void) memcpy((void *)(gc->pc + 28), (void *)(&width), 4);
4149 (void) memcpy((void *)(gc->pc + 32), (void *)(&height), 4);
4150 gc->pc += cmdlen;
4151 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
4152 }
4153
4154 #define X_GLsop_DeleteTextures 144
4155 void __indirect_glDeleteTextures(GLsizei n, const GLuint * textures)
4156 {
4157 struct glx_context * const gc = __glXGetCurrentContext();
4158 Display * const dpy = gc->currentDpy;
4159 #ifndef USE_XCB
4160 const GLuint cmdlen = 4 + __GLX_PAD((n * 4));
4161 #endif
4162 if (n < 0) {
4163 __glXSetError(gc, GL_INVALID_VALUE);
4164 return;
4165 }
4166 if (__builtin_expect((n >= 0) && (dpy != NULL), 1)) {
4167 #ifdef USE_XCB
4168 xcb_connection_t *c = XGetXCBConnection(dpy);
4169 (void) __glXFlushRenderBuffer(gc, gc->pc);
4170 xcb_glx_delete_textures(c, gc->currentContextTag, n, textures);
4171 #else
4172 GLubyte const * pc = __glXSetupSingleRequest(gc, X_GLsop_DeleteTextures, cmdlen);
4173 (void) memcpy((void *)(pc + 0), (void *)(&n), 4);
4174 (void) memcpy((void *)(pc + 4), (void *)(textures), (n * 4));
4175 UnlockDisplay(dpy); SyncHandle();
4176 #endif /* USE_XCB */
4177 }
4178 return;
4179 }
4180
4181 #define X_GLvop_DeleteTexturesEXT 12
4182 void glDeleteTexturesEXT(GLsizei n, const GLuint * textures)
4183 {
4184 struct glx_context * const gc = __glXGetCurrentContext();
4185
4186 #if defined(GLX_DIRECT_RENDERING) && !defined(GLX_USE_APPLEGL)
4187 if (gc->isDirect) {
4188 const _glapi_proc *const disp_table = GET_DISPATCH();
4189 PFNGLDELETETEXTURESEXTPROC p =
4190 (PFNGLDELETETEXTURESEXTPROC) disp_table[327];
4191 p(n, textures);
4192 } else
4193 #endif
4194 {
4195 struct glx_context * const gc = __glXGetCurrentContext();
4196 Display * const dpy = gc->currentDpy;
4197 const GLuint cmdlen = 4 + __GLX_PAD((n * 4));
4198 if (n < 0) {
4199 __glXSetError(gc, GL_INVALID_VALUE);
4200 return;
4201 }
4202 if (__builtin_expect((n >= 0) && (dpy != NULL), 1)) {
4203 GLubyte const * pc = __glXSetupVendorRequest(gc, X_GLXVendorPrivate, X_G Lvop_DeleteTexturesEXT, cmdlen);
4204 (void) memcpy((void *)(pc + 0), (void *)(&n), 4);
4205 (void) memcpy((void *)(pc + 4), (void *)(textures), (n * 4));
4206 UnlockDisplay(dpy); SyncHandle();
4207 }
4208 return;
4209 }
4210 }
4211
4212 #define X_GLsop_GenTextures 145
4213 void __indirect_glGenTextures(GLsizei n, GLuint * textures)
4214 {
4215 struct glx_context * const gc = __glXGetCurrentContext();
4216 Display * const dpy = gc->currentDpy;
4217 #ifndef USE_XCB
4218 const GLuint cmdlen = 4;
4219 #endif
4220 if (n < 0) {
4221 __glXSetError(gc, GL_INVALID_VALUE);
4222 return;
4223 }
4224 if (__builtin_expect((n >= 0) && (dpy != NULL), 1)) {
4225 #ifdef USE_XCB
4226 xcb_connection_t *c = XGetXCBConnection(dpy);
4227 (void) __glXFlushRenderBuffer(gc, gc->pc);
4228 xcb_glx_gen_textures_reply_t *reply = xcb_glx_gen_textures_reply(c, xcb_ glx_gen_textures(c, gc->currentContextTag, n), NULL);
4229 (void)memcpy(textures, xcb_glx_gen_textures_data(reply), xcb_glx_gen_tex tures_data_length(reply) * sizeof(GLuint));
4230 free(reply);
4231 #else
4232 GLubyte const * pc = __glXSetupSingleRequest(gc, X_GLsop_GenTextures, cm dlen);
4233 (void) memcpy((void *)(pc + 0), (void *)(&n), 4);
4234 (void) __glXReadReply(dpy, 4, textures, GL_TRUE);
4235 UnlockDisplay(dpy); SyncHandle();
4236 #endif /* USE_XCB */
4237 }
4238 return;
4239 }
4240
4241 #define X_GLvop_GenTexturesEXT 13
4242 void glGenTexturesEXT(GLsizei n, GLuint * textures)
4243 {
4244 struct glx_context * const gc = __glXGetCurrentContext();
4245
4246 #if defined(GLX_DIRECT_RENDERING) && !defined(GLX_USE_APPLEGL)
4247 if (gc->isDirect) {
4248 const _glapi_proc *const disp_table = GET_DISPATCH();
4249 PFNGLGENTEXTURESEXTPROC p =
4250 (PFNGLGENTEXTURESEXTPROC) disp_table[328];
4251 p(n, textures);
4252 } else
4253 #endif
4254 {
4255 struct glx_context * const gc = __glXGetCurrentContext();
4256 Display * const dpy = gc->currentDpy;
4257 const GLuint cmdlen = 4;
4258 if (n < 0) {
4259 __glXSetError(gc, GL_INVALID_VALUE);
4260 return;
4261 }
4262 if (__builtin_expect((n >= 0) && (dpy != NULL), 1)) {
4263 GLubyte const * pc = __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithR eply, X_GLvop_GenTexturesEXT, cmdlen);
4264 (void) memcpy((void *)(pc + 0), (void *)(&n), 4);
4265 (void) __glXReadReply(dpy, 4, textures, GL_TRUE);
4266 UnlockDisplay(dpy); SyncHandle();
4267 }
4268 return;
4269 }
4270 }
4271
4272 #define X_GLsop_IsTexture 146
4273 GLboolean __indirect_glIsTexture(GLuint texture)
4274 {
4275 struct glx_context * const gc = __glXGetCurrentContext();
4276 Display * const dpy = gc->currentDpy;
4277 GLboolean retval = (GLboolean) 0;
4278 #ifndef USE_XCB
4279 const GLuint cmdlen = 4;
4280 #endif
4281 if (__builtin_expect(dpy != NULL, 1)) {
4282 #ifdef USE_XCB
4283 xcb_connection_t *c = XGetXCBConnection(dpy);
4284 (void) __glXFlushRenderBuffer(gc, gc->pc);
4285 xcb_glx_is_texture_reply_t *reply = xcb_glx_is_texture_reply(c, xcb_glx_ is_texture(c, gc->currentContextTag, texture), NULL);
4286 retval = reply->ret_val;
4287 free(reply);
4288 #else
4289 GLubyte const * pc = __glXSetupSingleRequest(gc, X_GLsop_IsTexture, cmdl en);
4290 (void) memcpy((void *)(pc + 0), (void *)(&texture), 4);
4291 retval = (GLboolean) __glXReadReply(dpy, 0, NULL, GL_FALSE);
4292 UnlockDisplay(dpy); SyncHandle();
4293 #endif /* USE_XCB */
4294 }
4295 return retval;
4296 }
4297
4298 #define X_GLvop_IsTextureEXT 14
4299 GLboolean glIsTextureEXT(GLuint texture)
4300 {
4301 struct glx_context * const gc = __glXGetCurrentContext();
4302
4303 #if defined(GLX_DIRECT_RENDERING) && !defined(GLX_USE_APPLEGL)
4304 if (gc->isDirect) {
4305 const _glapi_proc *const disp_table = GET_DISPATCH();
4306 PFNGLISTEXTUREEXTPROC p =
4307 (PFNGLISTEXTUREEXTPROC) disp_table[330];
4308 return p(texture);
4309 } else
4310 #endif
4311 {
4312 struct glx_context * const gc = __glXGetCurrentContext();
4313 Display * const dpy = gc->currentDpy;
4314 GLboolean retval = (GLboolean) 0;
4315 const GLuint cmdlen = 4;
4316 if (__builtin_expect(dpy != NULL, 1)) {
4317 GLubyte const * pc = __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithR eply, X_GLvop_IsTextureEXT, cmdlen);
4318 (void) memcpy((void *)(pc + 0), (void *)(&texture), 4);
4319 retval = (GLboolean) __glXReadReply(dpy, 0, NULL, GL_FALSE);
4320 UnlockDisplay(dpy); SyncHandle();
4321 }
4322 return retval;
4323 }
4324 }
4325
4326 #define X_GLrop_PrioritizeTextures 4118
4327 void __indirect_glPrioritizeTextures(GLsizei n, const GLuint * textures, const G Lclampf * priorities)
4328 {
4329 struct glx_context * const gc = __glXGetCurrentContext();
4330 const GLuint cmdlen = 8 + __GLX_PAD((n * 4)) + __GLX_PAD((n * 4));
4331 if (n < 0) {
4332 __glXSetError(gc, GL_INVALID_VALUE);
4333 return;
4334 }
4335 if (__builtin_expect(n >= 0, 1)) {
4336 emit_header(gc->pc, X_GLrop_PrioritizeTextures, cmdlen);
4337 (void) memcpy((void *)(gc->pc + 4), (void *)(&n), 4);
4338 (void) memcpy((void *)(gc->pc + 8), (void *)(textures), (n * 4));
4339 (void) memcpy((void *)(gc->pc + 8 + (n * 4)), (void *)(priorities), (n * 4));
4340 gc->pc += cmdlen;
4341 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
4342 }
4343 }
4344
4345 static void
4346 __glx_TexSubImage_1D2D( unsigned opcode, unsigned dim, GLenum target, GLint leve l, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, G Lenum type, const GLvoid * pixels )
4347 {
4348 struct glx_context * const gc = __glXGetCurrentContext();
4349 const GLuint compsize = (pixels != NULL) ? __glImageSize(width, height, 1, f ormat, type, target) : 0;
4350 const GLuint cmdlen = 60 + __GLX_PAD(compsize);
4351 if (__builtin_expect(gc->currentDpy != NULL, 1)) {
4352 if (cmdlen <= gc->maxSmallRenderCommandSize) {
4353 if ( (gc->pc + cmdlen) > gc->bufEnd ) {
4354 (void) __glXFlushRenderBuffer(gc, gc->pc);
4355 }
4356 emit_header(gc->pc, opcode, cmdlen);
4357 (void) memcpy((void *)(gc->pc + 24), (void *)(&target), 4);
4358 (void) memcpy((void *)(gc->pc + 28), (void *)(&level), 4);
4359 (void) memcpy((void *)(gc->pc + 32), (void *)(&xoffset), 4);
4360 (void) memcpy((void *)(gc->pc + 36), (void *)(&yoffset), 4);
4361 (void) memcpy((void *)(gc->pc + 40), (void *)(&width), 4);
4362 (void) memcpy((void *)(gc->pc + 44), (void *)(&height), 4);
4363 (void) memcpy((void *)(gc->pc + 48), (void *)(&format), 4);
4364 (void) memcpy((void *)(gc->pc + 52), (void *)(&type), 4);
4365 (void) memset((void *)(gc->pc + 56), 0, 4);
4366 if (compsize > 0) {
4367 (*gc->fillImage)(gc, dim, width, height, 1, format, type, pixels, gc->pc + 6 0, gc->pc + 4);
4368 } else {
4369 (void) memcpy( gc->pc + 4, default_pixel_store_2D, default_pixel_store_2D_si ze );
4370 }
4371 gc->pc += cmdlen;
4372 if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
4373 }
4374 else {
4375 const GLint op = opcode;
4376 const GLuint cmdlenLarge = cmdlen + 4;
4377 GLubyte * const pc = __glXFlushRenderBuffer(gc, gc->pc);
4378 (void) memcpy((void *)(pc + 0), (void *)(&cmdlenLarge), 4);
4379 (void) memcpy((void *)(pc + 4), (void *)(&op), 4);
4380 (void) memcpy((void *)(pc + 28), (void *)(&target), 4);
4381 (void) memcpy((void *)(pc + 32), (void *)(&level), 4);
4382 (void) memcpy((void *)(pc + 36), (void *)(&xoffset), 4);
4383 (void) memcpy((void *)(pc + 40), (void *)(&yoffset), 4);
4384 (void) memcpy((void *)(pc + 44), (void *)(&width), 4);
4385 (void) memcpy((void *)(pc + 48), (void *)(&height), 4);
4386 (void) memcpy((void *)(pc + 52), (void *)(&format), 4);
4387 (void) memcpy((void *)(pc + 56), (void *)(&type), 4);
4388 (void) memset((void *)(pc + 60), 0, 4);
4389 __glXSendLargeImage(gc, compsize, dim, width, height, 1, format, type, pixels, p c + 64, pc + 8);
4390 }
4391 }
4392 }
4393
4394 #define X_GLrop_TexSubImage1D 4099
4395 void __indirect_glTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLsiz ei width, GLenum format, GLenum type, const GLvoid * pixels)
4396 {
4397 __glx_TexSubImage_1D2D(X_GLrop_TexSubImage1D, 1, target, level, xoffset, 1, width, 1, format, type, pixels );
4398 }
4399
4400 #define X_GLrop_TexSubImage2D 4100
4401 void __indirect_glTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoi d * pixels)
4402 {
4403 __glx_TexSubImage_1D2D(X_GLrop_TexSubImage2D, 2, target, level, xoffset, yof fset, width, height, format, type, pixels );
4404 }
4405
4406 #define X_GLrop_BlendColor 4096
4407 void __indirect_glBlendColor(GLclampf red, GLclampf green, GLclampf blue, GLclam pf alpha)
4408 {
4409 struct glx_context * const gc = __glXGetCurrentContext();
4410 const GLuint cmdlen = 20;
4411 emit_header(gc->pc, X_GLrop_BlendColor, cmdlen);
4412 (void) memcpy((void *)(gc->pc + 4), (void *)(&red), 4);
4413 (void) memcpy((void *)(gc->pc + 8), (void *)(&green), 4);
4414 (void) memcpy((void *)(gc->pc + 12), (void *)(&blue), 4);
4415 (void) memcpy((void *)(gc->pc + 16), (void *)(&alpha), 4);
4416 gc->pc += cmdlen;
4417 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
4418 }
4419
4420 #define X_GLrop_BlendEquation 4097
4421 void __indirect_glBlendEquation(GLenum mode)
4422 {
4423 struct glx_context * const gc = __glXGetCurrentContext();
4424 const GLuint cmdlen = 8;
4425 emit_header(gc->pc, X_GLrop_BlendEquation, cmdlen);
4426 (void) memcpy((void *)(gc->pc + 4), (void *)(&mode), 4);
4427 gc->pc += cmdlen;
4428 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
4429 }
4430
4431 #define X_GLrop_ColorTable 2053
4432 void __indirect_glColorTable(GLenum target, GLenum internalformat, GLsizei width , GLenum format, GLenum type, const GLvoid * table)
4433 {
4434 struct glx_context * const gc = __glXGetCurrentContext();
4435 const GLuint compsize = (table != NULL) ? __glImageSize(width, 1, 1, format, type, target) : 0;
4436 const GLuint cmdlen = 44 + __GLX_PAD(compsize);
4437 if (__builtin_expect(gc->currentDpy != NULL, 1)) {
4438 if (cmdlen <= gc->maxSmallRenderCommandSize) {
4439 if ( (gc->pc + cmdlen) > gc->bufEnd ) {
4440 (void) __glXFlushRenderBuffer(gc, gc->pc);
4441 }
4442 emit_header(gc->pc, X_GLrop_ColorTable, cmdlen);
4443 (void) memcpy((void *)(gc->pc + 24), (void *)(&target), 4);
4444 (void) memcpy((void *)(gc->pc + 28), (void *)(&internalformat), 4);
4445 (void) memcpy((void *)(gc->pc + 32), (void *)(&width), 4);
4446 (void) memcpy((void *)(gc->pc + 36), (void *)(&format), 4);
4447 (void) memcpy((void *)(gc->pc + 40), (void *)(&type), 4);
4448 if (compsize > 0) {
4449 (*gc->fillImage)(gc, 1, width, 1, 1, format, type, table, gc->pc + 44, gc->p c + 4);
4450 } else {
4451 (void) memcpy( gc->pc + 4, default_pixel_store_1D, default_pixel_store_1D_si ze );
4452 }
4453 gc->pc += cmdlen;
4454 if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
4455 }
4456 else {
4457 const GLint op = X_GLrop_ColorTable;
4458 const GLuint cmdlenLarge = cmdlen + 4;
4459 GLubyte * const pc = __glXFlushRenderBuffer(gc, gc->pc);
4460 (void) memcpy((void *)(pc + 0), (void *)(&cmdlenLarge), 4);
4461 (void) memcpy((void *)(pc + 4), (void *)(&op), 4);
4462 (void) memcpy((void *)(pc + 28), (void *)(&target), 4);
4463 (void) memcpy((void *)(pc + 32), (void *)(&internalformat), 4);
4464 (void) memcpy((void *)(pc + 36), (void *)(&width), 4);
4465 (void) memcpy((void *)(pc + 40), (void *)(&format), 4);
4466 (void) memcpy((void *)(pc + 44), (void *)(&type), 4);
4467 __glXSendLargeImage(gc, compsize, 1, width, 1, 1, format, type, table, pc + 48, pc + 8);
4468 }
4469 }
4470 }
4471
4472 #define X_GLrop_ColorTableParameterfv 2054
4473 void __indirect_glColorTableParameterfv(GLenum target, GLenum pname, const GLflo at * params)
4474 {
4475 struct glx_context * const gc = __glXGetCurrentContext();
4476 const GLuint compsize = __glColorTableParameterfv_size(pname);
4477 const GLuint cmdlen = 12 + __GLX_PAD((compsize * 4));
4478 emit_header(gc->pc, X_GLrop_ColorTableParameterfv, cmdlen);
4479 (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
4480 (void) memcpy((void *)(gc->pc + 8), (void *)(&pname), 4);
4481 (void) memcpy((void *)(gc->pc + 12), (void *)(params), (compsize * 4));
4482 gc->pc += cmdlen;
4483 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
4484 }
4485
4486 #define X_GLrop_ColorTableParameteriv 2055
4487 void __indirect_glColorTableParameteriv(GLenum target, GLenum pname, const GLint * params)
4488 {
4489 struct glx_context * const gc = __glXGetCurrentContext();
4490 const GLuint compsize = __glColorTableParameteriv_size(pname);
4491 const GLuint cmdlen = 12 + __GLX_PAD((compsize * 4));
4492 emit_header(gc->pc, X_GLrop_ColorTableParameteriv, cmdlen);
4493 (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
4494 (void) memcpy((void *)(gc->pc + 8), (void *)(&pname), 4);
4495 (void) memcpy((void *)(gc->pc + 12), (void *)(params), (compsize * 4));
4496 gc->pc += cmdlen;
4497 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
4498 }
4499
4500 #define X_GLrop_CopyColorTable 2056
4501 void __indirect_glCopyColorTable(GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width)
4502 {
4503 struct glx_context * const gc = __glXGetCurrentContext();
4504 const GLuint cmdlen = 24;
4505 emit_header(gc->pc, X_GLrop_CopyColorTable, cmdlen);
4506 (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
4507 (void) memcpy((void *)(gc->pc + 8), (void *)(&internalformat), 4);
4508 (void) memcpy((void *)(gc->pc + 12), (void *)(&x), 4);
4509 (void) memcpy((void *)(gc->pc + 16), (void *)(&y), 4);
4510 (void) memcpy((void *)(gc->pc + 20), (void *)(&width), 4);
4511 gc->pc += cmdlen;
4512 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
4513 }
4514
4515 #define X_GLsop_GetColorTable 147
4516 void __indirect_glGetColorTable(GLenum target, GLenum format, GLenum type, GLvoi d * table)
4517 {
4518 struct glx_context * const gc = __glXGetCurrentContext();
4519 const __GLXattribute * const state = gc->client_state_private;
4520 Display * const dpy = gc->currentDpy;
4521 #ifndef USE_XCB
4522 const GLuint cmdlen = 16;
4523 #endif
4524 if (__builtin_expect(dpy != NULL, 1)) {
4525 #ifdef USE_XCB
4526 xcb_connection_t *c = XGetXCBConnection(dpy);
4527 (void) __glXFlushRenderBuffer(gc, gc->pc);
4528 xcb_glx_get_color_table_reply_t *reply = xcb_glx_get_color_table_reply(c , xcb_glx_get_color_table(c, gc->currentContextTag, target, format, type, state- >storePack.swapEndian), NULL);
4529 __glEmptyImage(gc, 3, reply->width, 1, 1, format, type, xcb_glx_get_colo r_table_data(reply), table);
4530 free(reply);
4531 #else
4532 GLubyte const * pc = __glXSetupSingleRequest(gc, X_GLsop_GetColorTable, cmdlen);
4533 (void) memcpy((void *)(pc + 0), (void *)(&target), 4);
4534 (void) memcpy((void *)(pc + 4), (void *)(&format), 4);
4535 (void) memcpy((void *)(pc + 8), (void *)(&type), 4);
4536 *(int32_t *)(pc + 12) = 0;
4537 * (int8_t *)(pc + 12) = state->storePack.swapEndian;
4538 __glXReadPixelReply(dpy, gc, 1, 0, 0, 0, format, type, table, GL_TRUE);
4539 UnlockDisplay(dpy); SyncHandle();
4540 #endif /* USE_XCB */
4541 }
4542 return;
4543 }
4544
4545 #define X_GLvop_GetColorTableSGI 4098
4546 void glGetColorTableEXT(GLenum target, GLenum format, GLenum type, GLvoid * tabl e)
4547 {
4548 struct glx_context * const gc = __glXGetCurrentContext();
4549
4550 #if defined(GLX_DIRECT_RENDERING) && !defined(GLX_USE_APPLEGL)
4551 if (gc->isDirect) {
4552 const _glapi_proc *const disp_table = GET_DISPATCH();
4553 PFNGLGETCOLORTABLESGIPROC p =
4554 (PFNGLGETCOLORTABLESGIPROC) disp_table[343];
4555 p(target, format, type, table);
4556 } else
4557 #endif
4558 {
4559 struct glx_context * const gc = __glXGetCurrentContext();
4560 const __GLXattribute * const state = gc->client_state_private;
4561 Display * const dpy = gc->currentDpy;
4562 const GLuint cmdlen = 16;
4563 if (__builtin_expect(dpy != NULL, 1)) {
4564 GLubyte const * pc = __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithR eply, X_GLvop_GetColorTableSGI, cmdlen);
4565 (void) memcpy((void *)(pc + 0), (void *)(&target), 4);
4566 (void) memcpy((void *)(pc + 4), (void *)(&format), 4);
4567 (void) memcpy((void *)(pc + 8), (void *)(&type), 4);
4568 *(int32_t *)(pc + 12) = 0;
4569 * (int8_t *)(pc + 12) = state->storePack.swapEndian;
4570 __glXReadPixelReply(dpy, gc, 1, 0, 0, 0, format, type, table, GL_TRUE);
4571 UnlockDisplay(dpy); SyncHandle();
4572 }
4573 return;
4574 }
4575 }
4576
4577 #define X_GLsop_GetColorTableParameterfv 148
4578 void __indirect_glGetColorTableParameterfv(GLenum target, GLenum pname, GLfloat * params)
4579 {
4580 struct glx_context * const gc = __glXGetCurrentContext();
4581 Display * const dpy = gc->currentDpy;
4582 #ifndef USE_XCB
4583 const GLuint cmdlen = 8;
4584 #endif
4585 if (__builtin_expect(dpy != NULL, 1)) {
4586 #ifdef USE_XCB
4587 xcb_connection_t *c = XGetXCBConnection(dpy);
4588 (void) __glXFlushRenderBuffer(gc, gc->pc);
4589 xcb_glx_get_color_table_parameterfv_reply_t *reply = xcb_glx_get_color_t able_parameterfv_reply(c, xcb_glx_get_color_table_parameterfv(c, gc->currentCont extTag, target, pname), NULL);
4590 if (xcb_glx_get_color_table_parameterfv_data_length(reply) == 0)
4591 (void)memcpy(params, &reply->datum, sizeof(reply->datum));
4592 else
4593 (void)memcpy(params, xcb_glx_get_color_table_parameterfv_data(reply) , xcb_glx_get_color_table_parameterfv_data_length(reply) * sizeof(GLfloat));
4594 free(reply);
4595 #else
4596 GLubyte const * pc = __glXSetupSingleRequest(gc, X_GLsop_GetColorTablePa rameterfv, cmdlen);
4597 (void) memcpy((void *)(pc + 0), (void *)(&target), 4);
4598 (void) memcpy((void *)(pc + 4), (void *)(&pname), 4);
4599 (void) __glXReadReply(dpy, 4, params, GL_FALSE);
4600 UnlockDisplay(dpy); SyncHandle();
4601 #endif /* USE_XCB */
4602 }
4603 return;
4604 }
4605
4606 #define X_GLvop_GetColorTableParameterfvSGI 4099
4607 void glGetColorTableParameterfvEXT(GLenum target, GLenum pname, GLfloat * params )
4608 {
4609 struct glx_context * const gc = __glXGetCurrentContext();
4610
4611 #if defined(GLX_DIRECT_RENDERING) && !defined(GLX_USE_APPLEGL)
4612 if (gc->isDirect) {
4613 const _glapi_proc *const disp_table = GET_DISPATCH();
4614 PFNGLGETCOLORTABLEPARAMETERFVSGIPROC p =
4615 (PFNGLGETCOLORTABLEPARAMETERFVSGIPROC) disp_table[344];
4616 p(target, pname, params);
4617 } else
4618 #endif
4619 {
4620 struct glx_context * const gc = __glXGetCurrentContext();
4621 Display * const dpy = gc->currentDpy;
4622 const GLuint cmdlen = 8;
4623 if (__builtin_expect(dpy != NULL, 1)) {
4624 GLubyte const * pc = __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithR eply, X_GLvop_GetColorTableParameterfvSGI, cmdlen);
4625 (void) memcpy((void *)(pc + 0), (void *)(&target), 4);
4626 (void) memcpy((void *)(pc + 4), (void *)(&pname), 4);
4627 (void) __glXReadReply(dpy, 4, params, GL_FALSE);
4628 UnlockDisplay(dpy); SyncHandle();
4629 }
4630 return;
4631 }
4632 }
4633
4634 #define X_GLsop_GetColorTableParameteriv 149
4635 void __indirect_glGetColorTableParameteriv(GLenum target, GLenum pname, GLint * params)
4636 {
4637 struct glx_context * const gc = __glXGetCurrentContext();
4638 Display * const dpy = gc->currentDpy;
4639 #ifndef USE_XCB
4640 const GLuint cmdlen = 8;
4641 #endif
4642 if (__builtin_expect(dpy != NULL, 1)) {
4643 #ifdef USE_XCB
4644 xcb_connection_t *c = XGetXCBConnection(dpy);
4645 (void) __glXFlushRenderBuffer(gc, gc->pc);
4646 xcb_glx_get_color_table_parameteriv_reply_t *reply = xcb_glx_get_color_t able_parameteriv_reply(c, xcb_glx_get_color_table_parameteriv(c, gc->currentCont extTag, target, pname), NULL);
4647 if (xcb_glx_get_color_table_parameteriv_data_length(reply) == 0)
4648 (void)memcpy(params, &reply->datum, sizeof(reply->datum));
4649 else
4650 (void)memcpy(params, xcb_glx_get_color_table_parameteriv_data(reply) , xcb_glx_get_color_table_parameteriv_data_length(reply) * sizeof(GLint));
4651 free(reply);
4652 #else
4653 GLubyte const * pc = __glXSetupSingleRequest(gc, X_GLsop_GetColorTablePa rameteriv, cmdlen);
4654 (void) memcpy((void *)(pc + 0), (void *)(&target), 4);
4655 (void) memcpy((void *)(pc + 4), (void *)(&pname), 4);
4656 (void) __glXReadReply(dpy, 4, params, GL_FALSE);
4657 UnlockDisplay(dpy); SyncHandle();
4658 #endif /* USE_XCB */
4659 }
4660 return;
4661 }
4662
4663 #define X_GLvop_GetColorTableParameterivSGI 4100
4664 void glGetColorTableParameterivEXT(GLenum target, GLenum pname, GLint * params)
4665 {
4666 struct glx_context * const gc = __glXGetCurrentContext();
4667
4668 #if defined(GLX_DIRECT_RENDERING) && !defined(GLX_USE_APPLEGL)
4669 if (gc->isDirect) {
4670 const _glapi_proc *const disp_table = GET_DISPATCH();
4671 PFNGLGETCOLORTABLEPARAMETERIVSGIPROC p =
4672 (PFNGLGETCOLORTABLEPARAMETERIVSGIPROC) disp_table[345];
4673 p(target, pname, params);
4674 } else
4675 #endif
4676 {
4677 struct glx_context * const gc = __glXGetCurrentContext();
4678 Display * const dpy = gc->currentDpy;
4679 const GLuint cmdlen = 8;
4680 if (__builtin_expect(dpy != NULL, 1)) {
4681 GLubyte const * pc = __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithR eply, X_GLvop_GetColorTableParameterivSGI, cmdlen);
4682 (void) memcpy((void *)(pc + 0), (void *)(&target), 4);
4683 (void) memcpy((void *)(pc + 4), (void *)(&pname), 4);
4684 (void) __glXReadReply(dpy, 4, params, GL_FALSE);
4685 UnlockDisplay(dpy); SyncHandle();
4686 }
4687 return;
4688 }
4689 }
4690
4691 #define X_GLrop_ColorSubTable 195
4692 void __indirect_glColorSubTable(GLenum target, GLsizei start, GLsizei count, GLe num format, GLenum type, const GLvoid * data)
4693 {
4694 struct glx_context * const gc = __glXGetCurrentContext();
4695 const GLuint compsize = (data != NULL) ? __glImageSize(count, 1, 1, format, type, target) : 0;
4696 const GLuint cmdlen = 44 + __GLX_PAD(compsize);
4697 if (__builtin_expect(gc->currentDpy != NULL, 1)) {
4698 if (cmdlen <= gc->maxSmallRenderCommandSize) {
4699 if ( (gc->pc + cmdlen) > gc->bufEnd ) {
4700 (void) __glXFlushRenderBuffer(gc, gc->pc);
4701 }
4702 emit_header(gc->pc, X_GLrop_ColorSubTable, cmdlen);
4703 (void) memcpy((void *)(gc->pc + 24), (void *)(&target), 4);
4704 (void) memcpy((void *)(gc->pc + 28), (void *)(&start), 4);
4705 (void) memcpy((void *)(gc->pc + 32), (void *)(&count), 4);
4706 (void) memcpy((void *)(gc->pc + 36), (void *)(&format), 4);
4707 (void) memcpy((void *)(gc->pc + 40), (void *)(&type), 4);
4708 if (compsize > 0) {
4709 (*gc->fillImage)(gc, 1, count, 1, 1, format, type, data, gc->pc + 44, gc->pc + 4);
4710 } else {
4711 (void) memcpy( gc->pc + 4, default_pixel_store_1D, default_pixel_store_1D_si ze );
4712 }
4713 gc->pc += cmdlen;
4714 if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
4715 }
4716 else {
4717 const GLint op = X_GLrop_ColorSubTable;
4718 const GLuint cmdlenLarge = cmdlen + 4;
4719 GLubyte * const pc = __glXFlushRenderBuffer(gc, gc->pc);
4720 (void) memcpy((void *)(pc + 0), (void *)(&cmdlenLarge), 4);
4721 (void) memcpy((void *)(pc + 4), (void *)(&op), 4);
4722 (void) memcpy((void *)(pc + 28), (void *)(&target), 4);
4723 (void) memcpy((void *)(pc + 32), (void *)(&start), 4);
4724 (void) memcpy((void *)(pc + 36), (void *)(&count), 4);
4725 (void) memcpy((void *)(pc + 40), (void *)(&format), 4);
4726 (void) memcpy((void *)(pc + 44), (void *)(&type), 4);
4727 __glXSendLargeImage(gc, compsize, 1, count, 1, 1, format, type, data, pc + 48, p c + 8);
4728 }
4729 }
4730 }
4731
4732 #define X_GLrop_CopyColorSubTable 196
4733 void __indirect_glCopyColorSubTable(GLenum target, GLsizei start, GLint x, GLint y, GLsizei width)
4734 {
4735 struct glx_context * const gc = __glXGetCurrentContext();
4736 const GLuint cmdlen = 24;
4737 emit_header(gc->pc, X_GLrop_CopyColorSubTable, cmdlen);
4738 (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
4739 (void) memcpy((void *)(gc->pc + 8), (void *)(&start), 4);
4740 (void) memcpy((void *)(gc->pc + 12), (void *)(&x), 4);
4741 (void) memcpy((void *)(gc->pc + 16), (void *)(&y), 4);
4742 (void) memcpy((void *)(gc->pc + 20), (void *)(&width), 4);
4743 gc->pc += cmdlen;
4744 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
4745 }
4746
4747 static void
4748 __glx_ConvolutionFilter_1D2D( unsigned opcode, unsigned dim, GLenum target, GLen um internalformat, GLsizei width, GLsizei height, GLenum format, GLenum type, co nst GLvoid * image )
4749 {
4750 struct glx_context * const gc = __glXGetCurrentContext();
4751 const GLuint compsize = (image != NULL) ? __glImageSize(width, height, 1, fo rmat, type, target) : 0;
4752 const GLuint cmdlen = 48 + __GLX_PAD(compsize);
4753 if (__builtin_expect(gc->currentDpy != NULL, 1)) {
4754 if (cmdlen <= gc->maxSmallRenderCommandSize) {
4755 if ( (gc->pc + cmdlen) > gc->bufEnd ) {
4756 (void) __glXFlushRenderBuffer(gc, gc->pc);
4757 }
4758 emit_header(gc->pc, opcode, cmdlen);
4759 (void) memcpy((void *)(gc->pc + 24), (void *)(&target), 4);
4760 (void) memcpy((void *)(gc->pc + 28), (void *)(&internalformat), 4);
4761 (void) memcpy((void *)(gc->pc + 32), (void *)(&width), 4);
4762 (void) memcpy((void *)(gc->pc + 36), (void *)(&height), 4);
4763 (void) memcpy((void *)(gc->pc + 40), (void *)(&format), 4);
4764 (void) memcpy((void *)(gc->pc + 44), (void *)(&type), 4);
4765 if (compsize > 0) {
4766 (*gc->fillImage)(gc, dim, width, height, 1, format, type, image, gc->pc + 48 , gc->pc + 4);
4767 } else {
4768 (void) memcpy( gc->pc + 4, default_pixel_store_2D, default_pixel_store_2D_si ze );
4769 }
4770 gc->pc += cmdlen;
4771 if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
4772 }
4773 else {
4774 const GLint op = opcode;
4775 const GLuint cmdlenLarge = cmdlen + 4;
4776 GLubyte * const pc = __glXFlushRenderBuffer(gc, gc->pc);
4777 (void) memcpy((void *)(pc + 0), (void *)(&cmdlenLarge), 4);
4778 (void) memcpy((void *)(pc + 4), (void *)(&op), 4);
4779 (void) memcpy((void *)(pc + 28), (void *)(&target), 4);
4780 (void) memcpy((void *)(pc + 32), (void *)(&internalformat), 4);
4781 (void) memcpy((void *)(pc + 36), (void *)(&width), 4);
4782 (void) memcpy((void *)(pc + 40), (void *)(&height), 4);
4783 (void) memcpy((void *)(pc + 44), (void *)(&format), 4);
4784 (void) memcpy((void *)(pc + 48), (void *)(&type), 4);
4785 __glXSendLargeImage(gc, compsize, dim, width, height, 1, format, type, image, pc + 52, pc + 8);
4786 }
4787 }
4788 }
4789
4790 #define X_GLrop_ConvolutionFilter1D 4101
4791 void __indirect_glConvolutionFilter1D(GLenum target, GLenum internalformat, GLsi zei width, GLenum format, GLenum type, const GLvoid * image)
4792 {
4793 __glx_ConvolutionFilter_1D2D(X_GLrop_ConvolutionFilter1D, 1, target, interna lformat, width, 1, format, type, image );
4794 }
4795
4796 #define X_GLrop_ConvolutionFilter2D 4102
4797 void __indirect_glConvolutionFilter2D(GLenum target, GLenum internalformat, GLsi zei width, GLsizei height, GLenum format, GLenum type, const GLvoid * image)
4798 {
4799 __glx_ConvolutionFilter_1D2D(X_GLrop_ConvolutionFilter2D, 2, target, interna lformat, width, height, format, type, image );
4800 }
4801
4802 #define X_GLrop_ConvolutionParameterf 4103
4803 void __indirect_glConvolutionParameterf(GLenum target, GLenum pname, GLfloat par ams)
4804 {
4805 struct glx_context * const gc = __glXGetCurrentContext();
4806 const GLuint cmdlen = 16;
4807 emit_header(gc->pc, X_GLrop_ConvolutionParameterf, cmdlen);
4808 (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
4809 (void) memcpy((void *)(gc->pc + 8), (void *)(&pname), 4);
4810 (void) memcpy((void *)(gc->pc + 12), (void *)(&params), 4);
4811 gc->pc += cmdlen;
4812 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
4813 }
4814
4815 #define X_GLrop_ConvolutionParameterfv 4104
4816 void __indirect_glConvolutionParameterfv(GLenum target, GLenum pname, const GLfl oat * params)
4817 {
4818 struct glx_context * const gc = __glXGetCurrentContext();
4819 const GLuint compsize = __glConvolutionParameterfv_size(pname);
4820 const GLuint cmdlen = 12 + __GLX_PAD((compsize * 4));
4821 emit_header(gc->pc, X_GLrop_ConvolutionParameterfv, cmdlen);
4822 (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
4823 (void) memcpy((void *)(gc->pc + 8), (void *)(&pname), 4);
4824 (void) memcpy((void *)(gc->pc + 12), (void *)(params), (compsize * 4));
4825 gc->pc += cmdlen;
4826 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
4827 }
4828
4829 #define X_GLrop_ConvolutionParameteri 4105
4830 void __indirect_glConvolutionParameteri(GLenum target, GLenum pname, GLint param s)
4831 {
4832 struct glx_context * const gc = __glXGetCurrentContext();
4833 const GLuint cmdlen = 16;
4834 emit_header(gc->pc, X_GLrop_ConvolutionParameteri, cmdlen);
4835 (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
4836 (void) memcpy((void *)(gc->pc + 8), (void *)(&pname), 4);
4837 (void) memcpy((void *)(gc->pc + 12), (void *)(&params), 4);
4838 gc->pc += cmdlen;
4839 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
4840 }
4841
4842 #define X_GLrop_ConvolutionParameteriv 4106
4843 void __indirect_glConvolutionParameteriv(GLenum target, GLenum pname, const GLin t * params)
4844 {
4845 struct glx_context * const gc = __glXGetCurrentContext();
4846 const GLuint compsize = __glConvolutionParameteriv_size(pname);
4847 const GLuint cmdlen = 12 + __GLX_PAD((compsize * 4));
4848 emit_header(gc->pc, X_GLrop_ConvolutionParameteriv, cmdlen);
4849 (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
4850 (void) memcpy((void *)(gc->pc + 8), (void *)(&pname), 4);
4851 (void) memcpy((void *)(gc->pc + 12), (void *)(params), (compsize * 4));
4852 gc->pc += cmdlen;
4853 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
4854 }
4855
4856 #define X_GLrop_CopyConvolutionFilter1D 4107
4857 void __indirect_glCopyConvolutionFilter1D(GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width)
4858 {
4859 struct glx_context * const gc = __glXGetCurrentContext();
4860 const GLuint cmdlen = 24;
4861 emit_header(gc->pc, X_GLrop_CopyConvolutionFilter1D, cmdlen);
4862 (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
4863 (void) memcpy((void *)(gc->pc + 8), (void *)(&internalformat), 4);
4864 (void) memcpy((void *)(gc->pc + 12), (void *)(&x), 4);
4865 (void) memcpy((void *)(gc->pc + 16), (void *)(&y), 4);
4866 (void) memcpy((void *)(gc->pc + 20), (void *)(&width), 4);
4867 gc->pc += cmdlen;
4868 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
4869 }
4870
4871 #define X_GLrop_CopyConvolutionFilter2D 4108
4872 void __indirect_glCopyConvolutionFilter2D(GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height)
4873 {
4874 struct glx_context * const gc = __glXGetCurrentContext();
4875 const GLuint cmdlen = 28;
4876 emit_header(gc->pc, X_GLrop_CopyConvolutionFilter2D, cmdlen);
4877 (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
4878 (void) memcpy((void *)(gc->pc + 8), (void *)(&internalformat), 4);
4879 (void) memcpy((void *)(gc->pc + 12), (void *)(&x), 4);
4880 (void) memcpy((void *)(gc->pc + 16), (void *)(&y), 4);
4881 (void) memcpy((void *)(gc->pc + 20), (void *)(&width), 4);
4882 (void) memcpy((void *)(gc->pc + 24), (void *)(&height), 4);
4883 gc->pc += cmdlen;
4884 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
4885 }
4886
4887 #define X_GLsop_GetConvolutionFilter 150
4888 void __indirect_glGetConvolutionFilter(GLenum target, GLenum format, GLenum type , GLvoid * image)
4889 {
4890 struct glx_context * const gc = __glXGetCurrentContext();
4891 const __GLXattribute * const state = gc->client_state_private;
4892 Display * const dpy = gc->currentDpy;
4893 #ifndef USE_XCB
4894 const GLuint cmdlen = 16;
4895 #endif
4896 if (__builtin_expect(dpy != NULL, 1)) {
4897 #ifdef USE_XCB
4898 xcb_connection_t *c = XGetXCBConnection(dpy);
4899 (void) __glXFlushRenderBuffer(gc, gc->pc);
4900 xcb_glx_get_convolution_filter_reply_t *reply = xcb_glx_get_convolution_ filter_reply(c, xcb_glx_get_convolution_filter(c, gc->currentContextTag, target, format, type, state->storePack.swapEndian), NULL);
4901 if (reply->height == 0) { reply->height = 1; }
4902 __glEmptyImage(gc, 3, reply->width, reply->height, 1, format, type, xcb_ glx_get_convolution_filter_data(reply), image);
4903 free(reply);
4904 #else
4905 GLubyte const * pc = __glXSetupSingleRequest(gc, X_GLsop_GetConvolutionF ilter, cmdlen);
4906 (void) memcpy((void *)(pc + 0), (void *)(&target), 4);
4907 (void) memcpy((void *)(pc + 4), (void *)(&format), 4);
4908 (void) memcpy((void *)(pc + 8), (void *)(&type), 4);
4909 *(int32_t *)(pc + 12) = 0;
4910 * (int8_t *)(pc + 12) = state->storePack.swapEndian;
4911 __glXReadPixelReply(dpy, gc, 2, 0, 0, 0, format, type, image, GL_TRUE);
4912 UnlockDisplay(dpy); SyncHandle();
4913 #endif /* USE_XCB */
4914 }
4915 return;
4916 }
4917
4918 #define X_GLvop_GetConvolutionFilterEXT 1
4919 void gl_dispatch_stub_356(GLenum target, GLenum format, GLenum type, GLvoid * im age)
4920 {
4921 struct glx_context * const gc = __glXGetCurrentContext();
4922
4923 #if defined(GLX_DIRECT_RENDERING) && !defined(GLX_USE_APPLEGL)
4924 if (gc->isDirect) {
4925 const _glapi_proc *const disp_table = GET_DISPATCH();
4926 PFNGLGETCONVOLUTIONFILTEREXTPROC p =
4927 (PFNGLGETCONVOLUTIONFILTEREXTPROC) disp_table[356];
4928 p(target, format, type, image);
4929 } else
4930 #endif
4931 {
4932 struct glx_context * const gc = __glXGetCurrentContext();
4933 const __GLXattribute * const state = gc->client_state_private;
4934 Display * const dpy = gc->currentDpy;
4935 const GLuint cmdlen = 16;
4936 if (__builtin_expect(dpy != NULL, 1)) {
4937 GLubyte const * pc = __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithR eply, X_GLvop_GetConvolutionFilterEXT, cmdlen);
4938 (void) memcpy((void *)(pc + 0), (void *)(&target), 4);
4939 (void) memcpy((void *)(pc + 4), (void *)(&format), 4);
4940 (void) memcpy((void *)(pc + 8), (void *)(&type), 4);
4941 *(int32_t *)(pc + 12) = 0;
4942 * (int8_t *)(pc + 12) = state->storePack.swapEndian;
4943 __glXReadPixelReply(dpy, gc, 2, 0, 0, 0, format, type, image, GL_TRUE);
4944 UnlockDisplay(dpy); SyncHandle();
4945 }
4946 return;
4947 }
4948 }
4949
4950 #define X_GLsop_GetConvolutionParameterfv 151
4951 void __indirect_glGetConvolutionParameterfv(GLenum target, GLenum pname, GLfloat * params)
4952 {
4953 struct glx_context * const gc = __glXGetCurrentContext();
4954 Display * const dpy = gc->currentDpy;
4955 #ifndef USE_XCB
4956 const GLuint cmdlen = 8;
4957 #endif
4958 if (__builtin_expect(dpy != NULL, 1)) {
4959 #ifdef USE_XCB
4960 xcb_connection_t *c = XGetXCBConnection(dpy);
4961 (void) __glXFlushRenderBuffer(gc, gc->pc);
4962 xcb_glx_get_convolution_parameterfv_reply_t *reply = xcb_glx_get_convolu tion_parameterfv_reply(c, xcb_glx_get_convolution_parameterfv(c, gc->currentCont extTag, target, pname), NULL);
4963 if (xcb_glx_get_convolution_parameterfv_data_length(reply) == 0)
4964 (void)memcpy(params, &reply->datum, sizeof(reply->datum));
4965 else
4966 (void)memcpy(params, xcb_glx_get_convolution_parameterfv_data(reply) , xcb_glx_get_convolution_parameterfv_data_length(reply) * sizeof(GLfloat));
4967 free(reply);
4968 #else
4969 GLubyte const * pc = __glXSetupSingleRequest(gc, X_GLsop_GetConvolutionP arameterfv, cmdlen);
4970 (void) memcpy((void *)(pc + 0), (void *)(&target), 4);
4971 (void) memcpy((void *)(pc + 4), (void *)(&pname), 4);
4972 (void) __glXReadReply(dpy, 4, params, GL_FALSE);
4973 UnlockDisplay(dpy); SyncHandle();
4974 #endif /* USE_XCB */
4975 }
4976 return;
4977 }
4978
4979 #define X_GLvop_GetConvolutionParameterfvEXT 2
4980 void gl_dispatch_stub_357(GLenum target, GLenum pname, GLfloat * params)
4981 {
4982 struct glx_context * const gc = __glXGetCurrentContext();
4983
4984 #if defined(GLX_DIRECT_RENDERING) && !defined(GLX_USE_APPLEGL)
4985 if (gc->isDirect) {
4986 const _glapi_proc *const disp_table = GET_DISPATCH();
4987 PFNGLGETCONVOLUTIONPARAMETERFVEXTPROC p =
4988 (PFNGLGETCONVOLUTIONPARAMETERFVEXTPROC) disp_table[357];
4989 p(target, pname, params);
4990 } else
4991 #endif
4992 {
4993 struct glx_context * const gc = __glXGetCurrentContext();
4994 Display * const dpy = gc->currentDpy;
4995 const GLuint cmdlen = 8;
4996 if (__builtin_expect(dpy != NULL, 1)) {
4997 GLubyte const * pc = __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithR eply, X_GLvop_GetConvolutionParameterfvEXT, cmdlen);
4998 (void) memcpy((void *)(pc + 0), (void *)(&target), 4);
4999 (void) memcpy((void *)(pc + 4), (void *)(&pname), 4);
5000 (void) __glXReadReply(dpy, 4, params, GL_FALSE);
5001 UnlockDisplay(dpy); SyncHandle();
5002 }
5003 return;
5004 }
5005 }
5006
5007 #define X_GLsop_GetConvolutionParameteriv 152
5008 void __indirect_glGetConvolutionParameteriv(GLenum target, GLenum pname, GLint * params)
5009 {
5010 struct glx_context * const gc = __glXGetCurrentContext();
5011 Display * const dpy = gc->currentDpy;
5012 #ifndef USE_XCB
5013 const GLuint cmdlen = 8;
5014 #endif
5015 if (__builtin_expect(dpy != NULL, 1)) {
5016 #ifdef USE_XCB
5017 xcb_connection_t *c = XGetXCBConnection(dpy);
5018 (void) __glXFlushRenderBuffer(gc, gc->pc);
5019 xcb_glx_get_convolution_parameteriv_reply_t *reply = xcb_glx_get_convolu tion_parameteriv_reply(c, xcb_glx_get_convolution_parameteriv(c, gc->currentCont extTag, target, pname), NULL);
5020 if (xcb_glx_get_convolution_parameteriv_data_length(reply) == 0)
5021 (void)memcpy(params, &reply->datum, sizeof(reply->datum));
5022 else
5023 (void)memcpy(params, xcb_glx_get_convolution_parameteriv_data(reply) , xcb_glx_get_convolution_parameteriv_data_length(reply) * sizeof(GLint));
5024 free(reply);
5025 #else
5026 GLubyte const * pc = __glXSetupSingleRequest(gc, X_GLsop_GetConvolutionP arameteriv, cmdlen);
5027 (void) memcpy((void *)(pc + 0), (void *)(&target), 4);
5028 (void) memcpy((void *)(pc + 4), (void *)(&pname), 4);
5029 (void) __glXReadReply(dpy, 4, params, GL_FALSE);
5030 UnlockDisplay(dpy); SyncHandle();
5031 #endif /* USE_XCB */
5032 }
5033 return;
5034 }
5035
5036 #define X_GLvop_GetConvolutionParameterivEXT 3
5037 void gl_dispatch_stub_358(GLenum target, GLenum pname, GLint * params)
5038 {
5039 struct glx_context * const gc = __glXGetCurrentContext();
5040
5041 #if defined(GLX_DIRECT_RENDERING) && !defined(GLX_USE_APPLEGL)
5042 if (gc->isDirect) {
5043 const _glapi_proc *const disp_table = GET_DISPATCH();
5044 PFNGLGETCONVOLUTIONPARAMETERIVEXTPROC p =
5045 (PFNGLGETCONVOLUTIONPARAMETERIVEXTPROC) disp_table[358];
5046 p(target, pname, params);
5047 } else
5048 #endif
5049 {
5050 struct glx_context * const gc = __glXGetCurrentContext();
5051 Display * const dpy = gc->currentDpy;
5052 const GLuint cmdlen = 8;
5053 if (__builtin_expect(dpy != NULL, 1)) {
5054 GLubyte const * pc = __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithR eply, X_GLvop_GetConvolutionParameterivEXT, cmdlen);
5055 (void) memcpy((void *)(pc + 0), (void *)(&target), 4);
5056 (void) memcpy((void *)(pc + 4), (void *)(&pname), 4);
5057 (void) __glXReadReply(dpy, 4, params, GL_FALSE);
5058 UnlockDisplay(dpy); SyncHandle();
5059 }
5060 return;
5061 }
5062 }
5063
5064 #define X_GLsop_GetHistogram 154
5065 void __indirect_glGetHistogram(GLenum target, GLboolean reset, GLenum format, GL enum type, GLvoid * values)
5066 {
5067 struct glx_context * const gc = __glXGetCurrentContext();
5068 const __GLXattribute * const state = gc->client_state_private;
5069 Display * const dpy = gc->currentDpy;
5070 #ifndef USE_XCB
5071 const GLuint cmdlen = 16;
5072 #endif
5073 if (__builtin_expect(dpy != NULL, 1)) {
5074 #ifdef USE_XCB
5075 xcb_connection_t *c = XGetXCBConnection(dpy);
5076 (void) __glXFlushRenderBuffer(gc, gc->pc);
5077 xcb_glx_get_histogram_reply_t *reply = xcb_glx_get_histogram_reply(c, xc b_glx_get_histogram(c, gc->currentContextTag, target, reset, format, type, state ->storePack.swapEndian), NULL);
5078 __glEmptyImage(gc, 3, reply->width, 1, 1, format, type, xcb_glx_get_hist ogram_data(reply), values);
5079 free(reply);
5080 #else
5081 GLubyte const * pc = __glXSetupSingleRequest(gc, X_GLsop_GetHistogram, c mdlen);
5082 (void) memcpy((void *)(pc + 0), (void *)(&target), 4);
5083 (void) memcpy((void *)(pc + 4), (void *)(&format), 4);
5084 (void) memcpy((void *)(pc + 8), (void *)(&type), 4);
5085 *(int32_t *)(pc + 12) = 0;
5086 * (int8_t *)(pc + 12) = state->storePack.swapEndian;
5087 * (int8_t *)(pc + 13) = reset;
5088 __glXReadPixelReply(dpy, gc, 1, 0, 0, 0, format, type, values, GL_TRUE);
5089 UnlockDisplay(dpy); SyncHandle();
5090 #endif /* USE_XCB */
5091 }
5092 return;
5093 }
5094
5095 #define X_GLvop_GetHistogramEXT 5
5096 void gl_dispatch_stub_361(GLenum target, GLboolean reset, GLenum format, GLenum type, GLvoid * values)
5097 {
5098 struct glx_context * const gc = __glXGetCurrentContext();
5099
5100 #if defined(GLX_DIRECT_RENDERING) && !defined(GLX_USE_APPLEGL)
5101 if (gc->isDirect) {
5102 const _glapi_proc *const disp_table = GET_DISPATCH();
5103 PFNGLGETHISTOGRAMEXTPROC p =
5104 (PFNGLGETHISTOGRAMEXTPROC) disp_table[361];
5105 p(target, reset, format, type, values);
5106 } else
5107 #endif
5108 {
5109 struct glx_context * const gc = __glXGetCurrentContext();
5110 const __GLXattribute * const state = gc->client_state_private;
5111 Display * const dpy = gc->currentDpy;
5112 const GLuint cmdlen = 16;
5113 if (__builtin_expect(dpy != NULL, 1)) {
5114 GLubyte const * pc = __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithR eply, X_GLvop_GetHistogramEXT, cmdlen);
5115 (void) memcpy((void *)(pc + 0), (void *)(&target), 4);
5116 (void) memcpy((void *)(pc + 4), (void *)(&format), 4);
5117 (void) memcpy((void *)(pc + 8), (void *)(&type), 4);
5118 *(int32_t *)(pc + 12) = 0;
5119 * (int8_t *)(pc + 12) = state->storePack.swapEndian;
5120 * (int8_t *)(pc + 13) = reset;
5121 __glXReadPixelReply(dpy, gc, 1, 0, 0, 0, format, type, values, GL_TRUE);
5122 UnlockDisplay(dpy); SyncHandle();
5123 }
5124 return;
5125 }
5126 }
5127
5128 #define X_GLsop_GetHistogramParameterfv 155
5129 void __indirect_glGetHistogramParameterfv(GLenum target, GLenum pname, GLfloat * params)
5130 {
5131 struct glx_context * const gc = __glXGetCurrentContext();
5132 Display * const dpy = gc->currentDpy;
5133 #ifndef USE_XCB
5134 const GLuint cmdlen = 8;
5135 #endif
5136 if (__builtin_expect(dpy != NULL, 1)) {
5137 #ifdef USE_XCB
5138 xcb_connection_t *c = XGetXCBConnection(dpy);
5139 (void) __glXFlushRenderBuffer(gc, gc->pc);
5140 xcb_glx_get_histogram_parameterfv_reply_t *reply = xcb_glx_get_histogram _parameterfv_reply(c, xcb_glx_get_histogram_parameterfv(c, gc->currentContextTag , target, pname), NULL);
5141 if (xcb_glx_get_histogram_parameterfv_data_length(reply) == 0)
5142 (void)memcpy(params, &reply->datum, sizeof(reply->datum));
5143 else
5144 (void)memcpy(params, xcb_glx_get_histogram_parameterfv_data(reply), xcb_glx_get_histogram_parameterfv_data_length(reply) * sizeof(GLfloat));
5145 free(reply);
5146 #else
5147 GLubyte const * pc = __glXSetupSingleRequest(gc, X_GLsop_GetHistogramPar ameterfv, cmdlen);
5148 (void) memcpy((void *)(pc + 0), (void *)(&target), 4);
5149 (void) memcpy((void *)(pc + 4), (void *)(&pname), 4);
5150 (void) __glXReadReply(dpy, 4, params, GL_FALSE);
5151 UnlockDisplay(dpy); SyncHandle();
5152 #endif /* USE_XCB */
5153 }
5154 return;
5155 }
5156
5157 #define X_GLvop_GetHistogramParameterfvEXT 6
5158 void gl_dispatch_stub_362(GLenum target, GLenum pname, GLfloat * params)
5159 {
5160 struct glx_context * const gc = __glXGetCurrentContext();
5161
5162 #if defined(GLX_DIRECT_RENDERING) && !defined(GLX_USE_APPLEGL)
5163 if (gc->isDirect) {
5164 const _glapi_proc *const disp_table = GET_DISPATCH();
5165 PFNGLGETHISTOGRAMPARAMETERFVEXTPROC p =
5166 (PFNGLGETHISTOGRAMPARAMETERFVEXTPROC) disp_table[362];
5167 p(target, pname, params);
5168 } else
5169 #endif
5170 {
5171 struct glx_context * const gc = __glXGetCurrentContext();
5172 Display * const dpy = gc->currentDpy;
5173 const GLuint cmdlen = 8;
5174 if (__builtin_expect(dpy != NULL, 1)) {
5175 GLubyte const * pc = __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithR eply, X_GLvop_GetHistogramParameterfvEXT, cmdlen);
5176 (void) memcpy((void *)(pc + 0), (void *)(&target), 4);
5177 (void) memcpy((void *)(pc + 4), (void *)(&pname), 4);
5178 (void) __glXReadReply(dpy, 4, params, GL_FALSE);
5179 UnlockDisplay(dpy); SyncHandle();
5180 }
5181 return;
5182 }
5183 }
5184
5185 #define X_GLsop_GetHistogramParameteriv 156
5186 void __indirect_glGetHistogramParameteriv(GLenum target, GLenum pname, GLint * p arams)
5187 {
5188 struct glx_context * const gc = __glXGetCurrentContext();
5189 Display * const dpy = gc->currentDpy;
5190 #ifndef USE_XCB
5191 const GLuint cmdlen = 8;
5192 #endif
5193 if (__builtin_expect(dpy != NULL, 1)) {
5194 #ifdef USE_XCB
5195 xcb_connection_t *c = XGetXCBConnection(dpy);
5196 (void) __glXFlushRenderBuffer(gc, gc->pc);
5197 xcb_glx_get_histogram_parameteriv_reply_t *reply = xcb_glx_get_histogram _parameteriv_reply(c, xcb_glx_get_histogram_parameteriv(c, gc->currentContextTag , target, pname), NULL);
5198 if (xcb_glx_get_histogram_parameteriv_data_length(reply) == 0)
5199 (void)memcpy(params, &reply->datum, sizeof(reply->datum));
5200 else
5201 (void)memcpy(params, xcb_glx_get_histogram_parameteriv_data(reply), xcb_glx_get_histogram_parameteriv_data_length(reply) * sizeof(GLint));
5202 free(reply);
5203 #else
5204 GLubyte const * pc = __glXSetupSingleRequest(gc, X_GLsop_GetHistogramPar ameteriv, cmdlen);
5205 (void) memcpy((void *)(pc + 0), (void *)(&target), 4);
5206 (void) memcpy((void *)(pc + 4), (void *)(&pname), 4);
5207 (void) __glXReadReply(dpy, 4, params, GL_FALSE);
5208 UnlockDisplay(dpy); SyncHandle();
5209 #endif /* USE_XCB */
5210 }
5211 return;
5212 }
5213
5214 #define X_GLvop_GetHistogramParameterivEXT 7
5215 void gl_dispatch_stub_363(GLenum target, GLenum pname, GLint * params)
5216 {
5217 struct glx_context * const gc = __glXGetCurrentContext();
5218
5219 #if defined(GLX_DIRECT_RENDERING) && !defined(GLX_USE_APPLEGL)
5220 if (gc->isDirect) {
5221 const _glapi_proc *const disp_table = GET_DISPATCH();
5222 PFNGLGETHISTOGRAMPARAMETERIVEXTPROC p =
5223 (PFNGLGETHISTOGRAMPARAMETERIVEXTPROC) disp_table[363];
5224 p(target, pname, params);
5225 } else
5226 #endif
5227 {
5228 struct glx_context * const gc = __glXGetCurrentContext();
5229 Display * const dpy = gc->currentDpy;
5230 const GLuint cmdlen = 8;
5231 if (__builtin_expect(dpy != NULL, 1)) {
5232 GLubyte const * pc = __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithR eply, X_GLvop_GetHistogramParameterivEXT, cmdlen);
5233 (void) memcpy((void *)(pc + 0), (void *)(&target), 4);
5234 (void) memcpy((void *)(pc + 4), (void *)(&pname), 4);
5235 (void) __glXReadReply(dpy, 4, params, GL_FALSE);
5236 UnlockDisplay(dpy); SyncHandle();
5237 }
5238 return;
5239 }
5240 }
5241
5242 #define X_GLsop_GetMinmax 157
5243 void __indirect_glGetMinmax(GLenum target, GLboolean reset, GLenum format, GLenu m type, GLvoid * values)
5244 {
5245 struct glx_context * const gc = __glXGetCurrentContext();
5246 const __GLXattribute * const state = gc->client_state_private;
5247 Display * const dpy = gc->currentDpy;
5248 #ifndef USE_XCB
5249 const GLuint cmdlen = 16;
5250 #endif
5251 if (__builtin_expect(dpy != NULL, 1)) {
5252 #ifdef USE_XCB
5253 xcb_connection_t *c = XGetXCBConnection(dpy);
5254 (void) __glXFlushRenderBuffer(gc, gc->pc);
5255 xcb_glx_get_minmax_reply_t *reply = xcb_glx_get_minmax_reply(c, xcb_glx_ get_minmax(c, gc->currentContextTag, target, reset, format, type, state->storePa ck.swapEndian), NULL);
5256 __glEmptyImage(gc, 3, 2, 1, 1, format, type, xcb_glx_get_minmax_data(rep ly), values);
5257 free(reply);
5258 #else
5259 GLubyte const * pc = __glXSetupSingleRequest(gc, X_GLsop_GetMinmax, cmdl en);
5260 (void) memcpy((void *)(pc + 0), (void *)(&target), 4);
5261 (void) memcpy((void *)(pc + 4), (void *)(&format), 4);
5262 (void) memcpy((void *)(pc + 8), (void *)(&type), 4);
5263 *(int32_t *)(pc + 12) = 0;
5264 * (int8_t *)(pc + 12) = state->storePack.swapEndian;
5265 * (int8_t *)(pc + 13) = reset;
5266 __glXReadPixelReply(dpy, gc, 1, 2, 1, 1, format, type, values, GL_FALSE) ;
5267 UnlockDisplay(dpy); SyncHandle();
5268 #endif /* USE_XCB */
5269 }
5270 return;
5271 }
5272
5273 #define X_GLvop_GetMinmaxEXT 8
5274 void gl_dispatch_stub_364(GLenum target, GLboolean reset, GLenum format, GLenum type, GLvoid * values)
5275 {
5276 struct glx_context * const gc = __glXGetCurrentContext();
5277
5278 #if defined(GLX_DIRECT_RENDERING) && !defined(GLX_USE_APPLEGL)
5279 if (gc->isDirect) {
5280 const _glapi_proc *const disp_table = GET_DISPATCH();
5281 PFNGLGETMINMAXEXTPROC p =
5282 (PFNGLGETMINMAXEXTPROC) disp_table[364];
5283 p(target, reset, format, type, values);
5284 } else
5285 #endif
5286 {
5287 struct glx_context * const gc = __glXGetCurrentContext();
5288 const __GLXattribute * const state = gc->client_state_private;
5289 Display * const dpy = gc->currentDpy;
5290 const GLuint cmdlen = 16;
5291 if (__builtin_expect(dpy != NULL, 1)) {
5292 GLubyte const * pc = __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithR eply, X_GLvop_GetMinmaxEXT, cmdlen);
5293 (void) memcpy((void *)(pc + 0), (void *)(&target), 4);
5294 (void) memcpy((void *)(pc + 4), (void *)(&format), 4);
5295 (void) memcpy((void *)(pc + 8), (void *)(&type), 4);
5296 *(int32_t *)(pc + 12) = 0;
5297 * (int8_t *)(pc + 12) = state->storePack.swapEndian;
5298 * (int8_t *)(pc + 13) = reset;
5299 __glXReadPixelReply(dpy, gc, 1, 2, 1, 1, format, type, values, GL_FALSE) ;
5300 UnlockDisplay(dpy); SyncHandle();
5301 }
5302 return;
5303 }
5304 }
5305
5306 #define X_GLsop_GetMinmaxParameterfv 158
5307 void __indirect_glGetMinmaxParameterfv(GLenum target, GLenum pname, GLfloat * pa rams)
5308 {
5309 struct glx_context * const gc = __glXGetCurrentContext();
5310 Display * const dpy = gc->currentDpy;
5311 #ifndef USE_XCB
5312 const GLuint cmdlen = 8;
5313 #endif
5314 if (__builtin_expect(dpy != NULL, 1)) {
5315 #ifdef USE_XCB
5316 xcb_connection_t *c = XGetXCBConnection(dpy);
5317 (void) __glXFlushRenderBuffer(gc, gc->pc);
5318 xcb_glx_get_minmax_parameterfv_reply_t *reply = xcb_glx_get_minmax_param eterfv_reply(c, xcb_glx_get_minmax_parameterfv(c, gc->currentContextTag, target, pname), NULL);
5319 if (xcb_glx_get_minmax_parameterfv_data_length(reply) == 0)
5320 (void)memcpy(params, &reply->datum, sizeof(reply->datum));
5321 else
5322 (void)memcpy(params, xcb_glx_get_minmax_parameterfv_data(reply), xcb _glx_get_minmax_parameterfv_data_length(reply) * sizeof(GLfloat));
5323 free(reply);
5324 #else
5325 GLubyte const * pc = __glXSetupSingleRequest(gc, X_GLsop_GetMinmaxParame terfv, cmdlen);
5326 (void) memcpy((void *)(pc + 0), (void *)(&target), 4);
5327 (void) memcpy((void *)(pc + 4), (void *)(&pname), 4);
5328 (void) __glXReadReply(dpy, 4, params, GL_FALSE);
5329 UnlockDisplay(dpy); SyncHandle();
5330 #endif /* USE_XCB */
5331 }
5332 return;
5333 }
5334
5335 #define X_GLvop_GetMinmaxParameterfvEXT 9
5336 void gl_dispatch_stub_365(GLenum target, GLenum pname, GLfloat * params)
5337 {
5338 struct glx_context * const gc = __glXGetCurrentContext();
5339
5340 #if defined(GLX_DIRECT_RENDERING) && !defined(GLX_USE_APPLEGL)
5341 if (gc->isDirect) {
5342 const _glapi_proc *const disp_table = GET_DISPATCH();
5343 PFNGLGETMINMAXPARAMETERFVEXTPROC p =
5344 (PFNGLGETMINMAXPARAMETERFVEXTPROC) disp_table[365];
5345 p(target, pname, params);
5346 } else
5347 #endif
5348 {
5349 struct glx_context * const gc = __glXGetCurrentContext();
5350 Display * const dpy = gc->currentDpy;
5351 const GLuint cmdlen = 8;
5352 if (__builtin_expect(dpy != NULL, 1)) {
5353 GLubyte const * pc = __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithR eply, X_GLvop_GetMinmaxParameterfvEXT, cmdlen);
5354 (void) memcpy((void *)(pc + 0), (void *)(&target), 4);
5355 (void) memcpy((void *)(pc + 4), (void *)(&pname), 4);
5356 (void) __glXReadReply(dpy, 4, params, GL_FALSE);
5357 UnlockDisplay(dpy); SyncHandle();
5358 }
5359 return;
5360 }
5361 }
5362
5363 #define X_GLsop_GetMinmaxParameteriv 159
5364 void __indirect_glGetMinmaxParameteriv(GLenum target, GLenum pname, GLint * para ms)
5365 {
5366 struct glx_context * const gc = __glXGetCurrentContext();
5367 Display * const dpy = gc->currentDpy;
5368 #ifndef USE_XCB
5369 const GLuint cmdlen = 8;
5370 #endif
5371 if (__builtin_expect(dpy != NULL, 1)) {
5372 #ifdef USE_XCB
5373 xcb_connection_t *c = XGetXCBConnection(dpy);
5374 (void) __glXFlushRenderBuffer(gc, gc->pc);
5375 xcb_glx_get_minmax_parameteriv_reply_t *reply = xcb_glx_get_minmax_param eteriv_reply(c, xcb_glx_get_minmax_parameteriv(c, gc->currentContextTag, target, pname), NULL);
5376 if (xcb_glx_get_minmax_parameteriv_data_length(reply) == 0)
5377 (void)memcpy(params, &reply->datum, sizeof(reply->datum));
5378 else
5379 (void)memcpy(params, xcb_glx_get_minmax_parameteriv_data(reply), xcb _glx_get_minmax_parameteriv_data_length(reply) * sizeof(GLint));
5380 free(reply);
5381 #else
5382 GLubyte const * pc = __glXSetupSingleRequest(gc, X_GLsop_GetMinmaxParame teriv, cmdlen);
5383 (void) memcpy((void *)(pc + 0), (void *)(&target), 4);
5384 (void) memcpy((void *)(pc + 4), (void *)(&pname), 4);
5385 (void) __glXReadReply(dpy, 4, params, GL_FALSE);
5386 UnlockDisplay(dpy); SyncHandle();
5387 #endif /* USE_XCB */
5388 }
5389 return;
5390 }
5391
5392 #define X_GLvop_GetMinmaxParameterivEXT 10
5393 void gl_dispatch_stub_366(GLenum target, GLenum pname, GLint * params)
5394 {
5395 struct glx_context * const gc = __glXGetCurrentContext();
5396
5397 #if defined(GLX_DIRECT_RENDERING) && !defined(GLX_USE_APPLEGL)
5398 if (gc->isDirect) {
5399 const _glapi_proc *const disp_table = GET_DISPATCH();
5400 PFNGLGETMINMAXPARAMETERIVEXTPROC p =
5401 (PFNGLGETMINMAXPARAMETERIVEXTPROC) disp_table[366];
5402 p(target, pname, params);
5403 } else
5404 #endif
5405 {
5406 struct glx_context * const gc = __glXGetCurrentContext();
5407 Display * const dpy = gc->currentDpy;
5408 const GLuint cmdlen = 8;
5409 if (__builtin_expect(dpy != NULL, 1)) {
5410 GLubyte const * pc = __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithR eply, X_GLvop_GetMinmaxParameterivEXT, cmdlen);
5411 (void) memcpy((void *)(pc + 0), (void *)(&target), 4);
5412 (void) memcpy((void *)(pc + 4), (void *)(&pname), 4);
5413 (void) __glXReadReply(dpy, 4, params, GL_FALSE);
5414 UnlockDisplay(dpy); SyncHandle();
5415 }
5416 return;
5417 }
5418 }
5419
5420 #define X_GLrop_Histogram 4110
5421 void __indirect_glHistogram(GLenum target, GLsizei width, GLenum internalformat, GLboolean sink)
5422 {
5423 struct glx_context * const gc = __glXGetCurrentContext();
5424 const GLuint cmdlen = 20;
5425 emit_header(gc->pc, X_GLrop_Histogram, cmdlen);
5426 (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
5427 (void) memcpy((void *)(gc->pc + 8), (void *)(&width), 4);
5428 (void) memcpy((void *)(gc->pc + 12), (void *)(&internalformat), 4);
5429 (void) memcpy((void *)(gc->pc + 16), (void *)(&sink), 1);
5430 gc->pc += cmdlen;
5431 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
5432 }
5433
5434 #define X_GLrop_Minmax 4111
5435 void __indirect_glMinmax(GLenum target, GLenum internalformat, GLboolean sink)
5436 {
5437 struct glx_context * const gc = __glXGetCurrentContext();
5438 const GLuint cmdlen = 16;
5439 emit_header(gc->pc, X_GLrop_Minmax, cmdlen);
5440 (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
5441 (void) memcpy((void *)(gc->pc + 8), (void *)(&internalformat), 4);
5442 (void) memcpy((void *)(gc->pc + 12), (void *)(&sink), 1);
5443 gc->pc += cmdlen;
5444 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
5445 }
5446
5447 #define X_GLrop_ResetHistogram 4112
5448 void __indirect_glResetHistogram(GLenum target)
5449 {
5450 struct glx_context * const gc = __glXGetCurrentContext();
5451 const GLuint cmdlen = 8;
5452 emit_header(gc->pc, X_GLrop_ResetHistogram, cmdlen);
5453 (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
5454 gc->pc += cmdlen;
5455 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
5456 }
5457
5458 #define X_GLrop_ResetMinmax 4113
5459 void __indirect_glResetMinmax(GLenum target)
5460 {
5461 struct glx_context * const gc = __glXGetCurrentContext();
5462 const GLuint cmdlen = 8;
5463 emit_header(gc->pc, X_GLrop_ResetMinmax, cmdlen);
5464 (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
5465 gc->pc += cmdlen;
5466 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
5467 }
5468
5469 static void
5470 __glx_TexImage_3D4D( unsigned opcode, unsigned dim, GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLsizei depth, GLsizei exte nt, GLint border, GLenum format, GLenum type, const GLvoid * pixels )
5471 {
5472 struct glx_context * const gc = __glXGetCurrentContext();
5473 const GLuint compsize = (pixels != NULL) ? __glImageSize(width, height, dept h, format, type, target) : 0;
5474 const GLuint cmdlen = 84 + __GLX_PAD(compsize);
5475 if (__builtin_expect(gc->currentDpy != NULL, 1)) {
5476 if (cmdlen <= gc->maxSmallRenderCommandSize) {
5477 if ( (gc->pc + cmdlen) > gc->bufEnd ) {
5478 (void) __glXFlushRenderBuffer(gc, gc->pc);
5479 }
5480 emit_header(gc->pc, opcode, cmdlen);
5481 (void) memcpy((void *)(gc->pc + 40), (void *)(&target), 4);
5482 (void) memcpy((void *)(gc->pc + 44), (void *)(&level), 4);
5483 (void) memcpy((void *)(gc->pc + 48), (void *)(&internalformat), 4);
5484 (void) memcpy((void *)(gc->pc + 52), (void *)(&width), 4);
5485 (void) memcpy((void *)(gc->pc + 56), (void *)(&height), 4);
5486 (void) memcpy((void *)(gc->pc + 60), (void *)(&depth), 4);
5487 (void) memcpy((void *)(gc->pc + 64), (void *)(&extent), 4);
5488 (void) memcpy((void *)(gc->pc + 68), (void *)(&border), 4);
5489 (void) memcpy((void *)(gc->pc + 72), (void *)(&format), 4);
5490 (void) memcpy((void *)(gc->pc + 76), (void *)(&type), 4);
5491 (void) memcpy((void *)(gc->pc + 80), (void *)((pixels == NULL) ? one : zero), 4) ;
5492 if (compsize > 0) {
5493 (*gc->fillImage)(gc, dim, width, height, depth, format, type, pixels, gc->pc + 84, gc->pc + 4);
5494 } else {
5495 (void) memcpy( gc->pc + 4, default_pixel_store_4D, default_pixel_store_4D_si ze );
5496 }
5497 gc->pc += cmdlen;
5498 if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
5499 }
5500 else {
5501 const GLint op = opcode;
5502 const GLuint cmdlenLarge = cmdlen + 4;
5503 GLubyte * const pc = __glXFlushRenderBuffer(gc, gc->pc);
5504 (void) memcpy((void *)(pc + 0), (void *)(&cmdlenLarge), 4);
5505 (void) memcpy((void *)(pc + 4), (void *)(&op), 4);
5506 (void) memcpy((void *)(pc + 44), (void *)(&target), 4);
5507 (void) memcpy((void *)(pc + 48), (void *)(&level), 4);
5508 (void) memcpy((void *)(pc + 52), (void *)(&internalformat), 4);
5509 (void) memcpy((void *)(pc + 56), (void *)(&width), 4);
5510 (void) memcpy((void *)(pc + 60), (void *)(&height), 4);
5511 (void) memcpy((void *)(pc + 64), (void *)(&depth), 4);
5512 (void) memcpy((void *)(pc + 68), (void *)(&extent), 4);
5513 (void) memcpy((void *)(pc + 72), (void *)(&border), 4);
5514 (void) memcpy((void *)(pc + 76), (void *)(&format), 4);
5515 (void) memcpy((void *)(pc + 80), (void *)(&type), 4);
5516 (void) memcpy((void *)(pc + 84), zero, 4);
5517 __glXSendLargeImage(gc, compsize, dim, width, height, depth, format, type, pixel s, pc + 88, pc + 8);
5518 }
5519 }
5520 }
5521
5522 #define X_GLrop_TexImage3D 4114
5523 void __indirect_glTexImage3D(GLenum target, GLint level, GLint internalformat, G Lsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const GLvoid * pixels)
5524 {
5525 __glx_TexImage_3D4D(X_GLrop_TexImage3D, 3, target, level, internalformat, wi dth, height, depth, 1, border, format, type, pixels );
5526 }
5527
5528 static void
5529 __glx_TexSubImage_3D4D( unsigned opcode, unsigned dim, GLenum target, GLint leve l, GLint xoffset, GLint yoffset, GLint zoffset, GLint woffset, GLsizei width, GL sizei height, GLsizei depth, GLsizei extent, GLenum format, GLenum type, const G Lvoid * pixels )
5530 {
5531 struct glx_context * const gc = __glXGetCurrentContext();
5532 const GLuint compsize = (pixels != NULL) ? __glImageSize(width, height, dept h, format, type, target) : 0;
5533 const GLuint cmdlen = 92 + __GLX_PAD(compsize);
5534 if (__builtin_expect(gc->currentDpy != NULL, 1)) {
5535 if (cmdlen <= gc->maxSmallRenderCommandSize) {
5536 if ( (gc->pc + cmdlen) > gc->bufEnd ) {
5537 (void) __glXFlushRenderBuffer(gc, gc->pc);
5538 }
5539 emit_header(gc->pc, opcode, cmdlen);
5540 (void) memcpy((void *)(gc->pc + 40), (void *)(&target), 4);
5541 (void) memcpy((void *)(gc->pc + 44), (void *)(&level), 4);
5542 (void) memcpy((void *)(gc->pc + 48), (void *)(&xoffset), 4);
5543 (void) memcpy((void *)(gc->pc + 52), (void *)(&yoffset), 4);
5544 (void) memcpy((void *)(gc->pc + 56), (void *)(&zoffset), 4);
5545 (void) memcpy((void *)(gc->pc + 60), (void *)(&woffset), 4);
5546 (void) memcpy((void *)(gc->pc + 64), (void *)(&width), 4);
5547 (void) memcpy((void *)(gc->pc + 68), (void *)(&height), 4);
5548 (void) memcpy((void *)(gc->pc + 72), (void *)(&depth), 4);
5549 (void) memcpy((void *)(gc->pc + 76), (void *)(&extent), 4);
5550 (void) memcpy((void *)(gc->pc + 80), (void *)(&format), 4);
5551 (void) memcpy((void *)(gc->pc + 84), (void *)(&type), 4);
5552 (void) memset((void *)(gc->pc + 88), 0, 4);
5553 if (compsize > 0) {
5554 (*gc->fillImage)(gc, dim, width, height, depth, format, type, pixels, gc->pc + 92, gc->pc + 4);
5555 } else {
5556 (void) memcpy( gc->pc + 4, default_pixel_store_4D, default_pixel_store_4D_si ze );
5557 }
5558 gc->pc += cmdlen;
5559 if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
5560 }
5561 else {
5562 const GLint op = opcode;
5563 const GLuint cmdlenLarge = cmdlen + 4;
5564 GLubyte * const pc = __glXFlushRenderBuffer(gc, gc->pc);
5565 (void) memcpy((void *)(pc + 0), (void *)(&cmdlenLarge), 4);
5566 (void) memcpy((void *)(pc + 4), (void *)(&op), 4);
5567 (void) memcpy((void *)(pc + 44), (void *)(&target), 4);
5568 (void) memcpy((void *)(pc + 48), (void *)(&level), 4);
5569 (void) memcpy((void *)(pc + 52), (void *)(&xoffset), 4);
5570 (void) memcpy((void *)(pc + 56), (void *)(&yoffset), 4);
5571 (void) memcpy((void *)(pc + 60), (void *)(&zoffset), 4);
5572 (void) memcpy((void *)(pc + 64), (void *)(&woffset), 4);
5573 (void) memcpy((void *)(pc + 68), (void *)(&width), 4);
5574 (void) memcpy((void *)(pc + 72), (void *)(&height), 4);
5575 (void) memcpy((void *)(pc + 76), (void *)(&depth), 4);
5576 (void) memcpy((void *)(pc + 80), (void *)(&extent), 4);
5577 (void) memcpy((void *)(pc + 84), (void *)(&format), 4);
5578 (void) memcpy((void *)(pc + 88), (void *)(&type), 4);
5579 (void) memset((void *)(pc + 92), 0, 4);
5580 __glXSendLargeImage(gc, compsize, dim, width, height, depth, format, type, pixel s, pc + 96, pc + 8);
5581 }
5582 }
5583 }
5584
5585 #define X_GLrop_TexSubImage3D 4115
5586 void __indirect_glTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum fo rmat, GLenum type, const GLvoid * pixels)
5587 {
5588 __glx_TexSubImage_3D4D(X_GLrop_TexSubImage3D, 3, target, level, xoffset, yof fset, zoffset, 1, width, height, depth, 1, format, type, pixels );
5589 }
5590
5591 #define X_GLrop_CopyTexSubImage3D 4123
5592 void __indirect_glCopyTexSubImage3D(GLenum target, GLint level, GLint xoffset, G Lint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height)
5593 {
5594 struct glx_context * const gc = __glXGetCurrentContext();
5595 const GLuint cmdlen = 40;
5596 emit_header(gc->pc, X_GLrop_CopyTexSubImage3D, cmdlen);
5597 (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
5598 (void) memcpy((void *)(gc->pc + 8), (void *)(&level), 4);
5599 (void) memcpy((void *)(gc->pc + 12), (void *)(&xoffset), 4);
5600 (void) memcpy((void *)(gc->pc + 16), (void *)(&yoffset), 4);
5601 (void) memcpy((void *)(gc->pc + 20), (void *)(&zoffset), 4);
5602 (void) memcpy((void *)(gc->pc + 24), (void *)(&x), 4);
5603 (void) memcpy((void *)(gc->pc + 28), (void *)(&y), 4);
5604 (void) memcpy((void *)(gc->pc + 32), (void *)(&width), 4);
5605 (void) memcpy((void *)(gc->pc + 36), (void *)(&height), 4);
5606 gc->pc += cmdlen;
5607 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
5608 }
5609
5610 #define X_GLrop_ActiveTextureARB 197
5611 void __indirect_glActiveTextureARB(GLenum texture)
5612 {
5613 struct glx_context * const gc = __glXGetCurrentContext();
5614 const GLuint cmdlen = 8;
5615 emit_header(gc->pc, X_GLrop_ActiveTextureARB, cmdlen);
5616 (void) memcpy((void *)(gc->pc + 4), (void *)(&texture), 4);
5617 gc->pc += cmdlen;
5618 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
5619 }
5620
5621 #define X_GLrop_MultiTexCoord1dvARB 198
5622 void __indirect_glMultiTexCoord1dARB(GLenum target, GLdouble s)
5623 {
5624 struct glx_context * const gc = __glXGetCurrentContext();
5625 const GLuint cmdlen = 16;
5626 emit_header(gc->pc, X_GLrop_MultiTexCoord1dvARB, cmdlen);
5627 (void) memcpy((void *)(gc->pc + 4), (void *)(&s), 8);
5628 (void) memcpy((void *)(gc->pc + 12), (void *)(&target), 4);
5629 gc->pc += cmdlen;
5630 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
5631 }
5632
5633 #define X_GLrop_MultiTexCoord1dvARB 198
5634 void __indirect_glMultiTexCoord1dvARB(GLenum target, const GLdouble * v)
5635 {
5636 struct glx_context * const gc = __glXGetCurrentContext();
5637 const GLuint cmdlen = 16;
5638 emit_header(gc->pc, X_GLrop_MultiTexCoord1dvARB, cmdlen);
5639 (void) memcpy((void *)(gc->pc + 4), (void *)(v), 8);
5640 (void) memcpy((void *)(gc->pc + 12), (void *)(&target), 4);
5641 gc->pc += cmdlen;
5642 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
5643 }
5644
5645 #define X_GLrop_MultiTexCoord1fvARB 199
5646 void __indirect_glMultiTexCoord1fARB(GLenum target, GLfloat s)
5647 {
5648 struct glx_context * const gc = __glXGetCurrentContext();
5649 const GLuint cmdlen = 12;
5650 emit_header(gc->pc, X_GLrop_MultiTexCoord1fvARB, cmdlen);
5651 (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
5652 (void) memcpy((void *)(gc->pc + 8), (void *)(&s), 4);
5653 gc->pc += cmdlen;
5654 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
5655 }
5656
5657 #define X_GLrop_MultiTexCoord1fvARB 199
5658 void __indirect_glMultiTexCoord1fvARB(GLenum target, const GLfloat * v)
5659 {
5660 struct glx_context * const gc = __glXGetCurrentContext();
5661 const GLuint cmdlen = 12;
5662 emit_header(gc->pc, X_GLrop_MultiTexCoord1fvARB, cmdlen);
5663 (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
5664 (void) memcpy((void *)(gc->pc + 8), (void *)(v), 4);
5665 gc->pc += cmdlen;
5666 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
5667 }
5668
5669 #define X_GLrop_MultiTexCoord1ivARB 200
5670 void __indirect_glMultiTexCoord1iARB(GLenum target, GLint s)
5671 {
5672 struct glx_context * const gc = __glXGetCurrentContext();
5673 const GLuint cmdlen = 12;
5674 emit_header(gc->pc, X_GLrop_MultiTexCoord1ivARB, cmdlen);
5675 (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
5676 (void) memcpy((void *)(gc->pc + 8), (void *)(&s), 4);
5677 gc->pc += cmdlen;
5678 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
5679 }
5680
5681 #define X_GLrop_MultiTexCoord1ivARB 200
5682 void __indirect_glMultiTexCoord1ivARB(GLenum target, const GLint * v)
5683 {
5684 struct glx_context * const gc = __glXGetCurrentContext();
5685 const GLuint cmdlen = 12;
5686 emit_header(gc->pc, X_GLrop_MultiTexCoord1ivARB, cmdlen);
5687 (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
5688 (void) memcpy((void *)(gc->pc + 8), (void *)(v), 4);
5689 gc->pc += cmdlen;
5690 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
5691 }
5692
5693 #define X_GLrop_MultiTexCoord1svARB 201
5694 void __indirect_glMultiTexCoord1sARB(GLenum target, GLshort s)
5695 {
5696 struct glx_context * const gc = __glXGetCurrentContext();
5697 const GLuint cmdlen = 12;
5698 emit_header(gc->pc, X_GLrop_MultiTexCoord1svARB, cmdlen);
5699 (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
5700 (void) memcpy((void *)(gc->pc + 8), (void *)(&s), 2);
5701 gc->pc += cmdlen;
5702 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
5703 }
5704
5705 #define X_GLrop_MultiTexCoord1svARB 201
5706 void __indirect_glMultiTexCoord1svARB(GLenum target, const GLshort * v)
5707 {
5708 struct glx_context * const gc = __glXGetCurrentContext();
5709 const GLuint cmdlen = 12;
5710 emit_header(gc->pc, X_GLrop_MultiTexCoord1svARB, cmdlen);
5711 (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
5712 (void) memcpy((void *)(gc->pc + 8), (void *)(v), 2);
5713 gc->pc += cmdlen;
5714 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
5715 }
5716
5717 #define X_GLrop_MultiTexCoord2dvARB 202
5718 void __indirect_glMultiTexCoord2dARB(GLenum target, GLdouble s, GLdouble t)
5719 {
5720 struct glx_context * const gc = __glXGetCurrentContext();
5721 const GLuint cmdlen = 24;
5722 emit_header(gc->pc, X_GLrop_MultiTexCoord2dvARB, cmdlen);
5723 (void) memcpy((void *)(gc->pc + 4), (void *)(&s), 8);
5724 (void) memcpy((void *)(gc->pc + 12), (void *)(&t), 8);
5725 (void) memcpy((void *)(gc->pc + 20), (void *)(&target), 4);
5726 gc->pc += cmdlen;
5727 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
5728 }
5729
5730 #define X_GLrop_MultiTexCoord2dvARB 202
5731 void __indirect_glMultiTexCoord2dvARB(GLenum target, const GLdouble * v)
5732 {
5733 struct glx_context * const gc = __glXGetCurrentContext();
5734 const GLuint cmdlen = 24;
5735 emit_header(gc->pc, X_GLrop_MultiTexCoord2dvARB, cmdlen);
5736 (void) memcpy((void *)(gc->pc + 4), (void *)(v), 16);
5737 (void) memcpy((void *)(gc->pc + 20), (void *)(&target), 4);
5738 gc->pc += cmdlen;
5739 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
5740 }
5741
5742 #define X_GLrop_MultiTexCoord2fvARB 203
5743 void __indirect_glMultiTexCoord2fARB(GLenum target, GLfloat s, GLfloat t)
5744 {
5745 struct glx_context * const gc = __glXGetCurrentContext();
5746 const GLuint cmdlen = 16;
5747 emit_header(gc->pc, X_GLrop_MultiTexCoord2fvARB, cmdlen);
5748 (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
5749 (void) memcpy((void *)(gc->pc + 8), (void *)(&s), 4);
5750 (void) memcpy((void *)(gc->pc + 12), (void *)(&t), 4);
5751 gc->pc += cmdlen;
5752 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
5753 }
5754
5755 #define X_GLrop_MultiTexCoord2fvARB 203
5756 void __indirect_glMultiTexCoord2fvARB(GLenum target, const GLfloat * v)
5757 {
5758 struct glx_context * const gc = __glXGetCurrentContext();
5759 const GLuint cmdlen = 16;
5760 emit_header(gc->pc, X_GLrop_MultiTexCoord2fvARB, cmdlen);
5761 (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
5762 (void) memcpy((void *)(gc->pc + 8), (void *)(v), 8);
5763 gc->pc += cmdlen;
5764 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
5765 }
5766
5767 #define X_GLrop_MultiTexCoord2ivARB 204
5768 void __indirect_glMultiTexCoord2iARB(GLenum target, GLint s, GLint t)
5769 {
5770 struct glx_context * const gc = __glXGetCurrentContext();
5771 const GLuint cmdlen = 16;
5772 emit_header(gc->pc, X_GLrop_MultiTexCoord2ivARB, cmdlen);
5773 (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
5774 (void) memcpy((void *)(gc->pc + 8), (void *)(&s), 4);
5775 (void) memcpy((void *)(gc->pc + 12), (void *)(&t), 4);
5776 gc->pc += cmdlen;
5777 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
5778 }
5779
5780 #define X_GLrop_MultiTexCoord2ivARB 204
5781 void __indirect_glMultiTexCoord2ivARB(GLenum target, const GLint * v)
5782 {
5783 struct glx_context * const gc = __glXGetCurrentContext();
5784 const GLuint cmdlen = 16;
5785 emit_header(gc->pc, X_GLrop_MultiTexCoord2ivARB, cmdlen);
5786 (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
5787 (void) memcpy((void *)(gc->pc + 8), (void *)(v), 8);
5788 gc->pc += cmdlen;
5789 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
5790 }
5791
5792 #define X_GLrop_MultiTexCoord2svARB 205
5793 void __indirect_glMultiTexCoord2sARB(GLenum target, GLshort s, GLshort t)
5794 {
5795 struct glx_context * const gc = __glXGetCurrentContext();
5796 const GLuint cmdlen = 12;
5797 emit_header(gc->pc, X_GLrop_MultiTexCoord2svARB, cmdlen);
5798 (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
5799 (void) memcpy((void *)(gc->pc + 8), (void *)(&s), 2);
5800 (void) memcpy((void *)(gc->pc + 10), (void *)(&t), 2);
5801 gc->pc += cmdlen;
5802 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
5803 }
5804
5805 #define X_GLrop_MultiTexCoord2svARB 205
5806 void __indirect_glMultiTexCoord2svARB(GLenum target, const GLshort * v)
5807 {
5808 struct glx_context * const gc = __glXGetCurrentContext();
5809 const GLuint cmdlen = 12;
5810 emit_header(gc->pc, X_GLrop_MultiTexCoord2svARB, cmdlen);
5811 (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
5812 (void) memcpy((void *)(gc->pc + 8), (void *)(v), 4);
5813 gc->pc += cmdlen;
5814 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
5815 }
5816
5817 #define X_GLrop_MultiTexCoord3dvARB 206
5818 void __indirect_glMultiTexCoord3dARB(GLenum target, GLdouble s, GLdouble t, GLdo uble r)
5819 {
5820 struct glx_context * const gc = __glXGetCurrentContext();
5821 const GLuint cmdlen = 32;
5822 emit_header(gc->pc, X_GLrop_MultiTexCoord3dvARB, cmdlen);
5823 (void) memcpy((void *)(gc->pc + 4), (void *)(&s), 8);
5824 (void) memcpy((void *)(gc->pc + 12), (void *)(&t), 8);
5825 (void) memcpy((void *)(gc->pc + 20), (void *)(&r), 8);
5826 (void) memcpy((void *)(gc->pc + 28), (void *)(&target), 4);
5827 gc->pc += cmdlen;
5828 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
5829 }
5830
5831 #define X_GLrop_MultiTexCoord3dvARB 206
5832 void __indirect_glMultiTexCoord3dvARB(GLenum target, const GLdouble * v)
5833 {
5834 struct glx_context * const gc = __glXGetCurrentContext();
5835 const GLuint cmdlen = 32;
5836 emit_header(gc->pc, X_GLrop_MultiTexCoord3dvARB, cmdlen);
5837 (void) memcpy((void *)(gc->pc + 4), (void *)(v), 24);
5838 (void) memcpy((void *)(gc->pc + 28), (void *)(&target), 4);
5839 gc->pc += cmdlen;
5840 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
5841 }
5842
5843 #define X_GLrop_MultiTexCoord3fvARB 207
5844 void __indirect_glMultiTexCoord3fARB(GLenum target, GLfloat s, GLfloat t, GLfloa t r)
5845 {
5846 struct glx_context * const gc = __glXGetCurrentContext();
5847 const GLuint cmdlen = 20;
5848 emit_header(gc->pc, X_GLrop_MultiTexCoord3fvARB, cmdlen);
5849 (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
5850 (void) memcpy((void *)(gc->pc + 8), (void *)(&s), 4);
5851 (void) memcpy((void *)(gc->pc + 12), (void *)(&t), 4);
5852 (void) memcpy((void *)(gc->pc + 16), (void *)(&r), 4);
5853 gc->pc += cmdlen;
5854 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
5855 }
5856
5857 #define X_GLrop_MultiTexCoord3fvARB 207
5858 void __indirect_glMultiTexCoord3fvARB(GLenum target, const GLfloat * v)
5859 {
5860 struct glx_context * const gc = __glXGetCurrentContext();
5861 const GLuint cmdlen = 20;
5862 emit_header(gc->pc, X_GLrop_MultiTexCoord3fvARB, cmdlen);
5863 (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
5864 (void) memcpy((void *)(gc->pc + 8), (void *)(v), 12);
5865 gc->pc += cmdlen;
5866 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
5867 }
5868
5869 #define X_GLrop_MultiTexCoord3ivARB 208
5870 void __indirect_glMultiTexCoord3iARB(GLenum target, GLint s, GLint t, GLint r)
5871 {
5872 struct glx_context * const gc = __glXGetCurrentContext();
5873 const GLuint cmdlen = 20;
5874 emit_header(gc->pc, X_GLrop_MultiTexCoord3ivARB, cmdlen);
5875 (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
5876 (void) memcpy((void *)(gc->pc + 8), (void *)(&s), 4);
5877 (void) memcpy((void *)(gc->pc + 12), (void *)(&t), 4);
5878 (void) memcpy((void *)(gc->pc + 16), (void *)(&r), 4);
5879 gc->pc += cmdlen;
5880 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
5881 }
5882
5883 #define X_GLrop_MultiTexCoord3ivARB 208
5884 void __indirect_glMultiTexCoord3ivARB(GLenum target, const GLint * v)
5885 {
5886 struct glx_context * const gc = __glXGetCurrentContext();
5887 const GLuint cmdlen = 20;
5888 emit_header(gc->pc, X_GLrop_MultiTexCoord3ivARB, cmdlen);
5889 (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
5890 (void) memcpy((void *)(gc->pc + 8), (void *)(v), 12);
5891 gc->pc += cmdlen;
5892 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
5893 }
5894
5895 #define X_GLrop_MultiTexCoord3svARB 209
5896 void __indirect_glMultiTexCoord3sARB(GLenum target, GLshort s, GLshort t, GLshor t r)
5897 {
5898 struct glx_context * const gc = __glXGetCurrentContext();
5899 const GLuint cmdlen = 16;
5900 emit_header(gc->pc, X_GLrop_MultiTexCoord3svARB, cmdlen);
5901 (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
5902 (void) memcpy((void *)(gc->pc + 8), (void *)(&s), 2);
5903 (void) memcpy((void *)(gc->pc + 10), (void *)(&t), 2);
5904 (void) memcpy((void *)(gc->pc + 12), (void *)(&r), 2);
5905 gc->pc += cmdlen;
5906 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
5907 }
5908
5909 #define X_GLrop_MultiTexCoord3svARB 209
5910 void __indirect_glMultiTexCoord3svARB(GLenum target, const GLshort * v)
5911 {
5912 struct glx_context * const gc = __glXGetCurrentContext();
5913 const GLuint cmdlen = 16;
5914 emit_header(gc->pc, X_GLrop_MultiTexCoord3svARB, cmdlen);
5915 (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
5916 (void) memcpy((void *)(gc->pc + 8), (void *)(v), 6);
5917 gc->pc += cmdlen;
5918 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
5919 }
5920
5921 #define X_GLrop_MultiTexCoord4dvARB 210
5922 void __indirect_glMultiTexCoord4dARB(GLenum target, GLdouble s, GLdouble t, GLdo uble r, GLdouble q)
5923 {
5924 struct glx_context * const gc = __glXGetCurrentContext();
5925 const GLuint cmdlen = 40;
5926 emit_header(gc->pc, X_GLrop_MultiTexCoord4dvARB, cmdlen);
5927 (void) memcpy((void *)(gc->pc + 4), (void *)(&s), 8);
5928 (void) memcpy((void *)(gc->pc + 12), (void *)(&t), 8);
5929 (void) memcpy((void *)(gc->pc + 20), (void *)(&r), 8);
5930 (void) memcpy((void *)(gc->pc + 28), (void *)(&q), 8);
5931 (void) memcpy((void *)(gc->pc + 36), (void *)(&target), 4);
5932 gc->pc += cmdlen;
5933 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
5934 }
5935
5936 #define X_GLrop_MultiTexCoord4dvARB 210
5937 void __indirect_glMultiTexCoord4dvARB(GLenum target, const GLdouble * v)
5938 {
5939 struct glx_context * const gc = __glXGetCurrentContext();
5940 const GLuint cmdlen = 40;
5941 emit_header(gc->pc, X_GLrop_MultiTexCoord4dvARB, cmdlen);
5942 (void) memcpy((void *)(gc->pc + 4), (void *)(v), 32);
5943 (void) memcpy((void *)(gc->pc + 36), (void *)(&target), 4);
5944 gc->pc += cmdlen;
5945 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
5946 }
5947
5948 #define X_GLrop_MultiTexCoord4fvARB 211
5949 void __indirect_glMultiTexCoord4fARB(GLenum target, GLfloat s, GLfloat t, GLfloa t r, GLfloat q)
5950 {
5951 struct glx_context * const gc = __glXGetCurrentContext();
5952 const GLuint cmdlen = 24;
5953 emit_header(gc->pc, X_GLrop_MultiTexCoord4fvARB, cmdlen);
5954 (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
5955 (void) memcpy((void *)(gc->pc + 8), (void *)(&s), 4);
5956 (void) memcpy((void *)(gc->pc + 12), (void *)(&t), 4);
5957 (void) memcpy((void *)(gc->pc + 16), (void *)(&r), 4);
5958 (void) memcpy((void *)(gc->pc + 20), (void *)(&q), 4);
5959 gc->pc += cmdlen;
5960 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
5961 }
5962
5963 #define X_GLrop_MultiTexCoord4fvARB 211
5964 void __indirect_glMultiTexCoord4fvARB(GLenum target, const GLfloat * v)
5965 {
5966 struct glx_context * const gc = __glXGetCurrentContext();
5967 const GLuint cmdlen = 24;
5968 emit_header(gc->pc, X_GLrop_MultiTexCoord4fvARB, cmdlen);
5969 (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
5970 (void) memcpy((void *)(gc->pc + 8), (void *)(v), 16);
5971 gc->pc += cmdlen;
5972 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
5973 }
5974
5975 #define X_GLrop_MultiTexCoord4ivARB 212
5976 void __indirect_glMultiTexCoord4iARB(GLenum target, GLint s, GLint t, GLint r, G Lint q)
5977 {
5978 struct glx_context * const gc = __glXGetCurrentContext();
5979 const GLuint cmdlen = 24;
5980 emit_header(gc->pc, X_GLrop_MultiTexCoord4ivARB, cmdlen);
5981 (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
5982 (void) memcpy((void *)(gc->pc + 8), (void *)(&s), 4);
5983 (void) memcpy((void *)(gc->pc + 12), (void *)(&t), 4);
5984 (void) memcpy((void *)(gc->pc + 16), (void *)(&r), 4);
5985 (void) memcpy((void *)(gc->pc + 20), (void *)(&q), 4);
5986 gc->pc += cmdlen;
5987 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
5988 }
5989
5990 #define X_GLrop_MultiTexCoord4ivARB 212
5991 void __indirect_glMultiTexCoord4ivARB(GLenum target, const GLint * v)
5992 {
5993 struct glx_context * const gc = __glXGetCurrentContext();
5994 const GLuint cmdlen = 24;
5995 emit_header(gc->pc, X_GLrop_MultiTexCoord4ivARB, cmdlen);
5996 (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
5997 (void) memcpy((void *)(gc->pc + 8), (void *)(v), 16);
5998 gc->pc += cmdlen;
5999 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
6000 }
6001
6002 #define X_GLrop_MultiTexCoord4svARB 213
6003 void __indirect_glMultiTexCoord4sARB(GLenum target, GLshort s, GLshort t, GLshor t r, GLshort q)
6004 {
6005 struct glx_context * const gc = __glXGetCurrentContext();
6006 const GLuint cmdlen = 16;
6007 emit_header(gc->pc, X_GLrop_MultiTexCoord4svARB, cmdlen);
6008 (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
6009 (void) memcpy((void *)(gc->pc + 8), (void *)(&s), 2);
6010 (void) memcpy((void *)(gc->pc + 10), (void *)(&t), 2);
6011 (void) memcpy((void *)(gc->pc + 12), (void *)(&r), 2);
6012 (void) memcpy((void *)(gc->pc + 14), (void *)(&q), 2);
6013 gc->pc += cmdlen;
6014 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
6015 }
6016
6017 #define X_GLrop_MultiTexCoord4svARB 213
6018 void __indirect_glMultiTexCoord4svARB(GLenum target, const GLshort * v)
6019 {
6020 struct glx_context * const gc = __glXGetCurrentContext();
6021 const GLuint cmdlen = 16;
6022 emit_header(gc->pc, X_GLrop_MultiTexCoord4svARB, cmdlen);
6023 (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
6024 (void) memcpy((void *)(gc->pc + 8), (void *)(v), 8);
6025 gc->pc += cmdlen;
6026 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
6027 }
6028
6029 #define X_GLrop_SampleCoverageARB 229
6030 void __indirect_glSampleCoverageARB(GLclampf value, GLboolean invert)
6031 {
6032 struct glx_context * const gc = __glXGetCurrentContext();
6033 const GLuint cmdlen = 12;
6034 emit_header(gc->pc, X_GLrop_SampleCoverageARB, cmdlen);
6035 (void) memcpy((void *)(gc->pc + 4), (void *)(&value), 4);
6036 (void) memcpy((void *)(gc->pc + 8), (void *)(&invert), 1);
6037 gc->pc += cmdlen;
6038 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
6039 }
6040
6041 #define X_GLvop_GetProgramStringARB 1308
6042 void __indirect_glGetProgramStringARB(GLenum target, GLenum pname, GLvoid * stri ng)
6043 {
6044 struct glx_context * const gc = __glXGetCurrentContext();
6045 Display * const dpy = gc->currentDpy;
6046 const GLuint cmdlen = 8;
6047 if (__builtin_expect(dpy != NULL, 1)) {
6048 GLubyte const * pc = __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithR eply, X_GLvop_GetProgramStringARB, cmdlen);
6049 (void) memcpy((void *)(pc + 0), (void *)(&target), 4);
6050 (void) memcpy((void *)(pc + 4), (void *)(&pname), 4);
6051 (void) __glXReadReply(dpy, 1, string, GL_TRUE);
6052 UnlockDisplay(dpy); SyncHandle();
6053 }
6054 return;
6055 }
6056
6057 #define X_GLvop_GetProgramivARB 1307
6058 void __indirect_glGetProgramivARB(GLenum target, GLenum pname, GLint * params)
6059 {
6060 struct glx_context * const gc = __glXGetCurrentContext();
6061 Display * const dpy = gc->currentDpy;
6062 const GLuint cmdlen = 8;
6063 if (__builtin_expect(dpy != NULL, 1)) {
6064 GLubyte const * pc = __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithR eply, X_GLvop_GetProgramivARB, cmdlen);
6065 (void) memcpy((void *)(pc + 0), (void *)(&target), 4);
6066 (void) memcpy((void *)(pc + 4), (void *)(&pname), 4);
6067 (void) __glXReadReply(dpy, 4, params, GL_FALSE);
6068 UnlockDisplay(dpy); SyncHandle();
6069 }
6070 return;
6071 }
6072
6073 #define X_GLrop_ProgramEnvParameter4dvARB 4185
6074 void __indirect_glProgramEnvParameter4dARB(GLenum target, GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w)
6075 {
6076 struct glx_context * const gc = __glXGetCurrentContext();
6077 const GLuint cmdlen = 44;
6078 emit_header(gc->pc, X_GLrop_ProgramEnvParameter4dvARB, cmdlen);
6079 (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
6080 (void) memcpy((void *)(gc->pc + 8), (void *)(&index), 4);
6081 (void) memcpy((void *)(gc->pc + 12), (void *)(&x), 8);
6082 (void) memcpy((void *)(gc->pc + 20), (void *)(&y), 8);
6083 (void) memcpy((void *)(gc->pc + 28), (void *)(&z), 8);
6084 (void) memcpy((void *)(gc->pc + 36), (void *)(&w), 8);
6085 gc->pc += cmdlen;
6086 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
6087 }
6088
6089 #define X_GLrop_ProgramEnvParameter4dvARB 4185
6090 void __indirect_glProgramEnvParameter4dvARB(GLenum target, GLuint index, const G Ldouble * params)
6091 {
6092 struct glx_context * const gc = __glXGetCurrentContext();
6093 const GLuint cmdlen = 44;
6094 emit_header(gc->pc, X_GLrop_ProgramEnvParameter4dvARB, cmdlen);
6095 (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
6096 (void) memcpy((void *)(gc->pc + 8), (void *)(&index), 4);
6097 (void) memcpy((void *)(gc->pc + 12), (void *)(params), 32);
6098 gc->pc += cmdlen;
6099 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
6100 }
6101
6102 #define X_GLrop_ProgramEnvParameter4fvARB 4184
6103 void __indirect_glProgramEnvParameter4fARB(GLenum target, GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
6104 {
6105 struct glx_context * const gc = __glXGetCurrentContext();
6106 const GLuint cmdlen = 28;
6107 emit_header(gc->pc, X_GLrop_ProgramEnvParameter4fvARB, cmdlen);
6108 (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
6109 (void) memcpy((void *)(gc->pc + 8), (void *)(&index), 4);
6110 (void) memcpy((void *)(gc->pc + 12), (void *)(&x), 4);
6111 (void) memcpy((void *)(gc->pc + 16), (void *)(&y), 4);
6112 (void) memcpy((void *)(gc->pc + 20), (void *)(&z), 4);
6113 (void) memcpy((void *)(gc->pc + 24), (void *)(&w), 4);
6114 gc->pc += cmdlen;
6115 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
6116 }
6117
6118 #define X_GLrop_ProgramEnvParameter4fvARB 4184
6119 void __indirect_glProgramEnvParameter4fvARB(GLenum target, GLuint index, const G Lfloat * params)
6120 {
6121 struct glx_context * const gc = __glXGetCurrentContext();
6122 const GLuint cmdlen = 28;
6123 emit_header(gc->pc, X_GLrop_ProgramEnvParameter4fvARB, cmdlen);
6124 (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
6125 (void) memcpy((void *)(gc->pc + 8), (void *)(&index), 4);
6126 (void) memcpy((void *)(gc->pc + 12), (void *)(params), 16);
6127 gc->pc += cmdlen;
6128 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
6129 }
6130
6131 #define X_GLrop_ProgramLocalParameter4dvARB 4216
6132 void __indirect_glProgramLocalParameter4dARB(GLenum target, GLuint index, GLdoub le x, GLdouble y, GLdouble z, GLdouble w)
6133 {
6134 struct glx_context * const gc = __glXGetCurrentContext();
6135 const GLuint cmdlen = 44;
6136 emit_header(gc->pc, X_GLrop_ProgramLocalParameter4dvARB, cmdlen);
6137 (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
6138 (void) memcpy((void *)(gc->pc + 8), (void *)(&index), 4);
6139 (void) memcpy((void *)(gc->pc + 12), (void *)(&x), 8);
6140 (void) memcpy((void *)(gc->pc + 20), (void *)(&y), 8);
6141 (void) memcpy((void *)(gc->pc + 28), (void *)(&z), 8);
6142 (void) memcpy((void *)(gc->pc + 36), (void *)(&w), 8);
6143 gc->pc += cmdlen;
6144 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
6145 }
6146
6147 #define X_GLrop_ProgramLocalParameter4dvARB 4216
6148 void __indirect_glProgramLocalParameter4dvARB(GLenum target, GLuint index, const GLdouble * params)
6149 {
6150 struct glx_context * const gc = __glXGetCurrentContext();
6151 const GLuint cmdlen = 44;
6152 emit_header(gc->pc, X_GLrop_ProgramLocalParameter4dvARB, cmdlen);
6153 (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
6154 (void) memcpy((void *)(gc->pc + 8), (void *)(&index), 4);
6155 (void) memcpy((void *)(gc->pc + 12), (void *)(params), 32);
6156 gc->pc += cmdlen;
6157 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
6158 }
6159
6160 #define X_GLrop_ProgramLocalParameter4fvARB 4215
6161 void __indirect_glProgramLocalParameter4fARB(GLenum target, GLuint index, GLfloa t x, GLfloat y, GLfloat z, GLfloat w)
6162 {
6163 struct glx_context * const gc = __glXGetCurrentContext();
6164 const GLuint cmdlen = 28;
6165 emit_header(gc->pc, X_GLrop_ProgramLocalParameter4fvARB, cmdlen);
6166 (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
6167 (void) memcpy((void *)(gc->pc + 8), (void *)(&index), 4);
6168 (void) memcpy((void *)(gc->pc + 12), (void *)(&x), 4);
6169 (void) memcpy((void *)(gc->pc + 16), (void *)(&y), 4);
6170 (void) memcpy((void *)(gc->pc + 20), (void *)(&z), 4);
6171 (void) memcpy((void *)(gc->pc + 24), (void *)(&w), 4);
6172 gc->pc += cmdlen;
6173 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
6174 }
6175
6176 #define X_GLrop_ProgramLocalParameter4fvARB 4215
6177 void __indirect_glProgramLocalParameter4fvARB(GLenum target, GLuint index, const GLfloat * params)
6178 {
6179 struct glx_context * const gc = __glXGetCurrentContext();
6180 const GLuint cmdlen = 28;
6181 emit_header(gc->pc, X_GLrop_ProgramLocalParameter4fvARB, cmdlen);
6182 (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
6183 (void) memcpy((void *)(gc->pc + 8), (void *)(&index), 4);
6184 (void) memcpy((void *)(gc->pc + 12), (void *)(params), 16);
6185 gc->pc += cmdlen;
6186 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
6187 }
6188
6189 #define X_GLrop_ProgramStringARB 4217
6190 void __indirect_glProgramStringARB(GLenum target, GLenum format, GLsizei len, co nst GLvoid * string)
6191 {
6192 struct glx_context * const gc = __glXGetCurrentContext();
6193 const GLuint cmdlen = 16 + __GLX_PAD(len);
6194 if (len < 0) {
6195 __glXSetError(gc, GL_INVALID_VALUE);
6196 return;
6197 }
6198 if (__builtin_expect((len >= 0) && (gc->currentDpy != NULL), 1)) {
6199 if (cmdlen <= gc->maxSmallRenderCommandSize) {
6200 if ( (gc->pc + cmdlen) > gc->bufEnd ) {
6201 (void) __glXFlushRenderBuffer(gc, gc->pc);
6202 }
6203 emit_header(gc->pc, X_GLrop_ProgramStringARB, cmdlen);
6204 (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
6205 (void) memcpy((void *)(gc->pc + 8), (void *)(&format), 4);
6206 (void) memcpy((void *)(gc->pc + 12), (void *)(&len), 4);
6207 (void) memcpy((void *)(gc->pc + 16), (void *)(string), len);
6208 gc->pc += cmdlen;
6209 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
6210 }
6211 else {
6212 const GLint op = X_GLrop_ProgramStringARB;
6213 const GLuint cmdlenLarge = cmdlen + 4;
6214 GLubyte * const pc = __glXFlushRenderBuffer(gc, gc->pc);
6215 (void) memcpy((void *)(pc + 0), (void *)(&cmdlenLarge), 4);
6216 (void) memcpy((void *)(pc + 4), (void *)(&op), 4);
6217 (void) memcpy((void *)(pc + 8), (void *)(&target), 4);
6218 (void) memcpy((void *)(pc + 12), (void *)(&format), 4);
6219 (void) memcpy((void *)(pc + 16), (void *)(&len), 4);
6220 __glXSendLargeCommand(gc, pc, 20, string, len);
6221 }
6222 }
6223 }
6224
6225 #define X_GLrop_VertexAttrib1dvARB 4197
6226 void __indirect_glVertexAttrib1dARB(GLuint index, GLdouble x)
6227 {
6228 struct glx_context * const gc = __glXGetCurrentContext();
6229 const GLuint cmdlen = 16;
6230 emit_header(gc->pc, X_GLrop_VertexAttrib1dvARB, cmdlen);
6231 (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
6232 (void) memcpy((void *)(gc->pc + 8), (void *)(&x), 8);
6233 gc->pc += cmdlen;
6234 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
6235 }
6236
6237 #define X_GLrop_VertexAttrib1dvARB 4197
6238 void __indirect_glVertexAttrib1dvARB(GLuint index, const GLdouble * v)
6239 {
6240 struct glx_context * const gc = __glXGetCurrentContext();
6241 const GLuint cmdlen = 16;
6242 emit_header(gc->pc, X_GLrop_VertexAttrib1dvARB, cmdlen);
6243 (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
6244 (void) memcpy((void *)(gc->pc + 8), (void *)(v), 8);
6245 gc->pc += cmdlen;
6246 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
6247 }
6248
6249 #define X_GLrop_VertexAttrib1fvARB 4193
6250 void __indirect_glVertexAttrib1fARB(GLuint index, GLfloat x)
6251 {
6252 struct glx_context * const gc = __glXGetCurrentContext();
6253 const GLuint cmdlen = 12;
6254 emit_header(gc->pc, X_GLrop_VertexAttrib1fvARB, cmdlen);
6255 (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
6256 (void) memcpy((void *)(gc->pc + 8), (void *)(&x), 4);
6257 gc->pc += cmdlen;
6258 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
6259 }
6260
6261 #define X_GLrop_VertexAttrib1fvARB 4193
6262 void __indirect_glVertexAttrib1fvARB(GLuint index, const GLfloat * v)
6263 {
6264 struct glx_context * const gc = __glXGetCurrentContext();
6265 const GLuint cmdlen = 12;
6266 emit_header(gc->pc, X_GLrop_VertexAttrib1fvARB, cmdlen);
6267 (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
6268 (void) memcpy((void *)(gc->pc + 8), (void *)(v), 4);
6269 gc->pc += cmdlen;
6270 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
6271 }
6272
6273 #define X_GLrop_VertexAttrib1svARB 4189
6274 void __indirect_glVertexAttrib1sARB(GLuint index, GLshort x)
6275 {
6276 struct glx_context * const gc = __glXGetCurrentContext();
6277 const GLuint cmdlen = 12;
6278 emit_header(gc->pc, X_GLrop_VertexAttrib1svARB, cmdlen);
6279 (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
6280 (void) memcpy((void *)(gc->pc + 8), (void *)(&x), 2);
6281 gc->pc += cmdlen;
6282 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
6283 }
6284
6285 #define X_GLrop_VertexAttrib1svARB 4189
6286 void __indirect_glVertexAttrib1svARB(GLuint index, const GLshort * v)
6287 {
6288 struct glx_context * const gc = __glXGetCurrentContext();
6289 const GLuint cmdlen = 12;
6290 emit_header(gc->pc, X_GLrop_VertexAttrib1svARB, cmdlen);
6291 (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
6292 (void) memcpy((void *)(gc->pc + 8), (void *)(v), 2);
6293 gc->pc += cmdlen;
6294 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
6295 }
6296
6297 #define X_GLrop_VertexAttrib2dvARB 4198
6298 void __indirect_glVertexAttrib2dARB(GLuint index, GLdouble x, GLdouble y)
6299 {
6300 struct glx_context * const gc = __glXGetCurrentContext();
6301 const GLuint cmdlen = 24;
6302 emit_header(gc->pc, X_GLrop_VertexAttrib2dvARB, cmdlen);
6303 (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
6304 (void) memcpy((void *)(gc->pc + 8), (void *)(&x), 8);
6305 (void) memcpy((void *)(gc->pc + 16), (void *)(&y), 8);
6306 gc->pc += cmdlen;
6307 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
6308 }
6309
6310 #define X_GLrop_VertexAttrib2dvARB 4198
6311 void __indirect_glVertexAttrib2dvARB(GLuint index, const GLdouble * v)
6312 {
6313 struct glx_context * const gc = __glXGetCurrentContext();
6314 const GLuint cmdlen = 24;
6315 emit_header(gc->pc, X_GLrop_VertexAttrib2dvARB, cmdlen);
6316 (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
6317 (void) memcpy((void *)(gc->pc + 8), (void *)(v), 16);
6318 gc->pc += cmdlen;
6319 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
6320 }
6321
6322 #define X_GLrop_VertexAttrib2fvARB 4194
6323 void __indirect_glVertexAttrib2fARB(GLuint index, GLfloat x, GLfloat y)
6324 {
6325 struct glx_context * const gc = __glXGetCurrentContext();
6326 const GLuint cmdlen = 16;
6327 emit_header(gc->pc, X_GLrop_VertexAttrib2fvARB, cmdlen);
6328 (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
6329 (void) memcpy((void *)(gc->pc + 8), (void *)(&x), 4);
6330 (void) memcpy((void *)(gc->pc + 12), (void *)(&y), 4);
6331 gc->pc += cmdlen;
6332 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
6333 }
6334
6335 #define X_GLrop_VertexAttrib2fvARB 4194
6336 void __indirect_glVertexAttrib2fvARB(GLuint index, const GLfloat * v)
6337 {
6338 struct glx_context * const gc = __glXGetCurrentContext();
6339 const GLuint cmdlen = 16;
6340 emit_header(gc->pc, X_GLrop_VertexAttrib2fvARB, cmdlen);
6341 (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
6342 (void) memcpy((void *)(gc->pc + 8), (void *)(v), 8);
6343 gc->pc += cmdlen;
6344 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
6345 }
6346
6347 #define X_GLrop_VertexAttrib2svARB 4190
6348 void __indirect_glVertexAttrib2sARB(GLuint index, GLshort x, GLshort y)
6349 {
6350 struct glx_context * const gc = __glXGetCurrentContext();
6351 const GLuint cmdlen = 12;
6352 emit_header(gc->pc, X_GLrop_VertexAttrib2svARB, cmdlen);
6353 (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
6354 (void) memcpy((void *)(gc->pc + 8), (void *)(&x), 2);
6355 (void) memcpy((void *)(gc->pc + 10), (void *)(&y), 2);
6356 gc->pc += cmdlen;
6357 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
6358 }
6359
6360 #define X_GLrop_VertexAttrib2svARB 4190
6361 void __indirect_glVertexAttrib2svARB(GLuint index, const GLshort * v)
6362 {
6363 struct glx_context * const gc = __glXGetCurrentContext();
6364 const GLuint cmdlen = 12;
6365 emit_header(gc->pc, X_GLrop_VertexAttrib2svARB, cmdlen);
6366 (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
6367 (void) memcpy((void *)(gc->pc + 8), (void *)(v), 4);
6368 gc->pc += cmdlen;
6369 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
6370 }
6371
6372 #define X_GLrop_VertexAttrib3dvARB 4199
6373 void __indirect_glVertexAttrib3dARB(GLuint index, GLdouble x, GLdouble y, GLdoub le z)
6374 {
6375 struct glx_context * const gc = __glXGetCurrentContext();
6376 const GLuint cmdlen = 32;
6377 emit_header(gc->pc, X_GLrop_VertexAttrib3dvARB, cmdlen);
6378 (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
6379 (void) memcpy((void *)(gc->pc + 8), (void *)(&x), 8);
6380 (void) memcpy((void *)(gc->pc + 16), (void *)(&y), 8);
6381 (void) memcpy((void *)(gc->pc + 24), (void *)(&z), 8);
6382 gc->pc += cmdlen;
6383 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
6384 }
6385
6386 #define X_GLrop_VertexAttrib3dvARB 4199
6387 void __indirect_glVertexAttrib3dvARB(GLuint index, const GLdouble * v)
6388 {
6389 struct glx_context * const gc = __glXGetCurrentContext();
6390 const GLuint cmdlen = 32;
6391 emit_header(gc->pc, X_GLrop_VertexAttrib3dvARB, cmdlen);
6392 (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
6393 (void) memcpy((void *)(gc->pc + 8), (void *)(v), 24);
6394 gc->pc += cmdlen;
6395 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
6396 }
6397
6398 #define X_GLrop_VertexAttrib3fvARB 4195
6399 void __indirect_glVertexAttrib3fARB(GLuint index, GLfloat x, GLfloat y, GLfloat z)
6400 {
6401 struct glx_context * const gc = __glXGetCurrentContext();
6402 const GLuint cmdlen = 20;
6403 emit_header(gc->pc, X_GLrop_VertexAttrib3fvARB, cmdlen);
6404 (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
6405 (void) memcpy((void *)(gc->pc + 8), (void *)(&x), 4);
6406 (void) memcpy((void *)(gc->pc + 12), (void *)(&y), 4);
6407 (void) memcpy((void *)(gc->pc + 16), (void *)(&z), 4);
6408 gc->pc += cmdlen;
6409 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
6410 }
6411
6412 #define X_GLrop_VertexAttrib3fvARB 4195
6413 void __indirect_glVertexAttrib3fvARB(GLuint index, const GLfloat * v)
6414 {
6415 struct glx_context * const gc = __glXGetCurrentContext();
6416 const GLuint cmdlen = 20;
6417 emit_header(gc->pc, X_GLrop_VertexAttrib3fvARB, cmdlen);
6418 (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
6419 (void) memcpy((void *)(gc->pc + 8), (void *)(v), 12);
6420 gc->pc += cmdlen;
6421 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
6422 }
6423
6424 #define X_GLrop_VertexAttrib3svARB 4191
6425 void __indirect_glVertexAttrib3sARB(GLuint index, GLshort x, GLshort y, GLshort z)
6426 {
6427 struct glx_context * const gc = __glXGetCurrentContext();
6428 const GLuint cmdlen = 16;
6429 emit_header(gc->pc, X_GLrop_VertexAttrib3svARB, cmdlen);
6430 (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
6431 (void) memcpy((void *)(gc->pc + 8), (void *)(&x), 2);
6432 (void) memcpy((void *)(gc->pc + 10), (void *)(&y), 2);
6433 (void) memcpy((void *)(gc->pc + 12), (void *)(&z), 2);
6434 gc->pc += cmdlen;
6435 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
6436 }
6437
6438 #define X_GLrop_VertexAttrib3svARB 4191
6439 void __indirect_glVertexAttrib3svARB(GLuint index, const GLshort * v)
6440 {
6441 struct glx_context * const gc = __glXGetCurrentContext();
6442 const GLuint cmdlen = 16;
6443 emit_header(gc->pc, X_GLrop_VertexAttrib3svARB, cmdlen);
6444 (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
6445 (void) memcpy((void *)(gc->pc + 8), (void *)(v), 6);
6446 gc->pc += cmdlen;
6447 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
6448 }
6449
6450 #define X_GLrop_VertexAttrib4NbvARB 4235
6451 void __indirect_glVertexAttrib4NbvARB(GLuint index, const GLbyte * v)
6452 {
6453 struct glx_context * const gc = __glXGetCurrentContext();
6454 const GLuint cmdlen = 12;
6455 emit_header(gc->pc, X_GLrop_VertexAttrib4NbvARB, cmdlen);
6456 (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
6457 (void) memcpy((void *)(gc->pc + 8), (void *)(v), 4);
6458 gc->pc += cmdlen;
6459 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
6460 }
6461
6462 #define X_GLrop_VertexAttrib4NivARB 4237
6463 void __indirect_glVertexAttrib4NivARB(GLuint index, const GLint * v)
6464 {
6465 struct glx_context * const gc = __glXGetCurrentContext();
6466 const GLuint cmdlen = 24;
6467 emit_header(gc->pc, X_GLrop_VertexAttrib4NivARB, cmdlen);
6468 (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
6469 (void) memcpy((void *)(gc->pc + 8), (void *)(v), 16);
6470 gc->pc += cmdlen;
6471 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
6472 }
6473
6474 #define X_GLrop_VertexAttrib4NsvARB 4236
6475 void __indirect_glVertexAttrib4NsvARB(GLuint index, const GLshort * v)
6476 {
6477 struct glx_context * const gc = __glXGetCurrentContext();
6478 const GLuint cmdlen = 16;
6479 emit_header(gc->pc, X_GLrop_VertexAttrib4NsvARB, cmdlen);
6480 (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
6481 (void) memcpy((void *)(gc->pc + 8), (void *)(v), 8);
6482 gc->pc += cmdlen;
6483 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
6484 }
6485
6486 #define X_GLrop_VertexAttrib4NubvARB 4201
6487 void __indirect_glVertexAttrib4NubARB(GLuint index, GLubyte x, GLubyte y, GLubyt e z, GLubyte w)
6488 {
6489 struct glx_context * const gc = __glXGetCurrentContext();
6490 const GLuint cmdlen = 12;
6491 emit_header(gc->pc, X_GLrop_VertexAttrib4NubvARB, cmdlen);
6492 (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
6493 (void) memcpy((void *)(gc->pc + 8), (void *)(&x), 1);
6494 (void) memcpy((void *)(gc->pc + 9), (void *)(&y), 1);
6495 (void) memcpy((void *)(gc->pc + 10), (void *)(&z), 1);
6496 (void) memcpy((void *)(gc->pc + 11), (void *)(&w), 1);
6497 gc->pc += cmdlen;
6498 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
6499 }
6500
6501 #define X_GLrop_VertexAttrib4NubvARB 4201
6502 void __indirect_glVertexAttrib4NubvARB(GLuint index, const GLubyte * v)
6503 {
6504 struct glx_context * const gc = __glXGetCurrentContext();
6505 const GLuint cmdlen = 12;
6506 emit_header(gc->pc, X_GLrop_VertexAttrib4NubvARB, cmdlen);
6507 (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
6508 (void) memcpy((void *)(gc->pc + 8), (void *)(v), 4);
6509 gc->pc += cmdlen;
6510 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
6511 }
6512
6513 #define X_GLrop_VertexAttrib4NuivARB 4239
6514 void __indirect_glVertexAttrib4NuivARB(GLuint index, const GLuint * v)
6515 {
6516 struct glx_context * const gc = __glXGetCurrentContext();
6517 const GLuint cmdlen = 24;
6518 emit_header(gc->pc, X_GLrop_VertexAttrib4NuivARB, cmdlen);
6519 (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
6520 (void) memcpy((void *)(gc->pc + 8), (void *)(v), 16);
6521 gc->pc += cmdlen;
6522 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
6523 }
6524
6525 #define X_GLrop_VertexAttrib4NusvARB 4238
6526 void __indirect_glVertexAttrib4NusvARB(GLuint index, const GLushort * v)
6527 {
6528 struct glx_context * const gc = __glXGetCurrentContext();
6529 const GLuint cmdlen = 16;
6530 emit_header(gc->pc, X_GLrop_VertexAttrib4NusvARB, cmdlen);
6531 (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
6532 (void) memcpy((void *)(gc->pc + 8), (void *)(v), 8);
6533 gc->pc += cmdlen;
6534 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
6535 }
6536
6537 #define X_GLrop_VertexAttrib4bvARB 4230
6538 void __indirect_glVertexAttrib4bvARB(GLuint index, const GLbyte * v)
6539 {
6540 struct glx_context * const gc = __glXGetCurrentContext();
6541 const GLuint cmdlen = 12;
6542 emit_header(gc->pc, X_GLrop_VertexAttrib4bvARB, cmdlen);
6543 (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
6544 (void) memcpy((void *)(gc->pc + 8), (void *)(v), 4);
6545 gc->pc += cmdlen;
6546 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
6547 }
6548
6549 #define X_GLrop_VertexAttrib4dvARB 4200
6550 void __indirect_glVertexAttrib4dARB(GLuint index, GLdouble x, GLdouble y, GLdoub le z, GLdouble w)
6551 {
6552 struct glx_context * const gc = __glXGetCurrentContext();
6553 const GLuint cmdlen = 40;
6554 emit_header(gc->pc, X_GLrop_VertexAttrib4dvARB, cmdlen);
6555 (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
6556 (void) memcpy((void *)(gc->pc + 8), (void *)(&x), 8);
6557 (void) memcpy((void *)(gc->pc + 16), (void *)(&y), 8);
6558 (void) memcpy((void *)(gc->pc + 24), (void *)(&z), 8);
6559 (void) memcpy((void *)(gc->pc + 32), (void *)(&w), 8);
6560 gc->pc += cmdlen;
6561 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
6562 }
6563
6564 #define X_GLrop_VertexAttrib4dvARB 4200
6565 void __indirect_glVertexAttrib4dvARB(GLuint index, const GLdouble * v)
6566 {
6567 struct glx_context * const gc = __glXGetCurrentContext();
6568 const GLuint cmdlen = 40;
6569 emit_header(gc->pc, X_GLrop_VertexAttrib4dvARB, cmdlen);
6570 (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
6571 (void) memcpy((void *)(gc->pc + 8), (void *)(v), 32);
6572 gc->pc += cmdlen;
6573 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
6574 }
6575
6576 #define X_GLrop_VertexAttrib4fvARB 4196
6577 void __indirect_glVertexAttrib4fARB(GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
6578 {
6579 struct glx_context * const gc = __glXGetCurrentContext();
6580 const GLuint cmdlen = 24;
6581 emit_header(gc->pc, X_GLrop_VertexAttrib4fvARB, cmdlen);
6582 (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
6583 (void) memcpy((void *)(gc->pc + 8), (void *)(&x), 4);
6584 (void) memcpy((void *)(gc->pc + 12), (void *)(&y), 4);
6585 (void) memcpy((void *)(gc->pc + 16), (void *)(&z), 4);
6586 (void) memcpy((void *)(gc->pc + 20), (void *)(&w), 4);
6587 gc->pc += cmdlen;
6588 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
6589 }
6590
6591 #define X_GLrop_VertexAttrib4fvARB 4196
6592 void __indirect_glVertexAttrib4fvARB(GLuint index, const GLfloat * v)
6593 {
6594 struct glx_context * const gc = __glXGetCurrentContext();
6595 const GLuint cmdlen = 24;
6596 emit_header(gc->pc, X_GLrop_VertexAttrib4fvARB, cmdlen);
6597 (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
6598 (void) memcpy((void *)(gc->pc + 8), (void *)(v), 16);
6599 gc->pc += cmdlen;
6600 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
6601 }
6602
6603 #define X_GLrop_VertexAttrib4ivARB 4231
6604 void __indirect_glVertexAttrib4ivARB(GLuint index, const GLint * v)
6605 {
6606 struct glx_context * const gc = __glXGetCurrentContext();
6607 const GLuint cmdlen = 24;
6608 emit_header(gc->pc, X_GLrop_VertexAttrib4ivARB, cmdlen);
6609 (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
6610 (void) memcpy((void *)(gc->pc + 8), (void *)(v), 16);
6611 gc->pc += cmdlen;
6612 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
6613 }
6614
6615 #define X_GLrop_VertexAttrib4svARB 4192
6616 void __indirect_glVertexAttrib4sARB(GLuint index, GLshort x, GLshort y, GLshort z, GLshort w)
6617 {
6618 struct glx_context * const gc = __glXGetCurrentContext();
6619 const GLuint cmdlen = 16;
6620 emit_header(gc->pc, X_GLrop_VertexAttrib4svARB, cmdlen);
6621 (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
6622 (void) memcpy((void *)(gc->pc + 8), (void *)(&x), 2);
6623 (void) memcpy((void *)(gc->pc + 10), (void *)(&y), 2);
6624 (void) memcpy((void *)(gc->pc + 12), (void *)(&z), 2);
6625 (void) memcpy((void *)(gc->pc + 14), (void *)(&w), 2);
6626 gc->pc += cmdlen;
6627 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
6628 }
6629
6630 #define X_GLrop_VertexAttrib4svARB 4192
6631 void __indirect_glVertexAttrib4svARB(GLuint index, const GLshort * v)
6632 {
6633 struct glx_context * const gc = __glXGetCurrentContext();
6634 const GLuint cmdlen = 16;
6635 emit_header(gc->pc, X_GLrop_VertexAttrib4svARB, cmdlen);
6636 (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
6637 (void) memcpy((void *)(gc->pc + 8), (void *)(v), 8);
6638 gc->pc += cmdlen;
6639 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
6640 }
6641
6642 #define X_GLrop_VertexAttrib4ubvARB 4232
6643 void __indirect_glVertexAttrib4ubvARB(GLuint index, const GLubyte * v)
6644 {
6645 struct glx_context * const gc = __glXGetCurrentContext();
6646 const GLuint cmdlen = 12;
6647 emit_header(gc->pc, X_GLrop_VertexAttrib4ubvARB, cmdlen);
6648 (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
6649 (void) memcpy((void *)(gc->pc + 8), (void *)(v), 4);
6650 gc->pc += cmdlen;
6651 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
6652 }
6653
6654 #define X_GLrop_VertexAttrib4uivARB 4234
6655 void __indirect_glVertexAttrib4uivARB(GLuint index, const GLuint * v)
6656 {
6657 struct glx_context * const gc = __glXGetCurrentContext();
6658 const GLuint cmdlen = 24;
6659 emit_header(gc->pc, X_GLrop_VertexAttrib4uivARB, cmdlen);
6660 (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
6661 (void) memcpy((void *)(gc->pc + 8), (void *)(v), 16);
6662 gc->pc += cmdlen;
6663 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
6664 }
6665
6666 #define X_GLrop_VertexAttrib4usvARB 4233
6667 void __indirect_glVertexAttrib4usvARB(GLuint index, const GLushort * v)
6668 {
6669 struct glx_context * const gc = __glXGetCurrentContext();
6670 const GLuint cmdlen = 16;
6671 emit_header(gc->pc, X_GLrop_VertexAttrib4usvARB, cmdlen);
6672 (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
6673 (void) memcpy((void *)(gc->pc + 8), (void *)(v), 8);
6674 gc->pc += cmdlen;
6675 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
6676 }
6677
6678 #define X_GLrop_BeginQueryARB 231
6679 void __indirect_glBeginQueryARB(GLenum target, GLuint id)
6680 {
6681 struct glx_context * const gc = __glXGetCurrentContext();
6682 const GLuint cmdlen = 12;
6683 emit_header(gc->pc, X_GLrop_BeginQueryARB, cmdlen);
6684 (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
6685 (void) memcpy((void *)(gc->pc + 8), (void *)(&id), 4);
6686 gc->pc += cmdlen;
6687 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
6688 }
6689
6690 #define X_GLsop_DeleteQueriesARB 161
6691 void __indirect_glDeleteQueriesARB(GLsizei n, const GLuint * ids)
6692 {
6693 struct glx_context * const gc = __glXGetCurrentContext();
6694 Display * const dpy = gc->currentDpy;
6695 #ifndef USE_XCB
6696 const GLuint cmdlen = 4 + __GLX_PAD((n * 4));
6697 #endif
6698 if (n < 0) {
6699 __glXSetError(gc, GL_INVALID_VALUE);
6700 return;
6701 }
6702 if (__builtin_expect((n >= 0) && (dpy != NULL), 1)) {
6703 #ifdef USE_XCB
6704 xcb_connection_t *c = XGetXCBConnection(dpy);
6705 (void) __glXFlushRenderBuffer(gc, gc->pc);
6706 xcb_glx_delete_queries_arb(c, gc->currentContextTag, n, ids);
6707 #else
6708 GLubyte const * pc = __glXSetupSingleRequest(gc, X_GLsop_DeleteQueriesAR B, cmdlen);
6709 (void) memcpy((void *)(pc + 0), (void *)(&n), 4);
6710 (void) memcpy((void *)(pc + 4), (void *)(ids), (n * 4));
6711 UnlockDisplay(dpy); SyncHandle();
6712 #endif /* USE_XCB */
6713 }
6714 return;
6715 }
6716
6717 #define X_GLrop_EndQueryARB 232
6718 void __indirect_glEndQueryARB(GLenum target)
6719 {
6720 struct glx_context * const gc = __glXGetCurrentContext();
6721 const GLuint cmdlen = 8;
6722 emit_header(gc->pc, X_GLrop_EndQueryARB, cmdlen);
6723 (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
6724 gc->pc += cmdlen;
6725 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
6726 }
6727
6728 #define X_GLsop_GenQueriesARB 162
6729 void __indirect_glGenQueriesARB(GLsizei n, GLuint * ids)
6730 {
6731 struct glx_context * const gc = __glXGetCurrentContext();
6732 Display * const dpy = gc->currentDpy;
6733 #ifndef USE_XCB
6734 const GLuint cmdlen = 4;
6735 #endif
6736 if (n < 0) {
6737 __glXSetError(gc, GL_INVALID_VALUE);
6738 return;
6739 }
6740 if (__builtin_expect((n >= 0) && (dpy != NULL), 1)) {
6741 #ifdef USE_XCB
6742 xcb_connection_t *c = XGetXCBConnection(dpy);
6743 (void) __glXFlushRenderBuffer(gc, gc->pc);
6744 xcb_glx_gen_queries_arb_reply_t *reply = xcb_glx_gen_queries_arb_reply(c , xcb_glx_gen_queries_arb(c, gc->currentContextTag, n), NULL);
6745 (void)memcpy(ids, xcb_glx_gen_queries_arb_data(reply), xcb_glx_gen_queri es_arb_data_length(reply) * sizeof(GLuint));
6746 free(reply);
6747 #else
6748 GLubyte const * pc = __glXSetupSingleRequest(gc, X_GLsop_GenQueriesARB, cmdlen);
6749 (void) memcpy((void *)(pc + 0), (void *)(&n), 4);
6750 (void) __glXReadReply(dpy, 4, ids, GL_TRUE);
6751 UnlockDisplay(dpy); SyncHandle();
6752 #endif /* USE_XCB */
6753 }
6754 return;
6755 }
6756
6757 #define X_GLsop_GetQueryObjectivARB 165
6758 void __indirect_glGetQueryObjectivARB(GLuint id, GLenum pname, GLint * params)
6759 {
6760 struct glx_context * const gc = __glXGetCurrentContext();
6761 Display * const dpy = gc->currentDpy;
6762 #ifndef USE_XCB
6763 const GLuint cmdlen = 8;
6764 #endif
6765 if (__builtin_expect(dpy != NULL, 1)) {
6766 #ifdef USE_XCB
6767 xcb_connection_t *c = XGetXCBConnection(dpy);
6768 (void) __glXFlushRenderBuffer(gc, gc->pc);
6769 xcb_glx_get_query_objectiv_arb_reply_t *reply = xcb_glx_get_query_object iv_arb_reply(c, xcb_glx_get_query_objectiv_arb(c, gc->currentContextTag, id, pna me), NULL);
6770 if (xcb_glx_get_query_objectiv_arb_data_length(reply) == 0)
6771 (void)memcpy(params, &reply->datum, sizeof(reply->datum));
6772 else
6773 (void)memcpy(params, xcb_glx_get_query_objectiv_arb_data(reply), xcb _glx_get_query_objectiv_arb_data_length(reply) * sizeof(GLint));
6774 free(reply);
6775 #else
6776 GLubyte const * pc = __glXSetupSingleRequest(gc, X_GLsop_GetQueryObjecti vARB, cmdlen);
6777 (void) memcpy((void *)(pc + 0), (void *)(&id), 4);
6778 (void) memcpy((void *)(pc + 4), (void *)(&pname), 4);
6779 (void) __glXReadReply(dpy, 4, params, GL_FALSE);
6780 UnlockDisplay(dpy); SyncHandle();
6781 #endif /* USE_XCB */
6782 }
6783 return;
6784 }
6785
6786 #define X_GLsop_GetQueryObjectuivARB 166
6787 void __indirect_glGetQueryObjectuivARB(GLuint id, GLenum pname, GLuint * params)
6788 {
6789 struct glx_context * const gc = __glXGetCurrentContext();
6790 Display * const dpy = gc->currentDpy;
6791 #ifndef USE_XCB
6792 const GLuint cmdlen = 8;
6793 #endif
6794 if (__builtin_expect(dpy != NULL, 1)) {
6795 #ifdef USE_XCB
6796 xcb_connection_t *c = XGetXCBConnection(dpy);
6797 (void) __glXFlushRenderBuffer(gc, gc->pc);
6798 xcb_glx_get_query_objectuiv_arb_reply_t *reply = xcb_glx_get_query_objec tuiv_arb_reply(c, xcb_glx_get_query_objectuiv_arb(c, gc->currentContextTag, id, pname), NULL);
6799 if (xcb_glx_get_query_objectuiv_arb_data_length(reply) == 0)
6800 (void)memcpy(params, &reply->datum, sizeof(reply->datum));
6801 else
6802 (void)memcpy(params, xcb_glx_get_query_objectuiv_arb_data(reply), xc b_glx_get_query_objectuiv_arb_data_length(reply) * sizeof(GLuint));
6803 free(reply);
6804 #else
6805 GLubyte const * pc = __glXSetupSingleRequest(gc, X_GLsop_GetQueryObjectu ivARB, cmdlen);
6806 (void) memcpy((void *)(pc + 0), (void *)(&id), 4);
6807 (void) memcpy((void *)(pc + 4), (void *)(&pname), 4);
6808 (void) __glXReadReply(dpy, 4, params, GL_FALSE);
6809 UnlockDisplay(dpy); SyncHandle();
6810 #endif /* USE_XCB */
6811 }
6812 return;
6813 }
6814
6815 #define X_GLsop_GetQueryivARB 164
6816 void __indirect_glGetQueryivARB(GLenum target, GLenum pname, GLint * params)
6817 {
6818 struct glx_context * const gc = __glXGetCurrentContext();
6819 Display * const dpy = gc->currentDpy;
6820 #ifndef USE_XCB
6821 const GLuint cmdlen = 8;
6822 #endif
6823 if (__builtin_expect(dpy != NULL, 1)) {
6824 #ifdef USE_XCB
6825 xcb_connection_t *c = XGetXCBConnection(dpy);
6826 (void) __glXFlushRenderBuffer(gc, gc->pc);
6827 xcb_glx_get_queryiv_arb_reply_t *reply = xcb_glx_get_queryiv_arb_reply(c , xcb_glx_get_queryiv_arb(c, gc->currentContextTag, target, pname), NULL);
6828 if (xcb_glx_get_queryiv_arb_data_length(reply) == 0)
6829 (void)memcpy(params, &reply->datum, sizeof(reply->datum));
6830 else
6831 (void)memcpy(params, xcb_glx_get_queryiv_arb_data(reply), xcb_glx_ge t_queryiv_arb_data_length(reply) * sizeof(GLint));
6832 free(reply);
6833 #else
6834 GLubyte const * pc = __glXSetupSingleRequest(gc, X_GLsop_GetQueryivARB, cmdlen);
6835 (void) memcpy((void *)(pc + 0), (void *)(&target), 4);
6836 (void) memcpy((void *)(pc + 4), (void *)(&pname), 4);
6837 (void) __glXReadReply(dpy, 4, params, GL_FALSE);
6838 UnlockDisplay(dpy); SyncHandle();
6839 #endif /* USE_XCB */
6840 }
6841 return;
6842 }
6843
6844 #define X_GLsop_IsQueryARB 163
6845 GLboolean __indirect_glIsQueryARB(GLuint id)
6846 {
6847 struct glx_context * const gc = __glXGetCurrentContext();
6848 Display * const dpy = gc->currentDpy;
6849 GLboolean retval = (GLboolean) 0;
6850 #ifndef USE_XCB
6851 const GLuint cmdlen = 4;
6852 #endif
6853 if (__builtin_expect(dpy != NULL, 1)) {
6854 #ifdef USE_XCB
6855 xcb_connection_t *c = XGetXCBConnection(dpy);
6856 (void) __glXFlushRenderBuffer(gc, gc->pc);
6857 xcb_glx_is_query_arb_reply_t *reply = xcb_glx_is_query_arb_reply(c, xcb_ glx_is_query_arb(c, gc->currentContextTag, id), NULL);
6858 retval = reply->ret_val;
6859 free(reply);
6860 #else
6861 GLubyte const * pc = __glXSetupSingleRequest(gc, X_GLsop_IsQueryARB, cmd len);
6862 (void) memcpy((void *)(pc + 0), (void *)(&id), 4);
6863 retval = (GLboolean) __glXReadReply(dpy, 0, NULL, GL_FALSE);
6864 UnlockDisplay(dpy); SyncHandle();
6865 #endif /* USE_XCB */
6866 }
6867 return retval;
6868 }
6869
6870 #define X_GLrop_DrawBuffersARB 233
6871 void __indirect_glDrawBuffersARB(GLsizei n, const GLenum * bufs)
6872 {
6873 struct glx_context * const gc = __glXGetCurrentContext();
6874 const GLuint cmdlen = 8 + __GLX_PAD((n * 4));
6875 if (n < 0) {
6876 __glXSetError(gc, GL_INVALID_VALUE);
6877 return;
6878 }
6879 if (__builtin_expect((n >= 0) && (gc->currentDpy != NULL), 1)) {
6880 if (cmdlen <= gc->maxSmallRenderCommandSize) {
6881 if ( (gc->pc + cmdlen) > gc->bufEnd ) {
6882 (void) __glXFlushRenderBuffer(gc, gc->pc);
6883 }
6884 emit_header(gc->pc, X_GLrop_DrawBuffersARB, cmdlen);
6885 (void) memcpy((void *)(gc->pc + 4), (void *)(&n), 4);
6886 (void) memcpy((void *)(gc->pc + 8), (void *)(bufs), (n * 4));
6887 gc->pc += cmdlen;
6888 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
6889 }
6890 else {
6891 const GLint op = X_GLrop_DrawBuffersARB;
6892 const GLuint cmdlenLarge = cmdlen + 4;
6893 GLubyte * const pc = __glXFlushRenderBuffer(gc, gc->pc);
6894 (void) memcpy((void *)(pc + 0), (void *)(&cmdlenLarge), 4);
6895 (void) memcpy((void *)(pc + 4), (void *)(&op), 4);
6896 (void) memcpy((void *)(pc + 8), (void *)(&n), 4);
6897 __glXSendLargeCommand(gc, pc, 12, bufs, (n * 4));
6898 }
6899 }
6900 }
6901
6902 #define X_GLrop_ClampColorARB 234
6903 void __indirect_glClampColorARB(GLenum target, GLenum clamp)
6904 {
6905 struct glx_context * const gc = __glXGetCurrentContext();
6906 const GLuint cmdlen = 12;
6907 emit_header(gc->pc, X_GLrop_ClampColorARB, cmdlen);
6908 (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
6909 (void) memcpy((void *)(gc->pc + 8), (void *)(&clamp), 4);
6910 gc->pc += cmdlen;
6911 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
6912 }
6913
6914 #define X_GLrop_RenderbufferStorageMultisample 4331
6915 void __indirect_glRenderbufferStorageMultisample(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height)
6916 {
6917 struct glx_context * const gc = __glXGetCurrentContext();
6918 const GLuint cmdlen = 24;
6919 emit_header(gc->pc, X_GLrop_RenderbufferStorageMultisample, cmdlen);
6920 (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
6921 (void) memcpy((void *)(gc->pc + 8), (void *)(&samples), 4);
6922 (void) memcpy((void *)(gc->pc + 12), (void *)(&internalformat), 4);
6923 (void) memcpy((void *)(gc->pc + 16), (void *)(&width), 4);
6924 (void) memcpy((void *)(gc->pc + 20), (void *)(&height), 4);
6925 gc->pc += cmdlen;
6926 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
6927 }
6928
6929 #define X_GLrop_SampleMaskSGIS 2048
6930 void __indirect_glSampleMaskSGIS(GLclampf value, GLboolean invert)
6931 {
6932 struct glx_context * const gc = __glXGetCurrentContext();
6933 const GLuint cmdlen = 12;
6934 emit_header(gc->pc, X_GLrop_SampleMaskSGIS, cmdlen);
6935 (void) memcpy((void *)(gc->pc + 4), (void *)(&value), 4);
6936 (void) memcpy((void *)(gc->pc + 8), (void *)(&invert), 1);
6937 gc->pc += cmdlen;
6938 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
6939 }
6940
6941 #define X_GLrop_SamplePatternSGIS 2049
6942 void __indirect_glSamplePatternSGIS(GLenum pattern)
6943 {
6944 struct glx_context * const gc = __glXGetCurrentContext();
6945 const GLuint cmdlen = 8;
6946 emit_header(gc->pc, X_GLrop_SamplePatternSGIS, cmdlen);
6947 (void) memcpy((void *)(gc->pc + 4), (void *)(&pattern), 4);
6948 gc->pc += cmdlen;
6949 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
6950 }
6951
6952 #define X_GLrop_PointParameterfEXT 2065
6953 void __indirect_glPointParameterfEXT(GLenum pname, GLfloat param)
6954 {
6955 struct glx_context * const gc = __glXGetCurrentContext();
6956 const GLuint cmdlen = 12;
6957 emit_header(gc->pc, X_GLrop_PointParameterfEXT, cmdlen);
6958 (void) memcpy((void *)(gc->pc + 4), (void *)(&pname), 4);
6959 (void) memcpy((void *)(gc->pc + 8), (void *)(&param), 4);
6960 gc->pc += cmdlen;
6961 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
6962 }
6963
6964 #define X_GLrop_PointParameterfvEXT 2066
6965 void __indirect_glPointParameterfvEXT(GLenum pname, const GLfloat * params)
6966 {
6967 struct glx_context * const gc = __glXGetCurrentContext();
6968 const GLuint compsize = __glPointParameterfvEXT_size(pname);
6969 const GLuint cmdlen = 8 + __GLX_PAD((compsize * 4));
6970 emit_header(gc->pc, X_GLrop_PointParameterfvEXT, cmdlen);
6971 (void) memcpy((void *)(gc->pc + 4), (void *)(&pname), 4);
6972 (void) memcpy((void *)(gc->pc + 8), (void *)(params), (compsize * 4));
6973 gc->pc += cmdlen;
6974 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
6975 }
6976
6977 #define X_GLrop_SecondaryColor3bvEXT 4126
6978 void __indirect_glSecondaryColor3bEXT(GLbyte red, GLbyte green, GLbyte blue)
6979 {
6980 struct glx_context * const gc = __glXGetCurrentContext();
6981 const GLuint cmdlen = 8;
6982 emit_header(gc->pc, X_GLrop_SecondaryColor3bvEXT, cmdlen);
6983 (void) memcpy((void *)(gc->pc + 4), (void *)(&red), 1);
6984 (void) memcpy((void *)(gc->pc + 5), (void *)(&green), 1);
6985 (void) memcpy((void *)(gc->pc + 6), (void *)(&blue), 1);
6986 gc->pc += cmdlen;
6987 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
6988 }
6989
6990 #define X_GLrop_SecondaryColor3bvEXT 4126
6991 void __indirect_glSecondaryColor3bvEXT(const GLbyte * v)
6992 {
6993 generic_3_byte( X_GLrop_SecondaryColor3bvEXT, v );
6994 }
6995
6996 #define X_GLrop_SecondaryColor3dvEXT 4130
6997 void __indirect_glSecondaryColor3dEXT(GLdouble red, GLdouble green, GLdouble blu e)
6998 {
6999 struct glx_context * const gc = __glXGetCurrentContext();
7000 const GLuint cmdlen = 28;
7001 emit_header(gc->pc, X_GLrop_SecondaryColor3dvEXT, cmdlen);
7002 (void) memcpy((void *)(gc->pc + 4), (void *)(&red), 8);
7003 (void) memcpy((void *)(gc->pc + 12), (void *)(&green), 8);
7004 (void) memcpy((void *)(gc->pc + 20), (void *)(&blue), 8);
7005 gc->pc += cmdlen;
7006 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
7007 }
7008
7009 #define X_GLrop_SecondaryColor3dvEXT 4130
7010 void __indirect_glSecondaryColor3dvEXT(const GLdouble * v)
7011 {
7012 generic_24_byte( X_GLrop_SecondaryColor3dvEXT, v );
7013 }
7014
7015 #define X_GLrop_SecondaryColor3fvEXT 4129
7016 void __indirect_glSecondaryColor3fEXT(GLfloat red, GLfloat green, GLfloat blue)
7017 {
7018 struct glx_context * const gc = __glXGetCurrentContext();
7019 const GLuint cmdlen = 16;
7020 emit_header(gc->pc, X_GLrop_SecondaryColor3fvEXT, cmdlen);
7021 (void) memcpy((void *)(gc->pc + 4), (void *)(&red), 4);
7022 (void) memcpy((void *)(gc->pc + 8), (void *)(&green), 4);
7023 (void) memcpy((void *)(gc->pc + 12), (void *)(&blue), 4);
7024 gc->pc += cmdlen;
7025 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
7026 }
7027
7028 #define X_GLrop_SecondaryColor3fvEXT 4129
7029 void __indirect_glSecondaryColor3fvEXT(const GLfloat * v)
7030 {
7031 generic_12_byte( X_GLrop_SecondaryColor3fvEXT, v );
7032 }
7033
7034 #define X_GLrop_SecondaryColor3ivEXT 4128
7035 void __indirect_glSecondaryColor3iEXT(GLint red, GLint green, GLint blue)
7036 {
7037 struct glx_context * const gc = __glXGetCurrentContext();
7038 const GLuint cmdlen = 16;
7039 emit_header(gc->pc, X_GLrop_SecondaryColor3ivEXT, cmdlen);
7040 (void) memcpy((void *)(gc->pc + 4), (void *)(&red), 4);
7041 (void) memcpy((void *)(gc->pc + 8), (void *)(&green), 4);
7042 (void) memcpy((void *)(gc->pc + 12), (void *)(&blue), 4);
7043 gc->pc += cmdlen;
7044 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
7045 }
7046
7047 #define X_GLrop_SecondaryColor3ivEXT 4128
7048 void __indirect_glSecondaryColor3ivEXT(const GLint * v)
7049 {
7050 generic_12_byte( X_GLrop_SecondaryColor3ivEXT, v );
7051 }
7052
7053 #define X_GLrop_SecondaryColor3svEXT 4127
7054 void __indirect_glSecondaryColor3sEXT(GLshort red, GLshort green, GLshort blue)
7055 {
7056 struct glx_context * const gc = __glXGetCurrentContext();
7057 const GLuint cmdlen = 12;
7058 emit_header(gc->pc, X_GLrop_SecondaryColor3svEXT, cmdlen);
7059 (void) memcpy((void *)(gc->pc + 4), (void *)(&red), 2);
7060 (void) memcpy((void *)(gc->pc + 6), (void *)(&green), 2);
7061 (void) memcpy((void *)(gc->pc + 8), (void *)(&blue), 2);
7062 gc->pc += cmdlen;
7063 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
7064 }
7065
7066 #define X_GLrop_SecondaryColor3svEXT 4127
7067 void __indirect_glSecondaryColor3svEXT(const GLshort * v)
7068 {
7069 generic_6_byte( X_GLrop_SecondaryColor3svEXT, v );
7070 }
7071
7072 #define X_GLrop_SecondaryColor3ubvEXT 4131
7073 void __indirect_glSecondaryColor3ubEXT(GLubyte red, GLubyte green, GLubyte blue)
7074 {
7075 struct glx_context * const gc = __glXGetCurrentContext();
7076 const GLuint cmdlen = 8;
7077 emit_header(gc->pc, X_GLrop_SecondaryColor3ubvEXT, cmdlen);
7078 (void) memcpy((void *)(gc->pc + 4), (void *)(&red), 1);
7079 (void) memcpy((void *)(gc->pc + 5), (void *)(&green), 1);
7080 (void) memcpy((void *)(gc->pc + 6), (void *)(&blue), 1);
7081 gc->pc += cmdlen;
7082 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
7083 }
7084
7085 #define X_GLrop_SecondaryColor3ubvEXT 4131
7086 void __indirect_glSecondaryColor3ubvEXT(const GLubyte * v)
7087 {
7088 generic_3_byte( X_GLrop_SecondaryColor3ubvEXT, v );
7089 }
7090
7091 #define X_GLrop_SecondaryColor3uivEXT 4133
7092 void __indirect_glSecondaryColor3uiEXT(GLuint red, GLuint green, GLuint blue)
7093 {
7094 struct glx_context * const gc = __glXGetCurrentContext();
7095 const GLuint cmdlen = 16;
7096 emit_header(gc->pc, X_GLrop_SecondaryColor3uivEXT, cmdlen);
7097 (void) memcpy((void *)(gc->pc + 4), (void *)(&red), 4);
7098 (void) memcpy((void *)(gc->pc + 8), (void *)(&green), 4);
7099 (void) memcpy((void *)(gc->pc + 12), (void *)(&blue), 4);
7100 gc->pc += cmdlen;
7101 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
7102 }
7103
7104 #define X_GLrop_SecondaryColor3uivEXT 4133
7105 void __indirect_glSecondaryColor3uivEXT(const GLuint * v)
7106 {
7107 generic_12_byte( X_GLrop_SecondaryColor3uivEXT, v );
7108 }
7109
7110 #define X_GLrop_SecondaryColor3usvEXT 4132
7111 void __indirect_glSecondaryColor3usEXT(GLushort red, GLushort green, GLushort bl ue)
7112 {
7113 struct glx_context * const gc = __glXGetCurrentContext();
7114 const GLuint cmdlen = 12;
7115 emit_header(gc->pc, X_GLrop_SecondaryColor3usvEXT, cmdlen);
7116 (void) memcpy((void *)(gc->pc + 4), (void *)(&red), 2);
7117 (void) memcpy((void *)(gc->pc + 6), (void *)(&green), 2);
7118 (void) memcpy((void *)(gc->pc + 8), (void *)(&blue), 2);
7119 gc->pc += cmdlen;
7120 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
7121 }
7122
7123 #define X_GLrop_SecondaryColor3usvEXT 4132
7124 void __indirect_glSecondaryColor3usvEXT(const GLushort * v)
7125 {
7126 generic_6_byte( X_GLrop_SecondaryColor3usvEXT, v );
7127 }
7128
7129 #define X_GLrop_FogCoorddvEXT 4125
7130 void __indirect_glFogCoorddEXT(GLdouble coord)
7131 {
7132 struct glx_context * const gc = __glXGetCurrentContext();
7133 const GLuint cmdlen = 12;
7134 emit_header(gc->pc, X_GLrop_FogCoorddvEXT, cmdlen);
7135 (void) memcpy((void *)(gc->pc + 4), (void *)(&coord), 8);
7136 gc->pc += cmdlen;
7137 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
7138 }
7139
7140 #define X_GLrop_FogCoorddvEXT 4125
7141 void __indirect_glFogCoorddvEXT(const GLdouble * coord)
7142 {
7143 generic_8_byte( X_GLrop_FogCoorddvEXT, coord );
7144 }
7145
7146 #define X_GLrop_FogCoordfvEXT 4124
7147 void __indirect_glFogCoordfEXT(GLfloat coord)
7148 {
7149 struct glx_context * const gc = __glXGetCurrentContext();
7150 const GLuint cmdlen = 8;
7151 emit_header(gc->pc, X_GLrop_FogCoordfvEXT, cmdlen);
7152 (void) memcpy((void *)(gc->pc + 4), (void *)(&coord), 4);
7153 gc->pc += cmdlen;
7154 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
7155 }
7156
7157 #define X_GLrop_FogCoordfvEXT 4124
7158 void __indirect_glFogCoordfvEXT(const GLfloat * coord)
7159 {
7160 generic_4_byte( X_GLrop_FogCoordfvEXT, coord );
7161 }
7162
7163 #define X_GLrop_BlendFuncSeparateEXT 4134
7164 void __indirect_glBlendFuncSeparateEXT(GLenum sfactorRGB, GLenum dfactorRGB, GLe num sfactorAlpha, GLenum dfactorAlpha)
7165 {
7166 struct glx_context * const gc = __glXGetCurrentContext();
7167 const GLuint cmdlen = 20;
7168 emit_header(gc->pc, X_GLrop_BlendFuncSeparateEXT, cmdlen);
7169 (void) memcpy((void *)(gc->pc + 4), (void *)(&sfactorRGB), 4);
7170 (void) memcpy((void *)(gc->pc + 8), (void *)(&dfactorRGB), 4);
7171 (void) memcpy((void *)(gc->pc + 12), (void *)(&sfactorAlpha), 4);
7172 (void) memcpy((void *)(gc->pc + 16), (void *)(&dfactorAlpha), 4);
7173 gc->pc += cmdlen;
7174 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
7175 }
7176
7177 #define X_GLrop_WindowPos3fvMESA 230
7178 void __indirect_glWindowPos3fMESA(GLfloat x, GLfloat y, GLfloat z)
7179 {
7180 struct glx_context * const gc = __glXGetCurrentContext();
7181 const GLuint cmdlen = 16;
7182 emit_header(gc->pc, X_GLrop_WindowPos3fvMESA, cmdlen);
7183 (void) memcpy((void *)(gc->pc + 4), (void *)(&x), 4);
7184 (void) memcpy((void *)(gc->pc + 8), (void *)(&y), 4);
7185 (void) memcpy((void *)(gc->pc + 12), (void *)(&z), 4);
7186 gc->pc += cmdlen;
7187 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
7188 }
7189
7190 #define X_GLrop_WindowPos3fvMESA 230
7191 void __indirect_glWindowPos3fvMESA(const GLfloat * v)
7192 {
7193 generic_12_byte( X_GLrop_WindowPos3fvMESA, v );
7194 }
7195
7196 #define X_GLvop_AreProgramsResidentNV 1293
7197 GLboolean __indirect_glAreProgramsResidentNV(GLsizei n, const GLuint * ids, GLbo olean * residences)
7198 {
7199 struct glx_context * const gc = __glXGetCurrentContext();
7200 Display * const dpy = gc->currentDpy;
7201 GLboolean retval = (GLboolean) 0;
7202 const GLuint cmdlen = 4 + __GLX_PAD((n * 4));
7203 if (n < 0) {
7204 __glXSetError(gc, GL_INVALID_VALUE);
7205 return 0;
7206 }
7207 if (__builtin_expect((n >= 0) && (dpy != NULL), 1)) {
7208 GLubyte const * pc = __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithR eply, X_GLvop_AreProgramsResidentNV, cmdlen);
7209 (void) memcpy((void *)(pc + 0), (void *)(&n), 4);
7210 (void) memcpy((void *)(pc + 4), (void *)(ids), (n * 4));
7211 retval = (GLboolean) __glXReadReply(dpy, 1, residences, GL_FALSE);
7212 UnlockDisplay(dpy); SyncHandle();
7213 }
7214 return retval;
7215 }
7216
7217 #define X_GLrop_BindProgramNV 4180
7218 void __indirect_glBindProgramNV(GLenum target, GLuint program)
7219 {
7220 struct glx_context * const gc = __glXGetCurrentContext();
7221 const GLuint cmdlen = 12;
7222 emit_header(gc->pc, X_GLrop_BindProgramNV, cmdlen);
7223 (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
7224 (void) memcpy((void *)(gc->pc + 8), (void *)(&program), 4);
7225 gc->pc += cmdlen;
7226 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
7227 }
7228
7229 #define X_GLvop_DeleteProgramsNV 1294
7230 void __indirect_glDeleteProgramsNV(GLsizei n, const GLuint * programs)
7231 {
7232 struct glx_context * const gc = __glXGetCurrentContext();
7233 Display * const dpy = gc->currentDpy;
7234 const GLuint cmdlen = 4 + __GLX_PAD((n * 4));
7235 if (n < 0) {
7236 __glXSetError(gc, GL_INVALID_VALUE);
7237 return;
7238 }
7239 if (__builtin_expect((n >= 0) && (dpy != NULL), 1)) {
7240 GLubyte const * pc = __glXSetupVendorRequest(gc, X_GLXVendorPrivate, X_G Lvop_DeleteProgramsNV, cmdlen);
7241 (void) memcpy((void *)(pc + 0), (void *)(&n), 4);
7242 (void) memcpy((void *)(pc + 4), (void *)(programs), (n * 4));
7243 UnlockDisplay(dpy); SyncHandle();
7244 }
7245 return;
7246 }
7247
7248 #define X_GLrop_ExecuteProgramNV 4181
7249 void __indirect_glExecuteProgramNV(GLenum target, GLuint id, const GLfloat * par ams)
7250 {
7251 struct glx_context * const gc = __glXGetCurrentContext();
7252 const GLuint cmdlen = 28;
7253 emit_header(gc->pc, X_GLrop_ExecuteProgramNV, cmdlen);
7254 (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
7255 (void) memcpy((void *)(gc->pc + 8), (void *)(&id), 4);
7256 (void) memcpy((void *)(gc->pc + 12), (void *)(params), 16);
7257 gc->pc += cmdlen;
7258 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
7259 }
7260
7261 #define X_GLvop_GenProgramsNV 1295
7262 void __indirect_glGenProgramsNV(GLsizei n, GLuint * programs)
7263 {
7264 struct glx_context * const gc = __glXGetCurrentContext();
7265 Display * const dpy = gc->currentDpy;
7266 const GLuint cmdlen = 4;
7267 if (n < 0) {
7268 __glXSetError(gc, GL_INVALID_VALUE);
7269 return;
7270 }
7271 if (__builtin_expect((n >= 0) && (dpy != NULL), 1)) {
7272 GLubyte const * pc = __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithR eply, X_GLvop_GenProgramsNV, cmdlen);
7273 (void) memcpy((void *)(pc + 0), (void *)(&n), 4);
7274 (void) __glXReadReply(dpy, 4, programs, GL_TRUE);
7275 UnlockDisplay(dpy); SyncHandle();
7276 }
7277 return;
7278 }
7279
7280 #define X_GLvop_GetProgramParameterdvNV 1297
7281 void __indirect_glGetProgramParameterdvNV(GLenum target, GLuint index, GLenum pn ame, GLdouble * params)
7282 {
7283 struct glx_context * const gc = __glXGetCurrentContext();
7284 Display * const dpy = gc->currentDpy;
7285 const GLuint cmdlen = 12;
7286 if (__builtin_expect(dpy != NULL, 1)) {
7287 GLubyte const * pc = __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithR eply, X_GLvop_GetProgramParameterdvNV, cmdlen);
7288 (void) memcpy((void *)(pc + 0), (void *)(&target), 4);
7289 (void) memcpy((void *)(pc + 4), (void *)(&index), 4);
7290 (void) memcpy((void *)(pc + 8), (void *)(&pname), 4);
7291 (void) __glXReadReply(dpy, 8, params, GL_FALSE);
7292 UnlockDisplay(dpy); SyncHandle();
7293 }
7294 return;
7295 }
7296
7297 #define X_GLvop_GetProgramParameterfvNV 1296
7298 void __indirect_glGetProgramParameterfvNV(GLenum target, GLuint index, GLenum pn ame, GLfloat * params)
7299 {
7300 struct glx_context * const gc = __glXGetCurrentContext();
7301 Display * const dpy = gc->currentDpy;
7302 const GLuint cmdlen = 12;
7303 if (__builtin_expect(dpy != NULL, 1)) {
7304 GLubyte const * pc = __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithR eply, X_GLvop_GetProgramParameterfvNV, cmdlen);
7305 (void) memcpy((void *)(pc + 0), (void *)(&target), 4);
7306 (void) memcpy((void *)(pc + 4), (void *)(&index), 4);
7307 (void) memcpy((void *)(pc + 8), (void *)(&pname), 4);
7308 (void) __glXReadReply(dpy, 4, params, GL_FALSE);
7309 UnlockDisplay(dpy); SyncHandle();
7310 }
7311 return;
7312 }
7313
7314 #define X_GLvop_GetProgramStringNV 1299
7315 void __indirect_glGetProgramStringNV(GLuint id, GLenum pname, GLubyte * program)
7316 {
7317 struct glx_context * const gc = __glXGetCurrentContext();
7318 Display * const dpy = gc->currentDpy;
7319 const GLuint cmdlen = 8;
7320 if (__builtin_expect(dpy != NULL, 1)) {
7321 GLubyte const * pc = __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithR eply, X_GLvop_GetProgramStringNV, cmdlen);
7322 (void) memcpy((void *)(pc + 0), (void *)(&id), 4);
7323 (void) memcpy((void *)(pc + 4), (void *)(&pname), 4);
7324 (void) __glXReadReply(dpy, 1, program, GL_TRUE);
7325 UnlockDisplay(dpy); SyncHandle();
7326 }
7327 return;
7328 }
7329
7330 #define X_GLvop_GetProgramivNV 1298
7331 void __indirect_glGetProgramivNV(GLuint id, GLenum pname, GLint * params)
7332 {
7333 struct glx_context * const gc = __glXGetCurrentContext();
7334 Display * const dpy = gc->currentDpy;
7335 const GLuint cmdlen = 8;
7336 if (__builtin_expect(dpy != NULL, 1)) {
7337 GLubyte const * pc = __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithR eply, X_GLvop_GetProgramivNV, cmdlen);
7338 (void) memcpy((void *)(pc + 0), (void *)(&id), 4);
7339 (void) memcpy((void *)(pc + 4), (void *)(&pname), 4);
7340 (void) __glXReadReply(dpy, 4, params, GL_FALSE);
7341 UnlockDisplay(dpy); SyncHandle();
7342 }
7343 return;
7344 }
7345
7346 #define X_GLvop_GetTrackMatrixivNV 1300
7347 void __indirect_glGetTrackMatrixivNV(GLenum target, GLuint address, GLenum pname , GLint * params)
7348 {
7349 struct glx_context * const gc = __glXGetCurrentContext();
7350 Display * const dpy = gc->currentDpy;
7351 const GLuint cmdlen = 12;
7352 if (__builtin_expect(dpy != NULL, 1)) {
7353 GLubyte const * pc = __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithR eply, X_GLvop_GetTrackMatrixivNV, cmdlen);
7354 (void) memcpy((void *)(pc + 0), (void *)(&target), 4);
7355 (void) memcpy((void *)(pc + 4), (void *)(&address), 4);
7356 (void) memcpy((void *)(pc + 8), (void *)(&pname), 4);
7357 (void) __glXReadReply(dpy, 4, params, GL_FALSE);
7358 UnlockDisplay(dpy); SyncHandle();
7359 }
7360 return;
7361 }
7362
7363 #define X_GLvop_GetVertexAttribdvNV 1301
7364 void __indirect_glGetVertexAttribdvNV(GLuint index, GLenum pname, GLdouble * par ams)
7365 {
7366 struct glx_context * const gc = __glXGetCurrentContext();
7367 Display * const dpy = gc->currentDpy;
7368 const GLuint cmdlen = 8;
7369 if (__builtin_expect(dpy != NULL, 1)) {
7370 GLubyte const * pc = __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithR eply, X_GLvop_GetVertexAttribdvNV, cmdlen);
7371 (void) memcpy((void *)(pc + 0), (void *)(&index), 4);
7372 (void) memcpy((void *)(pc + 4), (void *)(&pname), 4);
7373 (void) __glXReadReply(dpy, 8, params, GL_FALSE);
7374 UnlockDisplay(dpy); SyncHandle();
7375 }
7376 return;
7377 }
7378
7379 #define X_GLvop_GetVertexAttribfvNV 1302
7380 void __indirect_glGetVertexAttribfvNV(GLuint index, GLenum pname, GLfloat * para ms)
7381 {
7382 struct glx_context * const gc = __glXGetCurrentContext();
7383 Display * const dpy = gc->currentDpy;
7384 const GLuint cmdlen = 8;
7385 if (__builtin_expect(dpy != NULL, 1)) {
7386 GLubyte const * pc = __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithR eply, X_GLvop_GetVertexAttribfvNV, cmdlen);
7387 (void) memcpy((void *)(pc + 0), (void *)(&index), 4);
7388 (void) memcpy((void *)(pc + 4), (void *)(&pname), 4);
7389 (void) __glXReadReply(dpy, 4, params, GL_FALSE);
7390 UnlockDisplay(dpy); SyncHandle();
7391 }
7392 return;
7393 }
7394
7395 #define X_GLvop_GetVertexAttribivNV 1303
7396 void __indirect_glGetVertexAttribivNV(GLuint index, GLenum pname, GLint * params )
7397 {
7398 struct glx_context * const gc = __glXGetCurrentContext();
7399 Display * const dpy = gc->currentDpy;
7400 const GLuint cmdlen = 8;
7401 if (__builtin_expect(dpy != NULL, 1)) {
7402 GLubyte const * pc = __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithR eply, X_GLvop_GetVertexAttribivNV, cmdlen);
7403 (void) memcpy((void *)(pc + 0), (void *)(&index), 4);
7404 (void) memcpy((void *)(pc + 4), (void *)(&pname), 4);
7405 (void) __glXReadReply(dpy, 4, params, GL_FALSE);
7406 UnlockDisplay(dpy); SyncHandle();
7407 }
7408 return;
7409 }
7410
7411 #define X_GLvop_IsProgramNV 1304
7412 GLboolean __indirect_glIsProgramNV(GLuint program)
7413 {
7414 struct glx_context * const gc = __glXGetCurrentContext();
7415 Display * const dpy = gc->currentDpy;
7416 GLboolean retval = (GLboolean) 0;
7417 const GLuint cmdlen = 4;
7418 if (__builtin_expect(dpy != NULL, 1)) {
7419 GLubyte const * pc = __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithR eply, X_GLvop_IsProgramNV, cmdlen);
7420 (void) memcpy((void *)(pc + 0), (void *)(&program), 4);
7421 retval = (GLboolean) __glXReadReply(dpy, 0, NULL, GL_FALSE);
7422 UnlockDisplay(dpy); SyncHandle();
7423 }
7424 return retval;
7425 }
7426
7427 #define X_GLrop_LoadProgramNV 4183
7428 void __indirect_glLoadProgramNV(GLenum target, GLuint id, GLsizei len, const GLu byte * program)
7429 {
7430 struct glx_context * const gc = __glXGetCurrentContext();
7431 const GLuint cmdlen = 16 + __GLX_PAD(len);
7432 if (len < 0) {
7433 __glXSetError(gc, GL_INVALID_VALUE);
7434 return;
7435 }
7436 if (__builtin_expect(len >= 0, 1)) {
7437 emit_header(gc->pc, X_GLrop_LoadProgramNV, cmdlen);
7438 (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
7439 (void) memcpy((void *)(gc->pc + 8), (void *)(&id), 4);
7440 (void) memcpy((void *)(gc->pc + 12), (void *)(&len), 4);
7441 (void) memcpy((void *)(gc->pc + 16), (void *)(program), len);
7442 gc->pc += cmdlen;
7443 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
7444 }
7445 }
7446
7447 #define X_GLrop_ProgramParameters4dvNV 4187
7448 void __indirect_glProgramParameters4dvNV(GLenum target, GLuint index, GLsizei nu m, const GLdouble * params)
7449 {
7450 struct glx_context * const gc = __glXGetCurrentContext();
7451 const GLuint cmdlen = 16 + __GLX_PAD((num * 32));
7452 if (num < 0) {
7453 __glXSetError(gc, GL_INVALID_VALUE);
7454 return;
7455 }
7456 if (__builtin_expect(num >= 0, 1)) {
7457 emit_header(gc->pc, X_GLrop_ProgramParameters4dvNV, cmdlen);
7458 (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
7459 (void) memcpy((void *)(gc->pc + 8), (void *)(&index), 4);
7460 (void) memcpy((void *)(gc->pc + 12), (void *)(&num), 4);
7461 (void) memcpy((void *)(gc->pc + 16), (void *)(params), (num * 32));
7462 gc->pc += cmdlen;
7463 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
7464 }
7465 }
7466
7467 #define X_GLrop_ProgramParameters4fvNV 4186
7468 void __indirect_glProgramParameters4fvNV(GLenum target, GLuint index, GLsizei nu m, const GLfloat * params)
7469 {
7470 struct glx_context * const gc = __glXGetCurrentContext();
7471 const GLuint cmdlen = 16 + __GLX_PAD((num * 16));
7472 if (num < 0) {
7473 __glXSetError(gc, GL_INVALID_VALUE);
7474 return;
7475 }
7476 if (__builtin_expect(num >= 0, 1)) {
7477 emit_header(gc->pc, X_GLrop_ProgramParameters4fvNV, cmdlen);
7478 (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
7479 (void) memcpy((void *)(gc->pc + 8), (void *)(&index), 4);
7480 (void) memcpy((void *)(gc->pc + 12), (void *)(&num), 4);
7481 (void) memcpy((void *)(gc->pc + 16), (void *)(params), (num * 16));
7482 gc->pc += cmdlen;
7483 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
7484 }
7485 }
7486
7487 #define X_GLrop_RequestResidentProgramsNV 4182
7488 void __indirect_glRequestResidentProgramsNV(GLsizei n, const GLuint * ids)
7489 {
7490 struct glx_context * const gc = __glXGetCurrentContext();
7491 const GLuint cmdlen = 8 + __GLX_PAD((n * 4));
7492 if (n < 0) {
7493 __glXSetError(gc, GL_INVALID_VALUE);
7494 return;
7495 }
7496 if (__builtin_expect(n >= 0, 1)) {
7497 emit_header(gc->pc, X_GLrop_RequestResidentProgramsNV, cmdlen);
7498 (void) memcpy((void *)(gc->pc + 4), (void *)(&n), 4);
7499 (void) memcpy((void *)(gc->pc + 8), (void *)(ids), (n * 4));
7500 gc->pc += cmdlen;
7501 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
7502 }
7503 }
7504
7505 #define X_GLrop_TrackMatrixNV 4188
7506 void __indirect_glTrackMatrixNV(GLenum target, GLuint address, GLenum matrix, GL enum transform)
7507 {
7508 struct glx_context * const gc = __glXGetCurrentContext();
7509 const GLuint cmdlen = 20;
7510 emit_header(gc->pc, X_GLrop_TrackMatrixNV, cmdlen);
7511 (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
7512 (void) memcpy((void *)(gc->pc + 8), (void *)(&address), 4);
7513 (void) memcpy((void *)(gc->pc + 12), (void *)(&matrix), 4);
7514 (void) memcpy((void *)(gc->pc + 16), (void *)(&transform), 4);
7515 gc->pc += cmdlen;
7516 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
7517 }
7518
7519 #define X_GLrop_VertexAttrib1dvNV 4273
7520 void __indirect_glVertexAttrib1dNV(GLuint index, GLdouble x)
7521 {
7522 struct glx_context * const gc = __glXGetCurrentContext();
7523 const GLuint cmdlen = 16;
7524 emit_header(gc->pc, X_GLrop_VertexAttrib1dvNV, cmdlen);
7525 (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
7526 (void) memcpy((void *)(gc->pc + 8), (void *)(&x), 8);
7527 gc->pc += cmdlen;
7528 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
7529 }
7530
7531 #define X_GLrop_VertexAttrib1dvNV 4273
7532 void __indirect_glVertexAttrib1dvNV(GLuint index, const GLdouble * v)
7533 {
7534 struct glx_context * const gc = __glXGetCurrentContext();
7535 const GLuint cmdlen = 16;
7536 emit_header(gc->pc, X_GLrop_VertexAttrib1dvNV, cmdlen);
7537 (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
7538 (void) memcpy((void *)(gc->pc + 8), (void *)(v), 8);
7539 gc->pc += cmdlen;
7540 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
7541 }
7542
7543 #define X_GLrop_VertexAttrib1fvNV 4269
7544 void __indirect_glVertexAttrib1fNV(GLuint index, GLfloat x)
7545 {
7546 struct glx_context * const gc = __glXGetCurrentContext();
7547 const GLuint cmdlen = 12;
7548 emit_header(gc->pc, X_GLrop_VertexAttrib1fvNV, cmdlen);
7549 (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
7550 (void) memcpy((void *)(gc->pc + 8), (void *)(&x), 4);
7551 gc->pc += cmdlen;
7552 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
7553 }
7554
7555 #define X_GLrop_VertexAttrib1fvNV 4269
7556 void __indirect_glVertexAttrib1fvNV(GLuint index, const GLfloat * v)
7557 {
7558 struct glx_context * const gc = __glXGetCurrentContext();
7559 const GLuint cmdlen = 12;
7560 emit_header(gc->pc, X_GLrop_VertexAttrib1fvNV, cmdlen);
7561 (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
7562 (void) memcpy((void *)(gc->pc + 8), (void *)(v), 4);
7563 gc->pc += cmdlen;
7564 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
7565 }
7566
7567 #define X_GLrop_VertexAttrib1svNV 4265
7568 void __indirect_glVertexAttrib1sNV(GLuint index, GLshort x)
7569 {
7570 struct glx_context * const gc = __glXGetCurrentContext();
7571 const GLuint cmdlen = 12;
7572 emit_header(gc->pc, X_GLrop_VertexAttrib1svNV, cmdlen);
7573 (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
7574 (void) memcpy((void *)(gc->pc + 8), (void *)(&x), 2);
7575 gc->pc += cmdlen;
7576 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
7577 }
7578
7579 #define X_GLrop_VertexAttrib1svNV 4265
7580 void __indirect_glVertexAttrib1svNV(GLuint index, const GLshort * v)
7581 {
7582 struct glx_context * const gc = __glXGetCurrentContext();
7583 const GLuint cmdlen = 12;
7584 emit_header(gc->pc, X_GLrop_VertexAttrib1svNV, cmdlen);
7585 (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
7586 (void) memcpy((void *)(gc->pc + 8), (void *)(v), 2);
7587 gc->pc += cmdlen;
7588 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
7589 }
7590
7591 #define X_GLrop_VertexAttrib2dvNV 4274
7592 void __indirect_glVertexAttrib2dNV(GLuint index, GLdouble x, GLdouble y)
7593 {
7594 struct glx_context * const gc = __glXGetCurrentContext();
7595 const GLuint cmdlen = 24;
7596 emit_header(gc->pc, X_GLrop_VertexAttrib2dvNV, cmdlen);
7597 (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
7598 (void) memcpy((void *)(gc->pc + 8), (void *)(&x), 8);
7599 (void) memcpy((void *)(gc->pc + 16), (void *)(&y), 8);
7600 gc->pc += cmdlen;
7601 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
7602 }
7603
7604 #define X_GLrop_VertexAttrib2dvNV 4274
7605 void __indirect_glVertexAttrib2dvNV(GLuint index, const GLdouble * v)
7606 {
7607 struct glx_context * const gc = __glXGetCurrentContext();
7608 const GLuint cmdlen = 24;
7609 emit_header(gc->pc, X_GLrop_VertexAttrib2dvNV, cmdlen);
7610 (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
7611 (void) memcpy((void *)(gc->pc + 8), (void *)(v), 16);
7612 gc->pc += cmdlen;
7613 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
7614 }
7615
7616 #define X_GLrop_VertexAttrib2fvNV 4270
7617 void __indirect_glVertexAttrib2fNV(GLuint index, GLfloat x, GLfloat y)
7618 {
7619 struct glx_context * const gc = __glXGetCurrentContext();
7620 const GLuint cmdlen = 16;
7621 emit_header(gc->pc, X_GLrop_VertexAttrib2fvNV, cmdlen);
7622 (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
7623 (void) memcpy((void *)(gc->pc + 8), (void *)(&x), 4);
7624 (void) memcpy((void *)(gc->pc + 12), (void *)(&y), 4);
7625 gc->pc += cmdlen;
7626 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
7627 }
7628
7629 #define X_GLrop_VertexAttrib2fvNV 4270
7630 void __indirect_glVertexAttrib2fvNV(GLuint index, const GLfloat * v)
7631 {
7632 struct glx_context * const gc = __glXGetCurrentContext();
7633 const GLuint cmdlen = 16;
7634 emit_header(gc->pc, X_GLrop_VertexAttrib2fvNV, cmdlen);
7635 (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
7636 (void) memcpy((void *)(gc->pc + 8), (void *)(v), 8);
7637 gc->pc += cmdlen;
7638 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
7639 }
7640
7641 #define X_GLrop_VertexAttrib2svNV 4266
7642 void __indirect_glVertexAttrib2sNV(GLuint index, GLshort x, GLshort y)
7643 {
7644 struct glx_context * const gc = __glXGetCurrentContext();
7645 const GLuint cmdlen = 12;
7646 emit_header(gc->pc, X_GLrop_VertexAttrib2svNV, cmdlen);
7647 (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
7648 (void) memcpy((void *)(gc->pc + 8), (void *)(&x), 2);
7649 (void) memcpy((void *)(gc->pc + 10), (void *)(&y), 2);
7650 gc->pc += cmdlen;
7651 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
7652 }
7653
7654 #define X_GLrop_VertexAttrib2svNV 4266
7655 void __indirect_glVertexAttrib2svNV(GLuint index, const GLshort * v)
7656 {
7657 struct glx_context * const gc = __glXGetCurrentContext();
7658 const GLuint cmdlen = 12;
7659 emit_header(gc->pc, X_GLrop_VertexAttrib2svNV, cmdlen);
7660 (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
7661 (void) memcpy((void *)(gc->pc + 8), (void *)(v), 4);
7662 gc->pc += cmdlen;
7663 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
7664 }
7665
7666 #define X_GLrop_VertexAttrib3dvNV 4275
7667 void __indirect_glVertexAttrib3dNV(GLuint index, GLdouble x, GLdouble y, GLdoubl e z)
7668 {
7669 struct glx_context * const gc = __glXGetCurrentContext();
7670 const GLuint cmdlen = 32;
7671 emit_header(gc->pc, X_GLrop_VertexAttrib3dvNV, cmdlen);
7672 (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
7673 (void) memcpy((void *)(gc->pc + 8), (void *)(&x), 8);
7674 (void) memcpy((void *)(gc->pc + 16), (void *)(&y), 8);
7675 (void) memcpy((void *)(gc->pc + 24), (void *)(&z), 8);
7676 gc->pc += cmdlen;
7677 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
7678 }
7679
7680 #define X_GLrop_VertexAttrib3dvNV 4275
7681 void __indirect_glVertexAttrib3dvNV(GLuint index, const GLdouble * v)
7682 {
7683 struct glx_context * const gc = __glXGetCurrentContext();
7684 const GLuint cmdlen = 32;
7685 emit_header(gc->pc, X_GLrop_VertexAttrib3dvNV, cmdlen);
7686 (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
7687 (void) memcpy((void *)(gc->pc + 8), (void *)(v), 24);
7688 gc->pc += cmdlen;
7689 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
7690 }
7691
7692 #define X_GLrop_VertexAttrib3fvNV 4271
7693 void __indirect_glVertexAttrib3fNV(GLuint index, GLfloat x, GLfloat y, GLfloat z )
7694 {
7695 struct glx_context * const gc = __glXGetCurrentContext();
7696 const GLuint cmdlen = 20;
7697 emit_header(gc->pc, X_GLrop_VertexAttrib3fvNV, cmdlen);
7698 (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
7699 (void) memcpy((void *)(gc->pc + 8), (void *)(&x), 4);
7700 (void) memcpy((void *)(gc->pc + 12), (void *)(&y), 4);
7701 (void) memcpy((void *)(gc->pc + 16), (void *)(&z), 4);
7702 gc->pc += cmdlen;
7703 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
7704 }
7705
7706 #define X_GLrop_VertexAttrib3fvNV 4271
7707 void __indirect_glVertexAttrib3fvNV(GLuint index, const GLfloat * v)
7708 {
7709 struct glx_context * const gc = __glXGetCurrentContext();
7710 const GLuint cmdlen = 20;
7711 emit_header(gc->pc, X_GLrop_VertexAttrib3fvNV, cmdlen);
7712 (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
7713 (void) memcpy((void *)(gc->pc + 8), (void *)(v), 12);
7714 gc->pc += cmdlen;
7715 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
7716 }
7717
7718 #define X_GLrop_VertexAttrib3svNV 4267
7719 void __indirect_glVertexAttrib3sNV(GLuint index, GLshort x, GLshort y, GLshort z )
7720 {
7721 struct glx_context * const gc = __glXGetCurrentContext();
7722 const GLuint cmdlen = 16;
7723 emit_header(gc->pc, X_GLrop_VertexAttrib3svNV, cmdlen);
7724 (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
7725 (void) memcpy((void *)(gc->pc + 8), (void *)(&x), 2);
7726 (void) memcpy((void *)(gc->pc + 10), (void *)(&y), 2);
7727 (void) memcpy((void *)(gc->pc + 12), (void *)(&z), 2);
7728 gc->pc += cmdlen;
7729 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
7730 }
7731
7732 #define X_GLrop_VertexAttrib3svNV 4267
7733 void __indirect_glVertexAttrib3svNV(GLuint index, const GLshort * v)
7734 {
7735 struct glx_context * const gc = __glXGetCurrentContext();
7736 const GLuint cmdlen = 16;
7737 emit_header(gc->pc, X_GLrop_VertexAttrib3svNV, cmdlen);
7738 (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
7739 (void) memcpy((void *)(gc->pc + 8), (void *)(v), 6);
7740 gc->pc += cmdlen;
7741 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
7742 }
7743
7744 #define X_GLrop_VertexAttrib4dvNV 4276
7745 void __indirect_glVertexAttrib4dNV(GLuint index, GLdouble x, GLdouble y, GLdoubl e z, GLdouble w)
7746 {
7747 struct glx_context * const gc = __glXGetCurrentContext();
7748 const GLuint cmdlen = 40;
7749 emit_header(gc->pc, X_GLrop_VertexAttrib4dvNV, cmdlen);
7750 (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
7751 (void) memcpy((void *)(gc->pc + 8), (void *)(&x), 8);
7752 (void) memcpy((void *)(gc->pc + 16), (void *)(&y), 8);
7753 (void) memcpy((void *)(gc->pc + 24), (void *)(&z), 8);
7754 (void) memcpy((void *)(gc->pc + 32), (void *)(&w), 8);
7755 gc->pc += cmdlen;
7756 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
7757 }
7758
7759 #define X_GLrop_VertexAttrib4dvNV 4276
7760 void __indirect_glVertexAttrib4dvNV(GLuint index, const GLdouble * v)
7761 {
7762 struct glx_context * const gc = __glXGetCurrentContext();
7763 const GLuint cmdlen = 40;
7764 emit_header(gc->pc, X_GLrop_VertexAttrib4dvNV, cmdlen);
7765 (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
7766 (void) memcpy((void *)(gc->pc + 8), (void *)(v), 32);
7767 gc->pc += cmdlen;
7768 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
7769 }
7770
7771 #define X_GLrop_VertexAttrib4fvNV 4272
7772 void __indirect_glVertexAttrib4fNV(GLuint index, GLfloat x, GLfloat y, GLfloat z , GLfloat w)
7773 {
7774 struct glx_context * const gc = __glXGetCurrentContext();
7775 const GLuint cmdlen = 24;
7776 emit_header(gc->pc, X_GLrop_VertexAttrib4fvNV, cmdlen);
7777 (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
7778 (void) memcpy((void *)(gc->pc + 8), (void *)(&x), 4);
7779 (void) memcpy((void *)(gc->pc + 12), (void *)(&y), 4);
7780 (void) memcpy((void *)(gc->pc + 16), (void *)(&z), 4);
7781 (void) memcpy((void *)(gc->pc + 20), (void *)(&w), 4);
7782 gc->pc += cmdlen;
7783 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
7784 }
7785
7786 #define X_GLrop_VertexAttrib4fvNV 4272
7787 void __indirect_glVertexAttrib4fvNV(GLuint index, const GLfloat * v)
7788 {
7789 struct glx_context * const gc = __glXGetCurrentContext();
7790 const GLuint cmdlen = 24;
7791 emit_header(gc->pc, X_GLrop_VertexAttrib4fvNV, cmdlen);
7792 (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
7793 (void) memcpy((void *)(gc->pc + 8), (void *)(v), 16);
7794 gc->pc += cmdlen;
7795 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
7796 }
7797
7798 #define X_GLrop_VertexAttrib4svNV 4268
7799 void __indirect_glVertexAttrib4sNV(GLuint index, GLshort x, GLshort y, GLshort z , GLshort w)
7800 {
7801 struct glx_context * const gc = __glXGetCurrentContext();
7802 const GLuint cmdlen = 16;
7803 emit_header(gc->pc, X_GLrop_VertexAttrib4svNV, cmdlen);
7804 (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
7805 (void) memcpy((void *)(gc->pc + 8), (void *)(&x), 2);
7806 (void) memcpy((void *)(gc->pc + 10), (void *)(&y), 2);
7807 (void) memcpy((void *)(gc->pc + 12), (void *)(&z), 2);
7808 (void) memcpy((void *)(gc->pc + 14), (void *)(&w), 2);
7809 gc->pc += cmdlen;
7810 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
7811 }
7812
7813 #define X_GLrop_VertexAttrib4svNV 4268
7814 void __indirect_glVertexAttrib4svNV(GLuint index, const GLshort * v)
7815 {
7816 struct glx_context * const gc = __glXGetCurrentContext();
7817 const GLuint cmdlen = 16;
7818 emit_header(gc->pc, X_GLrop_VertexAttrib4svNV, cmdlen);
7819 (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
7820 (void) memcpy((void *)(gc->pc + 8), (void *)(v), 8);
7821 gc->pc += cmdlen;
7822 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
7823 }
7824
7825 #define X_GLrop_VertexAttrib4ubvNV 4277
7826 void __indirect_glVertexAttrib4ubNV(GLuint index, GLubyte x, GLubyte y, GLubyte z, GLubyte w)
7827 {
7828 struct glx_context * const gc = __glXGetCurrentContext();
7829 const GLuint cmdlen = 12;
7830 emit_header(gc->pc, X_GLrop_VertexAttrib4ubvNV, cmdlen);
7831 (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
7832 (void) memcpy((void *)(gc->pc + 8), (void *)(&x), 1);
7833 (void) memcpy((void *)(gc->pc + 9), (void *)(&y), 1);
7834 (void) memcpy((void *)(gc->pc + 10), (void *)(&z), 1);
7835 (void) memcpy((void *)(gc->pc + 11), (void *)(&w), 1);
7836 gc->pc += cmdlen;
7837 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
7838 }
7839
7840 #define X_GLrop_VertexAttrib4ubvNV 4277
7841 void __indirect_glVertexAttrib4ubvNV(GLuint index, const GLubyte * v)
7842 {
7843 struct glx_context * const gc = __glXGetCurrentContext();
7844 const GLuint cmdlen = 12;
7845 emit_header(gc->pc, X_GLrop_VertexAttrib4ubvNV, cmdlen);
7846 (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
7847 (void) memcpy((void *)(gc->pc + 8), (void *)(v), 4);
7848 gc->pc += cmdlen;
7849 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
7850 }
7851
7852 #define X_GLrop_VertexAttribs1dvNV 4210
7853 void __indirect_glVertexAttribs1dvNV(GLuint index, GLsizei n, const GLdouble * v )
7854 {
7855 struct glx_context * const gc = __glXGetCurrentContext();
7856 const GLuint cmdlen = 12 + __GLX_PAD((n * 8));
7857 if (n < 0) {
7858 __glXSetError(gc, GL_INVALID_VALUE);
7859 return;
7860 }
7861 if (__builtin_expect(n >= 0, 1)) {
7862 emit_header(gc->pc, X_GLrop_VertexAttribs1dvNV, cmdlen);
7863 (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
7864 (void) memcpy((void *)(gc->pc + 8), (void *)(&n), 4);
7865 (void) memcpy((void *)(gc->pc + 12), (void *)(v), (n * 8));
7866 gc->pc += cmdlen;
7867 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
7868 }
7869 }
7870
7871 #define X_GLrop_VertexAttribs1fvNV 4206
7872 void __indirect_glVertexAttribs1fvNV(GLuint index, GLsizei n, const GLfloat * v)
7873 {
7874 struct glx_context * const gc = __glXGetCurrentContext();
7875 const GLuint cmdlen = 12 + __GLX_PAD((n * 4));
7876 if (n < 0) {
7877 __glXSetError(gc, GL_INVALID_VALUE);
7878 return;
7879 }
7880 if (__builtin_expect(n >= 0, 1)) {
7881 emit_header(gc->pc, X_GLrop_VertexAttribs1fvNV, cmdlen);
7882 (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
7883 (void) memcpy((void *)(gc->pc + 8), (void *)(&n), 4);
7884 (void) memcpy((void *)(gc->pc + 12), (void *)(v), (n * 4));
7885 gc->pc += cmdlen;
7886 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
7887 }
7888 }
7889
7890 #define X_GLrop_VertexAttribs1svNV 4202
7891 void __indirect_glVertexAttribs1svNV(GLuint index, GLsizei n, const GLshort * v)
7892 {
7893 struct glx_context * const gc = __glXGetCurrentContext();
7894 const GLuint cmdlen = 12 + __GLX_PAD((n * 2));
7895 if (n < 0) {
7896 __glXSetError(gc, GL_INVALID_VALUE);
7897 return;
7898 }
7899 if (__builtin_expect(n >= 0, 1)) {
7900 emit_header(gc->pc, X_GLrop_VertexAttribs1svNV, cmdlen);
7901 (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
7902 (void) memcpy((void *)(gc->pc + 8), (void *)(&n), 4);
7903 (void) memcpy((void *)(gc->pc + 12), (void *)(v), (n * 2));
7904 gc->pc += cmdlen;
7905 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
7906 }
7907 }
7908
7909 #define X_GLrop_VertexAttribs2dvNV 4211
7910 void __indirect_glVertexAttribs2dvNV(GLuint index, GLsizei n, const GLdouble * v )
7911 {
7912 struct glx_context * const gc = __glXGetCurrentContext();
7913 const GLuint cmdlen = 12 + __GLX_PAD((n * 16));
7914 if (n < 0) {
7915 __glXSetError(gc, GL_INVALID_VALUE);
7916 return;
7917 }
7918 if (__builtin_expect(n >= 0, 1)) {
7919 emit_header(gc->pc, X_GLrop_VertexAttribs2dvNV, cmdlen);
7920 (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
7921 (void) memcpy((void *)(gc->pc + 8), (void *)(&n), 4);
7922 (void) memcpy((void *)(gc->pc + 12), (void *)(v), (n * 16));
7923 gc->pc += cmdlen;
7924 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
7925 }
7926 }
7927
7928 #define X_GLrop_VertexAttribs2fvNV 4207
7929 void __indirect_glVertexAttribs2fvNV(GLuint index, GLsizei n, const GLfloat * v)
7930 {
7931 struct glx_context * const gc = __glXGetCurrentContext();
7932 const GLuint cmdlen = 12 + __GLX_PAD((n * 8));
7933 if (n < 0) {
7934 __glXSetError(gc, GL_INVALID_VALUE);
7935 return;
7936 }
7937 if (__builtin_expect(n >= 0, 1)) {
7938 emit_header(gc->pc, X_GLrop_VertexAttribs2fvNV, cmdlen);
7939 (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
7940 (void) memcpy((void *)(gc->pc + 8), (void *)(&n), 4);
7941 (void) memcpy((void *)(gc->pc + 12), (void *)(v), (n * 8));
7942 gc->pc += cmdlen;
7943 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
7944 }
7945 }
7946
7947 #define X_GLrop_VertexAttribs2svNV 4203
7948 void __indirect_glVertexAttribs2svNV(GLuint index, GLsizei n, const GLshort * v)
7949 {
7950 struct glx_context * const gc = __glXGetCurrentContext();
7951 const GLuint cmdlen = 12 + __GLX_PAD((n * 4));
7952 if (n < 0) {
7953 __glXSetError(gc, GL_INVALID_VALUE);
7954 return;
7955 }
7956 if (__builtin_expect(n >= 0, 1)) {
7957 emit_header(gc->pc, X_GLrop_VertexAttribs2svNV, cmdlen);
7958 (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
7959 (void) memcpy((void *)(gc->pc + 8), (void *)(&n), 4);
7960 (void) memcpy((void *)(gc->pc + 12), (void *)(v), (n * 4));
7961 gc->pc += cmdlen;
7962 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
7963 }
7964 }
7965
7966 #define X_GLrop_VertexAttribs3dvNV 4212
7967 void __indirect_glVertexAttribs3dvNV(GLuint index, GLsizei n, const GLdouble * v )
7968 {
7969 struct glx_context * const gc = __glXGetCurrentContext();
7970 const GLuint cmdlen = 12 + __GLX_PAD((n * 24));
7971 if (n < 0) {
7972 __glXSetError(gc, GL_INVALID_VALUE);
7973 return;
7974 }
7975 if (__builtin_expect(n >= 0, 1)) {
7976 emit_header(gc->pc, X_GLrop_VertexAttribs3dvNV, cmdlen);
7977 (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
7978 (void) memcpy((void *)(gc->pc + 8), (void *)(&n), 4);
7979 (void) memcpy((void *)(gc->pc + 12), (void *)(v), (n * 24));
7980 gc->pc += cmdlen;
7981 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
7982 }
7983 }
7984
7985 #define X_GLrop_VertexAttribs3fvNV 4208
7986 void __indirect_glVertexAttribs3fvNV(GLuint index, GLsizei n, const GLfloat * v)
7987 {
7988 struct glx_context * const gc = __glXGetCurrentContext();
7989 const GLuint cmdlen = 12 + __GLX_PAD((n * 12));
7990 if (n < 0) {
7991 __glXSetError(gc, GL_INVALID_VALUE);
7992 return;
7993 }
7994 if (__builtin_expect(n >= 0, 1)) {
7995 emit_header(gc->pc, X_GLrop_VertexAttribs3fvNV, cmdlen);
7996 (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
7997 (void) memcpy((void *)(gc->pc + 8), (void *)(&n), 4);
7998 (void) memcpy((void *)(gc->pc + 12), (void *)(v), (n * 12));
7999 gc->pc += cmdlen;
8000 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
8001 }
8002 }
8003
8004 #define X_GLrop_VertexAttribs3svNV 4204
8005 void __indirect_glVertexAttribs3svNV(GLuint index, GLsizei n, const GLshort * v)
8006 {
8007 struct glx_context * const gc = __glXGetCurrentContext();
8008 const GLuint cmdlen = 12 + __GLX_PAD((n * 6));
8009 if (n < 0) {
8010 __glXSetError(gc, GL_INVALID_VALUE);
8011 return;
8012 }
8013 if (__builtin_expect(n >= 0, 1)) {
8014 emit_header(gc->pc, X_GLrop_VertexAttribs3svNV, cmdlen);
8015 (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
8016 (void) memcpy((void *)(gc->pc + 8), (void *)(&n), 4);
8017 (void) memcpy((void *)(gc->pc + 12), (void *)(v), (n * 6));
8018 gc->pc += cmdlen;
8019 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
8020 }
8021 }
8022
8023 #define X_GLrop_VertexAttribs4dvNV 4213
8024 void __indirect_glVertexAttribs4dvNV(GLuint index, GLsizei n, const GLdouble * v )
8025 {
8026 struct glx_context * const gc = __glXGetCurrentContext();
8027 const GLuint cmdlen = 12 + __GLX_PAD((n * 32));
8028 if (n < 0) {
8029 __glXSetError(gc, GL_INVALID_VALUE);
8030 return;
8031 }
8032 if (__builtin_expect(n >= 0, 1)) {
8033 emit_header(gc->pc, X_GLrop_VertexAttribs4dvNV, cmdlen);
8034 (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
8035 (void) memcpy((void *)(gc->pc + 8), (void *)(&n), 4);
8036 (void) memcpy((void *)(gc->pc + 12), (void *)(v), (n * 32));
8037 gc->pc += cmdlen;
8038 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
8039 }
8040 }
8041
8042 #define X_GLrop_VertexAttribs4fvNV 4209
8043 void __indirect_glVertexAttribs4fvNV(GLuint index, GLsizei n, const GLfloat * v)
8044 {
8045 struct glx_context * const gc = __glXGetCurrentContext();
8046 const GLuint cmdlen = 12 + __GLX_PAD((n * 16));
8047 if (n < 0) {
8048 __glXSetError(gc, GL_INVALID_VALUE);
8049 return;
8050 }
8051 if (__builtin_expect(n >= 0, 1)) {
8052 emit_header(gc->pc, X_GLrop_VertexAttribs4fvNV, cmdlen);
8053 (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
8054 (void) memcpy((void *)(gc->pc + 8), (void *)(&n), 4);
8055 (void) memcpy((void *)(gc->pc + 12), (void *)(v), (n * 16));
8056 gc->pc += cmdlen;
8057 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
8058 }
8059 }
8060
8061 #define X_GLrop_VertexAttribs4svNV 4205
8062 void __indirect_glVertexAttribs4svNV(GLuint index, GLsizei n, const GLshort * v)
8063 {
8064 struct glx_context * const gc = __glXGetCurrentContext();
8065 const GLuint cmdlen = 12 + __GLX_PAD((n * 8));
8066 if (n < 0) {
8067 __glXSetError(gc, GL_INVALID_VALUE);
8068 return;
8069 }
8070 if (__builtin_expect(n >= 0, 1)) {
8071 emit_header(gc->pc, X_GLrop_VertexAttribs4svNV, cmdlen);
8072 (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
8073 (void) memcpy((void *)(gc->pc + 8), (void *)(&n), 4);
8074 (void) memcpy((void *)(gc->pc + 12), (void *)(v), (n * 8));
8075 gc->pc += cmdlen;
8076 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
8077 }
8078 }
8079
8080 #define X_GLrop_VertexAttribs4ubvNV 4214
8081 void __indirect_glVertexAttribs4ubvNV(GLuint index, GLsizei n, const GLubyte * v )
8082 {
8083 struct glx_context * const gc = __glXGetCurrentContext();
8084 const GLuint cmdlen = 12 + __GLX_PAD((n * 4));
8085 if (n < 0) {
8086 __glXSetError(gc, GL_INVALID_VALUE);
8087 return;
8088 }
8089 if (__builtin_expect(n >= 0, 1)) {
8090 emit_header(gc->pc, X_GLrop_VertexAttribs4ubvNV, cmdlen);
8091 (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
8092 (void) memcpy((void *)(gc->pc + 8), (void *)(&n), 4);
8093 (void) memcpy((void *)(gc->pc + 12), (void *)(v), (n * 4));
8094 gc->pc += cmdlen;
8095 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
8096 }
8097 }
8098
8099 #define X_GLrop_PointParameteriNV 4221
8100 void __indirect_glPointParameteriNV(GLenum pname, GLint param)
8101 {
8102 struct glx_context * const gc = __glXGetCurrentContext();
8103 const GLuint cmdlen = 12;
8104 emit_header(gc->pc, X_GLrop_PointParameteriNV, cmdlen);
8105 (void) memcpy((void *)(gc->pc + 4), (void *)(&pname), 4);
8106 (void) memcpy((void *)(gc->pc + 8), (void *)(&param), 4);
8107 gc->pc += cmdlen;
8108 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
8109 }
8110
8111 #define X_GLrop_PointParameterivNV 4222
8112 void __indirect_glPointParameterivNV(GLenum pname, const GLint * params)
8113 {
8114 struct glx_context * const gc = __glXGetCurrentContext();
8115 const GLuint compsize = __glPointParameterivNV_size(pname);
8116 const GLuint cmdlen = 8 + __GLX_PAD((compsize * 4));
8117 emit_header(gc->pc, X_GLrop_PointParameterivNV, cmdlen);
8118 (void) memcpy((void *)(gc->pc + 4), (void *)(&pname), 4);
8119 (void) memcpy((void *)(gc->pc + 8), (void *)(params), (compsize * 4));
8120 gc->pc += cmdlen;
8121 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
8122 }
8123
8124 #define X_GLrop_ActiveStencilFaceEXT 4220
8125 void __indirect_glActiveStencilFaceEXT(GLenum face)
8126 {
8127 struct glx_context * const gc = __glXGetCurrentContext();
8128 const GLuint cmdlen = 8;
8129 emit_header(gc->pc, X_GLrop_ActiveStencilFaceEXT, cmdlen);
8130 (void) memcpy((void *)(gc->pc + 4), (void *)(&face), 4);
8131 gc->pc += cmdlen;
8132 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
8133 }
8134
8135 #define X_GLvop_GetProgramNamedParameterdvNV 1311
8136 void __indirect_glGetProgramNamedParameterdvNV(GLuint id, GLsizei len, const GLu byte * name, GLdouble * params)
8137 {
8138 struct glx_context * const gc = __glXGetCurrentContext();
8139 Display * const dpy = gc->currentDpy;
8140 const GLuint cmdlen = 8 + __GLX_PAD(len);
8141 if (len < 0) {
8142 __glXSetError(gc, GL_INVALID_VALUE);
8143 return;
8144 }
8145 if (__builtin_expect((len >= 0) && (dpy != NULL), 1)) {
8146 GLubyte const * pc = __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithR eply, X_GLvop_GetProgramNamedParameterdvNV, cmdlen);
8147 (void) memcpy((void *)(pc + 0), (void *)(&id), 4);
8148 (void) memcpy((void *)(pc + 4), (void *)(&len), 4);
8149 (void) memcpy((void *)(pc + 8), (void *)(name), len);
8150 (void) __glXReadReply(dpy, 8, params, GL_TRUE);
8151 UnlockDisplay(dpy); SyncHandle();
8152 }
8153 return;
8154 }
8155
8156 #define X_GLvop_GetProgramNamedParameterfvNV 1310
8157 void __indirect_glGetProgramNamedParameterfvNV(GLuint id, GLsizei len, const GLu byte * name, GLfloat * params)
8158 {
8159 struct glx_context * const gc = __glXGetCurrentContext();
8160 Display * const dpy = gc->currentDpy;
8161 const GLuint cmdlen = 8 + __GLX_PAD(len);
8162 if (len < 0) {
8163 __glXSetError(gc, GL_INVALID_VALUE);
8164 return;
8165 }
8166 if (__builtin_expect((len >= 0) && (dpy != NULL), 1)) {
8167 GLubyte const * pc = __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithR eply, X_GLvop_GetProgramNamedParameterfvNV, cmdlen);
8168 (void) memcpy((void *)(pc + 0), (void *)(&id), 4);
8169 (void) memcpy((void *)(pc + 4), (void *)(&len), 4);
8170 (void) memcpy((void *)(pc + 8), (void *)(name), len);
8171 (void) __glXReadReply(dpy, 4, params, GL_TRUE);
8172 UnlockDisplay(dpy); SyncHandle();
8173 }
8174 return;
8175 }
8176
8177 #define X_GLrop_ProgramNamedParameter4dvNV 4219
8178 void __indirect_glProgramNamedParameter4dNV(GLuint id, GLsizei len, const GLubyt e * name, GLdouble x, GLdouble y, GLdouble z, GLdouble w)
8179 {
8180 struct glx_context * const gc = __glXGetCurrentContext();
8181 const GLuint cmdlen = 44 + __GLX_PAD(len);
8182 if (len < 0) {
8183 __glXSetError(gc, GL_INVALID_VALUE);
8184 return;
8185 }
8186 if (__builtin_expect(len >= 0, 1)) {
8187 emit_header(gc->pc, X_GLrop_ProgramNamedParameter4dvNV, cmdlen);
8188 (void) memcpy((void *)(gc->pc + 4), (void *)(&x), 8);
8189 (void) memcpy((void *)(gc->pc + 12), (void *)(&y), 8);
8190 (void) memcpy((void *)(gc->pc + 20), (void *)(&z), 8);
8191 (void) memcpy((void *)(gc->pc + 28), (void *)(&w), 8);
8192 (void) memcpy((void *)(gc->pc + 36), (void *)(&id), 4);
8193 (void) memcpy((void *)(gc->pc + 40), (void *)(&len), 4);
8194 (void) memcpy((void *)(gc->pc + 44), (void *)(name), len);
8195 gc->pc += cmdlen;
8196 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
8197 }
8198 }
8199
8200 #define X_GLrop_ProgramNamedParameter4dvNV 4219
8201 void __indirect_glProgramNamedParameter4dvNV(GLuint id, GLsizei len, const GLuby te * name, const GLdouble * v)
8202 {
8203 struct glx_context * const gc = __glXGetCurrentContext();
8204 const GLuint cmdlen = 44 + __GLX_PAD(len);
8205 if (len < 0) {
8206 __glXSetError(gc, GL_INVALID_VALUE);
8207 return;
8208 }
8209 if (__builtin_expect(len >= 0, 1)) {
8210 emit_header(gc->pc, X_GLrop_ProgramNamedParameter4dvNV, cmdlen);
8211 (void) memcpy((void *)(gc->pc + 4), (void *)(v), 32);
8212 (void) memcpy((void *)(gc->pc + 36), (void *)(&id), 4);
8213 (void) memcpy((void *)(gc->pc + 40), (void *)(&len), 4);
8214 (void) memcpy((void *)(gc->pc + 44), (void *)(name), len);
8215 gc->pc += cmdlen;
8216 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
8217 }
8218 }
8219
8220 #define X_GLrop_ProgramNamedParameter4fvNV 4218
8221 void __indirect_glProgramNamedParameter4fNV(GLuint id, GLsizei len, const GLubyt e * name, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
8222 {
8223 struct glx_context * const gc = __glXGetCurrentContext();
8224 const GLuint cmdlen = 28 + __GLX_PAD(len);
8225 if (len < 0) {
8226 __glXSetError(gc, GL_INVALID_VALUE);
8227 return;
8228 }
8229 if (__builtin_expect(len >= 0, 1)) {
8230 emit_header(gc->pc, X_GLrop_ProgramNamedParameter4fvNV, cmdlen);
8231 (void) memcpy((void *)(gc->pc + 4), (void *)(&id), 4);
8232 (void) memcpy((void *)(gc->pc + 8), (void *)(&len), 4);
8233 (void) memcpy((void *)(gc->pc + 12), (void *)(&x), 4);
8234 (void) memcpy((void *)(gc->pc + 16), (void *)(&y), 4);
8235 (void) memcpy((void *)(gc->pc + 20), (void *)(&z), 4);
8236 (void) memcpy((void *)(gc->pc + 24), (void *)(&w), 4);
8237 (void) memcpy((void *)(gc->pc + 28), (void *)(name), len);
8238 gc->pc += cmdlen;
8239 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
8240 }
8241 }
8242
8243 #define X_GLrop_ProgramNamedParameter4fvNV 4218
8244 void __indirect_glProgramNamedParameter4fvNV(GLuint id, GLsizei len, const GLuby te * name, const GLfloat * v)
8245 {
8246 struct glx_context * const gc = __glXGetCurrentContext();
8247 const GLuint cmdlen = 28 + __GLX_PAD(len);
8248 if (len < 0) {
8249 __glXSetError(gc, GL_INVALID_VALUE);
8250 return;
8251 }
8252 if (__builtin_expect(len >= 0, 1)) {
8253 emit_header(gc->pc, X_GLrop_ProgramNamedParameter4fvNV, cmdlen);
8254 (void) memcpy((void *)(gc->pc + 4), (void *)(&id), 4);
8255 (void) memcpy((void *)(gc->pc + 8), (void *)(&len), 4);
8256 (void) memcpy((void *)(gc->pc + 12), (void *)(v), 16);
8257 (void) memcpy((void *)(gc->pc + 28), (void *)(name), len);
8258 gc->pc += cmdlen;
8259 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
8260 }
8261 }
8262
8263 #define X_GLrop_BlendEquationSeparateEXT 4228
8264 void __indirect_glBlendEquationSeparateEXT(GLenum modeRGB, GLenum modeA)
8265 {
8266 struct glx_context * const gc = __glXGetCurrentContext();
8267 const GLuint cmdlen = 12;
8268 emit_header(gc->pc, X_GLrop_BlendEquationSeparateEXT, cmdlen);
8269 (void) memcpy((void *)(gc->pc + 4), (void *)(&modeRGB), 4);
8270 (void) memcpy((void *)(gc->pc + 8), (void *)(&modeA), 4);
8271 gc->pc += cmdlen;
8272 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
8273 }
8274
8275 #define X_GLrop_BindFramebufferEXT 4319
8276 void __indirect_glBindFramebufferEXT(GLenum target, GLuint framebuffer)
8277 {
8278 struct glx_context * const gc = __glXGetCurrentContext();
8279 const GLuint cmdlen = 12;
8280 emit_header(gc->pc, X_GLrop_BindFramebufferEXT, cmdlen);
8281 (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
8282 (void) memcpy((void *)(gc->pc + 8), (void *)(&framebuffer), 4);
8283 gc->pc += cmdlen;
8284 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
8285 }
8286
8287 #define X_GLrop_BindRenderbufferEXT 4316
8288 void __indirect_glBindRenderbufferEXT(GLenum target, GLuint renderbuffer)
8289 {
8290 struct glx_context * const gc = __glXGetCurrentContext();
8291 const GLuint cmdlen = 12;
8292 emit_header(gc->pc, X_GLrop_BindRenderbufferEXT, cmdlen);
8293 (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
8294 (void) memcpy((void *)(gc->pc + 8), (void *)(&renderbuffer), 4);
8295 gc->pc += cmdlen;
8296 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
8297 }
8298
8299 #define X_GLvop_CheckFramebufferStatusEXT 1427
8300 GLenum __indirect_glCheckFramebufferStatusEXT(GLenum target)
8301 {
8302 struct glx_context * const gc = __glXGetCurrentContext();
8303 Display * const dpy = gc->currentDpy;
8304 GLenum retval = (GLenum) 0;
8305 const GLuint cmdlen = 4;
8306 if (__builtin_expect(dpy != NULL, 1)) {
8307 GLubyte const * pc = __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithR eply, X_GLvop_CheckFramebufferStatusEXT, cmdlen);
8308 (void) memcpy((void *)(pc + 0), (void *)(&target), 4);
8309 retval = (GLenum) __glXReadReply(dpy, 0, NULL, GL_FALSE);
8310 UnlockDisplay(dpy); SyncHandle();
8311 }
8312 return retval;
8313 }
8314
8315 #define X_GLrop_DeleteFramebuffersEXT 4320
8316 void __indirect_glDeleteFramebuffersEXT(GLsizei n, const GLuint * framebuffers)
8317 {
8318 struct glx_context * const gc = __glXGetCurrentContext();
8319 const GLuint cmdlen = 8 + __GLX_PAD((n * 4));
8320 if (n < 0) {
8321 __glXSetError(gc, GL_INVALID_VALUE);
8322 return;
8323 }
8324 if (__builtin_expect(n >= 0, 1)) {
8325 emit_header(gc->pc, X_GLrop_DeleteFramebuffersEXT, cmdlen);
8326 (void) memcpy((void *)(gc->pc + 4), (void *)(&n), 4);
8327 (void) memcpy((void *)(gc->pc + 8), (void *)(framebuffers), (n * 4));
8328 gc->pc += cmdlen;
8329 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
8330 }
8331 }
8332
8333 #define X_GLrop_DeleteRenderbuffersEXT 4317
8334 void __indirect_glDeleteRenderbuffersEXT(GLsizei n, const GLuint * renderbuffers )
8335 {
8336 struct glx_context * const gc = __glXGetCurrentContext();
8337 const GLuint cmdlen = 8 + __GLX_PAD((n * 4));
8338 if (n < 0) {
8339 __glXSetError(gc, GL_INVALID_VALUE);
8340 return;
8341 }
8342 if (__builtin_expect(n >= 0, 1)) {
8343 emit_header(gc->pc, X_GLrop_DeleteRenderbuffersEXT, cmdlen);
8344 (void) memcpy((void *)(gc->pc + 4), (void *)(&n), 4);
8345 (void) memcpy((void *)(gc->pc + 8), (void *)(renderbuffers), (n * 4));
8346 gc->pc += cmdlen;
8347 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
8348 }
8349 }
8350
8351 #define X_GLrop_FramebufferRenderbufferEXT 4324
8352 void __indirect_glFramebufferRenderbufferEXT(GLenum target, GLenum attachment, G Lenum renderbuffertarget, GLuint renderbuffer)
8353 {
8354 struct glx_context * const gc = __glXGetCurrentContext();
8355 const GLuint cmdlen = 20;
8356 emit_header(gc->pc, X_GLrop_FramebufferRenderbufferEXT, cmdlen);
8357 (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
8358 (void) memcpy((void *)(gc->pc + 8), (void *)(&attachment), 4);
8359 (void) memcpy((void *)(gc->pc + 12), (void *)(&renderbuffertarget), 4);
8360 (void) memcpy((void *)(gc->pc + 16), (void *)(&renderbuffer), 4);
8361 gc->pc += cmdlen;
8362 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
8363 }
8364
8365 #define X_GLrop_FramebufferTexture1DEXT 4321
8366 void __indirect_glFramebufferTexture1DEXT(GLenum target, GLenum attachment, GLen um textarget, GLuint texture, GLint level)
8367 {
8368 struct glx_context * const gc = __glXGetCurrentContext();
8369 const GLuint cmdlen = 24;
8370 emit_header(gc->pc, X_GLrop_FramebufferTexture1DEXT, cmdlen);
8371 (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
8372 (void) memcpy((void *)(gc->pc + 8), (void *)(&attachment), 4);
8373 (void) memcpy((void *)(gc->pc + 12), (void *)(&textarget), 4);
8374 (void) memcpy((void *)(gc->pc + 16), (void *)(&texture), 4);
8375 (void) memcpy((void *)(gc->pc + 20), (void *)(&level), 4);
8376 gc->pc += cmdlen;
8377 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
8378 }
8379
8380 #define X_GLrop_FramebufferTexture2DEXT 4322
8381 void __indirect_glFramebufferTexture2DEXT(GLenum target, GLenum attachment, GLen um textarget, GLuint texture, GLint level)
8382 {
8383 struct glx_context * const gc = __glXGetCurrentContext();
8384 const GLuint cmdlen = 24;
8385 emit_header(gc->pc, X_GLrop_FramebufferTexture2DEXT, cmdlen);
8386 (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
8387 (void) memcpy((void *)(gc->pc + 8), (void *)(&attachment), 4);
8388 (void) memcpy((void *)(gc->pc + 12), (void *)(&textarget), 4);
8389 (void) memcpy((void *)(gc->pc + 16), (void *)(&texture), 4);
8390 (void) memcpy((void *)(gc->pc + 20), (void *)(&level), 4);
8391 gc->pc += cmdlen;
8392 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
8393 }
8394
8395 #define X_GLrop_FramebufferTexture3DEXT 4323
8396 void __indirect_glFramebufferTexture3DEXT(GLenum target, GLenum attachment, GLen um textarget, GLuint texture, GLint level, GLint zoffset)
8397 {
8398 struct glx_context * const gc = __glXGetCurrentContext();
8399 const GLuint cmdlen = 28;
8400 emit_header(gc->pc, X_GLrop_FramebufferTexture3DEXT, cmdlen);
8401 (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
8402 (void) memcpy((void *)(gc->pc + 8), (void *)(&attachment), 4);
8403 (void) memcpy((void *)(gc->pc + 12), (void *)(&textarget), 4);
8404 (void) memcpy((void *)(gc->pc + 16), (void *)(&texture), 4);
8405 (void) memcpy((void *)(gc->pc + 20), (void *)(&level), 4);
8406 (void) memcpy((void *)(gc->pc + 24), (void *)(&zoffset), 4);
8407 gc->pc += cmdlen;
8408 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
8409 }
8410
8411 #define X_GLvop_GenFramebuffersEXT 1426
8412 void __indirect_glGenFramebuffersEXT(GLsizei n, GLuint * framebuffers)
8413 {
8414 struct glx_context * const gc = __glXGetCurrentContext();
8415 Display * const dpy = gc->currentDpy;
8416 const GLuint cmdlen = 4;
8417 if (n < 0) {
8418 __glXSetError(gc, GL_INVALID_VALUE);
8419 return;
8420 }
8421 if (__builtin_expect((n >= 0) && (dpy != NULL), 1)) {
8422 GLubyte const * pc = __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithR eply, X_GLvop_GenFramebuffersEXT, cmdlen);
8423 (void) memcpy((void *)(pc + 0), (void *)(&n), 4);
8424 (void) __glXReadReply(dpy, 4, framebuffers, GL_TRUE);
8425 UnlockDisplay(dpy); SyncHandle();
8426 }
8427 return;
8428 }
8429
8430 #define X_GLvop_GenRenderbuffersEXT 1423
8431 void __indirect_glGenRenderbuffersEXT(GLsizei n, GLuint * renderbuffers)
8432 {
8433 struct glx_context * const gc = __glXGetCurrentContext();
8434 Display * const dpy = gc->currentDpy;
8435 const GLuint cmdlen = 4;
8436 if (n < 0) {
8437 __glXSetError(gc, GL_INVALID_VALUE);
8438 return;
8439 }
8440 if (__builtin_expect((n >= 0) && (dpy != NULL), 1)) {
8441 GLubyte const * pc = __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithR eply, X_GLvop_GenRenderbuffersEXT, cmdlen);
8442 (void) memcpy((void *)(pc + 0), (void *)(&n), 4);
8443 (void) __glXReadReply(dpy, 4, renderbuffers, GL_TRUE);
8444 UnlockDisplay(dpy); SyncHandle();
8445 }
8446 return;
8447 }
8448
8449 #define X_GLrop_GenerateMipmapEXT 4325
8450 void __indirect_glGenerateMipmapEXT(GLenum target)
8451 {
8452 struct glx_context * const gc = __glXGetCurrentContext();
8453 const GLuint cmdlen = 8;
8454 emit_header(gc->pc, X_GLrop_GenerateMipmapEXT, cmdlen);
8455 (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
8456 gc->pc += cmdlen;
8457 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
8458 }
8459
8460 #define X_GLvop_GetFramebufferAttachmentParameterivEXT 1428
8461 void __indirect_glGetFramebufferAttachmentParameterivEXT(GLenum target, GLenum a ttachment, GLenum pname, GLint * params)
8462 {
8463 struct glx_context * const gc = __glXGetCurrentContext();
8464 Display * const dpy = gc->currentDpy;
8465 const GLuint cmdlen = 12;
8466 if (__builtin_expect(dpy != NULL, 1)) {
8467 GLubyte const * pc = __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithR eply, X_GLvop_GetFramebufferAttachmentParameterivEXT, cmdlen);
8468 (void) memcpy((void *)(pc + 0), (void *)(&target), 4);
8469 (void) memcpy((void *)(pc + 4), (void *)(&attachment), 4);
8470 (void) memcpy((void *)(pc + 8), (void *)(&pname), 4);
8471 (void) __glXReadReply(dpy, 4, params, GL_FALSE);
8472 UnlockDisplay(dpy); SyncHandle();
8473 }
8474 return;
8475 }
8476
8477 #define X_GLvop_GetRenderbufferParameterivEXT 1424
8478 void __indirect_glGetRenderbufferParameterivEXT(GLenum target, GLenum pname, GLi nt * params)
8479 {
8480 struct glx_context * const gc = __glXGetCurrentContext();
8481 Display * const dpy = gc->currentDpy;
8482 const GLuint cmdlen = 8;
8483 if (__builtin_expect(dpy != NULL, 1)) {
8484 GLubyte const * pc = __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithR eply, X_GLvop_GetRenderbufferParameterivEXT, cmdlen);
8485 (void) memcpy((void *)(pc + 0), (void *)(&target), 4);
8486 (void) memcpy((void *)(pc + 4), (void *)(&pname), 4);
8487 (void) __glXReadReply(dpy, 4, params, GL_FALSE);
8488 UnlockDisplay(dpy); SyncHandle();
8489 }
8490 return;
8491 }
8492
8493 #define X_GLvop_IsFramebufferEXT 1425
8494 GLboolean __indirect_glIsFramebufferEXT(GLuint framebuffer)
8495 {
8496 struct glx_context * const gc = __glXGetCurrentContext();
8497 Display * const dpy = gc->currentDpy;
8498 GLboolean retval = (GLboolean) 0;
8499 const GLuint cmdlen = 4;
8500 if (__builtin_expect(dpy != NULL, 1)) {
8501 GLubyte const * pc = __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithR eply, X_GLvop_IsFramebufferEXT, cmdlen);
8502 (void) memcpy((void *)(pc + 0), (void *)(&framebuffer), 4);
8503 retval = (GLboolean) __glXReadReply(dpy, 0, NULL, GL_FALSE);
8504 UnlockDisplay(dpy); SyncHandle();
8505 }
8506 return retval;
8507 }
8508
8509 #define X_GLvop_IsRenderbufferEXT 1422
8510 GLboolean __indirect_glIsRenderbufferEXT(GLuint renderbuffer)
8511 {
8512 struct glx_context * const gc = __glXGetCurrentContext();
8513 Display * const dpy = gc->currentDpy;
8514 GLboolean retval = (GLboolean) 0;
8515 const GLuint cmdlen = 4;
8516 if (__builtin_expect(dpy != NULL, 1)) {
8517 GLubyte const * pc = __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithR eply, X_GLvop_IsRenderbufferEXT, cmdlen);
8518 (void) memcpy((void *)(pc + 0), (void *)(&renderbuffer), 4);
8519 retval = (GLboolean) __glXReadReply(dpy, 0, NULL, GL_FALSE);
8520 UnlockDisplay(dpy); SyncHandle();
8521 }
8522 return retval;
8523 }
8524
8525 #define X_GLrop_RenderbufferStorageEXT 4318
8526 void __indirect_glRenderbufferStorageEXT(GLenum target, GLenum internalformat, G Lsizei width, GLsizei height)
8527 {
8528 struct glx_context * const gc = __glXGetCurrentContext();
8529 const GLuint cmdlen = 20;
8530 emit_header(gc->pc, X_GLrop_RenderbufferStorageEXT, cmdlen);
8531 (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
8532 (void) memcpy((void *)(gc->pc + 8), (void *)(&internalformat), 4);
8533 (void) memcpy((void *)(gc->pc + 12), (void *)(&width), 4);
8534 (void) memcpy((void *)(gc->pc + 16), (void *)(&height), 4);
8535 gc->pc += cmdlen;
8536 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
8537 }
8538
8539 #define X_GLrop_BlitFramebufferEXT 4330
8540 void __indirect_glBlitFramebufferEXT(GLint srcX0, GLint srcY0, GLint srcX1, GLin t srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GL enum filter)
8541 {
8542 struct glx_context * const gc = __glXGetCurrentContext();
8543 const GLuint cmdlen = 44;
8544 emit_header(gc->pc, X_GLrop_BlitFramebufferEXT, cmdlen);
8545 (void) memcpy((void *)(gc->pc + 4), (void *)(&srcX0), 4);
8546 (void) memcpy((void *)(gc->pc + 8), (void *)(&srcY0), 4);
8547 (void) memcpy((void *)(gc->pc + 12), (void *)(&srcX1), 4);
8548 (void) memcpy((void *)(gc->pc + 16), (void *)(&srcY1), 4);
8549 (void) memcpy((void *)(gc->pc + 20), (void *)(&dstX0), 4);
8550 (void) memcpy((void *)(gc->pc + 24), (void *)(&dstY0), 4);
8551 (void) memcpy((void *)(gc->pc + 28), (void *)(&dstX1), 4);
8552 (void) memcpy((void *)(gc->pc + 32), (void *)(&dstY1), 4);
8553 (void) memcpy((void *)(gc->pc + 36), (void *)(&mask), 4);
8554 (void) memcpy((void *)(gc->pc + 40), (void *)(&filter), 4);
8555 gc->pc += cmdlen;
8556 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
8557 }
8558
8559 #define X_GLrop_FramebufferTextureLayerEXT 237
8560 void __indirect_glFramebufferTextureLayerEXT(GLenum target, GLenum attachment, G Luint texture, GLint level, GLint layer)
8561 {
8562 struct glx_context * const gc = __glXGetCurrentContext();
8563 const GLuint cmdlen = 24;
8564 emit_header(gc->pc, X_GLrop_FramebufferTextureLayerEXT, cmdlen);
8565 (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
8566 (void) memcpy((void *)(gc->pc + 8), (void *)(&attachment), 4);
8567 (void) memcpy((void *)(gc->pc + 12), (void *)(&texture), 4);
8568 (void) memcpy((void *)(gc->pc + 16), (void *)(&level), 4);
8569 (void) memcpy((void *)(gc->pc + 20), (void *)(&layer), 4);
8570 gc->pc += cmdlen;
8571 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
8572 }
8573
8574
8575 #ifdef GLX_SHARED_GLAPI
8576
8577 static const struct proc_pair
8578 {
8579 const char *name;
8580 _glapi_proc proc;
8581 } proc_pairs[20] = {
8582 { "AreTexturesResidentEXT", (_glapi_proc) glAreTexturesResidentEXT },
8583 { "DeleteTexturesEXT", (_glapi_proc) glDeleteTexturesEXT },
8584 { "GenTexturesEXT", (_glapi_proc) glGenTexturesEXT },
8585 { "GetColorTableEXT", (_glapi_proc) glGetColorTableEXT },
8586 { "GetColorTableParameterfvEXT", (_glapi_proc) glGetColorTableParameterfvEXT },
8587 { "GetColorTableParameterfvSGI", (_glapi_proc) glGetColorTableParameterfvEXT },
8588 { "GetColorTableParameterivEXT", (_glapi_proc) glGetColorTableParameterivEXT },
8589 { "GetColorTableParameterivSGI", (_glapi_proc) glGetColorTableParameterivEXT },
8590 { "GetColorTableSGI", (_glapi_proc) glGetColorTableEXT },
8591 { "GetConvolutionFilterEXT", (_glapi_proc) gl_dispatch_stub_356 },
8592 { "GetConvolutionParameterfvEXT", (_glapi_proc) gl_dispatch_stub_357 },
8593 { "GetConvolutionParameterivEXT", (_glapi_proc) gl_dispatch_stub_358 },
8594 { "GetHistogramEXT", (_glapi_proc) gl_dispatch_stub_361 },
8595 { "GetHistogramParameterfvEXT", (_glapi_proc) gl_dispatch_stub_362 },
8596 { "GetHistogramParameterivEXT", (_glapi_proc) gl_dispatch_stub_363 },
8597 { "GetMinmaxEXT", (_glapi_proc) gl_dispatch_stub_364 },
8598 { "GetMinmaxParameterfvEXT", (_glapi_proc) gl_dispatch_stub_365 },
8599 { "GetMinmaxParameterivEXT", (_glapi_proc) gl_dispatch_stub_366 },
8600 { "GetSeparableFilterEXT", (_glapi_proc) gl_dispatch_stub_359 },
8601 { "IsTextureEXT", (_glapi_proc) glIsTextureEXT }
8602 };
8603
8604 static int
8605 __indirect_get_proc_compare(const void *key, const void *memb)
8606 {
8607 const struct proc_pair *pair = (const struct proc_pair *) memb;
8608 return strcmp((const char *) key, pair->name);
8609 }
8610
8611 _glapi_proc
8612 __indirect_get_proc_address(const char *name)
8613 {
8614 const struct proc_pair *pair;
8615
8616 /* skip "gl" */
8617 name += 2;
8618
8619 pair = (const struct proc_pair *) bsearch((const void *) name,
8620 (const void *) proc_pairs, ARRAY_SIZE(proc_pairs), sizeof(proc_pairs[0]),
8621 __indirect_get_proc_compare);
8622
8623 return (pair) ? pair->proc : NULL;
8624 }
8625
8626 #endif /* GLX_SHARED_GLAPI */
8627
8628
8629 # undef FASTCALL
8630 # undef NOINLINE
OLDNEW
« no previous file with comments | « third_party/mesa/chromium_gensrc/mesa/indirect.h ('k') | third_party/mesa/chromium_gensrc/mesa/indirect_init.c » ('j') | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698