12 files changed, 2790 insertions, 2790 deletions
diff --git a/mesalib/src/mesa/tnl/t_pipeline.h b/mesalib/src/mesa/tnl/t_pipeline.h
index 579207889..0eb03395c 100644
--- a/mesalib/src/mesa/tnl/t_pipeline.h
+++ b/mesalib/src/mesa/tnl/t_pipeline.h
@@ -1,73 +1,73 @@
-/*
- * Mesa 3-D graphics library
- * Version:  6.5.3
- *
- * Copyright (C) 1999-2007  Brian Paul   All Rights Reserved.
- *
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the "Software"),
- * to deal in the Software without restriction, including without limitation
- * the rights to use, copy, modify, merge, publish, distribute, sublicense,
- * and/or sell copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included
- * in all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
- * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
- * BRIAN PAUL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
- * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
- * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
- *
- * Authors:
- *    Keith Whitwell <keith@tungstengraphics.com>
- */
-
-
-
-#ifndef _T_PIPELINE_H_
-#define _T_PIPELINE_H_
-
-#include "main/mtypes.h"
-#include "t_context.h"
-
-extern void _tnl_run_pipeline( struct gl_context *ctx );
-
-extern void _tnl_destroy_pipeline( struct gl_context *ctx );
-
-extern void _tnl_install_pipeline( struct gl_context *ctx,
-				   const struct tnl_pipeline_stage **stages );
-
-
-/* These are implemented in the t_vb_*.c files:
- */
-extern const struct tnl_pipeline_stage _tnl_vertex_transform_stage;
-extern const struct tnl_pipeline_stage _tnl_normal_transform_stage;
-extern const struct tnl_pipeline_stage _tnl_lighting_stage;
-extern const struct tnl_pipeline_stage _tnl_fog_coordinate_stage;
-extern const struct tnl_pipeline_stage _tnl_texgen_stage;
-extern const struct tnl_pipeline_stage _tnl_texture_transform_stage;
-extern const struct tnl_pipeline_stage _tnl_point_attenuation_stage;
-extern const struct tnl_pipeline_stage _tnl_vertex_program_stage;
-extern const struct tnl_pipeline_stage _tnl_render_stage;
-
-/* Shorthand to plug in the default pipeline:
- */
-extern const struct tnl_pipeline_stage *_tnl_default_pipeline[];
-extern const struct tnl_pipeline_stage *_tnl_vp_pipeline[];
-
-
-/* Convenience routines provided by t_vb_render.c:
- */
-extern tnl_render_func _tnl_render_tab_elts[];
-extern tnl_render_func _tnl_render_tab_verts[];
-
-extern void _tnl_RenderClippedPolygon( struct gl_context *ctx, 
-				       const GLuint *elts, GLuint n );
-
-extern void _tnl_RenderClippedLine( struct gl_context *ctx, GLuint ii, GLuint jj );
-
-
-#endif
+/*
+ * Mesa 3-D graphics library
+ * Version:  6.5.3
+ *
+ * Copyright (C) 1999-2007  Brian Paul   All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * BRIAN PAUL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
+ * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ *
+ * Authors:
+ *    Keith Whitwell <keith@tungstengraphics.com>
+ */
+
+
+
+#ifndef _T_PIPELINE_H_
+#define _T_PIPELINE_H_
+
+#include "main/mtypes.h"
+#include "t_context.h"
+
+extern void _tnl_run_pipeline( struct gl_context *ctx );
+
+extern void _tnl_destroy_pipeline( struct gl_context *ctx );
+
+extern void _tnl_install_pipeline( struct gl_context *ctx,
+				   const struct tnl_pipeline_stage **stages );
+
+
+/* These are implemented in the t_vb_*.c files:
+ */
+extern const struct tnl_pipeline_stage _tnl_vertex_transform_stage;
+extern const struct tnl_pipeline_stage _tnl_normal_transform_stage;
+extern const struct tnl_pipeline_stage _tnl_lighting_stage;
+extern const struct tnl_pipeline_stage _tnl_fog_coordinate_stage;
+extern const struct tnl_pipeline_stage _tnl_texgen_stage;
+extern const struct tnl_pipeline_stage _tnl_texture_transform_stage;
+extern const struct tnl_pipeline_stage _tnl_point_attenuation_stage;
+extern const struct tnl_pipeline_stage _tnl_vertex_program_stage;
+extern const struct tnl_pipeline_stage _tnl_render_stage;
+
+/* Shorthand to plug in the default pipeline:
+ */
+extern const struct tnl_pipeline_stage *_tnl_default_pipeline[];
+extern const struct tnl_pipeline_stage *_tnl_vp_pipeline[];
+
+
+/* Convenience routines provided by t_vb_render.c:
+ */
+extern tnl_render_func _tnl_render_tab_elts[];
+extern tnl_render_func _tnl_render_tab_verts[];
+
+extern void _tnl_RenderClippedPolygon( struct gl_context *ctx, 
+				       const GLuint *elts, GLuint n );
+
+extern void _tnl_RenderClippedLine( struct gl_context *ctx, GLuint ii, GLuint jj );
+
+
+#endif
diff --git a/mesalib/src/mesa/tnl/t_vb_fog.c b/mesalib/src/mesa/tnl/t_vb_fog.c
index 3e5c99735..cbd8dfc96 100644
--- a/mesalib/src/mesa/tnl/t_vb_fog.c
+++ b/mesalib/src/mesa/tnl/t_vb_fog.c
@@ -1,276 +1,276 @@
-/*
- * Mesa 3-D graphics library
- * Version:  6.5
- *
- * Copyright (C) 1999-2006  Brian Paul   All Rights Reserved.
- *
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the "Software"),
- * to deal in the Software without restriction, including without limitation
- * the rights to use, copy, modify, merge, publish, distribute, sublicense,
- * and/or sell copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included
- * in all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
- * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
- * BRIAN PAUL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
- * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
- * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
- *
- * Authors:
- *    Keith Whitwell <keith@tungstengraphics.com>
- */
-
-
-#include "main/glheader.h"
-#include "main/colormac.h"
-#include "main/macros.h"
-#include "main/imports.h"
-#include "main/mtypes.h"
-
-#include "math/m_xform.h"
-
-#include "t_context.h"
-#include "t_pipeline.h"
-
-
-struct fog_stage_data {
-   GLvector4f fogcoord;		/* has actual storage allocated */
-};
-
-#define FOG_STAGE_DATA(stage) ((struct fog_stage_data *)stage->privatePtr)
-
-#define FOG_EXP_TABLE_SIZE 256
-#define FOG_MAX (10.0)
-#define EXP_FOG_MAX .0006595
-#define FOG_INCR (FOG_MAX/FOG_EXP_TABLE_SIZE)
-static GLfloat exp_table[FOG_EXP_TABLE_SIZE];
-static GLfloat inited = 0;
-
-#if 1
-#define NEG_EXP( result, narg )						\
-do {									\
-   GLfloat f = (GLfloat) (narg * (1.0/FOG_INCR));			\
-   GLint k = (GLint) f;							\
-   if (k > FOG_EXP_TABLE_SIZE-2) 					\
-      result = (GLfloat) EXP_FOG_MAX;					\
-   else									\
-      result = exp_table[k] + (f-k)*(exp_table[k+1]-exp_table[k]);	\
-} while (0)
-#else
-#define NEG_EXP( result, narg )					\
-do {								\
-   result = exp(-narg);						\
-} while (0)
-#endif
-
-
-/**
- * Initialize the exp_table[] lookup table for approximating exp().
- */
-static void
-init_static_data( void )
-{
-   GLfloat f = 0.0F;
-   GLint i = 0;
-   for ( ; i < FOG_EXP_TABLE_SIZE ; i++, f += FOG_INCR) {
-      exp_table[i] = EXPF(-f);
-   }
-   inited = 1;
-}
-
-
-/**
- * Compute per-vertex fog blend factors from fog coordinates by
- * evaluating the GL_LINEAR, GL_EXP or GL_EXP2 fog function.
- * Fog coordinates are distances from the eye (typically between the
- * near and far clip plane distances).
- * Note that fogcoords may be negative, if eye z is source absolute
- * value must be taken earlier.
- * Fog blend factors are in the range [0,1].
- */
-static void
-compute_fog_blend_factors(struct gl_context *ctx, GLvector4f *out, const GLvector4f *in)
-{
-   GLfloat end  = ctx->Fog.End;
-   GLfloat *v = in->start;
-   GLuint stride = in->stride;
-   GLuint n = in->count;
-   GLfloat (*data)[4] = out->data;
-   GLfloat d;
-   GLuint i;
-
-   out->count = in->count;
-
-   switch (ctx->Fog.Mode) {
-   case GL_LINEAR:
-      if (ctx->Fog.Start == ctx->Fog.End)
-         d = 1.0F;
-      else
-         d = 1.0F / (ctx->Fog.End - ctx->Fog.Start);
-      for ( i = 0 ; i < n ; i++, STRIDE_F(v, stride)) {
-         const GLfloat z = *v;
-         GLfloat f = (end - z) * d;
-	 data[i][0] = CLAMP(f, 0.0F, 1.0F);
-      }
-      break;
-   case GL_EXP:
-      d = ctx->Fog.Density;
-      for ( i = 0 ; i < n ; i++, STRIDE_F(v,stride)) {
-         const GLfloat z = *v;
-         NEG_EXP( data[i][0], d * z );
-      }
-      break;
-   case GL_EXP2:
-      d = ctx->Fog.Density*ctx->Fog.Density;
-      for ( i = 0 ; i < n ; i++, STRIDE_F(v, stride)) {
-         const GLfloat z = *v;
-         NEG_EXP( data[i][0], d * z * z );
-      }
-      break;
-   default:
-      _mesa_problem(ctx, "Bad fog mode in make_fog_coord");
-      return;
-   }
-}
-
-
-static GLboolean
-run_fog_stage(struct gl_context *ctx, struct tnl_pipeline_stage *stage)
-{
-   TNLcontext *tnl = TNL_CONTEXT(ctx);
-   struct vertex_buffer *VB = &tnl->vb;
-   struct fog_stage_data *store = FOG_STAGE_DATA(stage);
-   GLvector4f *input;
-
-
-   if (!ctx->Fog.Enabled)
-      return GL_TRUE;
-
-   if (ctx->Fog.FogCoordinateSource == GL_FRAGMENT_DEPTH_EXT && !ctx->VertexProgram._Current) {
-      GLuint i;
-      GLfloat *coord;
-      /* Fog is computed from vertex or fragment Z values */
-      /* source = VB->AttribPtr[_TNL_ATTRIB_POS] or VB->EyePtr coords */
-      /* dest = VB->AttribPtr[_TNL_ATTRIB_FOG] = fog stage private storage */
-      VB->AttribPtr[_TNL_ATTRIB_FOG] = &store->fogcoord;
-
-      if (!ctx->_NeedEyeCoords) {
-         /* compute fog coords from object coords */
-	 const GLfloat *m = ctx->ModelviewMatrixStack.Top->m;
-	 GLfloat plane[4];
-
-	 /* Use this to store calculated eye z values:
-	  */
-	 input = &store->fogcoord;
-
-	 plane[0] = m[2];
-	 plane[1] = m[6];
-	 plane[2] = m[10];
-	 plane[3] = m[14];
-	 /* Full eye coords weren't required, just calculate the
-	  * eye Z values.
-	  */
-	 _mesa_dotprod_tab[VB->AttribPtr[_TNL_ATTRIB_POS]->size]
-	    ( (GLfloat *) input->data,
-	      4 * sizeof(GLfloat),
-	      VB->AttribPtr[_TNL_ATTRIB_POS], plane );
-
-	 input->count = VB->AttribPtr[_TNL_ATTRIB_POS]->count;
-
-	 /* make sure coords are really positive
-	    NOTE should avoid going through array twice */
-	 coord = input->start;
-	 for (i = 0; i < input->count; i++) {
-	    *coord = FABSF(*coord);
-	    STRIDE_F(coord, input->stride);
-	 }
-      }
-      else {
-         /* fog coordinates = eye Z coordinates - need to copy for ABS */
-	 input = &store->fogcoord;
-
-	 if (VB->EyePtr->size < 2)
-	    _mesa_vector4f_clean_elem( VB->EyePtr, VB->Count, 2 );
-
-	 input->stride = 4 * sizeof(GLfloat);
-	 input->count = VB->EyePtr->count;
-	 coord = VB->EyePtr->start;
-	 for (i = 0 ; i < VB->EyePtr->count; i++) {
-	    input->data[i][0] = FABSF(coord[2]);
-	    STRIDE_F(coord, VB->EyePtr->stride);
-	 }
-      }
-   }
-   else {
-      /* use glFogCoord() coordinates */
-      input = VB->AttribPtr[_TNL_ATTRIB_FOG];  /* source data */
-
-      /* input->count may be one if glFogCoord was only called once
-       * before glBegin.  But we need to compute fog for all vertices.
-       */
-      input->count = VB->AttribPtr[_TNL_ATTRIB_POS]->count;
-
-      VB->AttribPtr[_TNL_ATTRIB_FOG] = &store->fogcoord;  /* dest data */
-   }
-
-   if (tnl->_DoVertexFog) {
-      /* compute blend factors from fog coordinates */
-      compute_fog_blend_factors( ctx, VB->AttribPtr[_TNL_ATTRIB_FOG], input );
-   }
-   else {
-      /* results = incoming fog coords (compute fog per-fragment later) */
-      VB->AttribPtr[_TNL_ATTRIB_FOG] = input;
-   }
-
-   return GL_TRUE;
-}
-
-
-
-/* Called the first time stage->run() is invoked.
- */
-static GLboolean
-alloc_fog_data(struct gl_context *ctx, struct tnl_pipeline_stage *stage)
-{
-   TNLcontext *tnl = TNL_CONTEXT(ctx);
-   struct fog_stage_data *store;
-   stage->privatePtr = MALLOC(sizeof(*store));
-   store = FOG_STAGE_DATA(stage);
-   if (!store)
-      return GL_FALSE;
-
-   _mesa_vector4f_alloc( &store->fogcoord, 0, tnl->vb.Size, 32 );
-
-   if (!inited)
-      init_static_data();
-
-   return GL_TRUE;
-}
-
-
-static void
-free_fog_data(struct tnl_pipeline_stage *stage)
-{
-   struct fog_stage_data *store = FOG_STAGE_DATA(stage);
-   if (store) {
-      _mesa_vector4f_free( &store->fogcoord );
-      FREE( store );
-      stage->privatePtr = NULL;
-   }
-}
-
-
-const struct tnl_pipeline_stage _tnl_fog_coordinate_stage =
-{
-   "build fog coordinates",	/* name */
-   NULL,			/* private_data */
-   alloc_fog_data,		/* dtr */
-   free_fog_data,		/* dtr */
-   NULL,		/* check */
-   run_fog_stage		/* run -- initially set to init. */
-};
+/*
+ * Mesa 3-D graphics library
+ * Version:  6.5
+ *
+ * Copyright (C) 1999-2006  Brian Paul   All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * BRIAN PAUL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
+ * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ *
+ * Authors:
+ *    Keith Whitwell <keith@tungstengraphics.com>
+ */
+
+
+#include "main/glheader.h"
+#include "main/colormac.h"
+#include "main/macros.h"
+#include "main/imports.h"
+#include "main/mtypes.h"
+
+#include "math/m_xform.h"
+
+#include "t_context.h"
+#include "t_pipeline.h"
+
+
+struct fog_stage_data {
+   GLvector4f fogcoord;		/* has actual storage allocated */
+};
+
+#define FOG_STAGE_DATA(stage) ((struct fog_stage_data *)stage->privatePtr)
+
+#define FOG_EXP_TABLE_SIZE 256
+#define FOG_MAX (10.0)
+#define EXP_FOG_MAX .0006595
+#define FOG_INCR (FOG_MAX/FOG_EXP_TABLE_SIZE)
+static GLfloat exp_table[FOG_EXP_TABLE_SIZE];
+static GLfloat inited = 0;
+
+#if 1
+#define NEG_EXP( result, narg )						\
+do {									\
+   GLfloat f = (GLfloat) (narg * (1.0/FOG_INCR));			\
+   GLint k = (GLint) f;							\
+   if (k > FOG_EXP_TABLE_SIZE-2) 					\
+      result = (GLfloat) EXP_FOG_MAX;					\
+   else									\
+      result = exp_table[k] + (f-k)*(exp_table[k+1]-exp_table[k]);	\
+} while (0)
+#else
+#define NEG_EXP( result, narg )					\
+do {								\
+   result = exp(-narg);						\
+} while (0)
+#endif
+
+
+/**
+ * Initialize the exp_table[] lookup table for approximating exp().
+ */
+static void
+init_static_data( void )
+{
+   GLfloat f = 0.0F;
+   GLint i = 0;
+   for ( ; i < FOG_EXP_TABLE_SIZE ; i++, f += FOG_INCR) {
+      exp_table[i] = EXPF(-f);
+   }
+   inited = 1;
+}
+
+
+/**
+ * Compute per-vertex fog blend factors from fog coordinates by
+ * evaluating the GL_LINEAR, GL_EXP or GL_EXP2 fog function.
+ * Fog coordinates are distances from the eye (typically between the
+ * near and far clip plane distances).
+ * Note that fogcoords may be negative, if eye z is source absolute
+ * value must be taken earlier.
+ * Fog blend factors are in the range [0,1].
+ */
+static void
+compute_fog_blend_factors(struct gl_context *ctx, GLvector4f *out, const GLvector4f *in)
+{
+   GLfloat end  = ctx->Fog.End;
+   GLfloat *v = in->start;
+   GLuint stride = in->stride;
+   GLuint n = in->count;
+   GLfloat (*data)[4] = out->data;
+   GLfloat d;
+   GLuint i;
+
+   out->count = in->count;
+
+   switch (ctx->Fog.Mode) {
+   case GL_LINEAR:
+      if (ctx->Fog.Start == ctx->Fog.End)
+         d = 1.0F;
+      else
+         d = 1.0F / (ctx->Fog.End - ctx->Fog.Start);
+      for ( i = 0 ; i < n ; i++, STRIDE_F(v, stride)) {
+         const GLfloat z = *v;
+         GLfloat f = (end - z) * d;
+	 data[i][0] = CLAMP(f, 0.0F, 1.0F);
+      }
+      break;
+   case GL_EXP:
+      d = ctx->Fog.Density;
+      for ( i = 0 ; i < n ; i++, STRIDE_F(v,stride)) {
+         const GLfloat z = *v;
+         NEG_EXP( data[i][0], d * z );
+      }
+      break;
+   case GL_EXP2:
+      d = ctx->Fog.Density*ctx->Fog.Density;
+      for ( i = 0 ; i < n ; i++, STRIDE_F(v, stride)) {
+         const GLfloat z = *v;
+         NEG_EXP( data[i][0], d * z * z );
+      }
+      break;
+   default:
+      _mesa_problem(ctx, "Bad fog mode in make_fog_coord");
+      return;
+   }
+}
+
+
+static GLboolean
+run_fog_stage(struct gl_context *ctx, struct tnl_pipeline_stage *stage)
+{
+   TNLcontext *tnl = TNL_CONTEXT(ctx);
+   struct vertex_buffer *VB = &tnl->vb;
+   struct fog_stage_data *store = FOG_STAGE_DATA(stage);
+   GLvector4f *input;
+
+
+   if (!ctx->Fog.Enabled)
+      return GL_TRUE;
+
+   if (ctx->Fog.FogCoordinateSource == GL_FRAGMENT_DEPTH_EXT && !ctx->VertexProgram._Current) {
+      GLuint i;
+      GLfloat *coord;
+      /* Fog is computed from vertex or fragment Z values */
+      /* source = VB->AttribPtr[_TNL_ATTRIB_POS] or VB->EyePtr coords */
+      /* dest = VB->AttribPtr[_TNL_ATTRIB_FOG] = fog stage private storage */
+      VB->AttribPtr[_TNL_ATTRIB_FOG] = &store->fogcoord;
+
+      if (!ctx->_NeedEyeCoords) {
+         /* compute fog coords from object coords */
+	 const GLfloat *m = ctx->ModelviewMatrixStack.Top->m;
+	 GLfloat plane[4];
+
+	 /* Use this to store calculated eye z values:
+	  */
+	 input = &store->fogcoord;
+
+	 plane[0] = m[2];
+	 plane[1] = m[6];
+	 plane[2] = m[10];
+	 plane[3] = m[14];
+	 /* Full eye coords weren't required, just calculate the
+	  * eye Z values.
+	  */
+	 _mesa_dotprod_tab[VB->AttribPtr[_TNL_ATTRIB_POS]->size]
+	    ( (GLfloat *) input->data,
+	      4 * sizeof(GLfloat),
+	      VB->AttribPtr[_TNL_ATTRIB_POS], plane );
+
+	 input->count = VB->AttribPtr[_TNL_ATTRIB_POS]->count;
+
+	 /* make sure coords are really positive
+	    NOTE should avoid going through array twice */
+	 coord = input->start;
+	 for (i = 0; i < input->count; i++) {
+	    *coord = FABSF(*coord);
+	    STRIDE_F(coord, input->stride);
+	 }
+      }
+      else {
+         /* fog coordinates = eye Z coordinates - need to copy for ABS */
+	 input = &store->fogcoord;
+
+	 if (VB->EyePtr->size < 2)
+	    _mesa_vector4f_clean_elem( VB->EyePtr, VB->Count, 2 );
+
+	 input->stride = 4 * sizeof(GLfloat);
+	 input->count = VB->EyePtr->count;
+	 coord = VB->EyePtr->start;
+	 for (i = 0 ; i < VB->EyePtr->count; i++) {
+	    input->data[i][0] = FABSF(coord[2]);
+	    STRIDE_F(coord, VB->EyePtr->stride);
+	 }
+      }
+   }
+   else {
+      /* use glFogCoord() coordinates */
+      input = VB->AttribPtr[_TNL_ATTRIB_FOG];  /* source data */
+
+      /* input->count may be one if glFogCoord was only called once
+       * before glBegin.  But we need to compute fog for all vertices.
+       */
+      input->count = VB->AttribPtr[_TNL_ATTRIB_POS]->count;
+
+      VB->AttribPtr[_TNL_ATTRIB_FOG] = &store->fogcoord;  /* dest data */
+   }
+
+   if (tnl->_DoVertexFog) {
+      /* compute blend factors from fog coordinates */
+      compute_fog_blend_factors( ctx, VB->AttribPtr[_TNL_ATTRIB_FOG], input );
+   }
+   else {
+      /* results = incoming fog coords (compute fog per-fragment later) */
+      VB->AttribPtr[_TNL_ATTRIB_FOG] = input;
+   }
+
+   return GL_TRUE;
+}
+
+
+
+/* Called the first time stage->run() is invoked.
+ */
+static GLboolean
+alloc_fog_data(struct gl_context *ctx, struct tnl_pipeline_stage *stage)
+{
+   TNLcontext *tnl = TNL_CONTEXT(ctx);
+   struct fog_stage_data *store;
+   stage->privatePtr = MALLOC(sizeof(*store));
+   store = FOG_STAGE_DATA(stage);
+   if (!store)
+      return GL_FALSE;
+
+   _mesa_vector4f_alloc( &store->fogcoord, 0, tnl->vb.Size, 32 );
+
+   if (!inited)
+      init_static_data();
+
+   return GL_TRUE;
+}
+
+
+static void
+free_fog_data(struct tnl_pipeline_stage *stage)
+{
+   struct fog_stage_data *store = FOG_STAGE_DATA(stage);
+   if (store) {
+      _mesa_vector4f_free( &store->fogcoord );
+      FREE( store );
+      stage->privatePtr = NULL;
+   }
+}
+
+
+const struct tnl_pipeline_stage _tnl_fog_coordinate_stage =
+{
+   "build fog coordinates",	/* name */
+   NULL,			/* private_data */
+   alloc_fog_data,		/* dtr */
+   free_fog_data,		/* dtr */
+   NULL,		/* check */
+   run_fog_stage		/* run -- initially set to init. */
+};
diff --git a/mesalib/src/mesa/tnl/t_vb_normals.c b/mesalib/src/mesa/tnl/t_vb_normals.c
index 94e8d0ab5..c19b48e51 100644
--- a/mesalib/src/mesa/tnl/t_vb_normals.c
+++ b/mesalib/src/mesa/tnl/t_vb_normals.c
@@ -1,187 +1,187 @@
-/*
- * Mesa 3-D graphics library
- * Version:  6.5
- *
- * Copyright (C) 1999-2006  Brian Paul   All Rights Reserved.
- *
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the "Software"),
- * to deal in the Software without restriction, including without limitation
- * the rights to use, copy, modify, merge, publish, distribute, sublicense,
- * and/or sell copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included
- * in all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
- * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
- * BRIAN PAUL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
- * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
- * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
- *
- * Authors:
- *    Keith Whitwell <keith@tungstengraphics.com>
- */
-
-
-#include "main/glheader.h"
-#include "main/colormac.h"
-#include "main/macros.h"
-#include "main/imports.h"
-#include "main/mtypes.h"
-
-#include "math/m_xform.h"
-
-#include "t_context.h"
-#include "t_pipeline.h"
-
-
-struct normal_stage_data {
-   normal_func NormalTransform;
-   GLvector4f normal;
-};
-
-#define NORMAL_STAGE_DATA(stage) ((struct normal_stage_data *)stage->privatePtr)
-
-
-static GLboolean
-run_normal_stage(struct gl_context *ctx, struct tnl_pipeline_stage *stage)
-{
-   struct normal_stage_data *store = NORMAL_STAGE_DATA(stage);
-   struct vertex_buffer *VB = &TNL_CONTEXT(ctx)->vb;
-   const GLfloat *lengths;
-
-   if (!store->NormalTransform)
-      return GL_TRUE;
-
-   /* We can only use the display list's saved normal lengths if we've
-    * got a transformation matrix with uniform scaling.
-    */
-   if (_math_matrix_is_general_scale(ctx->ModelviewMatrixStack.Top))
-      lengths = NULL;
-   else
-      lengths = VB->NormalLengthPtr;
-
-   store->NormalTransform( ctx->ModelviewMatrixStack.Top,
-			   ctx->_ModelViewInvScale,
-			   VB->AttribPtr[_TNL_ATTRIB_NORMAL],  /* input normals */
-			   lengths,
-			   &store->normal ); /* resulting normals */
-
-   if (VB->AttribPtr[_TNL_ATTRIB_NORMAL]->count > 1) {
-      store->normal.stride = 4 * sizeof(GLfloat);
-   }
-   else {
-      store->normal.stride = 0;
-   }
-
-   VB->AttribPtr[_TNL_ATTRIB_NORMAL] = &store->normal;
-
-   VB->NormalLengthPtr = NULL;	/* no longer valid */
-   return GL_TRUE;
-}
-
-
-/**
- * Examine current GL state and set the store->NormalTransform pointer
- * to point to the appropriate normal transformation routine.
- */
-static void
-validate_normal_stage(struct gl_context *ctx, struct tnl_pipeline_stage *stage)
-{
-   struct normal_stage_data *store = NORMAL_STAGE_DATA(stage);
-
-   if (ctx->VertexProgram._Current ||
-       (!ctx->Light.Enabled &&
-	!(ctx->Texture._GenFlags & TEXGEN_NEED_NORMALS))) {
-      store->NormalTransform = NULL;
-      return;
-   }
-
-   if (ctx->_NeedEyeCoords) {
-      /* Eye coordinates are needed, for whatever reasons.
-       * Do lighting in eye coordinates, as the GL spec says.
-       */
-      GLuint transform = NORM_TRANSFORM_NO_ROT;
-
-      if (_math_matrix_has_rotation(ctx->ModelviewMatrixStack.Top)) {
-         /* need to do full (3x3) matrix transform */
-	 transform = NORM_TRANSFORM;
-      }
-
-      if (ctx->Transform.Normalize) {
-	 store->NormalTransform = _mesa_normal_tab[transform | NORM_NORMALIZE];
-      }
-      else if (ctx->Transform.RescaleNormals &&
-               ctx->_ModelViewInvScale != 1.0) {
-	 store->NormalTransform = _mesa_normal_tab[transform | NORM_RESCALE];
-      }
-      else {
-	 store->NormalTransform = _mesa_normal_tab[transform];
-      }
-   }
-   else {
-      /* We don't need eye coordinates.
-       * Do lighting in object coordinates.  Thus, we don't need to fully
-       * transform normal vectors (just leave them in object coordinates)
-       * but we still need to do normalization/rescaling if enabled.
-       */
-      if (ctx->Transform.Normalize) {
-	 store->NormalTransform = _mesa_normal_tab[NORM_NORMALIZE];
-      }
-      else if (!ctx->Transform.RescaleNormals &&
-	       ctx->_ModelViewInvScale != 1.0) {
-	 store->NormalTransform = _mesa_normal_tab[NORM_RESCALE];
-      }
-      else {
-	 store->NormalTransform = NULL;
-      }
-   }
-}
-
-
-/**
- * Allocate stage's private data (storage for transformed normals).
- */
-static GLboolean
-alloc_normal_data(struct gl_context *ctx, struct tnl_pipeline_stage *stage)
-{
-   TNLcontext *tnl = TNL_CONTEXT(ctx);
-   struct normal_stage_data *store;
-
-   stage->privatePtr = malloc(sizeof(*store));
-   store = NORMAL_STAGE_DATA(stage);
-   if (!store)
-      return GL_FALSE;
-
-   _mesa_vector4f_alloc( &store->normal, 0, tnl->vb.Size, 32 );
-   return GL_TRUE;
-}
-
-
-/**
- * Free stage's private data.
- */
-static void
-free_normal_data(struct tnl_pipeline_stage *stage)
-{
-   struct normal_stage_data *store = NORMAL_STAGE_DATA(stage);
-   if (store) {
-      _mesa_vector4f_free( &store->normal );
-      free( store );
-      stage->privatePtr = NULL;
-   }
-}
-
-
-const struct tnl_pipeline_stage _tnl_normal_transform_stage =
-{
-   "normal transform",		/* name */
-   NULL,			/* privatePtr */
-   alloc_normal_data,		/* create */
-   free_normal_data,		/* destroy */
-   validate_normal_stage,	/* validate */
-   run_normal_stage             /* run */
-};
+/*
+ * Mesa 3-D graphics library
+ * Version:  6.5
+ *
+ * Copyright (C) 1999-2006  Brian Paul   All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * BRIAN PAUL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
+ * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ *
+ * Authors:
+ *    Keith Whitwell <keith@tungstengraphics.com>
+ */
+
+
+#include "main/glheader.h"
+#include "main/colormac.h"
+#include "main/macros.h"
+#include "main/imports.h"
+#include "main/mtypes.h"
+
+#include "math/m_xform.h"
+
+#include "t_context.h"
+#include "t_pipeline.h"
+
+
+struct normal_stage_data {
+   normal_func NormalTransform;
+   GLvector4f normal;
+};
+
+#define NORMAL_STAGE_DATA(stage) ((struct normal_stage_data *)stage->privatePtr)
+
+
+static GLboolean
+run_normal_stage(struct gl_context *ctx, struct tnl_pipeline_stage *stage)
+{
+   struct normal_stage_data *store = NORMAL_STAGE_DATA(stage);
+   struct vertex_buffer *VB = &TNL_CONTEXT(ctx)->vb;
+   const GLfloat *lengths;
+
+   if (!store->NormalTransform)
+      return GL_TRUE;
+
+   /* We can only use the display list's saved normal lengths if we've
+    * got a transformation matrix with uniform scaling.
+    */
+   if (_math_matrix_is_general_scale(ctx->ModelviewMatrixStack.Top))
+      lengths = NULL;
+   else
+      lengths = VB->NormalLengthPtr;
+
+   store->NormalTransform( ctx->ModelviewMatrixStack.Top,
+			   ctx->_ModelViewInvScale,
+			   VB->AttribPtr[_TNL_ATTRIB_NORMAL],  /* input normals */
+			   lengths,
+			   &store->normal ); /* resulting normals */
+
+   if (VB->AttribPtr[_TNL_ATTRIB_NORMAL]->count > 1) {
+      store->normal.stride = 4 * sizeof(GLfloat);
+   }
+   else {
+      store->normal.stride = 0;
+   }
+
+   VB->AttribPtr[_TNL_ATTRIB_NORMAL] = &store->normal;
+
+   VB->NormalLengthPtr = NULL;	/* no longer valid */
+   return GL_TRUE;
+}
+
+
+/**
+ * Examine current GL state and set the store->NormalTransform pointer
+ * to point to the appropriate normal transformation routine.
+ */
+static void
+validate_normal_stage(struct gl_context *ctx, struct tnl_pipeline_stage *stage)
+{
+   struct normal_stage_data *store = NORMAL_STAGE_DATA(stage);
+
+   if (ctx->VertexProgram._Current ||
+       (!ctx->Light.Enabled &&
+	!(ctx->Texture._GenFlags & TEXGEN_NEED_NORMALS))) {
+      store->NormalTransform = NULL;
+      return;
+   }
+
+   if (ctx->_NeedEyeCoords) {
+      /* Eye coordinates are needed, for whatever reasons.
+       * Do lighting in eye coordinates, as the GL spec says.
+       */
+      GLuint transform = NORM_TRANSFORM_NO_ROT;
+
+      if (_math_matrix_has_rotation(ctx->ModelviewMatrixStack.Top)) {
+         /* need to do full (3x3) matrix transform */
+	 transform = NORM_TRANSFORM;
+      }
+
+      if (ctx->Transform.Normalize) {
+	 store->NormalTransform = _mesa_normal_tab[transform | NORM_NORMALIZE];
+      }
+      else if (ctx->Transform.RescaleNormals &&
+               ctx->_ModelViewInvScale != 1.0) {
+	 store->NormalTransform = _mesa_normal_tab[transform | NORM_RESCALE];
+      }
+      else {
+	 store->NormalTransform = _mesa_normal_tab[transform];
+      }
+   }
+   else {
+      /* We don't need eye coordinates.
+       * Do lighting in object coordinates.  Thus, we don't need to fully
+       * transform normal vectors (just leave them in object coordinates)
+       * but we still need to do normalization/rescaling if enabled.
+       */
+      if (ctx->Transform.Normalize) {
+	 store->NormalTransform = _mesa_normal_tab[NORM_NORMALIZE];
+      }
+      else if (!ctx->Transform.RescaleNormals &&
+	       ctx->_ModelViewInvScale != 1.0) {
+	 store->NormalTransform = _mesa_normal_tab[NORM_RESCALE];
+      }
+      else {
+	 store->NormalTransform = NULL;
+      }
+   }
+}
+
+
+/**
+ * Allocate stage's private data (storage for transformed normals).
+ */
+static GLboolean
+alloc_normal_data(struct gl_context *ctx, struct tnl_pipeline_stage *stage)
+{
+   TNLcontext *tnl = TNL_CONTEXT(ctx);
+   struct normal_stage_data *store;
+
+   stage->privatePtr = malloc(sizeof(*store));
+   store = NORMAL_STAGE_DATA(stage);
+   if (!store)
+      return GL_FALSE;
+
+   _mesa_vector4f_alloc( &store->normal, 0, tnl->vb.Size, 32 );
+   return GL_TRUE;
+}
+
+
+/**
+ * Free stage's private data.
+ */
+static void
+free_normal_data(struct tnl_pipeline_stage *stage)
+{
+   struct normal_stage_data *store = NORMAL_STAGE_DATA(stage);
+   if (store) {
+      _mesa_vector4f_free( &store->normal );
+      free( store );
+      stage->privatePtr = NULL;
+   }
+}
+
+
+const struct tnl_pipeline_stage _tnl_normal_transform_stage =
+{
+   "normal transform",		/* name */
+   NULL,			/* privatePtr */
+   alloc_normal_data,		/* create */
+   free_normal_data,		/* destroy */
+   validate_normal_stage,	/* validate */
+   run_normal_stage             /* run */
+};
diff --git a/mesalib/src/mesa/tnl/t_vb_points.c b/mesalib/src/mesa/tnl/t_vb_points.c
index 1bf961a6d..9edbbc708 100644
--- a/mesalib/src/mesa/tnl/t_vb_points.c
+++ b/mesalib/src/mesa/tnl/t_vb_points.c
@@ -1,114 +1,114 @@
-/*
- * Mesa 3-D graphics library
- * Version:  7.0
- *
- * Copyright (C) 1999-2007  Brian Paul   All Rights Reserved.
- *
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the "Software"),
- * to deal in the Software without restriction, including without limitation
- * the rights to use, copy, modify, merge, publish, distribute, sublicense,
- * and/or sell copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included
- * in all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
- * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
- * BRIAN PAUL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
- * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
- * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
- *
- * Authors:
- *    Brian Paul
- */
-
-#include "main/glheader.h"
-#include "main/mtypes.h"
-#include "main/dd.h"
-#include "main/imports.h"
-#include "t_context.h"
-#include "t_pipeline.h"
-
-
-struct point_stage_data {
-   GLvector4f PointSize;
-};
-
-#define POINT_STAGE_DATA(stage) ((struct point_stage_data *)stage->privatePtr)
-
-
-/**
- * Compute point size for each vertex from the vertex eye-space Z
- * coordinate and the point size attenuation factors.
- * Only done when point size attenuation is enabled and vertex program is
- * disabled.
- */
-static GLboolean
-run_point_stage(struct gl_context *ctx, struct tnl_pipeline_stage *stage)
-{
-   if (ctx->Point._Attenuated && !ctx->VertexProgram._Current) {
-      struct point_stage_data *store = POINT_STAGE_DATA(stage);
-      struct vertex_buffer *VB = &TNL_CONTEXT(ctx)->vb;
-      const GLfloat *eyeCoord = (GLfloat *) VB->EyePtr->data + 2;
-      const GLint eyeCoordStride = VB->EyePtr->stride / sizeof(GLfloat);
-      const GLfloat p0 = ctx->Point.Params[0];
-      const GLfloat p1 = ctx->Point.Params[1];
-      const GLfloat p2 = ctx->Point.Params[2];
-      const GLfloat pointSize = ctx->Point.Size;
-      GLfloat (*size)[4] = store->PointSize.data;
-      GLuint i;
-
-      for (i = 0; i < VB->Count; i++) {
-         const GLfloat dist = FABSF(*eyeCoord);
-         const GLfloat q = p0 + dist * (p1 + dist * p2);
-         const GLfloat atten = (q != 0.0F) ? SQRTF(1.0F / q) : 1.0F;
-         size[i][0] = pointSize * atten; /* clamping done in rasterization */
-         eyeCoord += eyeCoordStride;
-      }
-
-      VB->AttribPtr[_TNL_ATTRIB_POINTSIZE] = &store->PointSize;
-   }
-
-   return GL_TRUE;
-}
-
-
-static GLboolean
-alloc_point_data(struct gl_context *ctx, struct tnl_pipeline_stage *stage)
-{
-   struct vertex_buffer *VB = &TNL_CONTEXT(ctx)->vb;
-   struct point_stage_data *store;
-   stage->privatePtr = malloc(sizeof(*store));
-   store = POINT_STAGE_DATA(stage);
-   if (!store)
-      return GL_FALSE;
-
-   _mesa_vector4f_alloc( &store->PointSize, 0, VB->Size, 32 );
-   return GL_TRUE;
-}
-
-
-static void
-free_point_data(struct tnl_pipeline_stage *stage)
-{
-   struct point_stage_data *store = POINT_STAGE_DATA(stage);
-   if (store) {
-      _mesa_vector4f_free( &store->PointSize );
-      free( store );
-      stage->privatePtr = NULL;
-   }
-}
-
-
-const struct tnl_pipeline_stage _tnl_point_attenuation_stage =
-{
-   "point size attenuation",	/* name */
-   NULL,			/* stage private data */
-   alloc_point_data,		/* alloc data */
-   free_point_data,		/* destructor */
-   NULL,
-   run_point_stage		/* run */
-};
+/*
+ * Mesa 3-D graphics library
+ * Version:  7.0
+ *
+ * Copyright (C) 1999-2007  Brian Paul   All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * BRIAN PAUL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
+ * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ *
+ * Authors:
+ *    Brian Paul
+ */
+
+#include "main/glheader.h"
+#include "main/mtypes.h"
+#include "main/dd.h"
+#include "main/imports.h"
+#include "t_context.h"
+#include "t_pipeline.h"
+
+
+struct point_stage_data {
+   GLvector4f PointSize;
+};
+
+#define POINT_STAGE_DATA(stage) ((struct point_stage_data *)stage->privatePtr)
+
+
+/**
+ * Compute point size for each vertex from the vertex eye-space Z
+ * coordinate and the point size attenuation factors.
+ * Only done when point size attenuation is enabled and vertex program is
+ * disabled.
+ */
+static GLboolean
+run_point_stage(struct gl_context *ctx, struct tnl_pipeline_stage *stage)
+{
+   if (ctx->Point._Attenuated && !ctx->VertexProgram._Current) {
+      struct point_stage_data *store = POINT_STAGE_DATA(stage);
+      struct vertex_buffer *VB = &TNL_CONTEXT(ctx)->vb;
+      const GLfloat *eyeCoord = (GLfloat *) VB->EyePtr->data + 2;
+      const GLint eyeCoordStride = VB->EyePtr->stride / sizeof(GLfloat);
+      const GLfloat p0 = ctx->Point.Params[0];
+      const GLfloat p1 = ctx->Point.Params[1];
+      const GLfloat p2 = ctx->Point.Params[2];
+      const GLfloat pointSize = ctx->Point.Size;
+      GLfloat (*size)[4] = store->PointSize.data;
+      GLuint i;
+
+      for (i = 0; i < VB->Count; i++) {
+         const GLfloat dist = FABSF(*eyeCoord);
+         const GLfloat q = p0 + dist * (p1 + dist * p2);
+         const GLfloat atten = (q != 0.0F) ? SQRTF(1.0F / q) : 1.0F;
+         size[i][0] = pointSize * atten; /* clamping done in rasterization */
+         eyeCoord += eyeCoordStride;
+      }
+
+      VB->AttribPtr[_TNL_ATTRIB_POINTSIZE] = &store->PointSize;
+   }
+
+   return GL_TRUE;
+}
+
+
+static GLboolean
+alloc_point_data(struct gl_context *ctx, struct tnl_pipeline_stage *stage)
+{
+   struct vertex_buffer *VB = &TNL_CONTEXT(ctx)->vb;
+   struct point_stage_data *store;
+   stage->privatePtr = malloc(sizeof(*store));
+   store = POINT_STAGE_DATA(stage);
+   if (!store)
+      return GL_FALSE;
+
+   _mesa_vector4f_alloc( &store->PointSize, 0, VB->Size, 32 );
+   return GL_TRUE;
+}
+
+
+static void
+free_point_data(struct tnl_pipeline_stage *stage)
+{
+   struct point_stage_data *store = POINT_STAGE_DATA(stage);
+   if (store) {
+      _mesa_vector4f_free( &store->PointSize );
+      free( store );
+      stage->privatePtr = NULL;
+   }
+}
+
+
+const struct tnl_pipeline_stage _tnl_point_attenuation_stage =
+{
+   "point size attenuation",	/* name */
+   NULL,			/* stage private data */
+   alloc_point_data,		/* alloc data */
+   free_point_data,		/* destructor */
+   NULL,
+   run_point_stage		/* run */
+};
diff --git a/mesalib/src/mesa/tnl/t_vb_render.c b/mesalib/src/mesa/tnl/t_vb_render.c
index 64dabca98..cb3192132 100644
--- a/mesalib/src/mesa/tnl/t_vb_render.c
+++ b/mesalib/src/mesa/tnl/t_vb_render.c
@@ -1,348 +1,348 @@
-/*
- * Mesa 3-D graphics library
- * Version:  6.5
- *
- * Copyright (C) 1999-2005  Brian Paul   All Rights Reserved.
- *
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the "Software"),
- * to deal in the Software without restriction, including without limitation
- * the rights to use, copy, modify, merge, publish, distribute, sublicense,
- * and/or sell copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included
- * in all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
- * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
- * BRIAN PAUL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
- * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
- * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
- *
- * Authors:
- *    Keith Whitwell <keith@tungstengraphics.com>
- */
-
-
-/*
- * Render whole vertex buffers, including projection of vertices from
- * clip space and clipping of primitives.
- *
- * This file makes calls to project vertices and to the point, line
- * and triangle rasterizers via the function pointers:
- *
- *    context->Driver.Render.*
- *
- */
-
-
-#include "main/glheader.h"
-#include "main/context.h"
-#include "main/enums.h"
-#include "main/macros.h"
-#include "main/imports.h"
-#include "main/mtypes.h"
-#include "math/m_xform.h"
-
-#include "t_pipeline.h"
-
-
-
-/**********************************************************************/
-/*                        Clip single primitives                      */
-/**********************************************************************/
-
-
-#define W(i) coord[i][3]
-#define Z(i) coord[i][2]
-#define Y(i) coord[i][1]
-#define X(i) coord[i][0]
-#define SIZE 4
-#define TAG(x) x##_4
-#include "t_vb_cliptmp.h"
-
-
-
-/**********************************************************************/
-/*              Clip and render whole begin/end objects               */
-/**********************************************************************/
-
-#define NEED_EDGEFLAG_SETUP (ctx->Polygon.FrontMode != GL_FILL || ctx->Polygon.BackMode != GL_FILL)
-#define EDGEFLAG_GET(idx) VB->EdgeFlag[idx]
-#define EDGEFLAG_SET(idx, val) VB->EdgeFlag[idx] = val
-
-
-/* This does NOT include the CLIP_USER_BIT! */
-#define CLIPMASK (CLIP_FRUSTUM_BITS | CLIP_CULL_BIT)
-
-
-/* Vertices, with the possibility of clipping.
- */
-#define RENDER_POINTS( start, count ) \
-   tnl->Driver.Render.Points( ctx, start, count )
-
-#define RENDER_LINE( v1, v2 )			\
-do {						\
-   GLubyte c1 = mask[v1], c2 = mask[v2];	\
-   GLubyte ormask = c1|c2;			\
-   if (!ormask)					\
-      LineFunc( ctx, v1, v2 );			\
-   else if (!(c1 & c2 & CLIPMASK))			\
-      clip_line_4( ctx, v1, v2, ormask );	\
-} while (0)
-
-#define RENDER_TRI( v1, v2, v3 )			\
-do {							\
-   GLubyte c1 = mask[v1], c2 = mask[v2], c3 = mask[v3];	\
-   GLubyte ormask = c1|c2|c3;				\
-   if (!ormask)						\
-      TriangleFunc( ctx, v1, v2, v3 );			\
-   else if (!(c1 & c2 & c3 & CLIPMASK)) 			\
-      clip_tri_4( ctx, v1, v2, v3, ormask );    	\
-} while (0)
-
-#define RENDER_QUAD( v1, v2, v3, v4 )			\
-do {							\
-   GLubyte c1 = mask[v1], c2 = mask[v2];		\
-   GLubyte c3 = mask[v3], c4 = mask[v4];		\
-   GLubyte ormask = c1|c2|c3|c4;			\
-   if (!ormask)						\
-      QuadFunc( ctx, v1, v2, v3, v4 );			\
-   else if (!(c1 & c2 & c3 & c4 & CLIPMASK)) 		\
-      clip_quad_4( ctx, v1, v2, v3, v4, ormask );	\
-} while (0)
-
-
-#define LOCAL_VARS						\
-   TNLcontext *tnl = TNL_CONTEXT(ctx);				\
-   struct vertex_buffer *VB = &tnl->vb;				\
-   const GLuint * const elt = VB->Elts;				\
-   const GLubyte *mask = VB->ClipMask;				\
-   const GLuint sz = VB->ClipPtr->size;				\
-   const tnl_line_func LineFunc = tnl->Driver.Render.Line;		\
-   const tnl_triangle_func TriangleFunc = tnl->Driver.Render.Triangle;	\
-   const tnl_quad_func QuadFunc = tnl->Driver.Render.Quad;		\
-   const GLboolean stipple = ctx->Line.StippleFlag;		\
-   (void) (LineFunc && TriangleFunc && QuadFunc);		\
-   (void) elt; (void) mask; (void) sz; (void) stipple;
-
-#define TAG(x) clip_##x##_verts
-#define INIT(x) tnl->Driver.Render.PrimitiveNotify( ctx, x )
-#define RESET_STIPPLE if (stipple) tnl->Driver.Render.ResetLineStipple( ctx )
-#define PRESERVE_VB_DEFS
-#include "t_vb_rendertmp.h"
-
-
-
-/* Elts, with the possibility of clipping.
- */
-#undef ELT
-#undef TAG
-#define ELT(x) elt[x]
-#define TAG(x) clip_##x##_elts
-#include "t_vb_rendertmp.h"
-
-/* TODO: do this for all primitives, verts and elts:
- */
-static void clip_elt_triangles( struct gl_context *ctx,
-				GLuint start,
-				GLuint count,
-				GLuint flags )
-{
-   TNLcontext *tnl = TNL_CONTEXT(ctx);
-   tnl_render_func render_tris = tnl->Driver.Render.PrimTabElts[GL_TRIANGLES];
-   struct vertex_buffer *VB = &tnl->vb;
-   const GLuint * const elt = VB->Elts;
-   GLubyte *mask = VB->ClipMask;
-   GLuint last = count-2;
-   GLuint j;
-   (void) flags;
-
-   tnl->Driver.Render.PrimitiveNotify( ctx, GL_TRIANGLES );
-
-   for (j=start; j < last; j+=3 ) {
-      GLubyte c1 = mask[elt[j]];
-      GLubyte c2 = mask[elt[j+1]];
-      GLubyte c3 = mask[elt[j+2]];
-      GLubyte ormask = c1|c2|c3;
-      if (ormask) {
-	 if (start < j)
-	    render_tris( ctx, start, j, 0 );
-	 if (!(c1&c2&c3&CLIPMASK))
-	    clip_tri_4( ctx, elt[j], elt[j+1], elt[j+2], ormask );
-	 start = j+3;
-      }
-   }
-
-   if (start < j)
-      render_tris( ctx, start, j, 0 );
-}
-
-/**********************************************************************/
-/*                  Render whole begin/end objects                    */
-/**********************************************************************/
-
-#define NEED_EDGEFLAG_SETUP (ctx->Polygon.FrontMode != GL_FILL || ctx->Polygon.BackMode != GL_FILL)
-#define EDGEFLAG_GET(idx) VB->EdgeFlag[idx]
-#define EDGEFLAG_SET(idx, val) VB->EdgeFlag[idx] = val
-
-
-/* Vertices, no clipping.
- */
-#define RENDER_POINTS( start, count ) \
-   tnl->Driver.Render.Points( ctx, start, count )
-
-#define RENDER_LINE( v1, v2 ) \
-   LineFunc( ctx, v1, v2 )
-
-#define RENDER_TRI( v1, v2, v3 ) \
-   TriangleFunc( ctx, v1, v2, v3 )
-
-#define RENDER_QUAD( v1, v2, v3, v4 ) \
-   QuadFunc( ctx, v1, v2, v3, v4 )
-
-#define TAG(x) _tnl_##x##_verts
-
-#define LOCAL_VARS						\
-   TNLcontext *tnl = TNL_CONTEXT(ctx);				\
-   struct vertex_buffer *VB = &tnl->vb;				\
-   const GLuint * const elt = VB->Elts;				\
-   const tnl_line_func LineFunc = tnl->Driver.Render.Line;		\
-   const tnl_triangle_func TriangleFunc = tnl->Driver.Render.Triangle;	\
-   const tnl_quad_func QuadFunc = tnl->Driver.Render.Quad;		\
-   const GLboolean stipple = ctx->Line.StippleFlag;		\
-   (void) (LineFunc && TriangleFunc && QuadFunc);		\
-   (void) elt; (void) stipple
-
-#define RESET_STIPPLE if (stipple) tnl->Driver.Render.ResetLineStipple( ctx )
-#define INIT(x) tnl->Driver.Render.PrimitiveNotify( ctx, x )
-#define RENDER_TAB_QUALIFIER
-#define PRESERVE_VB_DEFS
-#include "t_vb_rendertmp.h"
-
-
-/* Elts, no clipping.
- */
-#undef ELT
-#define TAG(x) _tnl_##x##_elts
-#define ELT(x) elt[x]
-#include "t_vb_rendertmp.h"
-
-
-/**********************************************************************/
-/*              Helper functions for drivers                  */
-/**********************************************************************/
-
-void _tnl_RenderClippedPolygon( struct gl_context *ctx, const GLuint *elts, GLuint n )
-{
-   TNLcontext *tnl = TNL_CONTEXT(ctx);
-   struct vertex_buffer *VB = &tnl->vb;
-   GLuint *tmp = VB->Elts;
-
-   VB->Elts = (GLuint *)elts;
-   tnl->Driver.Render.PrimTabElts[GL_POLYGON]( ctx, 0, n, PRIM_BEGIN|PRIM_END );
-   VB->Elts = tmp;
-}
-
-void _tnl_RenderClippedLine( struct gl_context *ctx, GLuint ii, GLuint jj )
-{
-   TNLcontext *tnl = TNL_CONTEXT(ctx);
-   tnl->Driver.Render.Line( ctx, ii, jj );
-}
-
-
-
-/**********************************************************************/
-/*              Clip and render whole vertex buffers                  */
-/**********************************************************************/
-
-
-static GLboolean run_render( struct gl_context *ctx,
-			     struct tnl_pipeline_stage *stage )
-{
-   TNLcontext *tnl = TNL_CONTEXT(ctx);
-   struct vertex_buffer *VB = &tnl->vb;
-   tnl_render_func *tab;
-   GLint pass = 0;
-
-   /* Allow the drivers to lock before projected verts are built so
-    * that window coordinates are guarenteed not to change before
-    * rendering.
-    */
-   ASSERT(tnl->Driver.Render.Start);
-
-   tnl->Driver.Render.Start( ctx );
-
-   ASSERT(tnl->Driver.Render.BuildVertices);
-   ASSERT(tnl->Driver.Render.PrimitiveNotify);
-   ASSERT(tnl->Driver.Render.Points);
-   ASSERT(tnl->Driver.Render.Line);
-   ASSERT(tnl->Driver.Render.Triangle);
-   ASSERT(tnl->Driver.Render.Quad);
-   ASSERT(tnl->Driver.Render.ResetLineStipple);
-   ASSERT(tnl->Driver.Render.Interp);
-   ASSERT(tnl->Driver.Render.CopyPV);
-   ASSERT(tnl->Driver.Render.ClippedLine);
-   ASSERT(tnl->Driver.Render.ClippedPolygon);
-   ASSERT(tnl->Driver.Render.Finish);
-
-   tnl->Driver.Render.BuildVertices( ctx, 0, VB->Count, ~0 );
-
-   if (VB->ClipOrMask) {
-      tab = VB->Elts ? clip_render_tab_elts : clip_render_tab_verts;
-      clip_render_tab_elts[GL_TRIANGLES] = clip_elt_triangles;
-   }
-   else {
-      tab = (VB->Elts ? 
-	     tnl->Driver.Render.PrimTabElts : 
-	     tnl->Driver.Render.PrimTabVerts);
-   }
-
-   do
-   {
-      GLuint i;
-
-      for (i = 0 ; i < VB->PrimitiveCount ; i++)
-      {
-	 GLuint prim = _tnl_translate_prim(&VB->Primitive[i]);
-	 GLuint start = VB->Primitive[i].start;
-	 GLuint length = VB->Primitive[i].count;
-
-	 assert((prim & PRIM_MODE_MASK) <= GL_POLYGON);
-
-	 if (MESA_VERBOSE & VERBOSE_PRIMS) 
-	    _mesa_debug(NULL, "MESA prim %s %d..%d\n", 
-			_mesa_lookup_enum_by_nr(prim & PRIM_MODE_MASK), 
-			start, start+length);
-
-	 if (length)
-	    tab[prim & PRIM_MODE_MASK]( ctx, start, start + length, prim );
-      }
-   } while (tnl->Driver.Render.Multipass &&
-	    tnl->Driver.Render.Multipass( ctx, ++pass ));
-
-   tnl->Driver.Render.Finish( ctx );
-
-   return GL_FALSE;		/* finished the pipe */
-}
-
-
-/**********************************************************************/
-/*                          Render pipeline stage                     */
-/**********************************************************************/
-
-
-
-
-
-const struct tnl_pipeline_stage _tnl_render_stage =
-{
-   "render",			/* name */
-   NULL,			/* private data */
-   NULL,			/* creator */
-   NULL,			/* destructor */
-   NULL,			/* validate */
-   run_render			/* run */
-};
+/*
+ * Mesa 3-D graphics library
+ * Version:  6.5
+ *
+ * Copyright (C) 1999-2005  Brian Paul   All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * BRIAN PAUL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
+ * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ *
+ * Authors:
+ *    Keith Whitwell <keith@tungstengraphics.com>
+ */
+
+
+/*
+ * Render whole vertex buffers, including projection of vertices from
+ * clip space and clipping of primitives.
+ *
+ * This file makes calls to project vertices and to the point, line
+ * and triangle rasterizers via the function pointers:
+ *
+ *    context->Driver.Render.*
+ *
+ */
+
+
+#include "main/glheader.h"
+#include "main/context.h"
+#include "main/enums.h"
+#include "main/macros.h"
+#include "main/imports.h"
+#include "main/mtypes.h"
+#include "math/m_xform.h"
+
+#include "t_pipeline.h"
+
+
+
+/**********************************************************************/
+/*                        Clip single primitives                      */
+/**********************************************************************/
+
+
+#define W(i) coord[i][3]
+#define Z(i) coord[i][2]
+#define Y(i) coord[i][1]
+#define X(i) coord[i][0]
+#define SIZE 4
+#define TAG(x) x##_4
+#include "t_vb_cliptmp.h"
+
+
+
+/**********************************************************************/
+/*              Clip and render whole begin/end objects               */
+/**********************************************************************/
+
+#define NEED_EDGEFLAG_SETUP (ctx->Polygon.FrontMode != GL_FILL || ctx->Polygon.BackMode != GL_FILL)
+#define EDGEFLAG_GET(idx) VB->EdgeFlag[idx]
+#define EDGEFLAG_SET(idx, val) VB->EdgeFlag[idx] = val
+
+
+/* This does NOT include the CLIP_USER_BIT! */
+#define CLIPMASK (CLIP_FRUSTUM_BITS | CLIP_CULL_BIT)
+
+
+/* Vertices, with the possibility of clipping.
+ */
+#define RENDER_POINTS( start, count ) \
+   tnl->Driver.Render.Points( ctx, start, count )
+
+#define RENDER_LINE( v1, v2 )			\
+do {						\
+   GLubyte c1 = mask[v1], c2 = mask[v2];	\
+   GLubyte ormask = c1|c2;			\
+   if (!ormask)					\
+      LineFunc( ctx, v1, v2 );			\
+   else if (!(c1 & c2 & CLIPMASK))			\
+      clip_line_4( ctx, v1, v2, ormask );	\
+} while (0)
+
+#define RENDER_TRI( v1, v2, v3 )			\
+do {							\
+   GLubyte c1 = mask[v1], c2 = mask[v2], c3 = mask[v3];	\
+   GLubyte ormask = c1|c2|c3;				\
+   if (!ormask)						\
+      TriangleFunc( ctx, v1, v2, v3 );			\
+   else if (!(c1 & c2 & c3 & CLIPMASK)) 			\
+      clip_tri_4( ctx, v1, v2, v3, ormask );    	\
+} while (0)
+
+#define RENDER_QUAD( v1, v2, v3, v4 )			\
+do {							\
+   GLubyte c1 = mask[v1], c2 = mask[v2];		\
+   GLubyte c3 = mask[v3], c4 = mask[v4];		\
+   GLubyte ormask = c1|c2|c3|c4;			\
+   if (!ormask)						\
+      QuadFunc( ctx, v1, v2, v3, v4 );			\
+   else if (!(c1 & c2 & c3 & c4 & CLIPMASK)) 		\
+      clip_quad_4( ctx, v1, v2, v3, v4, ormask );	\
+} while (0)
+
+
+#define LOCAL_VARS						\
+   TNLcontext *tnl = TNL_CONTEXT(ctx);				\
+   struct vertex_buffer *VB = &tnl->vb;				\
+   const GLuint * const elt = VB->Elts;				\
+   const GLubyte *mask = VB->ClipMask;				\
+   const GLuint sz = VB->ClipPtr->size;				\
+   const tnl_line_func LineFunc = tnl->Driver.Render.Line;		\
+   const tnl_triangle_func TriangleFunc = tnl->Driver.Render.Triangle;	\
+   const tnl_quad_func QuadFunc = tnl->Driver.Render.Quad;		\
+   const GLboolean stipple = ctx->Line.StippleFlag;		\
+   (void) (LineFunc && TriangleFunc && QuadFunc);		\
+   (void) elt; (void) mask; (void) sz; (void) stipple;
+
+#define TAG(x) clip_##x##_verts
+#define INIT(x) tnl->Driver.Render.PrimitiveNotify( ctx, x )
+#define RESET_STIPPLE if (stipple) tnl->Driver.Render.ResetLineStipple( ctx )
+#define PRESERVE_VB_DEFS
+#include "t_vb_rendertmp.h"
+
+
+
+/* Elts, with the possibility of clipping.
+ */
+#undef ELT
+#undef TAG
+#define ELT(x) elt[x]
+#define TAG(x) clip_##x##_elts
+#include "t_vb_rendertmp.h"
+
+/* TODO: do this for all primitives, verts and elts:
+ */
+static void clip_elt_triangles( struct gl_context *ctx,
+				GLuint start,
+				GLuint count,
+				GLuint flags )
+{
+   TNLcontext *tnl = TNL_CONTEXT(ctx);
+   tnl_render_func render_tris = tnl->Driver.Render.PrimTabElts[GL_TRIANGLES];
+   struct vertex_buffer *VB = &tnl->vb;
+   const GLuint * const elt = VB->Elts;
+   GLubyte *mask = VB->ClipMask;
+   GLuint last = count-2;
+   GLuint j;
+   (void) flags;
+
+   tnl->Driver.Render.PrimitiveNotify( ctx, GL_TRIANGLES );
+
+   for (j=start; j < last; j+=3 ) {
+      GLubyte c1 = mask[elt[j]];
+      GLubyte c2 = mask[elt[j+1]];
+      GLubyte c3 = mask[elt[j+2]];
+      GLubyte ormask = c1|c2|c3;
+      if (ormask) {
+	 if (start < j)
+	    render_tris( ctx, start, j, 0 );
+	 if (!(c1&c2&c3&CLIPMASK))
+	    clip_tri_4( ctx, elt[j], elt[j+1], elt[j+2], ormask );
+	 start = j+3;
+      }
+   }
+
+   if (start < j)
+      render_tris( ctx, start, j, 0 );
+}
+
+/**********************************************************************/
+/*                  Render whole begin/end objects                    */
+/**********************************************************************/
+
+#define NEED_EDGEFLAG_SETUP (ctx->Polygon.FrontMode != GL_FILL || ctx->Polygon.BackMode != GL_FILL)
+#define EDGEFLAG_GET(idx) VB->EdgeFlag[idx]
+#define EDGEFLAG_SET(idx, val) VB->EdgeFlag[idx] = val
+
+
+/* Vertices, no clipping.
+ */
+#define RENDER_POINTS( start, count ) \
+   tnl->Driver.Render.Points( ctx, start, count )
+
+#define RENDER_LINE( v1, v2 ) \
+   LineFunc( ctx, v1, v2 )
+
+#define RENDER_TRI( v1, v2, v3 ) \
+   TriangleFunc( ctx, v1, v2, v3 )
+
+#define RENDER_QUAD( v1, v2, v3, v4 ) \
+   QuadFunc( ctx, v1, v2, v3, v4 )
+
+#define TAG(x) _tnl_##x##_verts
+
+#define LOCAL_VARS						\
+   TNLcontext *tnl = TNL_CONTEXT(ctx);				\
+   struct vertex_buffer *VB = &tnl->vb;				\
+   const GLuint * const elt = VB->Elts;				\
+   const tnl_line_func LineFunc = tnl->Driver.Render.Line;		\
+   const tnl_triangle_func TriangleFunc = tnl->Driver.Render.Triangle;	\
+   const tnl_quad_func QuadFunc = tnl->Driver.Render.Quad;		\
+   const GLboolean stipple = ctx->Line.StippleFlag;		\
+   (void) (LineFunc && TriangleFunc && QuadFunc);		\
+   (void) elt; (void) stipple
+
+#define RESET_STIPPLE if (stipple) tnl->Driver.Render.ResetLineStipple( ctx )
+#define INIT(x) tnl->Driver.Render.PrimitiveNotify( ctx, x )
+#define RENDER_TAB_QUALIFIER
+#define PRESERVE_VB_DEFS
+#include "t_vb_rendertmp.h"
+
+
+/* Elts, no clipping.
+ */
+#undef ELT
+#define TAG(x) _tnl_##x##_elts
+#define ELT(x) elt[x]
+#include "t_vb_rendertmp.h"
+
+
+/**********************************************************************/
+/*              Helper functions for drivers                  */
+/**********************************************************************/
+
+void _tnl_RenderClippedPolygon( struct gl_context *ctx, const GLuint *elts, GLuint n )
+{
+   TNLcontext *tnl = TNL_CONTEXT(ctx);
+   struct vertex_buffer *VB = &tnl->vb;
+   GLuint *tmp = VB->Elts;
+
+   VB->Elts = (GLuint *)elts;
+   tnl->Driver.Render.PrimTabElts[GL_POLYGON]( ctx, 0, n, PRIM_BEGIN|PRIM_END );
+   VB->Elts = tmp;
+}
+
+void _tnl_RenderClippedLine( struct gl_context *ctx, GLuint ii, GLuint jj )
+{
+   TNLcontext *tnl = TNL_CONTEXT(ctx);
+   tnl->Driver.Render.Line( ctx, ii, jj );
+}
+
+
+
+/**********************************************************************/
+/*              Clip and render whole vertex buffers                  */
+/**********************************************************************/
+
+
+static GLboolean run_render( struct gl_context *ctx,
+			     struct tnl_pipeline_stage *stage )
+{
+   TNLcontext *tnl = TNL_CONTEXT(ctx);
+   struct vertex_buffer *VB = &tnl->vb;
+   tnl_render_func *tab;
+   GLint pass = 0;
+
+   /* Allow the drivers to lock before projected verts are built so
+    * that window coordinates are guarenteed not to change before
+    * rendering.
+    */
+   ASSERT(tnl->Driver.Render.Start);
+
+   tnl->Driver.Render.Start( ctx );
+
+   ASSERT(tnl->Driver.Render.BuildVertices);
+   ASSERT(tnl->Driver.Render.PrimitiveNotify);
+   ASSERT(tnl->Driver.Render.Points);
+   ASSERT(tnl->Driver.Render.Line);
+   ASSERT(tnl->Driver.Render.Triangle);
+   ASSERT(tnl->Driver.Render.Quad);
+   ASSERT(tnl->Driver.Render.ResetLineStipple);
+   ASSERT(tnl->Driver.Render.Interp);
+   ASSERT(tnl->Driver.Render.CopyPV);
+   ASSERT(tnl->Driver.Render.ClippedLine);
+   ASSERT(tnl->Driver.Render.ClippedPolygon);
+   ASSERT(tnl->Driver.Render.Finish);
+
+   tnl->Driver.Render.BuildVertices( ctx, 0, VB->Count, ~0 );
+
+   if (VB->ClipOrMask) {
+      tab = VB->Elts ? clip_render_tab_elts : clip_render_tab_verts;
+      clip_render_tab_elts[GL_TRIANGLES] = clip_elt_triangles;
+   }
+   else {
+      tab = (VB->Elts ? 
+	     tnl->Driver.Render.PrimTabElts : 
+	     tnl->Driver.Render.PrimTabVerts);
+   }
+
+   do
+   {
+      GLuint i;
+
+      for (i = 0 ; i < VB->PrimitiveCount ; i++)
+      {
+	 GLuint prim = _tnl_translate_prim(&VB->Primitive[i]);
+	 GLuint start = VB->Primitive[i].start;
+	 GLuint length = VB->Primitive[i].count;
+
+	 assert((prim & PRIM_MODE_MASK) <= GL_POLYGON);
+
+	 if (MESA_VERBOSE & VERBOSE_PRIMS) 
+	    _mesa_debug(NULL, "MESA prim %s %d..%d\n", 
+			_mesa_lookup_enum_by_nr(prim & PRIM_MODE_MASK), 
+			start, start+length);
+
+	 if (length)
+	    tab[prim & PRIM_MODE_MASK]( ctx, start, start + length, prim );
+      }
+   } while (tnl->Driver.Render.Multipass &&
+	    tnl->Driver.Render.Multipass( ctx, ++pass ));
+
+   tnl->Driver.Render.Finish( ctx );
+
+   return GL_FALSE;		/* finished the pipe */
+}
+
+
+/**********************************************************************/
+/*                          Render pipeline stage                     */
+/**********************************************************************/
+
+
+
+
+
+const struct tnl_pipeline_stage _tnl_render_stage =
+{
+   "render",			/* name */
+   NULL,			/* private data */
+   NULL,			/* creator */
+   NULL,			/* destructor */
+   NULL,			/* validate */
+   run_render			/* run */
+};
diff --git a/mesalib/src/mesa/tnl/t_vb_rendertmp.h b/mesalib/src/mesa/tnl/t_vb_rendertmp.h
index 92dbf219d..4ed485a7b 100644
--- a/mesalib/src/mesa/tnl/t_vb_rendertmp.h
+++ b/mesalib/src/mesa/tnl/t_vb_rendertmp.h
@@ -1,486 +1,486 @@
-/*
- * Mesa 3-D graphics library
- * Version:  6.5
- *
- * Copyright (C) 1999-2005  Brian Paul   All Rights Reserved.
- *
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the "Software"),
- * to deal in the Software without restriction, including without limitation
- * the rights to use, copy, modify, merge, publish, distribute, sublicense,
- * and/or sell copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included
- * in all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
- * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
- * BRIAN PAUL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
- * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
- * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
- *
- * Authors:
- *    Keith Whitwell <keith@tungstengraphics.com>
- */
-
-
-#ifndef POSTFIX
-#define POSTFIX
-#endif
-
-#ifndef INIT
-#define INIT(x)
-#endif
-
-#ifndef NEED_EDGEFLAG_SETUP
-#define NEED_EDGEFLAG_SETUP 0
-#define EDGEFLAG_GET(a) 0
-#define EDGEFLAG_SET(a,b) (void)b
-#endif
-
-#ifndef RESET_STIPPLE
-#define RESET_STIPPLE
-#endif
-
-#ifndef TEST_PRIM_END
-#define TEST_PRIM_END(prim) (flags & PRIM_END)
-#define TEST_PRIM_BEGIN(prim) (flags & PRIM_BEGIN)
-#endif
-
-#ifndef ELT
-#define ELT(x) x
-#endif
-
-#ifndef RENDER_TAB_QUALIFIER
-#define RENDER_TAB_QUALIFIER static
-#endif
-
-static void TAG(render_points)( struct gl_context *ctx,
-				GLuint start,
-				GLuint count,
-				GLuint flags )
-{
-   LOCAL_VARS;
-   (void) flags;
-
-   INIT(GL_POINTS);
-   RENDER_POINTS( start, count );
-   POSTFIX;
-}
-
-static void TAG(render_lines)( struct gl_context *ctx,
-			       GLuint start,
-			       GLuint count,
-			       GLuint flags )
-{
-   GLuint j;
-   LOCAL_VARS;
-   (void) flags;
-
-   INIT(GL_LINES);
-   for (j=start+1; j<count; j+=2 ) {
-      RESET_STIPPLE;
-      if (ctx->Light.ProvokingVertex == GL_LAST_VERTEX_CONVENTION_EXT)
-         RENDER_LINE( ELT(j-1), ELT(j) );
-      else
-         RENDER_LINE( ELT(j), ELT(j-1) );
-   }
-   POSTFIX;
-}
-
-
-static void TAG(render_line_strip)( struct gl_context *ctx,
-				    GLuint start,
-				    GLuint count,
-				    GLuint flags )
-{
-   GLuint j;
-   LOCAL_VARS;
-   (void) flags;
-
-   INIT(GL_LINE_STRIP);
-
-   if (TEST_PRIM_BEGIN(flags)) {
-      RESET_STIPPLE;
-   }
-
-   for (j=start+1; j<count; j++ ) {
-      if (ctx->Light.ProvokingVertex == GL_LAST_VERTEX_CONVENTION_EXT)
-         RENDER_LINE( ELT(j-1), ELT(j) );
-      else
-         RENDER_LINE( ELT(j), ELT(j-1) );
-   }
-   POSTFIX;
-}
-
-
-static void TAG(render_line_loop)( struct gl_context *ctx,
-				   GLuint start,
-				   GLuint count,
-				   GLuint flags )
-{
-   GLuint i;
-   LOCAL_VARS;
-
-   (void) flags;
-
-   INIT(GL_LINE_LOOP);
-
-   if (start+1 < count) {
-      if (TEST_PRIM_BEGIN(flags)) {
-	 RESET_STIPPLE;
-         if (ctx->Light.ProvokingVertex == GL_LAST_VERTEX_CONVENTION_EXT)
-            RENDER_LINE( ELT(start), ELT(start+1) );
-         else
-            RENDER_LINE( ELT(start+1), ELT(start) );
-      }
-
-      for ( i = start+2 ; i < count ; i++) {
-         if (ctx->Light.ProvokingVertex == GL_LAST_VERTEX_CONVENTION_EXT)
-            RENDER_LINE( ELT(i-1), ELT(i) );
-         else
-            RENDER_LINE( ELT(i), ELT(i-1) );
-      }
-
-      if ( TEST_PRIM_END(flags)) {
-         if (ctx->Light.ProvokingVertex == GL_LAST_VERTEX_CONVENTION_EXT)
-            RENDER_LINE( ELT(count-1), ELT(start) );
-         else
-            RENDER_LINE( ELT(start), ELT(count-1) );
-      }
-   }
-
-   POSTFIX;
-}
-
-
-static void TAG(render_triangles)( struct gl_context *ctx,
-				   GLuint start,
-				   GLuint count,
-				   GLuint flags )
-{
-   GLuint j;
-   LOCAL_VARS;
-   (void) flags;
-
-   INIT(GL_TRIANGLES);
-   if (NEED_EDGEFLAG_SETUP) {
-      for (j=start+2; j<count; j+=3) {
-	 /* Leave the edgeflags as supplied by the user.
-	  */
-	 RESET_STIPPLE;
-         if (ctx->Light.ProvokingVertex == GL_LAST_VERTEX_CONVENTION_EXT)
-            RENDER_TRI( ELT(j-2), ELT(j-1), ELT(j) );
-         else
-            RENDER_TRI( ELT(j-1), ELT(j), ELT(j-2) );
-      }
-   } else {
-      for (j=start+2; j<count; j+=3) {
-         if (ctx->Light.ProvokingVertex == GL_LAST_VERTEX_CONVENTION_EXT)
-            RENDER_TRI( ELT(j-2), ELT(j-1), ELT(j) );
-         else
-            RENDER_TRI( ELT(j-1), ELT(j), ELT(j-2) );
-      }
-   }
-   POSTFIX;
-}
-
-
-
-static void TAG(render_tri_strip)( struct gl_context *ctx,
-				   GLuint start,
-				   GLuint count,
-				   GLuint flags )
-{
-   GLuint j;
-   GLuint parity = 0;
-   LOCAL_VARS;
-
-   INIT(GL_TRIANGLE_STRIP);
-   if (NEED_EDGEFLAG_SETUP) {
-      for (j=start+2;j<count;j++,parity^=1) {
-         GLuint ej2, ej1, ej;
-         GLboolean ef2, ef1, ef;
-         if (ctx->Light.ProvokingVertex == GL_LAST_VERTEX_CONVENTION_EXT) {
-            ej2 = ELT(j-2+parity);
-            ej1 = ELT(j-1-parity);
-            ej = ELT(j);
-         }
-         else {
-            ej2 = ELT(j-1+parity);
-            ej1 = ELT(j-parity);
-            ej = ELT(j-2);
-         }
-	 ef2 = EDGEFLAG_GET( ej2 );
-	 ef1 = EDGEFLAG_GET( ej1 );
-	 ef = EDGEFLAG_GET( ej );
-	 if (TEST_PRIM_BEGIN(flags)) {
-	    RESET_STIPPLE;
-	 }
-	 EDGEFLAG_SET( ej2, GL_TRUE );
-	 EDGEFLAG_SET( ej1, GL_TRUE );
-	 EDGEFLAG_SET( ej, GL_TRUE );
-         RENDER_TRI( ej2, ej1, ej );
-	 EDGEFLAG_SET( ej2, ef2 );
-	 EDGEFLAG_SET( ej1, ef1 );
-	 EDGEFLAG_SET( ej, ef );
-      }
-   } else {
-      for (j=start+2; j<count ; j++, parity^=1) {
-         if (ctx->Light.ProvokingVertex == GL_LAST_VERTEX_CONVENTION_EXT)
-            RENDER_TRI( ELT(j-2+parity), ELT(j-1-parity), ELT(j) );
-         else
-            RENDER_TRI( ELT(j-1+parity), ELT(j-parity), ELT(j-2) );
-      }
-   }
-   POSTFIX;
-}
-
-
-static void TAG(render_tri_fan)( struct gl_context *ctx,
-				 GLuint start,
-				 GLuint count,
-				 GLuint flags )
-{
-   GLuint j;
-   LOCAL_VARS;
-   (void) flags;
-
-   INIT(GL_TRIANGLE_FAN);
-   if (NEED_EDGEFLAG_SETUP) {
-      for (j=start+2;j<count;j++) {
-	 /* For trifans, all edges are boundary.
-	  */
-	 GLuint ejs = ELT(start);
-	 GLuint ej1 = ELT(j-1);
-	 GLuint ej = ELT(j);
-	 GLboolean efs = EDGEFLAG_GET( ejs );
-	 GLboolean ef1 = EDGEFLAG_GET( ej1 );
-	 GLboolean ef = EDGEFLAG_GET( ej );
-	 if (TEST_PRIM_BEGIN(flags)) {
-	    RESET_STIPPLE;
-	 }
-	 EDGEFLAG_SET( ejs, GL_TRUE );
-	 EDGEFLAG_SET( ej1, GL_TRUE );
-	 EDGEFLAG_SET( ej, GL_TRUE );
-         if (ctx->Light.ProvokingVertex == GL_LAST_VERTEX_CONVENTION_EXT)
-            RENDER_TRI( ejs, ej1, ej);
-         else
-            RENDER_TRI( ej, ejs, ej1);
-	 EDGEFLAG_SET( ejs, efs );
-	 EDGEFLAG_SET( ej1, ef1 );
-	 EDGEFLAG_SET( ej, ef );
-      }
-   } else {
-      for (j=start+2;j<count;j++) {
-         if (ctx->Light.ProvokingVertex == GL_LAST_VERTEX_CONVENTION_EXT)
-            RENDER_TRI( ELT(start), ELT(j-1), ELT(j) );
-         else
-            RENDER_TRI( ELT(j), ELT(start), ELT(j-1) );
-      }
-   }
-
-   POSTFIX;
-}
-
-
-static void TAG(render_poly)( struct gl_context *ctx,
-			      GLuint start,
-			      GLuint count,
-			      GLuint flags )
-{
-   GLuint j = start+2;
-   LOCAL_VARS;
-   (void) flags;
-
-   INIT(GL_POLYGON);
-   if (NEED_EDGEFLAG_SETUP) {
-      GLboolean efstart = EDGEFLAG_GET( ELT(start) );
-      GLboolean efcount = EDGEFLAG_GET( ELT(count-1) );
-
-      /* If the primitive does not begin here, the first edge
-       * is non-boundary.
-       */
-      if (!TEST_PRIM_BEGIN(flags))
-	 EDGEFLAG_SET( ELT(start), GL_FALSE );
-      else {
-	 RESET_STIPPLE;
-      }
-
-      /* If the primitive does not end here, the final edge is
-       * non-boundary.
-       */
-      if (!TEST_PRIM_END(flags))
-	 EDGEFLAG_SET( ELT(count-1), GL_FALSE );
-
-      /* Draw the first triangles (possibly zero)
-       */
-      if (j+1<count) {
-	 GLboolean ef = EDGEFLAG_GET( ELT(j) );
-	 EDGEFLAG_SET( ELT(j), GL_FALSE );
-	 RENDER_TRI( ELT(j-1), ELT(j), ELT(start) );
-	 EDGEFLAG_SET( ELT(j), ef );
-	 j++;
-
-	 /* Don't render the first edge again:
-	  */
-	 EDGEFLAG_SET( ELT(start), GL_FALSE );
-
-	 for (;j+1<count;j++) {
-	    GLboolean efj = EDGEFLAG_GET( ELT(j) );
-	    EDGEFLAG_SET( ELT(j), GL_FALSE );
-	    RENDER_TRI( ELT(j-1), ELT(j), ELT(start) );
-	    EDGEFLAG_SET( ELT(j), efj );
-	 }
-      }
-
-      /* Draw the last or only triangle
-       */
-      if (j < count)
-	 RENDER_TRI( ELT(j-1), ELT(j), ELT(start) );
-
-      /* Restore the first and last edgeflags:
-       */
-      EDGEFLAG_SET( ELT(count-1), efcount );
-      EDGEFLAG_SET( ELT(start), efstart );
-
-   }
-   else {
-      for (j=start+2;j<count;j++) {
-	 RENDER_TRI( ELT(j-1), ELT(j), ELT(start) );
-      }
-   }
-   POSTFIX;
-}
-
-static void TAG(render_quads)( struct gl_context *ctx,
-			       GLuint start,
-			       GLuint count,
-			       GLuint flags )
-{
-   GLuint j;
-   LOCAL_VARS;
-   (void) flags;
-
-   INIT(GL_QUADS);
-   if (NEED_EDGEFLAG_SETUP) {
-      for (j=start+3; j<count; j+=4) {
-	 /* Use user-specified edgeflags for quads.
-	  */
-	 RESET_STIPPLE;
-         if (ctx->Light.ProvokingVertex == GL_LAST_VERTEX_CONVENTION_EXT ||
-             !ctx->Const.QuadsFollowProvokingVertexConvention)
-            RENDER_QUAD( ELT(j-3), ELT(j-2), ELT(j-1), ELT(j) );
-         else
-            RENDER_QUAD( ELT(j-2), ELT(j-1), ELT(j), ELT(j-3) );
-      }
-   } else {
-      for (j=start+3; j<count; j+=4) {
-         if (ctx->Light.ProvokingVertex == GL_LAST_VERTEX_CONVENTION_EXT ||
-             !ctx->Const.QuadsFollowProvokingVertexConvention)
-            RENDER_QUAD( ELT(j-3), ELT(j-2), ELT(j-1), ELT(j) );
-         else
-            RENDER_QUAD( ELT(j-2), ELT(j-1), ELT(j), ELT(j-3) );
-      }
-   }
-   POSTFIX;
-}
-
-static void TAG(render_quad_strip)( struct gl_context *ctx,
-				    GLuint start,
-				    GLuint count,
-				    GLuint flags )
-{
-   GLuint j;
-   LOCAL_VARS;
-   (void) flags;
-
-   INIT(GL_QUAD_STRIP);
-   if (NEED_EDGEFLAG_SETUP) {
-      for (j=start+3;j<count;j+=2) {
-	 /* All edges are boundary.  Set edgeflags to 1, draw the
-	  * quad, and restore them to the original values.
-	  */
-	 GLboolean ef3 = EDGEFLAG_GET( ELT(j-3) );
-	 GLboolean ef2 = EDGEFLAG_GET( ELT(j-2) );
-	 GLboolean ef1 = EDGEFLAG_GET( ELT(j-1) );
-	 GLboolean ef = EDGEFLAG_GET( ELT(j) );
-	 if (TEST_PRIM_BEGIN(flags)) {
-	    RESET_STIPPLE;
-	 }
-	 EDGEFLAG_SET( ELT(j-3), GL_TRUE );
-	 EDGEFLAG_SET( ELT(j-2), GL_TRUE );
-	 EDGEFLAG_SET( ELT(j-1), GL_TRUE );
-	 EDGEFLAG_SET( ELT(j), GL_TRUE );
-         if (ctx->Light.ProvokingVertex == GL_LAST_VERTEX_CONVENTION_EXT ||
-             !ctx->Const.QuadsFollowProvokingVertexConvention)
-            RENDER_QUAD( ELT(j-1), ELT(j-3), ELT(j-2), ELT(j) );
-         else
-            RENDER_QUAD( ELT(j-2), ELT(j), ELT(j-1), ELT(j-3) );
-	 EDGEFLAG_SET( ELT(j-3), ef3 );
-	 EDGEFLAG_SET( ELT(j-2), ef2 );
-	 EDGEFLAG_SET( ELT(j-1), ef1 );
-	 EDGEFLAG_SET( ELT(j), ef );
-      }
-   } else {
-      for (j=start+3;j<count;j+=2) {
-         if (ctx->Light.ProvokingVertex == GL_LAST_VERTEX_CONVENTION_EXT ||
-             !ctx->Const.QuadsFollowProvokingVertexConvention)
-            RENDER_QUAD( ELT(j-1), ELT(j-3), ELT(j-2), ELT(j) );
-         else
-            RENDER_QUAD( ELT(j-2), ELT(j), ELT(j-1), ELT(j-3) );
-      }
-   }
-   POSTFIX;
-}
-
-static void TAG(render_noop)( struct gl_context *ctx,
-			      GLuint start,
-			      GLuint count,
-			      GLuint flags )
-{
-   (void)(ctx && start && count && flags);
-}
-
-RENDER_TAB_QUALIFIER void (*TAG(render_tab)[GL_POLYGON+2])(struct gl_context *,
-							   GLuint,
-							   GLuint,
-							   GLuint) =
-{
-   TAG(render_points),
-   TAG(render_lines),
-   TAG(render_line_loop),
-   TAG(render_line_strip),
-   TAG(render_triangles),
-   TAG(render_tri_strip),
-   TAG(render_tri_fan),
-   TAG(render_quads),
-   TAG(render_quad_strip),
-   TAG(render_poly),
-   TAG(render_noop),
-};
-
-
-
-#ifndef PRESERVE_VB_DEFS
-#undef RENDER_TRI
-#undef RENDER_QUAD
-#undef RENDER_LINE
-#undef RENDER_POINTS
-#undef LOCAL_VARS
-#undef INIT
-#undef POSTFIX
-#undef RESET_STIPPLE
-#undef DBG
-#undef ELT
-#undef RENDER_TAB_QUALIFIER
-#endif
-
-#ifndef PRESERVE_TAG
-#undef TAG
-#endif
-
-#undef PRESERVE_VB_DEFS
-#undef PRESERVE_TAG
+/*
+ * Mesa 3-D graphics library
+ * Version:  6.5
+ *
+ * Copyright (C) 1999-2005  Brian Paul   All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * BRIAN PAUL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
+ * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ *
+ * Authors:
+ *    Keith Whitwell <keith@tungstengraphics.com>
+ */
+
+
+#ifndef POSTFIX
+#define POSTFIX
+#endif
+
+#ifndef INIT
+#define INIT(x)
+#endif
+
+#ifndef NEED_EDGEFLAG_SETUP
+#define NEED_EDGEFLAG_SETUP 0
+#define EDGEFLAG_GET(a) 0
+#define EDGEFLAG_SET(a,b) (void)b
+#endif
+
+#ifndef RESET_STIPPLE
+#define RESET_STIPPLE
+#endif
+
+#ifndef TEST_PRIM_END
+#define TEST_PRIM_END(prim) (flags & PRIM_END)
+#define TEST_PRIM_BEGIN(prim) (flags & PRIM_BEGIN)
+#endif
+
+#ifndef ELT
+#define ELT(x) x
+#endif
+
+#ifndef RENDER_TAB_QUALIFIER
+#define RENDER_TAB_QUALIFIER static
+#endif
+
+static void TAG(render_points)( struct gl_context *ctx,
+				GLuint start,
+				GLuint count,
+				GLuint flags )
+{
+   LOCAL_VARS;
+   (void) flags;
+
+   INIT(GL_POINTS);
+   RENDER_POINTS( start, count );
+   POSTFIX;
+}
+
+static void TAG(render_lines)( struct gl_context *ctx,
+			       GLuint start,
+			       GLuint count,
+			       GLuint flags )
+{
+   GLuint j;
+   LOCAL_VARS;
+   (void) flags;
+
+   INIT(GL_LINES);
+   for (j=start+1; j<count; j+=2 ) {
+      RESET_STIPPLE;
+      if (ctx->Light.ProvokingVertex == GL_LAST_VERTEX_CONVENTION_EXT)
+         RENDER_LINE( ELT(j-1), ELT(j) );
+      else
+         RENDER_LINE( ELT(j), ELT(j-1) );
+   }
+   POSTFIX;
+}
+
+
+static void TAG(render_line_strip)( struct gl_context *ctx,
+				    GLuint start,
+				    GLuint count,
+				    GLuint flags )
+{
+   GLuint j;
+   LOCAL_VARS;
+   (void) flags;
+
+   INIT(GL_LINE_STRIP);
+
+   if (TEST_PRIM_BEGIN(flags)) {
+      RESET_STIPPLE;
+   }
+
+   for (j=start+1; j<count; j++ ) {
+      if (ctx->Light.ProvokingVertex == GL_LAST_VERTEX_CONVENTION_EXT)
+         RENDER_LINE( ELT(j-1), ELT(j) );
+      else
+         RENDER_LINE( ELT(j), ELT(j-1) );
+   }
+   POSTFIX;
+}
+
+
+static void TAG(render_line_loop)( struct gl_context *ctx,
+				   GLuint start,
+				   GLuint count,
+				   GLuint flags )
+{
+   GLuint i;
+   LOCAL_VARS;
+
+   (void) flags;
+
+   INIT(GL_LINE_LOOP);
+
+   if (start+1 < count) {
+      if (TEST_PRIM_BEGIN(flags)) {
+	 RESET_STIPPLE;
+         if (ctx->Light.ProvokingVertex == GL_LAST_VERTEX_CONVENTION_EXT)
+            RENDER_LINE( ELT(start), ELT(start+1) );
+         else
+            RENDER_LINE( ELT(start+1), ELT(start) );
+      }
+
+      for ( i = start+2 ; i < count ; i++) {
+         if (ctx->Light.ProvokingVertex == GL_LAST_VERTEX_CONVENTION_EXT)
+            RENDER_LINE( ELT(i-1), ELT(i) );
+         else
+            RENDER_LINE( ELT(i), ELT(i-1) );
+      }
+
+      if ( TEST_PRIM_END(flags)) {
+         if (ctx->Light.ProvokingVertex == GL_LAST_VERTEX_CONVENTION_EXT)
+            RENDER_LINE( ELT(count-1), ELT(start) );
+         else
+            RENDER_LINE( ELT(start), ELT(count-1) );
+      }
+   }
+
+   POSTFIX;
+}
+
+
+static void TAG(render_triangles)( struct gl_context *ctx,
+				   GLuint start,
+				   GLuint count,
+				   GLuint flags )
+{
+   GLuint j;
+   LOCAL_VARS;
+   (void) flags;
+
+   INIT(GL_TRIANGLES);
+   if (NEED_EDGEFLAG_SETUP) {
+      for (j=start+2; j<count; j+=3) {
+	 /* Leave the edgeflags as supplied by the user.
+	  */
+	 RESET_STIPPLE;
+         if (ctx->Light.ProvokingVertex == GL_LAST_VERTEX_CONVENTION_EXT)
+            RENDER_TRI( ELT(j-2), ELT(j-1), ELT(j) );
+         else
+            RENDER_TRI( ELT(j-1), ELT(j), ELT(j-2) );
+      }
+   } else {
+      for (j=start+2; j<count; j+=3) {
+         if (ctx->Light.ProvokingVertex == GL_LAST_VERTEX_CONVENTION_EXT)
+            RENDER_TRI( ELT(j-2), ELT(j-1), ELT(j) );
+         else
+            RENDER_TRI( ELT(j-1), ELT(j), ELT(j-2) );
+      }
+   }
+   POSTFIX;
+}
+
+
+
+static void TAG(render_tri_strip)( struct gl_context *ctx,
+				   GLuint start,
+				   GLuint count,
+				   GLuint flags )
+{
+   GLuint j;
+   GLuint parity = 0;
+   LOCAL_VARS;
+
+   INIT(GL_TRIANGLE_STRIP);
+   if (NEED_EDGEFLAG_SETUP) {
+      for (j=start+2;j<count;j++,parity^=1) {
+         GLuint ej2, ej1, ej;
+         GLboolean ef2, ef1, ef;
+         if (ctx->Light.ProvokingVertex == GL_LAST_VERTEX_CONVENTION_EXT) {
+            ej2 = ELT(j-2+parity);
+            ej1 = ELT(j-1-parity);
+            ej = ELT(j);
+         }
+         else {
+            ej2 = ELT(j-1+parity);
+            ej1 = ELT(j-parity);
+            ej = ELT(j-2);
+         }
+	 ef2 = EDGEFLAG_GET( ej2 );
+	 ef1 = EDGEFLAG_GET( ej1 );
+	 ef = EDGEFLAG_GET( ej );
+	 if (TEST_PRIM_BEGIN(flags)) {
+	    RESET_STIPPLE;
+	 }
+	 EDGEFLAG_SET( ej2, GL_TRUE );
+	 EDGEFLAG_SET( ej1, GL_TRUE );
+	 EDGEFLAG_SET( ej, GL_TRUE );
+         RENDER_TRI( ej2, ej1, ej );
+	 EDGEFLAG_SET( ej2, ef2 );
+	 EDGEFLAG_SET( ej1, ef1 );
+	 EDGEFLAG_SET( ej, ef );
+      }
+   } else {
+      for (j=start+2; j<count ; j++, parity^=1) {
+         if (ctx->Light.ProvokingVertex == GL_LAST_VERTEX_CONVENTION_EXT)
+            RENDER_TRI( ELT(j-2+parity), ELT(j-1-parity), ELT(j) );
+         else
+            RENDER_TRI( ELT(j-1+parity), ELT(j-parity), ELT(j-2) );
+      }
+   }
+   POSTFIX;
+}
+
+
+static void TAG(render_tri_fan)( struct gl_context *ctx,
+				 GLuint start,
+				 GLuint count,
+				 GLuint flags )
+{
+   GLuint j;
+   LOCAL_VARS;
+   (void) flags;
+
+   INIT(GL_TRIANGLE_FAN);
+   if (NEED_EDGEFLAG_SETUP) {
+      for (j=start+2;j<count;j++) {
+	 /* For trifans, all edges are boundary.
+	  */
+	 GLuint ejs = ELT(start);
+	 GLuint ej1 = ELT(j-1);
+	 GLuint ej = ELT(j);
+	 GLboolean efs = EDGEFLAG_GET( ejs );
+	 GLboolean ef1 = EDGEFLAG_GET( ej1 );
+	 GLboolean ef = EDGEFLAG_GET( ej );
+	 if (TEST_PRIM_BEGIN(flags)) {
+	    RESET_STIPPLE;
+	 }
+	 EDGEFLAG_SET( ejs, GL_TRUE );
+	 EDGEFLAG_SET( ej1, GL_TRUE );
+	 EDGEFLAG_SET( ej, GL_TRUE );
+         if (ctx->Light.ProvokingVertex == GL_LAST_VERTEX_CONVENTION_EXT)
+            RENDER_TRI( ejs, ej1, ej);
+         else
+            RENDER_TRI( ej, ejs, ej1);
+	 EDGEFLAG_SET( ejs, efs );
+	 EDGEFLAG_SET( ej1, ef1 );
+	 EDGEFLAG_SET( ej, ef );
+      }
+   } else {
+      for (j=start+2;j<count;j++) {
+         if (ctx->Light.ProvokingVertex == GL_LAST_VERTEX_CONVENTION_EXT)
+            RENDER_TRI( ELT(start), ELT(j-1), ELT(j) );
+         else
+            RENDER_TRI( ELT(j), ELT(start), ELT(j-1) );
+      }
+   }
+
+   POSTFIX;
+}
+
+
+static void TAG(render_poly)( struct gl_context *ctx,
+			      GLuint start,
+			      GLuint count,
+			      GLuint flags )
+{
+   GLuint j = start+2;
+   LOCAL_VARS;
+   (void) flags;
+
+   INIT(GL_POLYGON);
+   if (NEED_EDGEFLAG_SETUP) {
+      GLboolean efstart = EDGEFLAG_GET( ELT(start) );
+      GLboolean efcount = EDGEFLAG_GET( ELT(count-1) );
+
+      /* If the primitive does not begin here, the first edge
+       * is non-boundary.
+       */
+      if (!TEST_PRIM_BEGIN(flags))
+	 EDGEFLAG_SET( ELT(start), GL_FALSE );
+      else {
+	 RESET_STIPPLE;
+      }
+
+      /* If the primitive does not end here, the final edge is
+       * non-boundary.
+       */
+      if (!TEST_PRIM_END(flags))
+	 EDGEFLAG_SET( ELT(count-1), GL_FALSE );
+
+      /* Draw the first triangles (possibly zero)
+       */
+      if (j+1<count) {
+	 GLboolean ef = EDGEFLAG_GET( ELT(j) );
+	 EDGEFLAG_SET( ELT(j), GL_FALSE );
+	 RENDER_TRI( ELT(j-1), ELT(j), ELT(start) );
+	 EDGEFLAG_SET( ELT(j), ef );
+	 j++;
+
+	 /* Don't render the first edge again:
+	  */
+	 EDGEFLAG_SET( ELT(start), GL_FALSE );
+
+	 for (;j+1<count;j++) {
+	    GLboolean efj = EDGEFLAG_GET( ELT(j) );
+	    EDGEFLAG_SET( ELT(j), GL_FALSE );
+	    RENDER_TRI( ELT(j-1), ELT(j), ELT(start) );
+	    EDGEFLAG_SET( ELT(j), efj );
+	 }
+      }
+
+      /* Draw the last or only triangle
+       */
+      if (j < count)
+	 RENDER_TRI( ELT(j-1), ELT(j), ELT(start) );
+
+      /* Restore the first and last edgeflags:
+       */
+      EDGEFLAG_SET( ELT(count-1), efcount );
+      EDGEFLAG_SET( ELT(start), efstart );
+
+   }
+   else {
+      for (j=start+2;j<count;j++) {
+	 RENDER_TRI( ELT(j-1), ELT(j), ELT(start) );
+      }
+   }
+   POSTFIX;
+}
+
+static void TAG(render_quads)( struct gl_context *ctx,
+			       GLuint start,
+			       GLuint count,
+			       GLuint flags )
+{
+   GLuint j;
+   LOCAL_VARS;
+   (void) flags;
+
+   INIT(GL_QUADS);
+   if (NEED_EDGEFLAG_SETUP) {
+      for (j=start+3; j<count; j+=4) {
+	 /* Use user-specified edgeflags for quads.
+	  */
+	 RESET_STIPPLE;
+         if (ctx->Light.ProvokingVertex == GL_LAST_VERTEX_CONVENTION_EXT ||
+             !ctx->Const.QuadsFollowProvokingVertexConvention)
+            RENDER_QUAD( ELT(j-3), ELT(j-2), ELT(j-1), ELT(j) );
+         else
+            RENDER_QUAD( ELT(j-2), ELT(j-1), ELT(j), ELT(j-3) );
+      }
+   } else {
+      for (j=start+3; j<count; j+=4) {
+         if (ctx->Light.ProvokingVertex == GL_LAST_VERTEX_CONVENTION_EXT ||
+             !ctx->Const.QuadsFollowProvokingVertexConvention)
+            RENDER_QUAD( ELT(j-3), ELT(j-2), ELT(j-1), ELT(j) );
+         else
+            RENDER_QUAD( ELT(j-2), ELT(j-1), ELT(j), ELT(j-3) );
+      }
+   }
+   POSTFIX;
+}
+
+static void TAG(render_quad_strip)( struct gl_context *ctx,
+				    GLuint start,
+				    GLuint count,
+				    GLuint flags )
+{
+   GLuint j;
+   LOCAL_VARS;
+   (void) flags;
+
+   INIT(GL_QUAD_STRIP);
+   if (NEED_EDGEFLAG_SETUP) {
+      for (j=start+3;j<count;j+=2) {
+	 /* All edges are boundary.  Set edgeflags to 1, draw the
+	  * quad, and restore them to the original values.
+	  */
+	 GLboolean ef3 = EDGEFLAG_GET( ELT(j-3) );
+	 GLboolean ef2 = EDGEFLAG_GET( ELT(j-2) );
+	 GLboolean ef1 = EDGEFLAG_GET( ELT(j-1) );
+	 GLboolean ef = EDGEFLAG_GET( ELT(j) );
+	 if (TEST_PRIM_BEGIN(flags)) {
+	    RESET_STIPPLE;
+	 }
+	 EDGEFLAG_SET( ELT(j-3), GL_TRUE );
+	 EDGEFLAG_SET( ELT(j-2), GL_TRUE );
+	 EDGEFLAG_SET( ELT(j-1), GL_TRUE );
+	 EDGEFLAG_SET( ELT(j), GL_TRUE );
+         if (ctx->Light.ProvokingVertex == GL_LAST_VERTEX_CONVENTION_EXT ||
+             !ctx->Const.QuadsFollowProvokingVertexConvention)
+            RENDER_QUAD( ELT(j-1), ELT(j-3), ELT(j-2), ELT(j) );
+         else
+            RENDER_QUAD( ELT(j-2), ELT(j), ELT(j-1), ELT(j-3) );
+	 EDGEFLAG_SET( ELT(j-3), ef3 );
+	 EDGEFLAG_SET( ELT(j-2), ef2 );
+	 EDGEFLAG_SET( ELT(j-1), ef1 );
+	 EDGEFLAG_SET( ELT(j), ef );
+      }
+   } else {
+      for (j=start+3;j<count;j+=2) {
+         if (ctx->Light.ProvokingVertex == GL_LAST_VERTEX_CONVENTION_EXT ||
+             !ctx->Const.QuadsFollowProvokingVertexConvention)
+            RENDER_QUAD( ELT(j-1), ELT(j-3), ELT(j-2), ELT(j) );
+         else
+            RENDER_QUAD( ELT(j-2), ELT(j), ELT(j-1), ELT(j-3) );
+      }
+   }
+   POSTFIX;
+}
+
+static void TAG(render_noop)( struct gl_context *ctx,
+			      GLuint start,
+			      GLuint count,
+			      GLuint flags )
+{
+   (void)(ctx && start && count && flags);
+}
+
+RENDER_TAB_QUALIFIER void (*TAG(render_tab)[GL_POLYGON+2])(struct gl_context *,
+							   GLuint,
+							   GLuint,
+							   GLuint) =
+{
+   TAG(render_points),
+   TAG(render_lines),
+   TAG(render_line_loop),
+   TAG(render_line_strip),
+   TAG(render_triangles),
+   TAG(render_tri_strip),
+   TAG(render_tri_fan),
+   TAG(render_quads),
+   TAG(render_quad_strip),
+   TAG(render_poly),
+   TAG(render_noop),
+};
+
+
+
+#ifndef PRESERVE_VB_DEFS
+#undef RENDER_TRI
+#undef RENDER_QUAD
+#undef RENDER_LINE
+#undef RENDER_POINTS
+#undef LOCAL_VARS
+#undef INIT
+#undef POSTFIX
+#undef RESET_STIPPLE
+#undef DBG
+#undef ELT
+#undef RENDER_TAB_QUALIFIER
+#endif
+
+#ifndef PRESERVE_TAG
+#undef TAG
+#endif
+
+#undef PRESERVE_VB_DEFS
+#undef PRESERVE_TAG
diff --git a/mesalib/src/mesa/tnl/t_vb_texgen.c b/mesalib/src/mesa/tnl/t_vb_texgen.c
index 228808461..61430c396 100644
--- a/mesalib/src/mesa/tnl/t_vb_texgen.c
+++ b/mesalib/src/mesa/tnl/t_vb_texgen.c
@@ -1,609 +1,609 @@
-/*
- * Mesa 3-D graphics library
- * Version:  6.5
- *
- * Copyright (C) 1999-2006  Brian Paul   All Rights Reserved.
- *
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the "Software"),
- * to deal in the Software without restriction, including without limitation
- * the rights to use, copy, modify, merge, publish, distribute, sublicense,
- * and/or sell copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included
- * in all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
- * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
- * BRIAN PAUL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
- * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
- * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
- *
- * Authors:
- *    Brian Paul
- *    Keith Whitwell <keith@tungstengraphics.com>
- */
-
-/*
- * Regarding GL_NV_texgen_reflection:
- *
- * Portions of this software may use or implement intellectual
- * property owned and licensed by NVIDIA Corporation. NVIDIA disclaims
- * any and all warranties with respect to such intellectual property,
- * including any use thereof or modifications thereto.
- */
-
-#include "main/glheader.h"
-#include "main/colormac.h"
-#include "main/macros.h"
-#include "main/imports.h"
-#include "main/mtypes.h"
-
-#include "math/m_xform.h"
-
-#include "t_context.h"
-#include "t_pipeline.h"
-
-
-/***********************************************************************
- * Automatic texture coordinate generation (texgen) code.
- */
-
-
-struct texgen_stage_data;
-
-typedef void (*texgen_func)( struct gl_context *ctx,
-			     struct texgen_stage_data *store,
-			     GLuint unit);
-
-
-struct texgen_stage_data {
-
-   /* Per-texunit derived state.
-    */
-   GLuint TexgenSize[MAX_TEXTURE_COORD_UNITS];
-   texgen_func TexgenFunc[MAX_TEXTURE_COORD_UNITS];
-
-   /* Temporary values used in texgen.
-    */
-   GLfloat (*tmp_f)[3];
-   GLfloat *tmp_m;
-
-   /* Buffered outputs of the stage.
-    */
-   GLvector4f texcoord[MAX_TEXTURE_COORD_UNITS];
-};
-
-
-#define TEXGEN_STAGE_DATA(stage) ((struct texgen_stage_data *)stage->privatePtr)
-
-
-
-static GLuint all_bits[5] = {
-   0,
-   VEC_SIZE_1,
-   VEC_SIZE_2,
-   VEC_SIZE_3,
-   VEC_SIZE_4,
-};
-
-#define VEC_SIZE_FLAGS (VEC_SIZE_1|VEC_SIZE_2|VEC_SIZE_3|VEC_SIZE_4)
-
-#define TEXGEN_NEED_M            (TEXGEN_SPHERE_MAP)
-#define TEXGEN_NEED_F            (TEXGEN_SPHERE_MAP        | \
-				  TEXGEN_REFLECTION_MAP_NV)
-
-
-
-static void build_m3( GLfloat f[][3], GLfloat m[],
-		      const GLvector4f *normal,
-		      const GLvector4f *eye )
-{
-   GLuint stride = eye->stride;
-   GLfloat *coord = (GLfloat *)eye->start;
-   GLuint count = eye->count;
-   const GLfloat *norm = normal->start;
-   GLuint i;
-
-   for (i=0;i<count;i++,STRIDE_F(coord,stride),STRIDE_F(norm,normal->stride)) {
-      GLfloat u[3], two_nu, fx, fy, fz;
-      COPY_3V( u, coord );
-      NORMALIZE_3FV( u );
-      two_nu = 2.0F * DOT3(norm,u);
-      fx = f[i][0] = u[0] - norm[0] * two_nu;
-      fy = f[i][1] = u[1] - norm[1] * two_nu;
-      fz = f[i][2] = u[2] - norm[2] * two_nu;
-      m[i] = fx * fx + fy * fy + (fz + 1.0F) * (fz + 1.0F);
-      if (m[i] != 0.0F) {
-	 m[i] = 0.5F * _mesa_inv_sqrtf(m[i]);
-      }
-   }
-}
-
-
-
-static void build_m2( GLfloat f[][3], GLfloat m[],
-		      const GLvector4f *normal,
-		      const GLvector4f *eye )
-{
-   GLuint stride = eye->stride;
-   GLfloat *coord = eye->start;
-   GLuint count = eye->count;
-
-   GLfloat *norm = normal->start;
-   GLuint i;
-
-   for (i=0;i<count;i++,STRIDE_F(coord,stride),STRIDE_F(norm,normal->stride)) {
-      GLfloat u[3], two_nu, fx, fy, fz;
-      COPY_2V( u, coord );
-      u[2] = 0;
-      NORMALIZE_3FV( u );
-      two_nu = 2.0F * DOT3(norm,u);
-      fx = f[i][0] = u[0] - norm[0] * two_nu;
-      fy = f[i][1] = u[1] - norm[1] * two_nu;
-      fz = f[i][2] = u[2] - norm[2] * two_nu;
-      m[i] = fx * fx + fy * fy + (fz + 1.0F) * (fz + 1.0F);
-      if (m[i] != 0.0F) {
-	 m[i] = 0.5F * _mesa_inv_sqrtf(m[i]);
-      }
-   }
-}
-
-
-
-typedef void (*build_m_func)( GLfloat f[][3],
-			      GLfloat m[],
-			      const GLvector4f *normal,
-			      const GLvector4f *eye );
-
-
-static build_m_func build_m_tab[5] = {
-   NULL,
-   NULL,
-   build_m2,
-   build_m3,
-   build_m3
-};
-
-
-/* This is unusual in that we respect the stride of the output vector
- * (f).  This allows us to pass in either a texcoord vector4f, or a
- * temporary vector3f.
- */
-static void build_f3( GLfloat *f,
-		      GLuint fstride,
-		      const GLvector4f *normal,
-		      const GLvector4f *eye )
-{
-   GLuint stride = eye->stride;
-   GLfloat *coord = eye->start;
-   GLuint count = eye->count;
-
-   GLfloat *norm = normal->start;
-   GLuint i;
-
-   for (i=0;i<count;i++) {
-      GLfloat u[3], two_nu;
-      COPY_3V( u, coord );
-      NORMALIZE_3FV( u );
-      two_nu = 2.0F * DOT3(norm,u);
-      f[0] = u[0] - norm[0] * two_nu;
-      f[1] = u[1] - norm[1] * two_nu;
-      f[2] = u[2] - norm[2] * two_nu;
-      STRIDE_F(coord,stride);
-      STRIDE_F(f,fstride);
-      STRIDE_F(norm, normal->stride);
-   }
-}
-
-
-static void build_f2( GLfloat *f,
-		      GLuint fstride,
-		      const GLvector4f *normal,
-		      const GLvector4f *eye )
-{
-   GLuint stride = eye->stride;
-   GLfloat *coord = eye->start;
-   GLuint count = eye->count;
-   GLfloat *norm = normal->start;
-   GLuint i;
-
-   for (i=0;i<count;i++) {
-
-      GLfloat u[3], two_nu;
-      COPY_2V( u, coord );
-      u[2] = 0;
-      NORMALIZE_3FV( u );
-      two_nu = 2.0F * DOT3(norm,u);
-      f[0] = u[0] - norm[0] * two_nu;
-      f[1] = u[1] - norm[1] * two_nu;
-      f[2] = u[2] - norm[2] * two_nu;
-
-      STRIDE_F(coord,stride);
-      STRIDE_F(f,fstride);
-      STRIDE_F(norm, normal->stride);
-   }
-}
-
-typedef void (*build_f_func)( GLfloat *f,
-			      GLuint fstride,
-			      const GLvector4f *normal_vec,
-			      const GLvector4f *eye );
-
-
-
-/* Just treat 4-vectors as 3-vectors.
- */
-static build_f_func build_f_tab[5] = {
-   NULL,
-   NULL,
-   build_f2,
-   build_f3,
-   build_f3
-};
-
-
-
-/* Special case texgen functions.
- */
-static void texgen_reflection_map_nv( struct gl_context *ctx,
-				      struct texgen_stage_data *store,
-				      GLuint unit )
-{
-   struct vertex_buffer *VB = &TNL_CONTEXT(ctx)->vb;
-   GLvector4f *in = VB->AttribPtr[VERT_ATTRIB_TEX0 + unit];
-   GLvector4f *out = &store->texcoord[unit];
-
-   build_f_tab[VB->EyePtr->size]( out->start,
-				  out->stride,
-				  VB->AttribPtr[_TNL_ATTRIB_NORMAL],
-				  VB->EyePtr );
-
-   out->flags |= (in->flags & VEC_SIZE_FLAGS) | VEC_SIZE_3;
-   out->count = VB->Count;
-   out->size = MAX2(in->size, 3);
-   if (in->size == 4) 
-      _mesa_copy_tab[0x8]( out, in );
-}
-
-
-
-static void texgen_normal_map_nv( struct gl_context *ctx,
-				  struct texgen_stage_data *store,
-				  GLuint unit )
-{
-   struct vertex_buffer *VB = &TNL_CONTEXT(ctx)->vb;
-   GLvector4f *in = VB->AttribPtr[VERT_ATTRIB_TEX0 + unit];
-   GLvector4f *out = &store->texcoord[unit];
-   GLvector4f *normal = VB->AttribPtr[_TNL_ATTRIB_NORMAL];
-   GLfloat (*texcoord)[4] = (GLfloat (*)[4])out->start;
-   GLuint count = VB->Count;
-   GLuint i;
-   const GLfloat *norm = normal->start;
-
-   for (i=0;i<count;i++, STRIDE_F(norm, normal->stride)) {
-      texcoord[i][0] = norm[0];
-      texcoord[i][1] = norm[1];
-      texcoord[i][2] = norm[2];
-   }
-
-
-   out->flags |= (in->flags & VEC_SIZE_FLAGS) | VEC_SIZE_3;
-   out->count = count;
-   out->size = MAX2(in->size, 3);
-   if (in->size == 4) 
-      _mesa_copy_tab[0x8]( out, in );
-}
-
-
-static void texgen_sphere_map( struct gl_context *ctx,
-			       struct texgen_stage_data *store,
-			       GLuint unit )
-{
-   struct vertex_buffer *VB = &TNL_CONTEXT(ctx)->vb;
-   GLvector4f *in = VB->AttribPtr[VERT_ATTRIB_TEX0 + unit];
-   GLvector4f *out = &store->texcoord[unit];
-   GLfloat (*texcoord)[4] = (GLfloat (*)[4]) out->start;
-   GLuint count = VB->Count;
-   GLuint i;
-   GLfloat (*f)[3] = store->tmp_f;
-   GLfloat *m = store->tmp_m;
-
-   (build_m_tab[VB->EyePtr->size])( store->tmp_f,
-				    store->tmp_m,
-				    VB->AttribPtr[_TNL_ATTRIB_NORMAL],
-				    VB->EyePtr );
-
-   out->size = MAX2(in->size,2);
-
-   for (i=0;i<count;i++) {
-      texcoord[i][0] = f[i][0] * m[i] + 0.5F;
-      texcoord[i][1] = f[i][1] * m[i] + 0.5F;
-   }
-
-   out->count = count;
-   out->flags |= (in->flags & VEC_SIZE_FLAGS) | VEC_SIZE_2;
-   if (in->size > 2)
-      _mesa_copy_tab[all_bits[in->size] & ~0x3]( out, in );
-}
-
-
-
-static void texgen( struct gl_context *ctx,
-		    struct texgen_stage_data *store,
-		    GLuint unit )
-{
-   TNLcontext *tnl = TNL_CONTEXT(ctx);
-   struct vertex_buffer *VB = &tnl->vb;
-   GLvector4f *in = VB->AttribPtr[VERT_ATTRIB_TEX0 + unit];
-   GLvector4f *out = &store->texcoord[unit];
-   const struct gl_texture_unit *texUnit = &ctx->Texture.Unit[unit];
-   const GLvector4f *obj = VB->AttribPtr[_TNL_ATTRIB_POS];
-   const GLvector4f *eye = VB->EyePtr;
-   const GLvector4f *normal = VB->AttribPtr[_TNL_ATTRIB_NORMAL];
-   const GLfloat *m = store->tmp_m;
-   const GLuint count = VB->Count;
-   GLfloat (*texcoord)[4] = (GLfloat (*)[4])out->data;
-   GLfloat (*f)[3] = store->tmp_f;
-   GLuint copy;
-
-   if (texUnit->_GenFlags & TEXGEN_NEED_M) {
-      build_m_tab[eye->size]( store->tmp_f, store->tmp_m, normal, eye );
-   } else if (texUnit->_GenFlags & TEXGEN_NEED_F) {
-      build_f_tab[eye->size]( (GLfloat *)store->tmp_f, 3, normal, eye );
-   }
-
-
-   out->size = MAX2(in->size, store->TexgenSize[unit]);
-   out->flags |= (in->flags & VEC_SIZE_FLAGS) | texUnit->TexGenEnabled;
-   out->count = count;
-
-   copy = (all_bits[in->size] & ~texUnit->TexGenEnabled);
-   if (copy)
-      _mesa_copy_tab[copy]( out, in );
-
-   if (texUnit->TexGenEnabled & S_BIT) {
-      GLuint i;
-      switch (texUnit->GenS.Mode) {
-      case GL_OBJECT_LINEAR:
-	 _mesa_dotprod_tab[obj->size]( (GLfloat *)out->data,
-				       sizeof(out->data[0]), obj,
-				       texUnit->GenS.ObjectPlane );
-	 break;
-      case GL_EYE_LINEAR:
-	 _mesa_dotprod_tab[eye->size]( (GLfloat *)out->data,
-				       sizeof(out->data[0]), eye,
-				       texUnit->GenS.EyePlane );
-	 break;
-      case GL_SPHERE_MAP:
-         for (i = 0; i < count; i++)
-            texcoord[i][0] = f[i][0] * m[i] + 0.5F;
-	 break;
-      case GL_REFLECTION_MAP_NV:
-	 for (i=0;i<count;i++)
-	     texcoord[i][0] = f[i][0];
-	 break;
-      case GL_NORMAL_MAP_NV: {
-	 const GLfloat *norm = normal->start;
-	 for (i=0;i<count;i++, STRIDE_F(norm, normal->stride)) {
-	     texcoord[i][0] = norm[0];
-	 }
-	 break;
-      }
-      default:
-	 _mesa_problem(ctx, "Bad S texgen");
-      }
-   }
-
-   if (texUnit->TexGenEnabled & T_BIT) {
-      GLuint i;
-      switch (texUnit->GenT.Mode) {
-      case GL_OBJECT_LINEAR:
-	 _mesa_dotprod_tab[obj->size]( &(out->data[0][1]),
-				       sizeof(out->data[0]), obj,
-				       texUnit->GenT.ObjectPlane );
-	 break;
-      case GL_EYE_LINEAR:
-	 _mesa_dotprod_tab[eye->size]( &(out->data[0][1]),
-				       sizeof(out->data[0]), eye,
-				       texUnit->GenT.EyePlane );
-	 break;
-      case GL_SPHERE_MAP:
-         for (i = 0; i < count; i++)
-            texcoord[i][1] = f[i][1] * m[i] + 0.5F;
-	 break;
-      case GL_REFLECTION_MAP_NV:
-	 for (i=0;i<count;i++)
-	     texcoord[i][1] = f[i][1];
-	 break;
-      case GL_NORMAL_MAP_NV: {
-	 const GLfloat *norm = normal->start;
-	 for (i=0;i<count;i++, STRIDE_F(norm, normal->stride)) {
-	     texcoord[i][1] = norm[1];
-	 }
-	 break;
-      }
-      default:
-	 _mesa_problem(ctx, "Bad T texgen");
-      }
-   }
-
-   if (texUnit->TexGenEnabled & R_BIT) {
-      GLuint i;
-      switch (texUnit->GenR.Mode) {
-      case GL_OBJECT_LINEAR:
-	 _mesa_dotprod_tab[obj->size]( &(out->data[0][2]),
-				       sizeof(out->data[0]), obj,
-				       texUnit->GenR.ObjectPlane );
-	 break;
-      case GL_EYE_LINEAR:
-	 _mesa_dotprod_tab[eye->size]( &(out->data[0][2]),
-				       sizeof(out->data[0]), eye,
-				       texUnit->GenR.EyePlane );
-	 break;
-      case GL_REFLECTION_MAP_NV:
-	 for (i=0;i<count;i++)
-	     texcoord[i][2] = f[i][2];
-	 break;
-      case GL_NORMAL_MAP_NV: {
-	 const GLfloat *norm = normal->start;
-	 for (i=0;i<count;i++,STRIDE_F(norm, normal->stride)) {
-	     texcoord[i][2] = norm[2];
-	 }
-	 break;
-      }
-      default:
-	 _mesa_problem(ctx, "Bad R texgen");
-      }
-   }
-
-   if (texUnit->TexGenEnabled & Q_BIT) {
-      switch (texUnit->GenQ.Mode) {
-      case GL_OBJECT_LINEAR:
-	 _mesa_dotprod_tab[obj->size]( &(out->data[0][3]),
-				       sizeof(out->data[0]), obj,
-				       texUnit->GenQ.ObjectPlane );
-	 break;
-      case GL_EYE_LINEAR:
-	 _mesa_dotprod_tab[eye->size]( &(out->data[0][3]),
-				       sizeof(out->data[0]), eye,
-				       texUnit->GenQ.EyePlane );
-	 break;
-      default:
-	 _mesa_problem(ctx, "Bad Q texgen");
-      }
-   }
-}
-
-
-
-
-static GLboolean run_texgen_stage( struct gl_context *ctx,
-				   struct tnl_pipeline_stage *stage )
-{
-   struct vertex_buffer *VB = &TNL_CONTEXT(ctx)->vb;
-   struct texgen_stage_data *store = TEXGEN_STAGE_DATA(stage);
-   GLuint i;
-
-   if (!ctx->Texture._TexGenEnabled || ctx->VertexProgram._Current) 
-      return GL_TRUE;
-
-   for (i = 0 ; i < ctx->Const.MaxTextureCoordUnits ; i++) {
-      struct gl_texture_unit *texUnit = &ctx->Texture.Unit[i];
-
-      if (texUnit->TexGenEnabled) {
-
-	 store->TexgenFunc[i]( ctx, store, i );
-
-         VB->AttribPtr[VERT_ATTRIB_TEX0 + i] = &store->texcoord[i];
-      }
-   }
-
-   return GL_TRUE;
-}
-
-
-static void validate_texgen_stage( struct gl_context *ctx,
-				   struct tnl_pipeline_stage *stage )
-{
-   struct texgen_stage_data *store = TEXGEN_STAGE_DATA(stage);
-   GLuint i;
-
-   if (!ctx->Texture._TexGenEnabled || ctx->VertexProgram._Current) 
-      return;
-
-   for (i = 0 ; i < ctx->Const.MaxTextureCoordUnits ; i++) {
-      struct gl_texture_unit *texUnit = &ctx->Texture.Unit[i];
-
-      if (texUnit->TexGenEnabled) {
-	 GLuint sz;
-
-	 if (texUnit->TexGenEnabled & Q_BIT)
-	    sz = 4;
-	 else if (texUnit->TexGenEnabled & R_BIT)
-	    sz = 3;
-	 else if (texUnit->TexGenEnabled & T_BIT)
-	    sz = 2;
-	 else
-	    sz = 1;
-
-	 store->TexgenSize[i] = sz;
-	 store->TexgenFunc[i] = texgen; /* general solution */
-
-         /* look for special texgen cases */
-	 if (texUnit->TexGenEnabled == (S_BIT|T_BIT|R_BIT)) {
-	    if (texUnit->_GenFlags == TEXGEN_REFLECTION_MAP_NV) {
-	       store->TexgenFunc[i] = texgen_reflection_map_nv;
-	    }
-	    else if (texUnit->_GenFlags == TEXGEN_NORMAL_MAP_NV) {
-	       store->TexgenFunc[i] = texgen_normal_map_nv;
-	    }
-	 }
-	 else if (texUnit->TexGenEnabled == (S_BIT|T_BIT) &&
-		  texUnit->_GenFlags == TEXGEN_SPHERE_MAP) {
-	    store->TexgenFunc[i] = texgen_sphere_map;
-	 }
-      }
-   }
-}
-
-
-
-
-
-/* Called the first time stage->run() is invoked.
- */
-static GLboolean alloc_texgen_data( struct gl_context *ctx,
-				    struct tnl_pipeline_stage *stage )
-{
-   struct vertex_buffer *VB = &TNL_CONTEXT(ctx)->vb;
-   struct texgen_stage_data *store;
-   GLuint i;
-
-   stage->privatePtr = CALLOC(sizeof(*store));
-   store = TEXGEN_STAGE_DATA(stage);
-   if (!store)
-      return GL_FALSE;
-
-   for (i = 0 ; i < ctx->Const.MaxTextureCoordUnits ; i++)
-      _mesa_vector4f_alloc( &store->texcoord[i], 0, VB->Size, 32 );
-
-   store->tmp_f = (GLfloat (*)[3]) MALLOC(VB->Size * sizeof(GLfloat) * 3);
-   store->tmp_m = (GLfloat *) MALLOC(VB->Size * sizeof(GLfloat));
-
-   return GL_TRUE;
-}
-
-
-static void free_texgen_data( struct tnl_pipeline_stage *stage )
-
-{
-   struct texgen_stage_data *store = TEXGEN_STAGE_DATA(stage);
-   GLuint i;
-
-   if (store) {
-      for (i = 0 ; i < MAX_TEXTURE_COORD_UNITS ; i++)
-	 if (store->texcoord[i].data)
-	    _mesa_vector4f_free( &store->texcoord[i] );
-
-
-      if (store->tmp_f) FREE( store->tmp_f );
-      if (store->tmp_m) FREE( store->tmp_m );
-      FREE( store );
-      stage->privatePtr = NULL;
-   }
-}
-
-
-
-const struct tnl_pipeline_stage _tnl_texgen_stage =
-{
-   "texgen",			/* name */
-   NULL,			/* private data */
-   alloc_texgen_data,		/* destructor */
-   free_texgen_data,		/* destructor */
-   validate_texgen_stage,		/* check */
-   run_texgen_stage		/* run -- initially set to alloc data */
-};
+/*
+ * Mesa 3-D graphics library
+ * Version:  6.5
+ *
+ * Copyright (C) 1999-2006  Brian Paul   All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * BRIAN PAUL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
+ * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ *
+ * Authors:
+ *    Brian Paul
+ *    Keith Whitwell <keith@tungstengraphics.com>
+ */
+
+/*
+ * Regarding GL_NV_texgen_reflection:
+ *
+ * Portions of this software may use or implement intellectual
+ * property owned and licensed by NVIDIA Corporation. NVIDIA disclaims
+ * any and all warranties with respect to such intellectual property,
+ * including any use thereof or modifications thereto.
+ */
+
+#include "main/glheader.h"
+#include "main/colormac.h"
+#include "main/macros.h"
+#include "main/imports.h"
+#include "main/mtypes.h"
+
+#include "math/m_xform.h"
+
+#include "t_context.h"
+#include "t_pipeline.h"
+
+
+/***********************************************************************
+ * Automatic texture coordinate generation (texgen) code.
+ */
+
+
+struct texgen_stage_data;
+
+typedef void (*texgen_func)( struct gl_context *ctx,
+			     struct texgen_stage_data *store,
+			     GLuint unit);
+
+
+struct texgen_stage_data {
+
+   /* Per-texunit derived state.
+    */
+   GLuint TexgenSize[MAX_TEXTURE_COORD_UNITS];
+   texgen_func TexgenFunc[MAX_TEXTURE_COORD_UNITS];
+
+   /* Temporary values used in texgen.
+    */
+   GLfloat (*tmp_f)[3];
+   GLfloat *tmp_m;
+
+   /* Buffered outputs of the stage.
+    */
+   GLvector4f texcoord[MAX_TEXTURE_COORD_UNITS];
+};
+
+
+#define TEXGEN_STAGE_DATA(stage) ((struct texgen_stage_data *)stage->privatePtr)
+
+
+
+static GLuint all_bits[5] = {
+   0,
+   VEC_SIZE_1,
+   VEC_SIZE_2,
+   VEC_SIZE_3,
+   VEC_SIZE_4,
+};
+
+#define VEC_SIZE_FLAGS (VEC_SIZE_1|VEC_SIZE_2|VEC_SIZE_3|VEC_SIZE_4)
+
+#define TEXGEN_NEED_M            (TEXGEN_SPHERE_MAP)
+#define TEXGEN_NEED_F            (TEXGEN_SPHERE_MAP        | \
+				  TEXGEN_REFLECTION_MAP_NV)
+
+
+
+static void build_m3( GLfloat f[][3], GLfloat m[],
+		      const GLvector4f *normal,
+		      const GLvector4f *eye )
+{
+   GLuint stride = eye->stride;
+   GLfloat *coord = (GLfloat *)eye->start;
+   GLuint count = eye->count;
+   const GLfloat *norm = normal->start;
+   GLuint i;
+
+   for (i=0;i<count;i++,STRIDE_F(coord,stride),STRIDE_F(norm,normal->stride)) {
+      GLfloat u[3], two_nu, fx, fy, fz;
+      COPY_3V( u, coord );
+      NORMALIZE_3FV( u );
+      two_nu = 2.0F * DOT3(norm,u);
+      fx = f[i][0] = u[0] - norm[0] * two_nu;
+      fy = f[i][1] = u[1] - norm[1] * two_nu;
+      fz = f[i][2] = u[2] - norm[2] * two_nu;
+      m[i] = fx * fx + fy * fy + (fz + 1.0F) * (fz + 1.0F);
+      if (m[i] != 0.0F) {
+	 m[i] = 0.5F * _mesa_inv_sqrtf(m[i]);
+      }
+   }
+}
+
+
+
+static void build_m2( GLfloat f[][3], GLfloat m[],
+		      const GLvector4f *normal,
+		      const GLvector4f *eye )
+{
+   GLuint stride = eye->stride;
+   GLfloat *coord = eye->start;
+   GLuint count = eye->count;
+
+   GLfloat *norm = normal->start;
+   GLuint i;
+
+   for (i=0;i<count;i++,STRIDE_F(coord,stride),STRIDE_F(norm,normal->stride)) {
+      GLfloat u[3], two_nu, fx, fy, fz;
+      COPY_2V( u, coord );
+      u[2] = 0;
+      NORMALIZE_3FV( u );
+      two_nu = 2.0F * DOT3(norm,u);
+      fx = f[i][0] = u[0] - norm[0] * two_nu;
+      fy = f[i][1] = u[1] - norm[1] * two_nu;
+      fz = f[i][2] = u[2] - norm[2] * two_nu;
+      m[i] = fx * fx + fy * fy + (fz + 1.0F) * (fz + 1.0F);
+      if (m[i] != 0.0F) {
+	 m[i] = 0.5F * _mesa_inv_sqrtf(m[i]);
+      }
+   }
+}
+
+
+
+typedef void (*build_m_func)( GLfloat f[][3],
+			      GLfloat m[],
+			      const GLvector4f *normal,
+			      const GLvector4f *eye );
+
+
+static build_m_func build_m_tab[5] = {
+   NULL,
+   NULL,
+   build_m2,
+   build_m3,
+   build_m3
+};
+
+
+/* This is unusual in that we respect the stride of the output vector
+ * (f).  This allows us to pass in either a texcoord vector4f, or a
+ * temporary vector3f.
+ */
+static void build_f3( GLfloat *f,
+		      GLuint fstride,
+		      const GLvector4f *normal,
+		      const GLvector4f *eye )
+{
+   GLuint stride = eye->stride;
+   GLfloat *coord = eye->start;
+   GLuint count = eye->count;
+
+   GLfloat *norm = normal->start;
+   GLuint i;
+
+   for (i=0;i<count;i++) {
+      GLfloat u[3], two_nu;
+      COPY_3V( u, coord );
+      NORMALIZE_3FV( u );
+      two_nu = 2.0F * DOT3(norm,u);
+      f[0] = u[0] - norm[0] * two_nu;
+      f[1] = u[1] - norm[1] * two_nu;
+      f[2] = u[2] - norm[2] * two_nu;
+      STRIDE_F(coord,stride);
+      STRIDE_F(f,fstride);
+      STRIDE_F(norm, normal->stride);
+   }
+}
+
+
+static void build_f2( GLfloat *f,
+		      GLuint fstride,
+		      const GLvector4f *normal,
+		      const GLvector4f *eye )
+{
+   GLuint stride = eye->stride;
+   GLfloat *coord = eye->start;
+   GLuint count = eye->count;
+   GLfloat *norm = normal->start;
+   GLuint i;
+
+   for (i=0;i<count;i++) {
+
+      GLfloat u[3], two_nu;
+      COPY_2V( u, coord );
+      u[2] = 0;
+      NORMALIZE_3FV( u );
+      two_nu = 2.0F * DOT3(norm,u);
+      f[0] = u[0] - norm[0] * two_nu;
+      f[1] = u[1] - norm[1] * two_nu;
+      f[2] = u[2] - norm[2] * two_nu;
+
+      STRIDE_F(coord,stride);
+      STRIDE_F(f,fstride);
+      STRIDE_F(norm, normal->stride);
+   }
+}
+
+typedef void (*build_f_func)( GLfloat *f,
+			      GLuint fstride,
+			      const GLvector4f *normal_vec,
+			      const GLvector4f *eye );
+
+
+
+/* Just treat 4-vectors as 3-vectors.
+ */
+static build_f_func build_f_tab[5] = {
+   NULL,
+   NULL,
+   build_f2,
+   build_f3,
+   build_f3
+};
+
+
+
+/* Special case texgen functions.
+ */
+static void texgen_reflection_map_nv( struct gl_context *ctx,
+				      struct texgen_stage_data *store,
+				      GLuint unit )
+{
+   struct vertex_buffer *VB = &TNL_CONTEXT(ctx)->vb;
+   GLvector4f *in = VB->AttribPtr[VERT_ATTRIB_TEX0 + unit];
+   GLvector4f *out = &store->texcoord[unit];
+
+   build_f_tab[VB->EyePtr->size]( out->start,
+				  out->stride,
+				  VB->AttribPtr[_TNL_ATTRIB_NORMAL],
+				  VB->EyePtr );
+
+   out->flags |= (in->flags & VEC_SIZE_FLAGS) | VEC_SIZE_3;
+   out->count = VB->Count;
+   out->size = MAX2(in->size, 3);
+   if (in->size == 4) 
+      _mesa_copy_tab[0x8]( out, in );
+}
+
+
+
+static void texgen_normal_map_nv( struct gl_context *ctx,
+				  struct texgen_stage_data *store,
+				  GLuint unit )
+{
+   struct vertex_buffer *VB = &TNL_CONTEXT(ctx)->vb;
+   GLvector4f *in = VB->AttribPtr[VERT_ATTRIB_TEX0 + unit];
+   GLvector4f *out = &store->texcoord[unit];
+   GLvector4f *normal = VB->AttribPtr[_TNL_ATTRIB_NORMAL];
+   GLfloat (*texcoord)[4] = (GLfloat (*)[4])out->start;
+   GLuint count = VB->Count;
+   GLuint i;
+   const GLfloat *norm = normal->start;
+
+   for (i=0;i<count;i++, STRIDE_F(norm, normal->stride)) {
+      texcoord[i][0] = norm[0];
+      texcoord[i][1] = norm[1];
+      texcoord[i][2] = norm[2];
+   }
+
+
+   out->flags |= (in->flags & VEC_SIZE_FLAGS) | VEC_SIZE_3;
+   out->count = count;
+   out->size = MAX2(in->size, 3);
+   if (in->size == 4) 
+      _mesa_copy_tab[0x8]( out, in );
+}
+
+
+static void texgen_sphere_map( struct gl_context *ctx,
+			       struct texgen_stage_data *store,
+			       GLuint unit )
+{
+   struct vertex_buffer *VB = &TNL_CONTEXT(ctx)->vb;
+   GLvector4f *in = VB->AttribPtr[VERT_ATTRIB_TEX0 + unit];
+   GLvector4f *out = &store->texcoord[unit];
+   GLfloat (*texcoord)[4] = (GLfloat (*)[4]) out->start;
+   GLuint count = VB->Count;
+   GLuint i;
+   GLfloat (*f)[3] = store->tmp_f;
+   GLfloat *m = store->tmp_m;
+
+   (build_m_tab[VB->EyePtr->size])( store->tmp_f,
+				    store->tmp_m,
+				    VB->AttribPtr[_TNL_ATTRIB_NORMAL],
+				    VB->EyePtr );
+
+   out->size = MAX2(in->size,2);
+
+   for (i=0;i<count;i++) {
+      texcoord[i][0] = f[i][0] * m[i] + 0.5F;
+      texcoord[i][1] = f[i][1] * m[i] + 0.5F;
+   }
+
+   out->count = count;
+   out->flags |= (in->flags & VEC_SIZE_FLAGS) | VEC_SIZE_2;
+   if (in->size > 2)
+      _mesa_copy_tab[all_bits[in->size] & ~0x3]( out, in );
+}
+
+
+
+static void texgen( struct gl_context *ctx,
+		    struct texgen_stage_data *store,
+		    GLuint unit )
+{
+   TNLcontext *tnl = TNL_CONTEXT(ctx);
+   struct vertex_buffer *VB = &tnl->vb;
+   GLvector4f *in = VB->AttribPtr[VERT_ATTRIB_TEX0 + unit];
+   GLvector4f *out = &store->texcoord[unit];
+   const struct gl_texture_unit *texUnit = &ctx->Texture.Unit[unit];
+   const GLvector4f *obj = VB->AttribPtr[_TNL_ATTRIB_POS];
+   const GLvector4f *eye = VB->EyePtr;
+   const GLvector4f *normal = VB->AttribPtr[_TNL_ATTRIB_NORMAL];
+   const GLfloat *m = store->tmp_m;
+   const GLuint count = VB->Count;
+   GLfloat (*texcoord)[4] = (GLfloat (*)[4])out->data;
+   GLfloat (*f)[3] = store->tmp_f;
+   GLuint copy;
+
+   if (texUnit->_GenFlags & TEXGEN_NEED_M) {
+      build_m_tab[eye->size]( store->tmp_f, store->tmp_m, normal, eye );
+   } else if (texUnit->_GenFlags & TEXGEN_NEED_F) {
+      build_f_tab[eye->size]( (GLfloat *)store->tmp_f, 3, normal, eye );
+   }
+
+
+   out->size = MAX2(in->size, store->TexgenSize[unit]);
+   out->flags |= (in->flags & VEC_SIZE_FLAGS) | texUnit->TexGenEnabled;
+   out->count = count;
+
+   copy = (all_bits[in->size] & ~texUnit->TexGenEnabled);
+   if (copy)
+      _mesa_copy_tab[copy]( out, in );
+
+   if (texUnit->TexGenEnabled & S_BIT) {
+      GLuint i;
+      switch (texUnit->GenS.Mode) {
+      case GL_OBJECT_LINEAR:
+	 _mesa_dotprod_tab[obj->size]( (GLfloat *)out->data,
+				       sizeof(out->data[0]), obj,
+				       texUnit->GenS.ObjectPlane );
+	 break;
+      case GL_EYE_LINEAR:
+	 _mesa_dotprod_tab[eye->size]( (GLfloat *)out->data,
+				       sizeof(out->data[0]), eye,
+				       texUnit->GenS.EyePlane );
+	 break;
+      case GL_SPHERE_MAP:
+         for (i = 0; i < count; i++)
+            texcoord[i][0] = f[i][0] * m[i] + 0.5F;
+	 break;
+      case GL_REFLECTION_MAP_NV:
+	 for (i=0;i<count;i++)
+	     texcoord[i][0] = f[i][0];
+	 break;
+      case GL_NORMAL_MAP_NV: {
+	 const GLfloat *norm = normal->start;
+	 for (i=0;i<count;i++, STRIDE_F(norm, normal->stride)) {
+	     texcoord[i][0] = norm[0];
+	 }
+	 break;
+      }
+      default:
+	 _mesa_problem(ctx, "Bad S texgen");
+      }
+   }
+
+   if (texUnit->TexGenEnabled & T_BIT) {
+      GLuint i;
+      switch (texUnit->GenT.Mode) {
+      case GL_OBJECT_LINEAR:
+	 _mesa_dotprod_tab[obj->size]( &(out->data[0][1]),
+				       sizeof(out->data[0]), obj,
+				       texUnit->GenT.ObjectPlane );
+	 break;
+      case GL_EYE_LINEAR:
+	 _mesa_dotprod_tab[eye->size]( &(out->data[0][1]),
+				       sizeof(out->data[0]), eye,
+				       texUnit->GenT.EyePlane );
+	 break;
+      case GL_SPHERE_MAP:
+         for (i = 0; i < count; i++)
+            texcoord[i][1] = f[i][1] * m[i] + 0.5F;
+	 break;
+      case GL_REFLECTION_MAP_NV:
+	 for (i=0;i<count;i++)
+	     texcoord[i][1] = f[i][1];
+	 break;
+      case GL_NORMAL_MAP_NV: {
+	 const GLfloat *norm = normal->start;
+	 for (i=0;i<count;i++, STRIDE_F(norm, normal->stride)) {
+	     texcoord[i][1] = norm[1];
+	 }
+	 break;
+      }
+      default:
+	 _mesa_problem(ctx, "Bad T texgen");
+      }
+   }
+
+   if (texUnit->TexGenEnabled & R_BIT) {
+      GLuint i;
+      switch (texUnit->GenR.Mode) {
+      case GL_OBJECT_LINEAR:
+	 _mesa_dotprod_tab[obj->size]( &(out->data[0][2]),
+				       sizeof(out->data[0]), obj,
+				       texUnit->GenR.ObjectPlane );
+	 break;
+      case GL_EYE_LINEAR:
+	 _mesa_dotprod_tab[eye->size]( &(out->data[0][2]),
+				       sizeof(out->data[0]), eye,
+				       texUnit->GenR.EyePlane );
+	 break;
+      case GL_REFLECTION_MAP_NV:
+	 for (i=0;i<count;i++)
+	     texcoord[i][2] = f[i][2];
+	 break;
+      case GL_NORMAL_MAP_NV: {
+	 const GLfloat *norm = normal->start;
+	 for (i=0;i<count;i++,STRIDE_F(norm, normal->stride)) {
+	     texcoord[i][2] = norm[2];
+	 }
+	 break;
+      }
+      default:
+	 _mesa_problem(ctx, "Bad R texgen");
+      }
+   }
+
+   if (texUnit->TexGenEnabled & Q_BIT) {
+      switch (texUnit->GenQ.Mode) {
+      case GL_OBJECT_LINEAR:
+	 _mesa_dotprod_tab[obj->size]( &(out->data[0][3]),
+				       sizeof(out->data[0]), obj,
+				       texUnit->GenQ.ObjectPlane );
+	 break;
+      case GL_EYE_LINEAR:
+	 _mesa_dotprod_tab[eye->size]( &(out->data[0][3]),
+				       sizeof(out->data[0]), eye,
+				       texUnit->GenQ.EyePlane );
+	 break;
+      default:
+	 _mesa_problem(ctx, "Bad Q texgen");
+      }
+   }
+}
+
+
+
+
+static GLboolean run_texgen_stage( struct gl_context *ctx,
+				   struct tnl_pipeline_stage *stage )
+{
+   struct vertex_buffer *VB = &TNL_CONTEXT(ctx)->vb;
+   struct texgen_stage_data *store = TEXGEN_STAGE_DATA(stage);
+   GLuint i;
+
+   if (!ctx->Texture._TexGenEnabled || ctx->VertexProgram._Current) 
+      return GL_TRUE;
+
+   for (i = 0 ; i < ctx->Const.MaxTextureCoordUnits ; i++) {
+      struct gl_texture_unit *texUnit = &ctx->Texture.Unit[i];
+
+      if (texUnit->TexGenEnabled) {
+
+	 store->TexgenFunc[i]( ctx, store, i );
+
+         VB->AttribPtr[VERT_ATTRIB_TEX0 + i] = &store->texcoord[i];
+      }
+   }
+
+   return GL_TRUE;
+}
+
+
+static void validate_texgen_stage( struct gl_context *ctx,
+				   struct tnl_pipeline_stage *stage )
+{
+   struct texgen_stage_data *store = TEXGEN_STAGE_DATA(stage);
+   GLuint i;
+
+   if (!ctx->Texture._TexGenEnabled || ctx->VertexProgram._Current) 
+      return;
+
+   for (i = 0 ; i < ctx->Const.MaxTextureCoordUnits ; i++) {
+      struct gl_texture_unit *texUnit = &ctx->Texture.Unit[i];
+
+      if (texUnit->TexGenEnabled) {
+	 GLuint sz;
+
+	 if (texUnit->TexGenEnabled & Q_BIT)
+	    sz = 4;
+	 else if (texUnit->TexGenEnabled & R_BIT)
+	    sz = 3;
+	 else if (texUnit->TexGenEnabled & T_BIT)
+	    sz = 2;
+	 else
+	    sz = 1;
+
+	 store->TexgenSize[i] = sz;
+	 store->TexgenFunc[i] = texgen; /* general solution */
+
+         /* look for special texgen cases */
+	 if (texUnit->TexGenEnabled == (S_BIT|T_BIT|R_BIT)) {
+	    if (texUnit->_GenFlags == TEXGEN_REFLECTION_MAP_NV) {
+	       store->TexgenFunc[i] = texgen_reflection_map_nv;
+	    }
+	    else if (texUnit->_GenFlags == TEXGEN_NORMAL_MAP_NV) {
+	       store->TexgenFunc[i] = texgen_normal_map_nv;
+	    }
+	 }
+	 else if (texUnit->TexGenEnabled == (S_BIT|T_BIT) &&
+		  texUnit->_GenFlags == TEXGEN_SPHERE_MAP) {
+	    store->TexgenFunc[i] = texgen_sphere_map;
+	 }
+      }
+   }
+}
+
+
+
+
+
+/* Called the first time stage->run() is invoked.
+ */
+static GLboolean alloc_texgen_data( struct gl_context *ctx,
+				    struct tnl_pipeline_stage *stage )
+{
+   struct vertex_buffer *VB = &TNL_CONTEXT(ctx)->vb;
+   struct texgen_stage_data *store;
+   GLuint i;
+
+   stage->privatePtr = CALLOC(sizeof(*store));
+   store = TEXGEN_STAGE_DATA(stage);
+   if (!store)
+      return GL_FALSE;
+
+   for (i = 0 ; i < ctx->Const.MaxTextureCoordUnits ; i++)
+      _mesa_vector4f_alloc( &store->texcoord[i], 0, VB->Size, 32 );
+
+   store->tmp_f = (GLfloat (*)[3]) MALLOC(VB->Size * sizeof(GLfloat) * 3);
+   store->tmp_m = (GLfloat *) MALLOC(VB->Size * sizeof(GLfloat));
+
+   return GL_TRUE;
+}
+
+
+static void free_texgen_data( struct tnl_pipeline_stage *stage )
+
+{
+   struct texgen_stage_data *store = TEXGEN_STAGE_DATA(stage);
+   GLuint i;
+
+   if (store) {
+      for (i = 0 ; i < MAX_TEXTURE_COORD_UNITS ; i++)
+	 if (store->texcoord[i].data)
+	    _mesa_vector4f_free( &store->texcoord[i] );
+
+
+      if (store->tmp_f) FREE( store->tmp_f );
+      if (store->tmp_m) FREE( store->tmp_m );
+      FREE( store );
+      stage->privatePtr = NULL;
+   }
+}
+
+
+
+const struct tnl_pipeline_stage _tnl_texgen_stage =
+{
+   "texgen",			/* name */
+   NULL,			/* private data */
+   alloc_texgen_data,		/* destructor */
+   free_texgen_data,		/* destructor */
+   validate_texgen_stage,		/* check */
+   run_texgen_stage		/* run -- initially set to alloc data */
+};
diff --git a/mesalib/src/mesa/tnl/t_vb_texmat.c b/mesalib/src/mesa/tnl/t_vb_texmat.c
index 7b30946c8..38aa51fc4 100644
--- a/mesalib/src/mesa/tnl/t_vb_texmat.c
+++ b/mesalib/src/mesa/tnl/t_vb_texmat.c
@@ -1,128 +1,128 @@
-/*
- * Mesa 3-D graphics library
- * Version:  6.5
- *
- * Copyright (C) 1999-2006  Brian Paul   All Rights Reserved.
- *
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the "Software"),
- * to deal in the Software without restriction, including without limitation
- * the rights to use, copy, modify, merge, publish, distribute, sublicense,
- * and/or sell copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included
- * in all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
- * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
- * BRIAN PAUL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
- * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
- * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
- *
- * Authors:
- *    Keith Whitwell <keith@tungstengraphics.com>
- */
-
-
-#include "main/glheader.h"
-#include "main/colormac.h"
-#include "main/macros.h"
-#include "main/imports.h"
-#include "main/mtypes.h"
-
-#include "math/m_xform.h"
-
-#include "t_context.h"
-#include "t_pipeline.h"
-
-/* Is there any real benefit seperating texmat from texgen?  It means
- * we need two lots of intermediate storage.  Any changes to
- * _NEW_TEXTURE will invalidate both sets -- it's only on changes to
- * *only* _NEW_TEXTURE_MATRIX that texgen survives but texmat doesn't.
- *
- * However, the seperation of this code from the complex texgen stuff
- * is very appealing.
- */
-struct texmat_stage_data {
-   GLvector4f texcoord[MAX_TEXTURE_COORD_UNITS];
-};
-
-#define TEXMAT_STAGE_DATA(stage) ((struct texmat_stage_data *)stage->privatePtr)
-
-
-
-static GLboolean run_texmat_stage( struct gl_context *ctx,
-				   struct tnl_pipeline_stage *stage )
-{
-   struct texmat_stage_data *store = TEXMAT_STAGE_DATA(stage);
-   struct vertex_buffer *VB = &TNL_CONTEXT(ctx)->vb;
-   GLuint i;
-
-   if (!ctx->Texture._TexMatEnabled || ctx->VertexProgram._Current) 
-      return GL_TRUE;
-
-   /* ENABLE_TEXMAT implies that the texture matrix is not the
-    * identity, so we don't have to check that here.
-    */
-   for (i = 0 ; i < ctx->Const.MaxTextureCoordUnits ; i++) {
-      if (ctx->Texture._TexMatEnabled & ENABLE_TEXMAT(i)) {
-	 (void) TransformRaw( &store->texcoord[i],
-			      ctx->TextureMatrixStack[i].Top,
-			      VB->AttribPtr[_TNL_ATTRIB_TEX0 + i]);
-
-	 VB->AttribPtr[VERT_ATTRIB_TEX0+i] = &store->texcoord[i];
-      }
-   }
-
-   return GL_TRUE;
-}
-
-
-/* Called the first time stage->run() is invoked.
- */
-static GLboolean alloc_texmat_data( struct gl_context *ctx,
-				    struct tnl_pipeline_stage *stage )
-{
-   struct vertex_buffer *VB = &TNL_CONTEXT(ctx)->vb;
-   struct texmat_stage_data *store;
-   GLuint i;
-
-   stage->privatePtr = CALLOC(sizeof(*store));
-   store = TEXMAT_STAGE_DATA(stage);
-   if (!store)
-      return GL_FALSE;
-
-   for (i = 0 ; i < ctx->Const.MaxTextureCoordUnits ; i++)
-      _mesa_vector4f_alloc( &store->texcoord[i], 0, VB->Size, 32 );
-
-   return GL_TRUE;
-}
-
-
-static void free_texmat_data( struct tnl_pipeline_stage *stage )
-{
-   struct texmat_stage_data *store = TEXMAT_STAGE_DATA(stage);
-   GLuint i;
-
-   if (store) {
-      for (i = 0; i < MAX_TEXTURE_COORD_UNITS; i++)
-	 if (store->texcoord[i].data)
-	    _mesa_vector4f_free( &store->texcoord[i] );
-      FREE( store );
-      stage->privatePtr = NULL;
-   }
-}
-
-
-
-const struct tnl_pipeline_stage _tnl_texture_transform_stage =
-{
-   "texture transform",			/* name */
-   NULL,				/* private data */
-   alloc_texmat_data,
-   free_texmat_data,			/* destructor */
-   NULL,
-   run_texmat_stage,
-};
+/*
+ * Mesa 3-D graphics library
+ * Version:  6.5
+ *
+ * Copyright (C) 1999-2006  Brian Paul   All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * BRIAN PAUL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
+ * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ *
+ * Authors:
+ *    Keith Whitwell <keith@tungstengraphics.com>
+ */
+
+
+#include "main/glheader.h"
+#include "main/colormac.h"
+#include "main/macros.h"
+#include "main/imports.h"
+#include "main/mtypes.h"
+
+#include "math/m_xform.h"
+
+#include "t_context.h"
+#include "t_pipeline.h"
+
+/* Is there any real benefit seperating texmat from texgen?  It means
+ * we need two lots of intermediate storage.  Any changes to
+ * _NEW_TEXTURE will invalidate both sets -- it's only on changes to
+ * *only* _NEW_TEXTURE_MATRIX that texgen survives but texmat doesn't.
+ *
+ * However, the seperation of this code from the complex texgen stuff
+ * is very appealing.
+ */
+struct texmat_stage_data {
+   GLvector4f texcoord[MAX_TEXTURE_COORD_UNITS];
+};
+
+#define TEXMAT_STAGE_DATA(stage) ((struct texmat_stage_data *)stage->privatePtr)
+
+
+
+static GLboolean run_texmat_stage( struct gl_context *ctx,
+				   struct tnl_pipeline_stage *stage )
+{
+   struct texmat_stage_data *store = TEXMAT_STAGE_DATA(stage);
+   struct vertex_buffer *VB = &TNL_CONTEXT(ctx)->vb;
+   GLuint i;
+
+   if (!ctx->Texture._TexMatEnabled || ctx->VertexProgram._Current) 
+      return GL_TRUE;
+
+   /* ENABLE_TEXMAT implies that the texture matrix is not the
+    * identity, so we don't have to check that here.
+    */
+   for (i = 0 ; i < ctx->Const.MaxTextureCoordUnits ; i++) {
+      if (ctx->Texture._TexMatEnabled & ENABLE_TEXMAT(i)) {
+	 (void) TransformRaw( &store->texcoord[i],
+			      ctx->TextureMatrixStack[i].Top,
+			      VB->AttribPtr[_TNL_ATTRIB_TEX0 + i]);
+
+	 VB->AttribPtr[VERT_ATTRIB_TEX0+i] = &store->texcoord[i];
+      }
+   }
+
+   return GL_TRUE;
+}
+
+
+/* Called the first time stage->run() is invoked.
+ */
+static GLboolean alloc_texmat_data( struct gl_context *ctx,
+				    struct tnl_pipeline_stage *stage )
+{
+   struct vertex_buffer *VB = &TNL_CONTEXT(ctx)->vb;
+   struct texmat_stage_data *store;
+   GLuint i;
+
+   stage->privatePtr = CALLOC(sizeof(*store));
+   store = TEXMAT_STAGE_DATA(stage);
+   if (!store)
+      return GL_FALSE;
+
+   for (i = 0 ; i < ctx->Const.MaxTextureCoordUnits ; i++)
+      _mesa_vector4f_alloc( &store->texcoord[i], 0, VB->Size, 32 );
+
+   return GL_TRUE;
+}
+
+
+static void free_texmat_data( struct tnl_pipeline_stage *stage )
+{
+   struct texmat_stage_data *store = TEXMAT_STAGE_DATA(stage);
+   GLuint i;
+
+   if (store) {
+      for (i = 0; i < MAX_TEXTURE_COORD_UNITS; i++)
+	 if (store->texcoord[i].data)
+	    _mesa_vector4f_free( &store->texcoord[i] );
+      FREE( store );
+      stage->privatePtr = NULL;
+   }
+}
+
+
+
+const struct tnl_pipeline_stage _tnl_texture_transform_stage =
+{
+   "texture transform",			/* name */
+   NULL,				/* private data */
+   alloc_texmat_data,
+   free_texmat_data,			/* destructor */
+   NULL,
+   run_texmat_stage,
+};
diff --git a/mesalib/src/mesa/tnl/t_vb_vertex.c b/mesalib/src/mesa/tnl/t_vb_vertex.c
index a77959410..26e8ae065 100644
--- a/mesalib/src/mesa/tnl/t_vb_vertex.c
+++ b/mesalib/src/mesa/tnl/t_vb_vertex.c
@@ -1,283 +1,283 @@
-/*
- * Mesa 3-D graphics library
- * Version:  6.5
- *
- * Copyright (C) 1999-2006  Brian Paul   All Rights Reserved.
- *
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the "Software"),
- * to deal in the Software without restriction, including without limitation
- * the rights to use, copy, modify, merge, publish, distribute, sublicense,
- * and/or sell copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included
- * in all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
- * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
- * BRIAN PAUL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
- * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
- * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
- *
- * Authors:
- *    Keith Whitwell <keith@tungstengraphics.com>
- */
-
-
-#include "main/glheader.h"
-#include "main/colormac.h"
-#include "main/macros.h"
-#include "main/imports.h"
-#include "main/mtypes.h"
-
-#include "math/m_xform.h"
-
-#include "t_context.h"
-#include "t_pipeline.h"
-
-
-
-struct vertex_stage_data {
-   GLvector4f eye;
-   GLvector4f clip;
-   GLvector4f proj;
-   GLubyte *clipmask;
-   GLubyte ormask;
-   GLubyte andmask;
-};
-
-#define VERTEX_STAGE_DATA(stage) ((struct vertex_stage_data *)stage->privatePtr)
-
-
-
-
-/* This function implements cliptesting for user-defined clip planes.
- * The clipping of primitives to these planes is implemented in
- * t_render_clip.h.
- */
-#define USER_CLIPTEST(NAME, SZ)					\
-static void NAME( struct gl_context *ctx,				\
-		  GLvector4f *clip,				\
-		  GLubyte *clipmask,				\
-		  GLubyte *clipormask,				\
-		  GLubyte *clipandmask )			\
-{								\
-   GLuint p;							\
-								\
-   for (p = 0; p < ctx->Const.MaxClipPlanes; p++)		\
-      if (ctx->Transform.ClipPlanesEnabled & (1 << p)) {	\
-	 GLuint nr, i;						\
-	 const GLfloat a = ctx->Transform._ClipUserPlane[p][0];	\
-	 const GLfloat b = ctx->Transform._ClipUserPlane[p][1];	\
-	 const GLfloat c = ctx->Transform._ClipUserPlane[p][2];	\
-	 const GLfloat d = ctx->Transform._ClipUserPlane[p][3];	\
-         GLfloat *coord = (GLfloat *)clip->data;		\
-         GLuint stride = clip->stride;				\
-         GLuint count = clip->count;				\
-								\
-	 for (nr = 0, i = 0 ; i < count ; i++) {		\
-	    GLfloat dp = coord[0] * a + coord[1] * b;		\
-	    if (SZ > 2) dp += coord[2] * c;			\
-	    if (SZ > 3) dp += coord[3] * d; else dp += d;	\
-								\
-	    if (dp < 0) {					\
-	       nr++;						\
-	       clipmask[i] |= CLIP_USER_BIT;			\
-	    }							\
-								\
-	    STRIDE_F(coord, stride);				\
-	 }							\
-								\
-	 if (nr > 0) {						\
-	    *clipormask |= CLIP_USER_BIT;			\
-	    if (nr == count) {					\
-	       *clipandmask |= CLIP_USER_BIT;			\
-	       return;						\
-	    }							\
-	 }							\
-      }								\
-}
-
-
-USER_CLIPTEST(userclip2, 2)
-USER_CLIPTEST(userclip3, 3)
-USER_CLIPTEST(userclip4, 4)
-
-static void (*(usercliptab[5]))( struct gl_context *,
-				 GLvector4f *, GLubyte *,
-				 GLubyte *, GLubyte * ) =
-{
-   NULL,
-   NULL,
-   userclip2,
-   userclip3,
-   userclip4
-};
-
-
-void
-tnl_clip_prepare(struct gl_context *ctx)
-{
-   /* Neither the x86 nor sparc asm cliptest functions have been updated
-    * for ARB_depth_clamp, so force the C paths.
-    */
-   if (ctx->Transform.DepthClamp) {
-      static GLboolean c_funcs_installed = GL_FALSE;
-      if (!c_funcs_installed) {
-         init_c_cliptest();
-         c_funcs_installed = GL_TRUE;
-      }
-   }
-}
-
-
-
-static GLboolean run_vertex_stage( struct gl_context *ctx,
-				   struct tnl_pipeline_stage *stage )
-{
-   struct vertex_stage_data *store = (struct vertex_stage_data *)stage->privatePtr;
-   TNLcontext *tnl = TNL_CONTEXT(ctx);
-   struct vertex_buffer *VB = &tnl->vb;
-
-   if (ctx->VertexProgram._Current) 
-      return GL_TRUE;
-
-   tnl_clip_prepare(ctx);
-
-   if (ctx->_NeedEyeCoords) {
-      /* Separate modelview transformation:
-       * Use combined ModelProject to avoid some depth artifacts
-       */
-      if (ctx->ModelviewMatrixStack.Top->type == MATRIX_IDENTITY)
-	 VB->EyePtr = VB->AttribPtr[_TNL_ATTRIB_POS];
-      else
-	 VB->EyePtr = TransformRaw( &store->eye,
-				    ctx->ModelviewMatrixStack.Top,
-				    VB->AttribPtr[_TNL_ATTRIB_POS]);
-   }
-
-   VB->ClipPtr = TransformRaw( &store->clip,
-			       &ctx->_ModelProjectMatrix,
-			       VB->AttribPtr[_TNL_ATTRIB_POS] );
-
-   /* Drivers expect this to be clean to element 4...
-    */
-   switch (VB->ClipPtr->size) {
-   case 1:			
-      /* impossible */
-   case 2:
-      _mesa_vector4f_clean_elem( VB->ClipPtr, VB->Count, 2 );
-      /* fall-through */
-   case 3:
-      _mesa_vector4f_clean_elem( VB->ClipPtr, VB->Count, 3 );
-      /* fall-through */
-   case 4:
-      break;
-   }
-
-
-   /* Cliptest and perspective divide.  Clip functions must clear
-    * the clipmask.
-    */
-   store->ormask = 0;
-   store->andmask = CLIP_FRUSTUM_BITS;
-
-   if (tnl->NeedNdcCoords) {
-      VB->NdcPtr =
-	 _mesa_clip_tab[VB->ClipPtr->size]( VB->ClipPtr,
-					    &store->proj,
-					    store->clipmask,
-					    &store->ormask,
-					    &store->andmask,
-					    !ctx->Transform.DepthClamp );
-   }
-   else {
-      VB->NdcPtr = NULL;
-      _mesa_clip_np_tab[VB->ClipPtr->size]( VB->ClipPtr,
-					    NULL,
-					    store->clipmask,
-					    &store->ormask,
-					    &store->andmask,
-					    !ctx->Transform.DepthClamp );
-   }
-
-   if (store->andmask)
-      return GL_FALSE;
-
-
-   /* Test userclip planes.  This contributes to VB->ClipMask, so
-    * is essentially required to be in this stage.
-    */
-   if (ctx->Transform.ClipPlanesEnabled) {
-      usercliptab[VB->ClipPtr->size]( ctx,
-				      VB->ClipPtr,
-				      store->clipmask,
-				      &store->ormask,
-				      &store->andmask );
-
-      if (store->andmask)
-	 return GL_FALSE;
-   }
-
-   VB->ClipAndMask = store->andmask;
-   VB->ClipOrMask = store->ormask;
-   VB->ClipMask = store->clipmask;
-
-   return GL_TRUE;
-}
-
-
-static GLboolean init_vertex_stage( struct gl_context *ctx,
-				    struct tnl_pipeline_stage *stage )
-{
-   struct vertex_buffer *VB = &TNL_CONTEXT(ctx)->vb;
-   struct vertex_stage_data *store;
-   GLuint size = VB->Size;
-
-   stage->privatePtr = CALLOC(sizeof(*store));
-   store = VERTEX_STAGE_DATA(stage);
-   if (!store)
-      return GL_FALSE;
-
-   _mesa_vector4f_alloc( &store->eye, 0, size, 32 );
-   _mesa_vector4f_alloc( &store->clip, 0, size, 32 );
-   _mesa_vector4f_alloc( &store->proj, 0, size, 32 );
-
-   store->clipmask = (GLubyte *) _mesa_align_malloc(sizeof(GLubyte)*size, 32 );
-
-   if (!store->clipmask ||
-       !store->eye.data ||
-       !store->clip.data ||
-       !store->proj.data)
-      return GL_FALSE;
-
-   return GL_TRUE;
-}
-
-static void dtr( struct tnl_pipeline_stage *stage )
-{
-   struct vertex_stage_data *store = VERTEX_STAGE_DATA(stage);
-
-   if (store) {
-      _mesa_vector4f_free( &store->eye );
-      _mesa_vector4f_free( &store->clip );
-      _mesa_vector4f_free( &store->proj );
-      _mesa_align_free( store->clipmask );
-      FREE(store);
-      stage->privatePtr = NULL;
-      stage->run = init_vertex_stage;
-   }
-}
-
-
-const struct tnl_pipeline_stage _tnl_vertex_transform_stage =
-{
-   "modelview/project/cliptest/divide",
-   NULL,			/* private data */
-   init_vertex_stage,
-   dtr,				/* destructor */
-   NULL,
-   run_vertex_stage		/* run -- initially set to init */
-};
+/*
+ * Mesa 3-D graphics library
+ * Version:  6.5
+ *
+ * Copyright (C) 1999-2006  Brian Paul   All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * BRIAN PAUL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
+ * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ *
+ * Authors:
+ *    Keith Whitwell <keith@tungstengraphics.com>
+ */
+
+
+#include "main/glheader.h"
+#include "main/colormac.h"
+#include "main/macros.h"
+#include "main/imports.h"
+#include "main/mtypes.h"
+
+#include "math/m_xform.h"
+
+#include "t_context.h"
+#include "t_pipeline.h"
+
+
+
+struct vertex_stage_data {
+   GLvector4f eye;
+   GLvector4f clip;
+   GLvector4f proj;
+   GLubyte *clipmask;
+   GLubyte ormask;
+   GLubyte andmask;
+};
+
+#define VERTEX_STAGE_DATA(stage) ((struct vertex_stage_data *)stage->privatePtr)
+
+
+
+
+/* This function implements cliptesting for user-defined clip planes.
+ * The clipping of primitives to these planes is implemented in
+ * t_render_clip.h.
+ */
+#define USER_CLIPTEST(NAME, SZ)					\
+static void NAME( struct gl_context *ctx,				\
+		  GLvector4f *clip,				\
+		  GLubyte *clipmask,				\
+		  GLubyte *clipormask,				\
+		  GLubyte *clipandmask )			\
+{								\
+   GLuint p;							\
+								\
+   for (p = 0; p < ctx->Const.MaxClipPlanes; p++)		\
+      if (ctx->Transform.ClipPlanesEnabled & (1 << p)) {	\
+	 GLuint nr, i;						\
+	 const GLfloat a = ctx->Transform._ClipUserPlane[p][0];	\
+	 const GLfloat b = ctx->Transform._ClipUserPlane[p][1];	\
+	 const GLfloat c = ctx->Transform._ClipUserPlane[p][2];	\
+	 const GLfloat d = ctx->Transform._ClipUserPlane[p][3];	\
+         GLfloat *coord = (GLfloat *)clip->data;		\
+         GLuint stride = clip->stride;				\
+         GLuint count = clip->count;				\
+								\
+	 for (nr = 0, i = 0 ; i < count ; i++) {		\
+	    GLfloat dp = coord[0] * a + coord[1] * b;		\
+	    if (SZ > 2) dp += coord[2] * c;			\
+	    if (SZ > 3) dp += coord[3] * d; else dp += d;	\
+								\
+	    if (dp < 0) {					\
+	       nr++;						\
+	       clipmask[i] |= CLIP_USER_BIT;			\
+	    }							\
+								\
+	    STRIDE_F(coord, stride);				\
+	 }							\
+								\
+	 if (nr > 0) {						\
+	    *clipormask |= CLIP_USER_BIT;			\
+	    if (nr == count) {					\
+	       *clipandmask |= CLIP_USER_BIT;			\
+	       return;						\
+	    }							\
+	 }							\
+      }								\
+}
+
+
+USER_CLIPTEST(userclip2, 2)
+USER_CLIPTEST(userclip3, 3)
+USER_CLIPTEST(userclip4, 4)
+
+static void (*(usercliptab[5]))( struct gl_context *,
+				 GLvector4f *, GLubyte *,
+				 GLubyte *, GLubyte * ) =
+{
+   NULL,
+   NULL,
+   userclip2,
+   userclip3,
+   userclip4
+};
+
+
+void
+tnl_clip_prepare(struct gl_context *ctx)
+{
+   /* Neither the x86 nor sparc asm cliptest functions have been updated
+    * for ARB_depth_clamp, so force the C paths.
+    */
+   if (ctx->Transform.DepthClamp) {
+      static GLboolean c_funcs_installed = GL_FALSE;
+      if (!c_funcs_installed) {
+         init_c_cliptest();
+         c_funcs_installed = GL_TRUE;
+      }
+   }
+}
+
+
+
+static GLboolean run_vertex_stage( struct gl_context *ctx,
+				   struct tnl_pipeline_stage *stage )
+{
+   struct vertex_stage_data *store = (struct vertex_stage_data *)stage->privatePtr;
+   TNLcontext *tnl = TNL_CONTEXT(ctx);
+   struct vertex_buffer *VB = &tnl->vb;
+
+   if (ctx->VertexProgram._Current) 
+      return GL_TRUE;
+
+   tnl_clip_prepare(ctx);
+
+   if (ctx->_NeedEyeCoords) {
+      /* Separate modelview transformation:
+       * Use combined ModelProject to avoid some depth artifacts
+       */
+      if (ctx->ModelviewMatrixStack.Top->type == MATRIX_IDENTITY)
+	 VB->EyePtr = VB->AttribPtr[_TNL_ATTRIB_POS];
+      else
+	 VB->EyePtr = TransformRaw( &store->eye,
+				    ctx->ModelviewMatrixStack.Top,
+				    VB->AttribPtr[_TNL_ATTRIB_POS]);
+   }
+
+   VB->ClipPtr = TransformRaw( &store->clip,
+			       &ctx->_ModelProjectMatrix,
+			       VB->AttribPtr[_TNL_ATTRIB_POS] );
+
+   /* Drivers expect this to be clean to element 4...
+    */
+   switch (VB->ClipPtr->size) {
+   case 1:			
+      /* impossible */
+   case 2:
+      _mesa_vector4f_clean_elem( VB->ClipPtr, VB->Count, 2 );
+      /* fall-through */
+   case 3:
+      _mesa_vector4f_clean_elem( VB->ClipPtr, VB->Count, 3 );
+      /* fall-through */
+   case 4:
+      break;
+   }
+
+
+   /* Cliptest and perspective divide.  Clip functions must clear
+    * the clipmask.
+    */
+   store->ormask = 0;
+   store->andmask = CLIP_FRUSTUM_BITS;
+
+   if (tnl->NeedNdcCoords) {
+      VB->NdcPtr =
+	 _mesa_clip_tab[VB->ClipPtr->size]( VB->ClipPtr,
+					    &store->proj,
+					    store->clipmask,
+					    &store->ormask,
+					    &store->andmask,
+					    !ctx->Transform.DepthClamp );
+   }
+   else {
+      VB->NdcPtr = NULL;
+      _mesa_clip_np_tab[VB->ClipPtr->size]( VB->ClipPtr,
+					    NULL,
+					    store->clipmask,
+					    &store->ormask,
+					    &store->andmask,
+					    !ctx->Transform.DepthClamp );
+   }
+
+   if (store->andmask)
+      return GL_FALSE;
+
+
+   /* Test userclip planes.  This contributes to VB->ClipMask, so
+    * is essentially required to be in this stage.
+    */
+   if (ctx->Transform.ClipPlanesEnabled) {
+      usercliptab[VB->ClipPtr->size]( ctx,
+				      VB->ClipPtr,
+				      store->clipmask,
+				      &store->ormask,
+				      &store->andmask );
+
+      if (store->andmask)
+	 return GL_FALSE;
+   }
+
+   VB->ClipAndMask = store->andmask;
+   VB->ClipOrMask = store->ormask;
+   VB->ClipMask = store->clipmask;
+
+   return GL_TRUE;
+}
+
+
+static GLboolean init_vertex_stage( struct gl_context *ctx,
+				    struct tnl_pipeline_stage *stage )
+{
+   struct vertex_buffer *VB = &TNL_CONTEXT(ctx)->vb;
+   struct vertex_stage_data *store;
+   GLuint size = VB->Size;
+
+   stage->privatePtr = CALLOC(sizeof(*store));
+   store = VERTEX_STAGE_DATA(stage);
+   if (!store)
+      return GL_FALSE;
+
+   _mesa_vector4f_alloc( &store->eye, 0, size, 32 );
+   _mesa_vector4f_alloc( &store->clip, 0, size, 32 );
+   _mesa_vector4f_alloc( &store->proj, 0, size, 32 );
+
+   store->clipmask = (GLubyte *) _mesa_align_malloc(sizeof(GLubyte)*size, 32 );
+
+   if (!store->clipmask ||
+       !store->eye.data ||
+       !store->clip.data ||
+       !store->proj.data)
+      return GL_FALSE;
+
+   return GL_TRUE;
+}
+
+static void dtr( struct tnl_pipeline_stage *stage )
+{
+   struct vertex_stage_data *store = VERTEX_STAGE_DATA(stage);
+
+   if (store) {
+      _mesa_vector4f_free( &store->eye );
+      _mesa_vector4f_free( &store->clip );
+      _mesa_vector4f_free( &store->proj );
+      _mesa_align_free( store->clipmask );
+      FREE(store);
+      stage->privatePtr = NULL;
+      stage->run = init_vertex_stage;
+   }
+}
+
+
+const struct tnl_pipeline_stage _tnl_vertex_transform_stage =
+{
+   "modelview/project/cliptest/divide",
+   NULL,			/* private data */
+   init_vertex_stage,
+   dtr,				/* destructor */
+   NULL,
+   run_vertex_stage		/* run -- initially set to init */
+};
diff --git a/mesalib/src/mesa/tnl/t_vertex.h b/mesalib/src/mesa/tnl/t_vertex.h
index bdbc88aff..83b0dbceb 100644
--- a/mesalib/src/mesa/tnl/t_vertex.h
+++ b/mesalib/src/mesa/tnl/t_vertex.h
@@ -1,184 +1,184 @@
-/*
- * Copyright 2003 Tungsten Graphics, inc.
- * All Rights Reserved.
- *
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the "Software"),
- * to deal in the Software without restriction, including without limitation
- * on the rights to use, copy, modify, merge, publish, distribute, sub
- * license, and/or sell copies of the Software, and to permit persons to whom
- * the Software is furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice (including the next
- * paragraph) shall be included in all copies or substantial portions of the
- * Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.  IN NO EVENT SHALL
- * TUNGSTEN GRAPHICS AND/OR THEIR SUPPLIERS BE LIABLE FOR ANY CLAIM,
- * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
- * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
- * USE OR OTHER DEALINGS IN THE SOFTWARE.
- *
- * Authors:
- *    Keith Whitwell <keithw@tungstengraphics.com>
- */
-
-#ifndef _TNL_VERTEX_H
-#define _TNL_VERTEX_H
-
-#include "main/glheader.h"
-#include "t_context.h"
-
-struct gl_context;
-struct tnl_clipspace;
-
-/* New mechanism to specify hardware vertices so that tnl can build
- * and manipulate them directly.  
- */
-
-
-/* It will probably be necessary to allow drivers to specify new
- * emit-styles to cover all the wierd and wacky things out there.
- */
-enum tnl_attr_format {
-   EMIT_1F,
-   EMIT_2F,
-   EMIT_3F,
-   EMIT_4F,
-   EMIT_2F_VIEWPORT,		/* do viewport transform and emit */
-   EMIT_3F_VIEWPORT,		/* do viewport transform and emit */
-   EMIT_4F_VIEWPORT,		/* do viewport transform and emit */
-   EMIT_3F_XYW,			/* for projective texture */
-   EMIT_1UB_1F,			/* for fog coordinate */
-   EMIT_3UB_3F_RGB,		/* for specular color */
-   EMIT_3UB_3F_BGR,		/* for specular color */
-   EMIT_4UB_4F_RGBA,		/* for color */
-   EMIT_4UB_4F_BGRA,		/* for color */
-   EMIT_4UB_4F_ARGB,		/* for color */
-   EMIT_4UB_4F_ABGR,		/* for color */
-   EMIT_4CHAN_4F_RGBA,		/* for swrast color */
-   EMIT_PAD,			/* leave a hole of 'offset' bytes */
-   EMIT_MAX
-};
-
-struct tnl_attr_map {
-   GLuint attrib;			/* _TNL_ATTRIB_ enum */
-   enum tnl_attr_format format;
-   GLuint offset;
-};
-
-struct tnl_format_info {
-   const char *name;
-   tnl_extract_func extract;
-   tnl_insert_func insert[4];
-   const GLuint attrsize;
-};
-
-extern const struct tnl_format_info _tnl_format_info[EMIT_MAX];
-
-
-/* Interpolate between two vertices to produce a third:
- */
-extern void _tnl_interp( struct gl_context *ctx,
-			 GLfloat t,
-			 GLuint edst, GLuint eout, GLuint ein,
-			 GLboolean force_boundary );
-
-/* Copy colors from one vertex to another:
- */
-extern void _tnl_copy_pv(  struct gl_context *ctx, GLuint edst, GLuint esrc );
-
-
-/* Extract a named attribute from a hardware vertex.  Will have to
- * reverse any viewport transformation, swizzling or other conversions
- * which may have been applied:
- */
-extern void _tnl_get_attr( struct gl_context *ctx, const void *vertex, GLenum attrib,
-			   GLfloat *dest );
-
-/* Complementary to the above.
- */
-extern void _tnl_set_attr( struct gl_context *ctx, void *vout, GLenum attrib, 
-			   const GLfloat *src );
-
-
-extern void *_tnl_get_vertex( struct gl_context *ctx, GLuint nr );
-
-extern GLuint _tnl_install_attrs( struct gl_context *ctx,
-				  const struct tnl_attr_map *map,
-				  GLuint nr, const GLfloat *vp,
-				  GLuint unpacked_size );
-
-extern void _tnl_free_vertices( struct gl_context *ctx );
-
-extern void _tnl_init_vertices( struct gl_context *ctx, 
-				GLuint vb_size,
-				GLuint max_vertex_size );
-
-extern void *_tnl_emit_vertices_to_buffer( struct gl_context *ctx,
-					   GLuint start,
-					   GLuint end,
-					   void *dest );
-
-/* This function isn't optimal. Check out 
- * gallium/auxilary/translate for a more comprehensive implementation of
- * the same functionality.
- */
-  
-extern void *_tnl_emit_indexed_vertices_to_buffer( struct gl_context *ctx,
-						   const GLuint *elts,
-						   GLuint start,
-						   GLuint end,
-						   void *dest );
-
-
-extern void _tnl_build_vertices( struct gl_context *ctx,
-				 GLuint start,
-				 GLuint end,
-				 GLuint newinputs );
-
-extern void _tnl_invalidate_vertices( struct gl_context *ctx, GLuint newinputs );
-
-extern void _tnl_invalidate_vertex_state( struct gl_context *ctx, GLuint new_state );
-
-extern void _tnl_notify_pipeline_output_change( struct gl_context *ctx );
-
-
-#define GET_VERTEX_STATE(ctx)  &(TNL_CONTEXT(ctx)->clipspace)
-
-/* Internal function:
- */
-void _tnl_register_fastpath( struct tnl_clipspace *vtx,
-			     GLboolean match_strides );
-
-
-/* t_vertex_generic.c -- Internal functions for t_vertex.c
- */
-void _tnl_generic_copy_pv_extras( struct gl_context *ctx, 
-				  GLuint dst, GLuint src );
-
-void _tnl_generic_interp_extras( struct gl_context *ctx,
-				 GLfloat t,
-				 GLuint dst, GLuint out, GLuint in,
-				 GLboolean force_boundary );
-
-void _tnl_generic_copy_pv( struct gl_context *ctx, GLuint edst, GLuint esrc );
-
-void _tnl_generic_interp( struct gl_context *ctx,
-			  GLfloat t,
-			  GLuint edst, GLuint eout, GLuint ein,
-			  GLboolean force_boundary );
-
-void _tnl_generic_emit( struct gl_context *ctx,
-			GLuint count,
-			GLubyte *v );
-
-void _tnl_generate_hardwired_emit( struct gl_context *ctx );
-
-/* t_vertex_sse.c -- Internal functions for t_vertex.c
- */
-void _tnl_generate_sse_emit( struct gl_context *ctx );
-
-#endif
+/*
+ * Copyright 2003 Tungsten Graphics, inc.
+ * All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * on the rights to use, copy, modify, merge, publish, distribute, sub
+ * license, and/or sell copies of the Software, and to permit persons to whom
+ * the Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice (including the next
+ * paragraph) shall be included in all copies or substantial portions of the
+ * Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.  IN NO EVENT SHALL
+ * TUNGSTEN GRAPHICS AND/OR THEIR SUPPLIERS BE LIABLE FOR ANY CLAIM,
+ * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+ * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+ * USE OR OTHER DEALINGS IN THE SOFTWARE.
+ *
+ * Authors:
+ *    Keith Whitwell <keithw@tungstengraphics.com>
+ */
+
+#ifndef _TNL_VERTEX_H
+#define _TNL_VERTEX_H
+
+#include "main/glheader.h"
+#include "t_context.h"
+
+struct gl_context;
+struct tnl_clipspace;
+
+/* New mechanism to specify hardware vertices so that tnl can build
+ * and manipulate them directly.  
+ */
+
+
+/* It will probably be necessary to allow drivers to specify new
+ * emit-styles to cover all the wierd and wacky things out there.
+ */
+enum tnl_attr_format {
+   EMIT_1F,
+   EMIT_2F,
+   EMIT_3F,
+   EMIT_4F,
+   EMIT_2F_VIEWPORT,		/* do viewport transform and emit */
+   EMIT_3F_VIEWPORT,		/* do viewport transform and emit */
+   EMIT_4F_VIEWPORT,		/* do viewport transform and emit */
+   EMIT_3F_XYW,			/* for projective texture */
+   EMIT_1UB_1F,			/* for fog coordinate */
+   EMIT_3UB_3F_RGB,		/* for specular color */
+   EMIT_3UB_3F_BGR,		/* for specular color */
+   EMIT_4UB_4F_RGBA,		/* for color */
+   EMIT_4UB_4F_BGRA,		/* for color */
+   EMIT_4UB_4F_ARGB,		/* for color */
+   EMIT_4UB_4F_ABGR,		/* for color */
+   EMIT_4CHAN_4F_RGBA,		/* for swrast color */
+   EMIT_PAD,			/* leave a hole of 'offset' bytes */
+   EMIT_MAX
+};
+
+struct tnl_attr_map {
+   GLuint attrib;			/* _TNL_ATTRIB_ enum */
+   enum tnl_attr_format format;
+   GLuint offset;
+};
+
+struct tnl_format_info {
+   const char *name;
+   tnl_extract_func extract;
+   tnl_insert_func insert[4];
+   const GLuint attrsize;
+};
+
+extern const struct tnl_format_info _tnl_format_info[EMIT_MAX];
+
+
+/* Interpolate between two vertices to produce a third:
+ */
+extern void _tnl_interp( struct gl_context *ctx,
+			 GLfloat t,
+			 GLuint edst, GLuint eout, GLuint ein,
+			 GLboolean force_boundary );
+
+/* Copy colors from one vertex to another:
+ */
+extern void _tnl_copy_pv(  struct gl_context *ctx, GLuint edst, GLuint esrc );
+
+
+/* Extract a named attribute from a hardware vertex.  Will have to
+ * reverse any viewport transformation, swizzling or other conversions
+ * which may have been applied:
+ */
+extern void _tnl_get_attr( struct gl_context *ctx, const void *vertex, GLenum attrib,
+			   GLfloat *dest );
+
+/* Complementary to the above.
+ */
+extern void _tnl_set_attr( struct gl_context *ctx, void *vout, GLenum attrib, 
+			   const GLfloat *src );
+
+
+extern void *_tnl_get_vertex( struct gl_context *ctx, GLuint nr );
+
+extern GLuint _tnl_install_attrs( struct gl_context *ctx,
+				  const struct tnl_attr_map *map,
+				  GLuint nr, const GLfloat *vp,
+				  GLuint unpacked_size );
+
+extern void _tnl_free_vertices( struct gl_context *ctx );
+
+extern void _tnl_init_vertices( struct gl_context *ctx, 
+				GLuint vb_size,
+				GLuint max_vertex_size );
+
+extern void *_tnl_emit_vertices_to_buffer( struct gl_context *ctx,
+					   GLuint start,
+					   GLuint end,
+					   void *dest );
+
+/* This function isn't optimal. Check out 
+ * gallium/auxilary/translate for a more comprehensive implementation of
+ * the same functionality.
+ */
+  
+extern void *_tnl_emit_indexed_vertices_to_buffer( struct gl_context *ctx,
+						   const GLuint *elts,
+						   GLuint start,
+						   GLuint end,
+						   void *dest );
+
+
+extern void _tnl_build_vertices( struct gl_context *ctx,
+				 GLuint start,
+				 GLuint end,
+				 GLuint newinputs );
+
+extern void _tnl_invalidate_vertices( struct gl_context *ctx, GLuint newinputs );
+
+extern void _tnl_invalidate_vertex_state( struct gl_context *ctx, GLuint new_state );
+
+extern void _tnl_notify_pipeline_output_change( struct gl_context *ctx );
+
+
+#define GET_VERTEX_STATE(ctx)  &(TNL_CONTEXT(ctx)->clipspace)
+
+/* Internal function:
+ */
+void _tnl_register_fastpath( struct tnl_clipspace *vtx,
+			     GLboolean match_strides );
+
+
+/* t_vertex_generic.c -- Internal functions for t_vertex.c
+ */
+void _tnl_generic_copy_pv_extras( struct gl_context *ctx, 
+				  GLuint dst, GLuint src );
+
+void _tnl_generic_interp_extras( struct gl_context *ctx,
+				 GLfloat t,
+				 GLuint dst, GLuint out, GLuint in,
+				 GLboolean force_boundary );
+
+void _tnl_generic_copy_pv( struct gl_context *ctx, GLuint edst, GLuint esrc );
+
+void _tnl_generic_interp( struct gl_context *ctx,
+			  GLfloat t,
+			  GLuint edst, GLuint eout, GLuint ein,
+			  GLboolean force_boundary );
+
+void _tnl_generic_emit( struct gl_context *ctx,
+			GLuint count,
+			GLubyte *v );
+
+void _tnl_generate_hardwired_emit( struct gl_context *ctx );
+
+/* t_vertex_sse.c -- Internal functions for t_vertex.c
+ */
+void _tnl_generate_sse_emit( struct gl_context *ctx );
+
+#endif
diff --git a/mesalib/src/mesa/tnl/t_vp_build.c b/mesalib/src/mesa/tnl/t_vp_build.c
index 913cba676..70492a435 100644
--- a/mesalib/src/mesa/tnl/t_vp_build.c
+++ b/mesalib/src/mesa/tnl/t_vp_build.c
@@ -1,60 +1,60 @@
-/*
- * Mesa 3-D graphics library
- * Version:  7.1
- *
- * Copyright (C) 2007  Tungsten Graphics   All Rights Reserved.
- *
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the "Software"),
- * to deal in the Software without restriction, including without limitation
- * the rights to use, copy, modify, merge, publish, distribute, sublicense,
- * and/or sell copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included
- * in all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
- * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
- * TUNGSTEN GRAPHICS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
- * WHETHER IN
- * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
- * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
- */
-
-/**
- * \file t_vp_build.c
- * Create a vertex program to execute the current fixed function T&L pipeline.
- * \author Keith Whitwell
- */
-
-
-#include "main/glheader.h"
-#include "main/ffvertex_prog.h"
-#include "main/mtypes.h"
-#include "t_vp_build.h"
-
-
-/**
- * XXX This should go away someday, but still referenced by some drivers...
- */
-void _tnl_UpdateFixedFunctionProgram( struct gl_context *ctx )
-{
-   const struct gl_vertex_program *prev = ctx->VertexProgram._Current;
-
-   if (!ctx->VertexProgram._Current ||
-       ctx->VertexProgram._Current == ctx->VertexProgram._TnlProgram) {
-      ctx->VertexProgram._Current
-         = ctx->VertexProgram._TnlProgram
-         = _mesa_get_fixed_func_vertex_program(ctx);
-   }
-
-   /* Tell the driver about the change.  Could define a new target for
-    * this?
-    */
-   if (ctx->VertexProgram._Current != prev && ctx->Driver.BindProgram) {
-      ctx->Driver.BindProgram(ctx, GL_VERTEX_PROGRAM_ARB,
-                            (struct gl_program *) ctx->VertexProgram._Current);
-   }
-}
+/*
+ * Mesa 3-D graphics library
+ * Version:  7.1
+ *
+ * Copyright (C) 2007  Tungsten Graphics   All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * TUNGSTEN GRAPHICS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN
+ * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+/**
+ * \file t_vp_build.c
+ * Create a vertex program to execute the current fixed function T&L pipeline.
+ * \author Keith Whitwell
+ */
+
+
+#include "main/glheader.h"
+#include "main/ffvertex_prog.h"
+#include "main/mtypes.h"
+#include "t_vp_build.h"
+
+
+/**
+ * XXX This should go away someday, but still referenced by some drivers...
+ */
+void _tnl_UpdateFixedFunctionProgram( struct gl_context *ctx )
+{
+   const struct gl_vertex_program *prev = ctx->VertexProgram._Current;
+
+   if (!ctx->VertexProgram._Current ||
+       ctx->VertexProgram._Current == ctx->VertexProgram._TnlProgram) {
+      ctx->VertexProgram._Current
+         = ctx->VertexProgram._TnlProgram
+         = _mesa_get_fixed_func_vertex_program(ctx);
+   }
+
+   /* Tell the driver about the change.  Could define a new target for
+    * this?
+    */
+   if (ctx->VertexProgram._Current != prev && ctx->Driver.BindProgram) {
+      ctx->Driver.BindProgram(ctx, GL_VERTEX_PROGRAM_ARB,
+                            (struct gl_program *) ctx->VertexProgram._Current);
+   }
+}
diff --git a/mesalib/src/mesa/tnl/t_vp_build.h b/mesalib/src/mesa/tnl/t_vp_build.h
index 6cba2ce5a..e9f6de5a9 100644
--- a/mesalib/src/mesa/tnl/t_vp_build.h
+++ b/mesalib/src/mesa/tnl/t_vp_build.h
@@ -1,42 +1,42 @@
-/*
- * Mesa 3-D graphics library
- * Version:  6.3
- *
- * Copyright (C) 2005  Tungsten Graphics   All Rights Reserved.
- *
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the "Software"),
- * to deal in the Software without restriction, including without limitation
- * the rights to use, copy, modify, merge, publish, distribute, sublicense,
- * and/or sell copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included
- * in all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
- * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
- * TUNGSTEN GRAPHICS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
- * WHETHER IN
- * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
- * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
- */
-
-
-#ifndef T_VP_BUILD_H
-#define T_VP_BUILD_H
-
-struct gl_context;
-
-#define TNL_FIXED_FUNCTION_STATE_FLAGS (_NEW_PROGRAM |		\
-					_NEW_LIGHT |		\
-					_NEW_TEXTURE |		\
-					_NEW_TEXTURE_MATRIX |		\
-					_NEW_TRANSFORM |	\
-					_NEW_FOG |		\
-					_NEW_POINT)
-
-extern void _tnl_UpdateFixedFunctionProgram( struct gl_context *ctx );
-
-#endif
+/*
+ * Mesa 3-D graphics library
+ * Version:  6.3
+ *
+ * Copyright (C) 2005  Tungsten Graphics   All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * TUNGSTEN GRAPHICS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN
+ * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+
+#ifndef T_VP_BUILD_H
+#define T_VP_BUILD_H
+
+struct gl_context;
+
+#define TNL_FIXED_FUNCTION_STATE_FLAGS (_NEW_PROGRAM |		\
+					_NEW_LIGHT |		\
+					_NEW_TEXTURE |		\
+					_NEW_TEXTURE_MATRIX |		\
+					_NEW_TRANSFORM |	\
+					_NEW_FOG |		\
+					_NEW_POINT)
+
+extern void _tnl_UpdateFixedFunctionProgram( struct gl_context *ctx );
+
+#endif