X-Git-Url: https://git.libre-soc.org/?a=blobdiff_plain;f=src%2Fmesa%2Ftnl%2Ft_array_import.c;h=7cc834ffa233fd943445473f92ac353b8f54b088;hb=91ed68b2b9e0fcb70675ee575d805612a675a82c;hp=7bb208cf72555d06cf676dc9354e9a4b726c3435;hpb=908be619fdba608b057ae512834dcc7a76aa3224;p=mesa.git

diff --git a/src/mesa/tnl/t_array_import.c b/src/mesa/tnl/t_array_import.c
index 7bb208cf725..7cc834ffa23 100644
--- a/src/mesa/tnl/t_array_import.c
+++ b/src/mesa/tnl/t_array_import.c
@@ -1,10 +1,8 @@
-/* $Id: t_array_import.c,v 1.13 2001/04/26 14:53:48 keithw Exp $ */
-
 /*
  * Mesa 3-D graphics library
- * Version:  3.5
+ * Version:  6.1
  *
- * Copyright (C) 1999-2001  Brian Paul   All Rights Reserved.
+ * Copyright (C) 1999-2004  Brian Paul   All Rights Reserved.
  *
  * Permission is hereby granted, free of charge, to any person obtaining a
  * copy of this software and associated documentation files (the "Software"),
@@ -24,14 +22,13 @@
  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  *
  * Authors:
- *    Keith Whitwell <keithw@valinux.com>
+ *    Keith Whitwell <keith@tungstengraphics.com>
  */
 
 #include "glheader.h"
 #include "context.h"
 #include "macros.h"
-#include "mem.h"
-#include "mmath.h"
+#include "imports.h"
 #include "state.h"
 #include "mtypes.h"
 
@@ -43,12 +40,13 @@
 
 
 static void _tnl_import_vertex( GLcontext *ctx,
-			   GLboolean writeable,
-			   GLboolean stride )
+				GLboolean writeable,
+				GLboolean stride )
 {
    struct gl_client_array *tmp;
    GLboolean is_writeable = 0;
-   struct vertex_arrays *inputs = &TNL_CONTEXT(ctx)->array_inputs;
+   struct tnl_vertex_arrays *inputs = &TNL_CONTEXT(ctx)->array_inputs;
+   const GLubyte *data;
 
    tmp = _ac_import_vertex(ctx,
 			   GL_FLOAT,
@@ -57,37 +55,31 @@ static void _tnl_import_vertex( GLcontext *ctx,
 			   writeable,
 			   &is_writeable);
 
-   inputs->Obj.data = (GLfloat (*)[4]) tmp->Ptr;
-   inputs->Obj.start = (GLfloat *) tmp->Ptr;
+   data = tmp->Ptr;
+   inputs->Obj.data = (GLfloat (*)[4]) data;
+   inputs->Obj.start = (GLfloat *) data;
    inputs->Obj.stride = tmp->StrideB;
    inputs->Obj.size = tmp->Size;
-   inputs->Obj.flags &= ~(VEC_BAD_STRIDE|VEC_NOT_WRITEABLE);
-   if (inputs->Obj.stride != 4*sizeof(GLfloat))
-      inputs->Obj.flags |= VEC_BAD_STRIDE;
-   if (!is_writeable)
-      inputs->Obj.flags |= VEC_NOT_WRITEABLE;
 }
 
 static void _tnl_import_normal( GLcontext *ctx,
-			   GLboolean writeable,
-			   GLboolean stride )
+				GLboolean writeable,
+				GLboolean stride )
 {
    struct gl_client_array *tmp;
    GLboolean is_writeable = 0;
-   struct vertex_arrays *inputs = &TNL_CONTEXT(ctx)->array_inputs;
+   struct tnl_vertex_arrays *inputs = &TNL_CONTEXT(ctx)->array_inputs;
+   const GLubyte *data;
 
    tmp = _ac_import_normal(ctx, GL_FLOAT,
 			   stride ? 3*sizeof(GLfloat) : 0, writeable,
 			   &is_writeable);
 
-   inputs->Normal.data = (GLfloat (*)[3]) tmp->Ptr;
-   inputs->Normal.start = (GLfloat *) tmp->Ptr;
+   data = tmp->Ptr;
+   inputs->Normal.data = (GLfloat (*)[4]) data;
+   inputs->Normal.start = (GLfloat *) data;
    inputs->Normal.stride = tmp->StrideB;
-   inputs->Normal.flags &= ~(VEC_BAD_STRIDE|VEC_NOT_WRITEABLE);
-   if (inputs->Normal.stride != 3*sizeof(GLfloat))
-      inputs->Normal.flags |= VEC_BAD_STRIDE;
-   if (!is_writeable)
-      inputs->Normal.flags |= VEC_NOT_WRITEABLE;
+   inputs->Normal.size = 3;
 }
 
 
@@ -97,431 +89,264 @@ static void _tnl_import_color( GLcontext *ctx,
 {
    struct gl_client_array *tmp;
    GLboolean is_writeable = 0;
-   struct vertex_arrays *inputs = &TNL_CONTEXT(ctx)->array_inputs;
-
-/*     fprintf(stderr, "%s\n", __FUNCTION__); */
+   struct tnl_vertex_arrays *inputs = &TNL_CONTEXT(ctx)->array_inputs;
+   const GLubyte *data;
 
    tmp = _ac_import_color(ctx,
-			  GL_UNSIGNED_BYTE,
-			  stride ? 4*sizeof(GLubyte) : 0,
+			  GL_FLOAT,
+			  stride ? 4*sizeof(GLfloat) : 0,
 			  4,
 			  writeable,
 			  &is_writeable);
 
-   inputs->Color.data = (GLchan (*)[4]) tmp->Ptr;
-   inputs->Color.start = (GLchan *) tmp->Ptr;
+   data = tmp->Ptr;
+   inputs->Color.data = (GLfloat (*)[4]) data;
+   inputs->Color.start = (GLfloat *) data;
    inputs->Color.stride = tmp->StrideB;
-   inputs->Color.flags &= ~(VEC_BAD_STRIDE|VEC_NOT_WRITEABLE);
-   if (inputs->Color.stride != 4*sizeof(GLchan))
-      inputs->Color.flags |= VEC_BAD_STRIDE;
-   if (!is_writeable)
-      inputs->Color.flags |= VEC_NOT_WRITEABLE;
+   inputs->Color.size = tmp->Size;
 }
 
 
 static void _tnl_import_secondarycolor( GLcontext *ctx,
-				   GLboolean writeable,
-				   GLboolean stride )
+					GLboolean writeable,
+					GLboolean stride )
 {
    struct gl_client_array *tmp;
    GLboolean is_writeable = 0;
-   struct vertex_arrays *inputs = &TNL_CONTEXT(ctx)->array_inputs;
+   struct tnl_vertex_arrays *inputs = &TNL_CONTEXT(ctx)->array_inputs;
+   const GLubyte *data;
 
-   tmp = _ac_import_secondarycolor(ctx, GL_UNSIGNED_BYTE,
-				   stride ? 4*sizeof(GLubyte) : 0,
+   tmp = _ac_import_secondarycolor(ctx, 
+				   GL_FLOAT,
+				   stride ? 4*sizeof(GLfloat) : 0,
 				   4,
 				   writeable,
 				   &is_writeable);
 
-   inputs->SecondaryColor.data = (GLchan (*)[4]) tmp->Ptr;
-   inputs->SecondaryColor.start = (GLchan *) tmp->Ptr;
+   data = tmp->Ptr;
+   inputs->SecondaryColor.data = (GLfloat (*)[4]) data;
+   inputs->SecondaryColor.start = (GLfloat *) data;
    inputs->SecondaryColor.stride = tmp->StrideB;
-   inputs->SecondaryColor.flags &= ~(VEC_BAD_STRIDE|VEC_NOT_WRITEABLE);
-   if (inputs->SecondaryColor.stride != 4*sizeof(GLubyte))
-      inputs->SecondaryColor.flags |= VEC_BAD_STRIDE;
-   if (!is_writeable)
-      inputs->SecondaryColor.flags |= VEC_NOT_WRITEABLE;
+   inputs->SecondaryColor.size = tmp->Size;
 }
 
 static void _tnl_import_fogcoord( GLcontext *ctx,
-			     GLboolean writeable,
-			     GLboolean stride )
+				  GLboolean writeable,
+				  GLboolean stride )
 {
-   struct vertex_arrays *inputs = &TNL_CONTEXT(ctx)->array_inputs;
-    struct gl_client_array *tmp;
+   struct tnl_vertex_arrays *inputs = &TNL_CONTEXT(ctx)->array_inputs;
+   struct gl_client_array *tmp;
    GLboolean is_writeable = 0;
+   const GLubyte *data;
 
    tmp = _ac_import_fogcoord(ctx, GL_FLOAT,
 			     stride ? sizeof(GLfloat) : 0, writeable,
 			     &is_writeable);
 
-   inputs->FogCoord.data = (GLfloat *) tmp->Ptr;
-   inputs->FogCoord.start = (GLfloat *) tmp->Ptr;
+   data = tmp->Ptr;
+   inputs->FogCoord.data = (GLfloat (*)[4]) data;
+   inputs->FogCoord.start = (GLfloat *) data;
    inputs->FogCoord.stride = tmp->StrideB;
-   inputs->FogCoord.flags &= ~(VEC_BAD_STRIDE|VEC_NOT_WRITEABLE);
-   if (inputs->FogCoord.stride != sizeof(GLfloat))
-      inputs->FogCoord.flags |= VEC_BAD_STRIDE;
-   if (!is_writeable)
-      inputs->FogCoord.flags |= VEC_NOT_WRITEABLE;
 }
 
 static void _tnl_import_index( GLcontext *ctx,
-			  GLboolean writeable,
-			  GLboolean stride )
+			       GLboolean writeable,
+			       GLboolean stride )
 {
-   struct vertex_arrays *inputs = &TNL_CONTEXT(ctx)->array_inputs;
+   struct tnl_vertex_arrays *inputs = &TNL_CONTEXT(ctx)->array_inputs;
    struct gl_client_array *tmp;
    GLboolean is_writeable = 0;
+   const GLubyte *data;
 
-   tmp = _ac_import_index(ctx, GL_UNSIGNED_INT,
-			  stride ? sizeof(GLuint) : 0, writeable,
+   tmp = _ac_import_index(ctx, GL_FLOAT,
+			  stride ? sizeof(GLfloat) : 0, writeable,
 			  &is_writeable);
 
-   inputs->Index.data = (GLuint *) tmp->Ptr;
-   inputs->Index.start = (GLuint *) tmp->Ptr;
+   data = tmp->Ptr;
+   inputs->Index.data = (GLfloat (*)[4]) data;
+   inputs->Index.start = (GLfloat *) data;
    inputs->Index.stride = tmp->StrideB;
-   inputs->Index.flags &= ~(VEC_BAD_STRIDE|VEC_NOT_WRITEABLE);
-   if (inputs->Index.stride != sizeof(GLuint))
-      inputs->Index.flags |= VEC_BAD_STRIDE;
-   if (!is_writeable)
-      inputs->Index.flags |= VEC_NOT_WRITEABLE;
 }
 
 
 static void _tnl_import_texcoord( GLcontext *ctx,
-			     GLuint i,
-			     GLboolean writeable,
-			     GLboolean stride )
+				  GLuint unit,
+				  GLboolean writeable,
+				  GLboolean stride )
 {
-   struct vertex_arrays *inputs = &TNL_CONTEXT(ctx)->array_inputs;
+   struct tnl_vertex_arrays *inputs = &TNL_CONTEXT(ctx)->array_inputs;
    struct gl_client_array *tmp;
    GLboolean is_writeable = 0;
+   const GLubyte *data;
 
-   tmp = _ac_import_texcoord(ctx, i, GL_FLOAT,
-			     stride ? 4*sizeof(GLfloat) : 0,
+   tmp = _ac_import_texcoord(ctx, unit, GL_FLOAT,
+			     stride ? 4 * sizeof(GLfloat) : 0,
 			     0,
 			     writeable,
 			     &is_writeable);
 
-   inputs->TexCoord[i].data = (GLfloat (*)[4]) tmp->Ptr;
-   inputs->TexCoord[i].start = (GLfloat *) tmp->Ptr;
-   inputs->TexCoord[i].stride = tmp->StrideB;
-   inputs->TexCoord[i].size = tmp->Size;
-   inputs->TexCoord[i].flags &= ~(VEC_BAD_STRIDE|VEC_NOT_WRITEABLE);
-   if (inputs->TexCoord[i].stride != 4*sizeof(GLfloat))
-      inputs->TexCoord[i].flags |= VEC_BAD_STRIDE;
-   if (!is_writeable)
-      inputs->TexCoord[i].flags |= VEC_NOT_WRITEABLE;
+   data = tmp->Ptr;
+   inputs->TexCoord[unit].data = (GLfloat (*)[4]) data;
+   inputs->TexCoord[unit].start = (GLfloat *) data;
+   inputs->TexCoord[unit].stride = tmp->StrideB;
+   inputs->TexCoord[unit].size = tmp->Size;
 }
 
 
 static void _tnl_import_edgeflag( GLcontext *ctx,
-			     GLboolean writeable,
-			     GLboolean stride )
+				  GLboolean writeable,
+				  GLboolean stride )
 {
-   struct vertex_arrays *inputs = &TNL_CONTEXT(ctx)->array_inputs;
+   struct tnl_vertex_arrays *inputs = &TNL_CONTEXT(ctx)->array_inputs;
    struct gl_client_array *tmp;
    GLboolean is_writeable = 0;
+   const GLubyte *data;
+   (void) writeable; (void) stride;
 
    tmp = _ac_import_edgeflag(ctx, GL_UNSIGNED_BYTE,
-			     stride ? sizeof(GLubyte) : 0,
+			     sizeof(GLubyte),
 			     0,
 			     &is_writeable);
 
-   inputs->EdgeFlag.data = (GLubyte *) tmp->Ptr;
-   inputs->EdgeFlag.start = (GLubyte *) tmp->Ptr;
-   inputs->EdgeFlag.stride = tmp->StrideB;
-   inputs->EdgeFlag.flags &= ~(VEC_BAD_STRIDE|VEC_NOT_WRITEABLE);
-   if (inputs->EdgeFlag.stride != sizeof(GLubyte))
-      inputs->EdgeFlag.flags |= VEC_BAD_STRIDE;
-   if (!is_writeable)
-      inputs->EdgeFlag.flags |= VEC_NOT_WRITEABLE;
+   data = tmp->Ptr;
+   inputs->EdgeFlag = (GLubyte *) data;
 }
 
 
 
-/* Callback for VB stages that need to improve the quality of arrays
- * bound to the VB.  This is only necessary for client arrays which
- * have not been transformed at any point in the pipeline.
- */
-static void _tnl_upgrade_client_data( GLcontext *ctx,
-				      GLuint required,
-				      GLuint flags )
+static void _tnl_import_attrib( GLcontext *ctx,
+                                GLuint index,
+                                GLboolean writeable,
+                                GLboolean stride )
 {
-   GLuint i;
-   struct vertex_buffer *VB = &TNL_CONTEXT(ctx)->vb;
-   GLboolean writeable = (flags & VEC_NOT_WRITEABLE) != 0;
-   GLboolean stride = (flags & VEC_BAD_STRIDE) != 0;
-   struct vertex_arrays *inputs = &TNL_CONTEXT(ctx)->array_inputs;
-   (void) inputs;
-
-   if ((required & VERT_CLIP) && VB->ClipPtr == VB->ObjPtr)
-      required |= VERT_OBJ;
-
-/*     _tnl_print_vert_flags("_tnl_upgrade_client_data", required); */
-
-   if ((required & VERT_OBJ) && (VB->ObjPtr->flags & flags)) {
-      ASSERT(VB->ObjPtr == &inputs->Obj);
-      _tnl_import_vertex( ctx, writeable, stride );
-      VB->importable_data &= ~(VERT_OBJ|VERT_CLIP);
-   }
-
-   if ((required & VERT_NORM) && (VB->NormalPtr->flags & flags)) {
-      ASSERT(VB->NormalPtr == &inputs->Normal);
-      _tnl_import_normal( ctx, writeable, stride );
-      VB->importable_data &= ~VERT_NORM;
-   }
-
-   if ((required & VERT_RGBA) && (VB->ColorPtr[0]->flags & flags)) {
-      ASSERT(VB->ColorPtr[0] == &inputs->Color);
-      _tnl_import_color( ctx, writeable, stride );
-      VB->importable_data &= ~VERT_RGBA;
-   }
-
-   if ((required & VERT_SPEC_RGB) && (VB->SecondaryColorPtr[0]->flags&flags)) {
-      ASSERT(VB->SecondaryColorPtr[0] == &inputs->SecondaryColor);
-      _tnl_import_secondarycolor( ctx, writeable, stride );
-      VB->importable_data &= ~VERT_SPEC_RGB;
-   }
-
-   if ((required & VERT_FOG_COORD) && (VB->FogCoordPtr->flags & flags)) {
-      ASSERT(VB->FogCoordPtr == &inputs->FogCoord);
-      _tnl_import_fogcoord( ctx, writeable, stride );
-      VB->importable_data &= ~VERT_FOG_COORD;
-   }
-
-   if ((required & VERT_INDEX) && (VB->IndexPtr[0]->flags & flags)) {
-      ASSERT(VB->IndexPtr[0] == &inputs->Index);
-      _tnl_import_index( ctx, writeable, stride );
-      VB->importable_data &= ~VERT_INDEX;
-   }
-
-   if (required & VERT_TEX_ANY)
-      for (i = 0 ; i < ctx->Const.MaxTextureUnits ; i++)
-	 if ((required & VERT_TEX(i)) && (VB->TexCoordPtr[i]->flags & flags)) {
-	    ASSERT(VB->TexCoordPtr[i] == &inputs->TexCoord[i]);
-	    _tnl_import_texcoord( ctx, i, writeable, stride );
-	    VB->importable_data &= ~VERT_TEX(i);
-	 }
-
+   struct tnl_vertex_arrays *inputs = &TNL_CONTEXT(ctx)->array_inputs;
+   struct gl_client_array *tmp;
+   GLboolean is_writeable = 0;
+   const GLubyte *data;
+
+   tmp = _ac_import_attrib(ctx, index, GL_FLOAT,
+                           stride ? 4 * sizeof(GLfloat) : 0,
+                           4,  /* want GLfloat[4] */
+                           writeable,
+                           &is_writeable);
+
+   data = tmp->Ptr;
+   inputs->Attribs[index].data = (GLfloat (*)[4]) data;
+   inputs->Attribs[index].start = (GLfloat *) data;
+   inputs->Attribs[index].stride = tmp->StrideB;
+   inputs->Attribs[index].size = tmp->Size;
 }
 
 
+static void _tnl_constant_attrib( TNLcontext *tnl,
+				  struct tnl_vertex_arrays *tmp,
+				  GLuint i )
+{
+   tmp->Attribs[i].count = 1;
+   tmp->Attribs[i].data = (GLfloat (*)[4]) tnl->vtx.current[i];
+   tmp->Attribs[i].start = tnl->vtx.current[i];
+   tmp->Attribs[i].size = 4; 
+   tmp->Attribs[i].stride = 0;
+   tnl->vb.AttribPtr[i] = &tmp->Attribs[i];
+}
 
 
 
-void _tnl_vb_bind_arrays( GLcontext *ctx, GLint start, GLsizei count )
+void _tnl_vb_bind_arrays( GLcontext *ctx, GLint start, GLint end)
 {
    TNLcontext *tnl = TNL_CONTEXT(ctx);
    struct vertex_buffer *VB = &tnl->vb;
-   GLuint inputs = tnl->pipeline.inputs;
-   GLuint imports;
-   struct vertex_arrays *tmp = &tnl->array_inputs;
-
-/*     fprintf(stderr, "_tnl_vb_bind_arrays %d..%d // %d..%d\n", */
-/*    	   start, count, ctx->Array.LockFirst, ctx->Array.LockCount);  */
-
-   if (ctx->Array.LockCount) {
-      ASSERT(start == (GLint) ctx->Array.LockFirst);
-      ASSERT(count == (GLint) ctx->Array.LockCount);
-   }
-
-   imports = tnl->pipeline.inputs;
-
-   _ac_import_range( ctx, start, count );
-
-   VB->Count = count - start;
-   VB->FirstClipped = VB->Count;
-
-   VB->Elts = 0;
-   VB->MaterialMask = 0;
-   VB->Material = 0;
-   VB->Flag = 0;
-
-/*     _tnl_print_vert_flags("_tnl_vb_bind_arrays: inputs", inputs); */
-/*     _tnl_print_vert_flags("_tnl_vb_bind_arrays: imports", imports); */
-/*     _tnl_print_vert_flags("_tnl_vb_bind_arrays: _Enabled", ctx->Array._Enabled); */
-
-   if (inputs & VERT_OBJ) {
-      if (imports & VERT_OBJ) {
+   struct tnl_vertex_arrays *tmp = &tnl->array_inputs;
+   GLuint i, index;
+
+   VB->Count = end - start;
+   VB->Elts = NULL;
+
+   _ac_import_range( ctx, start, end );
+
+   /* When vertex program mode is enabled, the generic vertex program
+    * attribute arrays have priority over the conventional attributes.
+    * Try to use them now.
+    */
+   for (index = 0; index < VERT_ATTRIB_MAX; index++) {
+      /* When vertex program mode is enabled, the generic vertex attribute
+       * arrays have priority over the conventional vertex arrays.
+       */
+      if (ctx->VertexProgram._Enabled
+          && ctx->Array.VertexAttrib[index].Enabled) {
+         /* Use generic attribute array */
+         _tnl_import_attrib( ctx, index, GL_FALSE, GL_TRUE );
+         VB->AttribPtr[index] = &tmp->Attribs[index];
+      }
+      /* use conventional arrays... */
+      else if (index == VERT_ATTRIB_POS) {
 	 _tnl_import_vertex( ctx, 0, 0 );
 	 tmp->Obj.count = VB->Count;
+	 VB->AttribPtr[_TNL_ATTRIB_POS] = &tmp->Obj;
       }
-      VB->ObjPtr = &tmp->Obj;
-   }
-
-   if (inputs & VERT_NORM) {
-      if (imports & VERT_NORM) {
+      else if (index == VERT_ATTRIB_NORMAL) {
 	 _tnl_import_normal( ctx, 0, 0 );
 	 tmp->Normal.count = VB->Count;
+	 VB->AttribPtr[_TNL_ATTRIB_NORMAL] = &tmp->Normal;
       }
-      VB->NormalPtr = &tmp->Normal;
-   }
-
-   if (inputs & VERT_RGBA) {
-      if (imports & VERT_RGBA) {
+      else if (index == VERT_ATTRIB_COLOR0) {
 	 _tnl_import_color( ctx, 0, 0 );
 	 tmp->Color.count = VB->Count;
+	 VB->AttribPtr[_TNL_ATTRIB_COLOR0] = &tmp->Color;
       }
-      VB->ColorPtr[0] = &tmp->Color;
-      VB->ColorPtr[1] = 0;
-   }
-
-   if (inputs & VERT_INDEX) {
-      if (imports & VERT_INDEX) {
-	 _tnl_import_index( ctx, 0, 0 );
-	 tmp->Index.count = VB->Count;
+      else if (index == VERT_ATTRIB_COLOR1) {
+	 _tnl_import_secondarycolor( ctx, 0, 0 );
+	 tmp->SecondaryColor.count = VB->Count;
+	 VB->AttribPtr[_TNL_ATTRIB_COLOR1] = &tmp->SecondaryColor;
       }
-      VB->IndexPtr[0] = &tmp->Index;
-      VB->IndexPtr[1] = 0;
-   }
-
-
-   if (inputs & VERT_FOG_COORD) {
-      if (imports & VERT_FOG_COORD) {
+      else if (index == VERT_ATTRIB_FOG) {
 	 _tnl_import_fogcoord( ctx, 0, 0 );
 	 tmp->FogCoord.count = VB->Count;
+	 VB->AttribPtr[_TNL_ATTRIB_FOG] = &tmp->FogCoord;
       }
-      VB->FogCoordPtr = &tmp->FogCoord;
-   }
-
-   if (inputs & VERT_EDGE) {
-      _tnl_import_edgeflag( ctx, GL_TRUE, sizeof(GLboolean) );
-      VB->EdgeFlag = (GLboolean *) tmp->EdgeFlag.data;
-   }
-
-   if (inputs & VERT_SPEC_RGB) {
-      if (imports & VERT_SPEC_RGB) {
-	 _tnl_import_secondarycolor( ctx, 0, 0 );
-	 tmp->SecondaryColor.count = VB->Count;
+      else if (index >= VERT_ATTRIB_TEX0 && index <= VERT_ATTRIB_TEX7) {
+	 i = index - VERT_ATTRIB_TEX0;
+	 _tnl_import_texcoord( ctx, i, GL_FALSE, GL_FALSE );
+	 tmp->TexCoord[i].count = VB->Count;
+	 VB->AttribPtr[_TNL_ATTRIB_TEX0 + i] = &tmp->TexCoord[i];
+      }
+      else {
+	 _tnl_constant_attrib(tnl, tmp, index);
       }
-      VB->SecondaryColorPtr[0] = &tmp->SecondaryColor;
-      VB->SecondaryColorPtr[1] = 0;
-   }
-
-   if (inputs & VERT_TEX_ANY) {
-      GLuint i;
-      for (i = 0; i < ctx->Const.MaxTextureUnits ; i++)
-	 if (inputs & VERT_TEX(i)) {
-	    if (imports & VERT_TEX(i)) {
-	       _tnl_import_texcoord( ctx, i, 0, 0 );
-	       tmp->TexCoord[i].count = VB->Count;
-	    }
-	    VB->TexCoordPtr[i] = &tmp->TexCoord[i];
-	 }
-   }
-
-   VB->Primitive = tnl->tmp_primitive;
-   VB->PrimitiveLength = tnl->tmp_primitive_length;
-   VB->import_data = _tnl_upgrade_client_data;
-   VB->importable_data = imports & VERT_FIXUP;
-/*     _tnl_print_vert_flags("_tnl_vb_bind_arrays: importable", VB->importable_data); */
-
-}
-
-
-
-
-/* Function to fill an immediate struct with the effects of
- * consecutive calls to ArrayElement with consecutive indices.
- */
-void _tnl_fill_immediate_drawarrays( GLcontext *ctx, struct immediate *IM,
-				     GLuint start, GLuint count )
-{
-   TNLcontext *tnl = TNL_CONTEXT(ctx);
-   GLuint required = ctx->Array._Enabled;
-   GLuint n = count - start;
-   GLuint i;
-
-   if (!ctx->CompileFlag)
-      required &= tnl->pipeline.inputs;
-
-   if (MESA_VERBOSE&VERBOSE_IMMEDIATE)
-      fprintf(stderr, "exec_full_array_elements %d .. %d\n", start, count);
-
-   _math_trans_4f( IM->Obj + IM->Start,
-		   ctx->Array.Vertex.Ptr,
-		   ctx->Array.Vertex.StrideB,
-		   ctx->Array.Vertex.Type,
-		   ctx->Array.Vertex.Size,
-		   start, n );
-
-   if (ctx->Array.Vertex.Size == 4)
-      required |= VERT_OBJ_234;
-   else if (ctx->Array.Vertex.Size == 3)
-      required |= VERT_OBJ_23;
-
-
-   if (required & VERT_NORM) {
-      _math_trans_3f( IM->Normal + IM->Start,
-		      ctx->Array.Normal.Ptr,
-		      ctx->Array.Normal.StrideB,
-		      ctx->Array.Normal.Type,
-		      start, n );
-   }
-
-   if (required & VERT_EDGE) {
-      _math_trans_1ub( IM->EdgeFlag + IM->Start,
-		       ctx->Array.EdgeFlag.Ptr,
-		       ctx->Array.EdgeFlag.StrideB,
-		       ctx->Array.EdgeFlag.Type,
-		       start, n );
    }
 
-   if (required & VERT_RGBA) {
-      _math_trans_4chan( IM->Color + IM->Start,
-		       ctx->Array.Color.Ptr,
-		       ctx->Array.Color.StrideB,
-		       ctx->Array.Color.Type,
-		       ctx->Array.Color.Size,
-		       start, n );
+   /* odd-ball vertex attributes */
+   {
+      _tnl_import_index( ctx, 0, 0 );
+      tmp->Index.count = VB->Count;
+      VB->AttribPtr[_TNL_ATTRIB_INDEX] = &tmp->Index;
    }
 
-   if (required & VERT_SPEC_RGB) {
-      _math_trans_4chan( IM->SecondaryColor + IM->Start,
-			 ctx->Array.SecondaryColor.Ptr,
-			 ctx->Array.SecondaryColor.StrideB,
-			 ctx->Array.SecondaryColor.Type,
-			 ctx->Array.SecondaryColor.Size,
-			 start, n );
+   {
+      _tnl_import_edgeflag( ctx, GL_TRUE, sizeof(GLboolean) );
+      VB->EdgeFlag = (GLboolean *) tmp->EdgeFlag;
    }
 
-   if (required & VERT_FOG_COORD) {
-      _math_trans_1f( IM->FogCoord + IM->Start,
-		      ctx->Array.FogCoord.Ptr,
-		      ctx->Array.FogCoord.StrideB,
-		      ctx->Array.FogCoord.Type,
-		      start, n );
+   /* These are constant & could be precalculated:
+    */
+   for (i = _TNL_ATTRIB_MAT_FRONT_AMBIENT; i < _TNL_ATTRIB_INDEX; i++) {
+      _tnl_constant_attrib(tnl, tmp, i);
    }
 
-   if (required & VERT_INDEX) {
-      _math_trans_1ui( IM->Index + IM->Start,
-		       ctx->Array.Index.Ptr,
-		       ctx->Array.Index.StrideB,
-		       ctx->Array.Index.Type,
-		       start, n );
-   }
 
-   if (required & VERT_TEX_ANY) {
-      for (i = 0 ; i < ctx->Const.MaxTextureUnits ; i++) {
-	 if (required & VERT_TEX(i)) {
-	    _math_trans_4f( IM->TexCoord[i] + IM->Start,
-			    ctx->Array.TexCoord[i].Ptr,
-			    ctx->Array.TexCoord[i].StrideB,
-			    ctx->Array.TexCoord[i].Type,
-			    ctx->Array.TexCoord[i].Size,
-			    start, n );
-
-	    if (ctx->Array.TexCoord[i].Size == 4)
-	       IM->TexSize |= TEX_SIZE_4(i);
-	    else if (ctx->Array.TexCoord[i].Size == 3)
-	       IM->TexSize |= TEX_SIZE_3(i);
-	 }
-      }
+   /* Legacy pointers -- remove one day.
+    */
+   VB->ObjPtr = VB->AttribPtr[_TNL_ATTRIB_POS];
+   VB->NormalPtr = VB->AttribPtr[_TNL_ATTRIB_NORMAL];
+   VB->ColorPtr[0] = VB->AttribPtr[_TNL_ATTRIB_COLOR0];
+   VB->ColorPtr[1] = NULL;
+   VB->IndexPtr[0] = VB->AttribPtr[_TNL_ATTRIB_INDEX];
+   VB->IndexPtr[1] = NULL;
+   VB->SecondaryColorPtr[0] = VB->AttribPtr[_TNL_ATTRIB_COLOR1];
+   VB->SecondaryColorPtr[1] = NULL;
+   VB->FogCoordPtr = VB->AttribPtr[_TNL_ATTRIB_FOG];
+
+   for (i = 0; i < ctx->Const.MaxTextureCoordUnits; i++) {
+      VB->TexCoordPtr[i] = VB->AttribPtr[_TNL_ATTRIB_TEX0 + i];
    }
-
-   IM->Count = IM->Start + n;
-   IM->Flag[IM->Start] |= required;
-   for (i = IM->Start+1 ; i < IM->Count ; i++)
-      IM->Flag[i] = required;
 }