Synchronised line endinge with release branch

2 files changed, 768 insertions, 768 deletions

diff --git a/mesalib/src/mesa/tnl/t_context.c b/mesalib/src/mesa/tnl/t_context.c
index aaa564fae..a6da8cafe 100644
--- a/mesalib/src/mesa/tnl/t_context.c
+++ b/mesalib/src/mesa/tnl/t_context.c
@@ -1,220 +1,220 @@
-/*

- * Mesa 3-D graphics library

- * Version:  7.2

- *

- * Copyright (C) 1999-2008  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/imports.h"

-#include "main/context.h"

-#include "main/macros.h"

-#include "main/mtypes.h"

-#include "main/light.h"

-#include "math/m_translate.h"

-#include "math/m_xform.h"

-#include "main/state.h"

-

-#include "tnl.h"

-#include "t_context.h"

-#include "t_pipeline.h"

-

-#include "vbo/vbo.h"

-

-GLboolean

-_tnl_CreateContext( struct gl_context *ctx )

-{

-   TNLcontext *tnl;

-

-   /* Create the TNLcontext structure

-    */

-   ctx->swtnl_context = tnl = (TNLcontext *) CALLOC( sizeof(TNLcontext) );

-

-   if (!tnl) {

-      return GL_FALSE;

-   }

-

-   /* Initialize the VB.

-    */

-   tnl->vb.Size = ctx->Const.MaxArrayLockSize + MAX_CLIPPED_VERTICES;

-

-

-   /* Initialize tnl state.

-    */

-   if (ctx->VertexProgram._MaintainTnlProgram) {

-      _tnl_install_pipeline( ctx, _tnl_vp_pipeline );

-   } else {

-      _tnl_install_pipeline( ctx, _tnl_default_pipeline );

-   }

-

-   tnl->NeedNdcCoords = GL_TRUE;

-   tnl->AllowVertexFog = GL_TRUE;

-   tnl->AllowPixelFog = GL_TRUE;

-

-   /* Set a few default values in the driver struct.

-    */

-   tnl->Driver.Render.PrimTabElts = _tnl_render_tab_elts;

-   tnl->Driver.Render.PrimTabVerts = _tnl_render_tab_verts;

-   tnl->Driver.NotifyMaterialChange = _mesa_validate_all_lighting_tables;

-

-   tnl->nr_blocks = 0;

-

-   /* plug in the VBO drawing function */

-   vbo_set_draw_func(ctx, _tnl_vbo_draw_prims);

-

-   _math_init_transformation();

-   _math_init_translate();

-

-   return GL_TRUE;

-}

-

-

-void

-_tnl_DestroyContext( struct gl_context *ctx )

-{

-   TNLcontext *tnl = TNL_CONTEXT(ctx);

-

-   _tnl_destroy_pipeline( ctx );

-

-   FREE(tnl);

-   ctx->swtnl_context = NULL;

-}

-

-

-void

-_tnl_InvalidateState( struct gl_context *ctx, GLuint new_state )

-{

-   TNLcontext *tnl = TNL_CONTEXT(ctx);

-   const struct gl_vertex_program *vp = ctx->VertexProgram._Current;

-   const struct gl_fragment_program *fp = ctx->FragmentProgram._Current;

-   GLuint i;

-

-   if (new_state & (_NEW_HINT | _NEW_PROGRAM)) {

-      ASSERT(tnl->AllowVertexFog || tnl->AllowPixelFog);

-      tnl->_DoVertexFog = ((tnl->AllowVertexFog && (ctx->Hint.Fog != GL_NICEST))

-         || !tnl->AllowPixelFog) && !fp;

-   }

-

-   tnl->pipeline.new_state |= new_state;

-

-   /* Calculate tnl->render_inputs.  This bitmask indicates which vertex

-    * attributes need to be emitted to the rasterizer.

-    */

-   RENDERINPUTS_ZERO( tnl->render_inputs_bitset );

-   RENDERINPUTS_SET( tnl->render_inputs_bitset, _TNL_ATTRIB_POS );

-

-   if (!fp || (fp->Base.InputsRead & FRAG_BIT_COL0)) {

-     RENDERINPUTS_SET( tnl->render_inputs_bitset, _TNL_ATTRIB_COLOR0 );

-   }

-

-   if (_mesa_need_secondary_color(ctx))

-     RENDERINPUTS_SET( tnl->render_inputs_bitset, _TNL_ATTRIB_COLOR1 );

-

-   for (i = 0; i < ctx->Const.MaxTextureCoordUnits; i++) {

-     if (ctx->Texture._EnabledCoordUnits & (1 << i) ||

-	 (fp && fp->Base.InputsRead & FRAG_BIT_TEX(i))) {

-       RENDERINPUTS_SET( tnl->render_inputs_bitset, _TNL_ATTRIB_TEX(i) );

-     }

-   }

-

-   if (ctx->Fog.Enabled

-       || (fp != NULL && (fp->Base.InputsRead & FRAG_BIT_FOGC) != 0)) {

-      /* Either fixed-function fog or a fragment program needs fog coord.

-       */

-      RENDERINPUTS_SET( tnl->render_inputs_bitset, _TNL_ATTRIB_FOG );

-   }

-

-   if (ctx->Polygon.FrontMode != GL_FILL || 

-       ctx->Polygon.BackMode != GL_FILL)

-      RENDERINPUTS_SET( tnl->render_inputs_bitset, _TNL_ATTRIB_EDGEFLAG );

-

-   if (ctx->RenderMode == GL_FEEDBACK)

-      RENDERINPUTS_SET( tnl->render_inputs_bitset, _TNL_ATTRIB_TEX0 );

-

-   if (ctx->Point._Attenuated ||

-       (ctx->VertexProgram._Enabled && ctx->VertexProgram.PointSizeEnabled))

-      RENDERINPUTS_SET( tnl->render_inputs_bitset, _TNL_ATTRIB_POINTSIZE );

-

-   /* check for varying vars which are written by the vertex program */

-   if (vp) {

-      GLuint i;

-      for (i = 0; i < MAX_VARYING; i++) {

-	 if (vp->Base.OutputsWritten & BITFIELD64_BIT(VERT_RESULT_VAR0 + i)) {

-            RENDERINPUTS_SET(tnl->render_inputs_bitset,

-                             _TNL_ATTRIB_GENERIC(i));

-         }

-      }

-   }

-}

-

-

-void

-_tnl_wakeup( struct gl_context *ctx )

-{

-   /* Assume we haven't been getting state updates either:

-    */

-   _tnl_InvalidateState( ctx, ~0 );

-

-#if 0

-   if (ctx->Light.ColorMaterialEnabled) {

-      _mesa_update_color_material( ctx, 

-				   ctx->Current.Attrib[VERT_ATTRIB_COLOR0] );

-   }

-#endif

-}

-

-

-

-

-/**

- * Drivers call this function to tell the TCL module whether or not

- * it wants Normalized Device Coords (NDC) computed.  I.e. whether

- * we should "Divide-by-W".  Software renders will want that.

- */

-void

-_tnl_need_projected_coords( struct gl_context *ctx, GLboolean mode )

-{

-   TNLcontext *tnl = TNL_CONTEXT(ctx);

-   tnl->NeedNdcCoords = mode;

-}

-

-void

-_tnl_allow_vertex_fog( struct gl_context *ctx, GLboolean value )

-{

-   TNLcontext *tnl = TNL_CONTEXT(ctx);

-   tnl->AllowVertexFog = value;

-   tnl->_DoVertexFog = ((tnl->AllowVertexFog && (ctx->Hint.Fog != GL_NICEST))

-      || !tnl->AllowPixelFog) && !ctx->FragmentProgram._Current;

-

-}

-

-void

-_tnl_allow_pixel_fog( struct gl_context *ctx, GLboolean value )

-{

-   TNLcontext *tnl = TNL_CONTEXT(ctx);

-   tnl->AllowPixelFog = value;

-   tnl->_DoVertexFog = ((tnl->AllowVertexFog && (ctx->Hint.Fog != GL_NICEST))

-      || !tnl->AllowPixelFog) && !ctx->FragmentProgram._Current;

-}

-

+/*
+ * Mesa 3-D graphics library
+ * Version:  7.2
+ *
+ * Copyright (C) 1999-2008  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/imports.h"
+#include "main/context.h"
+#include "main/macros.h"
+#include "main/mtypes.h"
+#include "main/light.h"
+#include "math/m_translate.h"
+#include "math/m_xform.h"
+#include "main/state.h"
+
+#include "tnl.h"
+#include "t_context.h"
+#include "t_pipeline.h"
+
+#include "vbo/vbo.h"
+
+GLboolean
+_tnl_CreateContext( struct gl_context *ctx )
+{
+   TNLcontext *tnl;
+
+   /* Create the TNLcontext structure
+    */
+   ctx->swtnl_context = tnl = (TNLcontext *) CALLOC( sizeof(TNLcontext) );
+
+   if (!tnl) {
+      return GL_FALSE;
+   }
+
+   /* Initialize the VB.
+    */
+   tnl->vb.Size = ctx->Const.MaxArrayLockSize + MAX_CLIPPED_VERTICES;
+
+
+   /* Initialize tnl state.
+    */
+   if (ctx->VertexProgram._MaintainTnlProgram) {
+      _tnl_install_pipeline( ctx, _tnl_vp_pipeline );
+   } else {
+      _tnl_install_pipeline( ctx, _tnl_default_pipeline );
+   }
+
+   tnl->NeedNdcCoords = GL_TRUE;
+   tnl->AllowVertexFog = GL_TRUE;
+   tnl->AllowPixelFog = GL_TRUE;
+
+   /* Set a few default values in the driver struct.
+    */
+   tnl->Driver.Render.PrimTabElts = _tnl_render_tab_elts;
+   tnl->Driver.Render.PrimTabVerts = _tnl_render_tab_verts;
+   tnl->Driver.NotifyMaterialChange = _mesa_validate_all_lighting_tables;
+
+   tnl->nr_blocks = 0;
+
+   /* plug in the VBO drawing function */
+   vbo_set_draw_func(ctx, _tnl_vbo_draw_prims);
+
+   _math_init_transformation();
+   _math_init_translate();
+
+   return GL_TRUE;
+}
+
+
+void
+_tnl_DestroyContext( struct gl_context *ctx )
+{
+   TNLcontext *tnl = TNL_CONTEXT(ctx);
+
+   _tnl_destroy_pipeline( ctx );
+
+   FREE(tnl);
+   ctx->swtnl_context = NULL;
+}
+
+
+void
+_tnl_InvalidateState( struct gl_context *ctx, GLuint new_state )
+{
+   TNLcontext *tnl = TNL_CONTEXT(ctx);
+   const struct gl_vertex_program *vp = ctx->VertexProgram._Current;
+   const struct gl_fragment_program *fp = ctx->FragmentProgram._Current;
+   GLuint i;
+
+   if (new_state & (_NEW_HINT | _NEW_PROGRAM)) {
+      ASSERT(tnl->AllowVertexFog || tnl->AllowPixelFog);
+      tnl->_DoVertexFog = ((tnl->AllowVertexFog && (ctx->Hint.Fog != GL_NICEST))
+         || !tnl->AllowPixelFog) && !fp;
+   }
+
+   tnl->pipeline.new_state |= new_state;
+
+   /* Calculate tnl->render_inputs.  This bitmask indicates which vertex
+    * attributes need to be emitted to the rasterizer.
+    */
+   RENDERINPUTS_ZERO( tnl->render_inputs_bitset );
+   RENDERINPUTS_SET( tnl->render_inputs_bitset, _TNL_ATTRIB_POS );
+
+   if (!fp || (fp->Base.InputsRead & FRAG_BIT_COL0)) {
+     RENDERINPUTS_SET( tnl->render_inputs_bitset, _TNL_ATTRIB_COLOR0 );
+   }
+
+   if (_mesa_need_secondary_color(ctx))
+     RENDERINPUTS_SET( tnl->render_inputs_bitset, _TNL_ATTRIB_COLOR1 );
+
+   for (i = 0; i < ctx->Const.MaxTextureCoordUnits; i++) {
+     if (ctx->Texture._EnabledCoordUnits & (1 << i) ||
+	 (fp && fp->Base.InputsRead & FRAG_BIT_TEX(i))) {
+       RENDERINPUTS_SET( tnl->render_inputs_bitset, _TNL_ATTRIB_TEX(i) );
+     }
+   }
+
+   if (ctx->Fog.Enabled
+       || (fp != NULL && (fp->Base.InputsRead & FRAG_BIT_FOGC) != 0)) {
+      /* Either fixed-function fog or a fragment program needs fog coord.
+       */
+      RENDERINPUTS_SET( tnl->render_inputs_bitset, _TNL_ATTRIB_FOG );
+   }
+
+   if (ctx->Polygon.FrontMode != GL_FILL || 
+       ctx->Polygon.BackMode != GL_FILL)
+      RENDERINPUTS_SET( tnl->render_inputs_bitset, _TNL_ATTRIB_EDGEFLAG );
+
+   if (ctx->RenderMode == GL_FEEDBACK)
+      RENDERINPUTS_SET( tnl->render_inputs_bitset, _TNL_ATTRIB_TEX0 );
+
+   if (ctx->Point._Attenuated ||
+       (ctx->VertexProgram._Enabled && ctx->VertexProgram.PointSizeEnabled))
+      RENDERINPUTS_SET( tnl->render_inputs_bitset, _TNL_ATTRIB_POINTSIZE );
+
+   /* check for varying vars which are written by the vertex program */
+   if (vp) {
+      GLuint i;
+      for (i = 0; i < MAX_VARYING; i++) {
+	 if (vp->Base.OutputsWritten & BITFIELD64_BIT(VERT_RESULT_VAR0 + i)) {
+            RENDERINPUTS_SET(tnl->render_inputs_bitset,
+                             _TNL_ATTRIB_GENERIC(i));
+         }
+      }
+   }
+}
+
+
+void
+_tnl_wakeup( struct gl_context *ctx )
+{
+   /* Assume we haven't been getting state updates either:
+    */
+   _tnl_InvalidateState( ctx, ~0 );
+
+#if 0
+   if (ctx->Light.ColorMaterialEnabled) {
+      _mesa_update_color_material( ctx, 
+				   ctx->Current.Attrib[VERT_ATTRIB_COLOR0] );
+   }
+#endif
+}
+
+
+
+
+/**
+ * Drivers call this function to tell the TCL module whether or not
+ * it wants Normalized Device Coords (NDC) computed.  I.e. whether
+ * we should "Divide-by-W".  Software renders will want that.
+ */
+void
+_tnl_need_projected_coords( struct gl_context *ctx, GLboolean mode )
+{
+   TNLcontext *tnl = TNL_CONTEXT(ctx);
+   tnl->NeedNdcCoords = mode;
+}
+
+void
+_tnl_allow_vertex_fog( struct gl_context *ctx, GLboolean value )
+{
+   TNLcontext *tnl = TNL_CONTEXT(ctx);
+   tnl->AllowVertexFog = value;
+   tnl->_DoVertexFog = ((tnl->AllowVertexFog && (ctx->Hint.Fog != GL_NICEST))
+      || !tnl->AllowPixelFog) && !ctx->FragmentProgram._Current;
+
+}
+
+void
+_tnl_allow_pixel_fog( struct gl_context *ctx, GLboolean value )
+{
+   TNLcontext *tnl = TNL_CONTEXT(ctx);
+   tnl->AllowPixelFog = value;
+   tnl->_DoVertexFog = ((tnl->AllowVertexFog && (ctx->Hint.Fog != GL_NICEST))
+      || !tnl->AllowPixelFog) && !ctx->FragmentProgram._Current;
+}
+
diff --git a/mesalib/src/mesa/tnl/t_draw.c b/mesalib/src/mesa/tnl/t_draw.c
index 03d343319..03424d7a4 100644
--- a/mesalib/src/mesa/tnl/t_draw.c
+++ b/mesalib/src/mesa/tnl/t_draw.c
@@ -1,548 +1,548 @@
-/*

- * Mesa 3-D graphics library

- * Version:  7.1

- *

- * 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>

- */

-

-#include "main/glheader.h"

-#include "main/bufferobj.h"

-#include "main/condrender.h"

-#include "main/context.h"

-#include "main/imports.h"

-#include "main/mtypes.h"

-#include "main/macros.h"

-#include "main/enums.h"

-

-#include "t_context.h"

-#include "tnl.h"

-

-

-

-static GLubyte *get_space(struct gl_context *ctx, GLuint bytes)

-{

-   TNLcontext *tnl = TNL_CONTEXT(ctx);

-   GLubyte *space = malloc(bytes);

-   

-   tnl->block[tnl->nr_blocks++] = space;

-   return space;

-}

-

-

-static void free_space(struct gl_context *ctx)

-{

-   TNLcontext *tnl = TNL_CONTEXT(ctx);

-   GLuint i;

-   for (i = 0; i < tnl->nr_blocks; i++)

-      free(tnl->block[i]);

-   tnl->nr_blocks = 0;

-}

-

-

-/* Convert the incoming array to GLfloats.  Understands the

- * array->Normalized flag and selects the correct conversion method.

- */

-#define CONVERT( TYPE, MACRO ) do {		\

-   GLuint i, j;					\

-   if (input->Normalized) {			\

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

-	 const TYPE *in = (TYPE *)ptr;		\

-	 for (j = 0; j < sz; j++) {		\

-	    *fptr++ = MACRO(*in);		\

-	    in++;				\

-	 }					\

-	 ptr += input->StrideB;			\

-      }						\

-   } else {					\

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

-	 const TYPE *in = (TYPE *)ptr;		\

-	 for (j = 0; j < sz; j++) {		\

-	    *fptr++ = (GLfloat)(*in);		\

-	    in++;				\

-	 }					\

-	 ptr += input->StrideB;			\

-      }						\

-   }						\

-} while (0)

-

-

-/**

- * Convert array of BGRA/GLubyte[4] values to RGBA/float[4]

- * \param ptr  input/ubyte array

- * \param fptr  output/float array

- */

-static void

-convert_bgra_to_float(const struct gl_client_array *input,

-                      const GLubyte *ptr, GLfloat *fptr,

-                      GLuint count )

-{

-   GLuint i;

-   assert(input->Normalized);

-   assert(input->Size == 4);

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

-      const GLubyte *in = (GLubyte *) ptr;  /* in is in BGRA order */

-      *fptr++ = UBYTE_TO_FLOAT(in[2]);  /* red */

-      *fptr++ = UBYTE_TO_FLOAT(in[1]);  /* green */

-      *fptr++ = UBYTE_TO_FLOAT(in[0]);  /* blue */

-      *fptr++ = UBYTE_TO_FLOAT(in[3]);  /* alpha */

-      ptr += input->StrideB;

-   }

-}

-

-static void

-convert_half_to_float(const struct gl_client_array *input,

-		      const GLubyte *ptr, GLfloat *fptr,

-		      GLuint count, GLuint sz)

-{

-   GLuint i, j;

-

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

-      GLhalfARB *in = (GLhalfARB *)ptr;

-

-      for (j = 0; j < sz; j++) {

-	 *fptr++ = _mesa_half_to_float(in[j]);

-      }

-      ptr += input->StrideB;

-   }

-}

-

-/**

- * \brief Convert fixed-point to floating-point.

- *

- * In OpenGL, a fixed-point number is a "signed 2's complement 16.16 scaled

- * integer" (Table 2.2 of the OpenGL ES 2.0 spec).

- *

- * If the buffer has the \c normalized flag set, the formula

- *     \code normalize(x) := (2*x + 1) / (2^16 - 1) \endcode

- * is used to map the fixed-point numbers into the range [-1, 1].

- */

-static void

-convert_fixed_to_float(const struct gl_client_array *input,

-                       const GLubyte *ptr, GLfloat *fptr,

-                       GLuint count)

-{

-   GLuint i, j;

-   const GLint size = input->Size;

-

-   if (input->Normalized) {

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

-         const GLfixed *in = (GLfixed *) ptr;

-         for (j = 0; j < size; ++j) {

-            *fptr++ = (GLfloat) (2 * in[j] + 1) / (GLfloat) ((1 << 16) - 1);

-         }

-         ptr += input->StrideB;

-      }

-   } else {

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

-         const GLfixed *in = (GLfixed *) ptr;

-         for (j = 0; j < size; ++j) {

-            *fptr++ = in[j] / (GLfloat) (1 << 16);

-         }

-         ptr += input->StrideB;

-      }

-   }

-}

-

-/* Adjust pointer to point at first requested element, convert to

- * floating point, populate VB->AttribPtr[].

- */

-static void _tnl_import_array( struct gl_context *ctx,

-			       GLuint attrib,

-			       GLuint count,

-			       const struct gl_client_array *input,

-			       const GLubyte *ptr )

-{

-   TNLcontext *tnl = TNL_CONTEXT(ctx);

-   struct vertex_buffer *VB = &tnl->vb;

-   GLuint stride = input->StrideB;

-

-   if (input->Type != GL_FLOAT) {

-      const GLuint sz = input->Size;

-      GLubyte *buf = get_space(ctx, count * sz * sizeof(GLfloat));

-      GLfloat *fptr = (GLfloat *)buf;

-

-      switch (input->Type) {

-      case GL_BYTE: 

-	 CONVERT(GLbyte, BYTE_TO_FLOAT); 

-	 break;

-      case GL_UNSIGNED_BYTE: 

-         if (input->Format == GL_BGRA) {

-            /* See GL_EXT_vertex_array_bgra */

-            convert_bgra_to_float(input, ptr, fptr, count);

-         }

-         else {

-            CONVERT(GLubyte, UBYTE_TO_FLOAT); 

-         }

-	 break;

-      case GL_SHORT: 

-	 CONVERT(GLshort, SHORT_TO_FLOAT); 

-	 break;

-      case GL_UNSIGNED_SHORT: 

-	 CONVERT(GLushort, USHORT_TO_FLOAT); 

-	 break;

-      case GL_INT: 

-	 CONVERT(GLint, INT_TO_FLOAT); 

-	 break;

-      case GL_UNSIGNED_INT: 

-	 CONVERT(GLuint, UINT_TO_FLOAT); 

-	 break;

-      case GL_DOUBLE: 

-	 CONVERT(GLdouble, (GLfloat)); 

-	 break;

-      case GL_HALF_FLOAT:

-	 convert_half_to_float(input, ptr, fptr, count, sz);

-	 break;

-      case GL_FIXED:

-         convert_fixed_to_float(input, ptr, fptr, count);

-         break;

-      default:

-	 assert(0);

-	 break;

-      }

-

-      ptr = buf;

-      stride = sz * sizeof(GLfloat);

-   }

-

-   VB->AttribPtr[attrib] = &tnl->tmp_inputs[attrib];

-   VB->AttribPtr[attrib]->data = (GLfloat (*)[4])ptr;

-   VB->AttribPtr[attrib]->start = (GLfloat *)ptr;

-   VB->AttribPtr[attrib]->count = count;

-   VB->AttribPtr[attrib]->stride = stride;

-   VB->AttribPtr[attrib]->size = input->Size;

-

-   /* This should die, but so should the whole GLvector4f concept: 

-    */

-   VB->AttribPtr[attrib]->flags = (((1<<input->Size)-1) | 

-				   VEC_NOT_WRITEABLE |

-				   (stride == 4*sizeof(GLfloat) ? 0 : VEC_BAD_STRIDE));

-   

-   VB->AttribPtr[attrib]->storage = NULL;

-}

-

-#define CLIPVERTS  ((6 + MAX_CLIP_PLANES) * 2)

-

-

-static GLboolean *_tnl_import_edgeflag( struct gl_context *ctx,

-					const GLvector4f *input,

-					GLuint count)

-{

-   const GLubyte *ptr = (const GLubyte *)input->data;

-   const GLuint stride = input->stride;

-   GLboolean *space = (GLboolean *)get_space(ctx, count + CLIPVERTS);

-   GLboolean *bptr = space;

-   GLuint i;

-

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

-      *bptr++ = ((GLfloat *)ptr)[0] == 1.0;

-      ptr += stride;

-   }

-

-   return space;

-}

-

-

-static void bind_inputs( struct gl_context *ctx, 

-			 const struct gl_client_array *inputs[],

-			 GLint count,

-			 struct gl_buffer_object **bo,

-			 GLuint *nr_bo )

-{

-   TNLcontext *tnl = TNL_CONTEXT(ctx);

-   struct vertex_buffer *VB = &tnl->vb;

-   GLuint i;

-

-   /* Map all the VBOs

-    */

-   for (i = 0; i < VERT_ATTRIB_MAX; i++) {

-      const void *ptr;

-

-      if (inputs[i]->BufferObj->Name) { 

-	 if (!inputs[i]->BufferObj->Pointer) {

-	    bo[*nr_bo] = inputs[i]->BufferObj;

-	    (*nr_bo)++;

-	    ctx->Driver.MapBufferRange(ctx, 0, inputs[i]->BufferObj->Size,

-				       GL_MAP_READ_BIT,

-				       inputs[i]->BufferObj);

-	    

-	    assert(inputs[i]->BufferObj->Pointer);

-	 }

-	 

-	 ptr = ADD_POINTERS(inputs[i]->BufferObj->Pointer,

-			    inputs[i]->Ptr);

-      }

-      else

-	 ptr = inputs[i]->Ptr;

-

-      /* Just make sure the array is floating point, otherwise convert to

-       * temporary storage.  

-       *

-       * XXX: remove the GLvector4f type at some stage and just use

-       * client arrays.

-       */

-      _tnl_import_array(ctx, i, count, inputs[i], ptr);

-   }

-

-   /* We process only the vertices between min & max index:

-    */

-   VB->Count = count;

-

-   /* These should perhaps be part of _TNL_ATTRIB_* */

-   VB->BackfaceColorPtr = NULL;

-   VB->BackfaceIndexPtr = NULL;

-   VB->BackfaceSecondaryColorPtr = NULL;

-

-   /* Clipping and drawing code still requires this to be a packed

-    * array of ubytes which can be written into.  TODO: Fix and

-    * remove.

-    */

-   if (ctx->Polygon.FrontMode != GL_FILL ||

-       ctx->Polygon.BackMode != GL_FILL)

-   {

-      VB->EdgeFlag = _tnl_import_edgeflag( ctx, 

-					   VB->AttribPtr[_TNL_ATTRIB_EDGEFLAG],

-					   VB->Count );

-   }

-   else {

-      /* the data previously pointed to by EdgeFlag may have been freed */

-      VB->EdgeFlag = NULL;

-   }

-}

-

-

-/* Translate indices to GLuints and store in VB->Elts.

- */

-static void bind_indices( struct gl_context *ctx,

-			  const struct _mesa_index_buffer *ib,

-			  struct gl_buffer_object **bo,

-			  GLuint *nr_bo)

-{

-   TNLcontext *tnl = TNL_CONTEXT(ctx);

-   struct vertex_buffer *VB = &tnl->vb;

-   GLuint i;

-   const void *ptr;

-

-   if (!ib) {

-      VB->Elts = NULL;

-      return;

-   }

-

-   if (_mesa_is_bufferobj(ib->obj) && !_mesa_bufferobj_mapped(ib->obj)) {

-      /* if the buffer object isn't mapped yet, map it now */

-      unsigned map_size;

-

-      switch (ib->type) {

-      case GL_UNSIGNED_BYTE:

-	 map_size = ib->count * sizeof(GLubyte);

-	 break;

-      case GL_UNSIGNED_SHORT:

-	 map_size = ib->count * sizeof(GLushort);

-	 break;

-      case GL_UNSIGNED_INT:

-	 map_size = ib->count * sizeof(GLuint);

-	 break;

-      default:

-	 assert(0);

-	 map_size = 0;

-      }

-

-      bo[*nr_bo] = ib->obj;

-      (*nr_bo)++;

-      ptr = ctx->Driver.MapBufferRange(ctx, (GLsizeiptr) ib->ptr, map_size,

-				       GL_MAP_READ_BIT, ib->obj);

-      assert(ib->obj->Pointer);

-   } else {

-      /* user-space elements, or buffer already mapped */

-      ptr = ADD_POINTERS(ib->obj->Pointer, ib->ptr);

-   }

-

-   if (ib->type == GL_UNSIGNED_INT && VB->Primitive[0].basevertex == 0) {

-      VB->Elts = (GLuint *) ptr;

-   }

-   else {

-      GLuint *elts = (GLuint *)get_space(ctx, ib->count * sizeof(GLuint));

-      VB->Elts = elts;

-

-      if (ib->type == GL_UNSIGNED_INT) {

-	 const GLuint *in = (GLuint *)ptr;

-	 for (i = 0; i < ib->count; i++)

-	    *elts++ = (GLuint)(*in++) + VB->Primitive[0].basevertex;

-      }

-      else if (ib->type == GL_UNSIGNED_SHORT) {

-	 const GLushort *in = (GLushort *)ptr;

-	 for (i = 0; i < ib->count; i++) 

-	    *elts++ = (GLuint)(*in++) + VB->Primitive[0].basevertex;

-      }

-      else {

-	 const GLubyte *in = (GLubyte *)ptr;

-	 for (i = 0; i < ib->count; i++) 

-	    *elts++ = (GLuint)(*in++) + VB->Primitive[0].basevertex;

-      }

-   }

-}

-

-static void bind_prims( struct gl_context *ctx,

-			const struct _mesa_prim *prim,

-			GLuint nr_prims )

-{

-   TNLcontext *tnl = TNL_CONTEXT(ctx);

-   struct vertex_buffer *VB = &tnl->vb;

-

-   VB->Primitive = prim;

-   VB->PrimitiveCount = nr_prims;

-}

-

-static void unmap_vbos( struct gl_context *ctx,

-			struct gl_buffer_object **bo,

-			GLuint nr_bo )

-{

-   GLuint i;

-   for (i = 0; i < nr_bo; i++) { 

-      ctx->Driver.UnmapBuffer(ctx, bo[i]);

-   }

-}

-

-

-void _tnl_vbo_draw_prims(struct gl_context *ctx,

-			 const struct gl_client_array *arrays[],

-			 const struct _mesa_prim *prim,

-			 GLuint nr_prims,

-			 const struct _mesa_index_buffer *ib,

-			 GLboolean index_bounds_valid,

-			 GLuint min_index,

-			 GLuint max_index)

-{

-   if (!index_bounds_valid)

-      vbo_get_minmax_index(ctx, prim, ib, &min_index, &max_index);

-

-   _tnl_draw_prims(ctx, arrays, prim, nr_prims, ib, min_index, max_index);

-}

-

-/* This is the main entrypoint into the slimmed-down software tnl

- * module.  In a regular swtnl driver, this can be plugged straight

- * into the vbo->Driver.DrawPrims() callback.

- */

-void _tnl_draw_prims( struct gl_context *ctx,

-		      const struct gl_client_array *arrays[],

-		      const struct _mesa_prim *prim,

-		      GLuint nr_prims,

-		      const struct _mesa_index_buffer *ib,

-		      GLuint min_index,

-		      GLuint max_index)

-{

-   TNLcontext *tnl = TNL_CONTEXT(ctx);

-   const GLuint TEST_SPLIT = 0;

-   const GLint max = TEST_SPLIT ? 8 : tnl->vb.Size - MAX_CLIPPED_VERTICES;

-   GLint max_basevertex = prim->basevertex;

-   GLuint i;

-

-   /* Mesa core state should have been validated already */

-   assert(ctx->NewState == 0x0);

-

-   if (!_mesa_check_conditional_render(ctx))

-      return; /* don't draw */

-

-   for (i = 1; i < nr_prims; i++)

-      max_basevertex = MAX2(max_basevertex, prim[i].basevertex);

-

-   if (0)

-   {

-      printf("%s %d..%d\n", __FUNCTION__, min_index, max_index);

-      for (i = 0; i < nr_prims; i++)

-	 printf("prim %d: %s start %d count %d\n", i, 

-		_mesa_lookup_enum_by_nr(prim[i].mode),

-		prim[i].start,

-		prim[i].count);

-   }

-

-   if (min_index) {

-      /* We always translate away calls with min_index != 0. 

-       */

-      vbo_rebase_prims( ctx, arrays, prim, nr_prims, ib, 

-			min_index, max_index,

-			_tnl_vbo_draw_prims );

-      return;

-   }

-   else if ((GLint)max_index + max_basevertex > max) {

-      /* The software TNL pipeline has a fixed amount of storage for

-       * vertices and it is necessary to split incoming drawing commands

-       * if they exceed that limit.

-       */

-      struct split_limits limits;

-      limits.max_verts = max;

-      limits.max_vb_size = ~0;

-      limits.max_indices = ~0;

-

-      /* This will split the buffers one way or another and

-       * recursively call back into this function.

-       */

-      vbo_split_prims( ctx, arrays, prim, nr_prims, ib, 

-		       0, max_index + prim->basevertex,

-		       _tnl_vbo_draw_prims,

-		       &limits );

-   }

-   else {

-      /* May need to map a vertex buffer object for every attribute plus

-       * one for the index buffer.

-       */

-      struct gl_buffer_object *bo[VERT_ATTRIB_MAX + 1];

-      GLuint nr_bo = 0;

-      GLuint inst;

-

-      for (i = 0; i < nr_prims;) {

-	 GLuint this_nr_prims;

-

-	 /* Our SW TNL pipeline doesn't handle basevertex yet, so bind_indices

-	  * will rebase the elements to the basevertex, and we'll only

-	  * emit strings of prims with the same basevertex in one draw call.

-	  */

-	 for (this_nr_prims = 1; i + this_nr_prims < nr_prims;

-	      this_nr_prims++) {

-	    if (prim[i].basevertex != prim[i + this_nr_prims].basevertex)

-	       break;

-	 }

-

-         assert(prim[i].num_instances > 0);

-

-	 /* Binding inputs may imply mapping some vertex buffer objects.

-	  * They will need to be unmapped below.

-	  */

-         for (inst = 0; inst < prim[i].num_instances; inst++) {

-

-            bind_prims(ctx, &prim[i], this_nr_prims);

-            bind_inputs(ctx, arrays, max_index + prim[i].basevertex + 1,

-                        bo, &nr_bo);

-            bind_indices(ctx, ib, bo, &nr_bo);

-

-            tnl->CurInstance = inst;

-            TNL_CONTEXT(ctx)->Driver.RunPipeline(ctx);

-

-            unmap_vbos(ctx, bo, nr_bo);

-            free_space(ctx);

-         }

-

-	 i += this_nr_prims;

-      }

-   }

-}

-

+/*
+ * Mesa 3-D graphics library
+ * Version:  7.1
+ *
+ * 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>
+ */
+
+#include "main/glheader.h"
+#include "main/bufferobj.h"
+#include "main/condrender.h"
+#include "main/context.h"
+#include "main/imports.h"
+#include "main/mtypes.h"
+#include "main/macros.h"
+#include "main/enums.h"
+
+#include "t_context.h"
+#include "tnl.h"
+
+
+
+static GLubyte *get_space(struct gl_context *ctx, GLuint bytes)
+{
+   TNLcontext *tnl = TNL_CONTEXT(ctx);
+   GLubyte *space = malloc(bytes);
+   
+   tnl->block[tnl->nr_blocks++] = space;
+   return space;
+}
+
+
+static void free_space(struct gl_context *ctx)
+{
+   TNLcontext *tnl = TNL_CONTEXT(ctx);
+   GLuint i;
+   for (i = 0; i < tnl->nr_blocks; i++)
+      free(tnl->block[i]);
+   tnl->nr_blocks = 0;
+}
+
+
+/* Convert the incoming array to GLfloats.  Understands the
+ * array->Normalized flag and selects the correct conversion method.
+ */
+#define CONVERT( TYPE, MACRO ) do {		\
+   GLuint i, j;					\
+   if (input->Normalized) {			\
+      for (i = 0; i < count; i++) {		\
+	 const TYPE *in = (TYPE *)ptr;		\
+	 for (j = 0; j < sz; j++) {		\
+	    *fptr++ = MACRO(*in);		\
+	    in++;				\
+	 }					\
+	 ptr += input->StrideB;			\
+      }						\
+   } else {					\
+      for (i = 0; i < count; i++) {		\
+	 const TYPE *in = (TYPE *)ptr;		\
+	 for (j = 0; j < sz; j++) {		\
+	    *fptr++ = (GLfloat)(*in);		\
+	    in++;				\
+	 }					\
+	 ptr += input->StrideB;			\
+      }						\
+   }						\
+} while (0)
+
+
+/**
+ * Convert array of BGRA/GLubyte[4] values to RGBA/float[4]
+ * \param ptr  input/ubyte array
+ * \param fptr  output/float array
+ */
+static void
+convert_bgra_to_float(const struct gl_client_array *input,
+                      const GLubyte *ptr, GLfloat *fptr,
+                      GLuint count )
+{
+   GLuint i;
+   assert(input->Normalized);
+   assert(input->Size == 4);
+   for (i = 0; i < count; i++) {
+      const GLubyte *in = (GLubyte *) ptr;  /* in is in BGRA order */
+      *fptr++ = UBYTE_TO_FLOAT(in[2]);  /* red */
+      *fptr++ = UBYTE_TO_FLOAT(in[1]);  /* green */
+      *fptr++ = UBYTE_TO_FLOAT(in[0]);  /* blue */
+      *fptr++ = UBYTE_TO_FLOAT(in[3]);  /* alpha */
+      ptr += input->StrideB;
+   }
+}
+
+static void
+convert_half_to_float(const struct gl_client_array *input,
+		      const GLubyte *ptr, GLfloat *fptr,
+		      GLuint count, GLuint sz)
+{
+   GLuint i, j;
+
+   for (i = 0; i < count; i++) {
+      GLhalfARB *in = (GLhalfARB *)ptr;
+
+      for (j = 0; j < sz; j++) {
+	 *fptr++ = _mesa_half_to_float(in[j]);
+      }
+      ptr += input->StrideB;
+   }
+}
+
+/**
+ * \brief Convert fixed-point to floating-point.
+ *
+ * In OpenGL, a fixed-point number is a "signed 2's complement 16.16 scaled
+ * integer" (Table 2.2 of the OpenGL ES 2.0 spec).
+ *
+ * If the buffer has the \c normalized flag set, the formula
+ *     \code normalize(x) := (2*x + 1) / (2^16 - 1) \endcode
+ * is used to map the fixed-point numbers into the range [-1, 1].
+ */
+static void
+convert_fixed_to_float(const struct gl_client_array *input,
+                       const GLubyte *ptr, GLfloat *fptr,
+                       GLuint count)
+{
+   GLuint i, j;
+   const GLint size = input->Size;
+
+   if (input->Normalized) {
+      for (i = 0; i < count; ++i) {
+         const GLfixed *in = (GLfixed *) ptr;
+         for (j = 0; j < size; ++j) {
+            *fptr++ = (GLfloat) (2 * in[j] + 1) / (GLfloat) ((1 << 16) - 1);
+         }
+         ptr += input->StrideB;
+      }
+   } else {
+      for (i = 0; i < count; ++i) {
+         const GLfixed *in = (GLfixed *) ptr;
+         for (j = 0; j < size; ++j) {
+            *fptr++ = in[j] / (GLfloat) (1 << 16);
+         }
+         ptr += input->StrideB;
+      }
+   }
+}
+
+/* Adjust pointer to point at first requested element, convert to
+ * floating point, populate VB->AttribPtr[].
+ */
+static void _tnl_import_array( struct gl_context *ctx,
+			       GLuint attrib,
+			       GLuint count,
+			       const struct gl_client_array *input,
+			       const GLubyte *ptr )
+{
+   TNLcontext *tnl = TNL_CONTEXT(ctx);
+   struct vertex_buffer *VB = &tnl->vb;
+   GLuint stride = input->StrideB;
+
+   if (input->Type != GL_FLOAT) {
+      const GLuint sz = input->Size;
+      GLubyte *buf = get_space(ctx, count * sz * sizeof(GLfloat));
+      GLfloat *fptr = (GLfloat *)buf;
+
+      switch (input->Type) {
+      case GL_BYTE: 
+	 CONVERT(GLbyte, BYTE_TO_FLOAT); 
+	 break;
+      case GL_UNSIGNED_BYTE: 
+         if (input->Format == GL_BGRA) {
+            /* See GL_EXT_vertex_array_bgra */
+            convert_bgra_to_float(input, ptr, fptr, count);
+         }
+         else {
+            CONVERT(GLubyte, UBYTE_TO_FLOAT); 
+         }
+	 break;
+      case GL_SHORT: 
+	 CONVERT(GLshort, SHORT_TO_FLOAT); 
+	 break;
+      case GL_UNSIGNED_SHORT: 
+	 CONVERT(GLushort, USHORT_TO_FLOAT); 
+	 break;
+      case GL_INT: 
+	 CONVERT(GLint, INT_TO_FLOAT); 
+	 break;
+      case GL_UNSIGNED_INT: 
+	 CONVERT(GLuint, UINT_TO_FLOAT); 
+	 break;
+      case GL_DOUBLE: 
+	 CONVERT(GLdouble, (GLfloat)); 
+	 break;
+      case GL_HALF_FLOAT:
+	 convert_half_to_float(input, ptr, fptr, count, sz);
+	 break;
+      case GL_FIXED:
+         convert_fixed_to_float(input, ptr, fptr, count);
+         break;
+      default:
+	 assert(0);
+	 break;
+      }
+
+      ptr = buf;
+      stride = sz * sizeof(GLfloat);
+   }
+
+   VB->AttribPtr[attrib] = &tnl->tmp_inputs[attrib];
+   VB->AttribPtr[attrib]->data = (GLfloat (*)[4])ptr;
+   VB->AttribPtr[attrib]->start = (GLfloat *)ptr;
+   VB->AttribPtr[attrib]->count = count;
+   VB->AttribPtr[attrib]->stride = stride;
+   VB->AttribPtr[attrib]->size = input->Size;
+
+   /* This should die, but so should the whole GLvector4f concept: 
+    */
+   VB->AttribPtr[attrib]->flags = (((1<<input->Size)-1) | 
+				   VEC_NOT_WRITEABLE |
+				   (stride == 4*sizeof(GLfloat) ? 0 : VEC_BAD_STRIDE));
+   
+   VB->AttribPtr[attrib]->storage = NULL;
+}
+
+#define CLIPVERTS  ((6 + MAX_CLIP_PLANES) * 2)
+
+
+static GLboolean *_tnl_import_edgeflag( struct gl_context *ctx,
+					const GLvector4f *input,
+					GLuint count)
+{
+   const GLubyte *ptr = (const GLubyte *)input->data;
+   const GLuint stride = input->stride;
+   GLboolean *space = (GLboolean *)get_space(ctx, count + CLIPVERTS);
+   GLboolean *bptr = space;
+   GLuint i;
+
+   for (i = 0; i < count; i++) {
+      *bptr++ = ((GLfloat *)ptr)[0] == 1.0;
+      ptr += stride;
+   }
+
+   return space;
+}
+
+
+static void bind_inputs( struct gl_context *ctx, 
+			 const struct gl_client_array *inputs[],
+			 GLint count,
+			 struct gl_buffer_object **bo,
+			 GLuint *nr_bo )
+{
+   TNLcontext *tnl = TNL_CONTEXT(ctx);
+   struct vertex_buffer *VB = &tnl->vb;
+   GLuint i;
+
+   /* Map all the VBOs
+    */
+   for (i = 0; i < VERT_ATTRIB_MAX; i++) {
+      const void *ptr;
+
+      if (inputs[i]->BufferObj->Name) { 
+	 if (!inputs[i]->BufferObj->Pointer) {
+	    bo[*nr_bo] = inputs[i]->BufferObj;
+	    (*nr_bo)++;
+	    ctx->Driver.MapBufferRange(ctx, 0, inputs[i]->BufferObj->Size,
+				       GL_MAP_READ_BIT,
+				       inputs[i]->BufferObj);
+	    
+	    assert(inputs[i]->BufferObj->Pointer);
+	 }
+	 
+	 ptr = ADD_POINTERS(inputs[i]->BufferObj->Pointer,
+			    inputs[i]->Ptr);
+      }
+      else
+	 ptr = inputs[i]->Ptr;
+
+      /* Just make sure the array is floating point, otherwise convert to
+       * temporary storage.  
+       *
+       * XXX: remove the GLvector4f type at some stage and just use
+       * client arrays.
+       */
+      _tnl_import_array(ctx, i, count, inputs[i], ptr);
+   }
+
+   /* We process only the vertices between min & max index:
+    */
+   VB->Count = count;
+
+   /* These should perhaps be part of _TNL_ATTRIB_* */
+   VB->BackfaceColorPtr = NULL;
+   VB->BackfaceIndexPtr = NULL;
+   VB->BackfaceSecondaryColorPtr = NULL;
+
+   /* Clipping and drawing code still requires this to be a packed
+    * array of ubytes which can be written into.  TODO: Fix and
+    * remove.
+    */
+   if (ctx->Polygon.FrontMode != GL_FILL ||
+       ctx->Polygon.BackMode != GL_FILL)
+   {
+      VB->EdgeFlag = _tnl_import_edgeflag( ctx, 
+					   VB->AttribPtr[_TNL_ATTRIB_EDGEFLAG],
+					   VB->Count );
+   }
+   else {
+      /* the data previously pointed to by EdgeFlag may have been freed */
+      VB->EdgeFlag = NULL;
+   }
+}
+
+
+/* Translate indices to GLuints and store in VB->Elts.
+ */
+static void bind_indices( struct gl_context *ctx,
+			  const struct _mesa_index_buffer *ib,
+			  struct gl_buffer_object **bo,
+			  GLuint *nr_bo)
+{
+   TNLcontext *tnl = TNL_CONTEXT(ctx);
+   struct vertex_buffer *VB = &tnl->vb;
+   GLuint i;
+   const void *ptr;
+
+   if (!ib) {
+      VB->Elts = NULL;
+      return;
+   }
+
+   if (_mesa_is_bufferobj(ib->obj) && !_mesa_bufferobj_mapped(ib->obj)) {
+      /* if the buffer object isn't mapped yet, map it now */
+      unsigned map_size;
+
+      switch (ib->type) {
+      case GL_UNSIGNED_BYTE:
+	 map_size = ib->count * sizeof(GLubyte);
+	 break;
+      case GL_UNSIGNED_SHORT:
+	 map_size = ib->count * sizeof(GLushort);
+	 break;
+      case GL_UNSIGNED_INT:
+	 map_size = ib->count * sizeof(GLuint);
+	 break;
+      default:
+	 assert(0);
+	 map_size = 0;
+      }
+
+      bo[*nr_bo] = ib->obj;
+      (*nr_bo)++;
+      ptr = ctx->Driver.MapBufferRange(ctx, (GLsizeiptr) ib->ptr, map_size,
+				       GL_MAP_READ_BIT, ib->obj);
+      assert(ib->obj->Pointer);
+   } else {
+      /* user-space elements, or buffer already mapped */
+      ptr = ADD_POINTERS(ib->obj->Pointer, ib->ptr);
+   }
+
+   if (ib->type == GL_UNSIGNED_INT && VB->Primitive[0].basevertex == 0) {
+      VB->Elts = (GLuint *) ptr;
+   }
+   else {
+      GLuint *elts = (GLuint *)get_space(ctx, ib->count * sizeof(GLuint));
+      VB->Elts = elts;
+
+      if (ib->type == GL_UNSIGNED_INT) {
+	 const GLuint *in = (GLuint *)ptr;
+	 for (i = 0; i < ib->count; i++)
+	    *elts++ = (GLuint)(*in++) + VB->Primitive[0].basevertex;
+      }
+      else if (ib->type == GL_UNSIGNED_SHORT) {
+	 const GLushort *in = (GLushort *)ptr;
+	 for (i = 0; i < ib->count; i++) 
+	    *elts++ = (GLuint)(*in++) + VB->Primitive[0].basevertex;
+      }
+      else {
+	 const GLubyte *in = (GLubyte *)ptr;
+	 for (i = 0; i < ib->count; i++) 
+	    *elts++ = (GLuint)(*in++) + VB->Primitive[0].basevertex;
+      }
+   }
+}
+
+static void bind_prims( struct gl_context *ctx,
+			const struct _mesa_prim *prim,
+			GLuint nr_prims )
+{
+   TNLcontext *tnl = TNL_CONTEXT(ctx);
+   struct vertex_buffer *VB = &tnl->vb;
+
+   VB->Primitive = prim;
+   VB->PrimitiveCount = nr_prims;
+}
+
+static void unmap_vbos( struct gl_context *ctx,
+			struct gl_buffer_object **bo,
+			GLuint nr_bo )
+{
+   GLuint i;
+   for (i = 0; i < nr_bo; i++) { 
+      ctx->Driver.UnmapBuffer(ctx, bo[i]);
+   }
+}
+
+
+void _tnl_vbo_draw_prims(struct gl_context *ctx,
+			 const struct gl_client_array *arrays[],
+			 const struct _mesa_prim *prim,
+			 GLuint nr_prims,
+			 const struct _mesa_index_buffer *ib,
+			 GLboolean index_bounds_valid,
+			 GLuint min_index,
+			 GLuint max_index)
+{
+   if (!index_bounds_valid)
+      vbo_get_minmax_index(ctx, prim, ib, &min_index, &max_index);
+
+   _tnl_draw_prims(ctx, arrays, prim, nr_prims, ib, min_index, max_index);
+}
+
+/* This is the main entrypoint into the slimmed-down software tnl
+ * module.  In a regular swtnl driver, this can be plugged straight
+ * into the vbo->Driver.DrawPrims() callback.
+ */
+void _tnl_draw_prims( struct gl_context *ctx,
+		      const struct gl_client_array *arrays[],
+		      const struct _mesa_prim *prim,
+		      GLuint nr_prims,
+		      const struct _mesa_index_buffer *ib,
+		      GLuint min_index,
+		      GLuint max_index)
+{
+   TNLcontext *tnl = TNL_CONTEXT(ctx);
+   const GLuint TEST_SPLIT = 0;
+   const GLint max = TEST_SPLIT ? 8 : tnl->vb.Size - MAX_CLIPPED_VERTICES;
+   GLint max_basevertex = prim->basevertex;
+   GLuint i;
+
+   /* Mesa core state should have been validated already */
+   assert(ctx->NewState == 0x0);
+
+   if (!_mesa_check_conditional_render(ctx))
+      return; /* don't draw */
+
+   for (i = 1; i < nr_prims; i++)
+      max_basevertex = MAX2(max_basevertex, prim[i].basevertex);
+
+   if (0)
+   {
+      printf("%s %d..%d\n", __FUNCTION__, min_index, max_index);
+      for (i = 0; i < nr_prims; i++)
+	 printf("prim %d: %s start %d count %d\n", i, 
+		_mesa_lookup_enum_by_nr(prim[i].mode),
+		prim[i].start,
+		prim[i].count);
+   }
+
+   if (min_index) {
+      /* We always translate away calls with min_index != 0. 
+       */
+      vbo_rebase_prims( ctx, arrays, prim, nr_prims, ib, 
+			min_index, max_index,
+			_tnl_vbo_draw_prims );
+      return;
+   }
+   else if ((GLint)max_index + max_basevertex > max) {
+      /* The software TNL pipeline has a fixed amount of storage for
+       * vertices and it is necessary to split incoming drawing commands
+       * if they exceed that limit.
+       */
+      struct split_limits limits;
+      limits.max_verts = max;
+      limits.max_vb_size = ~0;
+      limits.max_indices = ~0;
+
+      /* This will split the buffers one way or another and
+       * recursively call back into this function.
+       */
+      vbo_split_prims( ctx, arrays, prim, nr_prims, ib, 
+		       0, max_index + prim->basevertex,
+		       _tnl_vbo_draw_prims,
+		       &limits );
+   }
+   else {
+      /* May need to map a vertex buffer object for every attribute plus
+       * one for the index buffer.
+       */
+      struct gl_buffer_object *bo[VERT_ATTRIB_MAX + 1];
+      GLuint nr_bo = 0;
+      GLuint inst;
+
+      for (i = 0; i < nr_prims;) {
+	 GLuint this_nr_prims;
+
+	 /* Our SW TNL pipeline doesn't handle basevertex yet, so bind_indices
+	  * will rebase the elements to the basevertex, and we'll only
+	  * emit strings of prims with the same basevertex in one draw call.
+	  */
+	 for (this_nr_prims = 1; i + this_nr_prims < nr_prims;
+	      this_nr_prims++) {
+	    if (prim[i].basevertex != prim[i + this_nr_prims].basevertex)
+	       break;
+	 }
+
+         assert(prim[i].num_instances > 0);
+
+	 /* Binding inputs may imply mapping some vertex buffer objects.
+	  * They will need to be unmapped below.
+	  */
+         for (inst = 0; inst < prim[i].num_instances; inst++) {
+
+            bind_prims(ctx, &prim[i], this_nr_prims);
+            bind_inputs(ctx, arrays, max_index + prim[i].basevertex + 1,
+                        bo, &nr_bo);
+            bind_indices(ctx, ib, bo, &nr_bo);
+
+            tnl->CurInstance = inst;
+            TNL_CONTEXT(ctx)->Driver.RunPipeline(ctx);
+
+            unmap_vbos(ctx, bo, nr_bo);
+            free_space(ctx);
+         }
+
+	 i += this_nr_prims;
+      }
+   }
+}
+