t_dd_dmatmp2.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 !HAVE_TRIANGLES || !HAVE_POINTS || !HAVE_LINES
#error "must have points, lines & triangles to use render template"
#endif

#if !HAVE_TRI_STRIPS || !HAVE_TRI_FANS
#error "must have tri strip and fans to use render template"
#endif

#if !HAVE_LINE_STRIPS
#error "must have line strips to use render template"
#endif

#if !HAVE_POLYGONS
#error "must have polygons to use render template"
#endif

#if !HAVE_ELTS
#error "must have elts to use render template"
#endif


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


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


static ELT_TYPE *TAG(emit_elts)( GLcontext *ctx, 
                ELT_TYPE *dest,
                GLuint *elts, GLuint nr )
{
   GLint i;
   LOCAL_VARS;

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

static ELT_TYPE *TAG(emit_consecutive_elts)( GLcontext *ctx, 
                    ELT_TYPE *dest,
                    GLuint start, GLuint nr )
{
   GLint i;
   LOCAL_VARS;

   for ( i = 0 ; i+1 < nr ; i+=2, start += 2 ) {
      EMIT_TWO_ELTS( dest, 0, start, start+1 );
      dest += 2;
   }
   if (i < nr) {
      EMIT_ELT( dest, 0, start );
      dest += 1;
   }

   return dest;
}

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



static void TAG(render_points_verts)( GLcontext *ctx,
                      GLuint start,
                      GLuint count,
                      GLuint flags )
{
   if (start < count) {
      LOCAL_VARS;
      if (0) fprintf(stderr, "%s\n", __FUNCTION__);
      EMIT_PRIM( ctx, GL_POINTS, HW_POINTS, start, count );
   }
}

static void TAG(render_lines_verts)( GLcontext *ctx,
                     GLuint start,
                     GLuint count,
                     GLuint flags )
{
   LOCAL_VARS;
   if (0) fprintf(stderr, "%s\n", __FUNCTION__);
   count -= (count-start) & 1;

   if (start+1 >= count)
      return;

   if ((flags & PRIM_BEGIN) && ctx->Line.StippleFlag) {
      RESET_STIPPLE();
      AUTO_STIPPLE( GL_TRUE );
   }
      
   EMIT_PRIM( ctx, GL_LINES, HW_LINES, start, count );

   if ((flags & PRIM_END) && ctx->Line.StippleFlag)
      AUTO_STIPPLE( GL_FALSE );
}


static void TAG(render_line_strip_verts)( GLcontext *ctx,
                      GLuint start,
                      GLuint count,
                      GLuint flags )
{
   LOCAL_VARS;
   if (0) fprintf(stderr, "%s\n", __FUNCTION__);

   if (start+1 >= count)
      return;

   if ((flags & PRIM_BEGIN) && ctx->Line.StippleFlag)
      RESET_STIPPLE();


   if (PREFER_DISCRETE_ELT_PRIM( count-start, HW_LINES ))
   {   
      int dmasz = GET_MAX_HW_ELTS();
      GLuint j, nr;

      ELT_INIT( GL_LINES, HW_LINES );

      /* Emit whole number of lines in each full buffer.
       */
      dmasz = dmasz/2;


      for (j = start; j + 1 < count; j += nr - 1 ) {
     ELT_TYPE *dest;
     GLint i;

     nr = MIN2( dmasz, count - j );
     dest = ALLOC_ELTS( (nr-1)*2 );
        
     for ( i = j ; i+1 < j+nr ; i+=1 ) {
        EMIT_TWO_ELTS( dest, 0, (i+0), (i+1) );
        dest += 2;
     }

     CLOSE_ELTS();
      }
   }
   else
      EMIT_PRIM( ctx, GL_LINE_STRIP, HW_LINE_STRIP, start, count );
}


static void TAG(render_line_loop_verts)( GLcontext *ctx,
                     GLuint start,
                     GLuint count,
                     GLuint flags )
{
   LOCAL_VARS;
   GLuint j, nr;
   if (0) fprintf(stderr, "%s\n", __FUNCTION__);

   if (flags & PRIM_BEGIN) {
      j = start;
      if (ctx->Line.StippleFlag)
     RESET_STIPPLE( );
   }
   else
      j = start + 1;

   if (flags & PRIM_END) {

      if (start+1 >= count)
     return;

      if (PREFER_DISCRETE_ELT_PRIM( count-start, HW_LINES )) {
     int dmasz = GET_MAX_HW_ELTS();

     ELT_INIT( GL_LINES, HW_LINES );

     /* Emit whole number of lines in each full buffer.
      */
     dmasz = dmasz/2;

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

     for (; j + 1 < count;  ) {
        GLint i;
        ELT_TYPE *dest;

        nr = MIN2( dmasz, count - j );
        dest = ALLOC_ELTS( nr*2 );  /* allocs room for 1 more line */

        for ( i = 0 ; i < nr - 1 ; i+=1 ) {
           EMIT_TWO_ELTS( dest, 0, (j+i), (j+i+1) );
           dest += 2;
        }

        j += nr - 1;

        /* Emit 1 more line into space alloced above */
        if (j + 1 >= count) {
           EMIT_TWO_ELTS( dest, 0, (j), (start) ); 
           dest += 2; 
        }
 
        CLOSE_ELTS();
     }
      }
      else
      {
     int dmasz = GET_MAX_HW_ELTS() - 1;

     ELT_INIT( GL_LINE_STRIP, HW_LINE_STRIP );

     for ( ; j + 1 < count;  ) {
        nr = MIN2( dmasz, count - j );
        if (j + nr < count) {
           ELT_TYPE *dest = ALLOC_ELTS( nr );
           dest = TAG(emit_consecutive_elts)( ctx, dest, j, nr );
           j += nr - 1;
           CLOSE_ELTS();
        }
        else if (nr) {
           ELT_TYPE *dest = ALLOC_ELTS( nr + 1 );
           dest = TAG(emit_consecutive_elts)( ctx, dest, j, nr );
           dest = TAG(emit_consecutive_elts)( ctx, dest, start, 1 );
           j += nr;
           CLOSE_ELTS();
        }
     }   
      }
   } else {
      TAG(render_line_strip_verts)( ctx, j, count, flags );
   }
}


static void TAG(render_triangles_verts)( GLcontext *ctx,
                     GLuint start,
                     GLuint count,
                     GLuint flags )
{
   LOCAL_VARS;
   if (0) fprintf(stderr, "%s\n", __FUNCTION__);

   count -= (count-start)%3;

   if (start+2 >= count) {
      return;
   }

   /* need a PREFER_DISCRETE_ELT_PRIM here too..
    */
   EMIT_PRIM( ctx, GL_TRIANGLES, HW_TRIANGLES, start, count );
}



static void TAG(render_tri_strip_verts)( GLcontext *ctx,
                     GLuint start,
                     GLuint count,
                     GLuint flags )
{
   LOCAL_VARS;
   if (0) fprintf(stderr, "%s\n", __FUNCTION__);

   if (start + 2 >= count)
      return;

   if (PREFER_DISCRETE_ELT_PRIM( count-start, HW_TRIANGLES ))
   {   
      int dmasz = GET_MAX_HW_ELTS();
      int parity = 0;
      GLuint j, nr;

      ELT_INIT( GL_TRIANGLES, HW_TRIANGLES );

      /* Emit even number of tris in each full buffer.
       */
      dmasz = dmasz/3;
      dmasz -= dmasz & 1;

      for (j = start; j + 2 < count; j += nr - 2 ) {
     ELT_TYPE *dest;
     GLint i;

     nr = MIN2( dmasz, count - j );
     dest = ALLOC_ELTS( (nr-2)*3 );
        
     for ( i = j ; i+2 < j+nr ; i++, parity^=1 ) {
        EMIT_ELT( dest, 0, (i+0+parity) );
        EMIT_ELT( dest, 1, (i+1-parity) );
        EMIT_ELT( dest, 2, (i+2) );
        dest += 3;
     }

     CLOSE_ELTS();
      }
   }
   else
      EMIT_PRIM( ctx, GL_TRIANGLE_STRIP, HW_TRIANGLE_STRIP_0, start, count );
}

static void TAG(render_tri_fan_verts)( GLcontext *ctx,
                       GLuint start,
                       GLuint count,
                       GLuint flags )
{
   LOCAL_VARS;
   if (0) fprintf(stderr, "%s\n", __FUNCTION__);

   if (start+2 >= count) 
      return;

   if (PREFER_DISCRETE_ELT_PRIM( count-start, HW_TRIANGLES ))
   {   
      int dmasz = GET_MAX_HW_ELTS();
      GLuint j, nr;

      ELT_INIT( GL_TRIANGLES, HW_TRIANGLES );

      dmasz = dmasz/3;

      for (j = start + 1; j + 1 < count; j += nr - 1 ) {
     ELT_TYPE *dest;
     GLint i;

     nr = MIN2( dmasz, count - j );
     dest = ALLOC_ELTS( (nr-1)*3 );
        
     for ( i = j ; i+1 < j+nr ; i++ ) {
        EMIT_ELT( dest, 0, (start) );
        EMIT_ELT( dest, 1, (i) );
        EMIT_ELT( dest, 2, (i+1) );
        dest += 3;
     }
     
     CLOSE_ELTS();
      }
   }
   else {
      EMIT_PRIM( ctx, GL_TRIANGLE_FAN, HW_TRIANGLE_FAN, start, count );
   }
}


static void TAG(render_poly_verts)( GLcontext *ctx,
                    GLuint start,
                    GLuint count,
                    GLuint flags )
{
   LOCAL_VARS;
   if (0) fprintf(stderr, "%s\n", __FUNCTION__);

   if (start+2 >= count) 
      return;

   EMIT_PRIM( ctx, GL_POLYGON, HW_POLYGON, start, count );
}

static void TAG(render_quad_strip_verts)( GLcontext *ctx,
                      GLuint start,
                      GLuint count,
                      GLuint flags )
{
   LOCAL_VARS;
   if (0) fprintf(stderr, "%s\n", __FUNCTION__);

   count -= (count-start) & 1;

   if (start+3 >= count) 
      return;

   if (HAVE_QUAD_STRIPS) {
      EMIT_PRIM( ctx, GL_QUAD_STRIP, HW_QUAD_STRIP, start, count );
   } 
   else if (ctx->Light.ShadeModel == GL_FLAT) {
      LOCAL_VARS;
      int dmasz = GET_MAX_HW_ELTS();
      GLuint j, nr;

      ELT_INIT( GL_TRIANGLES, HW_TRIANGLES );

      /* Emit whole number of quads in total, and in each buffer.
       */
      dmasz = (dmasz/6)*2;

      for (j = start; j + 3 < count; j += nr - 2 ) {
     ELT_TYPE *dest;
     GLint quads, i;

     nr = MIN2( dmasz, count - j );
     quads = (nr/2)-1;
     dest = ALLOC_ELTS( quads*6 );
        
     for ( i = j ; i < j+quads*2 ; i+=2 ) {
        EMIT_TWO_ELTS( dest, 0, (i+0), (i+1) );
        EMIT_TWO_ELTS( dest, 2, (i+2), (i+1) );
        EMIT_TWO_ELTS( dest, 4, (i+3), (i+2) );
        dest += 6;
     }

     CLOSE_ELTS();
      }
   }
   else {
      EMIT_PRIM( ctx, GL_TRIANGLE_STRIP, HW_TRIANGLE_STRIP_0, start, count );
   }
}


static void TAG(render_quads_verts)( GLcontext *ctx,
                     GLuint start,
                     GLuint count,
                     GLuint flags )
{
   LOCAL_VARS;
   if (0) fprintf(stderr, "%s\n", __FUNCTION__);
   count -= (count-start)%4;

   if (start+3 >= count) 
      return;

   if (HAVE_QUADS) {
      EMIT_PRIM( ctx, GL_QUADS, HW_QUADS, start, count );
   } 
   else {
      /* Hardware doesn't have a quad primitive type -- simulate it
       * using indexed vertices and the triangle primitive: 
       */
      LOCAL_VARS;
      int dmasz = GET_MAX_HW_ELTS();
      GLuint j, nr;

      ELT_INIT( GL_TRIANGLES, HW_TRIANGLES );

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

      for (j = start; j < count; j += nr ) {
     ELT_TYPE *dest;
     GLint quads, i;

     nr = MIN2( dmasz, count - j );
     quads = nr/4;
     dest = ALLOC_ELTS( quads*6 );

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

     CLOSE_ELTS();
      }
   }
}

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

static void TAG(render_points_elts)( GLcontext *ctx,
                     GLuint start,
                     GLuint count,
                     GLuint flags )
{
   LOCAL_VARS;
   int dmasz = GET_MAX_HW_ELTS();
   GLuint *elts = GET_MESA_ELTS();
   GLuint j, nr;
   ELT_TYPE *dest;

   ELT_INIT( GL_POINTS, HW_POINTS );

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



static void TAG(render_lines_elts)( GLcontext *ctx,
                    GLuint start,
                    GLuint count,
                    GLuint flags )
{
   LOCAL_VARS;
   int dmasz = GET_MAX_HW_ELTS();
   GLuint *elts = GET_MESA_ELTS();
   GLuint j, nr;
   ELT_TYPE *dest;

   if (start+1 >= count)
      return;

   if ((flags & PRIM_BEGIN) && ctx->Line.StippleFlag) {
      RESET_STIPPLE();
      AUTO_STIPPLE( GL_TRUE );
   }

   ELT_INIT( GL_LINES, HW_LINES );

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

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

   if ((flags & PRIM_END) && ctx->Line.StippleFlag)
      AUTO_STIPPLE( GL_FALSE );
}


static void TAG(render_line_strip_elts)( GLcontext *ctx,
                     GLuint start,
                     GLuint count,
                     GLuint flags )
{
   LOCAL_VARS;
   int dmasz = GET_MAX_HW_ELTS();
   GLuint *elts = GET_MESA_ELTS();
   GLuint j, nr;
   ELT_TYPE *dest;

   if (start+1 >= count)
      return;

   ELT_INIT( GL_LINE_STRIP, HW_LINE_STRIP );

   if ((flags & PRIM_BEGIN) && ctx->Line.StippleFlag)
      RESET_STIPPLE();

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


static void TAG(render_line_loop_elts)( GLcontext *ctx,
                    GLuint start,
                    GLuint count,
                    GLuint flags )
{
   LOCAL_VARS;
   int dmasz = GET_MAX_HW_ELTS();
   GLuint *elts = GET_MESA_ELTS();
   GLuint j, nr;
   ELT_TYPE *dest;

   if (0) fprintf(stderr, "%s\n", __FUNCTION__);

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

   
   if (flags & PRIM_END) {
      if (start+1 >= count)
     return;
   } 
   else {
      if (j+1 >= count)
     return;
   }

   ELT_INIT( GL_LINE_STRIP, HW_LINE_STRIP );

   if ((flags & PRIM_BEGIN) && ctx->Line.StippleFlag)
      RESET_STIPPLE();

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

   for ( ; j + 1 < count; ) {
      nr = MIN2( dmasz, count - j );
      dest = ALLOC_ELTS( nr+1 );    /* Reserve possible space for last elt */
      dest = TAG(emit_elts)( ctx, dest, elts+j, nr );
      j += nr - 1;
      if (j + 1 >= count && (flags & PRIM_END)) {
     dest = TAG(emit_elts)( ctx, dest, elts+start, 1 );
      }
      CLOSE_ELTS();
   }
}


static void TAG(render_triangles_elts)( GLcontext *ctx,
                    GLuint start,
                    GLuint count,
                    GLuint flags )
{
   LOCAL_VARS;
   GLuint *elts = GET_MESA_ELTS();
   int dmasz = GET_MAX_HW_ELTS()/3*3;
   GLuint j, nr;
   ELT_TYPE *dest;

   if (start+2 >= count)
      return;

   ELT_INIT( GL_TRIANGLES, HW_TRIANGLES );


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

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



static void TAG(render_tri_strip_elts)( GLcontext *ctx,
                    GLuint start,
                    GLuint count,
                    GLuint flags )
{
   LOCAL_VARS;
   GLuint j, nr;
   GLuint *elts = GET_MESA_ELTS();
   int dmasz = GET_MAX_HW_ELTS();
   ELT_TYPE *dest;

   if (start+2 >= count)
      return;

   ELT_INIT( GL_TRIANGLE_STRIP, HW_TRIANGLE_STRIP_0 );

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

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

      dest = ALLOC_ELTS( nr );
      dest = TAG(emit_elts)( ctx, dest, elts+j, nr );
      CLOSE_ELTS();
   }
}

static void TAG(render_tri_fan_elts)( GLcontext *ctx,
                      GLuint start,
                      GLuint count,
                      GLuint flags )
{
   LOCAL_VARS;
   GLuint *elts = GET_MESA_ELTS();
   GLuint j, nr;
   int dmasz = GET_MAX_HW_ELTS();
   ELT_TYPE *dest;

   if (start+2 >= count)
      return;

   ELT_INIT( GL_TRIANGLE_FAN, HW_TRIANGLE_FAN );

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


static void TAG(render_poly_elts)( GLcontext *ctx,
                   GLuint start,
                   GLuint count,
                   GLuint flags )
{
   LOCAL_VARS;
   GLuint *elts = GET_MESA_ELTS();
   GLuint j, nr;
   int dmasz = GET_MAX_HW_ELTS();
   ELT_TYPE *dest;

   if (start+2 >= count)
      return;

   ELT_INIT( GL_POLYGON, HW_POLYGON );

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

static void TAG(render_quad_strip_elts)( GLcontext *ctx,
                     GLuint start,
                     GLuint count,
                     GLuint flags )
{
   if (start+3 >= count)
      return;

   if (HAVE_QUAD_STRIPS && 0) {
   }
   else {
      LOCAL_VARS;
      GLuint *elts = GET_MESA_ELTS();
      int dmasz = GET_MAX_HW_ELTS();
      GLuint j, nr;
      ELT_TYPE *dest;

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

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

     dmasz = dmasz/6*2;

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

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

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

           CLOSE_ELTS();
        }
     }
      }
      else {
     ELT_INIT( GL_TRIANGLE_STRIP, HW_TRIANGLE_STRIP_0 );

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


static void TAG(render_quads_elts)( GLcontext *ctx,
                    GLuint start,
                    GLuint count,
                    GLuint flags )
{
   if (start+3 >= count)
      return;

   if (HAVE_QUADS && 0) {
   } else {
      LOCAL_VARS;
      GLuint *elts = GET_MESA_ELTS();
      int dmasz = GET_MAX_HW_ELTS();
      GLuint j, nr;

      ELT_INIT( GL_TRIANGLES, HW_TRIANGLES );

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

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

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

     {
        GLint quads = nr/4;
        ELT_TYPE *dest = ALLOC_ELTS( quads * 6 );
        GLint i;

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

        CLOSE_ELTS();
     }
      }
   }
}



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),
};