X-Git-Url: https://git.libre-soc.org/?a=blobdiff_plain;f=src%2Fmesa%2Fmain%2Fapi_arrayelt.c;h=51a7d63b83e93ae26f75c01a18c2eab966f64854;hb=a0d667036d8c8b77fa62f74263583b07909f8637;hp=152340b5fdea2f21513617f2bfc0f437afce5892;hpb=fe72a069d1fcce943f315907b4744b63158938b1;p=mesa.git

diff --git a/src/mesa/main/api_arrayelt.c b/src/mesa/main/api_arrayelt.c
index 152340b5fde..51a7d63b83e 100644
--- a/src/mesa/main/api_arrayelt.c
+++ b/src/mesa/main/api_arrayelt.c
@@ -1,6 +1,5 @@
 /*
  * Mesa 3-D graphics library
- * Version:  6.5.1
  *
  * Copyright (C) 1999-2006  Brian Paul   All Rights Reserved.
  *
@@ -17,9 +16,10 @@
  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
- * BRIAN PAUL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
- * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
- * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
+ * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
+ * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
  */
 
 /**
@@ -31,142 +31,52 @@
 
 
 /* Author:
- *    Keith Whitwell <keith@tungstengraphics.com>
+ *    Keith Whitwell <keithw@vmware.com>
  */
 
 #include "glheader.h"
+#include "arrayobj.h"
 #include "api_arrayelt.h"
 #include "bufferobj.h"
 #include "context.h"
 #include "imports.h"
 #include "macros.h"
-#include "mfeatures.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;
-
-   struct gl_buffer_object *vbo[VERT_ATTRIB_MAX];
-   GLuint nr_vbos;
-   GLboolean mapped_vbos;
-
-} AEcontext;
-
-#define AE_CONTEXT(ctx) ((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.
  */
-#define TYPE_IDX(t) ( (t) == GL_DOUBLE ? 7 : (t) & 7 )
-
-#define NUM_TYPES 8
-
-
-#if FEATURE_arrayelt
+static inline int
+TYPE_IDX(GLenum t)
+{
+   return t == GL_DOUBLE ? 7 : t & 7;
+}
 
 
-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,
-   },
-};
+/*
+ * 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 IndexFuncs[NUM_TYPES] = {
-   -1,
-   _gloffset_Indexubv,
-   _gloffset_Indexsv,
-   -1,
-   _gloffset_Indexiv,
-   -1,
-   _gloffset_Indexfv,
-   _gloffset_Indexdv,
-};
 
-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
 
 
 /**
@@ -576,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 */
       {
@@ -1071,25 +981,25 @@ VertexAttrib4fvARB(GLuint index, const GLfloat *v)
 static void GLAPIENTRY
 VertexAttrib1dvARB(GLuint index, const GLdouble *v)
 {
-   CALL_VertexAttrib1dvARB(GET_DISPATCH(), (index, v));
+   CALL_VertexAttrib1dv(GET_DISPATCH(), (index, v));
 }
 
 static void GLAPIENTRY
 VertexAttrib2dvARB(GLuint index, const GLdouble *v)
 {
-   CALL_VertexAttrib2dvARB(GET_DISPATCH(), (index, v));
+   CALL_VertexAttrib2dv(GET_DISPATCH(), (index, v));
 }
 
 static void GLAPIENTRY
 VertexAttrib3dvARB(GLuint index, const GLdouble *v)
 {
-   CALL_VertexAttrib3dvARB(GET_DISPATCH(), (index, v));
+   CALL_VertexAttrib3dv(GET_DISPATCH(), (index, v));
 }
 
 static void GLAPIENTRY
 VertexAttrib4dvARB(GLuint index, const GLdouble *v)
 {
-   CALL_VertexAttrib4dvARB(GET_DISPATCH(), (index, v));
+   CALL_VertexAttrib4dv(GET_DISPATCH(), (index, v));
 }
 
 
@@ -1117,7 +1027,7 @@ VertexAttribI3bv(GLuint index, const GLbyte *v)
 static void GLAPIENTRY
 VertexAttribI4bv(GLuint index, const GLbyte *v)
 {
-   CALL_VertexAttribI4bvEXT(GET_DISPATCH(), (index, v));
+   CALL_VertexAttribI4bv(GET_DISPATCH(), (index, v));
 }
 
 
@@ -1142,7 +1052,7 @@ VertexAttribI3ubv(GLuint index, const GLubyte *v)
 static void GLAPIENTRY
 VertexAttribI4ubv(GLuint index, const GLubyte *v)
 {
-   CALL_VertexAttribI4ubvEXT(GET_DISPATCH(), (index, v));
+   CALL_VertexAttribI4ubv(GET_DISPATCH(), (index, v));
 }
 
 
@@ -1168,7 +1078,7 @@ VertexAttribI3sv(GLuint index, const GLshort *v)
 static void GLAPIENTRY
 VertexAttribI4sv(GLuint index, const GLshort *v)
 {
-   CALL_VertexAttribI4svEXT(GET_DISPATCH(), (index, v));
+   CALL_VertexAttribI4sv(GET_DISPATCH(), (index, v));
 }
 
 
@@ -1193,7 +1103,7 @@ VertexAttribI3usv(GLuint index, const GLushort *v)
 static void GLAPIENTRY
 VertexAttribI4usv(GLuint index, const GLushort *v)
 {
-   CALL_VertexAttribI4usvEXT(GET_DISPATCH(), (index, v));
+   CALL_VertexAttribI4usv(GET_DISPATCH(), (index, v));
 }
 
 
@@ -1247,14 +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 */
       {
@@ -1396,235 +1329,134 @@ 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 )
+/*
+ * Return VertexAttrib*NV function pointer matching the provided vertex format.
+ */
+static inline attrib_func
+func_nv(const struct gl_vertex_format *vformat)
 {
-   if (ctx->aelt_context)
-      return GL_TRUE;
-
-   /* These _gloffset_* values may not be compile-time constants */
-   SecondaryColorFuncs[0] = _gloffset_SecondaryColor3bvEXT;
-   SecondaryColorFuncs[1] = _gloffset_SecondaryColor3ubvEXT;
-   SecondaryColorFuncs[2] = _gloffset_SecondaryColor3svEXT;
-   SecondaryColorFuncs[3] = _gloffset_SecondaryColor3usvEXT;
-   SecondaryColorFuncs[4] = _gloffset_SecondaryColor3ivEXT;
-   SecondaryColorFuncs[5] = _gloffset_SecondaryColor3uivEXT;
-   SecondaryColorFuncs[6] = _gloffset_SecondaryColor3fvEXT;
-   SecondaryColorFuncs[7] = _gloffset_SecondaryColor3dvEXT;
-
-   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_FogCoorddvEXT;
-
-   ctx->aelt_context = calloc(1, sizeof(AEcontext));
-   if (!ctx->aelt_context)
-      return GL_FALSE;
-
-   AE_CONTEXT(ctx)->NewState = ~0;
-   return GL_TRUE;
+   return AttribFuncsNV[vformat->Normalized][vformat->Size-1]
+      [TYPE_IDX(vformat->Type)];
 }
 
 
-void _ae_destroy_context( struct gl_context *ctx )
-{
-   if ( AE_CONTEXT( ctx ) ) {
-      free(ctx->aelt_context);
-      ctx->aelt_context = NULL;
-   }
-}
-
-static void check_vbo( AEcontext *actx,
-		       struct gl_buffer_object *vbo )
+/*
+ * Return VertexAttrib*ARB function pointer matching the provided vertex format.
+ */
+static inline attrib_func
+func_arb(const struct gl_vertex_format *vformat)
 {
-   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;
-      assert(actx->nr_vbos < VERT_ATTRIB_MAX);
-      actx->vbo[actx->nr_vbos++] = vbo;
-   }
+   return AttribFuncsARB[vertex_format_to_index(vformat)][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 the address of the array attribute array at elt in the
+ * vertex array object vao.
  */
-static void _ae_update_state( struct gl_context *ctx )
-{
-   AEcontext *actx = AE_CONTEXT(ctx);
-   AEarray *aa = actx->arrays;
-   AEattrib *at = actx->attribs;
-   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) {
-         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 (ctx->VertexProgram._Enabled
-             && ctx->VertexProgram.Current->IsNVProgram) {
-            at->func = AttribFuncsNV[at->array->Normalized]
-                                    [at->array->Size-1]
-                                    [TYPE_IDX(at->array->Type)];
-         }
-         else {
-            GLint intOrNorm;
-            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;
-}
-
-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;
-
-   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;
+   const struct gl_vertex_buffer_binding *binding =
+      &vao->BufferBinding[array->BufferBindingIndex];
+   const GLubyte *src
+      = ADD_POINTERS(binding->BufferObj->Mappings[MAP_INTERNAL].Pointer,
+                     _mesa_vertex_attrib_address(array, binding))
+      + elt * binding->Stride;
+   return src;
 }
 
-void _ae_unmap_vbos( struct gl_context *ctx )
-{
-   AEcontext *actx = AE_CONTEXT(ctx);
-   GLuint i;
 
-   if (!actx->mapped_vbos)
-      return;
+void
+_mesa_array_element(struct gl_context *ctx, GLint elt)
+{
+   const struct gl_vertex_array_object *vao = ctx->Array.VAO;
+   GLbitfield mask;
 
-   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);
+    }
 }
 
 
@@ -1634,83 +1466,32 @@ void _ae_unmap_vbos( struct gl_context *ctx )
  * for all enabled vertex arrays (for elt-th element).
  * Note: this may be called during display list construction.
  */
-void GLAPIENTRY _ae_ArrayElement( GLint elt )
+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;
+   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;
-
-   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) );
-   }
+   vao = ctx->Array.VAO;
+   _mesa_vao_map_arrays(ctx, vao, GL_MAP_READ_BIT);
 
-   if (do_map)
-      _ae_unmap_vbos(ctx);
-}
-
-
-void _ae_invalidate_state( struct gl_context *ctx, GLuint new_state )
-{
-   AEcontext *actx = AE_CONTEXT(ctx);
+   _mesa_array_element(ctx, elt);
 
-   
-   /* 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);
 }
 
 
-void _mesa_install_arrayelt_vtxfmt(struct _glapi_table *disp,
-                                   const GLvertexformat *vfmt)
+void
+_mesa_install_arrayelt_vtxfmt(struct _glapi_table *disp,
+                              const GLvertexformat *vfmt)
 {
    SET_ArrayElement(disp, vfmt->ArrayElement);
 }
-
-
-#endif /* FEATURE_arrayelt */