src/gallium/auxiliary/util/u_prim.h

   1 /**************************************************************************
   2  *
   3  * Copyright 2008 VMware, Inc.
   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 VMWARE 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_PRIM_H
  30 #define U_PRIM_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    unsigned min;
  42    unsigned 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 enum pipe_prim_type
  50 u_decomposed_prim(enum pipe_prim_type 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 enum pipe_prim_type
  75 u_reduced_prim(enum pipe_prim_type 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 enum pipe_prim_type
  95 u_assembled_prim(enum pipe_prim_type 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(enum pipe_prim_type 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 /**
 140  * Given a vertex count, return the number of primitives.
 141  * For polygons, return the number of triangles.
 142  */
 143 static inline unsigned
 144 u_prims_for_vertices(enum pipe_prim_type prim, unsigned num)
 145 {
 146    const struct u_prim_vertex_count *info = u_prim_vertex_count(prim);
 147
 148    assert(info);
 149    assert(info->incr != 0);
 150
 151    if (num < info->min)
 152       return 0;
 153
 154    return 1 + ((num - info->min) / info->incr);
 155 }
 156
 157 static inline boolean
 158 u_validate_pipe_prim(enum pipe_prim_type pipe_prim, unsigned nr)
 159 {
 160    const struct u_prim_vertex_count *count = u_prim_vertex_count(pipe_prim);
 161
 162    return (count && nr >= count->min);
 163 }
 164
 165
 166 static inline boolean
 167 u_trim_pipe_prim(enum pipe_prim_type pipe_prim, unsigned *nr)
 168 {
 169    const struct u_prim_vertex_count *count = u_prim_vertex_count(pipe_prim);
 170
 171    if (count && *nr >= count->min) {
 172       if (count->incr > 1)
 173          *nr -= (*nr % count->incr);
 174       return TRUE;
 175    }
 176    else {
 177       *nr = 0;
 178       return FALSE;
 179    }
 180 }
 181
 182 static inline unsigned
 183 u_vertices_per_prim(enum pipe_prim_type primitive)
 184 {
 185    switch(primitive) {
 186    case PIPE_PRIM_POINTS:
 187       return 1;
 188    case PIPE_PRIM_LINES:
 189    case PIPE_PRIM_LINE_LOOP:
 190    case PIPE_PRIM_LINE_STRIP:
 191       return 2;
 192    case PIPE_PRIM_TRIANGLES:
 193    case PIPE_PRIM_TRIANGLE_STRIP:
 194    case PIPE_PRIM_TRIANGLE_FAN:
 195       return 3;
 196    case PIPE_PRIM_LINES_ADJACENCY:
 197    case PIPE_PRIM_LINE_STRIP_ADJACENCY:
 198       return 4;
 199    case PIPE_PRIM_TRIANGLES_ADJACENCY:
 200    case PIPE_PRIM_TRIANGLE_STRIP_ADJACENCY:
 201       return 6;
 202
 203    /* following primitives should never be used
 204     * with geometry shaders abd their size is
 205     * undefined */
 206    case PIPE_PRIM_POLYGON:
 207    case PIPE_PRIM_QUADS:
 208    case PIPE_PRIM_QUAD_STRIP:
 209    default:
 210       debug_printf("Unrecognized geometry shader primitive");
 211       return 3;
 212    }
 213 }
 214
 215 /**
 216  * Returns the number of decomposed primitives for the given
 217  * vertex count.
 218  * Parts of the pipline are invoked once for each triangle in
 219  * triangle strip, triangle fans and triangles and once
 220  * for each line in line strip, line loop, lines. Also
 221  * statistics depend on knowing the exact number of decomposed
 222  * primitives for a set of vertices.
 223  */
 224 static inline unsigned
 225 u_decomposed_prims_for_vertices(enum pipe_prim_type primitive, int vertices)
 226 {
 227    switch (primitive) {
 228    case PIPE_PRIM_POINTS:
 229       return vertices;
 230    case PIPE_PRIM_LINES:
 231       return vertices / 2;
 232    case PIPE_PRIM_LINE_LOOP:
 233       return (vertices >= 2) ? vertices : 0;
 234    case PIPE_PRIM_LINE_STRIP:
 235       return (vertices >= 2) ? vertices - 1 : 0;
 236    case PIPE_PRIM_TRIANGLES:
 237       return vertices / 3;
 238    case PIPE_PRIM_TRIANGLE_STRIP:
 239       return (vertices >= 3) ? vertices - 2 : 0;
 240    case PIPE_PRIM_TRIANGLE_FAN:
 241       return (vertices >= 3) ? vertices - 2 : 0;
 242    case PIPE_PRIM_LINES_ADJACENCY:
 243       return vertices / 4;
 244    case PIPE_PRIM_LINE_STRIP_ADJACENCY:
 245       return (vertices >= 4) ? vertices - 3 : 0;
 246    case PIPE_PRIM_TRIANGLES_ADJACENCY:
 247       return vertices / 6;
 248    case PIPE_PRIM_TRIANGLE_STRIP_ADJACENCY:
 249       return (vertices >= 6) ? 1 + (vertices - 6) / 2 : 0;
 250    case PIPE_PRIM_QUADS:
 251       return vertices / 4;
 252    case PIPE_PRIM_QUAD_STRIP:
 253       return (vertices >= 4) ? (vertices - 2) / 2 : 0;
 254    /* Polygons can't be decomposed
 255     * because the number of their vertices isn't known so
 256     * for them and whatever else we don't recognize just
 257     * return 1 if the number of vertices is greater than
 258     * or equal to 3 and zero otherwise */
 259    case PIPE_PRIM_POLYGON:
 260    default:
 261       debug_printf("Invalid decomposition primitive!\n");
 262       return (vertices >= 3) ? 1 : 0;
 263    }
 264 }
 265
 266 /**
 267  * Returns the number of reduced/tessellated primitives for the given vertex
 268  * count.  Each quad is treated as two triangles.  Polygons are treated as
 269  * triangle fans.
 270  */
 271 static inline unsigned
 272 u_reduced_prims_for_vertices(enum pipe_prim_type primitive, int vertices)
 273 {
 274    switch (primitive) {
 275    case PIPE_PRIM_QUADS:
 276    case PIPE_PRIM_QUAD_STRIP:
 277       return u_decomposed_prims_for_vertices(primitive, vertices) * 2;
 278    case PIPE_PRIM_POLYGON:
 279       primitive = PIPE_PRIM_TRIANGLE_FAN;
 280       /* fall through */
 281    default:
 282       return u_decomposed_prims_for_vertices(primitive, vertices);
 283    }
 284 }
 285
 286 static inline enum pipe_prim_type
 287 u_base_prim_type(enum pipe_prim_type prim_type)
 288 {
 289    switch(prim_type) {
 290       case PIPE_PRIM_POINTS:
 291          return PIPE_PRIM_POINTS;
 292       case PIPE_PRIM_LINES:
 293       case PIPE_PRIM_LINE_LOOP:
 294       case PIPE_PRIM_LINE_STRIP:
 295       case PIPE_PRIM_LINES_ADJACENCY:
 296       case PIPE_PRIM_LINE_STRIP_ADJACENCY:
 297          return PIPE_PRIM_LINES;
 298       case PIPE_PRIM_TRIANGLES:
 299       case PIPE_PRIM_TRIANGLE_STRIP:
 300       case PIPE_PRIM_TRIANGLE_FAN:
 301       case PIPE_PRIM_TRIANGLES_ADJACENCY:
 302       case PIPE_PRIM_TRIANGLE_STRIP_ADJACENCY:
 303          return PIPE_PRIM_TRIANGLES;
 304       case PIPE_PRIM_QUADS:
 305       case PIPE_PRIM_QUAD_STRIP:
 306          return PIPE_PRIM_QUADS;
 307       default:
 308          return prim_type;
 309    }
 310 }
 311
 312 static inline unsigned
 313 u_vertices_for_prims(enum pipe_prim_type prim_type, int count)
 314 {
 315    if (count <= 0)
 316       return 0;
 317
 318    /* We can only figure out the number of vertices from a number of primitives
 319     * if we are using basic primitives (so no loops, strips, fans, etc).
 320     */
 321    assert(prim_type == u_base_prim_type(prim_type) &&
 322           prim_type != PIPE_PRIM_PATCHES && prim_type != PIPE_PRIM_POLYGON);
 323
 324    const struct u_prim_vertex_count *info = u_prim_vertex_count(prim_type);
 325    assert(info);
 326
 327    return info->min + (count - 1) * info->incr;
 328 }
 329
 330 const char *u_prim_name(enum pipe_prim_type pipe_prim);
 331
 332
 333 #ifdef __cplusplus
 334 }
 335 #endif
 336
 337
 338 #endif