src/gallium/auxiliary/draw/draw_pt_vcache_tmp.h

   1
   2
   3 static void FUNC( struct draw_pt_front_end *frontend,
   4                   pt_elt_func get_elt,
   5                   const void *elts,
   6                   unsigned count )
   7 {
   8    struct vcache_frontend *vcache = (struct vcache_frontend *)frontend;
   9    struct draw_context *draw = vcache->draw;
  10
  11    boolean flatfirst = (draw->rasterizer->flatshade &&
  12                         draw->rasterizer->flatshade_first);
  13    unsigned i;
  14    ushort flags;
  15
  16    if (0) debug_printf("%s %d\n", __FUNCTION__, count);
  17
  18
  19    switch (vcache->input_prim) {
  20    case PIPE_PRIM_POINTS:
  21       for (i = 0; i < count; i ++) {
  22          POINT( vcache,
  23                 get_elt(elts, i + 0) );
  24       }
  25       break;
  26
  27    case PIPE_PRIM_LINES:
  28       for (i = 0; i+1 < count; i += 2) {
  29          LINE( vcache,
  30                DRAW_PIPE_RESET_STIPPLE,
  31                get_elt(elts, i + 0),
  32                get_elt(elts, i + 1));
  33       }
  34       break;
  35
  36    case PIPE_PRIM_LINE_LOOP:
  37       if (count >= 2) {
  38          flags = DRAW_PIPE_RESET_STIPPLE;
  39
  40          for (i = 1; i < count; i++, flags = 0) {
  41             LINE( vcache,
  42                   flags,
  43                   get_elt(elts, i - 1),
  44                   get_elt(elts, i ));
  45          }
  46
  47          LINE( vcache,
  48                flags,
  49                get_elt(elts, i - 1),
  50                get_elt(elts, 0 ));
  51       }
  52       break;
  53
  54    case PIPE_PRIM_LINE_STRIP:
  55       flags = DRAW_PIPE_RESET_STIPPLE;
  56       for (i = 1; i < count; i++, flags = 0) {
  57          LINE( vcache,
  58                flags,
  59                get_elt(elts, i - 1),
  60                get_elt(elts, i ));
  61       }
  62       break;
  63
  64    case PIPE_PRIM_TRIANGLES:
  65       for (i = 0; i+2 < count; i += 3) {
  66          TRIANGLE( vcache,
  67                    DRAW_PIPE_RESET_STIPPLE | DRAW_PIPE_EDGE_FLAG_ALL,
  68                    get_elt(elts, i + 0),
  69                    get_elt(elts, i + 1),
  70                    get_elt(elts, i + 2 ));
  71       }
  72       break;
  73
  74    case PIPE_PRIM_TRIANGLE_STRIP:
  75       if (flatfirst) {
  76          for (i = 0; i+2 < count; i++) {
  77             TRIANGLE( vcache,
  78                       DRAW_PIPE_RESET_STIPPLE | DRAW_PIPE_EDGE_FLAG_ALL,
  79                       get_elt(elts, i + 0),
  80                       get_elt(elts, i + 1 + (i&1)),
  81                       get_elt(elts, i + 2 - (i&1)));
  82          }
  83       }
  84       else {
  85          for (i = 0; i+2 < count; i++) {
  86             TRIANGLE( vcache,
  87                       DRAW_PIPE_RESET_STIPPLE | DRAW_PIPE_EDGE_FLAG_ALL,
  88                       get_elt(elts, i + 0 + (i&1)),
  89                       get_elt(elts, i + 1 - (i&1)),
  90                       get_elt(elts, i + 2 ));
  91          }
  92       }
  93       break;
  94
  95    case PIPE_PRIM_TRIANGLE_FAN:
  96       if (count >= 3) {
  97          if (flatfirst) {
  98             for (i = 0; i+2 < count; i++) {
  99                TRIANGLE( vcache,
 100                          DRAW_PIPE_RESET_STIPPLE | DRAW_PIPE_EDGE_FLAG_ALL,
 101                          get_elt(elts, i + 1),
 102                          get_elt(elts, i + 2),
 103                          get_elt(elts, 0 ));
 104             }
 105          }
 106          else {
 107             for (i = 0; i+2 < count; i++) {
 108                TRIANGLE( vcache,
 109                          DRAW_PIPE_RESET_STIPPLE | DRAW_PIPE_EDGE_FLAG_ALL,
 110                          get_elt(elts, 0),
 111                          get_elt(elts, i + 1),
 112                          get_elt(elts, i + 2 ));
 113             }
 114          }
 115       }
 116       break;
 117
 118
 119    case PIPE_PRIM_QUADS:
 120       for (i = 0; i+3 < count; i += 4) {
 121          if (flatfirst) {
 122             QUAD( vcache,
 123                   get_elt(elts, i + 0),
 124                   get_elt(elts, i + 1),
 125                   get_elt(elts, i + 2),
 126                   get_elt(elts, i + 3) );
 127          }
 128          else {
 129             QUAD( vcache,
 130                   get_elt(elts, i + 0),
 131                   get_elt(elts, i + 1),
 132                   get_elt(elts, i + 2),
 133                   get_elt(elts, i + 3) );
 134          }
 135       }
 136       break;
 137
 138    case PIPE_PRIM_QUAD_STRIP:
 139       for (i = 0; i+3 < count; i += 2) {
 140          if (flatfirst) {
 141             QUAD( vcache,
 142                   get_elt(elts, i + 0),
 143                   get_elt(elts, i + 1),
 144                   get_elt(elts, i + 3),
 145                   get_elt(elts, i + 2) );
 146          }
 147          else {
 148             QUAD( vcache,
 149                   get_elt(elts, i + 2),
 150                   get_elt(elts, i + 0),
 151                   get_elt(elts, i + 1),
 152                   get_elt(elts, i + 3) );
 153          }
 154       }
 155       break;
 156
 157    case PIPE_PRIM_POLYGON:
 158       {
 159          /* These bitflags look a little odd because we submit the
 160           * vertices as (1,2,0) to satisfy flatshade requirements.
 161           */
 162          const ushort edge_first  = DRAW_PIPE_EDGE_FLAG_2;
 163          const ushort edge_middle = DRAW_PIPE_EDGE_FLAG_0;
 164          const ushort edge_last   = DRAW_PIPE_EDGE_FLAG_1;
 165          ushort edge_next, edge_finish;
 166
 167          if (flatfirst) {
 168             flags = DRAW_PIPE_RESET_STIPPLE | edge_middle | edge_last;
 169             edge_next = edge_last;
 170             edge_finish = edge_first;
 171          }
 172          else {
 173             flags = DRAW_PIPE_RESET_STIPPLE | edge_first | edge_middle;
 174             edge_next = edge_middle;
 175             edge_finish = edge_last;
 176          }
 177
 178          for (i = 0; i+2 < count; i++, flags = edge_next) {
 179
 180             if (i + 3 == count)
 181                flags |= edge_finish;
 182
 183             if (flatfirst) {
 184                TRIANGLE( vcache,
 185                          flags,
 186                          get_elt(elts, 0),
 187                          get_elt(elts, i + 1),
 188                          get_elt(elts, i + 2) );
 189             }
 190             else {
 191                TRIANGLE( vcache,
 192                          flags,
 193                          get_elt(elts, i + 1),
 194                          get_elt(elts, i + 2),
 195                          get_elt(elts, 0));
 196             }
 197          }
 198       }
 199       break;
 200
 201    default:
 202       assert(0);
 203       break;
 204    }
 205
 206    vcache_flush( vcache );
 207 }
 208
 209
 210 #undef TRIANGLE
 211 #undef QUAD
 212 #undef POINT
 213 #undef LINE
 214 #undef FUNC