OpenHarmony/third_party_mesa3d
2
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

mesa: Use VERT_ATTRIB_* indexed array in gl_array_object.

Browse Source 
Replace the distinct struct gl_client_array members in gl_array_object by
an array of gl_client_arrays indexed by VERT_ATTRIB_*.
Renumber the vertex attributes slightly to keep the old semantics of the
distinct array members. Make use of the upper 32 bits in VERT_BIT_*.
Update all occurances of the distinct struct members with the array
equivalents.

Signed-off-by: Mathias Froehlich <Mathias.Froehlich@web.de>
Reviewed-by: Eric Anholt <eric@anholt.net>
This commit is contained in:
Mathias Fröhlich
2011-10-31 22:23:51 +01:00
parent dca6a28a14
commit 762c9766c9
14 changed files with 286 additions and 384 deletions
Download Patch File Download Diff File Expand all files Collapse all files

38
src/mesa/main/api_arrayelt.c
View File

@@ -1474,44 +1474,44 @@ static void _ae_update_state( struct gl_context *ctx )
actx->nr_vbos = 0; actx->nr_vbos = 0;
/* conventional vertex arrays */ /* conventional vertex arrays */
if (arrayObj->Index.Enabled) { if (arrayObj->VertexAttrib[VERT_ATTRIB_COLOR_INDEX].Enabled) {
aa->array = &arrayObj->Index; aa->array = &arrayObj->VertexAttrib[VERT_ATTRIB_COLOR_INDEX];
aa->offset = IndexFuncs[TYPE_IDX(aa->array->Type)]; aa->offset = IndexFuncs[TYPE_IDX(aa->array->Type)];
check_vbo(actx, aa->array->BufferObj); check_vbo(actx, aa->array->BufferObj);
aa++; aa++;
} }
if (arrayObj->EdgeFlag.Enabled) { if (arrayObj->VertexAttrib[VERT_ATTRIB_EDGEFLAG].Enabled) {
aa->array = &arrayObj->EdgeFlag; aa->array = &arrayObj->VertexAttrib[VERT_ATTRIB_EDGEFLAG];
aa->offset = _gloffset_EdgeFlagv; aa->offset = _gloffset_EdgeFlagv;
check_vbo(actx, aa->array->BufferObj); check_vbo(actx, aa->array->BufferObj);
aa++; aa++;
} }
if (arrayObj->Normal.Enabled) { if (arrayObj->VertexAttrib[VERT_ATTRIB_NORMAL].Enabled) {
aa->array = &arrayObj->Normal; aa->array = &arrayObj->VertexAttrib[VERT_ATTRIB_NORMAL];
aa->offset = NormalFuncs[TYPE_IDX(aa->array->Type)]; aa->offset = NormalFuncs[TYPE_IDX(aa->array->Type)];
check_vbo(actx, aa->array->BufferObj); check_vbo(actx, aa->array->BufferObj);
aa++; aa++;
} }
if (arrayObj->Color.Enabled) { if (arrayObj->VertexAttrib[VERT_ATTRIB_COLOR0].Enabled) {
aa->array = &arrayObj->Color; aa->array = &arrayObj->VertexAttrib[VERT_ATTRIB_COLOR0];
aa->offset = ColorFuncs[aa->array->Size-3][TYPE_IDX(aa->array->Type)]; aa->offset = ColorFuncs[aa->array->Size-3][TYPE_IDX(aa->array->Type)];
check_vbo(actx, aa->array->BufferObj); check_vbo(actx, aa->array->BufferObj);
aa++; aa++;
} }
if (arrayObj->SecondaryColor.Enabled) { if (arrayObj->VertexAttrib[VERT_ATTRIB_COLOR1].Enabled) {
aa->array = &arrayObj->SecondaryColor; aa->array = &arrayObj->VertexAttrib[VERT_ATTRIB_COLOR1];
aa->offset = SecondaryColorFuncs[TYPE_IDX(aa->array->Type)]; aa->offset = SecondaryColorFuncs[TYPE_IDX(aa->array->Type)];
check_vbo(actx, aa->array->BufferObj); check_vbo(actx, aa->array->BufferObj);
aa++; aa++;
} }
if (arrayObj->FogCoord.Enabled) { if (arrayObj->VertexAttrib[VERT_ATTRIB_FOG].Enabled) {
aa->array = &arrayObj->FogCoord; aa->array = &arrayObj->VertexAttrib[VERT_ATTRIB_FOG];
aa->offset = FogCoordFuncs[TYPE_IDX(aa->array->Type)]; aa->offset = FogCoordFuncs[TYPE_IDX(aa->array->Type)];
check_vbo(actx, aa->array->BufferObj); check_vbo(actx, aa->array->BufferObj);
aa++; aa++;
} }
for (i = 0; i < ctx->Const.MaxTextureCoordUnits; i++) { for (i = 0; i < ctx->Const.MaxTextureCoordUnits; i++) {
struct gl_client_array *attribArray = &arrayObj->TexCoord[i]; struct gl_client_array *attribArray = &arrayObj->VertexAttrib[VERT_ATTRIB_TEX(i)];
if (attribArray->Enabled) { if (attribArray->Enabled) {
/* NOTE: we use generic glVertexAttribNV functions here. /* NOTE: we use generic glVertexAttribNV functions here.
* If we ever remove GL_NV_vertex_program this will have to change. * If we ever remove GL_NV_vertex_program this will have to change.
@@ -1528,8 +1528,8 @@ static void _ae_update_state( struct gl_context *ctx )
} }
/* generic vertex attribute arrays */ /* generic vertex attribute arrays */
for (i = 1; i < Elements(arrayObj->VertexAttrib); i++) { /* skip zero! */ for (i = 1; i < VERT_ATTRIB_GENERIC_MAX; i++) { /* skip zero! */
struct gl_client_array *attribArray = &arrayObj->VertexAttrib[i]; struct gl_client_array *attribArray = &arrayObj->VertexAttrib[VERT_ATTRIB_GENERIC(i)];
if (attribArray->Enabled) { if (attribArray->Enabled) {
at->array = attribArray; at->array = attribArray;
/* Note: we can't grab the _glapi_Dispatch->VertexAttrib1fvNV /* Note: we can't grab the _glapi_Dispatch->VertexAttrib1fvNV
@@ -1563,18 +1563,18 @@ static void _ae_update_state( struct gl_context *ctx )
} }
/* finally, vertex position */ /* finally, vertex position */
if (arrayObj->VertexAttrib[0].Enabled) { if (arrayObj->VertexAttrib[VERT_ATTRIB_GENERIC0].Enabled) {
/* Use glVertex(v) instead of glVertexAttrib(0, v) to be sure it's /* Use glVertex(v) instead of glVertexAttrib(0, v) to be sure it's
* issued as the last (provoking) attribute). * issued as the last (provoking) attribute).
*/ */
aa->array = &arrayObj->VertexAttrib[0]; aa->array = &arrayObj->VertexAttrib[VERT_ATTRIB_GENERIC0];
assert(aa->array->Size >= 2); /* XXX fix someday? */ assert(aa->array->Size >= 2); /* XXX fix someday? */
aa->offset = VertexFuncs[aa->array->Size-2][TYPE_IDX(aa->array->Type)]; aa->offset = VertexFuncs[aa->array->Size-2][TYPE_IDX(aa->array->Type)];
check_vbo(actx, aa->array->BufferObj); check_vbo(actx, aa->array->BufferObj);
aa++; aa++;
} }
else if (arrayObj->Vertex.Enabled) { else if (arrayObj->VertexAttrib[VERT_ATTRIB_POS].Enabled) {
aa->array = &arrayObj->Vertex; aa->array = &arrayObj->VertexAttrib[VERT_ATTRIB_POS];
aa->offset = VertexFuncs[aa->array->Size-2][TYPE_IDX(aa->array->Type)]; aa->offset = VertexFuncs[aa->array->Size-2][TYPE_IDX(aa->array->Type)];
check_vbo(actx, aa->array->BufferObj); check_vbo(actx, aa->array->BufferObj);
aa++; aa++;

6
src/mesa/main/api_validate.c
View File

@@ -120,7 +120,7 @@ check_valid_to_render(struct gl_context *ctx, const char *function)
case API_OPENGLES: case API_OPENGLES:
/* For OpenGL ES, only draw if we have vertex positions /* For OpenGL ES, only draw if we have vertex positions
*/ */
if (!ctx->Array.ArrayObj->Vertex.Enabled) if (!ctx->Array.ArrayObj->VertexAttrib[VERT_ATTRIB_POS].Enabled)
return GL_FALSE; return GL_FALSE;
break; break;
#endif #endif
@@ -142,8 +142,8 @@ check_valid_to_render(struct gl_context *ctx, const char *function)
/* Draw if we have vertex positions (GL_VERTEX_ARRAY or generic /* Draw if we have vertex positions (GL_VERTEX_ARRAY or generic
* array [0]). * array [0]).
*/ */
return (ctx->Array.ArrayObj->Vertex.Enabled || return (ctx->Array.ArrayObj->VertexAttrib[VERT_ATTRIB_POS].Enabled ||
ctx->Array.ArrayObj->VertexAttrib[0].Enabled); ctx->Array.ArrayObj->VertexAttrib[VERT_ATTRIB_GENERIC0].Enabled);
} }
} }
break; break;

86
src/mesa/main/arrayobj.c
View File

@@ -85,24 +85,8 @@ unbind_array_object_vbos(struct gl_context *ctx, struct gl_array_object *obj)
{ {
GLuint i; GLuint i;
_mesa_reference_buffer_object(ctx, &obj->Vertex.BufferObj, NULL);
_mesa_reference_buffer_object(ctx, &obj->Weight.BufferObj, NULL);
_mesa_reference_buffer_object(ctx, &obj->Normal.BufferObj, NULL);
_mesa_reference_buffer_object(ctx, &obj->Color.BufferObj, NULL);
_mesa_reference_buffer_object(ctx, &obj->SecondaryColor.BufferObj, NULL);
_mesa_reference_buffer_object(ctx, &obj->FogCoord.BufferObj, NULL);
_mesa_reference_buffer_object(ctx, &obj->Index.BufferObj, NULL);
_mesa_reference_buffer_object(ctx, &obj->EdgeFlag.BufferObj, NULL);
for (i = 0; i < Elements(obj->TexCoord); i++)
_mesa_reference_buffer_object(ctx, &obj->TexCoord[i].BufferObj, NULL);
for (i = 0; i < Elements(obj->VertexAttrib); i++) for (i = 0; i < Elements(obj->VertexAttrib); i++)
_mesa_reference_buffer_object(ctx, &obj->VertexAttrib[i].BufferObj, NULL); _mesa_reference_buffer_object(ctx, &obj->VertexAttrib[i].BufferObj, NULL);
#if FEATURE_point_size_array
_mesa_reference_buffer_object(ctx, &obj->PointSize.BufferObj, NULL);
#endif
} }
@@ -235,24 +219,36 @@ _mesa_initialize_array_object( struct gl_context *ctx,
obj->RefCount = 1; obj->RefCount = 1;
/* Init the individual arrays */ /* Init the individual arrays */
init_array(ctx, &obj->Vertex, 4, GL_FLOAT);
init_array(ctx, &obj->Weight, 1, GL_FLOAT);
init_array(ctx, &obj->Normal, 3, GL_FLOAT);
init_array(ctx, &obj->Color, 4, GL_FLOAT);
init_array(ctx, &obj->SecondaryColor, 3, GL_FLOAT);
init_array(ctx, &obj->FogCoord, 1, GL_FLOAT);
init_array(ctx, &obj->Index, 1, GL_FLOAT);
for (i = 0; i < Elements(obj->TexCoord); i++) {
init_array(ctx, &obj->TexCoord[i], 4, GL_FLOAT);
}
init_array(ctx, &obj->EdgeFlag, 1, GL_BOOL);
for (i = 0; i < Elements(obj->VertexAttrib); i++) { for (i = 0; i < Elements(obj->VertexAttrib); i++) {
init_array(ctx, &obj->VertexAttrib[i], 4, GL_FLOAT); switch (i) {
} case VERT_ATTRIB_WEIGHT:
init_array(ctx, &obj->VertexAttrib[VERT_ATTRIB_WEIGHT], 1, GL_FLOAT);
break;
case VERT_ATTRIB_NORMAL:
init_array(ctx, &obj->VertexAttrib[VERT_ATTRIB_NORMAL], 3, GL_FLOAT);
break;
case VERT_ATTRIB_COLOR1:
init_array(ctx, &obj->VertexAttrib[VERT_ATTRIB_COLOR1], 3, GL_FLOAT);
break;
case VERT_ATTRIB_FOG:
init_array(ctx, &obj->VertexAttrib[VERT_ATTRIB_FOG], 1, GL_FLOAT);
break;
case VERT_ATTRIB_COLOR_INDEX:
init_array(ctx, &obj->VertexAttrib[VERT_ATTRIB_COLOR_INDEX], 1, GL_FLOAT);
break;
case VERT_ATTRIB_EDGEFLAG:
init_array(ctx, &obj->VertexAttrib[VERT_ATTRIB_EDGEFLAG], 1, GL_BOOL);
break;
#if FEATURE_point_size_array #if FEATURE_point_size_array
init_array(ctx, &obj->PointSize, 1, GL_FLOAT); case VERT_ATTRIB_POINT_SIZE:
init_array(ctx, &obj->VertexAttrib[VERT_ATTRIB_POINT_SIZE], 1, GL_FLOAT);
break;
#endif #endif
default:
init_array(ctx, &obj->VertexAttrib[i], 4, GL_FLOAT);
break;
}
}
_mesa_reference_buffer_object(ctx, &obj->ElementArrayBufferObj, _mesa_reference_buffer_object(ctx, &obj->ElementArrayBufferObj,
ctx->Shared->NullBufferObj); ctx->Shared->NullBufferObj);
@@ -294,13 +290,10 @@ remove_array_object( struct gl_context *ctx, struct gl_array_object *obj )
static GLuint static GLuint
update_min(GLuint min, struct gl_client_array *array) update_min(GLuint min, struct gl_client_array *array)
{ {
if (array->Enabled) { assert(array->Enabled);
_mesa_update_array_max_element(array); _mesa_update_array_max_element(array);
return MIN2(min, array->_MaxElement); return MIN2(min, array->_MaxElement);
} }
else
return min;
}
/** /**
@@ -310,23 +303,14 @@ void
_mesa_update_array_object_max_element(struct gl_context *ctx, _mesa_update_array_object_max_element(struct gl_context *ctx,
struct gl_array_object *arrayObj) struct gl_array_object *arrayObj)
{ {
GLuint i, min = ~0; GLbitfield64 enabled = arrayObj->_Enabled;
GLuint min = ~0u;
min = update_min(min, &arrayObj->Vertex); while (enabled) {
min = update_min(min, &arrayObj->Weight); GLint attrib = _mesa_ffsll(enabled) - 1;
min = update_min(min, &arrayObj->Normal); enabled &= ~BITFIELD64_BIT(attrib);
min = update_min(min, &arrayObj->Color); min = update_min(min, &arrayObj->VertexAttrib[attrib]);
min = update_min(min, &arrayObj->SecondaryColor); }
min = update_min(min, &arrayObj->FogCoord);
min = update_min(min, &arrayObj->Index);
min = update_min(min, &arrayObj->EdgeFlag);
#if FEATURE_point_size_array
min = update_min(min, &arrayObj->PointSize);
#endif
for (i = 0; i < ctx->Const.MaxTextureCoordUnits; i++)
min = update_min(min, &arrayObj->TexCoord[i]);
for (i = 0; i < Elements(arrayObj->VertexAttrib); i++)
min = update_min(min, &arrayObj->VertexAttrib[i]);
/* _MaxElement is one past the last legal array element */ /* _MaxElement is one past the last legal array element */
arrayObj->_MaxElement = min; arrayObj->_MaxElement = min;

13
src/mesa/main/attrib.c
View File

@@ -1322,19 +1322,6 @@ copy_array_object(struct gl_context *ctx,
/* In theory must be the same anyway, but on recreate make sure it matches */ /* In theory must be the same anyway, but on recreate make sure it matches */
dest->VBOonly = src->VBOonly; dest->VBOonly = src->VBOonly;
_mesa_copy_client_array(ctx, &dest->Vertex, &src->Vertex);
_mesa_copy_client_array(ctx, &dest->Weight, &src->Weight);
_mesa_copy_client_array(ctx, &dest->Normal, &src->Normal);
_mesa_copy_client_array(ctx, &dest->Color, &src->Color);
_mesa_copy_client_array(ctx, &dest->SecondaryColor, &src->SecondaryColor);
_mesa_copy_client_array(ctx, &dest->FogCoord, &src->FogCoord);
_mesa_copy_client_array(ctx, &dest->Index, &src->Index);
_mesa_copy_client_array(ctx, &dest->EdgeFlag, &src->EdgeFlag);
#if FEATURE_point_size_array
_mesa_copy_client_array(ctx, &dest->PointSize, &src->PointSize);
#endif
for (i = 0; i < Elements(src->TexCoord); i++)
_mesa_copy_client_array(ctx, &dest->TexCoord[i], &src->TexCoord[i]);
for (i = 0; i < Elements(src->VertexAttrib); i++) for (i = 0; i < Elements(src->VertexAttrib); i++)
_mesa_copy_client_array(ctx, &dest->VertexAttrib[i], &src->VertexAttrib[i]); _mesa_copy_client_array(ctx, &dest->VertexAttrib[i], &src->VertexAttrib[i]);

11
src/mesa/main/bufferobj.c
View File

@@ -738,17 +738,6 @@ _mesa_DeleteBuffersARB(GLsizei n, const GLuint *ids)
} }
/* unbind any vertex pointers bound to this buffer */ /* unbind any vertex pointers bound to this buffer */
unbind(ctx, &arrayObj->Vertex.BufferObj, bufObj);
unbind(ctx, &arrayObj->Weight.BufferObj, bufObj);
unbind(ctx, &arrayObj->Normal.BufferObj, bufObj);
unbind(ctx, &arrayObj->Color.BufferObj, bufObj);
unbind(ctx, &arrayObj->SecondaryColor.BufferObj, bufObj);
unbind(ctx, &arrayObj->FogCoord.BufferObj, bufObj);
unbind(ctx, &arrayObj->Index.BufferObj, bufObj);
unbind(ctx, &arrayObj->EdgeFlag.BufferObj, bufObj);
for (j = 0; j < Elements(arrayObj->TexCoord); j++) {
unbind(ctx, &arrayObj->TexCoord[j].BufferObj, bufObj);
}
for (j = 0; j < Elements(arrayObj->VertexAttrib); j++) { for (j = 0; j < Elements(arrayObj->VertexAttrib); j++) {
unbind(ctx, &arrayObj->VertexAttrib[j].BufferObj, bufObj); unbind(ctx, &arrayObj->VertexAttrib[j].BufferObj, bufObj);
} }

44
src/mesa/main/enable.c
View File

@@ -59,41 +59,41 @@ client_state(struct gl_context *ctx, GLenum cap, GLboolean state)
switch (cap) { switch (cap) {
case GL_VERTEX_ARRAY: case GL_VERTEX_ARRAY:
var = &arrayObj->Vertex.Enabled; var = &arrayObj->VertexAttrib[VERT_ATTRIB_POS].Enabled;
flag = VERT_BIT_POS; flag = VERT_BIT_POS;
break; break;
case GL_NORMAL_ARRAY: case GL_NORMAL_ARRAY:
var = &arrayObj->Normal.Enabled; var = &arrayObj->VertexAttrib[VERT_ATTRIB_NORMAL].Enabled;
flag = VERT_BIT_NORMAL; flag = VERT_BIT_NORMAL;
break; break;
case GL_COLOR_ARRAY: case GL_COLOR_ARRAY:
var = &arrayObj->Color.Enabled; var = &arrayObj->VertexAttrib[VERT_ATTRIB_COLOR0].Enabled;
flag = VERT_BIT_COLOR0; flag = VERT_BIT_COLOR0;
break; break;
case GL_INDEX_ARRAY: case GL_INDEX_ARRAY:
var = &arrayObj->Index.Enabled; var = &arrayObj->VertexAttrib[VERT_ATTRIB_COLOR_INDEX].Enabled;
flag = VERT_BIT_COLOR_INDEX; flag = VERT_BIT_COLOR_INDEX;
break; break;
case GL_TEXTURE_COORD_ARRAY: case GL_TEXTURE_COORD_ARRAY:
var = &arrayObj->TexCoord[ctx->Array.ActiveTexture].Enabled; var = &arrayObj->VertexAttrib[VERT_ATTRIB_TEX(ctx->Array.ActiveTexture)].Enabled;
flag = VERT_BIT_TEX(ctx->Array.ActiveTexture); flag = VERT_BIT_TEX(ctx->Array.ActiveTexture);
break; break;
case GL_EDGE_FLAG_ARRAY: case GL_EDGE_FLAG_ARRAY:
var = &arrayObj->EdgeFlag.Enabled; var = &arrayObj->VertexAttrib[VERT_ATTRIB_EDGEFLAG].Enabled;
flag = VERT_BIT_EDGEFLAG; flag = VERT_BIT_EDGEFLAG;
break; break;
case GL_FOG_COORDINATE_ARRAY_EXT: case GL_FOG_COORDINATE_ARRAY_EXT:
var = &arrayObj->FogCoord.Enabled; var = &arrayObj->VertexAttrib[VERT_ATTRIB_FOG].Enabled;
flag = VERT_BIT_FOG; flag = VERT_BIT_FOG;
break; break;
case GL_SECONDARY_COLOR_ARRAY_EXT: case GL_SECONDARY_COLOR_ARRAY_EXT:
var = &arrayObj->SecondaryColor.Enabled; var = &arrayObj->VertexAttrib[VERT_ATTRIB_COLOR1].Enabled;
flag = VERT_BIT_COLOR1; flag = VERT_BIT_COLOR1;
break; break;
#if FEATURE_point_size_array #if FEATURE_point_size_array
case GL_POINT_SIZE_ARRAY_OES: case GL_POINT_SIZE_ARRAY_OES:
var = &arrayObj->PointSize.Enabled; var = &arrayObj->VertexAttrib[VERT_ATTRIB_POINT_SIZE].Enabled;
flag = VERT_BIT_POINT_SIZE; flag = VERT_BIT_POINT_SIZE;
break; break;
#endif #endif
@@ -118,8 +118,8 @@ client_state(struct gl_context *ctx, GLenum cap, GLboolean state)
CHECK_EXTENSION(NV_vertex_program, cap); CHECK_EXTENSION(NV_vertex_program, cap);
{ {
GLint n = (GLint) cap - GL_VERTEX_ATTRIB_ARRAY0_NV; GLint n = (GLint) cap - GL_VERTEX_ATTRIB_ARRAY0_NV;
ASSERT(n < Elements(ctx->Array.ArrayObj->VertexAttrib)); ASSERT(VERT_ATTRIB_GENERIC(n) < Elements(ctx->Array.ArrayObj->VertexAttrib));
var = &arrayObj->VertexAttrib[n].Enabled; var = &arrayObj->VertexAttrib[VERT_ATTRIB_GENERIC(n)].Enabled;
flag = VERT_BIT_GENERIC(n); flag = VERT_BIT_GENERIC(n);
} }
break; break;
@@ -1226,27 +1226,27 @@ _mesa_IsEnabled( GLenum cap )
/* client-side state */ /* client-side state */
case GL_VERTEX_ARRAY: case GL_VERTEX_ARRAY:
return (ctx->Array.ArrayObj->Vertex.Enabled != 0); return (ctx->Array.ArrayObj->VertexAttrib[VERT_ATTRIB_POS].Enabled != 0);
case GL_NORMAL_ARRAY: case GL_NORMAL_ARRAY:
return (ctx->Array.ArrayObj->Normal.Enabled != 0); return (ctx->Array.ArrayObj->VertexAttrib[VERT_ATTRIB_NORMAL].Enabled != 0);
case GL_COLOR_ARRAY: case GL_COLOR_ARRAY:
return (ctx->Array.ArrayObj->Color.Enabled != 0); return (ctx->Array.ArrayObj->VertexAttrib[VERT_ATTRIB_COLOR0].Enabled != 0);
case GL_INDEX_ARRAY: case GL_INDEX_ARRAY:
return (ctx->Array.ArrayObj->Index.Enabled != 0); return (ctx->Array.ArrayObj->VertexAttrib[VERT_ATTRIB_COLOR_INDEX].Enabled != 0);
case GL_TEXTURE_COORD_ARRAY: case GL_TEXTURE_COORD_ARRAY:
return (ctx->Array.ArrayObj->TexCoord[ctx->Array.ActiveTexture] return (ctx->Array.ArrayObj->VertexAttrib[VERT_ATTRIB_TEX(ctx->Array.ActiveTexture)]
.Enabled != 0); .Enabled != 0);
case GL_EDGE_FLAG_ARRAY: case GL_EDGE_FLAG_ARRAY:
return (ctx->Array.ArrayObj->EdgeFlag.Enabled != 0); return (ctx->Array.ArrayObj->VertexAttrib[VERT_ATTRIB_EDGEFLAG].Enabled != 0);
case GL_FOG_COORDINATE_ARRAY_EXT: case GL_FOG_COORDINATE_ARRAY_EXT:
CHECK_EXTENSION(EXT_fog_coord); CHECK_EXTENSION(EXT_fog_coord);
return (ctx->Array.ArrayObj->FogCoord.Enabled != 0); return (ctx->Array.ArrayObj->VertexAttrib[VERT_ATTRIB_FOG].Enabled != 0);
case GL_SECONDARY_COLOR_ARRAY_EXT: case GL_SECONDARY_COLOR_ARRAY_EXT:
CHECK_EXTENSION(EXT_secondary_color); CHECK_EXTENSION(EXT_secondary_color);
return (ctx->Array.ArrayObj->SecondaryColor.Enabled != 0); return (ctx->Array.ArrayObj->VertexAttrib[VERT_ATTRIB_COLOR1].Enabled != 0);
#if FEATURE_point_size_array #if FEATURE_point_size_array
case GL_POINT_SIZE_ARRAY_OES: case GL_POINT_SIZE_ARRAY_OES:
return (ctx->Array.ArrayObj->PointSize.Enabled != 0); return (ctx->Array.ArrayObj->VertexAttrib[VERT_ATTRIB_POINT_SIZE].Enabled != 0);
#endif #endif
/* GL_ARB_texture_cube_map */ /* GL_ARB_texture_cube_map */
@@ -1312,8 +1312,8 @@ _mesa_IsEnabled( GLenum cap )
CHECK_EXTENSION(NV_vertex_program); CHECK_EXTENSION(NV_vertex_program);
{ {
GLint n = (GLint) cap - GL_VERTEX_ATTRIB_ARRAY0_NV; GLint n = (GLint) cap - GL_VERTEX_ATTRIB_ARRAY0_NV;
ASSERT(n < Elements(ctx->Array.ArrayObj->VertexAttrib)); ASSERT(VERT_ATTRIB_GENERIC(n) < Elements(ctx->Array.ArrayObj->VertexAttrib));
return (ctx->Array.ArrayObj->VertexAttrib[n].Enabled != 0); return (ctx->Array.ArrayObj->VertexAttrib[VERT_ATTRIB_GENERIC(n)].Enabled != 0);
} }
case GL_MAP1_VERTEX_ATTRIB0_4_NV: case GL_MAP1_VERTEX_ATTRIB0_4_NV:
case GL_MAP1_VERTEX_ATTRIB1_4_NV: case GL_MAP1_VERTEX_ATTRIB1_4_NV:

98
src/mesa/main/get.c
View File

@@ -589,17 +589,17 @@ static const struct value_desc values[] = {
{ GL_TEXTURE_STACK_DEPTH, LOC_CUSTOM, TYPE_INT, 0, { GL_TEXTURE_STACK_DEPTH, LOC_CUSTOM, TYPE_INT, 0,
extra_valid_texture_unit }, extra_valid_texture_unit },
{ GL_VERTEX_ARRAY, ARRAY_BOOL(Vertex.Enabled), NO_EXTRA }, { GL_VERTEX_ARRAY, ARRAY_BOOL(VertexAttrib[VERT_ATTRIB_POS].Enabled), NO_EXTRA },
{ GL_VERTEX_ARRAY_SIZE, ARRAY_INT(Vertex.Size), NO_EXTRA }, { GL_VERTEX_ARRAY_SIZE, ARRAY_INT(VertexAttrib[VERT_ATTRIB_POS].Size), NO_EXTRA },
{ GL_VERTEX_ARRAY_TYPE, ARRAY_ENUM(Vertex.Type), NO_EXTRA }, { GL_VERTEX_ARRAY_TYPE, ARRAY_ENUM(VertexAttrib[VERT_ATTRIB_POS].Type), NO_EXTRA },
{ GL_VERTEX_ARRAY_STRIDE, ARRAY_INT(Vertex.Stride), NO_EXTRA }, { GL_VERTEX_ARRAY_STRIDE, ARRAY_INT(VertexAttrib[VERT_ATTRIB_POS].Stride), NO_EXTRA },
{ GL_NORMAL_ARRAY, ARRAY_BOOL(Normal.Enabled), NO_EXTRA }, { GL_NORMAL_ARRAY, ARRAY_BOOL(VertexAttrib[VERT_ATTRIB_NORMAL].Enabled), NO_EXTRA },
{ GL_NORMAL_ARRAY_TYPE, ARRAY_ENUM(Normal.Type), NO_EXTRA }, { GL_NORMAL_ARRAY_TYPE, ARRAY_ENUM(VertexAttrib[VERT_ATTRIB_NORMAL].Type), NO_EXTRA },
{ GL_NORMAL_ARRAY_STRIDE, ARRAY_INT(Normal.Stride), NO_EXTRA }, { GL_NORMAL_ARRAY_STRIDE, ARRAY_INT(VertexAttrib[VERT_ATTRIB_NORMAL].Stride), NO_EXTRA },
{ GL_COLOR_ARRAY, ARRAY_BOOL(Color.Enabled), NO_EXTRA }, { GL_COLOR_ARRAY, ARRAY_BOOL(VertexAttrib[VERT_ATTRIB_COLOR0].Enabled), NO_EXTRA },
{ GL_COLOR_ARRAY_SIZE, ARRAY_INT(Color.Size), NO_EXTRA }, { GL_COLOR_ARRAY_SIZE, ARRAY_INT(VertexAttrib[VERT_ATTRIB_COLOR0].Size), NO_EXTRA },
{ GL_COLOR_ARRAY_TYPE, ARRAY_ENUM(Color.Type), NO_EXTRA }, { GL_COLOR_ARRAY_TYPE, ARRAY_ENUM(VertexAttrib[VERT_ATTRIB_COLOR0].Type), NO_EXTRA },
{ GL_COLOR_ARRAY_STRIDE, ARRAY_INT(Color.Stride), NO_EXTRA }, { GL_COLOR_ARRAY_STRIDE, ARRAY_INT(VertexAttrib[VERT_ATTRIB_COLOR0].Stride), NO_EXTRA },
{ GL_TEXTURE_COORD_ARRAY, { GL_TEXTURE_COORD_ARRAY,
LOC_CUSTOM, TYPE_BOOLEAN, offsetof(struct gl_client_array, Enabled), NO_EXTRA }, LOC_CUSTOM, TYPE_BOOLEAN, offsetof(struct gl_client_array, Enabled), NO_EXTRA },
{ GL_TEXTURE_COORD_ARRAY_SIZE, { GL_TEXTURE_COORD_ARRAY_SIZE,
@@ -634,11 +634,11 @@ static const struct value_desc values[] = {
/* GL_ARB_vertex_buffer_object */ /* GL_ARB_vertex_buffer_object */
{ GL_VERTEX_ARRAY_BUFFER_BINDING_ARB, LOC_CUSTOM, TYPE_INT, { GL_VERTEX_ARRAY_BUFFER_BINDING_ARB, LOC_CUSTOM, TYPE_INT,
offsetof(struct gl_array_object, Vertex.BufferObj), NO_EXTRA }, offsetof(struct gl_array_object, VertexAttrib[VERT_ATTRIB_POS].BufferObj), NO_EXTRA },
{ GL_NORMAL_ARRAY_BUFFER_BINDING_ARB, LOC_CUSTOM, TYPE_INT, { GL_NORMAL_ARRAY_BUFFER_BINDING_ARB, LOC_CUSTOM, TYPE_INT,
offsetof(struct gl_array_object, Normal.BufferObj), NO_EXTRA }, offsetof(struct gl_array_object, VertexAttrib[VERT_ATTRIB_NORMAL].BufferObj), NO_EXTRA },
{ GL_COLOR_ARRAY_BUFFER_BINDING_ARB, LOC_CUSTOM, TYPE_INT, { GL_COLOR_ARRAY_BUFFER_BINDING_ARB, LOC_CUSTOM, TYPE_INT,
offsetof(struct gl_array_object, Color.BufferObj), NO_EXTRA }, offsetof(struct gl_array_object, VertexAttrib[VERT_ATTRIB_COLOR0].BufferObj), NO_EXTRA },
{ GL_TEXTURE_COORD_ARRAY_BUFFER_BINDING_ARB, LOC_CUSTOM, TYPE_INT, NO_OFFSET, NO_EXTRA }, { GL_TEXTURE_COORD_ARRAY_BUFFER_BINDING_ARB, LOC_CUSTOM, TYPE_INT, NO_OFFSET, NO_EXTRA },
/* GL_OES_point_sprite */ /* GL_OES_point_sprite */
@@ -927,13 +927,13 @@ static const struct value_desc values[] = {
{ GL_VERTEX_ARRAY_COUNT_EXT, CONST(0), NO_EXTRA }, { GL_VERTEX_ARRAY_COUNT_EXT, CONST(0), NO_EXTRA },
{ GL_NORMAL_ARRAY_COUNT_EXT, CONST(0), NO_EXTRA }, { GL_NORMAL_ARRAY_COUNT_EXT, CONST(0), NO_EXTRA },
{ GL_COLOR_ARRAY_COUNT_EXT, CONST(0), NO_EXTRA }, { GL_COLOR_ARRAY_COUNT_EXT, CONST(0), NO_EXTRA },
{ GL_INDEX_ARRAY, ARRAY_BOOL(Index.Enabled), NO_EXTRA }, { GL_INDEX_ARRAY, ARRAY_BOOL(VertexAttrib[VERT_ATTRIB_COLOR_INDEX].Enabled), NO_EXTRA },
{ GL_INDEX_ARRAY_TYPE, ARRAY_ENUM(Index.Type), NO_EXTRA }, { GL_INDEX_ARRAY_TYPE, ARRAY_ENUM(VertexAttrib[VERT_ATTRIB_COLOR_INDEX].Type), NO_EXTRA },
{ GL_INDEX_ARRAY_STRIDE, ARRAY_INT(Index.Stride), NO_EXTRA }, { GL_INDEX_ARRAY_STRIDE, ARRAY_INT(VertexAttrib[VERT_ATTRIB_COLOR_INDEX].Stride), NO_EXTRA },
{ GL_INDEX_ARRAY_COUNT_EXT, CONST(0), NO_EXTRA }, { GL_INDEX_ARRAY_COUNT_EXT, CONST(0), NO_EXTRA },
{ GL_TEXTURE_COORD_ARRAY_COUNT_EXT, CONST(0), NO_EXTRA }, { GL_TEXTURE_COORD_ARRAY_COUNT_EXT, CONST(0), NO_EXTRA },
{ GL_EDGE_FLAG_ARRAY, ARRAY_BOOL(EdgeFlag.Enabled), NO_EXTRA }, { GL_EDGE_FLAG_ARRAY, ARRAY_BOOL(VertexAttrib[VERT_ATTRIB_EDGEFLAG].Enabled), NO_EXTRA },
{ GL_EDGE_FLAG_ARRAY_STRIDE, ARRAY_INT(EdgeFlag.Stride), NO_EXTRA }, { GL_EDGE_FLAG_ARRAY_STRIDE, ARRAY_INT(VertexAttrib[VERT_ATTRIB_EDGEFLAG].Stride), NO_EXTRA },
{ GL_EDGE_FLAG_ARRAY_COUNT_EXT, CONST(0), NO_EXTRA }, { GL_EDGE_FLAG_ARRAY_COUNT_EXT, CONST(0), NO_EXTRA },
/* GL_ARB_texture_compression */ /* GL_ARB_texture_compression */
@@ -958,24 +958,24 @@ static const struct value_desc values[] = {
{ GL_CURRENT_SECONDARY_COLOR_EXT, { GL_CURRENT_SECONDARY_COLOR_EXT,
CONTEXT_FIELD(Current.Attrib[VERT_ATTRIB_COLOR1][0], TYPE_FLOATN_4), CONTEXT_FIELD(Current.Attrib[VERT_ATTRIB_COLOR1][0], TYPE_FLOATN_4),
extra_EXT_secondary_color_flush_current }, extra_EXT_secondary_color_flush_current },
{ GL_SECONDARY_COLOR_ARRAY_EXT, ARRAY_BOOL(SecondaryColor.Enabled), { GL_SECONDARY_COLOR_ARRAY_EXT, ARRAY_BOOL(VertexAttrib[VERT_ATTRIB_COLOR1].Enabled),
extra_EXT_secondary_color }, extra_EXT_secondary_color },
{ GL_SECONDARY_COLOR_ARRAY_TYPE_EXT, ARRAY_ENUM(SecondaryColor.Type), { GL_SECONDARY_COLOR_ARRAY_TYPE_EXT, ARRAY_ENUM(VertexAttrib[VERT_ATTRIB_COLOR1].Type),
extra_EXT_secondary_color }, extra_EXT_secondary_color },
{ GL_SECONDARY_COLOR_ARRAY_STRIDE_EXT, ARRAY_INT(SecondaryColor.Stride), { GL_SECONDARY_COLOR_ARRAY_STRIDE_EXT, ARRAY_INT(VertexAttrib[VERT_ATTRIB_COLOR1].Stride),
extra_EXT_secondary_color }, extra_EXT_secondary_color },
{ GL_SECONDARY_COLOR_ARRAY_SIZE_EXT, ARRAY_INT(SecondaryColor.Size), { GL_SECONDARY_COLOR_ARRAY_SIZE_EXT, ARRAY_INT(VertexAttrib[VERT_ATTRIB_COLOR1].Size),
extra_EXT_secondary_color }, extra_EXT_secondary_color },
/* GL_EXT_fog_coord */ /* GL_EXT_fog_coord */
{ GL_CURRENT_FOG_COORDINATE_EXT, { GL_CURRENT_FOG_COORDINATE_EXT,
CONTEXT_FLOAT(Current.Attrib[VERT_ATTRIB_FOG][0]), CONTEXT_FLOAT(Current.Attrib[VERT_ATTRIB_FOG][0]),
extra_EXT_fog_coord_flush_current }, extra_EXT_fog_coord_flush_current },
{ GL_FOG_COORDINATE_ARRAY_EXT, ARRAY_BOOL(FogCoord.Enabled), { GL_FOG_COORDINATE_ARRAY_EXT, ARRAY_BOOL(VertexAttrib[VERT_ATTRIB_FOG].Enabled),
extra_EXT_fog_coord }, extra_EXT_fog_coord },
{ GL_FOG_COORDINATE_ARRAY_TYPE_EXT, ARRAY_ENUM(FogCoord.Type), { GL_FOG_COORDINATE_ARRAY_TYPE_EXT, ARRAY_ENUM(VertexAttrib[VERT_ATTRIB_FOG].Type),
extra_EXT_fog_coord }, extra_EXT_fog_coord },
{ GL_FOG_COORDINATE_ARRAY_STRIDE_EXT, ARRAY_INT(FogCoord.Stride), { GL_FOG_COORDINATE_ARRAY_STRIDE_EXT, ARRAY_INT(VertexAttrib[VERT_ATTRIB_FOG].Stride),
extra_EXT_fog_coord }, extra_EXT_fog_coord },
{ GL_FOG_COORDINATE_SOURCE_EXT, CONTEXT_ENUM(Fog.FogCoordinateSource), { GL_FOG_COORDINATE_SOURCE_EXT, CONTEXT_ENUM(Fog.FogCoordinateSource),
extra_EXT_fog_coord }, extra_EXT_fog_coord },
@@ -998,37 +998,37 @@ static const struct value_desc values[] = {
/* GL_NV_vertex_program */ /* GL_NV_vertex_program */
{ GL_VERTEX_PROGRAM_BINDING_NV, LOC_CUSTOM, TYPE_INT, 0, { GL_VERTEX_PROGRAM_BINDING_NV, LOC_CUSTOM, TYPE_INT, 0,
extra_NV_vertex_program }, extra_NV_vertex_program },
{ GL_VERTEX_ATTRIB_ARRAY0_NV, ARRAY_BOOL(VertexAttrib[0].Enabled), { GL_VERTEX_ATTRIB_ARRAY0_NV, ARRAY_BOOL(VertexAttrib[VERT_ATTRIB_GENERIC(0)].Enabled),
extra_NV_vertex_program }, extra_NV_vertex_program },
{ GL_VERTEX_ATTRIB_ARRAY1_NV, ARRAY_BOOL(VertexAttrib[1].Enabled), { GL_VERTEX_ATTRIB_ARRAY1_NV, ARRAY_BOOL(VertexAttrib[VERT_ATTRIB_GENERIC(1)].Enabled),
extra_NV_vertex_program }, extra_NV_vertex_program },
{ GL_VERTEX_ATTRIB_ARRAY2_NV, ARRAY_BOOL(VertexAttrib[2].Enabled), { GL_VERTEX_ATTRIB_ARRAY2_NV, ARRAY_BOOL(VertexAttrib[VERT_ATTRIB_GENERIC(2)].Enabled),
extra_NV_vertex_program }, extra_NV_vertex_program },
{ GL_VERTEX_ATTRIB_ARRAY3_NV, ARRAY_BOOL(VertexAttrib[3].Enabled), { GL_VERTEX_ATTRIB_ARRAY3_NV, ARRAY_BOOL(VertexAttrib[VERT_ATTRIB_GENERIC(3)].Enabled),
extra_NV_vertex_program }, extra_NV_vertex_program },
{ GL_VERTEX_ATTRIB_ARRAY4_NV, ARRAY_BOOL(VertexAttrib[4].Enabled), { GL_VERTEX_ATTRIB_ARRAY4_NV, ARRAY_BOOL(VertexAttrib[VERT_ATTRIB_GENERIC(4)].Enabled),
extra_NV_vertex_program }, extra_NV_vertex_program },
{ GL_VERTEX_ATTRIB_ARRAY5_NV, ARRAY_BOOL(VertexAttrib[5].Enabled), { GL_VERTEX_ATTRIB_ARRAY5_NV, ARRAY_BOOL(VertexAttrib[VERT_ATTRIB_GENERIC(5)].Enabled),
extra_NV_vertex_program }, extra_NV_vertex_program },
{ GL_VERTEX_ATTRIB_ARRAY6_NV, ARRAY_BOOL(VertexAttrib[6].Enabled), { GL_VERTEX_ATTRIB_ARRAY6_NV, ARRAY_BOOL(VertexAttrib[VERT_ATTRIB_GENERIC(6)].Enabled),
extra_NV_vertex_program }, extra_NV_vertex_program },
{ GL_VERTEX_ATTRIB_ARRAY7_NV, ARRAY_BOOL(VertexAttrib[7].Enabled), { GL_VERTEX_ATTRIB_ARRAY7_NV, ARRAY_BOOL(VertexAttrib[VERT_ATTRIB_GENERIC(7)].Enabled),
extra_NV_vertex_program }, extra_NV_vertex_program },
{ GL_VERTEX_ATTRIB_ARRAY8_NV, ARRAY_BOOL(VertexAttrib[8].Enabled), { GL_VERTEX_ATTRIB_ARRAY8_NV, ARRAY_BOOL(VertexAttrib[VERT_ATTRIB_GENERIC(8)].Enabled),
extra_NV_vertex_program }, extra_NV_vertex_program },
{ GL_VERTEX_ATTRIB_ARRAY9_NV, ARRAY_BOOL(VertexAttrib[9].Enabled), { GL_VERTEX_ATTRIB_ARRAY9_NV, ARRAY_BOOL(VertexAttrib[VERT_ATTRIB_GENERIC(9)].Enabled),
extra_NV_vertex_program }, extra_NV_vertex_program },
{ GL_VERTEX_ATTRIB_ARRAY10_NV, ARRAY_BOOL(VertexAttrib[10].Enabled), { GL_VERTEX_ATTRIB_ARRAY10_NV, ARRAY_BOOL(VertexAttrib[VERT_ATTRIB_GENERIC(10)].Enabled),
extra_NV_vertex_program }, extra_NV_vertex_program },
{ GL_VERTEX_ATTRIB_ARRAY11_NV, ARRAY_BOOL(VertexAttrib[11].Enabled), { GL_VERTEX_ATTRIB_ARRAY11_NV, ARRAY_BOOL(VertexAttrib[VERT_ATTRIB_GENERIC(11)].Enabled),
extra_NV_vertex_program }, extra_NV_vertex_program },
{ GL_VERTEX_ATTRIB_ARRAY12_NV, ARRAY_BOOL(VertexAttrib[12].Enabled), { GL_VERTEX_ATTRIB_ARRAY12_NV, ARRAY_BOOL(VertexAttrib[VERT_ATTRIB_GENERIC(12)].Enabled),
extra_NV_vertex_program }, extra_NV_vertex_program },
{ GL_VERTEX_ATTRIB_ARRAY13_NV, ARRAY_BOOL(VertexAttrib[13].Enabled), { GL_VERTEX_ATTRIB_ARRAY13_NV, ARRAY_BOOL(VertexAttrib[VERT_ATTRIB_GENERIC(13)].Enabled),
extra_NV_vertex_program }, extra_NV_vertex_program },
{ GL_VERTEX_ATTRIB_ARRAY14_NV, ARRAY_BOOL(VertexAttrib[14].Enabled), { GL_VERTEX_ATTRIB_ARRAY14_NV, ARRAY_BOOL(VertexAttrib[VERT_ATTRIB_GENERIC(14)].Enabled),
extra_NV_vertex_program }, extra_NV_vertex_program },
{ GL_VERTEX_ATTRIB_ARRAY15_NV, ARRAY_BOOL(VertexAttrib[15].Enabled), { GL_VERTEX_ATTRIB_ARRAY15_NV, ARRAY_BOOL(VertexAttrib[VERT_ATTRIB_GENERIC(15)].Enabled),
extra_NV_vertex_program }, extra_NV_vertex_program },
{ GL_MAP1_VERTEX_ATTRIB0_4_NV, CONTEXT_BOOL(Eval.Map1Attrib[0]), { GL_MAP1_VERTEX_ATTRIB0_4_NV, CONTEXT_BOOL(Eval.Map1Attrib[0]),
extra_NV_vertex_program }, extra_NV_vertex_program },
@@ -1099,13 +1099,13 @@ static const struct value_desc values[] = {
/* GL_ARB_vertex_buffer_object */ /* GL_ARB_vertex_buffer_object */
{ GL_INDEX_ARRAY_BUFFER_BINDING_ARB, LOC_CUSTOM, TYPE_INT, { GL_INDEX_ARRAY_BUFFER_BINDING_ARB, LOC_CUSTOM, TYPE_INT,
offsetof(struct gl_array_object, Index.BufferObj), NO_EXTRA }, offsetof(struct gl_array_object, VertexAttrib[VERT_ATTRIB_COLOR_INDEX].BufferObj), NO_EXTRA },
{ GL_EDGE_FLAG_ARRAY_BUFFER_BINDING_ARB, LOC_CUSTOM, TYPE_INT, { GL_EDGE_FLAG_ARRAY_BUFFER_BINDING_ARB, LOC_CUSTOM, TYPE_INT,
offsetof(struct gl_array_object, EdgeFlag.BufferObj), NO_EXTRA }, offsetof(struct gl_array_object, VertexAttrib[VERT_ATTRIB_EDGEFLAG].BufferObj), NO_EXTRA },
{ GL_SECONDARY_COLOR_ARRAY_BUFFER_BINDING_ARB, LOC_CUSTOM, TYPE_INT, { GL_SECONDARY_COLOR_ARRAY_BUFFER_BINDING_ARB, LOC_CUSTOM, TYPE_INT,
offsetof(struct gl_array_object, SecondaryColor.BufferObj), NO_EXTRA }, offsetof(struct gl_array_object, VertexAttrib[VERT_ATTRIB_COLOR1].BufferObj), NO_EXTRA },
{ GL_FOG_COORDINATE_ARRAY_BUFFER_BINDING_ARB, LOC_CUSTOM, TYPE_INT, { GL_FOG_COORDINATE_ARRAY_BUFFER_BINDING_ARB, LOC_CUSTOM, TYPE_INT,
offsetof(struct gl_array_object, FogCoord.BufferObj), NO_EXTRA }, offsetof(struct gl_array_object, VertexAttrib[VERT_ATTRIB_FOG].BufferObj), NO_EXTRA },
/* GL_EXT_pixel_buffer_object */ /* GL_EXT_pixel_buffer_object */
{ GL_PIXEL_PACK_BUFFER_BINDING_EXT, LOC_CUSTOM, TYPE_INT, 0, { GL_PIXEL_PACK_BUFFER_BINDING_EXT, LOC_CUSTOM, TYPE_INT, 0,
@@ -1487,7 +1487,7 @@ find_custom_value(struct gl_context *ctx, const struct value_desc *d, union valu
case GL_TEXTURE_COORD_ARRAY_SIZE: case GL_TEXTURE_COORD_ARRAY_SIZE:
case GL_TEXTURE_COORD_ARRAY_TYPE: case GL_TEXTURE_COORD_ARRAY_TYPE:
case GL_TEXTURE_COORD_ARRAY_STRIDE: case GL_TEXTURE_COORD_ARRAY_STRIDE:
array = &ctx->Array.ArrayObj->TexCoord[ctx->Array.ActiveTexture]; array = &ctx->Array.ArrayObj->VertexAttrib[VERT_ATTRIB_TEX(ctx->Array.ActiveTexture)];
v->value_int = *(GLuint *) ((char *) array + d->offset); v->value_int = *(GLuint *) ((char *) array + d->offset);
break; break;
@@ -1627,7 +1627,7 @@ find_custom_value(struct gl_context *ctx, const struct value_desc *d, union valu
break; break;
case GL_TEXTURE_COORD_ARRAY_BUFFER_BINDING_ARB: case GL_TEXTURE_COORD_ARRAY_BUFFER_BINDING_ARB:
v->value_int = v->value_int =
ctx->Array.ArrayObj->TexCoord[ctx->Array.ActiveTexture].BufferObj->Name; ctx->Array.ArrayObj->VertexAttrib[VERT_ATTRIB_TEX(ctx->Array.ActiveTexture)].BufferObj->Name;
break; break;
case GL_ELEMENT_ARRAY_BUFFER_BINDING_ARB: case GL_ELEMENT_ARRAY_BUFFER_BINDING_ARB:
v->value_int = ctx->Array.ArrayObj->ElementArrayBufferObj->Name; v->value_int = ctx->Array.ArrayObj->ElementArrayBufferObj->Name;
@@ -1679,7 +1679,7 @@ find_custom_value(struct gl_context *ctx, const struct value_desc *d, union valu
ctx->CurrentRenderbuffer ? ctx->CurrentRenderbuffer->Name : 0; ctx->CurrentRenderbuffer ? ctx->CurrentRenderbuffer->Name : 0;
break; break;
case GL_POINT_SIZE_ARRAY_BUFFER_BINDING_OES: case GL_POINT_SIZE_ARRAY_BUFFER_BINDING_OES:
v->value_int = ctx->Array.ArrayObj->PointSize.BufferObj->Name; v->value_int = ctx->Array.ArrayObj->VertexAttrib[VERT_ATTRIB_POINT_SIZE].BufferObj->Name;
break; break;
case GL_FOG_COLOR: case GL_FOG_COLOR:

18
src/mesa/main/getstring.c
View File

@@ -190,28 +190,28 @@ _mesa_GetPointerv( GLenum pname, GLvoid **params )
switch (pname) { switch (pname) {
case GL_VERTEX_ARRAY_POINTER: case GL_VERTEX_ARRAY_POINTER:
*params = (GLvoid *) ctx->Array.ArrayObj->Vertex.Ptr; *params = (GLvoid *) ctx->Array.ArrayObj->VertexAttrib[VERT_ATTRIB_POS].Ptr;
break; break;
case GL_NORMAL_ARRAY_POINTER: case GL_NORMAL_ARRAY_POINTER:
*params = (GLvoid *) ctx->Array.ArrayObj->Normal.Ptr; *params = (GLvoid *) ctx->Array.ArrayObj->VertexAttrib[VERT_ATTRIB_NORMAL].Ptr;
break; break;
case GL_COLOR_ARRAY_POINTER: case GL_COLOR_ARRAY_POINTER:
*params = (GLvoid *) ctx->Array.ArrayObj->Color.Ptr; *params = (GLvoid *) ctx->Array.ArrayObj->VertexAttrib[VERT_ATTRIB_COLOR0].Ptr;
break; break;
case GL_SECONDARY_COLOR_ARRAY_POINTER_EXT: case GL_SECONDARY_COLOR_ARRAY_POINTER_EXT:
*params = (GLvoid *) ctx->Array.ArrayObj->SecondaryColor.Ptr; *params = (GLvoid *) ctx->Array.ArrayObj->VertexAttrib[VERT_ATTRIB_COLOR1].Ptr;
break; break;
case GL_FOG_COORDINATE_ARRAY_POINTER_EXT: case GL_FOG_COORDINATE_ARRAY_POINTER_EXT:
*params = (GLvoid *) ctx->Array.ArrayObj->FogCoord.Ptr; *params = (GLvoid *) ctx->Array.ArrayObj->VertexAttrib[VERT_ATTRIB_FOG].Ptr;
break; break;
case GL_INDEX_ARRAY_POINTER: case GL_INDEX_ARRAY_POINTER:
*params = (GLvoid *) ctx->Array.ArrayObj->Index.Ptr; *params = (GLvoid *) ctx->Array.ArrayObj->VertexAttrib[VERT_ATTRIB_COLOR_INDEX].Ptr;
break; break;
case GL_TEXTURE_COORD_ARRAY_POINTER: case GL_TEXTURE_COORD_ARRAY_POINTER:
*params = (GLvoid *) ctx->Array.ArrayObj->TexCoord[clientUnit].Ptr; *params = (GLvoid *) ctx->Array.ArrayObj->VertexAttrib[VERT_ATTRIB_TEX(clientUnit)].Ptr;
break; break;
case GL_EDGE_FLAG_ARRAY_POINTER: case GL_EDGE_FLAG_ARRAY_POINTER:
*params = (GLvoid *) ctx->Array.ArrayObj->EdgeFlag.Ptr; *params = (GLvoid *) ctx->Array.ArrayObj->VertexAttrib[VERT_ATTRIB_EDGEFLAG].Ptr;
break; break;
case GL_FEEDBACK_BUFFER_POINTER: case GL_FEEDBACK_BUFFER_POINTER:
*params = ctx->Feedback.Buffer; *params = ctx->Feedback.Buffer;
@@ -221,7 +221,7 @@ _mesa_GetPointerv( GLenum pname, GLvoid **params )
break; break;
#if FEATURE_point_size_array #if FEATURE_point_size_array
case GL_POINT_SIZE_ARRAY_POINTER_OES: case GL_POINT_SIZE_ARRAY_POINTER_OES:
*params = (GLvoid *) ctx->Array.ArrayObj->PointSize.Ptr; *params = (GLvoid *) ctx->Array.ArrayObj->VertexAttrib[VERT_ATTRIB_POINT_SIZE].Ptr;
break; break;
#endif #endif
default: default:

61
src/mesa/main/mtypes.h
View File

@@ -110,7 +110,6 @@ typedef enum
VERT_ATTRIB_COLOR1 = 4, VERT_ATTRIB_COLOR1 = 4,
VERT_ATTRIB_FOG = 5, VERT_ATTRIB_FOG = 5,
VERT_ATTRIB_COLOR_INDEX = 6, VERT_ATTRIB_COLOR_INDEX = 6,
VERT_ATTRIB_POINT_SIZE = 6, /*alias*/
VERT_ATTRIB_EDGEFLAG = 7, VERT_ATTRIB_EDGEFLAG = 7,
VERT_ATTRIB_TEX0 = 8, VERT_ATTRIB_TEX0 = 8,
VERT_ATTRIB_TEX1 = 9, VERT_ATTRIB_TEX1 = 9,
@@ -120,23 +119,24 @@ typedef enum
VERT_ATTRIB_TEX5 = 13, VERT_ATTRIB_TEX5 = 13,
VERT_ATTRIB_TEX6 = 14, VERT_ATTRIB_TEX6 = 14,
VERT_ATTRIB_TEX7 = 15, VERT_ATTRIB_TEX7 = 15,
VERT_ATTRIB_GENERIC0 = 16, VERT_ATTRIB_POINT_SIZE = 16,
VERT_ATTRIB_GENERIC1 = 17, VERT_ATTRIB_GENERIC0 = 17,
VERT_ATTRIB_GENERIC2 = 18, VERT_ATTRIB_GENERIC1 = 18,
VERT_ATTRIB_GENERIC3 = 19, VERT_ATTRIB_GENERIC2 = 19,
VERT_ATTRIB_GENERIC4 = 20, VERT_ATTRIB_GENERIC3 = 20,
VERT_ATTRIB_GENERIC5 = 21, VERT_ATTRIB_GENERIC4 = 21,
VERT_ATTRIB_GENERIC6 = 22, VERT_ATTRIB_GENERIC5 = 22,
VERT_ATTRIB_GENERIC7 = 23, VERT_ATTRIB_GENERIC6 = 23,
VERT_ATTRIB_GENERIC8 = 24, VERT_ATTRIB_GENERIC7 = 24,
VERT_ATTRIB_GENERIC9 = 25, VERT_ATTRIB_GENERIC8 = 25,
VERT_ATTRIB_GENERIC10 = 26, VERT_ATTRIB_GENERIC9 = 26,
VERT_ATTRIB_GENERIC11 = 27, VERT_ATTRIB_GENERIC10 = 27,
VERT_ATTRIB_GENERIC12 = 28, VERT_ATTRIB_GENERIC11 = 28,
VERT_ATTRIB_GENERIC13 = 29, VERT_ATTRIB_GENERIC12 = 29,
VERT_ATTRIB_GENERIC14 = 30, VERT_ATTRIB_GENERIC13 = 30,
VERT_ATTRIB_GENERIC15 = 31, VERT_ATTRIB_GENERIC14 = 31,
VERT_ATTRIB_MAX = 32 VERT_ATTRIB_GENERIC15 = 32,
VERT_ATTRIB_MAX = 33
} gl_vert_attrib; } gl_vert_attrib;
/** /**
@@ -180,7 +180,6 @@ typedef enum
#define VERT_BIT_COLOR1 BITFIELD64_BIT(VERT_ATTRIB_COLOR1) #define VERT_BIT_COLOR1 BITFIELD64_BIT(VERT_ATTRIB_COLOR1)
#define VERT_BIT_FOG BITFIELD64_BIT(VERT_ATTRIB_FOG) #define VERT_BIT_FOG BITFIELD64_BIT(VERT_ATTRIB_FOG)
#define VERT_BIT_COLOR_INDEX BITFIELD64_BIT(VERT_ATTRIB_COLOR_INDEX) #define VERT_BIT_COLOR_INDEX BITFIELD64_BIT(VERT_ATTRIB_COLOR_INDEX)
#define VERT_BIT_POINT_SIZE BITFIELD64_BIT(VERT_ATTRIB_POINT_SIZE)
#define VERT_BIT_EDGEFLAG BITFIELD64_BIT(VERT_ATTRIB_EDGEFLAG) #define VERT_BIT_EDGEFLAG BITFIELD64_BIT(VERT_ATTRIB_EDGEFLAG)
#define VERT_BIT_TEX0 BITFIELD64_BIT(VERT_ATTRIB_TEX0) #define VERT_BIT_TEX0 BITFIELD64_BIT(VERT_ATTRIB_TEX0)
#define VERT_BIT_TEX1 BITFIELD64_BIT(VERT_ATTRIB_TEX1) #define VERT_BIT_TEX1 BITFIELD64_BIT(VERT_ATTRIB_TEX1)
@@ -190,6 +189,7 @@ typedef enum
#define VERT_BIT_TEX5 BITFIELD64_BIT(VERT_ATTRIB_TEX5) #define VERT_BIT_TEX5 BITFIELD64_BIT(VERT_ATTRIB_TEX5)
#define VERT_BIT_TEX6 BITFIELD64_BIT(VERT_ATTRIB_TEX6) #define VERT_BIT_TEX6 BITFIELD64_BIT(VERT_ATTRIB_TEX6)
#define VERT_BIT_TEX7 BITFIELD64_BIT(VERT_ATTRIB_TEX7) #define VERT_BIT_TEX7 BITFIELD64_BIT(VERT_ATTRIB_TEX7)
#define VERT_BIT_POINT_SIZE BITFIELD64_BIT(VERT_ATTRIB_POINT_SIZE)
#define VERT_BIT_GENERIC0 BITFIELD64_BIT(VERT_ATTRIB_GENERIC0) #define VERT_BIT_GENERIC0 BITFIELD64_BIT(VERT_ATTRIB_GENERIC0)
#define VERT_BIT(i) BITFIELD64_BIT(i) #define VERT_BIT(i) BITFIELD64_BIT(i)
@@ -1608,27 +1608,8 @@ struct gl_array_object
_glthread_Mutex Mutex; _glthread_Mutex Mutex;
GLboolean VBOonly; /**< require all arrays to live in VBOs? */ GLboolean VBOonly; /**< require all arrays to live in VBOs? */
/** Conventional vertex arrays */ /** Vertex attribute arrays */
/*@{*/ struct gl_client_array VertexAttrib[VERT_ATTRIB_MAX];
struct gl_client_array Vertex;
struct gl_client_array Weight;
struct gl_client_array Normal;
struct gl_client_array Color;
struct gl_client_array SecondaryColor;
struct gl_client_array FogCoord;
struct gl_client_array Index;
struct gl_client_array EdgeFlag;
struct gl_client_array TexCoord[MAX_TEXTURE_COORD_UNITS];
struct gl_client_array PointSize;
/*@}*/
/**
* Generic arrays for vertex programs/shaders.
* For NV vertex programs, these attributes alias and take priority
* over the conventional attribs above. For ARB vertex programs and
* GLSL vertex shaders, these attributes are separate.
*/
struct gl_client_array VertexAttrib[MAX_VERTEX_GENERIC_ATTRIBS];
/** Mask of VERT_BIT_* values indicating which arrays are enabled */ /** Mask of VERT_BIT_* values indicating which arrays are enabled */
GLbitfield64 _Enabled; GLbitfield64 _Enabled;

8
src/mesa/main/nvprogram.c
View File

@@ -365,7 +365,7 @@ _mesa_GetVertexAttribdvNV(GLuint index, GLenum pname, GLdouble *params)
return; return;
} }
array = &ctx->Array.ArrayObj->VertexAttrib[index]; array = &ctx->Array.ArrayObj->VertexAttrib[VERT_ATTRIB_GENERIC(index)];
switch (pname) { switch (pname) {
case GL_ATTRIB_ARRAY_SIZE_NV: case GL_ATTRIB_ARRAY_SIZE_NV:
@@ -409,7 +409,7 @@ _mesa_GetVertexAttribfvNV(GLuint index, GLenum pname, GLfloat *params)
return; return;
} }
array = &ctx->Array.ArrayObj->VertexAttrib[index]; array = &ctx->Array.ArrayObj->VertexAttrib[VERT_ATTRIB_GENERIC(index)];
switch (pname) { switch (pname) {
case GL_ATTRIB_ARRAY_SIZE_NV: case GL_ATTRIB_ARRAY_SIZE_NV:
@@ -453,7 +453,7 @@ _mesa_GetVertexAttribivNV(GLuint index, GLenum pname, GLint *params)
return; return;
} }
array = &ctx->Array.ArrayObj->VertexAttrib[index]; array = &ctx->Array.ArrayObj->VertexAttrib[VERT_ATTRIB_GENERIC(index)];
switch (pname) { switch (pname) {
case GL_ATTRIB_ARRAY_SIZE_NV: case GL_ATTRIB_ARRAY_SIZE_NV:
@@ -508,7 +508,7 @@ _mesa_GetVertexAttribPointervNV(GLuint index, GLenum pname, GLvoid **pointer)
return; return;
} }
*pointer = (GLvoid *) ctx->Array.ArrayObj->VertexAttrib[index].Ptr; *pointer = (GLvoid *) ctx->Array.ArrayObj->VertexAttrib[VERT_ATTRIB_GENERIC(index)].Ptr;
} }
void void

83
src/mesa/main/state.c
View File

@@ -83,98 +83,101 @@ update_arrays( struct gl_context *ctx )
struct gl_array_object *arrayObj = ctx->Array.ArrayObj; struct gl_array_object *arrayObj = ctx->Array.ArrayObj;
GLuint i, min = ~0; GLuint i, min = ~0;
/* find min of _MaxElement values for all enabled arrays */ /* find min of _MaxElement values for all enabled arrays.
* Note that the generic arrays always take precedence over
* the legacy arrays.
*/
/* 0 */ /* 0 */
if (ctx->VertexProgram._Current if (ctx->VertexProgram._Current
&& arrayObj->VertexAttrib[VERT_ATTRIB_POS].Enabled) { && arrayObj->VertexAttrib[VERT_ATTRIB_GENERIC0].Enabled) {
min = update_min(min, &arrayObj->VertexAttrib[VERT_ATTRIB_POS]); min = update_min(min, &arrayObj->VertexAttrib[VERT_ATTRIB_GENERIC0]);
} }
else if (arrayObj->Vertex.Enabled) { else if (arrayObj->VertexAttrib[VERT_ATTRIB_POS].Enabled) {
min = update_min(min, &arrayObj->Vertex); min = update_min(min, &arrayObj->VertexAttrib[VERT_ATTRIB_POS]);
} }
/* 1 */ /* 1 */
if (ctx->VertexProgram._Enabled if (ctx->VertexProgram._Enabled
&& arrayObj->VertexAttrib[VERT_ATTRIB_WEIGHT].Enabled) { && arrayObj->VertexAttrib[VERT_ATTRIB_GENERIC1].Enabled) {
min = update_min(min, &arrayObj->VertexAttrib[VERT_ATTRIB_WEIGHT]); min = update_min(min, &arrayObj->VertexAttrib[VERT_ATTRIB_GENERIC1]);
} }
/* no conventional vertex weight array */ /* no conventional vertex weight array */
/* 2 */ /* 2 */
if (ctx->VertexProgram._Enabled if (ctx->VertexProgram._Enabled
&& arrayObj->VertexAttrib[VERT_ATTRIB_NORMAL].Enabled) { && arrayObj->VertexAttrib[VERT_ATTRIB_GENERIC2].Enabled) {
min = update_min(min, &arrayObj->VertexAttrib[VERT_ATTRIB_NORMAL]); min = update_min(min, &arrayObj->VertexAttrib[VERT_ATTRIB_GENERIC2]);
} }
else if (arrayObj->Normal.Enabled) { else if (arrayObj->VertexAttrib[VERT_ATTRIB_NORMAL].Enabled) {
min = update_min(min, &arrayObj->Normal); min = update_min(min, &arrayObj->VertexAttrib[VERT_ATTRIB_NORMAL]);
} }
/* 3 */ /* 3 */
if (ctx->VertexProgram._Enabled if (ctx->VertexProgram._Enabled
&& arrayObj->VertexAttrib[VERT_ATTRIB_COLOR0].Enabled) { && arrayObj->VertexAttrib[VERT_ATTRIB_GENERIC3].Enabled) {
min = update_min(min, &arrayObj->VertexAttrib[VERT_ATTRIB_COLOR0]); min = update_min(min, &arrayObj->VertexAttrib[VERT_ATTRIB_GENERIC3]);
} }
else if (arrayObj->Color.Enabled) { else if (arrayObj->VertexAttrib[VERT_ATTRIB_COLOR0].Enabled) {
min = update_min(min, &arrayObj->Color); min = update_min(min, &arrayObj->VertexAttrib[VERT_ATTRIB_COLOR0]);
} }
/* 4 */ /* 4 */
if (ctx->VertexProgram._Enabled if (ctx->VertexProgram._Enabled
&& arrayObj->VertexAttrib[VERT_ATTRIB_COLOR1].Enabled) { && arrayObj->VertexAttrib[VERT_ATTRIB_GENERIC4].Enabled) {
min = update_min(min, &arrayObj->VertexAttrib[VERT_ATTRIB_COLOR1]); min = update_min(min, &arrayObj->VertexAttrib[VERT_ATTRIB_GENERIC4]);
} }
else if (arrayObj->SecondaryColor.Enabled) { else if (arrayObj->VertexAttrib[VERT_ATTRIB_COLOR1].Enabled) {
min = update_min(min, &arrayObj->SecondaryColor); min = update_min(min, &arrayObj->VertexAttrib[VERT_ATTRIB_COLOR1]);
} }
/* 5 */ /* 5 */
if (ctx->VertexProgram._Enabled if (ctx->VertexProgram._Enabled
&& arrayObj->VertexAttrib[VERT_ATTRIB_FOG].Enabled) { && arrayObj->VertexAttrib[VERT_ATTRIB_GENERIC5].Enabled) {
min = update_min(min, &arrayObj->VertexAttrib[VERT_ATTRIB_FOG]); min = update_min(min, &arrayObj->VertexAttrib[VERT_ATTRIB_GENERIC5]);
} }
else if (arrayObj->FogCoord.Enabled) { else if (arrayObj->VertexAttrib[VERT_ATTRIB_FOG].Enabled) {
min = update_min(min, &arrayObj->FogCoord); min = update_min(min, &arrayObj->VertexAttrib[VERT_ATTRIB_FOG]);
} }
/* 6 */ /* 6 */
if (ctx->VertexProgram._Enabled if (ctx->VertexProgram._Enabled
&& arrayObj->VertexAttrib[VERT_ATTRIB_COLOR_INDEX].Enabled) { && arrayObj->VertexAttrib[VERT_ATTRIB_GENERIC6].Enabled) {
min = update_min(min, &arrayObj->VertexAttrib[VERT_ATTRIB_COLOR_INDEX]); min = update_min(min, &arrayObj->VertexAttrib[VERT_ATTRIB_GENERIC6]);
} }
else if (arrayObj->Index.Enabled) { else if (arrayObj->VertexAttrib[VERT_ATTRIB_COLOR_INDEX].Enabled) {
min = update_min(min, &arrayObj->Index); min = update_min(min, &arrayObj->VertexAttrib[VERT_ATTRIB_COLOR_INDEX]);
} }
/* 7 */ /* 7 */
if (ctx->VertexProgram._Enabled if (ctx->VertexProgram._Enabled
&& arrayObj->VertexAttrib[VERT_ATTRIB_EDGEFLAG].Enabled) { && arrayObj->VertexAttrib[VERT_ATTRIB_GENERIC7].Enabled) {
min = update_min(min, &arrayObj->VertexAttrib[VERT_ATTRIB_EDGEFLAG]); min = update_min(min, &arrayObj->VertexAttrib[VERT_ATTRIB_GENERIC7]);
} }
/* 8..15 */ /* 8..15 */
for (i = VERT_ATTRIB_TEX0; i <= VERT_ATTRIB_TEX7; i++) { for (i = 0; i < VERT_ATTRIB_TEX_MAX; i++) {
if (ctx->VertexProgram._Enabled if (ctx->VertexProgram._Enabled
&& arrayObj->VertexAttrib[i].Enabled) { && arrayObj->VertexAttrib[VERT_ATTRIB_GENERIC8 + i].Enabled) {
min = update_min(min, &arrayObj->VertexAttrib[i]); min = update_min(min, &arrayObj->VertexAttrib[VERT_ATTRIB_GENERIC8 + i]);
} }
else if (i - VERT_ATTRIB_TEX0 < ctx->Const.MaxTextureCoordUnits else if (i < ctx->Const.MaxTextureCoordUnits
&& arrayObj->TexCoord[i - VERT_ATTRIB_TEX0].Enabled) { && arrayObj->VertexAttrib[VERT_ATTRIB_TEX(i)].Enabled) {
min = update_min(min, &arrayObj->TexCoord[i - VERT_ATTRIB_TEX0]); min = update_min(min, &arrayObj->VertexAttrib[VERT_ATTRIB_TEX(i)]);
} }
} }
/* 16..31 */ /* 16..31 */
if (ctx->VertexProgram._Current) { if (ctx->VertexProgram._Current) {
for (i = 0; i < Elements(arrayObj->VertexAttrib); i++) { for (i = 0; i < VERT_ATTRIB_GENERIC_MAX; i++) {
if (arrayObj->VertexAttrib[i].Enabled) { if (arrayObj->VertexAttrib[VERT_ATTRIB_GENERIC(i)].Enabled) {
min = update_min(min, &arrayObj->VertexAttrib[i]); min = update_min(min, &arrayObj->VertexAttrib[VERT_ATTRIB_GENERIC(i)]);
} }
} }
} }
if (arrayObj->EdgeFlag.Enabled) { if (arrayObj->VertexAttrib[VERT_ATTRIB_EDGEFLAG].Enabled) {
min = update_min(min, &arrayObj->EdgeFlag); min = update_min(min, &arrayObj->VertexAttrib[VERT_ATTRIB_EDGEFLAG]);
} }
/* _MaxElement is one past the last legal array element */ /* _MaxElement is one past the last legal array element */

98
src/mesa/main/varray.c
View File

@@ -108,8 +108,7 @@ type_to_bit(const struct gl_context *ctx, GLenum type)
* functions. * functions.
* *
* \param func name of calling function used for error reporting * \param func name of calling function used for error reporting
* \param array the array to update * \param attrib the attribute array index to update
* \param dirtyBit which bit to set in ctx->Array.NewState for this array
* \param legalTypes bitmask of *_BIT above indicating legal datatypes * \param legalTypes bitmask of *_BIT above indicating legal datatypes
* \param sizeMin min allowable size value * \param sizeMin min allowable size value
* \param sizeMax max allowable size value (may also be BGRA_OR_4) * \param sizeMax max allowable size value (may also be BGRA_OR_4)
@@ -123,13 +122,13 @@ type_to_bit(const struct gl_context *ctx, GLenum type)
static void static void
update_array(struct gl_context *ctx, update_array(struct gl_context *ctx,
const char *func, const char *func,
struct gl_client_array *array, GLuint attrib, GLbitfield legalTypesMask,
GLbitfield64 dirtyBit, GLbitfield legalTypesMask,
GLint sizeMin, GLint sizeMax, GLint sizeMin, GLint sizeMax,
GLint size, GLenum type, GLsizei stride, GLint size, GLenum type, GLsizei stride,
GLboolean normalized, GLboolean integer, GLboolean normalized, GLboolean integer,
const GLvoid *ptr) const GLvoid *ptr)
{ {
struct gl_client_array *array;
GLbitfield typeBit; GLbitfield typeBit;
GLsizei elementSize; GLsizei elementSize;
GLenum format = GL_RGBA; GLenum format = GL_RGBA;
@@ -206,6 +205,7 @@ update_array(struct gl_context *ctx,
elementSize = _mesa_sizeof_type(type) * size; elementSize = _mesa_sizeof_type(type) * size;
array = &ctx->Array.ArrayObj->VertexAttrib[attrib];
array->Size = size; array->Size = size;
array->Type = type; array->Type = type;
array->Format = format; array->Format = format;
@@ -220,7 +220,7 @@ update_array(struct gl_context *ctx,
ctx->Array.ArrayBufferObj); ctx->Array.ArrayBufferObj);
ctx->NewState |= _NEW_ARRAY; ctx->NewState |= _NEW_ARRAY;
ctx->Array.NewState |= dirtyBit; ctx->Array.NewState |= VERT_BIT(attrib);
} }
@@ -237,8 +237,7 @@ _mesa_VertexPointer(GLint size, GLenum type, GLsizei stride, const GLvoid *ptr)
if (ctx->API == API_OPENGLES) if (ctx->API == API_OPENGLES)
legalTypes |= BYTE_BIT; legalTypes |= BYTE_BIT;
update_array(ctx, "glVertexPointer", update_array(ctx, "glVertexPointer", VERT_ATTRIB_POS,
&ctx->Array.ArrayObj->Vertex, VERT_BIT_POS,
legalTypes, 2, 4, legalTypes, 2, 4,
size, type, stride, GL_FALSE, GL_FALSE, ptr); size, type, stride, GL_FALSE, GL_FALSE, ptr);
} }
@@ -255,8 +254,7 @@ _mesa_NormalPointer(GLenum type, GLsizei stride, const GLvoid *ptr )
GET_CURRENT_CONTEXT(ctx); GET_CURRENT_CONTEXT(ctx);
ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx); ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx);
update_array(ctx, "glNormalPointer", update_array(ctx, "glNormalPointer", VERT_ATTRIB_NORMAL,
&ctx->Array.ArrayObj->Normal, VERT_BIT_NORMAL,
legalTypes, 3, 3, legalTypes, 3, 3,
3, type, stride, GL_TRUE, GL_FALSE, ptr); 3, type, stride, GL_TRUE, GL_FALSE, ptr);
} }
@@ -275,8 +273,7 @@ _mesa_ColorPointer(GLint size, GLenum type, GLsizei stride, const GLvoid *ptr)
GET_CURRENT_CONTEXT(ctx); GET_CURRENT_CONTEXT(ctx);
ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx); ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx);
update_array(ctx, "glColorPointer", update_array(ctx, "glColorPointer", VERT_ATTRIB_COLOR0,
&ctx->Array.ArrayObj->Color, VERT_BIT_COLOR0,
legalTypes, 3, BGRA_OR_4, legalTypes, 3, BGRA_OR_4,
size, type, stride, GL_TRUE, GL_FALSE, ptr); size, type, stride, GL_TRUE, GL_FALSE, ptr);
} }
@@ -289,8 +286,7 @@ _mesa_FogCoordPointerEXT(GLenum type, GLsizei stride, const GLvoid *ptr)
GET_CURRENT_CONTEXT(ctx); GET_CURRENT_CONTEXT(ctx);
ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx); ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx);
update_array(ctx, "glFogCoordPointer", update_array(ctx, "glFogCoordPointer", VERT_ATTRIB_FOG,
&ctx->Array.ArrayObj->FogCoord, VERT_BIT_FOG,
legalTypes, 1, 1, legalTypes, 1, 1,
1, type, stride, GL_FALSE, GL_FALSE, ptr); 1, type, stride, GL_FALSE, GL_FALSE, ptr);
} }
@@ -304,8 +300,7 @@ _mesa_IndexPointer(GLenum type, GLsizei stride, const GLvoid *ptr)
GET_CURRENT_CONTEXT(ctx); GET_CURRENT_CONTEXT(ctx);
ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx); ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx);
update_array(ctx, "glIndexPointer", update_array(ctx, "glIndexPointer", VERT_ATTRIB_COLOR_INDEX,
&ctx->Array.ArrayObj->Index, VERT_BIT_COLOR_INDEX,
legalTypes, 1, 1, legalTypes, 1, 1,
1, type, stride, GL_FALSE, GL_FALSE, ptr); 1, type, stride, GL_FALSE, GL_FALSE, ptr);
} }
@@ -324,8 +319,7 @@ _mesa_SecondaryColorPointerEXT(GLint size, GLenum type,
GET_CURRENT_CONTEXT(ctx); GET_CURRENT_CONTEXT(ctx);
ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx); ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx);
update_array(ctx, "glSecondaryColorPointer", update_array(ctx, "glSecondaryColorPointer", VERT_ATTRIB_COLOR1,
&ctx->Array.ArrayObj->SecondaryColor, VERT_BIT_COLOR1,
legalTypes, 3, BGRA_OR_4, legalTypes, 3, BGRA_OR_4,
size, type, stride, GL_TRUE, GL_FALSE, ptr); size, type, stride, GL_TRUE, GL_FALSE, ptr);
} }
@@ -349,9 +343,7 @@ _mesa_TexCoordPointer(GLint size, GLenum type, GLsizei stride,
ASSERT(unit < Elements(ctx->Array.ArrayObj->TexCoord)); ASSERT(unit < Elements(ctx->Array.ArrayObj->TexCoord));
update_array(ctx, "glTexCoordPointer", update_array(ctx, "glTexCoordPointer", VERT_ATTRIB_TEX(unit),
&ctx->Array.ArrayObj->TexCoord[unit],
VERT_BIT_TEX(unit),
legalTypes, 1, 4, legalTypes, 1, 4,
size, type, stride, GL_FALSE, GL_FALSE, size, type, stride, GL_FALSE, GL_FALSE,
ptr); ptr);
@@ -367,8 +359,7 @@ _mesa_EdgeFlagPointer(GLsizei stride, const GLvoid *ptr)
GET_CURRENT_CONTEXT(ctx); GET_CURRENT_CONTEXT(ctx);
ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx); ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx);
update_array(ctx, "glEdgeFlagPointer", update_array(ctx, "glEdgeFlagPointer", VERT_ATTRIB_EDGEFLAG,
&ctx->Array.ArrayObj->EdgeFlag, VERT_BIT_EDGEFLAG,
legalTypes, 1, 1, legalTypes, 1, 1,
1, GL_UNSIGNED_BYTE, stride, GL_FALSE, integer, ptr); 1, GL_UNSIGNED_BYTE, stride, GL_FALSE, integer, ptr);
} }
@@ -387,8 +378,7 @@ _mesa_PointSizePointer(GLenum type, GLsizei stride, const GLvoid *ptr)
return; return;
} }
update_array(ctx, "glPointSizePointer", update_array(ctx, "glPointSizePointer", VERT_ATTRIB_POINT_SIZE,
&ctx->Array.ArrayObj->PointSize, VERT_BIT_POINT_SIZE,
legalTypes, 1, 1, legalTypes, 1, 1,
1, type, stride, GL_FALSE, GL_FALSE, ptr); 1, type, stride, GL_FALSE, GL_FALSE, ptr);
} }
@@ -421,9 +411,7 @@ _mesa_VertexAttribPointerNV(GLuint index, GLint size, GLenum type,
return; return;
} }
update_array(ctx, "glVertexAttribPointerNV", update_array(ctx, "glVertexAttribPointerNV", VERT_ATTRIB_GENERIC(index),
&ctx->Array.ArrayObj->VertexAttrib[index],
VERT_BIT_GENERIC(index),
legalTypes, 1, BGRA_OR_4, legalTypes, 1, BGRA_OR_4,
size, type, stride, normalized, GL_FALSE, ptr); size, type, stride, normalized, GL_FALSE, ptr);
} }
@@ -456,9 +444,7 @@ _mesa_VertexAttribPointerARB(GLuint index, GLint size, GLenum type,
return; return;
} }
update_array(ctx, "glVertexAttribPointer", update_array(ctx, "glVertexAttribPointer", VERT_ATTRIB_GENERIC(index),
&ctx->Array.ArrayObj->VertexAttrib[index],
VERT_BIT_GENERIC(index),
legalTypes, 1, BGRA_OR_4, legalTypes, 1, BGRA_OR_4,
size, type, stride, normalized, GL_FALSE, ptr); size, type, stride, normalized, GL_FALSE, ptr);
} }
@@ -488,9 +474,7 @@ _mesa_VertexAttribIPointer(GLuint index, GLint size, GLenum type,
return; return;
} }
update_array(ctx, "glVertexAttribIPointer", update_array(ctx, "glVertexAttribIPointer", VERT_ATTRIB_GENERIC(index),
&ctx->Array.ArrayObj->VertexAttrib[index],
VERT_BIT_GENERIC(index),
legalTypes, 1, 4, legalTypes, 1, 4,
size, type, stride, normalized, integer, ptr); size, type, stride, normalized, integer, ptr);
} }
@@ -509,10 +493,10 @@ _mesa_EnableVertexAttribArrayARB(GLuint index)
return; return;
} }
ASSERT(index < Elements(ctx->Array.ArrayObj->VertexAttrib)); ASSERT(VERT_ATTRIB_GENERIC(index) < Elements(ctx->Array.ArrayObj->VertexAttrib));
FLUSH_VERTICES(ctx, _NEW_ARRAY); FLUSH_VERTICES(ctx, _NEW_ARRAY);
ctx->Array.ArrayObj->VertexAttrib[index].Enabled = GL_TRUE; ctx->Array.ArrayObj->VertexAttrib[VERT_ATTRIB_GENERIC(index)].Enabled = GL_TRUE;
ctx->Array.ArrayObj->_Enabled |= VERT_BIT_GENERIC(index); ctx->Array.ArrayObj->_Enabled |= VERT_BIT_GENERIC(index);
ctx->Array.NewState |= VERT_BIT_GENERIC(index); ctx->Array.NewState |= VERT_BIT_GENERIC(index);
} }
@@ -530,10 +514,10 @@ _mesa_DisableVertexAttribArrayARB(GLuint index)
return; return;
} }
ASSERT(index < Elements(ctx->Array.ArrayObj->VertexAttrib)); ASSERT(VERT_ATTRIB_GENERIC(index) < Elements(ctx->Array.ArrayObj->VertexAttrib));
FLUSH_VERTICES(ctx, _NEW_ARRAY); FLUSH_VERTICES(ctx, _NEW_ARRAY);
ctx->Array.ArrayObj->VertexAttrib[index].Enabled = GL_FALSE; ctx->Array.ArrayObj->VertexAttrib[VERT_ATTRIB_GENERIC(index)].Enabled = GL_FALSE;
ctx->Array.ArrayObj->_Enabled &= ~VERT_BIT_GENERIC(index); ctx->Array.ArrayObj->_Enabled &= ~VERT_BIT_GENERIC(index);
ctx->Array.NewState |= VERT_BIT_GENERIC(index); ctx->Array.NewState |= VERT_BIT_GENERIC(index);
} }
@@ -555,9 +539,9 @@ get_vertex_array_attrib(struct gl_context *ctx, GLuint index, GLenum pname,
return 0; return 0;
} }
ASSERT(index < Elements(ctx->Array.ArrayObj->VertexAttrib)); ASSERT(VERT_ATTRIB_GENERIC(index) < Elements(ctx->Array.ArrayObj->VertexAttrib));
array = &ctx->Array.ArrayObj->VertexAttrib[index]; array = &ctx->Array.ArrayObj->VertexAttrib[VERT_ATTRIB_GENERIC(index)];
switch (pname) { switch (pname) {
case GL_VERTEX_ATTRIB_ARRAY_ENABLED_ARB: case GL_VERTEX_ATTRIB_ARRAY_ENABLED_ARB:
@@ -607,8 +591,10 @@ get_current_attrib(struct gl_context *ctx, GLuint index, const char *function)
return NULL; return NULL;
} }
ASSERT(VERT_ATTRIB_GENERIC(index) < Elements(ctx->Array.ArrayObj->VertexAttrib));
FLUSH_CURRENT(ctx, 0); FLUSH_CURRENT(ctx, 0);
return ctx->Current.Attrib[VERT_ATTRIB_GENERIC0 + index]; return ctx->Current.Attrib[VERT_ATTRIB_GENERIC(index)];
} }
void GLAPIENTRY void GLAPIENTRY
@@ -741,9 +727,9 @@ _mesa_GetVertexAttribPointervARB(GLuint index, GLenum pname, GLvoid **pointer)
return; return;
} }
ASSERT(index < Elements(ctx->Array.ArrayObj->VertexAttrib)); ASSERT(VERT_ATTRIB_GENERIC(index) < Elements(ctx->Array.ArrayObj->VertexAttrib));
*pointer = (GLvoid *) ctx->Array.ArrayObj->VertexAttrib[index].Ptr; *pointer = (GLvoid *) ctx->Array.ArrayObj->VertexAttrib[VERT_ATTRIB_GENERIC(index)].Ptr;
} }
@@ -1133,7 +1119,9 @@ _mesa_VertexAttribDivisor(GLuint index, GLuint divisor)
return; return;
} }
ctx->Array.ArrayObj->VertexAttrib[index].InstanceDivisor = divisor; ASSERT(VERT_ATTRIB_GENERIC(index) < Elements(ctx->Array.ArrayObj->VertexAttrib));
ctx->Array.ArrayObj->VertexAttrib[VERT_ATTRIB_GENERIC(index)].InstanceDivisor = divisor;
} }
@@ -1193,18 +1181,18 @@ _mesa_print_arrays(struct gl_context *ctx)
_mesa_update_array_object_max_element(ctx, arrayObj); _mesa_update_array_object_max_element(ctx, arrayObj);
printf("Array Object %u\n", arrayObj->Name); printf("Array Object %u\n", arrayObj->Name);
if (arrayObj->Vertex.Enabled) if (arrayObj->VertexAttrib[VERT_ATTRIB_POS].Enabled)
print_array("Vertex", -1, &arrayObj->Vertex); print_array("Vertex", -1, &arrayObj->VertexAttrib[VERT_ATTRIB_POS]);
if (arrayObj->Normal.Enabled) if (arrayObj->VertexAttrib[VERT_ATTRIB_NORMAL].Enabled)
print_array("Normal", -1, &arrayObj->Normal); print_array("Normal", -1, &arrayObj->VertexAttrib[VERT_ATTRIB_NORMAL]);
if (arrayObj->Color.Enabled) if (arrayObj->VertexAttrib[VERT_ATTRIB_COLOR0].Enabled)
print_array("Color", -1, &arrayObj->Color); print_array("Color", -1, &arrayObj->VertexAttrib[VERT_ATTRIB_COLOR0]);
for (i = 0; i < Elements(arrayObj->TexCoord); i++) for (i = 0; i < ctx->Const.MaxTextureCoordUnits; i++)
if (arrayObj->TexCoord[i].Enabled) if (arrayObj->VertexAttrib[VERT_ATTRIB_TEX(i)].Enabled)
print_array("TexCoord", i, &arrayObj->TexCoord[i]); print_array("TexCoord", i, &arrayObj->VertexAttrib[VERT_ATTRIB_TEX(i)]);
for (i = 0; i < Elements(arrayObj->VertexAttrib); i++) for (i = 0; i < VERT_ATTRIB_GENERIC_MAX; i++)
if (arrayObj->VertexAttrib[i].Enabled) if (arrayObj->VertexAttrib[VERT_ATTRIB_GENERIC(i)].Enabled)
print_array("Attrib", i, &arrayObj->VertexAttrib[i]); print_array("Attrib", i, &arrayObj->VertexAttrib[VERT_ATTRIB_GENERIC(i)]);
printf(" _MaxElement = %u\n", arrayObj->_MaxElement); printf(" _MaxElement = %u\n", arrayObj->_MaxElement);
} }

59
src/mesa/vbo/vbo_attrib.h
View File

@@ -60,43 +60,44 @@ enum {
VBO_ATTRIB_TEX5 = 13, VBO_ATTRIB_TEX5 = 13,
VBO_ATTRIB_TEX6 = 14, VBO_ATTRIB_TEX6 = 14,
VBO_ATTRIB_TEX7 = 15, VBO_ATTRIB_TEX7 = 15,
VBO_ATTRIB_POINT_SIZE = 16,
VBO_ATTRIB_GENERIC0 = 16, /* Not used? */ VBO_ATTRIB_GENERIC0 = 17, /* Not used? */
VBO_ATTRIB_GENERIC1 = 17, VBO_ATTRIB_GENERIC1 = 18,
VBO_ATTRIB_GENERIC2 = 18, VBO_ATTRIB_GENERIC2 = 19,
VBO_ATTRIB_GENERIC3 = 19, VBO_ATTRIB_GENERIC3 = 20,
VBO_ATTRIB_GENERIC4 = 20, VBO_ATTRIB_GENERIC4 = 21,
VBO_ATTRIB_GENERIC5 = 21, VBO_ATTRIB_GENERIC5 = 22,
VBO_ATTRIB_GENERIC6 = 22, VBO_ATTRIB_GENERIC6 = 23,
VBO_ATTRIB_GENERIC7 = 23, VBO_ATTRIB_GENERIC7 = 24,
VBO_ATTRIB_GENERIC8 = 24, VBO_ATTRIB_GENERIC8 = 25,
VBO_ATTRIB_GENERIC9 = 25, VBO_ATTRIB_GENERIC9 = 26,
VBO_ATTRIB_GENERIC10 = 26, VBO_ATTRIB_GENERIC10 = 27,
VBO_ATTRIB_GENERIC11 = 27, VBO_ATTRIB_GENERIC11 = 28,
VBO_ATTRIB_GENERIC12 = 28, VBO_ATTRIB_GENERIC12 = 29,
VBO_ATTRIB_GENERIC13 = 29, VBO_ATTRIB_GENERIC13 = 30,
VBO_ATTRIB_GENERIC14 = 30, VBO_ATTRIB_GENERIC14 = 31,
VBO_ATTRIB_GENERIC15 = 31, VBO_ATTRIB_GENERIC15 = 32,
/* XXX: in the vertex program InputsRead flag, we alias /* XXX: in the vertex program InputsRead flag, we alias
* materials and generics and use knowledge about the program * materials and generics and use knowledge about the program
* (whether it is a fixed-function emulation) to * (whether it is a fixed-function emulation) to
* differentiate. Here we must keep them apart instead. * differentiate. Here we must keep them apart instead.
*/ */
VBO_ATTRIB_MAT_FRONT_AMBIENT = 32, VBO_ATTRIB_MAT_FRONT_AMBIENT = 33,
VBO_ATTRIB_MAT_BACK_AMBIENT = 33, VBO_ATTRIB_MAT_BACK_AMBIENT = 34,
VBO_ATTRIB_MAT_FRONT_DIFFUSE = 34, VBO_ATTRIB_MAT_FRONT_DIFFUSE = 35,
VBO_ATTRIB_MAT_BACK_DIFFUSE = 35, VBO_ATTRIB_MAT_BACK_DIFFUSE = 36,
VBO_ATTRIB_MAT_FRONT_SPECULAR = 36, VBO_ATTRIB_MAT_FRONT_SPECULAR = 37,
VBO_ATTRIB_MAT_BACK_SPECULAR = 37, VBO_ATTRIB_MAT_BACK_SPECULAR = 38,
VBO_ATTRIB_MAT_FRONT_EMISSION = 38, VBO_ATTRIB_MAT_FRONT_EMISSION = 39,
VBO_ATTRIB_MAT_BACK_EMISSION = 39, VBO_ATTRIB_MAT_BACK_EMISSION = 40,
VBO_ATTRIB_MAT_FRONT_SHININESS = 40, VBO_ATTRIB_MAT_FRONT_SHININESS = 41,
VBO_ATTRIB_MAT_BACK_SHININESS = 41, VBO_ATTRIB_MAT_BACK_SHININESS = 42,
VBO_ATTRIB_MAT_FRONT_INDEXES = 42, VBO_ATTRIB_MAT_FRONT_INDEXES = 43,
VBO_ATTRIB_MAT_BACK_INDEXES = 43, VBO_ATTRIB_MAT_BACK_INDEXES = 44,
VBO_ATTRIB_MAX = 44 VBO_ATTRIB_MAX = 45
}; };
#define VBO_ATTRIB_FIRST_MATERIAL VBO_ATTRIB_MAT_FRONT_AMBIENT #define VBO_ATTRIB_FIRST_MATERIAL VBO_ATTRIB_MAT_FRONT_AMBIENT

41
src/mesa/vbo/vbo_exec_array.c
View File

@@ -297,16 +297,8 @@ check_draw_elements_data(struct gl_context *ctx, GLsizei count, GLenum elemType,
} }
/* check element j of each enabled array */ /* check element j of each enabled array */
check_array_data(ctx, &arrayObj->Vertex, VERT_ATTRIB_POS, j);
check_array_data(ctx, &arrayObj->Normal, VERT_ATTRIB_NORMAL, j);
check_array_data(ctx, &arrayObj->Color, VERT_ATTRIB_COLOR0, j);
check_array_data(ctx, &arrayObj->SecondaryColor, VERT_ATTRIB_COLOR1, j);
for (k = 0; k < Elements(arrayObj->TexCoord); k++) {
check_array_data(ctx, &arrayObj->TexCoord[k], VERT_ATTRIB_TEX0 + k, j);
}
for (k = 0; k < Elements(arrayObj->VertexAttrib); k++) { for (k = 0; k < Elements(arrayObj->VertexAttrib); k++) {
check_array_data(ctx, &arrayObj->VertexAttrib[k], check_array_data(ctx, &arrayObj->VertexAttrib[k], k, j);
VERT_ATTRIB_GENERIC0 + k, j);
} }
} }
@@ -314,12 +306,6 @@ check_draw_elements_data(struct gl_context *ctx, GLsizei count, GLenum elemType,
ctx->Driver.UnmapBuffer(ctx, ctx->Array.ArrayObj->ElementArrayBufferObj); ctx->Driver.UnmapBuffer(ctx, ctx->Array.ArrayObj->ElementArrayBufferObj);
} }
unmap_array_buffer(ctx, &arrayObj->Vertex);
unmap_array_buffer(ctx, &arrayObj->Normal);
unmap_array_buffer(ctx, &arrayObj->Color);
for (k = 0; k < Elements(arrayObj->TexCoord); k++) {
unmap_array_buffer(ctx, &arrayObj->TexCoord[k]);
}
for (k = 0; k < Elements(arrayObj->VertexAttrib); k++) { for (k = 0; k < Elements(arrayObj->VertexAttrib); k++) {
unmap_array_buffer(ctx, &arrayObj->VertexAttrib[k]); unmap_array_buffer(ctx, &arrayObj->VertexAttrib[k]);
} }
@@ -398,29 +384,12 @@ bind_array_obj(struct gl_context *ctx)
struct gl_array_object *arrayObj = ctx->Array.ArrayObj; struct gl_array_object *arrayObj = ctx->Array.ArrayObj;
GLuint i; GLuint i;
/* TODO: Fix the ArrayObj struct to keep legacy arrays in an array for (i = 0; i < VERT_ATTRIB_FF_MAX; i++)
* rather than as individual named arrays. Then this function can exec->array.legacy_array[i] = &arrayObj->VertexAttrib[VERT_ATTRIB_FF(i)];
* go away.
*/
exec->array.legacy_array[VERT_ATTRIB_POS] = &arrayObj->Vertex;
exec->array.legacy_array[VERT_ATTRIB_WEIGHT] = &arrayObj->Weight;
exec->array.legacy_array[VERT_ATTRIB_NORMAL] = &arrayObj->Normal;
exec->array.legacy_array[VERT_ATTRIB_COLOR0] = &arrayObj->Color;
exec->array.legacy_array[VERT_ATTRIB_COLOR1] = &arrayObj->SecondaryColor;
exec->array.legacy_array[VERT_ATTRIB_FOG] = &arrayObj->FogCoord;
exec->array.legacy_array[VERT_ATTRIB_COLOR_INDEX] = &arrayObj->Index;
if (arrayObj->PointSize.Enabled) {
/* this aliases COLOR_INDEX */
exec->array.legacy_array[VERT_ATTRIB_POINT_SIZE] = &arrayObj->PointSize;
}
exec->array.legacy_array[VERT_ATTRIB_EDGEFLAG] = &arrayObj->EdgeFlag;
for (i = 0; i < Elements(arrayObj->TexCoord); i++) for (i = 0; i < VERT_ATTRIB_GENERIC_MAX; i++) {
exec->array.legacy_array[VERT_ATTRIB_TEX0 + i] = &arrayObj->TexCoord[i];
for (i = 0; i < Elements(arrayObj->VertexAttrib); i++) {
assert(i < Elements(exec->array.generic_array)); assert(i < Elements(exec->array.generic_array));
exec->array.generic_array[i] = &arrayObj->VertexAttrib[i]; exec->array.generic_array[i] = &arrayObj->VertexAttrib[VERT_ATTRIB_GENERIC(i)];
} }
} }