/* * SGI FREE SOFTWARE LICENSE B (Version 2.0, Sept. 18, 2008) * Copyright (C) 1991-2000 Silicon Graphics, Inc. All Rights Reserved. * * Permission is hereby granted, free of charge, to any person obtaining a * copy of this software and associated documentation files (the "Software"), * to deal in the Software without restriction, including without limitation * the rights to use, copy, modify, merge, publish, distribute, sublicense, * and/or sell copies of the Software, and to permit persons to whom the * Software is furnished to do so, subject to the following conditions: * * The above copyright notice including the dates of first publication and * either this permission notice or a reference to * http://oss.sgi.com/projects/FreeB/ * shall be included in all copies or substantial portions of the Software. * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL * SILICON GRAPHICS, INC. BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF * OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE * SOFTWARE. * * Except as contained in this notice, the name of Silicon Graphics, Inc. * shall not be used in advertising or otherwise to promote the sale, use or * other dealings in this Software without prior written authorization from * Silicon Graphics, Inc. */ #include <stdio.h> #include <assert.h> #include "glxclient.h" #include "packsingle.h" #include "glxextensions.h" #include "indirect.h" #include "indirect_vertex_array.h" #include "glapi.h" #include <xcb/xcb.h> #include <xcb/glx.h> #include <X11/Xlib-xcb.h> #if !defined(__GNUC__) # define __builtin_expect(x, y) x #endif /* Used for GL_ARB_transpose_matrix */ static void TransposeMatrixf(GLfloat m[16]) { int i, j; for (i = 0; i < 4; i++) { for (j = 0; j < i; j++) { GLfloat tmp = m[i * 4 + j]; m[i * 4 + j] = m[j * 4 + i]; m[j * 4 + i] = tmp; } } } /* Used for GL_ARB_transpose_matrix */ static void TransposeMatrixb(GLboolean m[16]) { int i, j; for (i = 0; i < 4; i++) { for (j = 0; j < i; j++) { GLboolean tmp = m[i * 4 + j]; m[i * 4 + j] = m[j * 4 + i]; m[j * 4 + i] = tmp; } } } /* Used for GL_ARB_transpose_matrix */ static void TransposeMatrixd(GLdouble m[16]) { int i, j; for (i = 0; i < 4; i++) { for (j = 0; j < i; j++) { GLdouble tmp = m[i * 4 + j]; m[i * 4 + j] = m[j * 4 + i]; m[j * 4 + i] = tmp; } } } /* Used for GL_ARB_transpose_matrix */ static void TransposeMatrixi(GLint m[16]) { int i, j; for (i = 0; i < 4; i++) { for (j = 0; j < i; j++) { GLint tmp = m[i * 4 + j]; m[i * 4 + j] = m[j * 4 + i]; m[j * 4 + i] = tmp; } } } /** * Remap a transpose-matrix enum to a non-transpose-matrix enum. Enums * that are not transpose-matrix enums are unaffected. */ static GLenum RemapTransposeEnum(GLenum e) { switch (e) { case GL_TRANSPOSE_MODELVIEW_MATRIX: case GL_TRANSPOSE_PROJECTION_MATRIX: case GL_TRANSPOSE_TEXTURE_MATRIX: return e - (GL_TRANSPOSE_MODELVIEW_MATRIX - GL_MODELVIEW_MATRIX); case GL_TRANSPOSE_COLOR_MATRIX: return GL_COLOR_MATRIX; default: return e; }; } GLenum __indirect_glGetError(void) { __GLX_SINGLE_DECLARE_VARIABLES(); GLuint retval = GL_NO_ERROR; xGLXGetErrorReply reply; if (gc->error) { /* Use internal error first */ retval = gc->error; gc->error = GL_NO_ERROR; return retval; } __GLX_SINGLE_LOAD_VARIABLES(); __GLX_SINGLE_BEGIN(X_GLsop_GetError, 0); __GLX_SINGLE_READ_XREPLY(); retval = reply.error; __GLX_SINGLE_END(); return retval; } /** * Get the selected attribute from the client state. * * \returns * On success \c GL_TRUE is returned. Otherwise, \c GL_FALSE is returned. */ static GLboolean get_client_data(struct glx_context * gc, GLenum cap, GLintptr * data) { GLboolean retval = GL_TRUE; __GLXattribute *state = (__GLXattribute *) (gc->client_state_private); const GLint tex_unit = __glXGetActiveTextureUnit(state); switch (cap) { case GL_VERTEX_ARRAY: case GL_NORMAL_ARRAY: case GL_COLOR_ARRAY: case GL_INDEX_ARRAY: case GL_EDGE_FLAG_ARRAY: case GL_SECONDARY_COLOR_ARRAY: case GL_FOG_COORD_ARRAY: retval = __glXGetArrayEnable(state, cap, 0, data); break; case GL_VERTEX_ARRAY_SIZE: retval = __glXGetArraySize(state, GL_VERTEX_ARRAY, 0, data); break; case GL_COLOR_ARRAY_SIZE: retval = __glXGetArraySize(state, GL_COLOR_ARRAY, 0, data); break; case GL_SECONDARY_COLOR_ARRAY_SIZE: retval = __glXGetArraySize(state, GL_SECONDARY_COLOR_ARRAY, 0, data); break; case GL_VERTEX_ARRAY_TYPE: retval = __glXGetArrayType(state, GL_VERTEX_ARRAY, 0, data); break; case GL_NORMAL_ARRAY_TYPE: retval = __glXGetArrayType(state, GL_NORMAL_ARRAY, 0, data); break; case GL_INDEX_ARRAY_TYPE: retval = __glXGetArrayType(state, GL_INDEX_ARRAY, 0, data); break; case GL_COLOR_ARRAY_TYPE: retval = __glXGetArrayType(state, GL_COLOR_ARRAY, 0, data); break; case GL_SECONDARY_COLOR_ARRAY_TYPE: retval = __glXGetArrayType(state, GL_SECONDARY_COLOR_ARRAY, 0, data); break; case GL_FOG_COORD_ARRAY_TYPE: retval = __glXGetArrayType(state, GL_FOG_COORD_ARRAY, 0, data); break; case GL_VERTEX_ARRAY_STRIDE: retval = __glXGetArrayStride(state, GL_VERTEX_ARRAY, 0, data); break; case GL_NORMAL_ARRAY_STRIDE: retval = __glXGetArrayStride(state, GL_NORMAL_ARRAY, 0, data); break; case GL_INDEX_ARRAY_STRIDE: retval = __glXGetArrayStride(state, GL_INDEX_ARRAY, 0, data); break; case GL_EDGE_FLAG_ARRAY_STRIDE: retval = __glXGetArrayStride(state, GL_EDGE_FLAG_ARRAY, 0, data); break; case GL_COLOR_ARRAY_STRIDE: retval = __glXGetArrayStride(state, GL_COLOR_ARRAY, 0, data); break; case GL_SECONDARY_COLOR_ARRAY_STRIDE: retval = __glXGetArrayStride(state, GL_SECONDARY_COLOR_ARRAY, 0, data); break; case GL_FOG_COORD_ARRAY_STRIDE: retval = __glXGetArrayStride(state, GL_FOG_COORD_ARRAY, 0, data); break; case GL_TEXTURE_COORD_ARRAY: retval = __glXGetArrayEnable(state, GL_TEXTURE_COORD_ARRAY, tex_unit, data); break; case GL_TEXTURE_COORD_ARRAY_SIZE: retval = __glXGetArraySize(state, GL_TEXTURE_COORD_ARRAY, tex_unit, data); break; case GL_TEXTURE_COORD_ARRAY_TYPE: retval = __glXGetArrayType(state, GL_TEXTURE_COORD_ARRAY, tex_unit, data); break; case GL_TEXTURE_COORD_ARRAY_STRIDE: retval = __glXGetArrayStride(state, GL_TEXTURE_COORD_ARRAY, tex_unit, data); break; case GL_MAX_ELEMENTS_VERTICES: case GL_MAX_ELEMENTS_INDICES: retval = GL_TRUE; *data = ~0UL; break; case GL_PACK_ROW_LENGTH: *data = (GLintptr) state->storePack.rowLength; break; case GL_PACK_IMAGE_HEIGHT: *data = (GLintptr) state->storePack.imageHeight; break; case GL_PACK_SKIP_ROWS: *data = (GLintptr) state->storePack.skipRows; break; case GL_PACK_SKIP_PIXELS: *data = (GLintptr) state->storePack.skipPixels; break; case GL_PACK_SKIP_IMAGES: *data = (GLintptr) state->storePack.skipImages; break; case GL_PACK_ALIGNMENT: *data = (GLintptr) state->storePack.alignment; break; case GL_PACK_SWAP_BYTES: *data = (GLintptr) state->storePack.swapEndian; break; case GL_PACK_LSB_FIRST: *data = (GLintptr) state->storePack.lsbFirst; break; case GL_UNPACK_ROW_LENGTH: *data = (GLintptr) state->storeUnpack.rowLength; break; case GL_UNPACK_IMAGE_HEIGHT: *data = (GLintptr) state->storeUnpack.imageHeight; break; case GL_UNPACK_SKIP_ROWS: *data = (GLintptr) state->storeUnpack.skipRows; break; case GL_UNPACK_SKIP_PIXELS: *data = (GLintptr) state->storeUnpack.skipPixels; break; case GL_UNPACK_SKIP_IMAGES: *data = (GLintptr) state->storeUnpack.skipImages; break; case GL_UNPACK_ALIGNMENT: *data = (GLintptr) state->storeUnpack.alignment; break; case GL_UNPACK_SWAP_BYTES: *data = (GLintptr) state->storeUnpack.swapEndian; break; case GL_UNPACK_LSB_FIRST: *data = (GLintptr) state->storeUnpack.lsbFirst; break; case GL_CLIENT_ATTRIB_STACK_DEPTH: *data = (GLintptr) (gc->attributes.stackPointer - gc->attributes.stack); break; case GL_MAX_CLIENT_ATTRIB_STACK_DEPTH: *data = (GLintptr) __GL_CLIENT_ATTRIB_STACK_DEPTH; break; case GL_CLIENT_ACTIVE_TEXTURE: *data = (GLintptr) (tex_unit + GL_TEXTURE0); break; default: retval = GL_FALSE; break; } return retval; } void __indirect_glGetBooleanv(GLenum val, GLboolean * b) { const GLenum origVal = val; __GLX_SINGLE_DECLARE_VARIABLES(); xGLXSingleReply reply; val = RemapTransposeEnum(val); __GLX_SINGLE_LOAD_VARIABLES(); __GLX_SINGLE_BEGIN(X_GLsop_GetBooleanv, 4); __GLX_SINGLE_PUT_LONG(0, val); __GLX_SINGLE_READ_XREPLY(); __GLX_SINGLE_GET_SIZE(compsize); if (compsize == 0) { /* ** Error occured; don't modify user's buffer. */ } else { GLintptr data; /* ** We still needed to send the request to the server in order to ** find out whether it was legal to make a query (it's illegal, ** for example, to call a query between glBegin() and glEnd()). */ if (get_client_data(gc, val, &data)) { *b = (GLboolean) data; } else { /* ** Not a local value, so use what we got from the server. */ if (compsize == 1) { __GLX_SINGLE_GET_CHAR(b); } else { __GLX_SINGLE_GET_CHAR_ARRAY(b, compsize); if (val != origVal) { /* matrix transpose */ TransposeMatrixb(b); } } } } __GLX_SINGLE_END(); } void __indirect_glGetDoublev(GLenum val, GLdouble * d) { const GLenum origVal = val; __GLX_SINGLE_DECLARE_VARIABLES(); xGLXSingleReply reply; val = RemapTransposeEnum(val); __GLX_SINGLE_LOAD_VARIABLES(); __GLX_SINGLE_BEGIN(X_GLsop_GetDoublev, 4); __GLX_SINGLE_PUT_LONG(0, val); __GLX_SINGLE_READ_XREPLY(); __GLX_SINGLE_GET_SIZE(compsize); if (compsize == 0) { /* ** Error occured; don't modify user's buffer. */ } else { GLintptr data; /* ** We still needed to send the request to the server in order to ** find out whether it was legal to make a query (it's illegal, ** for example, to call a query between glBegin() and glEnd()). */ if (get_client_data(gc, val, &data)) { *d = (GLdouble) data; } else { /* ** Not a local value, so use what we got from the server. */ if (compsize == 1) { __GLX_SINGLE_GET_DOUBLE(d); } else { __GLX_SINGLE_GET_DOUBLE_ARRAY(d, compsize); if (val != origVal) { /* matrix transpose */ TransposeMatrixd(d); } } } } __GLX_SINGLE_END(); } void __indirect_glGetFloatv(GLenum val, GLfloat * f) { const GLenum origVal = val; __GLX_SINGLE_DECLARE_VARIABLES(); xGLXSingleReply reply; val = RemapTransposeEnum(val); __GLX_SINGLE_LOAD_VARIABLES(); __GLX_SINGLE_BEGIN(X_GLsop_GetFloatv, 4); __GLX_SINGLE_PUT_LONG(0, val); __GLX_SINGLE_READ_XREPLY(); __GLX_SINGLE_GET_SIZE(compsize); if (compsize == 0) { /* ** Error occured; don't modify user's buffer. */ } else { GLintptr data; /* ** We still needed to send the request to the server in order to ** find out whether it was legal to make a query (it's illegal, ** for example, to call a query between glBegin() and glEnd()). */ if (get_client_data(gc, val, &data)) { *f = (GLfloat) data; } else { /* ** Not a local value, so use what we got from the server. */ if (compsize == 1) { __GLX_SINGLE_GET_FLOAT(f); } else { __GLX_SINGLE_GET_FLOAT_ARRAY(f, compsize); if (val != origVal) { /* matrix transpose */ TransposeMatrixf(f); } } } } __GLX_SINGLE_END(); } void __indirect_glGetIntegerv(GLenum val, GLint * i) { const GLenum origVal = val; __GLX_SINGLE_DECLARE_VARIABLES(); xGLXSingleReply reply; val = RemapTransposeEnum(val); __GLX_SINGLE_LOAD_VARIABLES(); __GLX_SINGLE_BEGIN(X_GLsop_GetIntegerv, 4); __GLX_SINGLE_PUT_LONG(0, val); __GLX_SINGLE_READ_XREPLY(); __GLX_SINGLE_GET_SIZE(compsize); if (compsize == 0) { /* ** Error occured; don't modify user's buffer. */ } else { GLintptr data; /* ** We still needed to send the request to the server in order to ** find out whether it was legal to make a query (it's illegal, ** for example, to call a query between glBegin() and glEnd()). */ if (get_client_data(gc, val, &data)) { *i = (GLint) data; } else { /* ** Not a local value, so use what we got from the server. */ if (compsize == 1) { __GLX_SINGLE_GET_LONG(i); } else { __GLX_SINGLE_GET_LONG_ARRAY(i, compsize); if (val != origVal) { /* matrix transpose */ TransposeMatrixi(i); } } } } __GLX_SINGLE_END(); } /* ** Send all pending commands to server. */ void __indirect_glFlush(void) { __GLX_SINGLE_DECLARE_VARIABLES(); if (!dpy) return; __GLX_SINGLE_LOAD_VARIABLES(); __GLX_SINGLE_BEGIN(X_GLsop_Flush, 0); __GLX_SINGLE_END(); /* And finally flush the X protocol data */ XFlush(dpy); } void __indirect_glFeedbackBuffer(GLsizei size, GLenum type, GLfloat * buffer) { __GLX_SINGLE_DECLARE_VARIABLES(); if (!dpy) return; __GLX_SINGLE_LOAD_VARIABLES(); __GLX_SINGLE_BEGIN(X_GLsop_FeedbackBuffer, 8); __GLX_SINGLE_PUT_LONG(0, size); __GLX_SINGLE_PUT_LONG(4, type); __GLX_SINGLE_END(); gc->feedbackBuf = buffer; } void __indirect_glSelectBuffer(GLsizei numnames, GLuint * buffer) { __GLX_SINGLE_DECLARE_VARIABLES(); if (!dpy) return; __GLX_SINGLE_LOAD_VARIABLES(); __GLX_SINGLE_BEGIN(X_GLsop_SelectBuffer, 4); __GLX_SINGLE_PUT_LONG(0, numnames); __GLX_SINGLE_END(); gc->selectBuf = buffer; } GLint __indirect_glRenderMode(GLenum mode) { __GLX_SINGLE_DECLARE_VARIABLES(); GLint retval = 0; xGLXRenderModeReply reply; if (!dpy) return -1; __GLX_SINGLE_LOAD_VARIABLES(); __GLX_SINGLE_BEGIN(X_GLsop_RenderMode, 4); __GLX_SINGLE_PUT_LONG(0, mode); __GLX_SINGLE_READ_XREPLY(); __GLX_SINGLE_GET_RETVAL(retval, GLint); if (reply.newMode != mode) { /* ** Switch to new mode did not take effect, therefore an error ** occured. When an error happens the server won't send us any ** other data. */ } else { /* Read the feedback or selection data */ if (gc->renderMode == GL_FEEDBACK) { __GLX_SINGLE_GET_SIZE(compsize); __GLX_SINGLE_GET_FLOAT_ARRAY(gc->feedbackBuf, compsize); } else if (gc->renderMode == GL_SELECT) { __GLX_SINGLE_GET_SIZE(compsize); __GLX_SINGLE_GET_LONG_ARRAY(gc->selectBuf, compsize); } gc->renderMode = mode; } __GLX_SINGLE_END(); return retval; } void __indirect_glFinish(void) { __GLX_SINGLE_DECLARE_VARIABLES(); xGLXSingleReply reply; __GLX_SINGLE_LOAD_VARIABLES(); __GLX_SINGLE_BEGIN(X_GLsop_Finish, 0); __GLX_SINGLE_READ_XREPLY(); __GLX_SINGLE_END(); } /** * Extract the major and minor version numbers from a version string. */ static void version_from_string(const char *ver, int *major_version, int *minor_version) { const char *end; long major; long minor; major = strtol(ver, (char **) &end, 10); minor = strtol(end + 1, NULL, 10); *major_version = major; *minor_version = minor; } const GLubyte * __indirect_glGetString(GLenum name) { struct glx_context *gc = __glXGetCurrentContext(); Display *dpy = gc->currentDpy; GLubyte *s = NULL; if (!dpy) return 0; /* ** Return the cached copy if the string has already been fetched */ switch (name) { case GL_VENDOR: if (gc->vendor) return gc->vendor; break; case GL_RENDERER: if (gc->renderer) return gc->renderer; break; case GL_VERSION: if (gc->version) return gc->version; break; case GL_EXTENSIONS: if (gc->extensions) return gc->extensions; break; default: __glXSetError(gc, GL_INVALID_ENUM); return 0; } /* ** Get requested string from server */ (void) __glXFlushRenderBuffer(gc, gc->pc); s = (GLubyte *) __glXGetString(dpy, gc->majorOpcode, gc->currentContextTag, name); if (!s) { /* Throw data on the floor */ __glXSetError(gc, GL_OUT_OF_MEMORY); } else { /* ** Update local cache */ switch (name) { case GL_VENDOR: gc->vendor = s; break; case GL_RENDERER: gc->renderer = s; break; case GL_VERSION:{ int client_major; int client_minor; version_from_string((char *) s, &gc->server_major, &gc->server_minor); __glXGetGLVersion(&client_major, &client_minor); if ((gc->server_major < client_major) || ((gc->server_major == client_major) && (gc->server_minor <= client_minor))) { gc->version = s; } else { /* Allow 7 bytes for the client-side GL version. This allows * for upto version 999.999. I'm not holding my breath for * that one! The extra 4 is for the ' ()\0' that will be * added. */ const size_t size = 7 + strlen((char *) s) + 4; gc->version = malloc(size); if (gc->version == NULL) { /* If we couldn't allocate memory for the new string, * make a best-effort and just copy the client-side version * to the string and use that. It probably doesn't * matter what is done here. If there not memory available * for a short string, the system is probably going to die * soon anyway. */ snprintf((char *) s, strlen((char *) s) + 1, "%u.%u", client_major, client_minor); gc->version = s; } else { snprintf((char *) gc->version, size, "%u.%u (%s)", client_major, client_minor, s); free(s); s = gc->version; } } break; } case GL_EXTENSIONS:{ int major = 1; int minor = 0; /* This code is currently disabled. I was reminded that some * vendors intentionally exclude some extensions from their * extension string that are part of the core version they * advertise. In particular, on Nvidia drivers this means that * the functionality is supported by the driver, but is not * hardware accelerated. For example, a TNT will show core * version 1.5, but most of the post-1.2 functionality is a * software fallback. * * I don't want to break applications that rely on this odd * behavior. At the same time, the code is written and tested, * so I didn't want to throw it away. Therefore, the code is here * but disabled. In the future, we may wish to and an environment * variable to enable it. */ #if 0 /* Call glGetString just to make sure that gc->server_major and * gc->server_minor are set. This version may be higher than we * can completely support, but it may imply support for some * extensions that we can support. * * For example, at the time of this writing, the client-side * library only supports upto core GL version 1.2. However, cubic * textures, multitexture, multisampling, and some other 1.3 * features are supported. If the server reports back version * 1.3, but does not report all of those extensions, we will * enable them. */ (void *) glGetString(GL_VERSION); major = gc->server_major, minor = gc->server_minor; #endif __glXCalculateUsableGLExtensions(gc, (char *) s, major, minor); free(s); s = gc->extensions; break; } } } return s; } GLboolean __indirect_glIsEnabled(GLenum cap) { __GLX_SINGLE_DECLARE_VARIABLES(); __GLXattribute *state = (__GLXattribute *) (gc->client_state_private); xGLXSingleReply reply; GLboolean retval = 0; GLintptr enable; if (!dpy) return 0; switch (cap) { case GL_VERTEX_ARRAY: case GL_NORMAL_ARRAY: case GL_COLOR_ARRAY: case GL_INDEX_ARRAY: case GL_EDGE_FLAG_ARRAY: case GL_SECONDARY_COLOR_ARRAY: case GL_FOG_COORD_ARRAY: retval = __glXGetArrayEnable(state, cap, 0, &enable); assert(retval); return (GLboolean) enable; break; case GL_TEXTURE_COORD_ARRAY: retval = __glXGetArrayEnable(state, GL_TEXTURE_COORD_ARRAY, __glXGetActiveTextureUnit(state), &enable); assert(retval); return (GLboolean) enable; break; } __GLX_SINGLE_LOAD_VARIABLES(); __GLX_SINGLE_BEGIN(X_GLsop_IsEnabled, 4); __GLX_SINGLE_PUT_LONG(0, cap); __GLX_SINGLE_READ_XREPLY(); __GLX_SINGLE_GET_RETVAL(retval, GLboolean); __GLX_SINGLE_END(); return retval; } void __indirect_glGetPointerv(GLenum pname, void **params) { struct glx_context *gc = __glXGetCurrentContext(); __GLXattribute *state = (__GLXattribute *) (gc->client_state_private); Display *dpy = gc->currentDpy; if (!dpy) return; switch (pname) { case GL_VERTEX_ARRAY_POINTER: case GL_NORMAL_ARRAY_POINTER: case GL_COLOR_ARRAY_POINTER: case GL_INDEX_ARRAY_POINTER: case GL_EDGE_FLAG_ARRAY_POINTER: __glXGetArrayPointer(state, pname - GL_VERTEX_ARRAY_POINTER + GL_VERTEX_ARRAY, 0, params); return; case GL_TEXTURE_COORD_ARRAY_POINTER: __glXGetArrayPointer(state, GL_TEXTURE_COORD_ARRAY, __glXGetActiveTextureUnit(state), params); return; case GL_SECONDARY_COLOR_ARRAY_POINTER: case GL_FOG_COORD_ARRAY_POINTER: __glXGetArrayPointer(state, pname - GL_FOG_COORD_ARRAY_POINTER + GL_FOG_COORD_ARRAY, 0, params); return; case GL_FEEDBACK_BUFFER_POINTER: *params = (void *) gc->feedbackBuf; return; case GL_SELECTION_BUFFER_POINTER: *params = (void *) gc->selectBuf; return; default: __glXSetError(gc, GL_INVALID_ENUM); return; } } /** * This was previously auto-generated, but we need to special-case * how we handle writing into the 'residences' buffer when n%4!=0. */ #define X_GLsop_AreTexturesResident 143 GLboolean __indirect_glAreTexturesResident(GLsizei n, const GLuint * textures, GLboolean * residences) { struct glx_context *const gc = __glXGetCurrentContext(); Display *const dpy = gc->currentDpy; GLboolean retval = (GLboolean) 0; if (__builtin_expect((n >= 0) && (dpy != NULL), 1)) { xcb_connection_t *c = XGetXCBConnection(dpy); xcb_glx_are_textures_resident_reply_t *reply; (void) __glXFlushRenderBuffer(gc, gc->pc); reply = xcb_glx_are_textures_resident_reply(c, xcb_glx_are_textures_resident (c, gc->currentContextTag, n, textures), NULL); (void) memcpy(residences, xcb_glx_are_textures_resident_data(reply), xcb_glx_are_textures_resident_data_length(reply) * sizeof(GLboolean)); retval = reply->ret_val; free(reply); } return retval; } /** * This was previously auto-generated, but we need to special-case * how we handle writing into the 'residences' buffer when n%4!=0. */ #define X_GLvop_AreTexturesResidentEXT 11 GLboolean glAreTexturesResidentEXT(GLsizei n, const GLuint * textures, GLboolean * residences) { struct glx_context *const gc = __glXGetCurrentContext(); if (gc->isDirect) { const _glapi_proc *const table = (_glapi_proc *) GET_DISPATCH(); PFNGLARETEXTURESRESIDENTEXTPROC p = (PFNGLARETEXTURESRESIDENTEXTPROC) table[332]; return p(n, textures, residences); } else { struct glx_context *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_AreTexturesResidentEXT, cmdlen); (void) memcpy((void *) (pc + 0), (void *) (&n), 4); (void) memcpy((void *) (pc + 4), (void *) (textures), (n * 4)); if (n & 3) { /* see comments in __indirect_glAreTexturesResident() */ GLboolean *res4 = malloc((n + 3) & ~3); retval = (GLboolean) __glXReadReply(dpy, 1, res4, GL_TRUE); memcpy(residences, res4, n); free(res4); } else { retval = (GLboolean) __glXReadReply(dpy, 1, residences, GL_TRUE); } UnlockDisplay(dpy); SyncHandle(); } return retval; } }