gallium: Set vertex state/buffers en-mass.

16 files changed, 205 insertions, 183 deletions

diff --git a/src/gallium/auxiliary/draw/draw_context.c b/src/gallium/auxiliary/draw/draw_context.c
index 81858e01cac..10bf9f54c10 100644
--- a/src/gallium/auxiliary/draw/draw_context.c
+++ b/src/gallium/auxiliary/draw/draw_context.c
@@ -233,24 +233,28 @@ void draw_set_viewport_state( struct draw_context *draw,
 
 
 void
-draw_set_vertex_buffer(struct draw_context *draw,
-                       unsigned attr,
-                       const struct pipe_vertex_buffer *buffer)
+draw_set_vertex_buffers(struct draw_context *draw,
+                        unsigned count,
+                        const struct pipe_vertex_buffer *buffers)
 {
+   assert(count <= PIPE_MAX_ATTRIBS);
+
    draw_do_flush( draw, DRAW_FLUSH_VERTEX_CACHE/*STATE_CHANGE*/ );
-   assert(attr < PIPE_MAX_ATTRIBS);
-   draw->vertex_buffer[attr] = *buffer;
+
+   memcpy(draw->vertex_buffer, buffers, count * sizeof(buffers[0]));
 }
 
 
 void
-draw_set_vertex_element(struct draw_context *draw,
-                        unsigned attr,
-                        const struct pipe_vertex_element *element)
+draw_set_vertex_elements(struct draw_context *draw,
+                         unsigned count,
+                         const struct pipe_vertex_element *elements)
 {
+   assert(count <= PIPE_MAX_ATTRIBS);
+
    draw_do_flush( draw, DRAW_FLUSH_VERTEX_CACHE/*STATE_CHANGE*/ );
-   assert(attr < PIPE_MAX_ATTRIBS);
-   draw->vertex_element[attr] = *element;
+
+   memcpy(draw->vertex_element, elements, count * sizeof(elements[0]));
 }
 
 
diff --git a/src/gallium/auxiliary/draw/draw_context.h b/src/gallium/auxiliary/draw/draw_context.h
index dae687e5906..84bae3bd78d 100644
--- a/src/gallium/auxiliary/draw/draw_context.h
+++ b/src/gallium/auxiliary/draw/draw_context.h
@@ -138,13 +138,13 @@ void draw_delete_vertex_shader(struct draw_context *draw,
  * Vertex data functions
  */
 
-void draw_set_vertex_buffer(struct draw_context *draw,
-			    unsigned attr,
-			    const struct pipe_vertex_buffer *buffer);
+void draw_set_vertex_buffers(struct draw_context *draw,
+                             unsigned count,
+                             const struct pipe_vertex_buffer *buffers);
 
-void draw_set_vertex_element(struct draw_context *draw,
-			     unsigned attr,
-			     const struct pipe_vertex_element *element);
+void draw_set_vertex_elements(struct draw_context *draw,
+			      unsigned count,
+                              const struct pipe_vertex_element *elements);
 
 void draw_set_mapped_element_buffer( struct draw_context *draw,
                                      unsigned eltSize, void *elements );
diff --git a/src/gallium/auxiliary/util/u_draw_quad.c b/src/gallium/auxiliary/util/u_draw_quad.c
index 37e85336091..e659edb0881 100644
--- a/src/gallium/auxiliary/util/u_draw_quad.c
+++ b/src/gallium/auxiliary/util/u_draw_quad.c
@@ -45,23 +45,25 @@ util_draw_vertex_buffer(struct pipe_context *pipe,
                         uint num_attribs)
 {
    struct pipe_vertex_buffer vbuffer;
-   struct pipe_vertex_element velement;
+   struct pipe_vertex_element velements[PIPE_MAX_ATTRIBS];
    uint i;
 
+   assert(num_attribs <= PIPE_MAX_ATTRIBS);
+
    /* tell pipe about the vertex buffer */
    vbuffer.buffer = vbuf;
    vbuffer.pitch = num_attribs * 4 * sizeof(float);  /* vertex size */
    vbuffer.buffer_offset = 0;
-   pipe->set_vertex_buffer(pipe, 0, &vbuffer);
+   pipe->set_vertex_buffers(pipe, 1, &vbuffer);
 
    /* tell pipe about the vertex attributes */
    for (i = 0; i < num_attribs; i++) {
-      velement.src_offset = i * 4 * sizeof(float);
-      velement.vertex_buffer_index = 0;
-      velement.src_format = PIPE_FORMAT_R32G32B32A32_FLOAT;
-      velement.nr_components = 4;
-      pipe->set_vertex_element(pipe, i, &velement);
+      velements[i].src_offset = i * 4 * sizeof(float);
+      velements[i].vertex_buffer_index = 0;
+      velements[i].src_format = PIPE_FORMAT_R32G32B32A32_FLOAT;
+      velements[i].nr_components = 4;
    }
+   pipe->set_vertex_elements(pipe, num_attribs, velements);
 
    /* draw */
    pipe->draw_arrays(pipe, prim_type, 0, num_verts);
diff --git a/src/gallium/drivers/cell/ppu/cell_context.c b/src/gallium/drivers/cell/ppu/cell_context.c
index ccbbd1d331c..12eb5aa2547 100644
--- a/src/gallium/drivers/cell/ppu/cell_context.c
+++ b/src/gallium/drivers/cell/ppu/cell_context.c
@@ -103,8 +103,8 @@ cell_create_context(struct pipe_screen *screen,
    cell->pipe.destroy = cell_destroy_context;
 
    /* state setters */
-   cell->pipe.set_vertex_buffer = cell_set_vertex_buffer;
-   cell->pipe.set_vertex_element = cell_set_vertex_element;
+   cell->pipe.set_vertex_buffers = cell_set_vertex_buffers;
+   cell->pipe.set_vertex_elements = cell_set_vertex_elements;
 
    cell->pipe.draw_arrays = cell_draw_arrays;
    cell->pipe.draw_elements = cell_draw_elements;
diff --git a/src/gallium/drivers/cell/ppu/cell_state.h b/src/gallium/drivers/cell/ppu/cell_state.h
index 31ce505e211..82580ea35ab 100644
--- a/src/gallium/drivers/cell/ppu/cell_state.h
+++ b/src/gallium/drivers/cell/ppu/cell_state.h
@@ -48,13 +48,13 @@
 #define CELL_NEW_VERTEX_INFO   0x8000
 
 
-void cell_set_vertex_element(struct pipe_context *,
-                             unsigned index,
-                             const struct pipe_vertex_element *);
+void cell_set_vertex_elements(struct pipe_context *,
+                              unsigned count,
+                              const struct pipe_vertex_element *);
 
-void cell_set_vertex_buffer(struct pipe_context *,
-                            unsigned index,
-                            const struct pipe_vertex_buffer *);
+void cell_set_vertex_buffers(struct pipe_context *,
+                             unsigned count,
+                             const struct pipe_vertex_buffer *);
 
 void cell_update_derived( struct cell_context *softpipe );
 
diff --git a/src/gallium/drivers/cell/ppu/cell_state_vertex.c b/src/gallium/drivers/cell/ppu/cell_state_vertex.c
index 37d25fb3578..6c83b8dc722 100644
--- a/src/gallium/drivers/cell/ppu/cell_state_vertex.c
+++ b/src/gallium/drivers/cell/ppu/cell_state_vertex.c
@@ -36,28 +36,34 @@
 
 
 void
-cell_set_vertex_element(struct pipe_context *pipe,
-                            unsigned index,
-                            const struct pipe_vertex_element *attrib)
+cell_set_vertex_elements(struct pipe_context *pipe,
+                         unsigned count,
+                         const struct pipe_vertex_element *elements)
 {
    struct cell_context *cell = cell_context(pipe);
-   assert(index < PIPE_MAX_ATTRIBS);
-   cell->vertex_element[index] = *attrib; /* struct copy */
+
+   assert(count <= PIPE_MAX_ATTRIBS);
+
+   memcpy(cell->vertex_element, elements, count * sizeof(elements[0]));
+
    cell->dirty |= CELL_NEW_VERTEX;
 
-   draw_set_vertex_element(cell->draw, index, attrib);
+   draw_set_vertex_elements(cell->draw, count, elements);
 }
 
 
 void
-cell_set_vertex_buffer(struct pipe_context *pipe,
-                           unsigned index,
-                           const struct pipe_vertex_buffer *buffer)
+cell_set_vertex_buffers(struct pipe_context *pipe,
+                        unsigned count,
+                        const struct pipe_vertex_buffer *buffers)
 {
    struct cell_context *cell = cell_context(pipe);
-   assert(index < PIPE_MAX_ATTRIBS);
-   cell->vertex_buffer[index] = *buffer; /* struct copy */
+
+   assert(count <= PIPE_MAX_ATTRIBS);
+
+   memcpy(cell->vertex_buffer, buffers, count * sizeof(buffers[0]));
+
    cell->dirty |= CELL_NEW_VERTEX;
 
-   draw_set_vertex_buffer(cell->draw, index, buffer);
+   draw_set_vertex_buffers(cell->draw, count, buffers);
 }
diff --git a/src/gallium/drivers/failover/fo_context.h b/src/gallium/drivers/failover/fo_context.h
index 4afe10c4b86..c6409fe1e1c 100644
--- a/src/gallium/drivers/failover/fo_context.h
+++ b/src/gallium/drivers/failover/fo_context.h
@@ -84,15 +84,16 @@ struct failover_context {
    struct pipe_scissor_state scissor;
    struct pipe_texture *texture[PIPE_MAX_SAMPLERS];
    struct pipe_viewport_state viewport;
-   struct pipe_vertex_buffer vertex_buffer[PIPE_MAX_ATTRIBS];
-   struct pipe_vertex_element vertex_element[PIPE_MAX_ATTRIBS];
+   struct pipe_vertex_buffer vertex_buffers[PIPE_MAX_ATTRIBS];
+   struct pipe_vertex_element vertex_elements[PIPE_MAX_ATTRIBS];
+
+   uint num_vertex_buffers;
+   uint num_vertex_elements;
 
    void *sw_sampler_state[PIPE_MAX_SAMPLERS];
    void *hw_sampler_state[PIPE_MAX_SAMPLERS];
 
    unsigned dirty;
-   unsigned dirty_vertex_buffer;
-   unsigned dirty_vertex_element;
 
    unsigned num_samplers;
    unsigned num_textures;
diff --git a/src/gallium/drivers/failover/fo_state.c b/src/gallium/drivers/failover/fo_state.c
index 11eec2714eb..6a797066322 100644
--- a/src/gallium/drivers/failover/fo_state.c
+++ b/src/gallium/drivers/failover/fo_state.c
@@ -402,32 +402,35 @@ failover_set_viewport_state( struct pipe_context *pipe,
 
 
 static void
-failover_set_vertex_buffer(struct pipe_context *pipe,
-			   unsigned unit,
-                           const struct pipe_vertex_buffer *vertex_buffer)
+failover_set_vertex_buffers(struct pipe_context *pipe,
+                            unsigned count,
+                            const struct pipe_vertex_buffer *vertex_buffers)
 {
    struct failover_context *failover = failover_context(pipe);
 
-   failover->vertex_buffer[unit] = *vertex_buffer;
+   memcpy(failover->vertex_buffers, vertex_buffers,
+          count * sizeof(vertex_buffers[0]));
    failover->dirty |= FO_NEW_VERTEX_BUFFER;
-   failover->dirty_vertex_buffer |= (1<<unit);
-   failover->sw->set_vertex_buffer( failover->sw, unit, vertex_buffer );
-   failover->hw->set_vertex_buffer( failover->hw, unit, vertex_buffer );
+   failover->num_vertex_buffers = count;
+   failover->sw->set_vertex_buffers( failover->sw, count, vertex_buffers );
+   failover->hw->set_vertex_buffers( failover->hw, count, vertex_buffers );
 }
 
 
 static void
-failover_set_vertex_element(struct pipe_context *pipe,
-			    unsigned unit,
-			    const struct pipe_vertex_element *vertex_element)
+failover_set_vertex_elements(struct pipe_context *pipe,
+                             unsigned count,
+                             const struct pipe_vertex_element *vertex_elements)
 {
    struct failover_context *failover = failover_context(pipe);
 
-   failover->vertex_element[unit] = *vertex_element;
+   memcpy(failover->vertex_elements, vertex_elements,
+          count * sizeof(vertex_elements[0]));
+
    failover->dirty |= FO_NEW_VERTEX_ELEMENT;
-   failover->dirty_vertex_element |= (1<<unit);
-   failover->sw->set_vertex_element( failover->sw, unit, vertex_element );
-   failover->hw->set_vertex_element( failover->hw, unit, vertex_element );
+   failover->num_vertex_elements = count;
+   failover->sw->set_vertex_elements( failover->sw, count, vertex_elements );
+   failover->hw->set_vertex_elements( failover->hw, count, vertex_elements );
 }
 
 void
@@ -474,7 +477,7 @@ failover_init_state_functions( struct failover_context *failover )
    failover->pipe.set_scissor_state = failover_set_scissor_state;
    failover->pipe.set_sampler_textures = failover_set_sampler_textures;
    failover->pipe.set_viewport_state = failover_set_viewport_state;
-   failover->pipe.set_vertex_buffer = failover_set_vertex_buffer;
-   failover->pipe.set_vertex_element = failover_set_vertex_element;
+   failover->pipe.set_vertex_buffers = failover_set_vertex_buffers;
+   failover->pipe.set_vertex_elements = failover_set_vertex_elements;
    failover->pipe.set_constant_buffer = failover_set_constant_buffer;
 }
diff --git a/src/gallium/drivers/failover/fo_state_emit.c b/src/gallium/drivers/failover/fo_state_emit.c
index bb89f925e93..bd4fce9d209 100644
--- a/src/gallium/drivers/failover/fo_state_emit.c
+++ b/src/gallium/drivers/failover/fo_state_emit.c
@@ -53,8 +53,6 @@
 void
 failover_state_emit( struct failover_context *failover )
 {
-   unsigned i;
-
    if (failover->dirty & FO_NEW_BLEND)
       failover->sw->bind_blend_state( failover->sw,
                                       failover->blend->sw_state );
@@ -104,24 +102,16 @@ failover_state_emit( struct failover_context *failover )
    }
 
    if (failover->dirty & FO_NEW_VERTEX_BUFFER) {
-      for (i = 0; i < PIPE_MAX_ATTRIBS; i++) {
-	 if (failover->dirty_vertex_buffer & (1<<i)) {
-	    failover->sw->set_vertex_buffer( failover->sw, i, 
-					     &failover->vertex_buffer[i] );
-	 }
-      }
+      failover->sw->set_vertex_buffers( failover->sw,
+                                        failover->num_vertex_buffers,
+                                        failover->vertex_buffers );
    }
 
    if (failover->dirty & FO_NEW_VERTEX_ELEMENT) {
-      for (i = 0; i < PIPE_MAX_ATTRIBS; i++) {
-	 if (failover->dirty_vertex_element & (1<<i)) {
-	    failover->sw->set_vertex_element( failover->sw, i, 
-					      &failover->vertex_element[i] );
-	 }
-      }
+      failover->sw->set_vertex_elements( failover->sw,
+                                         failover->num_vertex_elements,
+                                         failover->vertex_elements );
    }
 
    failover->dirty = 0;
-   failover->dirty_vertex_element = 0;
-   failover->dirty_vertex_buffer = 0;
 }
diff --git a/src/gallium/drivers/i915simple/i915_state.c b/src/gallium/drivers/i915simple/i915_state.c
index 1cec36e206d..4404bc45901 100644
--- a/src/gallium/drivers/i915simple/i915_state.c
+++ b/src/gallium/drivers/i915simple/i915_state.c
@@ -687,23 +687,24 @@ static void i915_delete_rasterizer_state(struct pipe_context *pipe,
    FREE(raster);
 }
 
-static void i915_set_vertex_buffer( struct pipe_context *pipe,
-                                    unsigned index,
-                                    const struct pipe_vertex_buffer *buffer )
+static void i915_set_vertex_buffers(struct pipe_context *pipe,
+                                    unsigned count,
+                                    const struct pipe_vertex_buffer *buffers)
 {
    struct i915_context *i915 = i915_context(pipe);
-   i915->vertex_buffer[index] = *buffer;
+
+   memcpy(i915->vertex_buffer, buffers, count * sizeof(buffers[0]));
    /* pass-through to draw module */
-   draw_set_vertex_buffer(i915->draw, index, buffer);
+   draw_set_vertex_buffers(i915->draw, count, buffers);
 }
 
-static void i915_set_vertex_element( struct pipe_context *pipe,
-                                     unsigned index,
-                                     const struct pipe_vertex_element *element)
+static void i915_set_vertex_elements(struct pipe_context *pipe,
+                                     unsigned count,
+                                     const struct pipe_vertex_element *elements)
 {
    struct i915_context *i915 = i915_context(pipe);
    /* pass-through to draw module */
-   draw_set_vertex_element(i915->draw, index, element);
+   draw_set_vertex_elements(i915->draw, count, elements);
 }
 
 
@@ -742,6 +743,6 @@ i915_init_state_functions( struct i915_context *i915 )
    i915->pipe.set_scissor_state = i915_set_scissor_state;
    i915->pipe.set_sampler_textures = i915_set_sampler_textures;
    i915->pipe.set_viewport_state = i915_set_viewport_state;
-   i915->pipe.set_vertex_buffer = i915_set_vertex_buffer;
-   i915->pipe.set_vertex_element = i915_set_vertex_element;
+   i915->pipe.set_vertex_buffers = i915_set_vertex_buffers;
+   i915->pipe.set_vertex_elements = i915_set_vertex_elements;
 }
diff --git a/src/gallium/drivers/i965simple/brw_state.c b/src/gallium/drivers/i965simple/brw_state.c
index 0d04a8a5947..376f1487b29 100644
--- a/src/gallium/drivers/i965simple/brw_state.c
+++ b/src/gallium/drivers/i965simple/brw_state.c
@@ -277,45 +277,49 @@ static void brw_set_viewport_state( struct pipe_context *pipe,
 }

 

 

-static void brw_set_vertex_buffer( struct pipe_context *pipe,

-				   unsigned index,

-				   const struct pipe_vertex_buffer *buffer )

+static void brw_set_vertex_buffers(struct pipe_context *pipe,

+				   unsigned count,

+				   const struct pipe_vertex_buffer *buffers)

 {

    struct brw_context *brw = brw_context(pipe);

-   brw->vb.vbo_array[index] = buffer;

+   memcpy(brw->vb.vbo_array, buffers, count * sizeof(buffers[0]));

 }

 

-static void brw_set_vertex_element(struct pipe_context *pipe,

-                                   unsigned index,

-                                   const struct pipe_vertex_element *element)

+static void brw_set_vertex_elements(struct pipe_context *pipe,

+                                    unsigned count,

+                                    const struct pipe_vertex_element *elements)

 {

    /* flush ? */

    struct brw_context *brw = brw_context(pipe);

+   uint i;

 

-   assert(index < PIPE_MAX_ATTRIBS);

-   struct brw_vertex_element_state el;

-   memset(&el, 0, sizeof(el));

+   assert(count <= PIPE_MAX_ATTRIBS);

 

-   el.ve0.src_offset = element->src_offset;

-   el.ve0.src_format = brw_translate_surface_format(element->src_format);

-   el.ve0.valid = 1;

-   el.ve0.vertex_buffer_index = element->vertex_buffer_index;

+   for (i = 0; i < count; i++) {

+      struct brw_vertex_element_state el;

+      memset(&el, 0, sizeof(el));

 

-   el.ve1.dst_offset   = index * 4;

+      el.ve0.src_offset = elements[i].src_offset;

+      el.ve0.src_format = brw_translate_surface_format(elements[i].src_format);

+      el.ve0.valid = 1;

+      el.ve0.vertex_buffer_index = elements[i].vertex_buffer_index;

 

-   el.ve1.vfcomponent3 = BRW_VFCOMPONENT_STORE_SRC;

-   el.ve1.vfcomponent2 = BRW_VFCOMPONENT_STORE_SRC;

-   el.ve1.vfcomponent1 = BRW_VFCOMPONENT_STORE_SRC;

-   el.ve1.vfcomponent0 = BRW_VFCOMPONENT_STORE_SRC;

+      el.ve1.dst_offset   = i * 4;

 

-   switch (element->nr_components) {

-   case 1: el.ve1.vfcomponent1 = BRW_VFCOMPONENT_STORE_0;

-   case 2: el.ve1.vfcomponent2 = BRW_VFCOMPONENT_STORE_0;

-   case 3: el.ve1.vfcomponent3 = BRW_VFCOMPONENT_STORE_1_FLT;

-      break;

-   }

+      el.ve1.vfcomponent3 = BRW_VFCOMPONENT_STORE_SRC;

+      el.ve1.vfcomponent2 = BRW_VFCOMPONENT_STORE_SRC;

+      el.ve1.vfcomponent1 = BRW_VFCOMPONENT_STORE_SRC;

+      el.ve1.vfcomponent0 = BRW_VFCOMPONENT_STORE_SRC;

 

-   brw->vb.inputs[index] = el;

+      switch (elements[i].nr_components) {

+      case 1: el.ve1.vfcomponent1 = BRW_VFCOMPONENT_STORE_0;

+      case 2: el.ve1.vfcomponent2 = BRW_VFCOMPONENT_STORE_0;

+      case 3: el.ve1.vfcomponent3 = BRW_VFCOMPONENT_STORE_1_FLT;

+         break;

+      }

+

+      brw->vb.inputs[i] = el;

+   }

 }

 

 

@@ -457,6 +461,6 @@ brw_init_state_functions( struct brw_context *brw )
    brw->pipe.set_scissor_state = brw_set_scissor_state;

    brw->pipe.set_sampler_textures = brw_set_sampler_textures;

    brw->pipe.set_viewport_state = brw_set_viewport_state;

-   brw->pipe.set_vertex_buffer = brw_set_vertex_buffer;

-   brw->pipe.set_vertex_element = brw_set_vertex_element;

+   brw->pipe.set_vertex_buffers = brw_set_vertex_buffers;

+   brw->pipe.set_vertex_elements = brw_set_vertex_elements;

 }

diff --git a/src/gallium/drivers/softpipe/sp_context.c b/src/gallium/drivers/softpipe/sp_context.c
index 16fb06f176f..e298ed37c36 100644
--- a/src/gallium/drivers/softpipe/sp_context.c
+++ b/src/gallium/drivers/softpipe/sp_context.c
@@ -174,8 +174,8 @@ softpipe_create( struct pipe_screen *screen,
    softpipe->pipe.set_sampler_textures = softpipe_set_sampler_textures;
    softpipe->pipe.set_viewport_state = softpipe_set_viewport_state;
 
-   softpipe->pipe.set_vertex_buffer = softpipe_set_vertex_buffer;
-   softpipe->pipe.set_vertex_element = softpipe_set_vertex_element;
+   softpipe->pipe.set_vertex_buffers = softpipe_set_vertex_buffers;
+   softpipe->pipe.set_vertex_elements = softpipe_set_vertex_elements;
 
    softpipe->pipe.draw_arrays = softpipe_draw_arrays;
    softpipe->pipe.draw_elements = softpipe_draw_elements;
diff --git a/src/gallium/drivers/softpipe/sp_state.h b/src/gallium/drivers/softpipe/sp_state.h
index 0bb1095aece..6e6501f5bc4 100644
--- a/src/gallium/drivers/softpipe/sp_state.h
+++ b/src/gallium/drivers/softpipe/sp_state.h
@@ -151,13 +151,13 @@ void softpipe_set_sampler_textures( struct pipe_context *,
 void softpipe_set_viewport_state( struct pipe_context *,
                                   const struct pipe_viewport_state * );
 
-void softpipe_set_vertex_element(struct pipe_context *,
-                                 unsigned index,
-                                 const struct pipe_vertex_element *);
+void softpipe_set_vertex_elements(struct pipe_context *,
+                                  unsigned count,
+                                  const struct pipe_vertex_element *);
 
-void softpipe_set_vertex_buffer(struct pipe_context *,
-                                unsigned index,
-                                const struct pipe_vertex_buffer *);
+void softpipe_set_vertex_buffers(struct pipe_context *,
+                                 unsigned count,
+                                 const struct pipe_vertex_buffer *);
 
 
 void softpipe_update_derived( struct softpipe_context *softpipe );
diff --git a/src/gallium/drivers/softpipe/sp_state_vertex.c b/src/gallium/drivers/softpipe/sp_state_vertex.c
index c054e76d9be..e0230e16a4e 100644
--- a/src/gallium/drivers/softpipe/sp_state_vertex.c
+++ b/src/gallium/drivers/softpipe/sp_state_vertex.c
@@ -37,28 +37,35 @@
 
 
 void
-softpipe_set_vertex_element(struct pipe_context *pipe,
-                            unsigned index,
-                            const struct pipe_vertex_element *attrib)
+softpipe_set_vertex_elements(struct pipe_context *pipe,
+                             unsigned count,
+                             const struct pipe_vertex_element *attribs)
 {
    struct softpipe_context *softpipe = softpipe_context(pipe);
-   assert(index < PIPE_MAX_ATTRIBS);
-   softpipe->vertex_element[index] = *attrib; /* struct copy */
+
+   assert(count <= PIPE_MAX_ATTRIBS);
+
+   memcpy(softpipe->vertex_element, attribs,
+          count * sizeof(struct pipe_vertex_element));
+
    softpipe->dirty |= SP_NEW_VERTEX;
 
-   draw_set_vertex_element(softpipe->draw, index, attrib);
+   draw_set_vertex_elements(softpipe->draw, count, attribs);
 }
 
 
 void
-softpipe_set_vertex_buffer(struct pipe_context *pipe,
-                           unsigned index,
-                           const struct pipe_vertex_buffer *buffer)
+softpipe_set_vertex_buffers(struct pipe_context *pipe,
+                            unsigned count,
+                            const struct pipe_vertex_buffer *buffers)
 {
    struct softpipe_context *softpipe = softpipe_context(pipe);
-   assert(index < PIPE_MAX_ATTRIBS);
-   softpipe->vertex_buffer[index] = *buffer; /* struct copy */
+
+   assert(count <= PIPE_MAX_ATTRIBS);
+
+   memcpy(softpipe->vertex_buffer, buffers, count * sizeof(buffers[0]));
+
    softpipe->dirty |= SP_NEW_VERTEX;
 
-   draw_set_vertex_buffer(softpipe->draw, index, buffer);
+   draw_set_vertex_buffers(softpipe->draw, count, buffers);
 }
diff --git a/src/gallium/include/pipe/p_context.h b/src/gallium/include/pipe/p_context.h
index 2d063e3f9e4..324f70185af 100644
--- a/src/gallium/include/pipe/p_context.h
+++ b/src/gallium/include/pipe/p_context.h
@@ -155,13 +155,13 @@ struct pipe_context {
                                  unsigned num_textures,
                                  struct pipe_texture ** );
 
-   void (*set_vertex_buffer)( struct pipe_context *,
-                              unsigned index,
-                              const struct pipe_vertex_buffer * );
+   void (*set_vertex_buffers)( struct pipe_context *,
+                               unsigned num_buffers,
+                               const struct pipe_vertex_buffer * );
 
-   void (*set_vertex_element)( struct pipe_context *,
-			       unsigned index,
-			       const struct pipe_vertex_element * );
+   void (*set_vertex_elements)( struct pipe_context *,
+                                unsigned num_elements,
+                                const struct pipe_vertex_element * );
    /*@}*/
 
 
diff --git a/src/mesa/state_tracker/st_draw.c b/src/mesa/state_tracker/st_draw.c
index 4aca3311b7b..f0f62246ddc 100644
--- a/src/mesa/state_tracker/st_draw.c
+++ b/src/mesa/state_tracker/st_draw.c
@@ -210,6 +210,7 @@ st_draw_vbo(GLcontext *ctx,
    const struct pipe_shader_state *vs;
    struct pipe_vertex_buffer vbuffer[PIPE_MAX_SHADER_INPUTS];
    GLuint attr;
+   struct pipe_vertex_element velements[PIPE_MAX_ATTRIBS];
 
    /* sanity check for pointer arithmetic below */
    assert(sizeof(arrays[0]->Ptr[0]) == 1);
@@ -226,7 +227,6 @@ st_draw_vbo(GLcontext *ctx,
    for (attr = 0; attr < vp->num_inputs; attr++) {
       const GLuint mesaAttr = vp->index_to_input[attr];
       struct gl_buffer_object *bufobj = arrays[mesaAttr]->BufferObj;
-      struct pipe_vertex_element velement;
 
       if (bufobj && bufobj->Name) {
          /* Attribute data is in a VBO.
@@ -239,8 +239,8 @@ st_draw_vbo(GLcontext *ctx,
          vbuffer[attr].buffer = NULL;
          pipe_buffer_reference(winsys, &vbuffer[attr].buffer, stobj->buffer);
          vbuffer[attr].buffer_offset = (unsigned) arrays[0]->Ptr;/* in bytes */
-         velement.src_offset = arrays[mesaAttr]->Ptr - arrays[0]->Ptr;
-         assert(velement.src_offset <= 2048); /* 11-bit field */
+         velements[attr].src_offset = arrays[mesaAttr]->Ptr - arrays[0]->Ptr;
+         assert(velements[attr].src_offset <= 2048); /* 11-bit field */
       }
       else {
          /* attribute data is in user-space memory, not a VBO */
@@ -259,24 +259,24 @@ st_draw_vbo(GLcontext *ctx,
                                          (void *) arrays[mesaAttr]->Ptr,
                                          bytes);
          vbuffer[attr].buffer_offset = 0;
-         velement.src_offset = 0;
+         velements[attr].src_offset = 0;
       }
 
       /* common-case setup */
       vbuffer[attr].pitch = arrays[mesaAttr]->StrideB; /* in bytes */
       vbuffer[attr].max_index = max_index;
-      velement.vertex_buffer_index = attr;
-      velement.nr_components = arrays[mesaAttr]->Size;
-      velement.src_format = pipe_vertex_format(arrays[mesaAttr]->Type,
-                                               arrays[mesaAttr]->Size,
-                                               arrays[mesaAttr]->Normalized);
-      assert(velement.src_format);
-
-      /* tell pipe about this attribute */
-      pipe->set_vertex_buffer(pipe, attr, &vbuffer[attr]);
-      pipe->set_vertex_element(pipe, attr, &velement);
+      velements[attr].vertex_buffer_index = attr;
+      velements[attr].nr_components = arrays[mesaAttr]->Size;
+      velements[attr].src_format
+         = pipe_vertex_format(arrays[mesaAttr]->Type,
+                              arrays[mesaAttr]->Size,
+                              arrays[mesaAttr]->Normalized);
+      assert(velements[attr].src_format);
    }
 
+   pipe->set_vertex_buffers(pipe, vp->num_inputs, vbuffer);
+   pipe->set_vertex_elements(pipe, vp->num_inputs, velements);
+
 
    /* do actual drawing */
    if (ib) {
@@ -336,8 +336,8 @@ st_draw_vbo(GLcontext *ctx,
    for (attr = 0; attr < vp->num_inputs; attr++) {
       pipe_buffer_reference(winsys, &vbuffer[attr].buffer, NULL);
       assert(!vbuffer[attr].buffer);
-      pipe->set_vertex_buffer(pipe, attr, &vbuffer[attr]);
    }
+   pipe->set_vertex_buffers(pipe, vp->num_inputs, vbuffer);
 }
 
 
@@ -362,7 +362,7 @@ st_draw_vertices(GLcontext *ctx, unsigned prim,
    struct pipe_context *pipe = ctx->st->pipe;
    struct pipe_buffer *vbuf;
    struct pipe_vertex_buffer vbuffer;
-   struct pipe_vertex_element velement;
+   struct pipe_vertex_element velements[PIPE_MAX_ATTRIBS];
    unsigned i;
 
    assert(numAttribs > 0);
@@ -393,16 +393,16 @@ st_draw_vertices(GLcontext *ctx, unsigned prim,
    vbuffer.buffer = vbuf;
    vbuffer.pitch = numAttribs * 4 * sizeof(float);  /* vertex size */
    vbuffer.buffer_offset = 0;
-   pipe->set_vertex_buffer(pipe, 0, &vbuffer);
+   pipe->set_vertex_buffers(pipe, 1, &vbuffer);
 
    /* tell pipe about the vertex attributes */
    for (i = 0; i < numAttribs; i++) {
-      velement.src_offset = i * 4 * sizeof(GLfloat);
-      velement.vertex_buffer_index = 0;
-      velement.src_format = PIPE_FORMAT_R32G32B32A32_FLOAT;
-      velement.nr_components = 4;
-      pipe->set_vertex_element(pipe, i, &velement);
+      velements[i].src_offset = i * 4 * sizeof(GLfloat);
+      velements[i].vertex_buffer_index = 0;
+      velements[i].src_format = PIPE_FORMAT_R32G32B32A32_FLOAT;
+      velements[i].nr_components = 4;
    }
+   pipe->set_vertex_elements(pipe, numAttribs, velements);
 
    /* draw */
    pipe->draw_arrays(pipe, prim, 0, numVertex);
@@ -470,7 +470,8 @@ st_feedback_draw_vbo(GLcontext *ctx,
    const struct st_vertex_program *vp;
    const struct pipe_shader_state *vs;
    struct pipe_buffer *index_buffer_handle = 0;
-   struct pipe_vertex_buffer vbuffer[PIPE_MAX_SHADER_INPUTS];
+   struct pipe_vertex_buffer vbuffers[PIPE_MAX_SHADER_INPUTS];
+   struct pipe_vertex_element velements[PIPE_MAX_ATTRIBS];
    GLuint attr, i;
    ubyte *mapped_constants;
 
@@ -505,7 +506,6 @@ st_feedback_draw_vbo(GLcontext *ctx,
    for (attr = 0; attr < vp->num_inputs; attr++) {
       const GLuint mesaAttr = vp->index_to_input[attr];
       struct gl_buffer_object *bufobj = arrays[mesaAttr]->BufferObj;
-      struct pipe_vertex_element velement;
       void *map;
 
       if (bufobj && bufobj->Name) {
@@ -516,10 +516,10 @@ st_feedback_draw_vbo(GLcontext *ctx,
          struct st_buffer_object *stobj = st_buffer_object(bufobj);
          assert(stobj->buffer);
 
-         vbuffer[attr].buffer = NULL;
-         pipe_buffer_reference(winsys, &vbuffer[attr].buffer, stobj->buffer);
-         vbuffer[attr].buffer_offset = (unsigned) arrays[0]->Ptr;/* in bytes */
-         velement.src_offset = arrays[mesaAttr]->Ptr - arrays[0]->Ptr;
+         vbuffers[attr].buffer = NULL;
+         pipe_buffer_reference(winsys, &vbuffers[attr].buffer, stobj->buffer);
+         vbuffers[attr].buffer_offset = (unsigned) arrays[0]->Ptr;/* in bytes */
+         velements[attr].src_offset = arrays[mesaAttr]->Ptr - arrays[0]->Ptr;
       }
       else {
          /* attribute data is in user-space memory, not a VBO */
@@ -528,35 +528,39 @@ st_feedback_draw_vbo(GLcontext *ctx,
                        * (max_index + 1));
 
          /* wrap user data */
-         vbuffer[attr].buffer
+         vbuffers[attr].buffer
             = winsys->user_buffer_create(winsys,
                                          (void *) arrays[mesaAttr]->Ptr,
                                          bytes);
-         vbuffer[attr].buffer_offset = 0;
-         velement.src_offset = 0;
+         vbuffers[attr].buffer_offset = 0;
+         velements[attr].src_offset = 0;
       }
 
       /* common-case setup */
-      vbuffer[attr].pitch = arrays[mesaAttr]->StrideB; /* in bytes */
-      vbuffer[attr].max_index = max_index;
-      velement.vertex_buffer_index = attr;
-      velement.nr_components = arrays[mesaAttr]->Size;
-      velement.src_format = pipe_vertex_format(arrays[mesaAttr]->Type,
+      vbuffers[attr].pitch = arrays[mesaAttr]->StrideB; /* in bytes */
+      vbuffers[attr].max_index = max_index;
+      velements[attr].vertex_buffer_index = attr;
+      velements[attr].nr_components = arrays[mesaAttr]->Size;
+      velements[attr].src_format = pipe_vertex_format(arrays[mesaAttr]->Type,
                                                arrays[mesaAttr]->Size,
                                                arrays[mesaAttr]->Normalized);
-      assert(velement.src_format);
+      assert(velements[attr].src_format);
 
       /* tell draw about this attribute */
+#if 0
       draw_set_vertex_buffer(draw, attr, &vbuffer[attr]);
-      draw_set_vertex_element(draw, attr, &velement);
+#endif
 
       /* map the attrib buffer */
       map = pipe->winsys->buffer_map(pipe->winsys,
-                                     vbuffer[attr].buffer,
+                                     vbuffers[attr].buffer,
                                      PIPE_BUFFER_USAGE_CPU_READ);
       draw_set_mapped_vertex_buffer(draw, attr, map);
    }
 
+   draw_set_vertex_buffers(draw, vp->num_inputs, vbuffers);
+   draw_set_vertex_elements(draw, vp->num_inputs, velements);
+
    if (ib) {
       unsigned indexSize;
       struct gl_buffer_object *bufobj = ib->obj;