1 /* DO NOT EDIT - This file generated automatically by glX_proto_send.py (from Mesa) script */
4 * (C) Copyright IBM Corporation 2004
7 * Permission is hereby granted, free of charge, to any person obtaining a
8 * copy of this software and associated documentation files (the "Software"),
9 * to deal in the Software without restriction, including without limitation
10 * the rights to use, copy, modify, merge, publish, distribute, sub license,
11 * and/or sell copies of the Software, and to permit persons to whom the
12 * Software is furnished to do so, subject to the following conditions:
14 * The above copyright notice and this permission notice (including the next
15 * paragraph) shall be included in all copies or substantial portions of the
18 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
19 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
20 * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL
22 * AND/OR THEIR SUPPLIERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
23 * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF
24 * OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
31 #include "glxclient.h"
33 #include <GL/glxproto.h>
35 #define __GLX_PAD(n) (((n) + 3) & ~3)
37 # if defined(__i386__) && defined(__GNUC__)
38 # define FASTCALL __attribute__((fastcall))
42 # if defined(__GNUC__)
43 # define NOINLINE __attribute__((noinline))
48 /* If the size and opcode values are known at compile-time, this will, on
49 * x86 at least, emit them with a single instruction.
51 #define emit_header(dest, op, size) \
52 do { union { short s[2]; int i; } temp; \
53 temp.s[0] = (size); temp.s[1] = (op); \
54 *((int *)(dest)) = temp.i; } while(0)
56 static NOINLINE CARD32
57 read_reply( Display *dpy, size_t size, void * dest, GLboolean reply_is_always_array )
59 xGLXSingleReply reply;
61 (void) _XReply(dpy, (xReply *) & reply, 0, False);
63 if ((reply.size >= 1) || reply_is_always_array) {
64 const GLint bytes = (reply_is_always_array)
65 ? (4 * reply.length) : (reply.size * size);
66 const GLint extra = 4 - (bytes & 3);
68 _XRead(dpy, dest, bytes);
70 _XEatData(dpy, extra);
74 (void) memcpy( dest, &(reply.pad3), size);
83 static NOINLINE GLubyte *
84 setup_single_request( __GLXcontext * gc, GLint sop, GLint cmdlen )
87 Display * const dpy = gc->currentDpy;
89 (void) __glXFlushRenderBuffer(gc, gc->pc);
91 GetReqExtra(GLXSingle, cmdlen, req);
92 req->reqType = gc->majorOpcode;
93 req->contextTag = gc->currentContextTag;
95 return (GLubyte *)(req) + sz_xGLXSingleReq;
98 static NOINLINE GLubyte *
99 setup_vendor_request( __GLXcontext * gc, GLint code, GLint vop, GLint cmdlen )
101 xGLXVendorPrivateReq * req;
102 Display * const dpy = gc->currentDpy;
104 (void) __glXFlushRenderBuffer(gc, gc->pc);
106 GetReqExtra(GLXVendorPrivate, cmdlen, req);
107 req->reqType = gc->majorOpcode;
109 req->vendorCode = vop;
110 req->contextTag = gc->currentContextTag;
111 return (GLubyte *)(req) + sz_xGLXVendorPrivateReq;
114 static FASTCALL NOINLINE void
115 generic_3_byte( GLint rop, const void * ptr )
117 __GLXcontext * const gc = __glXGetCurrentContext();
118 const GLuint cmdlen = 7;
120 emit_header(gc->pc, rop, cmdlen);
121 (void) memcpy((void *)(gc->pc + 4), ptr, 3);
123 if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
126 static FASTCALL NOINLINE void
127 generic_4_byte( GLint rop, const void * ptr )
129 __GLXcontext * const gc = __glXGetCurrentContext();
130 const GLuint cmdlen = 8;
132 emit_header(gc->pc, rop, cmdlen);
133 (void) memcpy((void *)(gc->pc + 4), ptr, 4);
135 if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
138 static FASTCALL NOINLINE void
139 generic_6_byte( GLint rop, const void * ptr )
141 __GLXcontext * const gc = __glXGetCurrentContext();
142 const GLuint cmdlen = 10;
144 emit_header(gc->pc, rop, cmdlen);
145 (void) memcpy((void *)(gc->pc + 4), ptr, 6);
147 if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
150 static FASTCALL NOINLINE void
151 generic_8_byte( GLint rop, const void * ptr )
153 __GLXcontext * const gc = __glXGetCurrentContext();
154 const GLuint cmdlen = 12;
156 emit_header(gc->pc, rop, cmdlen);
157 (void) memcpy((void *)(gc->pc + 4), ptr, 8);
159 if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
162 static FASTCALL NOINLINE void
163 generic_12_byte( GLint rop, const void * ptr )
165 __GLXcontext * const gc = __glXGetCurrentContext();
166 const GLuint cmdlen = 16;
168 emit_header(gc->pc, rop, cmdlen);
169 (void) memcpy((void *)(gc->pc + 4), ptr, 12);
171 if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
174 static FASTCALL NOINLINE void
175 generic_16_byte( GLint rop, const void * ptr )
177 __GLXcontext * const gc = __glXGetCurrentContext();
178 const GLuint cmdlen = 20;
180 emit_header(gc->pc, rop, cmdlen);
181 (void) memcpy((void *)(gc->pc + 4), ptr, 16);
183 if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
186 static FASTCALL NOINLINE void
187 generic_24_byte( GLint rop, const void * ptr )
189 __GLXcontext * const gc = __glXGetCurrentContext();
190 const GLuint cmdlen = 28;
192 emit_header(gc->pc, rop, cmdlen);
193 (void) memcpy((void *)(gc->pc + 4), ptr, 24);
195 if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
198 static FASTCALL NOINLINE void
199 generic_32_byte( GLint rop, const void * ptr )
201 __GLXcontext * const gc = __glXGetCurrentContext();
202 const GLuint cmdlen = 36;
204 emit_header(gc->pc, rop, cmdlen);
205 (void) memcpy((void *)(gc->pc + 4), ptr, 32);
207 if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
210 #define X_GLsop_NewList 101
212 __indirect_glNewList(GLuint list, GLenum mode)
214 __GLXcontext * const gc = __glXGetCurrentContext();
215 Display * const dpy = gc->currentDpy;
216 const GLuint cmdlen = 8;
219 GLubyte const * pc = setup_single_request(gc, X_GLsop_NewList, cmdlen);
220 (void) memcpy((void *)(pc + 0), (void *)(&list), 4);
221 (void) memcpy((void *)(pc + 4), (void *)(&mode), 4);
222 UnlockDisplay(gc->currentDpy); SyncHandle();
227 #define X_GLsop_EndList 102
229 __indirect_glEndList(void)
231 __GLXcontext * const gc = __glXGetCurrentContext();
232 Display * const dpy = gc->currentDpy;
233 const GLuint cmdlen = 0;
236 (void) setup_single_request(gc, X_GLsop_EndList, cmdlen);
237 UnlockDisplay(gc->currentDpy); SyncHandle();
242 #define X_GLrop_CallList 1
244 __indirect_glCallList(GLuint list)
246 __GLXcontext * const gc = __glXGetCurrentContext();
247 Display * const dpy = gc->currentDpy;
248 const GLuint cmdlen = 8;
250 emit_header(gc->pc, X_GLrop_CallList, cmdlen);
251 (void) memcpy((void *)(gc->pc + 4), (void *)(&list), 4);
253 if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
256 #define X_GLrop_CallLists 2
258 __indirect_glCallLists(GLsizei n, GLenum type, const GLvoid * lists)
260 __GLXcontext * const gc = __glXGetCurrentContext();
261 Display * const dpy = gc->currentDpy;
262 const GLuint compsize = __glCallLists_size(type);
263 const GLuint cmdlen = 12 + __GLX_PAD((compsize * n));
264 if (dpy == NULL) return;
265 if ( ((gc->pc + cmdlen) > gc->bufEnd)
266 || (cmdlen > gc->maxSmallRenderCommandSize)) {
267 (void) __glXFlushRenderBuffer(gc, gc->pc);
269 if (cmdlen <= gc->maxSmallRenderCommandSize) {
270 emit_header(gc->pc, X_GLrop_CallLists, cmdlen);
271 (void) memcpy((void *)(gc->pc + 4), (void *)(&n), 4);
272 (void) memcpy((void *)(gc->pc + 8), (void *)(&type), 4);
273 (void) memcpy((void *)(gc->pc + 12), (void *)(lists), (compsize * n));
275 if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
278 const GLint op = X_GLrop_CallLists;
279 const GLuint cmdlenLarge = cmdlen + 4;
280 (void) memcpy((void *)(gc->pc + 0), (void *)(&op), 4);
281 (void) memcpy((void *)(gc->pc + 4), (void *)(&cmdlenLarge), 4);
282 (void) memcpy((void *)(gc->pc + 8), (void *)(&n), 4);
283 (void) memcpy((void *)(gc->pc + 12), (void *)(&type), 4);
284 __glXSendLargeCommand(gc, gc->pc, 16, lists, (compsize * n));
288 #define X_GLsop_DeleteLists 103
290 __indirect_glDeleteLists(GLuint list, GLsizei range)
292 __GLXcontext * const gc = __glXGetCurrentContext();
293 Display * const dpy = gc->currentDpy;
294 const GLuint cmdlen = 8;
297 GLubyte const * pc = setup_single_request(gc, X_GLsop_DeleteLists, cmdlen);
298 (void) memcpy((void *)(pc + 0), (void *)(&list), 4);
299 (void) memcpy((void *)(pc + 4), (void *)(&range), 4);
300 UnlockDisplay(gc->currentDpy); SyncHandle();
305 #define X_GLsop_GenLists 104
307 __indirect_glGenLists(GLsizei range)
309 __GLXcontext * const gc = __glXGetCurrentContext();
310 Display * const dpy = gc->currentDpy;
311 GLuint retval = (GLuint) 0;
312 const GLuint cmdlen = 4;
315 GLubyte const * pc = setup_single_request(gc, X_GLsop_GenLists, cmdlen);
316 (void) memcpy((void *)(pc + 0), (void *)(&range), 4);
317 retval = (GLuint) read_reply(gc->currentDpy, 0, NULL, GL_FALSE);
318 UnlockDisplay(gc->currentDpy); SyncHandle();
323 #define X_GLrop_ListBase 3
325 __indirect_glListBase(GLuint base)
327 __GLXcontext * const gc = __glXGetCurrentContext();
328 Display * const dpy = gc->currentDpy;
329 const GLuint cmdlen = 8;
331 emit_header(gc->pc, X_GLrop_ListBase, cmdlen);
332 (void) memcpy((void *)(gc->pc + 4), (void *)(&base), 4);
334 if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
337 #define X_GLrop_Begin 4
339 __indirect_glBegin(GLenum mode)
341 __GLXcontext * const gc = __glXGetCurrentContext();
342 Display * const dpy = gc->currentDpy;
343 const GLuint cmdlen = 8;
345 emit_header(gc->pc, X_GLrop_Begin, cmdlen);
346 (void) memcpy((void *)(gc->pc + 4), (void *)(&mode), 4);
348 if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
351 #define X_GLrop_Color3bv 6
353 __indirect_glColor3b(GLbyte red, GLbyte green, GLbyte blue)
355 __GLXcontext * const gc = __glXGetCurrentContext();
356 Display * const dpy = gc->currentDpy;
357 const GLuint cmdlen = 8;
359 emit_header(gc->pc, X_GLrop_Color3bv, cmdlen);
360 (void) memcpy((void *)(gc->pc + 4), (void *)(&red), 1);
361 (void) memcpy((void *)(gc->pc + 5), (void *)(&green), 1);
362 (void) memcpy((void *)(gc->pc + 6), (void *)(&blue), 1);
364 if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
367 #define X_GLrop_Color3bv 6
369 __indirect_glColor3bv(const GLbyte * v)
371 generic_3_byte( X_GLrop_Color3bv, v );
374 #define X_GLrop_Color3dv 7
376 __indirect_glColor3d(GLdouble red, GLdouble green, GLdouble blue)
378 __GLXcontext * const gc = __glXGetCurrentContext();
379 Display * const dpy = gc->currentDpy;
380 const GLuint cmdlen = 28;
382 emit_header(gc->pc, X_GLrop_Color3dv, cmdlen);
383 (void) memcpy((void *)(gc->pc + 4), (void *)(&red), 8);
384 (void) memcpy((void *)(gc->pc + 12), (void *)(&green), 8);
385 (void) memcpy((void *)(gc->pc + 20), (void *)(&blue), 8);
387 if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
390 #define X_GLrop_Color3dv 7
392 __indirect_glColor3dv(const GLdouble * v)
394 generic_24_byte( X_GLrop_Color3dv, v );
397 #define X_GLrop_Color3fv 8
399 __indirect_glColor3f(GLfloat red, GLfloat green, GLfloat blue)
401 __GLXcontext * const gc = __glXGetCurrentContext();
402 Display * const dpy = gc->currentDpy;
403 const GLuint cmdlen = 16;
405 emit_header(gc->pc, X_GLrop_Color3fv, cmdlen);
406 (void) memcpy((void *)(gc->pc + 4), (void *)(&red), 4);
407 (void) memcpy((void *)(gc->pc + 8), (void *)(&green), 4);
408 (void) memcpy((void *)(gc->pc + 12), (void *)(&blue), 4);
410 if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
413 #define X_GLrop_Color3fv 8
415 __indirect_glColor3fv(const GLfloat * v)
417 generic_12_byte( X_GLrop_Color3fv, v );
420 #define X_GLrop_Color3iv 9
422 __indirect_glColor3i(GLint red, GLint green, GLint blue)
424 __GLXcontext * const gc = __glXGetCurrentContext();
425 Display * const dpy = gc->currentDpy;
426 const GLuint cmdlen = 16;
428 emit_header(gc->pc, X_GLrop_Color3iv, cmdlen);
429 (void) memcpy((void *)(gc->pc + 4), (void *)(&red), 4);
430 (void) memcpy((void *)(gc->pc + 8), (void *)(&green), 4);
431 (void) memcpy((void *)(gc->pc + 12), (void *)(&blue), 4);
433 if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
436 #define X_GLrop_Color3iv 9
438 __indirect_glColor3iv(const GLint * v)
440 generic_12_byte( X_GLrop_Color3iv, v );
443 #define X_GLrop_Color3sv 10
445 __indirect_glColor3s(GLshort red, GLshort green, GLshort blue)
447 __GLXcontext * const gc = __glXGetCurrentContext();
448 Display * const dpy = gc->currentDpy;
449 const GLuint cmdlen = 12;
451 emit_header(gc->pc, X_GLrop_Color3sv, cmdlen);
452 (void) memcpy((void *)(gc->pc + 4), (void *)(&red), 2);
453 (void) memcpy((void *)(gc->pc + 6), (void *)(&green), 2);
454 (void) memcpy((void *)(gc->pc + 8), (void *)(&blue), 2);
456 if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
459 #define X_GLrop_Color3sv 10
461 __indirect_glColor3sv(const GLshort * v)
463 generic_6_byte( X_GLrop_Color3sv, v );
466 #define X_GLrop_Color3ubv 11
468 __indirect_glColor3ub(GLubyte red, GLubyte green, GLubyte blue)
470 __GLXcontext * const gc = __glXGetCurrentContext();
471 Display * const dpy = gc->currentDpy;
472 const GLuint cmdlen = 8;
474 emit_header(gc->pc, X_GLrop_Color3ubv, cmdlen);
475 (void) memcpy((void *)(gc->pc + 4), (void *)(&red), 1);
476 (void) memcpy((void *)(gc->pc + 5), (void *)(&green), 1);
477 (void) memcpy((void *)(gc->pc + 6), (void *)(&blue), 1);
479 if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
482 #define X_GLrop_Color3ubv 11
484 __indirect_glColor3ubv(const GLubyte * v)
486 generic_3_byte( X_GLrop_Color3ubv, v );
489 #define X_GLrop_Color3uiv 12
491 __indirect_glColor3ui(GLuint red, GLuint green, GLuint blue)
493 __GLXcontext * const gc = __glXGetCurrentContext();
494 Display * const dpy = gc->currentDpy;
495 const GLuint cmdlen = 16;
497 emit_header(gc->pc, X_GLrop_Color3uiv, cmdlen);
498 (void) memcpy((void *)(gc->pc + 4), (void *)(&red), 4);
499 (void) memcpy((void *)(gc->pc + 8), (void *)(&green), 4);
500 (void) memcpy((void *)(gc->pc + 12), (void *)(&blue), 4);
502 if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
505 #define X_GLrop_Color3uiv 12
507 __indirect_glColor3uiv(const GLuint * v)
509 generic_12_byte( X_GLrop_Color3uiv, v );
512 #define X_GLrop_Color3usv 13
514 __indirect_glColor3us(GLushort red, GLushort green, GLushort blue)
516 __GLXcontext * const gc = __glXGetCurrentContext();
517 Display * const dpy = gc->currentDpy;
518 const GLuint cmdlen = 12;
520 emit_header(gc->pc, X_GLrop_Color3usv, cmdlen);
521 (void) memcpy((void *)(gc->pc + 4), (void *)(&red), 2);
522 (void) memcpy((void *)(gc->pc + 6), (void *)(&green), 2);
523 (void) memcpy((void *)(gc->pc + 8), (void *)(&blue), 2);
525 if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
528 #define X_GLrop_Color3usv 13
530 __indirect_glColor3usv(const GLushort * v)
532 generic_6_byte( X_GLrop_Color3usv, v );
535 #define X_GLrop_Color4bv 14
537 __indirect_glColor4b(GLbyte red, GLbyte green, GLbyte blue, GLbyte alpha)
539 __GLXcontext * const gc = __glXGetCurrentContext();
540 Display * const dpy = gc->currentDpy;
541 const GLuint cmdlen = 8;
543 emit_header(gc->pc, X_GLrop_Color4bv, cmdlen);
544 (void) memcpy((void *)(gc->pc + 4), (void *)(&red), 1);
545 (void) memcpy((void *)(gc->pc + 5), (void *)(&green), 1);
546 (void) memcpy((void *)(gc->pc + 6), (void *)(&blue), 1);
547 (void) memcpy((void *)(gc->pc + 7), (void *)(&alpha), 1);
549 if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
552 #define X_GLrop_Color4bv 14
554 __indirect_glColor4bv(const GLbyte * v)
556 generic_4_byte( X_GLrop_Color4bv, v );
559 #define X_GLrop_Color4dv 15
561 __indirect_glColor4d(GLdouble red, GLdouble green, GLdouble blue, GLdouble alpha)
563 __GLXcontext * const gc = __glXGetCurrentContext();
564 Display * const dpy = gc->currentDpy;
565 const GLuint cmdlen = 36;
567 emit_header(gc->pc, X_GLrop_Color4dv, cmdlen);
568 (void) memcpy((void *)(gc->pc + 4), (void *)(&red), 8);
569 (void) memcpy((void *)(gc->pc + 12), (void *)(&green), 8);
570 (void) memcpy((void *)(gc->pc + 20), (void *)(&blue), 8);
571 (void) memcpy((void *)(gc->pc + 28), (void *)(&alpha), 8);
573 if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
576 #define X_GLrop_Color4dv 15
578 __indirect_glColor4dv(const GLdouble * v)
580 generic_32_byte( X_GLrop_Color4dv, v );
583 #define X_GLrop_Color4fv 16
585 __indirect_glColor4f(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)
587 __GLXcontext * const gc = __glXGetCurrentContext();
588 Display * const dpy = gc->currentDpy;
589 const GLuint cmdlen = 20;
591 emit_header(gc->pc, X_GLrop_Color4fv, cmdlen);
592 (void) memcpy((void *)(gc->pc + 4), (void *)(&red), 4);
593 (void) memcpy((void *)(gc->pc + 8), (void *)(&green), 4);
594 (void) memcpy((void *)(gc->pc + 12), (void *)(&blue), 4);
595 (void) memcpy((void *)(gc->pc + 16), (void *)(&alpha), 4);
597 if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
600 #define X_GLrop_Color4fv 16
602 __indirect_glColor4fv(const GLfloat * v)
604 generic_16_byte( X_GLrop_Color4fv, v );
607 #define X_GLrop_Color4iv 17
609 __indirect_glColor4i(GLint red, GLint green, GLint blue, GLint alpha)
611 __GLXcontext * const gc = __glXGetCurrentContext();
612 Display * const dpy = gc->currentDpy;
613 const GLuint cmdlen = 20;
615 emit_header(gc->pc, X_GLrop_Color4iv, cmdlen);
616 (void) memcpy((void *)(gc->pc + 4), (void *)(&red), 4);
617 (void) memcpy((void *)(gc->pc + 8), (void *)(&green), 4);
618 (void) memcpy((void *)(gc->pc + 12), (void *)(&blue), 4);
619 (void) memcpy((void *)(gc->pc + 16), (void *)(&alpha), 4);
621 if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
624 #define X_GLrop_Color4iv 17
626 __indirect_glColor4iv(const GLint * v)
628 generic_16_byte( X_GLrop_Color4iv, v );
631 #define X_GLrop_Color4sv 18
633 __indirect_glColor4s(GLshort red, GLshort green, GLshort blue, GLshort alpha)
635 __GLXcontext * const gc = __glXGetCurrentContext();
636 Display * const dpy = gc->currentDpy;
637 const GLuint cmdlen = 12;
639 emit_header(gc->pc, X_GLrop_Color4sv, cmdlen);
640 (void) memcpy((void *)(gc->pc + 4), (void *)(&red), 2);
641 (void) memcpy((void *)(gc->pc + 6), (void *)(&green), 2);
642 (void) memcpy((void *)(gc->pc + 8), (void *)(&blue), 2);
643 (void) memcpy((void *)(gc->pc + 10), (void *)(&alpha), 2);
645 if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
648 #define X_GLrop_Color4sv 18
650 __indirect_glColor4sv(const GLshort * v)
652 generic_8_byte( X_GLrop_Color4sv, v );
655 #define X_GLrop_Color4ubv 19
657 __indirect_glColor4ub(GLubyte red, GLubyte green, GLubyte blue, GLubyte alpha)
659 __GLXcontext * const gc = __glXGetCurrentContext();
660 Display * const dpy = gc->currentDpy;
661 const GLuint cmdlen = 8;
663 emit_header(gc->pc, X_GLrop_Color4ubv, cmdlen);
664 (void) memcpy((void *)(gc->pc + 4), (void *)(&red), 1);
665 (void) memcpy((void *)(gc->pc + 5), (void *)(&green), 1);
666 (void) memcpy((void *)(gc->pc + 6), (void *)(&blue), 1);
667 (void) memcpy((void *)(gc->pc + 7), (void *)(&alpha), 1);
669 if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
672 #define X_GLrop_Color4ubv 19
674 __indirect_glColor4ubv(const GLubyte * v)
676 generic_4_byte( X_GLrop_Color4ubv, v );
679 #define X_GLrop_Color4uiv 20
681 __indirect_glColor4ui(GLuint red, GLuint green, GLuint blue, GLuint alpha)
683 __GLXcontext * const gc = __glXGetCurrentContext();
684 Display * const dpy = gc->currentDpy;
685 const GLuint cmdlen = 20;
687 emit_header(gc->pc, X_GLrop_Color4uiv, cmdlen);
688 (void) memcpy((void *)(gc->pc + 4), (void *)(&red), 4);
689 (void) memcpy((void *)(gc->pc + 8), (void *)(&green), 4);
690 (void) memcpy((void *)(gc->pc + 12), (void *)(&blue), 4);
691 (void) memcpy((void *)(gc->pc + 16), (void *)(&alpha), 4);
693 if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
696 #define X_GLrop_Color4uiv 20
698 __indirect_glColor4uiv(const GLuint * v)
700 generic_16_byte( X_GLrop_Color4uiv, v );
703 #define X_GLrop_Color4usv 21
705 __indirect_glColor4us(GLushort red, GLushort green, GLushort blue, GLushort alpha)
707 __GLXcontext * const gc = __glXGetCurrentContext();
708 Display * const dpy = gc->currentDpy;
709 const GLuint cmdlen = 12;
711 emit_header(gc->pc, X_GLrop_Color4usv, cmdlen);
712 (void) memcpy((void *)(gc->pc + 4), (void *)(&red), 2);
713 (void) memcpy((void *)(gc->pc + 6), (void *)(&green), 2);
714 (void) memcpy((void *)(gc->pc + 8), (void *)(&blue), 2);
715 (void) memcpy((void *)(gc->pc + 10), (void *)(&alpha), 2);
717 if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
720 #define X_GLrop_Color4usv 21
722 __indirect_glColor4usv(const GLushort * v)
724 generic_8_byte( X_GLrop_Color4usv, v );
727 #define X_GLrop_EdgeFlagv 22
729 __indirect_glEdgeFlag(GLboolean flag)
731 __GLXcontext * const gc = __glXGetCurrentContext();
732 Display * const dpy = gc->currentDpy;
733 const GLuint cmdlen = 8;
735 emit_header(gc->pc, X_GLrop_EdgeFlagv, cmdlen);
736 (void) memcpy((void *)(gc->pc + 4), (void *)(&flag), 1);
738 if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
741 #define X_GLrop_EdgeFlagv 22
743 __indirect_glEdgeFlagv(const GLboolean * flag)
745 __GLXcontext * const gc = __glXGetCurrentContext();
746 Display * const dpy = gc->currentDpy;
747 const GLuint cmdlen = 8;
749 emit_header(gc->pc, X_GLrop_EdgeFlagv, cmdlen);
750 (void) memcpy((void *)(gc->pc + 4), (void *)(flag), 1);
752 if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
755 #define X_GLrop_End 23
757 __indirect_glEnd(void)
759 __GLXcontext * const gc = __glXGetCurrentContext();
760 Display * const dpy = gc->currentDpy;
761 const GLuint cmdlen = 4;
763 emit_header(gc->pc, X_GLrop_End, cmdlen);
765 if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
768 #define X_GLrop_Indexdv 24
770 __indirect_glIndexd(GLdouble c)
772 __GLXcontext * const gc = __glXGetCurrentContext();
773 Display * const dpy = gc->currentDpy;
774 const GLuint cmdlen = 12;
776 emit_header(gc->pc, X_GLrop_Indexdv, cmdlen);
777 (void) memcpy((void *)(gc->pc + 4), (void *)(&c), 8);
779 if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
782 #define X_GLrop_Indexdv 24
784 __indirect_glIndexdv(const GLdouble * c)
786 generic_8_byte( X_GLrop_Indexdv, c );
789 #define X_GLrop_Indexfv 25
791 __indirect_glIndexf(GLfloat c)
793 __GLXcontext * const gc = __glXGetCurrentContext();
794 Display * const dpy = gc->currentDpy;
795 const GLuint cmdlen = 8;
797 emit_header(gc->pc, X_GLrop_Indexfv, cmdlen);
798 (void) memcpy((void *)(gc->pc + 4), (void *)(&c), 4);
800 if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
803 #define X_GLrop_Indexfv 25
805 __indirect_glIndexfv(const GLfloat * c)
807 generic_4_byte( X_GLrop_Indexfv, c );
810 #define X_GLrop_Indexiv 26
812 __indirect_glIndexi(GLint c)
814 __GLXcontext * const gc = __glXGetCurrentContext();
815 Display * const dpy = gc->currentDpy;
816 const GLuint cmdlen = 8;
818 emit_header(gc->pc, X_GLrop_Indexiv, cmdlen);
819 (void) memcpy((void *)(gc->pc + 4), (void *)(&c), 4);
821 if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
824 #define X_GLrop_Indexiv 26
826 __indirect_glIndexiv(const GLint * c)
828 generic_4_byte( X_GLrop_Indexiv, c );
831 #define X_GLrop_Indexsv 27
833 __indirect_glIndexs(GLshort c)
835 __GLXcontext * const gc = __glXGetCurrentContext();
836 Display * const dpy = gc->currentDpy;
837 const GLuint cmdlen = 8;
839 emit_header(gc->pc, X_GLrop_Indexsv, cmdlen);
840 (void) memcpy((void *)(gc->pc + 4), (void *)(&c), 2);
842 if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
845 #define X_GLrop_Indexsv 27
847 __indirect_glIndexsv(const GLshort * c)
849 __GLXcontext * const gc = __glXGetCurrentContext();
850 Display * const dpy = gc->currentDpy;
851 const GLuint cmdlen = 8;
853 emit_header(gc->pc, X_GLrop_Indexsv, cmdlen);
854 (void) memcpy((void *)(gc->pc + 4), (void *)(c), 2);
856 if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
859 #define X_GLrop_Normal3bv 28
861 __indirect_glNormal3b(GLbyte nx, GLbyte ny, GLbyte nz)
863 __GLXcontext * const gc = __glXGetCurrentContext();
864 Display * const dpy = gc->currentDpy;
865 const GLuint cmdlen = 8;
867 emit_header(gc->pc, X_GLrop_Normal3bv, cmdlen);
868 (void) memcpy((void *)(gc->pc + 4), (void *)(&nx), 1);
869 (void) memcpy((void *)(gc->pc + 5), (void *)(&ny), 1);
870 (void) memcpy((void *)(gc->pc + 6), (void *)(&nz), 1);
872 if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
875 #define X_GLrop_Normal3bv 28
877 __indirect_glNormal3bv(const GLbyte * v)
879 generic_3_byte( X_GLrop_Normal3bv, v );
882 #define X_GLrop_Normal3dv 29
884 __indirect_glNormal3d(GLdouble nx, GLdouble ny, GLdouble nz)
886 __GLXcontext * const gc = __glXGetCurrentContext();
887 Display * const dpy = gc->currentDpy;
888 const GLuint cmdlen = 28;
890 emit_header(gc->pc, X_GLrop_Normal3dv, cmdlen);
891 (void) memcpy((void *)(gc->pc + 4), (void *)(&nx), 8);
892 (void) memcpy((void *)(gc->pc + 12), (void *)(&ny), 8);
893 (void) memcpy((void *)(gc->pc + 20), (void *)(&nz), 8);
895 if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
898 #define X_GLrop_Normal3dv 29
900 __indirect_glNormal3dv(const GLdouble * v)
902 generic_24_byte( X_GLrop_Normal3dv, v );
905 #define X_GLrop_Normal3fv 30
907 __indirect_glNormal3f(GLfloat nx, GLfloat ny, GLfloat nz)
909 __GLXcontext * const gc = __glXGetCurrentContext();
910 Display * const dpy = gc->currentDpy;
911 const GLuint cmdlen = 16;
913 emit_header(gc->pc, X_GLrop_Normal3fv, cmdlen);
914 (void) memcpy((void *)(gc->pc + 4), (void *)(&nx), 4);
915 (void) memcpy((void *)(gc->pc + 8), (void *)(&ny), 4);
916 (void) memcpy((void *)(gc->pc + 12), (void *)(&nz), 4);
918 if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
921 #define X_GLrop_Normal3fv 30
923 __indirect_glNormal3fv(const GLfloat * v)
925 generic_12_byte( X_GLrop_Normal3fv, v );
928 #define X_GLrop_Normal3iv 31
930 __indirect_glNormal3i(GLint nx, GLint ny, GLint nz)
932 __GLXcontext * const gc = __glXGetCurrentContext();
933 Display * const dpy = gc->currentDpy;
934 const GLuint cmdlen = 16;
936 emit_header(gc->pc, X_GLrop_Normal3iv, cmdlen);
937 (void) memcpy((void *)(gc->pc + 4), (void *)(&nx), 4);
938 (void) memcpy((void *)(gc->pc + 8), (void *)(&ny), 4);
939 (void) memcpy((void *)(gc->pc + 12), (void *)(&nz), 4);
941 if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
944 #define X_GLrop_Normal3iv 31
946 __indirect_glNormal3iv(const GLint * v)
948 generic_12_byte( X_GLrop_Normal3iv, v );
951 #define X_GLrop_Normal3sv 32
953 __indirect_glNormal3s(GLshort nx, GLshort ny, GLshort nz)
955 __GLXcontext * const gc = __glXGetCurrentContext();
956 Display * const dpy = gc->currentDpy;
957 const GLuint cmdlen = 12;
959 emit_header(gc->pc, X_GLrop_Normal3sv, cmdlen);
960 (void) memcpy((void *)(gc->pc + 4), (void *)(&nx), 2);
961 (void) memcpy((void *)(gc->pc + 6), (void *)(&ny), 2);
962 (void) memcpy((void *)(gc->pc + 8), (void *)(&nz), 2);
964 if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
967 #define X_GLrop_Normal3sv 32
969 __indirect_glNormal3sv(const GLshort * v)
971 generic_6_byte( X_GLrop_Normal3sv, v );
974 #define X_GLrop_RasterPos2dv 33
976 __indirect_glRasterPos2d(GLdouble x, GLdouble y)
978 __GLXcontext * const gc = __glXGetCurrentContext();
979 Display * const dpy = gc->currentDpy;
980 const GLuint cmdlen = 20;
982 emit_header(gc->pc, X_GLrop_RasterPos2dv, cmdlen);
983 (void) memcpy((void *)(gc->pc + 4), (void *)(&x), 8);
984 (void) memcpy((void *)(gc->pc + 12), (void *)(&y), 8);
986 if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
989 #define X_GLrop_RasterPos2dv 33
991 __indirect_glRasterPos2dv(const GLdouble * v)
993 generic_16_byte( X_GLrop_RasterPos2dv, v );
996 #define X_GLrop_RasterPos2fv 34
998 __indirect_glRasterPos2f(GLfloat x, GLfloat y)
1000 __GLXcontext * const gc = __glXGetCurrentContext();
1001 Display * const dpy = gc->currentDpy;
1002 const GLuint cmdlen = 12;
1004 emit_header(gc->pc, X_GLrop_RasterPos2fv, cmdlen);
1005 (void) memcpy((void *)(gc->pc + 4), (void *)(&x), 4);
1006 (void) memcpy((void *)(gc->pc + 8), (void *)(&y), 4);
1008 if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
1011 #define X_GLrop_RasterPos2fv 34
1013 __indirect_glRasterPos2fv(const GLfloat * v)
1015 generic_8_byte( X_GLrop_RasterPos2fv, v );
1018 #define X_GLrop_RasterPos2iv 35
1020 __indirect_glRasterPos2i(GLint x, GLint y)
1022 __GLXcontext * const gc = __glXGetCurrentContext();
1023 Display * const dpy = gc->currentDpy;
1024 const GLuint cmdlen = 12;
1026 emit_header(gc->pc, X_GLrop_RasterPos2iv, cmdlen);
1027 (void) memcpy((void *)(gc->pc + 4), (void *)(&x), 4);
1028 (void) memcpy((void *)(gc->pc + 8), (void *)(&y), 4);
1030 if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
1033 #define X_GLrop_RasterPos2iv 35
1035 __indirect_glRasterPos2iv(const GLint * v)
1037 generic_8_byte( X_GLrop_RasterPos2iv, v );
1040 #define X_GLrop_RasterPos2sv 36
1042 __indirect_glRasterPos2s(GLshort x, GLshort y)
1044 __GLXcontext * const gc = __glXGetCurrentContext();
1045 Display * const dpy = gc->currentDpy;
1046 const GLuint cmdlen = 8;
1048 emit_header(gc->pc, X_GLrop_RasterPos2sv, cmdlen);
1049 (void) memcpy((void *)(gc->pc + 4), (void *)(&x), 2);
1050 (void) memcpy((void *)(gc->pc + 6), (void *)(&y), 2);
1052 if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
1055 #define X_GLrop_RasterPos2sv 36
1057 __indirect_glRasterPos2sv(const GLshort * v)
1059 generic_4_byte( X_GLrop_RasterPos2sv, v );
1062 #define X_GLrop_RasterPos3dv 37
1064 __indirect_glRasterPos3d(GLdouble x, GLdouble y, GLdouble z)
1066 __GLXcontext * const gc = __glXGetCurrentContext();
1067 Display * const dpy = gc->currentDpy;
1068 const GLuint cmdlen = 28;
1070 emit_header(gc->pc, X_GLrop_RasterPos3dv, cmdlen);
1071 (void) memcpy((void *)(gc->pc + 4), (void *)(&x), 8);
1072 (void) memcpy((void *)(gc->pc + 12), (void *)(&y), 8);
1073 (void) memcpy((void *)(gc->pc + 20), (void *)(&z), 8);
1075 if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
1078 #define X_GLrop_RasterPos3dv 37
1080 __indirect_glRasterPos3dv(const GLdouble * v)
1082 generic_24_byte( X_GLrop_RasterPos3dv, v );
1085 #define X_GLrop_RasterPos3fv 38
1087 __indirect_glRasterPos3f(GLfloat x, GLfloat y, GLfloat z)
1089 __GLXcontext * const gc = __glXGetCurrentContext();
1090 Display * const dpy = gc->currentDpy;
1091 const GLuint cmdlen = 16;
1093 emit_header(gc->pc, X_GLrop_RasterPos3fv, cmdlen);
1094 (void) memcpy((void *)(gc->pc + 4), (void *)(&x), 4);
1095 (void) memcpy((void *)(gc->pc + 8), (void *)(&y), 4);
1096 (void) memcpy((void *)(gc->pc + 12), (void *)(&z), 4);
1098 if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
1101 #define X_GLrop_RasterPos3fv 38
1103 __indirect_glRasterPos3fv(const GLfloat * v)
1105 generic_12_byte( X_GLrop_RasterPos3fv, v );
1108 #define X_GLrop_RasterPos3iv 39
1110 __indirect_glRasterPos3i(GLint x, GLint y, GLint z)
1112 __GLXcontext * const gc = __glXGetCurrentContext();
1113 Display * const dpy = gc->currentDpy;
1114 const GLuint cmdlen = 16;
1116 emit_header(gc->pc, X_GLrop_RasterPos3iv, cmdlen);
1117 (void) memcpy((void *)(gc->pc + 4), (void *)(&x), 4);
1118 (void) memcpy((void *)(gc->pc + 8), (void *)(&y), 4);
1119 (void) memcpy((void *)(gc->pc + 12), (void *)(&z), 4);
1121 if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
1124 #define X_GLrop_RasterPos3iv 39
1126 __indirect_glRasterPos3iv(const GLint * v)
1128 generic_12_byte( X_GLrop_RasterPos3iv, v );
1131 #define X_GLrop_RasterPos3sv 40
1133 __indirect_glRasterPos3s(GLshort x, GLshort y, GLshort z)
1135 __GLXcontext * const gc = __glXGetCurrentContext();
1136 Display * const dpy = gc->currentDpy;
1137 const GLuint cmdlen = 12;
1139 emit_header(gc->pc, X_GLrop_RasterPos3sv, cmdlen);
1140 (void) memcpy((void *)(gc->pc + 4), (void *)(&x), 2);
1141 (void) memcpy((void *)(gc->pc + 6), (void *)(&y), 2);
1142 (void) memcpy((void *)(gc->pc + 8), (void *)(&z), 2);
1144 if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
1147 #define X_GLrop_RasterPos3sv 40
1149 __indirect_glRasterPos3sv(const GLshort * v)
1151 generic_6_byte( X_GLrop_RasterPos3sv, v );
1154 #define X_GLrop_RasterPos4dv 41
1156 __indirect_glRasterPos4d(GLdouble x, GLdouble y, GLdouble z, GLdouble w)
1158 __GLXcontext * const gc = __glXGetCurrentContext();
1159 Display * const dpy = gc->currentDpy;
1160 const GLuint cmdlen = 36;
1162 emit_header(gc->pc, X_GLrop_RasterPos4dv, cmdlen);
1163 (void) memcpy((void *)(gc->pc + 4), (void *)(&x), 8);
1164 (void) memcpy((void *)(gc->pc + 12), (void *)(&y), 8);
1165 (void) memcpy((void *)(gc->pc + 20), (void *)(&z), 8);
1166 (void) memcpy((void *)(gc->pc + 28), (void *)(&w), 8);
1168 if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
1171 #define X_GLrop_RasterPos4dv 41
1173 __indirect_glRasterPos4dv(const GLdouble * v)
1175 generic_32_byte( X_GLrop_RasterPos4dv, v );
1178 #define X_GLrop_RasterPos4fv 42
1180 __indirect_glRasterPos4f(GLfloat x, GLfloat y, GLfloat z, GLfloat w)
1182 __GLXcontext * const gc = __glXGetCurrentContext();
1183 Display * const dpy = gc->currentDpy;
1184 const GLuint cmdlen = 20;
1186 emit_header(gc->pc, X_GLrop_RasterPos4fv, cmdlen);
1187 (void) memcpy((void *)(gc->pc + 4), (void *)(&x), 4);
1188 (void) memcpy((void *)(gc->pc + 8), (void *)(&y), 4);
1189 (void) memcpy((void *)(gc->pc + 12), (void *)(&z), 4);
1190 (void) memcpy((void *)(gc->pc + 16), (void *)(&w), 4);
1192 if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
1195 #define X_GLrop_RasterPos4fv 42
1197 __indirect_glRasterPos4fv(const GLfloat * v)
1199 generic_16_byte( X_GLrop_RasterPos4fv, v );
1202 #define X_GLrop_RasterPos4iv 43
1204 __indirect_glRasterPos4i(GLint x, GLint y, GLint z, GLint w)
1206 __GLXcontext * const gc = __glXGetCurrentContext();
1207 Display * const dpy = gc->currentDpy;
1208 const GLuint cmdlen = 20;
1210 emit_header(gc->pc, X_GLrop_RasterPos4iv, cmdlen);
1211 (void) memcpy((void *)(gc->pc + 4), (void *)(&x), 4);
1212 (void) memcpy((void *)(gc->pc + 8), (void *)(&y), 4);
1213 (void) memcpy((void *)(gc->pc + 12), (void *)(&z), 4);
1214 (void) memcpy((void *)(gc->pc + 16), (void *)(&w), 4);
1216 if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
1219 #define X_GLrop_RasterPos4iv 43
1221 __indirect_glRasterPos4iv(const GLint * v)
1223 generic_16_byte( X_GLrop_RasterPos4iv, v );
1226 #define X_GLrop_RasterPos4sv 44
1228 __indirect_glRasterPos4s(GLshort x, GLshort y, GLshort z, GLshort w)
1230 __GLXcontext * const gc = __glXGetCurrentContext();
1231 Display * const dpy = gc->currentDpy;
1232 const GLuint cmdlen = 12;
1234 emit_header(gc->pc, X_GLrop_RasterPos4sv, cmdlen);
1235 (void) memcpy((void *)(gc->pc + 4), (void *)(&x), 2);
1236 (void) memcpy((void *)(gc->pc + 6), (void *)(&y), 2);
1237 (void) memcpy((void *)(gc->pc + 8), (void *)(&z), 2);
1238 (void) memcpy((void *)(gc->pc + 10), (void *)(&w), 2);
1240 if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
1243 #define X_GLrop_RasterPos4sv 44
1245 __indirect_glRasterPos4sv(const GLshort * v)
1247 generic_8_byte( X_GLrop_RasterPos4sv, v );
1250 #define X_GLrop_Rectdv 45
1252 __indirect_glRectd(GLdouble x1, GLdouble y1, GLdouble x2, GLdouble y2)
1254 __GLXcontext * const gc = __glXGetCurrentContext();
1255 Display * const dpy = gc->currentDpy;
1256 const GLuint cmdlen = 36;
1258 emit_header(gc->pc, X_GLrop_Rectdv, cmdlen);
1259 (void) memcpy((void *)(gc->pc + 4), (void *)(&x1), 8);
1260 (void) memcpy((void *)(gc->pc + 12), (void *)(&y1), 8);
1261 (void) memcpy((void *)(gc->pc + 20), (void *)(&x2), 8);
1262 (void) memcpy((void *)(gc->pc + 28), (void *)(&y2), 8);
1264 if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
1267 #define X_GLrop_Rectdv 45
1269 __indirect_glRectdv(const GLdouble * v1, const GLdouble * v2)
1271 __GLXcontext * const gc = __glXGetCurrentContext();
1272 Display * const dpy = gc->currentDpy;
1273 const GLuint cmdlen = 36;
1275 emit_header(gc->pc, X_GLrop_Rectdv, cmdlen);
1276 (void) memcpy((void *)(gc->pc + 4), (void *)(v1), 16);
1277 (void) memcpy((void *)(gc->pc + 20), (void *)(v2), 16);
1279 if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
1282 #define X_GLrop_Rectfv 46
1284 __indirect_glRectf(GLfloat x1, GLfloat y1, GLfloat x2, GLfloat y2)
1286 __GLXcontext * const gc = __glXGetCurrentContext();
1287 Display * const dpy = gc->currentDpy;
1288 const GLuint cmdlen = 20;
1290 emit_header(gc->pc, X_GLrop_Rectfv, cmdlen);
1291 (void) memcpy((void *)(gc->pc + 4), (void *)(&x1), 4);
1292 (void) memcpy((void *)(gc->pc + 8), (void *)(&y1), 4);
1293 (void) memcpy((void *)(gc->pc + 12), (void *)(&x2), 4);
1294 (void) memcpy((void *)(gc->pc + 16), (void *)(&y2), 4);
1296 if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
1299 #define X_GLrop_Rectfv 46
1301 __indirect_glRectfv(const GLfloat * v1, const GLfloat * v2)
1303 __GLXcontext * const gc = __glXGetCurrentContext();
1304 Display * const dpy = gc->currentDpy;
1305 const GLuint cmdlen = 20;
1307 emit_header(gc->pc, X_GLrop_Rectfv, cmdlen);
1308 (void) memcpy((void *)(gc->pc + 4), (void *)(v1), 8);
1309 (void) memcpy((void *)(gc->pc + 12), (void *)(v2), 8);
1311 if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
1314 #define X_GLrop_Rectiv 47
1316 __indirect_glRecti(GLint x1, GLint y1, GLint x2, GLint y2)
1318 __GLXcontext * const gc = __glXGetCurrentContext();
1319 Display * const dpy = gc->currentDpy;
1320 const GLuint cmdlen = 20;
1322 emit_header(gc->pc, X_GLrop_Rectiv, cmdlen);
1323 (void) memcpy((void *)(gc->pc + 4), (void *)(&x1), 4);
1324 (void) memcpy((void *)(gc->pc + 8), (void *)(&y1), 4);
1325 (void) memcpy((void *)(gc->pc + 12), (void *)(&x2), 4);
1326 (void) memcpy((void *)(gc->pc + 16), (void *)(&y2), 4);
1328 if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
1331 #define X_GLrop_Rectiv 47
1333 __indirect_glRectiv(const GLint * v1, const GLint * v2)
1335 __GLXcontext * const gc = __glXGetCurrentContext();
1336 Display * const dpy = gc->currentDpy;
1337 const GLuint cmdlen = 20;
1339 emit_header(gc->pc, X_GLrop_Rectiv, cmdlen);
1340 (void) memcpy((void *)(gc->pc + 4), (void *)(v1), 8);
1341 (void) memcpy((void *)(gc->pc + 12), (void *)(v2), 8);
1343 if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
1346 #define X_GLrop_Rectsv 48
1348 __indirect_glRects(GLshort x1, GLshort y1, GLshort x2, GLshort y2)
1350 __GLXcontext * const gc = __glXGetCurrentContext();
1351 Display * const dpy = gc->currentDpy;
1352 const GLuint cmdlen = 12;
1354 emit_header(gc->pc, X_GLrop_Rectsv, cmdlen);
1355 (void) memcpy((void *)(gc->pc + 4), (void *)(&x1), 2);
1356 (void) memcpy((void *)(gc->pc + 6), (void *)(&y1), 2);
1357 (void) memcpy((void *)(gc->pc + 8), (void *)(&x2), 2);
1358 (void) memcpy((void *)(gc->pc + 10), (void *)(&y2), 2);
1360 if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
1363 #define X_GLrop_Rectsv 48
1365 __indirect_glRectsv(const GLshort * v1, const GLshort * v2)
1367 __GLXcontext * const gc = __glXGetCurrentContext();
1368 Display * const dpy = gc->currentDpy;
1369 const GLuint cmdlen = 12;
1371 emit_header(gc->pc, X_GLrop_Rectsv, cmdlen);
1372 (void) memcpy((void *)(gc->pc + 4), (void *)(v1), 4);
1373 (void) memcpy((void *)(gc->pc + 8), (void *)(v2), 4);
1375 if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
1378 #define X_GLrop_TexCoord1dv 49
1380 __indirect_glTexCoord1d(GLdouble s)
1382 __GLXcontext * const gc = __glXGetCurrentContext();
1383 Display * const dpy = gc->currentDpy;
1384 const GLuint cmdlen = 12;
1386 emit_header(gc->pc, X_GLrop_TexCoord1dv, cmdlen);
1387 (void) memcpy((void *)(gc->pc + 4), (void *)(&s), 8);
1389 if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
1392 #define X_GLrop_TexCoord1dv 49
1394 __indirect_glTexCoord1dv(const GLdouble * v)
1396 generic_8_byte( X_GLrop_TexCoord1dv, v );
1399 #define X_GLrop_TexCoord1fv 50
1401 __indirect_glTexCoord1f(GLfloat s)
1403 __GLXcontext * const gc = __glXGetCurrentContext();
1404 Display * const dpy = gc->currentDpy;
1405 const GLuint cmdlen = 8;
1407 emit_header(gc->pc, X_GLrop_TexCoord1fv, cmdlen);
1408 (void) memcpy((void *)(gc->pc + 4), (void *)(&s), 4);
1410 if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
1413 #define X_GLrop_TexCoord1fv 50
1415 __indirect_glTexCoord1fv(const GLfloat * v)
1417 generic_4_byte( X_GLrop_TexCoord1fv, v );
1420 #define X_GLrop_TexCoord1iv 51
1422 __indirect_glTexCoord1i(GLint s)
1424 __GLXcontext * const gc = __glXGetCurrentContext();
1425 Display * const dpy = gc->currentDpy;
1426 const GLuint cmdlen = 8;
1428 emit_header(gc->pc, X_GLrop_TexCoord1iv, cmdlen);
1429 (void) memcpy((void *)(gc->pc + 4), (void *)(&s), 4);
1431 if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
1434 #define X_GLrop_TexCoord1iv 51
1436 __indirect_glTexCoord1iv(const GLint * v)
1438 generic_4_byte( X_GLrop_TexCoord1iv, v );
1441 #define X_GLrop_TexCoord1sv 52
1443 __indirect_glTexCoord1s(GLshort s)
1445 __GLXcontext * const gc = __glXGetCurrentContext();
1446 Display * const dpy = gc->currentDpy;
1447 const GLuint cmdlen = 8;
1449 emit_header(gc->pc, X_GLrop_TexCoord1sv, cmdlen);
1450 (void) memcpy((void *)(gc->pc + 4), (void *)(&s), 2);
1452 if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
1455 #define X_GLrop_TexCoord1sv 52
1457 __indirect_glTexCoord1sv(const GLshort * v)
1459 __GLXcontext * const gc = __glXGetCurrentContext();
1460 Display * const dpy = gc->currentDpy;
1461 const GLuint cmdlen = 8;
1463 emit_header(gc->pc, X_GLrop_TexCoord1sv, cmdlen);
1464 (void) memcpy((void *)(gc->pc + 4), (void *)(v), 2);
1466 if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
1469 #define X_GLrop_TexCoord2dv 53
1471 __indirect_glTexCoord2d(GLdouble s, GLdouble t)
1473 __GLXcontext * const gc = __glXGetCurrentContext();
1474 Display * const dpy = gc->currentDpy;
1475 const GLuint cmdlen = 20;
1477 emit_header(gc->pc, X_GLrop_TexCoord2dv, cmdlen);
1478 (void) memcpy((void *)(gc->pc + 4), (void *)(&s), 8);
1479 (void) memcpy((void *)(gc->pc + 12), (void *)(&t), 8);
1481 if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
1484 #define X_GLrop_TexCoord2dv 53
1486 __indirect_glTexCoord2dv(const GLdouble * v)
1488 generic_16_byte( X_GLrop_TexCoord2dv, v );
1491 #define X_GLrop_TexCoord2fv 54
1493 __indirect_glTexCoord2f(GLfloat s, GLfloat t)
1495 __GLXcontext * const gc = __glXGetCurrentContext();
1496 Display * const dpy = gc->currentDpy;
1497 const GLuint cmdlen = 12;
1499 emit_header(gc->pc, X_GLrop_TexCoord2fv, cmdlen);
1500 (void) memcpy((void *)(gc->pc + 4), (void *)(&s), 4);
1501 (void) memcpy((void *)(gc->pc + 8), (void *)(&t), 4);
1503 if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
1506 #define X_GLrop_TexCoord2fv 54
1508 __indirect_glTexCoord2fv(const GLfloat * v)
1510 generic_8_byte( X_GLrop_TexCoord2fv, v );
1513 #define X_GLrop_TexCoord2iv 55
1515 __indirect_glTexCoord2i(GLint s, GLint t)
1517 __GLXcontext * const gc = __glXGetCurrentContext();
1518 Display * const dpy = gc->currentDpy;
1519 const GLuint cmdlen = 12;
1521 emit_header(gc->pc, X_GLrop_TexCoord2iv, cmdlen);
1522 (void) memcpy((void *)(gc->pc + 4), (void *)(&s), 4);
1523 (void) memcpy((void *)(gc->pc + 8), (void *)(&t), 4);
1525 if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
1528 #define X_GLrop_TexCoord2iv 55
1530 __indirect_glTexCoord2iv(const GLint * v)
1532 generic_8_byte( X_GLrop_TexCoord2iv, v );
1535 #define X_GLrop_TexCoord2sv 56
1537 __indirect_glTexCoord2s(GLshort s, GLshort t)
1539 __GLXcontext * const gc = __glXGetCurrentContext();
1540 Display * const dpy = gc->currentDpy;
1541 const GLuint cmdlen = 8;
1543 emit_header(gc->pc, X_GLrop_TexCoord2sv, cmdlen);
1544 (void) memcpy((void *)(gc->pc + 4), (void *)(&s), 2);
1545 (void) memcpy((void *)(gc->pc + 6), (void *)(&t), 2);
1547 if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
1550 #define X_GLrop_TexCoord2sv 56
1552 __indirect_glTexCoord2sv(const GLshort * v)
1554 generic_4_byte( X_GLrop_TexCoord2sv, v );
1557 #define X_GLrop_TexCoord3dv 57
1559 __indirect_glTexCoord3d(GLdouble s, GLdouble t, GLdouble r)
1561 __GLXcontext * const gc = __glXGetCurrentContext();
1562 Display * const dpy = gc->currentDpy;
1563 const GLuint cmdlen = 28;
1565 emit_header(gc->pc, X_GLrop_TexCoord3dv, cmdlen);
1566 (void) memcpy((void *)(gc->pc + 4), (void *)(&s), 8);
1567 (void) memcpy((void *)(gc->pc + 12), (void *)(&t), 8);
1568 (void) memcpy((void *)(gc->pc + 20), (void *)(&r), 8);
1570 if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
1573 #define X_GLrop_TexCoord3dv 57
1575 __indirect_glTexCoord3dv(const GLdouble * v)
1577 generic_24_byte( X_GLrop_TexCoord3dv, v );
1580 #define X_GLrop_TexCoord3fv 58
1582 __indirect_glTexCoord3f(GLfloat s, GLfloat t, GLfloat r)
1584 __GLXcontext * const gc = __glXGetCurrentContext();
1585 Display * const dpy = gc->currentDpy;
1586 const GLuint cmdlen = 16;
1588 emit_header(gc->pc, X_GLrop_TexCoord3fv, cmdlen);
1589 (void) memcpy((void *)(gc->pc + 4), (void *)(&s), 4);
1590 (void) memcpy((void *)(gc->pc + 8), (void *)(&t), 4);
1591 (void) memcpy((void *)(gc->pc + 12), (void *)(&r), 4);
1593 if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
1596 #define X_GLrop_TexCoord3fv 58
1598 __indirect_glTexCoord3fv(const GLfloat * v)
1600 generic_12_byte( X_GLrop_TexCoord3fv, v );
1603 #define X_GLrop_TexCoord3iv 59
1605 __indirect_glTexCoord3i(GLint s, GLint t, GLint r)
1607 __GLXcontext * const gc = __glXGetCurrentContext();
1608 Display * const dpy = gc->currentDpy;
1609 const GLuint cmdlen = 16;
1611 emit_header(gc->pc, X_GLrop_TexCoord3iv, cmdlen);
1612 (void) memcpy((void *)(gc->pc + 4), (void *)(&s), 4);
1613 (void) memcpy((void *)(gc->pc + 8), (void *)(&t), 4);
1614 (void) memcpy((void *)(gc->pc + 12), (void *)(&r), 4);
1616 if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
1619 #define X_GLrop_TexCoord3iv 59
1621 __indirect_glTexCoord3iv(const GLint * v)
1623 generic_12_byte( X_GLrop_TexCoord3iv, v );
1626 #define X_GLrop_TexCoord3sv 60
1628 __indirect_glTexCoord3s(GLshort s, GLshort t, GLshort r)
1630 __GLXcontext * const gc = __glXGetCurrentContext();
1631 Display * const dpy = gc->currentDpy;
1632 const GLuint cmdlen = 12;
1634 emit_header(gc->pc, X_GLrop_TexCoord3sv, cmdlen);
1635 (void) memcpy((void *)(gc->pc + 4), (void *)(&s), 2);
1636 (void) memcpy((void *)(gc->pc + 6), (void *)(&t), 2);
1637 (void) memcpy((void *)(gc->pc + 8), (void *)(&r), 2);
1639 if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
1642 #define X_GLrop_TexCoord3sv 60
1644 __indirect_glTexCoord3sv(const GLshort * v)
1646 generic_6_byte( X_GLrop_TexCoord3sv, v );
1649 #define X_GLrop_TexCoord4dv 61
1651 __indirect_glTexCoord4d(GLdouble s, GLdouble t, GLdouble r, GLdouble q)
1653 __GLXcontext * const gc = __glXGetCurrentContext();
1654 Display * const dpy = gc->currentDpy;
1655 const GLuint cmdlen = 36;
1657 emit_header(gc->pc, X_GLrop_TexCoord4dv, cmdlen);
1658 (void) memcpy((void *)(gc->pc + 4), (void *)(&s), 8);
1659 (void) memcpy((void *)(gc->pc + 12), (void *)(&t), 8);
1660 (void) memcpy((void *)(gc->pc + 20), (void *)(&r), 8);
1661 (void) memcpy((void *)(gc->pc + 28), (void *)(&q), 8);
1663 if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
1666 #define X_GLrop_TexCoord4dv 61
1668 __indirect_glTexCoord4dv(const GLdouble * v)
1670 generic_32_byte( X_GLrop_TexCoord4dv, v );
1673 #define X_GLrop_TexCoord4fv 62
1675 __indirect_glTexCoord4f(GLfloat s, GLfloat t, GLfloat r, GLfloat q)
1677 __GLXcontext * const gc = __glXGetCurrentContext();
1678 Display * const dpy = gc->currentDpy;
1679 const GLuint cmdlen = 20;
1681 emit_header(gc->pc, X_GLrop_TexCoord4fv, cmdlen);
1682 (void) memcpy((void *)(gc->pc + 4), (void *)(&s), 4);
1683 (void) memcpy((void *)(gc->pc + 8), (void *)(&t), 4);
1684 (void) memcpy((void *)(gc->pc + 12), (void *)(&r), 4);
1685 (void) memcpy((void *)(gc->pc + 16), (void *)(&q), 4);
1687 if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
1690 #define X_GLrop_TexCoord4fv 62
1692 __indirect_glTexCoord4fv(const GLfloat * v)
1694 generic_16_byte( X_GLrop_TexCoord4fv, v );
1697 #define X_GLrop_TexCoord4iv 63
1699 __indirect_glTexCoord4i(GLint s, GLint t, GLint r, GLint q)
1701 __GLXcontext * const gc = __glXGetCurrentContext();
1702 Display * const dpy = gc->currentDpy;
1703 const GLuint cmdlen = 20;
1705 emit_header(gc->pc, X_GLrop_TexCoord4iv, cmdlen);
1706 (void) memcpy((void *)(gc->pc + 4), (void *)(&s), 4);
1707 (void) memcpy((void *)(gc->pc + 8), (void *)(&t), 4);
1708 (void) memcpy((void *)(gc->pc + 12), (void *)(&r), 4);
1709 (void) memcpy((void *)(gc->pc + 16), (void *)(&q), 4);
1711 if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
1714 #define X_GLrop_TexCoord4iv 63
1716 __indirect_glTexCoord4iv(const GLint * v)
1718 generic_16_byte( X_GLrop_TexCoord4iv, v );
1721 #define X_GLrop_TexCoord4sv 64
1723 __indirect_glTexCoord4s(GLshort s, GLshort t, GLshort r, GLshort q)
1725 __GLXcontext * const gc = __glXGetCurrentContext();
1726 Display * const dpy = gc->currentDpy;
1727 const GLuint cmdlen = 12;
1729 emit_header(gc->pc, X_GLrop_TexCoord4sv, cmdlen);
1730 (void) memcpy((void *)(gc->pc + 4), (void *)(&s), 2);
1731 (void) memcpy((void *)(gc->pc + 6), (void *)(&t), 2);
1732 (void) memcpy((void *)(gc->pc + 8), (void *)(&r), 2);
1733 (void) memcpy((void *)(gc->pc + 10), (void *)(&q), 2);
1735 if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
1738 #define X_GLrop_TexCoord4sv 64
1740 __indirect_glTexCoord4sv(const GLshort * v)
1742 generic_8_byte( X_GLrop_TexCoord4sv, v );
1745 #define X_GLrop_Vertex2dv 65
1747 __indirect_glVertex2d(GLdouble x, GLdouble y)
1749 __GLXcontext * const gc = __glXGetCurrentContext();
1750 Display * const dpy = gc->currentDpy;
1751 const GLuint cmdlen = 20;
1753 emit_header(gc->pc, X_GLrop_Vertex2dv, cmdlen);
1754 (void) memcpy((void *)(gc->pc + 4), (void *)(&x), 8);
1755 (void) memcpy((void *)(gc->pc + 12), (void *)(&y), 8);
1757 if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
1760 #define X_GLrop_Vertex2dv 65
1762 __indirect_glVertex2dv(const GLdouble * v)
1764 generic_16_byte( X_GLrop_Vertex2dv, v );
1767 #define X_GLrop_Vertex2fv 66
1769 __indirect_glVertex2f(GLfloat x, GLfloat y)
1771 __GLXcontext * const gc = __glXGetCurrentContext();
1772 Display * const dpy = gc->currentDpy;
1773 const GLuint cmdlen = 12;
1775 emit_header(gc->pc, X_GLrop_Vertex2fv, cmdlen);
1776 (void) memcpy((void *)(gc->pc + 4), (void *)(&x), 4);
1777 (void) memcpy((void *)(gc->pc + 8), (void *)(&y), 4);
1779 if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
1782 #define X_GLrop_Vertex2fv 66
1784 __indirect_glVertex2fv(const GLfloat * v)
1786 generic_8_byte( X_GLrop_Vertex2fv, v );
1789 #define X_GLrop_Vertex2iv 67
1791 __indirect_glVertex2i(GLint x, GLint y)
1793 __GLXcontext * const gc = __glXGetCurrentContext();
1794 Display * const dpy = gc->currentDpy;
1795 const GLuint cmdlen = 12;
1797 emit_header(gc->pc, X_GLrop_Vertex2iv, cmdlen);
1798 (void) memcpy((void *)(gc->pc + 4), (void *)(&x), 4);
1799 (void) memcpy((void *)(gc->pc + 8), (void *)(&y), 4);
1801 if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
1804 #define X_GLrop_Vertex2iv 67
1806 __indirect_glVertex2iv(const GLint * v)
1808 generic_8_byte( X_GLrop_Vertex2iv, v );
1811 #define X_GLrop_Vertex2sv 68
1813 __indirect_glVertex2s(GLshort x, GLshort y)
1815 __GLXcontext * const gc = __glXGetCurrentContext();
1816 Display * const dpy = gc->currentDpy;
1817 const GLuint cmdlen = 8;
1819 emit_header(gc->pc, X_GLrop_Vertex2sv, cmdlen);
1820 (void) memcpy((void *)(gc->pc + 4), (void *)(&x), 2);
1821 (void) memcpy((void *)(gc->pc + 6), (void *)(&y), 2);
1823 if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
1826 #define X_GLrop_Vertex2sv 68
1828 __indirect_glVertex2sv(const GLshort * v)
1830 generic_4_byte( X_GLrop_Vertex2sv, v );
1833 #define X_GLrop_Vertex3dv 69
1835 __indirect_glVertex3d(GLdouble x, GLdouble y, GLdouble z)
1837 __GLXcontext * const gc = __glXGetCurrentContext();
1838 Display * const dpy = gc->currentDpy;
1839 const GLuint cmdlen = 28;
1841 emit_header(gc->pc, X_GLrop_Vertex3dv, cmdlen);
1842 (void) memcpy((void *)(gc->pc + 4), (void *)(&x), 8);
1843 (void) memcpy((void *)(gc->pc + 12), (void *)(&y), 8);
1844 (void) memcpy((void *)(gc->pc + 20), (void *)(&z), 8);
1846 if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
1849 #define X_GLrop_Vertex3dv 69
1851 __indirect_glVertex3dv(const GLdouble * v)
1853 generic_24_byte( X_GLrop_Vertex3dv, v );
1856 #define X_GLrop_Vertex3fv 70
1858 __indirect_glVertex3f(GLfloat x, GLfloat y, GLfloat z)
1860 __GLXcontext * const gc = __glXGetCurrentContext();
1861 Display * const dpy = gc->currentDpy;
1862 const GLuint cmdlen = 16;
1864 emit_header(gc->pc, X_GLrop_Vertex3fv, cmdlen);
1865 (void) memcpy((void *)(gc->pc + 4), (void *)(&x), 4);
1866 (void) memcpy((void *)(gc->pc + 8), (void *)(&y), 4);
1867 (void) memcpy((void *)(gc->pc + 12), (void *)(&z), 4);
1869 if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
1872 #define X_GLrop_Vertex3fv 70
1874 __indirect_glVertex3fv(const GLfloat * v)
1876 generic_12_byte( X_GLrop_Vertex3fv, v );
1879 #define X_GLrop_Vertex3iv 71
1881 __indirect_glVertex3i(GLint x, GLint y, GLint z)
1883 __GLXcontext * const gc = __glXGetCurrentContext();
1884 Display * const dpy = gc->currentDpy;
1885 const GLuint cmdlen = 16;
1887 emit_header(gc->pc, X_GLrop_Vertex3iv, cmdlen);
1888 (void) memcpy((void *)(gc->pc + 4), (void *)(&x), 4);
1889 (void) memcpy((void *)(gc->pc + 8), (void *)(&y), 4);
1890 (void) memcpy((void *)(gc->pc + 12), (void *)(&z), 4);
1892 if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
1895 #define X_GLrop_Vertex3iv 71
1897 __indirect_glVertex3iv(const GLint * v)
1899 generic_12_byte( X_GLrop_Vertex3iv, v );
1902 #define X_GLrop_Vertex3sv 72
1904 __indirect_glVertex3s(GLshort x, GLshort y, GLshort z)
1906 __GLXcontext * const gc = __glXGetCurrentContext();
1907 Display * const dpy = gc->currentDpy;
1908 const GLuint cmdlen = 12;
1910 emit_header(gc->pc, X_GLrop_Vertex3sv, cmdlen);
1911 (void) memcpy((void *)(gc->pc + 4), (void *)(&x), 2);
1912 (void) memcpy((void *)(gc->pc + 6), (void *)(&y), 2);
1913 (void) memcpy((void *)(gc->pc + 8), (void *)(&z), 2);
1915 if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
1918 #define X_GLrop_Vertex3sv 72
1920 __indirect_glVertex3sv(const GLshort * v)
1922 generic_6_byte( X_GLrop_Vertex3sv, v );
1925 #define X_GLrop_Vertex4dv 73
1927 __indirect_glVertex4d(GLdouble x, GLdouble y, GLdouble z, GLdouble w)
1929 __GLXcontext * const gc = __glXGetCurrentContext();
1930 Display * const dpy = gc->currentDpy;
1931 const GLuint cmdlen = 36;
1933 emit_header(gc->pc, X_GLrop_Vertex4dv, cmdlen);
1934 (void) memcpy((void *)(gc->pc + 4), (void *)(&x), 8);
1935 (void) memcpy((void *)(gc->pc + 12), (void *)(&y), 8);
1936 (void) memcpy((void *)(gc->pc + 20), (void *)(&z), 8);
1937 (void) memcpy((void *)(gc->pc + 28), (void *)(&w), 8);
1939 if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
1942 #define X_GLrop_Vertex4dv 73
1944 __indirect_glVertex4dv(const GLdouble * v)
1946 generic_32_byte( X_GLrop_Vertex4dv, v );
1949 #define X_GLrop_Vertex4fv 74
1951 __indirect_glVertex4f(GLfloat x, GLfloat y, GLfloat z, GLfloat w)
1953 __GLXcontext * const gc = __glXGetCurrentContext();
1954 Display * const dpy = gc->currentDpy;
1955 const GLuint cmdlen = 20;
1957 emit_header(gc->pc, X_GLrop_Vertex4fv, cmdlen);
1958 (void) memcpy((void *)(gc->pc + 4), (void *)(&x), 4);
1959 (void) memcpy((void *)(gc->pc + 8), (void *)(&y), 4);
1960 (void) memcpy((void *)(gc->pc + 12), (void *)(&z), 4);
1961 (void) memcpy((void *)(gc->pc + 16), (void *)(&w), 4);
1963 if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
1966 #define X_GLrop_Vertex4fv 74
1968 __indirect_glVertex4fv(const GLfloat * v)
1970 generic_16_byte( X_GLrop_Vertex4fv, v );
1973 #define X_GLrop_Vertex4iv 75
1975 __indirect_glVertex4i(GLint x, GLint y, GLint z, GLint w)
1977 __GLXcontext * const gc = __glXGetCurrentContext();
1978 Display * const dpy = gc->currentDpy;
1979 const GLuint cmdlen = 20;
1981 emit_header(gc->pc, X_GLrop_Vertex4iv, cmdlen);
1982 (void) memcpy((void *)(gc->pc + 4), (void *)(&x), 4);
1983 (void) memcpy((void *)(gc->pc + 8), (void *)(&y), 4);
1984 (void) memcpy((void *)(gc->pc + 12), (void *)(&z), 4);
1985 (void) memcpy((void *)(gc->pc + 16), (void *)(&w), 4);
1987 if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
1990 #define X_GLrop_Vertex4iv 75
1992 __indirect_glVertex4iv(const GLint * v)
1994 generic_16_byte( X_GLrop_Vertex4iv, v );
1997 #define X_GLrop_Vertex4sv 76
1999 __indirect_glVertex4s(GLshort x, GLshort y, GLshort z, GLshort w)
2001 __GLXcontext * const gc = __glXGetCurrentContext();
2002 Display * const dpy = gc->currentDpy;
2003 const GLuint cmdlen = 12;
2005 emit_header(gc->pc, X_GLrop_Vertex4sv, cmdlen);
2006 (void) memcpy((void *)(gc->pc + 4), (void *)(&x), 2);
2007 (void) memcpy((void *)(gc->pc + 6), (void *)(&y), 2);
2008 (void) memcpy((void *)(gc->pc + 8), (void *)(&z), 2);
2009 (void) memcpy((void *)(gc->pc + 10), (void *)(&w), 2);
2011 if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
2014 #define X_GLrop_Vertex4sv 76
2016 __indirect_glVertex4sv(const GLshort * v)
2018 generic_8_byte( X_GLrop_Vertex4sv, v );
2021 #define X_GLrop_ClipPlane 77
2023 __indirect_glClipPlane(GLenum plane, const GLdouble * equation)
2025 __GLXcontext * const gc = __glXGetCurrentContext();
2026 Display * const dpy = gc->currentDpy;
2027 const GLuint cmdlen = 40;
2029 emit_header(gc->pc, X_GLrop_ClipPlane, cmdlen);
2030 (void) memcpy((void *)(gc->pc + 4), (void *)(equation), 32);
2031 (void) memcpy((void *)(gc->pc + 36), (void *)(&plane), 4);
2033 if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
2036 #define X_GLrop_ColorMaterial 78
2038 __indirect_glColorMaterial(GLenum face, GLenum mode)
2040 __GLXcontext * const gc = __glXGetCurrentContext();
2041 Display * const dpy = gc->currentDpy;
2042 const GLuint cmdlen = 12;
2044 emit_header(gc->pc, X_GLrop_ColorMaterial, cmdlen);
2045 (void) memcpy((void *)(gc->pc + 4), (void *)(&face), 4);
2046 (void) memcpy((void *)(gc->pc + 8), (void *)(&mode), 4);
2048 if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
2051 #define X_GLrop_CullFace 79
2053 __indirect_glCullFace(GLenum mode)
2055 __GLXcontext * const gc = __glXGetCurrentContext();
2056 Display * const dpy = gc->currentDpy;
2057 const GLuint cmdlen = 8;
2059 emit_header(gc->pc, X_GLrop_CullFace, cmdlen);
2060 (void) memcpy((void *)(gc->pc + 4), (void *)(&mode), 4);
2062 if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
2065 #define X_GLrop_Fogf 80
2067 __indirect_glFogf(GLenum pname, GLfloat param)
2069 __GLXcontext * const gc = __glXGetCurrentContext();
2070 Display * const dpy = gc->currentDpy;
2071 const GLuint cmdlen = 12;
2073 emit_header(gc->pc, X_GLrop_Fogf, cmdlen);
2074 (void) memcpy((void *)(gc->pc + 4), (void *)(&pname), 4);
2075 (void) memcpy((void *)(gc->pc + 8), (void *)(¶m), 4);
2077 if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
2080 #define X_GLrop_Fogfv 81
2082 __indirect_glFogfv(GLenum pname, const GLfloat * params)
2084 __GLXcontext * const gc = __glXGetCurrentContext();
2085 Display * const dpy = gc->currentDpy;
2086 const GLuint compsize = __glFogfv_size(pname);
2087 const GLuint cmdlen = 8 + __GLX_PAD((compsize * 4));
2089 emit_header(gc->pc, X_GLrop_Fogfv, cmdlen);
2090 (void) memcpy((void *)(gc->pc + 4), (void *)(&pname), 4);
2091 (void) memcpy((void *)(gc->pc + 8), (void *)(params), (compsize * 4));
2093 if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
2096 #define X_GLrop_Fogi 82
2098 __indirect_glFogi(GLenum pname, GLint param)
2100 __GLXcontext * const gc = __glXGetCurrentContext();
2101 Display * const dpy = gc->currentDpy;
2102 const GLuint cmdlen = 12;
2104 emit_header(gc->pc, X_GLrop_Fogi, cmdlen);
2105 (void) memcpy((void *)(gc->pc + 4), (void *)(&pname), 4);
2106 (void) memcpy((void *)(gc->pc + 8), (void *)(¶m), 4);
2108 if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
2111 #define X_GLrop_Fogiv 83
2113 __indirect_glFogiv(GLenum pname, const GLint * params)
2115 __GLXcontext * const gc = __glXGetCurrentContext();
2116 Display * const dpy = gc->currentDpy;
2117 const GLuint compsize = __glFogiv_size(pname);
2118 const GLuint cmdlen = 8 + __GLX_PAD((compsize * 4));
2120 emit_header(gc->pc, X_GLrop_Fogiv, cmdlen);
2121 (void) memcpy((void *)(gc->pc + 4), (void *)(&pname), 4);
2122 (void) memcpy((void *)(gc->pc + 8), (void *)(params), (compsize * 4));
2124 if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
2127 #define X_GLrop_FrontFace 84
2129 __indirect_glFrontFace(GLenum mode)
2131 __GLXcontext * const gc = __glXGetCurrentContext();
2132 Display * const dpy = gc->currentDpy;
2133 const GLuint cmdlen = 8;
2135 emit_header(gc->pc, X_GLrop_FrontFace, cmdlen);
2136 (void) memcpy((void *)(gc->pc + 4), (void *)(&mode), 4);
2138 if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
2141 #define X_GLrop_Hint 85
2143 __indirect_glHint(GLenum target, GLenum mode)
2145 __GLXcontext * const gc = __glXGetCurrentContext();
2146 Display * const dpy = gc->currentDpy;
2147 const GLuint cmdlen = 12;
2149 emit_header(gc->pc, X_GLrop_Hint, cmdlen);
2150 (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
2151 (void) memcpy((void *)(gc->pc + 8), (void *)(&mode), 4);
2153 if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
2156 #define X_GLrop_Lightf 86
2158 __indirect_glLightf(GLenum light, GLenum pname, GLfloat param)
2160 __GLXcontext * const gc = __glXGetCurrentContext();
2161 Display * const dpy = gc->currentDpy;
2162 const GLuint cmdlen = 16;
2164 emit_header(gc->pc, X_GLrop_Lightf, cmdlen);
2165 (void) memcpy((void *)(gc->pc + 4), (void *)(&light), 4);
2166 (void) memcpy((void *)(gc->pc + 8), (void *)(&pname), 4);
2167 (void) memcpy((void *)(gc->pc + 12), (void *)(¶m), 4);
2169 if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
2172 #define X_GLrop_Lightfv 87
2174 __indirect_glLightfv(GLenum light, GLenum pname, const GLfloat * params)
2176 __GLXcontext * const gc = __glXGetCurrentContext();
2177 Display * const dpy = gc->currentDpy;
2178 const GLuint compsize = __glLightfv_size(pname);
2179 const GLuint cmdlen = 12 + __GLX_PAD((compsize * 4));
2181 emit_header(gc->pc, X_GLrop_Lightfv, cmdlen);
2182 (void) memcpy((void *)(gc->pc + 4), (void *)(&light), 4);
2183 (void) memcpy((void *)(gc->pc + 8), (void *)(&pname), 4);
2184 (void) memcpy((void *)(gc->pc + 12), (void *)(params), (compsize * 4));
2186 if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
2189 #define X_GLrop_Lighti 88
2191 __indirect_glLighti(GLenum light, GLenum pname, GLint param)
2193 __GLXcontext * const gc = __glXGetCurrentContext();
2194 Display * const dpy = gc->currentDpy;
2195 const GLuint cmdlen = 16;
2197 emit_header(gc->pc, X_GLrop_Lighti, cmdlen);
2198 (void) memcpy((void *)(gc->pc + 4), (void *)(&light), 4);
2199 (void) memcpy((void *)(gc->pc + 8), (void *)(&pname), 4);
2200 (void) memcpy((void *)(gc->pc + 12), (void *)(¶m), 4);
2202 if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
2205 #define X_GLrop_Lightiv 89
2207 __indirect_glLightiv(GLenum light, GLenum pname, const GLint * params)
2209 __GLXcontext * const gc = __glXGetCurrentContext();
2210 Display * const dpy = gc->currentDpy;
2211 const GLuint compsize = __glLightiv_size(pname);
2212 const GLuint cmdlen = 12 + __GLX_PAD((compsize * 4));
2214 emit_header(gc->pc, X_GLrop_Lightiv, cmdlen);
2215 (void) memcpy((void *)(gc->pc + 4), (void *)(&light), 4);
2216 (void) memcpy((void *)(gc->pc + 8), (void *)(&pname), 4);
2217 (void) memcpy((void *)(gc->pc + 12), (void *)(params), (compsize * 4));
2219 if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
2222 #define X_GLrop_LightModelf 90
2224 __indirect_glLightModelf(GLenum pname, GLfloat param)
2226 __GLXcontext * const gc = __glXGetCurrentContext();
2227 Display * const dpy = gc->currentDpy;
2228 const GLuint cmdlen = 12;
2230 emit_header(gc->pc, X_GLrop_LightModelf, cmdlen);
2231 (void) memcpy((void *)(gc->pc + 4), (void *)(&pname), 4);
2232 (void) memcpy((void *)(gc->pc + 8), (void *)(¶m), 4);
2234 if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
2237 #define X_GLrop_LightModelfv 91
2239 __indirect_glLightModelfv(GLenum pname, const GLfloat * params)
2241 __GLXcontext * const gc = __glXGetCurrentContext();
2242 Display * const dpy = gc->currentDpy;
2243 const GLuint compsize = __glLightModelfv_size(pname);
2244 const GLuint cmdlen = 8 + __GLX_PAD((compsize * 4));
2246 emit_header(gc->pc, X_GLrop_LightModelfv, cmdlen);
2247 (void) memcpy((void *)(gc->pc + 4), (void *)(&pname), 4);
2248 (void) memcpy((void *)(gc->pc + 8), (void *)(params), (compsize * 4));
2250 if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
2253 #define X_GLrop_LightModeli 92
2255 __indirect_glLightModeli(GLenum pname, GLint param)
2257 __GLXcontext * const gc = __glXGetCurrentContext();
2258 Display * const dpy = gc->currentDpy;
2259 const GLuint cmdlen = 12;
2261 emit_header(gc->pc, X_GLrop_LightModeli, cmdlen);
2262 (void) memcpy((void *)(gc->pc + 4), (void *)(&pname), 4);
2263 (void) memcpy((void *)(gc->pc + 8), (void *)(¶m), 4);
2265 if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
2268 #define X_GLrop_LightModeliv 93
2270 __indirect_glLightModeliv(GLenum pname, const GLint * params)
2272 __GLXcontext * const gc = __glXGetCurrentContext();
2273 Display * const dpy = gc->currentDpy;
2274 const GLuint compsize = __glLightModeliv_size(pname);
2275 const GLuint cmdlen = 8 + __GLX_PAD((compsize * 4));
2277 emit_header(gc->pc, X_GLrop_LightModeliv, cmdlen);
2278 (void) memcpy((void *)(gc->pc + 4), (void *)(&pname), 4);
2279 (void) memcpy((void *)(gc->pc + 8), (void *)(params), (compsize * 4));
2281 if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
2284 #define X_GLrop_LineStipple 94
2286 __indirect_glLineStipple(GLint factor, GLushort pattern)
2288 __GLXcontext * const gc = __glXGetCurrentContext();
2289 Display * const dpy = gc->currentDpy;
2290 const GLuint cmdlen = 12;
2292 emit_header(gc->pc, X_GLrop_LineStipple, cmdlen);
2293 (void) memcpy((void *)(gc->pc + 4), (void *)(&factor), 4);
2294 (void) memcpy((void *)(gc->pc + 8), (void *)(&pattern), 2);
2296 if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
2299 #define X_GLrop_LineWidth 95
2301 __indirect_glLineWidth(GLfloat width)
2303 __GLXcontext * const gc = __glXGetCurrentContext();
2304 Display * const dpy = gc->currentDpy;
2305 const GLuint cmdlen = 8;
2307 emit_header(gc->pc, X_GLrop_LineWidth, cmdlen);
2308 (void) memcpy((void *)(gc->pc + 4), (void *)(&width), 4);
2310 if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
2313 #define X_GLrop_Materialf 96
2315 __indirect_glMaterialf(GLenum face, GLenum pname, GLfloat param)
2317 __GLXcontext * const gc = __glXGetCurrentContext();
2318 Display * const dpy = gc->currentDpy;
2319 const GLuint cmdlen = 16;
2321 emit_header(gc->pc, X_GLrop_Materialf, cmdlen);
2322 (void) memcpy((void *)(gc->pc + 4), (void *)(&face), 4);
2323 (void) memcpy((void *)(gc->pc + 8), (void *)(&pname), 4);
2324 (void) memcpy((void *)(gc->pc + 12), (void *)(¶m), 4);
2326 if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
2329 #define X_GLrop_Materialfv 97
2331 __indirect_glMaterialfv(GLenum face, GLenum pname, const GLfloat * params)
2333 __GLXcontext * const gc = __glXGetCurrentContext();
2334 Display * const dpy = gc->currentDpy;
2335 const GLuint compsize = __glMaterialfv_size(pname);
2336 const GLuint cmdlen = 12 + __GLX_PAD((compsize * 4));
2338 emit_header(gc->pc, X_GLrop_Materialfv, cmdlen);
2339 (void) memcpy((void *)(gc->pc + 4), (void *)(&face), 4);
2340 (void) memcpy((void *)(gc->pc + 8), (void *)(&pname), 4);
2341 (void) memcpy((void *)(gc->pc + 12), (void *)(params), (compsize * 4));
2343 if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
2346 #define X_GLrop_Materiali 98
2348 __indirect_glMateriali(GLenum face, GLenum pname, GLint param)
2350 __GLXcontext * const gc = __glXGetCurrentContext();
2351 Display * const dpy = gc->currentDpy;
2352 const GLuint cmdlen = 16;
2354 emit_header(gc->pc, X_GLrop_Materiali, cmdlen);
2355 (void) memcpy((void *)(gc->pc + 4), (void *)(&face), 4);
2356 (void) memcpy((void *)(gc->pc + 8), (void *)(&pname), 4);
2357 (void) memcpy((void *)(gc->pc + 12), (void *)(¶m), 4);
2359 if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
2362 #define X_GLrop_Materialiv 99
2364 __indirect_glMaterialiv(GLenum face, GLenum pname, const GLint * params)
2366 __GLXcontext * const gc = __glXGetCurrentContext();
2367 Display * const dpy = gc->currentDpy;
2368 const GLuint compsize = __glMaterialiv_size(pname);
2369 const GLuint cmdlen = 12 + __GLX_PAD((compsize * 4));
2371 emit_header(gc->pc, X_GLrop_Materialiv, cmdlen);
2372 (void) memcpy((void *)(gc->pc + 4), (void *)(&face), 4);
2373 (void) memcpy((void *)(gc->pc + 8), (void *)(&pname), 4);
2374 (void) memcpy((void *)(gc->pc + 12), (void *)(params), (compsize * 4));
2376 if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
2379 #define X_GLrop_PointSize 100
2381 __indirect_glPointSize(GLfloat size)
2383 __GLXcontext * const gc = __glXGetCurrentContext();
2384 Display * const dpy = gc->currentDpy;
2385 const GLuint cmdlen = 8;
2387 emit_header(gc->pc, X_GLrop_PointSize, cmdlen);
2388 (void) memcpy((void *)(gc->pc + 4), (void *)(&size), 4);
2390 if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
2393 #define X_GLrop_PolygonMode 101
2395 __indirect_glPolygonMode(GLenum face, GLenum mode)
2397 __GLXcontext * const gc = __glXGetCurrentContext();
2398 Display * const dpy = gc->currentDpy;
2399 const GLuint cmdlen = 12;
2401 emit_header(gc->pc, X_GLrop_PolygonMode, cmdlen);
2402 (void) memcpy((void *)(gc->pc + 4), (void *)(&face), 4);
2403 (void) memcpy((void *)(gc->pc + 8), (void *)(&mode), 4);
2405 if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
2408 #define X_GLrop_Scissor 103
2410 __indirect_glScissor(GLint x, GLint y, GLsizei width, GLsizei height)
2412 __GLXcontext * const gc = __glXGetCurrentContext();
2413 Display * const dpy = gc->currentDpy;
2414 const GLuint cmdlen = 20;
2416 emit_header(gc->pc, X_GLrop_Scissor, cmdlen);
2417 (void) memcpy((void *)(gc->pc + 4), (void *)(&x), 4);
2418 (void) memcpy((void *)(gc->pc + 8), (void *)(&y), 4);
2419 (void) memcpy((void *)(gc->pc + 12), (void *)(&width), 4);
2420 (void) memcpy((void *)(gc->pc + 16), (void *)(&height), 4);
2422 if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
2425 #define X_GLrop_ShadeModel 104
2427 __indirect_glShadeModel(GLenum mode)
2429 __GLXcontext * const gc = __glXGetCurrentContext();
2430 Display * const dpy = gc->currentDpy;
2431 const GLuint cmdlen = 8;
2433 emit_header(gc->pc, X_GLrop_ShadeModel, cmdlen);
2434 (void) memcpy((void *)(gc->pc + 4), (void *)(&mode), 4);
2436 if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
2439 #define X_GLrop_TexParameterf 105
2441 __indirect_glTexParameterf(GLenum target, GLenum pname, GLfloat param)
2443 __GLXcontext * const gc = __glXGetCurrentContext();
2444 Display * const dpy = gc->currentDpy;
2445 const GLuint cmdlen = 16;
2447 emit_header(gc->pc, X_GLrop_TexParameterf, cmdlen);
2448 (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
2449 (void) memcpy((void *)(gc->pc + 8), (void *)(&pname), 4);
2450 (void) memcpy((void *)(gc->pc + 12), (void *)(¶m), 4);
2452 if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
2455 #define X_GLrop_TexParameterfv 106
2457 __indirect_glTexParameterfv(GLenum target, GLenum pname, const GLfloat * params)
2459 __GLXcontext * const gc = __glXGetCurrentContext();
2460 Display * const dpy = gc->currentDpy;
2461 const GLuint compsize = __glTexParameterfv_size(pname);
2462 const GLuint cmdlen = 12 + __GLX_PAD((compsize * 4));
2464 emit_header(gc->pc, X_GLrop_TexParameterfv, cmdlen);
2465 (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
2466 (void) memcpy((void *)(gc->pc + 8), (void *)(&pname), 4);
2467 (void) memcpy((void *)(gc->pc + 12), (void *)(params), (compsize * 4));
2469 if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
2472 #define X_GLrop_TexParameteri 107
2474 __indirect_glTexParameteri(GLenum target, GLenum pname, GLint param)
2476 __GLXcontext * const gc = __glXGetCurrentContext();
2477 Display * const dpy = gc->currentDpy;
2478 const GLuint cmdlen = 16;
2480 emit_header(gc->pc, X_GLrop_TexParameteri, cmdlen);
2481 (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
2482 (void) memcpy((void *)(gc->pc + 8), (void *)(&pname), 4);
2483 (void) memcpy((void *)(gc->pc + 12), (void *)(¶m), 4);
2485 if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
2488 #define X_GLrop_TexParameteriv 108
2490 __indirect_glTexParameteriv(GLenum target, GLenum pname, const GLint * params)
2492 __GLXcontext * const gc = __glXGetCurrentContext();
2493 Display * const dpy = gc->currentDpy;
2494 const GLuint compsize = __glTexParameteriv_size(pname);
2495 const GLuint cmdlen = 12 + __GLX_PAD((compsize * 4));
2497 emit_header(gc->pc, X_GLrop_TexParameteriv, cmdlen);
2498 (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
2499 (void) memcpy((void *)(gc->pc + 8), (void *)(&pname), 4);
2500 (void) memcpy((void *)(gc->pc + 12), (void *)(params), (compsize * 4));
2502 if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
2505 #define X_GLrop_TexEnvf 111
2507 __indirect_glTexEnvf(GLenum target, GLenum pname, GLfloat param)
2509 __GLXcontext * const gc = __glXGetCurrentContext();
2510 Display * const dpy = gc->currentDpy;
2511 const GLuint cmdlen = 16;
2513 emit_header(gc->pc, X_GLrop_TexEnvf, cmdlen);
2514 (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
2515 (void) memcpy((void *)(gc->pc + 8), (void *)(&pname), 4);
2516 (void) memcpy((void *)(gc->pc + 12), (void *)(¶m), 4);
2518 if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
2521 #define X_GLrop_TexEnvfv 112
2523 __indirect_glTexEnvfv(GLenum target, GLenum pname, const GLfloat * params)
2525 __GLXcontext * const gc = __glXGetCurrentContext();
2526 Display * const dpy = gc->currentDpy;
2527 const GLuint compsize = __glTexEnvfv_size(pname);
2528 const GLuint cmdlen = 12 + __GLX_PAD((compsize * 4));
2530 emit_header(gc->pc, X_GLrop_TexEnvfv, cmdlen);
2531 (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
2532 (void) memcpy((void *)(gc->pc + 8), (void *)(&pname), 4);
2533 (void) memcpy((void *)(gc->pc + 12), (void *)(params), (compsize * 4));
2535 if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
2538 #define X_GLrop_TexEnvi 113
2540 __indirect_glTexEnvi(GLenum target, GLenum pname, GLint param)
2542 __GLXcontext * const gc = __glXGetCurrentContext();
2543 Display * const dpy = gc->currentDpy;
2544 const GLuint cmdlen = 16;
2546 emit_header(gc->pc, X_GLrop_TexEnvi, cmdlen);
2547 (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
2548 (void) memcpy((void *)(gc->pc + 8), (void *)(&pname), 4);
2549 (void) memcpy((void *)(gc->pc + 12), (void *)(¶m), 4);
2551 if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
2554 #define X_GLrop_TexEnviv 114
2556 __indirect_glTexEnviv(GLenum target, GLenum pname, const GLint * params)
2558 __GLXcontext * const gc = __glXGetCurrentContext();
2559 Display * const dpy = gc->currentDpy;
2560 const GLuint compsize = __glTexEnviv_size(pname);
2561 const GLuint cmdlen = 12 + __GLX_PAD((compsize * 4));
2563 emit_header(gc->pc, X_GLrop_TexEnviv, cmdlen);
2564 (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
2565 (void) memcpy((void *)(gc->pc + 8), (void *)(&pname), 4);
2566 (void) memcpy((void *)(gc->pc + 12), (void *)(params), (compsize * 4));
2568 if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
2571 #define X_GLrop_TexGend 115
2573 __indirect_glTexGend(GLenum coord, GLenum pname, GLdouble param)
2575 __GLXcontext * const gc = __glXGetCurrentContext();
2576 Display * const dpy = gc->currentDpy;
2577 const GLuint cmdlen = 20;
2579 emit_header(gc->pc, X_GLrop_TexGend, cmdlen);
2580 (void) memcpy((void *)(gc->pc + 4), (void *)(¶m), 8);
2581 (void) memcpy((void *)(gc->pc + 12), (void *)(&coord), 4);
2582 (void) memcpy((void *)(gc->pc + 16), (void *)(&pname), 4);
2584 if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
2587 #define X_GLrop_TexGendv 116
2589 __indirect_glTexGendv(GLenum coord, GLenum pname, const GLdouble * params)
2591 __GLXcontext * const gc = __glXGetCurrentContext();
2592 Display * const dpy = gc->currentDpy;
2593 const GLuint compsize = __glTexGendv_size(pname);
2594 const GLuint cmdlen = 12 + __GLX_PAD((compsize * 8));
2596 emit_header(gc->pc, X_GLrop_TexGendv, cmdlen);
2597 (void) memcpy((void *)(gc->pc + 4), (void *)(&coord), 4);
2598 (void) memcpy((void *)(gc->pc + 8), (void *)(&pname), 4);
2599 (void) memcpy((void *)(gc->pc + 12), (void *)(params), (compsize * 8));
2601 if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
2604 #define X_GLrop_TexGenf 117
2606 __indirect_glTexGenf(GLenum coord, GLenum pname, GLfloat param)
2608 __GLXcontext * const gc = __glXGetCurrentContext();
2609 Display * const dpy = gc->currentDpy;
2610 const GLuint cmdlen = 16;
2612 emit_header(gc->pc, X_GLrop_TexGenf, cmdlen);
2613 (void) memcpy((void *)(gc->pc + 4), (void *)(&coord), 4);
2614 (void) memcpy((void *)(gc->pc + 8), (void *)(&pname), 4);
2615 (void) memcpy((void *)(gc->pc + 12), (void *)(¶m), 4);
2617 if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
2620 #define X_GLrop_TexGenfv 118
2622 __indirect_glTexGenfv(GLenum coord, GLenum pname, const GLfloat * params)
2624 __GLXcontext * const gc = __glXGetCurrentContext();
2625 Display * const dpy = gc->currentDpy;
2626 const GLuint compsize = __glTexGenfv_size(pname);
2627 const GLuint cmdlen = 12 + __GLX_PAD((compsize * 4));
2629 emit_header(gc->pc, X_GLrop_TexGenfv, cmdlen);
2630 (void) memcpy((void *)(gc->pc + 4), (void *)(&coord), 4);
2631 (void) memcpy((void *)(gc->pc + 8), (void *)(&pname), 4);
2632 (void) memcpy((void *)(gc->pc + 12), (void *)(params), (compsize * 4));
2634 if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
2637 #define X_GLrop_TexGeni 119
2639 __indirect_glTexGeni(GLenum coord, GLenum pname, GLint param)
2641 __GLXcontext * const gc = __glXGetCurrentContext();
2642 Display * const dpy = gc->currentDpy;
2643 const GLuint cmdlen = 16;
2645 emit_header(gc->pc, X_GLrop_TexGeni, cmdlen);
2646 (void) memcpy((void *)(gc->pc + 4), (void *)(&coord), 4);
2647 (void) memcpy((void *)(gc->pc + 8), (void *)(&pname), 4);
2648 (void) memcpy((void *)(gc->pc + 12), (void *)(¶m), 4);
2650 if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
2653 #define X_GLrop_TexGeniv 120
2655 __indirect_glTexGeniv(GLenum coord, GLenum pname, const GLint * params)
2657 __GLXcontext * const gc = __glXGetCurrentContext();
2658 Display * const dpy = gc->currentDpy;
2659 const GLuint compsize = __glTexGeniv_size(pname);
2660 const GLuint cmdlen = 12 + __GLX_PAD((compsize * 4));
2662 emit_header(gc->pc, X_GLrop_TexGeniv, cmdlen);
2663 (void) memcpy((void *)(gc->pc + 4), (void *)(&coord), 4);
2664 (void) memcpy((void *)(gc->pc + 8), (void *)(&pname), 4);
2665 (void) memcpy((void *)(gc->pc + 12), (void *)(params), (compsize * 4));
2667 if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
2670 #define X_GLrop_InitNames 121
2672 __indirect_glInitNames(void)
2674 __GLXcontext * const gc = __glXGetCurrentContext();
2675 Display * const dpy = gc->currentDpy;
2676 const GLuint cmdlen = 4;
2678 emit_header(gc->pc, X_GLrop_InitNames, cmdlen);
2680 if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
2683 #define X_GLrop_LoadName 122
2685 __indirect_glLoadName(GLuint name)
2687 __GLXcontext * const gc = __glXGetCurrentContext();
2688 Display * const dpy = gc->currentDpy;
2689 const GLuint cmdlen = 8;
2691 emit_header(gc->pc, X_GLrop_LoadName, cmdlen);
2692 (void) memcpy((void *)(gc->pc + 4), (void *)(&name), 4);
2694 if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
2697 #define X_GLrop_PassThrough 123
2699 __indirect_glPassThrough(GLfloat token)
2701 __GLXcontext * const gc = __glXGetCurrentContext();
2702 Display * const dpy = gc->currentDpy;
2703 const GLuint cmdlen = 8;
2705 emit_header(gc->pc, X_GLrop_PassThrough, cmdlen);
2706 (void) memcpy((void *)(gc->pc + 4), (void *)(&token), 4);
2708 if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
2711 #define X_GLrop_PopName 124
2713 __indirect_glPopName(void)
2715 __GLXcontext * const gc = __glXGetCurrentContext();
2716 Display * const dpy = gc->currentDpy;
2717 const GLuint cmdlen = 4;
2719 emit_header(gc->pc, X_GLrop_PopName, cmdlen);
2721 if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
2724 #define X_GLrop_PushName 125
2726 __indirect_glPushName(GLuint name)
2728 __GLXcontext * const gc = __glXGetCurrentContext();
2729 Display * const dpy = gc->currentDpy;
2730 const GLuint cmdlen = 8;
2732 emit_header(gc->pc, X_GLrop_PushName, cmdlen);
2733 (void) memcpy((void *)(gc->pc + 4), (void *)(&name), 4);
2735 if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
2738 #define X_GLrop_DrawBuffer 126
2740 __indirect_glDrawBuffer(GLenum mode)
2742 __GLXcontext * const gc = __glXGetCurrentContext();
2743 Display * const dpy = gc->currentDpy;
2744 const GLuint cmdlen = 8;
2746 emit_header(gc->pc, X_GLrop_DrawBuffer, cmdlen);
2747 (void) memcpy((void *)(gc->pc + 4), (void *)(&mode), 4);
2749 if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
2752 #define X_GLrop_Clear 127
2754 __indirect_glClear(GLbitfield mask)
2756 __GLXcontext * const gc = __glXGetCurrentContext();
2757 Display * const dpy = gc->currentDpy;
2758 const GLuint cmdlen = 8;
2760 emit_header(gc->pc, X_GLrop_Clear, cmdlen);
2761 (void) memcpy((void *)(gc->pc + 4), (void *)(&mask), 4);
2763 if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
2766 #define X_GLrop_ClearAccum 128
2768 __indirect_glClearAccum(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)
2770 __GLXcontext * const gc = __glXGetCurrentContext();
2771 Display * const dpy = gc->currentDpy;
2772 const GLuint cmdlen = 20;
2774 emit_header(gc->pc, X_GLrop_ClearAccum, cmdlen);
2775 (void) memcpy((void *)(gc->pc + 4), (void *)(&red), 4);
2776 (void) memcpy((void *)(gc->pc + 8), (void *)(&green), 4);
2777 (void) memcpy((void *)(gc->pc + 12), (void *)(&blue), 4);
2778 (void) memcpy((void *)(gc->pc + 16), (void *)(&alpha), 4);
2780 if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
2783 #define X_GLrop_ClearIndex 129
2785 __indirect_glClearIndex(GLfloat c)
2787 __GLXcontext * const gc = __glXGetCurrentContext();
2788 Display * const dpy = gc->currentDpy;
2789 const GLuint cmdlen = 8;
2791 emit_header(gc->pc, X_GLrop_ClearIndex, cmdlen);
2792 (void) memcpy((void *)(gc->pc + 4), (void *)(&c), 4);
2794 if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
2797 #define X_GLrop_ClearColor 130
2799 __indirect_glClearColor(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha)
2801 __GLXcontext * const gc = __glXGetCurrentContext();
2802 Display * const dpy = gc->currentDpy;
2803 const GLuint cmdlen = 20;
2805 emit_header(gc->pc, X_GLrop_ClearColor, cmdlen);
2806 (void) memcpy((void *)(gc->pc + 4), (void *)(&red), 4);
2807 (void) memcpy((void *)(gc->pc + 8), (void *)(&green), 4);
2808 (void) memcpy((void *)(gc->pc + 12), (void *)(&blue), 4);
2809 (void) memcpy((void *)(gc->pc + 16), (void *)(&alpha), 4);
2811 if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
2814 #define X_GLrop_ClearStencil 131
2816 __indirect_glClearStencil(GLint s)
2818 __GLXcontext * const gc = __glXGetCurrentContext();
2819 Display * const dpy = gc->currentDpy;
2820 const GLuint cmdlen = 8;
2822 emit_header(gc->pc, X_GLrop_ClearStencil, cmdlen);
2823 (void) memcpy((void *)(gc->pc + 4), (void *)(&s), 4);
2825 if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
2828 #define X_GLrop_ClearDepth 132
2830 __indirect_glClearDepth(GLclampd depth)
2832 __GLXcontext * const gc = __glXGetCurrentContext();
2833 Display * const dpy = gc->currentDpy;
2834 const GLuint cmdlen = 12;
2836 emit_header(gc->pc, X_GLrop_ClearDepth, cmdlen);
2837 (void) memcpy((void *)(gc->pc + 4), (void *)(&depth), 8);
2839 if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
2842 #define X_GLrop_StencilMask 133
2844 __indirect_glStencilMask(GLuint mask)
2846 __GLXcontext * const gc = __glXGetCurrentContext();
2847 Display * const dpy = gc->currentDpy;
2848 const GLuint cmdlen = 8;
2850 emit_header(gc->pc, X_GLrop_StencilMask, cmdlen);
2851 (void) memcpy((void *)(gc->pc + 4), (void *)(&mask), 4);
2853 if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
2856 #define X_GLrop_ColorMask 134
2858 __indirect_glColorMask(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha)
2860 __GLXcontext * const gc = __glXGetCurrentContext();
2861 Display * const dpy = gc->currentDpy;
2862 const GLuint cmdlen = 8;
2864 emit_header(gc->pc, X_GLrop_ColorMask, cmdlen);
2865 (void) memcpy((void *)(gc->pc + 4), (void *)(&red), 1);
2866 (void) memcpy((void *)(gc->pc + 5), (void *)(&green), 1);
2867 (void) memcpy((void *)(gc->pc + 6), (void *)(&blue), 1);
2868 (void) memcpy((void *)(gc->pc + 7), (void *)(&alpha), 1);
2870 if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
2873 #define X_GLrop_DepthMask 135
2875 __indirect_glDepthMask(GLboolean flag)
2877 __GLXcontext * const gc = __glXGetCurrentContext();
2878 Display * const dpy = gc->currentDpy;
2879 const GLuint cmdlen = 8;
2881 emit_header(gc->pc, X_GLrop_DepthMask, cmdlen);
2882 (void) memcpy((void *)(gc->pc + 4), (void *)(&flag), 1);
2884 if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
2887 #define X_GLrop_IndexMask 136
2889 __indirect_glIndexMask(GLuint mask)
2891 __GLXcontext * const gc = __glXGetCurrentContext();
2892 Display * const dpy = gc->currentDpy;
2893 const GLuint cmdlen = 8;
2895 emit_header(gc->pc, X_GLrop_IndexMask, cmdlen);
2896 (void) memcpy((void *)(gc->pc + 4), (void *)(&mask), 4);
2898 if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
2901 #define X_GLrop_Accum 137
2903 __indirect_glAccum(GLenum op, GLfloat value)
2905 __GLXcontext * const gc = __glXGetCurrentContext();
2906 Display * const dpy = gc->currentDpy;
2907 const GLuint cmdlen = 12;
2909 emit_header(gc->pc, X_GLrop_Accum, cmdlen);
2910 (void) memcpy((void *)(gc->pc + 4), (void *)(&op), 4);
2911 (void) memcpy((void *)(gc->pc + 8), (void *)(&value), 4);
2913 if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
2916 #define X_GLrop_PopAttrib 141
2918 __indirect_glPopAttrib(void)
2920 __GLXcontext * const gc = __glXGetCurrentContext();
2921 Display * const dpy = gc->currentDpy;
2922 const GLuint cmdlen = 4;
2924 emit_header(gc->pc, X_GLrop_PopAttrib, cmdlen);
2926 if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
2929 #define X_GLrop_PushAttrib 142
2931 __indirect_glPushAttrib(GLbitfield mask)
2933 __GLXcontext * const gc = __glXGetCurrentContext();
2934 Display * const dpy = gc->currentDpy;
2935 const GLuint cmdlen = 8;
2937 emit_header(gc->pc, X_GLrop_PushAttrib, cmdlen);
2938 (void) memcpy((void *)(gc->pc + 4), (void *)(&mask), 4);
2940 if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
2943 #define X_GLrop_MapGrid1d 147
2945 __indirect_glMapGrid1d(GLint un, GLdouble u1, GLdouble u2)
2947 __GLXcontext * const gc = __glXGetCurrentContext();
2948 Display * const dpy = gc->currentDpy;
2949 const GLuint cmdlen = 24;
2951 emit_header(gc->pc, X_GLrop_MapGrid1d, cmdlen);
2952 (void) memcpy((void *)(gc->pc + 4), (void *)(&u1), 8);
2953 (void) memcpy((void *)(gc->pc + 12), (void *)(&u2), 8);
2954 (void) memcpy((void *)(gc->pc + 20), (void *)(&un), 4);
2956 if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
2959 #define X_GLrop_MapGrid1f 148
2961 __indirect_glMapGrid1f(GLint un, GLfloat u1, GLfloat u2)
2963 __GLXcontext * const gc = __glXGetCurrentContext();
2964 Display * const dpy = gc->currentDpy;
2965 const GLuint cmdlen = 16;
2967 emit_header(gc->pc, X_GLrop_MapGrid1f, cmdlen);
2968 (void) memcpy((void *)(gc->pc + 4), (void *)(&un), 4);
2969 (void) memcpy((void *)(gc->pc + 8), (void *)(&u1), 4);
2970 (void) memcpy((void *)(gc->pc + 12), (void *)(&u2), 4);
2972 if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
2975 #define X_GLrop_MapGrid2d 149
2977 __indirect_glMapGrid2d(GLint un, GLdouble u1, GLdouble u2, GLint vn, GLdouble v1, GLdouble v2)
2979 __GLXcontext * const gc = __glXGetCurrentContext();
2980 Display * const dpy = gc->currentDpy;
2981 const GLuint cmdlen = 44;
2983 emit_header(gc->pc, X_GLrop_MapGrid2d, cmdlen);
2984 (void) memcpy((void *)(gc->pc + 4), (void *)(&u1), 8);
2985 (void) memcpy((void *)(gc->pc + 12), (void *)(&u2), 8);
2986 (void) memcpy((void *)(gc->pc + 20), (void *)(&v1), 8);
2987 (void) memcpy((void *)(gc->pc + 28), (void *)(&v2), 8);
2988 (void) memcpy((void *)(gc->pc + 36), (void *)(&un), 4);
2989 (void) memcpy((void *)(gc->pc + 40), (void *)(&vn), 4);
2991 if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
2994 #define X_GLrop_MapGrid2f 150
2996 __indirect_glMapGrid2f(GLint un, GLfloat u1, GLfloat u2, GLint vn, GLfloat v1, GLfloat v2)
2998 __GLXcontext * const gc = __glXGetCurrentContext();
2999 Display * const dpy = gc->currentDpy;
3000 const GLuint cmdlen = 28;
3002 emit_header(gc->pc, X_GLrop_MapGrid2f, cmdlen);
3003 (void) memcpy((void *)(gc->pc + 4), (void *)(&un), 4);
3004 (void) memcpy((void *)(gc->pc + 8), (void *)(&u1), 4);
3005 (void) memcpy((void *)(gc->pc + 12), (void *)(&u2), 4);
3006 (void) memcpy((void *)(gc->pc + 16), (void *)(&vn), 4);
3007 (void) memcpy((void *)(gc->pc + 20), (void *)(&v1), 4);
3008 (void) memcpy((void *)(gc->pc + 24), (void *)(&v2), 4);
3010 if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
3013 #define X_GLrop_EvalCoord1dv 151
3015 __indirect_glEvalCoord1d(GLdouble u)
3017 __GLXcontext * const gc = __glXGetCurrentContext();
3018 Display * const dpy = gc->currentDpy;
3019 const GLuint cmdlen = 12;
3021 emit_header(gc->pc, X_GLrop_EvalCoord1dv, cmdlen);
3022 (void) memcpy((void *)(gc->pc + 4), (void *)(&u), 8);
3024 if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
3027 #define X_GLrop_EvalCoord1dv 151
3029 __indirect_glEvalCoord1dv(const GLdouble * u)
3031 generic_8_byte( X_GLrop_EvalCoord1dv, u );
3034 #define X_GLrop_EvalCoord1fv 152
3036 __indirect_glEvalCoord1f(GLfloat u)
3038 __GLXcontext * const gc = __glXGetCurrentContext();
3039 Display * const dpy = gc->currentDpy;
3040 const GLuint cmdlen = 8;
3042 emit_header(gc->pc, X_GLrop_EvalCoord1fv, cmdlen);
3043 (void) memcpy((void *)(gc->pc + 4), (void *)(&u), 4);
3045 if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
3048 #define X_GLrop_EvalCoord1fv 152
3050 __indirect_glEvalCoord1fv(const GLfloat * u)
3052 generic_4_byte( X_GLrop_EvalCoord1fv, u );
3055 #define X_GLrop_EvalCoord2dv 153
3057 __indirect_glEvalCoord2d(GLdouble u, GLdouble v)
3059 __GLXcontext * const gc = __glXGetCurrentContext();
3060 Display * const dpy = gc->currentDpy;
3061 const GLuint cmdlen = 20;
3063 emit_header(gc->pc, X_GLrop_EvalCoord2dv, cmdlen);
3064 (void) memcpy((void *)(gc->pc + 4), (void *)(&u), 8);
3065 (void) memcpy((void *)(gc->pc + 12), (void *)(&v), 8);
3067 if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
3070 #define X_GLrop_EvalCoord2dv 153
3072 __indirect_glEvalCoord2dv(const GLdouble * u)
3074 generic_16_byte( X_GLrop_EvalCoord2dv, u );
3077 #define X_GLrop_EvalCoord2fv 154
3079 __indirect_glEvalCoord2f(GLfloat u, GLfloat v)
3081 __GLXcontext * const gc = __glXGetCurrentContext();
3082 Display * const dpy = gc->currentDpy;
3083 const GLuint cmdlen = 12;
3085 emit_header(gc->pc, X_GLrop_EvalCoord2fv, cmdlen);
3086 (void) memcpy((void *)(gc->pc + 4), (void *)(&u), 4);
3087 (void) memcpy((void *)(gc->pc + 8), (void *)(&v), 4);
3089 if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
3092 #define X_GLrop_EvalCoord2fv 154
3094 __indirect_glEvalCoord2fv(const GLfloat * u)
3096 generic_8_byte( X_GLrop_EvalCoord2fv, u );
3099 #define X_GLrop_EvalMesh1 155
3101 __indirect_glEvalMesh1(GLenum mode, GLint i1, GLint i2)
3103 __GLXcontext * const gc = __glXGetCurrentContext();
3104 Display * const dpy = gc->currentDpy;
3105 const GLuint cmdlen = 16;
3107 emit_header(gc->pc, X_GLrop_EvalMesh1, cmdlen);
3108 (void) memcpy((void *)(gc->pc + 4), (void *)(&mode), 4);
3109 (void) memcpy((void *)(gc->pc + 8), (void *)(&i1), 4);
3110 (void) memcpy((void *)(gc->pc + 12), (void *)(&i2), 4);
3112 if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
3115 #define X_GLrop_EvalPoint1 156
3117 __indirect_glEvalPoint1(GLint i)
3119 __GLXcontext * const gc = __glXGetCurrentContext();
3120 Display * const dpy = gc->currentDpy;
3121 const GLuint cmdlen = 8;
3123 emit_header(gc->pc, X_GLrop_EvalPoint1, cmdlen);
3124 (void) memcpy((void *)(gc->pc + 4), (void *)(&i), 4);
3126 if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
3129 #define X_GLrop_EvalMesh2 157
3131 __indirect_glEvalMesh2(GLenum mode, GLint i1, GLint i2, GLint j1, GLint j2)
3133 __GLXcontext * const gc = __glXGetCurrentContext();
3134 Display * const dpy = gc->currentDpy;
3135 const GLuint cmdlen = 24;
3137 emit_header(gc->pc, X_GLrop_EvalMesh2, cmdlen);
3138 (void) memcpy((void *)(gc->pc + 4), (void *)(&mode), 4);
3139 (void) memcpy((void *)(gc->pc + 8), (void *)(&i1), 4);
3140 (void) memcpy((void *)(gc->pc + 12), (void *)(&i2), 4);
3141 (void) memcpy((void *)(gc->pc + 16), (void *)(&j1), 4);
3142 (void) memcpy((void *)(gc->pc + 20), (void *)(&j2), 4);
3144 if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
3147 #define X_GLrop_EvalPoint2 158
3149 __indirect_glEvalPoint2(GLint i, GLint j)
3151 __GLXcontext * const gc = __glXGetCurrentContext();
3152 Display * const dpy = gc->currentDpy;
3153 const GLuint cmdlen = 12;
3155 emit_header(gc->pc, X_GLrop_EvalPoint2, cmdlen);
3156 (void) memcpy((void *)(gc->pc + 4), (void *)(&i), 4);
3157 (void) memcpy((void *)(gc->pc + 8), (void *)(&j), 4);
3159 if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
3162 #define X_GLrop_AlphaFunc 159
3164 __indirect_glAlphaFunc(GLenum func, GLclampf ref)
3166 __GLXcontext * const gc = __glXGetCurrentContext();
3167 Display * const dpy = gc->currentDpy;
3168 const GLuint cmdlen = 12;
3170 emit_header(gc->pc, X_GLrop_AlphaFunc, cmdlen);
3171 (void) memcpy((void *)(gc->pc + 4), (void *)(&func), 4);
3172 (void) memcpy((void *)(gc->pc + 8), (void *)(&ref), 4);
3174 if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
3177 #define X_GLrop_BlendFunc 160
3179 __indirect_glBlendFunc(GLenum sfactor, GLenum dfactor)
3181 __GLXcontext * const gc = __glXGetCurrentContext();
3182 Display * const dpy = gc->currentDpy;
3183 const GLuint cmdlen = 12;
3185 emit_header(gc->pc, X_GLrop_BlendFunc, cmdlen);
3186 (void) memcpy((void *)(gc->pc + 4), (void *)(&sfactor), 4);
3187 (void) memcpy((void *)(gc->pc + 8), (void *)(&dfactor), 4);
3189 if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
3192 #define X_GLrop_LogicOp 161
3194 __indirect_glLogicOp(GLenum opcode)
3196 __GLXcontext * const gc = __glXGetCurrentContext();
3197 Display * const dpy = gc->currentDpy;
3198 const GLuint cmdlen = 8;
3200 emit_header(gc->pc, X_GLrop_LogicOp, cmdlen);
3201 (void) memcpy((void *)(gc->pc + 4), (void *)(&opcode), 4);
3203 if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
3206 #define X_GLrop_StencilFunc 162
3208 __indirect_glStencilFunc(GLenum func, GLint ref, GLuint mask)
3210 __GLXcontext * const gc = __glXGetCurrentContext();
3211 Display * const dpy = gc->currentDpy;
3212 const GLuint cmdlen = 16;
3214 emit_header(gc->pc, X_GLrop_StencilFunc, cmdlen);
3215 (void) memcpy((void *)(gc->pc + 4), (void *)(&func), 4);
3216 (void) memcpy((void *)(gc->pc + 8), (void *)(&ref), 4);
3217 (void) memcpy((void *)(gc->pc + 12), (void *)(&mask), 4);
3219 if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
3222 #define X_GLrop_StencilOp 163
3224 __indirect_glStencilOp(GLenum fail, GLenum zfail, GLenum zpass)
3226 __GLXcontext * const gc = __glXGetCurrentContext();
3227 Display * const dpy = gc->currentDpy;
3228 const GLuint cmdlen = 16;
3230 emit_header(gc->pc, X_GLrop_StencilOp, cmdlen);
3231 (void) memcpy((void *)(gc->pc + 4), (void *)(&fail), 4);
3232 (void) memcpy((void *)(gc->pc + 8), (void *)(&zfail), 4);
3233 (void) memcpy((void *)(gc->pc + 12), (void *)(&zpass), 4);
3235 if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
3238 #define X_GLrop_DepthFunc 164
3240 __indirect_glDepthFunc(GLenum func)
3242 __GLXcontext * const gc = __glXGetCurrentContext();
3243 Display * const dpy = gc->currentDpy;
3244 const GLuint cmdlen = 8;
3246 emit_header(gc->pc, X_GLrop_DepthFunc, cmdlen);
3247 (void) memcpy((void *)(gc->pc + 4), (void *)(&func), 4);
3249 if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
3252 #define X_GLrop_PixelZoom 165
3254 __indirect_glPixelZoom(GLfloat xfactor, GLfloat yfactor)
3256 __GLXcontext * const gc = __glXGetCurrentContext();
3257 Display * const dpy = gc->currentDpy;
3258 const GLuint cmdlen = 12;
3260 emit_header(gc->pc, X_GLrop_PixelZoom, cmdlen);
3261 (void) memcpy((void *)(gc->pc + 4), (void *)(&xfactor), 4);
3262 (void) memcpy((void *)(gc->pc + 8), (void *)(&yfactor), 4);
3264 if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
3267 #define X_GLrop_PixelTransferf 166
3269 __indirect_glPixelTransferf(GLenum pname, GLfloat param)
3271 __GLXcontext * const gc = __glXGetCurrentContext();
3272 Display * const dpy = gc->currentDpy;
3273 const GLuint cmdlen = 12;
3275 emit_header(gc->pc, X_GLrop_PixelTransferf, cmdlen);
3276 (void) memcpy((void *)(gc->pc + 4), (void *)(&pname), 4);
3277 (void) memcpy((void *)(gc->pc + 8), (void *)(¶m), 4);
3279 if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
3282 #define X_GLrop_PixelTransferi 167
3284 __indirect_glPixelTransferi(GLenum pname, GLint param)
3286 __GLXcontext * const gc = __glXGetCurrentContext();
3287 Display * const dpy = gc->currentDpy;
3288 const GLuint cmdlen = 12;
3290 emit_header(gc->pc, X_GLrop_PixelTransferi, cmdlen);
3291 (void) memcpy((void *)(gc->pc + 4), (void *)(&pname), 4);
3292 (void) memcpy((void *)(gc->pc + 8), (void *)(¶m), 4);
3294 if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
3297 #define X_GLrop_PixelMapfv 168
3299 __indirect_glPixelMapfv(GLenum map, GLsizei mapsize, const GLfloat * values)
3301 __GLXcontext * const gc = __glXGetCurrentContext();
3302 Display * const dpy = gc->currentDpy;
3303 const GLuint cmdlen = 12 + __GLX_PAD((mapsize * 4));
3304 if (mapsize < 0) return;
3305 if (dpy == NULL) return;
3306 if ( ((gc->pc + cmdlen) > gc->bufEnd)
3307 || (cmdlen > gc->maxSmallRenderCommandSize)) {
3308 (void) __glXFlushRenderBuffer(gc, gc->pc);
3310 if (cmdlen <= gc->maxSmallRenderCommandSize) {
3311 emit_header(gc->pc, X_GLrop_PixelMapfv, cmdlen);
3312 (void) memcpy((void *)(gc->pc + 4), (void *)(&map), 4);
3313 (void) memcpy((void *)(gc->pc + 8), (void *)(&mapsize), 4);
3314 (void) memcpy((void *)(gc->pc + 12), (void *)(values), (mapsize * 4));
3316 if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
3319 const GLint op = X_GLrop_PixelMapfv;
3320 const GLuint cmdlenLarge = cmdlen + 4;
3321 (void) memcpy((void *)(gc->pc + 0), (void *)(&op), 4);
3322 (void) memcpy((void *)(gc->pc + 4), (void *)(&cmdlenLarge), 4);
3323 (void) memcpy((void *)(gc->pc + 8), (void *)(&map), 4);
3324 (void) memcpy((void *)(gc->pc + 12), (void *)(&mapsize), 4);
3325 __glXSendLargeCommand(gc, gc->pc, 16, values, (mapsize * 4));
3329 #define X_GLrop_PixelMapuiv 169
3331 __indirect_glPixelMapuiv(GLenum map, GLsizei mapsize, const GLuint * values)
3333 __GLXcontext * const gc = __glXGetCurrentContext();
3334 Display * const dpy = gc->currentDpy;
3335 const GLuint cmdlen = 12 + __GLX_PAD((mapsize * 4));
3336 if (mapsize < 0) return;
3337 if (dpy == NULL) return;
3338 if ( ((gc->pc + cmdlen) > gc->bufEnd)
3339 || (cmdlen > gc->maxSmallRenderCommandSize)) {
3340 (void) __glXFlushRenderBuffer(gc, gc->pc);
3342 if (cmdlen <= gc->maxSmallRenderCommandSize) {
3343 emit_header(gc->pc, X_GLrop_PixelMapuiv, cmdlen);
3344 (void) memcpy((void *)(gc->pc + 4), (void *)(&map), 4);
3345 (void) memcpy((void *)(gc->pc + 8), (void *)(&mapsize), 4);
3346 (void) memcpy((void *)(gc->pc + 12), (void *)(values), (mapsize * 4));
3348 if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
3351 const GLint op = X_GLrop_PixelMapuiv;
3352 const GLuint cmdlenLarge = cmdlen + 4;
3353 (void) memcpy((void *)(gc->pc + 0), (void *)(&op), 4);
3354 (void) memcpy((void *)(gc->pc + 4), (void *)(&cmdlenLarge), 4);
3355 (void) memcpy((void *)(gc->pc + 8), (void *)(&map), 4);
3356 (void) memcpy((void *)(gc->pc + 12), (void *)(&mapsize), 4);
3357 __glXSendLargeCommand(gc, gc->pc, 16, values, (mapsize * 4));
3361 #define X_GLrop_PixelMapusv 170
3363 __indirect_glPixelMapusv(GLenum map, GLsizei mapsize, const GLushort * values)
3365 __GLXcontext * const gc = __glXGetCurrentContext();
3366 Display * const dpy = gc->currentDpy;
3367 const GLuint cmdlen = 12 + __GLX_PAD((mapsize * 2));
3368 if (mapsize < 0) return;
3369 if (dpy == NULL) return;
3370 if ( ((gc->pc + cmdlen) > gc->bufEnd)
3371 || (cmdlen > gc->maxSmallRenderCommandSize)) {
3372 (void) __glXFlushRenderBuffer(gc, gc->pc);
3374 if (cmdlen <= gc->maxSmallRenderCommandSize) {
3375 emit_header(gc->pc, X_GLrop_PixelMapusv, cmdlen);
3376 (void) memcpy((void *)(gc->pc + 4), (void *)(&map), 4);
3377 (void) memcpy((void *)(gc->pc + 8), (void *)(&mapsize), 4);
3378 (void) memcpy((void *)(gc->pc + 12), (void *)(values), (mapsize * 2));
3380 if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
3383 const GLint op = X_GLrop_PixelMapusv;
3384 const GLuint cmdlenLarge = cmdlen + 4;
3385 (void) memcpy((void *)(gc->pc + 0), (void *)(&op), 4);
3386 (void) memcpy((void *)(gc->pc + 4), (void *)(&cmdlenLarge), 4);
3387 (void) memcpy((void *)(gc->pc + 8), (void *)(&map), 4);
3388 (void) memcpy((void *)(gc->pc + 12), (void *)(&mapsize), 4);
3389 __glXSendLargeCommand(gc, gc->pc, 16, values, (mapsize * 2));
3393 #define X_GLrop_ReadBuffer 171
3395 __indirect_glReadBuffer(GLenum mode)
3397 __GLXcontext * const gc = __glXGetCurrentContext();
3398 Display * const dpy = gc->currentDpy;
3399 const GLuint cmdlen = 8;
3401 emit_header(gc->pc, X_GLrop_ReadBuffer, cmdlen);
3402 (void) memcpy((void *)(gc->pc + 4), (void *)(&mode), 4);
3404 if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
3407 #define X_GLrop_CopyPixels 172
3409 __indirect_glCopyPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum type)
3411 __GLXcontext * const gc = __glXGetCurrentContext();
3412 Display * const dpy = gc->currentDpy;
3413 const GLuint cmdlen = 24;
3415 emit_header(gc->pc, X_GLrop_CopyPixels, cmdlen);
3416 (void) memcpy((void *)(gc->pc + 4), (void *)(&x), 4);
3417 (void) memcpy((void *)(gc->pc + 8), (void *)(&y), 4);
3418 (void) memcpy((void *)(gc->pc + 12), (void *)(&width), 4);
3419 (void) memcpy((void *)(gc->pc + 16), (void *)(&height), 4);
3420 (void) memcpy((void *)(gc->pc + 20), (void *)(&type), 4);
3422 if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
3425 #define X_GLsop_GetClipPlane 113
3427 __indirect_glGetClipPlane(GLenum plane, GLdouble * equation)
3429 __GLXcontext * const gc = __glXGetCurrentContext();
3430 Display * const dpy = gc->currentDpy;
3431 const GLuint cmdlen = 4;
3434 GLubyte const * pc = setup_single_request(gc, X_GLsop_GetClipPlane, cmdlen);
3435 (void) memcpy((void *)(pc + 0), (void *)(&plane), 4);
3436 (void) read_reply(gc->currentDpy, 8, equation, GL_TRUE);
3437 UnlockDisplay(gc->currentDpy); SyncHandle();
3442 #define X_GLsop_GetLightfv 118
3444 __indirect_glGetLightfv(GLenum light, GLenum pname, GLfloat * params)
3446 __GLXcontext * const gc = __glXGetCurrentContext();
3447 Display * const dpy = gc->currentDpy;
3448 const GLuint cmdlen = 8;
3451 GLubyte const * pc = setup_single_request(gc, X_GLsop_GetLightfv, cmdlen);
3452 (void) memcpy((void *)(pc + 0), (void *)(&light), 4);
3453 (void) memcpy((void *)(pc + 4), (void *)(&pname), 4);
3454 (void) read_reply(gc->currentDpy, 4, params, GL_FALSE);
3455 UnlockDisplay(gc->currentDpy); SyncHandle();
3460 #define X_GLsop_GetLightiv 119
3462 __indirect_glGetLightiv(GLenum light, GLenum pname, GLint * params)
3464 __GLXcontext * const gc = __glXGetCurrentContext();
3465 Display * const dpy = gc->currentDpy;
3466 const GLuint cmdlen = 8;
3469 GLubyte const * pc = setup_single_request(gc, X_GLsop_GetLightiv, cmdlen);
3470 (void) memcpy((void *)(pc + 0), (void *)(&light), 4);
3471 (void) memcpy((void *)(pc + 4), (void *)(&pname), 4);
3472 (void) read_reply(gc->currentDpy, 4, params, GL_FALSE);
3473 UnlockDisplay(gc->currentDpy); SyncHandle();
3478 #define X_GLsop_GetMapdv 120
3480 __indirect_glGetMapdv(GLenum target, GLenum query, GLdouble * v)
3482 __GLXcontext * const gc = __glXGetCurrentContext();
3483 Display * const dpy = gc->currentDpy;
3484 const GLuint cmdlen = 8;
3487 GLubyte const * pc = setup_single_request(gc, X_GLsop_GetMapdv, cmdlen);
3488 (void) memcpy((void *)(pc + 0), (void *)(&target), 4);
3489 (void) memcpy((void *)(pc + 4), (void *)(&query), 4);
3490 (void) read_reply(gc->currentDpy, 8, v, GL_FALSE);
3491 UnlockDisplay(gc->currentDpy); SyncHandle();
3496 #define X_GLsop_GetMapfv 121
3498 __indirect_glGetMapfv(GLenum target, GLenum query, GLfloat * v)
3500 __GLXcontext * const gc = __glXGetCurrentContext();
3501 Display * const dpy = gc->currentDpy;
3502 const GLuint cmdlen = 8;
3505 GLubyte const * pc = setup_single_request(gc, X_GLsop_GetMapfv, cmdlen);
3506 (void) memcpy((void *)(pc + 0), (void *)(&target), 4);
3507 (void) memcpy((void *)(pc + 4), (void *)(&query), 4);
3508 (void) read_reply(gc->currentDpy, 4, v, GL_FALSE);
3509 UnlockDisplay(gc->currentDpy); SyncHandle();
3514 #define X_GLsop_GetMapiv 122
3516 __indirect_glGetMapiv(GLenum target, GLenum query, GLint * v)
3518 __GLXcontext * const gc = __glXGetCurrentContext();
3519 Display * const dpy = gc->currentDpy;
3520 const GLuint cmdlen = 8;
3523 GLubyte const * pc = setup_single_request(gc, X_GLsop_GetMapiv, cmdlen);
3524 (void) memcpy((void *)(pc + 0), (void *)(&target), 4);
3525 (void) memcpy((void *)(pc + 4), (void *)(&query), 4);
3526 (void) read_reply(gc->currentDpy, 4, v, GL_FALSE);
3527 UnlockDisplay(gc->currentDpy); SyncHandle();
3532 #define X_GLsop_GetMaterialfv 123
3534 __indirect_glGetMaterialfv(GLenum face, GLenum pname, GLfloat * params)
3536 __GLXcontext * const gc = __glXGetCurrentContext();
3537 Display * const dpy = gc->currentDpy;
3538 const GLuint cmdlen = 8;
3541 GLubyte const * pc = setup_single_request(gc, X_GLsop_GetMaterialfv, cmdlen);
3542 (void) memcpy((void *)(pc + 0), (void *)(&face), 4);
3543 (void) memcpy((void *)(pc + 4), (void *)(&pname), 4);
3544 (void) read_reply(gc->currentDpy, 4, params, GL_FALSE);
3545 UnlockDisplay(gc->currentDpy); SyncHandle();
3550 #define X_GLsop_GetMaterialiv 124
3552 __indirect_glGetMaterialiv(GLenum face, GLenum pname, GLint * params)
3554 __GLXcontext * const gc = __glXGetCurrentContext();
3555 Display * const dpy = gc->currentDpy;
3556 const GLuint cmdlen = 8;
3559 GLubyte const * pc = setup_single_request(gc, X_GLsop_GetMaterialiv, cmdlen);
3560 (void) memcpy((void *)(pc + 0), (void *)(&face), 4);
3561 (void) memcpy((void *)(pc + 4), (void *)(&pname), 4);
3562 (void) read_reply(gc->currentDpy, 4, params, GL_FALSE);
3563 UnlockDisplay(gc->currentDpy); SyncHandle();
3568 #define X_GLsop_GetPixelMapfv 125
3570 __indirect_glGetPixelMapfv(GLenum map, GLfloat * values)
3572 __GLXcontext * const gc = __glXGetCurrentContext();
3573 Display * const dpy = gc->currentDpy;
3574 const GLuint cmdlen = 4;
3577 GLubyte const * pc = setup_single_request(gc, X_GLsop_GetPixelMapfv, cmdlen);
3578 (void) memcpy((void *)(pc + 0), (void *)(&map), 4);
3579 (void) read_reply(gc->currentDpy, 4, values, GL_FALSE);
3580 UnlockDisplay(gc->currentDpy); SyncHandle();
3585 #define X_GLsop_GetPixelMapuiv 126
3587 __indirect_glGetPixelMapuiv(GLenum map, GLuint * values)
3589 __GLXcontext * const gc = __glXGetCurrentContext();
3590 Display * const dpy = gc->currentDpy;
3591 const GLuint cmdlen = 4;
3594 GLubyte const * pc = setup_single_request(gc, X_GLsop_GetPixelMapuiv, cmdlen);
3595 (void) memcpy((void *)(pc + 0), (void *)(&map), 4);
3596 (void) read_reply(gc->currentDpy, 4, values, GL_FALSE);
3597 UnlockDisplay(gc->currentDpy); SyncHandle();
3602 #define X_GLsop_GetPixelMapusv 127
3604 __indirect_glGetPixelMapusv(GLenum map, GLushort * values)
3606 __GLXcontext * const gc = __glXGetCurrentContext();
3607 Display * const dpy = gc->currentDpy;
3608 const GLuint cmdlen = 4;
3611 GLubyte const * pc = setup_single_request(gc, X_GLsop_GetPixelMapusv, cmdlen);
3612 (void) memcpy((void *)(pc + 0), (void *)(&map), 4);
3613 (void) read_reply(gc->currentDpy, 2, values, GL_FALSE);
3614 UnlockDisplay(gc->currentDpy); SyncHandle();
3619 #define X_GLsop_GetTexEnvfv 130
3621 __indirect_glGetTexEnvfv(GLenum target, GLenum pname, GLfloat * params)
3623 __GLXcontext * const gc = __glXGetCurrentContext();
3624 Display * const dpy = gc->currentDpy;
3625 const GLuint cmdlen = 8;
3628 GLubyte const * pc = setup_single_request(gc, X_GLsop_GetTexEnvfv, cmdlen);
3629 (void) memcpy((void *)(pc + 0), (void *)(&target), 4);
3630 (void) memcpy((void *)(pc + 4), (void *)(&pname), 4);
3631 (void) read_reply(gc->currentDpy, 4, params, GL_FALSE);
3632 UnlockDisplay(gc->currentDpy); SyncHandle();
3637 #define X_GLsop_GetTexEnviv 131
3639 __indirect_glGetTexEnviv(GLenum target, GLenum pname, GLint * params)
3641 __GLXcontext * const gc = __glXGetCurrentContext();
3642 Display * const dpy = gc->currentDpy;
3643 const GLuint cmdlen = 8;
3646 GLubyte const * pc = setup_single_request(gc, X_GLsop_GetTexEnviv, cmdlen);
3647 (void) memcpy((void *)(pc + 0), (void *)(&target), 4);
3648 (void) memcpy((void *)(pc + 4), (void *)(&pname), 4);
3649 (void) read_reply(gc->currentDpy, 4, params, GL_FALSE);
3650 UnlockDisplay(gc->currentDpy); SyncHandle();
3655 #define X_GLsop_GetTexGendv 132
3657 __indirect_glGetTexGendv(GLenum coord, GLenum pname, GLdouble * params)
3659 __GLXcontext * const gc = __glXGetCurrentContext();
3660 Display * const dpy = gc->currentDpy;
3661 const GLuint cmdlen = 8;
3664 GLubyte const * pc = setup_single_request(gc, X_GLsop_GetTexGendv, cmdlen);
3665 (void) memcpy((void *)(pc + 0), (void *)(&coord), 4);
3666 (void) memcpy((void *)(pc + 4), (void *)(&pname), 4);
3667 (void) read_reply(gc->currentDpy, 8, params, GL_FALSE);
3668 UnlockDisplay(gc->currentDpy); SyncHandle();
3673 #define X_GLsop_GetTexGenfv 133
3675 __indirect_glGetTexGenfv(GLenum coord, GLenum pname, GLfloat * params)
3677 __GLXcontext * const gc = __glXGetCurrentContext();
3678 Display * const dpy = gc->currentDpy;
3679 const GLuint cmdlen = 8;
3682 GLubyte const * pc = setup_single_request(gc, X_GLsop_GetTexGenfv, cmdlen);
3683 (void) memcpy((void *)(pc + 0), (void *)(&coord), 4);
3684 (void) memcpy((void *)(pc + 4), (void *)(&pname), 4);
3685 (void) read_reply(gc->currentDpy, 4, params, GL_FALSE);
3686 UnlockDisplay(gc->currentDpy); SyncHandle();
3691 #define X_GLsop_GetTexGeniv 134
3693 __indirect_glGetTexGeniv(GLenum coord, GLenum pname, GLint * params)
3695 __GLXcontext * const gc = __glXGetCurrentContext();
3696 Display * const dpy = gc->currentDpy;
3697 const GLuint cmdlen = 8;
3700 GLubyte const * pc = setup_single_request(gc, X_GLsop_GetTexGeniv, cmdlen);
3701 (void) memcpy((void *)(pc + 0), (void *)(&coord), 4);
3702 (void) memcpy((void *)(pc + 4), (void *)(&pname), 4);
3703 (void) read_reply(gc->currentDpy, 4, params, GL_FALSE);
3704 UnlockDisplay(gc->currentDpy); SyncHandle();
3709 #define X_GLsop_GetTexParameterfv 136
3711 __indirect_glGetTexParameterfv(GLenum target, GLenum pname, GLfloat * params)
3713 __GLXcontext * const gc = __glXGetCurrentContext();
3714 Display * const dpy = gc->currentDpy;
3715 const GLuint cmdlen = 8;
3718 GLubyte const * pc = setup_single_request(gc, X_GLsop_GetTexParameterfv, cmdlen);
3719 (void) memcpy((void *)(pc + 0), (void *)(&target), 4);
3720 (void) memcpy((void *)(pc + 4), (void *)(&pname), 4);
3721 (void) read_reply(gc->currentDpy, 4, params, GL_FALSE);
3722 UnlockDisplay(gc->currentDpy); SyncHandle();
3727 #define X_GLsop_GetTexParameteriv 137
3729 __indirect_glGetTexParameteriv(GLenum target, GLenum pname, GLint * params)
3731 __GLXcontext * const gc = __glXGetCurrentContext();
3732 Display * const dpy = gc->currentDpy;
3733 const GLuint cmdlen = 8;
3736 GLubyte const * pc = setup_single_request(gc, X_GLsop_GetTexParameteriv, cmdlen);
3737 (void) memcpy((void *)(pc + 0), (void *)(&target), 4);
3738 (void) memcpy((void *)(pc + 4), (void *)(&pname), 4);
3739 (void) read_reply(gc->currentDpy, 4, params, GL_FALSE);
3740 UnlockDisplay(gc->currentDpy); SyncHandle();
3745 #define X_GLsop_GetTexLevelParameterfv 138
3747 __indirect_glGetTexLevelParameterfv(GLenum target, GLint level, GLenum pname, GLfloat * params)
3749 __GLXcontext * const gc = __glXGetCurrentContext();
3750 Display * const dpy = gc->currentDpy;
3751 const GLuint cmdlen = 12;
3754 GLubyte const * pc = setup_single_request(gc, X_GLsop_GetTexLevelParameterfv, cmdlen);
3755 (void) memcpy((void *)(pc + 0), (void *)(&target), 4);
3756 (void) memcpy((void *)(pc + 4), (void *)(&level), 4);
3757 (void) memcpy((void *)(pc + 8), (void *)(&pname), 4);
3758 (void) read_reply(gc->currentDpy, 4, params, GL_FALSE);
3759 UnlockDisplay(gc->currentDpy); SyncHandle();
3764 #define X_GLsop_GetTexLevelParameteriv 139
3766 __indirect_glGetTexLevelParameteriv(GLenum target, GLint level, GLenum pname, GLint * params)
3768 __GLXcontext * const gc = __glXGetCurrentContext();
3769 Display * const dpy = gc->currentDpy;
3770 const GLuint cmdlen = 12;
3773 GLubyte const * pc = setup_single_request(gc, X_GLsop_GetTexLevelParameteriv, cmdlen);
3774 (void) memcpy((void *)(pc + 0), (void *)(&target), 4);
3775 (void) memcpy((void *)(pc + 4), (void *)(&level), 4);
3776 (void) memcpy((void *)(pc + 8), (void *)(&pname), 4);
3777 (void) read_reply(gc->currentDpy, 4, params, GL_FALSE);
3778 UnlockDisplay(gc->currentDpy); SyncHandle();
3783 #define X_GLsop_IsList 141
3785 __indirect_glIsList(GLuint list)
3787 __GLXcontext * const gc = __glXGetCurrentContext();
3788 Display * const dpy = gc->currentDpy;
3789 GLboolean retval = (GLboolean) 0;
3790 const GLuint cmdlen = 4;
3793 GLubyte const * pc = setup_single_request(gc, X_GLsop_IsList, cmdlen);
3794 (void) memcpy((void *)(pc + 0), (void *)(&list), 4);
3795 retval = (GLboolean) read_reply(gc->currentDpy, 0, NULL, GL_FALSE);
3796 UnlockDisplay(gc->currentDpy); SyncHandle();
3801 #define X_GLrop_DepthRange 174
3803 __indirect_glDepthRange(GLclampd zNear, GLclampd zFar)
3805 __GLXcontext * const gc = __glXGetCurrentContext();
3806 Display * const dpy = gc->currentDpy;
3807 const GLuint cmdlen = 20;
3809 emit_header(gc->pc, X_GLrop_DepthRange, cmdlen);
3810 (void) memcpy((void *)(gc->pc + 4), (void *)(&zNear), 8);
3811 (void) memcpy((void *)(gc->pc + 12), (void *)(&zFar), 8);
3813 if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
3816 #define X_GLrop_Frustum 175
3818 __indirect_glFrustum(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar)
3820 __GLXcontext * const gc = __glXGetCurrentContext();
3821 Display * const dpy = gc->currentDpy;
3822 const GLuint cmdlen = 52;
3824 emit_header(gc->pc, X_GLrop_Frustum, cmdlen);
3825 (void) memcpy((void *)(gc->pc + 4), (void *)(&left), 8);
3826 (void) memcpy((void *)(gc->pc + 12), (void *)(&right), 8);
3827 (void) memcpy((void *)(gc->pc + 20), (void *)(&bottom), 8);
3828 (void) memcpy((void *)(gc->pc + 28), (void *)(&top), 8);
3829 (void) memcpy((void *)(gc->pc + 36), (void *)(&zNear), 8);
3830 (void) memcpy((void *)(gc->pc + 44), (void *)(&zFar), 8);
3832 if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
3835 #define X_GLrop_LoadIdentity 176
3837 __indirect_glLoadIdentity(void)
3839 __GLXcontext * const gc = __glXGetCurrentContext();
3840 Display * const dpy = gc->currentDpy;
3841 const GLuint cmdlen = 4;
3843 emit_header(gc->pc, X_GLrop_LoadIdentity, cmdlen);
3845 if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
3848 #define X_GLrop_LoadMatrixf 177
3850 __indirect_glLoadMatrixf(const GLfloat * m)
3852 __GLXcontext * const gc = __glXGetCurrentContext();
3853 Display * const dpy = gc->currentDpy;
3854 const GLuint cmdlen = 68;
3856 emit_header(gc->pc, X_GLrop_LoadMatrixf, cmdlen);
3857 (void) memcpy((void *)(gc->pc + 4), (void *)(m), 64);
3859 if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
3862 #define X_GLrop_LoadMatrixd 178
3864 __indirect_glLoadMatrixd(const GLdouble * m)
3866 __GLXcontext * const gc = __glXGetCurrentContext();
3867 Display * const dpy = gc->currentDpy;
3868 const GLuint cmdlen = 132;
3870 emit_header(gc->pc, X_GLrop_LoadMatrixd, cmdlen);
3871 (void) memcpy((void *)(gc->pc + 4), (void *)(m), 128);
3873 if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
3876 #define X_GLrop_MatrixMode 179
3878 __indirect_glMatrixMode(GLenum mode)
3880 __GLXcontext * const gc = __glXGetCurrentContext();
3881 Display * const dpy = gc->currentDpy;
3882 const GLuint cmdlen = 8;
3884 emit_header(gc->pc, X_GLrop_MatrixMode, cmdlen);
3885 (void) memcpy((void *)(gc->pc + 4), (void *)(&mode), 4);
3887 if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
3890 #define X_GLrop_MultMatrixf 180
3892 __indirect_glMultMatrixf(const GLfloat * m)
3894 __GLXcontext * const gc = __glXGetCurrentContext();
3895 Display * const dpy = gc->currentDpy;
3896 const GLuint cmdlen = 68;
3898 emit_header(gc->pc, X_GLrop_MultMatrixf, cmdlen);
3899 (void) memcpy((void *)(gc->pc + 4), (void *)(m), 64);
3901 if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
3904 #define X_GLrop_MultMatrixd 181
3906 __indirect_glMultMatrixd(const GLdouble * m)
3908 __GLXcontext * const gc = __glXGetCurrentContext();
3909 Display * const dpy = gc->currentDpy;
3910 const GLuint cmdlen = 132;
3912 emit_header(gc->pc, X_GLrop_MultMatrixd, cmdlen);
3913 (void) memcpy((void *)(gc->pc + 4), (void *)(m), 128);
3915 if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
3918 #define X_GLrop_Ortho 182
3920 __indirect_glOrtho(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar)
3922 __GLXcontext * const gc = __glXGetCurrentContext();
3923 Display * const dpy = gc->currentDpy;
3924 const GLuint cmdlen = 52;
3926 emit_header(gc->pc, X_GLrop_Ortho, cmdlen);
3927 (void) memcpy((void *)(gc->pc + 4), (void *)(&left), 8);
3928 (void) memcpy((void *)(gc->pc + 12), (void *)(&right), 8);
3929 (void) memcpy((void *)(gc->pc + 20), (void *)(&bottom), 8);
3930 (void) memcpy((void *)(gc->pc + 28), (void *)(&top), 8);
3931 (void) memcpy((void *)(gc->pc + 36), (void *)(&zNear), 8);
3932 (void) memcpy((void *)(gc->pc + 44), (void *)(&zFar), 8);
3934 if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
3937 #define X_GLrop_PopMatrix 183
3939 __indirect_glPopMatrix(void)
3941 __GLXcontext * const gc = __glXGetCurrentContext();
3942 Display * const dpy = gc->currentDpy;
3943 const GLuint cmdlen = 4;
3945 emit_header(gc->pc, X_GLrop_PopMatrix, cmdlen);
3947 if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
3950 #define X_GLrop_PushMatrix 184
3952 __indirect_glPushMatrix(void)
3954 __GLXcontext * const gc = __glXGetCurrentContext();
3955 Display * const dpy = gc->currentDpy;
3956 const GLuint cmdlen = 4;
3958 emit_header(gc->pc, X_GLrop_PushMatrix, cmdlen);
3960 if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
3963 #define X_GLrop_Rotated 185
3965 __indirect_glRotated(GLdouble angle, GLdouble x, GLdouble y, GLdouble z)
3967 __GLXcontext * const gc = __glXGetCurrentContext();
3968 Display * const dpy = gc->currentDpy;
3969 const GLuint cmdlen = 36;
3971 emit_header(gc->pc, X_GLrop_Rotated, cmdlen);
3972 (void) memcpy((void *)(gc->pc + 4), (void *)(&angle), 8);
3973 (void) memcpy((void *)(gc->pc + 12), (void *)(&x), 8);
3974 (void) memcpy((void *)(gc->pc + 20), (void *)(&y), 8);
3975 (void) memcpy((void *)(gc->pc + 28), (void *)(&z), 8);
3977 if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
3980 #define X_GLrop_Rotatef 186
3982 __indirect_glRotatef(GLfloat angle, GLfloat x, GLfloat y, GLfloat z)
3984 __GLXcontext * const gc = __glXGetCurrentContext();
3985 Display * const dpy = gc->currentDpy;
3986 const GLuint cmdlen = 20;
3988 emit_header(gc->pc, X_GLrop_Rotatef, cmdlen);
3989 (void) memcpy((void *)(gc->pc + 4), (void *)(&angle), 4);
3990 (void) memcpy((void *)(gc->pc + 8), (void *)(&x), 4);
3991 (void) memcpy((void *)(gc->pc + 12), (void *)(&y), 4);
3992 (void) memcpy((void *)(gc->pc + 16), (void *)(&z), 4);
3994 if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
3997 #define X_GLrop_Scaled 187
3999 __indirect_glScaled(GLdouble x, GLdouble y, GLdouble z)
4001 __GLXcontext * const gc = __glXGetCurrentContext();
4002 Display * const dpy = gc->currentDpy;
4003 const GLuint cmdlen = 28;
4005 emit_header(gc->pc, X_GLrop_Scaled, cmdlen);
4006 (void) memcpy((void *)(gc->pc + 4), (void *)(&x), 8);
4007 (void) memcpy((void *)(gc->pc + 12), (void *)(&y), 8);
4008 (void) memcpy((void *)(gc->pc + 20), (void *)(&z), 8);
4010 if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
4013 #define X_GLrop_Scalef 188
4015 __indirect_glScalef(GLfloat x, GLfloat y, GLfloat z)
4017 __GLXcontext * const gc = __glXGetCurrentContext();
4018 Display * const dpy = gc->currentDpy;
4019 const GLuint cmdlen = 16;
4021 emit_header(gc->pc, X_GLrop_Scalef, cmdlen);
4022 (void) memcpy((void *)(gc->pc + 4), (void *)(&x), 4);
4023 (void) memcpy((void *)(gc->pc + 8), (void *)(&y), 4);
4024 (void) memcpy((void *)(gc->pc + 12), (void *)(&z), 4);
4026 if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
4029 #define X_GLrop_Translated 189
4031 __indirect_glTranslated(GLdouble x, GLdouble y, GLdouble z)
4033 __GLXcontext * const gc = __glXGetCurrentContext();
4034 Display * const dpy = gc->currentDpy;
4035 const GLuint cmdlen = 28;
4037 emit_header(gc->pc, X_GLrop_Translated, cmdlen);
4038 (void) memcpy((void *)(gc->pc + 4), (void *)(&x), 8);
4039 (void) memcpy((void *)(gc->pc + 12), (void *)(&y), 8);
4040 (void) memcpy((void *)(gc->pc + 20), (void *)(&z), 8);
4042 if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
4045 #define X_GLrop_Translatef 190
4047 __indirect_glTranslatef(GLfloat x, GLfloat y, GLfloat z)
4049 __GLXcontext * const gc = __glXGetCurrentContext();
4050 Display * const dpy = gc->currentDpy;
4051 const GLuint cmdlen = 16;
4053 emit_header(gc->pc, X_GLrop_Translatef, cmdlen);
4054 (void) memcpy((void *)(gc->pc + 4), (void *)(&x), 4);
4055 (void) memcpy((void *)(gc->pc + 8), (void *)(&y), 4);
4056 (void) memcpy((void *)(gc->pc + 12), (void *)(&z), 4);
4058 if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
4061 #define X_GLrop_Viewport 191
4063 __indirect_glViewport(GLint x, GLint y, GLsizei width, GLsizei height)
4065 __GLXcontext * const gc = __glXGetCurrentContext();
4066 Display * const dpy = gc->currentDpy;
4067 const GLuint cmdlen = 20;
4069 emit_header(gc->pc, X_GLrop_Viewport, cmdlen);
4070 (void) memcpy((void *)(gc->pc + 4), (void *)(&x), 4);
4071 (void) memcpy((void *)(gc->pc + 8), (void *)(&y), 4);
4072 (void) memcpy((void *)(gc->pc + 12), (void *)(&width), 4);
4073 (void) memcpy((void *)(gc->pc + 16), (void *)(&height), 4);
4075 if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
4078 #define X_GLrop_BindTexture 4117
4080 __indirect_glBindTexture(GLenum target, GLuint texture)
4082 __GLXcontext * const gc = __glXGetCurrentContext();
4083 Display * const dpy = gc->currentDpy;
4084 const GLuint cmdlen = 12;
4086 emit_header(gc->pc, X_GLrop_BindTexture, cmdlen);
4087 (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
4088 (void) memcpy((void *)(gc->pc + 8), (void *)(&texture), 4);
4090 if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
4093 #define X_GLrop_Indexubv 194
4095 __indirect_glIndexub(GLubyte c)
4097 __GLXcontext * const gc = __glXGetCurrentContext();
4098 Display * const dpy = gc->currentDpy;
4099 const GLuint cmdlen = 8;
4101 emit_header(gc->pc, X_GLrop_Indexubv, cmdlen);
4102 (void) memcpy((void *)(gc->pc + 4), (void *)(&c), 1);
4104 if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
4107 #define X_GLrop_Indexubv 194
4109 __indirect_glIndexubv(const GLubyte * c)
4111 __GLXcontext * const gc = __glXGetCurrentContext();
4112 Display * const dpy = gc->currentDpy;
4113 const GLuint cmdlen = 8;
4115 emit_header(gc->pc, X_GLrop_Indexubv, cmdlen);
4116 (void) memcpy((void *)(gc->pc + 4), (void *)(c), 1);
4118 if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
4121 #define X_GLrop_PolygonOffset 192
4123 __indirect_glPolygonOffset(GLfloat factor, GLfloat units)
4125 __GLXcontext * const gc = __glXGetCurrentContext();
4126 Display * const dpy = gc->currentDpy;
4127 const GLuint cmdlen = 12;
4129 emit_header(gc->pc, X_GLrop_PolygonOffset, cmdlen);
4130 (void) memcpy((void *)(gc->pc + 4), (void *)(&factor), 4);
4131 (void) memcpy((void *)(gc->pc + 8), (void *)(&units), 4);
4133 if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
4136 #define X_GLsop_AreTexturesResident 143
4138 __indirect_glAreTexturesResident(GLsizei n, const GLuint * textures, GLboolean * residences)
4140 __GLXcontext * const gc = __glXGetCurrentContext();
4141 Display * const dpy = gc->currentDpy;
4142 GLboolean retval = (GLboolean) 0;
4143 const GLuint cmdlen = 4 + __GLX_PAD((n * 4));
4144 if (n < 0) return retval;
4147 GLubyte const * pc = setup_single_request(gc, X_GLsop_AreTexturesResident, cmdlen);
4148 (void) memcpy((void *)(pc + 0), (void *)(&n), 4);
4149 (void) memcpy((void *)(pc + 4), (void *)(textures), (n * 4));
4150 retval = (GLboolean) read_reply(gc->currentDpy, 1, residences, GL_TRUE);
4151 UnlockDisplay(gc->currentDpy); SyncHandle();
4156 #define X_GLrop_CopyTexImage1D 4119
4158 __indirect_glCopyTexImage1D(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLint border)
4160 __GLXcontext * const gc = __glXGetCurrentContext();
4161 Display * const dpy = gc->currentDpy;
4162 const GLuint cmdlen = 32;
4164 emit_header(gc->pc, X_GLrop_CopyTexImage1D, cmdlen);
4165 (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
4166 (void) memcpy((void *)(gc->pc + 8), (void *)(&level), 4);
4167 (void) memcpy((void *)(gc->pc + 12), (void *)(&internalformat), 4);
4168 (void) memcpy((void *)(gc->pc + 16), (void *)(&x), 4);
4169 (void) memcpy((void *)(gc->pc + 20), (void *)(&y), 4);
4170 (void) memcpy((void *)(gc->pc + 24), (void *)(&width), 4);
4171 (void) memcpy((void *)(gc->pc + 28), (void *)(&border), 4);
4173 if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
4176 #define X_GLrop_CopyTexImage2D 4120
4178 __indirect_glCopyTexImage2D(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border)
4180 __GLXcontext * const gc = __glXGetCurrentContext();
4181 Display * const dpy = gc->currentDpy;
4182 const GLuint cmdlen = 36;
4184 emit_header(gc->pc, X_GLrop_CopyTexImage2D, cmdlen);
4185 (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
4186 (void) memcpy((void *)(gc->pc + 8), (void *)(&level), 4);
4187 (void) memcpy((void *)(gc->pc + 12), (void *)(&internalformat), 4);
4188 (void) memcpy((void *)(gc->pc + 16), (void *)(&x), 4);
4189 (void) memcpy((void *)(gc->pc + 20), (void *)(&y), 4);
4190 (void) memcpy((void *)(gc->pc + 24), (void *)(&width), 4);
4191 (void) memcpy((void *)(gc->pc + 28), (void *)(&height), 4);
4192 (void) memcpy((void *)(gc->pc + 32), (void *)(&border), 4);
4194 if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
4197 #define X_GLrop_CopyTexSubImage1D 4121
4199 __indirect_glCopyTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width)
4201 __GLXcontext * const gc = __glXGetCurrentContext();
4202 Display * const dpy = gc->currentDpy;
4203 const GLuint cmdlen = 28;
4205 emit_header(gc->pc, X_GLrop_CopyTexSubImage1D, cmdlen);
4206 (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
4207 (void) memcpy((void *)(gc->pc + 8), (void *)(&level), 4);
4208 (void) memcpy((void *)(gc->pc + 12), (void *)(&xoffset), 4);
4209 (void) memcpy((void *)(gc->pc + 16), (void *)(&x), 4);
4210 (void) memcpy((void *)(gc->pc + 20), (void *)(&y), 4);
4211 (void) memcpy((void *)(gc->pc + 24), (void *)(&width), 4);
4213 if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
4216 #define X_GLrop_CopyTexSubImage2D 4122
4218 __indirect_glCopyTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height)
4220 __GLXcontext * const gc = __glXGetCurrentContext();
4221 Display * const dpy = gc->currentDpy;
4222 const GLuint cmdlen = 36;
4224 emit_header(gc->pc, X_GLrop_CopyTexSubImage2D, cmdlen);
4225 (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
4226 (void) memcpy((void *)(gc->pc + 8), (void *)(&level), 4);
4227 (void) memcpy((void *)(gc->pc + 12), (void *)(&xoffset), 4);
4228 (void) memcpy((void *)(gc->pc + 16), (void *)(&yoffset), 4);
4229 (void) memcpy((void *)(gc->pc + 20), (void *)(&x), 4);
4230 (void) memcpy((void *)(gc->pc + 24), (void *)(&y), 4);
4231 (void) memcpy((void *)(gc->pc + 28), (void *)(&width), 4);
4232 (void) memcpy((void *)(gc->pc + 32), (void *)(&height), 4);
4234 if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
4237 #define X_GLsop_DeleteTextures 144
4239 __indirect_glDeleteTextures(GLsizei n, const GLuint * textures)
4241 __GLXcontext * const gc = __glXGetCurrentContext();
4242 Display * const dpy = gc->currentDpy;
4243 const GLuint cmdlen = 4 + __GLX_PAD((n * 4));
4247 GLubyte const * pc = setup_single_request(gc, X_GLsop_DeleteTextures, cmdlen);
4248 (void) memcpy((void *)(pc + 0), (void *)(&n), 4);
4249 (void) memcpy((void *)(pc + 4), (void *)(textures), (n * 4));
4250 UnlockDisplay(gc->currentDpy); SyncHandle();
4255 #define X_GLsop_GenTextures 145
4257 __indirect_glGenTextures(GLsizei n, GLuint * textures)
4259 __GLXcontext * const gc = __glXGetCurrentContext();
4260 Display * const dpy = gc->currentDpy;
4261 const GLuint cmdlen = 4;
4264 GLubyte const * pc = setup_single_request(gc, X_GLsop_GenTextures, cmdlen);
4265 (void) memcpy((void *)(pc + 0), (void *)(&n), 4);
4266 (void) read_reply(gc->currentDpy, 4, textures, GL_TRUE);
4267 UnlockDisplay(gc->currentDpy); SyncHandle();
4272 #define X_GLsop_IsTexture 146
4274 __indirect_glIsTexture(GLuint texture)
4276 __GLXcontext * const gc = __glXGetCurrentContext();
4277 Display * const dpy = gc->currentDpy;
4278 GLboolean retval = (GLboolean) 0;
4279 const GLuint cmdlen = 4;
4282 GLubyte const * pc = setup_single_request(gc, X_GLsop_IsTexture, cmdlen);
4283 (void) memcpy((void *)(pc + 0), (void *)(&texture), 4);
4284 retval = (GLboolean) read_reply(gc->currentDpy, 0, NULL, GL_FALSE);
4285 UnlockDisplay(gc->currentDpy); SyncHandle();
4290 #define X_GLrop_PrioritizeTextures 4118
4292 __indirect_glPrioritizeTextures(GLsizei n, const GLuint * textures, const GLclampf * priorities)
4294 __GLXcontext * const gc = __glXGetCurrentContext();
4295 Display * const dpy = gc->currentDpy;
4296 const GLuint cmdlen = 8 + __GLX_PAD((n * 4)) + __GLX_PAD((n * 4));
4299 emit_header(gc->pc, X_GLrop_PrioritizeTextures, cmdlen);
4300 (void) memcpy((void *)(gc->pc + 4), (void *)(&n), 4);
4301 (void) memcpy((void *)(gc->pc + 8), (void *)(textures), (n * 4));
4302 (void) memcpy((void *)(gc->pc + 8), (void *)(priorities), (n * 4));
4304 if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
4307 #define X_GLrop_BlendColor 4096
4309 __indirect_glBlendColor(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha)
4311 __GLXcontext * const gc = __glXGetCurrentContext();
4312 Display * const dpy = gc->currentDpy;
4313 const GLuint cmdlen = 20;
4315 emit_header(gc->pc, X_GLrop_BlendColor, cmdlen);
4316 (void) memcpy((void *)(gc->pc + 4), (void *)(&red), 4);
4317 (void) memcpy((void *)(gc->pc + 8), (void *)(&green), 4);
4318 (void) memcpy((void *)(gc->pc + 12), (void *)(&blue), 4);
4319 (void) memcpy((void *)(gc->pc + 16), (void *)(&alpha), 4);
4321 if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
4324 #define X_GLrop_BlendEquation 4097
4326 __indirect_glBlendEquation(GLenum mode)
4328 __GLXcontext * const gc = __glXGetCurrentContext();
4329 Display * const dpy = gc->currentDpy;
4330 const GLuint cmdlen = 8;
4332 emit_header(gc->pc, X_GLrop_BlendEquation, cmdlen);
4333 (void) memcpy((void *)(gc->pc + 4), (void *)(&mode), 4);
4335 if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
4338 #define X_GLrop_ColorTableParameterfv 2054
4340 __indirect_glColorTableParameterfv(GLenum target, GLenum pname, const GLfloat * params)
4342 __GLXcontext * const gc = __glXGetCurrentContext();
4343 Display * const dpy = gc->currentDpy;
4344 const GLuint compsize = __glColorTableParameterfv_size(pname);
4345 const GLuint cmdlen = 12 + __GLX_PAD((compsize * 4));
4347 emit_header(gc->pc, X_GLrop_ColorTableParameterfv, cmdlen);
4348 (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
4349 (void) memcpy((void *)(gc->pc + 8), (void *)(&pname), 4);
4350 (void) memcpy((void *)(gc->pc + 12), (void *)(params), (compsize * 4));
4352 if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
4355 #define X_GLrop_ColorTableParameteriv 2055
4357 __indirect_glColorTableParameteriv(GLenum target, GLenum pname, const GLint * params)
4359 __GLXcontext * const gc = __glXGetCurrentContext();
4360 Display * const dpy = gc->currentDpy;
4361 const GLuint compsize = __glColorTableParameteriv_size(pname);
4362 const GLuint cmdlen = 12 + __GLX_PAD((compsize * 4));
4364 emit_header(gc->pc, X_GLrop_ColorTableParameteriv, cmdlen);
4365 (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
4366 (void) memcpy((void *)(gc->pc + 8), (void *)(&pname), 4);
4367 (void) memcpy((void *)(gc->pc + 12), (void *)(params), (compsize * 4));
4369 if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
4372 #define X_GLrop_CopyColorTable 2056
4374 __indirect_glCopyColorTable(GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width)
4376 __GLXcontext * const gc = __glXGetCurrentContext();
4377 Display * const dpy = gc->currentDpy;
4378 const GLuint cmdlen = 24;
4380 emit_header(gc->pc, X_GLrop_CopyColorTable, cmdlen);
4381 (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
4382 (void) memcpy((void *)(gc->pc + 8), (void *)(&internalformat), 4);
4383 (void) memcpy((void *)(gc->pc + 12), (void *)(&x), 4);
4384 (void) memcpy((void *)(gc->pc + 16), (void *)(&y), 4);
4385 (void) memcpy((void *)(gc->pc + 20), (void *)(&width), 4);
4387 if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
4390 #define X_GLsop_GetColorTableParameterfv 148
4392 __indirect_glGetColorTableParameterfv(GLenum target, GLenum pname, GLfloat * params)
4394 __GLXcontext * const gc = __glXGetCurrentContext();
4395 Display * const dpy = gc->currentDpy;
4396 const GLuint cmdlen = 8;
4399 GLubyte const * pc = setup_single_request(gc, X_GLsop_GetColorTableParameterfv, cmdlen);
4400 (void) memcpy((void *)(pc + 0), (void *)(&target), 4);
4401 (void) memcpy((void *)(pc + 4), (void *)(&pname), 4);
4402 (void) read_reply(gc->currentDpy, 4, params, GL_FALSE);
4403 UnlockDisplay(gc->currentDpy); SyncHandle();
4408 #define X_GLsop_GetColorTableParameteriv 149
4410 __indirect_glGetColorTableParameteriv(GLenum target, GLenum pname, GLint * params)
4412 __GLXcontext * const gc = __glXGetCurrentContext();
4413 Display * const dpy = gc->currentDpy;
4414 const GLuint cmdlen = 8;
4417 GLubyte const * pc = setup_single_request(gc, X_GLsop_GetColorTableParameteriv, cmdlen);
4418 (void) memcpy((void *)(pc + 0), (void *)(&target), 4);
4419 (void) memcpy((void *)(pc + 4), (void *)(&pname), 4);
4420 (void) read_reply(gc->currentDpy, 4, params, GL_FALSE);
4421 UnlockDisplay(gc->currentDpy); SyncHandle();
4426 #define X_GLrop_CopyColorSubTable 196
4428 __indirect_glCopyColorSubTable(GLenum target, GLsizei start, GLint x, GLint y, GLsizei width)
4430 __GLXcontext * const gc = __glXGetCurrentContext();
4431 Display * const dpy = gc->currentDpy;
4432 const GLuint cmdlen = 24;
4434 emit_header(gc->pc, X_GLrop_CopyColorSubTable, cmdlen);
4435 (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
4436 (void) memcpy((void *)(gc->pc + 8), (void *)(&start), 4);
4437 (void) memcpy((void *)(gc->pc + 12), (void *)(&x), 4);
4438 (void) memcpy((void *)(gc->pc + 16), (void *)(&y), 4);
4439 (void) memcpy((void *)(gc->pc + 20), (void *)(&width), 4);
4441 if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
4444 #define X_GLrop_ConvolutionParameterf 4103
4446 __indirect_glConvolutionParameterf(GLenum target, GLenum pname, GLfloat params)
4448 __GLXcontext * const gc = __glXGetCurrentContext();
4449 Display * const dpy = gc->currentDpy;
4450 const GLuint cmdlen = 16;
4452 emit_header(gc->pc, X_GLrop_ConvolutionParameterf, cmdlen);
4453 (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
4454 (void) memcpy((void *)(gc->pc + 8), (void *)(&pname), 4);
4455 (void) memcpy((void *)(gc->pc + 12), (void *)(¶ms), 4);
4457 if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
4460 #define X_GLrop_ConvolutionParameterfv 4104
4462 __indirect_glConvolutionParameterfv(GLenum target, GLenum pname, const GLfloat * params)
4464 __GLXcontext * const gc = __glXGetCurrentContext();
4465 Display * const dpy = gc->currentDpy;
4466 const GLuint compsize = __glConvolutionParameterfv_size(pname);
4467 const GLuint cmdlen = 12 + __GLX_PAD((compsize * 4));
4469 emit_header(gc->pc, X_GLrop_ConvolutionParameterfv, cmdlen);
4470 (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
4471 (void) memcpy((void *)(gc->pc + 8), (void *)(&pname), 4);
4472 (void) memcpy((void *)(gc->pc + 12), (void *)(params), (compsize * 4));
4474 if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
4477 #define X_GLrop_ConvolutionParameteri 4105
4479 __indirect_glConvolutionParameteri(GLenum target, GLenum pname, GLint params)
4481 __GLXcontext * const gc = __glXGetCurrentContext();
4482 Display * const dpy = gc->currentDpy;
4483 const GLuint cmdlen = 16;
4485 emit_header(gc->pc, X_GLrop_ConvolutionParameteri, cmdlen);
4486 (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
4487 (void) memcpy((void *)(gc->pc + 8), (void *)(&pname), 4);
4488 (void) memcpy((void *)(gc->pc + 12), (void *)(¶ms), 4);
4490 if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
4493 #define X_GLrop_ConvolutionParameteriv 4106
4495 __indirect_glConvolutionParameteriv(GLenum target, GLenum pname, const GLint * params)
4497 __GLXcontext * const gc = __glXGetCurrentContext();
4498 Display * const dpy = gc->currentDpy;
4499 const GLuint compsize = __glConvolutionParameteriv_size(pname);
4500 const GLuint cmdlen = 12 + __GLX_PAD((compsize * 4));
4502 emit_header(gc->pc, X_GLrop_ConvolutionParameteriv, cmdlen);
4503 (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
4504 (void) memcpy((void *)(gc->pc + 8), (void *)(&pname), 4);
4505 (void) memcpy((void *)(gc->pc + 12), (void *)(params), (compsize * 4));
4507 if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
4510 #define X_GLrop_CopyConvolutionFilter1D 4107
4512 __indirect_glCopyConvolutionFilter1D(GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width)
4514 __GLXcontext * const gc = __glXGetCurrentContext();
4515 Display * const dpy = gc->currentDpy;
4516 const GLuint cmdlen = 24;
4518 emit_header(gc->pc, X_GLrop_CopyConvolutionFilter1D, cmdlen);
4519 (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
4520 (void) memcpy((void *)(gc->pc + 8), (void *)(&internalformat), 4);
4521 (void) memcpy((void *)(gc->pc + 12), (void *)(&x), 4);
4522 (void) memcpy((void *)(gc->pc + 16), (void *)(&y), 4);
4523 (void) memcpy((void *)(gc->pc + 20), (void *)(&width), 4);
4525 if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
4528 #define X_GLrop_CopyConvolutionFilter2D 4108
4530 __indirect_glCopyConvolutionFilter2D(GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height)
4532 __GLXcontext * const gc = __glXGetCurrentContext();
4533 Display * const dpy = gc->currentDpy;
4534 const GLuint cmdlen = 28;
4536 emit_header(gc->pc, X_GLrop_CopyConvolutionFilter2D, cmdlen);
4537 (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
4538 (void) memcpy((void *)(gc->pc + 8), (void *)(&internalformat), 4);
4539 (void) memcpy((void *)(gc->pc + 12), (void *)(&x), 4);
4540 (void) memcpy((void *)(gc->pc + 16), (void *)(&y), 4);
4541 (void) memcpy((void *)(gc->pc + 20), (void *)(&width), 4);
4542 (void) memcpy((void *)(gc->pc + 24), (void *)(&height), 4);
4544 if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
4547 #define X_GLsop_GetConvolutionParameterfv 151
4549 __indirect_glGetConvolutionParameterfv(GLenum target, GLenum pname, GLfloat * params)
4551 __GLXcontext * const gc = __glXGetCurrentContext();
4552 Display * const dpy = gc->currentDpy;
4553 const GLuint cmdlen = 8;
4556 GLubyte const * pc = setup_single_request(gc, X_GLsop_GetConvolutionParameterfv, cmdlen);
4557 (void) memcpy((void *)(pc + 0), (void *)(&target), 4);
4558 (void) memcpy((void *)(pc + 4), (void *)(&pname), 4);
4559 (void) read_reply(gc->currentDpy, 4, params, GL_FALSE);
4560 UnlockDisplay(gc->currentDpy); SyncHandle();
4565 #define X_GLsop_GetConvolutionParameteriv 152
4567 __indirect_glGetConvolutionParameteriv(GLenum target, GLenum pname, GLint * params)
4569 __GLXcontext * const gc = __glXGetCurrentContext();
4570 Display * const dpy = gc->currentDpy;
4571 const GLuint cmdlen = 8;
4574 GLubyte const * pc = setup_single_request(gc, X_GLsop_GetConvolutionParameteriv, cmdlen);
4575 (void) memcpy((void *)(pc + 0), (void *)(&target), 4);
4576 (void) memcpy((void *)(pc + 4), (void *)(&pname), 4);
4577 (void) read_reply(gc->currentDpy, 4, params, GL_FALSE);
4578 UnlockDisplay(gc->currentDpy); SyncHandle();
4583 #define X_GLsop_GetHistogramParameterfv 155
4585 __indirect_glGetHistogramParameterfv(GLenum target, GLenum pname, GLfloat * params)
4587 __GLXcontext * const gc = __glXGetCurrentContext();
4588 Display * const dpy = gc->currentDpy;
4589 const GLuint cmdlen = 8;
4592 GLubyte const * pc = setup_single_request(gc, X_GLsop_GetHistogramParameterfv, cmdlen);
4593 (void) memcpy((void *)(pc + 0), (void *)(&target), 4);
4594 (void) memcpy((void *)(pc + 4), (void *)(&pname), 4);
4595 (void) read_reply(gc->currentDpy, 4, params, GL_FALSE);
4596 UnlockDisplay(gc->currentDpy); SyncHandle();
4601 #define X_GLsop_GetHistogramParameteriv 156
4603 __indirect_glGetHistogramParameteriv(GLenum target, GLenum pname, GLint * params)
4605 __GLXcontext * const gc = __glXGetCurrentContext();
4606 Display * const dpy = gc->currentDpy;
4607 const GLuint cmdlen = 8;
4610 GLubyte const * pc = setup_single_request(gc, X_GLsop_GetHistogramParameteriv, cmdlen);
4611 (void) memcpy((void *)(pc + 0), (void *)(&target), 4);
4612 (void) memcpy((void *)(pc + 4), (void *)(&pname), 4);
4613 (void) read_reply(gc->currentDpy, 4, params, GL_FALSE);
4614 UnlockDisplay(gc->currentDpy); SyncHandle();
4619 #define X_GLsop_GetMinmaxParameterfv 158
4621 __indirect_glGetMinmaxParameterfv(GLenum target, GLenum pname, GLfloat * params)
4623 __GLXcontext * const gc = __glXGetCurrentContext();
4624 Display * const dpy = gc->currentDpy;
4625 const GLuint cmdlen = 8;
4628 GLubyte const * pc = setup_single_request(gc, X_GLsop_GetMinmaxParameterfv, cmdlen);
4629 (void) memcpy((void *)(pc + 0), (void *)(&target), 4);
4630 (void) memcpy((void *)(pc + 4), (void *)(&pname), 4);
4631 (void) read_reply(gc->currentDpy, 4, params, GL_FALSE);
4632 UnlockDisplay(gc->currentDpy); SyncHandle();
4637 #define X_GLsop_GetMinmaxParameteriv 159
4639 __indirect_glGetMinmaxParameteriv(GLenum target, GLenum pname, GLint * params)
4641 __GLXcontext * const gc = __glXGetCurrentContext();
4642 Display * const dpy = gc->currentDpy;
4643 const GLuint cmdlen = 8;
4646 GLubyte const * pc = setup_single_request(gc, X_GLsop_GetMinmaxParameteriv, cmdlen);
4647 (void) memcpy((void *)(pc + 0), (void *)(&target), 4);
4648 (void) memcpy((void *)(pc + 4), (void *)(&pname), 4);
4649 (void) read_reply(gc->currentDpy, 4, params, GL_FALSE);
4650 UnlockDisplay(gc->currentDpy); SyncHandle();
4655 #define X_GLrop_Histogram 4110
4657 __indirect_glHistogram(GLenum target, GLsizei width, GLenum internalformat, GLboolean sink)
4659 __GLXcontext * const gc = __glXGetCurrentContext();
4660 Display * const dpy = gc->currentDpy;
4661 const GLuint cmdlen = 20;
4663 emit_header(gc->pc, X_GLrop_Histogram, cmdlen);
4664 (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
4665 (void) memcpy((void *)(gc->pc + 8), (void *)(&width), 4);
4666 (void) memcpy((void *)(gc->pc + 12), (void *)(&internalformat), 4);
4667 (void) memcpy((void *)(gc->pc + 16), (void *)(&sink), 1);
4669 if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
4672 #define X_GLrop_Minmax 4111
4674 __indirect_glMinmax(GLenum target, GLenum internalformat, GLboolean sink)
4676 __GLXcontext * const gc = __glXGetCurrentContext();
4677 Display * const dpy = gc->currentDpy;
4678 const GLuint cmdlen = 16;
4680 emit_header(gc->pc, X_GLrop_Minmax, cmdlen);
4681 (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
4682 (void) memcpy((void *)(gc->pc + 8), (void *)(&internalformat), 4);
4683 (void) memcpy((void *)(gc->pc + 12), (void *)(&sink), 1);
4685 if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
4688 #define X_GLrop_ResetHistogram 4112
4690 __indirect_glResetHistogram(GLenum target)
4692 __GLXcontext * const gc = __glXGetCurrentContext();
4693 Display * const dpy = gc->currentDpy;
4694 const GLuint cmdlen = 8;
4696 emit_header(gc->pc, X_GLrop_ResetHistogram, cmdlen);
4697 (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
4699 if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
4702 #define X_GLrop_ResetMinmax 4113
4704 __indirect_glResetMinmax(GLenum target)
4706 __GLXcontext * const gc = __glXGetCurrentContext();
4707 Display * const dpy = gc->currentDpy;
4708 const GLuint cmdlen = 8;
4710 emit_header(gc->pc, X_GLrop_ResetMinmax, cmdlen);
4711 (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
4713 if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
4716 #define X_GLrop_CopyTexSubImage3D 4123
4718 __indirect_glCopyTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height)
4720 __GLXcontext * const gc = __glXGetCurrentContext();
4721 Display * const dpy = gc->currentDpy;
4722 const GLuint cmdlen = 40;
4724 emit_header(gc->pc, X_GLrop_CopyTexSubImage3D, cmdlen);
4725 (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
4726 (void) memcpy((void *)(gc->pc + 8), (void *)(&level), 4);
4727 (void) memcpy((void *)(gc->pc + 12), (void *)(&xoffset), 4);
4728 (void) memcpy((void *)(gc->pc + 16), (void *)(&yoffset), 4);
4729 (void) memcpy((void *)(gc->pc + 20), (void *)(&zoffset), 4);
4730 (void) memcpy((void *)(gc->pc + 24), (void *)(&x), 4);
4731 (void) memcpy((void *)(gc->pc + 28), (void *)(&y), 4);
4732 (void) memcpy((void *)(gc->pc + 32), (void *)(&width), 4);
4733 (void) memcpy((void *)(gc->pc + 36), (void *)(&height), 4);
4735 if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
4738 #define X_GLrop_ActiveTextureARB 197
4740 __indirect_glActiveTextureARB(GLenum texture)
4742 __GLXcontext * const gc = __glXGetCurrentContext();
4743 Display * const dpy = gc->currentDpy;
4744 const GLuint cmdlen = 8;
4746 emit_header(gc->pc, X_GLrop_ActiveTextureARB, cmdlen);
4747 (void) memcpy((void *)(gc->pc + 4), (void *)(&texture), 4);
4749 if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
4752 #define X_GLrop_MultiTexCoord1dvARB 198
4754 __indirect_glMultiTexCoord1dARB(GLenum target, GLdouble s)
4756 __GLXcontext * const gc = __glXGetCurrentContext();
4757 Display * const dpy = gc->currentDpy;
4758 const GLuint cmdlen = 16;
4760 emit_header(gc->pc, X_GLrop_MultiTexCoord1dvARB, cmdlen);
4761 (void) memcpy((void *)(gc->pc + 4), (void *)(&s), 8);
4762 (void) memcpy((void *)(gc->pc + 12), (void *)(&target), 4);
4764 if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
4767 #define X_GLrop_MultiTexCoord1dvARB 198
4769 __indirect_glMultiTexCoord1dvARB(GLenum target, const GLdouble * v)
4771 __GLXcontext * const gc = __glXGetCurrentContext();
4772 Display * const dpy = gc->currentDpy;
4773 const GLuint cmdlen = 16;
4775 emit_header(gc->pc, X_GLrop_MultiTexCoord1dvARB, cmdlen);
4776 (void) memcpy((void *)(gc->pc + 4), (void *)(v), 8);
4777 (void) memcpy((void *)(gc->pc + 12), (void *)(&target), 4);
4779 if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
4782 #define X_GLrop_MultiTexCoord1fvARB 199
4784 __indirect_glMultiTexCoord1fARB(GLenum target, GLfloat s)
4786 __GLXcontext * const gc = __glXGetCurrentContext();
4787 Display * const dpy = gc->currentDpy;
4788 const GLuint cmdlen = 12;
4790 emit_header(gc->pc, X_GLrop_MultiTexCoord1fvARB, cmdlen);
4791 (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
4792 (void) memcpy((void *)(gc->pc + 8), (void *)(&s), 4);
4794 if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
4797 #define X_GLrop_MultiTexCoord1fvARB 199
4799 __indirect_glMultiTexCoord1fvARB(GLenum target, const GLfloat * v)
4801 __GLXcontext * const gc = __glXGetCurrentContext();
4802 Display * const dpy = gc->currentDpy;
4803 const GLuint cmdlen = 12;
4805 emit_header(gc->pc, X_GLrop_MultiTexCoord1fvARB, cmdlen);
4806 (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
4807 (void) memcpy((void *)(gc->pc + 8), (void *)(v), 4);
4809 if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
4812 #define X_GLrop_MultiTexCoord1ivARB 200
4814 __indirect_glMultiTexCoord1iARB(GLenum target, GLint s)
4816 __GLXcontext * const gc = __glXGetCurrentContext();
4817 Display * const dpy = gc->currentDpy;
4818 const GLuint cmdlen = 12;
4820 emit_header(gc->pc, X_GLrop_MultiTexCoord1ivARB, cmdlen);
4821 (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
4822 (void) memcpy((void *)(gc->pc + 8), (void *)(&s), 4);
4824 if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
4827 #define X_GLrop_MultiTexCoord1ivARB 200
4829 __indirect_glMultiTexCoord1ivARB(GLenum target, const GLint * v)
4831 __GLXcontext * const gc = __glXGetCurrentContext();
4832 Display * const dpy = gc->currentDpy;
4833 const GLuint cmdlen = 12;
4835 emit_header(gc->pc, X_GLrop_MultiTexCoord1ivARB, cmdlen);
4836 (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
4837 (void) memcpy((void *)(gc->pc + 8), (void *)(v), 4);
4839 if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
4842 #define X_GLrop_MultiTexCoord1svARB 201
4844 __indirect_glMultiTexCoord1sARB(GLenum target, GLshort s)
4846 __GLXcontext * const gc = __glXGetCurrentContext();
4847 Display * const dpy = gc->currentDpy;
4848 const GLuint cmdlen = 12;
4850 emit_header(gc->pc, X_GLrop_MultiTexCoord1svARB, cmdlen);
4851 (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
4852 (void) memcpy((void *)(gc->pc + 8), (void *)(&s), 2);
4854 if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
4857 #define X_GLrop_MultiTexCoord1svARB 201
4859 __indirect_glMultiTexCoord1svARB(GLenum target, const GLshort * v)
4861 __GLXcontext * const gc = __glXGetCurrentContext();
4862 Display * const dpy = gc->currentDpy;
4863 const GLuint cmdlen = 12;
4865 emit_header(gc->pc, X_GLrop_MultiTexCoord1svARB, cmdlen);
4866 (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
4867 (void) memcpy((void *)(gc->pc + 8), (void *)(v), 2);
4869 if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
4872 #define X_GLrop_MultiTexCoord2dvARB 202
4874 __indirect_glMultiTexCoord2dARB(GLenum target, GLdouble s, GLdouble t)
4876 __GLXcontext * const gc = __glXGetCurrentContext();
4877 Display * const dpy = gc->currentDpy;
4878 const GLuint cmdlen = 24;
4880 emit_header(gc->pc, X_GLrop_MultiTexCoord2dvARB, cmdlen);
4881 (void) memcpy((void *)(gc->pc + 4), (void *)(&s), 8);
4882 (void) memcpy((void *)(gc->pc + 12), (void *)(&t), 8);
4883 (void) memcpy((void *)(gc->pc + 20), (void *)(&target), 4);
4885 if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
4888 #define X_GLrop_MultiTexCoord2dvARB 202
4890 __indirect_glMultiTexCoord2dvARB(GLenum target, const GLdouble * v)
4892 __GLXcontext * const gc = __glXGetCurrentContext();
4893 Display * const dpy = gc->currentDpy;
4894 const GLuint cmdlen = 24;
4896 emit_header(gc->pc, X_GLrop_MultiTexCoord2dvARB, cmdlen);
4897 (void) memcpy((void *)(gc->pc + 4), (void *)(v), 16);
4898 (void) memcpy((void *)(gc->pc + 20), (void *)(&target), 4);
4900 if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
4903 #define X_GLrop_MultiTexCoord2fvARB 203
4905 __indirect_glMultiTexCoord2fARB(GLenum target, GLfloat s, GLfloat t)
4907 __GLXcontext * const gc = __glXGetCurrentContext();
4908 Display * const dpy = gc->currentDpy;
4909 const GLuint cmdlen = 16;
4911 emit_header(gc->pc, X_GLrop_MultiTexCoord2fvARB, cmdlen);
4912 (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
4913 (void) memcpy((void *)(gc->pc + 8), (void *)(&s), 4);
4914 (void) memcpy((void *)(gc->pc + 12), (void *)(&t), 4);
4916 if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
4919 #define X_GLrop_MultiTexCoord2fvARB 203
4921 __indirect_glMultiTexCoord2fvARB(GLenum target, const GLfloat * v)
4923 __GLXcontext * const gc = __glXGetCurrentContext();
4924 Display * const dpy = gc->currentDpy;
4925 const GLuint cmdlen = 16;
4927 emit_header(gc->pc, X_GLrop_MultiTexCoord2fvARB, cmdlen);
4928 (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
4929 (void) memcpy((void *)(gc->pc + 8), (void *)(v), 8);
4931 if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
4934 #define X_GLrop_MultiTexCoord2ivARB 204
4936 __indirect_glMultiTexCoord2iARB(GLenum target, GLint s, GLint t)
4938 __GLXcontext * const gc = __glXGetCurrentContext();
4939 Display * const dpy = gc->currentDpy;
4940 const GLuint cmdlen = 16;
4942 emit_header(gc->pc, X_GLrop_MultiTexCoord2ivARB, cmdlen);
4943 (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
4944 (void) memcpy((void *)(gc->pc + 8), (void *)(&s), 4);
4945 (void) memcpy((void *)(gc->pc + 12), (void *)(&t), 4);
4947 if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
4950 #define X_GLrop_MultiTexCoord2ivARB 204
4952 __indirect_glMultiTexCoord2ivARB(GLenum target, const GLint * v)
4954 __GLXcontext * const gc = __glXGetCurrentContext();
4955 Display * const dpy = gc->currentDpy;
4956 const GLuint cmdlen = 16;
4958 emit_header(gc->pc, X_GLrop_MultiTexCoord2ivARB, cmdlen);
4959 (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
4960 (void) memcpy((void *)(gc->pc + 8), (void *)(v), 8);
4962 if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
4965 #define X_GLrop_MultiTexCoord2svARB 205
4967 __indirect_glMultiTexCoord2sARB(GLenum target, GLshort s, GLshort t)
4969 __GLXcontext * const gc = __glXGetCurrentContext();
4970 Display * const dpy = gc->currentDpy;
4971 const GLuint cmdlen = 12;
4973 emit_header(gc->pc, X_GLrop_MultiTexCoord2svARB, cmdlen);
4974 (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
4975 (void) memcpy((void *)(gc->pc + 8), (void *)(&s), 2);
4976 (void) memcpy((void *)(gc->pc + 10), (void *)(&t), 2);
4978 if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
4981 #define X_GLrop_MultiTexCoord2svARB 205
4983 __indirect_glMultiTexCoord2svARB(GLenum target, const GLshort * v)
4985 __GLXcontext * const gc = __glXGetCurrentContext();
4986 Display * const dpy = gc->currentDpy;
4987 const GLuint cmdlen = 12;
4989 emit_header(gc->pc, X_GLrop_MultiTexCoord2svARB, cmdlen);
4990 (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
4991 (void) memcpy((void *)(gc->pc + 8), (void *)(v), 4);
4993 if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
4996 #define X_GLrop_MultiTexCoord3dvARB 206
4998 __indirect_glMultiTexCoord3dARB(GLenum target, GLdouble s, GLdouble t, GLdouble r)
5000 __GLXcontext * const gc = __glXGetCurrentContext();
5001 Display * const dpy = gc->currentDpy;
5002 const GLuint cmdlen = 32;
5004 emit_header(gc->pc, X_GLrop_MultiTexCoord3dvARB, cmdlen);
5005 (void) memcpy((void *)(gc->pc + 4), (void *)(&s), 8);
5006 (void) memcpy((void *)(gc->pc + 12), (void *)(&t), 8);
5007 (void) memcpy((void *)(gc->pc + 20), (void *)(&r), 8);
5008 (void) memcpy((void *)(gc->pc + 28), (void *)(&target), 4);
5010 if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
5013 #define X_GLrop_MultiTexCoord3dvARB 206
5015 __indirect_glMultiTexCoord3dvARB(GLenum target, const GLdouble * v)
5017 __GLXcontext * const gc = __glXGetCurrentContext();
5018 Display * const dpy = gc->currentDpy;
5019 const GLuint cmdlen = 32;
5021 emit_header(gc->pc, X_GLrop_MultiTexCoord3dvARB, cmdlen);
5022 (void) memcpy((void *)(gc->pc + 4), (void *)(v), 24);
5023 (void) memcpy((void *)(gc->pc + 28), (void *)(&target), 4);
5025 if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
5028 #define X_GLrop_MultiTexCoord3fvARB 207
5030 __indirect_glMultiTexCoord3fARB(GLenum target, GLfloat s, GLfloat t, GLfloat r)
5032 __GLXcontext * const gc = __glXGetCurrentContext();
5033 Display * const dpy = gc->currentDpy;
5034 const GLuint cmdlen = 20;
5036 emit_header(gc->pc, X_GLrop_MultiTexCoord3fvARB, cmdlen);
5037 (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
5038 (void) memcpy((void *)(gc->pc + 8), (void *)(&s), 4);
5039 (void) memcpy((void *)(gc->pc + 12), (void *)(&t), 4);
5040 (void) memcpy((void *)(gc->pc + 16), (void *)(&r), 4);
5042 if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
5045 #define X_GLrop_MultiTexCoord3fvARB 207
5047 __indirect_glMultiTexCoord3fvARB(GLenum target, const GLfloat * v)
5049 __GLXcontext * const gc = __glXGetCurrentContext();
5050 Display * const dpy = gc->currentDpy;
5051 const GLuint cmdlen = 20;
5053 emit_header(gc->pc, X_GLrop_MultiTexCoord3fvARB, cmdlen);
5054 (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
5055 (void) memcpy((void *)(gc->pc + 8), (void *)(v), 12);
5057 if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
5060 #define X_GLrop_MultiTexCoord3ivARB 208
5062 __indirect_glMultiTexCoord3iARB(GLenum target, GLint s, GLint t, GLint r)
5064 __GLXcontext * const gc = __glXGetCurrentContext();
5065 Display * const dpy = gc->currentDpy;
5066 const GLuint cmdlen = 20;
5068 emit_header(gc->pc, X_GLrop_MultiTexCoord3ivARB, cmdlen);
5069 (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
5070 (void) memcpy((void *)(gc->pc + 8), (void *)(&s), 4);
5071 (void) memcpy((void *)(gc->pc + 12), (void *)(&t), 4);
5072 (void) memcpy((void *)(gc->pc + 16), (void *)(&r), 4);
5074 if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
5077 #define X_GLrop_MultiTexCoord3ivARB 208
5079 __indirect_glMultiTexCoord3ivARB(GLenum target, const GLint * v)
5081 __GLXcontext * const gc = __glXGetCurrentContext();
5082 Display * const dpy = gc->currentDpy;
5083 const GLuint cmdlen = 20;
5085 emit_header(gc->pc, X_GLrop_MultiTexCoord3ivARB, cmdlen);
5086 (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
5087 (void) memcpy((void *)(gc->pc + 8), (void *)(v), 12);
5089 if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
5092 #define X_GLrop_MultiTexCoord3svARB 209
5094 __indirect_glMultiTexCoord3sARB(GLenum target, GLshort s, GLshort t, GLshort r)
5096 __GLXcontext * const gc = __glXGetCurrentContext();
5097 Display * const dpy = gc->currentDpy;
5098 const GLuint cmdlen = 16;
5100 emit_header(gc->pc, X_GLrop_MultiTexCoord3svARB, cmdlen);
5101 (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
5102 (void) memcpy((void *)(gc->pc + 8), (void *)(&s), 2);
5103 (void) memcpy((void *)(gc->pc + 10), (void *)(&t), 2);
5104 (void) memcpy((void *)(gc->pc + 12), (void *)(&r), 2);
5106 if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
5109 #define X_GLrop_MultiTexCoord3svARB 209
5111 __indirect_glMultiTexCoord3svARB(GLenum target, const GLshort * v)
5113 __GLXcontext * const gc = __glXGetCurrentContext();
5114 Display * const dpy = gc->currentDpy;
5115 const GLuint cmdlen = 16;
5117 emit_header(gc->pc, X_GLrop_MultiTexCoord3svARB, cmdlen);
5118 (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
5119 (void) memcpy((void *)(gc->pc + 8), (void *)(v), 6);
5121 if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
5124 #define X_GLrop_MultiTexCoord4dvARB 210
5126 __indirect_glMultiTexCoord4dARB(GLenum target, GLdouble s, GLdouble t, GLdouble r, GLdouble q)
5128 __GLXcontext * const gc = __glXGetCurrentContext();
5129 Display * const dpy = gc->currentDpy;
5130 const GLuint cmdlen = 40;
5132 emit_header(gc->pc, X_GLrop_MultiTexCoord4dvARB, cmdlen);
5133 (void) memcpy((void *)(gc->pc + 4), (void *)(&s), 8);
5134 (void) memcpy((void *)(gc->pc + 12), (void *)(&t), 8);
5135 (void) memcpy((void *)(gc->pc + 20), (void *)(&r), 8);
5136 (void) memcpy((void *)(gc->pc + 28), (void *)(&q), 8);
5137 (void) memcpy((void *)(gc->pc + 36), (void *)(&target), 4);
5139 if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
5142 #define X_GLrop_MultiTexCoord4dvARB 210
5144 __indirect_glMultiTexCoord4dvARB(GLenum target, const GLdouble * v)
5146 __GLXcontext * const gc = __glXGetCurrentContext();
5147 Display * const dpy = gc->currentDpy;
5148 const GLuint cmdlen = 40;
5150 emit_header(gc->pc, X_GLrop_MultiTexCoord4dvARB, cmdlen);
5151 (void) memcpy((void *)(gc->pc + 4), (void *)(v), 32);
5152 (void) memcpy((void *)(gc->pc + 36), (void *)(&target), 4);
5154 if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
5157 #define X_GLrop_MultiTexCoord4fvARB 211
5159 __indirect_glMultiTexCoord4fARB(GLenum target, GLfloat s, GLfloat t, GLfloat r, GLfloat q)
5161 __GLXcontext * const gc = __glXGetCurrentContext();
5162 Display * const dpy = gc->currentDpy;
5163 const GLuint cmdlen = 24;
5165 emit_header(gc->pc, X_GLrop_MultiTexCoord4fvARB, cmdlen);
5166 (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
5167 (void) memcpy((void *)(gc->pc + 8), (void *)(&s), 4);
5168 (void) memcpy((void *)(gc->pc + 12), (void *)(&t), 4);
5169 (void) memcpy((void *)(gc->pc + 16), (void *)(&r), 4);
5170 (void) memcpy((void *)(gc->pc + 20), (void *)(&q), 4);
5172 if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
5175 #define X_GLrop_MultiTexCoord4fvARB 211
5177 __indirect_glMultiTexCoord4fvARB(GLenum target, const GLfloat * v)
5179 __GLXcontext * const gc = __glXGetCurrentContext();
5180 Display * const dpy = gc->currentDpy;
5181 const GLuint cmdlen = 24;
5183 emit_header(gc->pc, X_GLrop_MultiTexCoord4fvARB, cmdlen);
5184 (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
5185 (void) memcpy((void *)(gc->pc + 8), (void *)(v), 16);
5187 if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
5190 #define X_GLrop_MultiTexCoord4ivARB 212
5192 __indirect_glMultiTexCoord4iARB(GLenum target, GLint s, GLint t, GLint r, GLint q)
5194 __GLXcontext * const gc = __glXGetCurrentContext();
5195 Display * const dpy = gc->currentDpy;
5196 const GLuint cmdlen = 24;
5198 emit_header(gc->pc, X_GLrop_MultiTexCoord4ivARB, cmdlen);
5199 (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
5200 (void) memcpy((void *)(gc->pc + 8), (void *)(&s), 4);
5201 (void) memcpy((void *)(gc->pc + 12), (void *)(&t), 4);
5202 (void) memcpy((void *)(gc->pc + 16), (void *)(&r), 4);
5203 (void) memcpy((void *)(gc->pc + 20), (void *)(&q), 4);
5205 if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
5208 #define X_GLrop_MultiTexCoord4ivARB 212
5210 __indirect_glMultiTexCoord4ivARB(GLenum target, const GLint * v)
5212 __GLXcontext * const gc = __glXGetCurrentContext();
5213 Display * const dpy = gc->currentDpy;
5214 const GLuint cmdlen = 24;
5216 emit_header(gc->pc, X_GLrop_MultiTexCoord4ivARB, cmdlen);
5217 (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
5218 (void) memcpy((void *)(gc->pc + 8), (void *)(v), 16);
5220 if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
5223 #define X_GLrop_MultiTexCoord4svARB 213
5225 __indirect_glMultiTexCoord4sARB(GLenum target, GLshort s, GLshort t, GLshort r, GLshort q)
5227 __GLXcontext * const gc = __glXGetCurrentContext();
5228 Display * const dpy = gc->currentDpy;
5229 const GLuint cmdlen = 16;
5231 emit_header(gc->pc, X_GLrop_MultiTexCoord4svARB, cmdlen);
5232 (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
5233 (void) memcpy((void *)(gc->pc + 8), (void *)(&s), 2);
5234 (void) memcpy((void *)(gc->pc + 10), (void *)(&t), 2);
5235 (void) memcpy((void *)(gc->pc + 12), (void *)(&r), 2);
5236 (void) memcpy((void *)(gc->pc + 14), (void *)(&q), 2);
5238 if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
5241 #define X_GLrop_MultiTexCoord4svARB 213
5243 __indirect_glMultiTexCoord4svARB(GLenum target, const GLshort * v)
5245 __GLXcontext * const gc = __glXGetCurrentContext();
5246 Display * const dpy = gc->currentDpy;
5247 const GLuint cmdlen = 16;
5249 emit_header(gc->pc, X_GLrop_MultiTexCoord4svARB, cmdlen);
5250 (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
5251 (void) memcpy((void *)(gc->pc + 8), (void *)(v), 8);
5253 if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
5256 #define X_GLrop_SampleCoverageARB 229
5258 __indirect_glSampleCoverageARB(GLclampf value, GLboolean invert)
5260 __GLXcontext * const gc = __glXGetCurrentContext();
5261 Display * const dpy = gc->currentDpy;
5262 const GLuint cmdlen = 12;
5264 emit_header(gc->pc, X_GLrop_SampleCoverageARB, cmdlen);
5265 (void) memcpy((void *)(gc->pc + 4), (void *)(&value), 4);
5266 (void) memcpy((void *)(gc->pc + 8), (void *)(&invert), 1);
5268 if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
5271 #define X_GLvop_AreTexturesResidentEXT 11
5273 __indirect_glAreTexturesResidentEXT(GLsizei n, const GLuint * textures, GLboolean * residences)
5275 __GLXcontext * const gc = __glXGetCurrentContext();
5276 Display * const dpy = gc->currentDpy;
5277 GLboolean retval = (GLboolean) 0;
5278 const GLuint cmdlen = 4 + __GLX_PAD((n * 4));
5279 if (n < 0) return retval;
5282 GLubyte const * pc = setup_vendor_request(gc, X_GLXVendorPrivateWithReply, X_GLvop_AreTexturesResidentEXT, cmdlen);
5283 (void) memcpy((void *)(pc + 0), (void *)(&n), 4);
5284 (void) memcpy((void *)(pc + 4), (void *)(textures), (n * 4));
5285 retval = (GLboolean) read_reply(gc->currentDpy, 1, residences, GL_TRUE);
5286 UnlockDisplay(gc->currentDpy); SyncHandle();
5291 #define X_GLvop_GenTexturesEXT 13
5293 __indirect_glGenTexturesEXT(GLsizei n, GLuint * textures)
5295 __GLXcontext * const gc = __glXGetCurrentContext();
5296 Display * const dpy = gc->currentDpy;
5297 const GLuint cmdlen = 4;
5300 GLubyte const * pc = setup_vendor_request(gc, X_GLXVendorPrivateWithReply, X_GLvop_GenTexturesEXT, cmdlen);
5301 (void) memcpy((void *)(pc + 0), (void *)(&n), 4);
5302 (void) read_reply(gc->currentDpy, 4, textures, GL_TRUE);
5303 UnlockDisplay(gc->currentDpy); SyncHandle();
5308 #define X_GLvop_IsTextureEXT 14
5310 __indirect_glIsTextureEXT(GLuint texture)
5312 __GLXcontext * const gc = __glXGetCurrentContext();
5313 Display * const dpy = gc->currentDpy;
5314 GLboolean retval = (GLboolean) 0;
5315 const GLuint cmdlen = 4;
5318 GLubyte const * pc = setup_vendor_request(gc, X_GLXVendorPrivateWithReply, X_GLvop_IsTextureEXT, cmdlen);
5319 (void) memcpy((void *)(pc + 0), (void *)(&texture), 4);
5320 retval = (GLboolean) read_reply(gc->currentDpy, 0, NULL, GL_FALSE);
5321 UnlockDisplay(gc->currentDpy); SyncHandle();
5326 #define X_GLrop_SampleMaskSGIS 2048
5328 __indirect_glSampleMaskSGIS(GLclampf value, GLboolean invert)
5330 __GLXcontext * const gc = __glXGetCurrentContext();
5331 Display * const dpy = gc->currentDpy;
5332 const GLuint cmdlen = 12;
5334 emit_header(gc->pc, X_GLrop_SampleMaskSGIS, cmdlen);
5335 (void) memcpy((void *)(gc->pc + 4), (void *)(&value), 4);
5336 (void) memcpy((void *)(gc->pc + 8), (void *)(&invert), 1);
5338 if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
5341 #define X_GLrop_SamplePatternSGIS 2049
5343 __indirect_glSamplePatternSGIS(GLenum pattern)
5345 __GLXcontext * const gc = __glXGetCurrentContext();
5346 Display * const dpy = gc->currentDpy;
5347 const GLuint cmdlen = 8;
5349 emit_header(gc->pc, X_GLrop_SamplePatternSGIS, cmdlen);
5350 (void) memcpy((void *)(gc->pc + 4), (void *)(&pattern), 4);
5352 if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
5355 #define X_GLrop_PointParameterfEXT 2065
5357 __indirect_glPointParameterfEXT(GLenum pname, GLfloat param)
5359 __GLXcontext * const gc = __glXGetCurrentContext();
5360 Display * const dpy = gc->currentDpy;
5361 const GLuint cmdlen = 12;
5363 emit_header(gc->pc, X_GLrop_PointParameterfEXT, cmdlen);
5364 (void) memcpy((void *)(gc->pc + 4), (void *)(&pname), 4);
5365 (void) memcpy((void *)(gc->pc + 8), (void *)(¶m), 4);
5367 if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
5370 #define X_GLrop_PointParameterfvEXT 2066
5372 __indirect_glPointParameterfvEXT(GLenum pname, const GLfloat * params)
5374 __GLXcontext * const gc = __glXGetCurrentContext();
5375 Display * const dpy = gc->currentDpy;
5376 const GLuint compsize = __glPointParameterfvEXT_size(pname);
5377 const GLuint cmdlen = 8 + __GLX_PAD((compsize * 4));
5379 emit_header(gc->pc, X_GLrop_PointParameterfvEXT, cmdlen);
5380 (void) memcpy((void *)(gc->pc + 4), (void *)(&pname), 4);
5381 (void) memcpy((void *)(gc->pc + 8), (void *)(params), (compsize * 4));
5383 if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
5386 #define X_GLrop_WindowPos3fvMESA 230
5388 __indirect_glWindowPos3fMESA(GLfloat x, GLfloat y, GLfloat z)
5390 __GLXcontext * const gc = __glXGetCurrentContext();
5391 Display * const dpy = gc->currentDpy;
5392 const GLuint cmdlen = 16;
5394 emit_header(gc->pc, X_GLrop_WindowPos3fvMESA, cmdlen);
5395 (void) memcpy((void *)(gc->pc + 4), (void *)(&x), 4);
5396 (void) memcpy((void *)(gc->pc + 8), (void *)(&y), 4);
5397 (void) memcpy((void *)(gc->pc + 12), (void *)(&z), 4);
5399 if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
5402 #define X_GLrop_WindowPos3fvMESA 230
5404 __indirect_glWindowPos3fvMESA(const GLfloat * v)
5406 generic_12_byte( X_GLrop_WindowPos3fvMESA, v );
5409 #define X_GLrop_BlendFuncSeparateEXT 4134
5411 __indirect_glBlendFuncSeparateEXT(GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha)
5413 __GLXcontext * const gc = __glXGetCurrentContext();
5414 Display * const dpy = gc->currentDpy;
5415 const GLuint cmdlen = 20;
5417 emit_header(gc->pc, X_GLrop_BlendFuncSeparateEXT, cmdlen);
5418 (void) memcpy((void *)(gc->pc + 4), (void *)(&sfactorRGB), 4);
5419 (void) memcpy((void *)(gc->pc + 8), (void *)(&dfactorRGB), 4);
5420 (void) memcpy((void *)(gc->pc + 12), (void *)(&sfactorAlpha), 4);
5421 (void) memcpy((void *)(gc->pc + 16), (void *)(&dfactorAlpha), 4);
5423 if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
5426 #define X_GLrop_FogCoordfvEXT 4124
5428 __indirect_glFogCoordfEXT(GLfloat coord)
5430 __GLXcontext * const gc = __glXGetCurrentContext();
5431 Display * const dpy = gc->currentDpy;
5432 const GLuint cmdlen = 8;
5434 emit_header(gc->pc, X_GLrop_FogCoordfvEXT, cmdlen);
5435 (void) memcpy((void *)(gc->pc + 4), (void *)(&coord), 4);
5437 if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
5440 #define X_GLrop_FogCoordfvEXT 4124
5442 __indirect_glFogCoordfvEXT(const GLfloat * coord)
5444 generic_4_byte( X_GLrop_FogCoordfvEXT, coord );
5447 #define X_GLrop_FogCoorddvEXT 4125
5449 __indirect_glFogCoorddEXT(GLdouble coord)
5451 __GLXcontext * const gc = __glXGetCurrentContext();
5452 Display * const dpy = gc->currentDpy;
5453 const GLuint cmdlen = 12;
5455 emit_header(gc->pc, X_GLrop_FogCoorddvEXT, cmdlen);
5456 (void) memcpy((void *)(gc->pc + 4), (void *)(&coord), 8);
5458 if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
5461 #define X_GLrop_FogCoorddvEXT 4125
5463 __indirect_glFogCoorddvEXT(const GLdouble * coord)
5465 generic_8_byte( X_GLrop_FogCoorddvEXT, coord );
5468 #define X_GLrop_SecondaryColor3bvEXT 4126
5470 __indirect_glSecondaryColor3bEXT(GLbyte red, GLbyte green, GLbyte blue)
5472 __GLXcontext * const gc = __glXGetCurrentContext();
5473 Display * const dpy = gc->currentDpy;
5474 const GLuint cmdlen = 8;
5476 emit_header(gc->pc, X_GLrop_SecondaryColor3bvEXT, cmdlen);
5477 (void) memcpy((void *)(gc->pc + 4), (void *)(&red), 1);
5478 (void) memcpy((void *)(gc->pc + 5), (void *)(&green), 1);
5479 (void) memcpy((void *)(gc->pc + 6), (void *)(&blue), 1);
5481 if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
5484 #define X_GLrop_SecondaryColor3bvEXT 4126
5486 __indirect_glSecondaryColor3bvEXT(const GLbyte * v)
5488 generic_3_byte( X_GLrop_SecondaryColor3bvEXT, v );
5491 #define X_GLrop_SecondaryColor3dvEXT 4130
5493 __indirect_glSecondaryColor3dEXT(GLdouble red, GLdouble green, GLdouble blue)
5495 __GLXcontext * const gc = __glXGetCurrentContext();
5496 Display * const dpy = gc->currentDpy;
5497 const GLuint cmdlen = 28;
5499 emit_header(gc->pc, X_GLrop_SecondaryColor3dvEXT, cmdlen);
5500 (void) memcpy((void *)(gc->pc + 4), (void *)(&red), 8);
5501 (void) memcpy((void *)(gc->pc + 12), (void *)(&green), 8);
5502 (void) memcpy((void *)(gc->pc + 20), (void *)(&blue), 8);
5504 if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
5507 #define X_GLrop_SecondaryColor3dvEXT 4130
5509 __indirect_glSecondaryColor3dvEXT(const GLdouble * v)
5511 generic_24_byte( X_GLrop_SecondaryColor3dvEXT, v );
5514 #define X_GLrop_SecondaryColor3fvEXT 4129
5516 __indirect_glSecondaryColor3fEXT(GLfloat red, GLfloat green, GLfloat blue)
5518 __GLXcontext * const gc = __glXGetCurrentContext();
5519 Display * const dpy = gc->currentDpy;
5520 const GLuint cmdlen = 16;
5522 emit_header(gc->pc, X_GLrop_SecondaryColor3fvEXT, cmdlen);
5523 (void) memcpy((void *)(gc->pc + 4), (void *)(&red), 4);
5524 (void) memcpy((void *)(gc->pc + 8), (void *)(&green), 4);
5525 (void) memcpy((void *)(gc->pc + 12), (void *)(&blue), 4);
5527 if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
5530 #define X_GLrop_SecondaryColor3fvEXT 4129
5532 __indirect_glSecondaryColor3fvEXT(const GLfloat * v)
5534 generic_12_byte( X_GLrop_SecondaryColor3fvEXT, v );
5537 #define X_GLrop_SecondaryColor3ivEXT 4128
5539 __indirect_glSecondaryColor3iEXT(GLint red, GLint green, GLint blue)
5541 __GLXcontext * const gc = __glXGetCurrentContext();
5542 Display * const dpy = gc->currentDpy;
5543 const GLuint cmdlen = 16;
5545 emit_header(gc->pc, X_GLrop_SecondaryColor3ivEXT, cmdlen);
5546 (void) memcpy((void *)(gc->pc + 4), (void *)(&red), 4);
5547 (void) memcpy((void *)(gc->pc + 8), (void *)(&green), 4);
5548 (void) memcpy((void *)(gc->pc + 12), (void *)(&blue), 4);
5550 if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
5553 #define X_GLrop_SecondaryColor3ivEXT 4128
5555 __indirect_glSecondaryColor3ivEXT(const GLint * v)
5557 generic_12_byte( X_GLrop_SecondaryColor3ivEXT, v );
5560 #define X_GLrop_SecondaryColor3svEXT 4128
5562 __indirect_glSecondaryColor3sEXT(GLshort red, GLshort green, GLshort blue)
5564 __GLXcontext * const gc = __glXGetCurrentContext();
5565 Display * const dpy = gc->currentDpy;
5566 const GLuint cmdlen = 12;
5568 emit_header(gc->pc, X_GLrop_SecondaryColor3svEXT, cmdlen);
5569 (void) memcpy((void *)(gc->pc + 4), (void *)(&red), 2);
5570 (void) memcpy((void *)(gc->pc + 6), (void *)(&green), 2);
5571 (void) memcpy((void *)(gc->pc + 8), (void *)(&blue), 2);
5573 if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
5576 #define X_GLrop_SecondaryColor3svEXT 4128
5578 __indirect_glSecondaryColor3svEXT(const GLshort * v)
5580 generic_6_byte( X_GLrop_SecondaryColor3svEXT, v );
5583 #define X_GLrop_SecondaryColor3ubvEXT 4131
5585 __indirect_glSecondaryColor3ubEXT(GLubyte red, GLubyte green, GLubyte blue)
5587 __GLXcontext * const gc = __glXGetCurrentContext();
5588 Display * const dpy = gc->currentDpy;
5589 const GLuint cmdlen = 8;
5591 emit_header(gc->pc, X_GLrop_SecondaryColor3ubvEXT, cmdlen);
5592 (void) memcpy((void *)(gc->pc + 4), (void *)(&red), 1);
5593 (void) memcpy((void *)(gc->pc + 5), (void *)(&green), 1);
5594 (void) memcpy((void *)(gc->pc + 6), (void *)(&blue), 1);
5596 if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
5599 #define X_GLrop_SecondaryColor3ubvEXT 4131
5601 __indirect_glSecondaryColor3ubvEXT(const GLubyte * v)
5603 generic_3_byte( X_GLrop_SecondaryColor3ubvEXT, v );
5606 #define X_GLrop_SecondaryColor3uivEXT 4133
5608 __indirect_glSecondaryColor3uiEXT(GLuint red, GLuint green, GLuint blue)
5610 __GLXcontext * const gc = __glXGetCurrentContext();
5611 Display * const dpy = gc->currentDpy;
5612 const GLuint cmdlen = 16;
5614 emit_header(gc->pc, X_GLrop_SecondaryColor3uivEXT, cmdlen);
5615 (void) memcpy((void *)(gc->pc + 4), (void *)(&red), 4);
5616 (void) memcpy((void *)(gc->pc + 8), (void *)(&green), 4);
5617 (void) memcpy((void *)(gc->pc + 12), (void *)(&blue), 4);
5619 if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
5622 #define X_GLrop_SecondaryColor3uivEXT 4133
5624 __indirect_glSecondaryColor3uivEXT(const GLuint * v)
5626 generic_12_byte( X_GLrop_SecondaryColor3uivEXT, v );
5629 #define X_GLrop_SecondaryColor3usvEXT 4132
5631 __indirect_glSecondaryColor3usEXT(GLushort red, GLushort green, GLushort blue)
5633 __GLXcontext * const gc = __glXGetCurrentContext();
5634 Display * const dpy = gc->currentDpy;
5635 const GLuint cmdlen = 12;
5637 emit_header(gc->pc, X_GLrop_SecondaryColor3usvEXT, cmdlen);
5638 (void) memcpy((void *)(gc->pc + 4), (void *)(&red), 2);
5639 (void) memcpy((void *)(gc->pc + 6), (void *)(&green), 2);
5640 (void) memcpy((void *)(gc->pc + 8), (void *)(&blue), 2);
5642 if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
5645 #define X_GLrop_SecondaryColor3usvEXT 4132
5647 __indirect_glSecondaryColor3usvEXT(const GLushort * v)
5649 generic_6_byte( X_GLrop_SecondaryColor3usvEXT, v );
5652 #define X_GLrop_PointParameteriNV 4221
5654 __indirect_glPointParameteriNV(GLenum pname, GLint params)
5656 __GLXcontext * const gc = __glXGetCurrentContext();
5657 Display * const dpy = gc->currentDpy;
5658 const GLuint cmdlen = 12;
5660 emit_header(gc->pc, X_GLrop_PointParameteriNV, cmdlen);
5661 (void) memcpy((void *)(gc->pc + 4), (void *)(&pname), 4);
5662 (void) memcpy((void *)(gc->pc + 8), (void *)(¶ms), 4);
5664 if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
5667 #define X_GLrop_PointParameterivNV 4222
5669 __indirect_glPointParameterivNV(GLenum pname, const GLint * params)
5671 __GLXcontext * const gc = __glXGetCurrentContext();
5672 Display * const dpy = gc->currentDpy;
5673 const GLuint compsize = __glPointParameterivNV_size(pname);
5674 const GLuint cmdlen = 8 + __GLX_PAD((compsize * 4));
5676 emit_header(gc->pc, X_GLrop_PointParameterivNV, cmdlen);
5677 (void) memcpy((void *)(gc->pc + 4), (void *)(&pname), 4);
5678 (void) memcpy((void *)(gc->pc + 8), (void *)(params), (compsize * 4));
5680 if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
5683 #define X_GLrop_ActiveStencilFaceEXT 4220
5685 __indirect_glActiveStencilFaceEXT(GLenum face)
5687 __GLXcontext * const gc = __glXGetCurrentContext();
5688 Display * const dpy = gc->currentDpy;
5689 const GLuint cmdlen = 8;
5691 emit_header(gc->pc, X_GLrop_ActiveStencilFaceEXT, cmdlen);
5692 (void) memcpy((void *)(gc->pc + 4), (void *)(&face), 4);
5694 if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }