X-Git-Url: https://git.libre-soc.org/?p=mesa.git;a=blobdiff_plain;f=src%2Fmesa%2Fmain%2Fapi_arrayelt.c;h=5df7b05fbd8883f76e5bdfd5ffa74e5ba439a9e8;hp=c9d4d038f007dd1ac5f512ce4a3ec31b184905d8;hb=0ca266025ab309d538ed8c804cb46d2945c6a547;hpb=ff353c218a1ab1fd3fb797a4780612ec4b0451d8 diff --git a/src/mesa/main/api_arrayelt.c b/src/mesa/main/api_arrayelt.c index c9d4d038f00..5df7b05fbd8 100644 --- a/src/mesa/main/api_arrayelt.c +++ b/src/mesa/main/api_arrayelt.c @@ -31,7 +31,7 @@ /* Author: - * Keith Whitwell + * Keith Whitwell */ #include "glheader.h" @@ -39,142 +39,44 @@ #include "api_arrayelt.h" #include "bufferobj.h" #include "context.h" -#include "imports.h" + #include "macros.h" #include "mtypes.h" #include "main/dispatch.h" - -typedef void (GLAPIENTRY *array_func)( const void * ); - -typedef struct { - const struct gl_client_array *array; - int offset; -} AEarray; +#include "varray.h" typedef void (GLAPIENTRY *attrib_func)( GLuint indx, const void *data ); -typedef struct { - const struct gl_client_array *array; - attrib_func func; - GLuint index; -} AEattrib; - -typedef struct { - AEarray arrays[32]; - AEattrib attribs[VERT_ATTRIB_MAX + 1]; - GLuint NewState; - - /* List of VBOs we need to map before executing ArrayElements */ - struct gl_buffer_object *vbo[VERT_ATTRIB_MAX]; - GLuint nr_vbos; - GLboolean mapped_vbos; /**< Any currently mapped VBOs? */ -} AEcontext; - - -/** Cast wrapper */ -static INLINE AEcontext * -AE_CONTEXT(struct gl_context *ctx) -{ - return (AEcontext *) ctx->aelt_context; -} - - /* * Convert GL_BYTE, GL_UNSIGNED_BYTE, .. GL_DOUBLE into an integer * in the range [0, 7]. Luckily these type tokens are sequentially * numbered in gl.h, except for GL_DOUBLE. */ -static INLINE int +static inline int TYPE_IDX(GLenum t) { return t == GL_DOUBLE ? 7 : t & 7; } -#define NUM_TYPES 8 - - -static const int ColorFuncs[2][NUM_TYPES] = { - { - _gloffset_Color3bv, - _gloffset_Color3ubv, - _gloffset_Color3sv, - _gloffset_Color3usv, - _gloffset_Color3iv, - _gloffset_Color3uiv, - _gloffset_Color3fv, - _gloffset_Color3dv, - }, - { - _gloffset_Color4bv, - _gloffset_Color4ubv, - _gloffset_Color4sv, - _gloffset_Color4usv, - _gloffset_Color4iv, - _gloffset_Color4uiv, - _gloffset_Color4fv, - _gloffset_Color4dv, - }, -}; - -static const int VertexFuncs[3][NUM_TYPES] = { - { - -1, - -1, - _gloffset_Vertex2sv, - -1, - _gloffset_Vertex2iv, - -1, - _gloffset_Vertex2fv, - _gloffset_Vertex2dv, - }, - { - -1, - -1, - _gloffset_Vertex3sv, - -1, - _gloffset_Vertex3iv, - -1, - _gloffset_Vertex3fv, - _gloffset_Vertex3dv, - }, - { - -1, - -1, - _gloffset_Vertex4sv, - -1, - _gloffset_Vertex4iv, - -1, - _gloffset_Vertex4fv, - _gloffset_Vertex4dv, - }, -}; - -static const int IndexFuncs[NUM_TYPES] = { - -1, - _gloffset_Indexubv, - _gloffset_Indexsv, - -1, - _gloffset_Indexiv, - -1, - _gloffset_Indexfv, - _gloffset_Indexdv, -}; +/* + * Convert normalized/integer/double to the range [0, 3]. + */ +static inline int +vertex_format_to_index(const struct gl_vertex_format *vformat) +{ + if (vformat->Doubles) + return 3; + else if (vformat->Integer) + return 2; + else if (vformat->Normalized) + return 1; + else + return 0; +} -static const int NormalFuncs[NUM_TYPES] = { - _gloffset_Normal3bv, - -1, - _gloffset_Normal3sv, - -1, - _gloffset_Normal3iv, - -1, - _gloffset_Normal3fv, - _gloffset_Normal3dv, -}; -/* Note: _gloffset_* for these may not be a compile-time constant. */ -static int SecondaryColorFuncs[NUM_TYPES]; -static int FogCoordFuncs[NUM_TYPES]; +#define NUM_TYPES 8 /** @@ -584,7 +486,7 @@ VertexAttrib4dvNV(GLuint index, const GLdouble *v) /* * Array [size][type] of VertexAttrib functions */ -static attrib_func AttribFuncsNV[2][4][NUM_TYPES] = { +static const attrib_func AttribFuncsNV[2][4][NUM_TYPES] = { { /* non-normalized */ { @@ -1255,12 +1157,37 @@ VertexAttribI4uiv(GLuint index, const GLuint *v) CALL_VertexAttribI4uivEXT(GET_DISPATCH(), (index, v)); } +/* GL_DOUBLE unconverted attributes */ + +static void GLAPIENTRY +VertexAttribL1dv(GLuint index, const GLdouble *v) +{ + CALL_VertexAttribL1dv(GET_DISPATCH(), (index, v)); +} + +static void GLAPIENTRY +VertexAttribL2dv(GLuint index, const GLdouble *v) +{ + CALL_VertexAttribL2dv(GET_DISPATCH(), (index, v)); +} + +static void GLAPIENTRY +VertexAttribL3dv(GLuint index, const GLdouble *v) +{ + CALL_VertexAttribL3dv(GET_DISPATCH(), (index, v)); +} + +static void GLAPIENTRY +VertexAttribL4dv(GLuint index, const GLdouble *v) +{ + CALL_VertexAttribL4dv(GET_DISPATCH(), (index, v)); +} /* * Array [unnormalized/normalized/integer][size][type] of VertexAttrib * functions */ -static attrib_func AttribFuncsARB[3][4][NUM_TYPES] = { +static const attrib_func AttribFuncsARB[4][4][NUM_TYPES] = { { /* non-normalized */ { @@ -1402,262 +1329,137 @@ static attrib_func AttribFuncsARB[3][4][NUM_TYPES] = { NULL, /* GL_FLOAT */ NULL /* GL_DOUBLE */ } + }, + { + /* double-valued */ + { + /* size 1 */ + NULL, + NULL, + NULL, + NULL, + NULL, + NULL, + NULL, + (attrib_func) VertexAttribL1dv, + }, + { + /* size 2 */ + NULL, + NULL, + NULL, + NULL, + NULL, + NULL, + NULL, + (attrib_func) VertexAttribL2dv, + }, + { + /* size 3 */ + NULL, + NULL, + NULL, + NULL, + NULL, + NULL, + NULL, + (attrib_func) VertexAttribL3dv, + }, + { + /* size 4 */ + NULL, + NULL, + NULL, + NULL, + NULL, + NULL, + NULL, + (attrib_func) VertexAttribL4dv, + } } -}; - - -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; - } -} +}; -/** - * Check if the given vertex buffer object exists and is not mapped. - * If so, add it to the list of buffers we must map before executing - * an glArrayElement call. +/* + * Return VertexAttrib*NV function pointer matching the provided vertex format. */ -static void -check_vbo(AEcontext *actx, struct gl_buffer_object *vbo) -{ - if (_mesa_is_bufferobj(vbo) && !_mesa_bufferobj_mapped(vbo)) { - GLuint i; - for (i = 0; i < actx->nr_vbos; i++) - if (actx->vbo[i] == vbo) - return; /* already in the list, we're done */ - assert(actx->nr_vbos < VERT_ATTRIB_MAX); - actx->vbo[actx->nr_vbos++] = vbo; - } -} - - -static inline void -update_derived_client_arrays(struct gl_context *ctx) +static inline attrib_func +func_nv(const struct gl_vertex_format *vformat) { - struct gl_array_object *arrayObj = ctx->Array.ArrayObj; - - if (arrayObj->NewArrays) { - _mesa_update_array_object_client_arrays(ctx, arrayObj); - arrayObj->NewArrays = 0; - } + return AttribFuncsNV[vformat->Normalized][vformat->Size-1] + [TYPE_IDX(vformat->Type)]; } -/** - * 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. +/* + * Return VertexAttrib*ARB function pointer matching the provided vertex format. */ -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_array_object *arrayObj = ctx->Array.ArrayObj; - - actx->nr_vbos = 0; - - /* conventional vertex arrays */ - if (arrayObj->_VertexAttrib[VERT_ATTRIB_COLOR_INDEX].Enabled) { - aa->array = &arrayObj->_VertexAttrib[VERT_ATTRIB_COLOR_INDEX]; - aa->offset = IndexFuncs[TYPE_IDX(aa->array->Type)]; - check_vbo(actx, aa->array->BufferObj); - aa++; - } - if (arrayObj->_VertexAttrib[VERT_ATTRIB_EDGEFLAG].Enabled) { - aa->array = &arrayObj->_VertexAttrib[VERT_ATTRIB_EDGEFLAG]; - aa->offset = _gloffset_EdgeFlagv; - check_vbo(actx, aa->array->BufferObj); - aa++; - } - if (arrayObj->_VertexAttrib[VERT_ATTRIB_NORMAL].Enabled) { - aa->array = &arrayObj->_VertexAttrib[VERT_ATTRIB_NORMAL]; - aa->offset = NormalFuncs[TYPE_IDX(aa->array->Type)]; - check_vbo(actx, aa->array->BufferObj); - aa++; - } - if (arrayObj->_VertexAttrib[VERT_ATTRIB_COLOR0].Enabled) { - aa->array = &arrayObj->_VertexAttrib[VERT_ATTRIB_COLOR0]; - aa->offset = ColorFuncs[aa->array->Size-3][TYPE_IDX(aa->array->Type)]; - check_vbo(actx, aa->array->BufferObj); - aa++; - } - if (arrayObj->_VertexAttrib[VERT_ATTRIB_COLOR1].Enabled) { - aa->array = &arrayObj->_VertexAttrib[VERT_ATTRIB_COLOR1]; - aa->offset = SecondaryColorFuncs[TYPE_IDX(aa->array->Type)]; - check_vbo(actx, aa->array->BufferObj); - aa++; - } - if (arrayObj->_VertexAttrib[VERT_ATTRIB_FOG].Enabled) { - aa->array = &arrayObj->_VertexAttrib[VERT_ATTRIB_FOG]; - 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 = - &arrayObj->_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; - 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_GENERIC_MAX; i++) { /* skip zero! */ - struct gl_client_array *attribArray = - &arrayObj->_VertexAttrib[VERT_ATTRIB_GENERIC(i)]; - if (attribArray->Enabled) { - GLint intOrNorm; - 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_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->array->BufferObj); - at++; - } - } - - /* finally, vertex position */ - if (arrayObj->_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 = &arrayObj->_VertexAttrib[VERT_ATTRIB_GENERIC0]; - 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 (arrayObj->_VertexAttrib[VERT_ATTRIB_POS].Enabled) { - aa->array = &arrayObj->_VertexAttrib[VERT_ATTRIB_POS]; - aa->offset = VertexFuncs[aa->array->Size-2][TYPE_IDX(aa->array->Type)]; - check_vbo(actx, aa->array->BufferObj); - aa++; - } - - check_vbo(actx, arrayObj->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; +static inline attrib_func +func_arb(const struct gl_vertex_format *vformat) +{ + return AttribFuncsARB[vertex_format_to_index(vformat)][vformat->Size-1] + [TYPE_IDX(vformat->Type)]; } -/** - * Before replaying glArrayElements calls we need to map (for reading) any - * VBOs referenced by the enabled vertex arrays. +/* + * Return the address of the array attribute array at elt in the + * vertex array object vao. */ -void -_ae_map_vbos(struct gl_context *ctx) +static inline const void * +attrib_src(const struct gl_vertex_array_object *vao, + const struct gl_array_attributes *array, GLint elt) { - AEcontext *actx = AE_CONTEXT(ctx); - GLuint i; - - if (actx->mapped_vbos) - return; - - update_derived_client_arrays(ctx); + const struct gl_vertex_buffer_binding *binding = + &vao->BufferBinding[array->BufferBindingIndex]; + const GLubyte *src = _mesa_vertex_attrib_address(array, binding); - 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 (binding->BufferObj) { + src = ADD_POINTERS(binding->BufferObj->Mappings[MAP_INTERNAL].Pointer, + src); + } - if (actx->nr_vbos) - actx->mapped_vbos = GL_TRUE; + return src + elt * binding->Stride; } -/** - * Unmap VBOs - */ void -_ae_unmap_vbos(struct gl_context *ctx) +_mesa_array_element(struct gl_context *ctx, GLint elt) { - AEcontext *actx = AE_CONTEXT(ctx); - GLuint i; + const struct gl_vertex_array_object *vao = ctx->Array.VAO; + GLbitfield mask; - if (!actx->mapped_vbos) - return; - - assert (!actx->NewState); + /* emit conventional arrays elements */ + mask = (VERT_BIT_FF_ALL & ~VERT_BIT_POS) & vao->Enabled; + while (mask) { + const gl_vert_attrib attrib = u_bit_scan(&mask); + const struct gl_array_attributes *array = &vao->VertexAttrib[attrib]; + const void *src = attrib_src(vao, array, elt); + func_nv(&array->Format)(attrib, src); + } - for (i = 0; i < actx->nr_vbos; i++) - ctx->Driver.UnmapBuffer(ctx, actx->vbo[i]); + /* emit generic attribute elements */ + mask = (VERT_BIT_GENERIC_ALL & ~VERT_BIT_GENERIC0) & vao->Enabled; + while (mask) { + const gl_vert_attrib attrib = u_bit_scan(&mask); + const struct gl_array_attributes *array = &vao->VertexAttrib[attrib]; + const void *src = attrib_src(vao, array, elt); + func_arb(&array->Format)(attrib - VERT_ATTRIB_GENERIC0, src); + } - actx->mapped_vbos = GL_FALSE; + /* finally, vertex position */ + if (vao->Enabled & VERT_BIT_GENERIC0) { + const gl_vert_attrib attrib = VERT_ATTRIB_GENERIC0; + const struct gl_array_attributes *array = &vao->VertexAttrib[attrib]; + const void *src = attrib_src(vao, array, elt); + func_arb(&array->Format)(0, src); + } else if (vao->Enabled & VERT_BIT_POS) { + const gl_vert_attrib attrib = VERT_ATTRIB_POS; + const struct gl_array_attributes *array = &vao->VertexAttrib[attrib]; + const void *src = attrib_src(vao, array, elt); + func_nv(&array->Format)(0, src); + } } @@ -1671,73 +1473,22 @@ 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; - - update_derived_client_arrays(ctx); + struct gl_vertex_array_object *vao; /* 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, ()); + CALL_PrimitiveRestartNV(GET_DISPATCH(), ()); return; } - if (actx->NewState) { - assert(!actx->mapped_vbos); - _ae_update_state(ctx); - } - - /* Determine if we need to map/unmap VBOs */ - do_map = actx->nr_vbos && !actx->mapped_vbos; + vao = ctx->Array.VAO; + _mesa_vao_map_arrays(ctx, vao, GL_MAP_READ_BIT); - if (do_map) - _ae_map_vbos(ctx); + _mesa_array_element(ctx, elt); - /* 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(struct gl_context *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; - } + _mesa_vao_unmap_arrays(ctx, vao); }