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->vs.post_nr = 0;
 118    draw_vertex_cache_unreference( draw );
 119 }
 120
 121
 122
 123 void draw_do_flush( struct draw_context *draw, unsigned flags )
 124 {
 125    static boolean flushing = FALSE;
 126
 127    if (0)
 128       debug_printf("Flushing with %d verts, %d prims\n",
 129                    draw->vs.queue_nr,
 130                    draw->pq.queue_nr );
 131
 132    if (!flushing) {
 133       flushing = TRUE;
 134
 135    if (flags >= DRAW_FLUSH_SHADER_QUEUE) {
 136       if (draw->vs.queue_nr)
 137          (*draw->shader_queue_flush)(draw);
 138
 139       if (flags >= DRAW_FLUSH_PRIM_QUEUE) {
 140          if (draw->pq.queue_nr)
 141             draw_prim_queue_flush(draw);
 142
 143          if (flags >= DRAW_FLUSH_VERTEX_CACHE) {
 144             draw_vertex_cache_invalidate(draw);
 145
 146             if (flags >= DRAW_FLUSH_STATE_CHANGE) {
 147                draw->pipeline.first->flush( draw->pipeline.first, flags );
 148                draw->pipeline.first = draw->pipeline.validate;
 149                draw->reduced_prim = ~0;
 150             }
 151          }
 152       }
 153    }
 154
 155       flushing = FALSE;
 156    }
 157 }
 158
 159
 160
 161 /* Return a pointer to a freshly queued primitive header.  Ensure that
 162  * there is room in the vertex cache for a maximum of "nr_verts" new
 163  * vertices.  Flush primitive and/or vertex queues if necessary to
 164  * make space.
 165  */
 166 static struct prim_header *get_queued_prim( struct draw_context *draw,
 167                                             unsigned nr_verts )
 168 {
 169    if (!draw_vertex_cache_check_space( draw, nr_verts )) {
 170 //      debug_printf("v");
 171       draw_do_flush( draw, DRAW_FLUSH_VERTEX_CACHE );
 172    }
 173    else if (draw->pq.queue_nr == PRIM_QUEUE_LENGTH) {
 174 //      debug_printf("p");
 175       draw_do_flush( draw, DRAW_FLUSH_PRIM_QUEUE );
 176    }
 177
 178    assert(draw->pq.queue_nr < PRIM_QUEUE_LENGTH);
 179
 180    return &draw->pq.queue[draw->pq.queue_nr++];
 181 }
 182
 183
 184
 185 /**
 186  * Add a point to the primitive queue.
 187  * \param i0  index into user's vertex arrays
 188  */
 189 static void do_point( struct draw_context *draw,
 190                       unsigned i0 )
 191 {
 192    struct prim_header *prim = get_queued_prim( draw, 1 );
 193
 194    prim->reset_line_stipple = 0;
 195    prim->edgeflags = 1;
 196    prim->pad = 0;
 197    prim->v[0] = draw->vcache.get_vertex( draw, i0 );
 198 }
 199
 200
 201 /**
 202  * Add a line to the primitive queue.
 203  * \param i0  index into user's vertex arrays
 204  * \param i1  index into user's vertex arrays
 205  */
 206 static void do_line( struct draw_context *draw,
 207                      boolean reset_stipple,
 208                      unsigned i0,
 209                      unsigned i1 )
 210 {
 211    struct prim_header *prim = get_queued_prim( draw, 2 );
 212
 213    prim->reset_line_stipple = reset_stipple;
 214    prim->edgeflags = 1;
 215    prim->pad = 0;
 216    prim->v[0] = draw->vcache.get_vertex( draw, i0 );
 217    prim->v[1] = draw->vcache.get_vertex( draw, i1 );
 218 }
 219
 220 /**
 221  * Add a triangle to the primitive queue.
 222  */
 223 static void do_triangle( struct draw_context *draw,
 224                          unsigned i0,
 225                          unsigned i1,
 226                          unsigned i2 )
 227 {
 228    struct prim_header *prim = get_queued_prim( draw, 3 );
 229
 230 //   _mesa_printf("tri %d %d %d\n", i0, i1, i2);
 231    prim->reset_line_stipple = 1;
 232    prim->edgeflags = ~0;
 233    prim->pad = 0;
 234    prim->v[0] = draw->vcache.get_vertex( draw, i0 );
 235    prim->v[1] = draw->vcache.get_vertex( draw, i1 );
 236    prim->v[2] = draw->vcache.get_vertex( draw, i2 );
 237 }
 238
 239 static void do_ef_triangle( struct draw_context *draw,
 240                             boolean reset_stipple,
 241                             unsigned ef_mask,
 242                             unsigned i0,
 243                             unsigned i1,
 244                             unsigned i2 )
 245 {
 246    struct prim_header *prim = get_queued_prim( draw, 3 );
 247    struct vertex_header *v0 = draw->vcache.get_vertex( draw, i0 );
 248    struct vertex_header *v1 = draw->vcache.get_vertex( draw, i1 );
 249    struct vertex_header *v2 = draw->vcache.get_vertex( draw, i2 );
 250
 251    prim->reset_line_stipple = reset_stipple;
 252
 253    prim->edgeflags = ef_mask & ((v0->edgeflag << 0) |
 254                                 (v1->edgeflag << 1) |
 255                                 (v2->edgeflag << 2));
 256    prim->pad = 0;
 257    prim->v[0] = v0;
 258    prim->v[1] = v1;
 259    prim->v[2] = v2;
 260 }
 261
 262
 263 static void do_ef_quad( struct draw_context *draw,
 264                      unsigned v0,
 265                      unsigned v1,
 266                      unsigned v2,
 267                      unsigned v3 )
 268 {
 269    const unsigned omitEdge2 = ~(1 << 1);
 270    const unsigned omitEdge3 = ~(1 << 2);
 271    do_ef_triangle( draw, 1, omitEdge2, v0, v1, v3 );
 272    do_ef_triangle( draw, 0, omitEdge3, v1, v2, v3 );
 273 }
 274
 275 static void do_quad( struct draw_context *draw,
 276                      unsigned v0,
 277                      unsigned v1,
 278                      unsigned v2,
 279                      unsigned v3 )
 280 {
 281    do_triangle( draw, v0, v1, v3 );
 282    do_triangle( draw, v1, v2, v3 );
 283 }
 284
 285
 286 /**
 287  * Main entrypoint to draw some number of points/lines/triangles
 288  */
 289 static void
 290 draw_prim( struct draw_context *draw,
 291            unsigned prim, unsigned start, unsigned count )
 292 {
 293    unsigned i;
 294    boolean unfilled = (draw->rasterizer->fill_cw != PIPE_POLYGON_MODE_FILL ||
 295                        draw->rasterizer->fill_ccw != PIPE_POLYGON_MODE_FILL);
 296
 297 //   debug_printf("%s (%d) %d/%d\n", __FUNCTION__, draw->prim, start, count );
 298
 299    switch (prim) {
 300    case PIPE_PRIM_POINTS:
 301       for (i = 0; i < count; i ++) {
 302          do_point( draw,
 303                    start + i );
 304       }
 305       break;
 306
 307    case PIPE_PRIM_LINES:
 308       for (i = 0; i+1 < count; i += 2) {
 309          do_line( draw,
 310                   TRUE,
 311                   start + i + 0,
 312                   start + i + 1);
 313       }
 314       break;
 315
 316    case PIPE_PRIM_LINE_LOOP:
 317       if (count >= 2) {
 318          for (i = 1; i < count; i++) {
 319             do_line( draw,
 320                      i == 1,    /* XXX: only if vb not split */
 321                      start + i - 1,
 322                      start + i );
 323          }
 324
 325          do_line( draw,
 326                   0,
 327                   start + count - 1,
 328                   start + 0 );
 329       }
 330       break;
 331
 332    case PIPE_PRIM_LINE_STRIP:
 333       for (i = 1; i < count; i++) {
 334          do_line( draw,
 335                   i == 1,
 336                   start + i - 1,
 337                   start + i );
 338       }
 339       break;
 340
 341    case PIPE_PRIM_TRIANGLES:
 342       if (unfilled) {
 343          for (i = 0; i+2 < count; i += 3) {
 344             do_ef_triangle( draw,
 345                             1,
 346                             ~0,
 347                             start + i + 0,
 348                             start + i + 1,
 349                             start + i + 2 );
 350          }
 351       }
 352       else {
 353          for (i = 0; i+2 < count; i += 3) {
 354             do_triangle( draw,
 355                          start + i + 0,
 356                          start + i + 1,
 357                          start + i + 2 );
 358          }
 359       }
 360       break;
 361
 362    case PIPE_PRIM_TRIANGLE_STRIP:
 363       for (i = 0; i+2 < count; i++) {
 364          if (i & 1) {
 365             do_triangle( draw,
 366                          start + i + 1,
 367                          start + i + 0,
 368                          start + i + 2 );
 369          }
 370          else {
 371             do_triangle( draw,
 372                          start + i + 0,
 373                          start + i + 1,
 374                          start + i + 2 );
 375          }
 376       }
 377       break;
 378
 379    case PIPE_PRIM_TRIANGLE_FAN:
 380       if (count >= 3) {
 381          for (i = 0; i+2 < count; i++) {
 382             do_triangle( draw,
 383                          start + 0,
 384                          start + i + 1,
 385                          start + i + 2 );
 386          }
 387       }
 388       break;
 389
 390
 391    case PIPE_PRIM_QUADS:
 392       if (unfilled) {
 393          for (i = 0; i+3 < count; i += 4) {
 394             do_ef_quad( draw,
 395                         start + i + 0,
 396                         start + i + 1,
 397                         start + i + 2,
 398                         start + i + 3);
 399          }
 400       }
 401       else {
 402          for (i = 0; i+3 < count; i += 4) {
 403             do_quad( draw,
 404                      start + i + 0,
 405                      start + i + 1,
 406                      start + i + 2,
 407                      start + i + 3);
 408          }
 409       }
 410       break;
 411
 412    case PIPE_PRIM_QUAD_STRIP:
 413       if (unfilled) {
 414          for (i = 0; i+3 < count; i += 2) {
 415             do_ef_quad( draw,
 416                         start + i + 2,
 417                         start + i + 0,
 418                         start + i + 1,
 419                         start + i + 3);
 420          }
 421       }
 422       else {
 423          for (i = 0; i+3 < count; i += 2) {
 424             do_quad( draw,
 425                      start + i + 2,
 426                      start + i + 0,
 427                      start + i + 1,
 428                      start + i + 3);
 429          }
 430       }
 431       break;
 432
 433    case PIPE_PRIM_POLYGON:
 434       if (unfilled) {
 435          unsigned ef_mask = (1<<2) | (1<<0);
 436
 437          for (i = 0; i+2 < count; i++) {
 438
 439             if (i + 3 >= count)
 440                ef_mask |= (1<<1);
 441
 442             do_ef_triangle( draw,
 443                             i == 0,
 444                             ef_mask,
 445                             start + i + 1,
 446                             start + i + 2,
 447                             start + 0);
 448
 449             ef_mask &= ~(1<<2);
 450          }
 451       }
 452       else {
 453          for (i = 0; i+2 < count; i++) {
 454             do_triangle( draw,
 455                          start + i + 1,
 456                          start + i + 2,
 457                          start + 0);
 458          }
 459       }
 460       break;
 461
 462    default:
 463       assert(0);
 464       break;
 465    }
 466 }
 467
 468
 469
 470
 471 /**
 472  * Draw vertex arrays
 473  * This is the main entrypoint into the drawing module.
 474  * \param prim  one of PIPE_PRIM_x
 475  * \param start  index of first vertex to draw
 476  * \param count  number of vertices to draw
 477  */
 478 void
 479 draw_arrays(struct draw_context *draw, unsigned prim,
 480             unsigned start, unsigned count)
 481 {
 482    if (reduced_prim[prim] != draw->reduced_prim) {
 483       draw_do_flush( draw, DRAW_FLUSH_STATE_CHANGE );
 484       draw->reduced_prim = reduced_prim[prim];
 485    }
 486
 487    /* drawing done here: */
 488    draw_prim(draw, prim, start, count);
 489 }
 490
 491