src/mesa/tnl_dd/t_dd_dmatmp.h

   1 /*
   2  * Mesa 3-D graphics library
   3  * Version:  6.5.1
   4  *
   5  * Copyright (C) 1999-2006  Brian Paul   All Rights Reserved.
   6  *
   7  * Permission is hereby granted, free of charge, to any person obtaining a
   8  * copy of this software and associated documentation files (the "Software"),
   9  * to deal in the Software without restriction, including without limitation
  10  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
  11  * and/or sell copies of the Software, and to permit persons to whom the
  12  * Software is furnished to do so, subject to the following conditions:
  13  *
  14  * The above copyright notice and this permission notice shall be included
  15  * in all copies or substantial portions of the Software.
  16  *
  17  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  18  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  19  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
  20  * BRIAN PAUL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
  21  * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
  22  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  23  *
  24  * Authors:
  25  *    Keith Whitwell <keith@tungstengraphics.com>
  26  */
  27
  28
  29 /**
  30  * \file t_dd_dmatmp.h
  31  * Template for render stages which build and emit vertices directly
  32  * to fixed-size dma buffers.  Useful for rendering strips and other
  33  * native primitives where clipping and per-vertex tweaks such as
  34  * those in t_dd_tritmp.h are not required.
  35  *
  36  * Produces code for both inline triangles and indexed triangles.
  37  * Where various primitive types are unaccelerated by hardware, the
  38  * code attempts to fallback to other primitive types (quadstrips to
  39  * tristrips, lineloops to linestrips), or to indexed vertices.
  40  */
  41
  42 #if !defined(HAVE_TRIANGLES)
  43 #error "must have at least triangles to use render template"
  44 #endif
  45
  46 #if !HAVE_ELTS
  47 #define ELTS_VARS(buf)
  48 #define ALLOC_ELTS(nr) 0
  49 #define EMIT_ELT( offset, elt )
  50 #define EMIT_TWO_ELTS( offset, elt0, elt1 )
  51 #define INCR_ELTS( nr )
  52 #define ELT_INIT(prim)
  53 #define GET_CURRENT_VB_MAX_ELTS() 0
  54 #define GET_SUBSEQUENT_VB_MAX_ELTS() 0
  55 #define RELEASE_ELT_VERTS()
  56 #define EMIT_INDEXED_VERTS( ctx, start, count )
  57 #endif
  58
  59 #ifndef EMIT_TWO_ELTS
  60 #define EMIT_TWO_ELTS( offset, elt0, elt1 )     \
  61 do {                                            \
  62    EMIT_ELT( offset, elt0 );                    \
  63    EMIT_ELT( offset+1, elt1 );                  \
  64 } while (0)
  65 #endif
  66
  67
  68 /**********************************************************************/
  69 /*                  Render whole begin/end objects                    */
  70 /**********************************************************************/
  71
  72
  73
  74
  75 #if (HAVE_ELTS)
  76 static void *TAG(emit_elts)( struct gl_context *ctx, GLuint *elts, GLuint nr,
  77                              void *buf)
  78 {
  79    GLint i;
  80    LOCAL_VARS;
  81    ELTS_VARS(buf);
  82
  83    for ( i = 0 ; i+1 < nr ; i+=2, elts += 2 ) {
  84       EMIT_TWO_ELTS( 0, elts[0], elts[1] );
  85       INCR_ELTS( 2 );
  86    }
  87
  88    if (i < nr) {
  89       EMIT_ELT( 0, elts[0] );
  90       INCR_ELTS( 1 );
  91    }
  92
  93    return (void *)ELTPTR;
  94 }
  95 #endif
  96
  97 static __inline void *TAG(emit_verts)( struct gl_context *ctx, GLuint start,
  98                                      GLuint count, void *buf )
  99 {
 100    return EMIT_VERTS(ctx, start, count, buf);
 101 }
 102
 103 /***********************************************************************
 104  *                    Render non-indexed primitives.
 105  ***********************************************************************/
 106
 107 static void TAG(render_points_verts)( struct gl_context *ctx,
 108                                       GLuint start,
 109                                       GLuint count,
 110                                       GLuint flags )
 111 {
 112    if (HAVE_POINTS) {
 113       LOCAL_VARS;
 114       int dmasz = GET_SUBSEQUENT_VB_MAX_VERTS();
 115       int currentsz;
 116       GLuint j, nr;
 117
 118       INIT( GL_POINTS );
 119
 120       currentsz = GET_CURRENT_VB_MAX_VERTS();
 121       if (currentsz < 8)
 122          currentsz = dmasz;
 123
 124       for (j = start; j < count; j += nr ) {
 125          nr = MIN2( currentsz, count - j );
 126          TAG(emit_verts)( ctx, j, nr, ALLOC_VERTS(nr) );
 127          currentsz = dmasz;
 128       }
 129
 130    } else {
 131       fprintf(stderr, "%s - cannot draw primitive\n", __FUNCTION__);
 132       return;
 133    }
 134 }
 135
 136 static void TAG(render_lines_verts)( struct gl_context *ctx,
 137                                      GLuint start,
 138                                      GLuint count,
 139                                      GLuint flags )
 140 {
 141    if (HAVE_LINES) {
 142       LOCAL_VARS;
 143       int dmasz = GET_SUBSEQUENT_VB_MAX_VERTS();
 144       int currentsz;
 145       GLuint j, nr;
 146
 147       INIT( GL_LINES );
 148
 149       /* Emit whole number of lines in total and in each buffer:
 150        */
 151       count -= (count-start) & 1;
 152       currentsz = GET_CURRENT_VB_MAX_VERTS();
 153       currentsz -= currentsz & 1;
 154       dmasz -= dmasz & 1;
 155
 156       if (currentsz < 8)
 157          currentsz = dmasz;
 158
 159       for (j = start; j < count; j += nr ) {
 160          nr = MIN2( currentsz, count - j );
 161          TAG(emit_verts)( ctx, j, nr, ALLOC_VERTS(nr) );
 162          currentsz = dmasz;
 163       }
 164
 165    } else {
 166       fprintf(stderr, "%s - cannot draw primitive\n", __FUNCTION__);
 167       return;
 168    }
 169 }
 170
 171
 172 static void TAG(render_line_strip_verts)( struct gl_context *ctx,
 173                                           GLuint start,
 174                                           GLuint count,
 175                                           GLuint flags )
 176 {
 177    if (HAVE_LINE_STRIPS) {
 178       LOCAL_VARS;
 179       int dmasz = GET_SUBSEQUENT_VB_MAX_VERTS();
 180       int currentsz;
 181       GLuint j, nr;
 182
 183       INIT( GL_LINE_STRIP );
 184
 185       currentsz = GET_CURRENT_VB_MAX_VERTS();
 186       if (currentsz < 8)
 187          currentsz = dmasz;
 188
 189       for (j = start; j + 1 < count; j += nr - 1 ) {
 190          nr = MIN2( currentsz, count - j );
 191          TAG(emit_verts)( ctx, j, nr, ALLOC_VERTS(nr) );
 192          currentsz = dmasz;
 193       }
 194
 195       FLUSH();
 196
 197    } else {
 198       fprintf(stderr, "%s - cannot draw primitive\n", __FUNCTION__);
 199       return;
 200    }
 201 }
 202
 203
 204 static void TAG(render_line_loop_verts)( struct gl_context *ctx,
 205                                          GLuint start,
 206                                          GLuint count,
 207                                          GLuint flags )
 208 {
 209    if (HAVE_LINE_STRIPS) {
 210       LOCAL_VARS;
 211       int dmasz = GET_SUBSEQUENT_VB_MAX_VERTS();
 212       int currentsz;
 213       GLuint j, nr;
 214
 215       INIT( GL_LINE_STRIP );
 216
 217       if (flags & PRIM_BEGIN)
 218          j = start;
 219       else
 220          j = start + 1;
 221
 222       /* Ensure last vertex won't wrap buffers:
 223        */
 224       currentsz = GET_CURRENT_VB_MAX_VERTS();
 225       currentsz--;
 226       dmasz--;
 227
 228       if (currentsz < 8) {
 229          currentsz = dmasz;
 230       }
 231
 232       if (j + 1 < count) {
 233          for ( ; j + 1 < count; j += nr - 1 ) {
 234             nr = MIN2( currentsz, count - j );
 235
 236             if (j + nr >= count &&
 237                 start < count - 1 &&
 238                 (flags & PRIM_END))
 239             {
 240                void *tmp;
 241                tmp = ALLOC_VERTS(nr+1);
 242                tmp = TAG(emit_verts)( ctx, j, nr, tmp );
 243                tmp = TAG(emit_verts)( ctx, start, 1, tmp );
 244                (void) tmp;
 245             }
 246             else {
 247                TAG(emit_verts)( ctx, j, nr, ALLOC_VERTS(nr) );
 248                currentsz = dmasz;
 249             }
 250          }
 251
 252       }
 253       else if (start + 1 < count && (flags & PRIM_END)) {
 254          void *tmp;
 255          tmp = ALLOC_VERTS(2);
 256          tmp = TAG(emit_verts)( ctx, start+1, 1, tmp );
 257          tmp = TAG(emit_verts)( ctx, start, 1, tmp );
 258          (void) tmp;
 259       }
 260
 261       FLUSH();
 262
 263    } else {
 264       fprintf(stderr, "%s - cannot draw primitive\n", __FUNCTION__);
 265       return;
 266    }
 267 }
 268
 269
 270 static void TAG(render_triangles_verts)( struct gl_context *ctx,
 271                                          GLuint start,
 272                                          GLuint count,
 273                                          GLuint flags )
 274 {
 275    LOCAL_VARS;
 276    int dmasz = (GET_SUBSEQUENT_VB_MAX_VERTS()/3) * 3;
 277    int currentsz;
 278    GLuint j, nr;
 279
 280    INIT(GL_TRIANGLES);
 281
 282    currentsz = (GET_CURRENT_VB_MAX_VERTS()/3) * 3;
 283
 284    /* Emit whole number of tris in total.  dmasz is already a multiple
 285     * of 3.
 286     */
 287    count -= (count-start)%3;
 288
 289    if (currentsz < 8)
 290       currentsz = dmasz;
 291
 292    for (j = start; j < count; j += nr) {
 293       nr = MIN2( currentsz, count - j );
 294       TAG(emit_verts)( ctx, j, nr, ALLOC_VERTS(nr) );
 295       currentsz = dmasz;
 296    }
 297 }
 298
 299
 300
 301 static void TAG(render_tri_strip_verts)( struct gl_context *ctx,
 302                                          GLuint start,
 303                                          GLuint count,
 304                                          GLuint flags )
 305 {
 306    if (HAVE_TRI_STRIPS) {
 307       LOCAL_VARS;
 308       GLuint j, nr;
 309       int dmasz = GET_SUBSEQUENT_VB_MAX_VERTS();
 310       int currentsz;
 311
 312       INIT(GL_TRIANGLE_STRIP);
 313
 314       currentsz = GET_CURRENT_VB_MAX_VERTS();
 315
 316       if (currentsz < 8) {
 317          currentsz = dmasz;
 318       }
 319
 320       /* From here on emit even numbers of tris when wrapping over buffers:
 321        */
 322       dmasz -= (dmasz & 1);
 323       currentsz -= (currentsz & 1);
 324
 325       for (j = start ; j + 2 < count; j += nr - 2 ) {
 326          nr = MIN2( currentsz, count - j );
 327          TAG(emit_verts)( ctx, j, nr, ALLOC_VERTS(nr) );
 328          currentsz = dmasz;
 329       }
 330
 331       FLUSH();
 332
 333    } else {
 334       fprintf(stderr, "%s - cannot draw primitive\n", __FUNCTION__);
 335       return;
 336    }
 337 }
 338
 339 static void TAG(render_tri_fan_verts)( struct gl_context *ctx,
 340                                        GLuint start,
 341                                        GLuint count,
 342                                        GLuint flags )
 343 {
 344    if (HAVE_TRI_FANS) {
 345       LOCAL_VARS;
 346       GLuint j, nr;
 347       int dmasz = GET_SUBSEQUENT_VB_MAX_VERTS();
 348       int currentsz;
 349
 350       INIT(GL_TRIANGLE_FAN);
 351
 352       currentsz = GET_CURRENT_VB_MAX_VERTS();
 353       if (currentsz < 8) {
 354          currentsz = dmasz;
 355       }
 356
 357       for (j = start + 1 ; j + 1 < count; j += nr - 2 ) {
 358          void *tmp;
 359          nr = MIN2( currentsz, count - j + 1 );
 360          tmp = ALLOC_VERTS( nr );
 361          tmp = TAG(emit_verts)( ctx, start, 1, tmp );
 362          tmp = TAG(emit_verts)( ctx, j, nr - 1, tmp );
 363          (void) tmp;
 364          currentsz = dmasz;
 365       }
 366
 367       FLUSH();
 368    }
 369    else {
 370       /* Could write code to emit these as indexed vertices (for the
 371        * g400, for instance).
 372        */
 373       fprintf(stderr, "%s - cannot draw primitive\n", __FUNCTION__);
 374       return;
 375    }
 376 }
 377
 378
 379 static void TAG(render_poly_verts)( struct gl_context *ctx,
 380                                     GLuint start,
 381                                     GLuint count,
 382                                     GLuint flags )
 383 {
 384    if (HAVE_POLYGONS) {
 385       LOCAL_VARS;
 386       GLuint j, nr;
 387       int dmasz = GET_SUBSEQUENT_VB_MAX_VERTS();
 388       int currentsz;
 389
 390       INIT(GL_POLYGON);
 391
 392       currentsz = GET_CURRENT_VB_MAX_VERTS();
 393       if (currentsz < 8) {
 394          currentsz = dmasz;
 395       }
 396
 397       for (j = start + 1 ; j + 1 < count ; j += nr - 2 ) {
 398          void *tmp;
 399          nr = MIN2( currentsz, count - j + 1 );
 400          tmp = ALLOC_VERTS( nr );
 401          tmp = TAG(emit_verts)( ctx, start, 1, tmp );
 402          tmp = TAG(emit_verts)( ctx, j, nr - 1, tmp );
 403          (void) tmp;
 404          currentsz = dmasz;
 405       }
 406
 407       FLUSH();
 408    }
 409    else if (HAVE_TRI_FANS && ctx->Light.ShadeModel == GL_SMOOTH) {
 410       TAG(render_tri_fan_verts)( ctx, start, count, flags );
 411    } else {
 412       fprintf(stderr, "%s - cannot draw primitive\n", __FUNCTION__);
 413       return;
 414    }
 415 }
 416
 417 static void TAG(render_quad_strip_verts)( struct gl_context *ctx,
 418                                           GLuint start,
 419                                           GLuint count,
 420                                           GLuint flags )
 421 {
 422    GLuint j, nr;
 423
 424    if (HAVE_QUAD_STRIPS) {
 425       LOCAL_VARS;
 426       GLuint j, nr;
 427       int dmasz = GET_SUBSEQUENT_VB_MAX_VERTS();
 428       int currentsz;
 429
 430       INIT(GL_QUAD_STRIP);
 431
 432       currentsz = GET_CURRENT_VB_MAX_VERTS();
 433       if (currentsz < 8) {
 434          currentsz = dmasz;
 435       }
 436
 437       dmasz -= (dmasz & 2);
 438       currentsz -= (currentsz & 2);
 439
 440       for (j = start ; j + 3 < count; j += nr - 2 ) {
 441          nr = MIN2( currentsz, count - j );
 442          TAG(emit_verts)( ctx, j, nr, ALLOC_VERTS(nr) );
 443          currentsz = dmasz;
 444       }
 445
 446       FLUSH();
 447
 448    } else if (HAVE_TRI_STRIPS &&
 449               ctx->Light.ShadeModel == GL_FLAT &&
 450               TNL_CONTEXT(ctx)->vb.AttribPtr[_TNL_ATTRIB_COLOR0]->stride) {
 451       if (HAVE_ELTS) {
 452          LOCAL_VARS;
 453          int dmasz = GET_SUBSEQUENT_VB_MAX_ELTS();
 454          int currentsz;
 455          GLuint j, nr;
 456
 457          EMIT_INDEXED_VERTS( ctx, start, count );
 458
 459          /* Simulate flat-shaded quadstrips using indexed vertices:
 460           */
 461          ELT_INIT( GL_TRIANGLES );
 462
 463          currentsz = GET_CURRENT_VB_MAX_ELTS();
 464
 465          /* Emit whole number of quads in total, and in each buffer.
 466           */
 467          dmasz -= dmasz & 1;
 468          count -= (count-start) & 1;
 469          currentsz -= currentsz & 1;
 470
 471          if (currentsz < 12)
 472             currentsz = dmasz;
 473
 474          currentsz = currentsz/6*2;
 475          dmasz = dmasz/6*2;
 476
 477          for (j = start; j + 3 < count; j += nr - 2 ) {
 478             nr = MIN2( currentsz, count - j );
 479             if (nr >= 4) {
 480                GLint quads = (nr/2)-1;
 481                GLint i;
 482                ELTS_VARS( ALLOC_ELTS( quads*6 ) );
 483
 484                for ( i = j-start ; i < j-start+quads*2 ; i+=2 ) {
 485                   EMIT_TWO_ELTS( 0, (i+0), (i+1) );
 486                   EMIT_TWO_ELTS( 2, (i+2), (i+1) );
 487                   EMIT_TWO_ELTS( 4, (i+3), (i+2) );
 488                   INCR_ELTS( 6 );
 489                }
 490
 491                FLUSH();
 492             }
 493             currentsz = dmasz;
 494          }
 495
 496          RELEASE_ELT_VERTS();
 497          FLUSH();
 498       }
 499       else {
 500          /* Vertices won't fit in a single buffer or elts not
 501           * available - should never happen.
 502           */
 503          fprintf(stderr, "%s - cannot draw primitive\n", __FUNCTION__);
 504          return;
 505       }
 506    }
 507    else if (HAVE_TRI_STRIPS) {
 508       LOCAL_VARS;
 509       int dmasz = GET_SUBSEQUENT_VB_MAX_VERTS();
 510       int currentsz;
 511
 512       /* Emit smooth-shaded quadstrips as tristrips:
 513        */
 514       FLUSH();
 515       INIT( GL_TRIANGLE_STRIP );
 516
 517       /* Emit whole number of quads in total, and in each buffer.
 518        */
 519       dmasz -= dmasz & 1;
 520       currentsz = GET_CURRENT_VB_MAX_VERTS();
 521       currentsz -= currentsz & 1;
 522       count -= (count-start) & 1;
 523
 524       if (currentsz < 8) {
 525          currentsz = dmasz;
 526       }
 527
 528       for (j = start; j + 3 < count; j += nr - 2 ) {
 529          nr = MIN2( currentsz, count - j );
 530          TAG(emit_verts)( ctx, j, nr, ALLOC_VERTS(nr) );
 531          currentsz = dmasz;
 532       }
 533
 534       FLUSH();
 535
 536    } else {
 537       fprintf(stderr, "%s - cannot draw primitive\n", __FUNCTION__);
 538       return;
 539    }
 540 }
 541
 542
 543 static void TAG(render_quads_verts)( struct gl_context *ctx,
 544                                      GLuint start,
 545                                      GLuint count,
 546                                      GLuint flags )
 547 {
 548    if (HAVE_QUADS) {
 549       LOCAL_VARS;
 550       int dmasz = (GET_SUBSEQUENT_VB_MAX_VERTS()/4) * 4;
 551       int currentsz;
 552       GLuint j, nr;
 553
 554       INIT(GL_QUADS);
 555
 556       /* Emit whole number of quads in total.  dmasz is already a multiple
 557        * of 4.
 558        */
 559       count -= (count-start)%4;
 560
 561       currentsz = (GET_CURRENT_VB_MAX_VERTS()/4) * 4;
 562       if (currentsz < 8)
 563          currentsz = dmasz;
 564
 565       for (j = start; j < count; j += nr) {
 566          nr = MIN2( currentsz, count - j );
 567          TAG(emit_verts)( ctx, j, nr, ALLOC_VERTS(nr) );
 568          currentsz = dmasz;
 569       }
 570    }
 571    else if (HAVE_ELTS) {
 572       /* Hardware doesn't have a quad primitive type -- try to
 573        * simulate it using indexed vertices and the triangle
 574        * primitive:
 575        */
 576       LOCAL_VARS;
 577       int dmasz = GET_SUBSEQUENT_VB_MAX_ELTS();
 578       int currentsz;
 579       GLuint j, nr;
 580
 581       EMIT_INDEXED_VERTS( ctx, start, count );
 582
 583       FLUSH();
 584       ELT_INIT( GL_TRIANGLES );
 585       currentsz = GET_CURRENT_VB_MAX_ELTS();
 586
 587       /* Emit whole number of quads in total, and in each buffer.
 588        */
 589       dmasz -= dmasz & 3;
 590       count -= (count-start) & 3;
 591       currentsz -= currentsz & 3;
 592
 593       /* Adjust for rendering as triangles:
 594        */
 595       currentsz = currentsz/6*4;
 596       dmasz = dmasz/6*4;
 597
 598       if (currentsz < 8)
 599          currentsz = dmasz;
 600
 601       for (j = start; j < count; j += nr ) {
 602          nr = MIN2( currentsz, count - j );
 603          if (nr >= 4) {
 604             GLint quads = nr/4;
 605             GLint i;
 606             ELTS_VARS( ALLOC_ELTS( quads*6 ) );
 607
 608             for ( i = j-start ; i < j-start+quads*4 ; i+=4 ) {
 609                EMIT_TWO_ELTS( 0, (i+0), (i+1) );
 610                EMIT_TWO_ELTS( 2, (i+3), (i+1) );
 611                EMIT_TWO_ELTS( 4, (i+2), (i+3) );
 612                INCR_ELTS( 6 );
 613             }
 614
 615             FLUSH();
 616          }
 617          currentsz = dmasz;
 618       }
 619
 620       RELEASE_ELT_VERTS();
 621    }
 622    else if (HAVE_TRIANGLES) {
 623       /* Hardware doesn't have a quad primitive type -- try to
 624        * simulate it using triangle primitive.  This is a win for
 625        * gears, but is it useful in the broader world?
 626        */
 627       LOCAL_VARS;
 628       GLuint j;
 629
 630       INIT(GL_TRIANGLES);
 631
 632       for (j = start; j < count-3; j += 4) {
 633          void *tmp = ALLOC_VERTS( 6 );
 634          /* Send v0, v1, v3
 635           */
 636          tmp = EMIT_VERTS(ctx, j,     2, tmp);
 637          tmp = EMIT_VERTS(ctx, j + 3, 1, tmp);
 638          /* Send v1, v2, v3
 639           */
 640          tmp = EMIT_VERTS(ctx, j + 1, 3, tmp);
 641          (void) tmp;
 642       }
 643    }
 644    else {
 645       /* Vertices won't fit in a single buffer, should never happen.
 646        */
 647       fprintf(stderr, "%s - cannot draw primitive\n", __FUNCTION__);
 648       return;
 649    }
 650 }
 651
 652 static void TAG(render_noop)( struct gl_context *ctx,
 653                               GLuint start,
 654                               GLuint count,
 655                               GLuint flags )
 656 {
 657 }
 658
 659
 660
 661
 662 static tnl_render_func TAG(render_tab_verts)[GL_POLYGON+2] =
 663 {
 664    TAG(render_points_verts),
 665    TAG(render_lines_verts),
 666    TAG(render_line_loop_verts),
 667    TAG(render_line_strip_verts),
 668    TAG(render_triangles_verts),
 669    TAG(render_tri_strip_verts),
 670    TAG(render_tri_fan_verts),
 671    TAG(render_quads_verts),
 672    TAG(render_quad_strip_verts),
 673    TAG(render_poly_verts),
 674    TAG(render_noop),
 675 };
 676
 677
 678 /****************************************************************************
 679  *                 Render elts using hardware indexed verts                 *
 680  ****************************************************************************/
 681
 682 #if (HAVE_ELTS)
 683 static void TAG(render_points_elts)( struct gl_context *ctx,
 684                                      GLuint start,
 685                                      GLuint count,
 686                                      GLuint flags )
 687 {
 688    if (HAVE_POINTS) {
 689       LOCAL_VARS;
 690       int dmasz = GET_SUBSEQUENT_VB_MAX_ELTS();
 691       int currentsz;
 692       GLuint *elts = TNL_CONTEXT(ctx)->vb.Elts;
 693       GLuint j, nr;
 694
 695       ELT_INIT( GL_POINTS );
 696
 697       currentsz = GET_CURRENT_VB_MAX_ELTS();
 698       if (currentsz < 8)
 699          currentsz = dmasz;
 700
 701       for (j = start; j < count; j += nr ) {
 702          nr = MIN2( currentsz, count - j );
 703          TAG(emit_elts)( ctx, elts+j, nr, ALLOC_ELTS(nr) );
 704          FLUSH();
 705          currentsz = dmasz;
 706       }
 707    } else {
 708       fprintf(stderr, "%s - cannot draw primitive\n", __FUNCTION__);
 709       return;
 710    }
 711 }
 712
 713
 714
 715 static void TAG(render_lines_elts)( struct gl_context *ctx,
 716                                     GLuint start,
 717                                     GLuint count,
 718                                     GLuint flags )
 719 {
 720    if (HAVE_LINES) {
 721       LOCAL_VARS;
 722       int dmasz = GET_SUBSEQUENT_VB_MAX_ELTS();
 723       int currentsz;
 724       GLuint *elts = TNL_CONTEXT(ctx)->vb.Elts;
 725       GLuint j, nr;
 726
 727       ELT_INIT( GL_LINES );
 728
 729       /* Emit whole number of lines in total and in each buffer:
 730        */
 731       count -= (count-start) & 1;
 732       currentsz -= currentsz & 1;
 733       dmasz -= dmasz & 1;
 734
 735       currentsz = GET_CURRENT_VB_MAX_ELTS();
 736       if (currentsz < 8)
 737          currentsz = dmasz;
 738
 739       for (j = start; j < count; j += nr ) {
 740          nr = MIN2( currentsz, count - j );
 741          TAG(emit_elts)( ctx, elts+j, nr, ALLOC_ELTS(nr) );
 742          FLUSH();
 743          currentsz = dmasz;
 744       }
 745    } else {
 746       fprintf(stderr, "%s - cannot draw primitive\n", __FUNCTION__);
 747       return;
 748    }
 749 }
 750
 751
 752 static void TAG(render_line_strip_elts)( struct gl_context *ctx,
 753                                          GLuint start,
 754                                          GLuint count,
 755                                          GLuint flags )
 756 {
 757    if (HAVE_LINE_STRIPS) {
 758       LOCAL_VARS;
 759       int dmasz = GET_SUBSEQUENT_VB_MAX_ELTS();
 760       int currentsz;
 761       GLuint *elts = TNL_CONTEXT(ctx)->vb.Elts;
 762       GLuint j, nr;
 763
 764       FLUSH(); /* always a new primitive */
 765       ELT_INIT( GL_LINE_STRIP );
 766
 767       currentsz = GET_CURRENT_VB_MAX_ELTS();
 768       if (currentsz < 8)
 769          currentsz = dmasz;
 770
 771       for (j = start; j + 1 < count; j += nr - 1 ) {
 772          nr = MIN2( currentsz, count - j );
 773          TAG(emit_elts)( ctx, elts+j, nr, ALLOC_ELTS(nr) );
 774          FLUSH();
 775          currentsz = dmasz;
 776       }
 777    } else {
 778       /* TODO: Try to emit as indexed lines.
 779        */
 780       fprintf(stderr, "%s - cannot draw primitive\n", __FUNCTION__);
 781       return;
 782    }
 783 }
 784
 785
 786 static void TAG(render_line_loop_elts)( struct gl_context *ctx,
 787                                         GLuint start,
 788                                         GLuint count,
 789                                         GLuint flags )
 790 {
 791    if (HAVE_LINE_STRIPS) {
 792       LOCAL_VARS;
 793       int dmasz = GET_SUBSEQUENT_VB_MAX_ELTS();
 794       int currentsz;
 795       GLuint *elts = TNL_CONTEXT(ctx)->vb.Elts;
 796       GLuint j, nr;
 797
 798       FLUSH();
 799       ELT_INIT( GL_LINE_STRIP );
 800
 801       if (flags & PRIM_BEGIN)
 802          j = start;
 803       else
 804          j = start + 1;
 805
 806       currentsz = GET_CURRENT_VB_MAX_ELTS();
 807       if (currentsz < 8) {
 808          currentsz = dmasz;
 809       }
 810
 811       /* Ensure last vertex doesn't wrap:
 812        */
 813       currentsz--;
 814       dmasz--;
 815
 816       if (j + 1 < count) {
 817          for ( ; j + 1 < count; j += nr - 1 ) {
 818             nr = MIN2( currentsz, count - j );
 819
 820             if (j + nr >= count &&
 821                 start < count - 1 &&
 822                 (flags & PRIM_END))
 823             {
 824                void *tmp;
 825                tmp = ALLOC_ELTS(nr+1);
 826                tmp = TAG(emit_elts)( ctx, elts+j, nr, tmp );
 827                tmp = TAG(emit_elts)( ctx, elts+start, 1, tmp );
 828                (void) tmp;
 829             }
 830             else {
 831                TAG(emit_elts)( ctx, elts+j, nr, ALLOC_ELTS(nr) );
 832                currentsz = dmasz;
 833             }
 834          }
 835
 836       }
 837       else if (start + 1 < count && (flags & PRIM_END)) {
 838          void *tmp;
 839          tmp = ALLOC_ELTS(2);
 840          tmp = TAG(emit_elts)( ctx, elts+start+1, 1, tmp );
 841          tmp = TAG(emit_elts)( ctx, elts+start, 1, tmp );
 842          (void) tmp;
 843       }
 844
 845       FLUSH();
 846    } else {
 847       /* TODO: Try to emit as indexed lines */
 848       fprintf(stderr, "%s - cannot draw primitive\n", __FUNCTION__);
 849       return;
 850    }
 851 }
 852
 853
 854 /* For verts, we still eliminate the copy from main memory to dma
 855  * buffers.  For elts, this is probably no better (worse?) than the
 856  * standard path.
 857  */
 858 static void TAG(render_triangles_elts)( struct gl_context *ctx,
 859                                         GLuint start,
 860                                         GLuint count,
 861                                         GLuint flags )
 862 {
 863    LOCAL_VARS;
 864    GLuint *elts = TNL_CONTEXT(ctx)->vb.Elts;
 865    int dmasz = GET_SUBSEQUENT_VB_MAX_ELTS()/3*3;
 866    int currentsz;
 867    GLuint j, nr;
 868
 869    FLUSH();
 870    ELT_INIT( GL_TRIANGLES );
 871
 872    currentsz = GET_CURRENT_VB_MAX_ELTS();
 873
 874    /* Emit whole number of tris in total.  dmasz is already a multiple
 875     * of 3.
 876     */
 877    count -= (count-start)%3;
 878    currentsz -= currentsz%3;
 879    if (currentsz < 8)
 880       currentsz = dmasz;
 881
 882    for (j = start; j < count; j += nr) {
 883       nr = MIN2( currentsz, count - j );
 884       TAG(emit_elts)( ctx, elts+j, nr, ALLOC_ELTS(nr) );
 885       FLUSH();
 886       currentsz = dmasz;
 887    }
 888 }
 889
 890
 891
 892 static void TAG(render_tri_strip_elts)( struct gl_context *ctx,
 893                                         GLuint start,
 894                                         GLuint count,
 895                                         GLuint flags )
 896 {
 897    if (HAVE_TRI_STRIPS) {
 898       LOCAL_VARS;
 899       GLuint j, nr;
 900       GLuint *elts = TNL_CONTEXT(ctx)->vb.Elts;
 901       int dmasz = GET_SUBSEQUENT_VB_MAX_ELTS();
 902       int currentsz;
 903
 904       FLUSH();
 905       ELT_INIT( GL_TRIANGLE_STRIP );
 906
 907       currentsz = GET_CURRENT_VB_MAX_ELTS();
 908       if (currentsz < 8) {
 909          currentsz = dmasz;
 910       }
 911
 912       /* Keep the same winding over multiple buffers:
 913        */
 914       dmasz -= (dmasz & 1);
 915       currentsz -= (currentsz & 1);
 916
 917       for (j = start ; j + 2 < count; j += nr - 2 ) {
 918          nr = MIN2( currentsz, count - j );
 919          TAG(emit_elts)( ctx, elts+j, nr, ALLOC_ELTS(nr) );
 920          FLUSH();
 921          currentsz = dmasz;
 922       }
 923    } else {
 924       /* TODO: try to emit as indexed triangles */
 925       fprintf(stderr, "%s - cannot draw primitive\n", __FUNCTION__);
 926       return;
 927    }
 928 }
 929
 930 static void TAG(render_tri_fan_elts)( struct gl_context *ctx,
 931                                       GLuint start,
 932                                       GLuint count,
 933                                       GLuint flags )
 934 {
 935    if (HAVE_TRI_FANS) {
 936       LOCAL_VARS;
 937       GLuint *elts = TNL_CONTEXT(ctx)->vb.Elts;
 938       GLuint j, nr;
 939       int dmasz = GET_SUBSEQUENT_VB_MAX_ELTS();
 940       int currentsz;
 941
 942       FLUSH();
 943       ELT_INIT( GL_TRIANGLE_FAN );
 944
 945       currentsz = GET_CURRENT_VB_MAX_ELTS();
 946       if (currentsz < 8) {
 947          currentsz = dmasz;
 948       }
 949
 950       for (j = start + 1 ; j + 1 < count; j += nr - 2 ) {
 951          void *tmp;
 952          nr = MIN2( currentsz, count - j + 1 );
 953          tmp = ALLOC_ELTS( nr );
 954          tmp = TAG(emit_elts)( ctx, elts+start, 1, tmp );
 955          tmp = TAG(emit_elts)( ctx, elts+j, nr - 1, tmp );
 956          (void) tmp;
 957          FLUSH();
 958          currentsz = dmasz;
 959       }
 960    } else {
 961       /* TODO: try to emit as indexed triangles */
 962       fprintf(stderr, "%s - cannot draw primitive\n", __FUNCTION__);
 963       return;
 964    }
 965 }
 966
 967
 968 static void TAG(render_poly_elts)( struct gl_context *ctx,
 969                                    GLuint start,
 970                                    GLuint count,
 971                                    GLuint flags )
 972 {
 973    if (HAVE_POLYGONS) {
 974       LOCAL_VARS;
 975       GLuint *elts = TNL_CONTEXT(ctx)->vb.Elts;
 976       GLuint j, nr;
 977       int dmasz = GET_SUBSEQUENT_VB_MAX_ELTS();
 978       int currentsz;
 979
 980       FLUSH();
 981       ELT_INIT( GL_POLYGON );
 982
 983       currentsz = GET_CURRENT_VB_MAX_ELTS();
 984       if (currentsz < 8) {
 985          currentsz = dmasz;
 986       }
 987
 988       for (j = start + 1 ; j + 1 < count; j += nr - 2 ) {
 989          void *tmp;
 990          nr = MIN2( currentsz, count - j + 1 );
 991          tmp = ALLOC_ELTS( nr );
 992          tmp = TAG(emit_elts)( ctx, elts+start, 1, tmp );
 993          tmp = TAG(emit_elts)( ctx, elts+j, nr - 1, tmp );
 994          (void) tmp;
 995          FLUSH();
 996          currentsz = dmasz;
 997       }
 998    } else if (HAVE_TRI_FANS && ctx->Light.ShadeModel == GL_SMOOTH) {
 999       TAG(render_tri_fan_verts)( ctx, start, count, flags );
1000    } else {
1001       fprintf(stderr, "%s - cannot draw primitive\n", __FUNCTION__);
1002       return;
1003    }
1004 }
1005
1006 static void TAG(render_quad_strip_elts)( struct gl_context *ctx,
1007                                          GLuint start,
1008                                          GLuint count,
1009                                          GLuint flags )
1010 {
1011    if (HAVE_QUAD_STRIPS && 0) {
1012    }
1013    else if (HAVE_TRI_STRIPS) {
1014       LOCAL_VARS;
1015       GLuint *elts = TNL_CONTEXT(ctx)->vb.Elts;
1016       int dmasz = GET_SUBSEQUENT_VB_MAX_ELTS();
1017       int currentsz;
1018       GLuint j, nr;
1019
1020       FLUSH();
1021       currentsz = GET_CURRENT_VB_MAX_ELTS();
1022
1023       /* Emit whole number of quads in total, and in each buffer.
1024        */
1025       dmasz -= dmasz & 1;
1026       count -= (count-start) & 1;
1027       currentsz -= currentsz & 1;
1028
1029       if (currentsz < 12)
1030          currentsz = dmasz;
1031
1032       if (ctx->Light.ShadeModel == GL_FLAT) {
1033          ELT_INIT( GL_TRIANGLES );
1034
1035          currentsz = currentsz/6*2;
1036          dmasz = dmasz/6*2;
1037
1038          for (j = start; j + 3 < count; j += nr - 2 ) {
1039             nr = MIN2( currentsz, count - j );
1040
1041             if (nr >= 4)
1042             {
1043                GLint i;
1044                GLint quads = (nr/2)-1;
1045                ELTS_VARS( ALLOC_ELTS( quads*6 ) );
1046
1047                for ( i = j-start ; i < j-start+quads ; i++, elts += 2 ) {
1048                   EMIT_TWO_ELTS( 0, elts[0], elts[1] );
1049                   EMIT_TWO_ELTS( 2, elts[2], elts[1] );
1050                   EMIT_TWO_ELTS( 4, elts[3], elts[2] );
1051                   INCR_ELTS( 6 );
1052                }
1053
1054                FLUSH();
1055             }
1056
1057             currentsz = dmasz;
1058          }
1059       }
1060       else {
1061          ELT_INIT( GL_TRIANGLE_STRIP );
1062
1063          for (j = start; j + 3 < count; j += nr - 2 ) {
1064             nr = MIN2( currentsz, count - j );
1065             TAG(emit_elts)( ctx, elts+j, nr, ALLOC_ELTS(nr) );
1066             FLUSH();
1067             currentsz = dmasz;
1068          }
1069       }
1070    }
1071 }
1072
1073
1074 static void TAG(render_quads_elts)( struct gl_context *ctx,
1075                                     GLuint start,
1076                                     GLuint count,
1077                                     GLuint flags )
1078 {
1079    if (HAVE_QUADS) {
1080       LOCAL_VARS;
1081       GLuint *elts = TNL_CONTEXT(ctx)->vb.Elts;
1082       int dmasz = GET_SUBSEQUENT_VB_MAX_ELTS()/4*4;
1083       int currentsz;
1084       GLuint j, nr;
1085
1086       FLUSH();
1087       ELT_INIT( GL_TRIANGLES );
1088
1089       currentsz = GET_CURRENT_VB_MAX_ELTS()/4*4;
1090
1091       count -= (count-start)%4;
1092
1093       if (currentsz < 8)
1094          currentsz = dmasz;
1095
1096       for (j = start; j < count; j += nr) {
1097          nr = MIN2( currentsz, count - j );
1098          TAG(emit_elts)( ctx, elts+j, nr, ALLOC_ELTS(nr) );
1099          FLUSH();
1100          currentsz = dmasz;
1101       }
1102    } else {
1103       LOCAL_VARS;
1104       GLuint *elts = TNL_CONTEXT(ctx)->vb.Elts;
1105       int dmasz = GET_SUBSEQUENT_VB_MAX_ELTS();
1106       int currentsz;
1107       GLuint j, nr;
1108
1109       ELT_INIT( GL_TRIANGLES );
1110       currentsz = GET_CURRENT_VB_MAX_ELTS();
1111
1112       /* Emit whole number of quads in total, and in each buffer.
1113        */
1114       dmasz -= dmasz & 3;
1115       count -= (count-start) & 3;
1116       currentsz -= currentsz & 3;
1117
1118       /* Adjust for rendering as triangles:
1119        */
1120       currentsz = currentsz/6*4;
1121       dmasz = dmasz/6*4;
1122
1123       if (currentsz < 8)
1124          currentsz = dmasz;
1125
1126       for (j = start; j + 3 < count; j += nr - 2 ) {
1127          nr = MIN2( currentsz, count - j );
1128
1129          if (nr >= 4)
1130          {
1131             GLint quads = nr/4;
1132             GLint i;
1133             ELTS_VARS( ALLOC_ELTS( quads * 6 ) );
1134
1135             for ( i = j-start ; i < j-start+quads ; i++, elts += 4 ) {
1136                EMIT_TWO_ELTS( 0, elts[0], elts[1] );
1137                EMIT_TWO_ELTS( 2, elts[3], elts[1] );
1138                EMIT_TWO_ELTS( 4, elts[2], elts[3] );
1139                INCR_ELTS( 6 );
1140             }
1141
1142             FLUSH();
1143          }
1144
1145          currentsz = dmasz;
1146       }
1147    }
1148 }
1149
1150
1151
1152 static tnl_render_func TAG(render_tab_elts)[GL_POLYGON+2] =
1153 {
1154    TAG(render_points_elts),
1155    TAG(render_lines_elts),
1156    TAG(render_line_loop_elts),
1157    TAG(render_line_strip_elts),
1158    TAG(render_triangles_elts),
1159    TAG(render_tri_strip_elts),
1160    TAG(render_tri_fan_elts),
1161    TAG(render_quads_elts),
1162    TAG(render_quad_strip_elts),
1163    TAG(render_poly_elts),
1164    TAG(render_noop),
1165 };
1166
1167
1168
1169 #endif
1170
1171
1172
1173 /* Pre-check the primitives in the VB to prevent the need for
1174  * fallbacks later on.
1175  */
1176 static GLboolean TAG(validate_render)( struct gl_context *ctx,
1177                                        struct vertex_buffer *VB )
1178 {
1179    GLint i;
1180
1181    if (VB->ClipOrMask & ~CLIP_CULL_BIT)
1182       return GL_FALSE;
1183
1184    if (VB->Elts && !HAVE_ELTS)
1185       return GL_FALSE;
1186
1187    for (i = 0 ; i < VB->PrimitiveCount ; i++) {
1188       GLuint prim = VB->Primitive[i].mode;
1189       GLuint count = VB->Primitive[i].count;
1190       GLboolean ok = GL_FALSE;
1191
1192       if (!count)
1193          continue;
1194
1195       switch (prim & PRIM_MODE_MASK) {
1196       case GL_POINTS:
1197          ok = HAVE_POINTS;
1198          break;
1199       case GL_LINES:
1200          ok = HAVE_LINES && !ctx->Line.StippleFlag;
1201          break;
1202       case GL_LINE_STRIP:
1203          ok = HAVE_LINE_STRIPS && !ctx->Line.StippleFlag;
1204          break;
1205       case GL_LINE_LOOP:
1206          ok = HAVE_LINE_STRIPS && !ctx->Line.StippleFlag;
1207          break;
1208       case GL_TRIANGLES:
1209          ok = HAVE_TRIANGLES;
1210          break;
1211       case GL_TRIANGLE_STRIP:
1212          ok = HAVE_TRI_STRIPS;
1213          break;
1214       case GL_TRIANGLE_FAN:
1215          ok = HAVE_TRI_FANS;
1216          break;
1217       case GL_POLYGON:
1218          if (HAVE_POLYGONS) {
1219             ok = GL_TRUE;
1220          }
1221          else {
1222             ok = (HAVE_TRI_FANS && ctx->Light.ShadeModel == GL_SMOOTH);
1223          }
1224          break;
1225       case GL_QUAD_STRIP:
1226          if (VB->Elts) {
1227             ok = HAVE_TRI_STRIPS;
1228          }
1229          else if (HAVE_QUAD_STRIPS) {
1230             ok = GL_TRUE;
1231          } else if (HAVE_TRI_STRIPS &&
1232                     ctx->Light.ShadeModel == GL_FLAT &&
1233                     VB->AttribPtr[_TNL_ATTRIB_COLOR0]->stride != 0) {
1234             if (HAVE_ELTS) {
1235                ok = (GLint) count < GET_SUBSEQUENT_VB_MAX_ELTS();
1236             }
1237             else {
1238                ok = GL_FALSE;
1239             }
1240          }
1241          else
1242             ok = HAVE_TRI_STRIPS;
1243          break;
1244       case GL_QUADS:
1245          if (HAVE_QUADS) {
1246             ok = GL_TRUE;
1247          } else if (HAVE_ELTS) {
1248             ok = (GLint) count < GET_SUBSEQUENT_VB_MAX_ELTS();
1249          }
1250          else {
1251             ok = HAVE_TRIANGLES; /* flatshading is ok. */
1252          }
1253          break;
1254       default:
1255          break;
1256       }
1257
1258       if (!ok) {
1259 /*       fprintf(stderr, "not ok %s\n", _mesa_lookup_enum_by_nr(prim & PRIM_MODE_MASK)); */
1260          return GL_FALSE;
1261       }
1262    }
1263
1264    return GL_TRUE;
1265 }
1266