void __indirect_glIndexPointer( GLenum type, GLsizei stride, const GLvoid * pointer ) { uint16_t opcode; __GLXcontext *gc = __glXGetCurrentContext(); __GLXattribute * state = (__GLXattribute *)(gc->client_state_private); struct array_state_vector * arrays = state->array_state; struct array_state * a; if (stride < 0) { __glXSetError(gc, GL_INVALID_VALUE); return; } switch ( type ) { case GL_UNSIGNED_BYTE: opcode = X_GLrop_Indexubv; break; case GL_SHORT: opcode = X_GLrop_Indexsv; break; case GL_INT: opcode = X_GLrop_Indexiv; break; case GL_FLOAT: opcode = X_GLrop_Indexfv; break; case GL_DOUBLE: opcode = X_GLrop_Indexdv; break; default: __glXSetError(gc, GL_INVALID_ENUM); return; } a = get_array_entry( arrays, GL_INDEX_ARRAY, 0 ); assert( a != NULL ); COMMON_ARRAY_DATA_INIT( a, pointer, type, stride, 1, GL_FALSE, 4, opcode ); if ( a->enabled ) { arrays->array_info_cache_valid = GL_FALSE; } }
void __indirect_glIndexPointer(GLenum type, GLsizei stride, const GLvoid *pointer) { __GLXcontext *gc = __glXGetCurrentContext(); __GLXattribute * state = (__GLXattribute *)(gc->client_state_private); __GLXvertexArrayPointerState *indexPointer = &state->vertArray.arrays[ index_ARRAY ]; /* Check arguments */ if (stride < 0) { __glXSetError(gc, GL_INVALID_VALUE); return; } /* Choose appropriate api proc */ switch(type) { __GL_INDEX_FUNC(UNSIGNED_BYTE, ub); __GL_INDEX_FUNC(SHORT, s); __GL_INDEX_FUNC(INT, i); __GL_INDEX_FUNC(FLOAT, f); __GL_INDEX_FUNC(DOUBLE, d); default: __glXSetError(gc, GL_INVALID_ENUM); return; } indexPointer->type = type; indexPointer->stride = stride; indexPointer->ptr = pointer; /* Set internal state */ if (stride == 0) { indexPointer->skip = __glXTypeSize(type); } else { indexPointer->skip = stride; } }
/** * Validate that the \c mode and \c count parameters to \c glDrawArrays or * \c glDrawElements are valid. If the arguments are not valid, then an * error code is set in the GLX context. * * \returns \c GL_TRUE if the arguments are valide, \c GL_FALSE if they are * not. */ static GLboolean glx_validate_array_args(__GLXcontext *gc, GLenum mode, GLsizei count) { switch(mode) { case GL_POINTS: case GL_LINE_STRIP: case GL_LINE_LOOP: case GL_LINES: case GL_TRIANGLE_STRIP: case GL_TRIANGLE_FAN: case GL_TRIANGLES: case GL_QUAD_STRIP: case GL_QUADS: case GL_POLYGON: break; default: __glXSetError(gc, GL_INVALID_ENUM); return GL_FALSE; } if (count < 0) { __glXSetError(gc, GL_INVALID_VALUE); return GL_FALSE; } return GL_TRUE; }
/** * I don't have 100% confidence that this is correct. The different rules * about whether or not generic vertex attributes alias "classic" vertex * attributes (i.e., attrib1 ?= primary color) between ARB_vertex_program, * ARB_vertex_shader, and NV_vertex_program are a bit confusing. My * feeling is that the client-side doesn't have to worry about it. The * client just sends all the data to the server and lets the server deal * with it. */ void __indirect_glVertexAttribPointerNV( GLuint index, GLint size, GLenum type, GLsizei stride, const GLvoid * pointer) { __GLXcontext *gc = __glXGetCurrentContext(); GLboolean normalized = GL_FALSE; switch( type ) { case GL_UNSIGNED_BYTE: if ( size != 4 ) { __glXSetError(gc, GL_INVALID_VALUE); return; } normalized = GL_TRUE; case GL_SHORT: case GL_FLOAT: case GL_DOUBLE: __indirect_glVertexAttribPointerARB(index, size, type, normalized, stride, pointer); return; default: __glXSetError(gc, GL_INVALID_ENUM); return; } }
void __indirect_glFogCoordPointerEXT(GLenum type, GLsizei stride, const GLvoid * pointer) { __GLXcontext *gc = __glXGetCurrentContext(); __GLXattribute * state = (__GLXattribute *)(gc->client_state_private); __GLXvertexArrayPointerState *fogPointer = &state->vertArray.arrays[ fogCoord_ARRAY ]; /* Check arguments */ if (stride < 0) { __glXSetError(gc, GL_INVALID_VALUE); return; } /* Choose appropriate api proc */ switch(type) { __GL_FOG_FUNC(FLOAT, f); __GL_FOG_FUNC(DOUBLE, d); default: __glXSetError(gc, GL_INVALID_ENUM); return; } fogPointer->size = 1; fogPointer->type = type; fogPointer->stride = stride; fogPointer->ptr = pointer; /* Set internal state */ if (stride == 0) { fogPointer->skip = __glXTypeSize(type); } else { fogPointer->skip = stride; } }
void __indirect_glGetVertexAttribPointervNV( GLuint index, GLenum pname, GLvoid ** pointer ) { __GLXcontext * const gc = __glXGetCurrentContext(); __GLXattribute * state = (__GLXattribute *)(gc->client_state_private); if ( pname != GL_VERTEX_ATTRIB_ARRAY_POINTER_ARB ) { __glXSetError( gc, GL_INVALID_ENUM ); } if ( ! __glXGetArrayPointer( state, GL_VERTEX_ATTRIB_ARRAY_POINTER_ARB, index, pointer ) ) { __glXSetError( gc, GL_INVALID_VALUE ); } }
void __indirect_glPopClientAttrib(void) { __GLXcontext *gc = __glXGetCurrentContext(); __GLXattribute *state = (__GLXattribute *) (gc->client_state_private); __GLXattribute **spp = gc->attributes.stackPointer, *sp; GLuint mask; if (spp > &gc->attributes.stack[0]) { --spp; sp = *spp; assert(sp != 0); mask = sp->mask; gc->attributes.stackPointer = spp; if (mask & GL_CLIENT_PIXEL_STORE_BIT) { state->storePack = sp->storePack; state->storeUnpack = sp->storeUnpack; } if (mask & GL_CLIENT_VERTEX_ARRAY_BIT) { __glXPopArrayState(state); } sp->mask = 0; } else { __glXSetError(gc, GL_STACK_UNDERFLOW); return; } }
void __indirect_glEdgeFlagPointer(GLsizei stride, const GLvoid *pointer) { __GLXcontext *gc = __glXGetCurrentContext(); __GLXattribute * state = (__GLXattribute *)(gc->client_state_private); __GLXvertexArrayPointerState *edgeFlagPointer = &state->vertArray.arrays[ edgeFlag_ARRAY ]; /* Check arguments */ if (stride < 0) { __glXSetError(gc, GL_INVALID_VALUE); return; } /* Choose appropriate api proc */ edgeFlagPointer->proc = (void (*)(const void *))__indirect_glEdgeFlagv; edgeFlagPointer->stride = stride; edgeFlagPointer->ptr = pointer; /* Set internal state */ if (stride == 0) { edgeFlagPointer->skip = sizeof(GLboolean); } else { edgeFlagPointer->skip = stride; } }
/** * Send a large image to the server. If necessary, a buffer is allocated * to hold the unpacked data that is copied from the clients memory. * * \param gc Current GLX context * \param compsize Size, in bytes, of the image portion * \param dim Number of dimensions of the image * \param width Width of the image * \param height Height of the image, must be 1 for 1D images * \param depth Depth of the image, must be 1 for 1D or 2D images * \param format Format of the image * \param type Data type of the image * \param src Pointer to the image data * \param pc Pointer to end of the command header * \param modes Pointer to the pixel unpack data * * \todo * Modify this function so that \c NULL images are sent using * \c __glXSendLargeChunk instead of __glXSendLargeCommand. Doing this * will eliminate the need to allocate a buffer for that case. */ void __glXSendLargeImage(struct glx_context * gc, GLint compsize, GLint dim, GLint width, GLint height, GLint depth, GLenum format, GLenum type, const GLvoid * src, GLubyte * pc, GLubyte * modes) { /* Allocate a temporary holding buffer */ GLubyte *buf = malloc(compsize); if (!buf) { __glXSetError(gc, GL_OUT_OF_MEMORY); return; } /* Apply pixel store unpack modes to copy data into buf */ if (src != NULL) { (*gc->fillImage) (gc, dim, width, height, depth, format, type, src, buf, modes); } else { if (dim < 3) { (void) memcpy(modes, __glXDefaultPixelStore + 4, 20); } else { (void) memcpy(modes, __glXDefaultPixelStore + 0, 36); } } /* Send large command */ __glXSendLargeCommand(gc, gc->pc, pc - gc->pc, buf, compsize); /* Free buffer */ free((char *) buf); }
void __indirect_glPushClientAttrib(GLuint mask) { __GLXcontext *gc = __glXGetCurrentContext(); __GLXattribute *state = (__GLXattribute *) (gc->client_state_private); __GLXattribute **spp = gc->attributes.stackPointer, *sp; if (spp < &gc->attributes.stack[__GL_CLIENT_ATTRIB_STACK_DEPTH]) { if (!(sp = *spp)) { sp = (__GLXattribute *) Xmalloc(sizeof(__GLXattribute)); *spp = sp; } sp->mask = mask; gc->attributes.stackPointer = spp + 1; if (mask & GL_CLIENT_PIXEL_STORE_BIT) { sp->storePack = state->storePack; sp->storeUnpack = state->storeUnpack; } if (mask & GL_CLIENT_VERTEX_ARRAY_BIT) { __glXPushArrayState(state); } } else { __glXSetError(gc, GL_STACK_OVERFLOW); return; } }
void __indirect_glVertexPointer( GLint size, GLenum type, GLsizei stride, const GLvoid * pointer ) { static const uint16_t short_ops[5] = { 0, 0, X_GLrop_Vertex2sv, X_GLrop_Vertex3sv, X_GLrop_Vertex4sv }; static const uint16_t int_ops[5] = { 0, 0, X_GLrop_Vertex2iv, X_GLrop_Vertex3iv, X_GLrop_Vertex4iv }; static const uint16_t float_ops[5] = { 0, 0, X_GLrop_Vertex2fv, X_GLrop_Vertex3fv, X_GLrop_Vertex4fv }; static const uint16_t double_ops[5] = { 0, 0, X_GLrop_Vertex2dv, X_GLrop_Vertex3dv, X_GLrop_Vertex4dv }; uint16_t opcode; __GLXcontext *gc = __glXGetCurrentContext(); __GLXattribute * state = (__GLXattribute *)(gc->client_state_private); struct array_state_vector * arrays = state->array_state; struct array_state * a; if (size < 2 || size > 4 || stride < 0) { __glXSetError(gc, GL_INVALID_VALUE); return; } switch ( type ) { case GL_SHORT: opcode = short_ops[size]; break; case GL_INT: opcode = int_ops[size]; break; case GL_FLOAT: opcode = float_ops[size]; break; case GL_DOUBLE: opcode = double_ops[size]; break; default: __glXSetError(gc, GL_INVALID_ENUM); return; } a = get_array_entry( arrays, GL_VERTEX_ARRAY, 0 ); assert( a != NULL ); COMMON_ARRAY_DATA_INIT( a, pointer, type, stride, size, GL_FALSE, 4, opcode ); if ( a->enabled ) { arrays->array_info_cache_valid = GL_FALSE; } }
/** * Validate that the \c count parameter to \c glDrawArrays, et. al. is valid. * A value less than zero is invalid and will result in \c GL_INVALID_VALUE * being set. A value of zero will not result in an error being set, but * will result in \c GL_FALSE being returned. * * \returns * \c GL_TRUE if the argument is valid, \c GL_FALSE if it is not. */ static GLboolean validate_count(__GLXcontext *gc, GLsizei count) { if (count < 0) { __glXSetError(gc, GL_INVALID_VALUE); } return (count > 0); }
void do_vertex_attrib_enable( GLuint index, GLboolean val ) { __GLXcontext *gc = __glXGetCurrentContext(); __GLXattribute * state = (__GLXattribute *)(gc->client_state_private); if ( ! __glXSetArrayEnable( state, GL_VERTEX_ATTRIB_ARRAY_POINTER_ARB, index, val ) ) { __glXSetError(gc, GL_INVALID_ENUM); } }
void __indirect_glSecondaryColorPointerEXT( GLint size, GLenum type, GLsizei stride, const GLvoid * pointer ) { uint16_t opcode; __GLXcontext *gc = __glXGetCurrentContext(); __GLXattribute * state = (__GLXattribute *)(gc->client_state_private); struct array_state_vector * arrays = state->array_state; struct array_state * a; if (size != 3 || stride < 0) { __glXSetError(gc, GL_INVALID_VALUE); return; } switch ( type ) { case GL_BYTE: opcode = 4126; break; case GL_UNSIGNED_BYTE: opcode = 4131; break; case GL_SHORT: opcode = 4127; break; case GL_UNSIGNED_SHORT: opcode = 4132; break; case GL_INT: opcode = 4128; break; case GL_UNSIGNED_INT: opcode = 4133; break; case GL_FLOAT: opcode = 4129; break; case GL_DOUBLE: opcode = 4130; break; default: __glXSetError(gc, GL_INVALID_ENUM); return; } a = get_array_entry( arrays, GL_SECONDARY_COLOR_ARRAY, 0 ); if ( a == NULL ) { __glXSetError(gc, GL_INVALID_OPERATION); return; } COMMON_ARRAY_DATA_INIT( a, pointer, type, stride, size, GL_TRUE, 4, opcode ); if ( a->enabled ) { arrays->array_info_cache_valid = GL_FALSE; } }
/** * Validate that the \c type parameter to \c glDrawElements, et. al. is * valid. Only \c GL_UNSIGNED_BYTE, \c GL_UNSIGNED_SHORT, and * \c GL_UNSIGNED_INT are valid. * * \returns * \c GL_TRUE if the argument is valid, \c GL_FALSE if it is not. */ static GLboolean validate_type(__GLXcontext *gc, GLenum type) { switch( type ) { case GL_UNSIGNED_INT: case GL_UNSIGNED_SHORT: case GL_UNSIGNED_BYTE: return GL_TRUE; default: __glXSetError(gc, GL_INVALID_ENUM); return GL_FALSE; } }
void __indirect_glClientActiveTextureARB(GLenum texture) { __GLXcontext *gc = __glXGetCurrentContext(); __GLXattribute * state = (__GLXattribute *)(gc->client_state_private); GLint unit = (GLint) texture - GL_TEXTURE0; if (unit < 0 || __GLX_MAX_TEXTURE_UNITS <= unit) { __glXSetError(gc, GL_INVALID_ENUM); return; } state->vertArray.activeTexture = unit; }
void __indirect_glSecondaryColorPointerEXT(GLint size, GLenum type, GLsizei stride, const GLvoid * pointer ) { __GLXcontext *gc = __glXGetCurrentContext(); __GLXattribute * state = (__GLXattribute *)(gc->client_state_private); __GLXvertexArrayPointerState *seccolorPointer = &state->vertArray.arrays[ secondaryColor_ARRAY ]; /* Check arguments */ if ( (stride < 0) || (size != 3) ) { __glXSetError(gc, GL_INVALID_VALUE); return; } /* Choose appropriate api proc */ switch(type) { __GL_SEC_COLOR_FUNC(BYTE, b); __GL_SEC_COLOR_FUNC(UNSIGNED_BYTE, ub); __GL_SEC_COLOR_FUNC(SHORT, s); __GL_SEC_COLOR_FUNC(UNSIGNED_SHORT, us); __GL_SEC_COLOR_FUNC(INT, i); __GL_SEC_COLOR_FUNC(UNSIGNED_INT, ui); __GL_SEC_COLOR_FUNC(FLOAT, f); __GL_SEC_COLOR_FUNC(DOUBLE, d); default: __glXSetError(gc, GL_INVALID_ENUM); return; } seccolorPointer->size = size; seccolorPointer->type = type; seccolorPointer->stride = stride; seccolorPointer->ptr = pointer; /* Set internal state */ if (stride == 0) { seccolorPointer->skip = size * __glXTypeSize(type); } else { seccolorPointer->skip = stride; } }
void __indirect_glDrawRangeElements(GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const GLvoid *indices) { __GLXcontext *gc = __glXGetCurrentContext(); if (end < start) { __glXSetError(gc, GL_INVALID_VALUE); return; } __indirect_glDrawElements(mode,count,type,indices); }
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_glTexCoordPointer(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer) { __GLXcontext *gc = __glXGetCurrentContext(); __GLXattribute * state = (__GLXattribute *)(gc->client_state_private); __GLXvertexArrayPointerState *texCoordPointer = &state->vertArray.texCoord[state->vertArray.activeTexture]; /* Check arguments */ if (size < 1 || size > 4 || stride < 0) { __glXSetError(gc, GL_INVALID_VALUE); return; } /* Choose appropriate api proc */ switch(type) { __GL_TEXTURE_FUNC(SHORT, s); __GL_TEXTURE_FUNC(INT, i); __GL_TEXTURE_FUNC(FLOAT, f); __GL_TEXTURE_FUNC(DOUBLE, d); default: __glXSetError(gc, GL_INVALID_ENUM); return; } texCoordPointer->size = size; texCoordPointer->type = type; texCoordPointer->stride = stride; texCoordPointer->ptr = pointer; /* Set internal state */ if (stride == 0) { texCoordPointer->skip = __glXTypeSize(type) * size; } else { texCoordPointer->skip = stride; } }
static void do_enable_disable(GLenum array, GLboolean val) { __GLXcontext *gc = __glXGetCurrentContext(); __GLXattribute *state = (__GLXattribute *) (gc->client_state_private); unsigned index = 0; if (array == GL_TEXTURE_COORD_ARRAY) { index = __glXGetActiveTextureUnit(state); } if (!__glXSetArrayEnable(state, array, index, val)) { __glXSetError(gc, GL_INVALID_ENUM); } }
void __indirect_glClientActiveTextureARB(GLenum texture) { __GLXcontext * const gc = __glXGetCurrentContext(); __GLXattribute * const state = (__GLXattribute *)(gc->client_state_private); struct array_state_vector * const arrays = state->array_state; const GLint unit = (GLint) texture - GL_TEXTURE0; if ( (unit < 0) || (unit > arrays->num_texture_units) ) { __glXSetError(gc, GL_INVALID_ENUM); return; } arrays->active_texture_unit = unit; }
void __indirect_glFogCoordPointerEXT( GLenum type, GLsizei stride, const GLvoid * pointer ) { uint16_t opcode; __GLXcontext *gc = __glXGetCurrentContext(); __GLXattribute * state = (__GLXattribute *)(gc->client_state_private); struct array_state_vector * arrays = state->array_state; struct array_state * a; if (stride < 0) { __glXSetError(gc, GL_INVALID_VALUE); return; } switch ( type ) { case GL_FLOAT: opcode = 4124; break; case GL_DOUBLE: opcode = 4125; break; default: __glXSetError(gc, GL_INVALID_ENUM); return; } a = get_array_entry( arrays, GL_FOG_COORD_ARRAY, 0 ); if ( a == NULL ) { __glXSetError(gc, GL_INVALID_OPERATION); return; } COMMON_ARRAY_DATA_INIT( a, pointer, type, stride, 1, GL_FALSE, 4, opcode ); if ( a->enabled ) { arrays->array_info_cache_valid = GL_FALSE; } }
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 __glXReadPixelReply(Display * dpy, struct glx_context * 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); } } }
void glGetPointerv(GLenum pname, void **params) { __GLXcontext *gc = __glXGetCurrentContext(); __GLXattribute * state = (__GLXattribute *)(gc->client_state_private); Display *dpy = gc->currentDpy; if (!dpy) return; switch(pname) { case GL_VERTEX_ARRAY_POINTER: *params = (void *)state->vertArray.vertex.ptr; return; case GL_NORMAL_ARRAY_POINTER: *params = (void *)state->vertArray.normal.ptr; return; case GL_COLOR_ARRAY_POINTER: *params = (void *)state->vertArray.color.ptr; return; case GL_INDEX_ARRAY_POINTER: *params = (void *)state->vertArray.index.ptr; return; case GL_TEXTURE_COORD_ARRAY_POINTER: *params = (void *)state->vertArray.texCoord[state->vertArray.activeTexture].ptr; return; case GL_EDGE_FLAG_ARRAY_POINTER: *params = (void *)state->vertArray.edgeFlag.ptr; return; case GL_SECONDARY_COLOR_ARRAY_POINTER: *params = (void *)state->vertArray.secondaryColor.ptr; return; case GL_FOG_COORDINATE_ARRAY_POINTER: *params = (void *)state->vertArray.fogCoord.ptr; 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; } }
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; } }
/** * Validate that the \c mode parameter to \c glDrawArrays, et. al. is valid. * If it is not valid, then an error code is set in the GLX context. * * \returns * \c GL_TRUE if the argument is valid, \c GL_FALSE if is not. */ static GLboolean validate_mode(__GLXcontext *gc, GLenum mode) { switch(mode) { case GL_POINTS: case GL_LINE_STRIP: case GL_LINE_LOOP: case GL_LINES: case GL_TRIANGLE_STRIP: case GL_TRIANGLE_FAN: case GL_TRIANGLES: case GL_QUAD_STRIP: case GL_QUADS: case GL_POLYGON: break; default: __glXSetError(gc, GL_INVALID_ENUM); return GL_FALSE; } return GL_TRUE; }