void crStateBufferObjectInit (CRContext *ctx) { CRStateBits *sb = GetCurrentBits(); CRBufferObjectBits *bb = &sb->bufferobject; CRBufferObjectState *b = &ctx->bufferobject; RESET(bb->dirty, ctx->bitid); RESET(bb->arrayBinding, ctx->bitid); RESET(bb->elementsBinding, ctx->bitid); #ifdef CR_ARB_pixel_buffer_object RESET(bb->unpackBinding, ctx->bitid); RESET(bb->packBinding, ctx->bitid); #endif #ifdef IN_GUEST b->retainBufferData = GL_TRUE; #else b->retainBufferData = GL_FALSE; #endif b->nullBuffer = AllocBufferObject(0); b->arrayBuffer = b->nullBuffer; b->elementsBuffer = b->nullBuffer; b->nullBuffer->refCount += 2; #ifdef CR_ARB_pixel_buffer_object b->packBuffer = b->nullBuffer; b->unpackBuffer = b->nullBuffer; b->nullBuffer->refCount += 2; #endif ctx->shared->bVBOResyncNeeded = GL_FALSE; }
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 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 crStateClearAccum (GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha) { CRContext *g = GetCurrentContext(); CRBufferState *b = &(g->buffer); CRStateBits *sp = GetCurrentBits(); CRBufferBits *bb = &(sp->buffer); if (g->current.inBeginEnd) { crStateError(__LINE__, __FILE__, GL_INVALID_OPERATION, "glClearAccum called in begin/end"); return; } FLUSH(); if (red < -1.0f) red = 0.0f; if (red > 1.0f) red = 1.0f; if (green < -1.0f) green = 0.0f; if (green > 1.0f) green = 1.0f; if (blue < -1.0f) blue = 0.0f; if (blue > 1.0f) blue = 1.0f; if (alpha < -1.0f) alpha = 0.0f; if (alpha > 1.0f) alpha = 1.0f; b->accumClearValue.r = red; b->accumClearValue.g = green; b->accumClearValue.b = blue; b->accumClearValue.a = alpha; DIRTY(bb->dirty, g->neg_bitid); DIRTY(bb->clearAccum, g->neg_bitid); }
void STATE_APIENTRY crStatePolygonStipple (const GLubyte *p) { CRContext *g = GetCurrentContext(); CRPolygonState *poly = &(g->polygon); CRStateBits *sb = GetCurrentBits(); CRPolygonBits *pb = &(sb->polygon); if (g->current.inBeginEnd) { crStateError(__LINE__, __FILE__, GL_INVALID_OPERATION, "glPolygonStipple called in begin/end"); return; } FLUSH(); if (!p) { crStateError(__LINE__, __FILE__, GL_NO_ERROR, "Void pointer passed to PolygonStipple"); return; } crMemcpy((char*)poly->stipple, (char*)p, 128); DIRTY(pb->dirty, g->neg_bitid); DIRTY(pb->stipple, g->neg_bitid); }
void crStateUpdateColorBits(void) { /* This is a hack to force updating the 'current' attribs */ CRStateBits *sb = GetCurrentBits(); FILLDIRTY(sb->current.dirty); FILLDIRTY(sb->current.vertexAttrib[VERT_ATTRIB_COLOR0]); }
void STATE_APIENTRY crStateCullFace(GLenum mode) { CRContext *g = GetCurrentContext(); CRPolygonState *p = &(g->polygon); CRStateBits *sb = GetCurrentBits(); CRPolygonBits *pb = &(sb->polygon); if (g->current.inBeginEnd) { crStateError(__LINE__, __FILE__, GL_INVALID_OPERATION, "glCullFace called in begin/end"); return; } FLUSH(); if (mode != GL_FRONT && mode != GL_BACK && mode != GL_FRONT_AND_BACK) { crStateError(__LINE__, __FILE__, GL_INVALID_ENUM, "glCullFace called with bogus mode: 0x%x", mode); return; } p->cullFaceMode = mode; DIRTY(pb->mode, g->neg_bitid); DIRTY(pb->dirty, g->neg_bitid); }
void crStatePolygonInit(CRContext *ctx) { CRPolygonState *p = &ctx->polygon; CRStateBits *sb = GetCurrentBits(ctx->pStateTracker); CRPolygonBits *pb = &(sb->polygon); int i; p->polygonSmooth = GL_FALSE; p->polygonOffsetFill = GL_FALSE; p->polygonOffsetLine = GL_FALSE; p->polygonOffsetPoint = GL_FALSE; p->polygonStipple = GL_FALSE; p->cullFace = GL_FALSE; RESET(pb->enable, ctx->bitid); p->offsetFactor = 0; p->offsetUnits = 0; RESET(pb->offset, ctx->bitid); p->cullFaceMode = GL_BACK; p->frontFace = GL_CCW; p->frontMode = GL_FILL; p->backMode = GL_FILL; RESET(pb->mode, ctx->bitid); for (i=0; i<32; i++) p->stipple[i] = 0xFFFFFFFF; RESET(pb->stipple, ctx->bitid); RESET(pb->dirty, ctx->bitid); }
void STATE_APIENTRY crStatePolygonStipple (PCRStateTracker pState, const GLubyte *p) { CRContext *g = GetCurrentContext(pState); CRPolygonState *poly = &(g->polygon); CRStateBits *sb = GetCurrentBits(pState); CRPolygonBits *pb = &(sb->polygon); if (g->current.inBeginEnd) { crStateError(pState, __LINE__, __FILE__, GL_INVALID_OPERATION, "glPolygonStipple called in begin/end"); return; } FLUSH(); if (!p && !crStateIsBufferBound(pState, GL_PIXEL_UNPACK_BUFFER_ARB)) { crDebug("Void pointer passed to PolygonStipple"); return; } /** @todo track mask if buffer is bound?*/ if (!crStateIsBufferBound(pState, GL_PIXEL_UNPACK_BUFFER_ARB)) { crMemcpy((char*)poly->stipple, (char*)p, 128); } DIRTY(pb->dirty, g->neg_bitid); DIRTY(pb->stipple, g->neg_bitid); }
void STATE_APIENTRY crStateFrontFace (PCRStateTracker pState, GLenum mode) { CRContext *g = GetCurrentContext(pState); CRPolygonState *p = &(g->polygon); CRStateBits *sb = GetCurrentBits(pState); CRPolygonBits *pb = &(sb->polygon); if (g->current.inBeginEnd) { crStateError(pState, __LINE__, __FILE__, GL_INVALID_OPERATION, "glFrontFace called in begin/end"); return; } FLUSH(); if (mode != GL_CW && mode != GL_CCW) { crStateError(pState, __LINE__, __FILE__, GL_INVALID_ENUM, "glFrontFace called with bogus mode: 0x%x", mode); return; } p->frontFace = mode; DIRTY(pb->mode, g->neg_bitid); DIRTY(pb->dirty, g->neg_bitid); }
void STATE_APIENTRY crStatePointSize(GLfloat size) { CRContext *g = GetCurrentContext(); CRPointState *p = &(g->point); CRStateBits *sb = GetCurrentBits(); CRPointBits *pb = &(sb->point); if (g->current.inBeginEnd) { crStateError(__LINE__, __FILE__, GL_INVALID_OPERATION, "glPointSize called in begin/end"); return; } FLUSH(); if (size <= 0.0f) { crStateError(__LINE__, __FILE__, GL_INVALID_VALUE, "glPointSize called with size <= 0.0: %f", size); return; } p->pointSize = size; DIRTY(pb->size, g->neg_bitid); DIRTY(pb->dirty, g->neg_bitid); }
void crStateFogInit (CRContext *ctx) { CRFogState *f = &ctx->fog; CRStateBits *sb = GetCurrentBits(ctx->pStateTracker); CRFogBits *fb = &(sb->fog); GLcolorf black = {0.0f, 0.0f, 0.0f, 0.0f}; f->color = black; RESET(fb->color, ctx->bitid); f->density = 1.0f; RESET(fb->density, ctx->bitid); f->end = 1.0f; RESET(fb->end, ctx->bitid); f->start = 0.0f; RESET(fb->start, ctx->bitid); f->mode = GL_EXP; RESET(fb->mode, ctx->bitid); f->index = 0; RESET(fb->index, ctx->bitid); f->enable = GL_FALSE; RESET(fb->enable, ctx->bitid); #ifdef CR_NV_fog_distance f->fogDistanceMode = GL_EYE_PLANE_ABSOLUTE_NV; RESET(fb->fogDistanceMode, ctx->bitid); #endif #ifdef CR_EXT_fog_coord f->fogCoordinateSource = GL_FRAGMENT_DEPTH_EXT; RESET(fb->fogCoordinateSource, ctx->bitid); #endif RESET(fb->dirty, ctx->bitid); }
void STATE_APIENTRY crStateBufferSubDataARB(GLenum target, GLintptrARB offset, GLsizeiptrARB size, const GLvoid * data) { CRContext *g = GetCurrentContext(); CRBufferObjectState *b = &g->bufferobject; CRBufferObject *obj; CRStateBits *sb = GetCurrentBits(); CRBufferObjectBits *bb = &sb->bufferobject; FLUSH(); if (g->current.inBeginEnd) { crStateError(__LINE__, __FILE__, GL_INVALID_OPERATION, "glBufferSubDataARB called in begin/end"); return; } obj = crStateGetBoundBufferObject(target, b); if (!obj) { crStateError(__LINE__, __FILE__, GL_INVALID_ENUM, "glBufferSubDataARB(target)"); return; } if (obj->id == 0) { crStateError(__LINE__, __FILE__, GL_INVALID_OPERATION, "glBufferSubDataARB"); return; } if (obj->pointer) { crStateError(__LINE__, __FILE__, GL_INVALID_OPERATION, "glBufferSubDataARB(buffer is mapped)"); return; } if (size < 0 || offset < 0 || (unsigned int)offset + size > obj->size) { crStateError(__LINE__, __FILE__, GL_INVALID_OPERATION, "glBufferSubDataARB(bad offset and/or size)"); return; } if (b->retainBufferData && obj->data) { crMemcpy((char *) obj->data + offset, data, size); } DIRTY(bb->dirty, g->neg_bitid); DIRTY(obj->dirty, g->neg_bitid); /* grow dirty region */ if (offset + size > obj->dirtyStart + obj->dirtyLength) obj->dirtyLength = offset + size; if (offset < obj->dirtyStart) obj->dirtyStart = offset; }
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); }
void STATE_APIENTRY crStateDisable (GLenum cap) { CRContext *g = GetCurrentContext(); CRStateBits *sb = GetCurrentBits(); if (g->current.inBeginEnd) { crStateError(__LINE__, __FILE__, GL_INVALID_OPERATION, "glDisable called in begin/end"); return; } FLUSH(); __enableSet(g, sb, g->neg_bitid, cap, GL_FALSE); }
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); }
GLboolean STATE_APIENTRY crStateUnmapBufferARB(GLenum target) { CRContext *g = GetCurrentContext(); CRBufferObjectState *b = &g->bufferobject; CRBufferObject *obj; CRStateBits *sb = GetCurrentBits(); CRBufferObjectBits *bb = &sb->bufferobject; FLUSH(); if (g->current.inBeginEnd) { crStateError(__LINE__, __FILE__, GL_INVALID_OPERATION, "glUnmapBufferARB called in begin/end"); return GL_FALSE; } obj = crStateGetBoundBufferObject(target, b); if (!obj) { crStateError(__LINE__, __FILE__, GL_INVALID_ENUM, "glUnmapBufferARB(target)"); return GL_FALSE; } if (obj->id == 0) { crStateError(__LINE__, __FILE__, GL_INVALID_OPERATION, "glUnmapBufferARB"); return GL_FALSE; } if (!obj->pointer) { crStateError(__LINE__, __FILE__, GL_INVALID_OPERATION, "glUnmapBufferARB"); return GL_FALSE; } obj->pointer = NULL; if (obj->access != GL_READ_ONLY_ARB) { /* the data was most likely modified */ DIRTY(bb->dirty, g->neg_bitid); DIRTY(obj->dirty, g->neg_bitid); obj->dirtyStart = 0; obj->dirtyLength = obj->size; } return GL_TRUE; }
void crStatePointInit (CRContext *ctx) { CRPointState *p = &ctx->point; CRStateBits *sb = GetCurrentBits(); CRPointBits *pb = &(sb->point); int i; p->pointSmooth = GL_FALSE; RESET(pb->enableSmooth, ctx->bitid); p->pointSize = 1.0f; RESET(pb->size, ctx->bitid); #ifdef CR_ARB_point_parameters p->minSize = 0.0f; RESET(pb->minSize, ctx->bitid); p->maxSize = CR_ALIASED_POINT_SIZE_MAX; RESET(pb->maxSize, ctx->bitid); p->fadeThresholdSize = 1.0f; RESET(pb->fadeThresholdSize, ctx->bitid); p->distanceAttenuation[0] = 1.0f; p->distanceAttenuation[1] = 0.0f; p->distanceAttenuation[2] = 0.0f; RESET(pb->distanceAttenuation, ctx->bitid); #endif #ifdef CR_ARB_point_sprite p->pointSprite = GL_FALSE; RESET(pb->enableSprite, ctx->bitid); for (i = 0; i < CR_MAX_TEXTURE_UNITS; i++) { p->coordReplacement[i] = GL_FALSE; RESET(pb->coordReplacement[i], ctx->bitid); } #endif p->spriteCoordOrigin = (GLfloat)GL_UPPER_LEFT; RESET(pb->spriteCoordOrigin, ctx->bitid); RESET(pb->dirty, ctx->bitid); /* *p->aliasedpointsizerange_min = c->aliasedpointsizerange_min; *p->aliasedpointsizerange_max = c->aliasedpointsizerange_max; *p->aliasedpointsizegranularity = c->aliasedpointsizegranularity; *p->smoothpointsizerange_min = c->smoothpointsizerange_min; *p->smoothpointsizerange_max = c->smoothpointsizerange_max; *p->smoothpointgranularity = c->smoothpointgranularity; */ }
void STATE_APIENTRY crStateClearIndex (GLfloat c) { CRContext *g = GetCurrentContext(); CRBufferState *b = &(g->buffer); CRStateBits *sp = GetCurrentBits(); CRBufferBits *bb = &(sp->buffer); if (g->current.inBeginEnd) { crStateError(__LINE__, __FILE__, GL_INVALID_OPERATION, "glClearIndex called in begin/end"); return; } b->indexClearValue = c; DIRTY(bb->dirty, g->neg_bitid); DIRTY(bb->clearIndex, g->neg_bitid); }
void STATE_APIENTRY crStateLogicOp (GLenum opcode) { CRContext *g = GetCurrentContext(); CRBufferState *b = &(g->buffer); CRStateBits *sb = GetCurrentBits(); CRBufferBits *bb = &(sb->buffer); if (g->current.inBeginEnd) { crStateError(__LINE__, __FILE__, GL_INVALID_OPERATION, "glLogicOp called in begin/end"); return; } FLUSH(); switch (opcode) { case GL_CLEAR: case GL_SET: case GL_COPY: case GL_COPY_INVERTED: case GL_NOOP: case GL_INVERT: case GL_AND: case GL_NAND: case GL_OR: case GL_NOR: case GL_XOR: case GL_EQUIV: case GL_AND_REVERSE: case GL_AND_INVERTED: case GL_OR_REVERSE: case GL_OR_INVERTED: break; default: crStateError(__LINE__, __FILE__, GL_INVALID_ENUM, "glLogicOp called with bogus opcode: %d", opcode); return; } b->logicOpMode = opcode; DIRTY(bb->dirty, g->neg_bitid); DIRTY(bb->logicOp, g->neg_bitid); DIRTY(bb->indexLogicOp, g->neg_bitid); }
void STATE_APIENTRY crStateDepthMask (GLboolean b) { CRContext *g = GetCurrentContext(); CRBufferState *bs = &(g->buffer); CRStateBits *sp = GetCurrentBits(); CRBufferBits *bb = &(sp->buffer); if (g->current.inBeginEnd) { crStateError(__LINE__, __FILE__, GL_INVALID_OPERATION, "DepthMask called in begin/end"); return; } FLUSH(); bs->depthMask = b; DIRTY(bb->dirty, g->neg_bitid); DIRTY(bb->depthMask, g->neg_bitid); }
void STATE_APIENTRY crStateIndexMask (GLuint mask) { CRContext *g = GetCurrentContext(); CRBufferState *b = &(g->buffer); CRStateBits *sp = GetCurrentBits(); CRBufferBits *bb = &(sp->buffer); if (g->current.inBeginEnd) { crStateError(__LINE__, __FILE__, GL_INVALID_OPERATION, "glReadBuffer called in begin/end"); return; } FLUSH(); b->indexWriteMask = mask; DIRTY(bb->dirty, g->neg_bitid); DIRTY(bb->indexMask, g->neg_bitid); }
void STATE_APIENTRY crStateCombinerParameterfvNV( GLenum pname, const GLfloat *params ) { CRContext *g = GetCurrentContext(); CRRegCombinerState *r = &(g->regcombiner); CRStateBits *sb = GetCurrentBits(); CRRegCombinerBits *rb = &(sb->regcombiner); switch( pname ) { case GL_CONSTANT_COLOR0_NV: r->constantColor0.r = params[0]; r->constantColor0.g = params[1]; r->constantColor0.b = params[2]; r->constantColor0.a = params[3]; DIRTY(rb->regCombinerColor0, g->neg_bitid); break; case GL_CONSTANT_COLOR1_NV: r->constantColor1.r = params[0]; r->constantColor1.g = params[1]; r->constantColor1.b = params[2]; r->constantColor1.a = params[3]; DIRTY(rb->regCombinerColor1, g->neg_bitid); break; case GL_NUM_GENERAL_COMBINERS_NV: if( *params < 1 || *params > g->limits.maxGeneralCombiners ) { crStateError(__LINE__, __FILE__, GL_INVALID_VALUE, "CombinerParameter passed invalid NUM_GENERAL_COMBINERS param: %d", (GLint)*params ); return; } r->numGeneralCombiners = (GLint)*params; DIRTY(rb->regCombinerVars, g->neg_bitid); break; case GL_COLOR_SUM_CLAMP_NV: r->colorSumClamp = (GLboolean)*params; DIRTY(rb->regCombinerVars, g->neg_bitid); break; default: crStateError( __LINE__, __FILE__, GL_INVALID_ENUM, "CombinerParameter passed bogus pname: 0x%x", pname ); return; } DIRTY(rb->dirty, g->neg_bitid); }
void STATE_APIENTRY crStateBlendColorEXT( GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha ) { CRContext *g = GetCurrentContext(); CRBufferState *b = &(g->buffer); CRStateBits *sb = GetCurrentBits(); CRBufferBits *bb = &(sb->buffer); if (g->current.inBeginEnd) { crStateError( __LINE__, __FILE__, GL_INVALID_OPERATION, "BlendColorEXT called inside a Begin/End" ); return; } b->blendColor.r = red; b->blendColor.g = green; b->blendColor.b = blue; b->blendColor.a = alpha; DIRTY(bb->blendColor, g->neg_bitid); DIRTY(bb->dirty, 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 crStatePolygonMode (PCRStateTracker pState, GLenum face, GLenum mode) { CRContext *g = GetCurrentContext(pState); CRPolygonState *p = &(g->polygon); CRStateBits *sb = GetCurrentBits(pState); CRPolygonBits *pb = &(sb->polygon); if (g->current.inBeginEnd) { crStateError(pState, __LINE__, __FILE__, GL_INVALID_OPERATION, "glPolygonMode called in begin/end"); return; } FLUSH(); if (mode != GL_POINT && mode != GL_LINE && mode != GL_FILL) { crStateError(pState, __LINE__, __FILE__, GL_INVALID_ENUM, "glPolygonMode called with bogus mode: 0x%x", mode); return; } switch (face) { case GL_FRONT: p->frontMode = mode; break; case GL_FRONT_AND_BACK: p->frontMode = mode; RT_FALL_THRU(); case GL_BACK: p->backMode = mode; break; default: crStateError(pState, __LINE__, __FILE__, GL_INVALID_ENUM, "glPolygonMode called with bogus face: 0x%x", face); return; } DIRTY(pb->mode, g->neg_bitid); DIRTY(pb->dirty, 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; } if (size != 3) { 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 crStatePolygonOffset (PCRStateTracker pState, GLfloat factor, GLfloat units) { CRContext *g = GetCurrentContext(pState); CRPolygonState *p = &(g->polygon); CRStateBits *sb = GetCurrentBits(pState); CRPolygonBits *pb = &(sb->polygon); if (g->current.inBeginEnd) { crStateError(pState, __LINE__, __FILE__, GL_INVALID_OPERATION, "glPolygonOffset called in begin/end"); return; } FLUSH(); p->offsetFactor = factor; p->offsetUnits = units; DIRTY(pb->offset, g->neg_bitid); DIRTY(pb->dirty, g->neg_bitid); }
void STATE_APIENTRY crStateClearDepth (GLclampd depth) { CRContext *g = GetCurrentContext(); CRBufferState *b = &(g->buffer); CRStateBits *sp = GetCurrentBits(); CRBufferBits *bb = &(sp->buffer); if (g->current.inBeginEnd) { crStateError(__LINE__, __FILE__, GL_INVALID_OPERATION, "glClearDepth called in begin/end"); return; } FLUSH(); if (depth < 0.0) depth = 0.0; if (depth > 1.0) depth = 1.0; b->depthClearValue = (GLdefault) depth; DIRTY(bb->dirty, g->neg_bitid); DIRTY(bb->clearDepth, g->neg_bitid); }
void STATE_APIENTRY crStateAlphaFunc (GLenum func, GLclampf ref) { CRContext *g = GetCurrentContext(); CRBufferState *b = &(g->buffer); CRStateBits *sb = GetCurrentBits(); CRBufferBits *bb = &(sb->buffer); if (g->current.inBeginEnd) { crStateError(__LINE__, __FILE__, GL_INVALID_OPERATION, "glAlphaFunc called in begin/end"); return; } FLUSH(); switch (func) { case GL_NEVER: case GL_LESS: case GL_EQUAL: case GL_LEQUAL: case GL_GREATER: case GL_GEQUAL: case GL_NOTEQUAL: case GL_ALWAYS: break; default: crStateError(__LINE__, __FILE__, GL_INVALID_ENUM, "glAlphaFunc: Invalid func: %d", func); return; } if (ref < 0.0f) ref = 0.0f; if (ref > 1.0f) ref = 1.0f; b->alphaTestFunc = func; b->alphaTestRef = ref; DIRTY(bb->dirty, g->neg_bitid); DIRTY(bb->alphaFunc, g->neg_bitid); }