src/gallium/auxiliary/util/u_prim.h

   1 /**************************************************************************
   2  *
   3  * Copyright 2008 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 #ifndef U_BLIT_H
  30 #define U_BLIT_H
  31
  32
  33 #include "pipe/p_defines.h"
  34 #include "util/u_debug.h"
  35
  36 #ifdef __cplusplus
  37 extern "C" {
  38 #endif
  39
  40 struct u_prim_vertex_count {
  41    int min;
  42    int incr;
  43 };
  44
  45 /**
  46  * Decompose a primitive that is a loop, a strip, or a fan.  Return the
  47  * original primitive if it is already decomposed.
  48  */
  49 static INLINE unsigned
  50 u_decomposed_prim(unsigned prim)
  51 {
  52    switch (prim) {
  53    case PIPE_PRIM_LINE_LOOP:
  54    case PIPE_PRIM_LINE_STRIP:
  55       return PIPE_PRIM_LINES;
  56    case PIPE_PRIM_TRIANGLE_STRIP:
  57    case PIPE_PRIM_TRIANGLE_FAN:
  58       return PIPE_PRIM_TRIANGLES;
  59    case PIPE_PRIM_QUAD_STRIP:
  60       return PIPE_PRIM_QUADS;
  61    case PIPE_PRIM_LINE_STRIP_ADJACENCY:
  62       return PIPE_PRIM_LINES_ADJACENCY;
  63    case PIPE_PRIM_TRIANGLE_STRIP_ADJACENCY:
  64       return PIPE_PRIM_TRIANGLES_ADJACENCY;
  65    default:
  66       return prim;
  67    }
  68 }
  69
  70 /**
  71  * Reduce a primitive to one of PIPE_PRIM_POINTS, PIPE_PRIM_LINES, and
  72  * PIPE_PRIM_TRIANGLES.
  73  */
  74 static INLINE unsigned
  75 u_reduced_prim(unsigned prim)
  76 {
  77    switch (prim) {
  78    case PIPE_PRIM_POINTS:
  79       return PIPE_PRIM_POINTS;
  80    case PIPE_PRIM_LINES:
  81    case PIPE_PRIM_LINE_LOOP:
  82    case PIPE_PRIM_LINE_STRIP:
  83    case PIPE_PRIM_LINES_ADJACENCY:
  84    case PIPE_PRIM_LINE_STRIP_ADJACENCY:
  85       return PIPE_PRIM_LINES;
  86    default:
  87       return PIPE_PRIM_TRIANGLES;
  88    }
  89 }
  90
  91 /**
  92  * Re-assemble a primitive to remove its adjacency.
  93  */
  94 static INLINE unsigned
  95 u_assembled_prim(unsigned prim)
  96 {
  97    switch (prim) {
  98    case PIPE_PRIM_LINES_ADJACENCY:
  99    case PIPE_PRIM_LINE_STRIP_ADJACENCY:
 100       return PIPE_PRIM_LINES;
 101    case PIPE_PRIM_TRIANGLES_ADJACENCY:
 102    case PIPE_PRIM_TRIANGLE_STRIP_ADJACENCY:
 103       return PIPE_PRIM_TRIANGLES;
 104    default:
 105       return prim;
 106    }
 107 }
 108
 109 /**
 110  * Return the vertex count information for a primitive.
 111  *
 112  * Note that if this function is called directly or indirectly anywhere in a
 113  * source file, it will increase the size of the binary slightly more than
 114  * expected because of the use of a table.
 115  */
 116 static INLINE const struct u_prim_vertex_count *
 117 u_prim_vertex_count(unsigned prim)
 118 {
 119    static const struct u_prim_vertex_count prim_table[PIPE_PRIM_MAX] = {
 120       { 1, 1 }, /* PIPE_PRIM_POINTS */
 121       { 2, 2 }, /* PIPE_PRIM_LINES */
 122       { 2, 1 }, /* PIPE_PRIM_LINE_LOOP */
 123       { 2, 1 }, /* PIPE_PRIM_LINE_STRIP */
 124       { 3, 3 }, /* PIPE_PRIM_TRIANGLES */
 125       { 3, 1 }, /* PIPE_PRIM_TRIANGLE_STRIP */
 126       { 3, 1 }, /* PIPE_PRIM_TRIANGLE_FAN */
 127       { 4, 4 }, /* PIPE_PRIM_QUADS */
 128       { 4, 2 }, /* PIPE_PRIM_QUAD_STRIP */
 129       { 3, 1 }, /* PIPE_PRIM_POLYGON */
 130       { 4, 4 }, /* PIPE_PRIM_LINES_ADJACENCY */
 131       { 4, 1 }, /* PIPE_PRIM_LINE_STRIP_ADJACENCY */
 132       { 6, 6 }, /* PIPE_PRIM_TRIANGLES_ADJACENCY */
 133       { 6, 2 }, /* PIPE_PRIM_TRIANGLE_STRIP_ADJACENCY */
 134    };
 135
 136    return (likely(prim < PIPE_PRIM_MAX)) ? &prim_table[prim] : NULL;
 137 }
 138
 139 static INLINE boolean u_validate_pipe_prim( unsigned pipe_prim, unsigned nr )
 140 {
 141    boolean ok = TRUE;
 142
 143    switch (pipe_prim) {
 144    case PIPE_PRIM_POINTS:
 145       ok = (nr >= 1);
 146       break;
 147    case PIPE_PRIM_LINES:
 148       ok = (nr >= 2);
 149       break;
 150    case PIPE_PRIM_LINE_STRIP:
 151    case PIPE_PRIM_LINE_LOOP:
 152       ok = (nr >= 2);
 153       break;
 154    case PIPE_PRIM_TRIANGLES:
 155       ok = (nr >= 3);
 156       break;
 157    case PIPE_PRIM_TRIANGLE_STRIP:
 158    case PIPE_PRIM_TRIANGLE_FAN:
 159    case PIPE_PRIM_POLYGON:
 160       ok = (nr >= 3);
 161       break;
 162    case PIPE_PRIM_QUADS:
 163       ok = (nr >= 4);
 164       break;
 165    case PIPE_PRIM_QUAD_STRIP:
 166       ok = (nr >= 4);
 167       break;
 168    default:
 169       ok = 0;
 170       break;
 171    }
 172
 173    return ok;
 174 }
 175
 176
 177 static INLINE boolean u_trim_pipe_prim( unsigned pipe_prim, unsigned *nr )
 178 {
 179    const struct u_prim_vertex_count *count = u_prim_vertex_count(pipe_prim);
 180
 181    if (count && *nr >= count->min) {
 182       if (count->incr > 1)
 183          *nr -= (*nr % count->incr);
 184       return TRUE;
 185    }
 186    else {
 187       *nr = 0;
 188       return FALSE;
 189    }
 190 }
 191
 192 static INLINE unsigned
 193 u_vertices_per_prim(int primitive)
 194 {
 195    switch(primitive) {
 196    case PIPE_PRIM_POINTS:
 197       return 1;
 198    case PIPE_PRIM_LINES:
 199    case PIPE_PRIM_LINE_LOOP:
 200    case PIPE_PRIM_LINE_STRIP:
 201       return 2;
 202    case PIPE_PRIM_TRIANGLES:
 203    case PIPE_PRIM_TRIANGLE_STRIP:
 204    case PIPE_PRIM_TRIANGLE_FAN:
 205       return 3;
 206    case PIPE_PRIM_LINES_ADJACENCY:
 207    case PIPE_PRIM_LINE_STRIP_ADJACENCY:
 208       return 4;
 209    case PIPE_PRIM_TRIANGLES_ADJACENCY:
 210    case PIPE_PRIM_TRIANGLE_STRIP_ADJACENCY:
 211       return 6;
 212
 213    /* following primitives should never be used
 214     * with geometry shaders abd their size is
 215     * undefined */
 216    case PIPE_PRIM_POLYGON:
 217    case PIPE_PRIM_QUADS:
 218    case PIPE_PRIM_QUAD_STRIP:
 219    default:
 220       debug_printf("Unrecognized geometry shader primitive");
 221       return 3;
 222    }
 223 }
 224
 225 /**
 226  * Returns the number of decomposed primitives for the given
 227  * vertex count.
 228  * Parts of the pipline are invoked once for each triangle in
 229  * triangle strip, triangle fans and triangles and once
 230  * for each line in line strip, line loop, lines. Also
 231  * statistics depend on knowing the exact number of decomposed
 232  * primitives for a set of vertices.
 233  */
 234 static INLINE unsigned
 235 u_decomposed_prims_for_vertices(int primitive, int vertices)
 236 {
 237    switch(primitive) {
 238    case PIPE_PRIM_POINTS:
 239       return vertices;
 240    case PIPE_PRIM_LINES:
 241       return vertices / 2;
 242    case PIPE_PRIM_LINE_LOOP:
 243       return vertices;
 244    case PIPE_PRIM_LINE_STRIP:
 245       return (vertices > 1) ? vertices - 1 : 0;
 246    case PIPE_PRIM_TRIANGLES:
 247       return vertices /  3;
 248    case PIPE_PRIM_TRIANGLE_STRIP:
 249       return (vertices > 2) ? vertices - 2 : 0;
 250    case PIPE_PRIM_TRIANGLE_FAN:
 251       return (vertices > 2) ? vertices - 2 : 0;
 252    case PIPE_PRIM_LINES_ADJACENCY:
 253       return vertices / 4;
 254    case PIPE_PRIM_LINE_STRIP_ADJACENCY:
 255       return (vertices > 3) ? vertices - 3 : 0;
 256    case PIPE_PRIM_TRIANGLES_ADJACENCY:
 257       return vertices / 6;
 258    case PIPE_PRIM_TRIANGLE_STRIP_ADJACENCY:
 259       return (vertices > 5) ? 1 + (vertices - 6)/2 : 0;
 260    case PIPE_PRIM_QUADS:
 261       return vertices / 4;
 262    case PIPE_PRIM_QUAD_STRIP:
 263       return (vertices > 4) ? (vertices - 2) / 2 : 0;
 264    /* Polygons can't be decomposed
 265     * because the number of their vertices isn't known so
 266     * for them and whatever else we don't recognize just
 267     * return 1 if the number of vertices is greater than
 268     * 3 and zero otherwise */
 269    case PIPE_PRIM_POLYGON:
 270    default:
 271       debug_printf("Invalid decomposition primitive!\n");
 272       return (vertices > 3) ? 1 : 0;
 273    }
 274 }
 275
 276 static INLINE unsigned
 277 u_assembled_primitive(unsigned prim)
 278 {
 279    return u_assembled_prim(prim);
 280 }
 281
 282
 283
 284 const char *u_prim_name( unsigned pipe_prim );
 285
 286 #endif