src/mesa/swrast/s_pointtemp.h

   1 /*
   2  * Mesa 3-D graphics library
   3  * Version:  6.5
   4  *
   5  * Copyright (C) 1999-2005  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  * Regarding GL_NV_point_sprite:
  27  *
  28  * Portions of this software may use or implement intellectual
  29  * property owned and licensed by NVIDIA Corporation. NVIDIA disclaims
  30  * any and all warranties with respect to such intellectual property,
  31  * including any use thereof or modifications thereto.
  32  */
  33
  34
  35 /*
  36  * Point rendering template code.
  37  *
  38  * Set FLAGS = bitwise-OR of the following tokens:
  39  *
  40  *   RGBA = do rgba instead of color index
  41  *   SMOOTH = do antialiasing
  42  *   TEXTURE = do texture coords
  43  *   SPECULAR = do separate specular color
  44  *   LARGE = do points with diameter > 1 pixel
  45  *   ATTENUATE = compute point size attenuation
  46  *   SPRITE = GL_ARB_point_sprite / GL_NV_point_sprite
  47  *
  48  * Notes: LARGE and ATTENUATE are exclusive of each other.
  49  *        TEXTURE requires RGBA
  50  */
  51
  52
  53 /*
  54  * NOTES on antialiased point rasterization:
  55  *
  56  * Let d = distance of fragment center from vertex.
  57  * if d < rmin2 then
  58  *    fragment has 100% coverage
  59  * else if d > rmax2 then
  60  *    fragment has 0% coverage
  61  * else
  62  *    fragment has % coverage = (d - rmin2) / (rmax2 - rmin2)
  63  */
  64
  65
  66
  67 static void
  68 NAME ( GLcontext *ctx, const SWvertex *vert )
  69 {
  70 #if FLAGS & (ATTENUATE | LARGE | SMOOTH | SPRITE)
  71    GLfloat size;
  72 #endif
  73 #if FLAGS & RGBA
  74 #if (FLAGS & ATTENUATE) && (FLAGS & SMOOTH)
  75    GLfloat alphaAtten;
  76 #endif
  77    const GLchan red   = vert->color[0];
  78    const GLchan green = vert->color[1];
  79    const GLchan blue  = vert->color[2];
  80    const GLchan alpha = vert->color[3];
  81 #endif
  82 #if FLAGS & SPECULAR
  83    const GLchan specRed   = vert->specular[0];
  84    const GLchan specGreen = vert->specular[1];
  85    const GLchan specBlue  = vert->specular[2];
  86 #endif
  87 #if FLAGS & INDEX
  88    const GLuint colorIndex = (GLuint) vert->index; /* XXX round? */
  89 #endif
  90 #if FLAGS & TEXTURE
  91    GLfloat texcoord[MAX_TEXTURE_COORD_UNITS][4];
  92    GLuint u;
  93 #endif
  94    SWcontext *swrast = SWRAST_CONTEXT(ctx);
  95    struct sw_span *span = &(swrast->PointSpan);
  96
  97    /* Cull primitives with malformed coordinates.
  98     */
  99    {
 100       float tmp = vert->win[0] + vert->win[1];
 101       if (IS_INF_OR_NAN(tmp))
 102          return;
 103    }
 104
 105    /*
 106     * Span init
 107     */
 108    span->interpMask = SPAN_FOG;
 109    span->arrayMask = SPAN_XY | SPAN_Z;
 110    span->fog = vert->fog;
 111    span->fogStep = 0.0;
 112 #if FLAGS & RGBA
 113    span->arrayMask |= SPAN_RGBA;
 114 #endif
 115 #if FLAGS & SPECULAR
 116    span->arrayMask |= SPAN_SPEC;
 117 #endif
 118 #if FLAGS & INDEX
 119    span->arrayMask |= SPAN_INDEX;
 120 #endif
 121 #if FLAGS & TEXTURE
 122    span->arrayMask |= SPAN_TEXTURE;
 123    if (ctx->FragmentProgram._Active) {
 124       /* Don't divide texture s,t,r by q (use TXP to do that) */
 125       for (u = 0; u < ctx->Const.MaxTextureUnits; u++) {
 126          if (ctx->Texture._EnabledCoordUnits & (1 << u)) {
 127             COPY_4V(texcoord[u], vert->texcoord[u]);
 128          }
 129       }
 130    }
 131    else {
 132       /* Divide texture s,t,r by q here */
 133       for (u = 0; u < ctx->Const.MaxTextureUnits; u++) {
 134          if (ctx->Texture._EnabledCoordUnits & (1 << u)) {
 135             const GLfloat q = vert->texcoord[u][3];
 136             const GLfloat invQ = (q == 0.0F || q == 1.0F) ? 1.0F : (1.0F / q);
 137             texcoord[u][0] = vert->texcoord[u][0] * invQ;
 138             texcoord[u][1] = vert->texcoord[u][1] * invQ;
 139             texcoord[u][2] = vert->texcoord[u][2] * invQ;
 140             texcoord[u][3] = q;
 141          }
 142       }
 143    }
 144    /* need these for fragment programs */
 145    span->w = 1.0F;
 146    span->dwdx = 0.0F;
 147    span->dwdy = 0.0F;
 148 #endif
 149 #if FLAGS & SMOOTH
 150    span->arrayMask |= SPAN_COVERAGE;
 151 #endif
 152 #if FLAGS & SPRITE
 153    span->arrayMask |= SPAN_TEXTURE;
 154 #endif
 155
 156    /* Compute point size if not known to be one */
 157 #if FLAGS & ATTENUATE
 158    /* first, clamp attenuated size to the user-specifed range */
 159    size = CLAMP(vert->pointSize, ctx->Point.MinSize, ctx->Point.MaxSize);
 160 #if (FLAGS & RGBA) && (FLAGS & SMOOTH)
 161    /* only if multisampling, compute the fade factor */
 162    if (ctx->Multisample.Enabled) {
 163       if (vert->pointSize >= ctx->Point.Threshold) {
 164          alphaAtten = 1.0F;
 165       }
 166       else {
 167          GLfloat dsize = vert->pointSize / ctx->Point.Threshold;
 168          alphaAtten = dsize * dsize;
 169       }
 170    }
 171    else {
 172       alphaAtten = 1.0;
 173    }
 174 #endif
 175 #elif FLAGS & (LARGE | SMOOTH | SPRITE)
 176    /* constant, non-attenuated size */
 177    size = ctx->Point._Size; /* this is already clamped */
 178 #endif
 179
 180
 181 #if FLAGS & (ATTENUATE | LARGE | SMOOTH | SPRITE)
 182    /***
 183     *** Multi-pixel points
 184     ***/
 185
 186    /* do final clamping now */
 187    if (ctx->Point.SmoothFlag) {
 188       size = CLAMP(size, ctx->Const.MinPointSizeAA, ctx->Const.MaxPointSizeAA);
 189    }
 190    else {
 191       size = CLAMP(size, ctx->Const.MinPointSize, ctx->Const.MaxPointSize);
 192    }
 193
 194    {{
 195       GLint x, y;
 196       const GLfloat radius = 0.5F * size;
 197       const GLint z = (GLint) (vert->win[2] + 0.5F);
 198       GLuint count;
 199 #if FLAGS & SMOOTH
 200       const GLfloat rmin = radius - 0.7071F;  /* 0.7071 = sqrt(2)/2 */
 201       const GLfloat rmax = radius + 0.7071F;
 202       const GLfloat rmin2 = MAX2(0.0F, rmin * rmin);
 203       const GLfloat rmax2 = rmax * rmax;
 204       const GLfloat cscale = 1.0F / (rmax2 - rmin2);
 205       const GLint xmin = (GLint) (vert->win[0] - radius);
 206       const GLint xmax = (GLint) (vert->win[0] + radius);
 207       const GLint ymin = (GLint) (vert->win[1] - radius);
 208       const GLint ymax = (GLint) (vert->win[1] + radius);
 209 #else
 210       /* non-smooth */
 211       GLint xmin, xmax, ymin, ymax;
 212       GLint iSize = (GLint) (size + 0.5F);
 213       GLint iRadius;
 214       iSize = MAX2(1, iSize);
 215       iRadius = iSize / 2;
 216       if (iSize & 1) {
 217          /* odd size */
 218          xmin = (GLint) (vert->win[0] - iRadius);
 219          xmax = (GLint) (vert->win[0] + iRadius);
 220          ymin = (GLint) (vert->win[1] - iRadius);
 221          ymax = (GLint) (vert->win[1] + iRadius);
 222       }
 223       else {
 224          /* even size */
 225          xmin = (GLint) vert->win[0] - iRadius + 1;
 226          xmax = xmin + iSize - 1;
 227          ymin = (GLint) vert->win[1] - iRadius + 1;
 228          ymax = ymin + iSize - 1;
 229       }
 230 #endif /*SMOOTH*/
 231
 232       /* check if we need to flush */
 233       if (span->end + (xmax-xmin+1) * (ymax-ymin+1) >= MAX_WIDTH ||
 234           (swrast->_RasterMask & (BLEND_BIT | LOGIC_OP_BIT | MASKING_BIT))) {
 235 #if FLAGS & RGBA
 236          _swrast_write_rgba_span(ctx, span);
 237 #else
 238          _swrast_write_index_span(ctx, span);
 239 #endif
 240          span->end = 0;
 241       }
 242
 243       /*
 244        * OK, generate fragments
 245        */
 246       count = span->end;
 247       (void) radius;
 248       for (y = ymin; y <= ymax; y++) {
 249          /* check if we need to flush */
 250          if (count + (xmax-xmin+1) >= MAX_WIDTH) {
 251              span->end = count;
 252 #if FLAGS & RGBA
 253             _swrast_write_rgba_span(ctx, span);
 254 #else
 255             _swrast_write_index_span(ctx, span);
 256 #endif
 257             count = span->end = 0;
 258          }
 259          for (x = xmin; x <= xmax; x++) {
 260 #if FLAGS & (SPRITE | TEXTURE)
 261             GLuint u;
 262 #endif
 263
 264 #if FLAGS & RGBA
 265             span->array->rgba[count][RCOMP] = red;
 266             span->array->rgba[count][GCOMP] = green;
 267             span->array->rgba[count][BCOMP] = blue;
 268             span->array->rgba[count][ACOMP] = alpha;
 269 #endif
 270 #if FLAGS & SPECULAR
 271             span->array->spec[count][RCOMP] = specRed;
 272             span->array->spec[count][GCOMP] = specGreen;
 273             span->array->spec[count][BCOMP] = specBlue;
 274 #endif
 275 #if FLAGS & INDEX
 276             span->array->index[count] = colorIndex;
 277 #endif
 278 #if FLAGS & TEXTURE
 279             for (u = 0; u < ctx->Const.MaxTextureUnits; u++) {
 280                if (ctx->Texture._EnabledCoordUnits & (1 << u)) {
 281                   COPY_4V(span->array->texcoords[u][count], texcoord[u]);
 282                }
 283             }
 284 #endif
 285
 286 #if FLAGS & SMOOTH
 287             /* compute coverage */
 288             {
 289                const GLfloat dx = x - vert->win[0] + 0.5F;
 290                const GLfloat dy = y - vert->win[1] + 0.5F;
 291                const GLfloat dist2 = dx * dx + dy * dy;
 292                if (dist2 < rmax2) {
 293                   if (dist2 >= rmin2) {
 294                      /* compute partial coverage */
 295                      span->array->coverage[count] = 1.0F - (dist2 - rmin2) * cscale;
 296 #if FLAGS & INDEX
 297                      /* coverage in [0,15] */
 298                      span->array->coverage[count] *= 15.0;
 299 #endif
 300                   }
 301                   else {
 302                      /* full coverage */
 303                      span->array->coverage[count] = 1.0F;
 304                   }
 305
 306                   span->array->x[count] = x;
 307                   span->array->y[count] = y;
 308                   span->array->z[count] = z;
 309
 310 #if (FLAGS & ATTENUATE) && (FLAGS & RGBA)
 311                   span->array->rgba[count][ACOMP] = (GLchan) (alpha * alphaAtten);
 312 #elif FLAGS & RGBA
 313                   span->array->rgba[count][ACOMP] = alpha;
 314 #endif /*ATTENUATE*/
 315                   count++;
 316                } /*if*/
 317             }
 318
 319 #else /*SMOOTH*/
 320
 321             /* not smooth (square points) */
 322             span->array->x[count] = x;
 323             span->array->y[count] = y;
 324             span->array->z[count] = z;
 325
 326 #if FLAGS & SPRITE
 327             for (u = 0; u < ctx->Const.MaxTextureUnits; u++) {
 328                if (ctx->Texture.Unit[u]._ReallyEnabled) {
 329                   if (ctx->Point.CoordReplace[u]) {
 330                      GLfloat s = 0.5F + (x + 0.5F - vert->win[0]) / size;
 331                      GLfloat t, r;
 332                      if (ctx->Point.SpriteOrigin == GL_LOWER_LEFT)
 333                         t = 0.5F + (y + 0.5F - vert->win[1]) / size;
 334                      else /* GL_UPPER_LEFT */
 335                         t = 0.5F - (y + 0.5F - vert->win[1]) / size;
 336                      if (ctx->Point.SpriteRMode == GL_ZERO)
 337                         r = 0.0F;
 338                      else if (ctx->Point.SpriteRMode == GL_S)
 339                         r = vert->texcoord[u][0];
 340                      else /* GL_R */
 341                         r = vert->texcoord[u][2];
 342                      span->array->texcoords[u][count][0] = s;
 343                      span->array->texcoords[u][count][1] = t;
 344                      span->array->texcoords[u][count][2] = r;
 345                      span->array->texcoords[u][count][3] = 1.0F;
 346                   }
 347                   else {
 348                      COPY_4V(span->array->texcoords[u][count], vert->texcoord[u]);
 349                   }
 350                }
 351             }
 352 #endif /*SPRITE*/
 353
 354             count++;  /* square point */
 355
 356 #endif /*SMOOTH*/
 357
 358          } /*for x*/
 359       } /*for y*/
 360       span->end = count;
 361    }}
 362
 363 #else /* LARGE | ATTENUATE | SMOOTH | SPRITE */
 364
 365    /***
 366     *** Single-pixel points
 367     ***/
 368    {{
 369       GLuint count;
 370
 371       /* check if we need to flush */
 372       if (span->end >= MAX_WIDTH ||
 373           (swrast->_RasterMask & (BLEND_BIT | LOGIC_OP_BIT | MASKING_BIT))) {
 374 #if FLAGS & RGBA
 375          _swrast_write_rgba_span(ctx, span);
 376 #else
 377          _swrast_write_index_span(ctx, span);
 378 #endif
 379          span->end = 0;
 380       }
 381
 382       count = span->end;
 383
 384 #if FLAGS & RGBA
 385       span->array->rgba[count][RCOMP] = red;
 386       span->array->rgba[count][GCOMP] = green;
 387       span->array->rgba[count][BCOMP] = blue;
 388       span->array->rgba[count][ACOMP] = alpha;
 389 #endif
 390 #if FLAGS & SPECULAR
 391       span->array->spec[count][RCOMP] = specRed;
 392       span->array->spec[count][GCOMP] = specGreen;
 393       span->array->spec[count][BCOMP] = specBlue;
 394 #endif
 395 #if FLAGS & INDEX
 396       span->array->index[count] = colorIndex;
 397 #endif
 398 #if FLAGS & TEXTURE
 399       for (u = 0; u < ctx->Const.MaxTextureUnits; u++) {
 400          if (ctx->Texture.Unit[u]._ReallyEnabled) {
 401             COPY_4V(span->array->texcoords[u][count], texcoord[u]);
 402          }
 403       }
 404 #endif
 405
 406       span->array->x[count] = (GLint) vert->win[0];
 407       span->array->y[count] = (GLint) vert->win[1];
 408       span->array->z[count] = (GLint) (vert->win[2] + 0.5F);
 409       span->end = count + 1;
 410    }}
 411
 412 #endif /* LARGE || ATTENUATE || SMOOTH */
 413
 414    ASSERT(span->end <= MAX_WIDTH);
 415 }
 416
 417
 418 #undef FLAGS
 419 #undef NAME