src/mesa/swrast/s_tritemp.h

   1 /*
   2  * Mesa 3-D graphics library
   3  * Version:  7.0
   4  *
   5  * Copyright (C) 1999-2007  Brian Paul   All Rights Reserved.
   6  *
   7  * Permission is hereby granted, free of charge, to any person obtaining a
   8  * copy of this software and associated documentation files (the "Software"),
   9  * to deal in the Software without restriction, including without limitation
  10  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
  11  * and/or sell copies of the Software, and to permit persons to whom the
  12  * Software is furnished to do so, subject to the following conditions:
  13  *
  14  * The above copyright notice and this permission notice shall be included
  15  * in all copies or substantial portions of the Software.
  16  *
  17  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  18  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  19  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
  20  * BRIAN PAUL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
  21  * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
  22  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  23  */
  24
  25 /*
  26  * Triangle Rasterizer Template
  27  *
  28  * This file is #include'd to generate custom triangle rasterizers.
  29  *
  30  * The following macros may be defined to indicate what auxillary information
  31  * must be interpolated across the triangle:
  32  *    INTERP_Z        - if defined, interpolate integer Z values
  33  *    INTERP_RGB      - if defined, interpolate integer RGB values
  34  *    INTERP_ALPHA    - if defined, interpolate integer Alpha values
  35  *    INTERP_INT_TEX  - if defined, interpolate integer ST texcoords
  36  *                         (fast, simple 2-D texture mapping, without
  37  *                         perspective correction)
  38  *    INTERP_ATTRIBS  - if defined, interpolate arbitrary attribs (texcoords,
  39  *                         varying vars, etc)  This also causes W to be
  40  *                         computed for perspective correction).
  41  *
  42  * When one can directly address pixels in the color buffer the following
  43  * macros can be defined and used to compute pixel addresses during
  44  * rasterization (see pRow):
  45  *    PIXEL_TYPE          - the datatype of a pixel (GLubyte, GLushort, GLuint)
  46  *    BYTES_PER_ROW       - number of bytes per row in the color buffer
  47  *    PIXEL_ADDRESS(X,Y)  - returns the address of pixel at (X,Y) where
  48  *                          Y==0 at bottom of screen and increases upward.
  49  *
  50  * Similarly, for direct depth buffer access, this type is used for depth
  51  * buffer addressing (see zRow):
  52  *    DEPTH_TYPE          - either GLushort or GLuint
  53  *
  54  * Optionally, one may provide one-time setup code per triangle:
  55  *    SETUP_CODE    - code which is to be executed once per triangle
  56  *
  57  * The following macro MUST be defined:
  58  *    RENDER_SPAN(span) - code to write a span of pixels.
  59  *
  60  * This code was designed for the origin to be in the lower-left corner.
  61  *
  62  * Inspired by triangle rasterizer code written by Allen Akin.  Thanks Allen!
  63  *
  64  *
  65  * Some notes on rasterization accuracy:
  66  *
  67  * This code uses fixed point arithmetic (the GLfixed type) to iterate
  68  * over the triangle edges and interpolate ancillary data (such as Z,
  69  * color, secondary color, etc).  The number of fractional bits in
  70  * GLfixed and the value of SUB_PIXEL_BITS has a direct bearing on the
  71  * accuracy of rasterization.
  72  *
  73  * If SUB_PIXEL_BITS=4 then we'll snap the vertices to the nearest
  74  * 1/16 of a pixel.  If we're walking up a long, nearly vertical edge
  75  * (dx=1/16, dy=1024) we'll need 4 + 10 = 14 fractional bits in
  76  * GLfixed to walk the edge without error.  If the maximum viewport
  77  * height is 4K pixels, then we'll need 4 + 12 = 16 fractional bits.
  78  *
  79  * Historically, Mesa has used 11 fractional bits in GLfixed, snaps
  80  * vertices to 1/16 pixel and allowed a maximum viewport height of 2K
  81  * pixels.  11 fractional bits is actually insufficient for accurately
  82  * rasterizing some triangles.  More recently, the maximum viewport
  83  * height was increased to 4K pixels.  Thus, Mesa should be using 16
  84  * fractional bits in GLfixed.  Unfortunately, there may be some issues
  85  * with setting FIXED_FRAC_BITS=16, such as multiplication overflow.
  86  * This will have to be examined in some detail...
  87  *
  88  * For now, if you find rasterization errors, particularly with tall,
  89  * sliver triangles, try increasing FIXED_FRAC_BITS and/or decreasing
  90  * SUB_PIXEL_BITS.
  91  */
  92
  93
  94 /*
  95  * Some code we unfortunately need to prevent negative interpolated colors.
  96  */
  97 #ifndef CLAMP_INTERPOLANT
  98 #define CLAMP_INTERPOLANT(CHANNEL, CHANNELSTEP, LEN)            \
  99 do {                                                            \
 100    GLfixed endVal = span.CHANNEL + (LEN) * span.CHANNELSTEP;    \
 101    if (endVal < 0) {                                            \
 102       span.CHANNEL -= endVal;                                   \
 103    }                                                            \
 104    if (span.CHANNEL < 0) {                                      \
 105       span.CHANNEL = 0;                                         \
 106    }                                                            \
 107 } while (0)
 108 #endif
 109
 110
 111 static void NAME(struct gl_context *ctx, const SWvertex *v0,
 112                                  const SWvertex *v1,
 113                                  const SWvertex *v2 )
 114 {
 115    typedef struct {
 116       const SWvertex *v0, *v1;   /* Y(v0) < Y(v1) */
 117       GLfloat dx;       /* X(v1) - X(v0) */
 118       GLfloat dy;       /* Y(v1) - Y(v0) */
 119       GLfloat dxdy;     /* dx/dy */
 120       GLfixed fdxdy;    /* dx/dy in fixed-point */
 121       GLfloat adjy;     /* adjust from v[0]->fy to fsy, scaled */
 122       GLfixed fsx;      /* first sample point x coord */
 123       GLfixed fsy;
 124       GLfixed fx0;      /* fixed pt X of lower endpoint */
 125       GLint lines;      /* number of lines to be sampled on this edge */
 126    } EdgeT;
 127
 128    const SWcontext *swrast = SWRAST_CONTEXT(ctx);
 129 #ifdef INTERP_Z
 130    const GLint depthBits = ctx->DrawBuffer->Visual.depthBits;
 131    const GLint fixedToDepthShift = depthBits <= 16 ? FIXED_SHIFT : 0;
 132    const GLfloat maxDepth = ctx->DrawBuffer->_DepthMaxF;
 133 #define FixedToDepth(F)  ((F) >> fixedToDepthShift)
 134 #endif
 135    EdgeT eMaj, eTop, eBot;
 136    GLfloat oneOverArea;
 137    const SWvertex *vMin, *vMid, *vMax;  /* Y(vMin)<=Y(vMid)<=Y(vMax) */
 138    GLfloat bf = SWRAST_CONTEXT(ctx)->_BackfaceSign;
 139    const GLint snapMask = ~((FIXED_ONE / (1 << SUB_PIXEL_BITS)) - 1); /* for x/y coord snapping */
 140    GLfixed vMin_fx, vMin_fy, vMid_fx, vMid_fy, vMax_fx, vMax_fy;
 141
 142    SWspan span;
 143
 144    (void) swrast;
 145
 146    INIT_SPAN(span, GL_POLYGON);
 147    span.y = 0; /* silence warnings */
 148
 149 #ifdef INTERP_Z
 150    (void) fixedToDepthShift;
 151 #endif
 152
 153    /*
 154    printf("%s()\n", __FUNCTION__);
 155    printf("  %g, %g, %g\n",
 156           v0->attrib[FRAG_ATTRIB_WPOS][0],
 157           v0->attrib[FRAG_ATTRIB_WPOS][1],
 158           v0->attrib[FRAG_ATTRIB_WPOS][2]);
 159    printf("  %g, %g, %g\n",
 160           v1->attrib[FRAG_ATTRIB_WPOS][0],
 161           v1->attrib[FRAG_ATTRIB_WPOS][1],
 162           v1->attrib[FRAG_ATTRIB_WPOS][2]);
 163    printf("  %g, %g, %g\n",
 164           v2->attrib[FRAG_ATTRIB_WPOS][0],
 165           v2->attrib[FRAG_ATTRIB_WPOS][1],
 166           v2->attrib[FRAG_ATTRIB_WPOS][2]);
 167    */
 168
 169    /* Compute fixed point x,y coords w/ half-pixel offsets and snapping.
 170     * And find the order of the 3 vertices along the Y axis.
 171     */
 172    {
 173       const GLfixed fy0 = FloatToFixed(v0->attrib[FRAG_ATTRIB_WPOS][1] - 0.5F) & snapMask;
 174       const GLfixed fy1 = FloatToFixed(v1->attrib[FRAG_ATTRIB_WPOS][1] - 0.5F) & snapMask;
 175       const GLfixed fy2 = FloatToFixed(v2->attrib[FRAG_ATTRIB_WPOS][1] - 0.5F) & snapMask;
 176       if (fy0 <= fy1) {
 177          if (fy1 <= fy2) {
 178             /* y0 <= y1 <= y2 */
 179             vMin = v0;   vMid = v1;   vMax = v2;
 180             vMin_fy = fy0;  vMid_fy = fy1;  vMax_fy = fy2;
 181          }
 182          else if (fy2 <= fy0) {
 183             /* y2 <= y0 <= y1 */
 184             vMin = v2;   vMid = v0;   vMax = v1;
 185             vMin_fy = fy2;  vMid_fy = fy0;  vMax_fy = fy1;
 186          }
 187          else {
 188             /* y0 <= y2 <= y1 */
 189             vMin = v0;   vMid = v2;   vMax = v1;
 190             vMin_fy = fy0;  vMid_fy = fy2;  vMax_fy = fy1;
 191             bf = -bf;
 192          }
 193       }
 194       else {
 195          if (fy0 <= fy2) {
 196             /* y1 <= y0 <= y2 */
 197             vMin = v1;   vMid = v0;   vMax = v2;
 198             vMin_fy = fy1;  vMid_fy = fy0;  vMax_fy = fy2;
 199             bf = -bf;
 200          }
 201          else if (fy2 <= fy1) {
 202             /* y2 <= y1 <= y0 */
 203             vMin = v2;   vMid = v1;   vMax = v0;
 204             vMin_fy = fy2;  vMid_fy = fy1;  vMax_fy = fy0;
 205             bf = -bf;
 206          }
 207          else {
 208             /* y1 <= y2 <= y0 */
 209             vMin = v1;   vMid = v2;   vMax = v0;
 210             vMin_fy = fy1;  vMid_fy = fy2;  vMax_fy = fy0;
 211          }
 212       }
 213
 214       /* fixed point X coords */
 215       vMin_fx = FloatToFixed(vMin->attrib[FRAG_ATTRIB_WPOS][0] + 0.5F) & snapMask;
 216       vMid_fx = FloatToFixed(vMid->attrib[FRAG_ATTRIB_WPOS][0] + 0.5F) & snapMask;
 217       vMax_fx = FloatToFixed(vMax->attrib[FRAG_ATTRIB_WPOS][0] + 0.5F) & snapMask;
 218    }
 219
 220    /* vertex/edge relationship */
 221    eMaj.v0 = vMin;   eMaj.v1 = vMax;   /*TODO: .v1's not needed */
 222    eTop.v0 = vMid;   eTop.v1 = vMax;
 223    eBot.v0 = vMin;   eBot.v1 = vMid;
 224
 225    /* compute deltas for each edge:  vertex[upper] - vertex[lower] */
 226    eMaj.dx = FixedToFloat(vMax_fx - vMin_fx);
 227    eMaj.dy = FixedToFloat(vMax_fy - vMin_fy);
 228    eTop.dx = FixedToFloat(vMax_fx - vMid_fx);
 229    eTop.dy = FixedToFloat(vMax_fy - vMid_fy);
 230    eBot.dx = FixedToFloat(vMid_fx - vMin_fx);
 231    eBot.dy = FixedToFloat(vMid_fy - vMin_fy);
 232
 233    /* compute area, oneOverArea and perform backface culling */
 234    {
 235       const GLfloat area = eMaj.dx * eBot.dy - eBot.dx * eMaj.dy;
 236
 237       if (IS_INF_OR_NAN(area) || area == 0.0F)
 238          return;
 239
 240       if (area * bf * swrast->_BackfaceCullSign < 0.0)
 241          return;
 242
 243       oneOverArea = 1.0F / area;
 244
 245       /* 0 = front, 1 = back */
 246       span.facing = oneOverArea * bf > 0.0F;
 247    }
 248
 249    /* Edge setup.  For a triangle strip these could be reused... */
 250    {
 251       eMaj.fsy = FixedCeil(vMin_fy);
 252       eMaj.lines = FixedToInt(FixedCeil(vMax_fy - eMaj.fsy));
 253       if (eMaj.lines > 0) {
 254          eMaj.dxdy = eMaj.dx / eMaj.dy;
 255          eMaj.fdxdy = SignedFloatToFixed(eMaj.dxdy);
 256          eMaj.adjy = (GLfloat) (eMaj.fsy - vMin_fy);  /* SCALED! */
 257          eMaj.fx0 = vMin_fx;
 258          eMaj.fsx = eMaj.fx0 + (GLfixed) (eMaj.adjy * eMaj.dxdy);
 259       }
 260       else {
 261          return;  /*CULLED*/
 262       }
 263
 264       eTop.fsy = FixedCeil(vMid_fy);
 265       eTop.lines = FixedToInt(FixedCeil(vMax_fy - eTop.fsy));
 266       if (eTop.lines > 0) {
 267          eTop.dxdy = eTop.dx / eTop.dy;
 268          eTop.fdxdy = SignedFloatToFixed(eTop.dxdy);
 269          eTop.adjy = (GLfloat) (eTop.fsy - vMid_fy); /* SCALED! */
 270          eTop.fx0 = vMid_fx;
 271          eTop.fsx = eTop.fx0 + (GLfixed) (eTop.adjy * eTop.dxdy);
 272       }
 273
 274       eBot.fsy = FixedCeil(vMin_fy);
 275       eBot.lines = FixedToInt(FixedCeil(vMid_fy - eBot.fsy));
 276       if (eBot.lines > 0) {
 277          eBot.dxdy = eBot.dx / eBot.dy;
 278          eBot.fdxdy = SignedFloatToFixed(eBot.dxdy);
 279          eBot.adjy = (GLfloat) (eBot.fsy - vMin_fy);  /* SCALED! */
 280          eBot.fx0 = vMin_fx;
 281          eBot.fsx = eBot.fx0 + (GLfixed) (eBot.adjy * eBot.dxdy);
 282       }
 283    }
 284
 285    /*
 286     * Conceptually, we view a triangle as two subtriangles
 287     * separated by a perfectly horizontal line.  The edge that is
 288     * intersected by this line is one with maximal absolute dy; we
 289     * call it a ``major'' edge.  The other two edges are the
 290     * ``top'' edge (for the upper subtriangle) and the ``bottom''
 291     * edge (for the lower subtriangle).  If either of these two
 292     * edges is horizontal or very close to horizontal, the
 293     * corresponding subtriangle might cover zero sample points;
 294     * we take care to handle such cases, for performance as well
 295     * as correctness.
 296     *
 297     * By stepping rasterization parameters along the major edge,
 298     * we can avoid recomputing them at the discontinuity where
 299     * the top and bottom edges meet.  However, this forces us to
 300     * be able to scan both left-to-right and right-to-left.
 301     * Also, we must determine whether the major edge is at the
 302     * left or right side of the triangle.  We do this by
 303     * computing the magnitude of the cross-product of the major
 304     * and top edges.  Since this magnitude depends on the sine of
 305     * the angle between the two edges, its sign tells us whether
 306     * we turn to the left or to the right when travelling along
 307     * the major edge to the top edge, and from this we infer
 308     * whether the major edge is on the left or the right.
 309     *
 310     * Serendipitously, this cross-product magnitude is also a
 311     * value we need to compute the iteration parameter
 312     * derivatives for the triangle, and it can be used to perform
 313     * backface culling because its sign tells us whether the
 314     * triangle is clockwise or counterclockwise.  In this code we
 315     * refer to it as ``area'' because it's also proportional to
 316     * the pixel area of the triangle.
 317     */
 318
 319    {
 320       GLint scan_from_left_to_right;  /* true if scanning left-to-right */
 321
 322       /*
 323        * Execute user-supplied setup code
 324        */
 325 #ifdef SETUP_CODE
 326       SETUP_CODE
 327 #endif
 328
 329       scan_from_left_to_right = (oneOverArea < 0.0F);
 330
 331
 332       /* compute d?/dx and d?/dy derivatives */
 333 #ifdef INTERP_Z
 334       span.interpMask |= SPAN_Z;
 335       {
 336          GLfloat eMaj_dz = vMax->attrib[FRAG_ATTRIB_WPOS][2] - vMin->attrib[FRAG_ATTRIB_WPOS][2];
 337          GLfloat eBot_dz = vMid->attrib[FRAG_ATTRIB_WPOS][2] - vMin->attrib[FRAG_ATTRIB_WPOS][2];
 338          span.attrStepX[FRAG_ATTRIB_WPOS][2] = oneOverArea * (eMaj_dz * eBot.dy - eMaj.dy * eBot_dz);
 339          if (span.attrStepX[FRAG_ATTRIB_WPOS][2] > maxDepth ||
 340              span.attrStepX[FRAG_ATTRIB_WPOS][2] < -maxDepth) {
 341             /* probably a sliver triangle */
 342             span.attrStepX[FRAG_ATTRIB_WPOS][2] = 0.0;
 343             span.attrStepY[FRAG_ATTRIB_WPOS][2] = 0.0;
 344          }
 345          else {
 346             span.attrStepY[FRAG_ATTRIB_WPOS][2] = oneOverArea * (eMaj.dx * eBot_dz - eMaj_dz * eBot.dx);
 347          }
 348          if (depthBits <= 16)
 349             span.zStep = SignedFloatToFixed(span.attrStepX[FRAG_ATTRIB_WPOS][2]);
 350          else
 351             span.zStep = (GLint) span.attrStepX[FRAG_ATTRIB_WPOS][2];
 352       }
 353 #endif
 354 #ifdef INTERP_RGB
 355       span.interpMask |= SPAN_RGBA;
 356       if (ctx->Light.ShadeModel == GL_SMOOTH) {
 357          GLfloat eMaj_dr = (GLfloat) (vMax->color[RCOMP] - vMin->color[RCOMP]);
 358          GLfloat eBot_dr = (GLfloat) (vMid->color[RCOMP] - vMin->color[RCOMP]);
 359          GLfloat eMaj_dg = (GLfloat) (vMax->color[GCOMP] - vMin->color[GCOMP]);
 360          GLfloat eBot_dg = (GLfloat) (vMid->color[GCOMP] - vMin->color[GCOMP]);
 361          GLfloat eMaj_db = (GLfloat) (vMax->color[BCOMP] - vMin->color[BCOMP]);
 362          GLfloat eBot_db = (GLfloat) (vMid->color[BCOMP] - vMin->color[BCOMP]);
 363 #  ifdef INTERP_ALPHA
 364          GLfloat eMaj_da = (GLfloat) (vMax->color[ACOMP] - vMin->color[ACOMP]);
 365          GLfloat eBot_da = (GLfloat) (vMid->color[ACOMP] - vMin->color[ACOMP]);
 366 #  endif
 367          span.attrStepX[FRAG_ATTRIB_COL0][0] = oneOverArea * (eMaj_dr * eBot.dy - eMaj.dy * eBot_dr);
 368          span.attrStepY[FRAG_ATTRIB_COL0][0] = oneOverArea * (eMaj.dx * eBot_dr - eMaj_dr * eBot.dx);
 369          span.attrStepX[FRAG_ATTRIB_COL0][1] = oneOverArea * (eMaj_dg * eBot.dy - eMaj.dy * eBot_dg);
 370          span.attrStepY[FRAG_ATTRIB_COL0][1] = oneOverArea * (eMaj.dx * eBot_dg - eMaj_dg * eBot.dx);
 371          span.attrStepX[FRAG_ATTRIB_COL0][2] = oneOverArea * (eMaj_db * eBot.dy - eMaj.dy * eBot_db);
 372          span.attrStepY[FRAG_ATTRIB_COL0][2] = oneOverArea * (eMaj.dx * eBot_db - eMaj_db * eBot.dx);
 373          span.redStep   = SignedFloatToFixed(span.attrStepX[FRAG_ATTRIB_COL0][0]);
 374          span.greenStep = SignedFloatToFixed(span.attrStepX[FRAG_ATTRIB_COL0][1]);
 375          span.blueStep  = SignedFloatToFixed(span.attrStepX[FRAG_ATTRIB_COL0][2]);
 376 #  ifdef INTERP_ALPHA
 377          span.attrStepX[FRAG_ATTRIB_COL0][3] = oneOverArea * (eMaj_da * eBot.dy - eMaj.dy * eBot_da);
 378          span.attrStepY[FRAG_ATTRIB_COL0][3] = oneOverArea * (eMaj.dx * eBot_da - eMaj_da * eBot.dx);
 379          span.alphaStep = SignedFloatToFixed(span.attrStepX[FRAG_ATTRIB_COL0][3]);
 380 #  endif /* INTERP_ALPHA */
 381       }
 382       else {
 383          ASSERT(ctx->Light.ShadeModel == GL_FLAT);
 384          span.interpMask |= SPAN_FLAT;
 385          span.attrStepX[FRAG_ATTRIB_COL0][0] = span.attrStepY[FRAG_ATTRIB_COL0][0] = 0.0F;
 386          span.attrStepX[FRAG_ATTRIB_COL0][1] = span.attrStepY[FRAG_ATTRIB_COL0][1] = 0.0F;
 387          span.attrStepX[FRAG_ATTRIB_COL0][2] = span.attrStepY[FRAG_ATTRIB_COL0][2] = 0.0F;
 388          span.redStep   = 0;
 389          span.greenStep = 0;
 390          span.blueStep  = 0;
 391 #  ifdef INTERP_ALPHA
 392          span.attrStepX[FRAG_ATTRIB_COL0][3] = span.attrStepY[FRAG_ATTRIB_COL0][3] = 0.0F;
 393          span.alphaStep = 0;
 394 #  endif
 395       }
 396 #endif /* INTERP_RGB */
 397 #ifdef INTERP_INT_TEX
 398       {
 399          GLfloat eMaj_ds = (vMax->attrib[FRAG_ATTRIB_TEX0][0] - vMin->attrib[FRAG_ATTRIB_TEX0][0]) * S_SCALE;
 400          GLfloat eBot_ds = (vMid->attrib[FRAG_ATTRIB_TEX0][0] - vMin->attrib[FRAG_ATTRIB_TEX0][0]) * S_SCALE;
 401          GLfloat eMaj_dt = (vMax->attrib[FRAG_ATTRIB_TEX0][1] - vMin->attrib[FRAG_ATTRIB_TEX0][1]) * T_SCALE;
 402          GLfloat eBot_dt = (vMid->attrib[FRAG_ATTRIB_TEX0][1] - vMin->attrib[FRAG_ATTRIB_TEX0][1]) * T_SCALE;
 403          span.attrStepX[FRAG_ATTRIB_TEX0][0] = oneOverArea * (eMaj_ds * eBot.dy - eMaj.dy * eBot_ds);
 404          span.attrStepY[FRAG_ATTRIB_TEX0][0] = oneOverArea * (eMaj.dx * eBot_ds - eMaj_ds * eBot.dx);
 405          span.attrStepX[FRAG_ATTRIB_TEX0][1] = oneOverArea * (eMaj_dt * eBot.dy - eMaj.dy * eBot_dt);
 406          span.attrStepY[FRAG_ATTRIB_TEX0][1] = oneOverArea * (eMaj.dx * eBot_dt - eMaj_dt * eBot.dx);
 407          span.intTexStep[0] = SignedFloatToFixed(span.attrStepX[FRAG_ATTRIB_TEX0][0]);
 408          span.intTexStep[1] = SignedFloatToFixed(span.attrStepX[FRAG_ATTRIB_TEX0][1]);
 409       }
 410 #endif
 411 #ifdef INTERP_ATTRIBS
 412       {
 413          /* attrib[FRAG_ATTRIB_WPOS][3] is 1/W */
 414          const GLfloat wMax = vMax->attrib[FRAG_ATTRIB_WPOS][3];
 415          const GLfloat wMin = vMin->attrib[FRAG_ATTRIB_WPOS][3];
 416          const GLfloat wMid = vMid->attrib[FRAG_ATTRIB_WPOS][3];
 417          {
 418             const GLfloat eMaj_dw = wMax - wMin;
 419             const GLfloat eBot_dw = wMid - wMin;
 420             span.attrStepX[FRAG_ATTRIB_WPOS][3] = oneOverArea * (eMaj_dw * eBot.dy - eMaj.dy * eBot_dw);
 421             span.attrStepY[FRAG_ATTRIB_WPOS][3] = oneOverArea * (eMaj.dx * eBot_dw - eMaj_dw * eBot.dx);
 422          }
 423          ATTRIB_LOOP_BEGIN
 424             if (swrast->_InterpMode[attr] == GL_FLAT) {
 425                ASSIGN_4V(span.attrStepX[attr], 0.0, 0.0, 0.0, 0.0);
 426                ASSIGN_4V(span.attrStepY[attr], 0.0, 0.0, 0.0, 0.0);
 427             }
 428             else {
 429                GLuint c;
 430                for (c = 0; c < 4; c++) {
 431                   GLfloat eMaj_da = vMax->attrib[attr][c] * wMax - vMin->attrib[attr][c] * wMin;
 432                   GLfloat eBot_da = vMid->attrib[attr][c] * wMid - vMin->attrib[attr][c] * wMin;
 433                   span.attrStepX[attr][c] = oneOverArea * (eMaj_da * eBot.dy - eMaj.dy * eBot_da);
 434                   span.attrStepY[attr][c] = oneOverArea * (eMaj.dx * eBot_da - eMaj_da * eBot.dx);
 435                }
 436             }
 437          ATTRIB_LOOP_END
 438       }
 439 #endif
 440
 441       /*
 442        * We always sample at pixel centers.  However, we avoid
 443        * explicit half-pixel offsets in this code by incorporating
 444        * the proper offset in each of x and y during the
 445        * transformation to window coordinates.
 446        *
 447        * We also apply the usual rasterization rules to prevent
 448        * cracks and overlaps.  A pixel is considered inside a
 449        * subtriangle if it meets all of four conditions: it is on or
 450        * to the right of the left edge, strictly to the left of the
 451        * right edge, on or below the top edge, and strictly above
 452        * the bottom edge.  (Some edges may be degenerate.)
 453        *
 454        * The following discussion assumes left-to-right scanning
 455        * (that is, the major edge is on the left); the right-to-left
 456        * case is a straightforward variation.
 457        *
 458        * We start by finding the half-integral y coordinate that is
 459        * at or below the top of the triangle.  This gives us the
 460        * first scan line that could possibly contain pixels that are
 461        * inside the triangle.
 462        *
 463        * Next we creep down the major edge until we reach that y,
 464        * and compute the corresponding x coordinate on the edge.
 465        * Then we find the half-integral x that lies on or just
 466        * inside the edge.  This is the first pixel that might lie in
 467        * the interior of the triangle.  (We won't know for sure
 468        * until we check the other edges.)
 469        *
 470        * As we rasterize the triangle, we'll step down the major
 471        * edge.  For each step in y, we'll move an integer number
 472        * of steps in x.  There are two possible x step sizes, which
 473        * we'll call the ``inner'' step (guaranteed to land on the
 474        * edge or inside it) and the ``outer'' step (guaranteed to
 475        * land on the edge or outside it).  The inner and outer steps
 476        * differ by one.  During rasterization we maintain an error
 477        * term that indicates our distance from the true edge, and
 478        * select either the inner step or the outer step, whichever
 479        * gets us to the first pixel that falls inside the triangle.
 480        *
 481        * All parameters (z, red, etc.) as well as the buffer
 482        * addresses for color and z have inner and outer step values,
 483        * so that we can increment them appropriately.  This method
 484        * eliminates the need to adjust parameters by creeping a
 485        * sub-pixel amount into the triangle at each scanline.
 486        */
 487
 488       {
 489          GLint subTriangle;
 490          GLfixed fxLeftEdge = 0, fxRightEdge = 0;
 491          GLfixed fdxLeftEdge = 0, fdxRightEdge = 0;
 492          GLfixed fError = 0, fdError = 0;
 493 #ifdef PIXEL_ADDRESS
 494          PIXEL_TYPE *pRow = NULL;
 495          GLint dPRowOuter = 0, dPRowInner;  /* offset in bytes */
 496 #endif
 497 #ifdef INTERP_Z
 498 #  ifdef DEPTH_TYPE
 499          struct gl_renderbuffer *zrb
 500             = ctx->DrawBuffer->Attachment[BUFFER_DEPTH].Renderbuffer;
 501          DEPTH_TYPE *zRow = NULL;
 502          GLint dZRowOuter = 0, dZRowInner;  /* offset in bytes */
 503 #  endif
 504          GLuint zLeft = 0;
 505          GLfixed fdzOuter = 0, fdzInner;
 506 #endif
 507 #ifdef INTERP_RGB
 508          GLint rLeft = 0, fdrOuter = 0, fdrInner;
 509          GLint gLeft = 0, fdgOuter = 0, fdgInner;
 510          GLint bLeft = 0, fdbOuter = 0, fdbInner;
 511 #endif
 512 #ifdef INTERP_ALPHA
 513          GLint aLeft = 0, fdaOuter = 0, fdaInner;
 514 #endif
 515 #ifdef INTERP_INT_TEX
 516          GLfixed sLeft=0, dsOuter=0, dsInner;
 517          GLfixed tLeft=0, dtOuter=0, dtInner;
 518 #endif
 519 #ifdef INTERP_ATTRIBS
 520          GLfloat wLeft = 0, dwOuter = 0, dwInner;
 521          GLfloat attrLeft[FRAG_ATTRIB_MAX][4];
 522          GLfloat daOuter[FRAG_ATTRIB_MAX][4], daInner[FRAG_ATTRIB_MAX][4];
 523 #endif
 524
 525          for (subTriangle=0; subTriangle<=1; subTriangle++) {
 526             EdgeT *eLeft, *eRight;
 527             int setupLeft, setupRight;
 528             int lines;
 529
 530             if (subTriangle==0) {
 531                /* bottom half */
 532                if (scan_from_left_to_right) {
 533                   eLeft = &eMaj;
 534                   eRight = &eBot;
 535                   lines = eRight->lines;
 536                   setupLeft = 1;
 537                   setupRight = 1;
 538                }
 539                else {
 540                   eLeft = &eBot;
 541                   eRight = &eMaj;
 542                   lines = eLeft->lines;
 543                   setupLeft = 1;
 544                   setupRight = 1;
 545                }
 546             }
 547             else {
 548                /* top half */
 549                if (scan_from_left_to_right) {
 550                   eLeft = &eMaj;
 551                   eRight = &eTop;
 552                   lines = eRight->lines;
 553                   setupLeft = 0;
 554                   setupRight = 1;
 555                }
 556                else {
 557                   eLeft = &eTop;
 558                   eRight = &eMaj;
 559                   lines = eLeft->lines;
 560                   setupLeft = 1;
 561                   setupRight = 0;
 562                }
 563                if (lines == 0)
 564                   return;
 565             }
 566
 567             if (setupLeft && eLeft->lines > 0) {
 568                const SWvertex *vLower = eLeft->v0;
 569                const GLfixed fsy = eLeft->fsy;
 570                const GLfixed fsx = eLeft->fsx;  /* no fractional part */
 571                const GLfixed fx = FixedCeil(fsx);  /* no fractional part */
 572                const GLfixed adjx = (GLfixed) (fx - eLeft->fx0); /* SCALED! */
 573                const GLfixed adjy = (GLfixed) eLeft->adjy;      /* SCALED! */
 574                GLint idxOuter;
 575                GLfloat dxOuter;
 576                GLfixed fdxOuter;
 577
 578                fError = fx - fsx - FIXED_ONE;
 579                fxLeftEdge = fsx - FIXED_EPSILON;
 580                fdxLeftEdge = eLeft->fdxdy;
 581                fdxOuter = FixedFloor(fdxLeftEdge - FIXED_EPSILON);
 582                fdError = fdxOuter - fdxLeftEdge + FIXED_ONE;
 583                idxOuter = FixedToInt(fdxOuter);
 584                dxOuter = (GLfloat) idxOuter;
 585                span.y = FixedToInt(fsy);
 586
 587                /* silence warnings on some compilers */
 588                (void) dxOuter;
 589                (void) adjx;
 590                (void) adjy;
 591                (void) vLower;
 592
 593 #ifdef PIXEL_ADDRESS
 594                {
 595                   pRow = (PIXEL_TYPE *) PIXEL_ADDRESS(FixedToInt(fxLeftEdge), span.y);
 596                   dPRowOuter = -((int)BYTES_PER_ROW) + idxOuter * sizeof(PIXEL_TYPE);
 597                   /* negative because Y=0 at bottom and increases upward */
 598                }
 599 #endif
 600                /*
 601                 * Now we need the set of parameter (z, color, etc.) values at
 602                 * the point (fx, fsy).  This gives us properly-sampled parameter
 603                 * values that we can step from pixel to pixel.  Furthermore,
 604                 * although we might have intermediate results that overflow
 605                 * the normal parameter range when we step temporarily outside
 606                 * the triangle, we shouldn't overflow or underflow for any
 607                 * pixel that's actually inside the triangle.
 608                 */
 609
 610 #ifdef INTERP_Z
 611                {
 612                   GLfloat z0 = vLower->attrib[FRAG_ATTRIB_WPOS][2];
 613                   if (depthBits <= 16) {
 614                      /* interpolate fixed-pt values */
 615                      GLfloat tmp = (z0 * FIXED_SCALE
 616                                     + span.attrStepX[FRAG_ATTRIB_WPOS][2] * adjx
 617                                     + span.attrStepY[FRAG_ATTRIB_WPOS][2] * adjy) + FIXED_HALF;
 618                      if (tmp < MAX_GLUINT / 2)
 619                         zLeft = (GLfixed) tmp;
 620                      else
 621                         zLeft = MAX_GLUINT / 2;
 622                      fdzOuter = SignedFloatToFixed(span.attrStepY[FRAG_ATTRIB_WPOS][2] +
 623                                                    dxOuter * span.attrStepX[FRAG_ATTRIB_WPOS][2]);
 624                   }
 625                   else {
 626                      /* interpolate depth values w/out scaling */
 627                      zLeft = (GLuint) (z0 + span.attrStepX[FRAG_ATTRIB_WPOS][2] * FixedToFloat(adjx)
 628                                           + span.attrStepY[FRAG_ATTRIB_WPOS][2] * FixedToFloat(adjy));
 629                      fdzOuter = (GLint) (span.attrStepY[FRAG_ATTRIB_WPOS][2] +
 630                                          dxOuter * span.attrStepX[FRAG_ATTRIB_WPOS][2]);
 631                   }
 632 #  ifdef DEPTH_TYPE
 633                   zRow = (DEPTH_TYPE *)
 634                     zrb->GetPointer(ctx, zrb, FixedToInt(fxLeftEdge), span.y);
 635                   dZRowOuter = (ctx->DrawBuffer->Width + idxOuter) * sizeof(DEPTH_TYPE);
 636 #  endif
 637                }
 638 #endif
 639 #ifdef INTERP_RGB
 640                if (ctx->Light.ShadeModel == GL_SMOOTH) {
 641                   rLeft = (GLint)(ChanToFixed(vLower->color[RCOMP])
 642                                   + span.attrStepX[FRAG_ATTRIB_COL0][0] * adjx
 643                                   + span.attrStepY[FRAG_ATTRIB_COL0][0] * adjy) + FIXED_HALF;
 644                   gLeft = (GLint)(ChanToFixed(vLower->color[GCOMP])
 645                                   + span.attrStepX[FRAG_ATTRIB_COL0][1] * adjx
 646                                   + span.attrStepY[FRAG_ATTRIB_COL0][1] * adjy) + FIXED_HALF;
 647                   bLeft = (GLint)(ChanToFixed(vLower->color[BCOMP])
 648                                   + span.attrStepX[FRAG_ATTRIB_COL0][2] * adjx
 649                                   + span.attrStepY[FRAG_ATTRIB_COL0][2] * adjy) + FIXED_HALF;
 650                   fdrOuter = SignedFloatToFixed(span.attrStepY[FRAG_ATTRIB_COL0][0]
 651                                                 + dxOuter * span.attrStepX[FRAG_ATTRIB_COL0][0]);
 652                   fdgOuter = SignedFloatToFixed(span.attrStepY[FRAG_ATTRIB_COL0][1]
 653                                                 + dxOuter * span.attrStepX[FRAG_ATTRIB_COL0][1]);
 654                   fdbOuter = SignedFloatToFixed(span.attrStepY[FRAG_ATTRIB_COL0][2]
 655                                                 + dxOuter * span.attrStepX[FRAG_ATTRIB_COL0][2]);
 656 #  ifdef INTERP_ALPHA
 657                   aLeft = (GLint)(ChanToFixed(vLower->color[ACOMP])
 658                                   + span.attrStepX[FRAG_ATTRIB_COL0][3] * adjx
 659                                   + span.attrStepY[FRAG_ATTRIB_COL0][3] * adjy) + FIXED_HALF;
 660                   fdaOuter = SignedFloatToFixed(span.attrStepY[FRAG_ATTRIB_COL0][3]
 661                                                 + dxOuter * span.attrStepX[FRAG_ATTRIB_COL0][3]);
 662 #  endif
 663                }
 664                else {
 665                   ASSERT(ctx->Light.ShadeModel == GL_FLAT);
 666                   rLeft = ChanToFixed(v2->color[RCOMP]);
 667                   gLeft = ChanToFixed(v2->color[GCOMP]);
 668                   bLeft = ChanToFixed(v2->color[BCOMP]);
 669                   fdrOuter = fdgOuter = fdbOuter = 0;
 670 #  ifdef INTERP_ALPHA
 671                   aLeft = ChanToFixed(v2->color[ACOMP]);
 672                   fdaOuter = 0;
 673 #  endif
 674                }
 675 #endif /* INTERP_RGB */
 676
 677
 678 #ifdef INTERP_INT_TEX
 679                {
 680                   GLfloat s0, t0;
 681                   s0 = vLower->attrib[FRAG_ATTRIB_TEX0][0] * S_SCALE;
 682                   sLeft = (GLfixed)(s0 * FIXED_SCALE + span.attrStepX[FRAG_ATTRIB_TEX0][0] * adjx
 683                                  + span.attrStepY[FRAG_ATTRIB_TEX0][0] * adjy) + FIXED_HALF;
 684                   dsOuter = SignedFloatToFixed(span.attrStepY[FRAG_ATTRIB_TEX0][0]
 685                                                + dxOuter * span.attrStepX[FRAG_ATTRIB_TEX0][0]);
 686
 687                   t0 = vLower->attrib[FRAG_ATTRIB_TEX0][1] * T_SCALE;
 688                   tLeft = (GLfixed)(t0 * FIXED_SCALE + span.attrStepX[FRAG_ATTRIB_TEX0][1] * adjx
 689                                  + span.attrStepY[FRAG_ATTRIB_TEX0][1] * adjy) + FIXED_HALF;
 690                   dtOuter = SignedFloatToFixed(span.attrStepY[FRAG_ATTRIB_TEX0][1]
 691                                                + dxOuter * span.attrStepX[FRAG_ATTRIB_TEX0][1]);
 692                }
 693 #endif
 694 #ifdef INTERP_ATTRIBS
 695                {
 696                   const GLuint attr = FRAG_ATTRIB_WPOS;
 697                   wLeft = vLower->attrib[FRAG_ATTRIB_WPOS][3]
 698                         + (span.attrStepX[attr][3] * adjx
 699                            + span.attrStepY[attr][3] * adjy) * (1.0F/FIXED_SCALE);
 700                   dwOuter = span.attrStepY[attr][3] + dxOuter * span.attrStepX[attr][3];
 701                }
 702                ATTRIB_LOOP_BEGIN
 703                   const GLfloat invW = vLower->attrib[FRAG_ATTRIB_WPOS][3];
 704                   if (swrast->_InterpMode[attr] == GL_FLAT) {
 705                      GLuint c;
 706                      for (c = 0; c < 4; c++) {
 707                         attrLeft[attr][c] = v2->attrib[attr][c] * invW;
 708                         daOuter[attr][c] = 0.0;
 709                      }
 710                   }
 711                   else {
 712                      GLuint c;
 713                      for (c = 0; c < 4; c++) {
 714                         const GLfloat a = vLower->attrib[attr][c] * invW;
 715                         attrLeft[attr][c] = a + (  span.attrStepX[attr][c] * adjx
 716                                                  + span.attrStepY[attr][c] * adjy) * (1.0F/FIXED_SCALE);
 717                         daOuter[attr][c] = span.attrStepY[attr][c] + dxOuter * span.attrStepX[attr][c];
 718                      }
 719                   }
 720                ATTRIB_LOOP_END
 721 #endif
 722             } /*if setupLeft*/
 723
 724
 725             if (setupRight && eRight->lines>0) {
 726                fxRightEdge = eRight->fsx - FIXED_EPSILON;
 727                fdxRightEdge = eRight->fdxdy;
 728             }
 729
 730             if (lines==0) {
 731                continue;
 732             }
 733
 734
 735             /* Rasterize setup */
 736 #ifdef PIXEL_ADDRESS
 737             dPRowInner = dPRowOuter + sizeof(PIXEL_TYPE);
 738 #endif
 739 #ifdef INTERP_Z
 740 #  ifdef DEPTH_TYPE
 741             dZRowInner = dZRowOuter + sizeof(DEPTH_TYPE);
 742 #  endif
 743             fdzInner = fdzOuter + span.zStep;
 744 #endif
 745 #ifdef INTERP_RGB
 746             fdrInner = fdrOuter + span.redStep;
 747             fdgInner = fdgOuter + span.greenStep;
 748             fdbInner = fdbOuter + span.blueStep;
 749 #endif
 750 #ifdef INTERP_ALPHA
 751             fdaInner = fdaOuter + span.alphaStep;
 752 #endif
 753 #ifdef INTERP_INT_TEX
 754             dsInner = dsOuter + span.intTexStep[0];
 755             dtInner = dtOuter + span.intTexStep[1];
 756 #endif
 757 #ifdef INTERP_ATTRIBS
 758             dwInner = dwOuter + span.attrStepX[FRAG_ATTRIB_WPOS][3];
 759             ATTRIB_LOOP_BEGIN
 760                GLuint c;
 761                for (c = 0; c < 4; c++) {
 762                   daInner[attr][c] = daOuter[attr][c] + span.attrStepX[attr][c];
 763                }
 764             ATTRIB_LOOP_END
 765 #endif
 766
 767             while (lines > 0) {
 768                /* initialize the span interpolants to the leftmost value */
 769                /* ff = fixed-pt fragment */
 770                const GLint right = FixedToInt(fxRightEdge);
 771                span.x = FixedToInt(fxLeftEdge);
 772                if (right <= span.x)
 773                   span.end = 0;
 774                else
 775                   span.end = right - span.x;
 776
 777 #ifdef INTERP_Z
 778                span.z = zLeft;
 779 #endif
 780 #ifdef INTERP_RGB
 781                span.red = rLeft;
 782                span.green = gLeft;
 783                span.blue = bLeft;
 784 #endif
 785 #ifdef INTERP_ALPHA
 786                span.alpha = aLeft;
 787 #endif
 788 #ifdef INTERP_INT_TEX
 789                span.intTex[0] = sLeft;
 790                span.intTex[1] = tLeft;
 791 #endif
 792
 793 #ifdef INTERP_ATTRIBS
 794                span.attrStart[FRAG_ATTRIB_WPOS][3] = wLeft;
 795                ATTRIB_LOOP_BEGIN
 796                   GLuint c;
 797                   for (c = 0; c < 4; c++) {
 798                      span.attrStart[attr][c] = attrLeft[attr][c];
 799                   }
 800                ATTRIB_LOOP_END
 801 #endif
 802
 803                /* This is where we actually generate fragments */
 804                /* XXX the test for span.y > 0 _shouldn't_ be needed but
 805                 * it fixes a problem on 64-bit Opterons (bug 4842).
 806                 */
 807                if (span.end > 0 && span.y >= 0) {
 808                   const GLint len = span.end - 1;
 809                   (void) len;
 810 #ifdef INTERP_RGB
 811                   CLAMP_INTERPOLANT(red, redStep, len);
 812                   CLAMP_INTERPOLANT(green, greenStep, len);
 813                   CLAMP_INTERPOLANT(blue, blueStep, len);
 814 #endif
 815 #ifdef INTERP_ALPHA
 816                   CLAMP_INTERPOLANT(alpha, alphaStep, len);
 817 #endif
 818                   {
 819                      RENDER_SPAN( span );
 820                   }
 821                }
 822
 823                /*
 824                 * Advance to the next scan line.  Compute the
 825                 * new edge coordinates, and adjust the
 826                 * pixel-center x coordinate so that it stays
 827                 * on or inside the major edge.
 828                 */
 829                span.y++;
 830                lines--;
 831
 832                fxLeftEdge += fdxLeftEdge;
 833                fxRightEdge += fdxRightEdge;
 834
 835                fError += fdError;
 836                if (fError >= 0) {
 837                   fError -= FIXED_ONE;
 838
 839 #ifdef PIXEL_ADDRESS
 840                   pRow = (PIXEL_TYPE *) ((GLubyte *) pRow + dPRowOuter);
 841 #endif
 842 #ifdef INTERP_Z
 843 #  ifdef DEPTH_TYPE
 844                   zRow = (DEPTH_TYPE *) ((GLubyte *) zRow + dZRowOuter);
 845 #  endif
 846                   zLeft += fdzOuter;
 847 #endif
 848 #ifdef INTERP_RGB
 849                   rLeft += fdrOuter;
 850                   gLeft += fdgOuter;
 851                   bLeft += fdbOuter;
 852 #endif
 853 #ifdef INTERP_ALPHA
 854                   aLeft += fdaOuter;
 855 #endif
 856 #ifdef INTERP_INT_TEX
 857                   sLeft += dsOuter;
 858                   tLeft += dtOuter;
 859 #endif
 860 #ifdef INTERP_ATTRIBS
 861                   wLeft += dwOuter;
 862                   ATTRIB_LOOP_BEGIN
 863                      GLuint c;
 864                      for (c = 0; c < 4; c++) {
 865                         attrLeft[attr][c] += daOuter[attr][c];
 866                      }
 867                   ATTRIB_LOOP_END
 868 #endif
 869                }
 870                else {
 871 #ifdef PIXEL_ADDRESS
 872                   pRow = (PIXEL_TYPE *) ((GLubyte *) pRow + dPRowInner);
 873 #endif
 874 #ifdef INTERP_Z
 875 #  ifdef DEPTH_TYPE
 876                   zRow = (DEPTH_TYPE *) ((GLubyte *) zRow + dZRowInner);
 877 #  endif
 878                   zLeft += fdzInner;
 879 #endif
 880 #ifdef INTERP_RGB
 881                   rLeft += fdrInner;
 882                   gLeft += fdgInner;
 883                   bLeft += fdbInner;
 884 #endif
 885 #ifdef INTERP_ALPHA
 886                   aLeft += fdaInner;
 887 #endif
 888 #ifdef INTERP_INT_TEX
 889                   sLeft += dsInner;
 890                   tLeft += dtInner;
 891 #endif
 892 #ifdef INTERP_ATTRIBS
 893                   wLeft += dwInner;
 894                   ATTRIB_LOOP_BEGIN
 895                      GLuint c;
 896                      for (c = 0; c < 4; c++) {
 897                         attrLeft[attr][c] += daInner[attr][c];
 898                      }
 899                   ATTRIB_LOOP_END
 900 #endif
 901                }
 902             } /*while lines>0*/
 903
 904          } /* for subTriangle */
 905
 906       }
 907    }
 908 }
 909
 910 #undef SETUP_CODE
 911 #undef RENDER_SPAN
 912
 913 #undef PIXEL_TYPE
 914 #undef BYTES_PER_ROW
 915 #undef PIXEL_ADDRESS
 916 #undef DEPTH_TYPE
 917
 918 #undef INTERP_Z
 919 #undef INTERP_RGB
 920 #undef INTERP_ALPHA
 921 #undef INTERP_INT_TEX
 922 #undef INTERP_ATTRIBS
 923
 924 #undef S_SCALE
 925 #undef T_SCALE
 926
 927 #undef FixedToDepth
 928
 929 #undef NAME