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_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(); }
void glGetPixelMapusv(GLenum map, GLushort *values) { __GLX_SINGLE_DECLARE_VARIABLES(); xGLXSingleReply reply; __GLX_SINGLE_LOAD_VARIABLES(); __GLX_SINGLE_BEGIN(X_GLsop_GetPixelMapusv,4); __GLX_SINGLE_PUT_LONG(0,map); __GLX_SINGLE_READ_XREPLY(); __GLX_SINGLE_GET_SIZE(compsize); if (compsize == 1) { __GLX_SINGLE_GET_SHORT(values); } else { __GLX_SINGLE_GET_SHORT_ARRAY(values,compsize); } __GLX_SINGLE_END(); }
void glGetLightiv(GLenum light, GLenum pname, GLint *params) { __GLX_SINGLE_DECLARE_VARIABLES(); xGLXSingleReply reply; __GLX_SINGLE_LOAD_VARIABLES(); __GLX_SINGLE_BEGIN(X_GLsop_GetLightiv,8); __GLX_SINGLE_PUT_LONG(0,light); __GLX_SINGLE_PUT_LONG(4,pname); __GLX_SINGLE_READ_XREPLY(); __GLX_SINGLE_GET_SIZE(compsize); if (compsize == 1) { __GLX_SINGLE_GET_LONG(params); } else { __GLX_SINGLE_GET_LONG_ARRAY(params,compsize); } __GLX_SINGLE_END(); }
void glGetMinmaxParameterfv(GLenum target, GLenum pname, GLfloat *params) { __GLX_SINGLE_DECLARE_VARIABLES(); xGLXSingleReply reply; __GLX_SINGLE_LOAD_VARIABLES(); __GLX_SINGLE_BEGIN(X_GLsop_GetMinmaxParameterfv,8); __GLX_SINGLE_PUT_LONG(0,target); __GLX_SINGLE_PUT_LONG(4,pname); __GLX_SINGLE_READ_XREPLY(); __GLX_SINGLE_GET_SIZE(compsize); if (compsize == 1) { __GLX_SINGLE_GET_FLOAT(params); } else { __GLX_SINGLE_GET_FLOAT_ARRAY(params,compsize); } __GLX_SINGLE_END(); }
void glGetTexGendv(GLenum coord, GLenum pname, GLdouble *params) { __GLX_SINGLE_DECLARE_VARIABLES(); xGLXSingleReply reply; __GLX_SINGLE_LOAD_VARIABLES(); __GLX_SINGLE_BEGIN(X_GLsop_GetTexGendv,8); __GLX_SINGLE_PUT_LONG(0,coord); __GLX_SINGLE_PUT_LONG(4,pname); __GLX_SINGLE_READ_XREPLY(); __GLX_SINGLE_GET_SIZE(compsize); if (compsize == 1) { __GLX_SINGLE_GET_DOUBLE(params); } else { __GLX_SINGLE_GET_DOUBLE_ARRAY(params,compsize); } __GLX_SINGLE_END(); }
void glGetMapiv(GLenum target, GLenum query, GLint *v) { __GLX_SINGLE_DECLARE_VARIABLES(); xGLXSingleReply reply; __GLX_SINGLE_LOAD_VARIABLES(); __GLX_SINGLE_BEGIN(X_GLsop_GetMapiv,8); __GLX_SINGLE_PUT_LONG(0,target); __GLX_SINGLE_PUT_LONG(4,query); __GLX_SINGLE_READ_XREPLY(); __GLX_SINGLE_GET_SIZE(compsize); if (compsize == 1) { __GLX_SINGLE_GET_LONG(v); } else { __GLX_SINGLE_GET_LONG_ARRAY(v,compsize); } __GLX_SINGLE_END(); }
void glGetTexLevelParameteriv(GLenum target, GLint level, GLenum pname, GLint *params) { __GLX_SINGLE_DECLARE_VARIABLES(); xGLXSingleReply reply; __GLX_SINGLE_LOAD_VARIABLES(); __GLX_SINGLE_BEGIN(X_GLsop_GetTexLevelParameteriv,12); __GLX_SINGLE_PUT_LONG(0,target); __GLX_SINGLE_PUT_LONG(4,level); __GLX_SINGLE_PUT_LONG(8,pname); __GLX_SINGLE_READ_XREPLY(); __GLX_SINGLE_GET_SIZE(compsize); if (compsize == 1) { __GLX_SINGLE_GET_LONG(params); } else { __GLX_SINGLE_GET_LONG_ARRAY(params,compsize); } __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 glGetIntegerv(GLenum val, GLint *i) { 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_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 { /* ** 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: *i = (GLint)state->storePack.rowLength; break; case GL_PACK_IMAGE_HEIGHT: *i = (GLint)state->storePack.imageHeight; break; case GL_PACK_SKIP_ROWS: *i = (GLint)state->storePack.skipRows; break; case GL_PACK_SKIP_PIXELS: *i = (GLint)state->storePack.skipPixels; break; case GL_PACK_SKIP_IMAGES: *i = (GLint)state->storePack.skipImages; break; case GL_PACK_ALIGNMENT: *i = (GLint)state->storePack.alignment; break; case GL_PACK_SWAP_BYTES: *i = (GLint)state->storePack.swapEndian; break; case GL_PACK_LSB_FIRST: *i = (GLint)state->storePack.lsbFirst; break; case GL_UNPACK_ROW_LENGTH: *i = (GLint)state->storeUnpack.rowLength; break; case GL_UNPACK_IMAGE_HEIGHT: *i = (GLint)state->storeUnpack.imageHeight; break; case GL_UNPACK_SKIP_ROWS: *i = (GLint)state->storeUnpack.skipRows; break; case GL_UNPACK_SKIP_PIXELS: *i = (GLint)state->storeUnpack.skipPixels; break; case GL_UNPACK_SKIP_IMAGES: *i = (GLint)state->storeUnpack.skipImages; break; case GL_UNPACK_ALIGNMENT: *i = (GLint)state->storeUnpack.alignment; break; case GL_UNPACK_SWAP_BYTES: *i = (GLint)state->storeUnpack.swapEndian; break; case GL_UNPACK_LSB_FIRST: *i = (GLint)state->storeUnpack.lsbFirst; break; case GL_VERTEX_ARRAY: *i = (GLint)state->vertArray.vertex.enable; break; case GL_VERTEX_ARRAY_SIZE: *i = (GLint)state->vertArray.vertex.size; break; case GL_VERTEX_ARRAY_TYPE: *i = (GLint)state->vertArray.vertex.type; break; case GL_VERTEX_ARRAY_STRIDE: *i = (GLint)state->vertArray.vertex.stride; break; case GL_NORMAL_ARRAY: *i = (GLint)state->vertArray.normal.enable; break; case GL_NORMAL_ARRAY_TYPE: *i = (GLint)state->vertArray.normal.type; break; case GL_NORMAL_ARRAY_STRIDE: *i = (GLint)state->vertArray.normal.stride; break; case GL_COLOR_ARRAY: *i = (GLint)state->vertArray.color.enable; break; case GL_COLOR_ARRAY_SIZE: *i = (GLint)state->vertArray.color.size; break; case GL_COLOR_ARRAY_TYPE: *i = (GLint)state->vertArray.color.type; break; case GL_COLOR_ARRAY_STRIDE: *i = (GLint)state->vertArray.color.stride; break; case GL_INDEX_ARRAY: *i = (GLint)state->vertArray.index.enable; break; case GL_INDEX_ARRAY_TYPE: *i = (GLint)state->vertArray.index.type; break; case GL_INDEX_ARRAY_STRIDE: *i = (GLint)state->vertArray.index.stride; break; case GL_TEXTURE_COORD_ARRAY: *i = (GLint)state->vertArray.texCoord[state->vertArray.activeTexture].enable; break; case GL_TEXTURE_COORD_ARRAY_SIZE: *i = (GLint)state->vertArray.texCoord[state->vertArray.activeTexture].size; break; case GL_TEXTURE_COORD_ARRAY_TYPE: *i = (GLint)state->vertArray.texCoord[state->vertArray.activeTexture].type; break; case GL_TEXTURE_COORD_ARRAY_STRIDE: *i = (GLint)state->vertArray.texCoord[state->vertArray.activeTexture].stride; break; case GL_EDGE_FLAG_ARRAY: *i = (GLint)state->vertArray.edgeFlag.enable; break; case GL_EDGE_FLAG_ARRAY_STRIDE: *i = (GLint)state->vertArray.edgeFlag.stride; break; CASE_ARRAY_ALL(SECONDARY_COLOR, secondaryColor, i, GLint); CASE_ARRAY_ENABLE(FOG_COORDINATE, fogCoord, i, GLint); CASE_ARRAY_TYPE(FOG_COORDINATE, fogCoord, i, GLint); CASE_ARRAY_STRIDE(FOG_COORDINATE, fogCoord, i, GLint); case GL_MAX_ELEMENTS_VERTICES: *i = (GLint)state->vertArray.maxElementsVertices; break; case GL_MAX_ELEMENTS_INDICES: *i = (GLint)state->vertArray.maxElementsIndices; break; case GL_MAX_CLIENT_ATTRIB_STACK_DEPTH: *i = (GLint)__GL_CLIENT_ATTRIB_STACK_DEPTH; break; case GL_CLIENT_ACTIVE_TEXTURE_ARB: *i = (GLint)(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_LONG(i); } else { __GLX_SINGLE_GET_LONG_ARRAY(i,compsize); if (val != origVal) { /* matrix transpose */ TransposeMatrixi(i); } } } } __GLX_SINGLE_END(); }