src/gallium/auxiliary/draw/draw_prim.c

   1 /**************************************************************************
   2  *
   3  * Copyright 2007 Tungsten Graphics, Inc., Cedar Park, Texas.
   4  * All Rights Reserved.
   5  *
   6  * Permission is hereby granted, free of charge, to any person obtaining a
   7  * copy of this software and associated documentation files (the
   8  * "Software"), to deal in the Software without restriction, including
   9  * without limitation the rights to use, copy, modify, merge, publish,
  10  * distribute, sub license, and/or sell copies of the Software, and to
  11  * permit persons to whom the Software is furnished to do so, subject to
  12  * the following conditions:
  13  *
  14  * The above copyright notice and this permission notice (including the
  15  * next paragraph) shall be included in all copies or substantial portions
  16  * of the Software.
  17  *
  18  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  19  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  20  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
  21  * IN NO EVENT SHALL TUNGSTEN GRAPHICS AND/OR ITS SUPPLIERS BE LIABLE FOR
  22  * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
  23  * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
  24  * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  25  *
  26  **************************************************************************/
  27
  28  /*
  29   * Authors:
  30   *   Keith Whitwell <keith@tungstengraphics.com>
  31   */
  32
  33 #include "pipe/p_debug.h"
  34
  35 #include "draw_private.h"
  36 #include "draw_context.h"
  37
  38
  39
  40 #define RP_NONE  0
  41 #define RP_POINT 1
  42 #define RP_LINE  2
  43 #define RP_TRI   3
  44
  45
  46 static unsigned reduced_prim[PIPE_PRIM_POLYGON + 1] = {
  47    RP_POINT,
  48    RP_LINE,
  49    RP_LINE,
  50    RP_LINE,
  51    RP_TRI,
  52    RP_TRI,
  53    RP_TRI,
  54    RP_TRI,
  55    RP_TRI,
  56    RP_TRI
  57 };
  58
  59
  60 static void draw_prim_queue_flush( struct draw_context *draw )
  61 {
  62    unsigned i;
  63
  64    if (0)
  65       debug_printf("Flushing with %d prims, %d verts\n",
  66                    draw->pq.queue_nr, draw->vs.queue_nr);
  67
  68    assert (draw->pq.queue_nr != 0);
  69
  70    /* NOTE: we cannot save draw->pipeline->first in a local var because
  71     * draw->pipeline->first is often changed by the first call to tri(),
  72     * line(), etc.
  73     */
  74    if (draw->rasterizer->line_stipple_enable) {
  75       switch (draw->reduced_prim) {
  76       case RP_TRI:
  77          for (i = 0; i < draw->pq.queue_nr; i++) {
  78             if (draw->pq.queue[i].reset_line_stipple)
  79                draw->pipeline.first->reset_stipple_counter( draw->pipeline.first );
  80
  81             draw->pipeline.first->tri( draw->pipeline.first, &draw->pq.queue[i] );
  82          }
  83          break;
  84       case RP_LINE:
  85          for (i = 0; i < draw->pq.queue_nr; i++) {
  86             if (draw->pq.queue[i].reset_line_stipple)
  87                draw->pipeline.first->reset_stipple_counter( draw->pipeline.first );
  88
  89             draw->pipeline.first->line( draw->pipeline.first, &draw->pq.queue[i] );
  90          }
  91          break;
  92       case RP_POINT:
  93          draw->pipeline.first->reset_stipple_counter( draw->pipeline.first );
  94          for (i = 0; i < draw->pq.queue_nr; i++)
  95             draw->pipeline.first->point( draw->pipeline.first, &draw->pq.queue[i] );
  96          break;
  97       }
  98    }
  99    else {
 100       switch (draw->reduced_prim) {
 101       case RP_TRI:
 102          for (i = 0; i < draw->pq.queue_nr; i++)
 103             draw->pipeline.first->tri( draw->pipeline.first, &draw->pq.queue[i] );
 104          break;
 105       case RP_LINE:
 106          for (i = 0; i < draw->pq.queue_nr; i++)
 107             draw->pipeline.first->line( draw->pipeline.first, &draw->pq.queue[i] );
 108          break;
 109       case RP_POINT:
 110          for (i = 0; i < draw->pq.queue_nr; i++)
 111             draw->pipeline.first->point( draw->pipeline.first, &draw->pq.queue[i] );
 112          break;
 113       }
 114    }
 115
 116    draw->pq.queue_nr = 0;
 117    draw_vertex_cache_unreference( draw );
 118 }
 119
 120
 121
 122 void draw_do_flush( struct draw_context *draw, unsigned flags )
 123 {
 124    static boolean flushing = FALSE;
 125
 126    if (0)
 127       debug_printf("Flushing with %d verts, %d prims\n",
 128                    draw->vs.queue_nr,
 129                    draw->pq.queue_nr );
 130
 131    if (!flushing) {
 132       flushing = TRUE;
 133
 134    if (flags >= DRAW_FLUSH_SHADER_QUEUE) {
 135       if (draw->vs.queue_nr)
 136          (*draw->shader_queue_flush)(draw);
 137
 138       if (flags >= DRAW_FLUSH_PRIM_QUEUE) {
 139          if (draw->pq.queue_nr)
 140             draw_prim_queue_flush(draw);
 141
 142          if (flags >= DRAW_FLUSH_VERTEX_CACHE) {
 143             draw_vertex_cache_invalidate(draw);
 144
 145             if (flags >= DRAW_FLUSH_STATE_CHANGE) {
 146                draw->pipeline.first->flush( draw->pipeline.first, flags );
 147                draw->pipeline.first = draw->pipeline.validate;
 148                draw->reduced_prim = ~0;
 149             }
 150          }
 151       }
 152    }
 153
 154       flushing = FALSE;
 155    }
 156 }
 157
 158
 159
 160 /* Return a pointer to a freshly queued primitive header.  Ensure that
 161  * there is room in the vertex cache for a maximum of "nr_verts" new
 162  * vertices.  Flush primitive and/or vertex queues if necessary to
 163  * make space.
 164  */
 165 static struct prim_header *get_queued_prim( struct draw_context *draw,
 166                                             unsigned nr_verts )
 167 {
 168    if (!draw_vertex_cache_check_space( draw, nr_verts )) {
 169 //      debug_printf("v");
 170       draw_do_flush( draw, DRAW_FLUSH_VERTEX_CACHE );
 171    }
 172    else if (draw->pq.queue_nr == PRIM_QUEUE_LENGTH) {
 173 //      debug_printf("p");
 174       draw_do_flush( draw, DRAW_FLUSH_PRIM_QUEUE );
 175    }
 176
 177    assert(draw->pq.queue_nr < PRIM_QUEUE_LENGTH);
 178
 179    return &draw->pq.queue[draw->pq.queue_nr++];
 180 }
 181
 182
 183
 184 /**
 185  * Add a point to the primitive queue.
 186  * \param i0  index into user's vertex arrays
 187  */
 188 static void do_point( struct draw_context *draw,
 189                       unsigned i0 )
 190 {
 191    struct prim_header *prim = get_queued_prim( draw, 1 );
 192
 193    prim->reset_line_stipple = 0;
 194    prim->edgeflags = 1;
 195    prim->pad = 0;
 196    prim->v[0] = draw->vcache.get_vertex( draw, i0 );
 197 }
 198
 199
 200 /**
 201  * Add a line to the primitive queue.
 202  * \param i0  index into user's vertex arrays
 203  * \param i1  index into user's vertex arrays
 204  */
 205 static void do_line( struct draw_context *draw,
 206                      boolean reset_stipple,
 207                      unsigned i0,
 208                      unsigned i1 )
 209 {
 210    struct prim_header *prim = get_queued_prim( draw, 2 );
 211
 212    prim->reset_line_stipple = reset_stipple;
 213    prim->edgeflags = 1;
 214    prim->pad = 0;
 215    prim->v[0] = draw->vcache.get_vertex( draw, i0 );
 216    prim->v[1] = draw->vcache.get_vertex( draw, i1 );
 217 }
 218
 219 /**
 220  * Add a triangle to the primitive queue.
 221  */
 222 static void do_triangle( struct draw_context *draw,
 223                          unsigned i0,
 224                          unsigned i1,
 225                          unsigned i2 )
 226 {
 227    struct prim_header *prim = get_queued_prim( draw, 3 );
 228
 229    prim->reset_line_stipple = 1;
 230    prim->edgeflags = ~0;
 231    prim->pad = 0;
 232    prim->v[0] = draw->vcache.get_vertex( draw, i0 );
 233    prim->v[1] = draw->vcache.get_vertex( draw, i1 );
 234    prim->v[2] = draw->vcache.get_vertex( draw, i2 );
 235 }
 236
 237 static void do_ef_triangle( struct draw_context *draw,
 238                             boolean reset_stipple,
 239                             unsigned ef_mask,
 240                             unsigned i0,
 241                             unsigned i1,
 242                             unsigned i2 )
 243 {
 244    struct prim_header *prim = get_queued_prim( draw, 3 );
 245    struct vertex_header *v0 = draw->vcache.get_vertex( draw, i0 );
 246    struct vertex_header *v1 = draw->vcache.get_vertex( draw, i1 );
 247    struct vertex_header *v2 = draw->vcache.get_vertex( draw, i2 );
 248
 249    prim->reset_line_stipple = reset_stipple;
 250
 251    prim->edgeflags = ef_mask & ((v0->edgeflag << 0) |
 252                                 (v1->edgeflag << 1) |
 253                                 (v2->edgeflag << 2));
 254    prim->pad = 0;
 255    prim->v[0] = v0;
 256    prim->v[1] = v1;
 257    prim->v[2] = v2;
 258 }
 259
 260
 261 static void do_ef_quad( struct draw_context *draw,
 262                      unsigned v0,
 263                      unsigned v1,
 264                      unsigned v2,
 265                      unsigned v3 )
 266 {
 267    const unsigned omitEdge2 = ~(1 << 1);
 268    const unsigned omitEdge3 = ~(1 << 2);
 269    do_ef_triangle( draw, 1, omitEdge2, v0, v1, v3 );
 270    do_ef_triangle( draw, 0, omitEdge3, v1, v2, v3 );
 271 }
 272
 273 static void do_quad( struct draw_context *draw,
 274                      unsigned v0,
 275                      unsigned v1,
 276                      unsigned v2,
 277                      unsigned v3 )
 278 {
 279    do_triangle( draw, v0, v1, v3 );
 280    do_triangle( draw, v1, v2, v3 );
 281 }
 282
 283
 284 /**
 285  * Main entrypoint to draw some number of points/lines/triangles
 286  */
 287 static void
 288 draw_prim( struct draw_context *draw,
 289            unsigned prim, unsigned start, unsigned count )
 290 {
 291    unsigned i;
 292    boolean unfilled = (draw->rasterizer->fill_cw != PIPE_POLYGON_MODE_FILL ||
 293                        draw->rasterizer->fill_ccw != PIPE_POLYGON_MODE_FILL);
 294
 295 //   debug_printf("%s (%d) %d/%d\n", __FUNCTION__, draw->prim, start, count );
 296
 297    switch (prim) {
 298    case PIPE_PRIM_POINTS:
 299       for (i = 0; i < count; i ++) {
 300          do_point( draw,
 301                    start + i );
 302       }
 303       break;
 304
 305    case PIPE_PRIM_LINES:
 306       for (i = 0; i+1 < count; i += 2) {
 307          do_line( draw,
 308                   TRUE,
 309                   start + i + 0,
 310                   start + i + 1);
 311       }
 312       break;
 313
 314    case PIPE_PRIM_LINE_LOOP:
 315       if (count >= 2) {
 316          for (i = 1; i < count; i++) {
 317             do_line( draw,
 318                      i == 1,    /* XXX: only if vb not split */
 319                      start + i - 1,
 320                      start + i );
 321          }
 322
 323          do_line( draw,
 324                   0,
 325                   start + count - 1,
 326                   start + 0 );
 327       }
 328       break;
 329
 330    case PIPE_PRIM_LINE_STRIP:
 331       for (i = 1; i < count; i++) {
 332          do_line( draw,
 333                   i == 1,
 334                   start + i - 1,
 335                   start + i );
 336       }
 337       break;
 338
 339    case PIPE_PRIM_TRIANGLES:
 340       if (unfilled) {
 341          for (i = 0; i+2 < count; i += 3) {
 342             do_ef_triangle( draw,
 343                             1,
 344                             ~0,
 345                             start + i + 0,
 346                             start + i + 1,
 347                             start + i + 2 );
 348          }
 349       }
 350       else {
 351          for (i = 0; i+2 < count; i += 3) {
 352             do_triangle( draw,
 353                          start + i + 0,
 354                          start + i + 1,
 355                          start + i + 2 );
 356          }
 357       }
 358       break;
 359
 360    case PIPE_PRIM_TRIANGLE_STRIP:
 361       for (i = 0; i+2 < count; i++) {
 362          if (i & 1) {
 363             do_triangle( draw,
 364                          start + i + 1,
 365                          start + i + 0,
 366                          start + i + 2 );
 367          }
 368          else {
 369             do_triangle( draw,
 370                          start + i + 0,
 371                          start + i + 1,
 372                          start + i + 2 );
 373          }
 374       }
 375       break;
 376
 377    case PIPE_PRIM_TRIANGLE_FAN:
 378       if (count >= 3) {
 379          for (i = 0; i+2 < count; i++) {
 380             do_triangle( draw,
 381                          start + 0,
 382                          start + i + 1,
 383                          start + i + 2 );
 384          }
 385       }
 386       break;
 387
 388
 389    case PIPE_PRIM_QUADS:
 390       if (unfilled) {
 391          for (i = 0; i+3 < count; i += 4) {
 392             do_ef_quad( draw,
 393                         start + i + 0,
 394                         start + i + 1,
 395                         start + i + 2,
 396                         start + i + 3);
 397          }
 398       }
 399       else {
 400          for (i = 0; i+3 < count; i += 4) {
 401             do_quad( draw,
 402                      start + i + 0,
 403                      start + i + 1,
 404                      start + i + 2,
 405                      start + i + 3);
 406          }
 407       }
 408       break;
 409
 410    case PIPE_PRIM_QUAD_STRIP:
 411       if (unfilled) {
 412          for (i = 0; i+3 < count; i += 2) {
 413             do_ef_quad( draw,
 414                         start + i + 2,
 415                         start + i + 0,
 416                         start + i + 1,
 417                         start + i + 3);
 418          }
 419       }
 420       else {
 421          for (i = 0; i+3 < count; i += 2) {
 422             do_quad( draw,
 423                      start + i + 2,
 424                      start + i + 0,
 425                      start + i + 1,
 426                      start + i + 3);
 427          }
 428       }
 429       break;
 430
 431    case PIPE_PRIM_POLYGON:
 432       if (unfilled) {
 433          unsigned ef_mask = (1<<2) | (1<<0);
 434
 435          for (i = 0; i+2 < count; i++) {
 436
 437             if (i + 3 >= count)
 438                ef_mask |= (1<<1);
 439
 440             do_ef_triangle( draw,
 441                             i == 0,
 442                             ef_mask,
 443                             start + i + 1,
 444                             start + i + 2,
 445                             start + 0);
 446
 447             ef_mask &= ~(1<<2);
 448          }
 449       }
 450       else {
 451          for (i = 0; i+2 < count; i++) {
 452             do_triangle( draw,
 453                          start + i + 1,
 454                          start + i + 2,
 455                          start + 0);
 456          }
 457       }
 458       break;
 459
 460    default:
 461       assert(0);
 462       break;
 463    }
 464 }
 465
 466
 467
 468
 469 /**
 470  * Draw vertex arrays
 471  * This is the main entrypoint into the drawing module.
 472  * \param prim  one of PIPE_PRIM_x
 473  * \param start  index of first vertex to draw
 474  * \param count  number of vertices to draw
 475  */
 476 void
 477 draw_arrays(struct draw_context *draw, unsigned prim,
 478             unsigned start, unsigned count)
 479 {
 480    if (reduced_prim[prim] != draw->reduced_prim) {
 481       draw_do_flush( draw, DRAW_FLUSH_STATE_CHANGE );
 482       draw->reduced_prim = reduced_prim[prim];
 483    }
 484
 485    /* drawing done here: */
 486    draw_prim(draw, prim, start, count);
 487 }
 488
 489