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 #include "pipe/p_util.h"
  35
  36 #include "draw_private.h"
  37 #include "draw_context.h"
  38
  39
  40
  41 #define RP_NONE  0
  42 #define RP_POINT 1
  43 #define RP_LINE  2
  44 #define RP_TRI   3
  45
  46
  47 static unsigned reduced_prim[PIPE_PRIM_POLYGON + 1] = {
  48    RP_POINT,
  49    RP_LINE,
  50    RP_LINE,
  51    RP_LINE,
  52    RP_TRI,
  53    RP_TRI,
  54    RP_TRI,
  55    RP_TRI,
  56    RP_TRI,
  57    RP_TRI
  58 };
  59
  60
  61 static void draw_prim_queue_flush( struct draw_context *draw )
  62 {
  63    unsigned i;
  64
  65    if (0)
  66       debug_printf("Flushing with %d prims, %d verts\n",
  67                    draw->pq.queue_nr, draw->vs.queue_nr);
  68
  69    assert (draw->pq.queue_nr != 0);
  70
  71    /* NOTE: we cannot save draw->pipeline->first in a local var because
  72     * draw->pipeline->first is often changed by the first call to tri(),
  73     * line(), etc.
  74     */
  75    if (draw->rasterizer->line_stipple_enable) {
  76       switch (draw->reduced_prim) {
  77       case RP_TRI:
  78          for (i = 0; i < draw->pq.queue_nr; i++) {
  79             if (draw->pq.queue[i].reset_line_stipple)
  80                draw->pipeline.first->reset_stipple_counter( draw->pipeline.first );
  81
  82             draw->pipeline.first->tri( draw->pipeline.first, &draw->pq.queue[i] );
  83          }
  84          break;
  85       case RP_LINE:
  86          for (i = 0; i < draw->pq.queue_nr; i++) {
  87             if (draw->pq.queue[i].reset_line_stipple)
  88                draw->pipeline.first->reset_stipple_counter( draw->pipeline.first );
  89
  90             draw->pipeline.first->line( draw->pipeline.first, &draw->pq.queue[i] );
  91          }
  92          break;
  93       case RP_POINT:
  94          draw->pipeline.first->reset_stipple_counter( draw->pipeline.first );
  95          for (i = 0; i < draw->pq.queue_nr; i++)
  96             draw->pipeline.first->point( draw->pipeline.first, &draw->pq.queue[i] );
  97          break;
  98       }
  99    }
 100    else {
 101       switch (draw->reduced_prim) {
 102       case RP_TRI:
 103          for (i = 0; i < draw->pq.queue_nr; i++)
 104             draw->pipeline.first->tri( draw->pipeline.first, &draw->pq.queue[i] );
 105          break;
 106       case RP_LINE:
 107          for (i = 0; i < draw->pq.queue_nr; i++)
 108             draw->pipeline.first->line( draw->pipeline.first, &draw->pq.queue[i] );
 109          break;
 110       case RP_POINT:
 111          for (i = 0; i < draw->pq.queue_nr; i++)
 112             draw->pipeline.first->point( draw->pipeline.first, &draw->pq.queue[i] );
 113          break;
 114       }
 115    }
 116
 117    draw->pq.queue_nr = 0;
 118    draw->vs.post_nr = 0;
 119    draw_vertex_cache_unreference( draw );
 120 }
 121
 122 static INLINE void fetch_and_store(struct draw_context *draw)
 123 {
 124    /* run vertex shader on vertex cache entries, four per invokation */
 125 #if 0
 126    {
 127       const struct vertex_info *vinfo = draw->render->get_vertex_info(draw->render);
 128       memcpy(draw->vs.queue[0].vertex, draw->vs.queue[i + j].elt,
 129              count * vinfo->size);
 130    }
 131 #elif 0
 132    unsigned i;
 133
 134    draw_update_vertex_fetch(draw);
 135    for (i = 0; i < draw->vs.queue_nr; i += 4) {
 136       struct vertex_header *dests[4];
 137       unsigned elts[4];
 138       struct tgsi_exec_machine *machine = &draw->machine;
 139       int j, n = MIN2(4, draw->vs.queue_nr - i);
 140
 141       for (j = 0; j < n; j++) {
 142          elts[j] = draw->vs.queue[i + j].elt;
 143          dests[j] = draw->vs.queue[i + j].vertex;
 144       }
 145
 146       for ( ; j < 4; j++) {
 147          elts[j] = elts[0];
 148          dests[j] = draw->vs.queue[i + j].vertex;
 149       }
 150       //fetch directly into dests
 151       draw->vertex_fetch.fetch_func(draw, machine, dests, count);
 152    }
 153 #endif
 154
 155    draw->vs.post_nr = draw->vs.queue_nr;
 156    draw->vs.queue_nr = 0;
 157 }
 158
 159 void draw_do_flush( struct draw_context *draw, unsigned flags )
 160 {
 161    static boolean flushing = FALSE;
 162
 163    if (0)
 164       debug_printf("Flushing with %d verts, %d prims\n",
 165                    draw->vs.queue_nr,
 166                    draw->pq.queue_nr );
 167
 168    if (!flushing) {
 169       flushing = TRUE;
 170
 171    if (flags >= DRAW_FLUSH_SHADER_QUEUE) {
 172       if (draw->vs.queue_nr) {
 173          if (draw->rasterizer->bypass_vs)
 174             fetch_and_store(draw);
 175          else
 176             (*draw->shader_queue_flush)(draw);
 177       }
 178
 179       if (flags >= DRAW_FLUSH_PRIM_QUEUE) {
 180          if (draw->pq.queue_nr)
 181             draw_prim_queue_flush(draw);
 182
 183          if (flags >= DRAW_FLUSH_VERTEX_CACHE) {
 184             draw_vertex_cache_invalidate(draw);
 185
 186             if (flags >= DRAW_FLUSH_STATE_CHANGE) {
 187                draw->pipeline.first->flush( draw->pipeline.first, flags );
 188                draw->pipeline.first = draw->pipeline.validate;
 189                draw->reduced_prim = ~0;
 190             }
 191          }
 192       }
 193    }
 194
 195       flushing = FALSE;
 196    }
 197 }
 198
 199
 200
 201 /* Return a pointer to a freshly queued primitive header.  Ensure that
 202  * there is room in the vertex cache for a maximum of "nr_verts" new
 203  * vertices.  Flush primitive and/or vertex queues if necessary to
 204  * make space.
 205  */
 206 static struct prim_header *get_queued_prim( struct draw_context *draw,
 207                                             unsigned nr_verts )
 208 {
 209    if (!draw_vertex_cache_check_space( draw, nr_verts )) {
 210 //      debug_printf("v");
 211       draw_do_flush( draw, DRAW_FLUSH_VERTEX_CACHE );
 212    }
 213    else if (draw->pq.queue_nr == PRIM_QUEUE_LENGTH) {
 214 //      debug_printf("p");
 215       draw_do_flush( draw, DRAW_FLUSH_PRIM_QUEUE );
 216    }
 217
 218    assert(draw->pq.queue_nr < PRIM_QUEUE_LENGTH);
 219
 220    return &draw->pq.queue[draw->pq.queue_nr++];
 221 }
 222
 223
 224
 225 /**
 226  * Add a point to the primitive queue.
 227  * \param i0  index into user's vertex arrays
 228  */
 229 static void do_point( struct draw_context *draw,
 230                       unsigned i0 )
 231 {
 232    struct prim_header *prim = get_queued_prim( draw, 1 );
 233
 234    prim->reset_line_stipple = 0;
 235    prim->edgeflags = 1;
 236    prim->pad = 0;
 237    prim->v[0] = draw->vcache.get_vertex( draw, i0 );
 238 }
 239
 240
 241 /**
 242  * Add a line to the primitive queue.
 243  * \param i0  index into user's vertex arrays
 244  * \param i1  index into user's vertex arrays
 245  */
 246 static void do_line( struct draw_context *draw,
 247                      boolean reset_stipple,
 248                      unsigned i0,
 249                      unsigned i1 )
 250 {
 251    struct prim_header *prim = get_queued_prim( draw, 2 );
 252
 253    prim->reset_line_stipple = reset_stipple;
 254    prim->edgeflags = 1;
 255    prim->pad = 0;
 256    prim->v[0] = draw->vcache.get_vertex( draw, i0 );
 257    prim->v[1] = draw->vcache.get_vertex( draw, i1 );
 258 }
 259
 260 /**
 261  * Add a triangle to the primitive queue.
 262  */
 263 static void do_triangle( struct draw_context *draw,
 264                          unsigned i0,
 265                          unsigned i1,
 266                          unsigned i2 )
 267 {
 268    struct prim_header *prim = get_queued_prim( draw, 3 );
 269
 270 //   _mesa_printf("tri %d %d %d\n", i0, i1, i2);
 271    prim->reset_line_stipple = 1;
 272    prim->edgeflags = ~0;
 273    prim->pad = 0;
 274    prim->v[0] = draw->vcache.get_vertex( draw, i0 );
 275    prim->v[1] = draw->vcache.get_vertex( draw, i1 );
 276    prim->v[2] = draw->vcache.get_vertex( draw, i2 );
 277 }
 278
 279 static void do_ef_triangle( struct draw_context *draw,
 280                             boolean reset_stipple,
 281                             unsigned ef_mask,
 282                             unsigned i0,
 283                             unsigned i1,
 284                             unsigned i2 )
 285 {
 286    struct prim_header *prim = get_queued_prim( draw, 3 );
 287    struct vertex_header *v0 = draw->vcache.get_vertex( draw, i0 );
 288    struct vertex_header *v1 = draw->vcache.get_vertex( draw, i1 );
 289    struct vertex_header *v2 = draw->vcache.get_vertex( draw, i2 );
 290
 291    prim->reset_line_stipple = reset_stipple;
 292
 293    prim->edgeflags = ef_mask & ((v0->edgeflag << 0) |
 294                                 (v1->edgeflag << 1) |
 295                                 (v2->edgeflag << 2));
 296    prim->pad = 0;
 297    prim->v[0] = v0;
 298    prim->v[1] = v1;
 299    prim->v[2] = v2;
 300 }
 301
 302
 303 static void do_ef_quad( struct draw_context *draw,
 304                      unsigned v0,
 305                      unsigned v1,
 306                      unsigned v2,
 307                      unsigned v3 )
 308 {
 309    const unsigned omitEdge2 = ~(1 << 1);
 310    const unsigned omitEdge3 = ~(1 << 2);
 311    do_ef_triangle( draw, 1, omitEdge2, v0, v1, v3 );
 312    do_ef_triangle( draw, 0, omitEdge3, v1, v2, v3 );
 313 }
 314
 315 static void do_quad( struct draw_context *draw,
 316                      unsigned v0,
 317                      unsigned v1,
 318                      unsigned v2,
 319                      unsigned v3 )
 320 {
 321    do_triangle( draw, v0, v1, v3 );
 322    do_triangle( draw, v1, v2, v3 );
 323 }
 324
 325
 326 /**
 327  * Main entrypoint to draw some number of points/lines/triangles
 328  */
 329 static void
 330 draw_prim( struct draw_context *draw,
 331            unsigned prim, unsigned start, unsigned count )
 332 {
 333    unsigned i;
 334    boolean unfilled = (draw->rasterizer->fill_cw != PIPE_POLYGON_MODE_FILL ||
 335                        draw->rasterizer->fill_ccw != PIPE_POLYGON_MODE_FILL);
 336
 337 //   debug_printf("%s (%d) %d/%d\n", __FUNCTION__, draw->prim, start, count );
 338
 339    switch (prim) {
 340    case PIPE_PRIM_POINTS:
 341       for (i = 0; i < count; i ++) {
 342          do_point( draw,
 343                    start + i );
 344       }
 345       break;
 346
 347    case PIPE_PRIM_LINES:
 348       for (i = 0; i+1 < count; i += 2) {
 349          do_line( draw,
 350                   TRUE,
 351                   start + i + 0,
 352                   start + i + 1);
 353       }
 354       break;
 355
 356    case PIPE_PRIM_LINE_LOOP:
 357       if (count >= 2) {
 358          for (i = 1; i < count; i++) {
 359             do_line( draw,
 360                      i == 1,    /* XXX: only if vb not split */
 361                      start + i - 1,
 362                      start + i );
 363          }
 364
 365          do_line( draw,
 366                   0,
 367                   start + count - 1,
 368                   start + 0 );
 369       }
 370       break;
 371
 372    case PIPE_PRIM_LINE_STRIP:
 373       for (i = 1; i < count; i++) {
 374          do_line( draw,
 375                   i == 1,
 376                   start + i - 1,
 377                   start + i );
 378       }
 379       break;
 380
 381    case PIPE_PRIM_TRIANGLES:
 382       if (unfilled) {
 383          for (i = 0; i+2 < count; i += 3) {
 384             do_ef_triangle( draw,
 385                             1,
 386                             ~0,
 387                             start + i + 0,
 388                             start + i + 1,
 389                             start + i + 2 );
 390          }
 391       }
 392       else {
 393          for (i = 0; i+2 < count; i += 3) {
 394             do_triangle( draw,
 395                          start + i + 0,
 396                          start + i + 1,
 397                          start + i + 2 );
 398          }
 399       }
 400       break;
 401
 402    case PIPE_PRIM_TRIANGLE_STRIP:
 403       for (i = 0; i+2 < count; i++) {
 404          if (i & 1) {
 405             do_triangle( draw,
 406                          start + i + 1,
 407                          start + i + 0,
 408                          start + i + 2 );
 409          }
 410          else {
 411             do_triangle( draw,
 412                          start + i + 0,
 413                          start + i + 1,
 414                          start + i + 2 );
 415          }
 416       }
 417       break;
 418
 419    case PIPE_PRIM_TRIANGLE_FAN:
 420       if (count >= 3) {
 421          for (i = 0; i+2 < count; i++) {
 422             do_triangle( draw,
 423                          start + 0,
 424                          start + i + 1,
 425                          start + i + 2 );
 426          }
 427       }
 428       break;
 429
 430
 431    case PIPE_PRIM_QUADS:
 432       if (unfilled) {
 433          for (i = 0; i+3 < count; i += 4) {
 434             do_ef_quad( draw,
 435                         start + i + 0,
 436                         start + i + 1,
 437                         start + i + 2,
 438                         start + i + 3);
 439          }
 440       }
 441       else {
 442          for (i = 0; i+3 < count; i += 4) {
 443             do_quad( draw,
 444                      start + i + 0,
 445                      start + i + 1,
 446                      start + i + 2,
 447                      start + i + 3);
 448          }
 449       }
 450       break;
 451
 452    case PIPE_PRIM_QUAD_STRIP:
 453       if (unfilled) {
 454          for (i = 0; i+3 < count; i += 2) {
 455             do_ef_quad( draw,
 456                         start + i + 2,
 457                         start + i + 0,
 458                         start + i + 1,
 459                         start + i + 3);
 460          }
 461       }
 462       else {
 463          for (i = 0; i+3 < count; i += 2) {
 464             do_quad( draw,
 465                      start + i + 2,
 466                      start + i + 0,
 467                      start + i + 1,
 468                      start + i + 3);
 469          }
 470       }
 471       break;
 472
 473    case PIPE_PRIM_POLYGON:
 474       if (unfilled) {
 475          unsigned ef_mask = (1<<2) | (1<<0);
 476
 477          for (i = 0; i+2 < count; i++) {
 478
 479             if (i + 3 >= count)
 480                ef_mask |= (1<<1);
 481
 482             do_ef_triangle( draw,
 483                             i == 0,
 484                             ef_mask,
 485                             start + i + 1,
 486                             start + i + 2,
 487                             start + 0);
 488
 489             ef_mask &= ~(1<<2);
 490          }
 491       }
 492       else {
 493          for (i = 0; i+2 < count; i++) {
 494             do_triangle( draw,
 495                          start + i + 1,
 496                          start + i + 2,
 497                          start + 0);
 498          }
 499       }
 500       break;
 501
 502    default:
 503       assert(0);
 504       break;
 505    }
 506 }
 507
 508
 509
 510
 511 /**
 512  * Draw vertex arrays
 513  * This is the main entrypoint into the drawing module.
 514  * \param prim  one of PIPE_PRIM_x
 515  * \param start  index of first vertex to draw
 516  * \param count  number of vertices to draw
 517  */
 518 void
 519 draw_arrays(struct draw_context *draw, unsigned prim,
 520             unsigned start, unsigned count)
 521 {
 522    if (reduced_prim[prim] != draw->reduced_prim) {
 523       draw_do_flush( draw, DRAW_FLUSH_STATE_CHANGE );
 524       draw->reduced_prim = reduced_prim[prim];
 525    }
 526
 527    /* drawing done here: */
 528    if (!draw->rasterizer->bypass_vs ||
 529        !draw_pt_arrays(draw, prim, start, count)) {
 530       /* we have to run the whole pipeline */
 531       draw_prim(draw, prim, start, count);
 532    }
 533 }
 534
 535