Home | History | Annotate | Download | only in draw
      1 /**************************************************************************
      2  *
      3  * Copyright 2007 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  * \brief  Clipping stage
     30  *
     31  * \author  Keith Whitwell <keithw (at) vmware.com>
     32  */
     33 
     34 
     35 #include "util/u_bitcast.h"
     36 #include "util/u_memory.h"
     37 #include "util/u_math.h"
     38 
     39 #include "pipe/p_shader_tokens.h"
     40 
     41 #include "draw_vs.h"
     42 #include "draw_pipe.h"
     43 #include "draw_fs.h"
     44 #include "draw_gs.h"
     45 
     46 
     47 /** Set to 1 to enable printing of coords before/after clipping */
     48 #define DEBUG_CLIP 0
     49 
     50 
     51 #ifndef DIFFERENT_SIGNS
     52 #define DIFFERENT_SIGNS(x, y) ((x) * (y) <= 0.0F && (x) - (y) != 0.0F)
     53 #endif
     54 
     55 #define MAX_CLIPPED_VERTICES ((2 * (6 + PIPE_MAX_CLIP_PLANES))+1)
     56 
     57 
     58 
     59 struct clip_stage {
     60    struct draw_stage stage;      /**< base class */
     61 
     62    unsigned pos_attr;
     63    boolean have_clipdist;
     64    int cv_attr;
     65 
     66    /* List of the attributes to be constant interpolated. */
     67    uint num_const_attribs;
     68    uint8_t const_attribs[PIPE_MAX_SHADER_OUTPUTS];
     69    /* List of the attributes to be linear interpolated. */
     70    uint num_linear_attribs;
     71    uint8_t linear_attribs[PIPE_MAX_SHADER_OUTPUTS];
     72    /* List of the attributes to be perspective interpolated. */
     73    uint num_perspect_attribs;
     74    uint8_t perspect_attribs[PIPE_MAX_SHADER_OUTPUTS];
     75 
     76    float (*plane)[4];
     77 };
     78 
     79 
     80 /** Cast wrapper */
     81 static inline struct clip_stage *clip_stage(struct draw_stage *stage)
     82 {
     83    return (struct clip_stage *)stage;
     84 }
     85 
     86 static inline unsigned
     87 draw_viewport_index(struct draw_context *draw,
     88                     const struct vertex_header *leading_vertex)
     89 {
     90    if (draw_current_shader_uses_viewport_index(draw)) {
     91       unsigned viewport_index_output =
     92          draw_current_shader_viewport_index_output(draw);
     93       unsigned viewport_index =
     94          u_bitcast_f2u(leading_vertex->data[viewport_index_output][0]);
     95       return draw_clamp_viewport_idx(viewport_index);
     96    } else {
     97       return 0;
     98    }
     99 }
    100 
    101 
    102 #define LINTERP(T, OUT, IN) ((OUT) + (T) * ((IN) - (OUT)))
    103 
    104 
    105 /* All attributes are float[4], so this is easy:
    106  */
    107 static void interp_attr(float dst[4],
    108                         float t,
    109                         const float in[4],
    110                         const float out[4])
    111 {
    112    dst[0] = LINTERP( t, out[0], in[0] );
    113    dst[1] = LINTERP( t, out[1], in[1] );
    114    dst[2] = LINTERP( t, out[2], in[2] );
    115    dst[3] = LINTERP( t, out[3], in[3] );
    116 }
    117 
    118 
    119 /**
    120  * Copy flat shaded attributes src vertex to dst vertex.
    121  */
    122 static void copy_flat(struct draw_stage *stage,
    123                       struct vertex_header *dst,
    124                       const struct vertex_header *src)
    125 {
    126    const struct clip_stage *clipper = clip_stage(stage);
    127    uint i;
    128    for (i = 0; i < clipper->num_const_attribs; i++) {
    129       const uint attr = clipper->const_attribs[i];
    130       COPY_4FV(dst->data[attr], src->data[attr]);
    131    }
    132 }
    133 
    134 /* Interpolate between two vertices to produce a third.
    135  */
    136 static void interp(const struct clip_stage *clip,
    137                    struct vertex_header *dst,
    138                    float t,
    139                    const struct vertex_header *out,
    140                    const struct vertex_header *in,
    141                    unsigned viewport_index)
    142 {
    143    const unsigned pos_attr = clip->pos_attr;
    144    unsigned j;
    145    float t_nopersp;
    146 
    147    /* Vertex header.
    148     */
    149    dst->clipmask = 0;
    150    dst->edgeflag = 0;        /* will get overwritten later */
    151    dst->pad = 0;
    152    dst->vertex_id = UNDEFINED_VERTEX_ID;
    153 
    154    /* Interpolate the clip-space coords.
    155     */
    156    if (clip->cv_attr >= 0) {
    157       interp_attr(dst->data[clip->cv_attr], t,
    158                   in->data[clip->cv_attr], out->data[clip->cv_attr]);
    159    }
    160    /* interpolate the clip-space position */
    161    interp_attr(dst->clip_pos, t, in->clip_pos, out->clip_pos);
    162 
    163    /* Do the projective divide and viewport transformation to get
    164     * new window coordinates:
    165     */
    166    {
    167       const float *pos = dst->clip_pos;
    168       const float *scale =
    169          clip->stage.draw->viewports[viewport_index].scale;
    170       const float *trans =
    171          clip->stage.draw->viewports[viewport_index].translate;
    172       const float oow = 1.0f / pos[3];
    173 
    174       dst->data[pos_attr][0] = pos[0] * oow * scale[0] + trans[0];
    175       dst->data[pos_attr][1] = pos[1] * oow * scale[1] + trans[1];
    176       dst->data[pos_attr][2] = pos[2] * oow * scale[2] + trans[2];
    177       dst->data[pos_attr][3] = oow;
    178    }
    179 
    180 
    181    /* interp perspective attribs */
    182    for (j = 0; j < clip->num_perspect_attribs; j++) {
    183       const unsigned attr = clip->perspect_attribs[j];
    184       interp_attr(dst->data[attr], t, in->data[attr], out->data[attr]);
    185    }
    186 
    187    /**
    188     * Compute the t in screen-space instead of 3d space to use
    189     * for noperspective interpolation.
    190     *
    191     * The points can be aligned with the X axis, so in that case try
    192     * the Y.  When both points are at the same screen position, we can
    193     * pick whatever value (the interpolated point won't be in front
    194     * anyway), so just use the 3d t.
    195     */
    196    if (clip->num_linear_attribs) {
    197       int k;
    198       t_nopersp = t;
    199       /* find either in.x != out.x or in.y != out.y */
    200       for (k = 0; k < 2; k++) {
    201          if (in->clip_pos[k] != out->clip_pos[k]) {
    202             /* do divide by W, then compute linear interpolation factor */
    203             float in_coord = in->clip_pos[k] / in->clip_pos[3];
    204             float out_coord = out->clip_pos[k] / out->clip_pos[3];
    205             float dst_coord = dst->clip_pos[k] / dst->clip_pos[3];
    206             t_nopersp = (dst_coord - out_coord) / (in_coord - out_coord);
    207             break;
    208          }
    209       }
    210       for (j = 0; j < clip->num_linear_attribs; j++) {
    211          const unsigned attr = clip->linear_attribs[j];
    212          interp_attr(dst->data[attr], t_nopersp, in->data[attr], out->data[attr]);
    213       }
    214    }
    215 }
    216 
    217 /**
    218  * Checks whether the specified triangle is empty and if it is returns
    219  * true, otherwise returns false.
    220  * Triangle is considered null/empty if its area is equal to zero.
    221  */
    222 static inline boolean
    223 is_tri_null(const struct clip_stage *clip, const struct prim_header *header)
    224 {
    225    const unsigned pos_attr = clip->pos_attr;
    226    float x1 = header->v[1]->data[pos_attr][0] - header->v[0]->data[pos_attr][0];
    227    float y1 = header->v[1]->data[pos_attr][1] - header->v[0]->data[pos_attr][1];
    228    float z1 = header->v[1]->data[pos_attr][2] - header->v[0]->data[pos_attr][2];
    229 
    230    float x2 = header->v[2]->data[pos_attr][0] - header->v[0]->data[pos_attr][0];
    231    float y2 = header->v[2]->data[pos_attr][1] - header->v[0]->data[pos_attr][1];
    232    float z2 = header->v[2]->data[pos_attr][2] - header->v[0]->data[pos_attr][2];
    233 
    234    float vx = y1 * z2 - z1 * y2;
    235    float vy = x1 * z2 - z1 * x2;
    236    float vz = x1 * y2 - y1 * x2;
    237 
    238    return (vx*vx  + vy*vy + vz*vz) == 0.f;
    239 }
    240 
    241 /**
    242  * Emit a post-clip polygon to the next pipeline stage.  The polygon
    243  * will be convex and the provoking vertex will always be vertex[0].
    244  */
    245 static void emit_poly(struct draw_stage *stage,
    246                       struct vertex_header **inlist,
    247                       const boolean *edgeflags,
    248                       unsigned n,
    249                       const struct prim_header *origPrim)
    250 {
    251    const struct clip_stage *clipper = clip_stage(stage);
    252    struct prim_header header;
    253    unsigned i;
    254    ushort edge_first, edge_middle, edge_last;
    255    boolean last_tri_was_null = FALSE;
    256    boolean tri_was_not_null = FALSE;
    257 
    258    if (stage->draw->rasterizer->flatshade_first) {
    259       edge_first  = DRAW_PIPE_EDGE_FLAG_0;
    260       edge_middle = DRAW_PIPE_EDGE_FLAG_1;
    261       edge_last   = DRAW_PIPE_EDGE_FLAG_2;
    262    }
    263    else {
    264       edge_first  = DRAW_PIPE_EDGE_FLAG_2;
    265       edge_middle = DRAW_PIPE_EDGE_FLAG_0;
    266       edge_last   = DRAW_PIPE_EDGE_FLAG_1;
    267    }
    268 
    269    if (!edgeflags[0])
    270       edge_first = 0;
    271 
    272    /* later stages may need the determinant, but only the sign matters */
    273    header.det = origPrim->det;
    274    header.flags = DRAW_PIPE_RESET_STIPPLE | edge_first | edge_middle;
    275    header.pad = 0;
    276 
    277    for (i = 2; i < n; i++, header.flags = edge_middle) {
    278       boolean tri_null;
    279       /* order the triangle verts to respect the provoking vertex mode */
    280       if (stage->draw->rasterizer->flatshade_first) {
    281          header.v[0] = inlist[0];  /* the provoking vertex */
    282          header.v[1] = inlist[i-1];
    283          header.v[2] = inlist[i];
    284       }
    285       else {
    286          header.v[0] = inlist[i-1];
    287          header.v[1] = inlist[i];
    288          header.v[2] = inlist[0];  /* the provoking vertex */
    289       }
    290 
    291       tri_null = is_tri_null(clipper, &header);
    292       /* If we generated a triangle with an area, aka. non-null triangle,
    293        * or if the previous triangle was also null then skip all subsequent
    294        * null triangles */
    295       if ((tri_was_not_null && tri_null) || (last_tri_was_null && tri_null)) {
    296          last_tri_was_null = tri_null;
    297          continue;
    298       }
    299       last_tri_was_null = tri_null;
    300       if (!tri_null) {
    301          tri_was_not_null = TRUE;
    302       }
    303 
    304       if (!edgeflags[i-1]) {
    305          header.flags &= ~edge_middle;
    306       }
    307 
    308       if (i == n - 1 && edgeflags[i])
    309          header.flags |= edge_last;
    310 
    311       if (DEBUG_CLIP) {
    312          uint j, k;
    313          debug_printf("Clipped tri: (flat-shade-first = %d)\n",
    314                       stage->draw->rasterizer->flatshade_first);
    315          for (j = 0; j < 3; j++) {
    316             debug_printf("  Vert %d: clip pos: %f %f %f %f\n", j,
    317                          header.v[j]->clip_pos[0],
    318                          header.v[j]->clip_pos[1],
    319                          header.v[j]->clip_pos[2],
    320                          header.v[j]->clip_pos[3]);
    321             if (clipper->cv_attr >= 0) {
    322                debug_printf("  Vert %d: cv: %f %f %f %f\n", j,
    323                             header.v[j]->data[clipper->cv_attr][0],
    324                             header.v[j]->data[clipper->cv_attr][1],
    325                             header.v[j]->data[clipper->cv_attr][2],
    326                             header.v[j]->data[clipper->cv_attr][3]);
    327             }
    328             for (k = 0; k < draw_num_shader_outputs(stage->draw); k++) {
    329                debug_printf("  Vert %d: Attr %d:  %f %f %f %f\n", j, k,
    330                             header.v[j]->data[k][0],
    331                             header.v[j]->data[k][1],
    332                             header.v[j]->data[k][2],
    333                             header.v[j]->data[k][3]);
    334             }
    335          }
    336       }
    337       stage->next->tri(stage->next, &header);
    338    }
    339 }
    340 
    341 
    342 static inline float
    343 dot4(const float *a, const float *b)
    344 {
    345    return (a[0] * b[0] +
    346            a[1] * b[1] +
    347            a[2] * b[2] +
    348            a[3] * b[3]);
    349 }
    350 
    351 /*
    352  * this function extracts the clip distance for the current plane,
    353  * it first checks if the shader provided a clip distance, otherwise
    354  * it works out the value using the clipvertex
    355  */
    356 static inline float getclipdist(const struct clip_stage *clipper,
    357                                 struct vertex_header *vert,
    358                                 int plane_idx)
    359 {
    360    const float *plane;
    361    float dp;
    362    if (plane_idx < 6) {
    363       /* ordinary xyz view volume clipping uses pos output */
    364       plane = clipper->plane[plane_idx];
    365       dp = dot4(vert->clip_pos, plane);
    366    }
    367    else if (clipper->have_clipdist) {
    368       /* pick the correct clipdistance element from the output vectors */
    369       int _idx = plane_idx - 6;
    370       int cdi = _idx >= 4;
    371       int vidx = cdi ? _idx - 4 : _idx;
    372       dp = vert->data[draw_current_shader_ccdistance_output(clipper->stage.draw, cdi)][vidx];
    373    } else {
    374       /*
    375        * legacy user clip planes or gl_ClipVertex
    376        */
    377       plane = clipper->plane[plane_idx];
    378       if (clipper->cv_attr >= 0) {
    379          dp = dot4(vert->data[clipper->cv_attr], plane);
    380       }
    381       else {
    382          dp = dot4(vert->clip_pos, plane);
    383       }
    384    }
    385    return dp;
    386 }
    387 
    388 /* Clip a triangle against the viewport and user clip planes.
    389  */
    390 static void
    391 do_clip_tri(struct draw_stage *stage,
    392             struct prim_header *header,
    393             unsigned clipmask)
    394 {
    395    struct clip_stage *clipper = clip_stage( stage );
    396    struct vertex_header *a[MAX_CLIPPED_VERTICES];
    397    struct vertex_header *b[MAX_CLIPPED_VERTICES];
    398    struct vertex_header **inlist = a;
    399    struct vertex_header **outlist = b;
    400    struct vertex_header *prov_vertex;
    401    unsigned tmpnr = 0;
    402    unsigned n = 3;
    403    unsigned i;
    404    boolean aEdges[MAX_CLIPPED_VERTICES];
    405    boolean bEdges[MAX_CLIPPED_VERTICES];
    406    boolean *inEdges = aEdges;
    407    boolean *outEdges = bEdges;
    408    int viewport_index = 0;
    409 
    410    inlist[0] = header->v[0];
    411    inlist[1] = header->v[1];
    412    inlist[2] = header->v[2];
    413 
    414    /*
    415     * For d3d10, we need to take this from the leading (first) vertex.
    416     * For GL, we could do anything (as long as we advertize
    417     * GL_UNDEFINED_VERTEX for the VIEWPORT_INDEX_PROVOKING_VERTEX query),
    418     * but it needs to be consistent with what other parts (i.e. driver)
    419     * will do, and that seems easier with GL_PROVOKING_VERTEX logic.
    420     */
    421    if (stage->draw->rasterizer->flatshade_first) {
    422       prov_vertex = inlist[0];
    423    }
    424    else {
    425       prov_vertex = inlist[2];
    426    }
    427    viewport_index = draw_viewport_index(clipper->stage.draw, prov_vertex);
    428 
    429    if (DEBUG_CLIP) {
    430       const float *v0 = header->v[0]->clip_pos;
    431       const float *v1 = header->v[1]->clip_pos;
    432       const float *v2 = header->v[2]->clip_pos;
    433       debug_printf("Clip triangle pos:\n");
    434       debug_printf(" %f, %f, %f, %f\n", v0[0], v0[1], v0[2], v0[3]);
    435       debug_printf(" %f, %f, %f, %f\n", v1[0], v1[1], v1[2], v1[3]);
    436       debug_printf(" %f, %f, %f, %f\n", v2[0], v2[1], v2[2], v2[3]);
    437       if (clipper->cv_attr >= 0) {
    438          const float *v0 = header->v[0]->data[clipper->cv_attr];
    439          const float *v1 = header->v[1]->data[clipper->cv_attr];
    440          const float *v2 = header->v[2]->data[clipper->cv_attr];
    441          debug_printf("Clip triangle cv:\n");
    442          debug_printf(" %f, %f, %f, %f\n", v0[0], v0[1], v0[2], v0[3]);
    443          debug_printf(" %f, %f, %f, %f\n", v1[0], v1[1], v1[2], v1[3]);
    444          debug_printf(" %f, %f, %f, %f\n", v2[0], v2[1], v2[2], v2[3]);
    445       }
    446    }
    447 
    448    /*
    449     * Note: at this point we can't just use the per-vertex edge flags.
    450     * We have to observe the edge flag bits set in header->flags which
    451     * were set during primitive decomposition.  Put those flags into
    452     * an edge flags array which parallels the vertex array.
    453     * Later, in the 'unfilled' pipeline stage we'll draw the edge if both
    454     * the header.flags bit is set AND the per-vertex edgeflag field is set.
    455     */
    456    inEdges[0] = !!(header->flags & DRAW_PIPE_EDGE_FLAG_0);
    457    inEdges[1] = !!(header->flags & DRAW_PIPE_EDGE_FLAG_1);
    458    inEdges[2] = !!(header->flags & DRAW_PIPE_EDGE_FLAG_2);
    459 
    460    while (clipmask && n >= 3) {
    461       const unsigned plane_idx = ffs(clipmask)-1;
    462       const boolean is_user_clip_plane = plane_idx >= 6;
    463       struct vertex_header *vert_prev = inlist[0];
    464       boolean *edge_prev = &inEdges[0];
    465       float dp_prev;
    466       unsigned outcount = 0;
    467 
    468       dp_prev = getclipdist(clipper, vert_prev, plane_idx);
    469       clipmask &= ~(1<<plane_idx);
    470 
    471       if (util_is_inf_or_nan(dp_prev))
    472          return; //discard nan
    473 
    474       assert(n < MAX_CLIPPED_VERTICES);
    475       if (n >= MAX_CLIPPED_VERTICES)
    476          return;
    477       inlist[n] = inlist[0]; /* prevent rotation of vertices */
    478       inEdges[n] = inEdges[0];
    479 
    480       for (i = 1; i <= n; i++) {
    481          struct vertex_header *vert = inlist[i];
    482          boolean *edge = &inEdges[i];
    483 
    484          float dp = getclipdist(clipper, vert, plane_idx);
    485 
    486          if (util_is_inf_or_nan(dp))
    487             return; //discard nan
    488 
    489          if (dp_prev >= 0.0f) {
    490             assert(outcount < MAX_CLIPPED_VERTICES);
    491             if (outcount >= MAX_CLIPPED_VERTICES)
    492                return;
    493             outEdges[outcount] = *edge_prev;
    494             outlist[outcount++] = vert_prev;
    495          }
    496 
    497          if (DIFFERENT_SIGNS(dp, dp_prev)) {
    498             struct vertex_header *new_vert;
    499             boolean *new_edge;
    500 
    501             assert(tmpnr < MAX_CLIPPED_VERTICES + 1);
    502             if (tmpnr >= MAX_CLIPPED_VERTICES + 1)
    503                return;
    504             new_vert = clipper->stage.tmp[tmpnr++];
    505 
    506             assert(outcount < MAX_CLIPPED_VERTICES);
    507             if (outcount >= MAX_CLIPPED_VERTICES)
    508                return;
    509 
    510             new_edge = &outEdges[outcount];
    511             outlist[outcount++] = new_vert;
    512 
    513             if (dp < 0.0f) {
    514                /* Going out of bounds.  Avoid division by zero as we
    515                 * know dp != dp_prev from DIFFERENT_SIGNS, above.
    516                 */
    517                float t = dp / (dp - dp_prev);
    518                interp( clipper, new_vert, t, vert, vert_prev, viewport_index );
    519 
    520                /* Whether or not to set edge flag for the new vert depends
    521                 * on whether it's a user-defined clipping plane.  We're
    522                 * copying NVIDIA's behaviour here.
    523                 */
    524                if (is_user_clip_plane) {
    525                   /* we want to see an edge along the clip plane */
    526                   *new_edge = TRUE;
    527                   new_vert->edgeflag = TRUE;
    528                }
    529                else {
    530                   /* we don't want to see an edge along the frustum clip plane */
    531                   *new_edge = *edge_prev;
    532                   new_vert->edgeflag = FALSE;
    533                }
    534             }
    535             else {
    536                /* Coming back in.
    537                 */
    538                float t = dp_prev / (dp_prev - dp);
    539                interp( clipper, new_vert, t, vert_prev, vert, viewport_index );
    540 
    541                /* Copy starting vert's edgeflag:
    542                 */
    543                new_vert->edgeflag = vert_prev->edgeflag;
    544                *new_edge = *edge_prev;
    545             }
    546          }
    547 
    548          vert_prev = vert;
    549          edge_prev = edge;
    550          dp_prev = dp;
    551       }
    552 
    553       /* swap in/out lists */
    554       {
    555          struct vertex_header **tmp = inlist;
    556          inlist = outlist;
    557          outlist = tmp;
    558          n = outcount;
    559       }
    560       {
    561          boolean *tmp = inEdges;
    562          inEdges = outEdges;
    563          outEdges = tmp;
    564       }
    565 
    566    }
    567 
    568    /* If constant interpolated, copy provoking vertex attrib to polygon vertex[0]
    569     */
    570    if (n >= 3) {
    571       if (clipper->num_const_attribs) {
    572          if (stage->draw->rasterizer->flatshade_first) {
    573             if (inlist[0] != header->v[0]) {
    574                assert(tmpnr < MAX_CLIPPED_VERTICES + 1);
    575                if (tmpnr >= MAX_CLIPPED_VERTICES + 1)
    576                   return;
    577                inlist[0] = dup_vert(stage, inlist[0], tmpnr++);
    578                copy_flat(stage, inlist[0], header->v[0]);
    579             }
    580          }
    581          else {
    582             if (inlist[0] != header->v[2]) {
    583                assert(tmpnr < MAX_CLIPPED_VERTICES + 1);
    584                if (tmpnr >= MAX_CLIPPED_VERTICES + 1)
    585                   return;
    586                inlist[0] = dup_vert(stage, inlist[0], tmpnr++);
    587                copy_flat(stage, inlist[0], header->v[2]);
    588             }
    589          }
    590       }
    591 
    592       /* Emit the polygon as triangles to the setup stage:
    593        */
    594       emit_poly(stage, inlist, inEdges, n, header);
    595    }
    596 }
    597 
    598 
    599 /* Clip a line against the viewport and user clip planes.
    600  */
    601 static void
    602 do_clip_line(struct draw_stage *stage,
    603              struct prim_header *header,
    604              unsigned clipmask)
    605 {
    606    const struct clip_stage *clipper = clip_stage(stage);
    607    struct vertex_header *v0 = header->v[0];
    608    struct vertex_header *v1 = header->v[1];
    609    struct vertex_header *prov_vertex;
    610    float t0 = 0.0F;
    611    float t1 = 0.0F;
    612    struct prim_header newprim;
    613    int viewport_index;
    614 
    615    newprim.flags = header->flags;
    616 
    617    if (stage->draw->rasterizer->flatshade_first) {
    618       prov_vertex = v0;
    619    }
    620    else {
    621       prov_vertex = v1;
    622    }
    623    viewport_index = draw_viewport_index(clipper->stage.draw, prov_vertex);
    624 
    625    while (clipmask) {
    626       const unsigned plane_idx = ffs(clipmask)-1;
    627       const float dp0 = getclipdist(clipper, v0, plane_idx);
    628       const float dp1 = getclipdist(clipper, v1, plane_idx);
    629 
    630       if (util_is_inf_or_nan(dp0) || util_is_inf_or_nan(dp1))
    631          return; //discard nan
    632 
    633       if (dp1 < 0.0F) {
    634          float t = dp1 / (dp1 - dp0);
    635          t1 = MAX2(t1, t);
    636       }
    637 
    638       if (dp0 < 0.0F) {
    639          float t = dp0 / (dp0 - dp1);
    640          t0 = MAX2(t0, t);
    641       }
    642 
    643       if (t0 + t1 >= 1.0F)
    644          return; /* discard */
    645 
    646       clipmask &= ~(1 << plane_idx);  /* turn off this plane's bit */
    647    }
    648 
    649    if (v0->clipmask) {
    650       interp( clipper, stage->tmp[0], t0, v0, v1, viewport_index );
    651       if (stage->draw->rasterizer->flatshade_first) {
    652          copy_flat(stage, stage->tmp[0], v0);  /* copy v0 color to tmp[0] */
    653       }
    654       else {
    655          copy_flat(stage, stage->tmp[0], v1);  /* copy v1 color to tmp[0] */
    656       }
    657       newprim.v[0] = stage->tmp[0];
    658    }
    659    else {
    660       newprim.v[0] = v0;
    661    }
    662 
    663    if (v1->clipmask) {
    664       interp( clipper, stage->tmp[1], t1, v1, v0, viewport_index );
    665       if (stage->draw->rasterizer->flatshade_first) {
    666          copy_flat(stage, stage->tmp[1], v0);  /* copy v0 color to tmp[1] */
    667       }
    668       else {
    669          copy_flat(stage, stage->tmp[1], v1);  /* copy v1 color to tmp[1] */
    670       }
    671       newprim.v[1] = stage->tmp[1];
    672    }
    673    else {
    674       newprim.v[1] = v1;
    675    }
    676 
    677    stage->next->line( stage->next, &newprim );
    678 }
    679 
    680 
    681 static void
    682 clip_point(struct draw_stage *stage, struct prim_header *header)
    683 {
    684    if (header->v[0]->clipmask == 0)
    685       stage->next->point( stage->next, header );
    686 }
    687 
    688 
    689 /*
    690  * Clip points but ignore the first 4 (xy) clip planes.
    691  * (Because the generated clip mask is completely unaffacted by guard band,
    692  * we still need to manually evaluate the x/y planes if they are outside
    693  * the guard band and not just outside the vp.)
    694  */
    695 static void
    696 clip_point_guard_xy(struct draw_stage *stage, struct prim_header *header)
    697 {
    698    unsigned clipmask = header->v[0]->clipmask;
    699    if ((clipmask & 0xffffffff) == 0)
    700       stage->next->point(stage->next, header);
    701    else if ((clipmask & 0xfffffff0) == 0) {
    702       while (clipmask) {
    703          const unsigned plane_idx = ffs(clipmask)-1;
    704          clipmask &= ~(1 << plane_idx);  /* turn off this plane's bit */
    705          /* TODO: this should really do proper guardband clipping,
    706           * currently just throw out infs/nans.
    707           * Also note that vertices with negative w values MUST be tossed
    708           * out (not sure if proper guardband clipping would do this
    709           * automatically). These would usually be captured by depth clip
    710           * too but this can be disabled.
    711           */
    712          if (header->v[0]->clip_pos[3] <= 0.0f ||
    713              util_is_inf_or_nan(header->v[0]->clip_pos[0]) ||
    714              util_is_inf_or_nan(header->v[0]->clip_pos[1]))
    715             return;
    716       }
    717       stage->next->point(stage->next, header);
    718    }
    719 }
    720 
    721 
    722 static void
    723 clip_first_point(struct draw_stage *stage, struct prim_header *header)
    724 {
    725    stage->point = stage->draw->guard_band_points_xy ? clip_point_guard_xy : clip_point;
    726    stage->point(stage, header);
    727 }
    728 
    729 
    730 static void
    731 clip_line(struct draw_stage *stage, struct prim_header *header)
    732 {
    733    unsigned clipmask = (header->v[0]->clipmask |
    734                         header->v[1]->clipmask);
    735 
    736    if (clipmask == 0) {
    737       /* no clipping needed */
    738       stage->next->line( stage->next, header );
    739    }
    740    else if ((header->v[0]->clipmask &
    741              header->v[1]->clipmask) == 0) {
    742       do_clip_line(stage, header, clipmask);
    743    }
    744    /* else, totally clipped */
    745 }
    746 
    747 
    748 static void
    749 clip_tri(struct draw_stage *stage, struct prim_header *header)
    750 {
    751    unsigned clipmask = (header->v[0]->clipmask |
    752                         header->v[1]->clipmask |
    753                         header->v[2]->clipmask);
    754 
    755    if (clipmask == 0) {
    756       /* no clipping needed */
    757       stage->next->tri( stage->next, header );
    758    }
    759    else if ((header->v[0]->clipmask &
    760              header->v[1]->clipmask &
    761              header->v[2]->clipmask) == 0) {
    762       do_clip_tri(stage, header, clipmask);
    763    }
    764 }
    765 
    766 
    767 static int
    768 find_interp(const struct draw_fragment_shader *fs, int *indexed_interp,
    769             uint semantic_name, uint semantic_index)
    770 {
    771    int interp;
    772    /* If it's gl_{Front,Back}{,Secondary}Color, pick up the mode
    773     * from the array we've filled before. */
    774    if ((semantic_name == TGSI_SEMANTIC_COLOR ||
    775         semantic_name == TGSI_SEMANTIC_BCOLOR) &&
    776        semantic_index < 2) {
    777       interp = indexed_interp[semantic_index];
    778    } else if (semantic_name == TGSI_SEMANTIC_POSITION ||
    779               semantic_name == TGSI_SEMANTIC_CLIPVERTEX) {
    780       /* these inputs are handled specially always */
    781       return -1;
    782    } else {
    783       /* Otherwise, search in the FS inputs, with a decent default
    784        * if we don't find it.
    785        * This probably only matters for layer, vpindex, culldist, maybe
    786        * front_face.
    787        */
    788       uint j;
    789       if (semantic_name == TGSI_SEMANTIC_LAYER ||
    790           semantic_name == TGSI_SEMANTIC_VIEWPORT_INDEX) {
    791          interp = TGSI_INTERPOLATE_CONSTANT;
    792       }
    793       else {
    794          interp = TGSI_INTERPOLATE_PERSPECTIVE;
    795       }
    796       if (fs) {
    797          for (j = 0; j < fs->info.num_inputs; j++) {
    798             if (semantic_name == fs->info.input_semantic_name[j] &&
    799                 semantic_index == fs->info.input_semantic_index[j]) {
    800                interp = fs->info.input_interpolate[j];
    801                break;
    802             }
    803          }
    804       }
    805    }
    806    return interp;
    807 }
    808 
    809 /* Update state.  Could further delay this until we hit the first
    810  * primitive that really requires clipping.
    811  */
    812 static void
    813 clip_init_state(struct draw_stage *stage)
    814 {
    815    struct clip_stage *clipper = clip_stage(stage);
    816    const struct draw_context *draw = stage->draw;
    817    const struct draw_fragment_shader *fs = draw->fs.fragment_shader;
    818    const struct tgsi_shader_info *info = draw_get_shader_info(draw);
    819    uint i, j;
    820    int indexed_interp[2];
    821 
    822    clipper->pos_attr = draw_current_shader_position_output(draw);
    823    clipper->have_clipdist = draw_current_shader_num_written_clipdistances(draw) > 0;
    824    if (draw_current_shader_clipvertex_output(draw) != clipper->pos_attr) {
    825       clipper->cv_attr = (int)draw_current_shader_clipvertex_output(draw);
    826    }
    827    else {
    828       clipper->cv_attr = -1;
    829    }
    830 
    831    /* We need to know for each attribute what kind of interpolation is
    832     * done on it (flat, smooth or noperspective).  But the information
    833     * is not directly accessible for outputs, only for inputs.  So we
    834     * have to match semantic name and index between the VS (or GS/ES)
    835     * outputs and the FS inputs to get to the interpolation mode.
    836     *
    837     * The only hitch is with gl_FrontColor/gl_BackColor which map to
    838     * gl_Color, and their Secondary versions.  First there are (up to)
    839     * two outputs for one input, so we tuck the information in a
    840     * specific array.  Second if they don't have qualifiers, the
    841     * default value has to be picked from the global shade mode.
    842     *
    843     * Of course, if we don't have a fragment shader in the first
    844     * place, defaults should be used.
    845     */
    846 
    847    /* First pick up the interpolation mode for
    848     * gl_Color/gl_SecondaryColor, with the correct default.
    849     */
    850    indexed_interp[0] = indexed_interp[1] = draw->rasterizer->flatshade ?
    851       TGSI_INTERPOLATE_CONSTANT : TGSI_INTERPOLATE_PERSPECTIVE;
    852 
    853    if (fs) {
    854       for (i = 0; i < fs->info.num_inputs; i++) {
    855          if (fs->info.input_semantic_name[i] == TGSI_SEMANTIC_COLOR &&
    856              fs->info.input_semantic_index[i] < 2) {
    857             if (fs->info.input_interpolate[i] != TGSI_INTERPOLATE_COLOR)
    858                indexed_interp[fs->info.input_semantic_index[i]] = fs->info.input_interpolate[i];
    859          }
    860       }
    861    }
    862 
    863    /* Then resolve the interpolation mode for every output attribute. */
    864 
    865    clipper->num_const_attribs = 0;
    866    clipper->num_linear_attribs = 0;
    867    clipper->num_perspect_attribs = 0;
    868    for (i = 0; i < info->num_outputs; i++) {
    869       /* Find the interpolation mode for a specific attribute */
    870       int interp = find_interp(fs, indexed_interp,
    871                                info->output_semantic_name[i],
    872                                info->output_semantic_index[i]);
    873       switch (interp) {
    874       case TGSI_INTERPOLATE_CONSTANT:
    875          clipper->const_attribs[clipper->num_const_attribs] = i;
    876          clipper->num_const_attribs++;
    877          break;
    878       case TGSI_INTERPOLATE_LINEAR:
    879          clipper->linear_attribs[clipper->num_linear_attribs] = i;
    880          clipper->num_linear_attribs++;
    881          break;
    882       case TGSI_INTERPOLATE_PERSPECTIVE:
    883          clipper->perspect_attribs[clipper->num_perspect_attribs] = i;
    884          clipper->num_perspect_attribs++;
    885          break;
    886       case TGSI_INTERPOLATE_COLOR:
    887          if (draw->rasterizer->flatshade) {
    888             clipper->const_attribs[clipper->num_const_attribs] = i;
    889             clipper->num_const_attribs++;
    890          } else {
    891             clipper->perspect_attribs[clipper->num_perspect_attribs] = i;
    892             clipper->num_perspect_attribs++;
    893          }
    894          break;
    895       default:
    896          assert(interp == -1);
    897          break;
    898       }
    899    }
    900    /* Search the extra vertex attributes */
    901    for (j = 0; j < draw->extra_shader_outputs.num; j++) {
    902       /* Find the interpolation mode for a specific attribute */
    903       int interp = find_interp(fs, indexed_interp,
    904                                draw->extra_shader_outputs.semantic_name[j],
    905                                draw->extra_shader_outputs.semantic_index[j]);
    906       switch (interp) {
    907       case TGSI_INTERPOLATE_CONSTANT:
    908          clipper->const_attribs[clipper->num_const_attribs] = i + j;
    909          clipper->num_const_attribs++;
    910          break;
    911       case TGSI_INTERPOLATE_LINEAR:
    912          clipper->linear_attribs[clipper->num_linear_attribs] = i + j;
    913          clipper->num_linear_attribs++;
    914          break;
    915       case TGSI_INTERPOLATE_PERSPECTIVE:
    916          clipper->perspect_attribs[clipper->num_perspect_attribs] = i + j;
    917          clipper->num_perspect_attribs++;
    918          break;
    919       default:
    920          assert(interp == -1);
    921          break;
    922       }
    923    }
    924 
    925    stage->tri = clip_tri;
    926    stage->line = clip_line;
    927 }
    928 
    929 
    930 
    931 static void clip_first_tri(struct draw_stage *stage,
    932                            struct prim_header *header)
    933 {
    934    clip_init_state( stage );
    935    stage->tri( stage, header );
    936 }
    937 
    938 static void clip_first_line(struct draw_stage *stage,
    939                             struct prim_header *header)
    940 {
    941    clip_init_state( stage );
    942    stage->line( stage, header );
    943 }
    944 
    945 
    946 static void clip_flush(struct draw_stage *stage, unsigned flags)
    947 {
    948    stage->tri = clip_first_tri;
    949    stage->line = clip_first_line;
    950    stage->next->flush( stage->next, flags );
    951 }
    952 
    953 
    954 static void clip_reset_stipple_counter(struct draw_stage *stage)
    955 {
    956    stage->next->reset_stipple_counter( stage->next );
    957 }
    958 
    959 
    960 static void clip_destroy(struct draw_stage *stage)
    961 {
    962    draw_free_temp_verts( stage );
    963    FREE( stage );
    964 }
    965 
    966 
    967 /**
    968  * Allocate a new clipper stage.
    969  * \return pointer to new stage object
    970  */
    971 struct draw_stage *draw_clip_stage(struct draw_context *draw)
    972 {
    973    struct clip_stage *clipper = CALLOC_STRUCT(clip_stage);
    974    if (!clipper)
    975       goto fail;
    976 
    977    clipper->stage.draw = draw;
    978    clipper->stage.name = "clipper";
    979    clipper->stage.point = clip_first_point;
    980    clipper->stage.line = clip_first_line;
    981    clipper->stage.tri = clip_first_tri;
    982    clipper->stage.flush = clip_flush;
    983    clipper->stage.reset_stipple_counter = clip_reset_stipple_counter;
    984    clipper->stage.destroy = clip_destroy;
    985 
    986    clipper->plane = draw->plane;
    987 
    988    if (!draw_alloc_temp_verts( &clipper->stage, MAX_CLIPPED_VERTICES+1 ))
    989       goto fail;
    990 
    991    return &clipper->stage;
    992 
    993  fail:
    994    if (clipper)
    995       clipper->stage.destroy( &clipper->stage );
    996 
    997    return NULL;
    998 }
    999