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