void glGetTexImage(GLenum target, GLint level, GLenum format, GLenum type, GLvoid *texels) { __GLX_SINGLE_DECLARE_VARIABLES(); const __GLXattribute * state; xGLXGetTexImageReply reply; GLubyte *buf; if (!dpy) return; __GLX_SINGLE_LOAD_VARIABLES(); state = gc->client_state_private; /* Send request */ __GLX_SINGLE_BEGIN(X_GLsop_GetTexImage,__GLX_PAD(17)); __GLX_SINGLE_PUT_LONG(0,target); __GLX_SINGLE_PUT_LONG(4,level); __GLX_SINGLE_PUT_LONG(8,format); __GLX_SINGLE_PUT_LONG(12,type); __GLX_SINGLE_PUT_CHAR(16,state->storePack.swapEndian); __GLX_SINGLE_READ_XREPLY(); compsize = reply.length << 2; if (compsize != 0) { /* Allocate a holding buffer to transform the data from */ buf = (GLubyte*) Xmalloc(compsize); if (!buf) { /* Throw data away */ _XEatData(dpy, compsize); __glXSetError(gc, GL_OUT_OF_MEMORY); } else { GLint width, height, depth; /* ** Fetch data into holding buffer. Apply pixel store pack modes ** to put data back into client memory */ width = reply.width; height = reply.height; depth = reply.depth; __GLX_SINGLE_GET_CHAR_ARRAY(buf,compsize); __glEmptyImage(gc, 2, width, height, depth, format, type, buf, texels); Xfree((char*) buf); } } else { /* ** GL error occured, don't modify user's buffer. */ } __GLX_SINGLE_END(); }
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 glReadPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLvoid *pixels) { __GLX_SINGLE_DECLARE_VARIABLES(); const __GLXattribute * state; xGLXReadPixelsReply reply; GLubyte *buf; if (!dpy) return; __GLX_SINGLE_LOAD_VARIABLES(); state = gc->client_state_private; /* Send request */ __GLX_SINGLE_BEGIN(X_GLsop_ReadPixels,__GLX_PAD(26)); __GLX_SINGLE_PUT_LONG(0,x); __GLX_SINGLE_PUT_LONG(4,y); __GLX_SINGLE_PUT_LONG(8,width); __GLX_SINGLE_PUT_LONG(12,height); __GLX_SINGLE_PUT_LONG(16,format); __GLX_SINGLE_PUT_LONG(20,type); __GLX_SINGLE_PUT_CHAR(24,state->storePack.swapEndian); __GLX_SINGLE_PUT_CHAR(25,GL_FALSE); __GLX_SINGLE_READ_XREPLY(); compsize = reply.length << 2; if (compsize != 0) { /* Allocate a holding buffer to transform the data from */ buf = (GLubyte*) Xmalloc(compsize); if (!buf) { /* Throw data away */ _XEatData(dpy, compsize); __glXSetError(gc, GL_OUT_OF_MEMORY); } else { /* ** Fetch data into holding buffer. Apply pixel store pack modes ** to put data back into client memory */ __GLX_SINGLE_GET_CHAR_ARRAY(buf,compsize); __glEmptyImage(gc, 2, width, height, 1, format, type, buf, pixels); Xfree((char*) buf); } } else { /* ** GL error occurred; don't modify user's buffer. */ } __GLX_SINGLE_END(); }
void glGetHistogram(GLenum target, GLboolean reset, GLenum format, GLenum type, GLvoid *values) { __GLX_SINGLE_DECLARE_VARIABLES(); const __GLXattribute * state; xGLXGetHistogramReply reply; GLubyte *buf; if (!dpy) return; __GLX_SINGLE_LOAD_VARIABLES(); state = gc->client_state_private; /* Send request */ __GLX_SINGLE_BEGIN(X_GLsop_GetHistogram,__GLX_PAD(14)); __GLX_SINGLE_PUT_LONG(0,(long)target); __GLX_SINGLE_PUT_LONG(4,(long)format); __GLX_SINGLE_PUT_LONG(8,(long)type); __GLX_SINGLE_PUT_CHAR(12,state->storePack.swapEndian); __GLX_SINGLE_PUT_CHAR(13,reset); __GLX_SINGLE_READ_XREPLY(); compsize = (long)reply.length << 2; if (compsize != 0) { /* Allocate a holding buffer to transform the data from */ buf = (GLubyte*)Xmalloc(compsize); if (!buf) { /* Throw data away */ _XEatData(dpy, compsize); __glXSetError(gc, GL_OUT_OF_MEMORY); } else { GLint width; /* ** Fetch data into holding buffer. Apply pixel store pack modes ** to put data back into client memory */ width = (int)reply.width; __GLX_SINGLE_GET_CHAR_ARRAY(((char*)buf),(long)compsize); __glEmptyImage(gc, 1, width, 1, 1, format, type, buf, values); Xfree((char*) buf); } } else { /* ** GL error occured, don't modify user's buffer. */ } __GLX_SINGLE_END(); }
void glGetConvolutionFilter(GLenum target, GLenum format, GLenum type, GLvoid *image) { __GLX_SINGLE_DECLARE_VARIABLES(); xGLXGetConvolutionFilterReply reply; GLubyte *buf; if (!dpy) return; __GLX_SINGLE_LOAD_VARIABLES(); /* Send request */ __GLX_SINGLE_BEGIN(X_GLsop_GetConvolutionFilter, __GLX_PAD(13)); __GLX_SINGLE_PUT_LONG(0,target); __GLX_SINGLE_PUT_LONG(4,format); __GLX_SINGLE_PUT_LONG(8,type); __GLX_SINGLE_PUT_CHAR(12,gc->state.storePack.swapEndian); __GLX_SINGLE_READ_XREPLY(); compsize = reply.length << 2; if (compsize != 0) { /* Allocate a holding buffer to transform the data from */ buf = (GLubyte*) Xmalloc(compsize); if (!buf) { /* Throw data away */ _XEatData(dpy, compsize); __glXSetError(gc, GL_OUT_OF_MEMORY); } else { GLint width, height; /* ** Fetch data into holding buffer. Apply pixel store pack modes ** to put data back into client memory */ width = reply.width; height = reply.height; __GLX_SINGLE_GET_CHAR_ARRAY(((char*)buf),compsize); __glEmptyImage(gc, 2, width, height, 1, format, type, buf, image); Xfree((char*) buf); } } else { /* ** GL error occured, don't modify user's buffer. */ } __GLX_SINGLE_END(); }
void glGetPolygonStipple(GLubyte *mask) { __GLX_SINGLE_DECLARE_VARIABLES(); xGLXSingleReply reply; GLubyte buf[128]; if (!dpy) return; __GLX_SINGLE_LOAD_VARIABLES(); __GLX_SINGLE_BEGIN(X_GLsop_GetPolygonStipple,__GLX_PAD(1)); __GLX_SINGLE_PUT_CHAR(0,GL_FALSE); __GLX_SINGLE_READ_XREPLY(); if (reply.length == 32) { __GLX_SINGLE_GET_CHAR_ARRAY(buf,128); __glEmptyImage(gc, 2, 32, 32, 1, GL_COLOR_INDEX, GL_BITMAP, buf, mask); } __GLX_SINGLE_END(); }
GLboolean glAreTexturesResident(GLsizei n, const GLuint *textures, GLboolean *residences) { #if 0 /* see comments above */ __GLX_SINGLE_DECLARE_VARIABLES(); GLboolean retval = 0; xGLXSingleReply reply; __GLX_SINGLE_LOAD_VARIABLES(); if (n < 0) return retval; cmdlen = 4+n*4; __GLX_SINGLE_BEGIN(X_GLsop_AreTexturesResident,cmdlen); __GLX_SINGLE_PUT_LONG(0,n); __GLX_PUT_LONG_ARRAY(4,textures,n); __GLX_SINGLE_READ_XREPLY(); __GLX_SINGLE_GET_RETVAL(retval, GLboolean); __GLX_SINGLE_GET_CHAR_ARRAY(residences,n); __GLX_SINGLE_END(); return retval; #else return glAreTexturesResidentEXT(n, textures, residences); #endif }
void glGetSeparableFilter(GLenum target, GLenum format, GLenum type, GLvoid *row, GLvoid *column, GLvoid *span) { __GLX_SINGLE_DECLARE_VARIABLES(); xGLXGetSeparableFilterReply reply; GLubyte *rowBuf, *colBuf; if (!dpy) return; __GLX_SINGLE_LOAD_VARIABLES(); /* Send request */ __GLX_SINGLE_BEGIN(X_GLsop_GetSeparableFilter, __GLX_PAD(13)); __GLX_SINGLE_PUT_LONG(0,target); __GLX_SINGLE_PUT_LONG(4,format); __GLX_SINGLE_PUT_LONG(8,type); __GLX_SINGLE_PUT_CHAR(12,gc->state.storePack.swapEndian); __GLX_SINGLE_READ_XREPLY(); compsize = reply.length << 2; if (compsize != 0) { GLint width, height; GLint widthsize, heightsize; width = reply.width; height = reply.height; widthsize = __glImageSize(width,1,1,format, type); heightsize = __glImageSize(height,1,1,format, type); /* Allocate a holding buffer to transform the data from */ rowBuf = (GLubyte*) Xmalloc(widthsize); if (!rowBuf) { /* Throw data away */ _XEatData(dpy, compsize); __glXSetError(gc, GL_OUT_OF_MEMORY); UnlockDisplay(dpy); SyncHandle(); return; } else { __GLX_SINGLE_GET_CHAR_ARRAY(((char*)rowBuf),widthsize); __glEmptyImage(gc, 1, width, 1, 1, format, type, rowBuf, row); Xfree((char*) rowBuf); } colBuf = (GLubyte*) Xmalloc(heightsize); if (!colBuf) { /* Throw data away */ _XEatData(dpy, compsize - __GLX_PAD(widthsize)); __glXSetError(gc, GL_OUT_OF_MEMORY); UnlockDisplay(dpy); SyncHandle(); return; } else { __GLX_SINGLE_GET_CHAR_ARRAY(((char*)colBuf),heightsize); __glEmptyImage(gc, 1, height, 1, 1, format, type, colBuf, column); Xfree((char*) colBuf); } } else { /* ** don't modify user's buffer. */ } __GLX_SINGLE_END(); }
const GLubyte *glGetString(GLenum name) { __GLX_SINGLE_DECLARE_VARIABLES(); xGLXSingleReply reply; 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 */ __GLX_SINGLE_LOAD_VARIABLES(); __GLX_SINGLE_BEGIN(X_GLsop_GetString,4); __GLX_SINGLE_PUT_LONG(0,name); __GLX_SINGLE_READ_XREPLY(); __GLX_SINGLE_GET_SIZE(compsize); s = (GLubyte*) Xmalloc(compsize); if (!s) { /* Throw data on the floor */ _XEatData(dpy, compsize); __glXSetError(gc, GL_OUT_OF_MEMORY); } else { __GLX_SINGLE_GET_CHAR_ARRAY(s,compsize); /* ** Update local cache */ switch(name) { case GL_VENDOR: gc->vendor = s; break; case GL_RENDERER: gc->renderer = s; break; case GL_VERSION: { double server_version = strtod((char *)s, NULL); double client_version = strtod(__glXGLClientVersion, NULL); if ( server_version <= client_version ) { gc->version = s; } else { gc->version = Xmalloc( strlen(__glXGLClientVersion) + strlen((char *)s) + 4 ); 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. */ strcpy((char *)s, __glXGLClientVersion); } else { sprintf( (char *)gc->version, "%s (%s)", __glXGLClientVersion, s ); Xfree( s ); s = gc->version; } } break; } case GL_EXTENSIONS: gc->extensions = (GLubyte *)__glXCombineExtensionStrings( (const char *)s, __glXGLClientExtensions ); XFree( s ); s = gc->extensions; break; } } __GLX_SINGLE_END(); return s; }
void glGetBooleanv(GLenum val, GLboolean *b) { const GLenum origVal = val; __GLX_SINGLE_DECLARE_VARIABLES(); __GLXattribute * state = (__GLXattribute *)(gc->client_state_private); xGLXSingleReply reply; if (val == GL_TRANSPOSE_MODELVIEW_MATRIX_ARB) { val = GL_MODELVIEW_MATRIX; } else if (val == GL_TRANSPOSE_PROJECTION_MATRIX_ARB) { val = GL_PROJECTION_MATRIX; } else if (val == GL_TRANSPOSE_TEXTURE_MATRIX_ARB) { val = GL_TEXTURE_MATRIX; } else if (val == GL_TRANSPOSE_COLOR_MATRIX_ARB) { val = GL_COLOR_MATRIX; } __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 { /* ** For all the queries listed here, we use the locally stored ** values rather than the one returned by the server. Note that ** 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()). */ switch (val) { case GL_PACK_ROW_LENGTH: *b = (GLboolean)state->storePack.rowLength; break; case GL_PACK_IMAGE_HEIGHT: *b = (GLboolean)state->storePack.imageHeight; break; case GL_PACK_SKIP_ROWS: *b = (GLboolean)state->storePack.skipRows; break; case GL_PACK_SKIP_PIXELS: *b = (GLboolean)state->storePack.skipPixels; break; case GL_PACK_SKIP_IMAGES: *b = (GLboolean)state->storePack.skipImages; break; case GL_PACK_ALIGNMENT: *b = (GLboolean)state->storePack.alignment; break; case GL_PACK_SWAP_BYTES: *b = (GLboolean)state->storePack.swapEndian; break; case GL_PACK_LSB_FIRST: *b = (GLboolean)state->storePack.lsbFirst; break; case GL_UNPACK_ROW_LENGTH: *b = (GLboolean)state->storeUnpack.rowLength; break; case GL_UNPACK_IMAGE_HEIGHT: *b = (GLboolean)state->storeUnpack.imageHeight; break; case GL_UNPACK_SKIP_ROWS: *b = (GLboolean)state->storeUnpack.skipRows; break; case GL_UNPACK_SKIP_PIXELS: *b = (GLboolean)state->storeUnpack.skipPixels; break; case GL_UNPACK_SKIP_IMAGES: *b = (GLboolean)state->storeUnpack.skipImages; break; case GL_UNPACK_ALIGNMENT: *b = (GLboolean)state->storeUnpack.alignment; break; case GL_UNPACK_SWAP_BYTES: *b = (GLboolean)state->storeUnpack.swapEndian; break; case GL_UNPACK_LSB_FIRST: *b = (GLboolean)state->storeUnpack.lsbFirst; break; case GL_VERTEX_ARRAY: *b = (GLboolean)state->vertArray.vertex.enable; break; case GL_VERTEX_ARRAY_SIZE: *b = (GLboolean)state->vertArray.vertex.size; break; case GL_VERTEX_ARRAY_TYPE: *b = (GLboolean)state->vertArray.vertex.type; break; case GL_VERTEX_ARRAY_STRIDE: *b = (GLboolean)state->vertArray.vertex.stride; break; case GL_NORMAL_ARRAY: *b = (GLboolean)state->vertArray.normal.enable; break; case GL_NORMAL_ARRAY_TYPE: *b = (GLboolean)state->vertArray.normal.type; break; case GL_NORMAL_ARRAY_STRIDE: *b = (GLboolean)state->vertArray.normal.stride; break; case GL_COLOR_ARRAY: *b = (GLboolean)state->vertArray.color.enable; break; case GL_COLOR_ARRAY_SIZE: *b = (GLboolean)state->vertArray.color.size; break; case GL_COLOR_ARRAY_TYPE: *b = (GLboolean)state->vertArray.color.type; break; case GL_COLOR_ARRAY_STRIDE: *b = (GLboolean)state->vertArray.color.stride; break; case GL_INDEX_ARRAY: *b = (GLboolean)state->vertArray.index.enable; break; case GL_INDEX_ARRAY_TYPE: *b = (GLboolean)state->vertArray.index.type; break; case GL_INDEX_ARRAY_STRIDE: *b = (GLboolean)state->vertArray.index.stride; break; case GL_TEXTURE_COORD_ARRAY: *b = (GLboolean)state->vertArray.texCoord[state->vertArray.activeTexture].enable; break; case GL_TEXTURE_COORD_ARRAY_SIZE: *b = (GLboolean)state->vertArray.texCoord[state->vertArray.activeTexture].size; break; case GL_TEXTURE_COORD_ARRAY_TYPE: *b = (GLboolean)state->vertArray.texCoord[state->vertArray.activeTexture].type; break; case GL_TEXTURE_COORD_ARRAY_STRIDE: *b = (GLboolean)state->vertArray.texCoord[state->vertArray.activeTexture].stride; break; case GL_EDGE_FLAG_ARRAY: *b = (GLboolean)state->vertArray.edgeFlag.enable; break; case GL_EDGE_FLAG_ARRAY_STRIDE: *b = (GLboolean)state->vertArray.edgeFlag.stride; break; CASE_ARRAY_ALL(SECONDARY_COLOR, secondaryColor, b, GLboolean); CASE_ARRAY_ENABLE(FOG_COORDINATE, fogCoord, b, GLboolean); CASE_ARRAY_TYPE(FOG_COORDINATE, fogCoord, b, GLboolean); CASE_ARRAY_STRIDE(FOG_COORDINATE, fogCoord, b, GLboolean); case GL_MAX_ELEMENTS_VERTICES: *b = (GLboolean)state->vertArray.maxElementsVertices; break; case GL_MAX_ELEMENTS_INDICES: *b = (GLboolean)state->vertArray.maxElementsIndices; break; case GL_MAX_CLIENT_ATTRIB_STACK_DEPTH: *b = (GLboolean)__GL_CLIENT_ATTRIB_STACK_DEPTH; break; case GL_CLIENT_ACTIVE_TEXTURE_ARB: *b = (GLboolean)(state->vertArray.activeTexture + GL_TEXTURE0_ARB); break; default: /* ** 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(); }