/** * Called via glArrayElement() and glDrawArrays(). * Issue the glNormal, glVertex, glColor, glVertexAttrib, etc functions * for all enabled vertex arrays (for elt-th element). * Note: this may be called during display list construction. */ void GLAPIENTRY _ae_loopback_array_elt( GLint elt ) { GET_CURRENT_CONTEXT(ctx); const AEcontext *actx = AE_CONTEXT(ctx); const AEarray *aa; const AEattrib *at; if (actx->NewState) _ae_update_state( ctx ); /* generic attributes */ for (at = actx->attribs; at->func; at++) { const GLubyte *src = at->array->BufferObj->Data + (unsigned long) at->array->Ptr + elt * at->array->StrideB; at->func( at->index, src ); } /* conventional arrays */ for (aa = actx->arrays; aa->func ; aa++) { const GLubyte *src = aa->array->BufferObj->Data + (unsigned long) aa->array->Ptr + elt * aa->array->StrideB; aa->func( src ); } }
void _ae_destroy_context( GLcontext *ctx ) { if ( AE_CONTEXT( ctx ) ) { FREE( ctx->aelt_context ); ctx->aelt_context = 0; } }
GLboolean _ae_create_context(struct gl_context *ctx) { if (ctx->aelt_context) return GL_TRUE; /* These _gloffset_* values may not be compile-time constants */ SecondaryColorFuncs[0] = _gloffset_SecondaryColor3bv; SecondaryColorFuncs[1] = _gloffset_SecondaryColor3ubv; SecondaryColorFuncs[2] = _gloffset_SecondaryColor3sv; SecondaryColorFuncs[3] = _gloffset_SecondaryColor3usv; SecondaryColorFuncs[4] = _gloffset_SecondaryColor3iv; SecondaryColorFuncs[5] = _gloffset_SecondaryColor3uiv; SecondaryColorFuncs[6] = _gloffset_SecondaryColor3fvEXT; SecondaryColorFuncs[7] = _gloffset_SecondaryColor3dv; FogCoordFuncs[0] = -1; FogCoordFuncs[1] = -1; FogCoordFuncs[2] = -1; FogCoordFuncs[3] = -1; FogCoordFuncs[4] = -1; FogCoordFuncs[5] = -1; FogCoordFuncs[6] = _gloffset_FogCoordfvEXT; FogCoordFuncs[7] = _gloffset_FogCoorddv; ctx->aelt_context = calloc(1, sizeof(AEcontext)); if (!ctx->aelt_context) return GL_FALSE; AE_CONTEXT(ctx)->NewState = ~0; return GL_TRUE; }
void _ae_destroy_context( struct gl_context *ctx ) { if ( AE_CONTEXT( ctx ) ) { FREE( ctx->aelt_context ); ctx->aelt_context = NULL; } }
/** * Called via glArrayElement() and glDrawArrays(). * Issue the glNormal, glVertex, glColor, glVertexAttrib, etc functions * for all enabled vertex arrays (for elt-th element). * Note: this may be called during display list construction. */ void GLAPIENTRY _ae_loopback_array_elt( GLint elt ) { GET_CURRENT_CONTEXT(ctx); const AEcontext *actx = AE_CONTEXT(ctx); const AEarray *aa; const AEattrib *at; const struct _glapi_table * const disp = GET_DISPATCH(); if (actx->NewState) _ae_update_state( ctx ); /* generic attributes */ for (at = actx->attribs; at->func; at++) { const GLubyte *src = ADD_POINTERS(at->array->BufferObj->Data, at->array->Ptr) + elt * at->array->StrideB; at->func( at->index, src ); } /* conventional arrays */ for (aa = actx->arrays; aa->offset != -1 ; aa++) { const GLubyte *src = ADD_POINTERS(aa->array->BufferObj->Data, aa->array->Ptr) + elt * aa->array->StrideB; CALL_by_offset( disp, (array_func), aa->offset, ((const void *) src) ); } }
GLboolean _ae_create_context( GLcontext *ctx ) { if (ctx->aelt_context) return GL_TRUE; ctx->aelt_context = MALLOC( sizeof(AEcontext) ); if (!ctx->aelt_context) return GL_FALSE; AE_CONTEXT(ctx)->NewState = ~0; return GL_TRUE; }
/** * Unmap VBOs */ void _ae_unmap_vbos(struct gl_context *ctx) { AEcontext *actx = AE_CONTEXT(ctx); GLuint i; if (!actx->mapped_vbos) return; assert (!actx->NewState); for (i = 0; i < actx->nr_vbos; i++) ctx->Driver.UnmapBuffer(ctx, actx->vbo[i], MAP_INTERNAL); actx->mapped_vbos = GL_FALSE; }
void _ae_unmap_vbos( GLcontext *ctx ) { AEcontext *actx = AE_CONTEXT(ctx); GLuint i; if (!actx->mapped_vbos) return; assert (!actx->NewState); for (i = 0; i < actx->nr_vbos; i++) ctx->Driver.UnmapBuffer(ctx, GL_ARRAY_BUFFER_ARB, actx->vbo[i]); actx->mapped_vbos = GL_FALSE; }
/** * Called via glArrayElement() and glDrawArrays(). * Issue the glNormal, glVertex, glColor, glVertexAttrib, etc functions * for all enabled vertex arrays (for elt-th element). * Note: this may be called during display list construction. */ void GLAPIENTRY _ae_ArrayElement(GLint elt) { GET_CURRENT_CONTEXT(ctx); const AEcontext *actx = AE_CONTEXT(ctx); const AEarray *aa; const AEattrib *at; const struct _glapi_table * const disp = GET_DISPATCH(); GLboolean do_map; /* If PrimitiveRestart is enabled and the index is the RestartIndex * then we call PrimitiveRestartNV and return. */ if (ctx->Array.PrimitiveRestart && (elt == ctx->Array.RestartIndex)) { CALL_PrimitiveRestartNV((struct _glapi_table *)disp, ()); return; }
void _ae_map_vbos( GLcontext *ctx ) { AEcontext *actx = AE_CONTEXT(ctx); GLuint i; if (actx->mapped_vbos) return; if (actx->NewState) _ae_update_state(ctx); for (i = 0; i < actx->nr_vbos; i++) ctx->Driver.MapBuffer(ctx, GL_ARRAY_BUFFER_ARB, GL_DYNAMIC_DRAW_ARB, actx->vbo[i]); if (actx->nr_vbos) actx->mapped_vbos = GL_TRUE; }
void _ae_invalidate_state( GLcontext *ctx, GLuint new_state ) { AEcontext *actx = AE_CONTEXT(ctx); /* Only interested in this subset of mesa state. Need to prune * this down as both tnl/ and the drivers can raise statechanges * for arcane reasons in the middle of seemingly atomic operations * like DrawElements, over which we'd like to keep a known set of * arrays and vbo's mapped. * * Luckily, neither the drivers nor tnl muck with the state that * concerns us here: */ new_state &= _NEW_ARRAY | _NEW_PROGRAM; if (new_state) { assert(!actx->mapped_vbos); actx->NewState |= new_state; } }
/** * Before replaying glArrayElements calls we need to map (for reading) any * VBOs referenced by the enabled vertex arrays. */ void _ae_map_vbos(struct gl_context *ctx) { AEcontext *actx = AE_CONTEXT(ctx); GLuint i; if (actx->mapped_vbos) return; if (actx->NewState) _ae_update_state(ctx); for (i = 0; i < actx->nr_vbos; i++) ctx->Driver.MapBufferRange(ctx, 0, actx->vbo[i]->Size, GL_MAP_READ_BIT, actx->vbo[i]); if (actx->nr_vbos) actx->mapped_vbos = GL_TRUE; }
/** * Called via glArrayElement() and glDrawArrays(). * Issue the glNormal, glVertex, glColor, glVertexAttrib, etc functions * for all enabled vertex arrays (for elt-th element). * Note: this may be called during display list construction. */ void GLAPIENTRY _ae_ArrayElement( GLint elt ) { GET_CURRENT_CONTEXT(ctx); const AEcontext *actx = AE_CONTEXT(ctx); const AEarray *aa; const AEattrib *at; const struct _glapi_table * const disp = GET_DISPATCH(); GLboolean do_map; if (actx->NewState) { assert(!actx->mapped_vbos); _ae_update_state( ctx ); } /* Determine if w need to map/unmap VBOs */ do_map = actx->nr_vbos && !actx->mapped_vbos; if (do_map) _ae_map_vbos(ctx); /* emit generic attribute elements */ for (at = actx->attribs; at->func; at++) { const GLubyte *src = ADD_POINTERS(at->array->BufferObj->Pointer, at->array->Ptr) + elt * at->array->StrideB; at->func( at->index, src ); } /* emit conventional arrays elements */ for (aa = actx->arrays; aa->offset != -1 ; aa++) { const GLubyte *src = ADD_POINTERS(aa->array->BufferObj->Pointer, aa->array->Ptr) + elt * aa->array->StrideB; CALL_by_offset( disp, (array_func), aa->offset, ((const void *) src) ); } if (do_map) _ae_unmap_vbos(ctx); }
void _ae_invalidate_state( GLcontext *ctx, GLuint new_state ) { AE_CONTEXT(ctx)->NewState |= new_state; }
/** * Make a list of per-vertex functions to call for each glArrayElement call. * These functions access the array data (i.e. glVertex, glColor, glNormal, * etc). * Note: this may be called during display list construction. */ static void _ae_update_state(struct gl_context *ctx) { AEcontext *actx = AE_CONTEXT(ctx); AEarray *aa = actx->arrays; /* non-indexed arrays (ex: glNormal) */ AEattrib *at = actx->attribs; /* indexed arrays (ex: glMultiTexCoord) */ GLuint i; struct gl_vertex_array_object *vao = ctx->Array.VAO; actx->nr_vbos = 0; /* conventional vertex arrays */ if (vao->VertexAttrib[VERT_ATTRIB_COLOR_INDEX].Enabled) { aa->array = &vao->VertexAttrib[VERT_ATTRIB_COLOR_INDEX]; aa->binding = &vao->VertexBinding[aa->array->VertexBinding]; aa->offset = IndexFuncs[TYPE_IDX(aa->array->Type)]; check_vbo(actx, aa->binding->BufferObj); aa++; } if (vao->VertexAttrib[VERT_ATTRIB_EDGEFLAG].Enabled) { aa->array = &vao->VertexAttrib[VERT_ATTRIB_EDGEFLAG]; aa->binding = &vao->VertexBinding[aa->array->VertexBinding]; aa->offset = _gloffset_EdgeFlagv; check_vbo(actx, aa->binding->BufferObj); aa++; } if (vao->VertexAttrib[VERT_ATTRIB_NORMAL].Enabled) { aa->array = &vao->VertexAttrib[VERT_ATTRIB_NORMAL]; aa->binding = &vao->VertexBinding[aa->array->VertexBinding]; aa->offset = NormalFuncs[TYPE_IDX(aa->array->Type)]; check_vbo(actx, aa->binding->BufferObj); aa++; } if (vao->VertexAttrib[VERT_ATTRIB_COLOR0].Enabled) { aa->array = &vao->VertexAttrib[VERT_ATTRIB_COLOR0]; aa->binding = &vao->VertexBinding[aa->array->VertexBinding]; aa->offset = ColorFuncs[aa->array->Size-3][TYPE_IDX(aa->array->Type)]; check_vbo(actx, aa->binding->BufferObj); aa++; } if (vao->VertexAttrib[VERT_ATTRIB_COLOR1].Enabled) { aa->array = &vao->VertexAttrib[VERT_ATTRIB_COLOR1]; aa->binding = &vao->VertexBinding[aa->array->VertexBinding]; aa->offset = SecondaryColorFuncs[TYPE_IDX(aa->array->Type)]; check_vbo(actx, aa->binding->BufferObj); aa++; } if (vao->VertexAttrib[VERT_ATTRIB_FOG].Enabled) { aa->array = &vao->VertexAttrib[VERT_ATTRIB_FOG]; aa->binding = &vao->VertexBinding[aa->array->VertexBinding]; aa->offset = FogCoordFuncs[TYPE_IDX(aa->array->Type)]; check_vbo(actx, aa->binding->BufferObj); aa++; } for (i = 0; i < ctx->Const.MaxTextureCoordUnits; i++) { struct gl_vertex_attrib_array *attribArray = &vao->VertexAttrib[VERT_ATTRIB_TEX(i)]; if (attribArray->Enabled) { /* NOTE: we use generic glVertexAttribNV functions here. * If we ever remove GL_NV_vertex_program this will have to change. */ at->array = attribArray; at->binding = &vao->VertexBinding[attribArray->VertexBinding]; ASSERT(!at->array->Normalized); at->func = AttribFuncsNV[at->array->Normalized] [at->array->Size-1] [TYPE_IDX(at->array->Type)]; at->index = VERT_ATTRIB_TEX0 + i; check_vbo(actx, at->binding->BufferObj); at++; } } /* generic vertex attribute arrays */ for (i = 1; i < VERT_ATTRIB_GENERIC_MAX; i++) { /* skip zero! */ struct gl_vertex_attrib_array *attribArray = &vao->VertexAttrib[VERT_ATTRIB_GENERIC(i)]; if (attribArray->Enabled) { GLint intOrNorm; at->array = attribArray; at->binding = &vao->VertexBinding[attribArray->VertexBinding]; /* Note: we can't grab the _glapi_Dispatch->VertexAttrib1fvNV * function pointer here (for float arrays) since the pointer may * change from one execution of _ae_ArrayElement() to * the next. Doing so caused UT to break. */ if (at->array->Integer) intOrNorm = 2; else if (at->array->Normalized) intOrNorm = 1; else intOrNorm = 0; at->func = AttribFuncsARB[intOrNorm] [at->array->Size-1] [TYPE_IDX(at->array->Type)]; at->index = i; check_vbo(actx, at->binding->BufferObj); at++; } } /* finally, vertex position */ if (vao->VertexAttrib[VERT_ATTRIB_GENERIC0].Enabled) { /* Use glVertex(v) instead of glVertexAttrib(0, v) to be sure it's * issued as the last (provoking) attribute). */ aa->array = &vao->VertexAttrib[VERT_ATTRIB_GENERIC0]; aa->binding = &vao->VertexBinding[aa->array->VertexBinding]; assert(aa->array->Size >= 2); /* XXX fix someday? */ aa->offset = VertexFuncs[aa->array->Size-2][TYPE_IDX(aa->array->Type)]; check_vbo(actx, aa->binding->BufferObj); aa++; } else if (vao->VertexAttrib[VERT_ATTRIB_POS].Enabled) { aa->array = &vao->VertexAttrib[VERT_ATTRIB_POS]; aa->binding = &vao->VertexBinding[aa->array->VertexBinding]; aa->offset = VertexFuncs[aa->array->Size-2][TYPE_IDX(aa->array->Type)]; check_vbo(actx, aa->binding->BufferObj); aa++; } check_vbo(actx, vao->IndexBufferObj); ASSERT(at - actx->attribs <= VERT_ATTRIB_MAX); ASSERT(aa - actx->arrays < 32); at->func = NULL; /* terminate the list */ aa->offset = -1; /* terminate the list */ actx->NewState = 0; }
/** * Make a list of per-vertex functions to call for each glArrayElement call. * These functions access the array data (i.e. glVertex, glColor, glNormal, * etc). * Note: this may be called during display list construction. */ static void _ae_update_state( GLcontext *ctx ) { AEcontext *actx = AE_CONTEXT(ctx); AEarray *aa = actx->arrays; AEattrib *at = actx->attribs; GLuint i; actx->nr_vbos = 0; /* conventional vertex arrays */ if (ctx->Array.ArrayObj->Index.Enabled) { aa->array = &ctx->Array.ArrayObj->Index; aa->offset = IndexFuncs[TYPE_IDX(aa->array->Type)]; check_vbo(actx, aa->array->BufferObj); aa++; } if (ctx->Array.ArrayObj->EdgeFlag.Enabled) { aa->array = &ctx->Array.ArrayObj->EdgeFlag; aa->offset = _gloffset_EdgeFlagv; check_vbo(actx, aa->array->BufferObj); aa++; } if (ctx->Array.ArrayObj->Normal.Enabled) { aa->array = &ctx->Array.ArrayObj->Normal; aa->offset = NormalFuncs[TYPE_IDX(aa->array->Type)]; check_vbo(actx, aa->array->BufferObj); aa++; } if (ctx->Array.ArrayObj->Color.Enabled) { aa->array = &ctx->Array.ArrayObj->Color; aa->offset = ColorFuncs[aa->array->Size-3][TYPE_IDX(aa->array->Type)]; check_vbo(actx, aa->array->BufferObj); aa++; } if (ctx->Array.ArrayObj->SecondaryColor.Enabled) { aa->array = &ctx->Array.ArrayObj->SecondaryColor; aa->offset = SecondaryColorFuncs[TYPE_IDX(aa->array->Type)]; check_vbo(actx, aa->array->BufferObj); aa++; } if (ctx->Array.ArrayObj->FogCoord.Enabled) { aa->array = &ctx->Array.ArrayObj->FogCoord; aa->offset = FogCoordFuncs[TYPE_IDX(aa->array->Type)]; check_vbo(actx, aa->array->BufferObj); aa++; } for (i = 0; i < ctx->Const.MaxTextureCoordUnits; i++) { struct gl_client_array *attribArray = &ctx->Array.ArrayObj->TexCoord[i]; if (attribArray->Enabled) { /* NOTE: we use generic glVertexAttribNV functions here. * If we ever remove GL_NV_vertex_program this will have to change. */ at->array = attribArray; ASSERT(!at->array->Normalized); at->func = AttribFuncsNV[at->array->Normalized] [at->array->Size-1] [TYPE_IDX(at->array->Type)]; at->index = VERT_ATTRIB_TEX0 + i; check_vbo(actx, at->array->BufferObj); at++; } } /* generic vertex attribute arrays */ for (i = 1; i < VERT_ATTRIB_MAX; i++) { /* skip zero! */ struct gl_client_array *attribArray = &ctx->Array.ArrayObj->VertexAttrib[i]; if (attribArray->Enabled) { at->array = attribArray; /* Note: we can't grab the _glapi_Dispatch->VertexAttrib1fvNV * function pointer here (for float arrays) since the pointer may * change from one execution of _ae_loopback_array_elt() to * the next. Doing so caused UT to break. */ if (ctx->VertexProgram._Enabled && ctx->VertexProgram.Current->IsNVProgram) { at->func = AttribFuncsNV[at->array->Normalized] [at->array->Size-1] [TYPE_IDX(at->array->Type)]; } else { at->func = AttribFuncsARB[at->array->Normalized] [at->array->Size-1] [TYPE_IDX(at->array->Type)]; } at->index = i; check_vbo(actx, at->array->BufferObj); at++; } } /* finally, vertex position */ if (ctx->Array.ArrayObj->VertexAttrib[0].Enabled) { /* Use glVertex(v) instead of glVertexAttrib(0, v) to be sure it's * issued as the last (provoking) attribute). */ aa->array = &ctx->Array.ArrayObj->VertexAttrib[0]; assert(aa->array->Size >= 2); /* XXX fix someday? */ aa->offset = VertexFuncs[aa->array->Size-2][TYPE_IDX(aa->array->Type)]; check_vbo(actx, aa->array->BufferObj); aa++; } else if (ctx->Array.ArrayObj->Vertex.Enabled) { aa->array = &ctx->Array.ArrayObj->Vertex; aa->offset = VertexFuncs[aa->array->Size-2][TYPE_IDX(aa->array->Type)]; check_vbo(actx, aa->array->BufferObj); aa++; } check_vbo(actx, ctx->Array.ElementArrayBufferObj); ASSERT(at - actx->attribs <= VERT_ATTRIB_MAX); ASSERT(aa - actx->arrays < 32); at->func = NULL; /* terminate the list */ aa->offset = -1; /* terminate the list */ actx->NewState = 0; }
/** * Make a list of per-vertex functions to call for each glArrayElement call. * These functions access the array data (i.e. glVertex, glColor, glNormal, * etc). * Note: this may be called during display list construction. */ static void _ae_update_state( GLcontext *ctx ) { AEcontext *actx = AE_CONTEXT(ctx); AEarray *aa = actx->arrays; AEattrib *at = actx->attribs; GLuint i; /* conventional vertex arrays */ if (ctx->Array.Index.Enabled) { aa->array = &ctx->Array.Index; aa->func = IndexFuncs[TYPE_IDX(aa->array->Type)]; aa++; } if (ctx->Array.EdgeFlag.Enabled) { aa->array = &ctx->Array.EdgeFlag; aa->func = (array_func) EdgeFlagv; aa++; } if (ctx->Array.Normal.Enabled) { aa->array = &ctx->Array.Normal; aa->func = NormalFuncs[TYPE_IDX(aa->array->Type)]; aa++; } if (ctx->Array.Color.Enabled) { aa->array = &ctx->Array.Color; aa->func = ColorFuncs[aa->array->Size-3][TYPE_IDX(aa->array->Type)]; aa++; } if (ctx->Array.SecondaryColor.Enabled) { aa->array = &ctx->Array.SecondaryColor; aa->func = SecondaryColorFuncs[TYPE_IDX(aa->array->Type)]; aa++; } if (ctx->Array.FogCoord.Enabled) { aa->array = &ctx->Array.FogCoord; aa->func = FogCoordFuncs[TYPE_IDX(aa->array->Type)]; aa++; } for (i = 0; i < ctx->Const.MaxTextureCoordUnits; i++) { if (ctx->Array.TexCoord[i].Enabled) { /* NOTE: we use generic glVertexAttrib functions here. * If we ever de-alias conventional/generic vertex attribs this * will have to change. */ struct gl_client_array *attribArray = &ctx->Array.TexCoord[i]; at->array = attribArray; at->func = AttribFuncsNV[at->array->Normalized][at->array->Size-1][TYPE_IDX(at->array->Type)]; at->index = VERT_ATTRIB_TEX0 + i; at++; } } /* generic vertex attribute arrays */ for (i = 1; i < VERT_ATTRIB_MAX; i++) { /* skip zero! */ if (ctx->Array.VertexAttrib[i].Enabled) { struct gl_client_array *attribArray = &ctx->Array.VertexAttrib[i]; at->array = attribArray; /* Note: we can't grab the _glapi_Dispatch->VertexAttrib1fvNV * function pointer here (for float arrays) since the pointer may * change from one execution of _ae_loopback_array_elt() to * the next. Doing so caused UT to break. */ at->func = AttribFuncsNV[at->array->Normalized][at->array->Size-1][TYPE_IDX(at->array->Type)]; at->index = i; at++; } } /* finally, vertex position */ if (ctx->Array.VertexAttrib[0].Enabled) { /* Use glVertex(v) instead of glVertexAttrib(0, v) to be sure it's * issued as the last (proviking) attribute). */ aa->array = &ctx->Array.VertexAttrib[0]; assert(aa->array->Size >= 2); /* XXX fix someday? */ aa->func = VertexFuncs[aa->array->Size-2][TYPE_IDX(aa->array->Type)]; aa++; } else if (ctx->Array.Vertex.Enabled) { aa->array = &ctx->Array.Vertex; aa->func = VertexFuncs[aa->array->Size-2][TYPE_IDX(aa->array->Type)]; aa++; } ASSERT(at - actx->attribs <= VERT_ATTRIB_MAX); ASSERT(aa - actx->arrays < 32); at->func = NULL; /* terminate the list */ aa->func = NULL; /* terminate the list */ actx->NewState = 0; }
/** * Make a list of per-vertex functions to call for each glArrayElement call. * These functions access the array data (i.e. glVertex, glColor, glNormal, etc); */ static void _ae_update_state( GLcontext *ctx ) { AEcontext *actx = AE_CONTEXT(ctx); AEarray *aa = actx->arrays; AEattrib *at = actx->attribs; GLuint i; /* yuck, no generic array to correspond to color index or edge flag */ if (ctx->Array.Index.Enabled) { aa->array = &ctx->Array.Index; aa->func = indexfuncs[TYPE_IDX(aa->array->Type)]; aa++; } if (ctx->Array.EdgeFlag.Enabled) { aa->array = &ctx->Array.EdgeFlag; aa->func = (array_func) glEdgeFlagv; aa++; } /* all other arrays handled here */ for (i = 0; i < VERT_ATTRIB_MAX; i++) { /* Note: we count down to zero so glVertex (attrib 0) is last!!! */ const GLuint index = VERT_ATTRIB_MAX - i - 1; struct gl_client_array *attribArray = NULL; /* Generic arrays take priority over conventional arrays if vertex program * mode is enabled. */ if (ctx->VertexProgram.Enabled && ctx->Array.VertexAttrib[index].Enabled) { if (index == 0) { /* Special case: use glVertex() for vertex position so * that it's always executed last. */ aa->array = &ctx->Array.VertexAttrib[0]; aa->func = vertexfuncs[aa->array->Size-2][TYPE_IDX(aa->array->Type)]; aa++; } else { attribArray = &ctx->Array.VertexAttrib[index]; } } else { switch (index) { case VERT_ATTRIB_POS: if (ctx->Array.Vertex.Enabled) { aa->array = &ctx->Array.Vertex; aa->func = vertexfuncs[aa->array->Size-2][TYPE_IDX(aa->array->Type)]; aa++; } break; case VERT_ATTRIB_NORMAL: if (ctx->Array.Normal.Enabled) { aa->array = &ctx->Array.Normal; aa->func = normalfuncs[TYPE_IDX(aa->array->Type)]; aa++; } break; case VERT_ATTRIB_COLOR0: if (ctx->Array.Color.Enabled) { aa->array = &ctx->Array.Color; aa->func = colorfuncs[aa->array->Size-3][TYPE_IDX(aa->array->Type)]; aa++; } break; case VERT_ATTRIB_COLOR1: if (ctx->Array.SecondaryColor.Enabled) { aa->array = &ctx->Array.SecondaryColor; aa->func = secondarycolorfuncs[TYPE_IDX(aa->array->Type)]; aa++; } break; case VERT_ATTRIB_FOG: if (ctx->Array.FogCoord.Enabled) { aa->array = &ctx->Array.FogCoord; aa->func = fogcoordfuncs[TYPE_IDX(aa->array->Type)]; aa++; } break; case VERT_ATTRIB_TEX0: case VERT_ATTRIB_TEX1: case VERT_ATTRIB_TEX2: case VERT_ATTRIB_TEX3: case VERT_ATTRIB_TEX4: case VERT_ATTRIB_TEX5: case VERT_ATTRIB_TEX6: case VERT_ATTRIB_TEX7: /* use generic vertex attribs for texcoords */ if (ctx->Array.TexCoord[index - VERT_ATTRIB_TEX0].Enabled) { attribArray = &ctx->Array.TexCoord[index - VERT_ATTRIB_TEX0]; } default: /* nothing */; } } /* Save glVertexAttrib call (may be for glMultiTexCoord) */ if (attribArray) { at->array = attribArray; /* Note: we can't grab the _glapi_Dispatch->VertexAttrib1fvNV * function pointer here (for float arrays) since the pointer may * change from one execution of _ae_loopback_array_elt() to * the next. Doing so caused UT to break. */ at->func = attribfuncs[at->array->Normalized][at->array->Size-1][TYPE_IDX(at->array->Type)]; at->index = index; at++; } } ASSERT(at - actx->attribs <= VERT_ATTRIB_MAX); ASSERT(aa - actx->arrays < 32); at->func = NULL; /* terminate the list */ aa->func = NULL; /* terminate the list */ actx->NewState = 0; }