diff options
Diffstat (limited to 'src/VBox/GuestHost/OpenGL/state_tracker/state_client.c')
| -rw-r--r-- | src/VBox/GuestHost/OpenGL/state_tracker/state_client.c | 2433 |
1 files changed, 2433 insertions, 0 deletions
diff --git a/src/VBox/GuestHost/OpenGL/state_tracker/state_client.c b/src/VBox/GuestHost/OpenGL/state_tracker/state_client.c new file mode 100644 index 00000000..6ca6e159 --- /dev/null +++ b/src/VBox/GuestHost/OpenGL/state_tracker/state_client.c @@ -0,0 +1,2433 @@ +/* Copyright (c) 2001, Stanford University + * All rights reserved + * + * See the file LICENSE.txt for information on redistributing this software. + */ + +/* + * This file manages all the client-side state including: + * Pixel pack/unpack parameters + * Vertex arrays + */ + + +#include "cr_mem.h" +#include "state.h" +#include "state/cr_statetypes.h" +#include "state/cr_statefuncs.h" +#include "state_internals.h" + +const CRPixelPackState crStateNativePixelPacking = { + 0, /* rowLength */ + 0, /* skipRows */ + 0, /* skipPixels */ + 1, /* alignment */ + 0, /* imageHeight */ + 0, /* skipImages */ + GL_FALSE, /* swapBytes */ + GL_FALSE, /* psLSBFirst */ +}; + + +void crStateClientInitBits (CRClientBits *c) +{ + int i; + + /* XXX why GLCLIENT_BIT_ALLOC? */ + c->v = (CRbitvalue *) crCalloc(GLCLIENT_BIT_ALLOC*sizeof(CRbitvalue)); + c->n = (CRbitvalue *) crCalloc(GLCLIENT_BIT_ALLOC*sizeof(CRbitvalue)); + c->c = (CRbitvalue *) crCalloc(GLCLIENT_BIT_ALLOC*sizeof(CRbitvalue)); + c->s = (CRbitvalue *) crCalloc(GLCLIENT_BIT_ALLOC*sizeof(CRbitvalue)); + c->i = (CRbitvalue *) crCalloc(GLCLIENT_BIT_ALLOC*sizeof(CRbitvalue)); + for ( i = 0; i < CR_MAX_TEXTURE_UNITS; i++ ) + c->t[i] = (CRbitvalue *) crCalloc(GLCLIENT_BIT_ALLOC*sizeof(CRbitvalue)); + c->e = (CRbitvalue *) crCalloc(GLCLIENT_BIT_ALLOC*sizeof(CRbitvalue)); + c->f = (CRbitvalue *) crCalloc(GLCLIENT_BIT_ALLOC*sizeof(CRbitvalue)); + +#ifdef CR_NV_vertex_program + for ( i = 0; i < CR_MAX_VERTEX_ATTRIBS; i++ ) + c->a[i] = (CRbitvalue *) crCalloc(GLCLIENT_BIT_ALLOC*sizeof(CRbitvalue)); +#endif +} + +void crStateClientDestroyBits (CRClientBits *c) +{ + int i; + + crFree(c->v); + crFree(c->n); + crFree(c->c); + crFree(c->s); + crFree(c->i); + + for ( i = 0; i < CR_MAX_TEXTURE_UNITS; i++ ) + crFree(c->t[i]); + + crFree(c->e); + crFree(c->f); + +#ifdef CR_NV_vertex_program + for ( i = 0; i < CR_MAX_VERTEX_ATTRIBS; i++ ) + crFree(c->a[i]); +#endif +} + +static void crStateUnlockClientPointer(CRClientPointer* cp) +{ + if (cp->locked) + { +#ifndef IN_GUEST + if (cp->p) crFree(cp->p); +#endif + cp->locked = GL_FALSE; + } +} + +void crStateClientDestroy(CRContext *g) +{ + CRClientState *c = &(g->client); +#ifdef CR_EXT_compiled_vertex_array + if (c->array.locked) + { + unsigned int i; + + crStateUnlockClientPointer(&c->array.v); + crStateUnlockClientPointer(&c->array.c); + crStateUnlockClientPointer(&c->array.f); + crStateUnlockClientPointer(&c->array.s); + crStateUnlockClientPointer(&c->array.e); + crStateUnlockClientPointer(&c->array.i); + crStateUnlockClientPointer(&c->array.n); + for (i = 0 ; i < CR_MAX_TEXTURE_UNITS ; i++) + { + crStateUnlockClientPointer(&c->array.t[i]); + } + for (i = 0; i < CR_MAX_VERTEX_ATTRIBS; i++) + { + crStateUnlockClientPointer(&c->array.a[i]); + } + } +#endif +} + +void crStateClientInit(CRContext *ctx) +{ + CRClientState *c = &(ctx->client); + unsigned int i; + + /* pixel pack/unpack */ + c->unpack.rowLength = 0; + c->unpack.skipRows = 0; + c->unpack.skipPixels = 0; + c->unpack.skipImages = 0; + c->unpack.alignment = 4; + c->unpack.imageHeight = 0; + c->unpack.swapBytes = GL_FALSE; + c->unpack.psLSBFirst = GL_FALSE; + c->pack.rowLength = 0; + c->pack.skipRows = 0; + c->pack.skipPixels = 0; + c->pack.skipImages = 0; + c->pack.alignment = 4; + c->pack.imageHeight = 0; + c->pack.swapBytes = GL_FALSE; + c->pack.psLSBFirst = GL_FALSE; + + /* ARB multitexture */ + c->curClientTextureUnit = 0; + +#ifdef CR_EXT_compiled_vertex_array + c->array.lockFirst = 0; + c->array.lockCount = 0; + c->array.locked = GL_FALSE; +# ifdef IN_GUEST + c->array.synced = GL_FALSE; +# endif +#endif + + /* vertex array */ + c->array.v.p = NULL; + c->array.v.size = 4; + c->array.v.type = GL_FLOAT; + c->array.v.stride = 0; + c->array.v.enabled = 0; +#ifdef CR_ARB_vertex_buffer_object + c->array.v.buffer = ctx->bufferobject.arrayBuffer; + if (c->array.v.buffer) + ++c->array.v.buffer->refCount; +#endif +#ifdef CR_EXT_compiled_vertex_array + c->array.v.locked = GL_FALSE; + c->array.v.prevPtr = NULL; + c->array.v.prevStride = 0; +#endif + + /* color array */ + c->array.c.p = NULL; + c->array.c.size = 4; + c->array.c.type = GL_FLOAT; + c->array.c.stride = 0; + c->array.c.enabled = 0; +#ifdef CR_ARB_vertex_buffer_object + c->array.c.buffer = ctx->bufferobject.arrayBuffer; + if (c->array.c.buffer) + ++c->array.c.buffer->refCount; +#endif +#ifdef CR_EXT_compiled_vertex_array + c->array.c.locked = GL_FALSE; + c->array.c.prevPtr = NULL; + c->array.c.prevStride = 0; +#endif + + /* fog array */ + c->array.f.p = NULL; + c->array.f.size = 0; + c->array.f.type = GL_FLOAT; + c->array.f.stride = 0; + c->array.f.enabled = 0; +#ifdef CR_ARB_vertex_buffer_object + c->array.f.buffer = ctx->bufferobject.arrayBuffer; + if (c->array.f.buffer) + ++c->array.f.buffer->refCount; +#endif +#ifdef CR_EXT_compiled_vertex_array + c->array.f.locked = GL_FALSE; + c->array.f.prevPtr = NULL; + c->array.f.prevStride = 0; +#endif + + /* secondary color array */ + c->array.s.p = NULL; + c->array.s.size = 3; + c->array.s.type = GL_FLOAT; + c->array.s.stride = 0; + c->array.s.enabled = 0; +#ifdef CR_ARB_vertex_buffer_object + c->array.s.buffer = ctx->bufferobject.arrayBuffer; + if (c->array.s.buffer) + ++c->array.s.buffer->refCount; +#endif +#ifdef CR_EXT_compiled_vertex_array + c->array.s.locked = GL_FALSE; + c->array.s.prevPtr = NULL; + c->array.s.prevStride = 0; +#endif + + /* edge flag array */ + c->array.e.p = NULL; + c->array.e.size = 0; + c->array.e.type = GL_FLOAT; + c->array.e.stride = 0; + c->array.e.enabled = 0; +#ifdef CR_ARB_vertex_buffer_object + c->array.e.buffer = ctx->bufferobject.arrayBuffer; + if (c->array.e.buffer) + ++c->array.e.buffer->refCount; +#endif +#ifdef CR_EXT_compiled_vertex_array + c->array.e.locked = GL_FALSE; + c->array.e.prevPtr = NULL; + c->array.e.prevStride = 0; +#endif + + /* color index array */ + c->array.i.p = NULL; + c->array.i.size = 0; + c->array.i.type = GL_FLOAT; + c->array.i.stride = 0; + c->array.i.enabled = 0; +#ifdef CR_ARB_vertex_buffer_object + c->array.i.buffer = ctx->bufferobject.arrayBuffer; + if (c->array.i.buffer) + ++c->array.i.buffer->refCount; +#endif +#ifdef CR_EXT_compiled_vertex_array + c->array.i.locked = GL_FALSE; + c->array.i.prevPtr = NULL; + c->array.i.prevStride = 0; +#endif + + /* normal array */ + c->array.n.p = NULL; + c->array.n.size = 4; + c->array.n.type = GL_FLOAT; + c->array.n.stride = 0; + c->array.n.enabled = 0; +#ifdef CR_ARB_vertex_buffer_object + c->array.n.buffer = ctx->bufferobject.arrayBuffer; + if (c->array.n.buffer) + ++c->array.n.buffer->refCount; +#endif +#ifdef CR_EXT_compiled_vertex_array + c->array.n.locked = GL_FALSE; + c->array.n.prevPtr = NULL; + c->array.n.prevStride = 0; +#endif + + /* texcoord arrays */ + for (i = 0 ; i < CR_MAX_TEXTURE_UNITS ; i++) + { + c->array.t[i].p = NULL; + c->array.t[i].size = 4; + c->array.t[i].type = GL_FLOAT; + c->array.t[i].stride = 0; + c->array.t[i].enabled = 0; +#ifdef CR_ARB_vertex_buffer_object + c->array.t[i].buffer = ctx->bufferobject.arrayBuffer; + if (c->array.t[i].buffer) + ++c->array.t[i].buffer->refCount; +#endif +#ifdef CR_EXT_compiled_vertex_array + c->array.t[i].locked = GL_FALSE; + c->array.t[i].prevPtr = NULL; + c->array.t[i].prevStride = 0; +#endif + } + + /* generic vertex attributes */ +#ifdef CR_NV_vertex_program + for (i = 0; i < CR_MAX_VERTEX_ATTRIBS; i++) { + c->array.a[i].enabled = GL_FALSE; + c->array.a[i].type = GL_FLOAT; + c->array.a[i].size = 4; + c->array.a[i].stride = 0; +#ifdef CR_ARB_vertex_buffer_object + c->array.a[i].buffer = ctx->bufferobject.arrayBuffer; + if (c->array.a[i].buffer) + ++c->array.a[i].buffer->refCount; +#endif +#ifdef CR_EXT_compiled_vertex_array + c->array.a[i].locked = GL_FALSE; + c->array.a[i].prevPtr = NULL; + c->array.a[i].prevStride = 0; +#endif + } +#endif +} + + +/* + * PixelStore functions are here, not in state_pixel.c because this + * is client-side state, like vertex arrays. + */ + +void STATE_APIENTRY crStatePixelStoref (GLenum pname, GLfloat param) +{ + + /* The GL SPEC says I can do this on page 76. */ + switch( pname ) + { + case GL_PACK_SWAP_BYTES: + case GL_PACK_LSB_FIRST: + case GL_UNPACK_SWAP_BYTES: + case GL_UNPACK_LSB_FIRST: + crStatePixelStorei( pname, param == 0.0f ? 0: 1 ); + break; + default: + crStatePixelStorei( pname, (GLint) param ); + break; + } +} + +void STATE_APIENTRY crStatePixelStorei (GLenum pname, GLint param) +{ + CRContext *g = GetCurrentContext(); + CRClientState *c = &(g->client); + CRStateBits *sb = GetCurrentBits(); + CRClientBits *cb = &(sb->client); + + if (g->current.inBeginEnd) + { + crStateError(__LINE__, __FILE__, GL_INVALID_OPERATION, "PixelStore{if} called in Begin/End"); + return; + } + + FLUSH(); + + switch(pname) { + case GL_PACK_SWAP_BYTES: + c->pack.swapBytes = (GLboolean) param; + DIRTY(cb->pack, g->neg_bitid); + break; + case GL_PACK_LSB_FIRST: + c->pack.psLSBFirst = (GLboolean) param; + DIRTY(cb->pack, g->neg_bitid); + break; + case GL_PACK_ROW_LENGTH: + if (param < 0.0f) + { + crStateError(__LINE__, __FILE__, GL_INVALID_VALUE, "Negative Row Length: %f", param); + return; + } + c->pack.rowLength = param; + DIRTY(cb->pack, g->neg_bitid); + break; +#ifdef CR_OPENGL_VERSION_1_2 + case GL_PACK_IMAGE_HEIGHT: + if (param < 0.0f) + { + crStateError(__LINE__, __FILE__, GL_INVALID_VALUE, "Negative Image Height: %f", param); + return; + } + c->pack.imageHeight = param; + DIRTY(cb->pack, g->neg_bitid); + break; +#endif + case GL_PACK_SKIP_IMAGES: + if (param < 0.0f) + { + crStateError(__LINE__, __FILE__, GL_INVALID_VALUE, "Negative Skip Images: %f", param); + return; + } + c->pack.skipImages = param; + DIRTY(cb->pack, g->neg_bitid); + break; + case GL_PACK_SKIP_PIXELS: + if (param < 0.0f) + { + crStateError(__LINE__, __FILE__, GL_INVALID_VALUE, "Negative Skip Pixels: %f", param); + return; + } + c->pack.skipPixels = param; + DIRTY(cb->pack, g->neg_bitid); + break; + case GL_PACK_SKIP_ROWS: + if (param < 0.0f) + { + crStateError(__LINE__, __FILE__, GL_INVALID_VALUE, "Negative Row Skip: %f", param); + return; + } + c->pack.skipRows = param; + DIRTY(cb->pack, g->neg_bitid); + break; + case GL_PACK_ALIGNMENT: + if (((GLint) param) != 1 && + ((GLint) param) != 2 && + ((GLint) param) != 4 && + ((GLint) param) != 8) + { + crStateError(__LINE__, __FILE__, GL_INVALID_VALUE, "Invalid Alignment: %f", param); + return; + } + c->pack.alignment = param; + DIRTY(cb->pack, g->neg_bitid); + break; + + case GL_UNPACK_SWAP_BYTES: + c->unpack.swapBytes = (GLboolean) param; + DIRTY(cb->unpack, g->neg_bitid); + break; + case GL_UNPACK_LSB_FIRST: + c->unpack.psLSBFirst = (GLboolean) param; + DIRTY(cb->unpack, g->neg_bitid); + break; + case GL_UNPACK_ROW_LENGTH: + if (param < 0.0f) + { + crStateError(__LINE__, __FILE__, GL_INVALID_VALUE, "Negative Row Length: %f", param); + return; + } + c->unpack.rowLength = param; + DIRTY(cb->unpack, g->neg_bitid); + break; +#ifdef CR_OPENGL_VERSION_1_2 + case GL_UNPACK_IMAGE_HEIGHT: + if (param < 0.0f) + { + crStateError(__LINE__, __FILE__, GL_INVALID_VALUE, "Negative Image Height: %f", param); + return; + } + c->unpack.imageHeight = param; + DIRTY(cb->unpack, g->neg_bitid); + break; +#endif + case GL_UNPACK_SKIP_IMAGES: + if (param < 0.0f) + { + crStateError(__LINE__, __FILE__, GL_INVALID_VALUE, "Negative Skip Images: %f", param); + return; + } + c->unpack.skipImages = param; + DIRTY(cb->unpack, g->neg_bitid); + break; + case GL_UNPACK_SKIP_PIXELS: + if (param < 0.0f) + { + crStateError(__LINE__, __FILE__, GL_INVALID_VALUE, "Negative Skip Pixels: %f", param); + return; + } + c->unpack.skipPixels = param; + DIRTY(cb->unpack, g->neg_bitid); + break; + case GL_UNPACK_SKIP_ROWS: + if (param < 0.0f) + { + crStateError(__LINE__, __FILE__, GL_INVALID_VALUE, "Negative Row Skip: %f", param); + return; + } + c->unpack.skipRows = param; + DIRTY(cb->unpack, g->neg_bitid); + break; + case GL_UNPACK_ALIGNMENT: + if (((GLint) param) != 1 && + ((GLint) param) != 2 && + ((GLint) param) != 4 && + ((GLint) param) != 8) + { + crStateError(__LINE__, __FILE__, GL_INVALID_VALUE, "Invalid Alignment: %f", param); + return; + } + c->unpack.alignment = param; + DIRTY(cb->unpack, g->neg_bitid); + break; + default: + crStateError(__LINE__, __FILE__, GL_INVALID_VALUE, "Unknown glPixelStore Pname: %d", pname); + return; + } + DIRTY(cb->dirty, g->neg_bitid); +} + + +static void setClientState(CRClientState *c, CRClientBits *cb, + CRbitvalue *neg_bitid, GLenum array, GLboolean state) +{ + CRContext *g = GetCurrentContext(); + + switch (array) + { +#ifdef CR_NV_vertex_program + case GL_VERTEX_ATTRIB_ARRAY0_NV: + case GL_VERTEX_ATTRIB_ARRAY1_NV: + case GL_VERTEX_ATTRIB_ARRAY2_NV: + case GL_VERTEX_ATTRIB_ARRAY3_NV: + case GL_VERTEX_ATTRIB_ARRAY4_NV: + case GL_VERTEX_ATTRIB_ARRAY5_NV: + case GL_VERTEX_ATTRIB_ARRAY6_NV: + case GL_VERTEX_ATTRIB_ARRAY7_NV: + case GL_VERTEX_ATTRIB_ARRAY8_NV: + case GL_VERTEX_ATTRIB_ARRAY9_NV: + case GL_VERTEX_ATTRIB_ARRAY10_NV: + case GL_VERTEX_ATTRIB_ARRAY11_NV: + case GL_VERTEX_ATTRIB_ARRAY12_NV: + case GL_VERTEX_ATTRIB_ARRAY13_NV: + case GL_VERTEX_ATTRIB_ARRAY14_NV: + case GL_VERTEX_ATTRIB_ARRAY15_NV: + { + const GLuint i = array - GL_VERTEX_ATTRIB_ARRAY0_NV; + c->array.a[i].enabled = state; + } + break; +#endif + case GL_VERTEX_ARRAY: + c->array.v.enabled = state; + break; + case GL_COLOR_ARRAY: + c->array.c.enabled = state; + break; + case GL_NORMAL_ARRAY: + c->array.n.enabled = state; + break; + case GL_INDEX_ARRAY: + c->array.i.enabled = state; + break; + case GL_TEXTURE_COORD_ARRAY: + c->array.t[c->curClientTextureUnit].enabled = state; + break; + case GL_EDGE_FLAG_ARRAY: + c->array.e.enabled = state; + break; +#ifdef CR_EXT_fog_coord + case GL_FOG_COORDINATE_ARRAY_EXT: + c->array.f.enabled = state; + break; +#endif +#ifdef CR_EXT_secondary_color + case GL_SECONDARY_COLOR_ARRAY_EXT: + if( g->extensions.EXT_secondary_color ){ + c->array.s.enabled = state; + } + else { + crStateError(__LINE__, __FILE__, GL_INVALID_ENUM, "Invalid Enum passed to Enable/Disable Client State: SECONDARY_COLOR_ARRAY_EXT - EXT_secondary_color is not enabled." ); + return; + } + break; +#endif + default: + crStateError(__LINE__, __FILE__, GL_INVALID_ENUM, "Invalid Enum passed to Enable/Disable Client State: 0x%x", array ); + return; + } + DIRTY(cb->dirty, neg_bitid); + DIRTY(cb->enableClientState, neg_bitid); +} + +void STATE_APIENTRY crStateEnableClientState (GLenum array) +{ + CRContext *g = GetCurrentContext(); + CRClientState *c = &(g->client); + CRStateBits *sb = GetCurrentBits(); + CRClientBits *cb = &(sb->client); + + FLUSH(); + + setClientState(c, cb, g->neg_bitid, array, GL_TRUE); +} + +void STATE_APIENTRY crStateDisableClientState (GLenum array) +{ + CRContext *g = GetCurrentContext(); + CRClientState *c = &(g->client); + CRStateBits *sb = GetCurrentBits(); + CRClientBits *cb = &(sb->client); + + FLUSH(); + + setClientState(c, cb, g->neg_bitid, array, GL_FALSE); +} + +static void +crStateClientSetPointer(CRClientPointer *cp, GLint size, + GLenum type, GLboolean normalized, + GLsizei stride, const GLvoid *pointer) +{ + CRContext *g = GetCurrentContext(); + +#ifdef CR_EXT_compiled_vertex_array + crStateUnlockClientPointer(cp); + cp->prevPtr = cp->p; + cp->prevStride = cp->stride; +#endif + + cp->p = (unsigned char *) pointer; + cp->size = size; + cp->type = type; + cp->normalized = normalized; + + /* Calculate the bytes per index for address calculation */ + cp->bytesPerIndex = size; + switch (type) + { + case GL_BYTE: + case GL_UNSIGNED_BYTE: + break; + case GL_SHORT: + case GL_UNSIGNED_SHORT: + cp->bytesPerIndex *= sizeof(GLshort); + break; + case GL_INT: + case GL_UNSIGNED_INT: + cp->bytesPerIndex *= sizeof(GLint); + break; + case GL_FLOAT: + cp->bytesPerIndex *= sizeof(GLfloat); + break; + case GL_DOUBLE: + cp->bytesPerIndex *= sizeof(GLdouble); + break; + default: + crStateError( __LINE__, __FILE__, GL_INVALID_VALUE, + "Unknown type of vertex array: %d", type ); + return; + } + + /* + ** Note: If stride==0 then we set the + ** stride equal address offset + ** therefore stride can never equal + ** zero. + */ + if (stride) + cp->stride = stride; + else + cp->stride = cp->bytesPerIndex; + +#ifdef CR_ARB_vertex_buffer_object + if (cp->buffer) + { + --cp->buffer->refCount; + CRASSERT(cp->buffer->refCount && cp->buffer->refCount < UINT32_MAX/2); + } + cp->buffer = g->bufferobject.arrayBuffer; + if (cp->buffer) + ++cp->buffer->refCount; +#endif +} + +void STATE_APIENTRY crStateVertexPointer(GLint size, GLenum type, + GLsizei stride, const GLvoid *p) +{ + CRContext *g = GetCurrentContext(); + CRClientState *c = &(g->client); + CRStateBits *sb = GetCurrentBits(); + CRClientBits *cb = &(sb->client); + + FLUSH(); + + if (size != 2 && size != 3 && size != 4) + { + crStateError(__LINE__, __FILE__, GL_INVALID_VALUE, "glVertexPointer: invalid size: %d", size); + return; + } + if (type != GL_SHORT && type != GL_INT && + type != GL_FLOAT && type != GL_DOUBLE) + { + crStateError(__LINE__, __FILE__, GL_INVALID_ENUM, "glVertexPointer: invalid type: 0x%x", type); + return; + } + if (stride < 0) + { + crStateError(__LINE__, __FILE__, GL_INVALID_VALUE, "glVertexPointer: stride was negative: %d", stride); + return; + } + + crStateClientSetPointer(&(c->array.v), size, type, GL_FALSE, stride, p); + DIRTY(cb->dirty, g->neg_bitid); + DIRTY(cb->clientPointer, g->neg_bitid); + DIRTY(cb->v, g->neg_bitid); +} + +void STATE_APIENTRY crStateColorPointer(GLint size, GLenum type, + GLsizei stride, const GLvoid *p) +{ + CRContext *g = GetCurrentContext(); + CRClientState *c = &(g->client); + CRStateBits *sb = GetCurrentBits(); + CRClientBits *cb = &(sb->client); + + FLUSH(); + + if (size != 3 && size != 4) + { + crStateError(__LINE__, __FILE__, GL_INVALID_VALUE, "glColorPointer: invalid size: %d", size); + return; + } + if (type != GL_BYTE && type != GL_UNSIGNED_BYTE && + type != GL_SHORT && type != GL_UNSIGNED_SHORT && + type != GL_INT && type != GL_UNSIGNED_INT && + type != GL_FLOAT && type != GL_DOUBLE) + { + crStateError(__LINE__, __FILE__, GL_INVALID_ENUM, "glColorPointer: invalid type: 0x%x", type); + return; + } + if (stride < 0) + { + crStateError(__LINE__, __FILE__, GL_INVALID_VALUE, "glColorPointer: stride was negative: %d", stride); + return; + } + + crStateClientSetPointer(&(c->array.c), size, type, GL_TRUE, stride, p); + DIRTY(cb->dirty, g->neg_bitid); + DIRTY(cb->clientPointer, g->neg_bitid); + DIRTY(cb->c, g->neg_bitid); +} + +void STATE_APIENTRY crStateSecondaryColorPointerEXT(GLint size, + GLenum type, GLsizei stride, const GLvoid *p) +{ + CRContext *g = GetCurrentContext(); + CRClientState *c = &(g->client); + CRStateBits *sb = GetCurrentBits(); + CRClientBits *cb = &(sb->client); + + FLUSH(); + + if ( !g->extensions.EXT_secondary_color ) + { + crError( "glSecondaryColorPointerEXT called but EXT_secondary_color is disabled." ); + return; + } + + /*Note: According to opengl spec, only size==3 should be accepted here. + *But it turns out that most drivers accept size==4 here as well, and 4th value + *could even be accessed in shaders code. + *Having a strict check here, leads to difference between guest and host gpu states, which + *in turn could lead to crashes when using server side VBOs. + *@todo: add error reporting to state's VBO related functions and abort dispatching to + *real gpu on any failure to prevent other possible issues. + */ + + if ((size != 3) && (size != 4)) + { + crStateError(__LINE__, __FILE__, GL_INVALID_VALUE, "glSecondaryColorPointerEXT: invalid size: %d", size); + return; + } + if (type != GL_BYTE && type != GL_UNSIGNED_BYTE && + type != GL_SHORT && type != GL_UNSIGNED_SHORT && + type != GL_INT && type != GL_UNSIGNED_INT && + type != GL_FLOAT && type != GL_DOUBLE) + { + crStateError(__LINE__, __FILE__, GL_INVALID_ENUM, "glSecondaryColorPointerEXT: invalid type: 0x%x", type); + return; + } + if (stride < 0) + { + crStateError(__LINE__, __FILE__, GL_INVALID_VALUE, "glSecondaryColorPointerEXT: stride was negative: %d", stride); + return; + } + + crStateClientSetPointer(&(c->array.s), size, type, GL_TRUE, stride, p); + DIRTY(cb->dirty, g->neg_bitid); + DIRTY(cb->clientPointer, g->neg_bitid); + DIRTY(cb->s, g->neg_bitid); +} + +void STATE_APIENTRY crStateIndexPointer(GLenum type, GLsizei stride, + const GLvoid *p) +{ + CRContext *g = GetCurrentContext(); + CRClientState *c = &(g->client); + CRStateBits *sb = GetCurrentBits(); + CRClientBits *cb = &(sb->client); + + FLUSH(); + + if (type != GL_SHORT && type != GL_INT && type != GL_UNSIGNED_BYTE && + type != GL_FLOAT && type != GL_DOUBLE) + { + crStateError(__LINE__, __FILE__, GL_INVALID_ENUM, "glIndexPointer: invalid type: 0x%x", type); + return; + } + if (stride < 0) + { + crStateError(__LINE__, __FILE__, GL_INVALID_VALUE, "glIndexPointer: stride was negative: %d", stride); + return; + } + + crStateClientSetPointer(&(c->array.i), 1, type, GL_TRUE, stride, p); + DIRTY(cb->dirty, g->neg_bitid); + DIRTY(cb->clientPointer, g->neg_bitid); + DIRTY(cb->i, g->neg_bitid); +} + +void STATE_APIENTRY crStateNormalPointer(GLenum type, GLsizei stride, + const GLvoid *p) +{ + CRContext *g = GetCurrentContext(); + CRClientState *c = &(g->client); + CRStateBits *sb = GetCurrentBits(); + CRClientBits *cb = &(sb->client); + + FLUSH(); + + if (type != GL_BYTE && type != GL_SHORT && + type != GL_INT && type != GL_FLOAT && + type != GL_DOUBLE) + { + crStateError(__LINE__, __FILE__, GL_INVALID_ENUM, "glNormalPointer: invalid type: 0x%x", type); + return; + } + if (stride < 0) + { + crStateError(__LINE__, __FILE__, GL_INVALID_VALUE, "glNormalPointer: stride was negative: %d", stride); + return; + } + + crStateClientSetPointer(&(c->array.n), 3, type, GL_TRUE, stride, p); + DIRTY(cb->dirty, g->neg_bitid); + DIRTY(cb->clientPointer, g->neg_bitid); + DIRTY(cb->n, g->neg_bitid); +} + +void STATE_APIENTRY crStateTexCoordPointer(GLint size, GLenum type, + GLsizei stride, const GLvoid *p) +{ + CRContext *g = GetCurrentContext(); + CRClientState *c = &(g->client); + CRStateBits *sb = GetCurrentBits(); + CRClientBits *cb = &(sb->client); + + FLUSH(); + + if (size != 1 && size != 2 && size != 3 && size != 4) + { + crStateError(__LINE__, __FILE__, GL_INVALID_VALUE, "glTexCoordPointer: invalid size: %d", size); + return; + } + if (type != GL_SHORT && type != GL_INT && + type != GL_FLOAT && type != GL_DOUBLE) + { + crStateError(__LINE__, __FILE__, GL_INVALID_ENUM, "glTexCoordPointer: invalid type: 0x%x", type); + return; + } + if (stride < 0) + { + crStateError(__LINE__, __FILE__, GL_INVALID_VALUE, "glTexCoordPointer: stride was negative: %d", stride); + return; + } + + crStateClientSetPointer(&(c->array.t[c->curClientTextureUnit]), size, type, GL_FALSE, stride, p); + DIRTY(cb->dirty, g->neg_bitid); + DIRTY(cb->clientPointer, g->neg_bitid); + DIRTY(cb->t[c->curClientTextureUnit], g->neg_bitid); +} + +void STATE_APIENTRY crStateEdgeFlagPointer(GLsizei stride, const GLvoid *p) +{ + CRContext *g = GetCurrentContext(); + CRClientState *c = &(g->client); + CRStateBits *sb = GetCurrentBits(); + CRClientBits *cb = &(sb->client); + + FLUSH(); + + if (stride < 0) + { + crStateError(__LINE__, __FILE__, GL_INVALID_VALUE, "glTexCoordPointer: stride was negative: %d", stride); + return; + } + + crStateClientSetPointer(&(c->array.e), 1, GL_UNSIGNED_BYTE, GL_FALSE, stride, p); + DIRTY(cb->dirty, g->neg_bitid); + DIRTY(cb->clientPointer, g->neg_bitid); + DIRTY(cb->e, g->neg_bitid); +} + +void STATE_APIENTRY crStateFogCoordPointerEXT(GLenum type, GLsizei stride, const GLvoid *p) +{ + CRContext *g = GetCurrentContext(); + CRClientState *c = &(g->client); + CRStateBits *sb = GetCurrentBits(); + CRClientBits *cb = &(sb->client); + + FLUSH(); + + if (type != GL_BYTE && type != GL_UNSIGNED_BYTE && + type != GL_SHORT && type != GL_UNSIGNED_SHORT && + type != GL_INT && type != GL_UNSIGNED_INT && + type != GL_FLOAT && type != GL_DOUBLE) + { + crStateError(__LINE__, __FILE__, GL_INVALID_ENUM, "glFogCoordPointerEXT: invalid type: 0x%x", type); + return; + } + if (stride < 0) + { + crStateError(__LINE__, __FILE__, GL_INVALID_VALUE, "glFogCoordPointerEXT: stride was negative: %d", stride); + return; + } + + crStateClientSetPointer(&(c->array.f), 1, type, GL_FALSE, stride, p); + DIRTY(cb->dirty, g->neg_bitid); + DIRTY(cb->clientPointer, g->neg_bitid); + DIRTY(cb->f, g->neg_bitid); +} + + +void STATE_APIENTRY crStateVertexAttribPointerNV(GLuint index, GLint size, GLenum type, GLsizei stride, const GLvoid *p) +{ + GLboolean normalized = GL_FALSE; + /* Extra error checking for NV arrays */ + if (type != GL_UNSIGNED_BYTE && type != GL_SHORT && + type != GL_FLOAT && type != GL_DOUBLE) { + crStateError(__LINE__, __FILE__, GL_INVALID_ENUM, + "glVertexAttribPointerNV: invalid type: 0x%x", type); + return; + } + crStateVertexAttribPointerARB(index, size, type, normalized, stride, p); +} + + +void STATE_APIENTRY crStateVertexAttribPointerARB(GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const GLvoid *p) +{ + CRContext *g = GetCurrentContext(); + CRClientState *c = &(g->client); + CRStateBits *sb = GetCurrentBits(); + CRClientBits *cb = &(sb->client); + + FLUSH(); + + if (index >= CR_MAX_VERTEX_ATTRIBS) + { + crStateError(__LINE__, __FILE__, GL_INVALID_VALUE, "glVertexAttribPointerARB: invalid index: %d", (int) index); + return; + } + if (size != 1 && size != 2 && size != 3 && size != 4) + { + crStateError(__LINE__, __FILE__, GL_INVALID_VALUE, "glVertexAttribPointerARB: invalid size: %d", size); + return; + } + if (type != GL_BYTE && type != GL_UNSIGNED_BYTE && + type != GL_SHORT && type != GL_UNSIGNED_SHORT && + type != GL_INT && type != GL_UNSIGNED_INT && + type != GL_FLOAT && type != GL_DOUBLE) + { + crStateError(__LINE__, __FILE__, GL_INVALID_ENUM, "glVertexAttribPointerARB: invalid type: 0x%x", type); + return; + } + if (stride < 0) + { + crStateError(__LINE__, __FILE__, GL_INVALID_VALUE, "glVertexAttribPointerARB: stride was negative: %d", stride); + return; + } + + crStateClientSetPointer(&(c->array.a[index]), size, type, normalized, stride, p); + DIRTY(cb->dirty, g->neg_bitid); + DIRTY(cb->clientPointer, g->neg_bitid); + DIRTY(cb->a[index], g->neg_bitid); +} + + +void STATE_APIENTRY crStateGetVertexAttribPointervNV(GLuint index, GLenum pname, GLvoid **pointer) +{ + CRContext *g = GetCurrentContext(); + + if (g->current.inBeginEnd) { + crStateError(__LINE__, __FILE__, GL_INVALID_OPERATION, + "glGetVertexAttribPointervNV called in Begin/End"); + return; + } + + if (index >= CR_MAX_VERTEX_ATTRIBS) { + crStateError(__LINE__, __FILE__, GL_INVALID_VALUE, + "glGetVertexAttribPointervNV(index)"); + return; + } + + if (pname != GL_ATTRIB_ARRAY_POINTER_NV) { + crStateError(__LINE__, __FILE__, GL_INVALID_ENUM, + "glGetVertexAttribPointervNV(pname)"); + return; + } + + *pointer = g->client.array.a[index].p; +} + + +void STATE_APIENTRY crStateGetVertexAttribPointervARB(GLuint index, GLenum pname, GLvoid **pointer) +{ + crStateGetVertexAttribPointervNV(index, pname, pointer); +} + + + +/* +** Currently I treat Interleaved Arrays as if the +** user uses them as separate arrays. +** Certainly not the most efficient method but it +** lets me use the same glDrawArrays method. +*/ +void STATE_APIENTRY crStateInterleavedArrays(GLenum format, GLsizei stride, const GLvoid *p) +{ + CRContext *g = GetCurrentContext(); + CRClientState *c = &(g->client); + CRStateBits *sb = GetCurrentBits(); + CRClientBits *cb = &(sb->client); + CRClientPointer *cp; + unsigned char *base = (unsigned char *) p; + + if (g->current.inBeginEnd) + { + crStateError(__LINE__, __FILE__, GL_INVALID_OPERATION, "glInterleavedArrays called in begin/end"); + return; + } + + FLUSH(); + + if (stride < 0) + { + crStateError(__LINE__, __FILE__, GL_INVALID_OPERATION, "glInterleavedArrays: stride < 0: %d", stride); + return; + } + + switch (format) + { + case GL_T4F_C4F_N3F_V4F: + case GL_T2F_C4F_N3F_V3F: + case GL_C4F_N3F_V3F: + case GL_T4F_V4F: + case GL_T2F_C3F_V3F: + case GL_T2F_N3F_V3F: + case GL_C3F_V3F: + case GL_N3F_V3F: + case GL_T2F_C4UB_V3F: + case GL_T2F_V3F: + case GL_C4UB_V3F: + case GL_V3F: + case GL_C4UB_V2F: + case GL_V2F: + break; + default: + crStateError(__LINE__, __FILE__, GL_INVALID_ENUM, "glInterleavedArrays: Unrecognized format: %d", format); + return; + } + + DIRTY(cb->dirty, g->neg_bitid); + DIRTY(cb->clientPointer, g->neg_bitid); + +/* p, size, type, stride, enabled, bytesPerIndex */ +/* +** VertexPointer +*/ + + cp = &(c->array.v); + cp->type = GL_FLOAT; + cp->enabled = GL_TRUE; + +#ifdef CR_EXT_compiled_vertex_array + crStateUnlockClientPointer(cp); +#endif + + switch (format) + { + case GL_T4F_C4F_N3F_V4F: + cp->p = base+4*sizeof(GLfloat)+4*sizeof(GLfloat)+3*sizeof(GLfloat); + cp->size = 4; + break; + case GL_T2F_C4F_N3F_V3F: + cp->p = base+2*sizeof(GLfloat)+4*sizeof(GLfloat)+3*sizeof(GLfloat); + cp->size = 3; + break; + case GL_C4F_N3F_V3F: + cp->p = base+4*sizeof(GLfloat)+3*sizeof(GLfloat); + cp->size = 3; + break; + case GL_T4F_V4F: + cp->p = base+4*sizeof(GLfloat); + cp->size = 4; + break; + case GL_T2F_C3F_V3F: + cp->p = base+2*sizeof(GLfloat)+3*sizeof(GLfloat); + cp->size = 3; + break; + case GL_T2F_N3F_V3F: + cp->p = base+2*sizeof(GLfloat)+3*sizeof(GLfloat); + cp->size = 3; + break; + case GL_C3F_V3F: + cp->p = base+3*sizeof(GLfloat); + cp->size = 3; + break; + case GL_N3F_V3F: + cp->p = base+3*sizeof(GLfloat); + cp->size = 3; + break; + case GL_T2F_C4UB_V3F: + cp->p = base+2*sizeof(GLfloat)+4*sizeof(GLubyte); + cp->size = 3; + break; + case GL_T2F_V3F: + cp->p = base+2*sizeof(GLfloat); + cp->size = 3; + break; + case GL_C4UB_V3F: + cp->p = base+4*sizeof(GLubyte); + cp->size = 3; + break; + case GL_V3F: + cp->p = base; + cp->size = 3; + break; + case GL_C4UB_V2F: + cp->p = base+4*sizeof(GLubyte); + cp->size = 2; + break; + case GL_V2F: + cp->p = base; + cp->size = 2; + break; + default: + crStateError(__LINE__, __FILE__, GL_INVALID_ENUM, "glInterleavedArrays: Unrecognized format: %d", format); + return; + } + + cp->bytesPerIndex = cp->size * sizeof (GLfloat); + + if (stride==0) + stride = cp->bytesPerIndex + (cp->p - base); + cp->stride = stride; + +/* +** NormalPointer +*/ + + cp = &(c->array.n); + cp->enabled = GL_TRUE; + cp->stride = stride; +#ifdef CR_EXT_compiled_vertex_array + crStateUnlockClientPointer(cp); +#endif + + switch (format) + { + case GL_T4F_C4F_N3F_V4F: + cp->p = base+4*sizeof(GLfloat)+4*sizeof(GLfloat); + break; + case GL_T2F_C4F_N3F_V3F: + cp->p = base+2*sizeof(GLfloat)+4*sizeof(GLfloat); + break; + case GL_C4F_N3F_V3F: + cp->p = base+4*sizeof(GLfloat); + break; + case GL_T2F_N3F_V3F: + cp->p = base+2*sizeof(GLfloat); + break; + case GL_N3F_V3F: + cp->p = base; + break; + case GL_T4F_V4F: + case GL_T2F_C3F_V3F: + case GL_C3F_V3F: + case GL_T2F_C4UB_V3F: + case GL_T2F_V3F: + case GL_C4UB_V3F: + case GL_V3F: + case GL_C4UB_V2F: + case GL_V2F: + cp->enabled = GL_FALSE; + break; + default: + crStateError(__LINE__, __FILE__, GL_INVALID_ENUM, "glInterleavedArrays: Unrecognized format: %d", format); + return; + } + + if (cp->enabled) + { + cp->type = GL_FLOAT; + cp->size = 3; + cp->bytesPerIndex = cp->size * sizeof (GLfloat); + } + +/* +** ColorPointer +*/ + + cp = &(c->array.c); + cp->enabled = GL_TRUE; + cp->stride = stride; +#ifdef CR_EXT_compiled_vertex_array + crStateUnlockClientPointer(cp); +#endif + + switch (format) + { + case GL_T4F_C4F_N3F_V4F: + cp->size = 4; + cp->type = GL_FLOAT; + cp->bytesPerIndex = cp->size * sizeof(GLfloat); + cp->p = base+4*sizeof(GLfloat); + break; + case GL_T2F_C4F_N3F_V3F: + cp->size = 4; + cp->type = GL_FLOAT; + cp->bytesPerIndex = cp->size * sizeof(GLfloat); + cp->p = base+2*sizeof(GLfloat); + break; + case GL_C4F_N3F_V3F: + cp->size = 4; + cp->type = GL_FLOAT; + cp->bytesPerIndex = cp->size * sizeof(GLfloat); + cp->p = base; + break; + case GL_T2F_C3F_V3F: + cp->size = 3; + cp->type = GL_FLOAT; + cp->bytesPerIndex = cp->size * sizeof(GLfloat); + cp->p = base+2*sizeof(GLfloat); + break; + case GL_C3F_V3F: + cp->size = 3; + cp->type = GL_FLOAT; + cp->bytesPerIndex = cp->size * sizeof(GLfloat); + cp->p = base; + break; + case GL_T2F_C4UB_V3F: + cp->size = 4; + cp->type = GL_UNSIGNED_BYTE; + cp->bytesPerIndex = cp->size * sizeof(GLubyte); + cp->p = base+2*sizeof(GLfloat); + break; + case GL_C4UB_V3F: + cp->size = 4; + cp->type = GL_UNSIGNED_BYTE; + cp->bytesPerIndex = cp->size * sizeof(GLubyte); + cp->p = base; + break; + case GL_C4UB_V2F: + cp->size = 4; + cp->type = GL_UNSIGNED_BYTE; + cp->bytesPerIndex = cp->size * sizeof(GLubyte); + cp->p = base; + break; + case GL_T2F_N3F_V3F: + case GL_N3F_V3F: + case GL_T4F_V4F: + case GL_T2F_V3F: + case GL_V3F: + case GL_V2F: + cp->enabled = GL_FALSE; + break; + default: + crStateError(__LINE__, __FILE__, GL_INVALID_ENUM, "glInterleavedArrays: Unrecognized format: %d", format); + return; + } + +/* +** TexturePointer +*/ + + cp = &(c->array.t[c->curClientTextureUnit]); + cp->enabled = GL_TRUE; + cp->stride = stride; +#ifdef CR_EXT_compiled_vertex_array + crStateUnlockClientPointer(cp); +#endif + + switch (format) + { + case GL_T4F_C4F_N3F_V4F: + cp->size = 4; + cp->p = base; + break; + case GL_T2F_C4F_N3F_V3F: + cp->size = 3; + cp->p = base; + break; + case GL_T2F_C3F_V3F: + case GL_T2F_N3F_V3F: + cp->size = 3; + cp->p = base; + break; + case GL_T2F_C4UB_V3F: + cp->size = 3; + cp->p = base; + break; + case GL_T4F_V4F: + cp->size = 4; + cp->p = base; + break; + case GL_T2F_V3F: + cp->size = 3; + cp->p = base; + break; + case GL_C4UB_V3F: + case GL_C4UB_V2F: + case GL_C3F_V3F: + case GL_C4F_N3F_V3F: + case GL_N3F_V3F: + case GL_V3F: + case GL_V2F: + cp->enabled = GL_FALSE; + break; + default: + crStateError(__LINE__, __FILE__, GL_INVALID_ENUM, "glInterleavedArrays: Unrecognized format: %d", format); + return; + } + + if (cp->enabled) + { + cp->type = GL_FLOAT; + cp->bytesPerIndex = cp->size * sizeof (GLfloat); + } +} + +void STATE_APIENTRY crStateGetPointerv(GLenum pname, GLvoid * * params) +{ + CRContext *g = GetCurrentContext(); + CRClientState *c = &(g->client); + + if (g->current.inBeginEnd) + { + crStateError(__LINE__, __FILE__, GL_INVALID_OPERATION, + "GetPointerv called in begin/end"); + return; + } + + switch (pname) + { + case GL_VERTEX_ARRAY_POINTER: + *params = (GLvoid *) c->array.v.p; + break; + case GL_COLOR_ARRAY_POINTER: + *params = (GLvoid *) c->array.c.p; + break; + case GL_NORMAL_ARRAY_POINTER: + *params = (GLvoid *) c->array.n.p; + break; + case GL_INDEX_ARRAY_POINTER: + *params = (GLvoid *) c->array.i.p; + break; + case GL_TEXTURE_COORD_ARRAY_POINTER: + *params = (GLvoid *) c->array.t[c->curClientTextureUnit].p; + break; + case GL_EDGE_FLAG_ARRAY_POINTER: + *params = (GLvoid *) c->array.e.p; + break; +#ifdef CR_EXT_fog_coord + case GL_FOG_COORDINATE_ARRAY_POINTER_EXT: + *params = (GLvoid *) c->array.f.p; + break; +#endif +#ifdef CR_EXT_secondary_color + case GL_SECONDARY_COLOR_ARRAY_POINTER_EXT: + if( g->extensions.EXT_secondary_color ){ + *params = (GLvoid *) c->array.s.p; + } + else { + crStateError(__LINE__, __FILE__, GL_INVALID_ENUM, "Invalid Enum passed to glGetPointerv: SECONDARY_COLOR_ARRAY_EXT - EXT_secondary_color is not enabled." ); + return; + } + break; +#endif + case GL_FEEDBACK_BUFFER_POINTER: + case GL_SELECTION_BUFFER_POINTER: + /* do nothing - API switching should pick this up */ + break; + default: + crStateError(__LINE__, __FILE__, GL_INVALID_OPERATION, + "glGetPointerv: invalid pname: %d", pname); + return; + } +} + + +void STATE_APIENTRY crStatePushClientAttrib( GLbitfield mask ) +{ + CRContext *g = GetCurrentContext(); + CRClientState *c = &(g->client); + + if (g->current.inBeginEnd) { + crStateError(__LINE__, __FILE__, GL_INVALID_OPERATION, + "glPushClientAttrib called in Begin/End"); + return; + } + + if (c->attribStackDepth == CR_MAX_CLIENT_ATTRIB_STACK_DEPTH - 1) { + crStateError(__LINE__, __FILE__, GL_STACK_OVERFLOW, + "glPushClientAttrib called with a full stack!" ); + return; + } + + FLUSH(); + + c->pushMaskStack[c->attribStackDepth++] = mask; + + if (mask & GL_CLIENT_PIXEL_STORE_BIT) { + c->pixelPackStoreStack[c->pixelStoreStackDepth] = c->pack; + c->pixelUnpackStoreStack[c->pixelStoreStackDepth] = c->unpack; + c->pixelStoreStackDepth++; + } + if (mask & GL_CLIENT_VERTEX_ARRAY_BIT) { + c->vertexArrayStack[c->vertexArrayStackDepth] = c->array; + c->vertexArrayStackDepth++; + } + + /* dirty? - no, because we haven't really changed any state */ +} + + +void STATE_APIENTRY crStatePopClientAttrib( void ) +{ + CRContext *g = GetCurrentContext(); + CRClientState *c = &(g->client); + CRStateBits *sb = GetCurrentBits(); + CRClientBits *cb = &(sb->client); + CRbitvalue mask; + + if (g->current.inBeginEnd) { + crStateError(__LINE__, __FILE__, GL_INVALID_OPERATION, + "glPopClientAttrib called in Begin/End"); + return; + } + + if (c->attribStackDepth == 0) { + crStateError(__LINE__, __FILE__, GL_STACK_UNDERFLOW, + "glPopClientAttrib called with an empty stack!" ); + return; + } + + FLUSH(); + + mask = c->pushMaskStack[--c->attribStackDepth]; + + if (mask & GL_CLIENT_PIXEL_STORE_BIT) { + if (c->pixelStoreStackDepth == 0) { + crError("bug in glPopClientAttrib (pixel store) "); + return; + } + c->pixelStoreStackDepth--; + c->pack = c->pixelPackStoreStack[c->pixelStoreStackDepth]; + c->unpack = c->pixelUnpackStoreStack[c->pixelStoreStackDepth]; + DIRTY(cb->pack, g->neg_bitid); + } + + if (mask & GL_CLIENT_VERTEX_ARRAY_BIT) { + if (c->vertexArrayStackDepth == 0) { + crError("bug in glPopClientAttrib (vertex array) "); + return; + } + c->vertexArrayStackDepth--; + c->array = c->vertexArrayStack[c->vertexArrayStackDepth]; + DIRTY(cb->clientPointer, g->neg_bitid); + } + + DIRTY(cb->dirty, g->neg_bitid); +} + +static void crStateLockClientPointer(CRClientPointer* cp) +{ + crStateUnlockClientPointer(cp); + if (cp->enabled) + { + cp->locked = GL_TRUE; + } +} + +static GLboolean crStateCanLockClientPointer(CRClientPointer* cp) +{ + return !(cp->enabled && cp->buffer && cp->buffer->id); +} + +void STATE_APIENTRY crStateLockArraysEXT(GLint first, GLint count) +{ + CRContext *g = GetCurrentContext(); + CRClientState *c = &(g->client); + int i; + + for (i=0; i<CRSTATECLIENT_MAX_VERTEXARRAYS; ++i) + { + if (!crStateCanLockClientPointer(crStateGetClientPointerByIndex(i, &c->array))) + { + break; + } + } + if (i<CRSTATECLIENT_MAX_VERTEXARRAYS) + { + crDebug("crStateLockArraysEXT ignored because array %i have a bound VBO", i); + return; + } + + c->array.locked = GL_TRUE; + c->array.lockFirst = first; + c->array.lockCount = count; +#ifdef IN_GUEST + c->array.synced = GL_FALSE; +#endif + + for (i=0; i<CRSTATECLIENT_MAX_VERTEXARRAYS; ++i) + { + crStateLockClientPointer(crStateGetClientPointerByIndex(i, &c->array)); + } +} + +void STATE_APIENTRY crStateUnlockArraysEXT() +{ + CRContext *g = GetCurrentContext(); + CRClientState *c = &(g->client); + int i; + + if (!c->array.locked) + { + crDebug("crStateUnlockArraysEXT ignored because arrays aren't locked"); + return; + } + + c->array.locked = GL_FALSE; +#ifdef IN_GUEST + c->array.synced = GL_FALSE; +#endif + + for (i=0; i<CRSTATECLIENT_MAX_VERTEXARRAYS; ++i) + { + crStateUnlockClientPointer(crStateGetClientPointerByIndex(i, &c->array)); + } +} + +void STATE_APIENTRY crStateVertexArrayRangeNV(GLsizei length, const GLvoid *pointer) +{ + /* XXX todo */ + crWarning("crStateVertexArrayRangeNV not implemented"); + (void)length; (void)pointer; +} + + +void STATE_APIENTRY crStateFlushVertexArrayRangeNV(void) +{ + /* XXX todo */ + crWarning("crStateFlushVertexArrayRangeNV not implemented"); +} + +/*Returns if the given clientpointer could be used on server side directly*/ +#define CRSTATE_IS_SERVER_CP(cp) (!(cp).enabled || !(cp).p || ((cp).buffer && (cp).buffer->id) || ((cp).locked)) + +#if defined(DEBUG) && 0 +static void crStateDumpClientPointer(CRClientPointer *cp, const char *name, int i) +{ + if (i<0 && cp->enabled) + { + crDebug("CP(%s): enabled:%d ptr:%p buffer:%p buffer.name:%i locked: %i %s", + name, cp->enabled, cp->p, cp->buffer, cp->buffer ? cp->buffer->id : ~(GLuint)0, (int)cp->locked, + CRSTATE_IS_SERVER_CP(*cp) ? "":"!FAIL!"); + } + else if (0==i || cp->enabled) + { + crDebug("CP(%s%i): enabled:%d ptr:%p buffer:%p buffer.name:%i locked: %i %s", + name, i, cp->enabled, cp->p, cp->buffer, cp->buffer ? cp->buffer->id : ~(GLuint)0, (int)cp->locked, + CRSTATE_IS_SERVER_CP(*cp) ? "":"!FAIL!"); + } +} +#endif + +#ifdef DEBUG_misha +/* debugging */ +/*# define CR_NO_SERVER_ARRAYS*/ +#endif + +/* + * Determine if the enabled arrays all live on the server + * (via GL_ARB_vertex_buffer_object). + */ +GLboolean crStateUseServerArrays(void) +{ +#if defined(CR_ARB_vertex_buffer_object) && !defined(CR_NO_SERVER_ARRAYS) + CRContext *g = GetCurrentContext(); + CRClientState *c = &(g->client); + int i; + GLboolean res; + + res = CRSTATE_IS_SERVER_CP(c->array.v) + && CRSTATE_IS_SERVER_CP(c->array.n) + && CRSTATE_IS_SERVER_CP(c->array.c) + && CRSTATE_IS_SERVER_CP(c->array.i) + && CRSTATE_IS_SERVER_CP(c->array.e) + && CRSTATE_IS_SERVER_CP(c->array.s) + && CRSTATE_IS_SERVER_CP(c->array.f); + + if (res) + { + for (i = 0; (unsigned int)i < g->limits.maxTextureUnits; i++) + if (!CRSTATE_IS_SERVER_CP(c->array.t[i])) + { + res = GL_FALSE; + break; + } + } + + if (res) + { + for (i = 0; (unsigned int)i < g->limits.maxVertexProgramAttribs; i++) + if (!CRSTATE_IS_SERVER_CP(c->array.a[i])) + { + res = GL_FALSE; + break; + } + } + +#if defined(DEBUG) && 0 + if (!res) + { + crStateDumpClientPointer(&c->array.v, "v", -1); + crStateDumpClientPointer(&c->array.n, "n", -1); + crStateDumpClientPointer(&c->array.c, "c", -1); + crStateDumpClientPointer(&c->array.i, "i", -1); + crStateDumpClientPointer(&c->array.e, "e", -1); + crStateDumpClientPointer(&c->array.s, "s", -1); + crStateDumpClientPointer(&c->array.f, "f", -1); + for (i = 0; (unsigned int)i < g->limits.maxTextureUnits; i++) + crStateDumpClientPointer(&c->array.t[i], "tex", i); + for (i = 0; (unsigned int)i < g->limits.maxVertexProgramAttribs; i++) + crStateDumpClientPointer(&c->array.a[i], "attrib", i); + crDebug("crStateUseServerArrays->%d", res); + } +#endif + + return res; +#else + return GL_FALSE; +#endif +} + +GLuint crStateNeedDummyZeroVertexArray(CRContext *g, CRCurrentStatePointers *current, GLfloat *pZva) +{ +#if defined(CR_ARB_vertex_buffer_object) + CRClientState *c = &(g->client); + int i; + GLuint zvMax = 0; + + if (c->array.a[0].enabled) + return 0; + + for (i = 1; (unsigned int)i < g->limits.maxVertexProgramAttribs; i++) + { + if (c->array.a[i].enabled) + { + if (c->array.a[i].buffer && c->array.a[i].buffer->id) + { + GLuint cElements = c->array.a[i].buffer->size / c->array.a[i].stride; + if (zvMax < cElements) + zvMax = cElements; + } + else + { + zvMax = ~0; + break; + } + } + } + + if (zvMax) + { + Assert(!c->array.v.enabled); + + crStateCurrentRecoverNew(g, current); + + crMemcpy(pZva, &g->current.vertexAttrib[0][0], sizeof (*pZva) * 4); + } + + return zvMax; +#else + return GL_FALSE; +#endif +} + + +/** + * Determine if there's a server-side array element buffer. + * Called by glDrawElements() in packing SPUs to determine if glDrawElements + * should be evaluated (unrolled) locally or if glDrawElements should be + * packed and sent to the server. + */ +GLboolean +crStateUseServerArrayElements(void) +{ +#ifdef CR_ARB_vertex_buffer_object + CRContext *g = GetCurrentContext(); + if (g->bufferobject.elementsBuffer && + g->bufferobject.elementsBuffer->id > 0) + return GL_TRUE; + else + return GL_FALSE; +#else + return GL_FALSE; +#endif +} + +#define CR_BUFFER_HWID(_p) ((_p) ? (_p)->hwid : 0) + +void +crStateClientDiff(CRClientBits *cb, CRbitvalue *bitID, + CRContext *fromCtx, CRContext *toCtx) +{ + CRClientState *from = &(fromCtx->client); + const CRClientState *to = &(toCtx->client); + GLint curClientTextureUnit = from->curClientTextureUnit; + int i; + GLint idHwArrayBuffer = CR_BUFFER_HWID(toCtx->bufferobject.arrayBuffer); + const GLint idHwInitialBuffer = idHwArrayBuffer; + +#ifdef DEBUG_misha + { + GLint tstHwBuffer = -1; + diff_api.GetIntegerv(GL_ARRAY_BUFFER_BINDING, &tstHwBuffer); + CRASSERT(idHwInitialBuffer == tstHwBuffer); + } +#endif + + + if (CHECKDIRTY(cb->clientPointer, bitID)) { + /* one or more vertex pointers is dirty */ + if (CHECKDIRTY(cb->v, bitID)) { + if (from->array.v.size != to->array.v.size || + from->array.v.type != to->array.v.type || + from->array.v.stride != to->array.v.stride || + from->array.v.p != to->array.v.p || + from->array.v.buffer != to->array.v.buffer) { + GLint idHwArrayBufferUsed = CR_BUFFER_HWID(to->array.v.buffer); + if (idHwArrayBufferUsed != idHwArrayBuffer) + { + diff_api.BindBufferARB(GL_ARRAY_BUFFER_ARB, idHwArrayBufferUsed); + idHwArrayBuffer = idHwArrayBufferUsed; + } + diff_api.VertexPointer(to->array.v.size, to->array.v.type, + to->array.v.stride, to->array.v.p); + from->array.v.size = to->array.v.size; + from->array.v.type = to->array.v.type; + from->array.v.stride = to->array.v.stride; + from->array.v.p = to->array.v.p; + from->array.v.buffer = to->array.v.buffer; + } + CLEARDIRTY2(cb->v, bitID); + } + /* normal */ + if (CHECKDIRTY(cb->n, bitID)) { + if (from->array.n.type != to->array.n.type || + from->array.n.stride != to->array.n.stride || + from->array.n.p != to->array.n.p || + from->array.n.buffer != to->array.n.buffer) { + GLint idHwArrayBufferUsed = CR_BUFFER_HWID(to->array.n.buffer); + if (idHwArrayBufferUsed != idHwArrayBuffer) + { + diff_api.BindBufferARB(GL_ARRAY_BUFFER_ARB, idHwArrayBufferUsed); + idHwArrayBuffer = idHwArrayBufferUsed; + } + diff_api.NormalPointer(to->array.n.type, + to->array.n.stride, to->array.n.p); + from->array.n.type = to->array.n.type; + from->array.n.stride = to->array.n.stride; + from->array.n.p = to->array.n.p; + from->array.n.buffer = to->array.n.buffer; + } + CLEARDIRTY2(cb->n, bitID); + } + /* color */ + if (CHECKDIRTY(cb->c, bitID)) { + if (from->array.c.size != to->array.c.size || + from->array.c.type != to->array.c.type || + from->array.c.stride != to->array.c.stride || + from->array.c.p != to->array.c.p || + from->array.c.buffer != to->array.c.buffer) { + GLint idHwArrayBufferUsed = CR_BUFFER_HWID(to->array.c.buffer); + if (idHwArrayBufferUsed != idHwArrayBuffer) + { + diff_api.BindBufferARB(GL_ARRAY_BUFFER_ARB, idHwArrayBufferUsed); + idHwArrayBuffer = idHwArrayBufferUsed; + } + diff_api.ColorPointer(to->array.c.size, to->array.c.type, + to->array.c.stride, to->array.c.p); + from->array.c.size = to->array.c.size; + from->array.c.type = to->array.c.type; + from->array.c.stride = to->array.c.stride; + from->array.c.p = to->array.c.p; + from->array.c.buffer = to->array.c.buffer; + } + CLEARDIRTY2(cb->c, bitID); + } + /* index */ + if (CHECKDIRTY(cb->i, bitID)) { + if (from->array.i.type != to->array.i.type || + from->array.i.stride != to->array.i.stride || + from->array.i.p != to->array.i.p || + from->array.i.buffer != to->array.i.buffer) { + GLint idHwArrayBufferUsed = CR_BUFFER_HWID(to->array.i.buffer); + if (idHwArrayBufferUsed != idHwArrayBuffer) + { + diff_api.BindBufferARB(GL_ARRAY_BUFFER_ARB, idHwArrayBufferUsed); + idHwArrayBuffer = idHwArrayBufferUsed; + } + diff_api.IndexPointer(to->array.i.type, + to->array.i.stride, to->array.i.p); + from->array.i.type = to->array.i.type; + from->array.i.stride = to->array.i.stride; + from->array.i.p = to->array.i.p; + from->array.i.buffer = to->array.i.buffer; + } + CLEARDIRTY2(cb->i, bitID); + } + /* texcoords */ + for (i = 0; (unsigned int)i < toCtx->limits.maxTextureUnits; i++) { + if (CHECKDIRTY(cb->t[i], bitID)) { + if (from->array.t[i].size != to->array.t[i].size || + from->array.t[i].type != to->array.t[i].type || + from->array.t[i].stride != to->array.t[i].stride || + from->array.t[i].p != to->array.t[i].p || + from->array.t[i].buffer != to->array.t[i].buffer) { + GLint idHwArrayBufferUsed = CR_BUFFER_HWID(to->array.t[i].buffer); + if (idHwArrayBufferUsed != idHwArrayBuffer) + { + diff_api.BindBufferARB(GL_ARRAY_BUFFER_ARB, idHwArrayBufferUsed); + idHwArrayBuffer = idHwArrayBufferUsed; + } + diff_api.ClientActiveTextureARB(GL_TEXTURE0_ARB + i); + curClientTextureUnit = i; + diff_api.TexCoordPointer(to->array.t[i].size, to->array.t[i].type, + to->array.t[i].stride, to->array.t[i].p); + from->array.t[i].size = to->array.t[i].size; + from->array.t[i].type = to->array.t[i].type; + from->array.t[i].stride = to->array.t[i].stride; + from->array.t[i].p = to->array.t[i].p; + from->array.t[i].buffer = to->array.t[i].buffer; + } + CLEARDIRTY2(cb->t[i], bitID); + } + } + /* edge flag */ + if (CHECKDIRTY(cb->e, bitID)) { + if (from->array.e.stride != to->array.e.stride || + from->array.e.p != to->array.e.p || + from->array.e.buffer != to->array.e.buffer) { + GLint idHwArrayBufferUsed = CR_BUFFER_HWID(to->array.e.buffer); + if (idHwArrayBufferUsed != idHwArrayBuffer) + { + diff_api.BindBufferARB(GL_ARRAY_BUFFER_ARB, idHwArrayBufferUsed); + idHwArrayBuffer = idHwArrayBufferUsed; + } + diff_api.EdgeFlagPointer(to->array.e.stride, to->array.e.p); + from->array.e.stride = to->array.e.stride; + from->array.e.p = to->array.e.p; + from->array.e.buffer = to->array.e.buffer; + } + CLEARDIRTY2(cb->e, bitID); + } + /* secondary color */ + if (CHECKDIRTY(cb->s, bitID)) { + if (from->array.s.size != to->array.s.size || + from->array.s.type != to->array.s.type || + from->array.s.stride != to->array.s.stride || + from->array.s.p != to->array.s.p || + from->array.s.buffer != to->array.s.buffer) { + GLint idHwArrayBufferUsed = CR_BUFFER_HWID(to->array.s.buffer); + if (idHwArrayBufferUsed != idHwArrayBuffer) + { + diff_api.BindBufferARB(GL_ARRAY_BUFFER_ARB, idHwArrayBufferUsed); + idHwArrayBuffer = idHwArrayBufferUsed; + } + diff_api.SecondaryColorPointerEXT(to->array.s.size, to->array.s.type, + to->array.s.stride, to->array.s.p); + from->array.s.size = to->array.s.size; + from->array.s.type = to->array.s.type; + from->array.s.stride = to->array.s.stride; + from->array.s.p = to->array.s.p; + from->array.s.buffer = to->array.s.buffer; + } + CLEARDIRTY2(cb->s, bitID); + } + /* fog coord */ + if (CHECKDIRTY(cb->f, bitID)) { + if (from->array.f.type != to->array.f.type || + from->array.f.stride != to->array.f.stride || + from->array.f.p != to->array.f.p || + from->array.f.buffer != to->array.f.buffer) { + GLint idHwArrayBufferUsed = CR_BUFFER_HWID(to->array.f.buffer); + if (idHwArrayBufferUsed != idHwArrayBuffer) + { + diff_api.BindBufferARB(GL_ARRAY_BUFFER_ARB, idHwArrayBufferUsed); + idHwArrayBuffer = idHwArrayBufferUsed; + } + diff_api.FogCoordPointerEXT(to->array.f.type, + to->array.f.stride, to->array.f.p); + from->array.f.type = to->array.f.type; + from->array.f.stride = to->array.f.stride; + from->array.f.p = to->array.f.p; + from->array.f.buffer = to->array.f.buffer; + } + CLEARDIRTY2(cb->f, bitID); + } +#if defined(CR_NV_vertex_program) || defined(CR_ARB_vertex_program) + /* vertex attributes */ + for (i = 0; (unsigned int)i < toCtx->limits.maxVertexProgramAttribs; i++) { + if (CHECKDIRTY(cb->a[i], bitID)) { + if (from->array.a[i].size != to->array.a[i].size || + from->array.a[i].type != to->array.a[i].type || + from->array.a[i].stride != to->array.a[i].stride || + from->array.a[i].normalized != to->array.a[i].normalized || + from->array.a[i].p != to->array.a[i].p || + from->array.a[i].buffer != to->array.a[i].buffer) { + GLint idHwArrayBufferUsed = CR_BUFFER_HWID(to->array.a[i].buffer); + if (idHwArrayBufferUsed != idHwArrayBuffer) + { + diff_api.BindBufferARB(GL_ARRAY_BUFFER_ARB, idHwArrayBufferUsed); + idHwArrayBuffer = idHwArrayBufferUsed; + } + diff_api.VertexAttribPointerARB(i, to->array.a[i].size, + to->array.a[i].type, + to->array.a[i].normalized, + to->array.a[i].stride, + to->array.a[i].p); + from->array.a[i].size = to->array.a[i].size; + from->array.a[i].type = to->array.a[i].type; + from->array.a[i].stride = to->array.a[i].stride; + from->array.a[i].normalized = to->array.a[i].normalized; + from->array.a[i].p = to->array.a[i].p; + from->array.a[i].buffer = to->array.a[i].buffer; + } + CLEARDIRTY2(cb->a[i], bitID); + } + } +#endif + } + + if (idHwArrayBuffer != idHwInitialBuffer) + { + diff_api.BindBufferARB(GL_ARRAY_BUFFER_ARB, idHwInitialBuffer); + } + + if (CHECKDIRTY(cb->enableClientState, bitID)) { + /* update vertex array enable/disable flags */ + glAble able[2]; + able[0] = diff_api.DisableClientState; + able[1] = diff_api.EnableClientState; + if (from->array.v.enabled != to->array.v.enabled) { + able[to->array.v.enabled](GL_VERTEX_ARRAY); + from->array.v.enabled = to->array.v.enabled; + } + if (from->array.n.enabled != to->array.n.enabled) { + able[to->array.n.enabled](GL_NORMAL_ARRAY); + from->array.n.enabled = to->array.n.enabled; + } + if (from->array.c.enabled != to->array.c.enabled) { + able[to->array.c.enabled](GL_COLOR_ARRAY); + from->array.c.enabled = to->array.c.enabled; + } + if (from->array.i.enabled != to->array.i.enabled) { + able[to->array.i.enabled](GL_INDEX_ARRAY); + from->array.i.enabled = to->array.i.enabled; + } + for (i = 0; (unsigned int)i < toCtx->limits.maxTextureUnits; i++) { + if (from->array.t[i].enabled != to->array.t[i].enabled) { + diff_api.ClientActiveTextureARB(GL_TEXTURE0_ARB + i); + curClientTextureUnit = i; + able[to->array.t[i].enabled](GL_TEXTURE_COORD_ARRAY); + from->array.t[i].enabled = to->array.t[i].enabled; + } + } + if (from->array.e.enabled != to->array.e.enabled) { + able[to->array.e.enabled](GL_EDGE_FLAG_ARRAY); + from->array.e.enabled = to->array.e.enabled; + } + if (from->array.s.enabled != to->array.s.enabled) { + able[to->array.s.enabled](GL_SECONDARY_COLOR_ARRAY_EXT); + from->array.s.enabled = to->array.s.enabled; + } + if (from->array.f.enabled != to->array.f.enabled) { + able[to->array.f.enabled](GL_FOG_COORDINATE_ARRAY_EXT); + from->array.f.enabled = to->array.f.enabled; + } + for (i = 0; (unsigned int)i < toCtx->limits.maxVertexProgramAttribs; i++) { + if (from->array.a[i].enabled != to->array.a[i].enabled) { + if (to->array.a[i].enabled) + diff_api.EnableVertexAttribArrayARB(i); + else + diff_api.DisableVertexAttribArrayARB(i); + from->array.a[i].enabled = to->array.a[i].enabled; + } + } + CLEARDIRTY2(cb->enableClientState, bitID); + } + + if (to->curClientTextureUnit != curClientTextureUnit) + { + diff_api.ClientActiveTextureARB(GL_TEXTURE0_ARB + to->curClientTextureUnit); + } +} + + +void +crStateClientSwitch(CRClientBits *cb, CRbitvalue *bitID, + CRContext *fromCtx, CRContext *toCtx) +{ + const CRClientState *from = &(fromCtx->client); + const CRClientState *to = &(toCtx->client); + GLint curClientTextureUnit = from->curClientTextureUnit; + int i; + GLint idHwArrayBuffer = CR_BUFFER_HWID(toCtx->bufferobject.arrayBuffer); + const GLint idHwInitialBuffer = idHwArrayBuffer; + +#ifdef DEBUG_misha + { + GLint tstHwBuffer = -1; + diff_api.GetIntegerv(GL_ARRAY_BUFFER_BINDING, &tstHwBuffer); + CRASSERT(idHwInitialBuffer == tstHwBuffer); + } +#endif + + if (CHECKDIRTY(cb->clientPointer, bitID)) { + /* one or more vertex pointers is dirty */ + if (CHECKDIRTY(cb->v, bitID)) { + if (from->array.v.size != to->array.v.size || + from->array.v.type != to->array.v.type || + from->array.v.stride != to->array.v.stride || + from->array.v.p != to->array.v.p || + from->array.v.buffer != to->array.v.buffer) { + GLint idHwArrayBufferUsed = CR_BUFFER_HWID(to->array.v.buffer); + if (idHwArrayBufferUsed != idHwArrayBuffer) + { + diff_api.BindBufferARB(GL_ARRAY_BUFFER_ARB, idHwArrayBufferUsed); + idHwArrayBuffer = idHwArrayBufferUsed; + } + diff_api.VertexPointer(to->array.v.size, to->array.v.type, + to->array.v.stride, to->array.v.p); + FILLDIRTY(cb->v); + FILLDIRTY(cb->clientPointer); + FILLDIRTY(cb->dirty); + } + CLEARDIRTY2(cb->v, bitID); + } + /* normal */ + if (CHECKDIRTY(cb->n, bitID)) { + if (from->array.n.type != to->array.n.type || + from->array.n.stride != to->array.n.stride || + from->array.n.p != to->array.n.p || + from->array.n.buffer != to->array.n.buffer) { + GLint idHwArrayBufferUsed = CR_BUFFER_HWID(to->array.n.buffer); + if (idHwArrayBufferUsed != idHwArrayBuffer) + { + diff_api.BindBufferARB(GL_ARRAY_BUFFER_ARB, idHwArrayBufferUsed); + idHwArrayBuffer = idHwArrayBufferUsed; + } + diff_api.NormalPointer(to->array.n.type, + to->array.n.stride, to->array.n.p); + FILLDIRTY(cb->n); + FILLDIRTY(cb->clientPointer); + FILLDIRTY(cb->dirty); + } + CLEARDIRTY2(cb->n, bitID); + } + /* color */ + if (CHECKDIRTY(cb->c, bitID)) { + if (from->array.c.size != to->array.c.size || + from->array.c.type != to->array.c.type || + from->array.c.stride != to->array.c.stride || + from->array.c.p != to->array.c.p || + from->array.c.buffer != to->array.c.buffer) { + GLint idHwArrayBufferUsed = CR_BUFFER_HWID(to->array.c.buffer); + if (idHwArrayBufferUsed != idHwArrayBuffer) + { + diff_api.BindBufferARB(GL_ARRAY_BUFFER_ARB, idHwArrayBufferUsed); + idHwArrayBuffer = idHwArrayBufferUsed; + } + diff_api.ColorPointer(to->array.c.size, to->array.c.type, + to->array.c.stride, to->array.c.p); + FILLDIRTY(cb->c); + FILLDIRTY(cb->clientPointer); + FILLDIRTY(cb->dirty); + } + CLEARDIRTY2(cb->c, bitID); + } + /* index */ + if (CHECKDIRTY(cb->i, bitID)) { + if (from->array.i.type != to->array.i.type || + from->array.i.stride != to->array.i.stride || + from->array.i.p != to->array.i.p || + from->array.i.buffer != to->array.i.buffer) { + GLint idHwArrayBufferUsed = CR_BUFFER_HWID(to->array.i.buffer); + if (idHwArrayBufferUsed != idHwArrayBuffer) + { + diff_api.BindBufferARB(GL_ARRAY_BUFFER_ARB, idHwArrayBufferUsed); + idHwArrayBuffer = idHwArrayBufferUsed; + } + diff_api.IndexPointer(to->array.i.type, + to->array.i.stride, to->array.i.p); + FILLDIRTY(cb->i); + FILLDIRTY(cb->dirty); + FILLDIRTY(cb->clientPointer); + } + CLEARDIRTY2(cb->i, bitID); + } + /* texcoords */ + for (i = 0; (unsigned int)i < toCtx->limits.maxTextureUnits; i++) { + if (CHECKDIRTY(cb->t[i], bitID)) { + if (from->array.t[i].size != to->array.t[i].size || + from->array.t[i].type != to->array.t[i].type || + from->array.t[i].stride != to->array.t[i].stride || + from->array.t[i].p != to->array.t[i].p || + from->array.t[i].buffer != to->array.t[i].buffer) { + GLint idHwArrayBufferUsed = CR_BUFFER_HWID(to->array.t[i].buffer); + if (idHwArrayBufferUsed != idHwArrayBuffer) + { + diff_api.BindBufferARB(GL_ARRAY_BUFFER_ARB, idHwArrayBufferUsed); + idHwArrayBuffer = idHwArrayBufferUsed; + } + diff_api.ClientActiveTextureARB(GL_TEXTURE0_ARB + i); + curClientTextureUnit = i; + diff_api.TexCoordPointer(to->array.t[i].size, to->array.t[i].type, + to->array.t[i].stride, to->array.t[i].p); + FILLDIRTY(cb->t[i]); + FILLDIRTY(cb->clientPointer); + FILLDIRTY(cb->dirty); + } + CLEARDIRTY2(cb->t[i], bitID); + } + } + /* edge flag */ + if (CHECKDIRTY(cb->e, bitID)) { + if (from->array.e.stride != to->array.e.stride || + from->array.e.p != to->array.e.p || + from->array.e.buffer != to->array.e.buffer) { + GLint idHwArrayBufferUsed = CR_BUFFER_HWID(to->array.e.buffer); + if (idHwArrayBufferUsed != idHwArrayBuffer) + { + diff_api.BindBufferARB(GL_ARRAY_BUFFER_ARB, idHwArrayBufferUsed); + idHwArrayBuffer = idHwArrayBufferUsed; + } + diff_api.EdgeFlagPointer(to->array.e.stride, to->array.e.p); + FILLDIRTY(cb->e); + FILLDIRTY(cb->clientPointer); + FILLDIRTY(cb->dirty); + } + CLEARDIRTY2(cb->e, bitID); + } + /* secondary color */ + if (CHECKDIRTY(cb->s, bitID)) { + if (from->array.s.size != to->array.s.size || + from->array.s.type != to->array.s.type || + from->array.s.stride != to->array.s.stride || + from->array.s.p != to->array.s.p || + from->array.s.buffer != to->array.s.buffer) { + GLint idHwArrayBufferUsed = CR_BUFFER_HWID(to->array.s.buffer); + if (idHwArrayBufferUsed != idHwArrayBuffer) + { + diff_api.BindBufferARB(GL_ARRAY_BUFFER_ARB, idHwArrayBufferUsed); + idHwArrayBuffer = idHwArrayBufferUsed; + } + diff_api.SecondaryColorPointerEXT(to->array.s.size, to->array.s.type, + to->array.s.stride, to->array.s.p); + FILLDIRTY(cb->s); + FILLDIRTY(cb->clientPointer); + FILLDIRTY(cb->dirty); + } + CLEARDIRTY2(cb->s, bitID); + } + /* fog coord */ + if (CHECKDIRTY(cb->f, bitID)) { + if (from->array.f.type != to->array.f.type || + from->array.f.stride != to->array.f.stride || + from->array.f.p != to->array.f.p || + from->array.f.buffer != to->array.f.buffer) { + GLint idHwArrayBufferUsed = CR_BUFFER_HWID(to->array.f.buffer); + if (idHwArrayBufferUsed != idHwArrayBuffer) + { + diff_api.BindBufferARB(GL_ARRAY_BUFFER_ARB, idHwArrayBufferUsed); + idHwArrayBuffer = idHwArrayBufferUsed; + } + diff_api.FogCoordPointerEXT(to->array.f.type, + to->array.f.stride, to->array.f.p); + FILLDIRTY(cb->f); + FILLDIRTY(cb->clientPointer); + FILLDIRTY(cb->dirty); + } + CLEARDIRTY2(cb->f, bitID); + } +#if defined(CR_NV_vertex_program) || defined(CR_ARB_vertex_program) + /* vertex attributes */ + for (i = 0; (unsigned int)i < toCtx->limits.maxVertexProgramAttribs; i++) { + if (CHECKDIRTY(cb->a[i], bitID)) { + if (from->array.a[i].size != to->array.a[i].size || + from->array.a[i].type != to->array.a[i].type || + from->array.a[i].stride != to->array.a[i].stride || + from->array.a[i].normalized != to->array.a[i].normalized || + from->array.a[i].p != to->array.a[i].p || + from->array.a[i].buffer != to->array.a[i].buffer) { + GLint idHwArrayBufferUsed = CR_BUFFER_HWID(to->array.a[i].buffer); + if (idHwArrayBufferUsed != idHwArrayBuffer) + { + diff_api.BindBufferARB(GL_ARRAY_BUFFER_ARB, idHwArrayBufferUsed); + idHwArrayBuffer = idHwArrayBufferUsed; + } + diff_api.VertexAttribPointerARB(i, to->array.a[i].size, + to->array.a[i].type, + to->array.a[i].normalized, + to->array.a[i].stride, + to->array.a[i].p); + FILLDIRTY(cb->a[i]); + FILLDIRTY(cb->clientPointer); + FILLDIRTY(cb->dirty); + } + CLEARDIRTY2(cb->a[i], bitID); + } + } +#endif + } + + if (idHwArrayBuffer != idHwInitialBuffer) + { + diff_api.BindBufferARB(GL_ARRAY_BUFFER_ARB, idHwInitialBuffer); + } + + if (CHECKDIRTY(cb->enableClientState, bitID)) { + /* update vertex array enable/disable flags */ + glAble able[2]; + able[0] = diff_api.DisableClientState; + able[1] = diff_api.EnableClientState; + if (from->array.v.enabled != to->array.v.enabled) { + able[to->array.v.enabled](GL_VERTEX_ARRAY); + FILLDIRTY(cb->enableClientState); + FILLDIRTY(cb->dirty); + } + if (from->array.n.enabled != to->array.n.enabled) { + able[to->array.n.enabled](GL_NORMAL_ARRAY); + FILLDIRTY(cb->enableClientState); + FILLDIRTY(cb->dirty); + } + if (from->array.c.enabled != to->array.c.enabled) { + able[to->array.c.enabled](GL_COLOR_ARRAY); + FILLDIRTY(cb->enableClientState); + FILLDIRTY(cb->dirty); + } + if (from->array.i.enabled != to->array.i.enabled) { + able[to->array.i.enabled](GL_INDEX_ARRAY); + FILLDIRTY(cb->enableClientState); + FILLDIRTY(cb->dirty); + } + for (i = 0; (unsigned int)i < toCtx->limits.maxTextureUnits; i++) { + if (from->array.t[i].enabled != to->array.t[i].enabled) { + diff_api.ClientActiveTextureARB(GL_TEXTURE0_ARB + i); + curClientTextureUnit = i; + able[to->array.t[i].enabled](GL_TEXTURE_COORD_ARRAY); + FILLDIRTY(cb->enableClientState); + FILLDIRTY(cb->dirty); + } + } + if (from->array.e.enabled != to->array.e.enabled) { + able[to->array.e.enabled](GL_EDGE_FLAG_ARRAY); + FILLDIRTY(cb->enableClientState); + FILLDIRTY(cb->dirty); + } + if (from->array.s.enabled != to->array.s.enabled) { + able[to->array.s.enabled](GL_SECONDARY_COLOR_ARRAY_EXT); + FILLDIRTY(cb->enableClientState); + FILLDIRTY(cb->dirty); + } + if (from->array.f.enabled != to->array.f.enabled) { + able[to->array.f.enabled](GL_FOG_COORDINATE_ARRAY_EXT); + FILLDIRTY(cb->enableClientState); + FILLDIRTY(cb->dirty); + } + for (i = 0; (unsigned int)i < toCtx->limits.maxVertexProgramAttribs; i++) { + if (from->array.a[i].enabled != to->array.a[i].enabled) { + if (to->array.a[i].enabled) + diff_api.EnableVertexAttribArrayARB(i); + else + diff_api.DisableVertexAttribArrayARB(i); + FILLDIRTY(cb->enableClientState); + FILLDIRTY(cb->dirty); + } + } + CLEARDIRTY2(cb->enableClientState, bitID); + } + + if (to->curClientTextureUnit != curClientTextureUnit) + { + diff_api.ClientActiveTextureARB(GL_TEXTURE0_ARB + to->curClientTextureUnit); + } + + if (CHECKDIRTY(cb->unpack, bitID)) + { + if (from->unpack.rowLength != to->unpack.rowLength) + { + diff_api.PixelStorei(GL_UNPACK_ROW_LENGTH, to->unpack.rowLength); + FILLDIRTY(cb->unpack); + FILLDIRTY(cb->dirty); + } + if (from->unpack.skipRows != to->unpack.skipRows) + { + diff_api.PixelStorei(GL_UNPACK_SKIP_ROWS, to->unpack.skipRows); + FILLDIRTY(cb->unpack); + FILLDIRTY(cb->dirty); + } + if (from->unpack.skipPixels != to->unpack.skipPixels) + { + diff_api.PixelStorei(GL_UNPACK_SKIP_PIXELS, to->unpack.skipPixels); + FILLDIRTY(cb->unpack); + FILLDIRTY(cb->dirty); + } + if (from->unpack.alignment != to->unpack.alignment) + { + diff_api.PixelStorei(GL_UNPACK_ALIGNMENT, to->unpack.alignment); + FILLDIRTY(cb->unpack); + FILLDIRTY(cb->dirty); + } + if (from->unpack.imageHeight != to->unpack.imageHeight) + { + diff_api.PixelStorei(GL_UNPACK_IMAGE_HEIGHT, to->unpack.imageHeight); + FILLDIRTY(cb->unpack); + FILLDIRTY(cb->dirty); + } + if (from->unpack.skipImages != to->unpack.skipImages) + { + diff_api.PixelStorei(GL_UNPACK_SKIP_IMAGES, to->unpack.skipImages); + FILLDIRTY(cb->unpack); + FILLDIRTY(cb->dirty); + } + if (from->unpack.swapBytes != to->unpack.swapBytes) + { + diff_api.PixelStorei(GL_UNPACK_SWAP_BYTES, to->unpack.swapBytes); + FILLDIRTY(cb->unpack); + FILLDIRTY(cb->dirty); + } + if (from->unpack.psLSBFirst != to->unpack.psLSBFirst) + { + diff_api.PixelStorei(GL_UNPACK_LSB_FIRST, to->unpack.psLSBFirst); + FILLDIRTY(cb->unpack); + FILLDIRTY(cb->dirty); + } + CLEARDIRTY2(cb->unpack, bitID); + } + + if (CHECKDIRTY(cb->pack, bitID)) + { + if (from->pack.rowLength != to->pack.rowLength) + { + diff_api.PixelStorei(GL_PACK_ROW_LENGTH, to->pack.rowLength); + FILLDIRTY(cb->pack); + FILLDIRTY(cb->dirty); + } + if (from->pack.skipRows != to->pack.skipRows) + { + diff_api.PixelStorei(GL_PACK_SKIP_ROWS, to->pack.skipRows); + FILLDIRTY(cb->pack); + FILLDIRTY(cb->dirty); + } + if (from->pack.skipPixels != to->pack.skipPixels) + { + diff_api.PixelStorei(GL_PACK_SKIP_PIXELS, to->pack.skipPixels); + FILLDIRTY(cb->pack); + FILLDIRTY(cb->dirty); + } + if (from->pack.alignment != to->pack.alignment) + { + diff_api.PixelStorei(GL_PACK_ALIGNMENT, to->pack.alignment); + FILLDIRTY(cb->pack); + FILLDIRTY(cb->dirty); + } + if (from->pack.imageHeight != to->pack.imageHeight) + { + diff_api.PixelStorei(GL_PACK_IMAGE_HEIGHT, to->pack.imageHeight); + FILLDIRTY(cb->pack); + FILLDIRTY(cb->dirty); + } + if (from->pack.skipImages != to->pack.skipImages) + { + diff_api.PixelStorei(GL_PACK_SKIP_IMAGES, to->pack.skipImages); + FILLDIRTY(cb->pack); + FILLDIRTY(cb->dirty); + } + if (from->pack.swapBytes != to->pack.swapBytes) + { + diff_api.PixelStorei(GL_PACK_SWAP_BYTES, to->pack.swapBytes); + FILLDIRTY(cb->pack); + FILLDIRTY(cb->dirty); + } + if (from->pack.psLSBFirst != to->pack.psLSBFirst) + { + diff_api.PixelStorei(GL_PACK_LSB_FIRST, to->pack.psLSBFirst); + FILLDIRTY(cb->pack); + FILLDIRTY(cb->dirty); + } + CLEARDIRTY2(cb->pack, bitID); + } + + CLEARDIRTY2(cb->dirty, bitID); +} + +CRClientPointer* crStateGetClientPointerByIndex(int index, CRVertexArrays *array) +{ + CRASSERT(array && index>=0 && index<CRSTATECLIENT_MAX_VERTEXARRAYS); + + if (array == NULL || index < 0 || index >= CRSTATECLIENT_MAX_VERTEXARRAYS) + { + return NULL; + } + + if (index < 7) + { + switch (index) + { + case 0: return &array->v; + case 1: return &array->c; + case 2: return &array->f; + case 3: return &array->s; + case 4: return &array->e; + case 5: return &array->i; + case 6: return &array->n; + } + } + else if (index<(7+CR_MAX_TEXTURE_UNITS)) + { + return &array->t[index-7]; + } + else + { + return &array->a[index-7-CR_MAX_TEXTURE_UNITS]; + } + + /*silence the compiler warning*/ + CRASSERT(false); + return NULL; +} |