src/mesa/swrast/s_aalinetemp.h

   1 /*
   2  * Mesa 3-D graphics library
   3  *
   4  * Copyright (C) 1999-2007  Brian Paul   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 "Software"),
   8  * to deal in the Software without restriction, including without limitation
   9  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
  10  * and/or sell copies of the Software, and to permit persons to whom the
  11  * Software is furnished to do so, subject to the following conditions:
  12  *
  13  * The above copyright notice and this permission notice shall be included
  14  * in all copies or substantial portions of the Software.
  15  *
  16  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  17  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  18  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
  19  * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
  20  * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
  21  * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
  22  * OTHER DEALINGS IN THE SOFTWARE.
  23  */
  24
  25
  26 /*
  27  * Antialiased line template.
  28  */
  29
  30
  31 /*
  32  * Function to render each fragment in the AA line.
  33  * \param ix  - integer fragment window X coordiante
  34  * \param iy  - integer fragment window Y coordiante
  35  */
  36 static void
  37 NAME(plot)(struct gl_context *ctx, struct LineInfo *line, int ix, int iy)
  38 {
  39    const SWcontext *swrast = SWRAST_CONTEXT(ctx);
  40    const GLfloat fx = (GLfloat) ix;
  41    const GLfloat fy = (GLfloat) iy;
  42    const GLfloat coverage = compute_coveragef(line, ix, iy);
  43    const GLuint i = line->span.end;
  44
  45    (void) swrast;
  46
  47    if (coverage == 0.0F)
  48       return;
  49
  50    line->span.end++;
  51    line->span.array->coverage[i] = coverage;
  52    line->span.array->x[i] = ix;
  53    line->span.array->y[i] = iy;
  54
  55    /*
  56     * Compute Z, color, texture coords, fog for the fragment by
  57     * solving the plane equations at (ix,iy).
  58     */
  59 #ifdef DO_Z
  60    line->span.array->z[i] = (GLuint) solve_plane(fx, fy, line->zPlane);
  61 #endif
  62    line->span.array->rgba[i][RCOMP] = solve_plane_chan(fx, fy, line->rPlane);
  63    line->span.array->rgba[i][GCOMP] = solve_plane_chan(fx, fy, line->gPlane);
  64    line->span.array->rgba[i][BCOMP] = solve_plane_chan(fx, fy, line->bPlane);
  65    line->span.array->rgba[i][ACOMP] = solve_plane_chan(fx, fy, line->aPlane);
  66 #if defined(DO_ATTRIBS)
  67    ATTRIB_LOOP_BEGIN
  68       GLfloat (*attribArray)[4] = line->span.array->attribs[attr];
  69       if (attr >= VARYING_SLOT_TEX0 && attr < VARYING_SLOT_VAR0
  70           && !_swrast_use_fragment_program(ctx)) {
  71          /* texcoord w/ divide by Q */
  72          const GLuint unit = attr - VARYING_SLOT_TEX0;
  73          const GLfloat invQ = solve_plane_recip(fx, fy, line->attrPlane[attr][3]);
  74          GLuint c;
  75          for (c = 0; c < 3; c++) {
  76             attribArray[i][c] = solve_plane(fx, fy, line->attrPlane[attr][c]) * invQ;
  77          }
  78          line->span.array->lambda[unit][i]
  79             = compute_lambda(line->attrPlane[attr][0],
  80                              line->attrPlane[attr][1], invQ,
  81                              line->texWidth[attr], line->texHeight[attr]);
  82       }
  83       else {
  84          /* non-texture attrib */
  85          const GLfloat invW = solve_plane_recip(fx, fy, line->wPlane);
  86          GLuint c;
  87          for (c = 0; c < 4; c++) {
  88             attribArray[i][c] = solve_plane(fx, fy, line->attrPlane[attr][c]) * invW;
  89          }
  90       }
  91    ATTRIB_LOOP_END
  92 #endif
  93
  94    if (line->span.end == SWRAST_MAX_WIDTH) {
  95       _swrast_write_rgba_span(ctx, &(line->span));
  96       line->span.end = 0; /* reset counter */
  97    }
  98 }
  99
 100
 101
 102 /*
 103  * Line setup
 104  */
 105 static void
 106 NAME(line)(struct gl_context *ctx, const SWvertex *v0, const SWvertex *v1)
 107 {
 108    SWcontext *swrast = SWRAST_CONTEXT(ctx);
 109    GLfloat tStart, tEnd;   /* segment start, end along line length */
 110    GLboolean inSegment;
 111    GLint iLen, i;
 112
 113    /* Init the LineInfo struct */
 114    struct LineInfo line;
 115    line.x0 = v0->attrib[VARYING_SLOT_POS][0];
 116    line.y0 = v0->attrib[VARYING_SLOT_POS][1];
 117    line.x1 = v1->attrib[VARYING_SLOT_POS][0];
 118    line.y1 = v1->attrib[VARYING_SLOT_POS][1];
 119    line.dx = line.x1 - line.x0;
 120    line.dy = line.y1 - line.y0;
 121    line.len = sqrtf(line.dx * line.dx + line.dy * line.dy);
 122    line.halfWidth = 0.5F * CLAMP(ctx->Line.Width,
 123                                  ctx->Const.MinLineWidthAA,
 124                                  ctx->Const.MaxLineWidthAA);
 125
 126    if (line.len == 0.0F || util_is_inf_or_nan(line.len))
 127       return;
 128
 129    INIT_SPAN(line.span, GL_LINE);
 130    line.span.arrayMask = SPAN_XY | SPAN_COVERAGE;
 131    line.span.facing = swrast->PointLineFacing;
 132    line.xAdj = line.dx / line.len * line.halfWidth;
 133    line.yAdj = line.dy / line.len * line.halfWidth;
 134
 135 #ifdef DO_Z
 136    line.span.arrayMask |= SPAN_Z;
 137    compute_plane(line.x0, line.y0, line.x1, line.y1,
 138                  v0->attrib[VARYING_SLOT_POS][2], v1->attrib[VARYING_SLOT_POS][2], line.zPlane);
 139 #endif
 140    line.span.arrayMask |= SPAN_RGBA;
 141    if (ctx->Light.ShadeModel == GL_SMOOTH) {
 142       compute_plane(line.x0, line.y0, line.x1, line.y1,
 143                     v0->color[RCOMP], v1->color[RCOMP], line.rPlane);
 144       compute_plane(line.x0, line.y0, line.x1, line.y1,
 145                     v0->color[GCOMP], v1->color[GCOMP], line.gPlane);
 146       compute_plane(line.x0, line.y0, line.x1, line.y1,
 147                     v0->color[BCOMP], v1->color[BCOMP], line.bPlane);
 148       compute_plane(line.x0, line.y0, line.x1, line.y1,
 149                     v0->color[ACOMP], v1->color[ACOMP], line.aPlane);
 150    }
 151    else {
 152       constant_plane(v1->color[RCOMP], line.rPlane);
 153       constant_plane(v1->color[GCOMP], line.gPlane);
 154       constant_plane(v1->color[BCOMP], line.bPlane);
 155       constant_plane(v1->color[ACOMP], line.aPlane);
 156    }
 157 #if defined(DO_ATTRIBS)
 158    {
 159       const GLfloat invW0 = v0->attrib[VARYING_SLOT_POS][3];
 160       const GLfloat invW1 = v1->attrib[VARYING_SLOT_POS][3];
 161       line.span.arrayMask |= SPAN_LAMBDA;
 162       compute_plane(line.x0, line.y0, line.x1, line.y1, invW0, invW1, line.wPlane);
 163       ATTRIB_LOOP_BEGIN
 164          GLuint c;
 165          if (swrast->_InterpMode[attr] == GL_FLAT) {
 166             for (c = 0; c < 4; c++) {
 167                constant_plane(v1->attrib[attr][c], line.attrPlane[attr][c]);
 168             }
 169          }
 170          else {
 171             for (c = 0; c < 4; c++) {
 172                const GLfloat a0 = v0->attrib[attr][c] * invW0;
 173                const GLfloat a1 = v1->attrib[attr][c] * invW1;
 174                compute_plane(line.x0, line.y0, line.x1, line.y1, a0, a1,
 175                              line.attrPlane[attr][c]);
 176             }
 177          }
 178          line.span.arrayAttribs |= BITFIELD64_BIT(attr);
 179          if (attr >= VARYING_SLOT_TEX0 && attr < VARYING_SLOT_VAR0) {
 180             const GLuint u = attr - VARYING_SLOT_TEX0;
 181             const struct gl_texture_object *obj = ctx->Texture.Unit[u]._Current;
 182             if (obj) {
 183                const struct gl_texture_image *texImage =
 184                   _mesa_base_tex_image(obj);
 185                line.texWidth[attr]  = (GLfloat) texImage->Width;
 186                line.texHeight[attr] = (GLfloat) texImage->Height;
 187             }
 188          }
 189       ATTRIB_LOOP_END
 190    }
 191 #endif
 192
 193    tStart = tEnd = 0.0;
 194    inSegment = GL_FALSE;
 195    iLen = (GLint) line.len;
 196
 197    if (ctx->Line.StippleFlag) {
 198       for (i = 0; i < iLen; i++) {
 199          const GLuint bit = (swrast->StippleCounter / ctx->Line.StippleFactor) & 0xf;
 200          if ((1 << bit) & ctx->Line.StipplePattern) {
 201             /* stipple bit is on */
 202             const GLfloat t = (GLfloat) i / (GLfloat) line.len;
 203             if (!inSegment) {
 204                /* start new segment */
 205                inSegment = GL_TRUE;
 206                tStart = t;
 207             }
 208             else {
 209                /* still in the segment, extend it */
 210                tEnd = t;
 211             }
 212          }
 213          else {
 214             /* stipple bit is off */
 215             if (inSegment && (tEnd > tStart)) {
 216                /* draw the segment */
 217                segment(ctx, &line, NAME(plot), tStart, tEnd);
 218                inSegment = GL_FALSE;
 219             }
 220             else {
 221                /* still between segments, do nothing */
 222             }
 223          }
 224          swrast->StippleCounter++;
 225       }
 226
 227       if (inSegment) {
 228          /* draw the final segment of the line */
 229          segment(ctx, &line, NAME(plot), tStart, 1.0F);
 230       }
 231    }
 232    else {
 233       /* non-stippled */
 234       segment(ctx, &line, NAME(plot), 0.0, 1.0);
 235    }
 236
 237    _swrast_write_rgba_span(ctx, &(line.span));
 238 }
 239
 240
 241
 242
 243 #undef DO_Z
 244 #undef DO_ATTRIBS
 245 #undef NAME