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;
}
