Remove all traces of CULL_MASK_ACTIVE.

1 files changed, 152 insertions, 320 deletions

diff --git a/src/mesa/math/m_xform_tmp.h b/src/mesa/math/m_xform_tmp.h
index 8d96e6af71..ade052bdbd 100644
--- a/src/mesa/math/m_xform_tmp.h
+++ b/src/mesa/math/m_xform_tmp.h
@@ -1,4 +1,4 @@
-/* $Id: m_xform_tmp.h,v 1.5 2001/03/12 02:02:36 gareth Exp $ */
+/* $Id: m_xform_tmp.h,v 1.6 2001/03/30 14:44:43 gareth Exp $ */
 
 /*
  * Mesa 3-D graphics library
@@ -65,12 +65,16 @@
  *     cliped and/or culled vertices.
  */
 
+/* GH: Not any more -- it's easier (and faster) to just process the
+ *     entire vector.  Clipping and culling are handled further down
+ *     the pipe, most often during or after the conversion to some
+ *     driver-specific vertex format.
+ */
+
 static void _XFORMAPI
 TAG(transform_points1_general)( GLvector4f *to_vec,
 				const GLfloat m[16],
-				const GLvector4f *from_vec,
-				const GLubyte *mask,
-				const GLubyte flag )
+				const GLvector4f *from_vec )
 {
    const GLuint stride = from_vec->stride;
    GLfloat *from = from_vec->start;
@@ -81,18 +85,13 @@ TAG(transform_points1_general)( GLvector4f *to_vec,
    const GLfloat m2 = m[2],  m14 = m[14];
    const GLfloat m3 = m[3],  m15 = m[15];
    GLuint i;
-   (void) mask;
-   (void) flag;
    STRIDE_LOOP {
-      CLIP_CHECK {
-	 const GLfloat ox = from[0];
-	 to[i][0] = m0 * ox + m12;
-	 to[i][1] = m1 * ox + m13;
-	 to[i][2] = m2 * ox + m14;
-	 to[i][3] = m3 * ox + m15;
-      }
+      const GLfloat ox = from[0];
+      to[i][0] = m0 * ox + m12;
+      to[i][1] = m1 * ox + m13;
+      to[i][2] = m2 * ox + m14;
+      to[i][3] = m3 * ox + m15;
    }
-
    to_vec->size = 4;
    to_vec->flags |= VEC_SIZE_4;
    to_vec->count = from_vec->count;
@@ -101,24 +100,17 @@ TAG(transform_points1_general)( GLvector4f *to_vec,
 static void _XFORMAPI
 TAG(transform_points1_identity)( GLvector4f *to_vec,
 				 const GLfloat m[16],
-				 const GLvector4f *from_vec,
-				 const GLubyte *mask,
-				 const GLubyte flag )
+				 const GLvector4f *from_vec )
 {
    const GLuint stride = from_vec->stride;
    GLfloat *from = from_vec->start;
    GLuint count = from_vec->count;
    GLfloat (*to)[4] = (GLfloat (*)[4])to_vec->start;
    GLuint i;
-   (void) mask;
-   (void) flag;
    if (to_vec == from_vec) return;
    STRIDE_LOOP {
-      CLIP_CHECK {
-	 to[i][0] = from[0];
-      }
+      to[i][0] = from[0];
    }
-
    to_vec->size = 1;
    to_vec->flags |= VEC_SIZE_1;
    to_vec->count = from_vec->count;
@@ -127,9 +119,7 @@ TAG(transform_points1_identity)( GLvector4f *to_vec,
 static void _XFORMAPI
 TAG(transform_points1_2d)( GLvector4f *to_vec,
 			   const GLfloat m[16],
-			   const GLvector4f *from_vec,
-			   const GLubyte *mask,
-			   const GLubyte flag )
+			   const GLvector4f *from_vec )
 {
    const GLuint stride = from_vec->stride;
    GLfloat *from = from_vec->start;
@@ -138,14 +128,10 @@ TAG(transform_points1_2d)( GLvector4f *to_vec,
    const GLfloat m0 = m[0], m1 = m[1];
    const GLfloat m12 = m[12], m13 = m[13];
    GLuint i;
-   (void) mask;
-   (void) flag;
    STRIDE_LOOP {
-      CLIP_CHECK {
-	 const GLfloat ox = from[0];
-	 to[i][0] = m0 * ox + m12;
-	 to[i][1] = m1 * ox + m13;
-      }
+      const GLfloat ox = from[0];
+      to[i][0] = m0 * ox + m12;
+      to[i][1] = m1 * ox + m13;
    }
    to_vec->size = 2;
    to_vec->flags |= VEC_SIZE_2;
@@ -155,9 +141,7 @@ TAG(transform_points1_2d)( GLvector4f *to_vec,
 static void _XFORMAPI
 TAG(transform_points1_2d_no_rot)( GLvector4f *to_vec,
 				  const GLfloat m[16],
-				  const GLvector4f *from_vec,
-				  const GLubyte *mask,
-				  const GLubyte flag )
+				  const GLvector4f *from_vec )
 {
    const GLuint stride = from_vec->stride;
    GLfloat *from = from_vec->start;
@@ -165,16 +149,11 @@ TAG(transform_points1_2d_no_rot)( GLvector4f *to_vec,
    GLuint count = from_vec->count;
    const GLfloat m0 = m[0], m12 = m[12], m13 = m[13];
    GLuint i;
-   (void) mask;
-   (void) flag;
    STRIDE_LOOP {
-      CLIP_CHECK {
-	 const GLfloat ox = from[0];
-	 to[i][0] = m0 * ox + m12;
-	 to[i][1] =           m13;
-      }
+      const GLfloat ox = from[0];
+      to[i][0] = m0 * ox + m12;
+      to[i][1] =           m13;
    }
-
    to_vec->size = 2;
    to_vec->flags |= VEC_SIZE_2;
    to_vec->count = from_vec->count;
@@ -183,9 +162,7 @@ TAG(transform_points1_2d_no_rot)( GLvector4f *to_vec,
 static void _XFORMAPI
 TAG(transform_points1_3d)( GLvector4f *to_vec,
 			   const GLfloat m[16],
-			   const GLvector4f *from_vec,
-			   const GLubyte *mask,
-			   const GLubyte flag )
+			   const GLvector4f *from_vec )
 {
    const GLuint stride = from_vec->stride;
    GLfloat *from = from_vec->start;
@@ -194,15 +171,11 @@ TAG(transform_points1_3d)( GLvector4f *to_vec,
    const GLfloat m0 = m[0], m1 = m[1], m2 = m[2];
    const GLfloat m12 = m[12], m13 = m[13], m14 = m[14];
    GLuint i;
-   (void) mask;
-   (void) flag;
    STRIDE_LOOP {
-      CLIP_CHECK {
-	 const GLfloat ox = from[0];
-	 to[i][0] = m0 * ox + m12;
-	 to[i][1] = m1 * ox + m13;
-	 to[i][2] = m2 * ox + m14;
-      }
+      const GLfloat ox = from[0];
+      to[i][0] = m0 * ox + m12;
+      to[i][1] = m1 * ox + m13;
+      to[i][2] = m2 * ox + m14;
    }
    to_vec->size = 3;
    to_vec->flags |= VEC_SIZE_3;
@@ -213,9 +186,7 @@ TAG(transform_points1_3d)( GLvector4f *to_vec,
 static void _XFORMAPI
 TAG(transform_points1_3d_no_rot)( GLvector4f *to_vec,
 				  const GLfloat m[16],
-				  const GLvector4f *from_vec,
-				  const GLubyte *mask,
-				  const GLubyte flag )
+				  const GLvector4f *from_vec )
 {
    const GLuint stride = from_vec->stride;
    GLfloat *from = from_vec->start;
@@ -224,15 +195,11 @@ TAG(transform_points1_3d_no_rot)( GLvector4f *to_vec,
    const GLfloat m0 = m[0];
    const GLfloat m12 = m[12], m13 = m[13], m14 = m[14];
    GLuint i;
-   (void) mask;
-   (void) flag;
    STRIDE_LOOP {
-      CLIP_CHECK {
-	 const GLfloat ox = from[0];
-	 to[i][0] = m0 * ox           + m12;
-	 to[i][1] =                     m13;
-	 to[i][2] =                     m14;
-      }
+      const GLfloat ox = from[0];
+      to[i][0] = m0 * ox           + m12;
+      to[i][1] =                     m13;
+      to[i][2] =                     m14;
    }
    to_vec->size = 3;
    to_vec->flags |= VEC_SIZE_3;
@@ -242,9 +209,7 @@ TAG(transform_points1_3d_no_rot)( GLvector4f *to_vec,
 static void _XFORMAPI
 TAG(transform_points1_perspective)( GLvector4f *to_vec,
 				    const GLfloat m[16],
-				    const GLvector4f *from_vec,
-				    const GLubyte *mask,
-				    const GLubyte flag )
+				    const GLvector4f *from_vec )
 {
    const GLuint stride = from_vec->stride;
    GLfloat *from = from_vec->start;
@@ -252,16 +217,12 @@ TAG(transform_points1_perspective)( GLvector4f *to_vec,
    GLuint count = from_vec->count;
    const GLfloat m0 = m[0], m14 = m[14];
    GLuint i;
-   (void) mask;
-   (void) flag;
    STRIDE_LOOP {
-      CLIP_CHECK {
-	 const GLfloat ox = from[0];
-	 to[i][0] = m0 * ox                ;
-	 to[i][1] =           0            ;
-	 to[i][2] =                     m14;
-	 to[i][3] = 0;
-      }
+      const GLfloat ox = from[0];
+      to[i][0] = m0 * ox                ;
+      to[i][1] =           0            ;
+      to[i][2] =                     m14;
+      to[i][3] = 0;
    }
    to_vec->size = 4;
    to_vec->flags |= VEC_SIZE_4;
@@ -278,9 +239,7 @@ TAG(transform_points1_perspective)( GLvector4f *to_vec,
 static void _XFORMAPI
 TAG(transform_points2_general)( GLvector4f *to_vec,
 				const GLfloat m[16],
-				const GLvector4f *from_vec,
-				const GLubyte *mask,
-				const GLubyte flag )
+				const GLvector4f *from_vec )
 {
    const GLuint stride = from_vec->stride;
    GLfloat *from = from_vec->start;
@@ -291,16 +250,12 @@ TAG(transform_points2_general)( GLvector4f *to_vec,
    const GLfloat m2 = m[2],  m6 = m[6],  m14 = m[14];
    const GLfloat m3 = m[3],  m7 = m[7],  m15 = m[15];
    GLuint i;
-   (void) mask;
-   (void) flag;
    STRIDE_LOOP {
-      CLIP_CHECK {
-	 const GLfloat ox = from[0], oy = from[1];
-	 to[i][0] = m0 * ox + m4 * oy + m12;
-	 to[i][1] = m1 * ox + m5 * oy + m13;
-	 to[i][2] = m2 * ox + m6 * oy + m14;
-	 to[i][3] = m3 * ox + m7 * oy + m15;
-      }
+      const GLfloat ox = from[0], oy = from[1];
+      to[i][0] = m0 * ox + m4 * oy + m12;
+      to[i][1] = m1 * ox + m5 * oy + m13;
+      to[i][2] = m2 * ox + m6 * oy + m14;
+      to[i][3] = m3 * ox + m7 * oy + m15;
    }
    to_vec->size = 4;
    to_vec->flags |= VEC_SIZE_4;
@@ -310,23 +265,17 @@ TAG(transform_points2_general)( GLvector4f *to_vec,
 static void _XFORMAPI
 TAG(transform_points2_identity)( GLvector4f *to_vec,
 				 const GLfloat m[16],
-				 const GLvector4f *from_vec,
-				 const GLubyte *mask,
-				 const GLubyte flag )
+				 const GLvector4f *from_vec )
 {
    const GLuint stride = from_vec->stride;
    GLfloat *from = from_vec->start;
    GLfloat (*to)[4] = (GLfloat (*)[4])to_vec->start;
    GLuint count = from_vec->count;
    GLuint i;
-   (void) mask;
-   (void) flag;
    if (to_vec == from_vec) return;
    STRIDE_LOOP {
-      CLIP_CHECK {
-	 to[i][0] = from[0];
-	 to[i][1] = from[1];
-      }
+      to[i][0] = from[0];
+      to[i][1] = from[1];
    }
    to_vec->size = 2;
    to_vec->flags |= VEC_SIZE_2;
@@ -336,9 +285,7 @@ TAG(transform_points2_identity)( GLvector4f *to_vec,
 static void _XFORMAPI
 TAG(transform_points2_2d)( GLvector4f *to_vec,
 			   const GLfloat m[16],
-			   const GLvector4f *from_vec,
-			   const GLubyte *mask,
-			   const GLubyte flag )
+			   const GLvector4f *from_vec )
 {
    const GLuint stride = from_vec->stride;
    GLfloat *from = from_vec->start;
@@ -347,16 +294,11 @@ TAG(transform_points2_2d)( GLvector4f *to_vec,
    const GLfloat m0 = m[0], m1 = m[1], m4 = m[4], m5 = m[5];
    const GLfloat m12 = m[12], m13 = m[13];
    GLuint i;
-   (void) mask;
-   (void) flag;
    STRIDE_LOOP {
-      CLIP_CHECK {
-	 const GLfloat ox = from[0], oy = from[1];
-	 to[i][0] = m0 * ox + m4 * oy + m12;
-	 to[i][1] = m1 * ox + m5 * oy + m13;
-      }
+      const GLfloat ox = from[0], oy = from[1];
+      to[i][0] = m0 * ox + m4 * oy + m12;
+      to[i][1] = m1 * ox + m5 * oy + m13;
    }
-
    to_vec->size = 2;
    to_vec->flags |= VEC_SIZE_2;
    to_vec->count = from_vec->count;
@@ -365,9 +307,7 @@ TAG(transform_points2_2d)( GLvector4f *to_vec,
 static void _XFORMAPI
 TAG(transform_points2_2d_no_rot)( GLvector4f *to_vec,
 				  const GLfloat m[16],
-				  const GLvector4f *from_vec,
-				  const GLubyte *mask,
-				  const GLubyte flag )
+				  const GLvector4f *from_vec )
 {
    const GLuint stride = from_vec->stride;
    GLfloat *from = from_vec->start;
@@ -375,16 +315,11 @@ TAG(transform_points2_2d_no_rot)( GLvector4f *to_vec,
    GLuint count = from_vec->count;
    const GLfloat m0 = m[0], m5 = m[5], m12 = m[12], m13 = m[13];
    GLuint i;
-   (void) mask;
-   (void) flag;
    STRIDE_LOOP {
-      CLIP_CHECK {
-	 const GLfloat ox = from[0], oy = from[1];
-	 to[i][0] = m0 * ox           + m12;
-	 to[i][1] =           m5 * oy + m13;
-      }
+      const GLfloat ox = from[0], oy = from[1];
+      to[i][0] = m0 * ox           + m12;
+      to[i][1] =           m5 * oy + m13;
    }
-
    to_vec->size = 2;
    to_vec->flags |= VEC_SIZE_2;
    to_vec->count = from_vec->count;
@@ -393,9 +328,7 @@ TAG(transform_points2_2d_no_rot)( GLvector4f *to_vec,
 static void _XFORMAPI
 TAG(transform_points2_3d)( GLvector4f *to_vec,
 			   const GLfloat m[16],
-			   const GLvector4f *from_vec,
-			   const GLubyte *mask,
-			   const GLubyte flag )
+			   const GLvector4f *from_vec )
 {
    const GLuint stride = from_vec->stride;
    GLfloat *from = from_vec->start;
@@ -404,15 +337,11 @@ TAG(transform_points2_3d)( GLvector4f *to_vec,
    const GLfloat m0 = m[0], m1 = m[1], m2 = m[2], m4 = m[4], m5 = m[5];
    const GLfloat m6 = m[6], m12 = m[12], m13 = m[13], m14 = m[14];
    GLuint i;
-   (void) mask;
-   (void) flag;
    STRIDE_LOOP {
-      CLIP_CHECK {
-	 const GLfloat ox = from[0], oy = from[1];
-	 to[i][0] = m0 * ox + m4 * oy + m12;
-	 to[i][1] = m1 * ox + m5 * oy + m13;
-	 to[i][2] = m2 * ox + m6 * oy + m14;
-      }
+      const GLfloat ox = from[0], oy = from[1];
+      to[i][0] = m0 * ox + m4 * oy + m12;
+      to[i][1] = m1 * ox + m5 * oy + m13;
+      to[i][2] = m2 * ox + m6 * oy + m14;
    }
    to_vec->size = 3;
    to_vec->flags |= VEC_SIZE_3;
@@ -426,9 +355,7 @@ TAG(transform_points2_3d)( GLvector4f *to_vec,
 static void _XFORMAPI
 TAG(transform_points2_3d_no_rot)( GLvector4f *to_vec,
 				  const GLfloat m[16],
-				  const GLvector4f *from_vec,
-				  const GLubyte *mask,
-				  const GLubyte flag )
+				  const GLvector4f *from_vec )
 {
    const GLuint stride = from_vec->stride;
    GLfloat *from = from_vec->start;
@@ -437,15 +364,11 @@ TAG(transform_points2_3d_no_rot)( GLvector4f *to_vec,
    const GLfloat m0 = m[0], m5 = m[5];
    const GLfloat m12 = m[12], m13 = m[13], m14 = m[14];
    GLuint i;
-   (void) mask;
-   (void) flag;
    STRIDE_LOOP {
-      CLIP_CHECK {
-	 const GLfloat ox = from[0], oy = from[1];
-	 to[i][0] = m0 * ox           + m12;
-	 to[i][1] =           m5 * oy + m13;
-	 to[i][2] =                     m14;
-      }
+      const GLfloat ox = from[0], oy = from[1];
+      to[i][0] = m0 * ox           + m12;
+      to[i][1] =           m5 * oy + m13;
+      to[i][2] =                     m14;
    }
    if (m14 == 0) {
       to_vec->size = 2;
@@ -461,9 +384,7 @@ TAG(transform_points2_3d_no_rot)( GLvector4f *to_vec,
 static void _XFORMAPI
 TAG(transform_points2_perspective)( GLvector4f *to_vec,
 				    const GLfloat m[16],
-				    const GLvector4f *from_vec,
-				    const GLubyte *mask,
-				    const GLubyte flag )
+				    const GLvector4f *from_vec )
 {
    const GLuint stride = from_vec->stride;
    GLfloat *from = from_vec->start;
@@ -471,16 +392,12 @@ TAG(transform_points2_perspective)( GLvector4f *to_vec,
    GLuint count = from_vec->count;
    const GLfloat m0 = m[0], m5 = m[5], m14 = m[14];
    GLuint i;
-   (void) mask;
-   (void) flag;
    STRIDE_LOOP {
-      CLIP_CHECK {
-	 const GLfloat ox = from[0], oy = from[1];
-	 to[i][0] = m0 * ox                ;
-	 to[i][1] =           m5 * oy      ;
-	 to[i][2] =                     m14;
-	 to[i][3] = 0;
-      }
+      const GLfloat ox = from[0], oy = from[1];
+      to[i][0] = m0 * ox                ;
+      to[i][1] =           m5 * oy      ;
+      to[i][2] =                     m14;
+      to[i][3] = 0;
    }
    to_vec->size = 4;
    to_vec->flags |= VEC_SIZE_4;
@@ -492,9 +409,7 @@ TAG(transform_points2_perspective)( GLvector4f *to_vec,
 static void _XFORMAPI
 TAG(transform_points3_general)( GLvector4f *to_vec,
 				const GLfloat m[16],
-				const GLvector4f *from_vec,
-				const GLubyte *mask,
-				const GLubyte flag )
+				const GLvector4f *from_vec )
 {
    const GLuint stride = from_vec->stride;
    GLfloat *from = from_vec->start;
@@ -505,16 +420,12 @@ TAG(transform_points3_general)( GLvector4f *to_vec,
    const GLfloat m2 = m[2],  m6 = m[6],  m10 = m[10],  m14 = m[14];
    const GLfloat m3 = m[3],  m7 = m[7],  m11 = m[11],  m15 = m[15];
    GLuint i;
-   (void) mask;
-   (void) flag;
    STRIDE_LOOP {
-      CLIP_CHECK {
-	 const GLfloat ox = from[0], oy = from[1], oz = from[2];
-	 to[i][0] = m0 * ox + m4 * oy + m8  * oz + m12;
-	 to[i][1] = m1 * ox + m5 * oy + m9  * oz + m13;
-	 to[i][2] = m2 * ox + m6 * oy + m10 * oz + m14;
-	 to[i][3] = m3 * ox + m7 * oy + m11 * oz + m15;
-      }
+      const GLfloat ox = from[0], oy = from[1], oz = from[2];
+      to[i][0] = m0 * ox + m4 * oy + m8  * oz + m12;
+      to[i][1] = m1 * ox + m5 * oy + m9  * oz + m13;
+      to[i][2] = m2 * ox + m6 * oy + m10 * oz + m14;
+      to[i][3] = m3 * ox + m7 * oy + m11 * oz + m15;
    }
    to_vec->size = 4;
    to_vec->flags |= VEC_SIZE_4;
@@ -524,24 +435,18 @@ TAG(transform_points3_general)( GLvector4f *to_vec,
 static void _XFORMAPI
 TAG(transform_points3_identity)( GLvector4f *to_vec,
 				 const GLfloat m[16],
-				 const GLvector4f *from_vec,
-				 const GLubyte *mask,
-				 const GLubyte flag )
+				 const GLvector4f *from_vec )
 {
    const GLuint stride = from_vec->stride;
    GLfloat *from = from_vec->start;
    GLfloat (*to)[4] = (GLfloat (*)[4])to_vec->start;
    GLuint count = from_vec->count;
    GLuint i;
-   (void) mask;
-   (void) flag;
    if (to_vec == from_vec) return;
    STRIDE_LOOP {
-      CLIP_CHECK {
-	 to[i][0] = from[0];
-	 to[i][1] = from[1];
-	 to[i][2] = from[2];
-      }
+      to[i][0] = from[0];
+      to[i][1] = from[1];
+      to[i][2] = from[2];
    }
    to_vec->size = 3;
    to_vec->flags |= VEC_SIZE_3;
@@ -551,9 +456,7 @@ TAG(transform_points3_identity)( GLvector4f *to_vec,
 static void _XFORMAPI
 TAG(transform_points3_2d)( GLvector4f *to_vec,
 			   const GLfloat m[16],
-			   const GLvector4f *from_vec,
-			   const GLubyte *mask,
-			   const GLubyte flag )
+			   const GLvector4f *from_vec )
 {
    const GLuint stride = from_vec->stride;
    GLfloat *from = from_vec->start;
@@ -562,15 +465,11 @@ TAG(transform_points3_2d)( GLvector4f *to_vec,
    const GLfloat m0 = m[0], m1 = m[1], m4 = m[4], m5 = m[5];
    const GLfloat m12 = m[12], m13 = m[13];
    GLuint i;
-   (void) mask;
-   (void) flag;
    STRIDE_LOOP {
-      CLIP_CHECK {
-	 const GLfloat ox = from[0], oy = from[1], oz = from[2];
-	 to[i][0] = m0 * ox + m4 * oy            + m12       ;
-	 to[i][1] = m1 * ox + m5 * oy            + m13       ;
-	 to[i][2] =                   +       oz             ;
-      }
+      const GLfloat ox = from[0], oy = from[1], oz = from[2];
+      to[i][0] = m0 * ox + m4 * oy            + m12       ;
+      to[i][1] = m1 * ox + m5 * oy            + m13       ;
+      to[i][2] =                   +       oz             ;
    }
    to_vec->size = 3;
    to_vec->flags |= VEC_SIZE_3;
@@ -580,9 +479,7 @@ TAG(transform_points3_2d)( GLvector4f *to_vec,
 static void _XFORMAPI
 TAG(transform_points3_2d_no_rot)( GLvector4f *to_vec,
 				  const GLfloat m[16],
-				  const GLvector4f *from_vec,
-				  const GLubyte *mask,
-				  const GLubyte flag )
+				  const GLvector4f *from_vec )
 {
    const GLuint stride = from_vec->stride;
    GLfloat *from = from_vec->start;
@@ -590,15 +487,11 @@ TAG(transform_points3_2d_no_rot)( GLvector4f *to_vec,
    GLuint count = from_vec->count;
    const GLfloat m0 = m[0], m5 = m[5], m12 = m[12], m13 = m[13];
    GLuint i;
-   (void) mask;
-   (void) flag;
    STRIDE_LOOP {
-      CLIP_CHECK {
-	 const GLfloat ox = from[0], oy = from[1], oz = from[2];
-	 to[i][0] = m0 * ox                      + m12       ;
-	 to[i][1] =           m5 * oy            + m13       ;
-	 to[i][2] =                   +       oz             ;
-      }
+      const GLfloat ox = from[0], oy = from[1], oz = from[2];
+      to[i][0] = m0 * ox                      + m12       ;
+      to[i][1] =           m5 * oy            + m13       ;
+      to[i][2] =                   +       oz             ;
    }
    to_vec->size = 3;
    to_vec->flags |= VEC_SIZE_3;
@@ -608,9 +501,7 @@ TAG(transform_points3_2d_no_rot)( GLvector4f *to_vec,
 static void _XFORMAPI
 TAG(transform_points3_3d)( GLvector4f *to_vec,
 			   const GLfloat m[16],
-			   const GLvector4f *from_vec,
-			   const GLubyte *mask,
-			   const GLubyte flag )
+			   const GLvector4f *from_vec )
 {
    const GLuint stride = from_vec->stride;
    GLfloat *from = from_vec->start;
@@ -620,15 +511,11 @@ TAG(transform_points3_3d)( GLvector4f *to_vec,
    const GLfloat m6 = m[6], m8 = m[8], m9 = m[9], m10 = m[10];
    const GLfloat m12 = m[12], m13 = m[13], m14 = m[14];
    GLuint i;
-   (void) mask;
-   (void) flag;
    STRIDE_LOOP {
-      CLIP_CHECK {
-	 const GLfloat ox = from[0], oy = from[1], oz = from[2];
-	 to[i][0] = m0 * ox + m4 * oy +  m8 * oz + m12       ;
-	 to[i][1] = m1 * ox + m5 * oy +  m9 * oz + m13       ;
-	 to[i][2] = m2 * ox + m6 * oy + m10 * oz + m14       ;
-      }
+      const GLfloat ox = from[0], oy = from[1], oz = from[2];
+      to[i][0] = m0 * ox + m4 * oy +  m8 * oz + m12       ;
+      to[i][1] = m1 * ox + m5 * oy +  m9 * oz + m13       ;
+      to[i][2] = m2 * ox + m6 * oy + m10 * oz + m14       ;
    }
    to_vec->size = 3;
    to_vec->flags |= VEC_SIZE_3;
@@ -640,9 +527,7 @@ TAG(transform_points3_3d)( GLvector4f *to_vec,
 static void _XFORMAPI
 TAG(transform_points3_3d_no_rot)( GLvector4f *to_vec,
 				  const GLfloat m[16],
-				  const GLvector4f *from_vec,
-				  const GLubyte *mask,
-				  const GLubyte flag )
+				  const GLvector4f *from_vec )
 {
    const GLuint stride = from_vec->stride;
    GLfloat *from = from_vec->start;
@@ -651,15 +536,11 @@ TAG(transform_points3_3d_no_rot)( GLvector4f *to_vec,
    const GLfloat m0 = m[0], m5 = m[5];
    const GLfloat m10 = m[10], m12 = m[12], m13 = m[13], m14 = m[14];
    GLuint i;
-   (void) mask;
-   (void) flag;
    STRIDE_LOOP {
-      CLIP_CHECK {
-	 const GLfloat ox = from[0], oy = from[1], oz = from[2];
-	 to[i][0] = m0 * ox                      + m12       ;
-	 to[i][1] =           m5 * oy            + m13       ;
-	 to[i][2] =                     m10 * oz + m14       ;
-      }
+      const GLfloat ox = from[0], oy = from[1], oz = from[2];
+      to[i][0] = m0 * ox                      + m12       ;
+      to[i][1] =           m5 * oy            + m13       ;
+      to[i][2] =                     m10 * oz + m14       ;
    }
    to_vec->size = 3;
    to_vec->flags |= VEC_SIZE_3;
@@ -669,9 +550,7 @@ TAG(transform_points3_3d_no_rot)( GLvector4f *to_vec,
 static void _XFORMAPI
 TAG(transform_points3_perspective)( GLvector4f *to_vec,
 				    const GLfloat m[16],
-				    const GLvector4f *from_vec,
-				    const GLubyte *mask,
-				    const GLubyte flag )
+				    const GLvector4f *from_vec )
 {
    const GLuint stride = from_vec->stride;
    GLfloat *from = from_vec->start;
@@ -680,16 +559,12 @@ TAG(transform_points3_perspective)( GLvector4f *to_vec,
    const GLfloat m0 = m[0], m5 = m[5], m8 = m[8], m9 = m[9];
    const GLfloat m10 = m[10], m14 = m[14];
    GLuint i;
-   (void) mask;
-   (void) flag;
    STRIDE_LOOP {
-      CLIP_CHECK {
-	 const GLfloat ox = from[0], oy = from[1], oz = from[2];
-	 to[i][0] = m0 * ox           + m8  * oz       ;
-	 to[i][1] =           m5 * oy + m9  * oz       ;
-	 to[i][2] =                     m10 * oz + m14 ;
-	 to[i][3] =                          -oz       ;
-      }
+      const GLfloat ox = from[0], oy = from[1], oz = from[2];
+      to[i][0] = m0 * ox           + m8  * oz       ;
+      to[i][1] =           m5 * oy + m9  * oz       ;
+      to[i][2] =                     m10 * oz + m14 ;
+      to[i][3] =                          -oz       ;
    }
    to_vec->size = 4;
    to_vec->flags |= VEC_SIZE_4;
@@ -701,9 +576,7 @@ TAG(transform_points3_perspective)( GLvector4f *to_vec,
 static void _XFORMAPI
 TAG(transform_points4_general)( GLvector4f *to_vec,
 				const GLfloat m[16],
-				const GLvector4f *from_vec,
-				const GLubyte *mask,
-				const GLubyte flag )
+				const GLvector4f *from_vec )
 {
    const GLuint stride = from_vec->stride;
    GLfloat *from = from_vec->start;
@@ -714,16 +587,12 @@ TAG(transform_points4_general)( GLvector4f *to_vec,
    const GLfloat m2 = m[2],  m6 = m[6],  m10 = m[10],  m14 = m[14];
    const GLfloat m3 = m[3],  m7 = m[7],  m11 = m[11],  m15 = m[15];
    GLuint i;
-   (void) mask;
-   (void) flag;
    STRIDE_LOOP {
-      CLIP_CHECK {
-	 const GLfloat ox = from[0], oy = from[1], oz = from[2], ow = from[3];
-	 to[i][0] = m0 * ox + m4 * oy + m8  * oz + m12 * ow;
-	 to[i][1] = m1 * ox + m5 * oy + m9  * oz + m13 * ow;
-	 to[i][2] = m2 * ox + m6 * oy + m10 * oz + m14 * ow;
-	 to[i][3] = m3 * ox + m7 * oy + m11 * oz + m15 * ow;
-      }
+      const GLfloat ox = from[0], oy = from[1], oz = from[2], ow = from[3];
+      to[i][0] = m0 * ox + m4 * oy + m8  * oz + m12 * ow;
+      to[i][1] = m1 * ox + m5 * oy + m9  * oz + m13 * ow;
+      to[i][2] = m2 * ox + m6 * oy + m10 * oz + m14 * ow;
+      to[i][3] = m3 * ox + m7 * oy + m11 * oz + m15 * ow;
    }
    to_vec->size = 4;
    to_vec->flags |= VEC_SIZE_4;
@@ -733,25 +602,19 @@ TAG(transform_points4_general)( GLvector4f *to_vec,
 static void _XFORMAPI
 TAG(transform_points4_identity)( GLvector4f *to_vec,
 				 const GLfloat m[16],
-				 const GLvector4f *from_vec,
-				 const GLubyte *mask,
-				 const GLubyte flag )
+				 const GLvector4f *from_vec )
 {
    const GLuint stride = from_vec->stride;
    GLfloat *from = from_vec->start;
    GLfloat (*to)[4] = (GLfloat (*)[4])to_vec->start;
    GLuint count = from_vec->count;
    GLuint i;
-   (void) mask;
-   (void) flag;
    if (to_vec == from_vec) return;
    STRIDE_LOOP {
-      CLIP_CHECK {
-	 to[i][0] = from[0];
-	 to[i][1] = from[1];
-	 to[i][2] = from[2];
-	 to[i][3] = from[3];
-      }
+      to[i][0] = from[0];
+      to[i][1] = from[1];
+      to[i][2] = from[2];
+      to[i][3] = from[3];
    }
    to_vec->size = 4;
    to_vec->flags |= VEC_SIZE_4;
@@ -761,9 +624,7 @@ TAG(transform_points4_identity)( GLvector4f *to_vec,
 static void _XFORMAPI
 TAG(transform_points4_2d)( GLvector4f *to_vec,
 			   const GLfloat m[16],
-			   const GLvector4f *from_vec,
-			   const GLubyte *mask,
-			   const GLubyte flag )
+			   const GLvector4f *from_vec )
 {
    const GLuint stride = from_vec->stride;
    GLfloat *from = from_vec->start;
@@ -772,16 +633,12 @@ TAG(transform_points4_2d)( GLvector4f *to_vec,
    const GLfloat m0 = m[0], m1 = m[1], m4 = m[4], m5 = m[5];
    const GLfloat m12 = m[12], m13 = m[13];
    GLuint i;
-   (void) mask;
-   (void) flag;
    STRIDE_LOOP {
-      CLIP_CHECK {
-	 const GLfloat ox = from[0], oy = from[1], oz = from[2], ow = from[3];
-	 to[i][0] = m0 * ox + m4 * oy            + m12 * ow;
-	 to[i][1] = m1 * ox + m5 * oy            + m13 * ow;
-	 to[i][2] =                   +       oz           ;
-	 to[i][3] =                                      ow;
-      }
+      const GLfloat ox = from[0], oy = from[1], oz = from[2], ow = from[3];
+      to[i][0] = m0 * ox + m4 * oy            + m12 * ow;
+      to[i][1] = m1 * ox + m5 * oy            + m13 * ow;
+      to[i][2] =                   +       oz           ;
+      to[i][3] =                                      ow;
    }
    to_vec->size = 4;
    to_vec->flags |= VEC_SIZE_4;
@@ -791,9 +648,7 @@ TAG(transform_points4_2d)( GLvector4f *to_vec,
 static void _XFORMAPI
 TAG(transform_points4_2d_no_rot)( GLvector4f *to_vec,
 				  const GLfloat m[16],
-				  const GLvector4f *from_vec,
-				  const GLubyte *mask,
-				  const GLubyte flag )
+				  const GLvector4f *from_vec )
 {
    const GLuint stride = from_vec->stride;
    GLfloat *from = from_vec->start;
@@ -801,16 +656,12 @@ TAG(transform_points4_2d_no_rot)( GLvector4f *to_vec,
    GLuint count = from_vec->count;
    const GLfloat m0 = m[0], m5 = m[5], m12 = m[12], m13 = m[13];
    GLuint i;
-   (void) mask;
-   (void) flag;
    STRIDE_LOOP {
-      CLIP_CHECK {
-	 const GLfloat ox = from[0], oy = from[1], oz = from[2], ow = from[3];
-	 to[i][0] = m0 * ox                      + m12 * ow;
-	 to[i][1] =           m5 * oy            + m13 * ow;
-	 to[i][2] =                   +       oz           ;
-	 to[i][3] =                                      ow;
-      }
+      const GLfloat ox = from[0], oy = from[1], oz = from[2], ow = from[3];
+      to[i][0] = m0 * ox                      + m12 * ow;
+      to[i][1] =           m5 * oy            + m13 * ow;
+      to[i][2] =                   +       oz           ;
+      to[i][3] =                                      ow;
    }
    to_vec->size = 4;
    to_vec->flags |= VEC_SIZE_4;
@@ -820,9 +671,7 @@ TAG(transform_points4_2d_no_rot)( GLvector4f *to_vec,
 static void _XFORMAPI
 TAG(transform_points4_3d)( GLvector4f *to_vec,
 			   const GLfloat m[16],
-			   const GLvector4f *from_vec,
-			   const GLubyte *mask,
-			   const GLubyte flag )
+			   const GLvector4f *from_vec )
 {
    const GLuint stride = from_vec->stride;
    GLfloat *from = from_vec->start;
@@ -832,16 +681,12 @@ TAG(transform_points4_3d)( GLvector4f *to_vec,
    const GLfloat m6 = m[6], m8 = m[8], m9 = m[9], m10 = m[10];
    const GLfloat m12 = m[12], m13 = m[13], m14 = m[14];
    GLuint i;
-   (void) mask;
-   (void) flag;
    STRIDE_LOOP {
-      CLIP_CHECK {
-	 const GLfloat ox = from[0], oy = from[1], oz = from[2], ow = from[3];
-	 to[i][0] = m0 * ox + m4 * oy +  m8 * oz + m12 * ow;
-	 to[i][1] = m1 * ox + m5 * oy +  m9 * oz + m13 * ow;
-	 to[i][2] = m2 * ox + m6 * oy + m10 * oz + m14 * ow;
-	 to[i][3] =                                      ow;
-      }
+      const GLfloat ox = from[0], oy = from[1], oz = from[2], ow = from[3];
+      to[i][0] = m0 * ox + m4 * oy +  m8 * oz + m12 * ow;
+      to[i][1] = m1 * ox + m5 * oy +  m9 * oz + m13 * ow;
+      to[i][2] = m2 * ox + m6 * oy + m10 * oz + m14 * ow;
+      to[i][3] =                                      ow;
    }
    to_vec->size = 4;
    to_vec->flags |= VEC_SIZE_4;
@@ -851,9 +696,7 @@ TAG(transform_points4_3d)( GLvector4f *to_vec,
 static void _XFORMAPI
 TAG(transform_points4_3d_no_rot)( GLvector4f *to_vec,
 				  const GLfloat m[16],
-				  const GLvector4f *from_vec,
-				  const GLubyte *mask,
-				  const GLubyte flag )
+				  const GLvector4f *from_vec )
 {
    const GLuint stride = from_vec->stride;
    GLfloat *from = from_vec->start;
@@ -862,16 +705,12 @@ TAG(transform_points4_3d_no_rot)( GLvector4f *to_vec,
    const GLfloat m0 = m[0], m5 = m[5];
    const GLfloat m10 = m[10], m12 = m[12], m13 = m[13], m14 = m[14];
    GLuint i;
-   (void) mask;
-   (void) flag;
    STRIDE_LOOP {
-      CLIP_CHECK {
-	 const GLfloat ox = from[0], oy = from[1], oz = from[2], ow = from[3];
-	 to[i][0] = m0 * ox                      + m12 * ow;
-	 to[i][1] =           m5 * oy            + m13 * ow;
-	 to[i][2] =                     m10 * oz + m14 * ow;
-	 to[i][3] =                                      ow;
-      }
+      const GLfloat ox = from[0], oy = from[1], oz = from[2], ow = from[3];
+      to[i][0] = m0 * ox                      + m12 * ow;
+      to[i][1] =           m5 * oy            + m13 * ow;
+      to[i][2] =                     m10 * oz + m14 * ow;
+      to[i][3] =                                      ow;
    }
    to_vec->size = 4;
    to_vec->flags |= VEC_SIZE_4;
@@ -881,9 +720,7 @@ TAG(transform_points4_3d_no_rot)( GLvector4f *to_vec,
 static void _XFORMAPI
 TAG(transform_points4_perspective)( GLvector4f *to_vec,
 				    const GLfloat m[16],
-				    const GLvector4f *from_vec,
-				    const GLubyte *mask,
-				    const GLubyte flag )
+				    const GLvector4f *from_vec )
 {
    const GLuint stride = from_vec->stride;
    GLfloat *from = from_vec->start;
@@ -892,18 +729,13 @@ TAG(transform_points4_perspective)( GLvector4f *to_vec,
    const GLfloat m0 = m[0], m5 = m[5], m8 = m[8], m9 = m[9];
    const GLfloat m10 = m[10], m14 = m[14];
    GLuint i;
-   (void) mask;
-   (void) flag;
    STRIDE_LOOP {
-      CLIP_CHECK {
-	 const GLfloat ox = from[0], oy = from[1], oz = from[2], ow = from[3];
-	 to[i][0] = m0 * ox           + m8  * oz            ;
-	 to[i][1] =           m5 * oy + m9  * oz            ;
-	 to[i][2] =                     m10 * oz + m14 * ow ;
-	 to[i][3] =                          -oz            ;
-      }
+      const GLfloat ox = from[0], oy = from[1], oz = from[2], ow = from[3];
+      to[i][0] = m0 * ox           + m8  * oz            ;
+      to[i][1] =           m5 * oy + m9  * oz            ;
+      to[i][2] =                     m10 * oz + m14 * ow ;
+      to[i][3] =                          -oz            ;
    }
-
    to_vec->size = 4;
    to_vec->flags |= VEC_SIZE_4;
    to_vec->count = from_vec->count;
@@ -920,7 +752,7 @@ static transform_func _XFORMAPI TAG(transform_tab_4)[7];
  */
 static void _XFORMAPI TAG(init_c_transformations)( void )
 {
-#define TAG_TAB   _mesa_transform_tab[IDX]
+#define TAG_TAB   _mesa_transform_tab
 #define TAG_TAB_1 TAG(transform_tab_1)
 #define TAG_TAB_2 TAG(transform_tab_2)
 #define TAG_TAB_3 TAG(transform_tab_3)
@@ -935,7 +767,7 @@ static void _XFORMAPI TAG(init_c_transformations)( void )
    TAG_TAB_1[MATRIX_GENERAL]     = TAG(transform_points1_general);
    TAG_TAB_1[MATRIX_IDENTITY]    = TAG(transform_points1_identity);
    TAG_TAB_1[MATRIX_3D_NO_ROT]   = TAG(transform_points1_3d_no_rot);
-   TAG_TAB_1[MATRIX_PERSPECTIVE] = TAG(transform_points1_perspective) ;
+   TAG_TAB_1[MATRIX_PERSPECTIVE] = TAG(transform_points1_perspective);
    TAG_TAB_1[MATRIX_2D]          = TAG(transform_points1_2d);
    TAG_TAB_1[MATRIX_2D_NO_ROT]   = TAG(transform_points1_2d_no_rot);
    TAG_TAB_1[MATRIX_3D]          = TAG(transform_points1_3d);
@@ -944,7 +776,7 @@ static void _XFORMAPI TAG(init_c_transformations)( void )
    TAG_TAB_2[MATRIX_GENERAL]     = TAG(transform_points2_general);
    TAG_TAB_2[MATRIX_IDENTITY]    = TAG(transform_points2_identity);
    TAG_TAB_2[MATRIX_3D_NO_ROT]   = TAG(transform_points2_3d_no_rot);
-   TAG_TAB_2[MATRIX_PERSPECTIVE] = TAG(transform_points2_perspective) ;
+   TAG_TAB_2[MATRIX_PERSPECTIVE] = TAG(transform_points2_perspective);
    TAG_TAB_2[MATRIX_2D]          = TAG(transform_points2_2d);
    TAG_TAB_2[MATRIX_2D_NO_ROT]   = TAG(transform_points2_2d_no_rot);
    TAG_TAB_2[MATRIX_3D]          = TAG(transform_points2_3d);