Merge branch 'softpipe_0_1_branch' of git+ssh://[email protected]/git/mesa/mesa into softpipe_0_1_branch

44 files changed, 1268 insertions, 1119 deletions

diff --git a/src/mesa/pipe/draw/draw_context.c b/src/mesa/pipe/draw/draw_context.c
index a97f4883873..4335b47e094 100644
--- a/src/mesa/pipe/draw/draw_context.c
+++ b/src/mesa/pipe/draw/draw_context.c
@@ -59,6 +59,16 @@ struct draw_context *draw_create( void )
 
    draw->vf = vf_create( GL_TRUE );
 
+   /* Statically allocate maximum sized vertices for the cache - could be cleverer...
+    */
+   {
+      int i;
+      char *tmp = malloc(Elements(draw->vcache.vertex) * MAX_VERTEX_SIZE);
+
+      for (i = 0; i < Elements(draw->vcache.vertex); i++)
+	 draw->vcache.vertex[i] = (struct vertex_header *)(tmp + i * MAX_VERTEX_SIZE);
+   }
+
    return draw;
 }
 
@@ -70,6 +80,7 @@ void draw_destroy( struct draw_context *draw )
 
    vf_destroy( draw->vf );
 
+   FREE( draw->vcache.vertex[0] ); /* Frees all the vertices. */
    FREE( draw );
 }
 
diff --git a/src/mesa/pipe/draw/draw_private.h b/src/mesa/pipe/draw/draw_private.h
index 3dfaa0581db..597393afdc9 100644
--- a/src/mesa/pipe/draw/draw_private.h
+++ b/src/mesa/pipe/draw/draw_private.h
@@ -61,12 +61,18 @@ struct vertex_header {
    GLfloat data[][4];		/* Note variable size */
 };
 
+#define MAX_VERTEX_SIZE ((2 + FRAG_ATTRIB_MAX) * 4 * sizeof(GLfloat))
+
+
 
 /**
  * Basic info for a point/line/triangle primitive.
  */
 struct prim_header {
    GLfloat det;                 /**< front/back face determinant */
+   GLuint reset_line_stipple:1;
+   GLuint edgeflags:3;
+   GLuint pad:28;
    struct vertex_header *v[3];  /**< 1 to 3 vertex pointers */
 };
 
@@ -103,6 +109,12 @@ struct draw_stage
 };
 
 
+#define PRIM_QUEUE_LENGTH      16
+#define VCACHE_SIZE            32
+#define VCACHE_OVERFLOW        4
+#define VS_QUEUE_LENGTH        (VCACHE_SIZE + VCACHE_OVERFLOW + 1)	/* can never fill up */
+
+
 /**
  * Private context for the drawing module.
  */
@@ -141,7 +153,45 @@ struct draw_context
    GLuint nr_vertices;
    GLboolean in_vb;
 
+   void *elts;
+
+   struct vertex_header *(*get_vertex)( struct draw_context *draw,
+					GLuint i );
+
+   /* Post-tnl vertex cache:
+    */
+   struct {
+      GLuint referenced;
+      GLuint idx[VCACHE_SIZE + VCACHE_OVERFLOW];
+      struct vertex_header *vertex[VCACHE_SIZE + VCACHE_OVERFLOW];
+      GLuint overflow;
+   } vcache;
+
+   /* Vertex shader queue:
+    */
+   struct {
+      struct {
+	 GLuint elt;
+	 struct vertex_header *dest;
+      } queue[VS_QUEUE_LENGTH];
+      GLuint queue_nr;
+   } vs;
+
+   /* Prim pipeline queue:
+    */
+   struct {
+
+      /* Need to queue up primitives until their vertices have been
+       * transformed by a vs queue flush.
+       */
+      struct prim_header queue[PRIM_QUEUE_LENGTH];
+      GLuint queue_nr;
+   } pq;
+
+
+
    GLenum prim;   /**< GL_POINTS, GL_LINE_STRIP, GL_QUADS, etc */
+   unsigned reduced_prim;
 
    /* Helper for tnl:
     */
diff --git a/src/mesa/pipe/draw/draw_unfilled.c b/src/mesa/pipe/draw/draw_unfilled.c
index 05242d8d107..e0e486ebe6f 100644
--- a/src/mesa/pipe/draw/draw_unfilled.c
+++ b/src/mesa/pipe/draw/draw_unfilled.c
@@ -91,9 +91,9 @@ static void points( struct draw_stage *stage,
    struct vertex_header *v1 = header->v[1];
    struct vertex_header *v2 = header->v[2];
 
-   if (v0->edgeflag) point( stage, v0 );
-   if (v1->edgeflag) point( stage, v1 );
-   if (v2->edgeflag) point( stage, v2 );
+   if (header->edgeflags & 0x1) point( stage, v0 );
+   if (header->edgeflags & 0x2) point( stage, v1 );
+   if (header->edgeflags & 0x4) point( stage, v2 );
 }
 
 
@@ -104,9 +104,9 @@ static void lines( struct draw_stage *stage,
    struct vertex_header *v1 = header->v[1];
    struct vertex_header *v2 = header->v[2];
 
-   if (v0->edgeflag) line( stage, v0, v1 );
-   if (v1->edgeflag) line( stage, v1, v2 );
-   if (v2->edgeflag) line( stage, v2, v0 );
+   if (header->edgeflags & 0x1) line( stage, v0, v1 );
+   if (header->edgeflags & 0x2) line( stage, v1, v2 );
+   if (header->edgeflags & 0x4) line( stage, v2, v0 );
 }
 
 
diff --git a/src/mesa/pipe/draw/draw_vb.c b/src/mesa/pipe/draw/draw_vb.c
index f9c10e5f970..ef32f02ec10 100644
--- a/src/mesa/pipe/draw/draw_vb.c
+++ b/src/mesa/pipe/draw/draw_vb.c
@@ -40,356 +40,377 @@
 #include "draw_context.h"
 
 
-/* This file is a temporary set of hooks to allow us to use the tnl/
- * and vf/ modules until we have replacements in pipe.
- */
+#define RP_NONE  0
+#define RP_POINT 1
+#define RP_LINE  2
+#define RP_TRI   3
+
+static unsigned reduced_prim[GL_POLYGON + 1] = {
+   RP_POINT,
+   RP_LINE,
+   RP_LINE,
+   RP_LINE,
+   RP_TRI,
+   RP_TRI,
+   RP_TRI,
+   RP_TRI,
+   RP_TRI,
+   RP_TRI
+};
 
 
-static struct vertex_header *get_vertex( struct draw_context *pipe,
-					       GLuint i )
-{
-   return (struct vertex_header *)(pipe->verts + i * pipe->vertex_size);
-}
 
 
+/* This file is a temporary set of hooks to allow us to use the tnl/
+ * and vf/ modules until we have replacements in pipe.
+ */
 
-static void draw_allocate_vertices( struct draw_context *draw,
-				    GLuint nr_vertices )
+static void vs_flush( struct draw_context *draw )
 {
-   draw->nr_vertices = nr_vertices;
-   draw->verts = (GLubyte *) malloc( nr_vertices * draw->vertex_size );
+   unsigned i;
 
-   draw->pipeline.first->begin( draw->pipeline.first );
+   /* We're not really running a vertex shader yet, so flushing the vs
+    * queue is just a matter of building the vertices and returning.
+    */ 
+   /* Actually, I'm cheating even more and pre-building them still
+    * with the mesa/vf module.  So it's very easy...
+    */
+   for (i = 0; i < draw->vs.queue_nr; i++) {
+      /* Would do the following steps here:
+       *
+       * 1) Loop over vertex element descriptors, fetch data from each
+       *    to build the pre-tnl vertex.  This might require a new struct
+       *    to represent the pre-tnl vertex.
+       * 
+       * 2) Bundle groups of upto 4 pre-tnl vertices together and pass
+       *    to vertex shader.  
+       *
+       * 3) Do any necessary unswizzling, make sure vertex headers are
+       *    correctly populated, store resulting post-transformed
+       *    vertices in vcache.
+       *
+       * In this version, just do the last step:
+       */
+      unsigned elt = draw->vs.queue[i].elt;
+      struct vertex_header *dest = draw->vs.queue[i].dest;
+
+      /* Magic:
+       */
+      memcpy(dest, 
+	     draw->verts + elt * draw->vertex_size,
+	     draw->vertex_size);
+	     
+   }
+   draw->vs.queue_nr = 0;
 }
 
-static void draw_set_prim( struct draw_context *draw,
-			   GLenum prim )
+
+static void draw_flush( struct draw_context *draw )
 {
-   draw->prim = prim;
+   struct draw_stage *first = draw->pipeline.first;
+   unsigned i;
 
-   /* Not done yet - need to force edgeflags to 1 in strip/fan
-    * primitives.
+   /* Make sure all vertices are available:
     */
-#if 0
-   switch (prim) {
-   case GL_TRIANGLES:
-   case GL_POLYGON:
-   case GL_QUADS:
-   case GL_QUAD_STRIP:		/* yes, we need this */
-      respect_edgeflags( pipe, GL_TRUE );
+   vs_flush( draw );
+
+
+   switch (draw->reduced_prim) {
+   case RP_TRI:
+      for (i = 0; i < draw->pq.queue_nr; i++) {
+	 if (draw->pq.queue[i].reset_line_stipple)
+	    first->reset_stipple_counter( first );
+
+	 first->tri( first, &draw->pq.queue[i] );
+      }
       break;
+   case RP_LINE:
+      for (i = 0; i < draw->pq.queue_nr; i++) {
+	 if (draw->pq.queue[i].reset_line_stipple)
+	    first->reset_stipple_counter( first );
 
-   default:
-      respect_edgeflags( pipe, GL_FALSE );
+	 first->line( first, &draw->pq.queue[i] );
+      }
+      break;
+   case RP_POINT:
+      first->reset_stipple_counter( first );
+      for (i = 0; i < draw->pq.queue_nr; i++)
+	 first->point( first, &draw->pq.queue[i] );
       break;
    }
-#endif
-}
-			  
 
+   draw->pq.queue_nr = 0;
+   draw->vcache.referenced = 0;
+   draw->vcache.overflow = 0;
+}
 
-static void do_quad( struct draw_stage *first,
-		     struct vertex_header *v0,
-		     struct vertex_header *v1,
-		     struct vertex_header *v2,
-		     struct vertex_header *v3 )
+static void draw_invalidate_vcache( struct draw_context *draw )
 {
-   struct prim_header prim;
-
-   {
-      GLuint tmp = v1->edgeflag;
-      v1->edgeflag = 0;
-
-      prim.v[0] = v0;
-      prim.v[1] = v1;
-      prim.v[2] = v3;
-      first->tri( first, &prim );
+   unsigned i;
+
+   assert(draw->pq.queue_nr == 0);
+   assert(draw->vs.queue_nr == 0);
+   assert(draw->vcache.referenced == 0);
+   
+   for (i = 0; i < Elements( draw->vcache.idx ); i++)
+      draw->vcache.idx[i] = ~0;
+}
 
-      v1->edgeflag = tmp;
-   }
 
-   {
-      GLuint tmp = v3->edgeflag;
-      v3->edgeflag = 0;
+/* Return a pointer to a freshly queued primitive header.  Ensure that
+ * there is room in the vertex cache for a maximum of "nr_verts" new
+ * vertices.  Flush primitive and/or vertex queues if necessary to
+ * make space.
+ */
+static struct prim_header *get_queued_prim( struct draw_context *draw,
+					    GLuint nr_verts )
+{
+   if (draw->pq.queue_nr + 1 >= PRIM_QUEUE_LENGTH ||
+       draw->vcache.overflow + nr_verts >= VCACHE_OVERFLOW) 
+      draw_flush( draw );
 
-      prim.v[0] = v1;
-      prim.v[1] = v2;
-      prim.v[2] = v3;
-      first->tri( first, &prim );
+   /* The vs queue is sized so that this can never happen:
+    */
+   assert(draw->vs.queue_nr + nr_verts < VS_QUEUE_LENGTH);
 
-      v3->edgeflag = tmp;
-   }
+   return &draw->pq.queue[draw->pq.queue_nr++];
 }
 
 
-
-
-static void draw_indexed_prim( struct draw_context *draw,
-			       const GLuint *elts,
-			       GLuint count )
+/* Check if vertex is in cache, otherwise add it.  It won't go through
+ * VS yet, not until there is a flush operation or the VS queue fills up.  
+ */
+static struct vertex_header *get_vertex( struct draw_context *draw,
+					 GLuint i )
 {
-   struct draw_stage * const first = draw->pipeline.first;
-   struct prim_header prim;
-   GLuint i;
+   unsigned slot = (i + (i>>5)) & 31;
+   
+   /* Cache miss?
+    */
+   if (draw->vcache.idx[slot] != i) {
 
-   prim.det = 0;		/* valid from cull stage onwards */
-   prim.v[0] = 0;
-   prim.v[1] = 0;
-   prim.v[2] = 0;
+      /* If slot is in use, use the overflow area:
+       */
+      if (draw->vcache.referenced & (1<<slot)) 
+	 slot = draw->vcache.overflow++;
 
-   switch (draw->prim) {
-   case GL_POINTS:
-      for (i = 0; i < count; i ++) {
-	 prim.v[0] = get_vertex( draw, elts[i] );
+      draw->vcache.idx[slot] = i;
 
-	 first->point( first, &prim );
-      }
-      break;
+      /* Add to vertex shader queue:
+       */
+      draw->vs.queue[draw->vs.queue_nr].dest = draw->vcache.vertex[slot];
+      draw->vs.queue[draw->vs.queue_nr].elt = i;
+      draw->vs.queue_nr++;
+   }
 
-   case GL_LINES:
-      for (i = 0; i+1 < count; i += 2) {
-	 prim.v[0] = get_vertex( draw, elts[i + 0] );
-	 prim.v[1] = get_vertex( draw, elts[i + 1] );
-      
-         first->reset_stipple_counter( first );
-	 first->line( first, &prim );
-      }
-      break;
+   /* Mark slot as in-use:
+    */
+   draw->vcache.referenced |= (1<<slot);
+   return draw->vcache.vertex[slot];
+}
 
-   case GL_LINE_LOOP:  
-      if (count >= 2) {
-         first->reset_stipple_counter( first );
-	 for (i = 1; i < count; i++) {
-	    prim.v[0] = get_vertex( draw, elts[i-1] );
-	    prim.v[1] = get_vertex( draw, elts[i] );	    
-	    first->line( first, &prim );
-	 }
 
-	 prim.v[0] = get_vertex( draw, elts[count-1] );
-	 prim.v[1] = get_vertex( draw, elts[0] );	    
-	 first->line( first, &prim );
-      }
-      break;
+static struct vertex_header *get_uint_elt_vertex( struct draw_context *draw,
+						    GLuint i )
+{
+   const GLuint *elts = (const GLuint *)draw->elts;
+   return get_vertex( draw, elts[i] );
+}
 
-   case GL_LINE_STRIP:
-      /* I'm guessing it will be necessary to have something like a
-       * render->reset_line_stipple() method to properly support
-       * splitting strips into primitives like this.  Alternately we
-       * could just scan ahead to find individual clipped lines and
-       * otherwise leave the strip intact - that might be better, but
-       * require more complex code here.
-       */
-      if (count >= 2) {
-         first->reset_stipple_counter( first );
-	 prim.v[0] = 0;
-	 prim.v[1] = get_vertex( draw, elts[0] );
-	 
-	 for (i = 1; i < count; i++) {
-	    prim.v[0] = prim.v[1];
-	    prim.v[1] = get_vertex( draw, elts[i] );
-	    
-	    first->line( first, &prim );
-	 }
-      }
-      break;
+#if 0
+static struct vertex_header *get_ushort_elt_vertex( struct draw_context *draw,
+						    const void *elts,
+						    GLuint i )
+{
+   const GLushort *elts = (const GLushort *)draw->elts;
+   return get_vertex( draw, elts[i] );
+}
 
-   case GL_TRIANGLES:
-      for (i = 0; i+2 < count; i += 3) {
-	 prim.v[0] = get_vertex( draw, elts[i + 0] );
-	 prim.v[1] = get_vertex( draw, elts[i + 1] );
-	 prim.v[2] = get_vertex( draw, elts[i + 2] );
-      
-	 first->tri( first, &prim );
-      }
-      break;
+static struct vertex_header *get_ubyte_elt_vertex( struct draw_context *draw,
+						    const void *elts,
+						    GLuint i )
+{
+   const GLubyte *elts = (const GLubyte *)draw->elts;
+   return get_vertex( draw, elts[i] );
+}
+#endif
 
-   case GL_TRIANGLE_STRIP:
-      for (i = 0; i+2 < count; i++) {
-	 if (i & 1) {
-	    prim.v[0] = get_vertex( draw, elts[i + 1] );
-	    prim.v[1] = get_vertex( draw, elts[i + 0] );
-	    prim.v[2] = get_vertex( draw, elts[i + 2] );
-	 }
-	 else {
-	    prim.v[0] = get_vertex( draw, elts[i + 0] );
-	    prim.v[1] = get_vertex( draw, elts[i + 1] );
-	    prim.v[2] = get_vertex( draw, elts[i + 2] );
-	 }
-	 
-	 first->tri( first, &prim );
-      }
-      break;
 
-   case GL_TRIANGLE_FAN:
-      if (count >= 3) {
-	 prim.v[0] = get_vertex( draw, elts[0] );
-	 prim.v[1] = 0;
-	 prim.v[2] = get_vertex( draw, elts[1] );
-	 
-	 for (i = 0; i+2 < count; i++) {
-	    prim.v[1] = prim.v[2];
-	    prim.v[2] = get_vertex( draw, elts[i+2] );
-      
-	    first->tri( first, &prim );
-	 }
-      }
-      break;
+static void draw_set_prim( struct draw_context *draw,
+			   GLenum prim )
+{
+   if (reduced_prim[prim] != draw->reduced_prim) {
+      draw_flush( draw );
+      draw->reduced_prim = reduced_prim[prim];
+   }
 
-   case GL_QUADS:
-      for (i = 0; i+3 < count; i += 4) {
-	 do_quad( first,
-		  get_vertex( draw, elts[i + 0] ),
-		  get_vertex( draw, elts[i + 1] ),
-		  get_vertex( draw, elts[i + 2] ),
-		  get_vertex( draw, elts[i + 3] ));
-      }
-      break;
+   draw->prim = prim;
+}
 
-   case GL_QUAD_STRIP:
-      for (i = 0; i+3 < count; i += 2) {
-	 do_quad( first,
-		  get_vertex( draw, elts[i + 2] ),
-		  get_vertex( draw, elts[i + 0] ),
-		  get_vertex( draw, elts[i + 1] ),
-		  get_vertex( draw, elts[i + 3] ));
-      }
-      break;
 
+static void do_point( struct draw_context *draw,
+		      GLuint i0 )
+{
+   struct prim_header *prim = get_queued_prim( draw, 1 );
+   
+   prim->reset_line_stipple = 0;
+   prim->edgeflags = 1;
+   prim->pad = 0;
+   prim->v[0] = draw->get_vertex( draw, i0 );
+}
 
-   case GL_POLYGON:
-      if (count >= 3) {
-         int e1save, e2save;
-	 prim.v[0] = 0;
-	 prim.v[1] = get_vertex( draw, elts[1] );
-	 prim.v[2] = get_vertex( draw, elts[0] );
-	 e2save = prim.v[2]->edgeflag;
-	 
-	 for (i = 0; i+2 < count; i++) {
-	    prim.v[0] = prim.v[1];
-	    prim.v[1] = get_vertex( draw, elts[i+2] );
-      
-            /* save v1 edge flag, and clear if not last triangle */
-            e1save = prim.v[1]->edgeflag;
-            if (i + 3 < count)
-               prim.v[1]->edgeflag = 0;
 
-            /* draw */
-	    first->tri( first, &prim );
+static void do_line( struct draw_context *draw,
+		     GLboolean reset_stipple,
+		     GLuint i0,
+		     GLuint i1 )
+{
+   struct prim_header *prim = get_queued_prim( draw, 2 );
+   
+   prim->reset_line_stipple = reset_stipple;
+   prim->edgeflags = 1;
+   prim->pad = 0;
+   prim->v[0] = draw->get_vertex( draw, i0 );
+   prim->v[1] = draw->get_vertex( draw, i1 );
+}
 
-            prim.v[1]->edgeflag = e1save; /* restore */
-            prim.v[2]->edgeflag = 0; /* disable edge after 1st tri */
-	 }
-         prim.v[2]->edgeflag = e2save;
-      }
-      break;
+static void do_triangle( struct draw_context *draw,
+			 GLuint i0,
+			 GLuint i1,
+			 GLuint i2 )
+{
+   struct prim_header *prim = get_queued_prim( draw, 3 );
+   
+   prim->reset_line_stipple = 1;
+   prim->edgeflags = ~0;
+   prim->pad = 0;
+   prim->v[0] = draw->get_vertex( draw, i0 );
+   prim->v[1] = draw->get_vertex( draw, i1 );
+   prim->v[2] = draw->get_vertex( draw, i2 );
+}
+			  
+static void do_ef_triangle( struct draw_context *draw,
+			    GLboolean reset_stipple,
+			    GLuint ef_mask,
+			    GLuint i0,
+			    GLuint i1,
+			    GLuint i2 )
+{
+   struct prim_header *prim = get_queued_prim( draw, 3 );
+   struct vertex_header *v0 = draw->get_vertex( draw, i0 );
+   struct vertex_header *v1 = draw->get_vertex( draw, i1 );
+   struct vertex_header *v2 = draw->get_vertex( draw, i2 );
+   
+   prim->reset_line_stipple = reset_stipple;
+
+   prim->edgeflags = ef_mask & ((v0->edgeflag << 0) | 
+				(v1->edgeflag << 1) | 
+				(v2->edgeflag << 2));
+   prim->pad = 0;
+   prim->v[0] = v0;
+   prim->v[1] = v1;
+   prim->v[2] = v2;
+}
 
-   default:
-      assert(0);
-      break;
-   }
+
+static void do_quad( struct draw_context *draw,
+		     unsigned v0,
+		     unsigned v1,
+		     unsigned v2,
+		     unsigned v3 )
+{
+   do_ef_triangle( draw, 1, ~(1<<0), v0, v1, v3 );
+   do_ef_triangle( draw, 0, ~(1<<1), v1, v2, v3 );
 }
 
+
 static void draw_prim( struct draw_context *draw,
 		       GLuint start,
 		       GLuint count )
 {
-   struct draw_stage * const first = draw->pipeline.first;
-   struct prim_header prim;
    GLuint i;
 
 //   _mesa_printf("%s (%d) %d/%d\n", __FUNCTION__, draw->prim, start, count );
 
-   prim.det = 0;		/* valid from cull stage onwards */
-   prim.v[0] = 0;
-   prim.v[1] = 0;
-   prim.v[2] = 0;
-
    switch (draw->prim) {
    case GL_POINTS:
       for (i = 0; i < count; i ++) {
-	 prim.v[0] = get_vertex( draw, start + i );
-	 first->point( first, &prim );
+	 do_point( draw,
+		   start + i );
       }
       break;
 
    case GL_LINES:
       for (i = 0; i+1 < count; i += 2) {
-	 prim.v[0] = get_vertex( draw, start + i + 0 );
-	 prim.v[1] = get_vertex( draw, start + i + 1 );
-
-         first->reset_stipple_counter( first );
-	 first->line( first, &prim );
+	 do_line( draw, 
+		  TRUE,
+		  start + i + 0,
+		  start + i + 1);
       }
       break;
 
    case GL_LINE_LOOP:  
       if (count >= 2) {
-         first->reset_stipple_counter( first );
 	 for (i = 1; i < count; i++) {
-	    prim.v[0] = get_vertex( draw, start + i - 1 );
-	    prim.v[1] = get_vertex( draw, start + i );	    
-	    first->line( first, &prim );
+	    do_line( draw, 
+		     i == 1, 	/* XXX: only if vb not split */
+		     start + i - 1,
+		     start + i );
 	 }
 
-	 prim.v[0] = get_vertex( draw, start + count - 1 );
-	 prim.v[1] = get_vertex( draw, start + 0 );	    
-	 first->line( first, &prim );
+	 do_line( draw, 
+		  0,
+		  start + count - 1,
+		  start + 0 );
       }
       break;
 
    case GL_LINE_STRIP:
       if (count >= 2) {
-         first->reset_stipple_counter( first );
-	 prim.v[0] = 0;
-	 prim.v[1] = get_vertex( draw, start + 0 );
-	 
 	 for (i = 1; i < count; i++) {
-	    prim.v[0] = prim.v[1];
-	    prim.v[1] = get_vertex( draw, start + i );
-	    
-	    first->line( first, &prim );
+	    do_line( draw,
+		     i == 1,
+		     start + i - 1,
+		     start + i );
 	 }
       }
       break;
 
    case GL_TRIANGLES:
       for (i = 0; i+2 < count; i += 3) {
-	 prim.v[0] = get_vertex( draw, start + i + 0 );
-	 prim.v[1] = get_vertex( draw, start + i + 1 );
-	 prim.v[2] = get_vertex( draw, start + i + 2 );
-      
-	 first->tri( first, &prim );
+	 do_ef_triangle( draw,
+			 1, 
+			 ~0,
+			 start + i + 0,
+			 start + i + 1,
+			 start + i + 2 );
       }
       break;
 
    case GL_TRIANGLE_STRIP:
       for (i = 0; i+2 < count; i++) {
 	 if (i & 1) {
-	    prim.v[0] = get_vertex( draw, start + i + 1 );
-	    prim.v[1] = get_vertex( draw, start + i + 0 );
-	    prim.v[2] = get_vertex( draw, start + i + 2 );
+	    do_triangle( draw,
+			 start + i + 1,
+			 start + i + 0,
+			 start + i + 2 );
 	 }
 	 else {
-	    prim.v[0] = get_vertex( draw, start + i + 0 );
-	    prim.v[1] = get_vertex( draw, start + i + 1 );
-	    prim.v[2] = get_vertex( draw, start + i + 2 );
+	    do_triangle( draw,
+			 start + i + 0,
+			 start + i + 1,
+			 start + i + 2 );
 	 }
-	 
-	 first->tri( first, &prim );
       }
       break;
 
    case GL_TRIANGLE_FAN:
       if (count >= 3) {
-	 prim.v[0] = get_vertex( draw, start + 0 );
-	 prim.v[1] = 0;
-	 prim.v[2] = get_vertex( draw, start + 1 );
-	 
 	 for (i = 0; i+2 < count; i++) {
-	    prim.v[1] = prim.v[2];
-	    prim.v[2] = get_vertex( draw, start + i + 2 );
-      
-	    first->tri( first, &prim );
+	    do_triangle( draw,
+			 start + 0,
+			 start + i + 1,
+			 start + i + 2 );
 	 }
       }
       break;
@@ -397,48 +418,42 @@ static void draw_prim( struct draw_context *draw,
 
    case GL_QUADS:
       for (i = 0; i+3 < count; i += 4) {
-	 do_quad( first,
-		  get_vertex( draw, start + i + 0 ),
-		  get_vertex( draw, start + i + 1 ),
-		  get_vertex( draw, start + i + 2 ),
-		  get_vertex( draw, start + i + 3 ));
+	 do_quad( draw,
+		  start + i + 0,
+		  start + i + 1,
+		  start + i + 2,
+		  start + i + 3);
       }
       break;
 
    case GL_QUAD_STRIP:
       for (i = 0; i+3 < count; i += 2) {
-	 do_quad( first,
-		  get_vertex( draw, start + i + 2 ),
-		  get_vertex( draw, start + i + 0 ),
-		  get_vertex( draw, start + i + 1 ),
-		  get_vertex( draw, start + i + 3 ));
+	 do_quad( draw,
+		  start + i + 2,
+		  start + i + 0,
+		  start + i + 1,
+		  start + i + 3);
       }
       break;
 
    case GL_POLYGON:
       if (count >= 3) {
-         int e1save, e2save;
-	 prim.v[0] = 0;
-	 prim.v[1] = get_vertex( draw, start + 1 );
-	 prim.v[2] = get_vertex( draw, start + 0 );
-	 e2save = prim.v[2]->edgeflag;
+	 unsigned ef_mask = (1<<2) | (1<<0);
 
 	 for (i = 0; i+2 < count; i++) {
-	    prim.v[0] = prim.v[1];
-	    prim.v[1] = get_vertex( draw, start + i + 2 );
 
-            /* save v1 edge flag, and clear if not last triangle */
-            e1save = prim.v[1]->edgeflag;
-            if (i + 3 < count)
-               prim.v[1]->edgeflag = 0;
+            if (i + 3 >= count)
+	       ef_mask |= (1<<1);
 
-            /* draw */
-	    first->tri( first, &prim );
+	    do_ef_triangle( draw,
+			    i == 0,
+			    ef_mask,
+			    start + i + 1,
+			    start + i + 2,
+			    start + i + 0);
 
-            prim.v[1]->edgeflag = e1save; /* restore */
-            prim.v[2]->edgeflag = 0; /* disable edge after 1st tri */
+	    ef_mask &= ~(1<<2);
 	 }
-         prim.v[2]->edgeflag = e2save;
       }
       break;
 
@@ -449,10 +464,18 @@ static void draw_prim( struct draw_context *draw,
 }
 
 
-static void draw_release_vertices( struct draw_context *draw )
+static void draw_allocate_vertices( struct draw_context *draw,
+				    GLuint nr_vertices )
 {
-   draw->pipeline.first->end( draw->pipeline.first );
+   draw->nr_vertices = nr_vertices;
+   draw->verts = (GLubyte *) malloc( nr_vertices * draw->vertex_size );
+   draw_invalidate_vcache( draw );
+}
+
+
 
+static void draw_release_vertices( struct draw_context *draw )
+{
    free(draw->verts);
    draw->verts = NULL;
 }
@@ -598,6 +621,8 @@ void draw_vb(struct draw_context *draw,
 
    draw->in_vb = 1;
 
+   draw->pipeline.first->begin( draw->pipeline.first );
+
    /* Allocate the vertices:
     */
    draw_allocate_vertices( draw, VB->Count );
@@ -605,11 +630,14 @@ void draw_vb(struct draw_context *draw,
    /* Bind the vb outputs:
     */
    vf_set_sources( draw->vf, VB->AttribPtr, 0 );
-
-   /* Build the hardware or prim-pipe vertices: 
-    */
    vf_emit_vertices( draw->vf, VB->Count, draw->verts );
 
+   draw->elts = VB->Elts;
+
+   if (VB->Elts) 
+      draw->get_vertex = get_uint_elt_vertex;
+   else
+      draw->get_vertex = get_vertex;
 
    for (i = 0; i < VB->PrimitiveCount; i++) {
 
@@ -628,21 +656,15 @@ void draw_vb(struct draw_context *draw,
       if (draw->prim != mode) 
 	 draw_set_prim( draw, mode );
 
-      if (VB->Elts) {
-	 draw_indexed_prim( draw, 
-			    VB->Elts + start,
-			    length );
-      }
-      else {
-	 draw_prim( draw, 
-		    start,
-		    length );
-      }	 
+      draw_prim( draw, start, length );
    }
 
+   draw_flush(draw);
+   draw->pipeline.first->end( draw->pipeline.first );
    draw_release_vertices( draw );
    draw->verts = NULL;
    draw->in_vb = 0;
+   draw->elts = NULL;
 }
 
 
@@ -661,11 +683,17 @@ draw_vertices(struct draw_context *draw,
 
    assert(mode <= GL_POLYGON);
 
+   draw->get_vertex = get_vertex;
    draw->vertex_size
       = sizeof(struct vertex_header) + numAttrs * 4 * sizeof(GLfloat);
 
+
+
+
    /*draw_prim_info(mode, &first, &incr);*/
    draw_allocate_vertices( draw, numVerts );
+   draw->pipeline.first->begin( draw->pipeline.first );
+
    if (draw->prim != mode) 
       draw_set_prim( draw, mode );
 
@@ -694,6 +722,9 @@ draw_vertices(struct draw_context *draw,
 
    /* draw */
    draw_prim(draw, 0, numVerts);
+   draw_flush(draw);
+   draw->pipeline.first->end( draw->pipeline.first );
+
 
    /* clean up */
    draw_release_vertices( draw );
@@ -759,8 +790,6 @@ void draw_set_vertex_attributes( struct draw_context *draw,
 }
 			    
 
-#define MAX_VERTEX_SIZE ((2 + FRAG_ATTRIB_MAX) * 4 * sizeof(GLfloat))
-
 void draw_alloc_tmps( struct draw_stage *stage, GLuint nr )
 {
    stage->nr_tmps = nr;
diff --git a/src/mesa/pipe/p_context.h b/src/mesa/pipe/p_context.h
index 76357559478..c0685fa8cba 100644
--- a/src/mesa/pipe/p_context.h
+++ b/src/mesa/pipe/p_context.h
@@ -136,7 +136,15 @@ struct pipe_context {
    void (*set_viewport_state)( struct pipe_context *,
                                const struct pipe_viewport_state * );
 
-
+   void (*set_vertex_buffer)( struct pipe_context *,
+                              unsigned index,
+                              struct pipe_vertex_buffer * );
+   
+   void (*set_vertex_element)( struct pipe_context *,
+			       unsigned index,
+			       struct pipe_vertex_element * );
+			       
+   
    /*
     * Surface functions
     * This might go away...
diff --git a/src/mesa/pipe/p_defines.h b/src/mesa/pipe/p_defines.h
index e6aff6fb49c..addbb026bf5 100644
--- a/src/mesa/pipe/p_defines.h
+++ b/src/mesa/pipe/p_defines.h
@@ -162,8 +162,15 @@
 /**
  * Texture/surface image formats (preliminary)
  */
+
+/* KW: Added lots of surface formats to support vertex element layout
+ * definitions, and eventually render-to-vertex-buffer.  Could
+ * consider making float/int/uint/scaled/normalized a separate
+ * parameter, but on the other hand there are special cases like
+ * z24s8, compressed textures, ycbcr, etc that won't fit that model.
+ */
+
 #define PIPE_FORMAT_NONE               0  /**< unstructured */
-#define PIPE_FORMAT_U_R8_G8_B8_A8      1  /**< ubyte[4] RGBA */
 #define PIPE_FORMAT_U_A8_R8_G8_B8      2  /**< ubyte[4] ARGB */
 #define PIPE_FORMAT_U_A1_R5_G5_B5      3  /**< 16-bit packed RGBA */
 #define PIPE_FORMAT_U_A4_R4_G4_B4      4  /**< 16-bit packed RGBA */
@@ -180,8 +187,68 @@
 #define PIPE_FORMAT_F_Z32             15  /**< float Z/depth */
 #define PIPE_FORMAT_S8_Z24            16  /**< 8-bit stencil + 24-bit Z */
 #define PIPE_FORMAT_U_S8              17  /**< 8-bit stencil */
-#define PIPE_FORMAT_COUNT             18  /**< number of formats */
+#define PIPE_FORMAT_R64_FLOAT             0x20
+#define PIPE_FORMAT_R64G64_FLOAT          0x21
+#define PIPE_FORMAT_R64G64B64_FLOAT       0x22
+#define PIPE_FORMAT_R64G64B64A64_FLOAT    0x23
+#define PIPE_FORMAT_R32_FLOAT             0x24
+#define PIPE_FORMAT_R32G32_FLOAT          0x25
+#define PIPE_FORMAT_R32G32B32_FLOAT       0x26
+#define PIPE_FORMAT_R32G32B32A32_FLOAT    0x27
+#define PIPE_FORMAT_R32_UNORM             0x28
+#define PIPE_FORMAT_R32G32_UNORM          0x29
+#define PIPE_FORMAT_R32G32B32_UNORM       0x2a
+#define PIPE_FORMAT_R32G32B32A32_UNORM    0x2b
+#define PIPE_FORMAT_R32_USCALED           0x2c
+#define PIPE_FORMAT_R32G32_USCALED        0x2d
+#define PIPE_FORMAT_R32G32B32_USCALED     0x2e
+#define PIPE_FORMAT_R32G32B32A32_USCALED  0x2f
+#define PIPE_FORMAT_R32_SNORM             0x30
+#define PIPE_FORMAT_R32G32_SNORM          0x31
+#define PIPE_FORMAT_R32G32B32_SNORM       0x32
+#define PIPE_FORMAT_R32G32B32A32_SNORM    0x33
+#define PIPE_FORMAT_R32_SSCALED           0x34
+#define PIPE_FORMAT_R32G32_SSCALED        0x35
+#define PIPE_FORMAT_R32G32B32_SSCALED     0x36
+#define PIPE_FORMAT_R32G32B32A32_SSCALED  0x37
+#define PIPE_FORMAT_R16_UNORM             0x38
+#define PIPE_FORMAT_R16G16_UNORM          0x39
+#define PIPE_FORMAT_R16G16B16_UNORM       0x3a
+#define PIPE_FORMAT_R16G16B16A16_UNORM    0x3b
+#define PIPE_FORMAT_R16_USCALED           0x3c
+#define PIPE_FORMAT_R16G16_USCALED        0x3d
+#define PIPE_FORMAT_R16G16B16_USCALED     0x3e
+#define PIPE_FORMAT_R16G16B16A16_USCALED  0x3f
+#define PIPE_FORMAT_R16_SNORM             0x40
+#define PIPE_FORMAT_R16G16_SNORM          0x41
+#define PIPE_FORMAT_R16G16B16_SNORM       0x42
+#define PIPE_FORMAT_R16G16B16A16_SNORM    0x43
+#define PIPE_FORMAT_R16_SSCALED           0x44
+#define PIPE_FORMAT_R16G16_SSCALED        0x45
+#define PIPE_FORMAT_R16G16B16_SSCALED     0x46
+#define PIPE_FORMAT_R16G16B16A16_SSCALED  0x47
+#define PIPE_FORMAT_R8_UNORM              0x48
+#define PIPE_FORMAT_R8G8_UNORM            0x49
+#define PIPE_FORMAT_R8G8B8_UNORM          0x4a
+#define PIPE_FORMAT_R8G8B8A8_UNORM        0x4b
+#define PIPE_FORMAT_R8_USCALED            0x4c
+#define PIPE_FORMAT_R8G8_USCALED          0x4d
+#define PIPE_FORMAT_R8G8B8_USCALED        0x4e
+#define PIPE_FORMAT_R8G8B8A8_USCALED      0x4f
+#define PIPE_FORMAT_R8_SNORM              0x50
+#define PIPE_FORMAT_R8G8_SNORM            0x51
+#define PIPE_FORMAT_R8G8B8_SNORM          0x52
+#define PIPE_FORMAT_R8G8B8A8_SNORM        0x53
+#define PIPE_FORMAT_R8_SSCALED            0x54
+#define PIPE_FORMAT_R8G8_SSCALED          0x55
+#define PIPE_FORMAT_R8G8B8_SSCALED        0x56
+#define PIPE_FORMAT_R8G8B8A8_SSCALED      0x57
 
+#define PIPE_FORMAT_COUNT                 0x58  /**< number of formats */
+
+/* Duplicated formats:
+ */
+#define PIPE_FORMAT_U_R8_G8_B8_A8      PIPE_FORMAT_R8G8B8A8_UNORM
 
 /**
  * Surface flags
diff --git a/src/mesa/pipe/p_state.h b/src/mesa/pipe/p_state.h
index dc2b589e555..5051ebbfc05 100644
--- a/src/mesa/pipe/p_state.h
+++ b/src/mesa/pipe/p_state.h
@@ -320,4 +320,25 @@ struct pipe_mipmap_tree
 };
 
 
+
+struct pipe_vertex_buffer
+{
+   unsigned pitch:11; 
+   unsigned max_index;   
+   struct pipe_buffer_handle *buffer;
+   unsigned buffer_offset;
+};
+
+
+
+struct pipe_vertex_element
+{
+   unsigned src_offset:11; 
+   unsigned vertex_buffer_index:5; 
+   unsigned dst_offset:8; 
+   unsigned src_format:8; 	/* PIPE_FORMAT_* */
+};
+
+
+
 #endif
diff --git a/src/mesa/pipe/p_util.h b/src/mesa/pipe/p_util.h
index 979befb194b..50d57a2ed0b 100644
--- a/src/mesa/pipe/p_util.h
+++ b/src/mesa/pipe/p_util.h
@@ -28,25 +28,14 @@
 #define P_UTIL_H
 
 #include "p_compiler.h"
+#include <math.h>
 
 #define CALLOC_STRUCT(T)   (struct T *) calloc(1, sizeof(struct T))
 
-
-
-/** Clamp X to [MIN,MAX] */
 #define CLAMP( X, MIN, MAX )  ( (X)<(MIN) ? (MIN) : ((X)>(MAX) ? (MAX) : (X)) )
-
-/** Assign X to CLAMP(X, MIN, MAX) */
-#define CLAMP_SELF(x, mn, mx)  \
-   ( (x)<(mn) ? ((x) = (mn)) : ((x)>(mx) ? ((x)=(mx)) : (x)) )
-
-/** Minimum of two values: */
 #define MIN2( A, B )   ( (A)<(B) ? (A) : (B) )
-
-/** Maximum of two values: */
 #define MAX2( A, B )   ( (A)>(B) ? (A) : (B) )
 
-
 #define Elements(x) sizeof(x)/sizeof(*(x))
 
 union fi {
@@ -114,4 +103,74 @@ static INLINE unsigned pack_ui32_float4( float a,
 		    float_to_ubyte(d) );
 }
 
+#define COPY_4V( DST, SRC )         \
+do {                                \
+   (DST)[0] = (SRC)[0];             \
+   (DST)[1] = (SRC)[1];             \
+   (DST)[2] = (SRC)[2];             \
+   (DST)[3] = (SRC)[3];             \
+} while (0)
+
+
+static INLINE int ifloor(float f)
+{
+   int ai, bi;
+   double af, bf;
+   union fi u;
+
+   af = (3 << 22) + 0.5 + (double)f;
+   bf = (3 << 22) + 0.5 - (double)f;
+   u.f = (float) af;  ai = u.i;
+   u.f = (float) bf;  bi = u.i;
+   return (ai - bi) >> 1;
+}
+
+
+#if defined(__GNUC__) && defined(__i386__) 
+static INLINE int iround(float f)
+{
+   int r;
+   __asm__ ("fistpl %0" : "=m" (r) : "t" (f) : "st");
+   return r;
+}
+#elif defined(__MSC__) && defined(__WIN32__)
+static INLINE int iround(float f)
+{
+   int r;
+   _asm {
+	 fld f
+	 fistp r
+	}
+   return r;
+}
+#else
+#define IROUND(f)  ((int) (((f) >= 0.0F) ? ((f) + 0.5F) : ((f) - 0.5F)))
+#endif
+
+
+/* Could maybe have an inline version of this?
+ */
+#if defined(__GNUC__)
+#define FABSF(x)   fabsf(x)
+#else
+#define FABSF(x)   ((GLfloat) fabs(x))
+#endif
+
+/* Pretty fast, and accurate.
+ * Based on code from http://www.flipcode.com/totd/
+ */
+static INLINE float LOG2(float val)
+{
+   union fi num;
+   int log_2;
+
+   num.f = val;
+   log_2 = ((num.i >> 23) & 255) - 128;
+   num.i &= ~(255 << 23);
+   num.i += 127 << 23;
+   num.f = ((-1.0f/3) * num.f + 2) * num.f - 2.0f/3;
+   return num.f + log_2;
+}
+
+
 #endif
diff --git a/src/mesa/pipe/softpipe/sp_clear.c b/src/mesa/pipe/softpipe/sp_clear.c
index 14ddf0c3060..27744137209 100644
--- a/src/mesa/pipe/softpipe/sp_clear.c
+++ b/src/mesa/pipe/softpipe/sp_clear.c
@@ -35,7 +35,7 @@
 #include "sp_context.h"
 #include "sp_surface.h"
 #include "sp_state.h"
-#include "colormac.h"
+//#include "colormac.h"
 
 
 /**
@@ -47,7 +47,7 @@ softpipe_clear(struct pipe_context *pipe, struct pipe_surface *ps,
                unsigned clearValue)
 {
    struct softpipe_context *softpipe = softpipe_context(pipe);
-   GLint x, y, w, h;
+   int x, y, w, h;
 
    softpipe_update_derived(softpipe); /* not needed?? */
 
diff --git a/src/mesa/pipe/softpipe/sp_context.c b/src/mesa/pipe/softpipe/sp_context.c
index 34ef00f619e..1ea6bbbf7fe 100644
--- a/src/mesa/pipe/softpipe/sp_context.c
+++ b/src/mesa/pipe/softpipe/sp_context.c
@@ -29,10 +29,9 @@
  *    Keith Whitwell <[email protected]>
  */
 
-#include "main/imports.h"
-#include "main/macros.h"
 #include "pipe/draw/draw_context.h"
 #include "pipe/p_defines.h"
+#include "pipe/p_util.h"
 #include "sp_clear.h"
 #include "sp_context.h"
 #include "sp_flush.h"
@@ -50,11 +49,11 @@
  * If we find texture and drawable support differs, add a selector
  * parameter or another function.
  */
-static const GLuint *
-softpipe_supported_formats(struct pipe_context *pipe, GLuint *numFormats)
+static const unsigned *
+softpipe_supported_formats(struct pipe_context *pipe, unsigned *numFormats)
 {
 #if 0
-   static const GLuint supported[] = {
+   static const unsigned supported[] = {
       PIPE_FORMAT_U_R8_G8_B8_A8,
       PIPE_FORMAT_U_A8_R8_G8_B8,
       PIPE_FORMAT_U_R5_G6_B5,
@@ -82,9 +81,9 @@ softpipe_supported_formats(struct pipe_context *pipe, GLuint *numFormats)
 
 
 static void
-softpipe_max_texture_size(struct pipe_context *pipe, GLuint textureType,
-                          GLuint *maxWidth, GLuint *maxHeight,
-                          GLuint *maxDepth)
+softpipe_max_texture_size(struct pipe_context *pipe, unsigned textureType,
+                          unsigned *maxWidth, unsigned *maxHeight,
+                          unsigned *maxDepth)
 {
    switch (textureType) {
    case PIPE_TEXTURE_1D:
@@ -112,7 +111,7 @@ softpipe_max_texture_size(struct pipe_context *pipe, GLuint textureType,
 static void map_surfaces(struct softpipe_context *sp)
 {
    struct pipe_context *pipe = &sp->pipe;
-   GLuint i;
+   unsigned i;
 
    for (i = 0; i < sp->framebuffer.num_cbufs; i++) {
       struct softpipe_surface *sps = softpipe_surface(sp->framebuffer.cbufs[i]);
@@ -147,7 +146,7 @@ static void map_surfaces(struct softpipe_context *sp)
 static void unmap_surfaces(struct softpipe_context *sp)
 {
    struct pipe_context *pipe = &sp->pipe;
-   GLuint i;
+   unsigned i;
 
    for (i = 0; i < sp->framebuffer.num_cbufs; i++) {
       struct softpipe_surface *sps = softpipe_surface(sp->framebuffer.cbufs[i]);
@@ -206,9 +205,9 @@ static void softpipe_draw_vb( struct pipe_context *pipe,
 
 static void
 softpipe_draw_vertices(struct pipe_context *pipe,
-                       GLuint mode,
-                       GLuint numVertex, const GLfloat *verts,
-                       GLuint numAttribs, const GLuint attribs[])
+                       unsigned mode,
+                       unsigned numVertex, const float *verts,
+                       unsigned numAttribs, const unsigned attribs[])
 {
    struct softpipe_context *softpipe = softpipe_context( pipe );
 
@@ -230,7 +229,7 @@ static void softpipe_reset_occlusion_counter(struct pipe_context *pipe)
 }
 
 /* XXX pipe param should be const */
-static GLuint softpipe_get_occlusion_counter(struct pipe_context *pipe)
+static unsigned softpipe_get_occlusion_counter(struct pipe_context *pipe)
 {
    struct softpipe_context *softpipe = softpipe_context( pipe );
    return softpipe->occlusion_counter;
diff --git a/src/mesa/pipe/softpipe/sp_context.h b/src/mesa/pipe/softpipe/sp_context.h
index a99c083caa5..8887c576c1f 100644
--- a/src/mesa/pipe/softpipe/sp_context.h
+++ b/src/mesa/pipe/softpipe/sp_context.h
@@ -31,7 +31,7 @@
 #ifndef SP_CONTEXT_H
 #define SP_CONTEXT_H
 
-#include "glheader.h"
+//#include "glheader.h"
 
 #include "pipe/p_state.h"
 #include "pipe/p_context.h"
@@ -88,7 +88,7 @@ struct softpipe_context {
    struct pipe_stencil_state stencil;
    struct pipe_mipmap_tree *texture[PIPE_MAX_SAMPLERS];
    struct pipe_viewport_state viewport;
-   GLuint dirty;
+   unsigned dirty;
 
    /* Setup derived state.  TODO: this should be passed in the program
     * tokens as parameters to DECL instructions.
@@ -103,28 +103,28 @@ struct softpipe_context {
     */
 
    /** Map fragment program attribute to quad/coef array slot */
-   GLuint fp_attr_to_slot[PIPE_ATTRIB_MAX];
+   unsigned fp_attr_to_slot[PIPE_ATTRIB_MAX];
    /** Map vertex format attribute to a vertex attribute slot */
-   GLuint vf_attr_to_slot[PIPE_ATTRIB_MAX];
-   GLuint nr_attrs;
-   GLuint nr_frag_attrs;  /**< number of active fragment attribs */
-   GLbitfield attr_mask;  /**< bitfield of VF_ATTRIB_ indexes/bits */
+   unsigned vf_attr_to_slot[PIPE_ATTRIB_MAX];
+   unsigned nr_attrs;
+   unsigned nr_frag_attrs;  /**< number of active fragment attribs */
+   unsigned attr_mask;  /**< bitfield of VF_ATTRIB_ indexes/bits */
 
-   GLboolean need_z;  /**< produce quad/fragment Z values? */
-   GLboolean need_w;  /**< produce quad/fragment W values? */
+   boolean need_z;  /**< produce quad/fragment Z values? */
+   boolean need_w;  /**< produce quad/fragment W values? */
 
 #if 0
    /* Stipple derived state:
     */
-   GLubyte stipple_masks[16][16];
+   ubyte stipple_masks[16][16];
 #endif
 
    /** Derived from scissor and surface bounds: */
    struct pipe_scissor_state cliprect;
 
-   GLuint occlusion_counter;
+   unsigned occlusion_counter;
 
-   GLuint line_stipple_counter;
+   unsigned line_stipple_counter;
 
    /** Software quad rendering pipeline */
    struct {
diff --git a/src/mesa/pipe/softpipe/sp_headers.h b/src/mesa/pipe/softpipe/sp_headers.h
index 68a84621f2c..b7f46cb6583 100644
--- a/src/mesa/pipe/softpipe/sp_headers.h
+++ b/src/mesa/pipe/softpipe/sp_headers.h
@@ -57,9 +57,9 @@
 
 
 struct setup_coefficient {
-   GLfloat a0[NUM_CHANNELS];	/* in an xyzw layout */
-   GLfloat dadx[NUM_CHANNELS];
-   GLfloat dady[NUM_CHANNELS];
+   float a0[NUM_CHANNELS];	/* in an xyzw layout */
+   float dadx[NUM_CHANNELS];
+   float dady[NUM_CHANNELS];
 };
 
 
@@ -69,18 +69,18 @@ struct setup_coefficient {
  * "Channel-Serial" or "SoA" layout.  
  */
 struct quad_header {
-   GLint x0;
-   GLint y0;
-   GLuint mask:4;
-   GLuint facing:1;   /**< Front (0) or back (1) facing? */
-   GLuint prim:2;     /**< PRIM_POINT, LINE, TRI */
+   int x0;
+   int y0;
+   unsigned mask:4;
+   unsigned facing:1;   /**< Front (0) or back (1) facing? */
+   unsigned prim:2;     /**< PRIM_POINT, LINE, TRI */
 
    struct {
-      GLfloat color[4][QUAD_SIZE];	/* rrrr, gggg, bbbb, aaaa */
-      GLfloat depth[QUAD_SIZE];
+      float color[4][QUAD_SIZE];	/* rrrr, gggg, bbbb, aaaa */
+      float depth[QUAD_SIZE];
    } outputs;
 
-   GLfloat coverage[QUAD_SIZE];    /** fragment coverage for antialiasing */
+   float coverage[QUAD_SIZE];    /** fragment coverage for antialiasing */
 
    const struct setup_coefficient *coef;
 
@@ -88,7 +88,7 @@ struct quad_header {
 				    * encoded in fragment program DECL
 				    * statements. */
 
-   GLuint nr_attrs;
+   unsigned nr_attrs;
 };
 
 
diff --git a/src/mesa/pipe/softpipe/sp_prim_setup.c b/src/mesa/pipe/softpipe/sp_prim_setup.c
index 7a3d011b7bd..45d09860c3c 100644
--- a/src/mesa/pipe/softpipe/sp_prim_setup.c
+++ b/src/mesa/pipe/softpipe/sp_prim_setup.c
@@ -33,25 +33,26 @@
  */
 
 
-#include "imports.h"
-#include "macros.h"
+//#include "imports.h"
+//#include "macros.h"
 
 #include "sp_context.h"
 #include "sp_headers.h"
-#include "pipe/draw/draw_private.h"
 #include "sp_quad.h"
 #include "sp_prim_setup.h"
+#include "pipe/draw/draw_private.h"
+#include "pipe/p_util.h"
 
 
 /**
  * Triangle edge info
  */
 struct edge {
-   GLfloat dx;			/**< X(v1) - X(v0), used only during setup */
-   GLfloat dy;			/**< Y(v1) - Y(v0), used only during setup */
-   GLfloat dxdy;		/**< dx/dy */
-   GLfloat sx, sy;		/**< first sample point coord */
-   GLint lines;			/**< number of lines on this edge */
+   float dx;			/**< X(v1) - X(v0), used only during setup */
+   float dy;			/**< Y(v1) - Y(v0), used only during setup */
+   float dxdy;		/**< dx/dy */
+   float sx, sy;		/**< first sample point coord */
+   int lines;			/**< number of lines on this edge */
 };
 
 
@@ -77,17 +78,17 @@ struct setup_stage {
    struct edge etop;
    struct edge emaj;
 
-   GLfloat oneoverarea;
+   float oneoverarea;
 
    struct setup_coefficient coef[FRAG_ATTRIB_MAX];
    struct quad_header quad; 
 
    struct {
-      GLint left[2];   /**< [0] = row0, [1] = row1 */
-      GLint right[2];
-      GLint y;
-      GLuint y_flags;
-      GLuint mask;     /**< mask of MASK_BOTTOM/TOP_LEFT/RIGHT bits */
+      int left[2];   /**< [0] = row0, [1] = row1 */
+      int right[2];
+      int y;
+      unsigned y_flags;
+      unsigned mask;     /**< mask of MASK_BOTTOM/TOP_LEFT/RIGHT bits */
    } span;
 };
 
@@ -146,7 +147,7 @@ clip_emit_quad(struct setup_stage *setup)
  * Emit a quad (pass to next stage).  No clipping is done.
  */
 static INLINE void
-emit_quad( struct setup_stage *setup, GLint x, GLint y, GLuint mask )
+emit_quad( struct setup_stage *setup, int x, int y, unsigned mask )
 {
    struct softpipe_context *sp = setup->softpipe;
    setup->quad.x0 = x;
@@ -160,7 +161,7 @@ emit_quad( struct setup_stage *setup, GLint x, GLint y, GLuint mask )
  * Given an X or Y coordinate, return the block/quad coordinate that it
  * belongs to.
  */
-static INLINE GLint block( GLint x )
+static INLINE int block( int x )
 {
    return x & ~1;
 }
@@ -173,10 +174,10 @@ static INLINE GLint block( GLint x )
  * this is pretty nasty...  may need to rework flush_spans again to
  * fix it, if possible.
  */
-static GLuint calculate_mask( struct setup_stage *setup,
-			    GLint x )
+static unsigned calculate_mask( struct setup_stage *setup,
+			    int x )
 {
-   GLuint mask = 0;
+   unsigned mask = 0;
 
    if (x >= setup->span.left[0] && x < setup->span.right[0]) 
       mask |= MASK_BOTTOM_LEFT;
@@ -199,8 +200,8 @@ static GLuint calculate_mask( struct setup_stage *setup,
  */
 static void flush_spans( struct setup_stage *setup )
 {
-   GLint minleft, maxright;
-   GLint x;
+   int minleft, maxright;
+   int x;
 
    switch (setup->span.y_flags) {      
    case 3:
@@ -249,7 +250,7 @@ static void print_vertex(const struct setup_stage *setup,
 }
 #endif
 
-static GLboolean setup_sort_vertices( struct setup_stage *setup,
+static boolean setup_sort_vertices( struct setup_stage *setup,
 				      const struct prim_header *prim )
 {
    const struct vertex_header *v0 = prim->v[0];
@@ -267,9 +268,9 @@ static GLboolean setup_sort_vertices( struct setup_stage *setup,
 
    /* determine bottom to top order of vertices */
    {
-      GLfloat y0 = v0->data[0][1];
-      GLfloat y1 = v1->data[0][1];
-      GLfloat y2 = v2->data[0][1];
+      float y0 = v0->data[0][1];
+      float y1 = v1->data[0][1];
+      float y2 = v2->data[0][1];
       if (y0 <= y1) {
 	 if (y1 <= y2) {
 	    /* y0<=y1<=y2 */
@@ -330,7 +331,7 @@ static GLboolean setup_sort_vertices( struct setup_stage *setup,
     * use the prim->det value because its sign is correct.
     */
    {
-      const GLfloat area = (setup->emaj.dx * setup->ebot.dy - 
+      const float area = (setup->emaj.dx * setup->ebot.dy - 
 			    setup->ebot.dx * setup->emaj.dy);
 
       setup->oneoverarea = 1.0 / area;
@@ -346,7 +347,7 @@ static GLboolean setup_sort_vertices( struct setup_stage *setup,
     */
    setup->quad.facing = (prim->det > 0.0) ^ (setup->softpipe->setup.front_winding == PIPE_WINDING_CW);
 
-   return GL_TRUE;
+   return TRUE;
 }
 
 
@@ -358,8 +359,8 @@ static GLboolean setup_sort_vertices( struct setup_stage *setup,
  * \param i  which component of the slot (0..3)
  */
 static void const_coeff( struct setup_stage *setup,
-			 GLuint slot,
-			 GLuint i )
+			 unsigned slot,
+			 unsigned i )
 {
    assert(slot < FRAG_ATTRIB_MAX);
    assert(i <= 3);
@@ -378,13 +379,13 @@ static void const_coeff( struct setup_stage *setup,
  * for a triangle.
  */
 static void tri_linear_coeff( struct setup_stage *setup,
-                              GLuint slot,
-                              GLuint i)
+                              unsigned slot,
+                              unsigned i)
 {
-   GLfloat botda = setup->vmid->data[slot][i] - setup->vmin->data[slot][i];
-   GLfloat majda = setup->vmax->data[slot][i] - setup->vmin->data[slot][i];
-   GLfloat a = setup->ebot.dy * majda - botda * setup->emaj.dy;
-   GLfloat b = setup->emaj.dx * botda - majda * setup->ebot.dx;
+   float botda = setup->vmid->data[slot][i] - setup->vmin->data[slot][i];
+   float majda = setup->vmax->data[slot][i] - setup->vmin->data[slot][i];
+   float a = setup->ebot.dy * majda - botda * setup->emaj.dy;
+   float b = setup->emaj.dx * botda - majda * setup->ebot.dx;
    
    assert(slot < FRAG_ATTRIB_MAX);
    assert(i <= 3);
@@ -423,19 +424,19 @@ static void tri_linear_coeff( struct setup_stage *setup,
  * for a triangle.
  */
 static void tri_persp_coeff( struct setup_stage *setup,
-                             GLuint slot,
-                             GLuint i )
+                             unsigned slot,
+                             unsigned i )
 {
    /* premultiply by 1/w:
     */
-   GLfloat mina = setup->vmin->data[slot][i] * setup->vmin->data[0][3];
-   GLfloat mida = setup->vmid->data[slot][i] * setup->vmid->data[0][3];
-   GLfloat maxa = setup->vmax->data[slot][i] * setup->vmax->data[0][3];
-
-   GLfloat botda = mida - mina;
-   GLfloat majda = maxa - mina;
-   GLfloat a = setup->ebot.dy * majda - botda * setup->emaj.dy;
-   GLfloat b = setup->emaj.dx * botda - majda * setup->ebot.dx;
+   float mina = setup->vmin->data[slot][i] * setup->vmin->data[0][3];
+   float mida = setup->vmid->data[slot][i] * setup->vmid->data[0][3];
+   float maxa = setup->vmax->data[slot][i] * setup->vmax->data[0][3];
+
+   float botda = mida - mina;
+   float majda = maxa - mina;
+   float a = setup->ebot.dy * majda - botda * setup->emaj.dy;
+   float b = setup->emaj.dx * botda - majda * setup->ebot.dx;
       
    assert(slot < FRAG_ATTRIB_MAX);
    assert(i <= 3);
@@ -455,7 +456,7 @@ static void tri_persp_coeff( struct setup_stage *setup,
 static void setup_tri_coefficients( struct setup_stage *setup )
 {
    const enum interp_mode *interp = setup->softpipe->interp;
-   GLuint slot, j;
+   unsigned slot, j;
 
    /* z and w are done by linear interpolation:
     */
@@ -488,25 +489,25 @@ static void setup_tri_coefficients( struct setup_stage *setup )
 
 static void setup_tri_edges( struct setup_stage *setup )
 {
-   GLfloat vmin_x = setup->vmin->data[0][0] + 0.5;
-   GLfloat vmid_x = setup->vmid->data[0][0] + 0.5;
+   float vmin_x = setup->vmin->data[0][0] + 0.5;
+   float vmid_x = setup->vmid->data[0][0] + 0.5;
 
-   GLfloat vmin_y = setup->vmin->data[0][1] - 0.5;
-   GLfloat vmid_y = setup->vmid->data[0][1] - 0.5;
-   GLfloat vmax_y = setup->vmax->data[0][1] - 0.5;
+   float vmin_y = setup->vmin->data[0][1] - 0.5;
+   float vmid_y = setup->vmid->data[0][1] - 0.5;
+   float vmax_y = setup->vmax->data[0][1] - 0.5;
 
    setup->emaj.sy = ceilf(vmin_y);
-   setup->emaj.lines = (GLint) ceilf(vmax_y - setup->emaj.sy);
+   setup->emaj.lines = (int) ceilf(vmax_y - setup->emaj.sy);
    setup->emaj.dxdy = setup->emaj.dx / setup->emaj.dy;
    setup->emaj.sx = vmin_x + (setup->emaj.sy - vmin_y) * setup->emaj.dxdy;
 
    setup->etop.sy = ceilf(vmid_y);
-   setup->etop.lines = (GLint) ceilf(vmax_y - setup->etop.sy);
+   setup->etop.lines = (int) ceilf(vmax_y - setup->etop.sy);
    setup->etop.dxdy = setup->etop.dx / setup->etop.dy;
    setup->etop.sx = vmid_x + (setup->etop.sy - vmid_y) * setup->etop.dxdy;
 
    setup->ebot.sy = ceilf(vmin_y);
-   setup->ebot.lines = (GLint) ceilf(vmid_y - setup->ebot.sy);
+   setup->ebot.lines = (int) ceilf(vmid_y - setup->ebot.sy);
    setup->ebot.dxdy = setup->ebot.dx / setup->ebot.dy;
    setup->ebot.sx = vmin_x + (setup->ebot.sy - vmin_y) * setup->ebot.dxdy;
 }
@@ -519,13 +520,13 @@ static void setup_tri_edges( struct setup_stage *setup )
 static void subtriangle( struct setup_stage *setup,
 			 struct edge *eleft,
 			 struct edge *eright,
-			 GLuint lines )
+			 unsigned lines )
 {
    const struct pipe_scissor_state *cliprect = &setup->softpipe->cliprect;
-   GLint y, start_y, finish_y;
-   GLint sy = (GLint)eleft->sy;
+   int y, start_y, finish_y;
+   int sy = (int)eleft->sy;
 
-   assert((GLint)eleft->sy == (GLint) eright->sy);
+   assert((int)eleft->sy == (int) eright->sy);
 
    /* clip top/bottom */
    start_y = sy;
@@ -552,8 +553,8 @@ static void subtriangle( struct setup_stage *setup,
        *
        * this is all drowned out by the attribute interpolation anyway.
        */
-      GLint left = (GLint)(eleft->sx + y * eleft->dxdy);
-      GLint right = (GLint)(eright->sx + y * eright->dxdy);
+      int left = (int)(eleft->sx + y * eleft->dxdy);
+      int right = (int)(eright->sx + y * eright->dxdy);
 
       /* clip left/right */
       if (left < cliprect->minx)
@@ -562,7 +563,7 @@ static void subtriangle( struct setup_stage *setup,
          right = cliprect->maxx;
 
       if (left < right) {
-	 GLint _y = sy+y;
+	 int _y = sy+y;
 	 if (block(_y) != setup->span.y) {
 	    flush_spans(setup);
 	    setup->span.y = block(_y);
@@ -633,11 +634,11 @@ static void setup_tri( struct draw_stage *stage,
  * for a line.
  */
 static void
-line_linear_coeff(struct setup_stage *setup, GLuint slot, GLuint i)
+line_linear_coeff(struct setup_stage *setup, unsigned slot, unsigned i)
 {
-   const GLfloat dz = setup->vmax->data[slot][i] - setup->vmin->data[slot][i];
-   const GLfloat dadx = dz * setup->emaj.dx * setup->oneoverarea;
-   const GLfloat dady = dz * setup->emaj.dy * setup->oneoverarea;
+   const float dz = setup->vmax->data[slot][i] - setup->vmin->data[slot][i];
+   const float dadx = dz * setup->emaj.dx * setup->oneoverarea;
+   const float dady = dz * setup->emaj.dy * setup->oneoverarea;
    setup->coef[slot].dadx[i] = dadx;
    setup->coef[slot].dady[i] = dady;
    setup->coef[slot].a0[i]
@@ -652,7 +653,7 @@ line_linear_coeff(struct setup_stage *setup, GLuint slot, GLuint i)
  * for a line.
  */
 static void
-line_persp_coeff(struct setup_stage *setup, GLuint slot, GLuint i)
+line_persp_coeff(struct setup_stage *setup, unsigned slot, unsigned i)
 {
    /* XXX to do */
    line_linear_coeff(setup, slot, i); /* XXX temporary */
@@ -667,7 +668,7 @@ static INLINE void
 setup_line_coefficients(struct setup_stage *setup, struct prim_header *prim)
 {
    const enum interp_mode *interp = setup->softpipe->interp;
-   GLuint slot, j;
+   unsigned slot, j;
 
    /* use setup->vmin, vmax to point to vertices */
    setup->vprovoke = prim->v[1];
@@ -712,13 +713,13 @@ setup_line_coefficients(struct setup_stage *setup, struct prim_header *prim)
  * Plot a pixel in a line segment.
  */
 static INLINE void
-plot(struct setup_stage *setup, GLint x, GLint y)
+plot(struct setup_stage *setup, int x, int y)
 {
-   const GLint iy = y & 1;
-   const GLint ix = x & 1;
-   const GLint quadX = x - ix;
-   const GLint quadY = y - iy;
-   const GLint mask = (1 << ix) << (2 * iy);
+   const int iy = y & 1;
+   const int ix = x & 1;
+   const int quadX = x - ix;
+   const int quadY = y - iy;
+   const int mask = (1 << ix) << (2 * iy);
 
    if (quadX != setup->quad.x0 || 
        quadY != setup->quad.y0) 
@@ -741,10 +742,10 @@ plot(struct setup_stage *setup, GLint x, GLint y)
  * Determine whether or not to emit a line fragment by checking
  * line stipple pattern.
  */
-static INLINE GLuint
-stipple_test(GLint counter, GLushort pattern, GLint factor)
+static INLINE unsigned
+stipple_test(int counter, ushort pattern, int factor)
 {
-   GLint b = (counter / factor) & 0xf;
+   int b = (counter / factor) & 0xf;
    return (1 << b) & pattern;
 }
 
@@ -761,13 +762,13 @@ setup_line(struct draw_stage *stage, struct prim_header *prim)
    struct setup_stage *setup = setup_stage( stage );
    struct softpipe_context *sp = setup->softpipe;
 
-   GLint x0 = (GLint) v0->data[0][0];
-   GLint x1 = (GLint) v1->data[0][0];
-   GLint y0 = (GLint) v0->data[0][1];
-   GLint y1 = (GLint) v1->data[0][1];
-   GLint dx = x1 - x0;
-   GLint dy = y1 - y0;
-   GLint xstep, ystep;
+   int x0 = (int) v0->data[0][0];
+   int x1 = (int) v1->data[0][0];
+   int y0 = (int) v0->data[0][1];
+   int y1 = (int) v1->data[0][1];
+   int dx = x1 - x0;
+   int dy = y1 - y0;
+   int xstep, ystep;
 
    if (dx == 0 && dy == 0)
       return;
@@ -806,10 +807,10 @@ setup_line(struct draw_stage *stage, struct prim_header *prim)
 
    if (dx > dy) {
       /*** X-major line ***/
-      GLint i;
-      const GLint errorInc = dy + dy;
-      GLint error = errorInc - dx;
-      const GLint errorDec = error - dx;
+      int i;
+      const int errorInc = dy + dy;
+      int error = errorInc - dx;
+      const int errorDec = error - dx;
 
       for (i = 0; i < dx; i++) {
          if (!sp->setup.line_stipple_enable ||
@@ -833,10 +834,10 @@ setup_line(struct draw_stage *stage, struct prim_header *prim)
    }
    else {
       /*** Y-major line ***/
-      GLint i;
-      const GLint errorInc = dx + dx;
-      GLint error = errorInc - dy;
-      const GLint errorDec = error - dy;
+      int i;
+      const int errorInc = dx + dx;
+      int error = errorInc - dy;
+      const int errorDec = error - dy;
 
       for (i = 0; i < dy; i++) {
          if (!sp->setup.line_stipple_enable ||
@@ -877,12 +878,12 @@ setup_point(struct draw_stage *stage, struct prim_header *prim)
 {
    struct setup_stage *setup = setup_stage( stage );
    /*XXX this should be a vertex attrib! */
-   const GLfloat halfSize = 0.5 * setup->softpipe->setup.point_size;
-   const GLboolean round = setup->softpipe->setup.point_smooth;
+   const float halfSize = 0.5 * setup->softpipe->setup.point_size;
+   const boolean round = setup->softpipe->setup.point_smooth;
    const struct vertex_header *v0 = prim->v[0];
-   const GLfloat x = v0->data[FRAG_ATTRIB_WPOS][0];
-   const GLfloat y = v0->data[FRAG_ATTRIB_WPOS][1];
-   GLuint slot, j;
+   const float x = v0->data[FRAG_ATTRIB_WPOS][0];
+   const float y = v0->data[FRAG_ATTRIB_WPOS][1];
+   unsigned slot, j;
 
    /* For points, all interpolants are constant-valued.
     * However, for point sprites, we'll need to setup texcoords appropriately.
@@ -912,31 +913,31 @@ setup_point(struct draw_stage *stage, struct prim_header *prim)
 
    if (halfSize <= 0.5 && !round) {
       /* special case for 1-pixel points */
-      const GLint ix = ((GLint) x) & 1;
-      const GLint iy = ((GLint) y) & 1;
+      const int ix = ((int) x) & 1;
+      const int iy = ((int) y) & 1;
       setup->quad.x0 = x - ix;
       setup->quad.y0 = y - iy;
       setup->quad.mask = (1 << ix) << (2 * iy);
       clip_emit_quad(setup);
    }
    else {
-      const GLint ixmin = block((GLint) (x - halfSize));
-      const GLint ixmax = block((GLint) (x + halfSize));
-      const GLint iymin = block((GLint) (y - halfSize));
-      const GLint iymax = block((GLint) (y + halfSize));
-      GLint ix, iy;
+      const int ixmin = block((int) (x - halfSize));
+      const int ixmax = block((int) (x + halfSize));
+      const int iymin = block((int) (y - halfSize));
+      const int iymax = block((int) (y + halfSize));
+      int ix, iy;
 
       if (round) {
          /* rounded points */
-         const GLfloat rmin = halfSize - 0.7071F;  /* 0.7071 = sqrt(2)/2 */
-         const GLfloat rmax = halfSize + 0.7071F;
-         const GLfloat rmin2 = MAX2(0.0F, rmin * rmin);
-         const GLfloat rmax2 = rmax * rmax;
-         const GLfloat cscale = 1.0F / (rmax2 - rmin2);
+         const float rmin = halfSize - 0.7071F;  /* 0.7071 = sqrt(2)/2 */
+         const float rmax = halfSize + 0.7071F;
+         const float rmin2 = MAX2(0.0F, rmin * rmin);
+         const float rmax2 = rmax * rmax;
+         const float cscale = 1.0F / (rmax2 - rmin2);
 
          for (iy = iymin; iy <= iymax; iy += 2) {
             for (ix = ixmin; ix <= ixmax; ix += 2) {
-               GLfloat dx, dy, dist2, cover;
+               float dx, dy, dist2, cover;
 
                setup->quad.mask = 0x0;
 
diff --git a/src/mesa/pipe/softpipe/sp_prim_setup.h b/src/mesa/pipe/softpipe/sp_prim_setup.h
index 0180454a8d2..dece42fe457 100644
--- a/src/mesa/pipe/softpipe/sp_prim_setup.h
+++ b/src/mesa/pipe/softpipe/sp_prim_setup.h
@@ -37,86 +37,12 @@
  * all the enabled attributes run contiguously.
  */
 
-#include "glheader.h"
-#include "imports.h"
-#if 0
-#include "s_tri_public.h"
-#include "s_context.h"
-#endif
+struct draw_stage;
+struct softpipe_context;
 
 
 extern struct draw_stage *sp_draw_render_stage( struct softpipe_context *softpipe );
 
 
-#if 0 /* UNUSED? */
-struct tri_context;
-struct fp_context;
-struct be_context;
-
-/* Note the rasterizer does not take a GLcontext argument.  This is
- * deliberate.
- */
-struct tri_context *tri_create_context( GLcontext *ctx );
-
-void tri_destroy_context( struct tri_context *tri );
-
-void tri_set_fp_context( struct tri_context *tri,
-			 struct fp_context *fp,
-			 void (*fp_run)( struct fp_context *fp,
-					 const struct fp_inputs *,
-					 struct fp_outputs * ));
-
-
-void tri_set_be_context( struct tri_context *tri,
-			 struct be_context *be,
-			 void (*be_run)( struct be_context *be,
-					 const struct fp_outputs * ));
-
-void tri_set_attribs( struct tri_context *tri,
-		      const struct attr_info *info,
-		      GLuint nr_attrib );
-
-void tri_set_backface( struct tri_context *tri,
-		       GLfloat backface );
-					       
-void tri_set_scissor( struct tri_context *tri,
-		      GLint x,
-		      GLint y,
-		      GLuint width,
-		      GLuint height,
-		      GLboolean enabled );
-
-void tri_set_stipple( struct tri_context *tri,
-		      const GLuint *pattern,
-		      GLboolean enabled );
-
-/* Unfilled triangles will be handled elsewhere (higher in the
- * pipeline), as will things like stipple (lower in the pipeline).
- */
-
-void tri_triangle( struct tri_context *tri,
-		   const struct vertex *v0,
-		   const struct vertex *v1,
-		   const struct vertex *v2 );
-
-/* TODO: rasterize_line, rasterize_point?? 
- * How will linestipple work?
- */
-
-
-#ifdef SETUP_PRIVATE
-
-GLboolean tri_setup( struct tri_context *tri,
-		       const struct vertex *v0,
-		       const struct vertex *v1,
-		       const struct vertex *v2 );
-
-void tri_rasterize( struct tri_context *tri );
-void tri_rasterize_spans( struct tri_context *tri );
-
-#endif
-
-
-#endif
 
 #endif /* SP_PRIM_SETUP_H */
diff --git a/src/mesa/pipe/softpipe/sp_quad_alpha_test.c b/src/mesa/pipe/softpipe/sp_quad_alpha_test.c
index 1c519070787..64c1624bd0e 100644
--- a/src/mesa/pipe/softpipe/sp_quad_alpha_test.c
+++ b/src/mesa/pipe/softpipe/sp_quad_alpha_test.c
@@ -3,20 +3,19 @@
  * quad alpha test
  */
 
-#include "glheader.h"
-#include "imports.h"
 #include "sp_context.h"
 #include "sp_headers.h"
 #include "sp_quad.h"
 #include "pipe/p_defines.h"
+#include "pipe/p_util.h"
 
 
 static void
 alpha_test_quad(struct quad_stage *qs, struct quad_header *quad)
 {
    struct softpipe_context *softpipe = qs->softpipe;
-   const GLfloat ref = softpipe->alpha_test.ref;
-   GLuint passMask = 0x0, j;
+   const float ref = softpipe->alpha_test.ref;
+   unsigned passMask = 0x0, j;
 
    switch (softpipe->alpha_test.func) {
    case PIPE_FUNC_NEVER:
diff --git a/src/mesa/pipe/softpipe/sp_quad_blend.c b/src/mesa/pipe/softpipe/sp_quad_blend.c
index 09d0aa258c7..7e8851d214a 100644
--- a/src/mesa/pipe/softpipe/sp_quad_blend.c
+++ b/src/mesa/pipe/softpipe/sp_quad_blend.c
@@ -30,10 +30,8 @@
  * \author Brian Paul
  */
 
-#include "glheader.h"
-#include "imports.h"
-#include "macros.h"
 #include "pipe/p_defines.h"
+#include "pipe/p_util.h"
 #include "sp_context.h"
 #include "sp_headers.h"
 #include "sp_surface.h"
@@ -101,11 +99,11 @@ do { \
 static void
 blend_quad(struct quad_stage *qs, struct quad_header *quad)
 {
-   static const GLfloat zero[4] = { 0, 0, 0, 0 };
-   static const GLfloat one[4] = { 1, 1, 1, 1 };
+   static const float zero[4] = { 0, 0, 0, 0 };
+   static const float one[4] = { 1, 1, 1, 1 };
    struct softpipe_context *softpipe = qs->softpipe;
    struct softpipe_surface *sps = softpipe_surface(softpipe->cbuf);
-   GLfloat source[4][QUAD_SIZE], dest[4][QUAD_SIZE];
+   float source[4][QUAD_SIZE], dest[4][QUAD_SIZE];
    
    /* get colors from framebuffer */
    sps->read_quad_f_swz(sps, quad->x0, quad->y0, dest);
@@ -126,7 +124,7 @@ blend_quad(struct quad_stage *qs, struct quad_header *quad)
       break;
    case PIPE_BLENDFACTOR_SRC_ALPHA:
       {
-         const GLfloat *alpha = quad->outputs.color[3];
+         const float *alpha = quad->outputs.color[3];
          VEC4_MUL(source[0], quad->outputs.color[0], alpha); /* R */
          VEC4_MUL(source[1], quad->outputs.color[1], alpha); /* G */
          VEC4_MUL(source[2], quad->outputs.color[2], alpha); /* B */
@@ -139,7 +137,7 @@ blend_quad(struct quad_stage *qs, struct quad_header *quad)
       break;
    case PIPE_BLENDFACTOR_DST_ALPHA:
       {
-         const GLfloat *alpha = dest[3];
+         const float *alpha = dest[3];
          VEC4_MUL(source[0], quad->outputs.color[0], alpha); /* R */
          VEC4_MUL(source[1], quad->outputs.color[1], alpha); /* G */
          VEC4_MUL(source[2], quad->outputs.color[2], alpha); /* B */
@@ -150,7 +148,7 @@ blend_quad(struct quad_stage *qs, struct quad_header *quad)
       break;
    case PIPE_BLENDFACTOR_CONST_COLOR:
       {
-         GLfloat comp[4];
+         float comp[4];
          VEC4_SCALAR(comp, softpipe->blend_color.color[0]); /* R */
          VEC4_MUL(source[0], quad->outputs.color[0], comp); /* R */
          VEC4_SCALAR(comp, softpipe->blend_color.color[1]); /* G */
@@ -161,7 +159,7 @@ blend_quad(struct quad_stage *qs, struct quad_header *quad)
       break;
    case PIPE_BLENDFACTOR_CONST_ALPHA:
       {
-         GLfloat alpha[4];
+         float alpha[4];
          VEC4_SCALAR(alpha, softpipe->blend_color.color[3]);
          VEC4_MUL(source[0], quad->outputs.color[0], alpha); /* R */
          VEC4_MUL(source[1], quad->outputs.color[1], alpha); /* G */
@@ -181,7 +179,7 @@ blend_quad(struct quad_stage *qs, struct quad_header *quad)
       break;
    case PIPE_BLENDFACTOR_INV_SRC_COLOR:
       {
-         GLfloat inv_comp[4];
+         float inv_comp[4];
          VEC4_SUB(inv_comp, one, quad->outputs.color[0]); /* R */
          VEC4_MUL(source[0], quad->outputs.color[0], inv_comp); /* R */
          VEC4_SUB(inv_comp, one, quad->outputs.color[1]); /* G */
@@ -192,7 +190,7 @@ blend_quad(struct quad_stage *qs, struct quad_header *quad)
       break;
    case PIPE_BLENDFACTOR_INV_SRC_ALPHA:
       {
-         GLfloat inv_alpha[4];
+         float inv_alpha[4];
          VEC4_SUB(inv_alpha, one, quad->outputs.color[3]);
          VEC4_MUL(source[0], quad->outputs.color[0], inv_alpha); /* R */
          VEC4_MUL(source[1], quad->outputs.color[1], inv_alpha); /* G */
@@ -201,7 +199,7 @@ blend_quad(struct quad_stage *qs, struct quad_header *quad)
       break;
    case PIPE_BLENDFACTOR_INV_DST_ALPHA:
       {
-         GLfloat inv_alpha[4];
+         float inv_alpha[4];
          VEC4_SUB(inv_alpha, one, dest[3]);
          VEC4_MUL(source[0], quad->outputs.color[0], inv_alpha); /* R */
          VEC4_MUL(source[1], quad->outputs.color[1], inv_alpha); /* G */
@@ -210,7 +208,7 @@ blend_quad(struct quad_stage *qs, struct quad_header *quad)
       break;
    case PIPE_BLENDFACTOR_INV_DST_COLOR:
       {
-         GLfloat inv_comp[4];
+         float inv_comp[4];
          VEC4_SUB(inv_comp, one, dest[0]); /* R */
          VEC4_MUL(source[0], quad->outputs.color[0], inv_comp); /* R */
          VEC4_SUB(inv_comp, one, dest[1]); /* G */
@@ -221,7 +219,7 @@ blend_quad(struct quad_stage *qs, struct quad_header *quad)
       break;
    case PIPE_BLENDFACTOR_INV_CONST_COLOR:
       {
-         GLfloat inv_comp[4];
+         float inv_comp[4];
          /* R */
          VEC4_SCALAR(inv_comp, 1.0 - softpipe->blend_color.color[0]);
          VEC4_MUL(source[0], quad->outputs.color[0], inv_comp);
@@ -235,7 +233,7 @@ blend_quad(struct quad_stage *qs, struct quad_header *quad)
       break;
    case PIPE_BLENDFACTOR_INV_CONST_ALPHA:
       {
-         GLfloat alpha[4], inv_alpha[4];
+         float alpha[4], inv_alpha[4];
          VEC4_SCALAR(alpha, 1.0 - softpipe->blend_color.color[3]);
          VEC4_MUL(source[0], quad->outputs.color[0], inv_alpha); /* R */
          VEC4_MUL(source[1], quad->outputs.color[1], inv_alpha); /* G */
@@ -261,7 +259,7 @@ blend_quad(struct quad_stage *qs, struct quad_header *quad)
       break;
    case PIPE_BLENDFACTOR_SRC_ALPHA:
       {
-         const GLfloat *alpha = quad->outputs.color[3];
+         const float *alpha = quad->outputs.color[3];
          VEC4_MUL(source[3], quad->outputs.color[3], alpha); /* A */
       }
       break;
@@ -283,7 +281,7 @@ blend_quad(struct quad_stage *qs, struct quad_header *quad)
       break;
    case PIPE_BLENDFACTOR_INV_SRC_ALPHA:
       {
-         GLfloat one_minus_alpha[QUAD_SIZE];
+         float one_minus_alpha[QUAD_SIZE];
          VEC4_SUB(one_minus_alpha, one, quad->outputs.color[3]);
          VEC4_MUL(dest[0], dest[0], one_minus_alpha); /* R */
          VEC4_MUL(dest[1], dest[1], one_minus_alpha); /* G */
@@ -309,7 +307,7 @@ blend_quad(struct quad_stage *qs, struct quad_header *quad)
       break;
    case PIPE_BLENDFACTOR_INV_SRC_ALPHA:
       {
-         GLfloat one_minus_alpha[QUAD_SIZE];
+         float one_minus_alpha[QUAD_SIZE];
          VEC4_SUB(one_minus_alpha, one, quad->outputs.color[3]);
          VEC4_MUL(dest[3], dest[3], one_minus_alpha); /* A */
       }
diff --git a/src/mesa/pipe/softpipe/sp_quad_bufloop.c b/src/mesa/pipe/softpipe/sp_quad_bufloop.c
index c459a9e8b07..ae2fb5ef973 100644
--- a/src/mesa/pipe/softpipe/sp_quad_bufloop.c
+++ b/src/mesa/pipe/softpipe/sp_quad_bufloop.c
@@ -1,7 +1,5 @@
 
-
-#include "main/glheader.h"
-#include "main/imports.h"
+#include "pipe/p_util.h"
 #include "sp_context.h"
 #include "sp_headers.h"
 #include "sp_surface.h"
@@ -15,8 +13,8 @@ static void
 cbuf_loop_quad(struct quad_stage *qs, struct quad_header *quad)
 {
    struct softpipe_context *softpipe = qs->softpipe;
-   GLfloat tmp[4][QUAD_SIZE];
-   GLuint i;
+   float tmp[4][QUAD_SIZE];
+   unsigned i;
 
    assert(sizeof(quad->outputs.color) == sizeof(tmp));
    assert(softpipe->framebuffer.num_cbufs <= PIPE_MAX_COLOR_BUFS);
diff --git a/src/mesa/pipe/softpipe/sp_quad_colormask.c b/src/mesa/pipe/softpipe/sp_quad_colormask.c
index 5102a000b52..7bb65bf8c80 100644
--- a/src/mesa/pipe/softpipe/sp_quad_colormask.c
+++ b/src/mesa/pipe/softpipe/sp_quad_colormask.c
@@ -30,10 +30,8 @@
  * \author Brian Paul
  */
 
-#include "main/glheader.h"
-#include "main/imports.h"
-#include "main/macros.h"
 #include "pipe/p_defines.h"
+#include "pipe/p_util.h"
 #include "sp_context.h"
 #include "sp_headers.h"
 #include "sp_surface.h"
@@ -46,25 +44,25 @@ colormask_quad(struct quad_stage *qs, struct quad_header *quad)
 {
    struct softpipe_context *softpipe = qs->softpipe;
    struct softpipe_surface *sps = softpipe_surface(softpipe->cbuf);
-   GLfloat dest[4][QUAD_SIZE];
+   float dest[4][QUAD_SIZE];
    
    sps->read_quad_f_swz(sps, quad->x0, quad->y0, dest);
 
    /* R */
    if (!(softpipe->blend.colormask & PIPE_MASK_R))
-       COPY_4FV(quad->outputs.color[0], dest[0]);
+       COPY_4V(quad->outputs.color[0], dest[0]);
 
    /* G */
    if (!(softpipe->blend.colormask & PIPE_MASK_G))
-       COPY_4FV(quad->outputs.color[1], dest[1]);
+       COPY_4V(quad->outputs.color[1], dest[1]);
 
    /* B */
    if (!(softpipe->blend.colormask & PIPE_MASK_B))
-       COPY_4FV(quad->outputs.color[2], dest[2]);
+       COPY_4V(quad->outputs.color[2], dest[2]);
 
    /* A */
    if (!(softpipe->blend.colormask & PIPE_MASK_A))
-       COPY_4FV(quad->outputs.color[3], dest[3]);
+       COPY_4V(quad->outputs.color[3], dest[3]);
 
    /* pass quad to next stage */
    qs->next->run(qs->next, quad);
diff --git a/src/mesa/pipe/softpipe/sp_quad_coverage.c b/src/mesa/pipe/softpipe/sp_quad_coverage.c
index efeb85aab98..8dfec593500 100644
--- a/src/mesa/pipe/softpipe/sp_quad_coverage.c
+++ b/src/mesa/pipe/softpipe/sp_quad_coverage.c
@@ -32,9 +32,8 @@
  */
 
 
-#include "main/glheader.h"
-#include "main/macros.h"
 #include "pipe/p_defines.h"
+#include "pipe/p_util.h"
 #include "sp_context.h"
 #include "sp_headers.h"
 #include "sp_quad.h"
@@ -51,7 +50,7 @@ coverage_quad(struct quad_stage *qs, struct quad_header *quad)
    if ((softpipe->setup.poly_smooth && quad->prim == PRIM_TRI) ||
        (softpipe->setup.line_smooth && quad->prim == PRIM_LINE) ||
        (softpipe->setup.point_smooth && quad->prim == PRIM_POINT)) {
-      GLuint j;
+      unsigned j;
       for (j = 0; j < QUAD_SIZE; j++) {
          assert(quad->coverage[j] >= 0.0);
          assert(quad->coverage[j] <= 1.0);
diff --git a/src/mesa/pipe/softpipe/sp_quad_depth_test.c b/src/mesa/pipe/softpipe/sp_quad_depth_test.c
index 28f264b3c4a..5d46e70393d 100644
--- a/src/mesa/pipe/softpipe/sp_quad_depth_test.c
+++ b/src/mesa/pipe/softpipe/sp_quad_depth_test.c
@@ -26,9 +26,8 @@
  * \brief  Quad depth testing
  */
 
-#include "main/glheader.h"
-#include "main/imports.h"
 #include "pipe/p_defines.h"
+#include "pipe/p_util.h"
 #include "sp_context.h"
 #include "sp_headers.h"
 #include "sp_surface.h"
@@ -44,11 +43,11 @@ sp_depth_test_quad(struct quad_stage *qs, struct quad_header *quad)
 {
    struct softpipe_context *softpipe = qs->softpipe;
    struct softpipe_surface *sps = softpipe_surface(softpipe->framebuffer.zbuf);
-   GLuint bzzzz[QUAD_SIZE];  /**< Z values fetched from depth buffer */
-   GLuint qzzzz[QUAD_SIZE];  /**< Z values from the quad */
-   GLuint zmask = 0;
-   GLuint j;
-   GLfloat scale;
+   unsigned bzzzz[QUAD_SIZE];  /**< Z values fetched from depth buffer */
+   unsigned qzzzz[QUAD_SIZE];  /**< Z values from the quad */
+   unsigned zmask = 0;
+   unsigned j;
+   float scale;
 
    assert(sps); /* shouldn't get here if there's no zbuffer */
 
@@ -72,7 +71,7 @@ sp_depth_test_quad(struct quad_stage *qs, struct quad_header *quad)
     * Z-fighting errors.
     */
    for (j = 0; j < QUAD_SIZE; j++) {
-      qzzzz[j] = (GLuint) (quad->outputs.depth[j] * scale);
+      qzzzz[j] = (unsigned) (quad->outputs.depth[j] * scale);
    }
 
    /* get zquad from zbuffer */
diff --git a/src/mesa/pipe/softpipe/sp_quad_fs.c b/src/mesa/pipe/softpipe/sp_quad_fs.c
index e767d0a470e..edb3245cbae 100644
--- a/src/mesa/pipe/softpipe/sp_quad_fs.c
+++ b/src/mesa/pipe/softpipe/sp_quad_fs.c
@@ -32,8 +32,6 @@
  * all the enabled attributes run contiguously.
  */
 
-#include "main/mtypes.h"
-
 #include "pipe/p_util.h"
 #include "tgsi/core/tgsi_core.h"
 
@@ -42,6 +40,8 @@
 #include "sp_quad.h"
 #include "sp_tex_sample.h"
 
+#include "main/mtypes.h"
+
 #if 0
 #if defined __GNUC__
 #define ALIGNED_ATTRIBS 1
@@ -73,9 +73,9 @@ struct exec_machine {
    const struct setup_coefficient *coef; /**< will point to quad->coef */
 
 #if ALIGNED_ATTRIBS
-   GLfloat attr[PIPE_ATTRIB_MAX][NUM_CHANNELS][QUAD_SIZE] __attribute__(( aligned( 16 ) ));
+   float attr[PIPE_ATTRIB_MAX][NUM_CHANNELS][QUAD_SIZE] __attribute__(( aligned( 16 ) ));
 #else
-   GLfloat attr[PIPE_ATTRIB_MAX][NUM_CHANNELS][QUAD_SIZE];
+   float attr[PIPE_ATTRIB_MAX][NUM_CHANNELS][QUAD_SIZE];
 #endif
 };
 
@@ -84,10 +84,10 @@ struct exec_machine {
  * Compute quad's attributes values, as constants (GL_FLAT shading).
  */
 static INLINE void cinterp( struct exec_machine *exec,
-			    GLuint attrib,
-			    GLuint i )
+			    unsigned attrib,
+			    unsigned i )
 {
-   GLuint j;
+   unsigned j;
 
    for (j = 0; j < QUAD_SIZE; j++) {
       exec->attr[attrib][i][j] = exec->coef[attrib].a0[i];
@@ -104,14 +104,14 @@ static INLINE void cinterp( struct exec_machine *exec,
  *   INPUT[attr] = MAD INPUT[attr],   COEF_DADY[attr], INPUT_WPOS.yyyy
  */
 static INLINE void linterp( struct exec_machine *exec,
-			    GLuint attrib,
-			    GLuint i )
+			    unsigned attrib,
+			    unsigned i )
 {
-   GLuint j;
+   unsigned j;
 
    for (j = 0; j < QUAD_SIZE; j++) {
-      const GLfloat x = exec->attr[FRAG_ATTRIB_WPOS][0][j];
-      const GLfloat y = exec->attr[FRAG_ATTRIB_WPOS][1][j];
+      const float x = exec->attr[FRAG_ATTRIB_WPOS][0][j];
+      const float y = exec->attr[FRAG_ATTRIB_WPOS][1][j];
       exec->attr[attrib][i][j] = (exec->coef[attrib].a0[i] +
 				  exec->coef[attrib].dadx[i] * x + 
 				  exec->coef[attrib].dady[i] * y);
@@ -132,16 +132,16 @@ static INLINE void linterp( struct exec_machine *exec,
  *
  */
 static INLINE void pinterp( struct exec_machine *exec,
-			    GLuint attrib,
-			    GLuint i )
+			    unsigned attrib,
+			    unsigned i )
 {
-   GLuint j;
+   unsigned j;
 
    for (j = 0; j < QUAD_SIZE; j++) {
-      const GLfloat x = exec->attr[FRAG_ATTRIB_WPOS][0][j];
-      const GLfloat y = exec->attr[FRAG_ATTRIB_WPOS][1][j];
+      const float x = exec->attr[FRAG_ATTRIB_WPOS][0][j];
+      const float y = exec->attr[FRAG_ATTRIB_WPOS][1][j];
       /* FRAG_ATTRIB_WPOS.w here is really 1/w */
-      const GLfloat w = 1.0 / exec->attr[FRAG_ATTRIB_WPOS][3][j];
+      const float w = 1.0 / exec->attr[FRAG_ATTRIB_WPOS][3][j];
       exec->attr[attrib][i][j] = ((exec->coef[attrib].a0[i] +
 				   exec->coef[attrib].dadx[i] * x + 
 				   exec->coef[attrib].dady[i] * y) * w);
@@ -158,9 +158,9 @@ shade_quad( struct quad_stage *qs, struct quad_header *quad )
    struct quad_shade_stage *qss = quad_shade_stage(qs);
    struct softpipe_context *softpipe = qs->softpipe;
    struct exec_machine exec;
-   const GLfloat fx = quad->x0;
-   const GLfloat fy = quad->y0;
-   GLuint attr, i;
+   const float fx = quad->x0;
+   const float fy = quad->y0;
+   unsigned attr, i;
 
    exec.coef = quad->coef;
 
@@ -216,7 +216,7 @@ shade_quad( struct quad_stage *qs, struct quad_header *quad )
       struct tgsi_exec_machine machine;
       struct tgsi_exec_vector outputs[FRAG_ATTRIB_MAX + 1];
       struct tgsi_exec_vector *aoutputs;
-      GLuint i;
+      unsigned i;
 
 #if !ALIGNED_ATTRIBS
       struct tgsi_exec_vector inputs[FRAG_ATTRIB_MAX + 1];
@@ -289,7 +289,7 @@ shade_quad( struct quad_stage *qs, struct quad_header *quad )
    }
 #else
    {
-      GLuint attr = softpipe->fp_attr_to_slot[FRAG_ATTRIB_COL0];
+      unsigned attr = softpipe->fp_attr_to_slot[FRAG_ATTRIB_COL0];
       assert(attr);
 
       memcpy(quad->outputs.color, 
@@ -318,7 +318,7 @@ static void shade_begin(struct quad_stage *qs)
 {
    struct quad_shade_stage *qss = quad_shade_stage(qs);
    struct softpipe_context *softpipe = qs->softpipe;
-   GLuint i, entry;
+   unsigned i, entry;
 
    for (i = 0; i < PIPE_MAX_SAMPLERS; i++) {
       qss->samplers[i].state = &softpipe->sampler[i];
diff --git a/src/mesa/pipe/softpipe/sp_quad_occlusion.c b/src/mesa/pipe/softpipe/sp_quad_occlusion.c
index 8073f94553a..6b094a5befb 100644
--- a/src/mesa/pipe/softpipe/sp_quad_occlusion.c
+++ b/src/mesa/pipe/softpipe/sp_quad_occlusion.c
@@ -32,9 +32,8 @@
  */
 
 
-#include "main/glheader.h"
-#include "main/imports.h"
 #include "pipe/p_defines.h"
+#include "pipe/p_util.h"
 #include "sp_context.h"
 #include "sp_headers.h"
 #include "sp_surface.h"
diff --git a/src/mesa/pipe/softpipe/sp_quad_output.c b/src/mesa/pipe/softpipe/sp_quad_output.c
index 62f466be5d0..49420c4fe7d 100644
--- a/src/mesa/pipe/softpipe/sp_quad_output.c
+++ b/src/mesa/pipe/softpipe/sp_quad_output.c
@@ -31,20 +31,18 @@
  * Attributes are assumed to be 4 floats wide but are packed so that
  * all the enabled attributes run contiguously.
  */
-
-#include "glheader.h"
-#include "imports.h"
+#include "pipe/p_util.h"
 #include "sp_context.h"
 #include "sp_headers.h"
 #include "sp_surface.h"
 #include "sp_quad.h"
 
 
-static void mask_copy( GLfloat (*dest)[4],
-		       GLfloat (*src)[4],
-		       GLuint mask )
+static void mask_copy( float (*dest)[4],
+		       float (*src)[4],
+		       unsigned mask )
 {
-   GLuint i, j;
+   unsigned i, j;
 
    for (i = 0; i < 4; i++) {
       if (mask & (1<<i)) {
@@ -68,7 +66,7 @@ output_quad(struct quad_stage *qs, struct quad_header *quad)
    struct softpipe_surface *sps = softpipe_surface(softpipe->cbuf);
 
    if (quad->mask != MASK_ALL) {
-      GLfloat tmp[4][QUAD_SIZE];
+      float tmp[4][QUAD_SIZE];
 
       /* XXX probably add a masked-write function someday */
 
diff --git a/src/mesa/pipe/softpipe/sp_quad_stencil.c b/src/mesa/pipe/softpipe/sp_quad_stencil.c
index 857f1a5989b..47b3b4f0893 100644
--- a/src/mesa/pipe/softpipe/sp_quad_stencil.c
+++ b/src/mesa/pipe/softpipe/sp_quad_stencil.c
@@ -4,13 +4,12 @@
  */
 
 
-#include "main/glheader.h"
-#include "main/imports.h"
 #include "sp_context.h"
 #include "sp_headers.h"
 #include "sp_surface.h"
 #include "sp_quad.h"
 #include "pipe/p_defines.h"
+#include "pipe/p_util.h"
 
 
 /** Only 8-bit stencil supported */
@@ -28,12 +27,12 @@
  *                 values and ref value are to be used.
  * \return mask indicating which pixels passed the stencil test
  */
-static GLbitfield
-do_stencil_test(const GLubyte stencilVals[QUAD_SIZE], GLuint func,
-                GLbitfield ref, GLbitfield valMask)
+static unsigned
+do_stencil_test(const ubyte stencilVals[QUAD_SIZE], unsigned func,
+                unsigned ref, unsigned valMask)
 {
-   GLbitfield passMask = 0x0;
-   GLuint j;
+   unsigned passMask = 0x0;
+   unsigned j;
 
    ref &= valMask;
 
@@ -105,11 +104,11 @@ do_stencil_test(const GLubyte stencilVals[QUAD_SIZE], GLuint func,
  *                 stencil values
  */
 static void
-apply_stencil_op(GLubyte stencilVals[QUAD_SIZE],
-                 GLbitfield mask, GLuint op, GLubyte ref, GLubyte wrtMask)
+apply_stencil_op(ubyte stencilVals[QUAD_SIZE],
+                 unsigned mask, unsigned op, ubyte ref, ubyte wrtMask)
 {
-   GLuint j;
-   GLubyte newstencil[QUAD_SIZE];
+   unsigned j;
+   ubyte newstencil[QUAD_SIZE];
 
    for (j = 0; j < QUAD_SIZE; j++) {
       newstencil[j] = stencilVals[j];
@@ -202,9 +201,9 @@ stencil_test_quad(struct quad_stage *qs, struct quad_header *quad)
 {
    struct softpipe_context *softpipe = qs->softpipe;
    struct softpipe_surface *s_surf = softpipe_surface(softpipe->framebuffer.sbuf);
-   GLuint func, zFailOp, zPassOp, failOp;
-   GLubyte ref, wrtMask, valMask;
-   GLubyte stencilVals[QUAD_SIZE];
+   unsigned func, zFailOp, zPassOp, failOp;
+   ubyte ref, wrtMask, valMask;
+   ubyte stencilVals[QUAD_SIZE];
 
    /* choose front or back face function, operator, etc */
    /* XXX we could do these initializations once per primitive */
@@ -232,7 +231,7 @@ stencil_test_quad(struct quad_stage *qs, struct quad_header *quad)
 
    /* do the stencil test first */
    {
-      GLbitfield passMask, failMask;
+      unsigned passMask, failMask;
       passMask = do_stencil_test(stencilVals, func, ref, valMask);
       failMask = quad->mask & ~passMask;
       quad->mask &= passMask;
@@ -246,18 +245,18 @@ stencil_test_quad(struct quad_stage *qs, struct quad_header *quad)
 
       /* now the pixels that passed the stencil test are depth tested */
       if (softpipe->depth_test.enabled) {
-         const GLbitfield origMask = quad->mask;
+         const unsigned origMask = quad->mask;
 
          sp_depth_test_quad(qs, quad);  /* quad->mask is updated */
 
          /* update stencil buffer values according to z pass/fail result */
          if (zFailOp != PIPE_STENCIL_OP_KEEP) {
-            const GLbitfield failMask = origMask & ~quad->mask;
+            const unsigned failMask = origMask & ~quad->mask;
             apply_stencil_op(stencilVals, failMask, zFailOp, ref, wrtMask);
          }
 
          if (zPassOp != PIPE_STENCIL_OP_KEEP) {
-            const GLbitfield passMask = origMask & quad->mask;
+            const unsigned passMask = origMask & quad->mask;
             apply_stencil_op(stencilVals, passMask, zPassOp, ref, wrtMask);
          }
       }
diff --git a/src/mesa/pipe/softpipe/sp_quad_stipple.c b/src/mesa/pipe/softpipe/sp_quad_stipple.c
index 6e93bf81f1c..cb127095d70 100644
--- a/src/mesa/pipe/softpipe/sp_quad_stipple.c
+++ b/src/mesa/pipe/softpipe/sp_quad_stipple.c
@@ -3,12 +3,11 @@
  * quad polygon stipple stage
  */
 
-#include "glheader.h"
-#include "imports.h"
 #include "sp_context.h"
 #include "sp_headers.h"
 #include "sp_quad.h"
 #include "pipe/p_defines.h"
+#include "pipe/p_util.h"
 
 
 /**
@@ -19,10 +18,10 @@ stipple_quad(struct quad_stage *qs, struct quad_header *quad)
 {
    if (quad->prim == PRIM_TRI) {
       struct softpipe_context *softpipe = qs->softpipe;
-      const GLint col0 = quad->x0 % 32;
-      const GLint row0 = quad->y0 % 32;
-      const GLuint stipple0 = softpipe->poly_stipple.stipple[row0];
-      const GLuint stipple1 = softpipe->poly_stipple.stipple[row0 + 1];
+      const int col0 = quad->x0 % 32;
+      const int row0 = quad->y0 % 32;
+      const unsigned stipple0 = softpipe->poly_stipple.stipple[row0];
+      const unsigned stipple1 = softpipe->poly_stipple.stipple[row0 + 1];
 
       /* XXX there may be a better way to lay out the stored stipple
        * values to further simplify this computation.
diff --git a/src/mesa/pipe/softpipe/sp_region.c b/src/mesa/pipe/softpipe/sp_region.c
index 10b7479e975..231ea1ea223 100644
--- a/src/mesa/pipe/softpipe/sp_region.c
+++ b/src/mesa/pipe/softpipe/sp_region.c
@@ -54,7 +54,7 @@ sp_region_idle(struct pipe_context *pipe, struct pipe_region *region)
 }
 
 
-static GLubyte *
+static ubyte *
 sp_region_map(struct pipe_context *pipe, struct pipe_region *region)
 {
    struct softpipe_context *sp = softpipe_context( pipe );
@@ -83,7 +83,7 @@ sp_region_unmap(struct pipe_context *pipe, struct pipe_region *region)
 
 static struct pipe_region *
 sp_region_alloc(struct pipe_context *pipe,
-		GLuint cpp, GLuint width, GLuint height, GLbitfield flags)
+		unsigned cpp, unsigned width, unsigned height, unsigned flags)
 {
    struct softpipe_context *sp = softpipe_context( pipe );
    struct pipe_region *region = calloc(sizeof(*region), 1);
@@ -112,7 +112,7 @@ sp_region_release(struct pipe_context *pipe, struct pipe_region **region)
    if (!*region)
       return;
 
-   ASSERT((*region)->refcount > 0);
+   assert((*region)->refcount > 0);
    (*region)->refcount--;
 
    if ((*region)->refcount == 0) {
@@ -130,19 +130,19 @@ sp_region_release(struct pipe_context *pipe, struct pipe_region **region)
  * XXX Move this into core Mesa?
  */
 static void
-_mesa_copy_rect(GLubyte * dst,
-                GLuint cpp,
-                GLuint dst_pitch,
-                GLuint dst_x,
-                GLuint dst_y,
-                GLuint width,
-                GLuint height,
-                const GLubyte * src,
-                GLuint src_pitch,
-		GLuint src_x, 
-		GLuint src_y)
+_mesa_copy_rect(ubyte * dst,
+                unsigned cpp,
+                unsigned dst_pitch,
+                unsigned dst_x,
+                unsigned dst_y,
+                unsigned width,
+                unsigned height,
+                const ubyte * src,
+                unsigned src_pitch,
+		unsigned src_x, 
+		unsigned src_y)
 {
-   GLuint i;
+   unsigned i;
 
    dst_pitch *= cpp;
    src_pitch *= cpp;
@@ -174,10 +174,10 @@ _mesa_copy_rect(GLubyte * dst,
 static void
 sp_region_data(struct pipe_context *pipe,
 	       struct pipe_region *dst,
-	       GLuint dst_offset,
-	       GLuint dstx, GLuint dsty,
-	       const void *src, GLuint src_pitch,
-	       GLuint srcx, GLuint srcy, GLuint width, GLuint height)
+	       unsigned dst_offset,
+	       unsigned dstx, unsigned dsty,
+	       const void *src, unsigned src_pitch,
+	       unsigned srcx, unsigned srcy, unsigned width, unsigned height)
 {
    _mesa_copy_rect(pipe->region_map(pipe, dst) + dst_offset,
                    dst->cpp,
@@ -193,11 +193,11 @@ sp_region_data(struct pipe_context *pipe,
 static void
 sp_region_copy(struct pipe_context *pipe,
 	       struct pipe_region *dst,
-	       GLuint dst_offset,
-	       GLuint dstx, GLuint dsty,
+	       unsigned dst_offset,
+	       unsigned dstx, unsigned dsty,
 	       struct pipe_region *src,
-	       GLuint src_offset,
-	       GLuint srcx, GLuint srcy, GLuint width, GLuint height)
+	       unsigned src_offset,
+	       unsigned srcx, unsigned srcy, unsigned width, unsigned height)
 {
    assert( dst->cpp == src->cpp );
 
@@ -217,8 +217,8 @@ sp_region_copy(struct pipe_context *pipe,
 /* Fill a rectangular sub-region.  Need better logic about when to
  * push buffers into AGP - will currently do so whenever possible.
  */
-static GLubyte *
-get_pointer(struct pipe_region *dst, GLuint x, GLuint y)
+static ubyte *
+get_pointer(struct pipe_region *dst, unsigned x, unsigned y)
 {
    return dst->map + (y * dst->pitch + x) * dst->cpp;
 }
@@ -227,17 +227,17 @@ get_pointer(struct pipe_region *dst, GLuint x, GLuint y)
 static void
 sp_region_fill(struct pipe_context *pipe,
                struct pipe_region *dst,
-               GLuint dst_offset,
-               GLuint dstx, GLuint dsty,
-               GLuint width, GLuint height, GLuint value)
+               unsigned dst_offset,
+               unsigned dstx, unsigned dsty,
+               unsigned width, unsigned height, unsigned value)
 {
-   GLuint i, j;
+   unsigned i, j;
 
    (void)pipe->region_map(pipe, dst);
 
    switch (dst->cpp) {
    case 1: {
-      GLubyte *row = get_pointer(dst, dstx, dsty);
+      ubyte *row = get_pointer(dst, dstx, dsty);
       for (i = 0; i < height; i++) {
 	 memset(row, value, width);
 	 row += dst->pitch;
@@ -245,7 +245,7 @@ sp_region_fill(struct pipe_context *pipe,
    }
    break;
    case 2: {
-      GLushort *row = (GLushort *) get_pointer(dst, dstx, dsty);
+      ushort *row = (ushort *) get_pointer(dst, dstx, dsty);
       for (i = 0; i < height; i++) {
 	 for (j = 0; j < width; j++)
 	    row[j] = value;
@@ -254,7 +254,7 @@ sp_region_fill(struct pipe_context *pipe,
    }
    break;
    case 4: {
-      GLuint *row = (GLuint *) get_pointer(dst, dstx, dsty);
+      unsigned *row = (unsigned *) get_pointer(dst, dstx, dsty);
       for (i = 0; i < height; i++) {
 	 for (j = 0; j < width; j++)
 	    row[j] = value;
diff --git a/src/mesa/pipe/softpipe/sp_state.h b/src/mesa/pipe/softpipe/sp_state.h
index 3c572cdb6a4..5adf5930b85 100644
--- a/src/mesa/pipe/softpipe/sp_state.h
+++ b/src/mesa/pipe/softpipe/sp_state.h
@@ -31,7 +31,6 @@
 #ifndef SP_STATE_H
 #define SP_STATE_H
 
-#include "glheader.h"
 #include "pipe/p_state.h"
 
 
@@ -69,14 +68,14 @@ void softpipe_set_setup_state( struct pipe_context *,
 			      const struct pipe_setup_state * );
 
 void softpipe_set_sampler_state( struct pipe_context *,
-                                 GLuint unit,
+                                 unsigned unit,
                                  const struct pipe_sampler_state * );
 
 void softpipe_set_stencil_state( struct pipe_context *,
                                  const struct pipe_stencil_state * );
 
 void softpipe_set_texture_state( struct pipe_context *,
-                                 GLuint unit,
+                                 unsigned unit,
                                  struct pipe_mipmap_tree * );
 
 void softpipe_set_viewport_state( struct pipe_context *,
diff --git a/src/mesa/pipe/softpipe/sp_state_blend.c b/src/mesa/pipe/softpipe/sp_state_blend.c
index 8bc22b0efc0..b2e85d86cc0 100644
--- a/src/mesa/pipe/softpipe/sp_state_blend.c
+++ b/src/mesa/pipe/softpipe/sp_state_blend.c
@@ -27,8 +27,6 @@
 
 /* Authors:  Keith Whitwell <[email protected]>
  */
-#include "imports.h"
-
 #include "sp_context.h"
 #include "sp_state.h"
 
diff --git a/src/mesa/pipe/softpipe/sp_state_clip.c b/src/mesa/pipe/softpipe/sp_state_clip.c
index 8cf4383d3fa..08c5f06d05d 100644
--- a/src/mesa/pipe/softpipe/sp_state_clip.c
+++ b/src/mesa/pipe/softpipe/sp_state_clip.c
@@ -27,8 +27,6 @@
 
 /* Authors:  Keith Whitwell <[email protected]>
  */
-#include "imports.h"
-
 #include "sp_context.h"
 #include "sp_state.h"
 #include "pipe/draw/draw_context.h"
diff --git a/src/mesa/pipe/softpipe/sp_state_derived.c b/src/mesa/pipe/softpipe/sp_state_derived.c
index e1faaed93ce..0a2cfbb7d1b 100644
--- a/src/mesa/pipe/softpipe/sp_state_derived.c
+++ b/src/mesa/pipe/softpipe/sp_state_derived.c
@@ -46,7 +46,7 @@ do {								\
 } while (0)
 
 
-static const GLuint frag_to_vf[FRAG_ATTRIB_MAX] = 
+static const unsigned frag_to_vf[FRAG_ATTRIB_MAX] = 
 {
    VF_ATTRIB_POS,
    VF_ATTRIB_COLOR0,
@@ -78,27 +78,27 @@ static const GLuint frag_to_vf[FRAG_ATTRIB_MAX] =
  */
 static void calculate_vertex_layout( struct softpipe_context *softpipe )
 {
-   const GLbitfield inputsRead = softpipe->fs.inputs_read;
-   GLuint slot_to_vf_attr[VF_ATTRIB_MAX];
-   GLbitfield attr_mask = 0x0;
-   GLuint i;
+   const unsigned inputsRead = softpipe->fs.inputs_read;
+   unsigned slot_to_vf_attr[VF_ATTRIB_MAX];
+   unsigned attr_mask = 0x0;
+   unsigned i;
 
    /* Need Z if depth test is enabled or the fragment program uses the
     * fragment position (XYZW).
     */
    if (softpipe->depth_test.enabled ||
        (inputsRead & FRAG_ATTRIB_WPOS))
-      softpipe->need_z = GL_TRUE;
+      softpipe->need_z = TRUE;
    else
-      softpipe->need_z = GL_FALSE;
+      softpipe->need_z = FALSE;
 
    /* Need W if we do any perspective-corrected interpolation or the
     * fragment program uses the fragment position.
     */
    if (inputsRead & FRAG_ATTRIB_WPOS)
-      softpipe->need_w = GL_TRUE;
+      softpipe->need_w = TRUE;
    else
-      softpipe->need_w = GL_FALSE;
+      softpipe->need_w = FALSE;
 
 
    softpipe->nr_attrs = 0;
@@ -130,7 +130,7 @@ static void calculate_vertex_layout( struct softpipe_context *softpipe )
       if (inputsRead & (1 << i)) {
          assert(i < sizeof(frag_to_vf) / sizeof(frag_to_vf[0]));
          EMIT_ATTR(frag_to_vf[i], i, INTERP_PERSPECTIVE);
-         softpipe->need_w = GL_TRUE;
+         softpipe->need_w = TRUE;
       }
    }
 
@@ -169,7 +169,7 @@ static void calculate_vertex_layout( struct softpipe_context *softpipe )
 static void
 compute_cliprect(struct softpipe_context *sp)
 {
-   GLint surfWidth, surfHeight;
+   int surfWidth, surfHeight;
 
    if (sp->framebuffer.num_cbufs > 0) {
       surfWidth = sp->framebuffer.cbufs[0]->width;
diff --git a/src/mesa/pipe/softpipe/sp_state_sampler.c b/src/mesa/pipe/softpipe/sp_state_sampler.c
index 34cf2108348..2e3d0c3d65d 100644
--- a/src/mesa/pipe/softpipe/sp_state_sampler.c
+++ b/src/mesa/pipe/softpipe/sp_state_sampler.c
@@ -29,8 +29,6 @@
  *  Brian Paul
  */
 
-#include "imports.h"
-
 #include "sp_context.h"
 #include "sp_state.h"
 
@@ -38,7 +36,7 @@
 
 void
 softpipe_set_sampler_state(struct pipe_context *pipe,
-                           GLuint unit,
+                           unsigned unit,
                            const struct pipe_sampler_state *sampler)
 {
    struct softpipe_context *softpipe = softpipe_context(pipe);
@@ -52,7 +50,7 @@ softpipe_set_sampler_state(struct pipe_context *pipe,
 
 void
 softpipe_set_texture_state(struct pipe_context *pipe,
-                           GLuint unit,
+                           unsigned unit,
                            struct pipe_mipmap_tree *texture)
 {
    struct softpipe_context *softpipe = softpipe_context(pipe);
diff --git a/src/mesa/pipe/softpipe/sp_state_surface.c b/src/mesa/pipe/softpipe/sp_state_surface.c
index 8ce81eb2b04..a534ffb2c2e 100644
--- a/src/mesa/pipe/softpipe/sp_state_surface.c
+++ b/src/mesa/pipe/softpipe/sp_state_surface.c
@@ -27,8 +27,6 @@
 
 /* Authors:  Keith Whitwell <[email protected]>
  */
-#include "imports.h"
-
 #include "sp_context.h"
 #include "sp_state.h"
 #include "sp_surface.h"
diff --git a/src/mesa/pipe/softpipe/sp_surface.c b/src/mesa/pipe/softpipe/sp_surface.c
index 1919947abf6..4152e3510d0 100644
--- a/src/mesa/pipe/softpipe/sp_surface.c
+++ b/src/mesa/pipe/softpipe/sp_surface.c
@@ -29,8 +29,7 @@
 #include "sp_state.h"
 #include "sp_surface.h"
 #include "pipe/p_defines.h"
-#include "main/imports.h"
-#include "main/macros.h"
+#include "pipe/p_util.h"
 
 
 /**
@@ -48,13 +47,13 @@
 /*** PIPE_FORMAT_U_A8_R8_G8_B8 ***/
 
 static void
-a8r8g8b8_read_quad_f_swz(struct softpipe_surface *sps, GLint x, GLint y,
-                         GLfloat (*rrrr)[QUAD_SIZE])
+a8r8g8b8_read_quad_f_swz(struct softpipe_surface *sps, int x, int y,
+                         float (*rrrr)[QUAD_SIZE])
 {
-   const GLuint *src
-      = ((const GLuint *) (sps->surface.region->map + sps->surface.offset))
+   const unsigned *src
+      = ((const unsigned *) (sps->surface.region->map + sps->surface.offset))
       + y * sps->surface.region->pitch + x;
-   GLuint i, j;
+   unsigned i, j;
 
    assert(sps->surface.format == PIPE_FORMAT_U_A8_R8_G8_B8);
    assert(x < sps->surface.width - 1);
@@ -62,7 +61,7 @@ a8r8g8b8_read_quad_f_swz(struct softpipe_surface *sps, GLint x, GLint y,
 
    for (i = 0; i < 2; i++) { /* loop over pixel row */
       for (j = 0; j < 2; j++) {  /* loop over pixel column */
-         const GLuint p = src[j];
+         const unsigned p = src[j];
          rrrr[0][i * 2 + j] = UBYTE_TO_FLOAT((p >> 16) & 0xff); /*R*/
          rrrr[1][i * 2 + j] = UBYTE_TO_FLOAT((p >>  8) & 0xff); /*G*/
          rrrr[2][i * 2 + j] = UBYTE_TO_FLOAT((p      ) & 0xff); /*B*/
@@ -73,19 +72,19 @@ a8r8g8b8_read_quad_f_swz(struct softpipe_surface *sps, GLint x, GLint y,
 }
 
 static void
-a8r8g8b8_write_quad_f_swz(struct softpipe_surface *sps, GLint x, GLint y,
-                          GLfloat (*rrrr)[QUAD_SIZE])
+a8r8g8b8_write_quad_f_swz(struct softpipe_surface *sps, int x, int y,
+                          float (*rrrr)[QUAD_SIZE])
 {
-   GLuint *dst
-      = ((GLuint *) (sps->surface.region->map + sps->surface.offset))
+   unsigned *dst
+      = ((unsigned *) (sps->surface.region->map + sps->surface.offset))
       + y * sps->surface.region->pitch + x;
-   GLuint i, j;
+   unsigned i, j;
 
    assert(sps->surface.format == PIPE_FORMAT_U_A8_R8_G8_B8);
 
    for (i = 0; i < 2; i++) { /* loop over pixel row */
       for (j = 0; j < 2; j++) {  /* loop over pixel column */
-         GLubyte r, g, b, a;
+         ubyte r, g, b, a;
          UNCLAMPED_FLOAT_TO_UBYTE(r, rrrr[0][i * 2 + j]); /*R*/
          UNCLAMPED_FLOAT_TO_UBYTE(g, rrrr[1][i * 2 + j]); /*G*/
          UNCLAMPED_FLOAT_TO_UBYTE(b, rrrr[2][i * 2 + j]); /*B*/
@@ -98,13 +97,13 @@ a8r8g8b8_write_quad_f_swz(struct softpipe_surface *sps, GLint x, GLint y,
 
 static void
 a8r8g8b8_get_tile(struct pipe_surface *ps,
-                  GLuint x, GLuint y, GLuint w, GLuint h, GLfloat *p)
+                  unsigned x, unsigned y, unsigned w, unsigned h, float *p)
 {
-   const GLuint *src
-      = ((const GLuint *) (ps->region->map + ps->offset))
+   const unsigned *src
+      = ((const unsigned *) (ps->region->map + ps->offset))
       + y * ps->region->pitch + x;
-   GLuint i, j;
-   GLuint w0 = w;
+   unsigned i, j;
+   unsigned w0 = w;
 
    assert(ps->format == PIPE_FORMAT_U_A8_R8_G8_B8);
 
@@ -119,9 +118,9 @@ a8r8g8b8_get_tile(struct pipe_surface *ps,
       h = ps->height -y;
 #endif
    for (i = 0; i < h; i++) {
-      GLfloat *pRow = p;
+      float *pRow = p;
       for (j = 0; j < w; j++) {
-         const GLuint pixel = src[j];
+         const unsigned pixel = src[j];
          pRow[0] = UBYTE_TO_FLOAT((pixel >> 16) & 0xff);
          pRow[1] = UBYTE_TO_FLOAT((pixel >>  8) & 0xff);
          pRow[2] = UBYTE_TO_FLOAT((pixel >>  0) & 0xff);
@@ -138,18 +137,18 @@ a8r8g8b8_get_tile(struct pipe_surface *ps,
 
 static void
 a1r5g5b5_get_tile(struct pipe_surface *ps,
-                  GLuint x, GLuint y, GLuint w, GLuint h, GLfloat *p)
+                  unsigned x, unsigned y, unsigned w, unsigned h, float *p)
 {
-   const GLushort *src
-      = ((const GLushort *) (ps->region->map + ps->offset))
+   const ushort *src
+      = ((const ushort *) (ps->region->map + ps->offset))
       + y * ps->region->pitch + x;
-   GLuint i, j;
+   unsigned i, j;
 
    assert(ps->format == PIPE_FORMAT_U_A1_R5_G5_B5);
 
    for (i = 0; i < h; i++) {
       for (j = 0; j < w; j++) {
-         const GLushort pixel = src[j];
+         const ushort pixel = src[j];
          p[0] = ((pixel >> 10) & 0x1f) * (1.0 / 31);
          p[1] = ((pixel >>  5) & 0x1f) * (1.0 / 31);
          p[2] = ((pixel      ) & 0x1f) * (1.0 / 31);
@@ -166,15 +165,15 @@ a1r5g5b5_get_tile(struct pipe_surface *ps,
 
 static void
 z16_read_quad_z(struct softpipe_surface *sps,
-                GLint x, GLint y, GLuint zzzz[QUAD_SIZE])
+                int x, int y, unsigned zzzz[QUAD_SIZE])
 {
-   const GLushort *src
-      = ((const GLushort *) (sps->surface.region->map + sps->surface.offset))
+   const ushort *src
+      = ((const ushort *) (sps->surface.region->map + sps->surface.offset))
       + y * sps->surface.region->pitch + x;
 
    assert(sps->surface.format == PIPE_FORMAT_U_Z16);
 
-   /* converting GLushort to GLuint: */
+   /* converting ushort to unsigned: */
    zzzz[0] = src[0];
    zzzz[1] = src[1];
    src += sps->surface.region->pitch;
@@ -184,15 +183,15 @@ z16_read_quad_z(struct softpipe_surface *sps,
 
 static void
 z16_write_quad_z(struct softpipe_surface *sps,
-                 GLint x, GLint y, const GLuint zzzz[QUAD_SIZE])
+                 int x, int y, const unsigned zzzz[QUAD_SIZE])
 {
-   GLushort *dst
-      = ((GLushort *) (sps->surface.region->map + sps->surface.offset))
+   ushort *dst
+      = ((ushort *) (sps->surface.region->map + sps->surface.offset))
       + y * sps->surface.region->pitch + x;
 
    assert(sps->surface.format == PIPE_FORMAT_U_Z16);
 
-   /* converting GLuint to GLushort: */
+   /* converting unsigned to ushort: */
    dst[0] = zzzz[0];
    dst[1] = zzzz[1];
    dst += sps->surface.region->pitch;
@@ -205,10 +204,10 @@ z16_write_quad_z(struct softpipe_surface *sps,
 
 static void
 z32_read_quad_z(struct softpipe_surface *sps,
-                GLint x, GLint y, GLuint zzzz[QUAD_SIZE])
+                int x, int y, unsigned zzzz[QUAD_SIZE])
 {
-   const GLuint *src
-      = ((GLuint *) (sps->surface.region->map + sps->surface.offset))
+   const unsigned *src
+      = ((unsigned *) (sps->surface.region->map + sps->surface.offset))
       + y * sps->surface.region->pitch + x;
 
    assert(sps->surface.format == PIPE_FORMAT_U_Z32);
@@ -222,10 +221,10 @@ z32_read_quad_z(struct softpipe_surface *sps,
 
 static void
 z32_write_quad_z(struct softpipe_surface *sps,
-                 GLint x, GLint y, const GLuint zzzz[QUAD_SIZE])
+                 int x, int y, const unsigned zzzz[QUAD_SIZE])
 {
-   GLuint *dst
-      = ((GLuint *) (sps->surface.region->map + sps->surface.offset))
+   unsigned *dst
+      = ((unsigned *) (sps->surface.region->map + sps->surface.offset))
       + y * sps->surface.region->pitch + x;
 
    assert(sps->surface.format == PIPE_FORMAT_U_Z32);
@@ -242,11 +241,11 @@ z32_write_quad_z(struct softpipe_surface *sps,
 
 static void
 s8z24_read_quad_z(struct softpipe_surface *sps,
-                  GLint x, GLint y, GLuint zzzz[QUAD_SIZE])
+                  int x, int y, unsigned zzzz[QUAD_SIZE])
 {
-   static const GLuint mask = 0x00ffffff;
-   const GLuint *src
-      = ((GLuint *) (sps->surface.region->map + sps->surface.offset))
+   static const unsigned mask = 0x00ffffff;
+   const unsigned *src
+      = ((unsigned *) (sps->surface.region->map + sps->surface.offset))
       + y * sps->surface.region->pitch + x;
 
    assert(sps->surface.format == PIPE_FORMAT_S8_Z24);
@@ -261,11 +260,11 @@ s8z24_read_quad_z(struct softpipe_surface *sps,
 
 static void
 s8z24_write_quad_z(struct softpipe_surface *sps,
-                   GLint x, GLint y, const GLuint zzzz[QUAD_SIZE])
+                   int x, int y, const unsigned zzzz[QUAD_SIZE])
 {
-   static const GLuint mask = 0xff000000;
-   GLuint *dst
-      = ((GLuint *) (sps->surface.region->map + sps->surface.offset))
+   static const unsigned mask = 0xff000000;
+   unsigned *dst
+      = ((unsigned *) (sps->surface.region->map + sps->surface.offset))
       + y * sps->surface.region->pitch + x;
 
    assert(sps->surface.format == PIPE_FORMAT_S8_Z24);
@@ -280,10 +279,10 @@ s8z24_write_quad_z(struct softpipe_surface *sps,
 
 static void
 s8z24_read_quad_stencil(struct softpipe_surface *sps,
-                        GLint x, GLint y, GLubyte ssss[QUAD_SIZE])
+                        int x, int y, ubyte ssss[QUAD_SIZE])
 {
-   const GLuint *src
-      = ((GLuint *) (sps->surface.region->map + sps->surface.offset))
+   const unsigned *src
+      = ((unsigned *) (sps->surface.region->map + sps->surface.offset))
       + y * sps->surface.region->pitch + x;
 
    assert(sps->surface.format == PIPE_FORMAT_S8_Z24);
@@ -297,11 +296,11 @@ s8z24_read_quad_stencil(struct softpipe_surface *sps,
 
 static void
 s8z24_write_quad_stencil(struct softpipe_surface *sps,
-                         GLint x, GLint y, const GLubyte ssss[QUAD_SIZE])
+                         int x, int y, const ubyte ssss[QUAD_SIZE])
 {
-   static const GLuint mask = 0x00ffffff;
-   GLuint *dst
-      = ((GLuint *) (sps->surface.region->map + sps->surface.offset))
+   static const unsigned mask = 0x00ffffff;
+   unsigned *dst
+      = ((unsigned *) (sps->surface.region->map + sps->surface.offset))
       + y * sps->surface.region->pitch + x;
 
    assert(sps->surface.format == PIPE_FORMAT_S8_Z24);
@@ -318,9 +317,9 @@ s8z24_write_quad_stencil(struct softpipe_surface *sps,
 
 static void
 s8_read_quad_stencil(struct softpipe_surface *sps,
-                     GLint x, GLint y, GLubyte ssss[QUAD_SIZE])
+                     int x, int y, ubyte ssss[QUAD_SIZE])
 {
-   const GLubyte *src
+   const ubyte *src
       = sps->surface.region->map + sps->surface.offset
       + y * sps->surface.region->pitch + x;
 
@@ -335,9 +334,9 @@ s8_read_quad_stencil(struct softpipe_surface *sps,
 
 static void
 s8_write_quad_stencil(struct softpipe_surface *sps,
-                      GLint x, GLint y, const GLubyte ssss[QUAD_SIZE])
+                      int x, int y, const ubyte ssss[QUAD_SIZE])
 {
-   GLubyte *dst
+   ubyte *dst
       = sps->surface.region->map + sps->surface.offset
       + y * sps->surface.region->pitch + x;
 
@@ -393,7 +392,7 @@ softpipe_init_surface_funcs(struct softpipe_surface *sps)
 
 
 static struct pipe_surface *
-softpipe_surface_alloc(struct pipe_context *pipe, GLuint pipeFormat)
+softpipe_surface_alloc(struct pipe_context *pipe, unsigned pipeFormat)
 {
    struct softpipe_surface *sps = CALLOC_STRUCT(softpipe_surface);
    if (!sps)
@@ -419,17 +418,17 @@ softpipe_surface_alloc(struct pipe_context *pipe, GLuint pipeFormat)
 struct pipe_surface *
 softpipe_get_tex_surface(struct pipe_context *pipe,
                          struct pipe_mipmap_tree *mt,
-                         GLuint face, GLuint level, GLuint zslice)
+                         unsigned face, unsigned level, unsigned zslice)
 {
    struct pipe_surface *ps;
-   GLuint offset;  /* in bytes */
+   unsigned offset;  /* in bytes */
 
    offset = mt->level[level].level_offset;
 
-   if (mt->target == GL_TEXTURE_CUBE_MAP_ARB) {
+   if (mt->target == PIPE_TEXTURE_CUBE) {
       offset += mt->level[level].image_offset[face] * mt->cpp;
    }
-   else if (mt->target == GL_TEXTURE_3D) {
+   else if (mt->target == PIPE_TEXTURE_3D) {
       offset += mt->level[level].image_offset[zslice] * mt->cpp;
    }
    else {
diff --git a/src/mesa/pipe/softpipe/sp_surface.h b/src/mesa/pipe/softpipe/sp_surface.h
index 00b5edcd928..545983f4317 100644
--- a/src/mesa/pipe/softpipe/sp_surface.h
+++ b/src/mesa/pipe/softpipe/sp_surface.h
@@ -31,7 +31,6 @@
 #ifndef SP_SURFACE_H
 #define SP_SURFACE_H
 
-#include "glheader.h"
 #include "sp_headers.h"
 #include "pipe/p_state.h"
 
@@ -50,47 +49,47 @@ struct softpipe_surface {
     * Functions for read/writing surface data
     */
    void (*read_quad_f)( struct softpipe_surface *,
-			GLint x, GLint y,
-			GLfloat (*rgba)[NUM_CHANNELS] );
+			int x, int y,
+			float (*rgba)[NUM_CHANNELS] );
 
    void (*read_quad_f_swz)( struct softpipe_surface *,
-			    GLint x, GLint y,
-			    GLfloat (*rrrr)[QUAD_SIZE] );
+			    int x, int y,
+			    float (*rrrr)[QUAD_SIZE] );
 
    void (*read_quad_ub)( struct softpipe_surface *,
-			 GLint x, GLint y,
-			 GLubyte (*rgba)[NUM_CHANNELS] );
+			 int x, int y,
+			 ubyte (*rgba)[NUM_CHANNELS] );
 
 
    void (*write_quad_f)( struct softpipe_surface *,
-			 GLint x, GLint y,
-			 GLfloat (*rgba)[NUM_CHANNELS] );
+			 int x, int y,
+			 float (*rgba)[NUM_CHANNELS] );
 
    void (*write_quad_f_swz)( struct softpipe_surface *,
-			     GLint x, GLint y,
-			     GLfloat (*rrrr)[QUAD_SIZE] );
+			     int x, int y,
+			     float (*rrrr)[QUAD_SIZE] );
 
 
    void (*write_quad_ub)( struct softpipe_surface *,
-			  GLint x, GLint y,
-			  GLubyte (*rgba)[NUM_CHANNELS] );
+			  int x, int y,
+			  ubyte (*rgba)[NUM_CHANNELS] );
 
    void (*read_quad_z)(struct softpipe_surface *,
-                       GLint x, GLint y, GLuint zzzz[QUAD_SIZE]);
+                       int x, int y, unsigned zzzz[QUAD_SIZE]);
    void (*write_quad_z)(struct softpipe_surface *,
-                        GLint x, GLint y, const GLuint zzzz[QUAD_SIZE]);
+                        int x, int y, const unsigned zzzz[QUAD_SIZE]);
 
    void (*read_quad_stencil)(struct softpipe_surface *,
-                             GLint x, GLint y, GLubyte ssss[QUAD_SIZE]);
+                             int x, int y, ubyte ssss[QUAD_SIZE]);
    void (*write_quad_stencil)(struct softpipe_surface *,
-                              GLint x, GLint y, const GLubyte ssss[QUAD_SIZE]);
+                              int x, int y, const ubyte ssss[QUAD_SIZE]);
 };
 
 
 extern struct pipe_surface *
 softpipe_get_tex_surface(struct pipe_context *pipe,
                          struct pipe_mipmap_tree *mt,
-                         GLuint face, GLuint level, GLuint zslice);
+                         unsigned face, unsigned level, unsigned zslice);
 
 
 extern void
diff --git a/src/mesa/pipe/softpipe/sp_tex_layout.c b/src/mesa/pipe/softpipe/sp_tex_layout.c
index fda1b46ab43..0517c01b5d4 100644
--- a/src/mesa/pipe/softpipe/sp_tex_layout.c
+++ b/src/mesa/pipe/softpipe/sp_tex_layout.c
@@ -30,10 +30,10 @@
   *   Michel Dänzer <[email protected]>
   */
 
-#include "macros.h"
 #include "pipe/p_state.h"
 #include "pipe/p_context.h"
 #include "pipe/p_defines.h"
+#include "pipe/p_util.h"
 #include "sp_tex_layout.h"
 
 
@@ -43,7 +43,7 @@
  * little.
  */
 
-static GLuint minify( GLuint d )
+static unsigned minify( unsigned d )
 {
    return MAX2(1, d>>1);
 }
@@ -56,11 +56,11 @@ static int align(int value, int alignment)
 
 static void
 sp_miptree_set_level_info(struct pipe_mipmap_tree *mt,
-                             GLuint level,
-                             GLuint nr_images,
-                             GLuint x, GLuint y, GLuint w, GLuint h, GLuint d)
+                             unsigned level,
+                             unsigned nr_images,
+                             unsigned x, unsigned y, unsigned w, unsigned h, unsigned d)
 {
-   assert(level < MAX_TEXTURE_LEVELS);
+   assert(level < PIPE_MAX_TEXTURE_LEVELS);
 
    mt->level[level].width = w;
    mt->level[level].height = h;
@@ -83,14 +83,14 @@ sp_miptree_set_level_info(struct pipe_mipmap_tree *mt,
    assert(nr_images);
    assert(!mt->level[level].image_offset);
 
-   mt->level[level].image_offset = (GLuint *) malloc(nr_images * sizeof(GLuint));
+   mt->level[level].image_offset = (unsigned *) malloc(nr_images * sizeof(unsigned));
    mt->level[level].image_offset[0] = 0;
 }
 
 
 static void
 sp_miptree_set_image_offset(struct pipe_mipmap_tree *mt,
-                               GLuint level, GLuint img, GLuint x, GLuint y)
+                               unsigned level, unsigned img, unsigned x, unsigned y)
 {
    if (img == 0 && level == 0)
       assert(x == 0 && y == 0);
@@ -109,12 +109,12 @@ sp_miptree_set_image_offset(struct pipe_mipmap_tree *mt,
 static void
 sp_miptree_layout_2d( struct pipe_mipmap_tree *mt )
 {
-   GLint align_h = 2, align_w = 4;
-   GLuint level;
-   GLuint x = 0;
-   GLuint y = 0;
-   GLuint width = mt->width0;
-   GLuint height = mt->height0;
+   int align_h = 2, align_w = 4;
+   unsigned level;
+   unsigned x = 0;
+   unsigned y = 0;
+   unsigned width = mt->width0;
+   unsigned height = mt->height0;
 
    mt->pitch = mt->width0;
    /* XXX FIX THIS:
@@ -130,7 +130,7 @@ sp_miptree_layout_2d( struct pipe_mipmap_tree *mt )
     * 2nd mipmap out past the width of its parent.
     */
    if (mt->first_level != mt->last_level) {
-      GLuint mip1_width = align(minify(mt->width0), align_w)
+      unsigned mip1_width = align(minify(mt->width0), align_w)
 			+ minify(minify(mt->width0));
 
       if (mip1_width > mt->width0)
@@ -144,7 +144,7 @@ sp_miptree_layout_2d( struct pipe_mipmap_tree *mt )
    mt->total_height = 0;
 
    for ( level = mt->first_level ; level <= mt->last_level ; level++ ) {
-      GLuint img_height;
+      unsigned img_height;
 
       sp_miptree_set_level_info(mt, level, 1, x, y, width, height, 1);
 
@@ -174,7 +174,7 @@ sp_miptree_layout_2d( struct pipe_mipmap_tree *mt )
 }
 
 
-static const GLint initial_offsets[6][2] = {
+static const int initial_offsets[6][2] = {
    {0, 0},
    {0, 2},
    {1, 0},
@@ -183,7 +183,7 @@ static const GLint initial_offsets[6][2] = {
    {1, 3}
 };
 
-static const GLint step_offsets[6][2] = {
+static const int step_offsets[6][2] = {
    {0, 2},
    {0, 2},
    {-1, 2},
@@ -194,16 +194,16 @@ static const GLint step_offsets[6][2] = {
 
 
 
-GLboolean
+boolean
 softpipe_mipmap_tree_layout(struct pipe_context *pipe, struct pipe_mipmap_tree * mt)
 {
-   GLint level;
+   int level;
 
    switch (mt->target) {
-   case GL_TEXTURE_CUBE_MAP:{
-         const GLuint dim = mt->width0;
-         GLuint face;
-         GLuint lvlWidth = mt->width0, lvlHeight = mt->height0;
+   case PIPE_TEXTURE_CUBE:{
+         const unsigned dim = mt->width0;
+         unsigned face;
+         unsigned lvlWidth = mt->width0, lvlHeight = mt->height0;
 
          assert(lvlWidth == lvlHeight); /* cubemap images are square */
 
@@ -230,9 +230,9 @@ softpipe_mipmap_tree_layout(struct pipe_context *pipe, struct pipe_mipmap_tree *
 
 
          for (face = 0; face < 6; face++) {
-            GLuint x = initial_offsets[face][0] * dim;
-            GLuint y = initial_offsets[face][1] * dim;
-            GLuint d = dim;
+            unsigned x = initial_offsets[face][0] * dim;
+            unsigned y = initial_offsets[face][1] * dim;
+            unsigned d = dim;
 
             if (dim == 4 && face >= 4) {
                y = mt->total_height - 4;
@@ -286,13 +286,13 @@ softpipe_mipmap_tree_layout(struct pipe_context *pipe, struct pipe_mipmap_tree *
          }
          break;
       }
-   case GL_TEXTURE_3D:{
-         GLuint width = mt->width0;
-         GLuint height = mt->height0;
-         GLuint depth = mt->depth0;
-         GLuint pack_x_pitch, pack_x_nr;
-         GLuint pack_y_pitch;
-         GLuint level;
+   case PIPE_TEXTURE_3D:{
+         unsigned width = mt->width0;
+         unsigned height = mt->height0;
+         unsigned depth = mt->depth0;
+         unsigned pack_x_pitch, pack_x_nr;
+         unsigned pack_y_pitch;
+         unsigned level;
 
          mt->pitch = ((mt->width0 * mt->cpp + 3) & ~3) / mt->cpp;
          mt->total_height = 0;
@@ -302,10 +302,10 @@ softpipe_mipmap_tree_layout(struct pipe_context *pipe, struct pipe_mipmap_tree *
          pack_x_nr = 1;
 
          for (level = mt->first_level; level <= mt->last_level; level++) {
-            GLuint nr_images = mt->target == GL_TEXTURE_3D ? depth : 6;
-            GLint x = 0;
-            GLint y = 0;
-            GLint q, j;
+            unsigned nr_images = mt->target == PIPE_TEXTURE_3D ? depth : 6;
+            int x = 0;
+            int y = 0;
+            int q, j;
 
             sp_miptree_set_level_info(mt, level, nr_images,
                                          0, mt->total_height,
@@ -341,13 +341,14 @@ softpipe_mipmap_tree_layout(struct pipe_context *pipe, struct pipe_mipmap_tree *
          break;
       }
 
-   case GL_TEXTURE_1D:
-   case GL_TEXTURE_2D:
-   case GL_TEXTURE_RECTANGLE_ARB:
+   case PIPE_TEXTURE_1D:
+   case PIPE_TEXTURE_2D:
+//   case PIPE_TEXTURE_RECTANGLE:
          sp_miptree_layout_2d(mt);
          break;
    default:
-      _mesa_problem(NULL, "Unexpected tex target in sp_miptree_layout()");
+      assert(0);
+      break;
    }
 
    /*
@@ -356,6 +357,6 @@ softpipe_mipmap_tree_layout(struct pipe_context *pipe, struct pipe_mipmap_tree *
        mt->total_height, mt->cpp, mt->pitch * mt->total_height * mt->cpp);
    */
 
-   return GL_TRUE;
+   return TRUE;
 }
 
diff --git a/src/mesa/pipe/softpipe/sp_tex_layout.h b/src/mesa/pipe/softpipe/sp_tex_layout.h
index be85e4be584..ea19c13b23f 100644
--- a/src/mesa/pipe/softpipe/sp_tex_layout.h
+++ b/src/mesa/pipe/softpipe/sp_tex_layout.h
@@ -6,7 +6,7 @@ struct pipe_context;
 struct pipe_mipmap_tree;
 
 
-extern GLboolean
+extern boolean
 softpipe_mipmap_tree_layout(struct pipe_context *pipe,
                             struct pipe_mipmap_tree *mt);
 
diff --git a/src/mesa/pipe/softpipe/sp_tex_sample.c b/src/mesa/pipe/softpipe/sp_tex_sample.c
index 35993b946fc..23a0306bba1 100644
--- a/src/mesa/pipe/softpipe/sp_tex_sample.c
+++ b/src/mesa/pipe/softpipe/sp_tex_sample.c
@@ -33,12 +33,12 @@
  */
 
 
-#include "main/macros.h"
 #include "sp_context.h"
 #include "sp_surface.h"
 #include "sp_tex_sample.h"
 #include "pipe/p_context.h"
 #include "pipe/p_defines.h"
+#include "pipe/p_util.h"
 #include "pipe/tgsi/core/tgsi_exec.h"
 
 
@@ -49,7 +49,7 @@
  * Also note, FRAC(x) doesn't truly return the fractional part of x for x < 0.
  * Instead, if x < 0 then FRAC(x) = 1 - true_frac(x).
  */
-#define FRAC(f)  ((f) - IFLOOR(f))
+#define FRAC(f)  ((f) - ifloor(f))
 
 
 /**
@@ -80,8 +80,8 @@ lerp_2d(float a, float b,
  * Compute the remainder of a divided by b, but be careful with
  * negative values so that REPEAT mode works right.
  */
-static INLINE GLint
-repeat_remainder(GLint a, GLint b)
+static INLINE int
+repeat_remainder(int a, int b)
 {
    if (a >= 0)
       return a % b;
@@ -97,15 +97,15 @@ repeat_remainder(GLint a, GLint b)
  * \param size  the texture image size
  * \return  integer texture index
  */
-static INLINE GLint
-nearest_texcoord(GLuint wrapMode, float s, GLuint size)
+static INLINE int
+nearest_texcoord(unsigned wrapMode, float s, unsigned size)
 {
-   GLint i;
+   int i;
    switch (wrapMode) {
    case PIPE_TEX_WRAP_REPEAT:
       /* s limited to [0,1) */
       /* i limited to [0,size-1] */
-      i = IFLOOR(s * size);
+      i = ifloor(s * size);
       i = repeat_remainder(i, size);
       return i;
    case PIPE_TEX_WRAP_CLAMP:
@@ -116,7 +116,7 @@ nearest_texcoord(GLuint wrapMode, float s, GLuint size)
       else if (s >= 1.0F)
          i = size - 1;
       else
-         i = IFLOOR(s * size);
+         i = ifloor(s * size);
       return i;
    case PIPE_TEX_WRAP_CLAMP_TO_EDGE:
       {
@@ -129,7 +129,7 @@ nearest_texcoord(GLuint wrapMode, float s, GLuint size)
          else if (s > max)
             i = size - 1;
          else
-            i = IFLOOR(s * size);
+            i = ifloor(s * size);
       }
       return i;
    case PIPE_TEX_WRAP_CLAMP_TO_BORDER:
@@ -143,14 +143,14 @@ nearest_texcoord(GLuint wrapMode, float s, GLuint size)
          else if (s >= max)
             i = size;
          else
-            i = IFLOOR(s * size);
+            i = ifloor(s * size);
       }
       return i;
    case PIPE_TEX_WRAP_MIRROR_REPEAT:
       {
          const float min = 1.0F / (2.0F * size);
          const float max = 1.0F - min;
-         const GLint flr = IFLOOR(s);
+         const int flr = ifloor(s);
          float u;
          if (flr & 1)
             u = 1.0F - (s - (float) flr);
@@ -161,7 +161,7 @@ nearest_texcoord(GLuint wrapMode, float s, GLuint size)
          else if (u > max)
             i = size - 1;
          else
-            i = IFLOOR(u * size);
+            i = ifloor(u * size);
       }
       return i;
    case PIPE_TEX_WRAP_MIRROR_CLAMP:
@@ -174,7 +174,7 @@ nearest_texcoord(GLuint wrapMode, float s, GLuint size)
          else if (u >= 1.0F)
             i = size - 1;
          else
-            i = IFLOOR(u * size);
+            i = ifloor(u * size);
       }
       return i;
    case PIPE_TEX_WRAP_MIRROR_CLAMP_TO_EDGE:
@@ -189,7 +189,7 @@ nearest_texcoord(GLuint wrapMode, float s, GLuint size)
          else if (u > max)
             i = size - 1;
          else
-            i = IFLOOR(u * size);
+            i = ifloor(u * size);
       }
       return i;
    case PIPE_TEX_WRAP_MIRROR_CLAMP_TO_BORDER:
@@ -204,7 +204,7 @@ nearest_texcoord(GLuint wrapMode, float s, GLuint size)
          else if (u > max)
             i = size;
          else
-            i = IFLOOR(u * size);
+            i = ifloor(u * size);
       }
       return i;
    default:
@@ -224,14 +224,14 @@ nearest_texcoord(GLuint wrapMode, float s, GLuint size)
  * \param a  returns blend factor/weight between texture indexes
  */
 static INLINE void
-linear_texcoord(GLuint wrapMode, float s, GLuint size,
-                GLint *i0, GLint *i1, float *a)
+linear_texcoord(unsigned wrapMode, float s, unsigned size,
+                int *i0, int *i1, float *a)
 {
    float u;
    switch (wrapMode) {
    case PIPE_TEX_WRAP_REPEAT:
       u = s * size - 0.5F;
-      *i0 = repeat_remainder(IFLOOR(u), size);
+      *i0 = repeat_remainder(ifloor(u), size);
       *i1 = repeat_remainder(*i0 + 1, size);
       break;
    case PIPE_TEX_WRAP_CLAMP:
@@ -242,7 +242,7 @@ linear_texcoord(GLuint wrapMode, float s, GLuint size,
       else
          u = s * size;
       u -= 0.5F;
-      *i0 = IFLOOR(u);
+      *i0 = ifloor(u);
       *i1 = *i0 + 1;
       break;
    case PIPE_TEX_WRAP_CLAMP_TO_EDGE:
@@ -253,11 +253,11 @@ linear_texcoord(GLuint wrapMode, float s, GLuint size,
       else
          u = s * size;
       u -= 0.5F;
-      *i0 = IFLOOR(u);
+      *i0 = ifloor(u);
       *i1 = *i0 + 1;
       if (*i0 < 0)
          *i0 = 0;
-      if (*i1 >= (GLint) size)
+      if (*i1 >= (int) size)
          *i1 = size - 1;
       break;
    case PIPE_TEX_WRAP_CLAMP_TO_BORDER:
@@ -271,23 +271,23 @@ linear_texcoord(GLuint wrapMode, float s, GLuint size,
          else
             u = s * size;
          u -= 0.5F;
-         *i0 = IFLOOR(u);
+         *i0 = ifloor(u);
          *i1 = *i0 + 1;
       }
       break;
    case PIPE_TEX_WRAP_MIRROR_REPEAT:
       {
-         const GLint flr = IFLOOR(s);
+         const int flr = ifloor(s);
          if (flr & 1)
             u = 1.0F - (s - (float) flr);
          else
             u = s - (float) flr;
          u = (u * size) - 0.5F;
-         *i0 = IFLOOR(u);
+         *i0 = ifloor(u);
          *i1 = *i0 + 1;
          if (*i0 < 0)
             *i0 = 0;
-         if (*i1 >= (GLint) size)
+         if (*i1 >= (int) size)
             *i1 = size - 1;
       }
       break;
@@ -298,7 +298,7 @@ linear_texcoord(GLuint wrapMode, float s, GLuint size,
       else
          u *= size;
       u -= 0.5F;
-      *i0 = IFLOOR(u);
+      *i0 = ifloor(u);
       *i1 = *i0 + 1;
       break;
    case PIPE_TEX_WRAP_MIRROR_CLAMP_TO_EDGE:
@@ -308,11 +308,11 @@ linear_texcoord(GLuint wrapMode, float s, GLuint size,
       else
          u *= size;
       u -= 0.5F;
-      *i0 = IFLOOR(u);
+      *i0 = ifloor(u);
       *i1 = *i0 + 1;
       if (*i0 < 0)
          *i0 = 0;
-      if (*i1 >= (GLint) size)
+      if (*i1 >= (int) size)
          *i1 = size - 1;
       break;
    case PIPE_TEX_WRAP_MIRROR_CLAMP_TO_BORDER:
@@ -327,7 +327,7 @@ linear_texcoord(GLuint wrapMode, float s, GLuint size,
          else
             u *= size;
          u -= 0.5F;
-         *i0 = IFLOOR(u);
+         *i0 = ifloor(u);
          *i1 = *i0 + 1;
       }
       break;
@@ -338,7 +338,7 @@ linear_texcoord(GLuint wrapMode, float s, GLuint size,
 }
 
 
-static GLuint
+static unsigned
 choose_cube_face(float rx, float ry, float rz, float *newS, float *newT)
 {
    /*
@@ -353,7 +353,7 @@ choose_cube_face(float rx, float ry, float rz, float *newS, float *newT)
        -rz          TEXTURE_CUBE_MAP_NEGATIVE_Z_EXT    -rx    -ry   rz
    */
    const float arx = FABSF(rx), ary = FABSF(ry), arz = FABSF(rz);
-   GLuint face;
+   unsigned face;
    float sc, tc, ma;
 
    if (arx > ary && arx > arz) {
@@ -779,16 +779,16 @@ sp_get_samples(struct tgsi_sampler *sampler,
                float rgba[NUM_CHANNELS][QUAD_SIZE])
 {
    switch (sampler->texture->target) {
-   case GL_TEXTURE_1D:
+   case PIPE_TEXTURE_1D:
       sp_get_samples_1d(sampler, s, t, p, lodbias, rgba);
       break;
-   case GL_TEXTURE_2D:
+   case PIPE_TEXTURE_2D:
       sp_get_samples_2d(sampler, s, t, p, lodbias, rgba);
       break;
-   case GL_TEXTURE_3D:
+   case PIPE_TEXTURE_3D:
       sp_get_samples_3d(sampler, s, t, p, lodbias, rgba);
       break;
-   case GL_TEXTURE_CUBE_MAP:
+   case PIPE_TEXTURE_CUBE:
       sp_get_samples_cube(sampler, s, t, p, lodbias, rgba);
       break;
    default:
diff --git a/src/mesa/pipe/softpipe/sp_tex_sample.h b/src/mesa/pipe/softpipe/sp_tex_sample.h
index 43aae872836..404bfd0c365 100644
--- a/src/mesa/pipe/softpipe/sp_tex_sample.h
+++ b/src/mesa/pipe/softpipe/sp_tex_sample.h
@@ -7,11 +7,11 @@ struct tgsi_sampler;
 
 extern void
 sp_get_samples(struct tgsi_sampler *sampler,
-               const GLfloat s[QUAD_SIZE],
-               const GLfloat t[QUAD_SIZE],
-               const GLfloat p[QUAD_SIZE],
+               const float s[QUAD_SIZE],
+               const float t[QUAD_SIZE],
+               const float p[QUAD_SIZE],
                float lodbias,
-               GLfloat rgba[NUM_CHANNELS][QUAD_SIZE]);
+               float rgba[NUM_CHANNELS][QUAD_SIZE]);
 
 
 #endif /* SP_TEX_SAMPLE_H */
diff --git a/src/mesa/pipe/tgsi/core/tgsi_build.h b/src/mesa/pipe/tgsi/core/tgsi_build.h
index 35c1a2506d2..8b5db5662c9 100644
--- a/src/mesa/pipe/tgsi/core/tgsi_build.h
+++ b/src/mesa/pipe/tgsi/core/tgsi_build.h
@@ -24,7 +24,7 @@ tgsi_default_processor( void );
 
 struct tgsi_processor
 tgsi_build_processor(
-   GLuint processor,
+   unsigned processor,
    struct tgsi_header *header );
 
 /*
@@ -36,31 +36,31 @@ tgsi_default_declaration( void );
 
 struct tgsi_declaration
 tgsi_build_declaration(
-   GLuint file,
-   GLuint declare,
-   GLuint interpolate,
+   unsigned file,
+   unsigned declare,
+   unsigned interpolate,
    struct tgsi_header *header );
 
 struct tgsi_full_declaration
 tgsi_default_full_declaration( void );
 
-GLuint
+unsigned
 tgsi_build_full_declaration(
    const struct tgsi_full_declaration *full_decl,
    struct tgsi_token *tokens,
    struct tgsi_header *header,
-   GLuint maxsize );
+   unsigned maxsize );
 
 struct tgsi_declaration_range
 tgsi_build_declaration_range(
-   GLuint first,
-   GLuint last,
+   unsigned first,
+   unsigned last,
    struct tgsi_declaration *declaration,
    struct tgsi_header *header );
 
 struct tgsi_declaration_mask
 tgsi_build_declaration_mask(
-   GLuint mask,
+   unsigned mask,
    struct tgsi_declaration *declaration,
    struct tgsi_header *header );
 
@@ -69,7 +69,7 @@ tgsi_default_declaration_interpolation( void );
 
 struct tgsi_declaration_interpolation
 tgsi_build_declaration_interpolation(
-   GLuint interpolate,
+   unsigned interpolate,
    struct tgsi_declaration *declaration,
    struct tgsi_header *header );
 
@@ -89,16 +89,16 @@ tgsi_default_full_immediate( void );
 
 struct tgsi_immediate_float32
 tgsi_build_immediate_float32(
-   GLfloat value,
+   float value,
    struct tgsi_immediate *immediate,
    struct tgsi_header *header );
 
-GLuint
+unsigned
 tgsi_build_full_immediate(
    const struct tgsi_full_immediate *full_imm,
    struct tgsi_token *tokens,
    struct tgsi_header *header,
-   GLuint maxsize );
+   unsigned maxsize );
 
 /*
  * instruction
@@ -109,42 +109,42 @@ tgsi_default_instruction( void );
 
 struct tgsi_instruction
 tgsi_build_instruction(
-   GLuint opcode,
-   GLuint saturate,
-   GLuint num_dst_regs,
-   GLuint num_src_regs,
+   unsigned opcode,
+   unsigned saturate,
+   unsigned num_dst_regs,
+   unsigned num_src_regs,
    struct tgsi_header *header );
 
 struct tgsi_full_instruction
 tgsi_default_full_instruction( void );
 
-GLuint
+unsigned
 tgsi_build_full_instruction(
    const struct tgsi_full_instruction *full_inst,
    struct tgsi_token *tokens,
    struct tgsi_header *header,
-   GLuint maxsize );
+   unsigned maxsize );
 
 struct tgsi_instruction_ext_nv
 tgsi_default_instruction_ext_nv( void );
 
-GLuint
+unsigned
 tgsi_compare_instruction_ext_nv(
    struct tgsi_instruction_ext_nv a,
    struct tgsi_instruction_ext_nv b );
 
 struct tgsi_instruction_ext_nv
 tgsi_build_instruction_ext_nv(
-   GLuint precision,
-   GLuint cond_dst_index,
-   GLuint cond_flow_index,
-   GLuint cond_mask,
-   GLuint cond_swizzle_x,
-   GLuint cond_swizzle_y,
-   GLuint cond_swizzle_z,
-   GLuint cond_swizzle_w,
-   GLuint cond_dst_update,
-   GLuint cond_flow_update,
+   unsigned precision,
+   unsigned cond_dst_index,
+   unsigned cond_flow_index,
+   unsigned cond_mask,
+   unsigned cond_swizzle_x,
+   unsigned cond_swizzle_y,
+   unsigned cond_swizzle_z,
+   unsigned cond_swizzle_w,
+   unsigned cond_dst_update,
+   unsigned cond_flow_update,
    struct tgsi_token *prev_token,
    struct tgsi_instruction *instruction,
    struct tgsi_header *header );
@@ -152,14 +152,14 @@ tgsi_build_instruction_ext_nv(
 struct tgsi_instruction_ext_label
 tgsi_default_instruction_ext_label( void );
 
-GLuint
+unsigned
 tgsi_compare_instruction_ext_label(
    struct tgsi_instruction_ext_label a,
    struct tgsi_instruction_ext_label b );
 
 struct tgsi_instruction_ext_label
 tgsi_build_instruction_ext_label(
-   GLuint label,
+   unsigned label,
    struct tgsi_token *prev_token,
    struct tgsi_instruction *instruction,
    struct tgsi_header *header );
@@ -167,14 +167,14 @@ tgsi_build_instruction_ext_label(
 struct tgsi_instruction_ext_texture
 tgsi_default_instruction_ext_texture( void );
 
-GLuint
+unsigned
 tgsi_compare_instruction_ext_texture(
    struct tgsi_instruction_ext_texture a,
    struct tgsi_instruction_ext_texture b );
 
 struct tgsi_instruction_ext_texture
 tgsi_build_instruction_ext_texture(
-   GLuint texture,
+   unsigned texture,
    struct tgsi_token *prev_token,
    struct tgsi_instruction *instruction,
    struct tgsi_header *header );
@@ -184,15 +184,15 @@ tgsi_default_src_register( void );
 
 struct tgsi_src_register
 tgsi_build_src_register(
-   GLuint file,
-   GLuint swizzle_x,
-   GLuint swizzle_y,
-   GLuint swizzle_z,
-   GLuint swizzle_w,
-   GLuint negate,
-   GLuint indirect,
-   GLuint dimension,
-   GLint index,
+   unsigned file,
+   unsigned swizzle_x,
+   unsigned swizzle_y,
+   unsigned swizzle_z,
+   unsigned swizzle_w,
+   unsigned negate,
+   unsigned indirect,
+   unsigned dimension,
+   int index,
    struct tgsi_instruction *instruction,
    struct tgsi_header *header );
 
@@ -202,22 +202,22 @@ tgsi_default_full_src_register( void );
 struct tgsi_src_register_ext_swz
 tgsi_default_src_register_ext_swz( void );
 
-GLuint
+unsigned
 tgsi_compare_src_register_ext_swz(
    struct tgsi_src_register_ext_swz a,
    struct tgsi_src_register_ext_swz b );
 
 struct tgsi_src_register_ext_swz
 tgsi_build_src_register_ext_swz(
-   GLuint ext_swizzle_x,
-   GLuint ext_swizzle_y,
-   GLuint ext_swizzle_z,
-   GLuint ext_swizzle_w,
-   GLuint negate_x,
-   GLuint negate_y,
-   GLuint negate_z,
-   GLuint negate_w,
-   GLuint ext_divide,
+   unsigned ext_swizzle_x,
+   unsigned ext_swizzle_y,
+   unsigned ext_swizzle_z,
+   unsigned ext_swizzle_w,
+   unsigned negate_x,
+   unsigned negate_y,
+   unsigned negate_z,
+   unsigned negate_w,
+   unsigned ext_divide,
    struct tgsi_token *prev_token,
    struct tgsi_instruction *instruction,
    struct tgsi_header *header );
@@ -225,18 +225,18 @@ tgsi_build_src_register_ext_swz(
 struct tgsi_src_register_ext_mod
 tgsi_default_src_register_ext_mod( void );
 
-GLuint
+unsigned
 tgsi_compare_src_register_ext_mod(
    struct tgsi_src_register_ext_mod a,
    struct tgsi_src_register_ext_mod b );
 
 struct tgsi_src_register_ext_mod
 tgsi_build_src_register_ext_mod(
-   GLuint complement,
-   GLuint bias,
-   GLuint scale_2x,
-   GLuint absolute,
-   GLuint negate,
+   unsigned complement,
+   unsigned bias,
+   unsigned scale_2x,
+   unsigned absolute,
+   unsigned negate,
    struct tgsi_token *prev_token,
    struct tgsi_instruction *instruction,
    struct tgsi_header *header );
@@ -246,8 +246,8 @@ tgsi_default_dimension( void );
 
 struct tgsi_dimension
 tgsi_build_dimension(
-   GLuint indirect,
-   GLuint index,
+   unsigned indirect,
+   unsigned index,
    struct tgsi_instruction *instruction,
    struct tgsi_header *header );
 
@@ -256,9 +256,9 @@ tgsi_default_dst_register( void );
 
 struct tgsi_dst_register
 tgsi_build_dst_register(
-   GLuint file,
-   GLuint mask,
-   GLint index,
+   unsigned file,
+   unsigned mask,
+   int index,
    struct tgsi_instruction *instruction,
    struct tgsi_header *header );
 
@@ -268,19 +268,19 @@ tgsi_default_full_dst_register( void );
 struct tgsi_dst_register_ext_concode
 tgsi_default_dst_register_ext_concode( void );
 
-GLuint
+unsigned
 tgsi_compare_dst_register_ext_concode(
    struct tgsi_dst_register_ext_concode a,
    struct tgsi_dst_register_ext_concode b );
 
 struct tgsi_dst_register_ext_concode
 tgsi_build_dst_register_ext_concode(
-   GLuint cc,
-   GLuint swizzle_x,
-   GLuint swizzle_y,
-   GLuint swizzle_z,
-   GLuint swizzle_w,
-   GLint index,
+   unsigned cc,
+   unsigned swizzle_x,
+   unsigned swizzle_y,
+   unsigned swizzle_z,
+   unsigned swizzle_w,
+   int index,
    struct tgsi_token *prev_token,
    struct tgsi_instruction *instruction,
    struct tgsi_header *header );
@@ -288,14 +288,14 @@ tgsi_build_dst_register_ext_concode(
 struct tgsi_dst_register_ext_modulate
 tgsi_default_dst_register_ext_modulate( void );
 
-GLuint
+unsigned
 tgsi_compare_dst_register_ext_modulate(
    struct tgsi_dst_register_ext_modulate a,
    struct tgsi_dst_register_ext_modulate b );
 
 struct tgsi_dst_register_ext_modulate
 tgsi_build_dst_register_ext_modulate(
-   GLuint modulate,
+   unsigned modulate,
    struct tgsi_token *prev_token,
    struct tgsi_instruction *instruction,
    struct tgsi_header *header );
diff --git a/src/mesa/pipe/tgsi/core/tgsi_dump.h b/src/mesa/pipe/tgsi/core/tgsi_dump.h
index 8553bdff592..70860c0885a 100644
--- a/src/mesa/pipe/tgsi/core/tgsi_dump.h
+++ b/src/mesa/pipe/tgsi/core/tgsi_dump.h
@@ -12,7 +12,7 @@ extern "C" {
 void
 tgsi_dump(
    const struct tgsi_token *tokens,
-   GLuint flags );
+   unsigned flags );
 
 #if defined __cplusplus
 } // extern "C"
diff --git a/src/mesa/pipe/tgsi/core/tgsi_exec.h b/src/mesa/pipe/tgsi/core/tgsi_exec.h
index 5e07e18a31e..eed2207d7d3 100644
--- a/src/mesa/pipe/tgsi/core/tgsi_exec.h
+++ b/src/mesa/pipe/tgsi/core/tgsi_exec.h
@@ -1,6 +1,8 @@
 #if !defined TGSI_EXEC_H
 #define TGSI_EXEC_H
 
+#include "pipe/p_compiler.h"
+
 #if 0
 #include "x86/rtasm/x86sse.h"
 #endif
@@ -11,9 +13,9 @@ extern "C" {
 
 union tgsi_exec_channel
 {
-   GLfloat  f[4];
-   GLint    i[4];
-   GLuint   u[4];
+   float  f[4];
+   int    i[4];
+   unsigned   u[4];
 };
 
 struct tgsi_exec_vector
@@ -33,7 +35,7 @@ struct tgsi_exec_vector
 struct tgsi_texture_cache_entry
 {
    int x, y, face, level, zslice;
-   GLfloat data[TEX_CACHE_TILE_SIZE][TEX_CACHE_TILE_SIZE][4];
+   float data[TEX_CACHE_TILE_SIZE][TEX_CACHE_TILE_SIZE][4];
 };
 
 struct tgsi_sampler
@@ -42,19 +44,19 @@ struct tgsi_sampler
    struct pipe_mipmap_tree *texture;
    /** Get samples for four fragments in a quad */
    void (*get_samples)(struct tgsi_sampler *sampler,
-                       const GLfloat s[QUAD_SIZE],
-                       const GLfloat t[QUAD_SIZE],
-                       const GLfloat p[QUAD_SIZE],
-                       GLfloat lodbias,
-                       GLfloat rgba[NUM_CHANNELS][QUAD_SIZE]);
+                       const float s[QUAD_SIZE],
+                       const float t[QUAD_SIZE],
+                       const float p[QUAD_SIZE],
+                       float lodbias,
+                       float rgba[NUM_CHANNELS][QUAD_SIZE]);
    void *pipe; /*XXX temporary*/
    struct tgsi_texture_cache_entry cache[TEX_CACHE_NUM_ENTRIES];
 };
 
 struct tgsi_exec_labels
 {
-   GLuint   labels[128][2];
-   GLuint   count;
+   unsigned   labels[128][2];
+   unsigned   count;
 };
 
 #define TGSI_EXEC_TEMP_00000000_I   32
@@ -107,15 +109,15 @@ struct tgsi_exec_cond_state
 {
    struct tgsi_exec_cond_regs IfPortion;
    struct tgsi_exec_cond_regs ElsePortion;
-   GLuint                     Condition;
-   GLboolean                  WasElse;
+   unsigned                     Condition;
+   boolean                  WasElse;
 };
 
 /* XXX: This is temporary */
 struct tgsi_exec_cond_stack
 {
    struct tgsi_exec_cond_state   States[8];
-   GLuint                        Index;      /* into States[] */
+   unsigned                        Index;      /* into States[] */
 };
 
 struct tgsi_exec_machine
@@ -136,15 +138,15 @@ struct tgsi_exec_machine
 
    struct tgsi_sampler           *Samplers;
 
-   GLfloat                       Imms[256][4];
-   GLuint                        ImmLimit;
-   GLfloat                       (*Consts)[4];
+   float                       Imms[256][4];
+   unsigned                        ImmLimit;
+   float                       (*Consts)[4];
    const struct tgsi_exec_vector *Inputs;
    struct tgsi_exec_vector       *Outputs;
    struct tgsi_token             *Tokens;
-   GLuint                        Processor;
+   unsigned                        Processor;
 
-   GLuint                        *Primitives;
+   unsigned                        *Primitives;
 
    struct tgsi_exec_cond_stack   CondStack;
 #if XXX_SSE
@@ -156,7 +158,7 @@ void
 tgsi_exec_machine_init(
    struct tgsi_exec_machine *mach,
    struct tgsi_token *tokens,
-   GLuint numSamplers,
+   unsigned numSamplers,
    struct tgsi_sampler *samplers);
 
 void
diff --git a/src/mesa/pipe/tgsi/core/tgsi_parse.h b/src/mesa/pipe/tgsi/core/tgsi_parse.h
index 61ad0669b17..bba01431fac 100644
--- a/src/mesa/pipe/tgsi/core/tgsi_parse.h
+++ b/src/mesa/pipe/tgsi/core/tgsi_parse.h
@@ -86,7 +86,7 @@ tgsi_full_token_free(
 struct tgsi_parse_context
 {
    const struct tgsi_token    *Tokens;
-   GLuint                     Position;
+   unsigned                     Position;
    struct tgsi_full_version   FullVersion;
    struct tgsi_full_header    FullHeader;
    union tgsi_full_token      FullToken;
@@ -95,7 +95,7 @@ struct tgsi_parse_context
 #define TGSI_PARSE_OK      0
 #define TGSI_PARSE_ERROR   1
 
-GLuint
+unsigned
 tgsi_parse_init(
    struct tgsi_parse_context *ctx,
    const struct tgsi_token *tokens );
@@ -104,7 +104,7 @@ void
 tgsi_parse_free(
    struct tgsi_parse_context *ctx );
 
-GLuint
+unsigned
 tgsi_parse_end_of_tokens(
    struct tgsi_parse_context *ctx );
 
diff --git a/src/mesa/pipe/tgsi/core/tgsi_token.h b/src/mesa/pipe/tgsi/core/tgsi_token.h
index ec62836ef3b..dc9301ed374 100644
--- a/src/mesa/pipe/tgsi/core/tgsi_token.h
+++ b/src/mesa/pipe/tgsi/core/tgsi_token.h
@@ -7,15 +7,15 @@ extern "C" {
 
 struct tgsi_version
 {
-   GLuint MajorVersion  : 8;
-   GLuint MinorVersion  : 8;
-   GLuint Padding       : 16;
+   unsigned MajorVersion  : 8;
+   unsigned MinorVersion  : 8;
+   unsigned Padding       : 16;
 };
 
 struct tgsi_header
 {
-   GLuint HeaderSize : 8;
-   GLuint BodySize   : 24;
+   unsigned HeaderSize : 8;
+   unsigned BodySize   : 24;
 };
 
 #define TGSI_PROCESSOR_FRAGMENT  0
@@ -24,8 +24,8 @@ struct tgsi_header
 
 struct tgsi_processor
 {
-   GLuint Processor  : 4;  /* TGSI_PROCESSOR_ */
-   GLuint Padding    : 28;
+   unsigned Processor  : 4;  /* TGSI_PROCESSOR_ */
+   unsigned Padding    : 28;
 };
 
 #define TGSI_TOKEN_TYPE_DECLARATION    0
@@ -34,10 +34,10 @@ struct tgsi_processor
 
 struct tgsi_token
 {
-   GLuint Type       : 4;  /* TGSI_TOKEN_TYPE_ */
-   GLuint Size       : 8;  /* UINT */
-   GLuint Padding    : 19;
-   GLuint Extended   : 1;  /* BOOL */
+   unsigned Type       : 4;  /* TGSI_TOKEN_TYPE_ */
+   unsigned Size       : 8;  /* UINT */
+   unsigned Padding    : 19;
+   unsigned Extended   : 1;  /* BOOL */
 };
 
 #define TGSI_FILE_NULL        0
@@ -54,24 +54,24 @@ struct tgsi_token
 
 struct tgsi_declaration
 {
-   GLuint Type          : 4;  /* TGSI_TOKEN_TYPE_DECLARATION */
-   GLuint Size          : 8;  /* UINT */
-   GLuint File          : 4;  /* TGSI_FILE_ */
-   GLuint Declare       : 4;  /* TGSI_DECLARE_ */
-   GLuint Interpolate   : 1;  /* BOOL */
-   GLuint Padding       : 10;
-   GLuint Extended      : 1;  /* BOOL */
+   unsigned Type          : 4;  /* TGSI_TOKEN_TYPE_DECLARATION */
+   unsigned Size          : 8;  /* UINT */
+   unsigned File          : 4;  /* TGSI_FILE_ */
+   unsigned Declare       : 4;  /* TGSI_DECLARE_ */
+   unsigned Interpolate   : 1;  /* BOOL */
+   unsigned Padding       : 10;
+   unsigned Extended      : 1;  /* BOOL */
 };
 
 struct tgsi_declaration_range
 {
-   GLuint First   : 16; /* UINT */
-   GLuint Last    : 16; /* UINT */
+   unsigned First   : 16; /* UINT */
+   unsigned Last    : 16; /* UINT */
 };
 
 struct tgsi_declaration_mask
 {
-   GLuint Mask : 32; /* UINT */
+   unsigned Mask : 32; /* UINT */
 };
 
 #define TGSI_INTERPOLATE_CONSTANT      0
@@ -80,24 +80,24 @@ struct tgsi_declaration_mask
 
 struct tgsi_declaration_interpolation
 {
-   GLuint Interpolate   : 4;  /* TGSI_INTERPOLATE_ */
-   GLuint Padding       : 28;
+   unsigned Interpolate   : 4;  /* TGSI_INTERPOLATE_ */
+   unsigned Padding       : 28;
 };
 
 #define TGSI_IMM_FLOAT32   0
 
 struct tgsi_immediate
 {
-   GLuint Type       : 4;  /* TGSI_TOKEN_TYPE_IMMEDIATE */
-   GLuint Size       : 8;  /* UINT */
-   GLuint DataType   : 4;  /* TGSI_IMM_ */
-   GLuint Padding    : 15;
-   GLuint Extended   : 1;  /* BOOL */
+   unsigned Type       : 4;  /* TGSI_TOKEN_TYPE_IMMEDIATE */
+   unsigned Size       : 8;  /* UINT */
+   unsigned DataType   : 4;  /* TGSI_IMM_ */
+   unsigned Padding    : 15;
+   unsigned Extended   : 1;  /* BOOL */
 };
 
 struct tgsi_immediate_float32
 {
-   GLfloat Float;
+   float Float;
 };
 
 /*
@@ -1088,14 +1088,14 @@ struct tgsi_immediate_float32
 
 struct tgsi_instruction
 {
-   GLuint Type       : 4;  /* TGSI_TOKEN_TYPE_INSTRUCTION */
-   GLuint Size       : 8;  /* UINT */
-   GLuint Opcode     : 8;  /* TGSI_OPCODE_ */
-   GLuint Saturate   : 2;  /* TGSI_SAT_ */
-   GLuint NumDstRegs : 2;  /* UINT */
-   GLuint NumSrcRegs : 4;  /* UINT */
-   GLuint Padding    : 3;
-   GLuint Extended   : 1;  /* BOOL */
+   unsigned Type       : 4;  /* TGSI_TOKEN_TYPE_INSTRUCTION */
+   unsigned Size       : 8;  /* UINT */
+   unsigned Opcode     : 8;  /* TGSI_OPCODE_ */
+   unsigned Saturate   : 2;  /* TGSI_SAT_ */
+   unsigned NumDstRegs : 2;  /* UINT */
+   unsigned NumSrcRegs : 4;  /* UINT */
+   unsigned Padding    : 3;
+   unsigned Extended   : 1;  /* BOOL */
 };
 
 /*
@@ -1116,9 +1116,9 @@ struct tgsi_instruction
 
 struct tgsi_instruction_ext
 {
-   GLuint Type       : 4;  /* TGSI_INSTRUCTION_EXT_TYPE_ */
-   GLuint Padding    : 27;
-   GLuint Extended   : 1;  /* BOOL */
+   unsigned Type       : 4;  /* TGSI_INSTRUCTION_EXT_TYPE_ */
+   unsigned Padding    : 27;
+   unsigned Extended   : 1;  /* BOOL */
 };
 
 /*
@@ -1174,27 +1174,27 @@ struct tgsi_instruction_ext
 
 struct tgsi_instruction_ext_nv
 {
-   GLuint Type             : 4;    /* TGSI_INSTRUCTION_EXT_TYPE_NV */
-   GLuint Precision        : 4;    /* TGSI_PRECISION_ */
-   GLuint CondDstIndex     : 4;    /* UINT */
-   GLuint CondFlowIndex    : 4;    /* UINT */
-   GLuint CondMask         : 4;    /* TGSI_CC_ */
-   GLuint CondSwizzleX     : 2;    /* TGSI_SWIZZLE_ */
-   GLuint CondSwizzleY     : 2;    /* TGSI_SWIZZLE_ */
-   GLuint CondSwizzleZ     : 2;    /* TGSI_SWIZZLE_ */
-   GLuint CondSwizzleW     : 2;    /* TGSI_SWIZZLE_ */
-   GLuint CondDstUpdate    : 1;    /* BOOL */
-   GLuint CondFlowEnable   : 1;    /* BOOL */
-   GLuint Padding          : 1;
-   GLuint Extended         : 1;    /* BOOL */
+   unsigned Type             : 4;    /* TGSI_INSTRUCTION_EXT_TYPE_NV */
+   unsigned Precision        : 4;    /* TGSI_PRECISION_ */
+   unsigned CondDstIndex     : 4;    /* UINT */
+   unsigned CondFlowIndex    : 4;    /* UINT */
+   unsigned CondMask         : 4;    /* TGSI_CC_ */
+   unsigned CondSwizzleX     : 2;    /* TGSI_SWIZZLE_ */
+   unsigned CondSwizzleY     : 2;    /* TGSI_SWIZZLE_ */
+   unsigned CondSwizzleZ     : 2;    /* TGSI_SWIZZLE_ */
+   unsigned CondSwizzleW     : 2;    /* TGSI_SWIZZLE_ */
+   unsigned CondDstUpdate    : 1;    /* BOOL */
+   unsigned CondFlowEnable   : 1;    /* BOOL */
+   unsigned Padding          : 1;
+   unsigned Extended         : 1;    /* BOOL */
 };
 
 struct tgsi_instruction_ext_label
 {
-   GLuint Type     : 4;    /* TGSI_INSTRUCTION_EXT_TYPE_LABEL */
-   GLuint Label    : 24;   /* UINT */
-   GLuint Padding  : 3;
-   GLuint Extended : 1;    /* BOOL */
+   unsigned Type     : 4;    /* TGSI_INSTRUCTION_EXT_TYPE_LABEL */
+   unsigned Label    : 24;   /* UINT */
+   unsigned Padding  : 3;
+   unsigned Extended : 1;    /* BOOL */
 };
 
 #define TGSI_TEXTURE_UNKNOWN        0
@@ -1209,10 +1209,10 @@ struct tgsi_instruction_ext_label
 
 struct tgsi_instruction_ext_texture
 {
-   GLuint Type     : 4;    /* TGSI_INSTRUCTION_EXT_TYPE_TEXTURE */
-   GLuint Texture  : 8;    /* TGSI_TEXTURE_ */
-   GLuint Padding  : 19;
-   GLuint Extended : 1;    /* BOOL */
+   unsigned Type     : 4;    /* TGSI_INSTRUCTION_EXT_TYPE_TEXTURE */
+   unsigned Texture  : 8;    /* TGSI_TEXTURE_ */
+   unsigned Padding  : 19;
+   unsigned Extended : 1;    /* BOOL */
 };
 
 #define TGSI_WRITEMASK_NONE     0x00
@@ -1234,11 +1234,11 @@ struct tgsi_instruction_ext_texture
 
 struct tgsi_instruction_ext_predicate
 {
-   GLuint Type             : 4;    /* TGSI_INSTRUCTION_EXT_TYPE_PREDICATE */
-   GLuint PredDstIndex     : 4;    /* UINT */
-   GLuint PredWriteMask    : 4;    /* TGSI_WRITEMASK_ */
-   GLuint Padding          : 19;
-   GLuint Extended         : 1;    /* BOOL */
+   unsigned Type             : 4;    /* TGSI_INSTRUCTION_EXT_TYPE_PREDICATE */
+   unsigned PredDstIndex     : 4;    /* UINT */
+   unsigned PredWriteMask    : 4;    /* TGSI_WRITEMASK_ */
+   unsigned Padding          : 19;
+   unsigned Extended         : 1;    /* BOOL */
 };
 
 /*
@@ -1261,16 +1261,16 @@ struct tgsi_instruction_ext_predicate
 
 struct tgsi_src_register
 {
-   GLuint File         : 4;    /* TGSI_FILE_ */
-   GLuint SwizzleX     : 2;    /* TGSI_SWIZZLE_ */
-   GLuint SwizzleY     : 2;    /* TGSI_SWIZZLE_ */
-   GLuint SwizzleZ     : 2;    /* TGSI_SWIZZLE_ */
-   GLuint SwizzleW     : 2;    /* TGSI_SWIZZLE_ */
-   GLuint Negate       : 1;    /* BOOL */
-   GLuint Indirect     : 1;    /* BOOL */
-   GLuint Dimension    : 1;    /* BOOL */
-   GLint  Index        : 16;   /* SINT */
-   GLuint Extended     : 1;    /* BOOL */
+   unsigned File         : 4;    /* TGSI_FILE_ */
+   unsigned SwizzleX     : 2;    /* TGSI_SWIZZLE_ */
+   unsigned SwizzleY     : 2;    /* TGSI_SWIZZLE_ */
+   unsigned SwizzleZ     : 2;    /* TGSI_SWIZZLE_ */
+   unsigned SwizzleW     : 2;    /* TGSI_SWIZZLE_ */
+   unsigned Negate       : 1;    /* BOOL */
+   unsigned Indirect     : 1;    /* BOOL */
+   unsigned Dimension    : 1;    /* BOOL */
+   int  Index        : 16;   /* SINT */
+   unsigned Extended     : 1;    /* BOOL */
 };
 
 /*
@@ -1287,9 +1287,9 @@ struct tgsi_src_register
 
 struct tgsi_src_register_ext
 {
-   GLuint Type     : 4;    /* TGSI_SRC_REGISTER_EXT_TYPE_ */
-   GLuint Padding  : 27;
-   GLuint Extended : 1;    /* BOOL */
+   unsigned Type     : 4;    /* TGSI_SRC_REGISTER_EXT_TYPE_ */
+   unsigned Padding  : 27;
+   unsigned Extended : 1;    /* BOOL */
 };
 
 /*
@@ -1323,18 +1323,18 @@ struct tgsi_src_register_ext
 
 struct tgsi_src_register_ext_swz
 {
-   GLuint Type         : 4;    /* TGSI_SRC_REGISTER_EXT_TYPE_SWZ */
-   GLuint ExtSwizzleX  : 4;    /* TGSI_EXTSWIZZLE_ */
-   GLuint ExtSwizzleY  : 4;    /* TGSI_EXTSWIZZLE_ */
-   GLuint ExtSwizzleZ  : 4;    /* TGSI_EXTSWIZZLE_ */
-   GLuint ExtSwizzleW  : 4;    /* TGSI_EXTSWIZZLE_ */
-   GLuint NegateX      : 1;    /* BOOL */
-   GLuint NegateY      : 1;    /* BOOL */
-   GLuint NegateZ      : 1;    /* BOOL */
-   GLuint NegateW      : 1;    /* BOOL */
-   GLuint ExtDivide    : 4;    /* TGSI_EXTSWIZZLE_ */
-   GLuint Padding      : 3;
-   GLuint Extended     : 1;    /* BOOL */
+   unsigned Type         : 4;    /* TGSI_SRC_REGISTER_EXT_TYPE_SWZ */
+   unsigned ExtSwizzleX  : 4;    /* TGSI_EXTSWIZZLE_ */
+   unsigned ExtSwizzleY  : 4;    /* TGSI_EXTSWIZZLE_ */
+   unsigned ExtSwizzleZ  : 4;    /* TGSI_EXTSWIZZLE_ */
+   unsigned ExtSwizzleW  : 4;    /* TGSI_EXTSWIZZLE_ */
+   unsigned NegateX      : 1;    /* BOOL */
+   unsigned NegateY      : 1;    /* BOOL */
+   unsigned NegateZ      : 1;    /* BOOL */
+   unsigned NegateW      : 1;    /* BOOL */
+   unsigned ExtDivide    : 4;    /* TGSI_EXTSWIZZLE_ */
+   unsigned Padding      : 3;
+   unsigned Extended     : 1;    /* BOOL */
 };
 
 /*
@@ -1352,34 +1352,34 @@ struct tgsi_src_register_ext_swz
 
 struct tgsi_src_register_ext_mod
 {
-   GLuint Type         : 4;    /* TGSI_SRC_REGISTER_EXT_TYPE_MOD */
-   GLuint Complement   : 1;    /* BOOL */
-   GLuint Bias         : 1;    /* BOOL */
-   GLuint Scale2X      : 1;    /* BOOL */
-   GLuint Absolute     : 1;    /* BOOL */
-   GLuint Negate       : 1;    /* BOOL */
-   GLuint Padding      : 22;
-   GLuint Extended     : 1;    /* BOOL */
+   unsigned Type         : 4;    /* TGSI_SRC_REGISTER_EXT_TYPE_MOD */
+   unsigned Complement   : 1;    /* BOOL */
+   unsigned Bias         : 1;    /* BOOL */
+   unsigned Scale2X      : 1;    /* BOOL */
+   unsigned Absolute     : 1;    /* BOOL */
+   unsigned Negate       : 1;    /* BOOL */
+   unsigned Padding      : 22;
+   unsigned Extended     : 1;    /* BOOL */
 };
 
 struct tgsi_dimension
 {
-   GLuint Indirect     : 1;    /* BOOL */
-   GLuint Dimension    : 1;    /* BOOL */
-   GLuint Padding      : 13;
-   GLint  Index        : 16;   /* SINT */
-   GLuint Extended     : 1;    /* BOOL */
+   unsigned Indirect     : 1;    /* BOOL */
+   unsigned Dimension    : 1;    /* BOOL */
+   unsigned Padding      : 13;
+   int  Index        : 16;   /* SINT */
+   unsigned Extended     : 1;    /* BOOL */
 };
 
 struct tgsi_dst_register
 {
-   GLuint File         : 4;    /* TGSI_FILE_ */
-   GLuint WriteMask    : 4;    /* TGSI_WRITEMASK_ */
-   GLuint Indirect     : 1;    /* BOOL */
-   GLuint Dimension    : 1;    /* BOOL */
-   GLint  Index        : 16;   /* SINT */
-   GLuint Padding      : 5;
-   GLuint Extended     : 1;    /* BOOL */
+   unsigned File         : 4;    /* TGSI_FILE_ */
+   unsigned WriteMask    : 4;    /* TGSI_WRITEMASK_ */
+   unsigned Indirect     : 1;    /* BOOL */
+   unsigned Dimension    : 1;    /* BOOL */
+   int  Index        : 16;   /* SINT */
+   unsigned Padding      : 5;
+   unsigned Extended     : 1;    /* BOOL */
 };
 
 /*
@@ -1394,9 +1394,9 @@ struct tgsi_dst_register
 
 struct tgsi_dst_register_ext
 {
-   GLuint Type     : 4;    /* TGSI_DST_REGISTER_EXT_TYPE_ */
-   GLuint Padding  : 27;
-   GLuint Extended : 1;    /* BOOL */
+   unsigned Type     : 4;    /* TGSI_DST_REGISTER_EXT_TYPE_ */
+   unsigned Padding  : 27;
+   unsigned Extended : 1;    /* BOOL */
 };
 
 /*
@@ -1415,15 +1415,15 @@ struct tgsi_dst_register_ext
 
 struct tgsi_dst_register_ext_concode
 {
-   GLuint Type         : 4;    /* TGSI_DST_REGISTER_EXT_TYPE_CONDCODE */
-   GLuint CondMask     : 4;    /* TGSI_CC_ */
-   GLuint CondSwizzleX : 2;    /* TGSI_SWIZZLE_ */
-   GLuint CondSwizzleY : 2;    /* TGSI_SWIZZLE_ */
-   GLuint CondSwizzleZ : 2;    /* TGSI_SWIZZLE_ */
-   GLuint CondSwizzleW : 2;    /* TGSI_SWIZZLE_ */
-   GLuint CondSrcIndex : 4;    /* UINT */
-   GLuint Padding      : 11;
-   GLuint Extended     : 1;    /* BOOL */
+   unsigned Type         : 4;    /* TGSI_DST_REGISTER_EXT_TYPE_CONDCODE */
+   unsigned CondMask     : 4;    /* TGSI_CC_ */
+   unsigned CondSwizzleX : 2;    /* TGSI_SWIZZLE_ */
+   unsigned CondSwizzleY : 2;    /* TGSI_SWIZZLE_ */
+   unsigned CondSwizzleZ : 2;    /* TGSI_SWIZZLE_ */
+   unsigned CondSwizzleW : 2;    /* TGSI_SWIZZLE_ */
+   unsigned CondSrcIndex : 4;    /* UINT */
+   unsigned Padding      : 11;
+   unsigned Extended     : 1;    /* BOOL */
 };
 
 #define TGSI_MODULATE_1X        0
@@ -1436,10 +1436,10 @@ struct tgsi_dst_register_ext_concode
 
 struct tgsi_dst_register_ext_modulate
 {
-   GLuint Type     : 4;    /* TGSI_DST_REGISTER_EXT_TYPE_MODULATE */
-   GLuint Modulate : 4;    /* TGSI_MODULATE_ */
-   GLuint Padding  : 23;
-   GLuint Extended : 1;    /* BOOL */
+   unsigned Type     : 4;    /* TGSI_DST_REGISTER_EXT_TYPE_MODULATE */
+   unsigned Modulate : 4;    /* TGSI_MODULATE_ */
+   unsigned Padding  : 23;
+   unsigned Extended : 1;    /* BOOL */
 };
 
 /*
@@ -1451,15 +1451,15 @@ struct tgsi_dst_register_ext_modulate
 
 struct tgsi_dst_register_ext_predicate
 {
-   GLuint Type         : 4;    /* TGSI_DST_REGISTER_EXT_TYPE_PREDICATE */
-   GLuint PredSwizzleX : 2;    /* TGSI_SWIZZLE_ */
-   GLuint PredSwizzleY : 2;    /* TGSI_SWIZZLE_ */
-   GLuint PredSwizzleZ : 2;    /* TGSI_SWIZZLE_ */
-   GLuint PredSwizzleW : 2;    /* TGSI_SWIZZLE_ */
-   GLuint PredSrcIndex : 4;    /* UINT */
-   GLuint Negate       : 1;    /* BOOL */
-   GLuint Padding      : 14;
-   GLuint Extended     : 1;    /* BOOL */
+   unsigned Type         : 4;    /* TGSI_DST_REGISTER_EXT_TYPE_PREDICATE */
+   unsigned PredSwizzleX : 2;    /* TGSI_SWIZZLE_ */
+   unsigned PredSwizzleY : 2;    /* TGSI_SWIZZLE_ */
+   unsigned PredSwizzleZ : 2;    /* TGSI_SWIZZLE_ */
+   unsigned PredSwizzleW : 2;    /* TGSI_SWIZZLE_ */
+   unsigned PredSrcIndex : 4;    /* UINT */
+   unsigned Negate       : 1;    /* BOOL */
+   unsigned Padding      : 14;
+   unsigned Extended     : 1;    /* BOOL */
 };
 
 #if defined __cplusplus
diff --git a/src/mesa/pipe/tgsi/core/tgsi_util.h b/src/mesa/pipe/tgsi/core/tgsi_util.h
index 70c48690c5b..ef14446f0e4 100644
--- a/src/mesa/pipe/tgsi/core/tgsi_util.h
+++ b/src/mesa/pipe/tgsi/core/tgsi_util.h
@@ -9,58 +9,58 @@ void *
 tgsi_align_128bit(
    void *unaligned );
 
-GLuint
+unsigned
 tgsi_util_get_src_register_swizzle(
    const struct tgsi_src_register *reg,
-   GLuint component );
+   unsigned component );
 
-GLuint
+unsigned
 tgsi_util_get_src_register_extswizzle(
    const struct tgsi_src_register_ext_swz *reg,
-   GLuint component);
+   unsigned component);
 
-GLuint
+unsigned
 tgsi_util_get_full_src_register_extswizzle(
    const struct tgsi_full_src_register *reg,
-   GLuint component );
+   unsigned component );
 
 void
 tgsi_util_set_src_register_swizzle(
    struct tgsi_src_register *reg,
-   GLuint swizzle,
-   GLuint component );
+   unsigned swizzle,
+   unsigned component );
 
 void
 tgsi_util_set_src_register_extswizzle(
    struct tgsi_src_register_ext_swz *reg,
-   GLuint swizzle,
-   GLuint component );
+   unsigned swizzle,
+   unsigned component );
 
-GLuint
+unsigned
 tgsi_util_get_src_register_extnegate(
    const struct tgsi_src_register_ext_swz *reg,
-   GLuint component );
+   unsigned component );
 
 void
 tgsi_util_set_src_register_extnegate(
    struct tgsi_src_register_ext_swz *reg,
-   GLuint negate,
-   GLuint component );
+   unsigned negate,
+   unsigned component );
 
 #define TGSI_UTIL_SIGN_CLEAR    0   /* Force positive */
 #define TGSI_UTIL_SIGN_SET      1   /* Force negative */
 #define TGSI_UTIL_SIGN_TOGGLE   2   /* Negate */
 #define TGSI_UTIL_SIGN_KEEP     3   /* No change */
 
-GLuint
+unsigned
 tgsi_util_get_full_src_register_sign_mode(
    const struct tgsi_full_src_register *reg,
-   GLuint component );
+   unsigned component );
 
 void
 tgsi_util_set_full_src_register_sign_mode(
    struct tgsi_full_src_register *reg,
-   GLuint sign_mode );
+   unsigned sign_mode );
 
 #if defined __cplusplus
 } // extern "C"