t_dd_dmatmp.h

Go to the documentation of this file.

/*
 * Mesa 3-D graphics library
 * Version:  6.5.1
 *
 * 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>
 */


#if !defined(HAVE_TRIANGLES)
#error "must have at least triangles to use render template"
#endif

#if !HAVE_ELTS
#define ELTS_VARS(buf)
#define ALLOC_ELTS(nr) 0
#define EMIT_ELT( offset, elt )
#define EMIT_TWO_ELTS( offset, elt0, elt1 )
#define INCR_ELTS( nr )
#define ELT_INIT(prim)
#define GET_CURRENT_VB_MAX_ELTS() 0
#define GET_SUBSEQUENT_VB_MAX_ELTS() 0
#define RELEASE_ELT_VERTS()
#define EMIT_INDEXED_VERTS( ctx, start, count )
#endif

#ifndef EMIT_TWO_ELTS
#define EMIT_TWO_ELTS( offset, elt0, elt1 ) \
do {                        \
   EMIT_ELT( offset, elt0 );            \
   EMIT_ELT( offset+1, elt1 );          \
} while (0)
#endif


/**********************************************************************/
/*                  Render whole begin/end objects                    */
/**********************************************************************/




#if (HAVE_ELTS)
static void *TAG(emit_elts)( GLcontext *ctx, GLuint *elts, GLuint nr,
                 void *buf)
{
   GLint i;
   LOCAL_VARS;
   ELTS_VARS(buf);

   for ( i = 0 ; i+1 < nr ; i+=2, elts += 2 ) {
      EMIT_TWO_ELTS( 0, elts[0], elts[1] );
      INCR_ELTS( 2 );
   }
   
   if (i < nr) {
      EMIT_ELT( 0, elts[0] );
      INCR_ELTS( 1 );
   }

   return (void *)ELTPTR;
}
#endif

static __inline void *TAG(emit_verts)( GLcontext *ctx, GLuint start, 
                     GLuint count, void *buf )
{
   return EMIT_VERTS(ctx, start, count, buf);
}

/***********************************************************************
 *                    Render non-indexed primitives.
 ***********************************************************************/

static void TAG(render_points_verts)( GLcontext *ctx,
                      GLuint start,
                      GLuint count,
                      GLuint flags )
{
   if (HAVE_POINTS) {
      LOCAL_VARS;
      int dmasz = GET_SUBSEQUENT_VB_MAX_VERTS();
      int currentsz;
      GLuint j, nr;

      INIT( GL_POINTS );

      currentsz = GET_CURRENT_VB_MAX_VERTS();
      if (currentsz < 8)
     currentsz = dmasz;

      for (j = start; j < count; j += nr ) {
     nr = MIN2( currentsz, count - j );
     TAG(emit_verts)( ctx, j, nr, ALLOC_VERTS(nr) );
     currentsz = dmasz;
      }

   } else {
      fprintf(stderr, "%s - cannot draw primitive\n", __FUNCTION__);
      return;
   }
}

static void TAG(render_lines_verts)( GLcontext *ctx,
                     GLuint start,
                     GLuint count,
                     GLuint flags )
{
   if (HAVE_LINES) {
      LOCAL_VARS;
      int dmasz = GET_SUBSEQUENT_VB_MAX_VERTS();
      int currentsz;
      GLuint j, nr;

      INIT( GL_LINES );

      /* Emit whole number of lines in total and in each buffer:
       */
      count -= (count-start) & 1;
      currentsz = GET_CURRENT_VB_MAX_VERTS();
      currentsz -= currentsz & 1;
      dmasz -= dmasz & 1;

      if (currentsz < 8)
     currentsz = dmasz;

      for (j = start; j < count; j += nr ) {
     nr = MIN2( currentsz, count - j );
     TAG(emit_verts)( ctx, j, nr, ALLOC_VERTS(nr) );
     currentsz = dmasz;
      }

   } else {
      fprintf(stderr, "%s - cannot draw primitive\n", __FUNCTION__);
      return;
   }
}


static void TAG(render_line_strip_verts)( GLcontext *ctx,
                      GLuint start,
                      GLuint count,
                      GLuint flags )
{
   if (HAVE_LINE_STRIPS) {
      LOCAL_VARS;
      int dmasz = GET_SUBSEQUENT_VB_MAX_VERTS();
      int currentsz;
      GLuint j, nr;

      INIT( GL_LINE_STRIP );

      currentsz = GET_CURRENT_VB_MAX_VERTS();
      if (currentsz < 8)
     currentsz = dmasz;

      for (j = start; j + 1 < count; j += nr - 1 ) {
     nr = MIN2( currentsz, count - j );
     TAG(emit_verts)( ctx, j, nr, ALLOC_VERTS(nr) );
     currentsz = dmasz;
      }
 
      FLUSH();

   } else {
      fprintf(stderr, "%s - cannot draw primitive\n", __FUNCTION__);
      return;
   }
}


static void TAG(render_line_loop_verts)( GLcontext *ctx,
                     GLuint start,
                     GLuint count,
                     GLuint flags )
{
   if (HAVE_LINE_STRIPS) {
      LOCAL_VARS;
      int dmasz = GET_SUBSEQUENT_VB_MAX_VERTS();
      int currentsz;
      GLuint j, nr;

      INIT( GL_LINE_STRIP );

      if (flags & PRIM_BEGIN)
     j = start;
      else
     j = start + 1;

      /* Ensure last vertex won't wrap buffers:
       */
      currentsz = GET_CURRENT_VB_MAX_VERTS();
      currentsz--;
      dmasz--;

      if (currentsz < 8) {
     currentsz = dmasz;
      }

      if (j + 1 < count) {
     for ( ; j + 1 < count; j += nr - 1 ) {
        nr = MIN2( currentsz, count - j );

        if (j + nr >= count &&
        start < count - 1 && 
        (flags & PRIM_END)) 
        {
           void *tmp;
           tmp = ALLOC_VERTS(nr+1);
           tmp = TAG(emit_verts)( ctx, j, nr, tmp );
           tmp = TAG(emit_verts)( ctx, start, 1, tmp );
        }
        else {
           TAG(emit_verts)( ctx, j, nr, ALLOC_VERTS(nr) );
           currentsz = dmasz;
        }
     }

      }
      else if (start + 1 < count && (flags & PRIM_END)) {
     void *tmp;
     tmp = ALLOC_VERTS(2);
     tmp = TAG(emit_verts)( ctx, start+1, 1, tmp );
     tmp = TAG(emit_verts)( ctx, start, 1, tmp );
      }

      FLUSH();

   } else {
      fprintf(stderr, "%s - cannot draw primitive\n", __FUNCTION__);
      return;
   }
}


static void TAG(render_triangles_verts)( GLcontext *ctx,
                     GLuint start,
                     GLuint count,
                     GLuint flags )
{
   LOCAL_VARS;
   int dmasz = (GET_SUBSEQUENT_VB_MAX_VERTS()/3) * 3;
   int currentsz;
   GLuint j, nr;

   INIT(GL_TRIANGLES);

   currentsz = (GET_CURRENT_VB_MAX_VERTS()/3) * 3;

   /* Emit whole number of tris in total.  dmasz is already a multiple
    * of 3.
    */
   count -= (count-start)%3;

   if (currentsz < 8)
      currentsz = dmasz;

   for (j = start; j < count; j += nr) {
      nr = MIN2( currentsz, count - j );
      TAG(emit_verts)( ctx, j, nr, ALLOC_VERTS(nr) );
      currentsz = dmasz;
   }
}



static void TAG(render_tri_strip_verts)( GLcontext *ctx,
                     GLuint start,
                     GLuint count,
                     GLuint flags )
{
   if (HAVE_TRI_STRIPS) {
      LOCAL_VARS;
      GLuint j, nr;
      int dmasz = GET_SUBSEQUENT_VB_MAX_VERTS();
      int currentsz;

      INIT(GL_TRIANGLE_STRIP);

      currentsz = GET_CURRENT_VB_MAX_VERTS();

      if (currentsz < 8) {
     currentsz = dmasz;
      }

      /* From here on emit even numbers of tris when wrapping over buffers:
       */
      dmasz -= (dmasz & 1);
      currentsz -= (currentsz & 1);

      for (j = start ; j + 2 < count; j += nr - 2 ) {
     nr = MIN2( currentsz, count - j );
     TAG(emit_verts)( ctx, j, nr, ALLOC_VERTS(nr) );
     currentsz = dmasz;
      }

      FLUSH();

   } else {
      fprintf(stderr, "%s - cannot draw primitive\n", __FUNCTION__);
      return;
   }
}

static void TAG(render_tri_fan_verts)( GLcontext *ctx,
                       GLuint start,
                       GLuint count,
                       GLuint flags )
{
   if (HAVE_TRI_FANS) {
      LOCAL_VARS;
      GLuint j, nr;
      int dmasz = GET_SUBSEQUENT_VB_MAX_VERTS();
      int currentsz;

      INIT(GL_TRIANGLE_FAN);

      currentsz = GET_CURRENT_VB_MAX_VERTS();
      if (currentsz < 8) {
     currentsz = dmasz;
      }

      for (j = start + 1 ; j + 1 < count; j += nr - 2 ) {
     void *tmp;
     nr = MIN2( currentsz, count - j + 1 );
     tmp = ALLOC_VERTS( nr );
     tmp = TAG(emit_verts)( ctx, start, 1, tmp );
     tmp = TAG(emit_verts)( ctx, j, nr - 1, tmp );
     currentsz = dmasz;
      }

      FLUSH();
   }
   else {
      /* Could write code to emit these as indexed vertices (for the
       * g400, for instance).
       */
      fprintf(stderr, "%s - cannot draw primitive\n", __FUNCTION__);
      return;
   }
}


static void TAG(render_poly_verts)( GLcontext *ctx,
                    GLuint start,
                    GLuint count,
                    GLuint flags )
{
   if (HAVE_POLYGONS) {
      LOCAL_VARS;
      GLuint j, nr;
      int dmasz = GET_SUBSEQUENT_VB_MAX_VERTS();
      int currentsz;

      INIT(GL_POLYGON);

      currentsz = GET_CURRENT_VB_MAX_VERTS();
      if (currentsz < 8) {
     currentsz = dmasz;
      }

      for (j = start + 1 ; j + 1 < count ; j += nr - 2 ) {
     void *tmp;
     nr = MIN2( currentsz, count - j + 1 );
     tmp = ALLOC_VERTS( nr );
     tmp = TAG(emit_verts)( ctx, start, 1, tmp );
     tmp = TAG(emit_verts)( ctx, j, nr - 1, tmp );
     currentsz = dmasz;
      }

      FLUSH();
   }
   else if (HAVE_TRI_FANS && ctx->Light.ShadeModel == GL_SMOOTH) {
      TAG(render_tri_fan_verts)( ctx, start, count, flags );
   } else {
      fprintf(stderr, "%s - cannot draw primitive\n", __FUNCTION__);
      return;
   }
}

static void TAG(render_quad_strip_verts)( GLcontext *ctx,
                      GLuint start,
                      GLuint count,
                      GLuint flags )
{
   GLuint j, nr;

   if (HAVE_QUAD_STRIPS) {
      LOCAL_VARS;
      GLuint j, nr;
      int dmasz = GET_SUBSEQUENT_VB_MAX_VERTS();
      int currentsz;

      INIT(GL_QUAD_STRIP);

      currentsz = GET_CURRENT_VB_MAX_VERTS();
      if (currentsz < 8) {
     currentsz = dmasz;
      }

      dmasz -= (dmasz & 2);
      currentsz -= (currentsz & 2);

      for (j = start ; j + 3 < count; j += nr - 2 ) {
     nr = MIN2( currentsz, count - j );
     TAG(emit_verts)( ctx, j, nr, ALLOC_VERTS(nr) );
     currentsz = dmasz;
      }

      FLUSH();

   } else if (HAVE_TRI_STRIPS && 
          ctx->Light.ShadeModel == GL_FLAT &&
          TNL_CONTEXT(ctx)->vb.ColorPtr[0]->stride) {
      if (HAVE_ELTS) {
     LOCAL_VARS;
     int dmasz = GET_SUBSEQUENT_VB_MAX_ELTS();
     int currentsz;
     GLuint j, nr;

         EMIT_INDEXED_VERTS( ctx, start, count );

     /* Simulate flat-shaded quadstrips using indexed vertices:
      */
     ELT_INIT( GL_TRIANGLES );

     currentsz = GET_CURRENT_VB_MAX_ELTS();

     /* Emit whole number of quads in total, and in each buffer.
      */
     dmasz -= dmasz & 1;
     count -= (count-start) & 1;
     currentsz -= currentsz & 1;

     if (currentsz < 12)
        currentsz = dmasz;

     currentsz = currentsz/6*2;
     dmasz = dmasz/6*2;

     for (j = start; j + 3 < count; j += nr - 2 ) {
        nr = MIN2( currentsz, count - j );
        if (nr >= 4) {
           GLint quads = (nr/2)-1;
           GLint i;
           ELTS_VARS( ALLOC_ELTS( quads*6 ) );

           for ( i = j-start ; i < j-start+quads*2 ; i+=2 ) {
          EMIT_TWO_ELTS( 0, (i+0), (i+1) );
          EMIT_TWO_ELTS( 2, (i+2), (i+1) );
          EMIT_TWO_ELTS( 4, (i+3), (i+2) );
          INCR_ELTS( 6 );
           }

           FLUSH();
        }
        currentsz = dmasz;
     }

     RELEASE_ELT_VERTS();
     FLUSH();
      }
      else {
     /* Vertices won't fit in a single buffer or elts not
      * available - should never happen.
      */
     fprintf(stderr, "%s - cannot draw primitive\n", __FUNCTION__);
     return;
      }
   }
   else if (HAVE_TRI_STRIPS) {
      LOCAL_VARS;
      int dmasz = GET_SUBSEQUENT_VB_MAX_VERTS();
      int currentsz;

      /* Emit smooth-shaded quadstrips as tristrips:
       */
      FLUSH();
      INIT( GL_TRIANGLE_STRIP );

      /* Emit whole number of quads in total, and in each buffer.
       */
      dmasz -= dmasz & 1;
      currentsz = GET_CURRENT_VB_MAX_VERTS();
      currentsz -= currentsz & 1;
      count -= (count-start) & 1;

      if (currentsz < 8) {
     currentsz = dmasz;
      }

      for (j = start; j + 3 < count; j += nr - 2 ) {
     nr = MIN2( currentsz, count - j );
     TAG(emit_verts)( ctx, j, nr, ALLOC_VERTS(nr) );
     currentsz = dmasz;
      }

      FLUSH();

   } else {
      fprintf(stderr, "%s - cannot draw primitive\n", __FUNCTION__);
      return;
   }
}


static void TAG(render_quads_verts)( GLcontext *ctx,
                     GLuint start,
                     GLuint count,
                     GLuint flags )
{
   if (HAVE_QUADS) {
      LOCAL_VARS;
      int dmasz = (GET_SUBSEQUENT_VB_MAX_VERTS()/4) * 4;
      int currentsz;
      GLuint j, nr;

      INIT(GL_QUADS);

      /* Emit whole number of quads in total.  dmasz is already a multiple
       * of 4.
       */
      count -= (count-start)%4;

      currentsz = (GET_CURRENT_VB_MAX_VERTS()/4) * 4;
      if (currentsz < 8)
         currentsz = dmasz;

      for (j = start; j < count; j += nr) {
         nr = MIN2( currentsz, count - j );
         TAG(emit_verts)( ctx, j, nr, ALLOC_VERTS(nr) );
         currentsz = dmasz;
      }
   }
   else if (HAVE_ELTS) {
      /* Hardware doesn't have a quad primitive type -- try to
       * simulate it using indexed vertices and the triangle
       * primitive:
       */
      LOCAL_VARS;
      int dmasz = GET_SUBSEQUENT_VB_MAX_ELTS();
      int currentsz;
      GLuint j, nr;

      EMIT_INDEXED_VERTS( ctx, start, count );

      FLUSH();
      ELT_INIT( GL_TRIANGLES );
      currentsz = GET_CURRENT_VB_MAX_ELTS();

      /* Emit whole number of quads in total, and in each buffer.
       */
      dmasz -= dmasz & 3;
      count -= (count-start) & 3;
      currentsz -= currentsz & 3;

      /* Adjust for rendering as triangles:
       */
      currentsz = currentsz/6*4;
      dmasz = dmasz/6*4;

      if (currentsz < 8)
     currentsz = dmasz;

      for (j = start; j < count; j += nr ) {
     nr = MIN2( currentsz, count - j );
     if (nr >= 4) {
        GLint quads = nr/4;
        GLint i;
        ELTS_VARS( ALLOC_ELTS( quads*6 ) );

        for ( i = j-start ; i < j-start+quads*4 ; i+=4 ) {
           EMIT_TWO_ELTS( 0, (i+0), (i+1) );
           EMIT_TWO_ELTS( 2, (i+3), (i+1) );
           EMIT_TWO_ELTS( 4, (i+2), (i+3) );
           INCR_ELTS( 6 );
        }

        FLUSH();
     }
     currentsz = dmasz;
      }

      RELEASE_ELT_VERTS();
   }
   else if (HAVE_TRIANGLES) {
      /* Hardware doesn't have a quad primitive type -- try to
       * simulate it using triangle primitive.  This is a win for
       * gears, but is it useful in the broader world?
       */
      LOCAL_VARS;
      GLuint j;

      INIT(GL_TRIANGLES);

      for (j = start; j < count-3; j += 4) {
     void *tmp = ALLOC_VERTS( 6 );
     /* Send v0, v1, v3
      */
     tmp = EMIT_VERTS(ctx, j,     2, tmp);
     tmp = EMIT_VERTS(ctx, j + 3, 1, tmp);
     /* Send v1, v2, v3
      */
     tmp = EMIT_VERTS(ctx, j + 1, 3, tmp);
      }
   }
   else {
      /* Vertices won't fit in a single buffer, should never happen.
       */
      fprintf(stderr, "%s - cannot draw primitive\n", __FUNCTION__);
      return;
   }
}

static void TAG(render_noop)( GLcontext *ctx,
                  GLuint start,
                  GLuint count,
                  GLuint flags )
{
}




static tnl_render_func TAG(render_tab_verts)[GL_POLYGON+2] =
{
   TAG(render_points_verts),
   TAG(render_lines_verts),
   TAG(render_line_loop_verts),
   TAG(render_line_strip_verts),
   TAG(render_triangles_verts),
   TAG(render_tri_strip_verts),
   TAG(render_tri_fan_verts),
   TAG(render_quads_verts),
   TAG(render_quad_strip_verts),
   TAG(render_poly_verts),
   TAG(render_noop),
};


/****************************************************************************
 *                 Render elts using hardware indexed verts                 *
 ****************************************************************************/

#if (HAVE_ELTS)
static void TAG(render_points_elts)( GLcontext *ctx,
                     GLuint start,
                     GLuint count,
                     GLuint flags )
{
   if (HAVE_POINTS) {
      LOCAL_VARS;
      int dmasz = GET_SUBSEQUENT_VB_MAX_ELTS();
      int currentsz;
      GLuint *elts = TNL_CONTEXT(ctx)->vb.Elts;
      GLuint j, nr;

      ELT_INIT( GL_POINTS );

      currentsz = GET_CURRENT_VB_MAX_ELTS();
      if (currentsz < 8)
     currentsz = dmasz;

      for (j = start; j < count; j += nr ) {
     nr = MIN2( currentsz, count - j );
     TAG(emit_elts)( ctx, elts+j, nr, ALLOC_ELTS(nr) );
     FLUSH();
     currentsz = dmasz;
      }
   } else {
      fprintf(stderr, "%s - cannot draw primitive\n", __FUNCTION__);
      return;
   }
}



static void TAG(render_lines_elts)( GLcontext *ctx,
                    GLuint start,
                    GLuint count,
                    GLuint flags )
{
   if (HAVE_LINES) {
      LOCAL_VARS;
      int dmasz = GET_SUBSEQUENT_VB_MAX_ELTS();
      int currentsz;
      GLuint *elts = TNL_CONTEXT(ctx)->vb.Elts;
      GLuint j, nr;

      ELT_INIT( GL_LINES );

      /* Emit whole number of lines in total and in each buffer:
       */
      count -= (count-start) & 1;
      currentsz -= currentsz & 1;
      dmasz -= dmasz & 1;

      currentsz = GET_CURRENT_VB_MAX_ELTS();
      if (currentsz < 8)
     currentsz = dmasz;

      for (j = start; j < count; j += nr ) {
     nr = MIN2( currentsz, count - j );
     TAG(emit_elts)( ctx, elts+j, nr, ALLOC_ELTS(nr) );
     FLUSH();
     currentsz = dmasz;
      }
   } else {
      fprintf(stderr, "%s - cannot draw primitive\n", __FUNCTION__);
      return;
   }
}


static void TAG(render_line_strip_elts)( GLcontext *ctx,
                     GLuint start,
                     GLuint count,
                     GLuint flags )
{
   if (HAVE_LINE_STRIPS) {
      LOCAL_VARS;
      int dmasz = GET_SUBSEQUENT_VB_MAX_ELTS();
      int currentsz;
      GLuint *elts = TNL_CONTEXT(ctx)->vb.Elts;
      GLuint j, nr;

      FLUSH(); /* always a new primitive */
      ELT_INIT( GL_LINE_STRIP );

      currentsz = GET_CURRENT_VB_MAX_ELTS();
      if (currentsz < 8)
     currentsz = dmasz;

      for (j = start; j + 1 < count; j += nr - 1 ) {
     nr = MIN2( currentsz, count - j );
     TAG(emit_elts)( ctx, elts+j, nr, ALLOC_ELTS(nr) );
     FLUSH();
     currentsz = dmasz;
      }
   } else {
      /* TODO: Try to emit as indexed lines.
       */
      fprintf(stderr, "%s - cannot draw primitive\n", __FUNCTION__);
      return;
   }
}


static void TAG(render_line_loop_elts)( GLcontext *ctx,
                    GLuint start,
                    GLuint count,
                    GLuint flags )
{
   if (HAVE_LINE_STRIPS) {
      LOCAL_VARS;
      int dmasz = GET_SUBSEQUENT_VB_MAX_ELTS();
      int currentsz;
      GLuint *elts = TNL_CONTEXT(ctx)->vb.Elts;
      GLuint j, nr;

      FLUSH();
      ELT_INIT( GL_LINE_STRIP );

      if (flags & PRIM_BEGIN)
     j = start;
      else
     j = start + 1;

      currentsz = GET_CURRENT_VB_MAX_ELTS();
      if (currentsz < 8) {
     currentsz = dmasz;
      }

      /* Ensure last vertex doesn't wrap:
       */
      currentsz--;
      dmasz--;

      if (j + 1 < count) {
     for ( ; j + 1 < count; j += nr - 1 ) {
        nr = MIN2( currentsz, count - j );

        if (j + nr >= count &&
        start < count - 1 && 
        (flags & PRIM_END)) 
        {
           void *tmp;
           tmp = ALLOC_ELTS(nr+1);
           tmp = TAG(emit_elts)( ctx, elts+j, nr, tmp );
           tmp = TAG(emit_elts)( ctx, elts+start, 1, tmp );
        }
        else {
           TAG(emit_elts)( ctx, elts+j, nr, ALLOC_ELTS(nr) );
           currentsz = dmasz;
        }
     }

      }
      else if (start + 1 < count && (flags & PRIM_END)) {
     void *tmp;
     tmp = ALLOC_ELTS(2);
     tmp = TAG(emit_elts)( ctx, elts+start+1, 1, tmp );
     tmp = TAG(emit_elts)( ctx, elts+start, 1, tmp );
      }

      FLUSH();
   } else {
      /* TODO: Try to emit as indexed lines */
      fprintf(stderr, "%s - cannot draw primitive\n", __FUNCTION__);
      return;
   }
}


/* For verts, we still eliminate the copy from main memory to dma
 * buffers.  For elts, this is probably no better (worse?) than the
 * standard path.
 */
static void TAG(render_triangles_elts)( GLcontext *ctx,
                    GLuint start,
                    GLuint count,
                    GLuint flags )
{
   LOCAL_VARS;
   GLuint *elts = TNL_CONTEXT(ctx)->vb.Elts;
   int dmasz = GET_SUBSEQUENT_VB_MAX_ELTS()/3*3;
   int currentsz;
   GLuint j, nr;

   FLUSH();
   ELT_INIT( GL_TRIANGLES );

   currentsz = GET_CURRENT_VB_MAX_ELTS();

   /* Emit whole number of tris in total.  dmasz is already a multiple
    * of 3.
    */
   count -= (count-start)%3;
   currentsz -= currentsz%3;
   if (currentsz < 8)
      currentsz = dmasz;

   for (j = start; j < count; j += nr) {
      nr = MIN2( currentsz, count - j );
      TAG(emit_elts)( ctx, elts+j, nr, ALLOC_ELTS(nr) );
      FLUSH();
      currentsz = dmasz;
   }
}



static void TAG(render_tri_strip_elts)( GLcontext *ctx,
                    GLuint start,
                    GLuint count,
                    GLuint flags )
{
   if (HAVE_TRI_STRIPS) {
      LOCAL_VARS;
      GLuint j, nr;
      GLuint *elts = TNL_CONTEXT(ctx)->vb.Elts;
      int dmasz = GET_SUBSEQUENT_VB_MAX_ELTS();
      int currentsz;

      FLUSH();
      ELT_INIT( GL_TRIANGLE_STRIP );

      currentsz = GET_CURRENT_VB_MAX_ELTS();
      if (currentsz < 8) {
     currentsz = dmasz;
      }

      /* Keep the same winding over multiple buffers:
       */
      dmasz -= (dmasz & 1);
      currentsz -= (currentsz & 1);

      for (j = start ; j + 2 < count; j += nr - 2 ) {
     nr = MIN2( currentsz, count - j );
     TAG(emit_elts)( ctx, elts+j, nr, ALLOC_ELTS(nr) );
     FLUSH();
     currentsz = dmasz;
      }
   } else {
      /* TODO: try to emit as indexed triangles */
      fprintf(stderr, "%s - cannot draw primitive\n", __FUNCTION__);
      return;
   }
}

static void TAG(render_tri_fan_elts)( GLcontext *ctx,
                      GLuint start,
                      GLuint count,
                      GLuint flags )
{
   if (HAVE_TRI_FANS) {
      LOCAL_VARS;
      GLuint *elts = TNL_CONTEXT(ctx)->vb.Elts;
      GLuint j, nr;
      int dmasz = GET_SUBSEQUENT_VB_MAX_ELTS();
      int currentsz;

      FLUSH();
      ELT_INIT( GL_TRIANGLE_FAN );

      currentsz = GET_CURRENT_VB_MAX_ELTS();
      if (currentsz < 8) {
     currentsz = dmasz;
      }

      for (j = start + 1 ; j + 1 < count; j += nr - 2 ) {
     void *tmp;
     nr = MIN2( currentsz, count - j + 1 );
     tmp = ALLOC_ELTS( nr );
     tmp = TAG(emit_elts)( ctx, elts+start, 1, tmp );
     tmp = TAG(emit_elts)( ctx, elts+j, nr - 1, tmp );
     FLUSH();
     currentsz = dmasz;
      }
   } else {
      /* TODO: try to emit as indexed triangles */
      fprintf(stderr, "%s - cannot draw primitive\n", __FUNCTION__);
      return;
   }
}


static void TAG(render_poly_elts)( GLcontext *ctx,
                   GLuint start,
                   GLuint count,
                   GLuint flags )
{
   if (HAVE_POLYGONS) {
      LOCAL_VARS;
      GLuint *elts = TNL_CONTEXT(ctx)->vb.Elts;
      GLuint j, nr;
      int dmasz = GET_SUBSEQUENT_VB_MAX_ELTS();
      int currentsz;

      FLUSH();
      ELT_INIT( GL_POLYGON );

      currentsz = GET_CURRENT_VB_MAX_ELTS();
      if (currentsz < 8) {
     currentsz = dmasz;
      }

      for (j = start + 1 ; j + 1 < count; j += nr - 2 ) {
     void *tmp;
     nr = MIN2( currentsz, count - j + 1 );
     tmp = ALLOC_ELTS( nr );
     tmp = TAG(emit_elts)( ctx, elts+start, 1, tmp );
     tmp = TAG(emit_elts)( ctx, elts+j, nr - 1, tmp );
     FLUSH();
     currentsz = dmasz;
      }
   } else if (HAVE_TRI_FANS && ctx->Light.ShadeModel == GL_SMOOTH) {
      TAG(render_tri_fan_verts)( ctx, start, count, flags );
   } else {
      fprintf(stderr, "%s - cannot draw primitive\n", __FUNCTION__);
      return;
   }
}

static void TAG(render_quad_strip_elts)( GLcontext *ctx,
                     GLuint start,
                     GLuint count,
                     GLuint flags )
{
   if (HAVE_QUAD_STRIPS && 0) {
   }
   else if (HAVE_TRI_STRIPS) {
      LOCAL_VARS;
      GLuint *elts = TNL_CONTEXT(ctx)->vb.Elts;
      int dmasz = GET_SUBSEQUENT_VB_MAX_ELTS();
      int currentsz;
      GLuint j, nr;

      FLUSH();
      currentsz = GET_CURRENT_VB_MAX_ELTS();

      /* Emit whole number of quads in total, and in each buffer.
       */
      dmasz -= dmasz & 1;
      count -= (count-start) & 1;
      currentsz -= currentsz & 1;

      if (currentsz < 12)
     currentsz = dmasz;

      if (ctx->Light.ShadeModel == GL_FLAT) {
     ELT_INIT( GL_TRIANGLES );

     currentsz = currentsz/6*2;
     dmasz = dmasz/6*2;

     for (j = start; j + 3 < count; j += nr - 2 ) {
        nr = MIN2( currentsz, count - j );

        if (nr >= 4)
        {
           GLint i;
           GLint quads = (nr/2)-1;
           ELTS_VARS( ALLOC_ELTS( quads*6 ) );

           for ( i = j-start ; i < j-start+quads ; i++, elts += 2 ) {
          EMIT_TWO_ELTS( 0, elts[0], elts[1] );
          EMIT_TWO_ELTS( 2, elts[2], elts[1] );
          EMIT_TWO_ELTS( 4, elts[3], elts[2] );
          INCR_ELTS( 6 );
           }

           FLUSH();
        }

        currentsz = dmasz;
     }
      }
      else {
     ELT_INIT( GL_TRIANGLE_STRIP );

     for (j = start; j + 3 < count; j += nr - 2 ) {
        nr = MIN2( currentsz, count - j );
        TAG(emit_elts)( ctx, elts+j, nr, ALLOC_ELTS(nr) );
        FLUSH();
        currentsz = dmasz;
     }
      }
   }
}


static void TAG(render_quads_elts)( GLcontext *ctx,
                    GLuint start,
                    GLuint count,
                    GLuint flags )
{
   if (HAVE_QUADS) {
      LOCAL_VARS;
      GLuint *elts = TNL_CONTEXT(ctx)->vb.Elts;
      int dmasz = GET_SUBSEQUENT_VB_MAX_ELTS()/4*4;
      int currentsz;
      GLuint j, nr;

      FLUSH();
      ELT_INIT( GL_TRIANGLES );

      currentsz = GET_CURRENT_VB_MAX_ELTS()/4*4;

      count -= (count-start)%4;

      if (currentsz < 8)
     currentsz = dmasz;

      for (j = start; j < count; j += nr) {
     nr = MIN2( currentsz, count - j );
     TAG(emit_elts)( ctx, elts+j, nr, ALLOC_ELTS(nr) );
     FLUSH();
     currentsz = dmasz;
      }
   } else {
      LOCAL_VARS;
      GLuint *elts = TNL_CONTEXT(ctx)->vb.Elts;
      int dmasz = GET_SUBSEQUENT_VB_MAX_ELTS();
      int currentsz;
      GLuint j, nr;

      ELT_INIT( GL_TRIANGLES );
      currentsz = GET_CURRENT_VB_MAX_ELTS();

      /* Emit whole number of quads in total, and in each buffer.
       */
      dmasz -= dmasz & 3;
      count -= (count-start) & 3;
      currentsz -= currentsz & 3;

      /* Adjust for rendering as triangles:
       */
      currentsz = currentsz/6*4;
      dmasz = dmasz/6*4;

      if (currentsz < 8)
     currentsz = dmasz;

      for (j = start; j + 3 < count; j += nr - 2 ) {
     nr = MIN2( currentsz, count - j );

     if (nr >= 4)
     {
        GLint quads = nr/4;
        GLint i;
        ELTS_VARS( ALLOC_ELTS( quads * 6 ) );

        for ( i = j-start ; i < j-start+quads ; i++, elts += 4 ) {
           EMIT_TWO_ELTS( 0, elts[0], elts[1] );
           EMIT_TWO_ELTS( 2, elts[3], elts[1] );
           EMIT_TWO_ELTS( 4, elts[2], elts[3] );
           INCR_ELTS( 6 );
        }

        FLUSH();
     }

     currentsz = dmasz;
      }
   }
}



static tnl_render_func TAG(render_tab_elts)[GL_POLYGON+2] =
{
   TAG(render_points_elts),
   TAG(render_lines_elts),
   TAG(render_line_loop_elts),
   TAG(render_line_strip_elts),
   TAG(render_triangles_elts),
   TAG(render_tri_strip_elts),
   TAG(render_tri_fan_elts),
   TAG(render_quads_elts),
   TAG(render_quad_strip_elts),
   TAG(render_poly_elts),
   TAG(render_noop),
};



#endif



/* Pre-check the primitives in the VB to prevent the need for
 * fallbacks later on.
 */
static GLboolean TAG(validate_render)( GLcontext *ctx,
                       struct vertex_buffer *VB )
{
   GLint i;

   if (VB->ClipOrMask & ~CLIP_CULL_BIT)
      return GL_FALSE;

   if (VB->Elts && !HAVE_ELTS)
      return GL_FALSE;

   for (i = 0 ; i < VB->PrimitiveCount ; i++) {
      GLuint prim = VB->Primitive[i].mode;
      GLuint count = VB->Primitive[i].count;
      GLboolean ok = GL_FALSE;

      if (!count)
     continue;

      switch (prim & PRIM_MODE_MASK) {
      case GL_POINTS:
     ok = HAVE_POINTS;
     break;
      case GL_LINES:
     ok = HAVE_LINES && !ctx->Line.StippleFlag;
     break;
      case GL_LINE_STRIP:
     ok = HAVE_LINE_STRIPS && !ctx->Line.StippleFlag;
     break;
      case GL_LINE_LOOP:
     ok = HAVE_LINE_STRIPS && !ctx->Line.StippleFlag;
     break;
      case GL_TRIANGLES:
     ok = HAVE_TRIANGLES;
     break;
      case GL_TRIANGLE_STRIP:
     ok = HAVE_TRI_STRIPS;
     break;
      case GL_TRIANGLE_FAN:
     ok = HAVE_TRI_FANS;
     break;
      case GL_POLYGON:
     if (HAVE_POLYGONS) {
        ok = GL_TRUE;
     }
     else {
        ok = (HAVE_TRI_FANS && ctx->Light.ShadeModel == GL_SMOOTH);
         }
     break;
      case GL_QUAD_STRIP:
     if (VB->Elts) {
        ok = HAVE_TRI_STRIPS;
     }
     else if (HAVE_QUAD_STRIPS) {
        ok = GL_TRUE;
     } else if (HAVE_TRI_STRIPS && 
            ctx->Light.ShadeModel == GL_FLAT &&
            VB->ColorPtr[0]->stride != 0) {
        if (HAVE_ELTS) {
           ok = (GLint) count < GET_SUBSEQUENT_VB_MAX_ELTS();
        }
        else {
           ok = GL_FALSE;
        }
     }
     else 
        ok = HAVE_TRI_STRIPS;
     break;
      case GL_QUADS:
     if (HAVE_QUADS) {
        ok = GL_TRUE;
     } else if (HAVE_ELTS) {
        ok = (GLint) count < GET_SUBSEQUENT_VB_MAX_ELTS();
     }
     else {
        ok = HAVE_TRIANGLES; /* flatshading is ok. */
     }
     break;
      default:
     break;
      }
      
      if (!ok) {
/*   fprintf(stderr, "not ok %s\n", _mesa_lookup_enum_by_nr(prim & PRIM_MODE_MASK)); */
     return GL_FALSE;
      }
   }

   return GL_TRUE;
}