Used synchronise script to update files

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