/* DO NOT EDIT - This file generated automatically by glX_proto_send.py (from Mesa) script */
/*
- * (C) Copyright IBM Corporation 2004
+ * (C) Copyright IBM Corporation 2004, 2005
* All Rights Reserved.
*
* Permission is hereby granted, free of charge, to any person obtaining a
#include <GL/gl.h>
#include "indirect.h"
#include "glxclient.h"
-#include "size.h"
+#include "indirect_size.h"
#include <GL/glxproto.h>
+#ifdef USE_XCB
+#include <X11/xcl.h>
+#include <X11/XCB/xcb.h>
+#include <X11/XCB/glx.h>
+#endif /* USE_XCB */
#define __GLX_PAD(n) (((n) + 3) & ~3)
temp.s[0] = (size); temp.s[1] = (op); \
*((int *)(dest)) = temp.i; } while(0)
-static NOINLINE CARD32
-read_reply( Display *dpy, size_t size, void * dest, GLboolean reply_is_always_array )
+NOINLINE CARD32
+__glXReadReply( Display *dpy, size_t size, void * dest, GLboolean reply_is_always_array )
{
xGLXSingleReply reply;
(void) _XReply(dpy, (xReply *) & reply, 0, False);
if (size != 0) {
- if ((reply.length > 0) || reply_is_always_array) {
- const GLint bytes = (reply_is_always_array)
- ? (4 * reply.length) : (reply.size * size);
- const GLint extra = 4 - (bytes & 3);
-
- _XRead(dpy, dest, bytes);
- if ( extra < 4 ) {
- _XEatData(dpy, extra);
- }
- }
- else {
- (void) memcpy( dest, &(reply.pad3), size);
- }
+ if ((reply.length > 0) || reply_is_always_array) {
+ const GLint bytes = (reply_is_always_array)
+ ? (4 * reply.length) : (reply.size * size);
+ const GLint extra = 4 - (bytes & 3);
+
+ _XRead(dpy, dest, bytes);
+ if ( extra < 4 ) {
+ _XEatData(dpy, extra);
+ }
+ }
+ else {
+ (void) memcpy( dest, &(reply.pad3), size);
+ }
}
return reply.retval;
}
+NOINLINE void
+__glXReadPixelReply( Display *dpy, __GLXcontext * gc, unsigned max_dim,
+ GLint width, GLint height, GLint depth, GLenum format, GLenum type,
+ void * dest, GLboolean dimensions_in_reply )
+{
+ xGLXSingleReply reply;
+ GLint size;
+
+ (void) _XReply(dpy, (xReply *) & reply, 0, False);
+
+ if ( dimensions_in_reply ) {
+ width = reply.pad3;
+ height = reply.pad4;
+ depth = reply.pad5;
+
+ if ((height == 0) || (max_dim < 2)) { height = 1; }
+ if ((depth == 0) || (max_dim < 3)) { depth = 1; }
+ }
+
+ size = reply.length * 4;
+ if (size != 0) {
+ void * buf = Xmalloc( size );
+
+ if ( buf == NULL ) {
+ _XEatData(dpy, size);
+ __glXSetError(gc, GL_OUT_OF_MEMORY);
+ }
+ else {
+ const GLint extra = 4 - (size & 3);
+
+ _XRead(dpy, buf, size);
+ if ( extra < 4 ) {
+ _XEatData(dpy, extra);
+ }
+
+ __glEmptyImage(gc, 3, width, height, depth, format, type,
+ buf, dest);
+ Xfree(buf);
+ }
+ }
+}
+
#define X_GLXSingle 0
-static NOINLINE FASTCALL GLubyte *
-setup_single_request( __GLXcontext * gc, GLint sop, GLint cmdlen )
+NOINLINE FASTCALL GLubyte *
+__glXSetupSingleRequest( __GLXcontext * gc, GLint sop, GLint cmdlen )
{
xGLXSingleReq * req;
Display * const dpy = gc->currentDpy;
return (GLubyte *)(req) + sz_xGLXSingleReq;
}
-static NOINLINE FASTCALL GLubyte *
-setup_vendor_request( __GLXcontext * gc, GLint code, GLint vop, GLint cmdlen )
+NOINLINE FASTCALL GLubyte *
+__glXSetupVendorRequest( __GLXcontext * gc, GLint code, GLint vop, GLint cmdlen )
{
xGLXVendorPrivateReq * req;
Display * const dpy = gc->currentDpy;
return (GLubyte *)(req) + sz_xGLXVendorPrivateReq;
}
+const GLuint __glXDefaultPixelStore[9] = { 0, 0, 0, 0, 0, 0, 0, 0, 1 };
+
+#define zero (__glXDefaultPixelStore+0)
+#define one (__glXDefaultPixelStore+8)
+#define default_pixel_store_1D (__glXDefaultPixelStore+4)
+#define default_pixel_store_1D_size 20
+#define default_pixel_store_2D (__glXDefaultPixelStore+4)
+#define default_pixel_store_2D_size 20
+#define default_pixel_store_3D (__glXDefaultPixelStore+0)
+#define default_pixel_store_3D_size 36
+#define default_pixel_store_4D (__glXDefaultPixelStore+0)
+#define default_pixel_store_4D_size 36
+
static FASTCALL NOINLINE void
generic_3_byte( GLint rop, const void * ptr )
{
__GLXcontext * const gc = __glXGetCurrentContext();
- const GLuint cmdlen = 7;
+ const GLuint cmdlen = 8;
emit_header(gc->pc, rop, cmdlen);
- (void) memcpy((void *)(gc->pc + 4), ptr, 3);
+ (void) memcpy((void *)(gc->pc + 4), ptr, 4);
gc->pc += cmdlen;
if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
}
generic_6_byte( GLint rop, const void * ptr )
{
__GLXcontext * const gc = __glXGetCurrentContext();
- const GLuint cmdlen = 10;
+ const GLuint cmdlen = 12;
emit_header(gc->pc, rop, cmdlen);
- (void) memcpy((void *)(gc->pc + 4), ptr, 6);
+ (void) memcpy((void *)(gc->pc + 4), ptr, 8);
gc->pc += cmdlen;
if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
}
Display * const dpy = gc->currentDpy;
const GLuint cmdlen = 8;
if (__builtin_expect(dpy != NULL, 1)) {
- GLubyte const * pc = setup_single_request(gc, X_GLsop_NewList, cmdlen);
+#ifdef USE_XCB
+ XCBConnection *c = XCBConnectionOfDisplay(dpy);
+ (void) __glXFlushRenderBuffer(gc, gc->pc);
+ XCBGlxNewList(c, gc->currentContextTag, list, mode);
+#else
+ GLubyte const * pc = __glXSetupSingleRequest(gc, X_GLsop_NewList, cmdlen);
(void) memcpy((void *)(pc + 0), (void *)(&list), 4);
(void) memcpy((void *)(pc + 4), (void *)(&mode), 4);
UnlockDisplay(dpy); SyncHandle();
+#endif /* USE_XCB */
}
return;
}
Display * const dpy = gc->currentDpy;
const GLuint cmdlen = 0;
if (__builtin_expect(dpy != NULL, 1)) {
- (void) setup_single_request(gc, X_GLsop_EndList, cmdlen);
+#ifdef USE_XCB
+ XCBConnection *c = XCBConnectionOfDisplay(dpy);
+ (void) __glXFlushRenderBuffer(gc, gc->pc);
+ XCBGlxEndList(c, gc->currentContextTag);
+#else
+ (void) __glXSetupSingleRequest(gc, X_GLsop_EndList, cmdlen);
UnlockDisplay(dpy); SyncHandle();
+#endif /* USE_XCB */
}
return;
}
__GLXcontext * const gc = __glXGetCurrentContext();
const GLuint compsize = __glCallLists_size(type);
const GLuint cmdlen = 12 + __GLX_PAD((compsize * n));
- if (__builtin_expect(gc->currentDpy != NULL, 1)) {
+ if (__builtin_expect((n >= 0) && (gc->currentDpy != NULL), 1)) {
if (cmdlen <= gc->maxSmallRenderCommandSize) {
if ( (gc->pc + cmdlen) > gc->bufEnd ) {
(void) __glXFlushRenderBuffer(gc, gc->pc);
const GLint op = X_GLrop_CallLists;
const GLuint cmdlenLarge = cmdlen + 4;
GLubyte * const pc = __glXFlushRenderBuffer(gc, gc->pc);
- (void) memcpy((void *)(pc + 0), (void *)(&op), 4);
- (void) memcpy((void *)(pc + 4), (void *)(&cmdlenLarge), 4);
+ (void) memcpy((void *)(pc + 0), (void *)(&cmdlenLarge), 4);
+ (void) memcpy((void *)(pc + 4), (void *)(&op), 4);
(void) memcpy((void *)(pc + 8), (void *)(&n), 4);
(void) memcpy((void *)(pc + 12), (void *)(&type), 4);
__glXSendLargeCommand(gc, pc, 16, lists, (compsize * n));
Display * const dpy = gc->currentDpy;
const GLuint cmdlen = 8;
if (__builtin_expect(dpy != NULL, 1)) {
- GLubyte const * pc = setup_single_request(gc, X_GLsop_DeleteLists, cmdlen);
+#ifdef USE_XCB
+ XCBConnection *c = XCBConnectionOfDisplay(dpy);
+ (void) __glXFlushRenderBuffer(gc, gc->pc);
+ XCBGlxDeleteLists(c, gc->currentContextTag, list, range);
+#else
+ GLubyte const * pc = __glXSetupSingleRequest(gc, X_GLsop_DeleteLists, cmdlen);
(void) memcpy((void *)(pc + 0), (void *)(&list), 4);
(void) memcpy((void *)(pc + 4), (void *)(&range), 4);
UnlockDisplay(dpy); SyncHandle();
+#endif /* USE_XCB */
}
return;
}
GLuint retval = (GLuint) 0;
const GLuint cmdlen = 4;
if (__builtin_expect(dpy != NULL, 1)) {
- GLubyte const * pc = setup_single_request(gc, X_GLsop_GenLists, cmdlen);
+#ifdef USE_XCB
+ XCBConnection *c = XCBConnectionOfDisplay(dpy);
+ (void) __glXFlushRenderBuffer(gc, gc->pc);
+ XCBGlxGenListsRep *reply = XCBGlxGenListsReply(c, XCBGlxGenLists(c, gc->currentContextTag, range), NULL);
+ retval = reply->ret_val;
+ free(reply);
+#else
+ GLubyte const * pc = __glXSetupSingleRequest(gc, X_GLsop_GenLists, cmdlen);
(void) memcpy((void *)(pc + 0), (void *)(&range), 4);
- retval = (GLuint) read_reply(dpy, 0, NULL, GL_FALSE);
+ retval = (GLuint) __glXReadReply(dpy, 0, NULL, GL_FALSE);
UnlockDisplay(dpy); SyncHandle();
+#endif /* USE_XCB */
}
return retval;
}
if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
}
+#define X_GLrop_Bitmap 5
+void
+__indirect_glBitmap(GLsizei width, GLsizei height, GLfloat xorig, GLfloat yorig, GLfloat xmove, GLfloat ymove, const GLubyte * bitmap)
+{
+ __GLXcontext * const gc = __glXGetCurrentContext();
+ const GLuint compsize = (bitmap != NULL) ? __glImageSize(width, height, 1, GL_COLOR_INDEX, GL_BITMAP, 0) : 0;
+ const GLuint cmdlen = 48 + __GLX_PAD(compsize);
+ if (__builtin_expect(gc->currentDpy != NULL, 1)) {
+ if (cmdlen <= gc->maxSmallRenderCommandSize) {
+ if ( (gc->pc + cmdlen) > gc->bufEnd ) {
+ (void) __glXFlushRenderBuffer(gc, gc->pc);
+ }
+ emit_header(gc->pc, X_GLrop_Bitmap, cmdlen);
+ (void) memcpy((void *)(gc->pc + 24), (void *)(&width), 4);
+ (void) memcpy((void *)(gc->pc + 28), (void *)(&height), 4);
+ (void) memcpy((void *)(gc->pc + 32), (void *)(&xorig), 4);
+ (void) memcpy((void *)(gc->pc + 36), (void *)(&yorig), 4);
+ (void) memcpy((void *)(gc->pc + 40), (void *)(&xmove), 4);
+ (void) memcpy((void *)(gc->pc + 44), (void *)(&ymove), 4);
+ if (compsize > 0) {
+ (*gc->fillImage)(gc, 2, width, height, 1, GL_COLOR_INDEX, GL_BITMAP, bitmap, gc->pc + 48, gc->pc + 4);
+ }
+ else {
+ (void) memcpy( gc->pc + 4, default_pixel_store_2D, default_pixel_store_2D_size );
+ }
+ gc->pc += cmdlen;
+ if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+ }
+ else {
+ const GLint op = X_GLrop_Bitmap;
+ const GLuint cmdlenLarge = cmdlen + 4;
+ GLubyte * const pc = __glXFlushRenderBuffer(gc, gc->pc);
+ (void) memcpy((void *)(pc + 0), (void *)(&cmdlenLarge), 4);
+ (void) memcpy((void *)(pc + 4), (void *)(&op), 4);
+ (void) memcpy((void *)(pc + 28), (void *)(&width), 4);
+ (void) memcpy((void *)(pc + 32), (void *)(&height), 4);
+ (void) memcpy((void *)(pc + 36), (void *)(&xorig), 4);
+ (void) memcpy((void *)(pc + 40), (void *)(&yorig), 4);
+ (void) memcpy((void *)(pc + 44), (void *)(&xmove), 4);
+ (void) memcpy((void *)(pc + 48), (void *)(&ymove), 4);
+ __glXSendLargeImage(gc, compsize, 2, width, height, 1, GL_COLOR_INDEX, GL_BITMAP, bitmap, pc + 52, pc + 8);
+ }
+ }
+}
+
#define X_GLrop_Color3bv 6
void
__indirect_glColor3b(GLbyte red, GLbyte green, GLbyte blue)
if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
}
+#define X_GLrop_PolygonStipple 102
+void
+__indirect_glPolygonStipple(const GLubyte * mask)
+{
+ __GLXcontext * const gc = __glXGetCurrentContext();
+ const GLuint compsize = (mask != NULL) ? __glImageSize(32, 32, 1, GL_COLOR_INDEX, GL_BITMAP, 0) : 0;
+ const GLuint cmdlen = 24 + __GLX_PAD(compsize);
+ emit_header(gc->pc, X_GLrop_PolygonStipple, cmdlen);
+ if (compsize > 0) {
+ (*gc->fillImage)(gc, 2, 32, 32, 1, GL_COLOR_INDEX, GL_BITMAP, mask, gc->pc + 24, gc->pc + 4);
+ }
+ else {
+ (void) memcpy( gc->pc + 4, default_pixel_store_2D, default_pixel_store_2D_size );
+ }
+ gc->pc += cmdlen;
+ if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
#define X_GLrop_Scissor 103
void
__indirect_glScissor(GLint x, GLint y, GLsizei width, GLsizei height)
if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
}
+static void
+__glx_TexImage_1D2D( unsigned opcode, unsigned dim, GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const GLvoid * pixels )
+{
+ __GLXcontext * const gc = __glXGetCurrentContext();
+ const GLuint compsize = __glImageSize(width, height, 1, format, type, target);
+ const GLuint cmdlen = 56 + __GLX_PAD(compsize);
+ if (__builtin_expect(gc->currentDpy != NULL, 1)) {
+ if (cmdlen <= gc->maxSmallRenderCommandSize) {
+ if ( (gc->pc + cmdlen) > gc->bufEnd ) {
+ (void) __glXFlushRenderBuffer(gc, gc->pc);
+ }
+ emit_header(gc->pc, opcode, cmdlen);
+ (void) memcpy((void *)(gc->pc + 24), (void *)(&target), 4);
+ (void) memcpy((void *)(gc->pc + 28), (void *)(&level), 4);
+ (void) memcpy((void *)(gc->pc + 32), (void *)(&internalformat), 4);
+ (void) memcpy((void *)(gc->pc + 36), (void *)(&width), 4);
+ (void) memcpy((void *)(gc->pc + 40), (void *)(&height), 4);
+ (void) memcpy((void *)(gc->pc + 44), (void *)(&border), 4);
+ (void) memcpy((void *)(gc->pc + 48), (void *)(&format), 4);
+ (void) memcpy((void *)(gc->pc + 52), (void *)(&type), 4);
+ if ((compsize > 0) && (pixels != NULL)) {
+ (*gc->fillImage)(gc, dim, width, height, 1, format, type, pixels, gc->pc + 56, gc->pc + 4);
+ }
+ else {
+ (void) memcpy( gc->pc + 4, default_pixel_store_2D, default_pixel_store_2D_size );
+ }
+ gc->pc += cmdlen;
+ if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+ }
+ else {
+ const GLint op = opcode;
+ const GLuint cmdlenLarge = cmdlen + 4;
+ GLubyte * const pc = __glXFlushRenderBuffer(gc, gc->pc);
+ (void) memcpy((void *)(pc + 0), (void *)(&cmdlenLarge), 4);
+ (void) memcpy((void *)(pc + 4), (void *)(&op), 4);
+ (void) memcpy((void *)(pc + 28), (void *)(&target), 4);
+ (void) memcpy((void *)(pc + 32), (void *)(&level), 4);
+ (void) memcpy((void *)(pc + 36), (void *)(&internalformat), 4);
+ (void) memcpy((void *)(pc + 40), (void *)(&width), 4);
+ (void) memcpy((void *)(pc + 44), (void *)(&height), 4);
+ (void) memcpy((void *)(pc + 48), (void *)(&border), 4);
+ (void) memcpy((void *)(pc + 52), (void *)(&format), 4);
+ (void) memcpy((void *)(pc + 56), (void *)(&type), 4);
+ __glXSendLargeImage(gc, compsize, dim, width, height, 1, format, type, pixels, pc + 60, pc + 8);
+ }
+ }
+}
+
+#define X_GLrop_TexImage1D 109
+void
+__indirect_glTexImage1D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLint border, GLenum format, GLenum type, const GLvoid * pixels)
+{
+ __glx_TexImage_1D2D(X_GLrop_TexImage1D, 1, target, level, internalformat, width, 1, border, format, type, pixels );
+}
+
+#define X_GLrop_TexImage2D 110
+void
+__indirect_glTexImage2D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const GLvoid * pixels)
+{
+ __glx_TexImage_1D2D(X_GLrop_TexImage2D, 2, target, level, internalformat, width, height, border, format, type, pixels );
+}
+
#define X_GLrop_TexEnvf 111
void
__indirect_glTexEnvf(GLenum target, GLenum pname, GLfloat param)
const GLint op = X_GLrop_PixelMapfv;
const GLuint cmdlenLarge = cmdlen + 4;
GLubyte * const pc = __glXFlushRenderBuffer(gc, gc->pc);
- (void) memcpy((void *)(pc + 0), (void *)(&op), 4);
- (void) memcpy((void *)(pc + 4), (void *)(&cmdlenLarge), 4);
+ (void) memcpy((void *)(pc + 0), (void *)(&cmdlenLarge), 4);
+ (void) memcpy((void *)(pc + 4), (void *)(&op), 4);
(void) memcpy((void *)(pc + 8), (void *)(&map), 4);
(void) memcpy((void *)(pc + 12), (void *)(&mapsize), 4);
__glXSendLargeCommand(gc, pc, 16, values, (mapsize * 4));
const GLint op = X_GLrop_PixelMapuiv;
const GLuint cmdlenLarge = cmdlen + 4;
GLubyte * const pc = __glXFlushRenderBuffer(gc, gc->pc);
- (void) memcpy((void *)(pc + 0), (void *)(&op), 4);
- (void) memcpy((void *)(pc + 4), (void *)(&cmdlenLarge), 4);
+ (void) memcpy((void *)(pc + 0), (void *)(&cmdlenLarge), 4);
+ (void) memcpy((void *)(pc + 4), (void *)(&op), 4);
(void) memcpy((void *)(pc + 8), (void *)(&map), 4);
(void) memcpy((void *)(pc + 12), (void *)(&mapsize), 4);
__glXSendLargeCommand(gc, pc, 16, values, (mapsize * 4));
const GLint op = X_GLrop_PixelMapusv;
const GLuint cmdlenLarge = cmdlen + 4;
GLubyte * const pc = __glXFlushRenderBuffer(gc, gc->pc);
- (void) memcpy((void *)(pc + 0), (void *)(&op), 4);
- (void) memcpy((void *)(pc + 4), (void *)(&cmdlenLarge), 4);
+ (void) memcpy((void *)(pc + 0), (void *)(&cmdlenLarge), 4);
+ (void) memcpy((void *)(pc + 4), (void *)(&op), 4);
(void) memcpy((void *)(pc + 8), (void *)(&map), 4);
(void) memcpy((void *)(pc + 12), (void *)(&mapsize), 4);
__glXSendLargeCommand(gc, pc, 16, values, (mapsize * 2));
if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
}
+#define X_GLsop_ReadPixels 111
+void
+__indirect_glReadPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLvoid * pixels)
+{
+ __GLXcontext * const gc = __glXGetCurrentContext();
+ const __GLXattribute * const state = gc->client_state_private;
+ Display * const dpy = gc->currentDpy;
+ const GLuint cmdlen = 28;
+ if (__builtin_expect(dpy != NULL, 1)) {
+#ifdef USE_XCB
+ XCBConnection *c = XCBConnectionOfDisplay(dpy);
+ (void) __glXFlushRenderBuffer(gc, gc->pc);
+ XCBGlxReadPixelsRep *reply = XCBGlxReadPixelsReply(c, XCBGlxReadPixels(c, gc->currentContextTag, x, y, width, height, format, type, state->storePack.swapEndian, 0), NULL);
+ (void)memcpy(pixels, XCBGlxReadPixelsData(reply), XCBGlxReadPixelsDataLength(reply) * sizeof(GLvoid));
+ free(reply);
+#else
+ GLubyte const * pc = __glXSetupSingleRequest(gc, X_GLsop_ReadPixels, cmdlen);
+ (void) memcpy((void *)(pc + 0), (void *)(&x), 4);
+ (void) memcpy((void *)(pc + 4), (void *)(&y), 4);
+ (void) memcpy((void *)(pc + 8), (void *)(&width), 4);
+ (void) memcpy((void *)(pc + 12), (void *)(&height), 4);
+ (void) memcpy((void *)(pc + 16), (void *)(&format), 4);
+ (void) memcpy((void *)(pc + 20), (void *)(&type), 4);
+ *(int32_t *)(pc + 24) = 0;
+ * (int8_t *)(pc + 24) = state->storePack.swapEndian;
+ __glXReadPixelReply(dpy, gc, 2, width, height, 1, format, type, pixels, GL_FALSE);
+ UnlockDisplay(dpy); SyncHandle();
+#endif /* USE_XCB */
+ }
+ return;
+}
+
+#define X_GLrop_DrawPixels 173
+void
+__indirect_glDrawPixels(GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid * pixels)
+{
+ __GLXcontext * const gc = __glXGetCurrentContext();
+ const GLuint compsize = (pixels != NULL) ? __glImageSize(width, height, 1, format, type, 0) : 0;
+ const GLuint cmdlen = 40 + __GLX_PAD(compsize);
+ if (__builtin_expect(gc->currentDpy != NULL, 1)) {
+ if (cmdlen <= gc->maxSmallRenderCommandSize) {
+ if ( (gc->pc + cmdlen) > gc->bufEnd ) {
+ (void) __glXFlushRenderBuffer(gc, gc->pc);
+ }
+ emit_header(gc->pc, X_GLrop_DrawPixels, cmdlen);
+ (void) memcpy((void *)(gc->pc + 24), (void *)(&width), 4);
+ (void) memcpy((void *)(gc->pc + 28), (void *)(&height), 4);
+ (void) memcpy((void *)(gc->pc + 32), (void *)(&format), 4);
+ (void) memcpy((void *)(gc->pc + 36), (void *)(&type), 4);
+ if (compsize > 0) {
+ (*gc->fillImage)(gc, 2, width, height, 1, format, type, pixels, gc->pc + 40, gc->pc + 4);
+ }
+ else {
+ (void) memcpy( gc->pc + 4, default_pixel_store_2D, default_pixel_store_2D_size );
+ }
+ gc->pc += cmdlen;
+ if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+ }
+ else {
+ const GLint op = X_GLrop_DrawPixels;
+ const GLuint cmdlenLarge = cmdlen + 4;
+ GLubyte * const pc = __glXFlushRenderBuffer(gc, gc->pc);
+ (void) memcpy((void *)(pc + 0), (void *)(&cmdlenLarge), 4);
+ (void) memcpy((void *)(pc + 4), (void *)(&op), 4);
+ (void) memcpy((void *)(pc + 28), (void *)(&width), 4);
+ (void) memcpy((void *)(pc + 32), (void *)(&height), 4);
+ (void) memcpy((void *)(pc + 36), (void *)(&format), 4);
+ (void) memcpy((void *)(pc + 40), (void *)(&type), 4);
+ __glXSendLargeImage(gc, compsize, 2, width, height, 1, format, type, pixels, pc + 44, pc + 8);
+ }
+ }
+}
+
#define X_GLsop_GetClipPlane 113
void
__indirect_glGetClipPlane(GLenum plane, GLdouble * equation)
Display * const dpy = gc->currentDpy;
const GLuint cmdlen = 4;
if (__builtin_expect(dpy != NULL, 1)) {
- GLubyte const * pc = setup_single_request(gc, X_GLsop_GetClipPlane, cmdlen);
+#ifdef USE_XCB
+ XCBConnection *c = XCBConnectionOfDisplay(dpy);
+ (void) __glXFlushRenderBuffer(gc, gc->pc);
+ XCBGlxGetClipPlaneRep *reply = XCBGlxGetClipPlaneReply(c, XCBGlxGetClipPlane(c, gc->currentContextTag, plane), NULL);
+ (void)memcpy(equation, XCBGlxGetClipPlaneData(reply), XCBGlxGetClipPlaneDataLength(reply) * sizeof(GLdouble));
+ free(reply);
+#else
+ GLubyte const * pc = __glXSetupSingleRequest(gc, X_GLsop_GetClipPlane, cmdlen);
(void) memcpy((void *)(pc + 0), (void *)(&plane), 4);
- (void) read_reply(dpy, 8, equation, GL_TRUE);
+ (void) __glXReadReply(dpy, 8, equation, GL_TRUE);
UnlockDisplay(dpy); SyncHandle();
+#endif /* USE_XCB */
}
return;
}
Display * const dpy = gc->currentDpy;
const GLuint cmdlen = 8;
if (__builtin_expect(dpy != NULL, 1)) {
- GLubyte const * pc = setup_single_request(gc, X_GLsop_GetLightfv, cmdlen);
+#ifdef USE_XCB
+ XCBConnection *c = XCBConnectionOfDisplay(dpy);
+ (void) __glXFlushRenderBuffer(gc, gc->pc);
+ XCBGlxGetLightfvRep *reply = XCBGlxGetLightfvReply(c, XCBGlxGetLightfv(c, gc->currentContextTag, light, pname), NULL);
+ if (XCBGlxGetLightfvDataLength(reply) == 0)
+ (void)memcpy(params, &reply->datum, sizeof(reply->datum));
+ else
+ (void)memcpy(params, XCBGlxGetLightfvData(reply), XCBGlxGetLightfvDataLength(reply) * sizeof(GLfloat));
+ free(reply);
+#else
+ GLubyte const * pc = __glXSetupSingleRequest(gc, X_GLsop_GetLightfv, cmdlen);
(void) memcpy((void *)(pc + 0), (void *)(&light), 4);
(void) memcpy((void *)(pc + 4), (void *)(&pname), 4);
- (void) read_reply(dpy, 4, params, GL_FALSE);
+ (void) __glXReadReply(dpy, 4, params, GL_FALSE);
UnlockDisplay(dpy); SyncHandle();
+#endif /* USE_XCB */
}
return;
}
Display * const dpy = gc->currentDpy;
const GLuint cmdlen = 8;
if (__builtin_expect(dpy != NULL, 1)) {
- GLubyte const * pc = setup_single_request(gc, X_GLsop_GetLightiv, cmdlen);
+#ifdef USE_XCB
+ XCBConnection *c = XCBConnectionOfDisplay(dpy);
+ (void) __glXFlushRenderBuffer(gc, gc->pc);
+ XCBGlxGetLightivRep *reply = XCBGlxGetLightivReply(c, XCBGlxGetLightiv(c, gc->currentContextTag, light, pname), NULL);
+ if (XCBGlxGetLightivDataLength(reply) == 0)
+ (void)memcpy(params, &reply->datum, sizeof(reply->datum));
+ else
+ (void)memcpy(params, XCBGlxGetLightivData(reply), XCBGlxGetLightivDataLength(reply) * sizeof(GLint));
+ free(reply);
+#else
+ GLubyte const * pc = __glXSetupSingleRequest(gc, X_GLsop_GetLightiv, cmdlen);
(void) memcpy((void *)(pc + 0), (void *)(&light), 4);
(void) memcpy((void *)(pc + 4), (void *)(&pname), 4);
- (void) read_reply(dpy, 4, params, GL_FALSE);
+ (void) __glXReadReply(dpy, 4, params, GL_FALSE);
UnlockDisplay(dpy); SyncHandle();
+#endif /* USE_XCB */
}
return;
}
Display * const dpy = gc->currentDpy;
const GLuint cmdlen = 8;
if (__builtin_expect(dpy != NULL, 1)) {
- GLubyte const * pc = setup_single_request(gc, X_GLsop_GetMapdv, cmdlen);
+#ifdef USE_XCB
+ XCBConnection *c = XCBConnectionOfDisplay(dpy);
+ (void) __glXFlushRenderBuffer(gc, gc->pc);
+ XCBGlxGetMapdvRep *reply = XCBGlxGetMapdvReply(c, XCBGlxGetMapdv(c, gc->currentContextTag, target, query), NULL);
+ if (XCBGlxGetMapdvDataLength(reply) == 0)
+ (void)memcpy(v, &reply->datum, sizeof(reply->datum));
+ else
+ (void)memcpy(v, XCBGlxGetMapdvData(reply), XCBGlxGetMapdvDataLength(reply) * sizeof(GLdouble));
+ free(reply);
+#else
+ GLubyte const * pc = __glXSetupSingleRequest(gc, X_GLsop_GetMapdv, cmdlen);
(void) memcpy((void *)(pc + 0), (void *)(&target), 4);
(void) memcpy((void *)(pc + 4), (void *)(&query), 4);
- (void) read_reply(dpy, 8, v, GL_FALSE);
+ (void) __glXReadReply(dpy, 8, v, GL_FALSE);
UnlockDisplay(dpy); SyncHandle();
+#endif /* USE_XCB */
}
return;
}
Display * const dpy = gc->currentDpy;
const GLuint cmdlen = 8;
if (__builtin_expect(dpy != NULL, 1)) {
- GLubyte const * pc = setup_single_request(gc, X_GLsop_GetMapfv, cmdlen);
+#ifdef USE_XCB
+ XCBConnection *c = XCBConnectionOfDisplay(dpy);
+ (void) __glXFlushRenderBuffer(gc, gc->pc);
+ XCBGlxGetMapfvRep *reply = XCBGlxGetMapfvReply(c, XCBGlxGetMapfv(c, gc->currentContextTag, target, query), NULL);
+ if (XCBGlxGetMapfvDataLength(reply) == 0)
+ (void)memcpy(v, &reply->datum, sizeof(reply->datum));
+ else
+ (void)memcpy(v, XCBGlxGetMapfvData(reply), XCBGlxGetMapfvDataLength(reply) * sizeof(GLfloat));
+ free(reply);
+#else
+ GLubyte const * pc = __glXSetupSingleRequest(gc, X_GLsop_GetMapfv, cmdlen);
(void) memcpy((void *)(pc + 0), (void *)(&target), 4);
(void) memcpy((void *)(pc + 4), (void *)(&query), 4);
- (void) read_reply(dpy, 4, v, GL_FALSE);
+ (void) __glXReadReply(dpy, 4, v, GL_FALSE);
UnlockDisplay(dpy); SyncHandle();
+#endif /* USE_XCB */
}
return;
}
Display * const dpy = gc->currentDpy;
const GLuint cmdlen = 8;
if (__builtin_expect(dpy != NULL, 1)) {
- GLubyte const * pc = setup_single_request(gc, X_GLsop_GetMapiv, cmdlen);
+#ifdef USE_XCB
+ XCBConnection *c = XCBConnectionOfDisplay(dpy);
+ (void) __glXFlushRenderBuffer(gc, gc->pc);
+ XCBGlxGetMapivRep *reply = XCBGlxGetMapivReply(c, XCBGlxGetMapiv(c, gc->currentContextTag, target, query), NULL);
+ if (XCBGlxGetMapivDataLength(reply) == 0)
+ (void)memcpy(v, &reply->datum, sizeof(reply->datum));
+ else
+ (void)memcpy(v, XCBGlxGetMapivData(reply), XCBGlxGetMapivDataLength(reply) * sizeof(GLint));
+ free(reply);
+#else
+ GLubyte const * pc = __glXSetupSingleRequest(gc, X_GLsop_GetMapiv, cmdlen);
(void) memcpy((void *)(pc + 0), (void *)(&target), 4);
(void) memcpy((void *)(pc + 4), (void *)(&query), 4);
- (void) read_reply(dpy, 4, v, GL_FALSE);
+ (void) __glXReadReply(dpy, 4, v, GL_FALSE);
UnlockDisplay(dpy); SyncHandle();
+#endif /* USE_XCB */
}
return;
}
Display * const dpy = gc->currentDpy;
const GLuint cmdlen = 8;
if (__builtin_expect(dpy != NULL, 1)) {
- GLubyte const * pc = setup_single_request(gc, X_GLsop_GetMaterialfv, cmdlen);
+#ifdef USE_XCB
+ XCBConnection *c = XCBConnectionOfDisplay(dpy);
+ (void) __glXFlushRenderBuffer(gc, gc->pc);
+ XCBGlxGetMaterialfvRep *reply = XCBGlxGetMaterialfvReply(c, XCBGlxGetMaterialfv(c, gc->currentContextTag, face, pname), NULL);
+ if (XCBGlxGetMaterialfvDataLength(reply) == 0)
+ (void)memcpy(params, &reply->datum, sizeof(reply->datum));
+ else
+ (void)memcpy(params, XCBGlxGetMaterialfvData(reply), XCBGlxGetMaterialfvDataLength(reply) * sizeof(GLfloat));
+ free(reply);
+#else
+ GLubyte const * pc = __glXSetupSingleRequest(gc, X_GLsop_GetMaterialfv, cmdlen);
(void) memcpy((void *)(pc + 0), (void *)(&face), 4);
(void) memcpy((void *)(pc + 4), (void *)(&pname), 4);
- (void) read_reply(dpy, 4, params, GL_FALSE);
+ (void) __glXReadReply(dpy, 4, params, GL_FALSE);
UnlockDisplay(dpy); SyncHandle();
+#endif /* USE_XCB */
}
return;
}
Display * const dpy = gc->currentDpy;
const GLuint cmdlen = 8;
if (__builtin_expect(dpy != NULL, 1)) {
- GLubyte const * pc = setup_single_request(gc, X_GLsop_GetMaterialiv, cmdlen);
+#ifdef USE_XCB
+ XCBConnection *c = XCBConnectionOfDisplay(dpy);
+ (void) __glXFlushRenderBuffer(gc, gc->pc);
+ XCBGlxGetMaterialivRep *reply = XCBGlxGetMaterialivReply(c, XCBGlxGetMaterialiv(c, gc->currentContextTag, face, pname), NULL);
+ if (XCBGlxGetMaterialivDataLength(reply) == 0)
+ (void)memcpy(params, &reply->datum, sizeof(reply->datum));
+ else
+ (void)memcpy(params, XCBGlxGetMaterialivData(reply), XCBGlxGetMaterialivDataLength(reply) * sizeof(GLint));
+ free(reply);
+#else
+ GLubyte const * pc = __glXSetupSingleRequest(gc, X_GLsop_GetMaterialiv, cmdlen);
(void) memcpy((void *)(pc + 0), (void *)(&face), 4);
(void) memcpy((void *)(pc + 4), (void *)(&pname), 4);
- (void) read_reply(dpy, 4, params, GL_FALSE);
+ (void) __glXReadReply(dpy, 4, params, GL_FALSE);
UnlockDisplay(dpy); SyncHandle();
+#endif /* USE_XCB */
}
return;
}
Display * const dpy = gc->currentDpy;
const GLuint cmdlen = 4;
if (__builtin_expect(dpy != NULL, 1)) {
- GLubyte const * pc = setup_single_request(gc, X_GLsop_GetPixelMapfv, cmdlen);
+#ifdef USE_XCB
+ XCBConnection *c = XCBConnectionOfDisplay(dpy);
+ (void) __glXFlushRenderBuffer(gc, gc->pc);
+ XCBGlxGetPixelMapfvRep *reply = XCBGlxGetPixelMapfvReply(c, XCBGlxGetPixelMapfv(c, gc->currentContextTag, map), NULL);
+ if (XCBGlxGetPixelMapfvDataLength(reply) == 0)
+ (void)memcpy(values, &reply->datum, sizeof(reply->datum));
+ else
+ (void)memcpy(values, XCBGlxGetPixelMapfvData(reply), XCBGlxGetPixelMapfvDataLength(reply) * sizeof(GLfloat));
+ free(reply);
+#else
+ GLubyte const * pc = __glXSetupSingleRequest(gc, X_GLsop_GetPixelMapfv, cmdlen);
(void) memcpy((void *)(pc + 0), (void *)(&map), 4);
- (void) read_reply(dpy, 4, values, GL_FALSE);
+ (void) __glXReadReply(dpy, 4, values, GL_FALSE);
UnlockDisplay(dpy); SyncHandle();
+#endif /* USE_XCB */
}
return;
}
Display * const dpy = gc->currentDpy;
const GLuint cmdlen = 4;
if (__builtin_expect(dpy != NULL, 1)) {
- GLubyte const * pc = setup_single_request(gc, X_GLsop_GetPixelMapuiv, cmdlen);
+#ifdef USE_XCB
+ XCBConnection *c = XCBConnectionOfDisplay(dpy);
+ (void) __glXFlushRenderBuffer(gc, gc->pc);
+ XCBGlxGetPixelMapuivRep *reply = XCBGlxGetPixelMapuivReply(c, XCBGlxGetPixelMapuiv(c, gc->currentContextTag, map), NULL);
+ if (XCBGlxGetPixelMapuivDataLength(reply) == 0)
+ (void)memcpy(values, &reply->datum, sizeof(reply->datum));
+ else
+ (void)memcpy(values, XCBGlxGetPixelMapuivData(reply), XCBGlxGetPixelMapuivDataLength(reply) * sizeof(GLuint));
+ free(reply);
+#else
+ GLubyte const * pc = __glXSetupSingleRequest(gc, X_GLsop_GetPixelMapuiv, cmdlen);
(void) memcpy((void *)(pc + 0), (void *)(&map), 4);
- (void) read_reply(dpy, 4, values, GL_FALSE);
+ (void) __glXReadReply(dpy, 4, values, GL_FALSE);
UnlockDisplay(dpy); SyncHandle();
+#endif /* USE_XCB */
}
return;
}
Display * const dpy = gc->currentDpy;
const GLuint cmdlen = 4;
if (__builtin_expect(dpy != NULL, 1)) {
- GLubyte const * pc = setup_single_request(gc, X_GLsop_GetPixelMapusv, cmdlen);
+#ifdef USE_XCB
+ XCBConnection *c = XCBConnectionOfDisplay(dpy);
+ (void) __glXFlushRenderBuffer(gc, gc->pc);
+ XCBGlxGetPixelMapusvRep *reply = XCBGlxGetPixelMapusvReply(c, XCBGlxGetPixelMapusv(c, gc->currentContextTag, map), NULL);
+ if (XCBGlxGetPixelMapusvDataLength(reply) == 0)
+ (void)memcpy(values, &reply->datum, sizeof(reply->datum));
+ else
+ (void)memcpy(values, XCBGlxGetPixelMapusvData(reply), XCBGlxGetPixelMapusvDataLength(reply) * sizeof(GLushort));
+ free(reply);
+#else
+ GLubyte const * pc = __glXSetupSingleRequest(gc, X_GLsop_GetPixelMapusv, cmdlen);
(void) memcpy((void *)(pc + 0), (void *)(&map), 4);
- (void) read_reply(dpy, 2, values, GL_FALSE);
+ (void) __glXReadReply(dpy, 2, values, GL_FALSE);
UnlockDisplay(dpy); SyncHandle();
+#endif /* USE_XCB */
+ }
+ return;
+}
+
+#define X_GLsop_GetPolygonStipple 128
+void
+__indirect_glGetPolygonStipple(GLubyte * mask)
+{
+ __GLXcontext * const gc = __glXGetCurrentContext();
+ const __GLXattribute * const state = gc->client_state_private;
+ Display * const dpy = gc->currentDpy;
+ const GLuint cmdlen = 4;
+ if (__builtin_expect(dpy != NULL, 1)) {
+#ifdef USE_XCB
+ XCBConnection *c = XCBConnectionOfDisplay(dpy);
+ (void) __glXFlushRenderBuffer(gc, gc->pc);
+ XCBGlxGetPolygonStippleRep *reply = XCBGlxGetPolygonStippleReply(c, XCBGlxGetPolygonStipple(c, gc->currentContextTag, 0), NULL);
+ (void)memcpy(mask, XCBGlxGetPolygonStippleData(reply), XCBGlxGetPolygonStippleDataLength(reply) * sizeof(GLubyte));
+ free(reply);
+#else
+ GLubyte const * pc = __glXSetupSingleRequest(gc, X_GLsop_GetPolygonStipple, cmdlen);
+ *(int32_t *)(pc + 0) = 0;
+ __glXReadPixelReply(dpy, gc, 2, 32, 32, 1, GL_COLOR_INDEX, GL_BITMAP, mask, GL_FALSE);
+ UnlockDisplay(dpy); SyncHandle();
+#endif /* USE_XCB */
}
return;
}
Display * const dpy = gc->currentDpy;
const GLuint cmdlen = 8;
if (__builtin_expect(dpy != NULL, 1)) {
- GLubyte const * pc = setup_single_request(gc, X_GLsop_GetTexEnvfv, cmdlen);
+#ifdef USE_XCB
+ XCBConnection *c = XCBConnectionOfDisplay(dpy);
+ (void) __glXFlushRenderBuffer(gc, gc->pc);
+ XCBGlxGetTexEnvfvRep *reply = XCBGlxGetTexEnvfvReply(c, XCBGlxGetTexEnvfv(c, gc->currentContextTag, target, pname), NULL);
+ if (XCBGlxGetTexEnvfvDataLength(reply) == 0)
+ (void)memcpy(params, &reply->datum, sizeof(reply->datum));
+ else
+ (void)memcpy(params, XCBGlxGetTexEnvfvData(reply), XCBGlxGetTexEnvfvDataLength(reply) * sizeof(GLfloat));
+ free(reply);
+#else
+ GLubyte const * pc = __glXSetupSingleRequest(gc, X_GLsop_GetTexEnvfv, cmdlen);
(void) memcpy((void *)(pc + 0), (void *)(&target), 4);
(void) memcpy((void *)(pc + 4), (void *)(&pname), 4);
- (void) read_reply(dpy, 4, params, GL_FALSE);
+ (void) __glXReadReply(dpy, 4, params, GL_FALSE);
UnlockDisplay(dpy); SyncHandle();
+#endif /* USE_XCB */
}
return;
}
Display * const dpy = gc->currentDpy;
const GLuint cmdlen = 8;
if (__builtin_expect(dpy != NULL, 1)) {
- GLubyte const * pc = setup_single_request(gc, X_GLsop_GetTexEnviv, cmdlen);
+#ifdef USE_XCB
+ XCBConnection *c = XCBConnectionOfDisplay(dpy);
+ (void) __glXFlushRenderBuffer(gc, gc->pc);
+ XCBGlxGetTexEnvivRep *reply = XCBGlxGetTexEnvivReply(c, XCBGlxGetTexEnviv(c, gc->currentContextTag, target, pname), NULL);
+ if (XCBGlxGetTexEnvivDataLength(reply) == 0)
+ (void)memcpy(params, &reply->datum, sizeof(reply->datum));
+ else
+ (void)memcpy(params, XCBGlxGetTexEnvivData(reply), XCBGlxGetTexEnvivDataLength(reply) * sizeof(GLint));
+ free(reply);
+#else
+ GLubyte const * pc = __glXSetupSingleRequest(gc, X_GLsop_GetTexEnviv, cmdlen);
(void) memcpy((void *)(pc + 0), (void *)(&target), 4);
(void) memcpy((void *)(pc + 4), (void *)(&pname), 4);
- (void) read_reply(dpy, 4, params, GL_FALSE);
+ (void) __glXReadReply(dpy, 4, params, GL_FALSE);
UnlockDisplay(dpy); SyncHandle();
+#endif /* USE_XCB */
}
return;
}
Display * const dpy = gc->currentDpy;
const GLuint cmdlen = 8;
if (__builtin_expect(dpy != NULL, 1)) {
- GLubyte const * pc = setup_single_request(gc, X_GLsop_GetTexGendv, cmdlen);
+#ifdef USE_XCB
+ XCBConnection *c = XCBConnectionOfDisplay(dpy);
+ (void) __glXFlushRenderBuffer(gc, gc->pc);
+ XCBGlxGetTexGendvRep *reply = XCBGlxGetTexGendvReply(c, XCBGlxGetTexGendv(c, gc->currentContextTag, coord, pname), NULL);
+ if (XCBGlxGetTexGendvDataLength(reply) == 0)
+ (void)memcpy(params, &reply->datum, sizeof(reply->datum));
+ else
+ (void)memcpy(params, XCBGlxGetTexGendvData(reply), XCBGlxGetTexGendvDataLength(reply) * sizeof(GLdouble));
+ free(reply);
+#else
+ GLubyte const * pc = __glXSetupSingleRequest(gc, X_GLsop_GetTexGendv, cmdlen);
(void) memcpy((void *)(pc + 0), (void *)(&coord), 4);
(void) memcpy((void *)(pc + 4), (void *)(&pname), 4);
- (void) read_reply(dpy, 8, params, GL_FALSE);
+ (void) __glXReadReply(dpy, 8, params, GL_FALSE);
UnlockDisplay(dpy); SyncHandle();
+#endif /* USE_XCB */
}
return;
}
Display * const dpy = gc->currentDpy;
const GLuint cmdlen = 8;
if (__builtin_expect(dpy != NULL, 1)) {
- GLubyte const * pc = setup_single_request(gc, X_GLsop_GetTexGenfv, cmdlen);
+#ifdef USE_XCB
+ XCBConnection *c = XCBConnectionOfDisplay(dpy);
+ (void) __glXFlushRenderBuffer(gc, gc->pc);
+ XCBGlxGetTexGenfvRep *reply = XCBGlxGetTexGenfvReply(c, XCBGlxGetTexGenfv(c, gc->currentContextTag, coord, pname), NULL);
+ if (XCBGlxGetTexGenfvDataLength(reply) == 0)
+ (void)memcpy(params, &reply->datum, sizeof(reply->datum));
+ else
+ (void)memcpy(params, XCBGlxGetTexGenfvData(reply), XCBGlxGetTexGenfvDataLength(reply) * sizeof(GLfloat));
+ free(reply);
+#else
+ GLubyte const * pc = __glXSetupSingleRequest(gc, X_GLsop_GetTexGenfv, cmdlen);
(void) memcpy((void *)(pc + 0), (void *)(&coord), 4);
(void) memcpy((void *)(pc + 4), (void *)(&pname), 4);
- (void) read_reply(dpy, 4, params, GL_FALSE);
+ (void) __glXReadReply(dpy, 4, params, GL_FALSE);
UnlockDisplay(dpy); SyncHandle();
+#endif /* USE_XCB */
}
return;
}
Display * const dpy = gc->currentDpy;
const GLuint cmdlen = 8;
if (__builtin_expect(dpy != NULL, 1)) {
- GLubyte const * pc = setup_single_request(gc, X_GLsop_GetTexGeniv, cmdlen);
+#ifdef USE_XCB
+ XCBConnection *c = XCBConnectionOfDisplay(dpy);
+ (void) __glXFlushRenderBuffer(gc, gc->pc);
+ XCBGlxGetTexGenivRep *reply = XCBGlxGetTexGenivReply(c, XCBGlxGetTexGeniv(c, gc->currentContextTag, coord, pname), NULL);
+ if (XCBGlxGetTexGenivDataLength(reply) == 0)
+ (void)memcpy(params, &reply->datum, sizeof(reply->datum));
+ else
+ (void)memcpy(params, XCBGlxGetTexGenivData(reply), XCBGlxGetTexGenivDataLength(reply) * sizeof(GLint));
+ free(reply);
+#else
+ GLubyte const * pc = __glXSetupSingleRequest(gc, X_GLsop_GetTexGeniv, cmdlen);
(void) memcpy((void *)(pc + 0), (void *)(&coord), 4);
(void) memcpy((void *)(pc + 4), (void *)(&pname), 4);
- (void) read_reply(dpy, 4, params, GL_FALSE);
+ (void) __glXReadReply(dpy, 4, params, GL_FALSE);
+ UnlockDisplay(dpy); SyncHandle();
+#endif /* USE_XCB */
+ }
+ return;
+}
+
+#define X_GLsop_GetTexImage 135
+void
+__indirect_glGetTexImage(GLenum target, GLint level, GLenum format, GLenum type, GLvoid * pixels)
+{
+ __GLXcontext * const gc = __glXGetCurrentContext();
+ const __GLXattribute * const state = gc->client_state_private;
+ Display * const dpy = gc->currentDpy;
+ const GLuint cmdlen = 20;
+ if (__builtin_expect(dpy != NULL, 1)) {
+#ifdef USE_XCB
+ XCBConnection *c = XCBConnectionOfDisplay(dpy);
+ (void) __glXFlushRenderBuffer(gc, gc->pc);
+ XCBGlxGetTexImageRep *reply = XCBGlxGetTexImageReply(c, XCBGlxGetTexImage(c, gc->currentContextTag, target, level, format, type, state->storePack.swapEndian), NULL);
+ (void)memcpy(pixels, XCBGlxGetTexImageData(reply), XCBGlxGetTexImageDataLength(reply) * sizeof(GLvoid));
+ free(reply);
+#else
+ GLubyte const * pc = __glXSetupSingleRequest(gc, X_GLsop_GetTexImage, cmdlen);
+ (void) memcpy((void *)(pc + 0), (void *)(&target), 4);
+ (void) memcpy((void *)(pc + 4), (void *)(&level), 4);
+ (void) memcpy((void *)(pc + 8), (void *)(&format), 4);
+ (void) memcpy((void *)(pc + 12), (void *)(&type), 4);
+ *(int32_t *)(pc + 16) = 0;
+ * (int8_t *)(pc + 16) = state->storePack.swapEndian;
+ __glXReadPixelReply(dpy, gc, 3, 0, 0, 0, format, type, pixels, GL_TRUE);
UnlockDisplay(dpy); SyncHandle();
+#endif /* USE_XCB */
}
return;
}
Display * const dpy = gc->currentDpy;
const GLuint cmdlen = 8;
if (__builtin_expect(dpy != NULL, 1)) {
- GLubyte const * pc = setup_single_request(gc, X_GLsop_GetTexParameterfv, cmdlen);
+#ifdef USE_XCB
+ XCBConnection *c = XCBConnectionOfDisplay(dpy);
+ (void) __glXFlushRenderBuffer(gc, gc->pc);
+ XCBGlxGetTexParameterfvRep *reply = XCBGlxGetTexParameterfvReply(c, XCBGlxGetTexParameterfv(c, gc->currentContextTag, target, pname), NULL);
+ if (XCBGlxGetTexParameterfvDataLength(reply) == 0)
+ (void)memcpy(params, &reply->datum, sizeof(reply->datum));
+ else
+ (void)memcpy(params, XCBGlxGetTexParameterfvData(reply), XCBGlxGetTexParameterfvDataLength(reply) * sizeof(GLfloat));
+ free(reply);
+#else
+ GLubyte const * pc = __glXSetupSingleRequest(gc, X_GLsop_GetTexParameterfv, cmdlen);
(void) memcpy((void *)(pc + 0), (void *)(&target), 4);
(void) memcpy((void *)(pc + 4), (void *)(&pname), 4);
- (void) read_reply(dpy, 4, params, GL_FALSE);
+ (void) __glXReadReply(dpy, 4, params, GL_FALSE);
UnlockDisplay(dpy); SyncHandle();
+#endif /* USE_XCB */
}
return;
}
Display * const dpy = gc->currentDpy;
const GLuint cmdlen = 8;
if (__builtin_expect(dpy != NULL, 1)) {
- GLubyte const * pc = setup_single_request(gc, X_GLsop_GetTexParameteriv, cmdlen);
+#ifdef USE_XCB
+ XCBConnection *c = XCBConnectionOfDisplay(dpy);
+ (void) __glXFlushRenderBuffer(gc, gc->pc);
+ XCBGlxGetTexParameterivRep *reply = XCBGlxGetTexParameterivReply(c, XCBGlxGetTexParameteriv(c, gc->currentContextTag, target, pname), NULL);
+ if (XCBGlxGetTexParameterivDataLength(reply) == 0)
+ (void)memcpy(params, &reply->datum, sizeof(reply->datum));
+ else
+ (void)memcpy(params, XCBGlxGetTexParameterivData(reply), XCBGlxGetTexParameterivDataLength(reply) * sizeof(GLint));
+ free(reply);
+#else
+ GLubyte const * pc = __glXSetupSingleRequest(gc, X_GLsop_GetTexParameteriv, cmdlen);
(void) memcpy((void *)(pc + 0), (void *)(&target), 4);
(void) memcpy((void *)(pc + 4), (void *)(&pname), 4);
- (void) read_reply(dpy, 4, params, GL_FALSE);
+ (void) __glXReadReply(dpy, 4, params, GL_FALSE);
UnlockDisplay(dpy); SyncHandle();
+#endif /* USE_XCB */
}
return;
}
Display * const dpy = gc->currentDpy;
const GLuint cmdlen = 12;
if (__builtin_expect(dpy != NULL, 1)) {
- GLubyte const * pc = setup_single_request(gc, X_GLsop_GetTexLevelParameterfv, cmdlen);
+#ifdef USE_XCB
+ XCBConnection *c = XCBConnectionOfDisplay(dpy);
+ (void) __glXFlushRenderBuffer(gc, gc->pc);
+ XCBGlxGetTexLevelParameterfvRep *reply = XCBGlxGetTexLevelParameterfvReply(c, XCBGlxGetTexLevelParameterfv(c, gc->currentContextTag, target, level, pname), NULL);
+ if (XCBGlxGetTexLevelParameterfvDataLength(reply) == 0)
+ (void)memcpy(params, &reply->datum, sizeof(reply->datum));
+ else
+ (void)memcpy(params, XCBGlxGetTexLevelParameterfvData(reply), XCBGlxGetTexLevelParameterfvDataLength(reply) * sizeof(GLfloat));
+ free(reply);
+#else
+ GLubyte const * pc = __glXSetupSingleRequest(gc, X_GLsop_GetTexLevelParameterfv, cmdlen);
(void) memcpy((void *)(pc + 0), (void *)(&target), 4);
(void) memcpy((void *)(pc + 4), (void *)(&level), 4);
(void) memcpy((void *)(pc + 8), (void *)(&pname), 4);
- (void) read_reply(dpy, 4, params, GL_FALSE);
+ (void) __glXReadReply(dpy, 4, params, GL_FALSE);
UnlockDisplay(dpy); SyncHandle();
+#endif /* USE_XCB */
}
return;
}
Display * const dpy = gc->currentDpy;
const GLuint cmdlen = 12;
if (__builtin_expect(dpy != NULL, 1)) {
- GLubyte const * pc = setup_single_request(gc, X_GLsop_GetTexLevelParameteriv, cmdlen);
+#ifdef USE_XCB
+ XCBConnection *c = XCBConnectionOfDisplay(dpy);
+ (void) __glXFlushRenderBuffer(gc, gc->pc);
+ XCBGlxGetTexLevelParameterivRep *reply = XCBGlxGetTexLevelParameterivReply(c, XCBGlxGetTexLevelParameteriv(c, gc->currentContextTag, target, level, pname), NULL);
+ if (XCBGlxGetTexLevelParameterivDataLength(reply) == 0)
+ (void)memcpy(params, &reply->datum, sizeof(reply->datum));
+ else
+ (void)memcpy(params, XCBGlxGetTexLevelParameterivData(reply), XCBGlxGetTexLevelParameterivDataLength(reply) * sizeof(GLint));
+ free(reply);
+#else
+ GLubyte const * pc = __glXSetupSingleRequest(gc, X_GLsop_GetTexLevelParameteriv, cmdlen);
(void) memcpy((void *)(pc + 0), (void *)(&target), 4);
(void) memcpy((void *)(pc + 4), (void *)(&level), 4);
(void) memcpy((void *)(pc + 8), (void *)(&pname), 4);
- (void) read_reply(dpy, 4, params, GL_FALSE);
+ (void) __glXReadReply(dpy, 4, params, GL_FALSE);
UnlockDisplay(dpy); SyncHandle();
+#endif /* USE_XCB */
}
return;
}
GLboolean retval = (GLboolean) 0;
const GLuint cmdlen = 4;
if (__builtin_expect(dpy != NULL, 1)) {
- GLubyte const * pc = setup_single_request(gc, X_GLsop_IsList, cmdlen);
+#ifdef USE_XCB
+ XCBConnection *c = XCBConnectionOfDisplay(dpy);
+ (void) __glXFlushRenderBuffer(gc, gc->pc);
+ XCBGlxIsListRep *reply = XCBGlxIsListReply(c, XCBGlxIsList(c, gc->currentContextTag, list), NULL);
+ retval = reply->ret_val;
+ free(reply);
+#else
+ GLubyte const * pc = __glXSetupSingleRequest(gc, X_GLsop_IsList, cmdlen);
(void) memcpy((void *)(pc + 0), (void *)(&list), 4);
- retval = (GLboolean) read_reply(dpy, 0, NULL, GL_FALSE);
+ retval = (GLboolean) __glXReadReply(dpy, 0, NULL, GL_FALSE);
UnlockDisplay(dpy); SyncHandle();
+#endif /* USE_XCB */
}
return retval;
}
GLboolean retval = (GLboolean) 0;
const GLuint cmdlen = 4 + __GLX_PAD((n * 4));
if (__builtin_expect((n >= 0) && (dpy != NULL), 1)) {
- GLubyte const * pc = setup_single_request(gc, X_GLsop_AreTexturesResident, cmdlen);
+#ifdef USE_XCB
+ XCBConnection *c = XCBConnectionOfDisplay(dpy);
+ (void) __glXFlushRenderBuffer(gc, gc->pc);
+ XCBGlxAreTexturesResidentRep *reply = XCBGlxAreTexturesResidentReply(c, XCBGlxAreTexturesResident(c, gc->currentContextTag, n, textures), NULL);
+ (void)memcpy(residences, XCBGlxAreTexturesResidentData(reply), XCBGlxAreTexturesResidentDataLength(reply) * sizeof(GLboolean));
+ retval = reply->ret_val;
+ free(reply);
+#else
+ GLubyte const * pc = __glXSetupSingleRequest(gc, X_GLsop_AreTexturesResident, cmdlen);
(void) memcpy((void *)(pc + 0), (void *)(&n), 4);
(void) memcpy((void *)(pc + 4), (void *)(textures), (n * 4));
- retval = (GLboolean) read_reply(dpy, 1, residences, GL_TRUE);
+ retval = (GLboolean) __glXReadReply(dpy, 1, residences, GL_TRUE);
UnlockDisplay(dpy); SyncHandle();
+#endif /* USE_XCB */
}
return retval;
}
if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
}
-#define X_GLsop_DeleteTextures 144
+#define X_GLvop_DeleteTextures 12
void
__indirect_glDeleteTextures(GLsizei n, const GLuint * textures)
{
Display * const dpy = gc->currentDpy;
const GLuint cmdlen = 4 + __GLX_PAD((n * 4));
if (__builtin_expect((n >= 0) && (dpy != NULL), 1)) {
- GLubyte const * pc = setup_single_request(gc, X_GLsop_DeleteTextures, cmdlen);
+ GLubyte const * pc = __glXSetupVendorRequest(gc, X_GLXVendorPrivate, X_GLvop_DeleteTextures, cmdlen);
(void) memcpy((void *)(pc + 0), (void *)(&n), 4);
(void) memcpy((void *)(pc + 4), (void *)(textures), (n * 4));
UnlockDisplay(dpy); SyncHandle();
__GLXcontext * const gc = __glXGetCurrentContext();
Display * const dpy = gc->currentDpy;
const GLuint cmdlen = 4;
- if (__builtin_expect(dpy != NULL, 1)) {
- GLubyte const * pc = setup_single_request(gc, X_GLsop_GenTextures, cmdlen);
+ if (__builtin_expect((n >= 0) && (dpy != NULL), 1)) {
+#ifdef USE_XCB
+ XCBConnection *c = XCBConnectionOfDisplay(dpy);
+ (void) __glXFlushRenderBuffer(gc, gc->pc);
+ XCBGlxGenTexturesRep *reply = XCBGlxGenTexturesReply(c, XCBGlxGenTextures(c, gc->currentContextTag, n), NULL);
+ (void)memcpy(textures, XCBGlxGenTexturesData(reply), XCBGlxGenTexturesDataLength(reply) * sizeof(GLuint));
+ free(reply);
+#else
+ GLubyte const * pc = __glXSetupSingleRequest(gc, X_GLsop_GenTextures, cmdlen);
(void) memcpy((void *)(pc + 0), (void *)(&n), 4);
- (void) read_reply(dpy, 4, textures, GL_TRUE);
+ (void) __glXReadReply(dpy, 4, textures, GL_TRUE);
UnlockDisplay(dpy); SyncHandle();
+#endif /* USE_XCB */
}
return;
}
GLboolean retval = (GLboolean) 0;
const GLuint cmdlen = 4;
if (__builtin_expect(dpy != NULL, 1)) {
- GLubyte const * pc = setup_single_request(gc, X_GLsop_IsTexture, cmdlen);
+#ifdef USE_XCB
+ XCBConnection *c = XCBConnectionOfDisplay(dpy);
+ (void) __glXFlushRenderBuffer(gc, gc->pc);
+ XCBGlxIsTextureRep *reply = XCBGlxIsTextureReply(c, XCBGlxIsTexture(c, gc->currentContextTag, texture), NULL);
+ retval = reply->ret_val;
+ free(reply);
+#else
+ GLubyte const * pc = __glXSetupSingleRequest(gc, X_GLsop_IsTexture, cmdlen);
(void) memcpy((void *)(pc + 0), (void *)(&texture), 4);
- retval = (GLboolean) read_reply(dpy, 0, NULL, GL_FALSE);
+ retval = (GLboolean) __glXReadReply(dpy, 0, NULL, GL_FALSE);
UnlockDisplay(dpy); SyncHandle();
+#endif /* USE_XCB */
}
return retval;
}
emit_header(gc->pc, X_GLrop_PrioritizeTextures, cmdlen);
(void) memcpy((void *)(gc->pc + 4), (void *)(&n), 4);
(void) memcpy((void *)(gc->pc + 8), (void *)(textures), (n * 4));
- (void) memcpy((void *)(gc->pc + 8), (void *)(priorities), (n * 4));
+ (void) memcpy((void *)(gc->pc + 8 + (n * 4)), (void *)(priorities), (n * 4));
gc->pc += cmdlen;
if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
}
}
+static void
+__glx_TexSubImage_1D2D( unsigned opcode, unsigned dim, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid * pixels )
+{
+ __GLXcontext * const gc = __glXGetCurrentContext();
+ const GLuint compsize = (pixels != NULL) ? __glImageSize(width, height, 1, format, type, target) : 0;
+ const GLuint cmdlen = 60 + __GLX_PAD(compsize);
+ if (__builtin_expect(gc->currentDpy != NULL, 1)) {
+ if (cmdlen <= gc->maxSmallRenderCommandSize) {
+ if ( (gc->pc + cmdlen) > gc->bufEnd ) {
+ (void) __glXFlushRenderBuffer(gc, gc->pc);
+ }
+ emit_header(gc->pc, opcode, cmdlen);
+ (void) memcpy((void *)(gc->pc + 24), (void *)(&target), 4);
+ (void) memcpy((void *)(gc->pc + 28), (void *)(&level), 4);
+ (void) memcpy((void *)(gc->pc + 32), (void *)(&xoffset), 4);
+ (void) memcpy((void *)(gc->pc + 36), (void *)(&yoffset), 4);
+ (void) memcpy((void *)(gc->pc + 40), (void *)(&width), 4);
+ (void) memcpy((void *)(gc->pc + 44), (void *)(&height), 4);
+ (void) memcpy((void *)(gc->pc + 48), (void *)(&format), 4);
+ (void) memcpy((void *)(gc->pc + 52), (void *)(&type), 4);
+ (void) memcpy((void *)(gc->pc + 56), (void *)((pixels == NULL) ? one : zero), 4);
+ if (compsize > 0) {
+ (*gc->fillImage)(gc, dim, width, height, 1, format, type, pixels, gc->pc + 60, gc->pc + 4);
+ }
+ else {
+ (void) memcpy( gc->pc + 4, default_pixel_store_2D, default_pixel_store_2D_size );
+ }
+ gc->pc += cmdlen;
+ if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+ }
+ else {
+ const GLint op = opcode;
+ const GLuint cmdlenLarge = cmdlen + 4;
+ GLubyte * const pc = __glXFlushRenderBuffer(gc, gc->pc);
+ (void) memcpy((void *)(pc + 0), (void *)(&cmdlenLarge), 4);
+ (void) memcpy((void *)(pc + 4), (void *)(&op), 4);
+ (void) memcpy((void *)(pc + 28), (void *)(&target), 4);
+ (void) memcpy((void *)(pc + 32), (void *)(&level), 4);
+ (void) memcpy((void *)(pc + 36), (void *)(&xoffset), 4);
+ (void) memcpy((void *)(pc + 40), (void *)(&yoffset), 4);
+ (void) memcpy((void *)(pc + 44), (void *)(&width), 4);
+ (void) memcpy((void *)(pc + 48), (void *)(&height), 4);
+ (void) memcpy((void *)(pc + 52), (void *)(&format), 4);
+ (void) memcpy((void *)(pc + 56), (void *)(&type), 4);
+ (void) memcpy((void *)(pc + 60), zero, 4);
+ __glXSendLargeImage(gc, compsize, dim, width, height, 1, format, type, pixels, pc + 64, pc + 8);
+ }
+ }
+}
+
+#define X_GLrop_TexSubImage1D 4099
+void
+__indirect_glTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const GLvoid * pixels)
+{
+ __glx_TexSubImage_1D2D(X_GLrop_TexSubImage1D, 1, target, level, xoffset, 1, width, 1, format, type, pixels );
+}
+
+#define X_GLrop_TexSubImage2D 4100
+void
+__indirect_glTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid * pixels)
+{
+ __glx_TexSubImage_1D2D(X_GLrop_TexSubImage2D, 2, target, level, xoffset, yoffset, width, height, format, type, pixels );
+}
+
#define X_GLrop_BlendColor 4096
void
__indirect_glBlendColor(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha)
if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
}
+#define X_GLrop_ColorTable 2053
+void
+__indirect_glColorTable(GLenum target, GLenum internalformat, GLsizei width, GLenum format, GLenum type, const GLvoid * table)
+{
+ __GLXcontext * const gc = __glXGetCurrentContext();
+ const GLuint compsize = (table != NULL) ? __glImageSize(width, 1, 1, format, type, target) : 0;
+ const GLuint cmdlen = 44 + __GLX_PAD(compsize);
+ if (__builtin_expect(gc->currentDpy != NULL, 1)) {
+ if (cmdlen <= gc->maxSmallRenderCommandSize) {
+ if ( (gc->pc + cmdlen) > gc->bufEnd ) {
+ (void) __glXFlushRenderBuffer(gc, gc->pc);
+ }
+ emit_header(gc->pc, X_GLrop_ColorTable, cmdlen);
+ (void) memcpy((void *)(gc->pc + 24), (void *)(&target), 4);
+ (void) memcpy((void *)(gc->pc + 28), (void *)(&internalformat), 4);
+ (void) memcpy((void *)(gc->pc + 32), (void *)(&width), 4);
+ (void) memcpy((void *)(gc->pc + 36), (void *)(&format), 4);
+ (void) memcpy((void *)(gc->pc + 40), (void *)(&type), 4);
+ if (compsize > 0) {
+ (*gc->fillImage)(gc, 1, width, 1, 1, format, type, table, gc->pc + 44, gc->pc + 4);
+ }
+ else {
+ (void) memcpy( gc->pc + 4, default_pixel_store_1D, default_pixel_store_1D_size );
+ }
+ gc->pc += cmdlen;
+ if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+ }
+ else {
+ const GLint op = X_GLrop_ColorTable;
+ const GLuint cmdlenLarge = cmdlen + 4;
+ GLubyte * const pc = __glXFlushRenderBuffer(gc, gc->pc);
+ (void) memcpy((void *)(pc + 0), (void *)(&cmdlenLarge), 4);
+ (void) memcpy((void *)(pc + 4), (void *)(&op), 4);
+ (void) memcpy((void *)(pc + 28), (void *)(&target), 4);
+ (void) memcpy((void *)(pc + 32), (void *)(&internalformat), 4);
+ (void) memcpy((void *)(pc + 36), (void *)(&width), 4);
+ (void) memcpy((void *)(pc + 40), (void *)(&format), 4);
+ (void) memcpy((void *)(pc + 44), (void *)(&type), 4);
+ __glXSendLargeImage(gc, compsize, 1, width, 1, 1, format, type, table, pc + 48, pc + 8);
+ }
+ }
+}
+
#define X_GLrop_ColorTableParameterfv 2054
void
__indirect_glColorTableParameterfv(GLenum target, GLenum pname, const GLfloat * params)
if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
}
+#define X_GLsop_GetColorTable 147
+void
+__indirect_glGetColorTable(GLenum target, GLenum format, GLenum type, GLvoid * table)
+{
+ __GLXcontext * const gc = __glXGetCurrentContext();
+ const __GLXattribute * const state = gc->client_state_private;
+ Display * const dpy = gc->currentDpy;
+ const GLuint cmdlen = 16;
+ if (__builtin_expect(dpy != NULL, 1)) {
+#ifdef USE_XCB
+ XCBConnection *c = XCBConnectionOfDisplay(dpy);
+ (void) __glXFlushRenderBuffer(gc, gc->pc);
+ XCBGlxGetColorTableRep *reply = XCBGlxGetColorTableReply(c, XCBGlxGetColorTable(c, gc->currentContextTag, target, format, type, state->storePack.swapEndian), NULL);
+ (void)memcpy(table, XCBGlxGetColorTableData(reply), XCBGlxGetColorTableDataLength(reply) * sizeof(GLvoid));
+ free(reply);
+#else
+ GLubyte const * pc = __glXSetupSingleRequest(gc, X_GLsop_GetColorTable, cmdlen);
+ (void) memcpy((void *)(pc + 0), (void *)(&target), 4);
+ (void) memcpy((void *)(pc + 4), (void *)(&format), 4);
+ (void) memcpy((void *)(pc + 8), (void *)(&type), 4);
+ *(int32_t *)(pc + 12) = 0;
+ * (int8_t *)(pc + 12) = state->storePack.swapEndian;
+ __glXReadPixelReply(dpy, gc, 1, 0, 0, 0, format, type, table, GL_TRUE);
+ UnlockDisplay(dpy); SyncHandle();
+#endif /* USE_XCB */
+ }
+ return;
+}
+
#define X_GLsop_GetColorTableParameterfv 148
void
__indirect_glGetColorTableParameterfv(GLenum target, GLenum pname, GLfloat * params)
Display * const dpy = gc->currentDpy;
const GLuint cmdlen = 8;
if (__builtin_expect(dpy != NULL, 1)) {
- GLubyte const * pc = setup_single_request(gc, X_GLsop_GetColorTableParameterfv, cmdlen);
+#ifdef USE_XCB
+ XCBConnection *c = XCBConnectionOfDisplay(dpy);
+ (void) __glXFlushRenderBuffer(gc, gc->pc);
+ XCBGlxGetColorTableParameterfvRep *reply = XCBGlxGetColorTableParameterfvReply(c, XCBGlxGetColorTableParameterfv(c, gc->currentContextTag, target, pname), NULL);
+ if (XCBGlxGetColorTableParameterfvDataLength(reply) == 0)
+ (void)memcpy(params, &reply->datum, sizeof(reply->datum));
+ else
+ (void)memcpy(params, XCBGlxGetColorTableParameterfvData(reply), XCBGlxGetColorTableParameterfvDataLength(reply) * sizeof(GLfloat));
+ free(reply);
+#else
+ GLubyte const * pc = __glXSetupSingleRequest(gc, X_GLsop_GetColorTableParameterfv, cmdlen);
(void) memcpy((void *)(pc + 0), (void *)(&target), 4);
(void) memcpy((void *)(pc + 4), (void *)(&pname), 4);
- (void) read_reply(dpy, 4, params, GL_FALSE);
+ (void) __glXReadReply(dpy, 4, params, GL_FALSE);
UnlockDisplay(dpy); SyncHandle();
+#endif /* USE_XCB */
}
return;
}
Display * const dpy = gc->currentDpy;
const GLuint cmdlen = 8;
if (__builtin_expect(dpy != NULL, 1)) {
- GLubyte const * pc = setup_single_request(gc, X_GLsop_GetColorTableParameteriv, cmdlen);
+#ifdef USE_XCB
+ XCBConnection *c = XCBConnectionOfDisplay(dpy);
+ (void) __glXFlushRenderBuffer(gc, gc->pc);
+ XCBGlxGetColorTableParameterivRep *reply = XCBGlxGetColorTableParameterivReply(c, XCBGlxGetColorTableParameteriv(c, gc->currentContextTag, target, pname), NULL);
+ if (XCBGlxGetColorTableParameterivDataLength(reply) == 0)
+ (void)memcpy(params, &reply->datum, sizeof(reply->datum));
+ else
+ (void)memcpy(params, XCBGlxGetColorTableParameterivData(reply), XCBGlxGetColorTableParameterivDataLength(reply) * sizeof(GLint));
+ free(reply);
+#else
+ GLubyte const * pc = __glXSetupSingleRequest(gc, X_GLsop_GetColorTableParameteriv, cmdlen);
(void) memcpy((void *)(pc + 0), (void *)(&target), 4);
(void) memcpy((void *)(pc + 4), (void *)(&pname), 4);
- (void) read_reply(dpy, 4, params, GL_FALSE);
+ (void) __glXReadReply(dpy, 4, params, GL_FALSE);
UnlockDisplay(dpy); SyncHandle();
+#endif /* USE_XCB */
}
return;
}
+#define X_GLrop_ColorSubTable 195
+void
+__indirect_glColorSubTable(GLenum target, GLsizei start, GLsizei count, GLenum format, GLenum type, const GLvoid * data)
+{
+ __GLXcontext * const gc = __glXGetCurrentContext();
+ const GLuint compsize = (data != NULL) ? __glImageSize(count, 1, 1, format, type, target) : 0;
+ const GLuint cmdlen = 44 + __GLX_PAD(compsize);
+ if (__builtin_expect(gc->currentDpy != NULL, 1)) {
+ if (cmdlen <= gc->maxSmallRenderCommandSize) {
+ if ( (gc->pc + cmdlen) > gc->bufEnd ) {
+ (void) __glXFlushRenderBuffer(gc, gc->pc);
+ }
+ emit_header(gc->pc, X_GLrop_ColorSubTable, cmdlen);
+ (void) memcpy((void *)(gc->pc + 24), (void *)(&target), 4);
+ (void) memcpy((void *)(gc->pc + 28), (void *)(&start), 4);
+ (void) memcpy((void *)(gc->pc + 32), (void *)(&count), 4);
+ (void) memcpy((void *)(gc->pc + 36), (void *)(&format), 4);
+ (void) memcpy((void *)(gc->pc + 40), (void *)(&type), 4);
+ if (compsize > 0) {
+ (*gc->fillImage)(gc, 1, count, 1, 1, format, type, data, gc->pc + 44, gc->pc + 4);
+ }
+ else {
+ (void) memcpy( gc->pc + 4, default_pixel_store_1D, default_pixel_store_1D_size );
+ }
+ gc->pc += cmdlen;
+ if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+ }
+ else {
+ const GLint op = X_GLrop_ColorSubTable;
+ const GLuint cmdlenLarge = cmdlen + 4;
+ GLubyte * const pc = __glXFlushRenderBuffer(gc, gc->pc);
+ (void) memcpy((void *)(pc + 0), (void *)(&cmdlenLarge), 4);
+ (void) memcpy((void *)(pc + 4), (void *)(&op), 4);
+ (void) memcpy((void *)(pc + 28), (void *)(&target), 4);
+ (void) memcpy((void *)(pc + 32), (void *)(&start), 4);
+ (void) memcpy((void *)(pc + 36), (void *)(&count), 4);
+ (void) memcpy((void *)(pc + 40), (void *)(&format), 4);
+ (void) memcpy((void *)(pc + 44), (void *)(&type), 4);
+ __glXSendLargeImage(gc, compsize, 1, count, 1, 1, format, type, data, pc + 48, pc + 8);
+ }
+ }
+}
+
#define X_GLrop_CopyColorSubTable 196
void
__indirect_glCopyColorSubTable(GLenum target, GLsizei start, GLint x, GLint y, GLsizei width)
if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
}
+static void
+__glx_ConvolutionFilter_1D2D( unsigned opcode, unsigned dim, GLenum target, GLenum internalformat, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid * image )
+{
+ __GLXcontext * const gc = __glXGetCurrentContext();
+ const GLuint compsize = (image != NULL) ? __glImageSize(width, height, 1, format, type, target) : 0;
+ const GLuint cmdlen = 48 + __GLX_PAD(compsize);
+ if (__builtin_expect(gc->currentDpy != NULL, 1)) {
+ if (cmdlen <= gc->maxSmallRenderCommandSize) {
+ if ( (gc->pc + cmdlen) > gc->bufEnd ) {
+ (void) __glXFlushRenderBuffer(gc, gc->pc);
+ }
+ emit_header(gc->pc, opcode, cmdlen);
+ (void) memcpy((void *)(gc->pc + 24), (void *)(&target), 4);
+ (void) memcpy((void *)(gc->pc + 28), (void *)(&internalformat), 4);
+ (void) memcpy((void *)(gc->pc + 32), (void *)(&width), 4);
+ (void) memcpy((void *)(gc->pc + 36), (void *)(&height), 4);
+ (void) memcpy((void *)(gc->pc + 40), (void *)(&format), 4);
+ (void) memcpy((void *)(gc->pc + 44), (void *)(&type), 4);
+ if (compsize > 0) {
+ (*gc->fillImage)(gc, dim, width, height, 1, format, type, image, gc->pc + 48, gc->pc + 4);
+ }
+ else {
+ (void) memcpy( gc->pc + 4, default_pixel_store_2D, default_pixel_store_2D_size );
+ }
+ gc->pc += cmdlen;
+ if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+ }
+ else {
+ const GLint op = opcode;
+ const GLuint cmdlenLarge = cmdlen + 4;
+ GLubyte * const pc = __glXFlushRenderBuffer(gc, gc->pc);
+ (void) memcpy((void *)(pc + 0), (void *)(&cmdlenLarge), 4);
+ (void) memcpy((void *)(pc + 4), (void *)(&op), 4);
+ (void) memcpy((void *)(pc + 28), (void *)(&target), 4);
+ (void) memcpy((void *)(pc + 32), (void *)(&internalformat), 4);
+ (void) memcpy((void *)(pc + 36), (void *)(&width), 4);
+ (void) memcpy((void *)(pc + 40), (void *)(&height), 4);
+ (void) memcpy((void *)(pc + 44), (void *)(&format), 4);
+ (void) memcpy((void *)(pc + 48), (void *)(&type), 4);
+ __glXSendLargeImage(gc, compsize, dim, width, height, 1, format, type, image, pc + 52, pc + 8);
+ }
+ }
+}
+
+#define X_GLrop_ConvolutionFilter1D 4101
+void
+__indirect_glConvolutionFilter1D(GLenum target, GLenum internalformat, GLsizei width, GLenum format, GLenum type, const GLvoid * image)
+{
+ __glx_ConvolutionFilter_1D2D(X_GLrop_ConvolutionFilter1D, 1, target, internalformat, width, 1, format, type, image );
+}
+
+#define X_GLrop_ConvolutionFilter2D 4102
+void
+__indirect_glConvolutionFilter2D(GLenum target, GLenum internalformat, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid * image)
+{
+ __glx_ConvolutionFilter_1D2D(X_GLrop_ConvolutionFilter2D, 2, target, internalformat, width, height, format, type, image );
+}
+
#define X_GLrop_ConvolutionParameterf 4103
void
__indirect_glConvolutionParameterf(GLenum target, GLenum pname, GLfloat params)
if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
}
-#define X_GLsop_GetConvolutionParameterfv 151
+#define X_GLsop_GetConvolutionFilter 150
void
-__indirect_glGetConvolutionParameterfv(GLenum target, GLenum pname, GLfloat * params)
+__indirect_glGetConvolutionFilter(GLenum target, GLenum format, GLenum type, GLvoid * image)
{
__GLXcontext * const gc = __glXGetCurrentContext();
+ const __GLXattribute * const state = gc->client_state_private;
Display * const dpy = gc->currentDpy;
- const GLuint cmdlen = 8;
+ const GLuint cmdlen = 16;
if (__builtin_expect(dpy != NULL, 1)) {
- GLubyte const * pc = setup_single_request(gc, X_GLsop_GetConvolutionParameterfv, cmdlen);
+#ifdef USE_XCB
+ XCBConnection *c = XCBConnectionOfDisplay(dpy);
+ (void) __glXFlushRenderBuffer(gc, gc->pc);
+ XCBGlxGetConvolutionFilterRep *reply = XCBGlxGetConvolutionFilterReply(c, XCBGlxGetConvolutionFilter(c, gc->currentContextTag, target, format, type, state->storePack.swapEndian), NULL);
+ (void)memcpy(image, XCBGlxGetConvolutionFilterData(reply), XCBGlxGetConvolutionFilterDataLength(reply) * sizeof(GLvoid));
+ free(reply);
+#else
+ GLubyte const * pc = __glXSetupSingleRequest(gc, X_GLsop_GetConvolutionFilter, cmdlen);
(void) memcpy((void *)(pc + 0), (void *)(&target), 4);
- (void) memcpy((void *)(pc + 4), (void *)(&pname), 4);
- (void) read_reply(dpy, 4, params, GL_FALSE);
+ (void) memcpy((void *)(pc + 4), (void *)(&format), 4);
+ (void) memcpy((void *)(pc + 8), (void *)(&type), 4);
+ *(int32_t *)(pc + 12) = 0;
+ * (int8_t *)(pc + 12) = state->storePack.swapEndian;
+ __glXReadPixelReply(dpy, gc, 2, 0, 0, 0, format, type, image, GL_TRUE);
UnlockDisplay(dpy); SyncHandle();
+#endif /* USE_XCB */
}
return;
}
-#define X_GLsop_GetConvolutionParameteriv 152
+#define X_GLsop_GetConvolutionParameterfv 151
void
-__indirect_glGetConvolutionParameteriv(GLenum target, GLenum pname, GLint * params)
+__indirect_glGetConvolutionParameterfv(GLenum target, GLenum pname, GLfloat * params)
{
__GLXcontext * const gc = __glXGetCurrentContext();
Display * const dpy = gc->currentDpy;
const GLuint cmdlen = 8;
if (__builtin_expect(dpy != NULL, 1)) {
- GLubyte const * pc = setup_single_request(gc, X_GLsop_GetConvolutionParameteriv, cmdlen);
+#ifdef USE_XCB
+ XCBConnection *c = XCBConnectionOfDisplay(dpy);
+ (void) __glXFlushRenderBuffer(gc, gc->pc);
+ XCBGlxGetConvolutionParameterfvRep *reply = XCBGlxGetConvolutionParameterfvReply(c, XCBGlxGetConvolutionParameterfv(c, gc->currentContextTag, target, pname), NULL);
+ if (XCBGlxGetConvolutionParameterfvDataLength(reply) == 0)
+ (void)memcpy(params, &reply->datum, sizeof(reply->datum));
+ else
+ (void)memcpy(params, XCBGlxGetConvolutionParameterfvData(reply), XCBGlxGetConvolutionParameterfvDataLength(reply) * sizeof(GLfloat));
+ free(reply);
+#else
+ GLubyte const * pc = __glXSetupSingleRequest(gc, X_GLsop_GetConvolutionParameterfv, cmdlen);
(void) memcpy((void *)(pc + 0), (void *)(&target), 4);
(void) memcpy((void *)(pc + 4), (void *)(&pname), 4);
- (void) read_reply(dpy, 4, params, GL_FALSE);
+ (void) __glXReadReply(dpy, 4, params, GL_FALSE);
UnlockDisplay(dpy); SyncHandle();
+#endif /* USE_XCB */
}
return;
}
-#define X_GLsop_GetHistogramParameterfv 155
+#define X_GLsop_GetConvolutionParameteriv 152
void
-__indirect_glGetHistogramParameterfv(GLenum target, GLenum pname, GLfloat * params)
+__indirect_glGetConvolutionParameteriv(GLenum target, GLenum pname, GLint * params)
{
__GLXcontext * const gc = __glXGetCurrentContext();
Display * const dpy = gc->currentDpy;
const GLuint cmdlen = 8;
if (__builtin_expect(dpy != NULL, 1)) {
- GLubyte const * pc = setup_single_request(gc, X_GLsop_GetHistogramParameterfv, cmdlen);
+#ifdef USE_XCB
+ XCBConnection *c = XCBConnectionOfDisplay(dpy);
+ (void) __glXFlushRenderBuffer(gc, gc->pc);
+ XCBGlxGetConvolutionParameterivRep *reply = XCBGlxGetConvolutionParameterivReply(c, XCBGlxGetConvolutionParameteriv(c, gc->currentContextTag, target, pname), NULL);
+ if (XCBGlxGetConvolutionParameterivDataLength(reply) == 0)
+ (void)memcpy(params, &reply->datum, sizeof(reply->datum));
+ else
+ (void)memcpy(params, XCBGlxGetConvolutionParameterivData(reply), XCBGlxGetConvolutionParameterivDataLength(reply) * sizeof(GLint));
+ free(reply);
+#else
+ GLubyte const * pc = __glXSetupSingleRequest(gc, X_GLsop_GetConvolutionParameteriv, cmdlen);
(void) memcpy((void *)(pc + 0), (void *)(&target), 4);
(void) memcpy((void *)(pc + 4), (void *)(&pname), 4);
- (void) read_reply(dpy, 4, params, GL_FALSE);
+ (void) __glXReadReply(dpy, 4, params, GL_FALSE);
UnlockDisplay(dpy); SyncHandle();
+#endif /* USE_XCB */
}
return;
}
-#define X_GLsop_GetHistogramParameteriv 156
+#define X_GLsop_GetHistogram 154
void
-__indirect_glGetHistogramParameteriv(GLenum target, GLenum pname, GLint * params)
+__indirect_glGetHistogram(GLenum target, GLboolean reset, GLenum format, GLenum type, GLvoid * values)
{
__GLXcontext * const gc = __glXGetCurrentContext();
+ const __GLXattribute * const state = gc->client_state_private;
Display * const dpy = gc->currentDpy;
- const GLuint cmdlen = 8;
+ const GLuint cmdlen = 16;
+ if (__builtin_expect(dpy != NULL, 1)) {
+#ifdef USE_XCB
+ XCBConnection *c = XCBConnectionOfDisplay(dpy);
+ (void) __glXFlushRenderBuffer(gc, gc->pc);
+ XCBGlxGetHistogramRep *reply = XCBGlxGetHistogramReply(c, XCBGlxGetHistogram(c, gc->currentContextTag, target, reset, format, type, state->storePack.swapEndian), NULL);
+ (void)memcpy(values, XCBGlxGetHistogramData(reply), XCBGlxGetHistogramDataLength(reply) * sizeof(GLvoid));
+ free(reply);
+#else
+ GLubyte const * pc = __glXSetupSingleRequest(gc, X_GLsop_GetHistogram, cmdlen);
+ (void) memcpy((void *)(pc + 0), (void *)(&target), 4);
+ (void) memcpy((void *)(pc + 4), (void *)(&format), 4);
+ (void) memcpy((void *)(pc + 8), (void *)(&type), 4);
+ *(int32_t *)(pc + 12) = 0;
+ * (int8_t *)(pc + 12) = state->storePack.swapEndian;
+ * (int8_t *)(pc + 13) = reset;
+ __glXReadPixelReply(dpy, gc, 1, 0, 0, 0, format, type, values, GL_TRUE);
+ UnlockDisplay(dpy); SyncHandle();
+#endif /* USE_XCB */
+ }
+ return;
+}
+
+#define X_GLsop_GetHistogramParameterfv 155
+void
+__indirect_glGetHistogramParameterfv(GLenum target, GLenum pname, GLfloat * params)
+{
+ __GLXcontext * const gc = __glXGetCurrentContext();
+ Display * const dpy = gc->currentDpy;
+ const GLuint cmdlen = 8;
+ if (__builtin_expect(dpy != NULL, 1)) {
+#ifdef USE_XCB
+ XCBConnection *c = XCBConnectionOfDisplay(dpy);
+ (void) __glXFlushRenderBuffer(gc, gc->pc);
+ XCBGlxGetHistogramParameterfvRep *reply = XCBGlxGetHistogramParameterfvReply(c, XCBGlxGetHistogramParameterfv(c, gc->currentContextTag, target, pname), NULL);
+ if (XCBGlxGetHistogramParameterfvDataLength(reply) == 0)
+ (void)memcpy(params, &reply->datum, sizeof(reply->datum));
+ else
+ (void)memcpy(params, XCBGlxGetHistogramParameterfvData(reply), XCBGlxGetHistogramParameterfvDataLength(reply) * sizeof(GLfloat));
+ free(reply);
+#else
+ GLubyte const * pc = __glXSetupSingleRequest(gc, X_GLsop_GetHistogramParameterfv, cmdlen);
+ (void) memcpy((void *)(pc + 0), (void *)(&target), 4);
+ (void) memcpy((void *)(pc + 4), (void *)(&pname), 4);
+ (void) __glXReadReply(dpy, 4, params, GL_FALSE);
+ UnlockDisplay(dpy); SyncHandle();
+#endif /* USE_XCB */
+ }
+ return;
+}
+
+#define X_GLsop_GetHistogramParameteriv 156
+void
+__indirect_glGetHistogramParameteriv(GLenum target, GLenum pname, GLint * params)
+{
+ __GLXcontext * const gc = __glXGetCurrentContext();
+ Display * const dpy = gc->currentDpy;
+ const GLuint cmdlen = 8;
if (__builtin_expect(dpy != NULL, 1)) {
- GLubyte const * pc = setup_single_request(gc, X_GLsop_GetHistogramParameteriv, cmdlen);
+#ifdef USE_XCB
+ XCBConnection *c = XCBConnectionOfDisplay(dpy);
+ (void) __glXFlushRenderBuffer(gc, gc->pc);
+ XCBGlxGetHistogramParameterivRep *reply = XCBGlxGetHistogramParameterivReply(c, XCBGlxGetHistogramParameteriv(c, gc->currentContextTag, target, pname), NULL);
+ if (XCBGlxGetHistogramParameterivDataLength(reply) == 0)
+ (void)memcpy(params, &reply->datum, sizeof(reply->datum));
+ else
+ (void)memcpy(params, XCBGlxGetHistogramParameterivData(reply), XCBGlxGetHistogramParameterivDataLength(reply) * sizeof(GLint));
+ free(reply);
+#else
+ GLubyte const * pc = __glXSetupSingleRequest(gc, X_GLsop_GetHistogramParameteriv, cmdlen);
(void) memcpy((void *)(pc + 0), (void *)(&target), 4);
(void) memcpy((void *)(pc + 4), (void *)(&pname), 4);
- (void) read_reply(dpy, 4, params, GL_FALSE);
+ (void) __glXReadReply(dpy, 4, params, GL_FALSE);
+ UnlockDisplay(dpy); SyncHandle();
+#endif /* USE_XCB */
+ }
+ return;
+}
+
+#define X_GLsop_GetMinmax 157
+void
+__indirect_glGetMinmax(GLenum target, GLboolean reset, GLenum format, GLenum type, GLvoid * values)
+{
+ __GLXcontext * const gc = __glXGetCurrentContext();
+ const __GLXattribute * const state = gc->client_state_private;
+ Display * const dpy = gc->currentDpy;
+ const GLuint cmdlen = 16;
+ if (__builtin_expect(dpy != NULL, 1)) {
+#ifdef USE_XCB
+ XCBConnection *c = XCBConnectionOfDisplay(dpy);
+ (void) __glXFlushRenderBuffer(gc, gc->pc);
+ XCBGlxGetMinmaxRep *reply = XCBGlxGetMinmaxReply(c, XCBGlxGetMinmax(c, gc->currentContextTag, target, reset, format, type, state->storePack.swapEndian), NULL);
+ (void)memcpy(values, XCBGlxGetMinmaxData(reply), XCBGlxGetMinmaxDataLength(reply) * sizeof(GLvoid));
+ free(reply);
+#else
+ GLubyte const * pc = __glXSetupSingleRequest(gc, X_GLsop_GetMinmax, cmdlen);
+ (void) memcpy((void *)(pc + 0), (void *)(&target), 4);
+ (void) memcpy((void *)(pc + 4), (void *)(&format), 4);
+ (void) memcpy((void *)(pc + 8), (void *)(&type), 4);
+ *(int32_t *)(pc + 12) = 0;
+ * (int8_t *)(pc + 12) = state->storePack.swapEndian;
+ * (int8_t *)(pc + 13) = reset;
+ __glXReadPixelReply(dpy, gc, 1, 2, 1, 1, format, type, values, GL_FALSE);
UnlockDisplay(dpy); SyncHandle();
+#endif /* USE_XCB */
}
return;
}
Display * const dpy = gc->currentDpy;
const GLuint cmdlen = 8;
if (__builtin_expect(dpy != NULL, 1)) {
- GLubyte const * pc = setup_single_request(gc, X_GLsop_GetMinmaxParameterfv, cmdlen);
+#ifdef USE_XCB
+ XCBConnection *c = XCBConnectionOfDisplay(dpy);
+ (void) __glXFlushRenderBuffer(gc, gc->pc);
+ XCBGlxGetMinmaxParameterfvRep *reply = XCBGlxGetMinmaxParameterfvReply(c, XCBGlxGetMinmaxParameterfv(c, gc->currentContextTag, target, pname), NULL);
+ if (XCBGlxGetMinmaxParameterfvDataLength(reply) == 0)
+ (void)memcpy(params, &reply->datum, sizeof(reply->datum));
+ else
+ (void)memcpy(params, XCBGlxGetMinmaxParameterfvData(reply), XCBGlxGetMinmaxParameterfvDataLength(reply) * sizeof(GLfloat));
+ free(reply);
+#else
+ GLubyte const * pc = __glXSetupSingleRequest(gc, X_GLsop_GetMinmaxParameterfv, cmdlen);
(void) memcpy((void *)(pc + 0), (void *)(&target), 4);
(void) memcpy((void *)(pc + 4), (void *)(&pname), 4);
- (void) read_reply(dpy, 4, params, GL_FALSE);
+ (void) __glXReadReply(dpy, 4, params, GL_FALSE);
UnlockDisplay(dpy); SyncHandle();
+#endif /* USE_XCB */
}
return;
}
Display * const dpy = gc->currentDpy;
const GLuint cmdlen = 8;
if (__builtin_expect(dpy != NULL, 1)) {
- GLubyte const * pc = setup_single_request(gc, X_GLsop_GetMinmaxParameteriv, cmdlen);
+#ifdef USE_XCB
+ XCBConnection *c = XCBConnectionOfDisplay(dpy);
+ (void) __glXFlushRenderBuffer(gc, gc->pc);
+ XCBGlxGetMinmaxParameterivRep *reply = XCBGlxGetMinmaxParameterivReply(c, XCBGlxGetMinmaxParameteriv(c, gc->currentContextTag, target, pname), NULL);
+ if (XCBGlxGetMinmaxParameterivDataLength(reply) == 0)
+ (void)memcpy(params, &reply->datum, sizeof(reply->datum));
+ else
+ (void)memcpy(params, XCBGlxGetMinmaxParameterivData(reply), XCBGlxGetMinmaxParameterivDataLength(reply) * sizeof(GLint));
+ free(reply);
+#else
+ GLubyte const * pc = __glXSetupSingleRequest(gc, X_GLsop_GetMinmaxParameteriv, cmdlen);
(void) memcpy((void *)(pc + 0), (void *)(&target), 4);
(void) memcpy((void *)(pc + 4), (void *)(&pname), 4);
- (void) read_reply(dpy, 4, params, GL_FALSE);
+ (void) __glXReadReply(dpy, 4, params, GL_FALSE);
UnlockDisplay(dpy); SyncHandle();
+#endif /* USE_XCB */
}
return;
}
if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
}
+static void
+__glx_TexImage_3D4D( unsigned opcode, unsigned dim, GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLsizei depth, GLsizei extent, GLint border, GLenum format, GLenum type, const GLvoid * pixels )
+{
+ __GLXcontext * const gc = __glXGetCurrentContext();
+ const GLuint compsize = (pixels != NULL) ? __glImageSize(width, height, depth, format, type, target) : 0;
+ const GLuint cmdlen = 84 + __GLX_PAD(compsize);
+ if (__builtin_expect(gc->currentDpy != NULL, 1)) {
+ if (cmdlen <= gc->maxSmallRenderCommandSize) {
+ if ( (gc->pc + cmdlen) > gc->bufEnd ) {
+ (void) __glXFlushRenderBuffer(gc, gc->pc);
+ }
+ emit_header(gc->pc, opcode, cmdlen);
+ (void) memcpy((void *)(gc->pc + 40), (void *)(&target), 4);
+ (void) memcpy((void *)(gc->pc + 44), (void *)(&level), 4);
+ (void) memcpy((void *)(gc->pc + 48), (void *)(&internalformat), 4);
+ (void) memcpy((void *)(gc->pc + 52), (void *)(&width), 4);
+ (void) memcpy((void *)(gc->pc + 56), (void *)(&height), 4);
+ (void) memcpy((void *)(gc->pc + 60), (void *)(&depth), 4);
+ (void) memcpy((void *)(gc->pc + 64), (void *)(&extent), 4);
+ (void) memcpy((void *)(gc->pc + 68), (void *)(&border), 4);
+ (void) memcpy((void *)(gc->pc + 72), (void *)(&format), 4);
+ (void) memcpy((void *)(gc->pc + 76), (void *)(&type), 4);
+ (void) memcpy((void *)(gc->pc + 80), (void *)((pixels == NULL) ? one : zero), 4);
+ if (compsize > 0) {
+ (*gc->fillImage)(gc, dim, width, height, depth, format, type, pixels, gc->pc + 84, gc->pc + 4);
+ }
+ else {
+ (void) memcpy( gc->pc + 4, default_pixel_store_4D, default_pixel_store_4D_size );
+ }
+ gc->pc += cmdlen;
+ if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+ }
+ else {
+ const GLint op = opcode;
+ const GLuint cmdlenLarge = cmdlen + 4;
+ GLubyte * const pc = __glXFlushRenderBuffer(gc, gc->pc);
+ (void) memcpy((void *)(pc + 0), (void *)(&cmdlenLarge), 4);
+ (void) memcpy((void *)(pc + 4), (void *)(&op), 4);
+ (void) memcpy((void *)(pc + 44), (void *)(&target), 4);
+ (void) memcpy((void *)(pc + 48), (void *)(&level), 4);
+ (void) memcpy((void *)(pc + 52), (void *)(&internalformat), 4);
+ (void) memcpy((void *)(pc + 56), (void *)(&width), 4);
+ (void) memcpy((void *)(pc + 60), (void *)(&height), 4);
+ (void) memcpy((void *)(pc + 64), (void *)(&depth), 4);
+ (void) memcpy((void *)(pc + 68), (void *)(&extent), 4);
+ (void) memcpy((void *)(pc + 72), (void *)(&border), 4);
+ (void) memcpy((void *)(pc + 76), (void *)(&format), 4);
+ (void) memcpy((void *)(pc + 80), (void *)(&type), 4);
+ (void) memcpy((void *)(pc + 84), zero, 4);
+ __glXSendLargeImage(gc, compsize, dim, width, height, depth, format, type, pixels, pc + 88, pc + 8);
+ }
+ }
+}
+
+#define X_GLrop_TexImage3D 4114
+void
+__indirect_glTexImage3D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const GLvoid * pixels)
+{
+ __glx_TexImage_3D4D(X_GLrop_TexImage3D, 3, target, level, internalformat, width, height, depth, 1, border, format, type, pixels );
+}
+
+static void
+__glx_TexSubImage_3D4D( unsigned opcode, unsigned dim, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint woffset, GLsizei width, GLsizei height, GLsizei depth, GLsizei extent, GLenum format, GLenum type, const GLvoid * pixels )
+{
+ __GLXcontext * const gc = __glXGetCurrentContext();
+ const GLuint compsize = (pixels != NULL) ? __glImageSize(width, height, depth, format, type, target) : 0;
+ const GLuint cmdlen = 92 + __GLX_PAD(compsize);
+ if (__builtin_expect(gc->currentDpy != NULL, 1)) {
+ if (cmdlen <= gc->maxSmallRenderCommandSize) {
+ if ( (gc->pc + cmdlen) > gc->bufEnd ) {
+ (void) __glXFlushRenderBuffer(gc, gc->pc);
+ }
+ emit_header(gc->pc, opcode, cmdlen);
+ (void) memcpy((void *)(gc->pc + 40), (void *)(&target), 4);
+ (void) memcpy((void *)(gc->pc + 44), (void *)(&level), 4);
+ (void) memcpy((void *)(gc->pc + 48), (void *)(&xoffset), 4);
+ (void) memcpy((void *)(gc->pc + 52), (void *)(&yoffset), 4);
+ (void) memcpy((void *)(gc->pc + 56), (void *)(&zoffset), 4);
+ (void) memcpy((void *)(gc->pc + 60), (void *)(&woffset), 4);
+ (void) memcpy((void *)(gc->pc + 64), (void *)(&width), 4);
+ (void) memcpy((void *)(gc->pc + 68), (void *)(&height), 4);
+ (void) memcpy((void *)(gc->pc + 72), (void *)(&depth), 4);
+ (void) memcpy((void *)(gc->pc + 76), (void *)(&extent), 4);
+ (void) memcpy((void *)(gc->pc + 80), (void *)(&format), 4);
+ (void) memcpy((void *)(gc->pc + 84), (void *)(&type), 4);
+ (void) memcpy((void *)(gc->pc + 88), (void *)((pixels == NULL) ? one : zero), 4);
+ if (compsize > 0) {
+ (*gc->fillImage)(gc, dim, width, height, depth, format, type, pixels, gc->pc + 92, gc->pc + 4);
+ }
+ else {
+ (void) memcpy( gc->pc + 4, default_pixel_store_4D, default_pixel_store_4D_size );
+ }
+ gc->pc += cmdlen;
+ if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+ }
+ else {
+ const GLint op = opcode;
+ const GLuint cmdlenLarge = cmdlen + 4;
+ GLubyte * const pc = __glXFlushRenderBuffer(gc, gc->pc);
+ (void) memcpy((void *)(pc + 0), (void *)(&cmdlenLarge), 4);
+ (void) memcpy((void *)(pc + 4), (void *)(&op), 4);
+ (void) memcpy((void *)(pc + 44), (void *)(&target), 4);
+ (void) memcpy((void *)(pc + 48), (void *)(&level), 4);
+ (void) memcpy((void *)(pc + 52), (void *)(&xoffset), 4);
+ (void) memcpy((void *)(pc + 56), (void *)(&yoffset), 4);
+ (void) memcpy((void *)(pc + 60), (void *)(&zoffset), 4);
+ (void) memcpy((void *)(pc + 64), (void *)(&woffset), 4);
+ (void) memcpy((void *)(pc + 68), (void *)(&width), 4);
+ (void) memcpy((void *)(pc + 72), (void *)(&height), 4);
+ (void) memcpy((void *)(pc + 76), (void *)(&depth), 4);
+ (void) memcpy((void *)(pc + 80), (void *)(&extent), 4);
+ (void) memcpy((void *)(pc + 84), (void *)(&format), 4);
+ (void) memcpy((void *)(pc + 88), (void *)(&type), 4);
+ (void) memcpy((void *)(pc + 92), zero, 4);
+ __glXSendLargeImage(gc, compsize, dim, width, height, depth, format, type, pixels, pc + 96, pc + 8);
+ }
+ }
+}
+
+#define X_GLrop_TexSubImage3D 4115
+void
+__indirect_glTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const GLvoid * pixels)
+{
+ __glx_TexSubImage_3D4D(X_GLrop_TexSubImage3D, 3, target, level, xoffset, yoffset, zoffset, 1, width, height, depth, 1, format, type, pixels );
+}
+
#define X_GLrop_CopyTexSubImage3D 4123
void
__indirect_glCopyTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height)
if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
}
+#define X_GLrop_DrawBuffersARB 233
+void
+__indirect_glDrawBuffersARB(GLsizei n, const GLenum * bufs)
+{
+ __GLXcontext * const gc = __glXGetCurrentContext();
+ const GLuint cmdlen = 8 + __GLX_PAD((n * 4));
+ if (__builtin_expect((n >= 0) && (gc->currentDpy != NULL), 1)) {
+ if (cmdlen <= gc->maxSmallRenderCommandSize) {
+ if ( (gc->pc + cmdlen) > gc->bufEnd ) {
+ (void) __glXFlushRenderBuffer(gc, gc->pc);
+ }
+ emit_header(gc->pc, X_GLrop_DrawBuffersARB, cmdlen);
+ (void) memcpy((void *)(gc->pc + 4), (void *)(&n), 4);
+ (void) memcpy((void *)(gc->pc + 8), (void *)(bufs), (n * 4));
+ gc->pc += cmdlen;
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+ }
+ else {
+ const GLint op = X_GLrop_DrawBuffersARB;
+ const GLuint cmdlenLarge = cmdlen + 4;
+ GLubyte * const pc = __glXFlushRenderBuffer(gc, gc->pc);
+ (void) memcpy((void *)(pc + 0), (void *)(&cmdlenLarge), 4);
+ (void) memcpy((void *)(pc + 4), (void *)(&op), 4);
+ (void) memcpy((void *)(pc + 8), (void *)(&n), 4);
+ __glXSendLargeCommand(gc, pc, 12, bufs, (n * 4));
+ }
+ }
+}
+
#define X_GLvop_AreTexturesResidentEXT 11
GLboolean
__indirect_glAreTexturesResidentEXT(GLsizei n, const GLuint * textures, GLboolean * residences)
GLboolean retval = (GLboolean) 0;
const GLuint cmdlen = 4 + __GLX_PAD((n * 4));
if (__builtin_expect((n >= 0) && (dpy != NULL), 1)) {
- GLubyte const * pc = setup_vendor_request(gc, X_GLXVendorPrivateWithReply, X_GLvop_AreTexturesResidentEXT, cmdlen);
+ GLubyte const * pc = __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithReply, X_GLvop_AreTexturesResidentEXT, cmdlen);
(void) memcpy((void *)(pc + 0), (void *)(&n), 4);
(void) memcpy((void *)(pc + 4), (void *)(textures), (n * 4));
- retval = (GLboolean) read_reply(dpy, 1, residences, GL_TRUE);
+ retval = (GLboolean) __glXReadReply(dpy, 1, residences, GL_TRUE);
UnlockDisplay(dpy); SyncHandle();
}
return retval;
__GLXcontext * const gc = __glXGetCurrentContext();
Display * const dpy = gc->currentDpy;
const GLuint cmdlen = 4;
- if (__builtin_expect(dpy != NULL, 1)) {
- GLubyte const * pc = setup_vendor_request(gc, X_GLXVendorPrivateWithReply, X_GLvop_GenTexturesEXT, cmdlen);
+ if (__builtin_expect((n >= 0) && (dpy != NULL), 1)) {
+ GLubyte const * pc = __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithReply, X_GLvop_GenTexturesEXT, cmdlen);
(void) memcpy((void *)(pc + 0), (void *)(&n), 4);
- (void) read_reply(dpy, 4, textures, GL_TRUE);
+ (void) __glXReadReply(dpy, 4, textures, GL_TRUE);
UnlockDisplay(dpy); SyncHandle();
}
return;
GLboolean retval = (GLboolean) 0;
const GLuint cmdlen = 4;
if (__builtin_expect(dpy != NULL, 1)) {
- GLubyte const * pc = setup_vendor_request(gc, X_GLXVendorPrivateWithReply, X_GLvop_IsTextureEXT, cmdlen);
+ GLubyte const * pc = __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithReply, X_GLvop_IsTextureEXT, cmdlen);
(void) memcpy((void *)(pc + 0), (void *)(&texture), 4);
- retval = (GLboolean) read_reply(dpy, 0, NULL, GL_FALSE);
+ retval = (GLboolean) __glXReadReply(dpy, 0, NULL, GL_FALSE);
UnlockDisplay(dpy); SyncHandle();
}
return retval;
generic_12_byte( X_GLrop_SecondaryColor3ivEXT, v );
}
-#define X_GLrop_SecondaryColor3svEXT 4128
+#define X_GLrop_SecondaryColor3svEXT 4127
void
__indirect_glSecondaryColor3sEXT(GLshort red, GLshort green, GLshort blue)
{
if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
}
-#define X_GLrop_SecondaryColor3svEXT 4128
+#define X_GLrop_SecondaryColor3svEXT 4127
void
__indirect_glSecondaryColor3svEXT(const GLshort * v)
{
generic_6_byte( X_GLrop_SecondaryColor3usvEXT, v );
}
-#define X_GLrop_PointParameteriNV 4221
+#define X_GLvop_AreProgramsResidentNV 1293
+GLboolean
+__indirect_glAreProgramsResidentNV(GLsizei n, const GLuint * ids, GLboolean * residences)
+{
+ __GLXcontext * const gc = __glXGetCurrentContext();
+ Display * const dpy = gc->currentDpy;
+ GLboolean retval = (GLboolean) 0;
+ const GLuint cmdlen = 4 + __GLX_PAD((n * 4));
+ if (__builtin_expect((n >= 0) && (dpy != NULL), 1)) {
+ GLubyte const * pc = __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithReply, X_GLvop_AreProgramsResidentNV, cmdlen);
+ (void) memcpy((void *)(pc + 0), (void *)(&n), 4);
+ (void) memcpy((void *)(pc + 4), (void *)(ids), (n * 4));
+ retval = (GLboolean) __glXReadReply(dpy, 1, residences, GL_FALSE);
+ UnlockDisplay(dpy); SyncHandle();
+ }
+ return retval;
+}
+
+#define X_GLrop_BindProgramNV 4180
void
-__indirect_glPointParameteriNV(GLenum pname, GLint params)
+__indirect_glBindProgramNV(GLenum target, GLuint program)
{
__GLXcontext * const gc = __glXGetCurrentContext();
const GLuint cmdlen = 12;
- emit_header(gc->pc, X_GLrop_PointParameteriNV, cmdlen);
- (void) memcpy((void *)(gc->pc + 4), (void *)(&pname), 4);
- (void) memcpy((void *)(gc->pc + 8), (void *)(¶ms), 4);
+ emit_header(gc->pc, X_GLrop_BindProgramNV, cmdlen);
+ (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
+ (void) memcpy((void *)(gc->pc + 8), (void *)(&program), 4);
gc->pc += cmdlen;
if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
}
-#define X_GLrop_PointParameterivNV 4222
+#define X_GLvop_DeleteProgramsNV 1294
void
-__indirect_glPointParameterivNV(GLenum pname, const GLint * params)
+__indirect_glDeleteProgramsNV(GLsizei n, const GLuint * programs)
{
__GLXcontext * const gc = __glXGetCurrentContext();
- const GLuint compsize = __glPointParameterivNV_size(pname);
- const GLuint cmdlen = 8 + __GLX_PAD((compsize * 4));
- emit_header(gc->pc, X_GLrop_PointParameterivNV, cmdlen);
- (void) memcpy((void *)(gc->pc + 4), (void *)(&pname), 4);
- (void) memcpy((void *)(gc->pc + 8), (void *)(params), (compsize * 4));
+ Display * const dpy = gc->currentDpy;
+ const GLuint cmdlen = 4 + __GLX_PAD((n * 4));
+ if (__builtin_expect((n >= 0) && (dpy != NULL), 1)) {
+ GLubyte const * pc = __glXSetupVendorRequest(gc, X_GLXVendorPrivate, X_GLvop_DeleteProgramsNV, cmdlen);
+ (void) memcpy((void *)(pc + 0), (void *)(&n), 4);
+ (void) memcpy((void *)(pc + 4), (void *)(programs), (n * 4));
+ UnlockDisplay(dpy); SyncHandle();
+ }
+ return;
+}
+
+#define X_GLrop_ExecuteProgramNV 4181
+void
+__indirect_glExecuteProgramNV(GLenum target, GLuint id, const GLfloat * params)
+{
+ __GLXcontext * const gc = __glXGetCurrentContext();
+ const GLuint cmdlen = 28;
+ emit_header(gc->pc, X_GLrop_ExecuteProgramNV, cmdlen);
+ (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
+ (void) memcpy((void *)(gc->pc + 8), (void *)(&id), 4);
+ (void) memcpy((void *)(gc->pc + 12), (void *)(params), 16);
gc->pc += cmdlen;
if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
}
-#define X_GLrop_ActiveStencilFaceEXT 4220
+#define X_GLvop_GenProgramsNV 1295
void
-__indirect_glActiveStencilFaceEXT(GLenum face)
+__indirect_glGenProgramsNV(GLsizei n, GLuint * programs)
+{
+ __GLXcontext * const gc = __glXGetCurrentContext();
+ Display * const dpy = gc->currentDpy;
+ const GLuint cmdlen = 4;
+ if (__builtin_expect((n >= 0) && (dpy != NULL), 1)) {
+ GLubyte const * pc = __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithReply, X_GLvop_GenProgramsNV, cmdlen);
+ (void) memcpy((void *)(pc + 0), (void *)(&n), 4);
+ (void) __glXReadReply(dpy, 4, programs, GL_FALSE);
+ UnlockDisplay(dpy); SyncHandle();
+ }
+ return;
+}
+
+#define X_GLvop_GetProgramParameterdvNV 1297
+void
+__indirect_glGetProgramParameterdvNV(GLenum target, GLuint index, GLenum pname, GLdouble * params)
+{
+ __GLXcontext * const gc = __glXGetCurrentContext();
+ Display * const dpy = gc->currentDpy;
+ const GLuint cmdlen = 12;
+ if (__builtin_expect(dpy != NULL, 1)) {
+ GLubyte const * pc = __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithReply, X_GLvop_GetProgramParameterdvNV, cmdlen);
+ (void) memcpy((void *)(pc + 0), (void *)(&target), 4);
+ (void) memcpy((void *)(pc + 4), (void *)(&index), 4);
+ (void) memcpy((void *)(pc + 8), (void *)(&pname), 4);
+ (void) __glXReadReply(dpy, 8, params, GL_FALSE);
+ UnlockDisplay(dpy); SyncHandle();
+ }
+ return;
+}
+
+#define X_GLvop_GetProgramParameterfvNV 1296
+void
+__indirect_glGetProgramParameterfvNV(GLenum target, GLuint index, GLenum pname, GLfloat * params)
+{
+ __GLXcontext * const gc = __glXGetCurrentContext();
+ Display * const dpy = gc->currentDpy;
+ const GLuint cmdlen = 12;
+ if (__builtin_expect(dpy != NULL, 1)) {
+ GLubyte const * pc = __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithReply, X_GLvop_GetProgramParameterfvNV, cmdlen);
+ (void) memcpy((void *)(pc + 0), (void *)(&target), 4);
+ (void) memcpy((void *)(pc + 4), (void *)(&index), 4);
+ (void) memcpy((void *)(pc + 8), (void *)(&pname), 4);
+ (void) __glXReadReply(dpy, 4, params, GL_FALSE);
+ UnlockDisplay(dpy); SyncHandle();
+ }
+ return;
+}
+
+#define X_GLvop_GetProgramivNV 1298
+void
+__indirect_glGetProgramivNV(GLuint id, GLenum pname, GLint * params)
{
__GLXcontext * const gc = __glXGetCurrentContext();
+ Display * const dpy = gc->currentDpy;
const GLuint cmdlen = 8;
- emit_header(gc->pc, X_GLrop_ActiveStencilFaceEXT, cmdlen);
- (void) memcpy((void *)(gc->pc + 4), (void *)(&face), 4);
+ if (__builtin_expect(dpy != NULL, 1)) {
+ GLubyte const * pc = __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithReply, X_GLvop_GetProgramivNV, cmdlen);
+ (void) memcpy((void *)(pc + 0), (void *)(&id), 4);
+ (void) memcpy((void *)(pc + 4), (void *)(&pname), 4);
+ (void) __glXReadReply(dpy, 4, params, GL_FALSE);
+ UnlockDisplay(dpy); SyncHandle();
+ }
+ return;
+}
+
+#define X_GLvop_GetProgramStringNV 1299
+void
+__indirect_glGetProgramStringNV(GLuint id, GLenum pname, GLubyte * program)
+{
+ __GLXcontext * const gc = __glXGetCurrentContext();
+ Display * const dpy = gc->currentDpy;
+ const GLuint cmdlen = 8;
+ if (__builtin_expect(dpy != NULL, 1)) {
+ GLubyte const * pc = __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithReply, X_GLvop_GetProgramStringNV, cmdlen);
+ (void) memcpy((void *)(pc + 0), (void *)(&id), 4);
+ (void) memcpy((void *)(pc + 4), (void *)(&pname), 4);
+ (void) __glXReadReply(dpy, 1, program, GL_TRUE);
+ UnlockDisplay(dpy); SyncHandle();
+ }
+ return;
+}
+
+#define X_GLvop_GetTrackMatrixivNV 1300
+void
+__indirect_glGetTrackMatrixivNV(GLenum target, GLuint address, GLenum pname, GLint * params)
+{
+ __GLXcontext * const gc = __glXGetCurrentContext();
+ Display * const dpy = gc->currentDpy;
+ const GLuint cmdlen = 12;
+ if (__builtin_expect(dpy != NULL, 1)) {
+ GLubyte const * pc = __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithReply, X_GLvop_GetTrackMatrixivNV, cmdlen);
+ (void) memcpy((void *)(pc + 0), (void *)(&target), 4);
+ (void) memcpy((void *)(pc + 4), (void *)(&address), 4);
+ (void) memcpy((void *)(pc + 8), (void *)(&pname), 4);
+ (void) __glXReadReply(dpy, 4, params, GL_FALSE);
+ UnlockDisplay(dpy); SyncHandle();
+ }
+ return;
+}
+
+#define X_GLvop_IsProgramNV 1304
+GLboolean
+__indirect_glIsProgramNV(GLuint program)
+{
+ __GLXcontext * const gc = __glXGetCurrentContext();
+ Display * const dpy = gc->currentDpy;
+ GLboolean retval = (GLboolean) 0;
+ const GLuint cmdlen = 4;
+ if (__builtin_expect(dpy != NULL, 1)) {
+ GLubyte const * pc = __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithReply, X_GLvop_IsProgramNV, cmdlen);
+ (void) memcpy((void *)(pc + 0), (void *)(&program), 4);
+ retval = (GLboolean) __glXReadReply(dpy, 0, NULL, GL_FALSE);
+ UnlockDisplay(dpy); SyncHandle();
+ }
+ return retval;
+}
+
+#define X_GLrop_LoadProgramNV 4183
+void
+__indirect_glLoadProgramNV(GLenum target, GLuint id, GLsizei len, const GLubyte * program)
+{
+ __GLXcontext * const gc = __glXGetCurrentContext();
+ const GLuint cmdlen = 16 + __GLX_PAD(len);
+ if (__builtin_expect(len >= 0, 1)) {
+ emit_header(gc->pc, X_GLrop_LoadProgramNV, cmdlen);
+ (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
+ (void) memcpy((void *)(gc->pc + 8), (void *)(&id), 4);
+ (void) memcpy((void *)(gc->pc + 12), (void *)(&len), 4);
+ (void) memcpy((void *)(gc->pc + 16), (void *)(program), len);
+ gc->pc += cmdlen;
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+ }
+}
+
+#define X_GLrop_ProgramParameter4dvNV 4185
+void
+__indirect_glProgramParameter4dNV(GLenum target, GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w)
+{
+ __GLXcontext * const gc = __glXGetCurrentContext();
+ const GLuint cmdlen = 44;
+ emit_header(gc->pc, X_GLrop_ProgramParameter4dvNV, cmdlen);
+ (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
+ (void) memcpy((void *)(gc->pc + 8), (void *)(&index), 4);
+ (void) memcpy((void *)(gc->pc + 12), (void *)(&x), 8);
+ (void) memcpy((void *)(gc->pc + 20), (void *)(&y), 8);
+ (void) memcpy((void *)(gc->pc + 28), (void *)(&z), 8);
+ (void) memcpy((void *)(gc->pc + 36), (void *)(&w), 8);
gc->pc += cmdlen;
if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
}
+#define X_GLrop_ProgramParameter4dvNV 4185
+void
+__indirect_glProgramParameter4dvNV(GLenum target, GLuint index, const GLdouble * params)
+{
+ __GLXcontext * const gc = __glXGetCurrentContext();
+ const GLuint cmdlen = 44;
+ emit_header(gc->pc, X_GLrop_ProgramParameter4dvNV, cmdlen);
+ (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
+ (void) memcpy((void *)(gc->pc + 8), (void *)(&index), 4);
+ (void) memcpy((void *)(gc->pc + 12), (void *)(params), 32);
+ gc->pc += cmdlen;
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_ProgramParameter4fvNV 4184
+void
+__indirect_glProgramParameter4fNV(GLenum target, GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
+{
+ __GLXcontext * const gc = __glXGetCurrentContext();
+ const GLuint cmdlen = 28;
+ emit_header(gc->pc, X_GLrop_ProgramParameter4fvNV, cmdlen);
+ (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
+ (void) memcpy((void *)(gc->pc + 8), (void *)(&index), 4);
+ (void) memcpy((void *)(gc->pc + 12), (void *)(&x), 4);
+ (void) memcpy((void *)(gc->pc + 16), (void *)(&y), 4);
+ (void) memcpy((void *)(gc->pc + 20), (void *)(&z), 4);
+ (void) memcpy((void *)(gc->pc + 24), (void *)(&w), 4);
+ gc->pc += cmdlen;
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_ProgramParameter4fvNV 4184
+void
+__indirect_glProgramParameter4fvNV(GLenum target, GLuint index, const GLfloat * params)
+{
+ __GLXcontext * const gc = __glXGetCurrentContext();
+ const GLuint cmdlen = 28;
+ emit_header(gc->pc, X_GLrop_ProgramParameter4fvNV, cmdlen);
+ (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
+ (void) memcpy((void *)(gc->pc + 8), (void *)(&index), 4);
+ (void) memcpy((void *)(gc->pc + 12), (void *)(params), 16);
+ gc->pc += cmdlen;
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_ProgramParameters4dvNV 4187
+void
+__indirect_glProgramParameters4dvNV(GLenum target, GLuint index, GLuint num, const GLdouble * params)
+{
+ __GLXcontext * const gc = __glXGetCurrentContext();
+ const GLuint cmdlen = 16 + __GLX_PAD((num * 32));
+ if (__builtin_expect(num >= 0, 1)) {
+ emit_header(gc->pc, X_GLrop_ProgramParameters4dvNV, cmdlen);
+ (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
+ (void) memcpy((void *)(gc->pc + 8), (void *)(&index), 4);
+ (void) memcpy((void *)(gc->pc + 12), (void *)(&num), 4);
+ (void) memcpy((void *)(gc->pc + 16), (void *)(params), (num * 32));
+ gc->pc += cmdlen;
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+ }
+}
+
+#define X_GLrop_ProgramParameters4fvNV 4186
+void
+__indirect_glProgramParameters4fvNV(GLenum target, GLuint index, GLuint num, const GLfloat * params)
+{
+ __GLXcontext * const gc = __glXGetCurrentContext();
+ const GLuint cmdlen = 16 + __GLX_PAD((num * 16));
+ if (__builtin_expect(num >= 0, 1)) {
+ emit_header(gc->pc, X_GLrop_ProgramParameters4fvNV, cmdlen);
+ (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
+ (void) memcpy((void *)(gc->pc + 8), (void *)(&index), 4);
+ (void) memcpy((void *)(gc->pc + 12), (void *)(&num), 4);
+ (void) memcpy((void *)(gc->pc + 16), (void *)(params), (num * 16));
+ gc->pc += cmdlen;
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+ }
+}
+
+#define X_GLrop_RequestResidentProgramsNV 4182
+void
+__indirect_glRequestResidentProgramsNV(GLsizei n, const GLuint * ids)
+{
+ __GLXcontext * const gc = __glXGetCurrentContext();
+ const GLuint cmdlen = 8 + __GLX_PAD((n * 4));
+ if (__builtin_expect(n >= 0, 1)) {
+ emit_header(gc->pc, X_GLrop_RequestResidentProgramsNV, cmdlen);
+ (void) memcpy((void *)(gc->pc + 4), (void *)(&n), 4);
+ (void) memcpy((void *)(gc->pc + 8), (void *)(ids), (n * 4));
+ gc->pc += cmdlen;
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+ }
+}
+
+#define X_GLrop_TrackMatrixNV 4188
+void
+__indirect_glTrackMatrixNV(GLenum target, GLuint address, GLenum matrix, GLenum transform)
+{
+ __GLXcontext * const gc = __glXGetCurrentContext();
+ const GLuint cmdlen = 20;
+ emit_header(gc->pc, X_GLrop_TrackMatrixNV, cmdlen);
+ (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
+ (void) memcpy((void *)(gc->pc + 8), (void *)(&address), 4);
+ (void) memcpy((void *)(gc->pc + 12), (void *)(&matrix), 4);
+ (void) memcpy((void *)(gc->pc + 16), (void *)(&transform), 4);
+ gc->pc += cmdlen;
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_VertexAttrib1dvARB 4197
+void
+__indirect_glVertexAttrib1dARB(GLuint index, GLdouble x)
+{
+ __GLXcontext * const gc = __glXGetCurrentContext();
+ const GLuint cmdlen = 16;
+ emit_header(gc->pc, X_GLrop_VertexAttrib1dvARB, cmdlen);
+ (void) memcpy((void *)(gc->pc + 4), (void *)(&x), 8);
+ (void) memcpy((void *)(gc->pc + 12), (void *)(&index), 4);
+ gc->pc += cmdlen;
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_VertexAttrib1dvARB 4197
+void
+__indirect_glVertexAttrib1dvARB(GLuint index, const GLdouble * v)
+{
+ __GLXcontext * const gc = __glXGetCurrentContext();
+ const GLuint cmdlen = 16;
+ emit_header(gc->pc, X_GLrop_VertexAttrib1dvARB, cmdlen);
+ (void) memcpy((void *)(gc->pc + 4), (void *)(v), 8);
+ (void) memcpy((void *)(gc->pc + 12), (void *)(&index), 4);
+ gc->pc += cmdlen;
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_VertexAttrib1fvARB 4193
+void
+__indirect_glVertexAttrib1fARB(GLuint index, GLfloat x)
+{
+ __GLXcontext * const gc = __glXGetCurrentContext();
+ const GLuint cmdlen = 12;
+ emit_header(gc->pc, X_GLrop_VertexAttrib1fvARB, cmdlen);
+ (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
+ (void) memcpy((void *)(gc->pc + 8), (void *)(&x), 4);
+ gc->pc += cmdlen;
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_VertexAttrib1fvARB 4193
+void
+__indirect_glVertexAttrib1fvARB(GLuint index, const GLfloat * v)
+{
+ __GLXcontext * const gc = __glXGetCurrentContext();
+ const GLuint cmdlen = 12;
+ emit_header(gc->pc, X_GLrop_VertexAttrib1fvARB, cmdlen);
+ (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
+ (void) memcpy((void *)(gc->pc + 8), (void *)(v), 4);
+ gc->pc += cmdlen;
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_VertexAttrib1svARB 4189
+void
+__indirect_glVertexAttrib1sARB(GLuint index, GLshort x)
+{
+ __GLXcontext * const gc = __glXGetCurrentContext();
+ const GLuint cmdlen = 12;
+ emit_header(gc->pc, X_GLrop_VertexAttrib1svARB, cmdlen);
+ (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
+ (void) memcpy((void *)(gc->pc + 8), (void *)(&x), 2);
+ gc->pc += cmdlen;
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_VertexAttrib1svARB 4189
+void
+__indirect_glVertexAttrib1svARB(GLuint index, const GLshort * v)
+{
+ __GLXcontext * const gc = __glXGetCurrentContext();
+ const GLuint cmdlen = 12;
+ emit_header(gc->pc, X_GLrop_VertexAttrib1svARB, cmdlen);
+ (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
+ (void) memcpy((void *)(gc->pc + 8), (void *)(v), 2);
+ gc->pc += cmdlen;
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_VertexAttrib2dvARB 4198
+void
+__indirect_glVertexAttrib2dARB(GLuint index, GLdouble x, GLdouble y)
+{
+ __GLXcontext * const gc = __glXGetCurrentContext();
+ const GLuint cmdlen = 24;
+ emit_header(gc->pc, X_GLrop_VertexAttrib2dvARB, cmdlen);
+ (void) memcpy((void *)(gc->pc + 4), (void *)(&x), 8);
+ (void) memcpy((void *)(gc->pc + 12), (void *)(&y), 8);
+ (void) memcpy((void *)(gc->pc + 20), (void *)(&index), 4);
+ gc->pc += cmdlen;
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_VertexAttrib2dvARB 4198
+void
+__indirect_glVertexAttrib2dvARB(GLuint index, const GLdouble * v)
+{
+ __GLXcontext * const gc = __glXGetCurrentContext();
+ const GLuint cmdlen = 24;
+ emit_header(gc->pc, X_GLrop_VertexAttrib2dvARB, cmdlen);
+ (void) memcpy((void *)(gc->pc + 4), (void *)(v), 16);
+ (void) memcpy((void *)(gc->pc + 20), (void *)(&index), 4);
+ gc->pc += cmdlen;
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_VertexAttrib2fvARB 4194
+void
+__indirect_glVertexAttrib2fARB(GLuint index, GLfloat x, GLfloat y)
+{
+ __GLXcontext * const gc = __glXGetCurrentContext();
+ const GLuint cmdlen = 16;
+ emit_header(gc->pc, X_GLrop_VertexAttrib2fvARB, cmdlen);
+ (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
+ (void) memcpy((void *)(gc->pc + 8), (void *)(&x), 4);
+ (void) memcpy((void *)(gc->pc + 12), (void *)(&y), 4);
+ gc->pc += cmdlen;
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_VertexAttrib2fvARB 4194
+void
+__indirect_glVertexAttrib2fvARB(GLuint index, const GLfloat * v)
+{
+ __GLXcontext * const gc = __glXGetCurrentContext();
+ const GLuint cmdlen = 16;
+ emit_header(gc->pc, X_GLrop_VertexAttrib2fvARB, cmdlen);
+ (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
+ (void) memcpy((void *)(gc->pc + 8), (void *)(v), 8);
+ gc->pc += cmdlen;
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_VertexAttrib2svARB 4190
+void
+__indirect_glVertexAttrib2sARB(GLuint index, GLshort x, GLshort y)
+{
+ __GLXcontext * const gc = __glXGetCurrentContext();
+ const GLuint cmdlen = 12;
+ emit_header(gc->pc, X_GLrop_VertexAttrib2svARB, cmdlen);
+ (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
+ (void) memcpy((void *)(gc->pc + 8), (void *)(&x), 2);
+ (void) memcpy((void *)(gc->pc + 10), (void *)(&y), 2);
+ gc->pc += cmdlen;
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_VertexAttrib2svARB 4190
+void
+__indirect_glVertexAttrib2svARB(GLuint index, const GLshort * v)
+{
+ __GLXcontext * const gc = __glXGetCurrentContext();
+ const GLuint cmdlen = 12;
+ emit_header(gc->pc, X_GLrop_VertexAttrib2svARB, cmdlen);
+ (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
+ (void) memcpy((void *)(gc->pc + 8), (void *)(v), 4);
+ gc->pc += cmdlen;
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_VertexAttrib3dvARB 4199
+void
+__indirect_glVertexAttrib3dARB(GLuint index, GLdouble x, GLdouble y, GLdouble z)
+{
+ __GLXcontext * const gc = __glXGetCurrentContext();
+ const GLuint cmdlen = 32;
+ emit_header(gc->pc, X_GLrop_VertexAttrib3dvARB, cmdlen);
+ (void) memcpy((void *)(gc->pc + 4), (void *)(&x), 8);
+ (void) memcpy((void *)(gc->pc + 12), (void *)(&y), 8);
+ (void) memcpy((void *)(gc->pc + 20), (void *)(&z), 8);
+ (void) memcpy((void *)(gc->pc + 28), (void *)(&index), 4);
+ gc->pc += cmdlen;
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_VertexAttrib3dvARB 4199
+void
+__indirect_glVertexAttrib3dvARB(GLuint index, const GLdouble * v)
+{
+ __GLXcontext * const gc = __glXGetCurrentContext();
+ const GLuint cmdlen = 32;
+ emit_header(gc->pc, X_GLrop_VertexAttrib3dvARB, cmdlen);
+ (void) memcpy((void *)(gc->pc + 4), (void *)(v), 24);
+ (void) memcpy((void *)(gc->pc + 28), (void *)(&index), 4);
+ gc->pc += cmdlen;
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_VertexAttrib3fvARB 4195
+void
+__indirect_glVertexAttrib3fARB(GLuint index, GLfloat x, GLfloat y, GLfloat z)
+{
+ __GLXcontext * const gc = __glXGetCurrentContext();
+ const GLuint cmdlen = 20;
+ emit_header(gc->pc, X_GLrop_VertexAttrib3fvARB, cmdlen);
+ (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
+ (void) memcpy((void *)(gc->pc + 8), (void *)(&x), 4);
+ (void) memcpy((void *)(gc->pc + 12), (void *)(&y), 4);
+ (void) memcpy((void *)(gc->pc + 16), (void *)(&z), 4);
+ gc->pc += cmdlen;
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_VertexAttrib3fvARB 4195
+void
+__indirect_glVertexAttrib3fvARB(GLuint index, const GLfloat * v)
+{
+ __GLXcontext * const gc = __glXGetCurrentContext();
+ const GLuint cmdlen = 20;
+ emit_header(gc->pc, X_GLrop_VertexAttrib3fvARB, cmdlen);
+ (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
+ (void) memcpy((void *)(gc->pc + 8), (void *)(v), 12);
+ gc->pc += cmdlen;
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_VertexAttrib3svARB 4191
+void
+__indirect_glVertexAttrib3sARB(GLuint index, GLshort x, GLshort y, GLshort z)
+{
+ __GLXcontext * const gc = __glXGetCurrentContext();
+ const GLuint cmdlen = 16;
+ emit_header(gc->pc, X_GLrop_VertexAttrib3svARB, cmdlen);
+ (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
+ (void) memcpy((void *)(gc->pc + 8), (void *)(&x), 2);
+ (void) memcpy((void *)(gc->pc + 10), (void *)(&y), 2);
+ (void) memcpy((void *)(gc->pc + 12), (void *)(&z), 2);
+ gc->pc += cmdlen;
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_VertexAttrib3svARB 4191
+void
+__indirect_glVertexAttrib3svARB(GLuint index, const GLshort * v)
+{
+ __GLXcontext * const gc = __glXGetCurrentContext();
+ const GLuint cmdlen = 16;
+ emit_header(gc->pc, X_GLrop_VertexAttrib3svARB, cmdlen);
+ (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
+ (void) memcpy((void *)(gc->pc + 8), (void *)(v), 6);
+ gc->pc += cmdlen;
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_VertexAttrib4dvARB 4200
+void
+__indirect_glVertexAttrib4dARB(GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w)
+{
+ __GLXcontext * const gc = __glXGetCurrentContext();
+ const GLuint cmdlen = 40;
+ emit_header(gc->pc, X_GLrop_VertexAttrib4dvARB, cmdlen);
+ (void) memcpy((void *)(gc->pc + 4), (void *)(&x), 8);
+ (void) memcpy((void *)(gc->pc + 12), (void *)(&y), 8);
+ (void) memcpy((void *)(gc->pc + 20), (void *)(&z), 8);
+ (void) memcpy((void *)(gc->pc + 28), (void *)(&w), 8);
+ (void) memcpy((void *)(gc->pc + 36), (void *)(&index), 4);
+ gc->pc += cmdlen;
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_VertexAttrib4dvARB 4200
+void
+__indirect_glVertexAttrib4dvARB(GLuint index, const GLdouble * v)
+{
+ __GLXcontext * const gc = __glXGetCurrentContext();
+ const GLuint cmdlen = 40;
+ emit_header(gc->pc, X_GLrop_VertexAttrib4dvARB, cmdlen);
+ (void) memcpy((void *)(gc->pc + 4), (void *)(v), 32);
+ (void) memcpy((void *)(gc->pc + 36), (void *)(&index), 4);
+ gc->pc += cmdlen;
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_VertexAttrib4fvARB 4196
+void
+__indirect_glVertexAttrib4fARB(GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
+{
+ __GLXcontext * const gc = __glXGetCurrentContext();
+ const GLuint cmdlen = 24;
+ emit_header(gc->pc, X_GLrop_VertexAttrib4fvARB, cmdlen);
+ (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
+ (void) memcpy((void *)(gc->pc + 8), (void *)(&x), 4);
+ (void) memcpy((void *)(gc->pc + 12), (void *)(&y), 4);
+ (void) memcpy((void *)(gc->pc + 16), (void *)(&z), 4);
+ (void) memcpy((void *)(gc->pc + 20), (void *)(&w), 4);
+ gc->pc += cmdlen;
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_VertexAttrib4fvARB 4196
+void
+__indirect_glVertexAttrib4fvARB(GLuint index, const GLfloat * v)
+{
+ __GLXcontext * const gc = __glXGetCurrentContext();
+ const GLuint cmdlen = 24;
+ emit_header(gc->pc, X_GLrop_VertexAttrib4fvARB, cmdlen);
+ (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
+ (void) memcpy((void *)(gc->pc + 8), (void *)(v), 16);
+ gc->pc += cmdlen;
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_VertexAttrib4svARB 4192
+void
+__indirect_glVertexAttrib4sARB(GLuint index, GLshort x, GLshort y, GLshort z, GLshort w)
+{
+ __GLXcontext * const gc = __glXGetCurrentContext();
+ const GLuint cmdlen = 16;
+ emit_header(gc->pc, X_GLrop_VertexAttrib4svARB, cmdlen);
+ (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
+ (void) memcpy((void *)(gc->pc + 8), (void *)(&x), 2);
+ (void) memcpy((void *)(gc->pc + 10), (void *)(&y), 2);
+ (void) memcpy((void *)(gc->pc + 12), (void *)(&z), 2);
+ (void) memcpy((void *)(gc->pc + 14), (void *)(&w), 2);
+ gc->pc += cmdlen;
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_VertexAttrib4svARB 4192
+void
+__indirect_glVertexAttrib4svARB(GLuint index, const GLshort * v)
+{
+ __GLXcontext * const gc = __glXGetCurrentContext();
+ const GLuint cmdlen = 16;
+ emit_header(gc->pc, X_GLrop_VertexAttrib4svARB, cmdlen);
+ (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
+ (void) memcpy((void *)(gc->pc + 8), (void *)(v), 8);
+ gc->pc += cmdlen;
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_VertexAttrib4NubvARB 4201
+void
+__indirect_glVertexAttrib4NubARB(GLuint index, GLubyte x, GLubyte y, GLubyte z, GLubyte w)
+{
+ __GLXcontext * const gc = __glXGetCurrentContext();
+ const GLuint cmdlen = 12;
+ emit_header(gc->pc, X_GLrop_VertexAttrib4NubvARB, cmdlen);
+ (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
+ (void) memcpy((void *)(gc->pc + 8), (void *)(&x), 1);
+ (void) memcpy((void *)(gc->pc + 9), (void *)(&y), 1);
+ (void) memcpy((void *)(gc->pc + 10), (void *)(&z), 1);
+ (void) memcpy((void *)(gc->pc + 11), (void *)(&w), 1);
+ gc->pc += cmdlen;
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_VertexAttrib4NubvARB 4201
+void
+__indirect_glVertexAttrib4NubvARB(GLuint index, const GLubyte * v)
+{
+ __GLXcontext * const gc = __glXGetCurrentContext();
+ const GLuint cmdlen = 12;
+ emit_header(gc->pc, X_GLrop_VertexAttrib4NubvARB, cmdlen);
+ (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
+ (void) memcpy((void *)(gc->pc + 8), (void *)(v), 4);
+ gc->pc += cmdlen;
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_VertexAttribs1dvNV 4210
+void
+__indirect_glVertexAttribs1dvNV(GLuint index, GLsizei n, const GLdouble * v)
+{
+ __GLXcontext * const gc = __glXGetCurrentContext();
+ const GLuint cmdlen = 12 + __GLX_PAD((n * 8));
+ if (__builtin_expect(n >= 0, 1)) {
+ emit_header(gc->pc, X_GLrop_VertexAttribs1dvNV, cmdlen);
+ (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
+ (void) memcpy((void *)(gc->pc + 8), (void *)(&n), 4);
+ (void) memcpy((void *)(gc->pc + 12), (void *)(v), (n * 8));
+ gc->pc += cmdlen;
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+ }
+}
+
+#define X_GLrop_VertexAttribs1fvNV 4206
+void
+__indirect_glVertexAttribs1fvNV(GLuint index, GLsizei n, const GLfloat * v)
+{
+ __GLXcontext * const gc = __glXGetCurrentContext();
+ const GLuint cmdlen = 12 + __GLX_PAD((n * 4));
+ if (__builtin_expect(n >= 0, 1)) {
+ emit_header(gc->pc, X_GLrop_VertexAttribs1fvNV, cmdlen);
+ (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
+ (void) memcpy((void *)(gc->pc + 8), (void *)(&n), 4);
+ (void) memcpy((void *)(gc->pc + 12), (void *)(v), (n * 4));
+ gc->pc += cmdlen;
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+ }
+}
+
+#define X_GLrop_VertexAttribs1svNV 4202
+void
+__indirect_glVertexAttribs1svNV(GLuint index, GLsizei n, const GLshort * v)
+{
+ __GLXcontext * const gc = __glXGetCurrentContext();
+ const GLuint cmdlen = 12 + __GLX_PAD((n * 2));
+ if (__builtin_expect(n >= 0, 1)) {
+ emit_header(gc->pc, X_GLrop_VertexAttribs1svNV, cmdlen);
+ (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
+ (void) memcpy((void *)(gc->pc + 8), (void *)(&n), 4);
+ (void) memcpy((void *)(gc->pc + 12), (void *)(v), (n * 2));
+ gc->pc += cmdlen;
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+ }
+}
+
+#define X_GLrop_VertexAttribs2dvNV 4211
+void
+__indirect_glVertexAttribs2dvNV(GLuint index, GLsizei n, const GLdouble * v)
+{
+ __GLXcontext * const gc = __glXGetCurrentContext();
+ const GLuint cmdlen = 12 + __GLX_PAD((n * 16));
+ if (__builtin_expect(n >= 0, 1)) {
+ emit_header(gc->pc, X_GLrop_VertexAttribs2dvNV, cmdlen);
+ (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
+ (void) memcpy((void *)(gc->pc + 8), (void *)(&n), 4);
+ (void) memcpy((void *)(gc->pc + 12), (void *)(v), (n * 16));
+ gc->pc += cmdlen;
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+ }
+}
+
+#define X_GLrop_VertexAttribs2fvNV 4207
+void
+__indirect_glVertexAttribs2fvNV(GLuint index, GLsizei n, const GLfloat * v)
+{
+ __GLXcontext * const gc = __glXGetCurrentContext();
+ const GLuint cmdlen = 12 + __GLX_PAD((n * 8));
+ if (__builtin_expect(n >= 0, 1)) {
+ emit_header(gc->pc, X_GLrop_VertexAttribs2fvNV, cmdlen);
+ (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
+ (void) memcpy((void *)(gc->pc + 8), (void *)(&n), 4);
+ (void) memcpy((void *)(gc->pc + 12), (void *)(v), (n * 8));
+ gc->pc += cmdlen;
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+ }
+}
+
+#define X_GLrop_VertexAttribs2svNV 4203
+void
+__indirect_glVertexAttribs2svNV(GLuint index, GLsizei n, const GLshort * v)
+{
+ __GLXcontext * const gc = __glXGetCurrentContext();
+ const GLuint cmdlen = 12 + __GLX_PAD((n * 4));
+ if (__builtin_expect(n >= 0, 1)) {
+ emit_header(gc->pc, X_GLrop_VertexAttribs2svNV, cmdlen);
+ (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
+ (void) memcpy((void *)(gc->pc + 8), (void *)(&n), 4);
+ (void) memcpy((void *)(gc->pc + 12), (void *)(v), (n * 4));
+ gc->pc += cmdlen;
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+ }
+}
+
+#define X_GLrop_VertexAttribs3dvNV 4212
+void
+__indirect_glVertexAttribs3dvNV(GLuint index, GLsizei n, const GLdouble * v)
+{
+ __GLXcontext * const gc = __glXGetCurrentContext();
+ const GLuint cmdlen = 12 + __GLX_PAD((n * 24));
+ if (__builtin_expect(n >= 0, 1)) {
+ emit_header(gc->pc, X_GLrop_VertexAttribs3dvNV, cmdlen);
+ (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
+ (void) memcpy((void *)(gc->pc + 8), (void *)(&n), 4);
+ (void) memcpy((void *)(gc->pc + 12), (void *)(v), (n * 24));
+ gc->pc += cmdlen;
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+ }
+}
+
+#define X_GLrop_VertexAttribs3fvNV 4208
+void
+__indirect_glVertexAttribs3fvNV(GLuint index, GLsizei n, const GLfloat * v)
+{
+ __GLXcontext * const gc = __glXGetCurrentContext();
+ const GLuint cmdlen = 12 + __GLX_PAD((n * 12));
+ if (__builtin_expect(n >= 0, 1)) {
+ emit_header(gc->pc, X_GLrop_VertexAttribs3fvNV, cmdlen);
+ (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
+ (void) memcpy((void *)(gc->pc + 8), (void *)(&n), 4);
+ (void) memcpy((void *)(gc->pc + 12), (void *)(v), (n * 12));
+ gc->pc += cmdlen;
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+ }
+}
+
+#define X_GLrop_VertexAttribs3svNV 4204
+void
+__indirect_glVertexAttribs3svNV(GLuint index, GLsizei n, const GLshort * v)
+{
+ __GLXcontext * const gc = __glXGetCurrentContext();
+ const GLuint cmdlen = 12 + __GLX_PAD((n * 6));
+ if (__builtin_expect(n >= 0, 1)) {
+ emit_header(gc->pc, X_GLrop_VertexAttribs3svNV, cmdlen);
+ (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
+ (void) memcpy((void *)(gc->pc + 8), (void *)(&n), 4);
+ (void) memcpy((void *)(gc->pc + 12), (void *)(v), (n * 6));
+ gc->pc += cmdlen;
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+ }
+}
+
+#define X_GLrop_VertexAttribs4dvNV 4213
+void
+__indirect_glVertexAttribs4dvNV(GLuint index, GLsizei n, const GLdouble * v)
+{
+ __GLXcontext * const gc = __glXGetCurrentContext();
+ const GLuint cmdlen = 12 + __GLX_PAD((n * 32));
+ if (__builtin_expect(n >= 0, 1)) {
+ emit_header(gc->pc, X_GLrop_VertexAttribs4dvNV, cmdlen);
+ (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
+ (void) memcpy((void *)(gc->pc + 8), (void *)(&n), 4);
+ (void) memcpy((void *)(gc->pc + 12), (void *)(v), (n * 32));
+ gc->pc += cmdlen;
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+ }
+}
+
+#define X_GLrop_VertexAttribs4fvNV 4209
+void
+__indirect_glVertexAttribs4fvNV(GLuint index, GLsizei n, const GLfloat * v)
+{
+ __GLXcontext * const gc = __glXGetCurrentContext();
+ const GLuint cmdlen = 12 + __GLX_PAD((n * 16));
+ if (__builtin_expect(n >= 0, 1)) {
+ emit_header(gc->pc, X_GLrop_VertexAttribs4fvNV, cmdlen);
+ (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
+ (void) memcpy((void *)(gc->pc + 8), (void *)(&n), 4);
+ (void) memcpy((void *)(gc->pc + 12), (void *)(v), (n * 16));
+ gc->pc += cmdlen;
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+ }
+}
+
+#define X_GLrop_VertexAttribs4svNV 4205
+void
+__indirect_glVertexAttribs4svNV(GLuint index, GLsizei n, const GLshort * v)
+{
+ __GLXcontext * const gc = __glXGetCurrentContext();
+ const GLuint cmdlen = 12 + __GLX_PAD((n * 8));
+ if (__builtin_expect(n >= 0, 1)) {
+ emit_header(gc->pc, X_GLrop_VertexAttribs4svNV, cmdlen);
+ (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
+ (void) memcpy((void *)(gc->pc + 8), (void *)(&n), 4);
+ (void) memcpy((void *)(gc->pc + 12), (void *)(v), (n * 8));
+ gc->pc += cmdlen;
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+ }
+}
+
+#define X_GLrop_VertexAttribs4ubvNV 4214
+void
+__indirect_glVertexAttribs4ubvNV(GLuint index, GLsizei n, const GLubyte * v)
+{
+ __GLXcontext * const gc = __glXGetCurrentContext();
+ const GLuint cmdlen = 12 + __GLX_PAD((n * 4));
+ if (__builtin_expect(n >= 0, 1)) {
+ emit_header(gc->pc, X_GLrop_VertexAttribs4ubvNV, cmdlen);
+ (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
+ (void) memcpy((void *)(gc->pc + 8), (void *)(&n), 4);
+ (void) memcpy((void *)(gc->pc + 12), (void *)(v), (n * 4));
+ gc->pc += cmdlen;
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+ }
+}
+
+#define X_GLrop_PointParameteriNV 4221
+void
+__indirect_glPointParameteriNV(GLenum pname, GLint param)
+{
+ __GLXcontext * const gc = __glXGetCurrentContext();
+ const GLuint cmdlen = 12;
+ emit_header(gc->pc, X_GLrop_PointParameteriNV, cmdlen);
+ (void) memcpy((void *)(gc->pc + 4), (void *)(&pname), 4);
+ (void) memcpy((void *)(gc->pc + 8), (void *)(¶m), 4);
+ gc->pc += cmdlen;
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_PointParameterivNV 4222
+void
+__indirect_glPointParameterivNV(GLenum pname, const GLint * params)
+{
+ __GLXcontext * const gc = __glXGetCurrentContext();
+ const GLuint compsize = __glPointParameterivNV_size(pname);
+ const GLuint cmdlen = 8 + __GLX_PAD((compsize * 4));
+ emit_header(gc->pc, X_GLrop_PointParameterivNV, cmdlen);
+ (void) memcpy((void *)(gc->pc + 4), (void *)(&pname), 4);
+ (void) memcpy((void *)(gc->pc + 8), (void *)(params), (compsize * 4));
+ gc->pc += cmdlen;
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_ActiveStencilFaceEXT 4220
+void
+__indirect_glActiveStencilFaceEXT(GLenum face)
+{
+ __GLXcontext * const gc = __glXGetCurrentContext();
+ const GLuint cmdlen = 8;
+ emit_header(gc->pc, X_GLrop_ActiveStencilFaceEXT, cmdlen);
+ (void) memcpy((void *)(gc->pc + 4), (void *)(&face), 4);
+ gc->pc += cmdlen;
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_VertexAttrib4bvARB 4230
+void
+__indirect_glVertexAttrib4bvARB(GLuint index, const GLbyte * v)
+{
+ __GLXcontext * const gc = __glXGetCurrentContext();
+ const GLuint cmdlen = 12;
+ emit_header(gc->pc, X_GLrop_VertexAttrib4bvARB, cmdlen);
+ (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
+ (void) memcpy((void *)(gc->pc + 8), (void *)(v), 4);
+ gc->pc += cmdlen;
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_VertexAttrib4ivARB 4231
+void
+__indirect_glVertexAttrib4ivARB(GLuint index, const GLint * v)
+{
+ __GLXcontext * const gc = __glXGetCurrentContext();
+ const GLuint cmdlen = 24;
+ emit_header(gc->pc, X_GLrop_VertexAttrib4ivARB, cmdlen);
+ (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
+ (void) memcpy((void *)(gc->pc + 8), (void *)(v), 16);
+ gc->pc += cmdlen;
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_VertexAttrib4ubvARB 4232
+void
+__indirect_glVertexAttrib4ubvARB(GLuint index, const GLubyte * v)
+{
+ __GLXcontext * const gc = __glXGetCurrentContext();
+ const GLuint cmdlen = 12;
+ emit_header(gc->pc, X_GLrop_VertexAttrib4ubvARB, cmdlen);
+ (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
+ (void) memcpy((void *)(gc->pc + 8), (void *)(v), 4);
+ gc->pc += cmdlen;
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_VertexAttrib4usvARB 4233
+void
+__indirect_glVertexAttrib4usvARB(GLuint index, const GLushort * v)
+{
+ __GLXcontext * const gc = __glXGetCurrentContext();
+ const GLuint cmdlen = 16;
+ emit_header(gc->pc, X_GLrop_VertexAttrib4usvARB, cmdlen);
+ (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
+ (void) memcpy((void *)(gc->pc + 8), (void *)(v), 8);
+ gc->pc += cmdlen;
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_VertexAttrib4uivARB 4234
+void
+__indirect_glVertexAttrib4uivARB(GLuint index, const GLuint * v)
+{
+ __GLXcontext * const gc = __glXGetCurrentContext();
+ const GLuint cmdlen = 24;
+ emit_header(gc->pc, X_GLrop_VertexAttrib4uivARB, cmdlen);
+ (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
+ (void) memcpy((void *)(gc->pc + 8), (void *)(v), 16);
+ gc->pc += cmdlen;
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_VertexAttrib4NbvARB 4235
+void
+__indirect_glVertexAttrib4NbvARB(GLuint index, const GLbyte * v)
+{
+ __GLXcontext * const gc = __glXGetCurrentContext();
+ const GLuint cmdlen = 12;
+ emit_header(gc->pc, X_GLrop_VertexAttrib4NbvARB, cmdlen);
+ (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
+ (void) memcpy((void *)(gc->pc + 8), (void *)(v), 4);
+ gc->pc += cmdlen;
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_VertexAttrib4NsvARB 4236
+void
+__indirect_glVertexAttrib4NsvARB(GLuint index, const GLshort * v)
+{
+ __GLXcontext * const gc = __glXGetCurrentContext();
+ const GLuint cmdlen = 16;
+ emit_header(gc->pc, X_GLrop_VertexAttrib4NsvARB, cmdlen);
+ (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
+ (void) memcpy((void *)(gc->pc + 8), (void *)(v), 8);
+ gc->pc += cmdlen;
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_VertexAttrib4NivARB 4237
+void
+__indirect_glVertexAttrib4NivARB(GLuint index, const GLint * v)
+{
+ __GLXcontext * const gc = __glXGetCurrentContext();
+ const GLuint cmdlen = 24;
+ emit_header(gc->pc, X_GLrop_VertexAttrib4NivARB, cmdlen);
+ (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
+ (void) memcpy((void *)(gc->pc + 8), (void *)(v), 16);
+ gc->pc += cmdlen;
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_VertexAttrib4NusvARB 4238
+void
+__indirect_glVertexAttrib4NusvARB(GLuint index, const GLushort * v)
+{
+ __GLXcontext * const gc = __glXGetCurrentContext();
+ const GLuint cmdlen = 16;
+ emit_header(gc->pc, X_GLrop_VertexAttrib4NusvARB, cmdlen);
+ (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
+ (void) memcpy((void *)(gc->pc + 8), (void *)(v), 8);
+ gc->pc += cmdlen;
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_VertexAttrib4NuivARB 4239
+void
+__indirect_glVertexAttrib4NuivARB(GLuint index, const GLuint * v)
+{
+ __GLXcontext * const gc = __glXGetCurrentContext();
+ const GLuint cmdlen = 24;
+ emit_header(gc->pc, X_GLrop_VertexAttrib4NuivARB, cmdlen);
+ (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
+ (void) memcpy((void *)(gc->pc + 8), (void *)(v), 16);
+ gc->pc += cmdlen;
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_ProgramStringARB 4217
+void
+__indirect_glProgramStringARB(GLenum target, GLenum format, GLsizei len, const GLvoid * string)
+{
+ __GLXcontext * const gc = __glXGetCurrentContext();
+ const GLuint cmdlen = 16 + __GLX_PAD(len);
+ if (__builtin_expect((len >= 0) && (gc->currentDpy != NULL), 1)) {
+ if (cmdlen <= gc->maxSmallRenderCommandSize) {
+ if ( (gc->pc + cmdlen) > gc->bufEnd ) {
+ (void) __glXFlushRenderBuffer(gc, gc->pc);
+ }
+ emit_header(gc->pc, X_GLrop_ProgramStringARB, cmdlen);
+ (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
+ (void) memcpy((void *)(gc->pc + 8), (void *)(&format), 4);
+ (void) memcpy((void *)(gc->pc + 12), (void *)(&len), 4);
+ (void) memcpy((void *)(gc->pc + 16), (void *)(string), len);
+ gc->pc += cmdlen;
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+ }
+ else {
+ const GLint op = X_GLrop_ProgramStringARB;
+ const GLuint cmdlenLarge = cmdlen + 4;
+ GLubyte * const pc = __glXFlushRenderBuffer(gc, gc->pc);
+ (void) memcpy((void *)(pc + 0), (void *)(&cmdlenLarge), 4);
+ (void) memcpy((void *)(pc + 4), (void *)(&op), 4);
+ (void) memcpy((void *)(pc + 8), (void *)(&target), 4);
+ (void) memcpy((void *)(pc + 12), (void *)(&format), 4);
+ (void) memcpy((void *)(pc + 16), (void *)(&len), 4);
+ __glXSendLargeCommand(gc, pc, 20, string, len);
+ }
+ }
+}
+
+#define X_GLrop_ProgramEnvParameter4dvARB 4185
+void
+__indirect_glProgramEnvParameter4dARB(GLenum target, GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w)
+{
+ __GLXcontext * const gc = __glXGetCurrentContext();
+ const GLuint cmdlen = 44;
+ emit_header(gc->pc, X_GLrop_ProgramEnvParameter4dvARB, cmdlen);
+ (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
+ (void) memcpy((void *)(gc->pc + 8), (void *)(&index), 4);
+ (void) memcpy((void *)(gc->pc + 12), (void *)(&x), 8);
+ (void) memcpy((void *)(gc->pc + 20), (void *)(&y), 8);
+ (void) memcpy((void *)(gc->pc + 28), (void *)(&z), 8);
+ (void) memcpy((void *)(gc->pc + 36), (void *)(&w), 8);
+ gc->pc += cmdlen;
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_ProgramEnvParameter4dvARB 4185
+void
+__indirect_glProgramEnvParameter4dvARB(GLenum target, GLuint index, const GLdouble * params)
+{
+ __GLXcontext * const gc = __glXGetCurrentContext();
+ const GLuint cmdlen = 44;
+ emit_header(gc->pc, X_GLrop_ProgramEnvParameter4dvARB, cmdlen);
+ (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
+ (void) memcpy((void *)(gc->pc + 8), (void *)(&index), 4);
+ (void) memcpy((void *)(gc->pc + 12), (void *)(params), 32);
+ gc->pc += cmdlen;
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_ProgramEnvParameter4fvARB 4184
+void
+__indirect_glProgramEnvParameter4fARB(GLenum target, GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
+{
+ __GLXcontext * const gc = __glXGetCurrentContext();
+ const GLuint cmdlen = 28;
+ emit_header(gc->pc, X_GLrop_ProgramEnvParameter4fvARB, cmdlen);
+ (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
+ (void) memcpy((void *)(gc->pc + 8), (void *)(&index), 4);
+ (void) memcpy((void *)(gc->pc + 12), (void *)(&x), 4);
+ (void) memcpy((void *)(gc->pc + 16), (void *)(&y), 4);
+ (void) memcpy((void *)(gc->pc + 20), (void *)(&z), 4);
+ (void) memcpy((void *)(gc->pc + 24), (void *)(&w), 4);
+ gc->pc += cmdlen;
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_ProgramEnvParameter4fvARB 4184
+void
+__indirect_glProgramEnvParameter4fvARB(GLenum target, GLuint index, const GLfloat * params)
+{
+ __GLXcontext * const gc = __glXGetCurrentContext();
+ const GLuint cmdlen = 28;
+ emit_header(gc->pc, X_GLrop_ProgramEnvParameter4fvARB, cmdlen);
+ (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
+ (void) memcpy((void *)(gc->pc + 8), (void *)(&index), 4);
+ (void) memcpy((void *)(gc->pc + 12), (void *)(params), 16);
+ gc->pc += cmdlen;
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_ProgramLocalParameter4dvARB 4216
+void
+__indirect_glProgramLocalParameter4dARB(GLenum target, GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w)
+{
+ __GLXcontext * const gc = __glXGetCurrentContext();
+ const GLuint cmdlen = 44;
+ emit_header(gc->pc, X_GLrop_ProgramLocalParameter4dvARB, cmdlen);
+ (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
+ (void) memcpy((void *)(gc->pc + 8), (void *)(&index), 4);
+ (void) memcpy((void *)(gc->pc + 12), (void *)(&x), 8);
+ (void) memcpy((void *)(gc->pc + 20), (void *)(&y), 8);
+ (void) memcpy((void *)(gc->pc + 28), (void *)(&z), 8);
+ (void) memcpy((void *)(gc->pc + 36), (void *)(&w), 8);
+ gc->pc += cmdlen;
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_ProgramLocalParameter4dvARB 4216
+void
+__indirect_glProgramLocalParameter4dvARB(GLenum target, GLuint index, const GLdouble * params)
+{
+ __GLXcontext * const gc = __glXGetCurrentContext();
+ const GLuint cmdlen = 44;
+ emit_header(gc->pc, X_GLrop_ProgramLocalParameter4dvARB, cmdlen);
+ (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
+ (void) memcpy((void *)(gc->pc + 8), (void *)(&index), 4);
+ (void) memcpy((void *)(gc->pc + 12), (void *)(params), 32);
+ gc->pc += cmdlen;
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_ProgramLocalParameter4fvARB 4215
+void
+__indirect_glProgramLocalParameter4fARB(GLenum target, GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
+{
+ __GLXcontext * const gc = __glXGetCurrentContext();
+ const GLuint cmdlen = 28;
+ emit_header(gc->pc, X_GLrop_ProgramLocalParameter4fvARB, cmdlen);
+ (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
+ (void) memcpy((void *)(gc->pc + 8), (void *)(&index), 4);
+ (void) memcpy((void *)(gc->pc + 12), (void *)(&x), 4);
+ (void) memcpy((void *)(gc->pc + 16), (void *)(&y), 4);
+ (void) memcpy((void *)(gc->pc + 20), (void *)(&z), 4);
+ (void) memcpy((void *)(gc->pc + 24), (void *)(&w), 4);
+ gc->pc += cmdlen;
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_ProgramLocalParameter4fvARB 4215
+void
+__indirect_glProgramLocalParameter4fvARB(GLenum target, GLuint index, const GLfloat * params)
+{
+ __GLXcontext * const gc = __glXGetCurrentContext();
+ const GLuint cmdlen = 28;
+ emit_header(gc->pc, X_GLrop_ProgramLocalParameter4fvARB, cmdlen);
+ (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
+ (void) memcpy((void *)(gc->pc + 8), (void *)(&index), 4);
+ (void) memcpy((void *)(gc->pc + 12), (void *)(params), 16);
+ gc->pc += cmdlen;
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLvop_GetProgramivARB 1307
+void
+__indirect_glGetProgramivARB(GLenum target, GLenum pname, GLint * params)
+{
+ __GLXcontext * const gc = __glXGetCurrentContext();
+ Display * const dpy = gc->currentDpy;
+ const GLuint cmdlen = 8;
+ if (__builtin_expect(dpy != NULL, 1)) {
+ GLubyte const * pc = __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithReply, X_GLvop_GetProgramivARB, cmdlen);
+ (void) memcpy((void *)(pc + 0), (void *)(&target), 4);
+ (void) memcpy((void *)(pc + 4), (void *)(&pname), 4);
+ (void) __glXReadReply(dpy, 4, params, GL_FALSE);
+ UnlockDisplay(dpy); SyncHandle();
+ }
+ return;
+}
+
+#define X_GLvop_GetProgramStringARB 1308
+void
+__indirect_glGetProgramStringARB(GLenum target, GLenum pname, GLvoid * string)
+{
+ __GLXcontext * const gc = __glXGetCurrentContext();
+ Display * const dpy = gc->currentDpy;
+ const GLuint cmdlen = 8;
+ if (__builtin_expect(dpy != NULL, 1)) {
+ GLubyte const * pc = __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithReply, X_GLvop_GetProgramStringARB, cmdlen);
+ (void) memcpy((void *)(pc + 0), (void *)(&target), 4);
+ (void) memcpy((void *)(pc + 4), (void *)(&pname), 4);
+ (void) __glXReadReply(dpy, 1, string, GL_TRUE);
+ UnlockDisplay(dpy); SyncHandle();
+ }
+ return;
+}
+
+#define X_GLrop_ProgramNamedParameter4fvNV 4218
+void
+__indirect_glProgramNamedParameter4fNV(GLuint id, GLsizei len, const GLubyte * name, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
+{
+ __GLXcontext * const gc = __glXGetCurrentContext();
+ const GLuint cmdlen = 28 + __GLX_PAD(len);
+ if (__builtin_expect(len >= 0, 1)) {
+ emit_header(gc->pc, X_GLrop_ProgramNamedParameter4fvNV, cmdlen);
+ (void) memcpy((void *)(gc->pc + 4), (void *)(&id), 4);
+ (void) memcpy((void *)(gc->pc + 8), (void *)(&len), 4);
+ (void) memcpy((void *)(gc->pc + 12), (void *)(&x), 4);
+ (void) memcpy((void *)(gc->pc + 16), (void *)(&y), 4);
+ (void) memcpy((void *)(gc->pc + 20), (void *)(&z), 4);
+ (void) memcpy((void *)(gc->pc + 24), (void *)(&w), 4);
+ (void) memcpy((void *)(gc->pc + 28), (void *)(name), len);
+ gc->pc += cmdlen;
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+ }
+}
+
+#define X_GLrop_ProgramNamedParameter4dvNV 4219
+void
+__indirect_glProgramNamedParameter4dNV(GLuint id, GLsizei len, const GLubyte * name, GLdouble x, GLdouble y, GLdouble z, GLdouble w)
+{
+ __GLXcontext * const gc = __glXGetCurrentContext();
+ const GLuint cmdlen = 44 + __GLX_PAD(len);
+ if (__builtin_expect(len >= 0, 1)) {
+ emit_header(gc->pc, X_GLrop_ProgramNamedParameter4dvNV, cmdlen);
+ (void) memcpy((void *)(gc->pc + 4), (void *)(&x), 8);
+ (void) memcpy((void *)(gc->pc + 12), (void *)(&y), 8);
+ (void) memcpy((void *)(gc->pc + 20), (void *)(&z), 8);
+ (void) memcpy((void *)(gc->pc + 28), (void *)(&w), 8);
+ (void) memcpy((void *)(gc->pc + 36), (void *)(&id), 4);
+ (void) memcpy((void *)(gc->pc + 40), (void *)(&len), 4);
+ (void) memcpy((void *)(gc->pc + 44), (void *)(name), len);
+ gc->pc += cmdlen;
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+ }
+}
+
+#define X_GLrop_ProgramNamedParameter4fvNV 4218
+void
+__indirect_glProgramNamedParameter4fvNV(GLuint id, GLsizei len, const GLubyte * name, const GLfloat * v)
+{
+ __GLXcontext * const gc = __glXGetCurrentContext();
+ const GLuint cmdlen = 28 + __GLX_PAD(len);
+ if (__builtin_expect(len >= 0, 1)) {
+ emit_header(gc->pc, X_GLrop_ProgramNamedParameter4fvNV, cmdlen);
+ (void) memcpy((void *)(gc->pc + 4), (void *)(&id), 4);
+ (void) memcpy((void *)(gc->pc + 8), (void *)(&len), 4);
+ (void) memcpy((void *)(gc->pc + 12), (void *)(v), 16);
+ (void) memcpy((void *)(gc->pc + 28), (void *)(name), len);
+ gc->pc += cmdlen;
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+ }
+}
+
+#define X_GLrop_ProgramNamedParameter4dvNV 4219
+void
+__indirect_glProgramNamedParameter4dvNV(GLuint id, GLsizei len, const GLubyte * name, const GLdouble * v)
+{
+ __GLXcontext * const gc = __glXGetCurrentContext();
+ const GLuint cmdlen = 44 + __GLX_PAD(len);
+ if (__builtin_expect(len >= 0, 1)) {
+ emit_header(gc->pc, X_GLrop_ProgramNamedParameter4dvNV, cmdlen);
+ (void) memcpy((void *)(gc->pc + 4), (void *)(v), 32);
+ (void) memcpy((void *)(gc->pc + 36), (void *)(&id), 4);
+ (void) memcpy((void *)(gc->pc + 40), (void *)(&len), 4);
+ (void) memcpy((void *)(gc->pc + 44), (void *)(name), len);
+ gc->pc += cmdlen;
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+ }
+}
+
+#define X_GLvop_GetProgramNamedParameterfvNV 1310
+void
+__indirect_glGetProgramNamedParameterfvNV(GLuint id, GLsizei len, const GLubyte * name, GLfloat * params)
+{
+ __GLXcontext * const gc = __glXGetCurrentContext();
+ Display * const dpy = gc->currentDpy;
+ const GLuint cmdlen = 8 + __GLX_PAD(len);
+ if (__builtin_expect((len >= 0) && (dpy != NULL), 1)) {
+ GLubyte const * pc = __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithReply, X_GLvop_GetProgramNamedParameterfvNV, cmdlen);
+ (void) memcpy((void *)(pc + 0), (void *)(&id), 4);
+ (void) memcpy((void *)(pc + 4), (void *)(&len), 4);
+ (void) memcpy((void *)(pc + 8), (void *)(name), len);
+ (void) __glXReadReply(dpy, 4, params, GL_TRUE);
+ UnlockDisplay(dpy); SyncHandle();
+ }
+ return;
+}
+
+#define X_GLvop_GetProgramNamedParameterdvNV 1311
+void
+__indirect_glGetProgramNamedParameterdvNV(GLuint id, GLsizei len, const GLubyte * name, GLdouble * params)
+{
+ __GLXcontext * const gc = __glXGetCurrentContext();
+ Display * const dpy = gc->currentDpy;
+ const GLuint cmdlen = 8 + __GLX_PAD(len);
+ if (__builtin_expect((len >= 0) && (dpy != NULL), 1)) {
+ GLubyte const * pc = __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithReply, X_GLvop_GetProgramNamedParameterdvNV, cmdlen);
+ (void) memcpy((void *)(pc + 0), (void *)(&id), 4);
+ (void) memcpy((void *)(pc + 4), (void *)(&len), 4);
+ (void) memcpy((void *)(pc + 8), (void *)(name), len);
+ (void) __glXReadReply(dpy, 8, params, GL_TRUE);
+ UnlockDisplay(dpy); SyncHandle();
+ }
+ return;
+}
+
+#define X_GLsop_GenQueriesARB 162
+void
+__indirect_glGenQueriesARB(GLsizei n, GLuint * ids)
+{
+ __GLXcontext * const gc = __glXGetCurrentContext();
+ Display * const dpy = gc->currentDpy;
+ const GLuint cmdlen = 4;
+ if (__builtin_expect((n >= 0) && (dpy != NULL), 1)) {
+#ifdef USE_XCB
+ XCBConnection *c = XCBConnectionOfDisplay(dpy);
+ (void) __glXFlushRenderBuffer(gc, gc->pc);
+ XCBGlxGenQueriesARBRep *reply = XCBGlxGenQueriesARBReply(c, XCBGlxGenQueriesARB(c, gc->currentContextTag, n), NULL);
+ (void)memcpy(ids, XCBGlxGenQueriesARBData(reply), XCBGlxGenQueriesARBDataLength(reply) * sizeof(GLuint));
+ free(reply);
+#else
+ GLubyte const * pc = __glXSetupSingleRequest(gc, X_GLsop_GenQueriesARB, cmdlen);
+ (void) memcpy((void *)(pc + 0), (void *)(&n), 4);
+ (void) __glXReadReply(dpy, 4, ids, GL_TRUE);
+ UnlockDisplay(dpy); SyncHandle();
+#endif /* USE_XCB */
+ }
+ return;
+}
+
+#define X_GLsop_DeleteQueriesARB 161
+void
+__indirect_glDeleteQueriesARB(GLsizei n, const GLuint * ids)
+{
+ __GLXcontext * const gc = __glXGetCurrentContext();
+ Display * const dpy = gc->currentDpy;
+ const GLuint cmdlen = 4 + __GLX_PAD((n * 4));
+ if (__builtin_expect((n >= 0) && (dpy != NULL), 1)) {
+#ifdef USE_XCB
+ XCBConnection *c = XCBConnectionOfDisplay(dpy);
+ (void) __glXFlushRenderBuffer(gc, gc->pc);
+ XCBGlxDeleteQueriesARB(c, gc->currentContextTag, n, ids);
+#else
+ GLubyte const * pc = __glXSetupSingleRequest(gc, X_GLsop_DeleteQueriesARB, cmdlen);
+ (void) memcpy((void *)(pc + 0), (void *)(&n), 4);
+ (void) memcpy((void *)(pc + 4), (void *)(ids), (n * 4));
+ UnlockDisplay(dpy); SyncHandle();
+#endif /* USE_XCB */
+ }
+ return;
+}
+
+#define X_GLsop_IsQueryARB 163
+GLboolean
+__indirect_glIsQueryARB(GLuint id)
+{
+ __GLXcontext * const gc = __glXGetCurrentContext();
+ Display * const dpy = gc->currentDpy;
+ GLboolean retval = (GLboolean) 0;
+ const GLuint cmdlen = 4;
+ if (__builtin_expect(dpy != NULL, 1)) {
+#ifdef USE_XCB
+ XCBConnection *c = XCBConnectionOfDisplay(dpy);
+ (void) __glXFlushRenderBuffer(gc, gc->pc);
+ XCBGlxIsQueryARBRep *reply = XCBGlxIsQueryARBReply(c, XCBGlxIsQueryARB(c, gc->currentContextTag, id), NULL);
+ retval = reply->ret_val;
+ free(reply);
+#else
+ GLubyte const * pc = __glXSetupSingleRequest(gc, X_GLsop_IsQueryARB, cmdlen);
+ (void) memcpy((void *)(pc + 0), (void *)(&id), 4);
+ retval = (GLboolean) __glXReadReply(dpy, 0, NULL, GL_FALSE);
+ UnlockDisplay(dpy); SyncHandle();
+#endif /* USE_XCB */
+ }
+ return retval;
+}
+
+#define X_GLrop_BeginQueryARB 231
+void
+__indirect_glBeginQueryARB(GLenum target, GLuint id)
+{
+ __GLXcontext * const gc = __glXGetCurrentContext();
+ const GLuint cmdlen = 12;
+ emit_header(gc->pc, X_GLrop_BeginQueryARB, cmdlen);
+ (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
+ (void) memcpy((void *)(gc->pc + 8), (void *)(&id), 4);
+ gc->pc += cmdlen;
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_EndQueryARB 232
+void
+__indirect_glEndQueryARB(GLenum target)
+{
+ __GLXcontext * const gc = __glXGetCurrentContext();
+ const GLuint cmdlen = 8;
+ emit_header(gc->pc, X_GLrop_EndQueryARB, cmdlen);
+ (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
+ gc->pc += cmdlen;
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLsop_GetQueryivARB 164
+void
+__indirect_glGetQueryivARB(GLenum target, GLenum pname, GLint * params)
+{
+ __GLXcontext * const gc = __glXGetCurrentContext();
+ Display * const dpy = gc->currentDpy;
+ const GLuint cmdlen = 8;
+ if (__builtin_expect(dpy != NULL, 1)) {
+#ifdef USE_XCB
+ XCBConnection *c = XCBConnectionOfDisplay(dpy);
+ (void) __glXFlushRenderBuffer(gc, gc->pc);
+ XCBGlxGetQueryivARBRep *reply = XCBGlxGetQueryivARBReply(c, XCBGlxGetQueryivARB(c, gc->currentContextTag, target, pname), NULL);
+ if (XCBGlxGetQueryivARBDataLength(reply) == 0)
+ (void)memcpy(params, &reply->datum, sizeof(reply->datum));
+ else
+ (void)memcpy(params, XCBGlxGetQueryivARBData(reply), XCBGlxGetQueryivARBDataLength(reply) * sizeof(GLint));
+ free(reply);
+#else
+ GLubyte const * pc = __glXSetupSingleRequest(gc, X_GLsop_GetQueryivARB, cmdlen);
+ (void) memcpy((void *)(pc + 0), (void *)(&target), 4);
+ (void) memcpy((void *)(pc + 4), (void *)(&pname), 4);
+ (void) __glXReadReply(dpy, 4, params, GL_FALSE);
+ UnlockDisplay(dpy); SyncHandle();
+#endif /* USE_XCB */
+ }
+ return;
+}
+
+#define X_GLsop_GetQueryObjectivARB 165
+void
+__indirect_glGetQueryObjectivARB(GLuint id, GLenum pname, GLint * params)
+{
+ __GLXcontext * const gc = __glXGetCurrentContext();
+ Display * const dpy = gc->currentDpy;
+ const GLuint cmdlen = 8;
+ if (__builtin_expect(dpy != NULL, 1)) {
+#ifdef USE_XCB
+ XCBConnection *c = XCBConnectionOfDisplay(dpy);
+ (void) __glXFlushRenderBuffer(gc, gc->pc);
+ XCBGlxGetQueryObjectivARBRep *reply = XCBGlxGetQueryObjectivARBReply(c, XCBGlxGetQueryObjectivARB(c, gc->currentContextTag, id, pname), NULL);
+ if (XCBGlxGetQueryObjectivARBDataLength(reply) == 0)
+ (void)memcpy(params, &reply->datum, sizeof(reply->datum));
+ else
+ (void)memcpy(params, XCBGlxGetQueryObjectivARBData(reply), XCBGlxGetQueryObjectivARBDataLength(reply) * sizeof(GLint));
+ free(reply);
+#else
+ GLubyte const * pc = __glXSetupSingleRequest(gc, X_GLsop_GetQueryObjectivARB, cmdlen);
+ (void) memcpy((void *)(pc + 0), (void *)(&id), 4);
+ (void) memcpy((void *)(pc + 4), (void *)(&pname), 4);
+ (void) __glXReadReply(dpy, 4, params, GL_FALSE);
+ UnlockDisplay(dpy); SyncHandle();
+#endif /* USE_XCB */
+ }
+ return;
+}
+
+#define X_GLsop_GetQueryObjectuivARB 166
+void
+__indirect_glGetQueryObjectuivARB(GLuint id, GLenum pname, GLuint * params)
+{
+ __GLXcontext * const gc = __glXGetCurrentContext();
+ Display * const dpy = gc->currentDpy;
+ const GLuint cmdlen = 8;
+ if (__builtin_expect(dpy != NULL, 1)) {
+#ifdef USE_XCB
+ XCBConnection *c = XCBConnectionOfDisplay(dpy);
+ (void) __glXFlushRenderBuffer(gc, gc->pc);
+ XCBGlxGetQueryObjectuivARBRep *reply = XCBGlxGetQueryObjectuivARBReply(c, XCBGlxGetQueryObjectuivARB(c, gc->currentContextTag, id, pname), NULL);
+ if (XCBGlxGetQueryObjectuivARBDataLength(reply) == 0)
+ (void)memcpy(params, &reply->datum, sizeof(reply->datum));
+ else
+ (void)memcpy(params, XCBGlxGetQueryObjectuivARBData(reply), XCBGlxGetQueryObjectuivARBDataLength(reply) * sizeof(GLuint));
+ free(reply);
+#else
+ GLubyte const * pc = __glXSetupSingleRequest(gc, X_GLsop_GetQueryObjectuivARB, cmdlen);
+ (void) memcpy((void *)(pc + 0), (void *)(&id), 4);
+ (void) memcpy((void *)(pc + 4), (void *)(&pname), 4);
+ (void) __glXReadReply(dpy, 4, params, GL_FALSE);
+ UnlockDisplay(dpy); SyncHandle();
+#endif /* USE_XCB */
+ }
+ return;
+}
+
+#define X_GLvop_GetVertexAttribdvNV 1301
+void
+__indirect_glGetVertexAttribdvNV(GLuint index, GLenum pname, GLdouble * params)
+{
+ __GLXcontext * const gc = __glXGetCurrentContext();
+ Display * const dpy = gc->currentDpy;
+ const GLuint cmdlen = 8;
+ if (__builtin_expect(dpy != NULL, 1)) {
+ GLubyte const * pc = __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithReply, X_GLvop_GetVertexAttribdvNV, cmdlen);
+ (void) memcpy((void *)(pc + 0), (void *)(&index), 4);
+ (void) memcpy((void *)(pc + 4), (void *)(&pname), 4);
+ (void) __glXReadReply(dpy, 8, params, GL_FALSE);
+ UnlockDisplay(dpy); SyncHandle();
+ }
+ return;
+}
+
+#define X_GLvop_GetVertexAttribfvNV 1302
+void
+__indirect_glGetVertexAttribfvNV(GLuint index, GLenum pname, GLfloat * params)
+{
+ __GLXcontext * const gc = __glXGetCurrentContext();
+ Display * const dpy = gc->currentDpy;
+ const GLuint cmdlen = 8;
+ if (__builtin_expect(dpy != NULL, 1)) {
+ GLubyte const * pc = __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithReply, X_GLvop_GetVertexAttribfvNV, cmdlen);
+ (void) memcpy((void *)(pc + 0), (void *)(&index), 4);
+ (void) memcpy((void *)(pc + 4), (void *)(&pname), 4);
+ (void) __glXReadReply(dpy, 4, params, GL_FALSE);
+ UnlockDisplay(dpy); SyncHandle();
+ }
+ return;
+}
+
+#define X_GLvop_GetVertexAttribivNV 1303
+void
+__indirect_glGetVertexAttribivNV(GLuint index, GLenum pname, GLint * params)
+{
+ __GLXcontext * const gc = __glXGetCurrentContext();
+ Display * const dpy = gc->currentDpy;
+ const GLuint cmdlen = 8;
+ if (__builtin_expect(dpy != NULL, 1)) {
+ GLubyte const * pc = __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithReply, X_GLvop_GetVertexAttribivNV, cmdlen);
+ (void) memcpy((void *)(pc + 0), (void *)(&index), 4);
+ (void) memcpy((void *)(pc + 4), (void *)(&pname), 4);
+ (void) __glXReadReply(dpy, 4, params, GL_FALSE);
+ UnlockDisplay(dpy); SyncHandle();
+ }
+ return;
+}
+
+#define X_GLrop_VertexAttrib1dvNV 4197
+void
+__indirect_glVertexAttrib1dNV(GLuint index, GLdouble x)
+{
+ __GLXcontext * const gc = __glXGetCurrentContext();
+ const GLuint cmdlen = 16;
+ emit_header(gc->pc, X_GLrop_VertexAttrib1dvNV, cmdlen);
+ (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
+ (void) memcpy((void *)(gc->pc + 8), (void *)(&x), 8);
+ gc->pc += cmdlen;
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_VertexAttrib1dvNV 4197
+void
+__indirect_glVertexAttrib1dvNV(GLuint index, const GLdouble * v)
+{
+ __GLXcontext * const gc = __glXGetCurrentContext();
+ const GLuint cmdlen = 16;
+ emit_header(gc->pc, X_GLrop_VertexAttrib1dvNV, cmdlen);
+ (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
+ (void) memcpy((void *)(gc->pc + 8), (void *)(v), 8);
+ gc->pc += cmdlen;
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_VertexAttrib1fvNV 4193
+void
+__indirect_glVertexAttrib1fNV(GLuint index, GLfloat x)
+{
+ __GLXcontext * const gc = __glXGetCurrentContext();
+ const GLuint cmdlen = 12;
+ emit_header(gc->pc, X_GLrop_VertexAttrib1fvNV, cmdlen);
+ (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
+ (void) memcpy((void *)(gc->pc + 8), (void *)(&x), 4);
+ gc->pc += cmdlen;
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_VertexAttrib1fvNV 4193
+void
+__indirect_glVertexAttrib1fvNV(GLuint index, const GLfloat * v)
+{
+ __GLXcontext * const gc = __glXGetCurrentContext();
+ const GLuint cmdlen = 12;
+ emit_header(gc->pc, X_GLrop_VertexAttrib1fvNV, cmdlen);
+ (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
+ (void) memcpy((void *)(gc->pc + 8), (void *)(v), 4);
+ gc->pc += cmdlen;
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_VertexAttrib1svNV 4189
+void
+__indirect_glVertexAttrib1sNV(GLuint index, GLshort x)
+{
+ __GLXcontext * const gc = __glXGetCurrentContext();
+ const GLuint cmdlen = 12;
+ emit_header(gc->pc, X_GLrop_VertexAttrib1svNV, cmdlen);
+ (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
+ (void) memcpy((void *)(gc->pc + 8), (void *)(&x), 2);
+ gc->pc += cmdlen;
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_VertexAttrib1svNV 4189
+void
+__indirect_glVertexAttrib1svNV(GLuint index, const GLshort * v)
+{
+ __GLXcontext * const gc = __glXGetCurrentContext();
+ const GLuint cmdlen = 12;
+ emit_header(gc->pc, X_GLrop_VertexAttrib1svNV, cmdlen);
+ (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
+ (void) memcpy((void *)(gc->pc + 8), (void *)(v), 2);
+ gc->pc += cmdlen;
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_VertexAttrib2dvNV 4198
+void
+__indirect_glVertexAttrib2dNV(GLuint index, GLdouble x, GLdouble y)
+{
+ __GLXcontext * const gc = __glXGetCurrentContext();
+ const GLuint cmdlen = 24;
+ emit_header(gc->pc, X_GLrop_VertexAttrib2dvNV, cmdlen);
+ (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
+ (void) memcpy((void *)(gc->pc + 8), (void *)(&x), 8);
+ (void) memcpy((void *)(gc->pc + 16), (void *)(&y), 8);
+ gc->pc += cmdlen;
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_VertexAttrib2dvNV 4198
+void
+__indirect_glVertexAttrib2dvNV(GLuint index, const GLdouble * v)
+{
+ __GLXcontext * const gc = __glXGetCurrentContext();
+ const GLuint cmdlen = 24;
+ emit_header(gc->pc, X_GLrop_VertexAttrib2dvNV, cmdlen);
+ (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
+ (void) memcpy((void *)(gc->pc + 8), (void *)(v), 16);
+ gc->pc += cmdlen;
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_VertexAttrib2fvNV 4194
+void
+__indirect_glVertexAttrib2fNV(GLuint index, GLfloat x, GLfloat y)
+{
+ __GLXcontext * const gc = __glXGetCurrentContext();
+ const GLuint cmdlen = 16;
+ emit_header(gc->pc, X_GLrop_VertexAttrib2fvNV, cmdlen);
+ (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
+ (void) memcpy((void *)(gc->pc + 8), (void *)(&x), 4);
+ (void) memcpy((void *)(gc->pc + 12), (void *)(&y), 4);
+ gc->pc += cmdlen;
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_VertexAttrib2fvNV 4194
+void
+__indirect_glVertexAttrib2fvNV(GLuint index, const GLfloat * v)
+{
+ __GLXcontext * const gc = __glXGetCurrentContext();
+ const GLuint cmdlen = 16;
+ emit_header(gc->pc, X_GLrop_VertexAttrib2fvNV, cmdlen);
+ (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
+ (void) memcpy((void *)(gc->pc + 8), (void *)(v), 8);
+ gc->pc += cmdlen;
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_VertexAttrib2svNV 4190
+void
+__indirect_glVertexAttrib2sNV(GLuint index, GLshort x, GLshort y)
+{
+ __GLXcontext * const gc = __glXGetCurrentContext();
+ const GLuint cmdlen = 12;
+ emit_header(gc->pc, X_GLrop_VertexAttrib2svNV, cmdlen);
+ (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
+ (void) memcpy((void *)(gc->pc + 8), (void *)(&x), 2);
+ (void) memcpy((void *)(gc->pc + 10), (void *)(&y), 2);
+ gc->pc += cmdlen;
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_VertexAttrib2svNV 4190
+void
+__indirect_glVertexAttrib2svNV(GLuint index, const GLshort * v)
+{
+ __GLXcontext * const gc = __glXGetCurrentContext();
+ const GLuint cmdlen = 12;
+ emit_header(gc->pc, X_GLrop_VertexAttrib2svNV, cmdlen);
+ (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
+ (void) memcpy((void *)(gc->pc + 8), (void *)(v), 4);
+ gc->pc += cmdlen;
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_VertexAttrib3dvNV 4199
+void
+__indirect_glVertexAttrib3dNV(GLuint index, GLdouble x, GLdouble y, GLdouble z)
+{
+ __GLXcontext * const gc = __glXGetCurrentContext();
+ const GLuint cmdlen = 32;
+ emit_header(gc->pc, X_GLrop_VertexAttrib3dvNV, cmdlen);
+ (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
+ (void) memcpy((void *)(gc->pc + 8), (void *)(&x), 8);
+ (void) memcpy((void *)(gc->pc + 16), (void *)(&y), 8);
+ (void) memcpy((void *)(gc->pc + 24), (void *)(&z), 8);
+ gc->pc += cmdlen;
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_VertexAttrib3dvNV 4199
+void
+__indirect_glVertexAttrib3dvNV(GLuint index, const GLdouble * v)
+{
+ __GLXcontext * const gc = __glXGetCurrentContext();
+ const GLuint cmdlen = 32;
+ emit_header(gc->pc, X_GLrop_VertexAttrib3dvNV, cmdlen);
+ (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
+ (void) memcpy((void *)(gc->pc + 8), (void *)(v), 24);
+ gc->pc += cmdlen;
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_VertexAttrib3fvNV 4195
+void
+__indirect_glVertexAttrib3fNV(GLuint index, GLfloat x, GLfloat y, GLfloat z)
+{
+ __GLXcontext * const gc = __glXGetCurrentContext();
+ const GLuint cmdlen = 20;
+ emit_header(gc->pc, X_GLrop_VertexAttrib3fvNV, cmdlen);
+ (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
+ (void) memcpy((void *)(gc->pc + 8), (void *)(&x), 4);
+ (void) memcpy((void *)(gc->pc + 12), (void *)(&y), 4);
+ (void) memcpy((void *)(gc->pc + 16), (void *)(&z), 4);
+ gc->pc += cmdlen;
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_VertexAttrib3fvNV 4195
+void
+__indirect_glVertexAttrib3fvNV(GLuint index, const GLfloat * v)
+{
+ __GLXcontext * const gc = __glXGetCurrentContext();
+ const GLuint cmdlen = 20;
+ emit_header(gc->pc, X_GLrop_VertexAttrib3fvNV, cmdlen);
+ (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
+ (void) memcpy((void *)(gc->pc + 8), (void *)(v), 12);
+ gc->pc += cmdlen;
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_VertexAttrib3svNV 4191
+void
+__indirect_glVertexAttrib3sNV(GLuint index, GLshort x, GLshort y, GLshort z)
+{
+ __GLXcontext * const gc = __glXGetCurrentContext();
+ const GLuint cmdlen = 16;
+ emit_header(gc->pc, X_GLrop_VertexAttrib3svNV, cmdlen);
+ (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
+ (void) memcpy((void *)(gc->pc + 8), (void *)(&x), 2);
+ (void) memcpy((void *)(gc->pc + 10), (void *)(&y), 2);
+ (void) memcpy((void *)(gc->pc + 12), (void *)(&z), 2);
+ gc->pc += cmdlen;
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_VertexAttrib3svNV 4191
+void
+__indirect_glVertexAttrib3svNV(GLuint index, const GLshort * v)
+{
+ __GLXcontext * const gc = __glXGetCurrentContext();
+ const GLuint cmdlen = 16;
+ emit_header(gc->pc, X_GLrop_VertexAttrib3svNV, cmdlen);
+ (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
+ (void) memcpy((void *)(gc->pc + 8), (void *)(v), 6);
+ gc->pc += cmdlen;
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_VertexAttrib4dvNV 4200
+void
+__indirect_glVertexAttrib4dNV(GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w)
+{
+ __GLXcontext * const gc = __glXGetCurrentContext();
+ const GLuint cmdlen = 40;
+ emit_header(gc->pc, X_GLrop_VertexAttrib4dvNV, cmdlen);
+ (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
+ (void) memcpy((void *)(gc->pc + 8), (void *)(&x), 8);
+ (void) memcpy((void *)(gc->pc + 16), (void *)(&y), 8);
+ (void) memcpy((void *)(gc->pc + 24), (void *)(&z), 8);
+ (void) memcpy((void *)(gc->pc + 32), (void *)(&w), 8);
+ gc->pc += cmdlen;
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_VertexAttrib4dvNV 4200
+void
+__indirect_glVertexAttrib4dvNV(GLuint index, const GLdouble * v)
+{
+ __GLXcontext * const gc = __glXGetCurrentContext();
+ const GLuint cmdlen = 40;
+ emit_header(gc->pc, X_GLrop_VertexAttrib4dvNV, cmdlen);
+ (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
+ (void) memcpy((void *)(gc->pc + 8), (void *)(v), 32);
+ gc->pc += cmdlen;
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_VertexAttrib4fvNV 4196
+void
+__indirect_glVertexAttrib4fNV(GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
+{
+ __GLXcontext * const gc = __glXGetCurrentContext();
+ const GLuint cmdlen = 24;
+ emit_header(gc->pc, X_GLrop_VertexAttrib4fvNV, cmdlen);
+ (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
+ (void) memcpy((void *)(gc->pc + 8), (void *)(&x), 4);
+ (void) memcpy((void *)(gc->pc + 12), (void *)(&y), 4);
+ (void) memcpy((void *)(gc->pc + 16), (void *)(&z), 4);
+ (void) memcpy((void *)(gc->pc + 20), (void *)(&w), 4);
+ gc->pc += cmdlen;
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_VertexAttrib4fvNV 4196
+void
+__indirect_glVertexAttrib4fvNV(GLuint index, const GLfloat * v)
+{
+ __GLXcontext * const gc = __glXGetCurrentContext();
+ const GLuint cmdlen = 24;
+ emit_header(gc->pc, X_GLrop_VertexAttrib4fvNV, cmdlen);
+ (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
+ (void) memcpy((void *)(gc->pc + 8), (void *)(v), 16);
+ gc->pc += cmdlen;
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_VertexAttrib4svNV 4192
+void
+__indirect_glVertexAttrib4sNV(GLuint index, GLshort x, GLshort y, GLshort z, GLshort w)
+{
+ __GLXcontext * const gc = __glXGetCurrentContext();
+ const GLuint cmdlen = 16;
+ emit_header(gc->pc, X_GLrop_VertexAttrib4svNV, cmdlen);
+ (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
+ (void) memcpy((void *)(gc->pc + 8), (void *)(&x), 2);
+ (void) memcpy((void *)(gc->pc + 10), (void *)(&y), 2);
+ (void) memcpy((void *)(gc->pc + 12), (void *)(&z), 2);
+ (void) memcpy((void *)(gc->pc + 14), (void *)(&w), 2);
+ gc->pc += cmdlen;
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_VertexAttrib4svNV 4192
+void
+__indirect_glVertexAttrib4svNV(GLuint index, const GLshort * v)
+{
+ __GLXcontext * const gc = __glXGetCurrentContext();
+ const GLuint cmdlen = 16;
+ emit_header(gc->pc, X_GLrop_VertexAttrib4svNV, cmdlen);
+ (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
+ (void) memcpy((void *)(gc->pc + 8), (void *)(v), 8);
+ gc->pc += cmdlen;
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_VertexAttrib4ubvNV 4201
+void
+__indirect_glVertexAttrib4ubNV(GLuint index, GLubyte x, GLubyte y, GLubyte z, GLubyte w)
+{
+ __GLXcontext * const gc = __glXGetCurrentContext();
+ const GLuint cmdlen = 12;
+ emit_header(gc->pc, X_GLrop_VertexAttrib4ubvNV, cmdlen);
+ (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
+ (void) memcpy((void *)(gc->pc + 8), (void *)(&x), 1);
+ (void) memcpy((void *)(gc->pc + 9), (void *)(&y), 1);
+ (void) memcpy((void *)(gc->pc + 10), (void *)(&z), 1);
+ (void) memcpy((void *)(gc->pc + 11), (void *)(&w), 1);
+ gc->pc += cmdlen;
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_VertexAttrib4ubvNV 4201
+void
+__indirect_glVertexAttrib4ubvNV(GLuint index, const GLubyte * v)
+{
+ __GLXcontext * const gc = __glXGetCurrentContext();
+ const GLuint cmdlen = 12;
+ emit_header(gc->pc, X_GLrop_VertexAttrib4ubvNV, cmdlen);
+ (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
+ (void) memcpy((void *)(gc->pc + 8), (void *)(v), 4);
+ gc->pc += cmdlen;
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLvop_IsRenderbufferEXT 1422
+GLboolean
+__indirect_glIsRenderbufferEXT(GLuint renderbuffer)
+{
+ __GLXcontext * const gc = __glXGetCurrentContext();
+ Display * const dpy = gc->currentDpy;
+ GLboolean retval = (GLboolean) 0;
+ const GLuint cmdlen = 4;
+ if (__builtin_expect(dpy != NULL, 1)) {
+ GLubyte const * pc = __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithReply, X_GLvop_IsRenderbufferEXT, cmdlen);
+ (void) memcpy((void *)(pc + 0), (void *)(&renderbuffer), 4);
+ retval = (GLboolean) __glXReadReply(dpy, 0, NULL, GL_FALSE);
+ UnlockDisplay(dpy); SyncHandle();
+ }
+ return retval;
+}
+
+#define X_GLrop_BindRenderbufferEXT 4316
+void
+__indirect_glBindRenderbufferEXT(GLenum target, GLuint renderbuffer)
+{
+ __GLXcontext * const gc = __glXGetCurrentContext();
+ const GLuint cmdlen = 12;
+ emit_header(gc->pc, X_GLrop_BindRenderbufferEXT, cmdlen);
+ (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
+ (void) memcpy((void *)(gc->pc + 8), (void *)(&renderbuffer), 4);
+ gc->pc += cmdlen;
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_DeleteRenderbuffersEXT 4317
+void
+__indirect_glDeleteRenderbuffersEXT(GLsizei n, const GLuint * renderbuffers)
+{
+ __GLXcontext * const gc = __glXGetCurrentContext();
+ const GLuint cmdlen = 8 + __GLX_PAD((n * 4));
+ if (__builtin_expect(n >= 0, 1)) {
+ emit_header(gc->pc, X_GLrop_DeleteRenderbuffersEXT, cmdlen);
+ (void) memcpy((void *)(gc->pc + 4), (void *)(&n), 4);
+ (void) memcpy((void *)(gc->pc + 8), (void *)(renderbuffers), (n * 4));
+ gc->pc += cmdlen;
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+ }
+}
+
+#define X_GLvop_GenRenderbuffersEXT 1423
+void
+__indirect_glGenRenderbuffersEXT(GLsizei n, GLuint * renderbuffers)
+{
+ __GLXcontext * const gc = __glXGetCurrentContext();
+ Display * const dpy = gc->currentDpy;
+ const GLuint cmdlen = 4;
+ if (__builtin_expect((n >= 0) && (dpy != NULL), 1)) {
+ GLubyte const * pc = __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithReply, X_GLvop_GenRenderbuffersEXT, cmdlen);
+ (void) memcpy((void *)(pc + 0), (void *)(&n), 4);
+ (void) __glXReadReply(dpy, 4, renderbuffers, GL_TRUE);
+ UnlockDisplay(dpy); SyncHandle();
+ }
+ return;
+}
+
+#define X_GLrop_RenderbufferStorageEXT 4318
+void
+__indirect_glRenderbufferStorageEXT(GLenum target, GLenum internalformat, GLsizei width, GLsizei height)
+{
+ __GLXcontext * const gc = __glXGetCurrentContext();
+ const GLuint cmdlen = 20;
+ emit_header(gc->pc, X_GLrop_RenderbufferStorageEXT, cmdlen);
+ (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
+ (void) memcpy((void *)(gc->pc + 8), (void *)(&internalformat), 4);
+ (void) memcpy((void *)(gc->pc + 12), (void *)(&width), 4);
+ (void) memcpy((void *)(gc->pc + 16), (void *)(&height), 4);
+ gc->pc += cmdlen;
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLvop_GetRenderbufferParameterivEXT 1424
+void
+__indirect_glGetRenderbufferParameterivEXT(GLenum target, GLenum pname, GLint * params)
+{
+ __GLXcontext * const gc = __glXGetCurrentContext();
+ Display * const dpy = gc->currentDpy;
+ const GLuint cmdlen = 8;
+ if (__builtin_expect(dpy != NULL, 1)) {
+ GLubyte const * pc = __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithReply, X_GLvop_GetRenderbufferParameterivEXT, cmdlen);
+ (void) memcpy((void *)(pc + 0), (void *)(&target), 4);
+ (void) memcpy((void *)(pc + 4), (void *)(&pname), 4);
+ (void) __glXReadReply(dpy, 4, params, GL_FALSE);
+ UnlockDisplay(dpy); SyncHandle();
+ }
+ return;
+}
+
+#define X_GLvop_IsFramebufferEXT 1425
+GLboolean
+__indirect_glIsFramebufferEXT(GLuint framebuffer)
+{
+ __GLXcontext * const gc = __glXGetCurrentContext();
+ Display * const dpy = gc->currentDpy;
+ GLboolean retval = (GLboolean) 0;
+ const GLuint cmdlen = 4;
+ if (__builtin_expect(dpy != NULL, 1)) {
+ GLubyte const * pc = __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithReply, X_GLvop_IsFramebufferEXT, cmdlen);
+ (void) memcpy((void *)(pc + 0), (void *)(&framebuffer), 4);
+ retval = (GLboolean) __glXReadReply(dpy, 0, NULL, GL_FALSE);
+ UnlockDisplay(dpy); SyncHandle();
+ }
+ return retval;
+}
+
+#define X_GLrop_BindFramebufferEXT 4319
+void
+__indirect_glBindFramebufferEXT(GLenum target, GLuint framebuffer)
+{
+ __GLXcontext * const gc = __glXGetCurrentContext();
+ const GLuint cmdlen = 12;
+ emit_header(gc->pc, X_GLrop_BindFramebufferEXT, cmdlen);
+ (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
+ (void) memcpy((void *)(gc->pc + 8), (void *)(&framebuffer), 4);
+ gc->pc += cmdlen;
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_DeleteFramebuffersEXT 4320
+void
+__indirect_glDeleteFramebuffersEXT(GLsizei n, const GLuint * framebuffers)
+{
+ __GLXcontext * const gc = __glXGetCurrentContext();
+ const GLuint cmdlen = 8 + __GLX_PAD((n * 4));
+ if (__builtin_expect(n >= 0, 1)) {
+ emit_header(gc->pc, X_GLrop_DeleteFramebuffersEXT, cmdlen);
+ (void) memcpy((void *)(gc->pc + 4), (void *)(&n), 4);
+ (void) memcpy((void *)(gc->pc + 8), (void *)(framebuffers), (n * 4));
+ gc->pc += cmdlen;
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+ }
+}
+
+#define X_GLvop_GenFramebuffersEXT 1426
+void
+__indirect_glGenFramebuffersEXT(GLsizei n, GLuint * framebuffers)
+{
+ __GLXcontext * const gc = __glXGetCurrentContext();
+ Display * const dpy = gc->currentDpy;
+ const GLuint cmdlen = 4;
+ if (__builtin_expect((n >= 0) && (dpy != NULL), 1)) {
+ GLubyte const * pc = __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithReply, X_GLvop_GenFramebuffersEXT, cmdlen);
+ (void) memcpy((void *)(pc + 0), (void *)(&n), 4);
+ (void) __glXReadReply(dpy, 4, framebuffers, GL_TRUE);
+ UnlockDisplay(dpy); SyncHandle();
+ }
+ return;
+}
+
+#define X_GLvop_CheckFramebufferStatusEXT 1427
+GLenum
+__indirect_glCheckFramebufferStatusEXT(GLenum target)
+{
+ __GLXcontext * const gc = __glXGetCurrentContext();
+ Display * const dpy = gc->currentDpy;
+ GLenum retval = (GLenum) 0;
+ const GLuint cmdlen = 4;
+ if (__builtin_expect(dpy != NULL, 1)) {
+ GLubyte const * pc = __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithReply, X_GLvop_CheckFramebufferStatusEXT, cmdlen);
+ (void) memcpy((void *)(pc + 0), (void *)(&target), 4);
+ retval = (GLenum) __glXReadReply(dpy, 0, NULL, GL_FALSE);
+ UnlockDisplay(dpy); SyncHandle();
+ }
+ return retval;
+}
+
+#define X_GLrop_FramebufferTexture1DEXT 4321
+void
+__indirect_glFramebufferTexture1DEXT(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level)
+{
+ __GLXcontext * const gc = __glXGetCurrentContext();
+ const GLuint cmdlen = 24;
+ emit_header(gc->pc, X_GLrop_FramebufferTexture1DEXT, cmdlen);
+ (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
+ (void) memcpy((void *)(gc->pc + 8), (void *)(&attachment), 4);
+ (void) memcpy((void *)(gc->pc + 12), (void *)(&textarget), 4);
+ (void) memcpy((void *)(gc->pc + 16), (void *)(&texture), 4);
+ (void) memcpy((void *)(gc->pc + 20), (void *)(&level), 4);
+ gc->pc += cmdlen;
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_FramebufferTexture2DEXT 4322
+void
+__indirect_glFramebufferTexture2DEXT(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level)
+{
+ __GLXcontext * const gc = __glXGetCurrentContext();
+ const GLuint cmdlen = 24;
+ emit_header(gc->pc, X_GLrop_FramebufferTexture2DEXT, cmdlen);
+ (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
+ (void) memcpy((void *)(gc->pc + 8), (void *)(&attachment), 4);
+ (void) memcpy((void *)(gc->pc + 12), (void *)(&textarget), 4);
+ (void) memcpy((void *)(gc->pc + 16), (void *)(&texture), 4);
+ (void) memcpy((void *)(gc->pc + 20), (void *)(&level), 4);
+ gc->pc += cmdlen;
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_FramebufferTexture3DEXT 4323
+void
+__indirect_glFramebufferTexture3DEXT(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level, GLint zoffset)
+{
+ __GLXcontext * const gc = __glXGetCurrentContext();
+ const GLuint cmdlen = 28;
+ emit_header(gc->pc, X_GLrop_FramebufferTexture3DEXT, cmdlen);
+ (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
+ (void) memcpy((void *)(gc->pc + 8), (void *)(&attachment), 4);
+ (void) memcpy((void *)(gc->pc + 12), (void *)(&textarget), 4);
+ (void) memcpy((void *)(gc->pc + 16), (void *)(&texture), 4);
+ (void) memcpy((void *)(gc->pc + 20), (void *)(&level), 4);
+ (void) memcpy((void *)(gc->pc + 24), (void *)(&zoffset), 4);
+ gc->pc += cmdlen;
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_FramebufferRenderbufferEXT 4324
+void
+__indirect_glFramebufferRenderbufferEXT(GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer)
+{
+ __GLXcontext * const gc = __glXGetCurrentContext();
+ const GLuint cmdlen = 20;
+ emit_header(gc->pc, X_GLrop_FramebufferRenderbufferEXT, cmdlen);
+ (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
+ (void) memcpy((void *)(gc->pc + 8), (void *)(&attachment), 4);
+ (void) memcpy((void *)(gc->pc + 12), (void *)(&renderbuffertarget), 4);
+ (void) memcpy((void *)(gc->pc + 16), (void *)(&renderbuffer), 4);
+ gc->pc += cmdlen;
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLvop_GetFramebufferAttachmentParameterivEXT 1428
+void
+__indirect_glGetFramebufferAttachmentParameterivEXT(GLenum target, GLenum attachment, GLenum pname, GLint * params)
+{
+ __GLXcontext * const gc = __glXGetCurrentContext();
+ Display * const dpy = gc->currentDpy;
+ const GLuint cmdlen = 12;
+ if (__builtin_expect(dpy != NULL, 1)) {
+ GLubyte const * pc = __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithReply, X_GLvop_GetFramebufferAttachmentParameterivEXT, cmdlen);
+ (void) memcpy((void *)(pc + 0), (void *)(&target), 4);
+ (void) memcpy((void *)(pc + 4), (void *)(&attachment), 4);
+ (void) memcpy((void *)(pc + 8), (void *)(&pname), 4);
+ (void) __glXReadReply(dpy, 4, params, GL_FALSE);
+ UnlockDisplay(dpy); SyncHandle();
+ }
+ return;
+}
+
+#define X_GLrop_GenerateMipmapEXT 4325
+void
+__indirect_glGenerateMipmapEXT(GLenum target)
+{
+ __GLXcontext * const gc = __glXGetCurrentContext();
+ const GLuint cmdlen = 8;
+ emit_header(gc->pc, X_GLrop_GenerateMipmapEXT, cmdlen);
+ (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
+ gc->pc += cmdlen;
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+
+# undef FASTCALL
+# undef NOINLINE