svn merge ^/branches/released .

1 files changed, 572 insertions, 572 deletions

diff --git a/mesalib/src/mesa/swrast/s_points.c b/mesalib/src/mesa/swrast/s_points.c
index 12431662c..a46be8f58 100644
--- a/mesalib/src/mesa/swrast/s_points.c
+++ b/mesalib/src/mesa/swrast/s_points.c
@@ -1,572 +1,572 @@
-/*
- * Mesa 3-D graphics library
- * Version:  7.1
- *
- * Copyright (C) 1999-2007  Brian Paul   All Rights Reserved.
- *
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the "Software"),
- * to deal in the Software without restriction, including without limitation
- * the rights to use, copy, modify, merge, publish, distribute, sublicense,
- * and/or sell copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included
- * in all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
- * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
- * BRIAN PAUL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
- * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
- * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
- */
-
-
-#include "main/glheader.h"
-#include "main/colormac.h"
-#include "main/macros.h"
-#include "s_context.h"
-#include "s_feedback.h"
-#include "s_points.h"
-#include "s_span.h"
-
-
-/**
- * Used to cull points with invalid coords
- */
-#define CULL_INVALID(V)                              \
-   do {                                              \
-      float tmp = (V)->attrib[FRAG_ATTRIB_WPOS][0]   \
-                + (V)->attrib[FRAG_ATTRIB_WPOS][1];  \
-      if (IS_INF_OR_NAN(tmp))                        \
-	 return;                                     \
-   } while(0)
-
-
-
-/**
- * Get/compute the point size.
- * The size may come from a vertex shader, or computed with attentuation
- * or just the glPointSize value.
- * Must also clamp to user-defined range and implmentation limits.
- */
-static INLINE GLfloat
-get_size(const GLcontext *ctx, const SWvertex *vert, GLboolean smoothed)
-{
-   GLfloat size;
-
-   if (ctx->Point._Attenuated || ctx->VertexProgram.PointSizeEnabled) {
-      /* use vertex's point size */
-      size = vert->pointSize;
-   }
-   else {
-      /* use constant point size */
-      size = ctx->Point.Size;
-   }
-   /* always clamp to user-specified limits */
-   size = CLAMP(size, ctx->Point.MinSize, ctx->Point.MaxSize);
-   /* clamp to implementation limits */
-   if (smoothed)
-      size = CLAMP(size, ctx->Const.MinPointSizeAA, ctx->Const.MaxPointSizeAA);
-   else
-      size = CLAMP(size, ctx->Const.MinPointSize, ctx->Const.MaxPointSize);
-
-   return size;
-}
-
-
-/**
- * Draw a point sprite
- */
-static void
-sprite_point(GLcontext *ctx, const SWvertex *vert)
-{
-   SWcontext *swrast = SWRAST_CONTEXT(ctx);
-   SWspan span;
-   GLfloat size;
-   GLuint tCoords[MAX_TEXTURE_COORD_UNITS + 1];
-   GLuint numTcoords = 0;
-   GLfloat t0, dtdy;
-
-   CULL_INVALID(vert);
-
-   /* z coord */
-   if (ctx->DrawBuffer->Visual.depthBits <= 16)
-      span.z = FloatToFixed(vert->attrib[FRAG_ATTRIB_WPOS][2] + 0.5F);
-   else
-      span.z = (GLuint) (vert->attrib[FRAG_ATTRIB_WPOS][2] + 0.5F);
-   span.zStep = 0;
-
-   size = get_size(ctx, vert, GL_FALSE);
-
-   /* span init */
-   INIT_SPAN(span, GL_POINT);
-   span.interpMask = SPAN_Z | SPAN_RGBA;
-
-   span.facing = swrast->PointLineFacing;
-
-   span.red   = ChanToFixed(vert->color[0]);
-   span.green = ChanToFixed(vert->color[1]);
-   span.blue  = ChanToFixed(vert->color[2]);
-   span.alpha = ChanToFixed(vert->color[3]);
-   span.redStep = 0;
-   span.greenStep = 0;
-   span.blueStep = 0;
-   span.alphaStep = 0;
-
-   /* need these for fragment programs */
-   span.attrStart[FRAG_ATTRIB_WPOS][3] = 1.0F;
-   span.attrStepX[FRAG_ATTRIB_WPOS][3] = 0.0F;
-   span.attrStepY[FRAG_ATTRIB_WPOS][3] = 0.0F;
-
-   {
-      GLfloat s, r, dsdx;
-
-      /* texcoord / pointcoord interpolants */
-      s = 0.0F;
-      dsdx = 1.0F / size;
-      if (ctx->Point.SpriteOrigin == GL_LOWER_LEFT) {
-         dtdy = 1.0F / size;
-         t0 = 0.5F * dtdy;
-      }
-      else {
-         /* GL_UPPER_LEFT */
-         dtdy = -1.0F / size;
-         t0 = 1.0F + 0.5F * dtdy;
-      }
-
-      ATTRIB_LOOP_BEGIN
-         if (attr >= FRAG_ATTRIB_TEX0 && attr <= FRAG_ATTRIB_TEX7) {
-            /* a texcoord attribute */
-            const GLuint u = attr - FRAG_ATTRIB_TEX0;
-            ASSERT(u < Elements(ctx->Point.CoordReplace));
-            if (ctx->Point.CoordReplace[u]) {
-               tCoords[numTcoords++] = attr;
-
-               if (ctx->Point.SpriteRMode == GL_ZERO)
-                  r = 0.0F;
-               else if (ctx->Point.SpriteRMode == GL_S)
-                  r = vert->attrib[attr][0];
-               else /* GL_R */
-                  r = vert->attrib[attr][2];
-
-               span.attrStart[attr][0] = s;
-               span.attrStart[attr][1] = 0.0; /* overwritten below */
-               span.attrStart[attr][2] = r;
-               span.attrStart[attr][3] = 1.0;
-
-               span.attrStepX[attr][0] = dsdx;
-               span.attrStepX[attr][1] = 0.0;
-               span.attrStepX[attr][2] = 0.0;
-               span.attrStepX[attr][3] = 0.0;
-
-               span.attrStepY[attr][0] = 0.0;
-               span.attrStepY[attr][1] = dtdy;
-               span.attrStepY[attr][2] = 0.0;
-               span.attrStepY[attr][3] = 0.0;
-
-               continue;
-            }
-         }
-         else if (attr == FRAG_ATTRIB_PNTC) {
-            /* GLSL gl_PointCoord.xy (.zw undefined) */
-            span.attrStart[FRAG_ATTRIB_PNTC][0] = 0.0;
-            span.attrStart[FRAG_ATTRIB_PNTC][1] = 0.0; /* t0 set below */
-            span.attrStepX[FRAG_ATTRIB_PNTC][0] = dsdx;
-            span.attrStepX[FRAG_ATTRIB_PNTC][1] = 0.0;
-            span.attrStepY[FRAG_ATTRIB_PNTC][0] = 0.0;
-            span.attrStepY[FRAG_ATTRIB_PNTC][1] = dtdy;
-            tCoords[numTcoords++] = FRAG_ATTRIB_PNTC;
-            continue;
-         }
-         /* use vertex's texcoord/attrib */
-         COPY_4V(span.attrStart[attr], vert->attrib[attr]);
-         ASSIGN_4V(span.attrStepX[attr], 0, 0, 0, 0);
-         ASSIGN_4V(span.attrStepY[attr], 0, 0, 0, 0);
-      ATTRIB_LOOP_END;
-   }
-
-   /* compute pos, bounds and render */
-   {
-      const GLfloat x = vert->attrib[FRAG_ATTRIB_WPOS][0];
-      const GLfloat y = vert->attrib[FRAG_ATTRIB_WPOS][1];
-      GLint iSize = (GLint) (size + 0.5F);
-      GLint xmin, xmax, ymin, ymax, iy;
-      GLint iRadius;
-      GLfloat tcoord = t0;
-
-      iSize = MAX2(1, iSize);
-      iRadius = iSize / 2;
-
-      if (iSize & 1) {
-         /* odd size */
-         xmin = (GLint) (x - iRadius);
-         xmax = (GLint) (x + iRadius);
-         ymin = (GLint) (y - iRadius);
-         ymax = (GLint) (y + iRadius);
-      }
-      else {
-         /* even size */
-         /* 0.501 factor allows conformance to pass */
-         xmin = (GLint) (x + 0.501) - iRadius;
-         xmax = xmin + iSize - 1;
-         ymin = (GLint) (y + 0.501) - iRadius;
-         ymax = ymin + iSize - 1;
-      }
-
-      /* render spans */
-      for (iy = ymin; iy <= ymax; iy++) {
-         GLuint i;
-         /* setup texcoord T for this row */
-         for (i = 0; i < numTcoords; i++) {
-            span.attrStart[tCoords[i]][1] = tcoord;
-         }
-
-         /* these might get changed by span clipping */
-         span.x = xmin;
-         span.y = iy;
-         span.end = xmax - xmin + 1;
-
-         _swrast_write_rgba_span(ctx, &span);
-
-         tcoord += dtdy;
-      }
-   }
-}
-
-
-/**
- * Draw smooth/antialiased point.  RGB or CI mode.
- */
-static void
-smooth_point(GLcontext *ctx, const SWvertex *vert)
-{
-   SWcontext *swrast = SWRAST_CONTEXT(ctx);
-   SWspan span;
-   GLfloat size, alphaAtten;
-
-   CULL_INVALID(vert);
-
-   /* z coord */
-   if (ctx->DrawBuffer->Visual.depthBits <= 16)
-      span.z = FloatToFixed(vert->attrib[FRAG_ATTRIB_WPOS][2] + 0.5F);
-   else
-      span.z = (GLuint) (vert->attrib[FRAG_ATTRIB_WPOS][2] + 0.5F);
-   span.zStep = 0;
-
-   size = get_size(ctx, vert, GL_TRUE);
-
-   /* alpha attenuation / fade factor */
-   if (ctx->Multisample._Enabled) {
-      if (vert->pointSize >= ctx->Point.Threshold) {
-         alphaAtten = 1.0F;
-      }
-      else {
-         GLfloat dsize = vert->pointSize / ctx->Point.Threshold;
-         alphaAtten = dsize * dsize;
-      }
-   }
-   else {
-      alphaAtten = 1.0;
-   }
-   (void) alphaAtten; /* not used */
-
-   /* span init */
-   INIT_SPAN(span, GL_POINT);
-   span.interpMask = SPAN_Z | SPAN_RGBA;
-   span.arrayMask = SPAN_COVERAGE | SPAN_MASK;
-
-   span.facing = swrast->PointLineFacing;
-
-   span.red   = ChanToFixed(vert->color[0]);
-   span.green = ChanToFixed(vert->color[1]);
-   span.blue  = ChanToFixed(vert->color[2]);
-   span.alpha = ChanToFixed(vert->color[3]);
-   span.redStep = 0;
-   span.greenStep = 0;
-   span.blueStep = 0;
-   span.alphaStep = 0;
-
-   /* need these for fragment programs */
-   span.attrStart[FRAG_ATTRIB_WPOS][3] = 1.0F;
-   span.attrStepX[FRAG_ATTRIB_WPOS][3] = 0.0F;
-   span.attrStepY[FRAG_ATTRIB_WPOS][3] = 0.0F;
-
-   ATTRIB_LOOP_BEGIN
-      COPY_4V(span.attrStart[attr], vert->attrib[attr]);
-      ASSIGN_4V(span.attrStepX[attr], 0, 0, 0, 0);
-      ASSIGN_4V(span.attrStepY[attr], 0, 0, 0, 0);
-   ATTRIB_LOOP_END
-
-   /* compute pos, bounds and render */
-   {
-      const GLfloat x = vert->attrib[FRAG_ATTRIB_WPOS][0];
-      const GLfloat y = vert->attrib[FRAG_ATTRIB_WPOS][1];
-      const GLfloat radius = 0.5F * size;
-      const GLfloat rmin = radius - 0.7071F;  /* 0.7071 = sqrt(2)/2 */
-      const GLfloat rmax = radius + 0.7071F;
-      const GLfloat rmin2 = MAX2(0.0F, rmin * rmin);
-      const GLfloat rmax2 = rmax * rmax;
-      const GLfloat cscale = 1.0F / (rmax2 - rmin2);
-      const GLint xmin = (GLint) (x - radius);
-      const GLint xmax = (GLint) (x + radius);
-      const GLint ymin = (GLint) (y - radius);
-      const GLint ymax = (GLint) (y + radius);
-      GLint ix, iy;
-
-      for (iy = ymin; iy <= ymax; iy++) {
-
-         /* these might get changed by span clipping */
-         span.x = xmin;
-         span.y = iy;
-         span.end = xmax - xmin + 1;
-
-         /* compute coverage for each pixel in span */
-         for (ix = xmin; ix <= xmax; ix++) {
-            const GLfloat dx = ix - x + 0.5F;
-            const GLfloat dy = iy - y + 0.5F;
-            const GLfloat dist2 = dx * dx + dy * dy;
-            GLfloat coverage;
-
-            if (dist2 < rmax2) {
-               if (dist2 >= rmin2) {
-                  /* compute partial coverage */
-                  coverage = 1.0F - (dist2 - rmin2) * cscale;
-               }
-               else {
-                  /* full coverage */
-                  coverage = 1.0F;
-               }
-               span.array->mask[ix - xmin] = 1;
-            }
-            else {
-               /* zero coverage - fragment outside the radius */
-               coverage = 0.0;
-               span.array->mask[ix - xmin] = 0;
-            }
-            span.array->coverage[ix - xmin] = coverage;
-         }
-
-         /* render span */
-         _swrast_write_rgba_span(ctx, &span);
-
-      }
-   }
-}
-
-
-/**
- * Draw large (size >= 1) non-AA point.  RGB or CI mode.
- */
-static void
-large_point(GLcontext *ctx, const SWvertex *vert)
-{
-   SWcontext *swrast = SWRAST_CONTEXT(ctx);
-   SWspan span;
-   GLfloat size;
-
-   CULL_INVALID(vert);
-
-   /* z coord */
-   if (ctx->DrawBuffer->Visual.depthBits <= 16)
-      span.z = FloatToFixed(vert->attrib[FRAG_ATTRIB_WPOS][2] + 0.5F);
-   else
-      span.z = (GLuint) (vert->attrib[FRAG_ATTRIB_WPOS][2] + 0.5F);
-   span.zStep = 0;
-
-   size = get_size(ctx, vert, GL_FALSE);
-
-   /* span init */
-   INIT_SPAN(span, GL_POINT);
-   span.arrayMask = SPAN_XY;
-   span.facing = swrast->PointLineFacing;
-
-   span.interpMask = SPAN_Z | SPAN_RGBA;
-   span.red   = ChanToFixed(vert->color[0]);
-   span.green = ChanToFixed(vert->color[1]);
-   span.blue  = ChanToFixed(vert->color[2]);
-   span.alpha = ChanToFixed(vert->color[3]);
-   span.redStep = 0;
-   span.greenStep = 0;
-   span.blueStep = 0;
-   span.alphaStep = 0;
-
-   /* need these for fragment programs */
-   span.attrStart[FRAG_ATTRIB_WPOS][3] = 1.0F;
-   span.attrStepX[FRAG_ATTRIB_WPOS][3] = 0.0F;
-   span.attrStepY[FRAG_ATTRIB_WPOS][3] = 0.0F;
-
-   ATTRIB_LOOP_BEGIN
-      COPY_4V(span.attrStart[attr], vert->attrib[attr]);
-      ASSIGN_4V(span.attrStepX[attr], 0, 0, 0, 0);
-      ASSIGN_4V(span.attrStepY[attr], 0, 0, 0, 0);
-   ATTRIB_LOOP_END
-
-   /* compute pos, bounds and render */
-   {
-      const GLfloat x = vert->attrib[FRAG_ATTRIB_WPOS][0];
-      const GLfloat y = vert->attrib[FRAG_ATTRIB_WPOS][1];
-      GLint iSize = (GLint) (size + 0.5F);
-      GLint xmin, xmax, ymin, ymax, ix, iy;
-      GLint iRadius;
-
-      iSize = MAX2(1, iSize);
-      iRadius = iSize / 2;
-
-      if (iSize & 1) {
-         /* odd size */
-         xmin = (GLint) (x - iRadius);
-         xmax = (GLint) (x + iRadius);
-         ymin = (GLint) (y - iRadius);
-         ymax = (GLint) (y + iRadius);
-      }
-      else {
-         /* even size */
-         /* 0.501 factor allows conformance to pass */
-         xmin = (GLint) (x + 0.501) - iRadius;
-         xmax = xmin + iSize - 1;
-         ymin = (GLint) (y + 0.501) - iRadius;
-         ymax = ymin + iSize - 1;
-      }
-
-      /* generate fragments */
-      span.end = 0;
-      for (iy = ymin; iy <= ymax; iy++) {
-         for (ix = xmin; ix <= xmax; ix++) {
-            span.array->x[span.end] = ix;
-            span.array->y[span.end] = iy;
-            span.end++;
-         }
-      }
-      assert(span.end <= MAX_WIDTH);
-      _swrast_write_rgba_span(ctx, &span);
-   }
-}
-
-
-/**
- * Draw size=1, single-pixel point
- */
-static void
-pixel_point(GLcontext *ctx, const SWvertex *vert)
-{
-   SWcontext *swrast = SWRAST_CONTEXT(ctx);
-   /*
-    * Note that unlike the other functions, we put single-pixel points
-    * into a special span array in order to render as many points as
-    * possible with a single _swrast_write_rgba_span() call.
-    */
-   SWspan *span = &(swrast->PointSpan);
-   GLuint count;
-
-   CULL_INVALID(vert);
-
-   /* Span init */
-   span->interpMask = 0;
-   span->arrayMask = SPAN_XY | SPAN_Z;
-   span->arrayMask |= SPAN_RGBA;
-   /*span->arrayMask |= SPAN_LAMBDA;*/
-   span->arrayAttribs = swrast->_ActiveAttribMask; /* we'll produce these vals */
-
-   /* need these for fragment programs */
-   span->attrStart[FRAG_ATTRIB_WPOS][3] = 1.0F;
-   span->attrStepX[FRAG_ATTRIB_WPOS][3] = 0.0F;
-   span->attrStepY[FRAG_ATTRIB_WPOS][3] = 0.0F;
-
-   /* check if we need to flush */
-   if (span->end >= MAX_WIDTH ||
-       (swrast->_RasterMask & (BLEND_BIT | LOGIC_OP_BIT | MASKING_BIT)) ||
-       span->facing != swrast->PointLineFacing) {
-      if (span->end > 0) {
-	 _swrast_write_rgba_span(ctx, span);
-         span->end = 0;
-      }
-   }
-
-   count = span->end;
-
-   span->facing = swrast->PointLineFacing;
-
-   /* fragment attributes */
-   span->array->rgba[count][RCOMP] = vert->color[0];
-   span->array->rgba[count][GCOMP] = vert->color[1];
-   span->array->rgba[count][BCOMP] = vert->color[2];
-   span->array->rgba[count][ACOMP] = vert->color[3];
-
-   ATTRIB_LOOP_BEGIN
-      COPY_4V(span->array->attribs[attr][count], vert->attrib[attr]);
-   ATTRIB_LOOP_END
-
-   /* fragment position */
-   span->array->x[count] = (GLint) vert->attrib[FRAG_ATTRIB_WPOS][0];
-   span->array->y[count] = (GLint) vert->attrib[FRAG_ATTRIB_WPOS][1];
-   span->array->z[count] = (GLint) (vert->attrib[FRAG_ATTRIB_WPOS][2] + 0.5F);
-
-   span->end = count + 1;
-   ASSERT(span->end <= MAX_WIDTH);
-}
-
-
-/**
- * Add specular color to primary color, draw point, restore original
- * primary color.
- */
-void
-_swrast_add_spec_terms_point(GLcontext *ctx, const SWvertex *v0)
-{
-   SWvertex *ncv0 = (SWvertex *) v0; /* cast away const */
-   GLfloat rSum, gSum, bSum;
-   GLchan cSave[4];
-
-   /* save */
-   COPY_CHAN4(cSave, ncv0->color);
-   /* sum */
-   rSum = CHAN_TO_FLOAT(ncv0->color[0]) + ncv0->attrib[FRAG_ATTRIB_COL1][0];
-   gSum = CHAN_TO_FLOAT(ncv0->color[1]) + ncv0->attrib[FRAG_ATTRIB_COL1][1];
-   bSum = CHAN_TO_FLOAT(ncv0->color[2]) + ncv0->attrib[FRAG_ATTRIB_COL1][2];
-   UNCLAMPED_FLOAT_TO_CHAN(ncv0->color[0], rSum);
-   UNCLAMPED_FLOAT_TO_CHAN(ncv0->color[1], gSum);
-   UNCLAMPED_FLOAT_TO_CHAN(ncv0->color[2], bSum);
-   /* draw */
-   SWRAST_CONTEXT(ctx)->SpecPoint(ctx, ncv0);
-   /* restore */
-   COPY_CHAN4(ncv0->color, cSave);
-}
-
-
-/**
- * Examine current state to determine which point drawing function to use.
- */
-void
-_swrast_choose_point(GLcontext *ctx)
-{
-   SWcontext *swrast = SWRAST_CONTEXT(ctx);
-   const GLfloat size = CLAMP(ctx->Point.Size,
-                              ctx->Point.MinSize,
-                              ctx->Point.MaxSize);
-
-   if (ctx->RenderMode == GL_RENDER) {
-      if (ctx->Point.PointSprite) {
-         swrast->Point = sprite_point;
-      }
-      else if (ctx->Point.SmoothFlag) {
-         swrast->Point = smooth_point;
-      }
-      else if (size > 1.0 ||
-               ctx->Point._Attenuated ||
-               ctx->VertexProgram.PointSizeEnabled) {
-         swrast->Point = large_point;
-      }
-      else {
-         swrast->Point = pixel_point;
-      }
-   }
-   else if (ctx->RenderMode == GL_FEEDBACK) {
-      swrast->Point = _swrast_feedback_point;
-   }
-   else {
-      /* GL_SELECT mode */
-      swrast->Point = _swrast_select_point;
-   }
-}
+/*

+ * Mesa 3-D graphics library

+ * Version:  7.1

+ *

+ * Copyright (C) 1999-2007  Brian Paul   All Rights Reserved.

+ *

+ * Permission is hereby granted, free of charge, to any person obtaining a

+ * copy of this software and associated documentation files (the "Software"),

+ * to deal in the Software without restriction, including without limitation

+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,

+ * and/or sell copies of the Software, and to permit persons to whom the

+ * Software is furnished to do so, subject to the following conditions:

+ *

+ * The above copyright notice and this permission notice shall be included

+ * in all copies or substantial portions of the Software.

+ *

+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS

+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,

+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL

+ * BRIAN PAUL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN

+ * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN

+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

+ */

+

+

+#include "main/glheader.h"

+#include "main/colormac.h"

+#include "main/macros.h"

+#include "s_context.h"

+#include "s_feedback.h"

+#include "s_points.h"

+#include "s_span.h"

+

+

+/**

+ * Used to cull points with invalid coords

+ */

+#define CULL_INVALID(V)                              \

+   do {                                              \

+      float tmp = (V)->attrib[FRAG_ATTRIB_WPOS][0]   \

+                + (V)->attrib[FRAG_ATTRIB_WPOS][1];  \

+      if (IS_INF_OR_NAN(tmp))                        \

+	 return;                                     \

+   } while(0)

+

+

+

+/**

+ * Get/compute the point size.

+ * The size may come from a vertex shader, or computed with attentuation

+ * or just the glPointSize value.

+ * Must also clamp to user-defined range and implmentation limits.

+ */

+static INLINE GLfloat

+get_size(const struct gl_context *ctx, const SWvertex *vert, GLboolean smoothed)

+{

+   GLfloat size;

+

+   if (ctx->Point._Attenuated || ctx->VertexProgram.PointSizeEnabled) {

+      /* use vertex's point size */

+      size = vert->pointSize;

+   }

+   else {

+      /* use constant point size */

+      size = ctx->Point.Size;

+   }

+   /* always clamp to user-specified limits */

+   size = CLAMP(size, ctx->Point.MinSize, ctx->Point.MaxSize);

+   /* clamp to implementation limits */

+   if (smoothed)

+      size = CLAMP(size, ctx->Const.MinPointSizeAA, ctx->Const.MaxPointSizeAA);

+   else

+      size = CLAMP(size, ctx->Const.MinPointSize, ctx->Const.MaxPointSize);

+

+   return size;

+}

+

+

+/**

+ * Draw a point sprite

+ */

+static void

+sprite_point(struct gl_context *ctx, const SWvertex *vert)

+{

+   SWcontext *swrast = SWRAST_CONTEXT(ctx);

+   SWspan span;

+   GLfloat size;

+   GLuint tCoords[MAX_TEXTURE_COORD_UNITS + 1];

+   GLuint numTcoords = 0;

+   GLfloat t0, dtdy;

+

+   CULL_INVALID(vert);

+

+   /* z coord */

+   if (ctx->DrawBuffer->Visual.depthBits <= 16)

+      span.z = FloatToFixed(vert->attrib[FRAG_ATTRIB_WPOS][2] + 0.5F);

+   else

+      span.z = (GLuint) (vert->attrib[FRAG_ATTRIB_WPOS][2] + 0.5F);

+   span.zStep = 0;

+

+   size = get_size(ctx, vert, GL_FALSE);

+

+   /* span init */

+   INIT_SPAN(span, GL_POINT);

+   span.interpMask = SPAN_Z | SPAN_RGBA;

+

+   span.facing = swrast->PointLineFacing;

+

+   span.red   = ChanToFixed(vert->color[0]);

+   span.green = ChanToFixed(vert->color[1]);

+   span.blue  = ChanToFixed(vert->color[2]);

+   span.alpha = ChanToFixed(vert->color[3]);

+   span.redStep = 0;

+   span.greenStep = 0;

+   span.blueStep = 0;

+   span.alphaStep = 0;

+

+   /* need these for fragment programs */

+   span.attrStart[FRAG_ATTRIB_WPOS][3] = 1.0F;

+   span.attrStepX[FRAG_ATTRIB_WPOS][3] = 0.0F;

+   span.attrStepY[FRAG_ATTRIB_WPOS][3] = 0.0F;

+

+   {

+      GLfloat s, r, dsdx;

+

+      /* texcoord / pointcoord interpolants */

+      s = 0.0F;

+      dsdx = 1.0F / size;

+      if (ctx->Point.SpriteOrigin == GL_LOWER_LEFT) {

+         dtdy = 1.0F / size;

+         t0 = 0.5F * dtdy;

+      }

+      else {

+         /* GL_UPPER_LEFT */

+         dtdy = -1.0F / size;

+         t0 = 1.0F + 0.5F * dtdy;

+      }

+

+      ATTRIB_LOOP_BEGIN

+         if (attr >= FRAG_ATTRIB_TEX0 && attr <= FRAG_ATTRIB_TEX7) {

+            /* a texcoord attribute */

+            const GLuint u = attr - FRAG_ATTRIB_TEX0;

+            ASSERT(u < Elements(ctx->Point.CoordReplace));

+            if (ctx->Point.CoordReplace[u]) {

+               tCoords[numTcoords++] = attr;

+

+               if (ctx->Point.SpriteRMode == GL_ZERO)

+                  r = 0.0F;

+               else if (ctx->Point.SpriteRMode == GL_S)

+                  r = vert->attrib[attr][0];

+               else /* GL_R */

+                  r = vert->attrib[attr][2];

+

+               span.attrStart[attr][0] = s;

+               span.attrStart[attr][1] = 0.0; /* overwritten below */

+               span.attrStart[attr][2] = r;

+               span.attrStart[attr][3] = 1.0;

+

+               span.attrStepX[attr][0] = dsdx;

+               span.attrStepX[attr][1] = 0.0;

+               span.attrStepX[attr][2] = 0.0;

+               span.attrStepX[attr][3] = 0.0;

+

+               span.attrStepY[attr][0] = 0.0;

+               span.attrStepY[attr][1] = dtdy;

+               span.attrStepY[attr][2] = 0.0;

+               span.attrStepY[attr][3] = 0.0;

+

+               continue;

+            }

+         }

+         else if (attr == FRAG_ATTRIB_PNTC) {

+            /* GLSL gl_PointCoord.xy (.zw undefined) */

+            span.attrStart[FRAG_ATTRIB_PNTC][0] = 0.0;

+            span.attrStart[FRAG_ATTRIB_PNTC][1] = 0.0; /* t0 set below */

+            span.attrStepX[FRAG_ATTRIB_PNTC][0] = dsdx;

+            span.attrStepX[FRAG_ATTRIB_PNTC][1] = 0.0;

+            span.attrStepY[FRAG_ATTRIB_PNTC][0] = 0.0;

+            span.attrStepY[FRAG_ATTRIB_PNTC][1] = dtdy;

+            tCoords[numTcoords++] = FRAG_ATTRIB_PNTC;

+            continue;

+         }

+         /* use vertex's texcoord/attrib */

+         COPY_4V(span.attrStart[attr], vert->attrib[attr]);

+         ASSIGN_4V(span.attrStepX[attr], 0, 0, 0, 0);

+         ASSIGN_4V(span.attrStepY[attr], 0, 0, 0, 0);

+      ATTRIB_LOOP_END;

+   }

+

+   /* compute pos, bounds and render */

+   {

+      const GLfloat x = vert->attrib[FRAG_ATTRIB_WPOS][0];

+      const GLfloat y = vert->attrib[FRAG_ATTRIB_WPOS][1];

+      GLint iSize = (GLint) (size + 0.5F);

+      GLint xmin, xmax, ymin, ymax, iy;

+      GLint iRadius;

+      GLfloat tcoord = t0;

+

+      iSize = MAX2(1, iSize);

+      iRadius = iSize / 2;

+

+      if (iSize & 1) {

+         /* odd size */

+         xmin = (GLint) (x - iRadius);

+         xmax = (GLint) (x + iRadius);

+         ymin = (GLint) (y - iRadius);

+         ymax = (GLint) (y + iRadius);

+      }

+      else {

+         /* even size */

+         /* 0.501 factor allows conformance to pass */

+         xmin = (GLint) (x + 0.501) - iRadius;

+         xmax = xmin + iSize - 1;

+         ymin = (GLint) (y + 0.501) - iRadius;

+         ymax = ymin + iSize - 1;

+      }

+

+      /* render spans */

+      for (iy = ymin; iy <= ymax; iy++) {

+         GLuint i;

+         /* setup texcoord T for this row */

+         for (i = 0; i < numTcoords; i++) {

+            span.attrStart[tCoords[i]][1] = tcoord;

+         }

+

+         /* these might get changed by span clipping */

+         span.x = xmin;

+         span.y = iy;

+         span.end = xmax - xmin + 1;

+

+         _swrast_write_rgba_span(ctx, &span);

+

+         tcoord += dtdy;

+      }

+   }

+}

+

+

+/**

+ * Draw smooth/antialiased point.  RGB or CI mode.

+ */

+static void

+smooth_point(struct gl_context *ctx, const SWvertex *vert)

+{

+   SWcontext *swrast = SWRAST_CONTEXT(ctx);

+   SWspan span;

+   GLfloat size, alphaAtten;

+

+   CULL_INVALID(vert);

+

+   /* z coord */

+   if (ctx->DrawBuffer->Visual.depthBits <= 16)

+      span.z = FloatToFixed(vert->attrib[FRAG_ATTRIB_WPOS][2] + 0.5F);

+   else

+      span.z = (GLuint) (vert->attrib[FRAG_ATTRIB_WPOS][2] + 0.5F);

+   span.zStep = 0;

+

+   size = get_size(ctx, vert, GL_TRUE);

+

+   /* alpha attenuation / fade factor */

+   if (ctx->Multisample._Enabled) {

+      if (vert->pointSize >= ctx->Point.Threshold) {

+         alphaAtten = 1.0F;

+      }

+      else {

+         GLfloat dsize = vert->pointSize / ctx->Point.Threshold;

+         alphaAtten = dsize * dsize;

+      }

+   }

+   else {

+      alphaAtten = 1.0;

+   }

+   (void) alphaAtten; /* not used */

+

+   /* span init */

+   INIT_SPAN(span, GL_POINT);

+   span.interpMask = SPAN_Z | SPAN_RGBA;

+   span.arrayMask = SPAN_COVERAGE | SPAN_MASK;

+

+   span.facing = swrast->PointLineFacing;

+

+   span.red   = ChanToFixed(vert->color[0]);

+   span.green = ChanToFixed(vert->color[1]);

+   span.blue  = ChanToFixed(vert->color[2]);

+   span.alpha = ChanToFixed(vert->color[3]);

+   span.redStep = 0;

+   span.greenStep = 0;

+   span.blueStep = 0;

+   span.alphaStep = 0;

+

+   /* need these for fragment programs */

+   span.attrStart[FRAG_ATTRIB_WPOS][3] = 1.0F;

+   span.attrStepX[FRAG_ATTRIB_WPOS][3] = 0.0F;

+   span.attrStepY[FRAG_ATTRIB_WPOS][3] = 0.0F;

+

+   ATTRIB_LOOP_BEGIN

+      COPY_4V(span.attrStart[attr], vert->attrib[attr]);

+      ASSIGN_4V(span.attrStepX[attr], 0, 0, 0, 0);

+      ASSIGN_4V(span.attrStepY[attr], 0, 0, 0, 0);

+   ATTRIB_LOOP_END

+

+   /* compute pos, bounds and render */

+   {

+      const GLfloat x = vert->attrib[FRAG_ATTRIB_WPOS][0];

+      const GLfloat y = vert->attrib[FRAG_ATTRIB_WPOS][1];

+      const GLfloat radius = 0.5F * size;

+      const GLfloat rmin = radius - 0.7071F;  /* 0.7071 = sqrt(2)/2 */

+      const GLfloat rmax = radius + 0.7071F;

+      const GLfloat rmin2 = MAX2(0.0F, rmin * rmin);

+      const GLfloat rmax2 = rmax * rmax;

+      const GLfloat cscale = 1.0F / (rmax2 - rmin2);

+      const GLint xmin = (GLint) (x - radius);

+      const GLint xmax = (GLint) (x + radius);

+      const GLint ymin = (GLint) (y - radius);

+      const GLint ymax = (GLint) (y + radius);

+      GLint ix, iy;

+

+      for (iy = ymin; iy <= ymax; iy++) {

+

+         /* these might get changed by span clipping */

+         span.x = xmin;

+         span.y = iy;

+         span.end = xmax - xmin + 1;

+

+         /* compute coverage for each pixel in span */

+         for (ix = xmin; ix <= xmax; ix++) {

+            const GLfloat dx = ix - x + 0.5F;

+            const GLfloat dy = iy - y + 0.5F;

+            const GLfloat dist2 = dx * dx + dy * dy;

+            GLfloat coverage;

+

+            if (dist2 < rmax2) {

+               if (dist2 >= rmin2) {

+                  /* compute partial coverage */

+                  coverage = 1.0F - (dist2 - rmin2) * cscale;

+               }

+               else {

+                  /* full coverage */

+                  coverage = 1.0F;

+               }

+               span.array->mask[ix - xmin] = 1;

+            }

+            else {

+               /* zero coverage - fragment outside the radius */

+               coverage = 0.0;

+               span.array->mask[ix - xmin] = 0;

+            }

+            span.array->coverage[ix - xmin] = coverage;

+         }

+

+         /* render span */

+         _swrast_write_rgba_span(ctx, &span);

+

+      }

+   }

+}

+

+

+/**

+ * Draw large (size >= 1) non-AA point.  RGB or CI mode.

+ */

+static void

+large_point(struct gl_context *ctx, const SWvertex *vert)

+{

+   SWcontext *swrast = SWRAST_CONTEXT(ctx);

+   SWspan span;

+   GLfloat size;

+

+   CULL_INVALID(vert);

+

+   /* z coord */

+   if (ctx->DrawBuffer->Visual.depthBits <= 16)

+      span.z = FloatToFixed(vert->attrib[FRAG_ATTRIB_WPOS][2] + 0.5F);

+   else

+      span.z = (GLuint) (vert->attrib[FRAG_ATTRIB_WPOS][2] + 0.5F);

+   span.zStep = 0;

+

+   size = get_size(ctx, vert, GL_FALSE);

+

+   /* span init */

+   INIT_SPAN(span, GL_POINT);

+   span.arrayMask = SPAN_XY;

+   span.facing = swrast->PointLineFacing;

+

+   span.interpMask = SPAN_Z | SPAN_RGBA;

+   span.red   = ChanToFixed(vert->color[0]);

+   span.green = ChanToFixed(vert->color[1]);

+   span.blue  = ChanToFixed(vert->color[2]);

+   span.alpha = ChanToFixed(vert->color[3]);

+   span.redStep = 0;

+   span.greenStep = 0;

+   span.blueStep = 0;

+   span.alphaStep = 0;

+

+   /* need these for fragment programs */

+   span.attrStart[FRAG_ATTRIB_WPOS][3] = 1.0F;

+   span.attrStepX[FRAG_ATTRIB_WPOS][3] = 0.0F;

+   span.attrStepY[FRAG_ATTRIB_WPOS][3] = 0.0F;

+

+   ATTRIB_LOOP_BEGIN

+      COPY_4V(span.attrStart[attr], vert->attrib[attr]);

+      ASSIGN_4V(span.attrStepX[attr], 0, 0, 0, 0);

+      ASSIGN_4V(span.attrStepY[attr], 0, 0, 0, 0);

+   ATTRIB_LOOP_END

+

+   /* compute pos, bounds and render */

+   {

+      const GLfloat x = vert->attrib[FRAG_ATTRIB_WPOS][0];

+      const GLfloat y = vert->attrib[FRAG_ATTRIB_WPOS][1];

+      GLint iSize = (GLint) (size + 0.5F);

+      GLint xmin, xmax, ymin, ymax, ix, iy;

+      GLint iRadius;

+

+      iSize = MAX2(1, iSize);

+      iRadius = iSize / 2;

+

+      if (iSize & 1) {

+         /* odd size */

+         xmin = (GLint) (x - iRadius);

+         xmax = (GLint) (x + iRadius);

+         ymin = (GLint) (y - iRadius);

+         ymax = (GLint) (y + iRadius);

+      }

+      else {

+         /* even size */

+         /* 0.501 factor allows conformance to pass */

+         xmin = (GLint) (x + 0.501) - iRadius;

+         xmax = xmin + iSize - 1;

+         ymin = (GLint) (y + 0.501) - iRadius;

+         ymax = ymin + iSize - 1;

+      }

+

+      /* generate fragments */

+      span.end = 0;

+      for (iy = ymin; iy <= ymax; iy++) {

+         for (ix = xmin; ix <= xmax; ix++) {

+            span.array->x[span.end] = ix;

+            span.array->y[span.end] = iy;

+            span.end++;

+         }

+      }

+      assert(span.end <= MAX_WIDTH);

+      _swrast_write_rgba_span(ctx, &span);

+   }

+}

+

+

+/**

+ * Draw size=1, single-pixel point

+ */

+static void

+pixel_point(struct gl_context *ctx, const SWvertex *vert)

+{

+   SWcontext *swrast = SWRAST_CONTEXT(ctx);

+   /*

+    * Note that unlike the other functions, we put single-pixel points

+    * into a special span array in order to render as many points as

+    * possible with a single _swrast_write_rgba_span() call.

+    */

+   SWspan *span = &(swrast->PointSpan);

+   GLuint count;

+

+   CULL_INVALID(vert);

+

+   /* Span init */

+   span->interpMask = 0;

+   span->arrayMask = SPAN_XY | SPAN_Z;

+   span->arrayMask |= SPAN_RGBA;

+   /*span->arrayMask |= SPAN_LAMBDA;*/

+   span->arrayAttribs = swrast->_ActiveAttribMask; /* we'll produce these vals */

+

+   /* need these for fragment programs */

+   span->attrStart[FRAG_ATTRIB_WPOS][3] = 1.0F;

+   span->attrStepX[FRAG_ATTRIB_WPOS][3] = 0.0F;

+   span->attrStepY[FRAG_ATTRIB_WPOS][3] = 0.0F;

+

+   /* check if we need to flush */

+   if (span->end >= MAX_WIDTH ||

+       (swrast->_RasterMask & (BLEND_BIT | LOGIC_OP_BIT | MASKING_BIT)) ||

+       span->facing != swrast->PointLineFacing) {

+      if (span->end > 0) {

+	 _swrast_write_rgba_span(ctx, span);

+         span->end = 0;

+      }

+   }

+

+   count = span->end;

+

+   span->facing = swrast->PointLineFacing;

+

+   /* fragment attributes */

+   span->array->rgba[count][RCOMP] = vert->color[0];

+   span->array->rgba[count][GCOMP] = vert->color[1];

+   span->array->rgba[count][BCOMP] = vert->color[2];

+   span->array->rgba[count][ACOMP] = vert->color[3];

+

+   ATTRIB_LOOP_BEGIN

+      COPY_4V(span->array->attribs[attr][count], vert->attrib[attr]);

+   ATTRIB_LOOP_END

+

+   /* fragment position */

+   span->array->x[count] = (GLint) vert->attrib[FRAG_ATTRIB_WPOS][0];

+   span->array->y[count] = (GLint) vert->attrib[FRAG_ATTRIB_WPOS][1];

+   span->array->z[count] = (GLint) (vert->attrib[FRAG_ATTRIB_WPOS][2] + 0.5F);

+

+   span->end = count + 1;

+   ASSERT(span->end <= MAX_WIDTH);

+}

+

+

+/**

+ * Add specular color to primary color, draw point, restore original

+ * primary color.

+ */

+void

+_swrast_add_spec_terms_point(struct gl_context *ctx, const SWvertex *v0)

+{

+   SWvertex *ncv0 = (SWvertex *) v0; /* cast away const */

+   GLfloat rSum, gSum, bSum;

+   GLchan cSave[4];

+

+   /* save */

+   COPY_CHAN4(cSave, ncv0->color);

+   /* sum */

+   rSum = CHAN_TO_FLOAT(ncv0->color[0]) + ncv0->attrib[FRAG_ATTRIB_COL1][0];

+   gSum = CHAN_TO_FLOAT(ncv0->color[1]) + ncv0->attrib[FRAG_ATTRIB_COL1][1];

+   bSum = CHAN_TO_FLOAT(ncv0->color[2]) + ncv0->attrib[FRAG_ATTRIB_COL1][2];

+   UNCLAMPED_FLOAT_TO_CHAN(ncv0->color[0], rSum);

+   UNCLAMPED_FLOAT_TO_CHAN(ncv0->color[1], gSum);

+   UNCLAMPED_FLOAT_TO_CHAN(ncv0->color[2], bSum);

+   /* draw */

+   SWRAST_CONTEXT(ctx)->SpecPoint(ctx, ncv0);

+   /* restore */

+   COPY_CHAN4(ncv0->color, cSave);

+}

+

+

+/**

+ * Examine current state to determine which point drawing function to use.

+ */

+void

+_swrast_choose_point(struct gl_context *ctx)

+{

+   SWcontext *swrast = SWRAST_CONTEXT(ctx);

+   const GLfloat size = CLAMP(ctx->Point.Size,

+                              ctx->Point.MinSize,

+                              ctx->Point.MaxSize);

+

+   if (ctx->RenderMode == GL_RENDER) {

+      if (ctx->Point.PointSprite) {

+         swrast->Point = sprite_point;

+      }

+      else if (ctx->Point.SmoothFlag) {

+         swrast->Point = smooth_point;

+      }

+      else if (size > 1.0 ||

+               ctx->Point._Attenuated ||

+               ctx->VertexProgram.PointSizeEnabled) {

+         swrast->Point = large_point;

+      }

+      else {

+         swrast->Point = pixel_point;

+      }

+   }

+   else if (ctx->RenderMode == GL_FEEDBACK) {

+      swrast->Point = _swrast_feedback_point;

+   }

+   else {

+      /* GL_SELECT mode */

+      swrast->Point = _swrast_select_point;

+   }

+}