xserver and mesa git update 28-12-2010

55 files changed, 22680 insertions, 22796 deletions

diff --git a/mesalib/src/mesa/swrast/NOTES b/mesalib/src/mesa/swrast/NOTES
new file mode 100644
index 000000000..d6f991ee8
--- /dev/null
+++ b/mesalib/src/mesa/swrast/NOTES
@@ -0,0 +1,55 @@
+INTRODUCTION

+

+Mesa's native software rasterizer.  This module provides the fallback

+paths for rasterization operations and states that aren't accelerated

+in hardware drivers, and as the full rasterization engine in software

+drivers.

+

+The swrast module 'stands alone', relying only on interfaces to core

+mesa and it's own driver interface.  It knows nothing about the tnl or

+other modules, allowing it to be used for fallback paths in future tnl

+schemes without modification.

+

+As well as providing triangle/line/point rasterization functionality,

+the module provides implementations of the pixel operations

+(ReadPixels, etc), and texture operations (CopyTexSubImage) which may

+be plugged in to the core Mesa driver interface where accelerated

+versions of these operations are unavailable.

+

+

+STATE

+

+To create and destroy the module:

+

+	GLboolean _swrast_CreateContext( struct gl_context *ctx );

+	void _swrast_DestroyContext( struct gl_context *ctx );

+   

+This module tracks state changes internally and maintains derived

+values based on the current state.  For this to work, the driver

+ensure the following funciton is called whenever the state changes and

+the swsetup module is 'awake':

+

+	void _swrast_InvalidateState( struct gl_context *ctx, GLuint new_state );

+

+There is no explicit call to put the swrast module to sleep.  

+

+

+CUSTOMIZATION

+

+   void (*choose_point)( struct gl_context * );

+   void (*choose_line)( struct gl_context * );

+   void (*choose_triangle)( struct gl_context * );

+

+Drivers may add additional triangle/line/point functions to swrast by

+overriding these functions.  It is necessary for the driver to be very

+careful that it doesn't return an inappropriate function, eg a

+rasterization function in feedback mode.  See the X11 driver for

+examples.

+

+DRIVER INTERFACE

+

+The swrast device driver provides swrast primarily with span- and

+pixel- level interfaces to a framebuffer, with a few additional hooks

+for locking and setting the read buffer.

+

+See the definition of struct swrast_device_driver in swrast.h.
\ No newline at end of file
diff --git a/mesalib/src/mesa/swrast/s_aaline.c b/mesalib/src/mesa/swrast/s_aaline.c
index 6ba4604e6..be817f326 100644
--- a/mesalib/src/mesa/swrast/s_aaline.c
+++ b/mesalib/src/mesa/swrast/s_aaline.c
@@ -1,492 +1,492 @@
-/*
- * Mesa 3-D graphics library
- * Version:  6.5.3
- *
- * 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/imports.h"
-#include "main/macros.h"
-#include "main/mtypes.h"
-#include "swrast/s_aaline.h"
-#include "swrast/s_context.h"
-#include "swrast/s_span.h"
-#include "swrast/swrast.h"
-
-
-#define SUB_PIXEL 4
-
-
-/*
- * Info about the AA line we're rendering
- */
-struct LineInfo
-{
-   GLfloat x0, y0;        /* start */
-   GLfloat x1, y1;        /* end */
-   GLfloat dx, dy;        /* direction vector */
-   GLfloat len;           /* length */
-   GLfloat halfWidth;     /* half of line width */
-   GLfloat xAdj, yAdj;    /* X and Y adjustment for quad corners around line */
-   /* for coverage computation */
-   GLfloat qx0, qy0;      /* quad vertices */
-   GLfloat qx1, qy1;
-   GLfloat qx2, qy2;
-   GLfloat qx3, qy3;
-   GLfloat ex0, ey0;      /* quad edge vectors */
-   GLfloat ex1, ey1;
-   GLfloat ex2, ey2;
-   GLfloat ex3, ey3;
-
-   /* DO_Z */
-   GLfloat zPlane[4];
-   /* DO_RGBA - always enabled */
-   GLfloat rPlane[4], gPlane[4], bPlane[4], aPlane[4];
-   /* DO_ATTRIBS */
-   GLfloat wPlane[4];
-   GLfloat attrPlane[FRAG_ATTRIB_MAX][4][4];
-   GLfloat lambda[FRAG_ATTRIB_MAX];
-   GLfloat texWidth[FRAG_ATTRIB_MAX];
-   GLfloat texHeight[FRAG_ATTRIB_MAX];
-
-   SWspan span;
-};
-
-
-
-/*
- * Compute the equation of a plane used to interpolate line fragment data
- * such as color, Z, texture coords, etc.
- * Input: (x0, y0) and (x1,y1) are the endpoints of the line.
- *        z0, and z1 are the end point values to interpolate.
- * Output:  plane - the plane equation.
- *
- * Note: we don't really have enough parameters to specify a plane.
- * We take the endpoints of the line and compute a plane such that
- * the cross product of the line vector and the plane normal is
- * parallel to the projection plane.
- */
-static void
-compute_plane(GLfloat x0, GLfloat y0, GLfloat x1, GLfloat y1,
-              GLfloat z0, GLfloat z1, GLfloat plane[4])
-{
-#if 0
-   /* original */
-   const GLfloat px = x1 - x0;
-   const GLfloat py = y1 - y0;
-   const GLfloat pz = z1 - z0;
-   const GLfloat qx = -py;
-   const GLfloat qy = px;
-   const GLfloat qz = 0;
-   const GLfloat a = py * qz - pz * qy;
-   const GLfloat b = pz * qx - px * qz;
-   const GLfloat c = px * qy - py * qx;
-   const GLfloat d = -(a * x0 + b * y0 + c * z0);
-   plane[0] = a;
-   plane[1] = b;
-   plane[2] = c;
-   plane[3] = d;
-#else
-   /* simplified */
-   const GLfloat px = x1 - x0;
-   const GLfloat py = y1 - y0;
-   const GLfloat pz = z0 - z1;
-   const GLfloat a = pz * px;
-   const GLfloat b = pz * py;
-   const GLfloat c = px * px + py * py;
-   const GLfloat d = -(a * x0 + b * y0 + c * z0);
-   if (a == 0.0 && b == 0.0 && c == 0.0 && d == 0.0) {
-      plane[0] = 0.0;
-      plane[1] = 0.0;
-      plane[2] = 1.0;
-      plane[3] = 0.0;
-   }
-   else {
-      plane[0] = a;
-      plane[1] = b;
-      plane[2] = c;
-      plane[3] = d;
-   }
-#endif
-}
-
-
-static INLINE void
-constant_plane(GLfloat value, GLfloat plane[4])
-{
-   plane[0] = 0.0;
-   plane[1] = 0.0;
-   plane[2] = -1.0;
-   plane[3] = value;
-}
-
-
-static INLINE GLfloat
-solve_plane(GLfloat x, GLfloat y, const GLfloat plane[4])
-{
-   const GLfloat z = (plane[3] + plane[0] * x + plane[1] * y) / -plane[2];
-   return z;
-}
-
-#define SOLVE_PLANE(X, Y, PLANE) \
-   ((PLANE[3] + PLANE[0] * (X) + PLANE[1] * (Y)) / -PLANE[2])
-
-
-/*
- * Return 1 / solve_plane().
- */
-static INLINE GLfloat
-solve_plane_recip(GLfloat x, GLfloat y, const GLfloat plane[4])
-{
-   const GLfloat denom = plane[3] + plane[0] * x + plane[1] * y;
-   if (denom == 0.0)
-      return 0.0;
-   else
-      return -plane[2] / denom;
-}
-
-
-/*
- * Solve plane and return clamped GLchan value.
- */
-static INLINE GLchan
-solve_plane_chan(GLfloat x, GLfloat y, const GLfloat plane[4])
-{
-   const GLfloat z = (plane[3] + plane[0] * x + plane[1] * y) / -plane[2];
-#if CHAN_TYPE == GL_FLOAT
-   return CLAMP(z, 0.0F, CHAN_MAXF);
-#else
-   if (z < 0)
-      return 0;
-   else if (z > CHAN_MAX)
-      return CHAN_MAX;
-   return (GLchan) IROUND_POS(z);
-#endif
-}
-
-
-/*
- * Compute mipmap level of detail.
- */
-static INLINE GLfloat
-compute_lambda(const GLfloat sPlane[4], const GLfloat tPlane[4],
-               GLfloat invQ, GLfloat width, GLfloat height)
-{
-   GLfloat dudx = sPlane[0] / sPlane[2] * invQ * width;
-   GLfloat dudy = sPlane[1] / sPlane[2] * invQ * width;
-   GLfloat dvdx = tPlane[0] / tPlane[2] * invQ * height;
-   GLfloat dvdy = tPlane[1] / tPlane[2] * invQ * height;
-   GLfloat r1 = dudx * dudx + dudy * dudy;
-   GLfloat r2 = dvdx * dvdx + dvdy * dvdy;
-   GLfloat rho2 = r1 + r2;
-   /* return log base 2 of rho */
-   if (rho2 == 0.0F)
-      return 0.0;
-   else
-      return (GLfloat) (LOGF(rho2) * 1.442695 * 0.5);/* 1.442695 = 1/log(2) */
-}
-
-
-
-
-/*
- * Fill in the samples[] array with the (x,y) subpixel positions of
- * xSamples * ySamples sample positions.
- * Note that the four corner samples are put into the first four
- * positions of the array.  This allows us to optimize for the common
- * case of all samples being inside the polygon.
- */
-static void
-make_sample_table(GLint xSamples, GLint ySamples, GLfloat samples[][2])
-{
-   const GLfloat dx = 1.0F / (GLfloat) xSamples;
-   const GLfloat dy = 1.0F / (GLfloat) ySamples;
-   GLint x, y;
-   GLint i;
-
-   i = 4;
-   for (x = 0; x < xSamples; x++) {
-      for (y = 0; y < ySamples; y++) {
-         GLint j;
-         if (x == 0 && y == 0) {
-            /* lower left */
-            j = 0;
-         }
-         else if (x == xSamples - 1 && y == 0) {
-            /* lower right */
-            j = 1;
-         }
-         else if (x == 0 && y == ySamples - 1) {
-            /* upper left */
-            j = 2;
-         }
-         else if (x == xSamples - 1 && y == ySamples - 1) {
-            /* upper right */
-            j = 3;
-         }
-         else {
-            j = i++;
-         }
-         samples[j][0] = x * dx + 0.5F * dx;
-         samples[j][1] = y * dy + 0.5F * dy;
-      }
-   }
-}
-
-
-
-/*
- * Compute how much of the given pixel's area is inside the rectangle
- * defined by vertices v0, v1, v2, v3.
- * Vertices MUST be specified in counter-clockwise order.
- * Return:  coverage in [0, 1].
- */
-static GLfloat
-compute_coveragef(const struct LineInfo *info,
-                  GLint winx, GLint winy)
-{
-   static GLfloat samples[SUB_PIXEL * SUB_PIXEL][2];
-   static GLboolean haveSamples = GL_FALSE;
-   const GLfloat x = (GLfloat) winx;
-   const GLfloat y = (GLfloat) winy;
-   GLint stop = 4, i;
-   GLfloat insideCount = SUB_PIXEL * SUB_PIXEL;
-
-   if (!haveSamples) {
-      make_sample_table(SUB_PIXEL, SUB_PIXEL, samples);
-      haveSamples = GL_TRUE;
-   }
-
-#if 0 /*DEBUG*/
-   {
-      const GLfloat area = dx0 * dy1 - dx1 * dy0;
-      assert(area >= 0.0);
-   }
-#endif
-
-   for (i = 0; i < stop; i++) {
-      const GLfloat sx = x + samples[i][0];
-      const GLfloat sy = y + samples[i][1];
-      const GLfloat fx0 = sx - info->qx0;
-      const GLfloat fy0 = sy - info->qy0;
-      const GLfloat fx1 = sx - info->qx1;
-      const GLfloat fy1 = sy - info->qy1;
-      const GLfloat fx2 = sx - info->qx2;
-      const GLfloat fy2 = sy - info->qy2;
-      const GLfloat fx3 = sx - info->qx3;
-      const GLfloat fy3 = sy - info->qy3;
-      /* cross product determines if sample is inside or outside each edge */
-      GLfloat cross0 = (info->ex0 * fy0 - info->ey0 * fx0);
-      GLfloat cross1 = (info->ex1 * fy1 - info->ey1 * fx1);
-      GLfloat cross2 = (info->ex2 * fy2 - info->ey2 * fx2);
-      GLfloat cross3 = (info->ex3 * fy3 - info->ey3 * fx3);
-      /* Check if the sample is exactly on an edge.  If so, let cross be a
-       * positive or negative value depending on the direction of the edge.
-       */
-      if (cross0 == 0.0F)
-         cross0 = info->ex0 + info->ey0;
-      if (cross1 == 0.0F)
-         cross1 = info->ex1 + info->ey1;
-      if (cross2 == 0.0F)
-         cross2 = info->ex2 + info->ey2;
-      if (cross3 == 0.0F)
-         cross3 = info->ex3 + info->ey3;
-      if (cross0 < 0.0F || cross1 < 0.0F || cross2 < 0.0F || cross3 < 0.0F) {
-         /* point is outside quadrilateral */
-         insideCount -= 1.0F;
-         stop = SUB_PIXEL * SUB_PIXEL;
-      }
-   }
-   if (stop == 4)
-      return 1.0F;
-   else
-      return insideCount * (1.0F / (SUB_PIXEL * SUB_PIXEL));
-}
-
-
-typedef void (*plot_func)(GLcontext *ctx, struct LineInfo *line,
-                          int ix, int iy);
-                         
-
-
-/*
- * Draw an AA line segment (called many times per line when stippling)
- */
-static void
-segment(GLcontext *ctx,
-        struct LineInfo *line,
-        plot_func plot,
-        GLfloat t0, GLfloat t1)
-{
-   const GLfloat absDx = (line->dx < 0.0F) ? -line->dx : line->dx;
-   const GLfloat absDy = (line->dy < 0.0F) ? -line->dy : line->dy;
-   /* compute the actual segment's endpoints */
-   const GLfloat x0 = line->x0 + t0 * line->dx;
-   const GLfloat y0 = line->y0 + t0 * line->dy;
-   const GLfloat x1 = line->x0 + t1 * line->dx;
-   const GLfloat y1 = line->y0 + t1 * line->dy;
-
-   /* compute vertices of the line-aligned quadrilateral */
-   line->qx0 = x0 - line->yAdj;
-   line->qy0 = y0 + line->xAdj;
-   line->qx1 = x0 + line->yAdj;
-   line->qy1 = y0 - line->xAdj;
-   line->qx2 = x1 + line->yAdj;
-   line->qy2 = y1 - line->xAdj;
-   line->qx3 = x1 - line->yAdj;
-   line->qy3 = y1 + line->xAdj;
-   /* compute the quad's edge vectors (for coverage calc) */
-   line->ex0 = line->qx1 - line->qx0;
-   line->ey0 = line->qy1 - line->qy0;
-   line->ex1 = line->qx2 - line->qx1;
-   line->ey1 = line->qy2 - line->qy1;
-   line->ex2 = line->qx3 - line->qx2;
-   line->ey2 = line->qy3 - line->qy2;
-   line->ex3 = line->qx0 - line->qx3;
-   line->ey3 = line->qy0 - line->qy3;
-
-   if (absDx > absDy) {
-      /* X-major line */
-      GLfloat dydx = line->dy / line->dx;
-      GLfloat xLeft, xRight, yBot, yTop;
-      GLint ix, ixRight;
-      if (x0 < x1) {
-         xLeft = x0 - line->halfWidth;
-         xRight = x1 + line->halfWidth;
-         if (line->dy >= 0.0) {
-            yBot = y0 - 3.0F * line->halfWidth;
-            yTop = y0 + line->halfWidth;
-         }
-         else {
-            yBot = y0 - line->halfWidth;
-            yTop = y0 + 3.0F * line->halfWidth;
-         }
-      }
-      else {
-         xLeft = x1 - line->halfWidth;
-         xRight = x0 + line->halfWidth;
-         if (line->dy <= 0.0) {
-            yBot = y1 - 3.0F * line->halfWidth;
-            yTop = y1 + line->halfWidth;
-         }
-         else {
-            yBot = y1 - line->halfWidth;
-            yTop = y1 + 3.0F * line->halfWidth;
-         }
-      }
-
-      /* scan along the line, left-to-right */
-      ixRight = (GLint) (xRight + 1.0F);
-
-      /*printf("avg span height: %g\n", yTop - yBot);*/
-      for (ix = (GLint) xLeft; ix < ixRight; ix++) {
-         const GLint iyBot = (GLint) yBot;
-         const GLint iyTop = (GLint) (yTop + 1.0F);
-         GLint iy;
-         /* scan across the line, bottom-to-top */
-         for (iy = iyBot; iy < iyTop; iy++) {
-            (*plot)(ctx, line, ix, iy);
-         }
-         yBot += dydx;
-         yTop += dydx;
-      }
-   }
-   else {
-      /* Y-major line */
-      GLfloat dxdy = line->dx / line->dy;
-      GLfloat yBot, yTop, xLeft, xRight;
-      GLint iy, iyTop;
-      if (y0 < y1) {
-         yBot = y0 - line->halfWidth;
-         yTop = y1 + line->halfWidth;
-         if (line->dx >= 0.0) {
-            xLeft = x0 - 3.0F * line->halfWidth;
-            xRight = x0 + line->halfWidth;
-         }
-         else {
-            xLeft = x0 - line->halfWidth;
-            xRight = x0 + 3.0F * line->halfWidth;
-         }
-      }
-      else {
-         yBot = y1 - line->halfWidth;
-         yTop = y0 + line->halfWidth;
-         if (line->dx <= 0.0) {
-            xLeft = x1 - 3.0F * line->halfWidth;
-            xRight = x1 + line->halfWidth;
-         }
-         else {
-            xLeft = x1 - line->halfWidth;
-            xRight = x1 + 3.0F * line->halfWidth;
-         }
-      }
-
-      /* scan along the line, bottom-to-top */
-      iyTop = (GLint) (yTop + 1.0F);
-
-      /*printf("avg span width: %g\n", xRight - xLeft);*/
-      for (iy = (GLint) yBot; iy < iyTop; iy++) {
-         const GLint ixLeft = (GLint) xLeft;
-         const GLint ixRight = (GLint) (xRight + 1.0F);
-         GLint ix;
-         /* scan across the line, left-to-right */
-         for (ix = ixLeft; ix < ixRight; ix++) {
-            (*plot)(ctx, line, ix, iy);
-         }
-         xLeft += dxdy;
-         xRight += dxdy;
-      }
-   }
-}
-
-
-#define NAME(x) aa_rgba_##x
-#define DO_Z
-#include "s_aalinetemp.h"
-
-
-#define NAME(x)  aa_general_rgba_##x
-#define DO_Z
-#define DO_ATTRIBS
-#include "s_aalinetemp.h"
-
-
-
-void
-_swrast_choose_aa_line_function(GLcontext *ctx)
-{
-   SWcontext *swrast = SWRAST_CONTEXT(ctx);
-
-   ASSERT(ctx->Line.SmoothFlag);
-
-   if (ctx->Texture._EnabledCoordUnits != 0
-       || ctx->FragmentProgram._Current
-       || (ctx->Light.Enabled &&
-           ctx->Light.Model.ColorControl == GL_SEPARATE_SPECULAR_COLOR)
-       || ctx->Fog.ColorSumEnabled
-       || swrast->_FogEnabled) {
-      swrast->Line = aa_general_rgba_line;
-   }
-   else {
-      swrast->Line = aa_rgba_line;
-   }
-}
+/*

+ * Mesa 3-D graphics library

+ * Version:  6.5.3

+ *

+ * 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/imports.h"

+#include "main/macros.h"

+#include "main/mtypes.h"

+#include "swrast/s_aaline.h"

+#include "swrast/s_context.h"

+#include "swrast/s_span.h"

+#include "swrast/swrast.h"

+

+

+#define SUB_PIXEL 4

+

+

+/*

+ * Info about the AA line we're rendering

+ */

+struct LineInfo

+{

+   GLfloat x0, y0;        /* start */

+   GLfloat x1, y1;        /* end */

+   GLfloat dx, dy;        /* direction vector */

+   GLfloat len;           /* length */

+   GLfloat halfWidth;     /* half of line width */

+   GLfloat xAdj, yAdj;    /* X and Y adjustment for quad corners around line */

+   /* for coverage computation */

+   GLfloat qx0, qy0;      /* quad vertices */

+   GLfloat qx1, qy1;

+   GLfloat qx2, qy2;

+   GLfloat qx3, qy3;

+   GLfloat ex0, ey0;      /* quad edge vectors */

+   GLfloat ex1, ey1;

+   GLfloat ex2, ey2;

+   GLfloat ex3, ey3;

+

+   /* DO_Z */

+   GLfloat zPlane[4];

+   /* DO_RGBA - always enabled */

+   GLfloat rPlane[4], gPlane[4], bPlane[4], aPlane[4];

+   /* DO_ATTRIBS */

+   GLfloat wPlane[4];

+   GLfloat attrPlane[FRAG_ATTRIB_MAX][4][4];

+   GLfloat lambda[FRAG_ATTRIB_MAX];

+   GLfloat texWidth[FRAG_ATTRIB_MAX];

+   GLfloat texHeight[FRAG_ATTRIB_MAX];

+

+   SWspan span;

+};

+

+

+

+/*

+ * Compute the equation of a plane used to interpolate line fragment data

+ * such as color, Z, texture coords, etc.

+ * Input: (x0, y0) and (x1,y1) are the endpoints of the line.

+ *        z0, and z1 are the end point values to interpolate.

+ * Output:  plane - the plane equation.

+ *

+ * Note: we don't really have enough parameters to specify a plane.

+ * We take the endpoints of the line and compute a plane such that

+ * the cross product of the line vector and the plane normal is

+ * parallel to the projection plane.

+ */

+static void

+compute_plane(GLfloat x0, GLfloat y0, GLfloat x1, GLfloat y1,

+              GLfloat z0, GLfloat z1, GLfloat plane[4])

+{

+#if 0

+   /* original */

+   const GLfloat px = x1 - x0;

+   const GLfloat py = y1 - y0;

+   const GLfloat pz = z1 - z0;

+   const GLfloat qx = -py;

+   const GLfloat qy = px;

+   const GLfloat qz = 0;

+   const GLfloat a = py * qz - pz * qy;

+   const GLfloat b = pz * qx - px * qz;

+   const GLfloat c = px * qy - py * qx;

+   const GLfloat d = -(a * x0 + b * y0 + c * z0);

+   plane[0] = a;

+   plane[1] = b;

+   plane[2] = c;

+   plane[3] = d;

+#else

+   /* simplified */

+   const GLfloat px = x1 - x0;

+   const GLfloat py = y1 - y0;

+   const GLfloat pz = z0 - z1;

+   const GLfloat a = pz * px;

+   const GLfloat b = pz * py;

+   const GLfloat c = px * px + py * py;

+   const GLfloat d = -(a * x0 + b * y0 + c * z0);

+   if (a == 0.0 && b == 0.0 && c == 0.0 && d == 0.0) {

+      plane[0] = 0.0;

+      plane[1] = 0.0;

+      plane[2] = 1.0;

+      plane[3] = 0.0;

+   }

+   else {

+      plane[0] = a;

+      plane[1] = b;

+      plane[2] = c;

+      plane[3] = d;

+   }

+#endif

+}

+

+

+static INLINE void

+constant_plane(GLfloat value, GLfloat plane[4])

+{

+   plane[0] = 0.0;

+   plane[1] = 0.0;

+   plane[2] = -1.0;

+   plane[3] = value;

+}

+

+

+static INLINE GLfloat

+solve_plane(GLfloat x, GLfloat y, const GLfloat plane[4])

+{

+   const GLfloat z = (plane[3] + plane[0] * x + plane[1] * y) / -plane[2];

+   return z;

+}

+

+#define SOLVE_PLANE(X, Y, PLANE) \

+   ((PLANE[3] + PLANE[0] * (X) + PLANE[1] * (Y)) / -PLANE[2])

+

+

+/*

+ * Return 1 / solve_plane().

+ */

+static INLINE GLfloat

+solve_plane_recip(GLfloat x, GLfloat y, const GLfloat plane[4])

+{

+   const GLfloat denom = plane[3] + plane[0] * x + plane[1] * y;

+   if (denom == 0.0)

+      return 0.0;

+   else

+      return -plane[2] / denom;

+}

+

+

+/*

+ * Solve plane and return clamped GLchan value.

+ */

+static INLINE GLchan

+solve_plane_chan(GLfloat x, GLfloat y, const GLfloat plane[4])

+{

+   const GLfloat z = (plane[3] + plane[0] * x + plane[1] * y) / -plane[2];

+#if CHAN_TYPE == GL_FLOAT

+   return CLAMP(z, 0.0F, CHAN_MAXF);

+#else

+   if (z < 0)

+      return 0;

+   else if (z > CHAN_MAX)

+      return CHAN_MAX;

+   return (GLchan) IROUND_POS(z);

+#endif

+}

+

+

+/*

+ * Compute mipmap level of detail.

+ */

+static INLINE GLfloat

+compute_lambda(const GLfloat sPlane[4], const GLfloat tPlane[4],

+               GLfloat invQ, GLfloat width, GLfloat height)

+{

+   GLfloat dudx = sPlane[0] / sPlane[2] * invQ * width;

+   GLfloat dudy = sPlane[1] / sPlane[2] * invQ * width;

+   GLfloat dvdx = tPlane[0] / tPlane[2] * invQ * height;

+   GLfloat dvdy = tPlane[1] / tPlane[2] * invQ * height;

+   GLfloat r1 = dudx * dudx + dudy * dudy;

+   GLfloat r2 = dvdx * dvdx + dvdy * dvdy;

+   GLfloat rho2 = r1 + r2;

+   /* return log base 2 of rho */

+   if (rho2 == 0.0F)

+      return 0.0;

+   else

+      return (GLfloat) (LOGF(rho2) * 1.442695 * 0.5);/* 1.442695 = 1/log(2) */

+}

+

+

+

+

+/*

+ * Fill in the samples[] array with the (x,y) subpixel positions of

+ * xSamples * ySamples sample positions.

+ * Note that the four corner samples are put into the first four

+ * positions of the array.  This allows us to optimize for the common

+ * case of all samples being inside the polygon.

+ */

+static void

+make_sample_table(GLint xSamples, GLint ySamples, GLfloat samples[][2])

+{

+   const GLfloat dx = 1.0F / (GLfloat) xSamples;

+   const GLfloat dy = 1.0F / (GLfloat) ySamples;

+   GLint x, y;

+   GLint i;

+

+   i = 4;

+   for (x = 0; x < xSamples; x++) {

+      for (y = 0; y < ySamples; y++) {

+         GLint j;

+         if (x == 0 && y == 0) {

+            /* lower left */

+            j = 0;

+         }

+         else if (x == xSamples - 1 && y == 0) {

+            /* lower right */

+            j = 1;

+         }

+         else if (x == 0 && y == ySamples - 1) {

+            /* upper left */

+            j = 2;

+         }

+         else if (x == xSamples - 1 && y == ySamples - 1) {

+            /* upper right */

+            j = 3;

+         }

+         else {

+            j = i++;

+         }

+         samples[j][0] = x * dx + 0.5F * dx;

+         samples[j][1] = y * dy + 0.5F * dy;

+      }

+   }

+}

+

+

+

+/*

+ * Compute how much of the given pixel's area is inside the rectangle

+ * defined by vertices v0, v1, v2, v3.

+ * Vertices MUST be specified in counter-clockwise order.

+ * Return:  coverage in [0, 1].

+ */

+static GLfloat

+compute_coveragef(const struct LineInfo *info,

+                  GLint winx, GLint winy)

+{

+   static GLfloat samples[SUB_PIXEL * SUB_PIXEL][2];

+   static GLboolean haveSamples = GL_FALSE;

+   const GLfloat x = (GLfloat) winx;

+   const GLfloat y = (GLfloat) winy;

+   GLint stop = 4, i;

+   GLfloat insideCount = SUB_PIXEL * SUB_PIXEL;

+

+   if (!haveSamples) {

+      make_sample_table(SUB_PIXEL, SUB_PIXEL, samples);

+      haveSamples = GL_TRUE;

+   }

+

+#if 0 /*DEBUG*/

+   {

+      const GLfloat area = dx0 * dy1 - dx1 * dy0;

+      assert(area >= 0.0);

+   }

+#endif

+

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

+      const GLfloat sx = x + samples[i][0];

+      const GLfloat sy = y + samples[i][1];

+      const GLfloat fx0 = sx - info->qx0;

+      const GLfloat fy0 = sy - info->qy0;

+      const GLfloat fx1 = sx - info->qx1;

+      const GLfloat fy1 = sy - info->qy1;

+      const GLfloat fx2 = sx - info->qx2;

+      const GLfloat fy2 = sy - info->qy2;

+      const GLfloat fx3 = sx - info->qx3;

+      const GLfloat fy3 = sy - info->qy3;

+      /* cross product determines if sample is inside or outside each edge */

+      GLfloat cross0 = (info->ex0 * fy0 - info->ey0 * fx0);

+      GLfloat cross1 = (info->ex1 * fy1 - info->ey1 * fx1);

+      GLfloat cross2 = (info->ex2 * fy2 - info->ey2 * fx2);

+      GLfloat cross3 = (info->ex3 * fy3 - info->ey3 * fx3);

+      /* Check if the sample is exactly on an edge.  If so, let cross be a

+       * positive or negative value depending on the direction of the edge.

+       */

+      if (cross0 == 0.0F)

+         cross0 = info->ex0 + info->ey0;

+      if (cross1 == 0.0F)

+         cross1 = info->ex1 + info->ey1;

+      if (cross2 == 0.0F)

+         cross2 = info->ex2 + info->ey2;

+      if (cross3 == 0.0F)

+         cross3 = info->ex3 + info->ey3;

+      if (cross0 < 0.0F || cross1 < 0.0F || cross2 < 0.0F || cross3 < 0.0F) {

+         /* point is outside quadrilateral */

+         insideCount -= 1.0F;

+         stop = SUB_PIXEL * SUB_PIXEL;

+      }

+   }

+   if (stop == 4)

+      return 1.0F;

+   else

+      return insideCount * (1.0F / (SUB_PIXEL * SUB_PIXEL));

+}

+

+

+typedef void (*plot_func)(struct gl_context *ctx, struct LineInfo *line,

+                          int ix, int iy);

+                         

+

+

+/*

+ * Draw an AA line segment (called many times per line when stippling)

+ */

+static void

+segment(struct gl_context *ctx,

+        struct LineInfo *line,

+        plot_func plot,

+        GLfloat t0, GLfloat t1)

+{

+   const GLfloat absDx = (line->dx < 0.0F) ? -line->dx : line->dx;

+   const GLfloat absDy = (line->dy < 0.0F) ? -line->dy : line->dy;

+   /* compute the actual segment's endpoints */

+   const GLfloat x0 = line->x0 + t0 * line->dx;

+   const GLfloat y0 = line->y0 + t0 * line->dy;

+   const GLfloat x1 = line->x0 + t1 * line->dx;

+   const GLfloat y1 = line->y0 + t1 * line->dy;

+

+   /* compute vertices of the line-aligned quadrilateral */

+   line->qx0 = x0 - line->yAdj;

+   line->qy0 = y0 + line->xAdj;

+   line->qx1 = x0 + line->yAdj;

+   line->qy1 = y0 - line->xAdj;

+   line->qx2 = x1 + line->yAdj;

+   line->qy2 = y1 - line->xAdj;

+   line->qx3 = x1 - line->yAdj;

+   line->qy3 = y1 + line->xAdj;

+   /* compute the quad's edge vectors (for coverage calc) */

+   line->ex0 = line->qx1 - line->qx0;

+   line->ey0 = line->qy1 - line->qy0;

+   line->ex1 = line->qx2 - line->qx1;

+   line->ey1 = line->qy2 - line->qy1;

+   line->ex2 = line->qx3 - line->qx2;

+   line->ey2 = line->qy3 - line->qy2;

+   line->ex3 = line->qx0 - line->qx3;

+   line->ey3 = line->qy0 - line->qy3;

+

+   if (absDx > absDy) {

+      /* X-major line */

+      GLfloat dydx = line->dy / line->dx;

+      GLfloat xLeft, xRight, yBot, yTop;

+      GLint ix, ixRight;

+      if (x0 < x1) {

+         xLeft = x0 - line->halfWidth;

+         xRight = x1 + line->halfWidth;

+         if (line->dy >= 0.0) {

+            yBot = y0 - 3.0F * line->halfWidth;

+            yTop = y0 + line->halfWidth;

+         }

+         else {

+            yBot = y0 - line->halfWidth;

+            yTop = y0 + 3.0F * line->halfWidth;

+         }

+      }

+      else {

+         xLeft = x1 - line->halfWidth;

+         xRight = x0 + line->halfWidth;

+         if (line->dy <= 0.0) {

+            yBot = y1 - 3.0F * line->halfWidth;

+            yTop = y1 + line->halfWidth;

+         }

+         else {

+            yBot = y1 - line->halfWidth;

+            yTop = y1 + 3.0F * line->halfWidth;

+         }

+      }

+

+      /* scan along the line, left-to-right */

+      ixRight = (GLint) (xRight + 1.0F);

+

+      /*printf("avg span height: %g\n", yTop - yBot);*/

+      for (ix = (GLint) xLeft; ix < ixRight; ix++) {

+         const GLint iyBot = (GLint) yBot;

+         const GLint iyTop = (GLint) (yTop + 1.0F);

+         GLint iy;

+         /* scan across the line, bottom-to-top */

+         for (iy = iyBot; iy < iyTop; iy++) {

+            (*plot)(ctx, line, ix, iy);

+         }

+         yBot += dydx;

+         yTop += dydx;

+      }

+   }

+   else {

+      /* Y-major line */

+      GLfloat dxdy = line->dx / line->dy;

+      GLfloat yBot, yTop, xLeft, xRight;

+      GLint iy, iyTop;

+      if (y0 < y1) {

+         yBot = y0 - line->halfWidth;

+         yTop = y1 + line->halfWidth;

+         if (line->dx >= 0.0) {

+            xLeft = x0 - 3.0F * line->halfWidth;

+            xRight = x0 + line->halfWidth;

+         }

+         else {

+            xLeft = x0 - line->halfWidth;

+            xRight = x0 + 3.0F * line->halfWidth;

+         }

+      }

+      else {

+         yBot = y1 - line->halfWidth;

+         yTop = y0 + line->halfWidth;

+         if (line->dx <= 0.0) {

+            xLeft = x1 - 3.0F * line->halfWidth;

+            xRight = x1 + line->halfWidth;

+         }

+         else {

+            xLeft = x1 - line->halfWidth;

+            xRight = x1 + 3.0F * line->halfWidth;

+         }

+      }

+

+      /* scan along the line, bottom-to-top */

+      iyTop = (GLint) (yTop + 1.0F);

+

+      /*printf("avg span width: %g\n", xRight - xLeft);*/

+      for (iy = (GLint) yBot; iy < iyTop; iy++) {

+         const GLint ixLeft = (GLint) xLeft;

+         const GLint ixRight = (GLint) (xRight + 1.0F);

+         GLint ix;

+         /* scan across the line, left-to-right */

+         for (ix = ixLeft; ix < ixRight; ix++) {

+            (*plot)(ctx, line, ix, iy);

+         }

+         xLeft += dxdy;

+         xRight += dxdy;

+      }

+   }

+}

+

+

+#define NAME(x) aa_rgba_##x

+#define DO_Z

+#include "s_aalinetemp.h"

+

+

+#define NAME(x)  aa_general_rgba_##x

+#define DO_Z

+#define DO_ATTRIBS

+#include "s_aalinetemp.h"

+

+

+

+void

+_swrast_choose_aa_line_function(struct gl_context *ctx)

+{

+   SWcontext *swrast = SWRAST_CONTEXT(ctx);

+

+   ASSERT(ctx->Line.SmoothFlag);

+

+   if (ctx->Texture._EnabledCoordUnits != 0

+       || ctx->FragmentProgram._Current

+       || (ctx->Light.Enabled &&

+           ctx->Light.Model.ColorControl == GL_SEPARATE_SPECULAR_COLOR)

+       || ctx->Fog.ColorSumEnabled

+       || swrast->_FogEnabled) {

+      swrast->Line = aa_general_rgba_line;

+   }

+   else {

+      swrast->Line = aa_rgba_line;

+   }

+}

diff --git a/mesalib/src/mesa/swrast/s_aaline.h b/mesalib/src/mesa/swrast/s_aaline.h
index 922eb230e..993c12eab 100644
--- a/mesalib/src/mesa/swrast/s_aaline.h
+++ b/mesalib/src/mesa/swrast/s_aaline.h
@@ -1,38 +1,38 @@
-
-/*
- * Mesa 3-D graphics library
- * Version:  3.5
- *
- * Copyright (C) 1999-2001  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.
- */
-
-
-#ifndef S_AALINE_H
-#define S_AALINE_H
-
-
-#include "main/mtypes.h"
-
-
-extern void
-_swrast_choose_aa_line_function(GLcontext *ctx);
-
-
-#endif
+

+/*

+ * Mesa 3-D graphics library

+ * Version:  3.5

+ *

+ * Copyright (C) 1999-2001  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.

+ */

+

+

+#ifndef S_AALINE_H

+#define S_AALINE_H

+

+

+struct gl_context;

+

+

+extern void

+_swrast_choose_aa_line_function(struct gl_context *ctx);

+

+

+#endif

diff --git a/mesalib/src/mesa/swrast/s_aalinetemp.h b/mesalib/src/mesa/swrast/s_aalinetemp.h
index c28d47a67..7c535669b 100644
--- a/mesalib/src/mesa/swrast/s_aalinetemp.h
+++ b/mesalib/src/mesa/swrast/s_aalinetemp.h
@@ -1,242 +1,242 @@
-/*
- * 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.
- */
-
-
-/*
- * Antialiased line template.
- */
-
-
-/*
- * Function to render each fragment in the AA line.
- * \param ix  - integer fragment window X coordiante
- * \param iy  - integer fragment window Y coordiante
- */
-static void
-NAME(plot)(GLcontext *ctx, struct LineInfo *line, int ix, int iy)
-{
-   const SWcontext *swrast = SWRAST_CONTEXT(ctx);
-   const GLfloat fx = (GLfloat) ix;
-   const GLfloat fy = (GLfloat) iy;
-   const GLfloat coverage = compute_coveragef(line, ix, iy);
-   const GLuint i = line->span.end;
-
-   (void) swrast;
-
-   if (coverage == 0.0)
-      return;
-
-   line->span.end++;
-   line->span.array->coverage[i] = coverage;
-   line->span.array->x[i] = ix;
-   line->span.array->y[i] = iy;
-
-   /*
-    * Compute Z, color, texture coords, fog for the fragment by
-    * solving the plane equations at (ix,iy).
-    */
-#ifdef DO_Z
-   line->span.array->z[i] = (GLuint) solve_plane(fx, fy, line->zPlane);
-#endif
-   line->span.array->rgba[i][RCOMP] = solve_plane_chan(fx, fy, line->rPlane);
-   line->span.array->rgba[i][GCOMP] = solve_plane_chan(fx, fy, line->gPlane);
-   line->span.array->rgba[i][BCOMP] = solve_plane_chan(fx, fy, line->bPlane);
-   line->span.array->rgba[i][ACOMP] = solve_plane_chan(fx, fy, line->aPlane);
-#if defined(DO_ATTRIBS)
-   ATTRIB_LOOP_BEGIN
-      GLfloat (*attribArray)[4] = line->span.array->attribs[attr];
-      if (attr >= FRAG_ATTRIB_TEX0 && attr < FRAG_ATTRIB_VAR0
-          && !ctx->FragmentProgram._Current) {
-         /* texcoord w/ divide by Q */
-         const GLuint unit = attr - FRAG_ATTRIB_TEX0;
-         const GLfloat invQ = solve_plane_recip(fx, fy, line->attrPlane[attr][3]);
-         GLuint c;
-         for (c = 0; c < 3; c++) {
-            attribArray[i][c] = solve_plane(fx, fy, line->attrPlane[attr][c]) * invQ;
-         }
-         line->span.array->lambda[unit][i]
-            = compute_lambda(line->attrPlane[attr][0],
-                             line->attrPlane[attr][1], invQ,
-                             line->texWidth[attr], line->texHeight[attr]);
-      }
-      else {
-         /* non-texture attrib */
-         const GLfloat invW = solve_plane_recip(fx, fy, line->wPlane);
-         GLuint c;
-         for (c = 0; c < 4; c++) {
-            attribArray[i][c] = solve_plane(fx, fy, line->attrPlane[attr][c]) * invW;
-         }
-      }
-   ATTRIB_LOOP_END
-#endif
-
-   if (line->span.end == MAX_WIDTH) {
-      _swrast_write_rgba_span(ctx, &(line->span));
-      line->span.end = 0; /* reset counter */
-   }
-}
-
-
-
-/*
- * Line setup
- */
-static void
-NAME(line)(GLcontext *ctx, const SWvertex *v0, const SWvertex *v1)
-{
-   SWcontext *swrast = SWRAST_CONTEXT(ctx);
-   GLfloat tStart, tEnd;   /* segment start, end along line length */
-   GLboolean inSegment;
-   GLint iLen, i;
-
-   /* Init the LineInfo struct */
-   struct LineInfo line;
-   line.x0 = v0->attrib[FRAG_ATTRIB_WPOS][0];
-   line.y0 = v0->attrib[FRAG_ATTRIB_WPOS][1];
-   line.x1 = v1->attrib[FRAG_ATTRIB_WPOS][0];
-   line.y1 = v1->attrib[FRAG_ATTRIB_WPOS][1];
-   line.dx = line.x1 - line.x0;
-   line.dy = line.y1 - line.y0;
-   line.len = SQRTF(line.dx * line.dx + line.dy * line.dy);
-   line.halfWidth = 0.5F * CLAMP(ctx->Line.Width,
-                                 ctx->Const.MinLineWidthAA,
-                                 ctx->Const.MaxLineWidthAA);
-
-   if (line.len == 0.0 || IS_INF_OR_NAN(line.len))
-      return;
-
-   INIT_SPAN(line.span, GL_LINE);
-   line.span.arrayMask = SPAN_XY | SPAN_COVERAGE;
-   line.span.facing = swrast->PointLineFacing;
-   line.xAdj = line.dx / line.len * line.halfWidth;
-   line.yAdj = line.dy / line.len * line.halfWidth;
-
-#ifdef DO_Z
-   line.span.arrayMask |= SPAN_Z;
-   compute_plane(line.x0, line.y0, line.x1, line.y1,
-                 v0->attrib[FRAG_ATTRIB_WPOS][2], v1->attrib[FRAG_ATTRIB_WPOS][2], line.zPlane);
-#endif
-   line.span.arrayMask |= SPAN_RGBA;
-   if (ctx->Light.ShadeModel == GL_SMOOTH) {
-      compute_plane(line.x0, line.y0, line.x1, line.y1,
-                    v0->color[RCOMP], v1->color[RCOMP], line.rPlane);
-      compute_plane(line.x0, line.y0, line.x1, line.y1,
-                    v0->color[GCOMP], v1->color[GCOMP], line.gPlane);
-      compute_plane(line.x0, line.y0, line.x1, line.y1,
-                    v0->color[BCOMP], v1->color[BCOMP], line.bPlane);
-      compute_plane(line.x0, line.y0, line.x1, line.y1,
-                    v0->color[ACOMP], v1->color[ACOMP], line.aPlane);
-   }
-   else {
-      constant_plane(v1->color[RCOMP], line.rPlane);
-      constant_plane(v1->color[GCOMP], line.gPlane);
-      constant_plane(v1->color[BCOMP], line.bPlane);
-      constant_plane(v1->color[ACOMP], line.aPlane);
-   }
-#if defined(DO_ATTRIBS)
-   {
-      const GLfloat invW0 = v0->attrib[FRAG_ATTRIB_WPOS][3];
-      const GLfloat invW1 = v1->attrib[FRAG_ATTRIB_WPOS][3];
-      line.span.arrayMask |= SPAN_LAMBDA;
-      compute_plane(line.x0, line.y0, line.x1, line.y1, invW0, invW1, line.wPlane);
-      ATTRIB_LOOP_BEGIN
-         GLuint c;
-         if (swrast->_InterpMode[attr] == GL_FLAT) {
-            for (c = 0; c < 4; c++) {
-               constant_plane(v1->attrib[attr][c], line.attrPlane[attr][c]);
-            }
-         }
-         else {
-            for (c = 0; c < 4; c++) {
-               const GLfloat a0 = v0->attrib[attr][c] * invW0;
-               const GLfloat a1 = v1->attrib[attr][c] * invW1;
-               compute_plane(line.x0, line.y0, line.x1, line.y1, a0, a1,
-                             line.attrPlane[attr][c]);
-            }
-         }
-         line.span.arrayAttribs |= (1 << attr);
-         if (attr >= FRAG_ATTRIB_TEX0 && attr < FRAG_ATTRIB_VAR0) {
-            const GLuint u = attr - FRAG_ATTRIB_TEX0;
-            const struct gl_texture_object *obj = ctx->Texture.Unit[u]._Current;
-            const struct gl_texture_image *texImage = obj->Image[0][obj->BaseLevel];
-            line.texWidth[attr]  = (GLfloat) texImage->Width;
-            line.texHeight[attr] = (GLfloat) texImage->Height;
-         }
-      ATTRIB_LOOP_END
-   }
-#endif
-
-   tStart = tEnd = 0.0;
-   inSegment = GL_FALSE;
-   iLen = (GLint) line.len;
-
-   if (ctx->Line.StippleFlag) {
-      for (i = 0; i < iLen; i++) {
-         const GLuint bit = (swrast->StippleCounter / ctx->Line.StippleFactor) & 0xf;
-         if ((1 << bit) & ctx->Line.StipplePattern) {
-            /* stipple bit is on */
-            const GLfloat t = (GLfloat) i / (GLfloat) line.len;
-            if (!inSegment) {
-               /* start new segment */
-               inSegment = GL_TRUE;
-               tStart = t;
-            }
-            else {
-               /* still in the segment, extend it */
-               tEnd = t;
-            }
-         }
-         else {
-            /* stipple bit is off */
-            if (inSegment && (tEnd > tStart)) {
-               /* draw the segment */
-               segment(ctx, &line, NAME(plot), tStart, tEnd);
-               inSegment = GL_FALSE;
-            }
-            else {
-               /* still between segments, do nothing */
-            }
-         }
-         swrast->StippleCounter++;
-      }
-
-      if (inSegment) {
-         /* draw the final segment of the line */
-         segment(ctx, &line, NAME(plot), tStart, 1.0F);
-      }
-   }
-   else {
-      /* non-stippled */
-      segment(ctx, &line, NAME(plot), 0.0, 1.0);
-   }
-
-   _swrast_write_rgba_span(ctx, &(line.span));
-}
-
-
-
-
-#undef DO_Z
-#undef DO_ATTRIBS
-#undef NAME
+/*

+ * 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.

+ */

+

+

+/*

+ * Antialiased line template.

+ */

+

+

+/*

+ * Function to render each fragment in the AA line.

+ * \param ix  - integer fragment window X coordiante

+ * \param iy  - integer fragment window Y coordiante

+ */

+static void

+NAME(plot)(struct gl_context *ctx, struct LineInfo *line, int ix, int iy)

+{

+   const SWcontext *swrast = SWRAST_CONTEXT(ctx);

+   const GLfloat fx = (GLfloat) ix;

+   const GLfloat fy = (GLfloat) iy;

+   const GLfloat coverage = compute_coveragef(line, ix, iy);

+   const GLuint i = line->span.end;

+

+   (void) swrast;

+

+   if (coverage == 0.0)

+      return;

+

+   line->span.end++;

+   line->span.array->coverage[i] = coverage;

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

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

+

+   /*

+    * Compute Z, color, texture coords, fog for the fragment by

+    * solving the plane equations at (ix,iy).

+    */

+#ifdef DO_Z

+   line->span.array->z[i] = (GLuint) solve_plane(fx, fy, line->zPlane);

+#endif

+   line->span.array->rgba[i][RCOMP] = solve_plane_chan(fx, fy, line->rPlane);

+   line->span.array->rgba[i][GCOMP] = solve_plane_chan(fx, fy, line->gPlane);

+   line->span.array->rgba[i][BCOMP] = solve_plane_chan(fx, fy, line->bPlane);

+   line->span.array->rgba[i][ACOMP] = solve_plane_chan(fx, fy, line->aPlane);

+#if defined(DO_ATTRIBS)

+   ATTRIB_LOOP_BEGIN

+      GLfloat (*attribArray)[4] = line->span.array->attribs[attr];

+      if (attr >= FRAG_ATTRIB_TEX0 && attr < FRAG_ATTRIB_VAR0

+          && !ctx->FragmentProgram._Current) {

+         /* texcoord w/ divide by Q */

+         const GLuint unit = attr - FRAG_ATTRIB_TEX0;

+         const GLfloat invQ = solve_plane_recip(fx, fy, line->attrPlane[attr][3]);

+         GLuint c;

+         for (c = 0; c < 3; c++) {

+            attribArray[i][c] = solve_plane(fx, fy, line->attrPlane[attr][c]) * invQ;

+         }

+         line->span.array->lambda[unit][i]

+            = compute_lambda(line->attrPlane[attr][0],

+                             line->attrPlane[attr][1], invQ,

+                             line->texWidth[attr], line->texHeight[attr]);

+      }

+      else {

+         /* non-texture attrib */

+         const GLfloat invW = solve_plane_recip(fx, fy, line->wPlane);

+         GLuint c;

+         for (c = 0; c < 4; c++) {

+            attribArray[i][c] = solve_plane(fx, fy, line->attrPlane[attr][c]) * invW;

+         }

+      }

+   ATTRIB_LOOP_END

+#endif

+

+   if (line->span.end == MAX_WIDTH) {

+      _swrast_write_rgba_span(ctx, &(line->span));

+      line->span.end = 0; /* reset counter */

+   }

+}

+

+

+

+/*

+ * Line setup

+ */

+static void

+NAME(line)(struct gl_context *ctx, const SWvertex *v0, const SWvertex *v1)

+{

+   SWcontext *swrast = SWRAST_CONTEXT(ctx);

+   GLfloat tStart, tEnd;   /* segment start, end along line length */

+   GLboolean inSegment;

+   GLint iLen, i;

+

+   /* Init the LineInfo struct */

+   struct LineInfo line;

+   line.x0 = v0->attrib[FRAG_ATTRIB_WPOS][0];

+   line.y0 = v0->attrib[FRAG_ATTRIB_WPOS][1];

+   line.x1 = v1->attrib[FRAG_ATTRIB_WPOS][0];

+   line.y1 = v1->attrib[FRAG_ATTRIB_WPOS][1];

+   line.dx = line.x1 - line.x0;

+   line.dy = line.y1 - line.y0;

+   line.len = SQRTF(line.dx * line.dx + line.dy * line.dy);

+   line.halfWidth = 0.5F * CLAMP(ctx->Line.Width,

+                                 ctx->Const.MinLineWidthAA,

+                                 ctx->Const.MaxLineWidthAA);

+

+   if (line.len == 0.0 || IS_INF_OR_NAN(line.len))

+      return;

+

+   INIT_SPAN(line.span, GL_LINE);

+   line.span.arrayMask = SPAN_XY | SPAN_COVERAGE;

+   line.span.facing = swrast->PointLineFacing;

+   line.xAdj = line.dx / line.len * line.halfWidth;

+   line.yAdj = line.dy / line.len * line.halfWidth;

+

+#ifdef DO_Z

+   line.span.arrayMask |= SPAN_Z;

+   compute_plane(line.x0, line.y0, line.x1, line.y1,

+                 v0->attrib[FRAG_ATTRIB_WPOS][2], v1->attrib[FRAG_ATTRIB_WPOS][2], line.zPlane);

+#endif

+   line.span.arrayMask |= SPAN_RGBA;

+   if (ctx->Light.ShadeModel == GL_SMOOTH) {

+      compute_plane(line.x0, line.y0, line.x1, line.y1,

+                    v0->color[RCOMP], v1->color[RCOMP], line.rPlane);

+      compute_plane(line.x0, line.y0, line.x1, line.y1,

+                    v0->color[GCOMP], v1->color[GCOMP], line.gPlane);

+      compute_plane(line.x0, line.y0, line.x1, line.y1,

+                    v0->color[BCOMP], v1->color[BCOMP], line.bPlane);

+      compute_plane(line.x0, line.y0, line.x1, line.y1,

+                    v0->color[ACOMP], v1->color[ACOMP], line.aPlane);

+   }

+   else {

+      constant_plane(v1->color[RCOMP], line.rPlane);

+      constant_plane(v1->color[GCOMP], line.gPlane);

+      constant_plane(v1->color[BCOMP], line.bPlane);

+      constant_plane(v1->color[ACOMP], line.aPlane);

+   }

+#if defined(DO_ATTRIBS)

+   {

+      const GLfloat invW0 = v0->attrib[FRAG_ATTRIB_WPOS][3];

+      const GLfloat invW1 = v1->attrib[FRAG_ATTRIB_WPOS][3];

+      line.span.arrayMask |= SPAN_LAMBDA;

+      compute_plane(line.x0, line.y0, line.x1, line.y1, invW0, invW1, line.wPlane);

+      ATTRIB_LOOP_BEGIN

+         GLuint c;

+         if (swrast->_InterpMode[attr] == GL_FLAT) {

+            for (c = 0; c < 4; c++) {

+               constant_plane(v1->attrib[attr][c], line.attrPlane[attr][c]);

+            }

+         }

+         else {

+            for (c = 0; c < 4; c++) {

+               const GLfloat a0 = v0->attrib[attr][c] * invW0;

+               const GLfloat a1 = v1->attrib[attr][c] * invW1;

+               compute_plane(line.x0, line.y0, line.x1, line.y1, a0, a1,

+                             line.attrPlane[attr][c]);

+            }

+         }

+         line.span.arrayAttribs |= (1 << attr);

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

+            const GLuint u = attr - FRAG_ATTRIB_TEX0;

+            const struct gl_texture_object *obj = ctx->Texture.Unit[u]._Current;

+            const struct gl_texture_image *texImage = obj->Image[0][obj->BaseLevel];

+            line.texWidth[attr]  = (GLfloat) texImage->Width;

+            line.texHeight[attr] = (GLfloat) texImage->Height;

+         }

+      ATTRIB_LOOP_END

+   }

+#endif

+

+   tStart = tEnd = 0.0;

+   inSegment = GL_FALSE;

+   iLen = (GLint) line.len;

+

+   if (ctx->Line.StippleFlag) {

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

+         const GLuint bit = (swrast->StippleCounter / ctx->Line.StippleFactor) & 0xf;

+         if ((1 << bit) & ctx->Line.StipplePattern) {

+            /* stipple bit is on */

+            const GLfloat t = (GLfloat) i / (GLfloat) line.len;

+            if (!inSegment) {

+               /* start new segment */

+               inSegment = GL_TRUE;

+               tStart = t;

+            }

+            else {

+               /* still in the segment, extend it */

+               tEnd = t;

+            }

+         }

+         else {

+            /* stipple bit is off */

+            if (inSegment && (tEnd > tStart)) {

+               /* draw the segment */

+               segment(ctx, &line, NAME(plot), tStart, tEnd);

+               inSegment = GL_FALSE;

+            }

+            else {

+               /* still between segments, do nothing */

+            }

+         }

+         swrast->StippleCounter++;

+      }

+

+      if (inSegment) {

+         /* draw the final segment of the line */

+         segment(ctx, &line, NAME(plot), tStart, 1.0F);

+      }

+   }

+   else {

+      /* non-stippled */

+      segment(ctx, &line, NAME(plot), 0.0, 1.0);

+   }

+

+   _swrast_write_rgba_span(ctx, &(line.span));

+}

+

+

+

+

+#undef DO_Z

+#undef DO_ATTRIBS

+#undef NAME

diff --git a/mesalib/src/mesa/swrast/s_aatriangle.c b/mesalib/src/mesa/swrast/s_aatriangle.c
index 1d90f322a..ba92fc14a 100644
--- a/mesalib/src/mesa/swrast/s_aatriangle.c
+++ b/mesalib/src/mesa/swrast/s_aatriangle.c
@@ -1,317 +1,316 @@
-/*
- * Mesa 3-D graphics library
- * Version:  6.5.3
- *
- * 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.
- */
-
-
-/*
- * Antialiased Triangle rasterizers
- */
-
-
-#include "main/glheader.h"
-#include "main/context.h"
-#include "main/colormac.h"
-#include "main/context.h"
-#include "main/macros.h"
-#include "main/imports.h"
-#include "s_aatriangle.h"
-#include "s_context.h"
-#include "s_span.h"
-
-
-/*
- * Compute coefficients of a plane using the X,Y coords of the v0, v1, v2
- * vertices and the given Z values.
- * A point (x,y,z) lies on plane iff a*x+b*y+c*z+d = 0.
- */
-static INLINE void
-compute_plane(const GLfloat v0[], const GLfloat v1[], const GLfloat v2[],
-              GLfloat z0, GLfloat z1, GLfloat z2, GLfloat plane[4])
-{
-   const GLfloat px = v1[0] - v0[0];
-   const GLfloat py = v1[1] - v0[1];
-   const GLfloat pz = z1 - z0;
-
-   const GLfloat qx = v2[0] - v0[0];
-   const GLfloat qy = v2[1] - v0[1];
-   const GLfloat qz = z2 - z0;
-
-   /* Crossproduct "(a,b,c):= dv1 x dv2" is orthogonal to plane. */
-   const GLfloat a = py * qz - pz * qy;
-   const GLfloat b = pz * qx - px * qz;
-   const GLfloat c = px * qy - py * qx;
-   /* Point on the plane = "r*(a,b,c) + w", with fixed "r" depending
-      on the distance of plane from origin and arbitrary "w" parallel
-      to the plane. */
-   /* The scalar product "(r*(a,b,c)+w)*(a,b,c)" is "r*(a^2+b^2+c^2)",
-      which is equal to "-d" below. */
-   const GLfloat d = -(a * v0[0] + b * v0[1] + c * z0);
-
-   plane[0] = a;
-   plane[1] = b;
-   plane[2] = c;
-   plane[3] = d;
-}
-
-
-/*
- * Compute coefficients of a plane with a constant Z value.
- */
-static INLINE void
-constant_plane(GLfloat value, GLfloat plane[4])
-{
-   plane[0] = 0.0;
-   plane[1] = 0.0;
-   plane[2] = -1.0;
-   plane[3] = value;
-}
-
-#define CONSTANT_PLANE(VALUE, PLANE)	\
-do {					\
-   PLANE[0] = 0.0F;			\
-   PLANE[1] = 0.0F;			\
-   PLANE[2] = -1.0F;			\
-   PLANE[3] = VALUE;			\
-} while (0)
-
-
-
-/*
- * Solve plane equation for Z at (X,Y).
- */
-static INLINE GLfloat
-solve_plane(GLfloat x, GLfloat y, const GLfloat plane[4])
-{
-   ASSERT(plane[2] != 0.0F);
-   return (plane[3] + plane[0] * x + plane[1] * y) / -plane[2];
-}
-
-
-#define SOLVE_PLANE(X, Y, PLANE) \
-   ((PLANE[3] + PLANE[0] * (X) + PLANE[1] * (Y)) / -PLANE[2])
-
-
-/*
- * Return 1 / solve_plane().
- */
-static INLINE GLfloat
-solve_plane_recip(GLfloat x, GLfloat y, const GLfloat plane[4])
-{
-   const GLfloat denom = plane[3] + plane[0] * x + plane[1] * y;
-   if (denom == 0.0F)
-      return 0.0F;
-   else
-      return -plane[2] / denom;
-}
-
-
-/*
- * Solve plane and return clamped GLchan value.
- */
-static INLINE GLchan
-solve_plane_chan(GLfloat x, GLfloat y, const GLfloat plane[4])
-{
-   const GLfloat z = (plane[3] + plane[0] * x + plane[1] * y) / -plane[2];
-#if CHAN_TYPE == GL_FLOAT
-   return CLAMP(z, 0.0F, CHAN_MAXF);
-#else
-   if (z < 0)
-      return 0;
-   else if (z > CHAN_MAX)
-      return CHAN_MAX;
-   return (GLchan) IROUND_POS(z);
-#endif
-}
-
-
-static INLINE GLfloat
-plane_dx(const GLfloat plane[4])
-{
-   return -plane[0] / plane[2];
-}
-
-static INLINE GLfloat
-plane_dy(const GLfloat plane[4])
-{
-   return -plane[1] / plane[2];
-}
-
-
-
-/*
- * Compute how much (area) of the given pixel is inside the triangle.
- * Vertices MUST be specified in counter-clockwise order.
- * Return:  coverage in [0, 1].
- */
-static GLfloat
-compute_coveragef(const GLfloat v0[3], const GLfloat v1[3],
-                  const GLfloat v2[3], GLint winx, GLint winy)
-{
-   /* Given a position [0,3]x[0,3] return the sub-pixel sample position.
-    * Contributed by Ray Tice.
-    *
-    * Jitter sample positions -
-    * - average should be .5 in x & y for each column
-    * - each of the 16 rows and columns should be used once
-    * - the rectangle formed by the first four points
-    *   should contain the other points
-    * - the distrubition should be fairly even in any given direction
-    *
-    * The pattern drawn below isn't optimal, but it's better than a regular
-    * grid.  In the drawing, the center of each subpixel is surrounded by
-    * four dots.  The "x" marks the jittered position relative to the
-    * subpixel center.
-    */
-#define POS(a, b) (0.5+a*4+b)/16
-   static const GLfloat samples[16][2] = {
-      /* start with the four corners */
-      { POS(0, 2), POS(0, 0) },
-      { POS(3, 3), POS(0, 2) },
-      { POS(0, 0), POS(3, 1) },
-      { POS(3, 1), POS(3, 3) },
-      /* continue with interior samples */
-      { POS(1, 1), POS(0, 1) },
-      { POS(2, 0), POS(0, 3) },
-      { POS(0, 3), POS(1, 3) },
-      { POS(1, 2), POS(1, 0) },
-      { POS(2, 3), POS(1, 2) },
-      { POS(3, 2), POS(1, 1) },
-      { POS(0, 1), POS(2, 2) },
-      { POS(1, 0), POS(2, 1) },
-      { POS(2, 1), POS(2, 3) },
-      { POS(3, 0), POS(2, 0) },
-      { POS(1, 3), POS(3, 0) },
-      { POS(2, 2), POS(3, 2) }
-   };
-
-   const GLfloat x = (GLfloat) winx;
-   const GLfloat y = (GLfloat) winy;
-   const GLfloat dx0 = v1[0] - v0[0];
-   const GLfloat dy0 = v1[1] - v0[1];
-   const GLfloat dx1 = v2[0] - v1[0];
-   const GLfloat dy1 = v2[1] - v1[1];
-   const GLfloat dx2 = v0[0] - v2[0];
-   const GLfloat dy2 = v0[1] - v2[1];
-   GLint stop = 4, i;
-   GLfloat insideCount = 16.0F;
-
-#ifdef DEBUG
-   {
-      const GLfloat area = dx0 * dy1 - dx1 * dy0;
-      ASSERT(area >= 0.0);
-   }
-#endif
-
-   for (i = 0; i < stop; i++) {
-      const GLfloat sx = x + samples[i][0];
-      const GLfloat sy = y + samples[i][1];
-      /* cross product determines if sample is inside or outside each edge */
-      GLfloat cross = (dx0 * (sy - v0[1]) - dy0 * (sx - v0[0]));
-      /* Check if the sample is exactly on an edge.  If so, let cross be a
-       * positive or negative value depending on the direction of the edge.
-       */
-      if (cross == 0.0F)
-         cross = dx0 + dy0;
-      if (cross < 0.0F) {
-         /* sample point is outside first edge */
-         insideCount -= 1.0F;
-         stop = 16;
-      }
-      else {
-         /* sample point is inside first edge */
-         cross = (dx1 * (sy - v1[1]) - dy1 * (sx - v1[0]));
-         if (cross == 0.0F)
-            cross = dx1 + dy1;
-         if (cross < 0.0F) {
-            /* sample point is outside second edge */
-            insideCount -= 1.0F;
-            stop = 16;
-         }
-         else {
-            /* sample point is inside first and second edges */
-            cross = (dx2 * (sy - v2[1]) -  dy2 * (sx - v2[0]));
-            if (cross == 0.0F)
-               cross = dx2 + dy2;
-            if (cross < 0.0F) {
-               /* sample point is outside third edge */
-               insideCount -= 1.0F;
-               stop = 16;
-            }
-         }
-      }
-   }
-   if (stop == 4)
-      return 1.0F;
-   else
-      return insideCount * (1.0F / 16.0F);
-}
-
-
-
-static void
-rgba_aa_tri(GLcontext *ctx,
-	    const SWvertex *v0,
-	    const SWvertex *v1,
-	    const SWvertex *v2)
-{
-#define DO_Z
-#include "s_aatritemp.h"
-}
-
-
-static void
-general_aa_tri(GLcontext *ctx,
-               const SWvertex *v0,
-               const SWvertex *v1,
-               const SWvertex *v2)
-{
-#define DO_Z
-#define DO_ATTRIBS
-#include "s_aatritemp.h"
-}
-
-
-
-/*
- * Examine GL state and set swrast->Triangle to an
- * appropriate antialiased triangle rasterizer function.
- */
-void
-_swrast_set_aa_triangle_function(GLcontext *ctx)
-{
-   SWcontext *swrast = SWRAST_CONTEXT(ctx);
-
-   ASSERT(ctx->Polygon.SmoothFlag);
-
-   if (ctx->Texture._EnabledCoordUnits != 0
-       || ctx->FragmentProgram._Current
-       || swrast->_FogEnabled
-       || NEED_SECONDARY_COLOR(ctx)) {
-      SWRAST_CONTEXT(ctx)->Triangle = general_aa_tri;
-   }
-   else {
-      SWRAST_CONTEXT(ctx)->Triangle = rgba_aa_tri;
-   }
-
-   ASSERT(SWRAST_CONTEXT(ctx)->Triangle);
-}
+/*

+ * Mesa 3-D graphics library

+ * Version:  6.5.3

+ *

+ * 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.

+ */

+

+

+/*

+ * Antialiased Triangle rasterizers

+ */

+

+

+#include "main/glheader.h"

+#include "main/context.h"

+#include "main/colormac.h"

+#include "main/macros.h"

+#include "main/imports.h"

+#include "s_aatriangle.h"

+#include "s_context.h"

+#include "s_span.h"

+

+

+/*

+ * Compute coefficients of a plane using the X,Y coords of the v0, v1, v2

+ * vertices and the given Z values.

+ * A point (x,y,z) lies on plane iff a*x+b*y+c*z+d = 0.

+ */

+static INLINE void

+compute_plane(const GLfloat v0[], const GLfloat v1[], const GLfloat v2[],

+              GLfloat z0, GLfloat z1, GLfloat z2, GLfloat plane[4])

+{

+   const GLfloat px = v1[0] - v0[0];

+   const GLfloat py = v1[1] - v0[1];

+   const GLfloat pz = z1 - z0;

+

+   const GLfloat qx = v2[0] - v0[0];

+   const GLfloat qy = v2[1] - v0[1];

+   const GLfloat qz = z2 - z0;

+

+   /* Crossproduct "(a,b,c):= dv1 x dv2" is orthogonal to plane. */

+   const GLfloat a = py * qz - pz * qy;

+   const GLfloat b = pz * qx - px * qz;

+   const GLfloat c = px * qy - py * qx;

+   /* Point on the plane = "r*(a,b,c) + w", with fixed "r" depending

+      on the distance of plane from origin and arbitrary "w" parallel

+      to the plane. */

+   /* The scalar product "(r*(a,b,c)+w)*(a,b,c)" is "r*(a^2+b^2+c^2)",

+      which is equal to "-d" below. */

+   const GLfloat d = -(a * v0[0] + b * v0[1] + c * z0);

+

+   plane[0] = a;

+   plane[1] = b;

+   plane[2] = c;

+   plane[3] = d;

+}

+

+

+/*

+ * Compute coefficients of a plane with a constant Z value.

+ */

+static INLINE void

+constant_plane(GLfloat value, GLfloat plane[4])

+{

+   plane[0] = 0.0;

+   plane[1] = 0.0;

+   plane[2] = -1.0;

+   plane[3] = value;

+}

+

+#define CONSTANT_PLANE(VALUE, PLANE)	\

+do {					\

+   PLANE[0] = 0.0F;			\

+   PLANE[1] = 0.0F;			\

+   PLANE[2] = -1.0F;			\

+   PLANE[3] = VALUE;			\

+} while (0)

+

+

+

+/*

+ * Solve plane equation for Z at (X,Y).

+ */

+static INLINE GLfloat

+solve_plane(GLfloat x, GLfloat y, const GLfloat plane[4])

+{

+   ASSERT(plane[2] != 0.0F);

+   return (plane[3] + plane[0] * x + plane[1] * y) / -plane[2];

+}

+

+

+#define SOLVE_PLANE(X, Y, PLANE) \

+   ((PLANE[3] + PLANE[0] * (X) + PLANE[1] * (Y)) / -PLANE[2])

+

+

+/*

+ * Return 1 / solve_plane().

+ */

+static INLINE GLfloat

+solve_plane_recip(GLfloat x, GLfloat y, const GLfloat plane[4])

+{

+   const GLfloat denom = plane[3] + plane[0] * x + plane[1] * y;

+   if (denom == 0.0F)

+      return 0.0F;

+   else

+      return -plane[2] / denom;

+}

+

+

+/*

+ * Solve plane and return clamped GLchan value.

+ */

+static INLINE GLchan

+solve_plane_chan(GLfloat x, GLfloat y, const GLfloat plane[4])

+{

+   const GLfloat z = (plane[3] + plane[0] * x + plane[1] * y) / -plane[2];

+#if CHAN_TYPE == GL_FLOAT

+   return CLAMP(z, 0.0F, CHAN_MAXF);

+#else

+   if (z < 0)

+      return 0;

+   else if (z > CHAN_MAX)

+      return CHAN_MAX;

+   return (GLchan) IROUND_POS(z);

+#endif

+}

+

+

+static INLINE GLfloat

+plane_dx(const GLfloat plane[4])

+{

+   return -plane[0] / plane[2];

+}

+

+static INLINE GLfloat

+plane_dy(const GLfloat plane[4])

+{

+   return -plane[1] / plane[2];

+}

+

+

+

+/*

+ * Compute how much (area) of the given pixel is inside the triangle.

+ * Vertices MUST be specified in counter-clockwise order.

+ * Return:  coverage in [0, 1].

+ */

+static GLfloat

+compute_coveragef(const GLfloat v0[3], const GLfloat v1[3],

+                  const GLfloat v2[3], GLint winx, GLint winy)

+{

+   /* Given a position [0,3]x[0,3] return the sub-pixel sample position.

+    * Contributed by Ray Tice.

+    *

+    * Jitter sample positions -

+    * - average should be .5 in x & y for each column

+    * - each of the 16 rows and columns should be used once

+    * - the rectangle formed by the first four points

+    *   should contain the other points

+    * - the distrubition should be fairly even in any given direction

+    *

+    * The pattern drawn below isn't optimal, but it's better than a regular

+    * grid.  In the drawing, the center of each subpixel is surrounded by

+    * four dots.  The "x" marks the jittered position relative to the

+    * subpixel center.

+    */

+#define POS(a, b) (0.5+a*4+b)/16

+   static const GLfloat samples[16][2] = {

+      /* start with the four corners */

+      { POS(0, 2), POS(0, 0) },

+      { POS(3, 3), POS(0, 2) },

+      { POS(0, 0), POS(3, 1) },

+      { POS(3, 1), POS(3, 3) },

+      /* continue with interior samples */

+      { POS(1, 1), POS(0, 1) },

+      { POS(2, 0), POS(0, 3) },

+      { POS(0, 3), POS(1, 3) },

+      { POS(1, 2), POS(1, 0) },

+      { POS(2, 3), POS(1, 2) },

+      { POS(3, 2), POS(1, 1) },

+      { POS(0, 1), POS(2, 2) },

+      { POS(1, 0), POS(2, 1) },

+      { POS(2, 1), POS(2, 3) },

+      { POS(3, 0), POS(2, 0) },

+      { POS(1, 3), POS(3, 0) },

+      { POS(2, 2), POS(3, 2) }

+   };

+

+   const GLfloat x = (GLfloat) winx;

+   const GLfloat y = (GLfloat) winy;

+   const GLfloat dx0 = v1[0] - v0[0];

+   const GLfloat dy0 = v1[1] - v0[1];

+   const GLfloat dx1 = v2[0] - v1[0];

+   const GLfloat dy1 = v2[1] - v1[1];

+   const GLfloat dx2 = v0[0] - v2[0];

+   const GLfloat dy2 = v0[1] - v2[1];

+   GLint stop = 4, i;

+   GLfloat insideCount = 16.0F;

+

+#ifdef DEBUG

+   {

+      const GLfloat area = dx0 * dy1 - dx1 * dy0;

+      ASSERT(area >= 0.0);

+   }

+#endif

+

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

+      const GLfloat sx = x + samples[i][0];

+      const GLfloat sy = y + samples[i][1];

+      /* cross product determines if sample is inside or outside each edge */

+      GLfloat cross = (dx0 * (sy - v0[1]) - dy0 * (sx - v0[0]));

+      /* Check if the sample is exactly on an edge.  If so, let cross be a

+       * positive or negative value depending on the direction of the edge.

+       */

+      if (cross == 0.0F)

+         cross = dx0 + dy0;

+      if (cross < 0.0F) {

+         /* sample point is outside first edge */

+         insideCount -= 1.0F;

+         stop = 16;

+      }

+      else {

+         /* sample point is inside first edge */

+         cross = (dx1 * (sy - v1[1]) - dy1 * (sx - v1[0]));

+         if (cross == 0.0F)

+            cross = dx1 + dy1;

+         if (cross < 0.0F) {

+            /* sample point is outside second edge */

+            insideCount -= 1.0F;

+            stop = 16;

+         }

+         else {

+            /* sample point is inside first and second edges */

+            cross = (dx2 * (sy - v2[1]) -  dy2 * (sx - v2[0]));

+            if (cross == 0.0F)

+               cross = dx2 + dy2;

+            if (cross < 0.0F) {

+               /* sample point is outside third edge */

+               insideCount -= 1.0F;

+               stop = 16;

+            }

+         }

+      }

+   }

+   if (stop == 4)

+      return 1.0F;

+   else

+      return insideCount * (1.0F / 16.0F);

+}

+

+

+

+static void

+rgba_aa_tri(struct gl_context *ctx,

+	    const SWvertex *v0,

+	    const SWvertex *v1,

+	    const SWvertex *v2)

+{

+#define DO_Z

+#include "s_aatritemp.h"

+}

+

+

+static void

+general_aa_tri(struct gl_context *ctx,

+               const SWvertex *v0,

+               const SWvertex *v1,

+               const SWvertex *v2)

+{

+#define DO_Z

+#define DO_ATTRIBS

+#include "s_aatritemp.h"

+}

+

+

+

+/*

+ * Examine GL state and set swrast->Triangle to an

+ * appropriate antialiased triangle rasterizer function.

+ */

+void

+_swrast_set_aa_triangle_function(struct gl_context *ctx)

+{

+   SWcontext *swrast = SWRAST_CONTEXT(ctx);

+

+   ASSERT(ctx->Polygon.SmoothFlag);

+

+   if (ctx->Texture._EnabledCoordUnits != 0

+       || ctx->FragmentProgram._Current

+       || swrast->_FogEnabled

+       || NEED_SECONDARY_COLOR(ctx)) {

+      SWRAST_CONTEXT(ctx)->Triangle = general_aa_tri;

+   }

+   else {

+      SWRAST_CONTEXT(ctx)->Triangle = rgba_aa_tri;

+   }

+

+   ASSERT(SWRAST_CONTEXT(ctx)->Triangle);

+}

diff --git a/mesalib/src/mesa/swrast/s_aatriangle.h b/mesalib/src/mesa/swrast/s_aatriangle.h
index 9aed41a19..dec637920 100644
--- a/mesalib/src/mesa/swrast/s_aatriangle.h
+++ b/mesalib/src/mesa/swrast/s_aatriangle.h
@@ -1,38 +1,38 @@
-
-/*
- * Mesa 3-D graphics library
- * Version:  3.5
- *
- * Copyright (C) 1999-2001  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.
- */
-
-
-#ifndef S_AATRIANGLE_H
-#define S_AATRIANGLE_H
-
-
-#include "main/mtypes.h"
-
-
-extern void
-_swrast_set_aa_triangle_function(GLcontext *ctx);
-
-
-#endif
+

+/*

+ * Mesa 3-D graphics library

+ * Version:  3.5

+ *

+ * Copyright (C) 1999-2001  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.

+ */

+

+

+#ifndef S_AATRIANGLE_H

+#define S_AATRIANGLE_H

+

+

+struct gl_context;

+

+

+extern void

+_swrast_set_aa_triangle_function(struct gl_context *ctx);

+

+

+#endif

diff --git a/mesalib/src/mesa/swrast/s_aatritemp.h b/mesalib/src/mesa/swrast/s_aatritemp.h
index 5c1c6d904..4136df3a7 100644
--- a/mesalib/src/mesa/swrast/s_aatritemp.h
+++ b/mesalib/src/mesa/swrast/s_aatritemp.h
@@ -1,331 +1,331 @@
-/*
- * Mesa 3-D graphics library
- * Version:  7.0.3
- *
- * 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.
- */
-
-
-/*
- * Antialiased Triangle Rasterizer Template
- *
- * This file is #include'd to generate custom AA triangle rasterizers.
- * NOTE: this code hasn't been optimized yet.  That'll come after it
- * works correctly.
- *
- * The following macros may be defined to indicate what auxillary information
- * must be copmuted across the triangle:
- *    DO_Z         - if defined, compute Z values
- *    DO_ATTRIBS   - if defined, compute texcoords, varying, etc.
- */
-
-/*void triangle( GLcontext *ctx, GLuint v0, GLuint v1, GLuint v2, GLuint pv )*/
-{
-   const SWcontext *swrast = SWRAST_CONTEXT(ctx);
-   const GLfloat *p0 = v0->attrib[FRAG_ATTRIB_WPOS];
-   const GLfloat *p1 = v1->attrib[FRAG_ATTRIB_WPOS];
-   const GLfloat *p2 = v2->attrib[FRAG_ATTRIB_WPOS];
-   const SWvertex *vMin, *vMid, *vMax;
-   GLint iyMin, iyMax;
-   GLfloat yMin, yMax;
-   GLboolean ltor;
-   GLfloat majDx, majDy;  /* major (i.e. long) edge dx and dy */
-   
-   SWspan span;
-   
-#ifdef DO_Z
-   GLfloat zPlane[4];
-#endif
-   GLfloat rPlane[4], gPlane[4], bPlane[4], aPlane[4];
-#if defined(DO_ATTRIBS)
-   GLfloat attrPlane[FRAG_ATTRIB_MAX][4][4];
-   GLfloat wPlane[4];  /* win[3] */
-#endif
-   GLfloat bf = SWRAST_CONTEXT(ctx)->_BackfaceCullSign;
-   
-   (void) swrast;
-
-   INIT_SPAN(span, GL_POLYGON);
-   span.arrayMask = SPAN_COVERAGE;
-
-   /* determine bottom to top order of vertices */
-   {
-      GLfloat y0 = v0->attrib[FRAG_ATTRIB_WPOS][1];
-      GLfloat y1 = v1->attrib[FRAG_ATTRIB_WPOS][1];
-      GLfloat y2 = v2->attrib[FRAG_ATTRIB_WPOS][1];
-      if (y0 <= y1) {
-	 if (y1 <= y2) {
-	    vMin = v0;   vMid = v1;   vMax = v2;   /* y0<=y1<=y2 */
-	 }
-	 else if (y2 <= y0) {
-	    vMin = v2;   vMid = v0;   vMax = v1;   /* y2<=y0<=y1 */
-	 }
-	 else {
-	    vMin = v0;   vMid = v2;   vMax = v1;  bf = -bf; /* y0<=y2<=y1 */
-	 }
-      }
-      else {
-	 if (y0 <= y2) {
-	    vMin = v1;   vMid = v0;   vMax = v2;  bf = -bf; /* y1<=y0<=y2 */
-	 }
-	 else if (y2 <= y1) {
-	    vMin = v2;   vMid = v1;   vMax = v0;  bf = -bf; /* y2<=y1<=y0 */
-	 }
-	 else {
-	    vMin = v1;   vMid = v2;   vMax = v0;   /* y1<=y2<=y0 */
-	 }
-      }
-   }
-
-   majDx = vMax->attrib[FRAG_ATTRIB_WPOS][0] - vMin->attrib[FRAG_ATTRIB_WPOS][0];
-   majDy = vMax->attrib[FRAG_ATTRIB_WPOS][1] - vMin->attrib[FRAG_ATTRIB_WPOS][1];
-
-   /* front/back-face determination and cullling */
-   {
-      const GLfloat botDx = vMid->attrib[FRAG_ATTRIB_WPOS][0] - vMin->attrib[FRAG_ATTRIB_WPOS][0];
-      const GLfloat botDy = vMid->attrib[FRAG_ATTRIB_WPOS][1] - vMin->attrib[FRAG_ATTRIB_WPOS][1];
-      const GLfloat area = majDx * botDy - botDx * majDy;
-      /* Do backface culling */
-      if (area * bf < 0 || area == 0 || IS_INF_OR_NAN(area))
-	 return;
-      ltor = (GLboolean) (area < 0.0F);
-
-      span.facing = area * swrast->_BackfaceSign > 0.0F;
-   }
-
-   /* Plane equation setup:
-    * We evaluate plane equations at window (x,y) coordinates in order
-    * to compute color, Z, fog, texcoords, etc.  This isn't terribly
-    * efficient but it's easy and reliable.
-    */
-#ifdef DO_Z
-   compute_plane(p0, p1, p2, p0[2], p1[2], p2[2], zPlane);
-   span.arrayMask |= SPAN_Z;
-#endif
-   if (ctx->Light.ShadeModel == GL_SMOOTH) {
-      compute_plane(p0, p1, p2, v0->color[RCOMP], v1->color[RCOMP], v2->color[RCOMP], rPlane);
-      compute_plane(p0, p1, p2, v0->color[GCOMP], v1->color[GCOMP], v2->color[GCOMP], gPlane);
-      compute_plane(p0, p1, p2, v0->color[BCOMP], v1->color[BCOMP], v2->color[BCOMP], bPlane);
-      compute_plane(p0, p1, p2, v0->color[ACOMP], v1->color[ACOMP], v2->color[ACOMP], aPlane);
-   }
-   else {
-      constant_plane(v2->color[RCOMP], rPlane);
-      constant_plane(v2->color[GCOMP], gPlane);
-      constant_plane(v2->color[BCOMP], bPlane);
-      constant_plane(v2->color[ACOMP], aPlane);
-   }
-   span.arrayMask |= SPAN_RGBA;
-#if defined(DO_ATTRIBS)
-   {
-      const GLfloat invW0 = v0->attrib[FRAG_ATTRIB_WPOS][3];
-      const GLfloat invW1 = v1->attrib[FRAG_ATTRIB_WPOS][3];
-      const GLfloat invW2 = v2->attrib[FRAG_ATTRIB_WPOS][3];
-      compute_plane(p0, p1, p2, invW0, invW1, invW2, wPlane);
-      span.attrStepX[FRAG_ATTRIB_WPOS][3] = plane_dx(wPlane);
-      span.attrStepY[FRAG_ATTRIB_WPOS][3] = plane_dy(wPlane);
-      ATTRIB_LOOP_BEGIN
-         GLuint c;
-         if (swrast->_InterpMode[attr] == GL_FLAT) {
-            for (c = 0; c < 4; c++) {
-               constant_plane(v2->attrib[attr][c] * invW2, attrPlane[attr][c]);
-            }
-         }
-         else {
-            for (c = 0; c < 4; c++) {
-               const GLfloat a0 = v0->attrib[attr][c] * invW0;
-               const GLfloat a1 = v1->attrib[attr][c] * invW1;
-               const GLfloat a2 = v2->attrib[attr][c] * invW2;
-               compute_plane(p0, p1, p2, a0, a1, a2, attrPlane[attr][c]);
-            }
-         }
-         for (c = 0; c < 4; c++) {
-            span.attrStepX[attr][c] = plane_dx(attrPlane[attr][c]);
-            span.attrStepY[attr][c] = plane_dy(attrPlane[attr][c]);
-         }
-      ATTRIB_LOOP_END
-   }
-#endif
-
-   /* Begin bottom-to-top scan over the triangle.
-    * The long edge will either be on the left or right side of the
-    * triangle.  We always scan from the long edge toward the shorter
-    * edges, stopping when we find that coverage = 0.  If the long edge
-    * is on the left we scan left-to-right.  Else, we scan right-to-left.
-    */
-   yMin = vMin->attrib[FRAG_ATTRIB_WPOS][1];
-   yMax = vMax->attrib[FRAG_ATTRIB_WPOS][1];
-   iyMin = (GLint) yMin;
-   iyMax = (GLint) yMax + 1;
-
-   if (ltor) {
-      /* scan left to right */
-      const GLfloat *pMin = vMin->attrib[FRAG_ATTRIB_WPOS];
-      const GLfloat *pMid = vMid->attrib[FRAG_ATTRIB_WPOS];
-      const GLfloat *pMax = vMax->attrib[FRAG_ATTRIB_WPOS];
-      const GLfloat dxdy = majDx / majDy;
-      const GLfloat xAdj = dxdy < 0.0F ? -dxdy : 0.0F;
-      GLfloat x = pMin[0] - (yMin - iyMin) * dxdy;
-      GLint iy;
-      for (iy = iyMin; iy < iyMax; iy++, x += dxdy) {
-         GLint ix, startX = (GLint) (x - xAdj);
-         GLuint count;
-         GLfloat coverage = 0.0F;
-
-         /* skip over fragments with zero coverage */
-         while (startX < MAX_WIDTH) {
-            coverage = compute_coveragef(pMin, pMid, pMax, startX, iy);
-            if (coverage > 0.0F)
-               break;
-            startX++;
-         }
-
-         /* enter interior of triangle */
-         ix = startX;
-
-#if defined(DO_ATTRIBS)
-         /* compute attributes at left-most fragment */
-         span.attrStart[FRAG_ATTRIB_WPOS][3] = solve_plane(ix + 0.5F, iy + 0.5F, wPlane);
-         ATTRIB_LOOP_BEGIN
-            GLuint c;
-            for (c = 0; c < 4; c++) {
-               span.attrStart[attr][c] = solve_plane(ix + 0.5F, iy + 0.5F, attrPlane[attr][c]);
-            }
-         ATTRIB_LOOP_END
-#endif
-
-         count = 0;
-         while (coverage > 0.0F) {
-            /* (cx,cy) = center of fragment */
-            const GLfloat cx = ix + 0.5F, cy = iy + 0.5F;
-            SWspanarrays *array = span.array;
-            array->coverage[count] = coverage;
-#ifdef DO_Z
-            array->z[count] = (GLuint) solve_plane(cx, cy, zPlane);
-#endif
-            array->rgba[count][RCOMP] = solve_plane_chan(cx, cy, rPlane);
-            array->rgba[count][GCOMP] = solve_plane_chan(cx, cy, gPlane);
-            array->rgba[count][BCOMP] = solve_plane_chan(cx, cy, bPlane);
-            array->rgba[count][ACOMP] = solve_plane_chan(cx, cy, aPlane);
-            ix++;
-            count++;
-            coverage = compute_coveragef(pMin, pMid, pMax, ix, iy);
-         }
-         
-         if (ix <= startX)
-            continue;
-         
-         span.x = startX;
-         span.y = iy;
-         span.end = (GLuint) ix - (GLuint) startX;
-         _swrast_write_rgba_span(ctx, &span);
-      }
-   }
-   else {
-      /* scan right to left */
-      const GLfloat *pMin = vMin->attrib[FRAG_ATTRIB_WPOS];
-      const GLfloat *pMid = vMid->attrib[FRAG_ATTRIB_WPOS];
-      const GLfloat *pMax = vMax->attrib[FRAG_ATTRIB_WPOS];
-      const GLfloat dxdy = majDx / majDy;
-      const GLfloat xAdj = dxdy > 0 ? dxdy : 0.0F;
-      GLfloat x = pMin[0] - (yMin - iyMin) * dxdy;
-      GLint iy;
-      for (iy = iyMin; iy < iyMax; iy++, x += dxdy) {
-         GLint ix, left, startX = (GLint) (x + xAdj);
-         GLuint count, n;
-         GLfloat coverage = 0.0F;
-         
-         /* make sure we're not past the window edge */
-         if (startX >= ctx->DrawBuffer->_Xmax) {
-            startX = ctx->DrawBuffer->_Xmax - 1;
-         }
-
-         /* skip fragments with zero coverage */
-         while (startX > 0) {
-            coverage = compute_coveragef(pMin, pMax, pMid, startX, iy);
-            if (coverage > 0.0F)
-               break;
-            startX--;
-         }
-         
-         /* enter interior of triangle */
-         ix = startX;
-         count = 0;
-         while (coverage > 0.0F) {
-            /* (cx,cy) = center of fragment */
-            const GLfloat cx = ix + 0.5F, cy = iy + 0.5F;
-            SWspanarrays *array = span.array;
-            ASSERT(ix >= 0);
-            array->coverage[ix] = coverage;
-#ifdef DO_Z
-            array->z[ix] = (GLuint) solve_plane(cx, cy, zPlane);
-#endif
-            array->rgba[ix][RCOMP] = solve_plane_chan(cx, cy, rPlane);
-            array->rgba[ix][GCOMP] = solve_plane_chan(cx, cy, gPlane);
-            array->rgba[ix][BCOMP] = solve_plane_chan(cx, cy, bPlane);
-            array->rgba[ix][ACOMP] = solve_plane_chan(cx, cy, aPlane);
-            ix--;
-            count++;
-            coverage = compute_coveragef(pMin, pMax, pMid, ix, iy);
-         }
-         
-#if defined(DO_ATTRIBS)
-         /* compute attributes at left-most fragment */
-         span.attrStart[FRAG_ATTRIB_WPOS][3] = solve_plane(ix + 1.5F, iy + 0.5F, wPlane);
-         ATTRIB_LOOP_BEGIN
-            GLuint c;
-            for (c = 0; c < 4; c++) {
-               span.attrStart[attr][c] = solve_plane(ix + 1.5F, iy + 0.5F, attrPlane[attr][c]);
-            }
-         ATTRIB_LOOP_END
-#endif
-
-         if (startX <= ix)
-            continue;
-
-         n = (GLuint) startX - (GLuint) ix;
-
-         left = ix + 1;
-
-         /* shift all values to the left */
-         /* XXX this is temporary */
-         {
-            SWspanarrays *array = span.array;
-            GLint j;
-            for (j = 0; j < (GLint) n; j++) {
-               array->coverage[j] = array->coverage[j + left];
-               COPY_CHAN4(array->rgba[j], array->rgba[j + left]);
-#ifdef DO_Z
-               array->z[j] = array->z[j + left];
-#endif
-            }
-         }
-
-         span.x = left;
-         span.y = iy;
-         span.end = n;
-         _swrast_write_rgba_span(ctx, &span);
-      }
-   }
-}
-
-
-#undef DO_Z
-#undef DO_ATTRIBS
-#undef DO_OCCLUSION_TEST
+/*

+ * Mesa 3-D graphics library

+ * Version:  7.0.3

+ *

+ * 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.

+ */

+

+

+/*

+ * Antialiased Triangle Rasterizer Template

+ *

+ * This file is #include'd to generate custom AA triangle rasterizers.

+ * NOTE: this code hasn't been optimized yet.  That'll come after it

+ * works correctly.

+ *

+ * The following macros may be defined to indicate what auxillary information

+ * must be copmuted across the triangle:

+ *    DO_Z         - if defined, compute Z values

+ *    DO_ATTRIBS   - if defined, compute texcoords, varying, etc.

+ */

+

+/*void triangle( struct gl_context *ctx, GLuint v0, GLuint v1, GLuint v2, GLuint pv )*/

+{

+   const SWcontext *swrast = SWRAST_CONTEXT(ctx);

+   const GLfloat *p0 = v0->attrib[FRAG_ATTRIB_WPOS];

+   const GLfloat *p1 = v1->attrib[FRAG_ATTRIB_WPOS];

+   const GLfloat *p2 = v2->attrib[FRAG_ATTRIB_WPOS];

+   const SWvertex *vMin, *vMid, *vMax;

+   GLint iyMin, iyMax;

+   GLfloat yMin, yMax;

+   GLboolean ltor;

+   GLfloat majDx, majDy;  /* major (i.e. long) edge dx and dy */

+   

+   SWspan span;

+   

+#ifdef DO_Z

+   GLfloat zPlane[4];

+#endif

+   GLfloat rPlane[4], gPlane[4], bPlane[4], aPlane[4];

+#if defined(DO_ATTRIBS)

+   GLfloat attrPlane[FRAG_ATTRIB_MAX][4][4];

+   GLfloat wPlane[4];  /* win[3] */

+#endif

+   GLfloat bf = SWRAST_CONTEXT(ctx)->_BackfaceCullSign;

+   

+   (void) swrast;

+

+   INIT_SPAN(span, GL_POLYGON);

+   span.arrayMask = SPAN_COVERAGE;

+

+   /* determine bottom to top order of vertices */

+   {

+      GLfloat y0 = v0->attrib[FRAG_ATTRIB_WPOS][1];

+      GLfloat y1 = v1->attrib[FRAG_ATTRIB_WPOS][1];

+      GLfloat y2 = v2->attrib[FRAG_ATTRIB_WPOS][1];

+      if (y0 <= y1) {

+	 if (y1 <= y2) {

+	    vMin = v0;   vMid = v1;   vMax = v2;   /* y0<=y1<=y2 */

+	 }

+	 else if (y2 <= y0) {

+	    vMin = v2;   vMid = v0;   vMax = v1;   /* y2<=y0<=y1 */

+	 }

+	 else {

+	    vMin = v0;   vMid = v2;   vMax = v1;  bf = -bf; /* y0<=y2<=y1 */

+	 }

+      }

+      else {

+	 if (y0 <= y2) {

+	    vMin = v1;   vMid = v0;   vMax = v2;  bf = -bf; /* y1<=y0<=y2 */

+	 }

+	 else if (y2 <= y1) {

+	    vMin = v2;   vMid = v1;   vMax = v0;  bf = -bf; /* y2<=y1<=y0 */

+	 }

+	 else {

+	    vMin = v1;   vMid = v2;   vMax = v0;   /* y1<=y2<=y0 */

+	 }

+      }

+   }

+

+   majDx = vMax->attrib[FRAG_ATTRIB_WPOS][0] - vMin->attrib[FRAG_ATTRIB_WPOS][0];

+   majDy = vMax->attrib[FRAG_ATTRIB_WPOS][1] - vMin->attrib[FRAG_ATTRIB_WPOS][1];

+

+   /* front/back-face determination and cullling */

+   {

+      const GLfloat botDx = vMid->attrib[FRAG_ATTRIB_WPOS][0] - vMin->attrib[FRAG_ATTRIB_WPOS][0];

+      const GLfloat botDy = vMid->attrib[FRAG_ATTRIB_WPOS][1] - vMin->attrib[FRAG_ATTRIB_WPOS][1];

+      const GLfloat area = majDx * botDy - botDx * majDy;

+      /* Do backface culling */

+      if (area * bf < 0 || area == 0 || IS_INF_OR_NAN(area))

+	 return;

+      ltor = (GLboolean) (area < 0.0F);

+

+      span.facing = area * swrast->_BackfaceSign > 0.0F;

+   }

+

+   /* Plane equation setup:

+    * We evaluate plane equations at window (x,y) coordinates in order

+    * to compute color, Z, fog, texcoords, etc.  This isn't terribly

+    * efficient but it's easy and reliable.

+    */

+#ifdef DO_Z

+   compute_plane(p0, p1, p2, p0[2], p1[2], p2[2], zPlane);

+   span.arrayMask |= SPAN_Z;

+#endif

+   if (ctx->Light.ShadeModel == GL_SMOOTH) {

+      compute_plane(p0, p1, p2, v0->color[RCOMP], v1->color[RCOMP], v2->color[RCOMP], rPlane);

+      compute_plane(p0, p1, p2, v0->color[GCOMP], v1->color[GCOMP], v2->color[GCOMP], gPlane);

+      compute_plane(p0, p1, p2, v0->color[BCOMP], v1->color[BCOMP], v2->color[BCOMP], bPlane);

+      compute_plane(p0, p1, p2, v0->color[ACOMP], v1->color[ACOMP], v2->color[ACOMP], aPlane);

+   }

+   else {

+      constant_plane(v2->color[RCOMP], rPlane);

+      constant_plane(v2->color[GCOMP], gPlane);

+      constant_plane(v2->color[BCOMP], bPlane);

+      constant_plane(v2->color[ACOMP], aPlane);

+   }

+   span.arrayMask |= SPAN_RGBA;

+#if defined(DO_ATTRIBS)

+   {

+      const GLfloat invW0 = v0->attrib[FRAG_ATTRIB_WPOS][3];

+      const GLfloat invW1 = v1->attrib[FRAG_ATTRIB_WPOS][3];

+      const GLfloat invW2 = v2->attrib[FRAG_ATTRIB_WPOS][3];

+      compute_plane(p0, p1, p2, invW0, invW1, invW2, wPlane);

+      span.attrStepX[FRAG_ATTRIB_WPOS][3] = plane_dx(wPlane);

+      span.attrStepY[FRAG_ATTRIB_WPOS][3] = plane_dy(wPlane);

+      ATTRIB_LOOP_BEGIN

+         GLuint c;

+         if (swrast->_InterpMode[attr] == GL_FLAT) {

+            for (c = 0; c < 4; c++) {

+               constant_plane(v2->attrib[attr][c] * invW2, attrPlane[attr][c]);

+            }

+         }

+         else {

+            for (c = 0; c < 4; c++) {

+               const GLfloat a0 = v0->attrib[attr][c] * invW0;

+               const GLfloat a1 = v1->attrib[attr][c] * invW1;

+               const GLfloat a2 = v2->attrib[attr][c] * invW2;

+               compute_plane(p0, p1, p2, a0, a1, a2, attrPlane[attr][c]);

+            }

+         }

+         for (c = 0; c < 4; c++) {

+            span.attrStepX[attr][c] = plane_dx(attrPlane[attr][c]);

+            span.attrStepY[attr][c] = plane_dy(attrPlane[attr][c]);

+         }

+      ATTRIB_LOOP_END

+   }

+#endif

+

+   /* Begin bottom-to-top scan over the triangle.

+    * The long edge will either be on the left or right side of the

+    * triangle.  We always scan from the long edge toward the shorter

+    * edges, stopping when we find that coverage = 0.  If the long edge

+    * is on the left we scan left-to-right.  Else, we scan right-to-left.

+    */

+   yMin = vMin->attrib[FRAG_ATTRIB_WPOS][1];

+   yMax = vMax->attrib[FRAG_ATTRIB_WPOS][1];

+   iyMin = (GLint) yMin;

+   iyMax = (GLint) yMax + 1;

+

+   if (ltor) {

+      /* scan left to right */

+      const GLfloat *pMin = vMin->attrib[FRAG_ATTRIB_WPOS];

+      const GLfloat *pMid = vMid->attrib[FRAG_ATTRIB_WPOS];

+      const GLfloat *pMax = vMax->attrib[FRAG_ATTRIB_WPOS];

+      const GLfloat dxdy = majDx / majDy;

+      const GLfloat xAdj = dxdy < 0.0F ? -dxdy : 0.0F;

+      GLfloat x = pMin[0] - (yMin - iyMin) * dxdy;

+      GLint iy;

+      for (iy = iyMin; iy < iyMax; iy++, x += dxdy) {

+         GLint ix, startX = (GLint) (x - xAdj);

+         GLuint count;

+         GLfloat coverage = 0.0F;

+

+         /* skip over fragments with zero coverage */

+         while (startX < MAX_WIDTH) {

+            coverage = compute_coveragef(pMin, pMid, pMax, startX, iy);

+            if (coverage > 0.0F)

+               break;

+            startX++;

+         }

+

+         /* enter interior of triangle */

+         ix = startX;

+

+#if defined(DO_ATTRIBS)

+         /* compute attributes at left-most fragment */

+         span.attrStart[FRAG_ATTRIB_WPOS][3] = solve_plane(ix + 0.5F, iy + 0.5F, wPlane);

+         ATTRIB_LOOP_BEGIN

+            GLuint c;

+            for (c = 0; c < 4; c++) {

+               span.attrStart[attr][c] = solve_plane(ix + 0.5F, iy + 0.5F, attrPlane[attr][c]);

+            }

+         ATTRIB_LOOP_END

+#endif

+

+         count = 0;

+         while (coverage > 0.0F) {

+            /* (cx,cy) = center of fragment */

+            const GLfloat cx = ix + 0.5F, cy = iy + 0.5F;

+            SWspanarrays *array = span.array;

+            array->coverage[count] = coverage;

+#ifdef DO_Z

+            array->z[count] = (GLuint) solve_plane(cx, cy, zPlane);

+#endif

+            array->rgba[count][RCOMP] = solve_plane_chan(cx, cy, rPlane);

+            array->rgba[count][GCOMP] = solve_plane_chan(cx, cy, gPlane);

+            array->rgba[count][BCOMP] = solve_plane_chan(cx, cy, bPlane);

+            array->rgba[count][ACOMP] = solve_plane_chan(cx, cy, aPlane);

+            ix++;

+            count++;

+            coverage = compute_coveragef(pMin, pMid, pMax, ix, iy);

+         }

+         

+         if (ix <= startX)

+            continue;

+         

+         span.x = startX;

+         span.y = iy;

+         span.end = (GLuint) ix - (GLuint) startX;

+         _swrast_write_rgba_span(ctx, &span);

+      }

+   }

+   else {

+      /* scan right to left */

+      const GLfloat *pMin = vMin->attrib[FRAG_ATTRIB_WPOS];

+      const GLfloat *pMid = vMid->attrib[FRAG_ATTRIB_WPOS];

+      const GLfloat *pMax = vMax->attrib[FRAG_ATTRIB_WPOS];

+      const GLfloat dxdy = majDx / majDy;

+      const GLfloat xAdj = dxdy > 0 ? dxdy : 0.0F;

+      GLfloat x = pMin[0] - (yMin - iyMin) * dxdy;

+      GLint iy;

+      for (iy = iyMin; iy < iyMax; iy++, x += dxdy) {

+         GLint ix, left, startX = (GLint) (x + xAdj);

+         GLuint count, n;

+         GLfloat coverage = 0.0F;

+         

+         /* make sure we're not past the window edge */

+         if (startX >= ctx->DrawBuffer->_Xmax) {

+            startX = ctx->DrawBuffer->_Xmax - 1;

+         }

+

+         /* skip fragments with zero coverage */

+         while (startX > 0) {

+            coverage = compute_coveragef(pMin, pMax, pMid, startX, iy);

+            if (coverage > 0.0F)

+               break;

+            startX--;

+         }

+         

+         /* enter interior of triangle */

+         ix = startX;

+         count = 0;

+         while (coverage > 0.0F) {

+            /* (cx,cy) = center of fragment */

+            const GLfloat cx = ix + 0.5F, cy = iy + 0.5F;

+            SWspanarrays *array = span.array;

+            ASSERT(ix >= 0);

+            array->coverage[ix] = coverage;

+#ifdef DO_Z

+            array->z[ix] = (GLuint) solve_plane(cx, cy, zPlane);

+#endif

+            array->rgba[ix][RCOMP] = solve_plane_chan(cx, cy, rPlane);

+            array->rgba[ix][GCOMP] = solve_plane_chan(cx, cy, gPlane);

+            array->rgba[ix][BCOMP] = solve_plane_chan(cx, cy, bPlane);

+            array->rgba[ix][ACOMP] = solve_plane_chan(cx, cy, aPlane);

+            ix--;

+            count++;

+            coverage = compute_coveragef(pMin, pMax, pMid, ix, iy);

+         }

+         

+#if defined(DO_ATTRIBS)

+         /* compute attributes at left-most fragment */

+         span.attrStart[FRAG_ATTRIB_WPOS][3] = solve_plane(ix + 1.5F, iy + 0.5F, wPlane);

+         ATTRIB_LOOP_BEGIN

+            GLuint c;

+            for (c = 0; c < 4; c++) {

+               span.attrStart[attr][c] = solve_plane(ix + 1.5F, iy + 0.5F, attrPlane[attr][c]);

+            }

+         ATTRIB_LOOP_END

+#endif

+

+         if (startX <= ix)

+            continue;

+

+         n = (GLuint) startX - (GLuint) ix;

+

+         left = ix + 1;

+

+         /* shift all values to the left */

+         /* XXX this is temporary */

+         {

+            SWspanarrays *array = span.array;

+            GLint j;

+            for (j = 0; j < (GLint) n; j++) {

+               array->coverage[j] = array->coverage[j + left];

+               COPY_CHAN4(array->rgba[j], array->rgba[j + left]);

+#ifdef DO_Z

+               array->z[j] = array->z[j + left];

+#endif

+            }

+         }

+

+         span.x = left;

+         span.y = iy;

+         span.end = n;

+         _swrast_write_rgba_span(ctx, &span);

+      }

+   }

+}

+

+

+#undef DO_Z

+#undef DO_ATTRIBS

+#undef DO_OCCLUSION_TEST

diff --git a/mesalib/src/mesa/swrast/s_accum.c b/mesalib/src/mesa/swrast/s_accum.c
index 854e106b7..560a1d143 100644
--- a/mesalib/src/mesa/swrast/s_accum.c
+++ b/mesalib/src/mesa/swrast/s_accum.c
@@ -1,594 +1,594 @@
-/*
- * Mesa 3-D graphics library
- * Version:  6.5.2
- *
- * Copyright (C) 1999-2006  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/context.h"
-#include "main/macros.h"
-#include "main/imports.h"
-
-#include "s_accum.h"
-#include "s_context.h"
-#include "s_masking.h"
-#include "s_span.h"
-
-
-/* XXX this would have to change for accum buffers with more or less
- * than 16 bits per color channel.
- */
-#define ACCUM_SCALE16 32767.0F
-
-
-/*
- * Accumulation buffer notes
- *
- * Normally, accumulation buffer values are GLshorts with values in
- * [-32767, 32767] which represent floating point colors in [-1, 1],
- * as defined by the OpenGL specification.
- *
- * We optimize for the common case used for full-scene antialiasing:
- *    // start with accum buffer cleared to zero
- *    glAccum(GL_LOAD, w);   // or GL_ACCUM the first image
- *    glAccum(GL_ACCUM, w);
- *    ...
- *    glAccum(GL_ACCUM, w);
- *    glAccum(GL_RETURN, 1.0);
- * That is, we start with an empty accumulation buffer and accumulate
- * n images, each with weight w = 1/n.
- * In this scenario, we can simply store unscaled integer values in
- * the accum buffer instead of scaled integers.  We'll also keep track
- * of the w value so when we do GL_RETURN we simply divide the accumulated
- * values by n (n=1/w).
- * This lets us avoid _many_ int->float->int conversions.
- */
-
-
-#if CHAN_BITS == 8
-/* enable the optimization */
-#define USE_OPTIMIZED_ACCUM  1
-#else
-#define USE_OPTIMIZED_ACCUM  0
-#endif
-
-
-/**
- * This is called when we fall out of optimized/unscaled accum buffer mode.
- * That is, we convert each unscaled accum buffer value into a scaled value
- * representing the range[-1, 1].
- */
-static void
-rescale_accum( GLcontext *ctx )
-{
-   SWcontext *swrast = SWRAST_CONTEXT(ctx);
-   struct gl_renderbuffer *rb
-      = ctx->DrawBuffer->Attachment[BUFFER_ACCUM].Renderbuffer;
-   const GLfloat s = swrast->_IntegerAccumScaler * (32767.0F / CHAN_MAXF);
-
-   assert(rb);
-   assert(rb->_BaseFormat == GL_RGBA);
-   /* add other types in future? */
-   assert(rb->DataType == GL_SHORT || rb->DataType == GL_UNSIGNED_SHORT);
-   assert(swrast->_IntegerAccumMode);
-
-   if (rb->GetPointer(ctx, rb, 0, 0)) {
-      /* directly-addressable memory */
-      GLuint y;
-      for (y = 0; y < rb->Height; y++) {
-         GLuint i;
-         GLshort *acc = (GLshort *) rb->GetPointer(ctx, rb, 0, y);
-         for (i = 0; i < 4 * rb->Width; i++) {
-            acc[i] = (GLshort) (acc[i] * s);
-         }
-      }
-   }
-   else {
-      /* use get/put row funcs */
-      GLuint y;
-      for (y = 0; y < rb->Height; y++) {
-         GLshort accRow[MAX_WIDTH * 4];
-         GLuint i;
-         rb->GetRow(ctx, rb, rb->Width, 0, y, accRow);
-         for (i = 0; i < 4 * rb->Width; i++) {
-            accRow[i] = (GLshort) (accRow[i] * s);
-         }
-         rb->PutRow(ctx, rb, rb->Width, 0, y, accRow, NULL);
-      }
-   }
-
-   swrast->_IntegerAccumMode = GL_FALSE;
-}
-
-
-
-/**
- * Clear the accumulation Buffer.
- */
-void
-_swrast_clear_accum_buffer( GLcontext *ctx, struct gl_renderbuffer *rb )
-{
-   SWcontext *swrast = SWRAST_CONTEXT(ctx);
-   GLuint x, y, width, height;
-
-   /* No accumulation buffer! Not an error. */
-   if (!rb || !rb->Data)
-      return;
-
-   assert(rb->_BaseFormat == GL_RGBA);
-   /* add other types in future? */
-   assert(rb->DataType == GL_SHORT || rb->DataType == GL_UNSIGNED_SHORT);
-
-   /* bounds, with scissor */
-   x = ctx->DrawBuffer->_Xmin;
-   y = ctx->DrawBuffer->_Ymin;
-   width = ctx->DrawBuffer->_Xmax - ctx->DrawBuffer->_Xmin;
-   height = ctx->DrawBuffer->_Ymax - ctx->DrawBuffer->_Ymin;
-
-   if (rb->DataType == GL_SHORT || rb->DataType == GL_UNSIGNED_SHORT) {
-      const GLfloat accScale = 32767.0;
-      GLshort clearVal[4];
-      GLuint i;
-
-      clearVal[0] = (GLshort) (ctx->Accum.ClearColor[0] * accScale);
-      clearVal[1] = (GLshort) (ctx->Accum.ClearColor[1] * accScale);
-      clearVal[2] = (GLshort) (ctx->Accum.ClearColor[2] * accScale);
-      clearVal[3] = (GLshort) (ctx->Accum.ClearColor[3] * accScale);
-
-      for (i = 0; i < height; i++) {
-         rb->PutMonoRow(ctx, rb, width, x, y + i, clearVal, NULL);
-      }
-   }
-   else {
-      /* someday support other sizes */
-   }
-
-   /* update optimized accum state vars */
-   if (ctx->Accum.ClearColor[0] == 0.0 && ctx->Accum.ClearColor[1] == 0.0 &&
-       ctx->Accum.ClearColor[2] == 0.0 && ctx->Accum.ClearColor[3] == 0.0) {
-#if USE_OPTIMIZED_ACCUM
-      swrast->_IntegerAccumMode = GL_TRUE;
-#else
-      swrast->_IntegerAccumMode = GL_FALSE;
-#endif
-      swrast->_IntegerAccumScaler = 0.0;  /* denotes empty accum buffer */
-   }
-   else {
-      swrast->_IntegerAccumMode = GL_FALSE;
-   }
-}
-
-
-static void
-accum_add(GLcontext *ctx, GLfloat value,
-          GLint xpos, GLint ypos, GLint width, GLint height )
-{
-   SWcontext *swrast = SWRAST_CONTEXT(ctx);
-   struct gl_renderbuffer *rb
-      = ctx->DrawBuffer->Attachment[BUFFER_ACCUM].Renderbuffer;
-
-   assert(rb);
-
-   /* Leave optimized accum buffer mode */
-   if (swrast->_IntegerAccumMode)
-      rescale_accum(ctx);
-
-   if (rb->DataType == GL_SHORT || rb->DataType == GL_UNSIGNED_SHORT) {
-      const GLshort incr = (GLshort) (value * ACCUM_SCALE16);
-      if (rb->GetPointer(ctx, rb, 0, 0)) {
-         GLint i, j;
-         for (i = 0; i < height; i++) {
-            GLshort *acc = (GLshort *) rb->GetPointer(ctx, rb, xpos, ypos + i);
-            for (j = 0; j < 4 * width; j++) {
-               acc[j] += incr;
-            }
-         }
-      }
-      else {
-         GLint i, j;
-         for (i = 0; i < height; i++) {
-            GLshort accRow[4 * MAX_WIDTH];
-            rb->GetRow(ctx, rb, width, xpos, ypos + i, accRow);
-            for (j = 0; j < 4 * width; j++) {
-               accRow[j] += incr;
-            }
-            rb->PutRow(ctx, rb, width, xpos, ypos + i, accRow, NULL);
-         }
-      }
-   }
-   else {
-      /* other types someday */
-   }
-}
-
-
-static void
-accum_mult(GLcontext *ctx, GLfloat mult,
-           GLint xpos, GLint ypos, GLint width, GLint height )
-{
-   SWcontext *swrast = SWRAST_CONTEXT(ctx);
-   struct gl_renderbuffer *rb
-      = ctx->DrawBuffer->Attachment[BUFFER_ACCUM].Renderbuffer;
-
-   assert(rb);
-
-   /* Leave optimized accum buffer mode */
-   if (swrast->_IntegerAccumMode)
-      rescale_accum(ctx);
-
-   if (rb->DataType == GL_SHORT || rb->DataType == GL_UNSIGNED_SHORT) {
-      if (rb->GetPointer(ctx, rb, 0, 0)) {
-         GLint i, j;
-         for (i = 0; i < height; i++) {
-            GLshort *acc = (GLshort *) rb->GetPointer(ctx, rb, xpos, ypos + i);
-            for (j = 0; j < 4 * width; j++) {
-               acc[j] = (GLshort) (acc[j] * mult);
-            }
-         }
-      }
-      else {
-         GLint i, j;
-         for (i = 0; i < height; i++) {
-            GLshort accRow[4 * MAX_WIDTH];
-            rb->GetRow(ctx, rb, width, xpos, ypos + i, accRow);
-            for (j = 0; j < 4 * width; j++) {
-               accRow[j] = (GLshort) (accRow[j] * mult);
-            }
-            rb->PutRow(ctx, rb, width, xpos, ypos + i, accRow, NULL);
-         }
-      }
-   }
-   else {
-      /* other types someday */
-   }
-}
-
-
-
-static void
-accum_accum(GLcontext *ctx, GLfloat value,
-            GLint xpos, GLint ypos, GLint width, GLint height )
-{
-   SWcontext *swrast = SWRAST_CONTEXT(ctx);
-   struct gl_renderbuffer *rb
-      = ctx->DrawBuffer->Attachment[BUFFER_ACCUM].Renderbuffer;
-   const GLboolean directAccess = (rb->GetPointer(ctx, rb, 0, 0) != NULL);
-
-   assert(rb);
-
-   if (!ctx->ReadBuffer->_ColorReadBuffer) {
-      /* no read buffer - OK */
-      return;
-   }
-
-   /* May have to leave optimized accum buffer mode */
-   if (swrast->_IntegerAccumScaler == 0.0 && value > 0.0 && value <= 1.0)
-      swrast->_IntegerAccumScaler = value;
-   if (swrast->_IntegerAccumMode && value != swrast->_IntegerAccumScaler)
-      rescale_accum(ctx);
-
-   if (rb->DataType == GL_SHORT || rb->DataType == GL_UNSIGNED_SHORT) {
-      const GLfloat scale = value * ACCUM_SCALE16 / CHAN_MAXF;
-      GLshort accumRow[4 * MAX_WIDTH];
-      GLchan rgba[MAX_WIDTH][4];
-      GLint i;
-
-      for (i = 0; i < height; i++) {
-         GLshort *acc;
-         if (directAccess) {
-            acc = (GLshort *) rb->GetPointer(ctx, rb, xpos, ypos + i);
-         }
-         else {
-            rb->GetRow(ctx, rb, width, xpos, ypos + i, accumRow);
-            acc = accumRow;
-         }
-
-         /* read colors from color buffer */
-         _swrast_read_rgba_span(ctx, ctx->ReadBuffer->_ColorReadBuffer, width,
-                                xpos, ypos + i, CHAN_TYPE, rgba);
-
-         /* do accumulation */
-         if (swrast->_IntegerAccumMode) {
-            /* simply add integer color values into accum buffer */
-            GLint j;
-            for (j = 0; j < width; j++) {
-               acc[j * 4 + 0] += rgba[j][RCOMP];
-               acc[j * 4 + 1] += rgba[j][GCOMP];
-               acc[j * 4 + 2] += rgba[j][BCOMP];
-               acc[j * 4 + 3] += rgba[j][ACOMP];
-            }
-         }
-         else {
-            /* scaled integer (or float) accum buffer */
-            GLint j;
-            for (j = 0; j < width; j++) {
-               acc[j * 4 + 0] += (GLshort) ((GLfloat) rgba[j][RCOMP] * scale);
-               acc[j * 4 + 1] += (GLshort) ((GLfloat) rgba[j][GCOMP] * scale);
-               acc[j * 4 + 2] += (GLshort) ((GLfloat) rgba[j][BCOMP] * scale);
-               acc[j * 4 + 3] += (GLshort) ((GLfloat) rgba[j][ACOMP] * scale);
-            }
-         }
-
-         if (!directAccess) {
-            rb->PutRow(ctx, rb, width, xpos, ypos + i, accumRow, NULL);
-         }
-      }
-   }
-   else {
-      /* other types someday */
-   }
-}
-
-
-
-static void
-accum_load(GLcontext *ctx, GLfloat value,
-           GLint xpos, GLint ypos, GLint width, GLint height )
-{
-   SWcontext *swrast = SWRAST_CONTEXT(ctx);
-   struct gl_renderbuffer *rb
-      = ctx->DrawBuffer->Attachment[BUFFER_ACCUM].Renderbuffer;
-   const GLboolean directAccess = (rb->GetPointer(ctx, rb, 0, 0) != NULL);
-
-   assert(rb);
-
-   if (!ctx->ReadBuffer->_ColorReadBuffer) {
-      /* no read buffer - OK */
-      return;
-   }
-
-   /* This is a change to go into optimized accum buffer mode */
-   if (value > 0.0 && value <= 1.0) {
-#if USE_OPTIMIZED_ACCUM
-      swrast->_IntegerAccumMode = GL_TRUE;
-#else
-      swrast->_IntegerAccumMode = GL_FALSE;
-#endif
-      swrast->_IntegerAccumScaler = value;
-   }
-   else {
-      swrast->_IntegerAccumMode = GL_FALSE;
-      swrast->_IntegerAccumScaler = 0.0;
-   }
-
-   if (rb->DataType == GL_SHORT || rb->DataType == GL_UNSIGNED_SHORT) {
-      const GLfloat scale = value * ACCUM_SCALE16 / CHAN_MAXF;
-      GLshort accumRow[4 * MAX_WIDTH];
-      GLchan rgba[MAX_WIDTH][4];
-      GLint i;
-
-      for (i = 0; i < height; i++) {
-         GLshort *acc;
-         if (directAccess) {
-            acc = (GLshort *) rb->GetPointer(ctx, rb, xpos, ypos + i);
-         }
-         else {
-            rb->GetRow(ctx, rb, width, xpos, ypos + i, accumRow);
-            acc = accumRow;
-         }
-
-         /* read colors from color buffer */
-         _swrast_read_rgba_span(ctx, ctx->ReadBuffer->_ColorReadBuffer, width,
-                                xpos, ypos + i, CHAN_TYPE, rgba);
-
-         /* do load */
-         if (swrast->_IntegerAccumMode) {
-            /* just copy values in */
-            GLint j;
-            assert(swrast->_IntegerAccumScaler > 0.0);
-            assert(swrast->_IntegerAccumScaler <= 1.0);
-            for (j = 0; j < width; j++) {
-               acc[j * 4 + 0] = rgba[j][RCOMP];
-               acc[j * 4 + 1] = rgba[j][GCOMP];
-               acc[j * 4 + 2] = rgba[j][BCOMP];
-               acc[j * 4 + 3] = rgba[j][ACOMP];
-            }
-         }
-         else {
-            /* scaled integer (or float) accum buffer */
-            GLint j;
-            for (j = 0; j < width; j++) {
-               acc[j * 4 + 0] = (GLshort) ((GLfloat) rgba[j][RCOMP] * scale);
-               acc[j * 4 + 1] = (GLshort) ((GLfloat) rgba[j][GCOMP] * scale);
-               acc[j * 4 + 2] = (GLshort) ((GLfloat) rgba[j][BCOMP] * scale);
-               acc[j * 4 + 3] = (GLshort) ((GLfloat) rgba[j][ACOMP] * scale);
-            }
-         }
-
-         if (!directAccess) {
-            rb->PutRow(ctx, rb, width, xpos, ypos + i, accumRow, NULL);
-         }
-      }
-   }
-}
-
-
-static void
-accum_return(GLcontext *ctx, GLfloat value,
-             GLint xpos, GLint ypos, GLint width, GLint height )
-{
-   SWcontext *swrast = SWRAST_CONTEXT(ctx);
-   struct gl_framebuffer *fb = ctx->DrawBuffer;
-   struct gl_renderbuffer *accumRb = fb->Attachment[BUFFER_ACCUM].Renderbuffer;
-   const GLboolean directAccess
-      = (accumRb->GetPointer(ctx, accumRb, 0, 0) != NULL);
-
-   static GLchan multTable[32768];
-   static GLfloat prevMult = 0.0;
-   const GLfloat mult = swrast->_IntegerAccumScaler;
-   const GLint max = MIN2((GLint) (256 / mult), 32767);
-
-   /* May have to leave optimized accum buffer mode */
-   if (swrast->_IntegerAccumMode && value != 1.0)
-      rescale_accum(ctx);
-
-   if (swrast->_IntegerAccumMode && swrast->_IntegerAccumScaler > 0) {
-      /* build lookup table to avoid many floating point multiplies */
-      GLint j;
-      assert(swrast->_IntegerAccumScaler <= 1.0);
-      if (mult != prevMult) {
-         for (j = 0; j < max; j++)
-            multTable[j] = IROUND((GLfloat) j * mult);
-         prevMult = mult;
-      }
-   }
-
-   if (accumRb->DataType == GL_SHORT ||
-       accumRb->DataType == GL_UNSIGNED_SHORT) {
-      const GLfloat scale = value * CHAN_MAXF / ACCUM_SCALE16;
-      GLuint buffer;
-      GLint i;
-
-      /* XXX maybe transpose the 'i' and 'buffer' loops??? */
-      for (i = 0; i < height; i++) {
-         GLshort accumRow[4 * MAX_WIDTH];
-         GLshort *acc;
-         SWspan span;
-
-         /* init color span */
-         INIT_SPAN(span, GL_BITMAP);
-         span.end = width;
-         span.arrayMask = SPAN_RGBA;
-         span.x = xpos;
-         span.y = ypos + i;
-
-         if (directAccess) {
-            acc = (GLshort *) accumRb->GetPointer(ctx, accumRb, xpos, ypos +i);
-         }
-         else {
-            accumRb->GetRow(ctx, accumRb, width, xpos, ypos + i, accumRow);
-            acc = accumRow;
-         }
-
-         /* get the colors to return */
-         if (swrast->_IntegerAccumMode) {
-            GLint j;
-            for (j = 0; j < width; j++) {
-               ASSERT(acc[j * 4 + 0] < max);
-               ASSERT(acc[j * 4 + 1] < max);
-               ASSERT(acc[j * 4 + 2] < max);
-               ASSERT(acc[j * 4 + 3] < max);
-               span.array->rgba[j][RCOMP] = multTable[acc[j * 4 + 0]];
-               span.array->rgba[j][GCOMP] = multTable[acc[j * 4 + 1]];
-               span.array->rgba[j][BCOMP] = multTable[acc[j * 4 + 2]];
-               span.array->rgba[j][ACOMP] = multTable[acc[j * 4 + 3]];
-            }
-         }
-         else {
-            /* scaled integer (or float) accum buffer */
-            GLint j;
-            for (j = 0; j < width; j++) {
-#if CHAN_BITS==32
-               GLchan r = acc[j * 4 + 0] * scale;
-               GLchan g = acc[j * 4 + 1] * scale;
-               GLchan b = acc[j * 4 + 2] * scale;
-               GLchan a = acc[j * 4 + 3] * scale;
-#else
-               GLint r = IROUND( (GLfloat) (acc[j * 4 + 0]) * scale );
-               GLint g = IROUND( (GLfloat) (acc[j * 4 + 1]) * scale );
-               GLint b = IROUND( (GLfloat) (acc[j * 4 + 2]) * scale );
-               GLint a = IROUND( (GLfloat) (acc[j * 4 + 3]) * scale );
-#endif
-               span.array->rgba[j][RCOMP] = CLAMP( r, 0, CHAN_MAX );
-               span.array->rgba[j][GCOMP] = CLAMP( g, 0, CHAN_MAX );
-               span.array->rgba[j][BCOMP] = CLAMP( b, 0, CHAN_MAX );
-               span.array->rgba[j][ACOMP] = CLAMP( a, 0, CHAN_MAX );
-            }
-         }
-
-         /* store colors */
-         for (buffer = 0; buffer < fb->_NumColorDrawBuffers; buffer++) {
-            struct gl_renderbuffer *rb = fb->_ColorDrawBuffers[buffer];
-            const GLboolean masking = (!ctx->Color.ColorMask[buffer][RCOMP] ||
-                                       !ctx->Color.ColorMask[buffer][GCOMP] ||
-                                       !ctx->Color.ColorMask[buffer][BCOMP] ||
-                                       !ctx->Color.ColorMask[buffer][ACOMP]);
-            if (masking) {
-               _swrast_mask_rgba_span(ctx, rb, &span, buffer);
-            }
-            rb->PutRow(ctx, rb, width, xpos, ypos + i, span.array->rgba, NULL);
-         }
-      }
-   }
-   else {
-      /* other types someday */
-   }
-}
-
-
-
-/**
- * Software fallback for glAccum.
- */
-void
-_swrast_Accum(GLcontext *ctx, GLenum op, GLfloat value)
-{
-   SWcontext *swrast = SWRAST_CONTEXT(ctx);
-   GLint xpos, ypos, width, height;
-
-   if (swrast->NewState)
-      _swrast_validate_derived( ctx );
-
-   if (!ctx->DrawBuffer->Attachment[BUFFER_ACCUM].Renderbuffer) {
-      _mesa_warning(ctx, "Calling glAccum() without an accumulation buffer");
-      return;
-   }
-
-   swrast_render_start(ctx);
-
-   /* Compute region after calling swrast_render_start() so that we know the
-    * drawbuffer's size/bounds are up to date.
-    */
-   xpos = ctx->DrawBuffer->_Xmin;
-   ypos = ctx->DrawBuffer->_Ymin;
-   width =  ctx->DrawBuffer->_Xmax - ctx->DrawBuffer->_Xmin;
-   height = ctx->DrawBuffer->_Ymax - ctx->DrawBuffer->_Ymin;
-
-   switch (op) {
-      case GL_ADD:
-         if (value != 0.0F) {
-            accum_add(ctx, value, xpos, ypos, width, height);
-	 }
-	 break;
-      case GL_MULT:
-         if (value != 1.0F) {
-            accum_mult(ctx, value, xpos, ypos, width, height);
-	 }
-	 break;
-      case GL_ACCUM:
-         if (value != 0.0F) {
-            accum_accum(ctx, value, xpos, ypos, width, height);
-         }
-	 break;
-      case GL_LOAD:
-         accum_load(ctx, value, xpos, ypos, width, height);
-	 break;
-      case GL_RETURN:
-         accum_return(ctx, value, xpos, ypos, width, height);
-	 break;
-      default:
-         _mesa_problem(ctx, "invalid mode in _swrast_Accum()");
-         break;
-   }
-
-   swrast_render_finish(ctx);
-}
+/*

+ * Mesa 3-D graphics library

+ * Version:  6.5.2

+ *

+ * Copyright (C) 1999-2006  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/context.h"

+#include "main/macros.h"

+#include "main/imports.h"

+

+#include "s_accum.h"

+#include "s_context.h"

+#include "s_masking.h"

+#include "s_span.h"

+

+

+/* XXX this would have to change for accum buffers with more or less

+ * than 16 bits per color channel.

+ */

+#define ACCUM_SCALE16 32767.0F

+

+

+/*

+ * Accumulation buffer notes

+ *

+ * Normally, accumulation buffer values are GLshorts with values in

+ * [-32767, 32767] which represent floating point colors in [-1, 1],

+ * as defined by the OpenGL specification.

+ *

+ * We optimize for the common case used for full-scene antialiasing:

+ *    // start with accum buffer cleared to zero

+ *    glAccum(GL_LOAD, w);   // or GL_ACCUM the first image

+ *    glAccum(GL_ACCUM, w);

+ *    ...

+ *    glAccum(GL_ACCUM, w);

+ *    glAccum(GL_RETURN, 1.0);

+ * That is, we start with an empty accumulation buffer and accumulate

+ * n images, each with weight w = 1/n.

+ * In this scenario, we can simply store unscaled integer values in

+ * the accum buffer instead of scaled integers.  We'll also keep track

+ * of the w value so when we do GL_RETURN we simply divide the accumulated

+ * values by n (n=1/w).

+ * This lets us avoid _many_ int->float->int conversions.

+ */

+

+

+#if CHAN_BITS == 8

+/* enable the optimization */

+#define USE_OPTIMIZED_ACCUM  1

+#else

+#define USE_OPTIMIZED_ACCUM  0

+#endif

+

+

+/**

+ * This is called when we fall out of optimized/unscaled accum buffer mode.

+ * That is, we convert each unscaled accum buffer value into a scaled value

+ * representing the range[-1, 1].

+ */

+static void

+rescale_accum( struct gl_context *ctx )

+{

+   SWcontext *swrast = SWRAST_CONTEXT(ctx);

+   struct gl_renderbuffer *rb

+      = ctx->DrawBuffer->Attachment[BUFFER_ACCUM].Renderbuffer;

+   const GLfloat s = swrast->_IntegerAccumScaler * (32767.0F / CHAN_MAXF);

+

+   assert(rb);

+   assert(rb->_BaseFormat == GL_RGBA);

+   /* add other types in future? */

+   assert(rb->DataType == GL_SHORT || rb->DataType == GL_UNSIGNED_SHORT);

+   assert(swrast->_IntegerAccumMode);

+

+   if (rb->GetPointer(ctx, rb, 0, 0)) {

+      /* directly-addressable memory */

+      GLuint y;

+      for (y = 0; y < rb->Height; y++) {

+         GLuint i;

+         GLshort *acc = (GLshort *) rb->GetPointer(ctx, rb, 0, y);

+         for (i = 0; i < 4 * rb->Width; i++) {

+            acc[i] = (GLshort) (acc[i] * s);

+         }

+      }

+   }

+   else {

+      /* use get/put row funcs */

+      GLuint y;

+      for (y = 0; y < rb->Height; y++) {

+         GLshort accRow[MAX_WIDTH * 4];

+         GLuint i;

+         rb->GetRow(ctx, rb, rb->Width, 0, y, accRow);

+         for (i = 0; i < 4 * rb->Width; i++) {

+            accRow[i] = (GLshort) (accRow[i] * s);

+         }

+         rb->PutRow(ctx, rb, rb->Width, 0, y, accRow, NULL);

+      }

+   }

+

+   swrast->_IntegerAccumMode = GL_FALSE;

+}

+

+

+

+/**

+ * Clear the accumulation Buffer.

+ */

+void

+_swrast_clear_accum_buffer( struct gl_context *ctx, struct gl_renderbuffer *rb )

+{

+   SWcontext *swrast = SWRAST_CONTEXT(ctx);

+   GLuint x, y, width, height;

+

+   /* No accumulation buffer! Not an error. */

+   if (!rb || !rb->Data)

+      return;

+

+   assert(rb->_BaseFormat == GL_RGBA);

+   /* add other types in future? */

+   assert(rb->DataType == GL_SHORT || rb->DataType == GL_UNSIGNED_SHORT);

+

+   /* bounds, with scissor */

+   x = ctx->DrawBuffer->_Xmin;

+   y = ctx->DrawBuffer->_Ymin;

+   width = ctx->DrawBuffer->_Xmax - ctx->DrawBuffer->_Xmin;

+   height = ctx->DrawBuffer->_Ymax - ctx->DrawBuffer->_Ymin;

+

+   if (rb->DataType == GL_SHORT || rb->DataType == GL_UNSIGNED_SHORT) {

+      const GLfloat accScale = 32767.0;

+      GLshort clearVal[4];

+      GLuint i;

+

+      clearVal[0] = (GLshort) (ctx->Accum.ClearColor[0] * accScale);

+      clearVal[1] = (GLshort) (ctx->Accum.ClearColor[1] * accScale);

+      clearVal[2] = (GLshort) (ctx->Accum.ClearColor[2] * accScale);

+      clearVal[3] = (GLshort) (ctx->Accum.ClearColor[3] * accScale);

+

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

+         rb->PutMonoRow(ctx, rb, width, x, y + i, clearVal, NULL);

+      }

+   }

+   else {

+      /* someday support other sizes */

+   }

+

+   /* update optimized accum state vars */

+   if (ctx->Accum.ClearColor[0] == 0.0 && ctx->Accum.ClearColor[1] == 0.0 &&

+       ctx->Accum.ClearColor[2] == 0.0 && ctx->Accum.ClearColor[3] == 0.0) {

+#if USE_OPTIMIZED_ACCUM

+      swrast->_IntegerAccumMode = GL_TRUE;

+#else

+      swrast->_IntegerAccumMode = GL_FALSE;

+#endif

+      swrast->_IntegerAccumScaler = 0.0;  /* denotes empty accum buffer */

+   }

+   else {

+      swrast->_IntegerAccumMode = GL_FALSE;

+   }

+}

+

+

+static void

+accum_add(struct gl_context *ctx, GLfloat value,

+          GLint xpos, GLint ypos, GLint width, GLint height )

+{

+   SWcontext *swrast = SWRAST_CONTEXT(ctx);

+   struct gl_renderbuffer *rb

+      = ctx->DrawBuffer->Attachment[BUFFER_ACCUM].Renderbuffer;

+

+   assert(rb);

+

+   /* Leave optimized accum buffer mode */

+   if (swrast->_IntegerAccumMode)

+      rescale_accum(ctx);

+

+   if (rb->DataType == GL_SHORT || rb->DataType == GL_UNSIGNED_SHORT) {

+      const GLshort incr = (GLshort) (value * ACCUM_SCALE16);

+      if (rb->GetPointer(ctx, rb, 0, 0)) {

+         GLint i, j;

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

+            GLshort *acc = (GLshort *) rb->GetPointer(ctx, rb, xpos, ypos + i);

+            for (j = 0; j < 4 * width; j++) {

+               acc[j] += incr;

+            }

+         }

+      }

+      else {

+         GLint i, j;

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

+            GLshort accRow[4 * MAX_WIDTH];

+            rb->GetRow(ctx, rb, width, xpos, ypos + i, accRow);

+            for (j = 0; j < 4 * width; j++) {

+               accRow[j] += incr;

+            }

+            rb->PutRow(ctx, rb, width, xpos, ypos + i, accRow, NULL);

+         }

+      }

+   }

+   else {

+      /* other types someday */

+   }

+}

+

+

+static void

+accum_mult(struct gl_context *ctx, GLfloat mult,

+           GLint xpos, GLint ypos, GLint width, GLint height )

+{

+   SWcontext *swrast = SWRAST_CONTEXT(ctx);

+   struct gl_renderbuffer *rb

+      = ctx->DrawBuffer->Attachment[BUFFER_ACCUM].Renderbuffer;

+

+   assert(rb);

+

+   /* Leave optimized accum buffer mode */

+   if (swrast->_IntegerAccumMode)

+      rescale_accum(ctx);

+

+   if (rb->DataType == GL_SHORT || rb->DataType == GL_UNSIGNED_SHORT) {

+      if (rb->GetPointer(ctx, rb, 0, 0)) {

+         GLint i, j;

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

+            GLshort *acc = (GLshort *) rb->GetPointer(ctx, rb, xpos, ypos + i);

+            for (j = 0; j < 4 * width; j++) {

+               acc[j] = (GLshort) (acc[j] * mult);

+            }

+         }

+      }

+      else {

+         GLint i, j;

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

+            GLshort accRow[4 * MAX_WIDTH];

+            rb->GetRow(ctx, rb, width, xpos, ypos + i, accRow);

+            for (j = 0; j < 4 * width; j++) {

+               accRow[j] = (GLshort) (accRow[j] * mult);

+            }

+            rb->PutRow(ctx, rb, width, xpos, ypos + i, accRow, NULL);

+         }

+      }

+   }

+   else {

+      /* other types someday */

+   }

+}

+

+

+

+static void

+accum_accum(struct gl_context *ctx, GLfloat value,

+            GLint xpos, GLint ypos, GLint width, GLint height )

+{

+   SWcontext *swrast = SWRAST_CONTEXT(ctx);

+   struct gl_renderbuffer *rb

+      = ctx->DrawBuffer->Attachment[BUFFER_ACCUM].Renderbuffer;

+   const GLboolean directAccess = (rb->GetPointer(ctx, rb, 0, 0) != NULL);

+

+   assert(rb);

+

+   if (!ctx->ReadBuffer->_ColorReadBuffer) {

+      /* no read buffer - OK */

+      return;

+   }

+

+   /* May have to leave optimized accum buffer mode */

+   if (swrast->_IntegerAccumScaler == 0.0 && value > 0.0 && value <= 1.0)

+      swrast->_IntegerAccumScaler = value;

+   if (swrast->_IntegerAccumMode && value != swrast->_IntegerAccumScaler)

+      rescale_accum(ctx);

+

+   if (rb->DataType == GL_SHORT || rb->DataType == GL_UNSIGNED_SHORT) {

+      const GLfloat scale = value * ACCUM_SCALE16 / CHAN_MAXF;

+      GLshort accumRow[4 * MAX_WIDTH];

+      GLchan rgba[MAX_WIDTH][4];

+      GLint i;

+

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

+         GLshort *acc;

+         if (directAccess) {

+            acc = (GLshort *) rb->GetPointer(ctx, rb, xpos, ypos + i);

+         }

+         else {

+            rb->GetRow(ctx, rb, width, xpos, ypos + i, accumRow);

+            acc = accumRow;

+         }

+

+         /* read colors from color buffer */

+         _swrast_read_rgba_span(ctx, ctx->ReadBuffer->_ColorReadBuffer, width,

+                                xpos, ypos + i, CHAN_TYPE, rgba);

+

+         /* do accumulation */

+         if (swrast->_IntegerAccumMode) {

+            /* simply add integer color values into accum buffer */

+            GLint j;

+            for (j = 0; j < width; j++) {

+               acc[j * 4 + 0] += rgba[j][RCOMP];

+               acc[j * 4 + 1] += rgba[j][GCOMP];

+               acc[j * 4 + 2] += rgba[j][BCOMP];

+               acc[j * 4 + 3] += rgba[j][ACOMP];

+            }

+         }

+         else {

+            /* scaled integer (or float) accum buffer */

+            GLint j;

+            for (j = 0; j < width; j++) {

+               acc[j * 4 + 0] += (GLshort) ((GLfloat) rgba[j][RCOMP] * scale);

+               acc[j * 4 + 1] += (GLshort) ((GLfloat) rgba[j][GCOMP] * scale);

+               acc[j * 4 + 2] += (GLshort) ((GLfloat) rgba[j][BCOMP] * scale);

+               acc[j * 4 + 3] += (GLshort) ((GLfloat) rgba[j][ACOMP] * scale);

+            }

+         }

+

+         if (!directAccess) {

+            rb->PutRow(ctx, rb, width, xpos, ypos + i, accumRow, NULL);

+         }

+      }

+   }

+   else {

+      /* other types someday */

+   }

+}

+

+

+

+static void

+accum_load(struct gl_context *ctx, GLfloat value,

+           GLint xpos, GLint ypos, GLint width, GLint height )

+{

+   SWcontext *swrast = SWRAST_CONTEXT(ctx);

+   struct gl_renderbuffer *rb

+      = ctx->DrawBuffer->Attachment[BUFFER_ACCUM].Renderbuffer;

+   const GLboolean directAccess = (rb->GetPointer(ctx, rb, 0, 0) != NULL);

+

+   assert(rb);

+

+   if (!ctx->ReadBuffer->_ColorReadBuffer) {

+      /* no read buffer - OK */

+      return;

+   }

+

+   /* This is a change to go into optimized accum buffer mode */

+   if (value > 0.0 && value <= 1.0) {

+#if USE_OPTIMIZED_ACCUM

+      swrast->_IntegerAccumMode = GL_TRUE;

+#else

+      swrast->_IntegerAccumMode = GL_FALSE;

+#endif

+      swrast->_IntegerAccumScaler = value;

+   }

+   else {

+      swrast->_IntegerAccumMode = GL_FALSE;

+      swrast->_IntegerAccumScaler = 0.0;

+   }

+

+   if (rb->DataType == GL_SHORT || rb->DataType == GL_UNSIGNED_SHORT) {

+      const GLfloat scale = value * ACCUM_SCALE16 / CHAN_MAXF;

+      GLshort accumRow[4 * MAX_WIDTH];

+      GLchan rgba[MAX_WIDTH][4];

+      GLint i;

+

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

+         GLshort *acc;

+         if (directAccess) {

+            acc = (GLshort *) rb->GetPointer(ctx, rb, xpos, ypos + i);

+         }

+         else {

+            rb->GetRow(ctx, rb, width, xpos, ypos + i, accumRow);

+            acc = accumRow;

+         }

+

+         /* read colors from color buffer */

+         _swrast_read_rgba_span(ctx, ctx->ReadBuffer->_ColorReadBuffer, width,

+                                xpos, ypos + i, CHAN_TYPE, rgba);

+

+         /* do load */

+         if (swrast->_IntegerAccumMode) {

+            /* just copy values in */

+            GLint j;

+            assert(swrast->_IntegerAccumScaler > 0.0);

+            assert(swrast->_IntegerAccumScaler <= 1.0);

+            for (j = 0; j < width; j++) {

+               acc[j * 4 + 0] = rgba[j][RCOMP];

+               acc[j * 4 + 1] = rgba[j][GCOMP];

+               acc[j * 4 + 2] = rgba[j][BCOMP];

+               acc[j * 4 + 3] = rgba[j][ACOMP];

+            }

+         }

+         else {

+            /* scaled integer (or float) accum buffer */

+            GLint j;

+            for (j = 0; j < width; j++) {

+               acc[j * 4 + 0] = (GLshort) ((GLfloat) rgba[j][RCOMP] * scale);

+               acc[j * 4 + 1] = (GLshort) ((GLfloat) rgba[j][GCOMP] * scale);

+               acc[j * 4 + 2] = (GLshort) ((GLfloat) rgba[j][BCOMP] * scale);

+               acc[j * 4 + 3] = (GLshort) ((GLfloat) rgba[j][ACOMP] * scale);

+            }

+         }

+

+         if (!directAccess) {

+            rb->PutRow(ctx, rb, width, xpos, ypos + i, accumRow, NULL);

+         }

+      }

+   }

+}

+

+

+static void

+accum_return(struct gl_context *ctx, GLfloat value,

+             GLint xpos, GLint ypos, GLint width, GLint height )

+{

+   SWcontext *swrast = SWRAST_CONTEXT(ctx);

+   struct gl_framebuffer *fb = ctx->DrawBuffer;

+   struct gl_renderbuffer *accumRb = fb->Attachment[BUFFER_ACCUM].Renderbuffer;

+   const GLboolean directAccess

+      = (accumRb->GetPointer(ctx, accumRb, 0, 0) != NULL);

+

+   static GLchan multTable[32768];

+   static GLfloat prevMult = 0.0;

+   const GLfloat mult = swrast->_IntegerAccumScaler;

+   const GLint max = MIN2((GLint) (256 / mult), 32767);

+

+   /* May have to leave optimized accum buffer mode */

+   if (swrast->_IntegerAccumMode && value != 1.0)

+      rescale_accum(ctx);

+

+   if (swrast->_IntegerAccumMode && swrast->_IntegerAccumScaler > 0) {

+      /* build lookup table to avoid many floating point multiplies */

+      GLint j;

+      assert(swrast->_IntegerAccumScaler <= 1.0);

+      if (mult != prevMult) {

+         for (j = 0; j < max; j++)

+            multTable[j] = IROUND((GLfloat) j * mult);

+         prevMult = mult;

+      }

+   }

+

+   if (accumRb->DataType == GL_SHORT ||

+       accumRb->DataType == GL_UNSIGNED_SHORT) {

+      const GLfloat scale = value * CHAN_MAXF / ACCUM_SCALE16;

+      GLuint buffer;

+      GLint i;

+

+      /* XXX maybe transpose the 'i' and 'buffer' loops??? */

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

+         GLshort accumRow[4 * MAX_WIDTH];

+         GLshort *acc;

+         SWspan span;

+

+         /* init color span */

+         INIT_SPAN(span, GL_BITMAP);

+         span.end = width;

+         span.arrayMask = SPAN_RGBA;

+         span.x = xpos;

+         span.y = ypos + i;

+

+         if (directAccess) {

+            acc = (GLshort *) accumRb->GetPointer(ctx, accumRb, xpos, ypos +i);

+         }

+         else {

+            accumRb->GetRow(ctx, accumRb, width, xpos, ypos + i, accumRow);

+            acc = accumRow;

+         }

+

+         /* get the colors to return */

+         if (swrast->_IntegerAccumMode) {

+            GLint j;

+            for (j = 0; j < width; j++) {

+               ASSERT(acc[j * 4 + 0] < max);

+               ASSERT(acc[j * 4 + 1] < max);

+               ASSERT(acc[j * 4 + 2] < max);

+               ASSERT(acc[j * 4 + 3] < max);

+               span.array->rgba[j][RCOMP] = multTable[acc[j * 4 + 0]];

+               span.array->rgba[j][GCOMP] = multTable[acc[j * 4 + 1]];

+               span.array->rgba[j][BCOMP] = multTable[acc[j * 4 + 2]];

+               span.array->rgba[j][ACOMP] = multTable[acc[j * 4 + 3]];

+            }

+         }

+         else {

+            /* scaled integer (or float) accum buffer */

+            GLint j;

+            for (j = 0; j < width; j++) {

+#if CHAN_BITS==32

+               GLchan r = acc[j * 4 + 0] * scale;

+               GLchan g = acc[j * 4 + 1] * scale;

+               GLchan b = acc[j * 4 + 2] * scale;

+               GLchan a = acc[j * 4 + 3] * scale;

+#else

+               GLint r = IROUND( (GLfloat) (acc[j * 4 + 0]) * scale );

+               GLint g = IROUND( (GLfloat) (acc[j * 4 + 1]) * scale );

+               GLint b = IROUND( (GLfloat) (acc[j * 4 + 2]) * scale );

+               GLint a = IROUND( (GLfloat) (acc[j * 4 + 3]) * scale );

+#endif

+               span.array->rgba[j][RCOMP] = CLAMP( r, 0, CHAN_MAX );

+               span.array->rgba[j][GCOMP] = CLAMP( g, 0, CHAN_MAX );

+               span.array->rgba[j][BCOMP] = CLAMP( b, 0, CHAN_MAX );

+               span.array->rgba[j][ACOMP] = CLAMP( a, 0, CHAN_MAX );

+            }

+         }

+

+         /* store colors */

+         for (buffer = 0; buffer < fb->_NumColorDrawBuffers; buffer++) {

+            struct gl_renderbuffer *rb = fb->_ColorDrawBuffers[buffer];

+            const GLboolean masking = (!ctx->Color.ColorMask[buffer][RCOMP] ||

+                                       !ctx->Color.ColorMask[buffer][GCOMP] ||

+                                       !ctx->Color.ColorMask[buffer][BCOMP] ||

+                                       !ctx->Color.ColorMask[buffer][ACOMP]);

+            if (masking) {

+               _swrast_mask_rgba_span(ctx, rb, &span, buffer);

+            }

+            rb->PutRow(ctx, rb, width, xpos, ypos + i, span.array->rgba, NULL);

+         }

+      }

+   }

+   else {

+      /* other types someday */

+   }

+}

+

+

+

+/**

+ * Software fallback for glAccum.

+ */

+void

+_swrast_Accum(struct gl_context *ctx, GLenum op, GLfloat value)

+{

+   SWcontext *swrast = SWRAST_CONTEXT(ctx);

+   GLint xpos, ypos, width, height;

+

+   if (swrast->NewState)

+      _swrast_validate_derived( ctx );

+

+   if (!ctx->DrawBuffer->Attachment[BUFFER_ACCUM].Renderbuffer) {

+      _mesa_warning(ctx, "Calling glAccum() without an accumulation buffer");

+      return;

+   }

+

+   swrast_render_start(ctx);

+

+   /* Compute region after calling swrast_render_start() so that we know the

+    * drawbuffer's size/bounds are up to date.

+    */

+   xpos = ctx->DrawBuffer->_Xmin;

+   ypos = ctx->DrawBuffer->_Ymin;

+   width =  ctx->DrawBuffer->_Xmax - ctx->DrawBuffer->_Xmin;

+   height = ctx->DrawBuffer->_Ymax - ctx->DrawBuffer->_Ymin;

+

+   switch (op) {

+      case GL_ADD:

+         if (value != 0.0F) {

+            accum_add(ctx, value, xpos, ypos, width, height);

+	 }

+	 break;

+      case GL_MULT:

+         if (value != 1.0F) {

+            accum_mult(ctx, value, xpos, ypos, width, height);

+	 }

+	 break;

+      case GL_ACCUM:

+         if (value != 0.0F) {

+            accum_accum(ctx, value, xpos, ypos, width, height);

+         }

+	 break;

+      case GL_LOAD:

+         accum_load(ctx, value, xpos, ypos, width, height);

+	 break;

+      case GL_RETURN:

+         accum_return(ctx, value, xpos, ypos, width, height);

+	 break;

+      default:

+         _mesa_problem(ctx, "invalid mode in _swrast_Accum()");

+         break;

+   }

+

+   swrast_render_finish(ctx);

+}

diff --git a/mesalib/src/mesa/swrast/s_accum.h b/mesalib/src/mesa/swrast/s_accum.h
index 42e38cf02..bdd6ac326 100644
--- a/mesalib/src/mesa/swrast/s_accum.h
+++ b/mesalib/src/mesa/swrast/s_accum.h
@@ -1,37 +1,38 @@
-/*
- * Mesa 3-D graphics library
- * Version:  6.3
- *
- * Copyright (C) 1999-2005  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.
- */
-
-
-#ifndef S_ACCUM_H
-#define S_ACCUM_H
-
-
-#include "main/mtypes.h"
-
-
-extern void
-_swrast_clear_accum_buffer(GLcontext *ctx, struct gl_renderbuffer *rb);
-
-
-#endif
+/*

+ * Mesa 3-D graphics library

+ * Version:  6.3

+ *

+ * Copyright (C) 1999-2005  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.

+ */

+

+

+#ifndef S_ACCUM_H

+#define S_ACCUM_H

+

+

+struct gl_context;

+struct gl_renderbuffer;

+

+

+extern void

+_swrast_clear_accum_buffer(struct gl_context *ctx, struct gl_renderbuffer *rb);

+

+

+#endif

diff --git a/mesalib/src/mesa/swrast/s_alpha.c b/mesalib/src/mesa/swrast/s_alpha.c
index 509477433..798b506e4 100644
--- a/mesalib/src/mesa/swrast/s_alpha.c
+++ b/mesalib/src/mesa/swrast/s_alpha.c
@@ -1,160 +1,160 @@
-/*
- * Mesa 3-D graphics library
- * Version:  6.5.2
- *
- * Copyright (C) 1999-2006  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.
- */
-
-/**
- * \file swrast/s_alpha.c
- * \brief Functions to apply alpha test.
- */
-
-#include "main/glheader.h"
-#include "main/context.h"
-#include "main/colormac.h"
-#include "main/macros.h"
-
-#include "s_alpha.h"
-#include "s_context.h"
-
-
-#define ALPHA_TEST(ALPHA, LOOP_CODE)		\
-do {						\
-   switch (ctx->Color.AlphaFunc) {		\
-      case GL_LESS:				\
-         for (i = 0; i < n; i++) {		\
-            mask[i] &= (ALPHA < ref);		\
-            LOOP_CODE;				\
-         }					\
-         break;					\
-      case GL_LEQUAL:				\
-         for (i = 0; i < n; i++) {		\
-            mask[i] &= (ALPHA <= ref);		\
-            LOOP_CODE;				\
-         }					\
-         break;					\
-      case GL_GEQUAL:				\
-         for (i = 0; i < n; i++) {		\
-            mask[i] &= (ALPHA >= ref);		\
-            LOOP_CODE;				\
-         }					\
-         break;					\
-      case GL_GREATER:				\
-         for (i = 0; i < n; i++) {		\
-            mask[i] &= (ALPHA > ref);		\
-            LOOP_CODE;				\
-         }					\
-         break;					\
-      case GL_NOTEQUAL:				\
-         for (i = 0; i < n; i++) {		\
-            mask[i] &= (ALPHA != ref);		\
-            LOOP_CODE;				\
-         }					\
-         break;					\
-      case GL_EQUAL:				\
-         for (i = 0; i < n; i++) {		\
-            mask[i] &= (ALPHA == ref);		\
-            LOOP_CODE;				\
-         }					\
-         break;					\
-      default:					\
-         _mesa_problem(ctx, "Invalid alpha test in _swrast_alpha_test" ); \
-         return 0;				\
-   }						\
-} while (0)
-
-
-
-/**
- * Perform the alpha test for an array of pixels.
- * For pixels that fail the test, mask[i] will be set to 0.
- * \return  0 if all pixels in the span failed the alpha test,
- *          1 if one or more pixels passed the alpha test.
- */
-GLint
-_swrast_alpha_test(const GLcontext *ctx, SWspan *span)
-{
-   const GLuint n = span->end;
-   GLubyte *mask = span->array->mask;
-   GLuint i;
-
-   if (ctx->Color.AlphaFunc == GL_ALWAYS) {
-      /* do nothing */
-      return 1;
-   }
-   else if (ctx->Color.AlphaFunc == GL_NEVER) {
-      /* All pixels failed - caller should check for this return value and
-       * act accordingly.
-       */
-      span->writeAll = GL_FALSE;
-      return 0;
-   }
-
-   if (span->arrayMask & SPAN_RGBA) {
-      /* Use array's alpha values */
-      if (span->array->ChanType == GL_UNSIGNED_BYTE) {
-         GLubyte (*rgba)[4] = span->array->rgba8;
-         GLubyte ref;
-         CLAMPED_FLOAT_TO_UBYTE(ref, ctx->Color.AlphaRef);
-         ALPHA_TEST(rgba[i][ACOMP], ;);
-      }
-      else if (span->array->ChanType == GL_UNSIGNED_SHORT) {
-         GLushort (*rgba)[4] = span->array->rgba16;
-         GLushort ref;
-         CLAMPED_FLOAT_TO_USHORT(ref, ctx->Color.AlphaRef);
-         ALPHA_TEST(rgba[i][ACOMP], ;);
-      }
-      else {
-         GLfloat (*rgba)[4] = span->array->attribs[FRAG_ATTRIB_COL0];
-         const GLfloat ref = ctx->Color.AlphaRef;
-         ALPHA_TEST(rgba[i][ACOMP], ;);
-      }
-   }
-   else {
-      /* Interpolate alpha values */
-      ASSERT(span->interpMask & SPAN_RGBA);
-      if (span->array->ChanType == GL_UNSIGNED_BYTE) {
-         const GLfixed alphaStep = span->alphaStep;
-         GLfixed alpha = span->alpha;
-         GLubyte ref;
-         CLAMPED_FLOAT_TO_UBYTE(ref, ctx->Color.AlphaRef);
-         ALPHA_TEST(FixedToInt(alpha), alpha += alphaStep);
-      }
-      else if (span->array->ChanType == GL_UNSIGNED_SHORT) {
-         const GLfixed alphaStep = span->alphaStep;
-         GLfixed alpha = span->alpha;
-         GLushort ref;
-         CLAMPED_FLOAT_TO_USHORT(ref, ctx->Color.AlphaRef);
-         ALPHA_TEST(FixedToInt(alpha), alpha += alphaStep);
-      }
-      else {
-         const GLfloat alphaStep = FixedToFloat(span->alphaStep);
-         GLfloat alpha = FixedToFloat(span->alpha);
-         const GLfloat ref = ctx->Color.AlphaRef;
-         ALPHA_TEST(alpha, alpha += alphaStep);
-      }
-   }
-
-   span->writeAll = GL_FALSE;
-
-   /* XXX examine mask[] values? */
-   return 1;
-}
+/*

+ * Mesa 3-D graphics library

+ * Version:  6.5.2

+ *

+ * Copyright (C) 1999-2006  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.

+ */

+

+/**

+ * \file swrast/s_alpha.c

+ * \brief Functions to apply alpha test.

+ */

+

+#include "main/glheader.h"

+#include "main/context.h"

+#include "main/colormac.h"

+#include "main/macros.h"

+

+#include "s_alpha.h"

+#include "s_context.h"

+

+

+#define ALPHA_TEST(ALPHA, LOOP_CODE)		\

+do {						\

+   switch (ctx->Color.AlphaFunc) {		\

+      case GL_LESS:				\

+         for (i = 0; i < n; i++) {		\

+            mask[i] &= (ALPHA < ref);		\

+            LOOP_CODE;				\

+         }					\

+         break;					\

+      case GL_LEQUAL:				\

+         for (i = 0; i < n; i++) {		\

+            mask[i] &= (ALPHA <= ref);		\

+            LOOP_CODE;				\

+         }					\

+         break;					\

+      case GL_GEQUAL:				\

+         for (i = 0; i < n; i++) {		\

+            mask[i] &= (ALPHA >= ref);		\

+            LOOP_CODE;				\

+         }					\

+         break;					\

+      case GL_GREATER:				\

+         for (i = 0; i < n; i++) {		\

+            mask[i] &= (ALPHA > ref);		\

+            LOOP_CODE;				\

+         }					\

+         break;					\

+      case GL_NOTEQUAL:				\

+         for (i = 0; i < n; i++) {		\

+            mask[i] &= (ALPHA != ref);		\

+            LOOP_CODE;				\

+         }					\

+         break;					\

+      case GL_EQUAL:				\

+         for (i = 0; i < n; i++) {		\

+            mask[i] &= (ALPHA == ref);		\

+            LOOP_CODE;				\

+         }					\

+         break;					\

+      default:					\

+         _mesa_problem(ctx, "Invalid alpha test in _swrast_alpha_test" ); \

+         return 0;				\

+   }						\

+} while (0)

+

+

+

+/**

+ * Perform the alpha test for an array of pixels.

+ * For pixels that fail the test, mask[i] will be set to 0.

+ * \return  0 if all pixels in the span failed the alpha test,

+ *          1 if one or more pixels passed the alpha test.

+ */

+GLint

+_swrast_alpha_test(const struct gl_context *ctx, SWspan *span)

+{

+   const GLuint n = span->end;

+   GLubyte *mask = span->array->mask;

+   GLuint i;

+

+   if (ctx->Color.AlphaFunc == GL_ALWAYS) {

+      /* do nothing */

+      return 1;

+   }

+   else if (ctx->Color.AlphaFunc == GL_NEVER) {

+      /* All pixels failed - caller should check for this return value and

+       * act accordingly.

+       */

+      span->writeAll = GL_FALSE;

+      return 0;

+   }

+

+   if (span->arrayMask & SPAN_RGBA) {

+      /* Use array's alpha values */

+      if (span->array->ChanType == GL_UNSIGNED_BYTE) {

+         GLubyte (*rgba)[4] = span->array->rgba8;

+         GLubyte ref;

+         CLAMPED_FLOAT_TO_UBYTE(ref, ctx->Color.AlphaRef);

+         ALPHA_TEST(rgba[i][ACOMP], ;);

+      }

+      else if (span->array->ChanType == GL_UNSIGNED_SHORT) {

+         GLushort (*rgba)[4] = span->array->rgba16;

+         GLushort ref;

+         CLAMPED_FLOAT_TO_USHORT(ref, ctx->Color.AlphaRef);

+         ALPHA_TEST(rgba[i][ACOMP], ;);

+      }

+      else {

+         GLfloat (*rgba)[4] = span->array->attribs[FRAG_ATTRIB_COL0];

+         const GLfloat ref = ctx->Color.AlphaRef;

+         ALPHA_TEST(rgba[i][ACOMP], ;);

+      }

+   }

+   else {

+      /* Interpolate alpha values */

+      ASSERT(span->interpMask & SPAN_RGBA);

+      if (span->array->ChanType == GL_UNSIGNED_BYTE) {

+         const GLfixed alphaStep = span->alphaStep;

+         GLfixed alpha = span->alpha;

+         GLubyte ref;

+         CLAMPED_FLOAT_TO_UBYTE(ref, ctx->Color.AlphaRef);

+         ALPHA_TEST(FixedToInt(alpha), alpha += alphaStep);

+      }

+      else if (span->array->ChanType == GL_UNSIGNED_SHORT) {

+         const GLfixed alphaStep = span->alphaStep;

+         GLfixed alpha = span->alpha;

+         GLushort ref;

+         CLAMPED_FLOAT_TO_USHORT(ref, ctx->Color.AlphaRef);

+         ALPHA_TEST(FixedToInt(alpha), alpha += alphaStep);

+      }

+      else {

+         const GLfloat alphaStep = FixedToFloat(span->alphaStep);

+         GLfloat alpha = FixedToFloat(span->alpha);

+         const GLfloat ref = ctx->Color.AlphaRef;

+         ALPHA_TEST(alpha, alpha += alphaStep);

+      }

+   }

+

+   span->writeAll = GL_FALSE;

+

+   /* XXX examine mask[] values? */

+   return 1;

+}

diff --git a/mesalib/src/mesa/swrast/s_alpha.h b/mesalib/src/mesa/swrast/s_alpha.h
index 239484a97..ac5cd8dab 100644
--- a/mesalib/src/mesa/swrast/s_alpha.h
+++ b/mesalib/src/mesa/swrast/s_alpha.h
@@ -1,39 +1,39 @@
-
-/*
- * Mesa 3-D graphics library
- * Version:  4.1
- *
- * Copyright (C) 1999-2002  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.
- */
-
-
-#ifndef S_ALPHA_H
-#define S_ALPHA_H
-
-
-#include "main/mtypes.h"
-#include "s_span.h"
-
-
-extern GLint
-_swrast_alpha_test( const GLcontext *ctx, SWspan *span );
-
-
-#endif
+/*

+ * Mesa 3-D graphics library

+ * Version:  4.1

+ *

+ * Copyright (C) 1999-2002  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.

+ */

+

+

+#ifndef S_ALPHA_H

+#define S_ALPHA_H

+

+

+#include "main/glheader.h"

+#include "s_span.h"

+

+struct gl_context;

+

+extern GLint

+_swrast_alpha_test( const struct gl_context *ctx, SWspan *span );

+

+

+#endif

diff --git a/mesalib/src/mesa/swrast/s_atifragshader.c b/mesalib/src/mesa/swrast/s_atifragshader.c
index 1338b6802..6019eea5e 100644
--- a/mesalib/src/mesa/swrast/s_atifragshader.c
+++ b/mesalib/src/mesa/swrast/s_atifragshader.c
@@ -1,604 +1,604 @@
-/*
- * Copyright (C) 2004  David Airlie   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
- * DAVID AIRLIE 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 "main/atifragshader.h"
-#include "swrast/s_atifragshader.h"
-#include "swrast/s_context.h"
-
-
-/**
- * State for executing ATI fragment shader.
- */
-struct atifs_machine
-{
-   GLfloat Registers[6][4];         /** six temporary registers */
-   GLfloat PrevPassRegisters[6][4];
-   GLfloat Inputs[2][4];   /** Primary, secondary input colors */
-};
-
-
-
-/**
- * Fetch a texel.
- */
-static void
-fetch_texel(GLcontext * ctx, const GLfloat texcoord[4], GLfloat lambda,
-	    GLuint unit, GLfloat color[4])
-{
-   SWcontext *swrast = SWRAST_CONTEXT(ctx);
-
-   /* XXX use a float-valued TextureSample routine here!!! */
-   swrast->TextureSample[unit](ctx, ctx->Texture.Unit[unit]._Current,
-                               1, (const GLfloat(*)[4]) texcoord,
-                               &lambda, (GLfloat (*)[4]) color);
-}
-
-static void
-apply_swizzle(GLfloat values[4], GLuint swizzle)
-{
-   GLfloat s, t, r, q;
-
-   s = values[0];
-   t = values[1];
-   r = values[2];
-   q = values[3];
-
-   switch (swizzle) {
-   case GL_SWIZZLE_STR_ATI:
-      values[0] = s;
-      values[1] = t;
-      values[2] = r;
-      break;
-   case GL_SWIZZLE_STQ_ATI:
-      values[0] = s;
-      values[1] = t;
-      values[2] = q;
-      break;
-   case GL_SWIZZLE_STR_DR_ATI:
-      values[0] = s / r;
-      values[1] = t / r;
-      values[2] = 1 / r;
-      break;
-   case GL_SWIZZLE_STQ_DQ_ATI:
-/* make sure q is not 0 to avoid problems later with infinite values (texture lookup)? */
-      if (q == 0.0F)
-         q = 0.000000001F;
-      values[0] = s / q;
-      values[1] = t / q;
-      values[2] = 1.0F / q;
-      break;
-   }
-   values[3] = 0.0;
-}
-
-static void
-apply_src_rep(GLint optype, GLuint rep, GLfloat * val)
-{
-   GLint i;
-   GLint start, end;
-   if (!rep)
-      return;
-
-   start = optype ? 3 : 0;
-   end = 4;
-
-   for (i = start; i < end; i++) {
-      switch (rep) {
-      case GL_RED:
-	 val[i] = val[0];
-	 break;
-      case GL_GREEN:
-	 val[i] = val[1];
-	 break;
-      case GL_BLUE:
-	 val[i] = val[2];
-	 break;
-      case GL_ALPHA:
-	 val[i] = val[3];
-	 break;
-      }
-   }
-}
-
-static void
-apply_src_mod(GLint optype, GLuint mod, GLfloat * val)
-{
-   GLint i;
-   GLint start, end;
-
-   if (!mod)
-      return;
-
-   start = optype ? 3 : 0;
-   end = 4;
-
-   for (i = start; i < end; i++) {
-      if (mod & GL_COMP_BIT_ATI)
-	 val[i] = 1 - val[i];
-
-      if (mod & GL_BIAS_BIT_ATI)
-	 val[i] = val[i] - 0.5F;
-
-      if (mod & GL_2X_BIT_ATI)
-	 val[i] = 2 * val[i];
-
-      if (mod & GL_NEGATE_BIT_ATI)
-	 val[i] = -val[i];
-   }
-}
-
-static void
-apply_dst_mod(GLuint optype, GLuint mod, GLfloat * val)
-{
-   GLint i;
-   GLint has_sat = mod & GL_SATURATE_BIT_ATI;
-   GLint start, end;
-
-   mod &= ~GL_SATURATE_BIT_ATI;
-
-   start = optype ? 3 : 0;
-   end = optype ? 4 : 3;
-
-   for (i = start; i < end; i++) {
-      switch (mod) {
-      case GL_2X_BIT_ATI:
-	 val[i] = 2 * val[i];
-	 break;
-      case GL_4X_BIT_ATI:
-	 val[i] = 4 * val[i];
-	 break;
-      case GL_8X_BIT_ATI:
-	 val[i] = 8 * val[i];
-	 break;
-      case GL_HALF_BIT_ATI:
-	 val[i] = val[i] * 0.5F;
-	 break;
-      case GL_QUARTER_BIT_ATI:
-	 val[i] = val[i] * 0.25F;
-	 break;
-      case GL_EIGHTH_BIT_ATI:
-	 val[i] = val[i] * 0.125F;
-	 break;
-      }
-
-      if (has_sat) {
-	 if (val[i] < 0.0F)
-	    val[i] = 0.0F;
-	 else if (val[i] > 1.0F)
-	    val[i] = 1.0F;
-      }
-      else {
-	 if (val[i] < -8.0F)
-	    val[i] = -8.0F;
-	 else if (val[i] > 8.0F)
-	    val[i] = 8.0F;
-      }
-   }
-}
-
-
-static void
-write_dst_addr(GLuint optype, GLuint mod, GLuint mask, GLfloat * src,
-	       GLfloat * dst)
-{
-   GLint i;
-   apply_dst_mod(optype, mod, src);
-
-   if (optype == ATI_FRAGMENT_SHADER_COLOR_OP) {
-      if (mask) {
-	 if (mask & GL_RED_BIT_ATI)
-	    dst[0] = src[0];
-
-	 if (mask & GL_GREEN_BIT_ATI)
-	    dst[1] = src[1];
-
-	 if (mask & GL_BLUE_BIT_ATI)
-	    dst[2] = src[2];
-      }
-      else {
-	 for (i = 0; i < 3; i++)
-	    dst[i] = src[i];
-      }
-   }
-   else
-      dst[3] = src[3];
-}
-
-static void
-finish_pass(struct atifs_machine *machine)
-{
-   GLint i;
-
-   for (i = 0; i < 6; i++) {
-      COPY_4V(machine->PrevPassRegisters[i], machine->Registers[i]);
-   }
-}
-
-struct ati_fs_opcode_st ati_fs_opcodes[] = {
-   {GL_ADD_ATI, 2},
-   {GL_SUB_ATI, 2},
-   {GL_MUL_ATI, 2},
-   {GL_MAD_ATI, 3},
-   {GL_LERP_ATI, 3},
-   {GL_MOV_ATI, 1},
-   {GL_CND_ATI, 3},
-   {GL_CND0_ATI, 3},
-   {GL_DOT2_ADD_ATI, 3},
-   {GL_DOT3_ATI, 2},
-   {GL_DOT4_ATI, 2}
-};
-
-
-
-static void
-handle_pass_op(struct atifs_machine *machine, struct atifs_setupinst *texinst,
-	       const SWspan *span, GLuint column, GLuint idx)
-{
-   GLuint swizzle = texinst->swizzle;
-   GLuint pass_tex = texinst->src;
-
-   if (pass_tex >= GL_TEXTURE0_ARB && pass_tex <= GL_TEXTURE7_ARB) {
-      pass_tex -= GL_TEXTURE0_ARB;
-      COPY_4V(machine->Registers[idx],
-	      span->array->attribs[FRAG_ATTRIB_TEX0 + pass_tex][column]);
-   }
-   else if (pass_tex >= GL_REG_0_ATI && pass_tex <= GL_REG_5_ATI) {
-      pass_tex -= GL_REG_0_ATI;
-      COPY_4V(machine->Registers[idx], machine->PrevPassRegisters[pass_tex]);
-   }
-   apply_swizzle(machine->Registers[idx], swizzle);
-
-}
-
-static void
-handle_sample_op(GLcontext * ctx, struct atifs_machine *machine,
-		 struct atifs_setupinst *texinst, const SWspan *span,
-		 GLuint column, GLuint idx)
-{
-/* sample from unit idx using texinst->src as coords */
-   GLuint swizzle = texinst->swizzle;
-   GLuint coord_source = texinst->src;
-   GLfloat tex_coords[4] = { 0 };
-
-   if (coord_source >= GL_TEXTURE0_ARB && coord_source <= GL_TEXTURE7_ARB) {
-      coord_source -= GL_TEXTURE0_ARB;
-      COPY_4V(tex_coords,
-              span->array->attribs[FRAG_ATTRIB_TEX0 + coord_source][column]);
-   }
-   else if (coord_source >= GL_REG_0_ATI && coord_source <= GL_REG_5_ATI) {
-      coord_source -= GL_REG_0_ATI;
-      COPY_4V(tex_coords, machine->PrevPassRegisters[coord_source]);
-   }
-   apply_swizzle(tex_coords, swizzle);
-   fetch_texel(ctx, tex_coords, 0.0F, idx, machine->Registers[idx]);
-}
-
-#define SETUP_SRC_REG(optype, i, x)		\
-do {						\
-   COPY_4V(src[optype][i], x); 			\
-} while (0)
-
-
-
-/**
- * Execute the given fragment shader.
- * NOTE: we do everything in single-precision floating point
- * \param ctx - rendering context
- * \param shader - the shader to execute
- * \param machine - virtual machine state
- * \param span - the SWspan we're operating on
- * \param column - which pixel [i] we're operating on in the span
- */
-static void
-execute_shader(GLcontext *ctx, const struct ati_fragment_shader *shader,
-	       struct atifs_machine *machine, const SWspan *span,
-               GLuint column)
-{
-   GLuint pc;
-   struct atifs_instruction *inst;
-   struct atifs_setupinst *texinst;
-   GLint optype;
-   GLuint i;
-   GLint j, pass;
-   GLint dstreg;
-   GLfloat src[2][3][4];
-   GLfloat zeros[4] = { 0.0, 0.0, 0.0, 0.0 };
-   GLfloat ones[4] = { 1.0, 1.0, 1.0, 1.0 };
-   GLfloat dst[2][4], *dstp;
-
-   for (pass = 0; pass < shader->NumPasses; pass++) {
-      if (pass > 0)
-	 finish_pass(machine);
-      for (j = 0; j < MAX_NUM_FRAGMENT_REGISTERS_ATI; j++) {
-	 texinst = &shader->SetupInst[pass][j];
-	 if (texinst->Opcode == ATI_FRAGMENT_SHADER_PASS_OP)
-	    handle_pass_op(machine, texinst, span, column, j);
-	 else if (texinst->Opcode == ATI_FRAGMENT_SHADER_SAMPLE_OP)
-	    handle_sample_op(ctx, machine, texinst, span, column, j);
-      }
-
-      for (pc = 0; pc < shader->numArithInstr[pass]; pc++) {
-	 inst = &shader->Instructions[pass][pc];
-
-	 /* setup the source registers for color and alpha ops */
-	 for (optype = 0; optype < 2; optype++) {
- 	    for (i = 0; i < inst->ArgCount[optype]; i++) {
-	       GLint index = inst->SrcReg[optype][i].Index;
-
-	       if (index >= GL_REG_0_ATI && index <= GL_REG_5_ATI)
-		  SETUP_SRC_REG(optype, i,
-				machine->Registers[index - GL_REG_0_ATI]);
-	       else if (index >= GL_CON_0_ATI && index <= GL_CON_7_ATI) {
-		  if (shader->LocalConstDef & (1 << (index - GL_CON_0_ATI))) {
-		     SETUP_SRC_REG(optype, i,
-				shader->Constants[index - GL_CON_0_ATI]);
-		  } else {
-		     SETUP_SRC_REG(optype, i,
-				ctx->ATIFragmentShader.GlobalConstants[index - GL_CON_0_ATI]);
-		  }
-	       }
-	       else if (index == GL_ONE)
-		  SETUP_SRC_REG(optype, i, ones);
-	       else if (index == GL_ZERO)
-		  SETUP_SRC_REG(optype, i, zeros);
-	       else if (index == GL_PRIMARY_COLOR_EXT)
-		  SETUP_SRC_REG(optype, i,
-				machine->Inputs[ATI_FS_INPUT_PRIMARY]);
-	       else if (index == GL_SECONDARY_INTERPOLATOR_ATI)
-		  SETUP_SRC_REG(optype, i,
-				machine->Inputs[ATI_FS_INPUT_SECONDARY]);
-
-	       apply_src_rep(optype, inst->SrcReg[optype][i].argRep,
-			     src[optype][i]);
-	       apply_src_mod(optype, inst->SrcReg[optype][i].argMod,
-			     src[optype][i]);
-	    }
-	 }
-
-	 /* Execute the operations - color then alpha */
-	 for (optype = 0; optype < 2; optype++) {
-	    if (inst->Opcode[optype]) {
-	       switch (inst->Opcode[optype]) {
-	       case GL_ADD_ATI:
-		  if (!optype)
-		     for (i = 0; i < 3; i++) {
-			dst[optype][i] =
-			   src[optype][0][i] + src[optype][1][i];
-		     }
-		  else
-		     dst[optype][3] = src[optype][0][3] + src[optype][1][3];
-		  break;
-	       case GL_SUB_ATI:
-		  if (!optype)
-		     for (i = 0; i < 3; i++) {
-			dst[optype][i] =
-			   src[optype][0][i] - src[optype][1][i];
-		     }
-		  else
-		     dst[optype][3] = src[optype][0][3] - src[optype][1][3];
-		  break;
-	       case GL_MUL_ATI:
-		  if (!optype)
-		     for (i = 0; i < 3; i++) {
-			dst[optype][i] =
-			   src[optype][0][i] * src[optype][1][i];
-		     }
-		  else
-		     dst[optype][3] = src[optype][0][3] * src[optype][1][3];
-		  break;
-	       case GL_MAD_ATI:
-		  if (!optype)
-		     for (i = 0; i < 3; i++) {
-			dst[optype][i] =
-			   src[optype][0][i] * src[optype][1][i] +
-			   src[optype][2][i];
-		     }
-		  else
-		     dst[optype][3] =
-			src[optype][0][3] * src[optype][1][3] +
-			src[optype][2][3];
-		  break;
-	       case GL_LERP_ATI:
-		  if (!optype)
-		     for (i = 0; i < 3; i++) {
-			dst[optype][i] =
-			   src[optype][0][i] * src[optype][1][i] + (1 -
-								    src
-								    [optype]
-								    [0][i]) *
-			   src[optype][2][i];
-		     }
-		  else
-		     dst[optype][3] =
-			src[optype][0][3] * src[optype][1][3] + (1 -
-								 src[optype]
-								 [0][3]) *
-			src[optype][2][3];
-		  break;
-
-	       case GL_MOV_ATI:
-		  if (!optype)
-		     for (i = 0; i < 3; i++) {
-			dst[optype][i] = src[optype][0][i];
-		     }
-		  else
-		     dst[optype][3] = src[optype][0][3];
-		  break;
-	       case GL_CND_ATI:
-		  if (!optype) {
-		     for (i = 0; i < 3; i++) {
-			dst[optype][i] =
-			   (src[optype][2][i] >
-			    0.5) ? src[optype][0][i] : src[optype][1][i];
-		     }
-		  }
-		  else {
-		     dst[optype][3] =
-			(src[optype][2][3] >
-			 0.5) ? src[optype][0][3] : src[optype][1][3];
-		  }
-		  break;
-
-	       case GL_CND0_ATI:
-		  if (!optype)
-		     for (i = 0; i < 3; i++) {
-			dst[optype][i] =
-			   (src[optype][2][i] >=
-			    0) ? src[optype][0][i] : src[optype][1][i];
-		     }
-		  else {
-		     dst[optype][3] =
-			(src[optype][2][3] >=
-			 0) ? src[optype][0][3] : src[optype][1][3];
-		  }
-		  break;
-	       case GL_DOT2_ADD_ATI:
-		  {
-		     GLfloat result;
-
-		     /* DOT 2 always uses the source from the color op */
-		     /* could save recalculation of dot products for alpha inst */
-		     result = src[0][0][0] * src[0][1][0] +
-			src[0][0][1] * src[0][1][1] + src[0][2][2];
-		     if (!optype) {
-			for (i = 0; i < 3; i++) {
-			   dst[optype][i] = result;
-			}
-		     }
-		     else
-			dst[optype][3] = result;
-		  }
-		  break;
-	       case GL_DOT3_ATI:
-		  {
-		     GLfloat result;
-
-		     /* DOT 3 always uses the source from the color op */
-		     result = src[0][0][0] * src[0][1][0] +
-			src[0][0][1] * src[0][1][1] +
-			src[0][0][2] * src[0][1][2];
-
-		     if (!optype) {
-			for (i = 0; i < 3; i++) {
-			   dst[optype][i] = result;
-			}
-		     }
-		     else
-			dst[optype][3] = result;
-		  }
-		  break;
-	       case GL_DOT4_ATI:
-		  {
-		     GLfloat result;
-
-		     /* DOT 4 always uses the source from the color op */
-		     result = src[0][0][0] * src[0][1][0] +
-			src[0][0][1] * src[0][1][1] +
-			src[0][0][2] * src[0][1][2] +
-			src[0][0][3] * src[0][1][3];
-		     if (!optype) {
-			for (i = 0; i < 3; i++) {
-			   dst[optype][i] = result;
-			}
-		     }
-		     else
-			dst[optype][3] = result;
-		  }
-		  break;
-
-	       }
-	    }
-	 }
-
-	 /* write out the destination registers */
-	 for (optype = 0; optype < 2; optype++) {
-	    if (inst->Opcode[optype]) {
-	       dstreg = inst->DstReg[optype].Index;
-	       dstp = machine->Registers[dstreg - GL_REG_0_ATI];
-
-	       if ((optype == 0) || ((inst->Opcode[1] != GL_DOT2_ADD_ATI) &&
-		  (inst->Opcode[1] != GL_DOT3_ATI) && (inst->Opcode[1] != GL_DOT4_ATI)))
-	          write_dst_addr(optype, inst->DstReg[optype].dstMod,
-			      inst->DstReg[optype].dstMask, dst[optype],
-			      dstp);
-	       else
-		  write_dst_addr(1, inst->DstReg[0].dstMod, 0, dst[1], dstp);
-	    }
-	 }
-      }
-   }
-}
-
-
-/**
- * Init fragment shader virtual machine state.
- */
-static void
-init_machine(GLcontext * ctx, struct atifs_machine *machine,
-	     const struct ati_fragment_shader *shader,
-	     const SWspan *span, GLuint col)
-{
-   GLfloat (*inputs)[4] = machine->Inputs;
-   GLint i, j;
-
-   for (i = 0; i < 6; i++) {
-      for (j = 0; j < 4; j++)
-	 machine->Registers[i][j] = 0.0;
-   }
-
-   COPY_4V(inputs[ATI_FS_INPUT_PRIMARY], span->array->attribs[FRAG_ATTRIB_COL0][col]);
-   COPY_4V(inputs[ATI_FS_INPUT_SECONDARY], span->array->attribs[FRAG_ATTRIB_COL1][col]);
-}
-
-
-
-/**
- * Execute the current ATI shader program, operating on the given span.
- */
-void
-_swrast_exec_fragment_shader(GLcontext * ctx, SWspan *span)
-{
-   const struct ati_fragment_shader *shader = ctx->ATIFragmentShader.Current;
-   struct atifs_machine machine;
-   GLuint i;
-
-   /* incoming colors should be floats */
-   ASSERT(span->array->ChanType == GL_FLOAT);
-
-   for (i = 0; i < span->end; i++) {
-      if (span->array->mask[i]) {
-	 init_machine(ctx, &machine, shader, span, i);
-
-	 execute_shader(ctx, shader, &machine, span, i);
-
-         /* store result color */
-	 {
-	    const GLfloat *colOut = machine.Registers[0];
-            /*fprintf(stderr,"outputs %f %f %f %f\n",
-              colOut[0], colOut[1], colOut[2], colOut[3]); */
-            COPY_4V(span->array->attribs[FRAG_ATTRIB_COL0][i], colOut);
-	 }
-      }
-   }
-}
+/*

+ * Copyright (C) 2004  David Airlie   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

+ * DAVID AIRLIE 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 "main/atifragshader.h"

+#include "swrast/s_atifragshader.h"

+#include "swrast/s_context.h"

+

+

+/**

+ * State for executing ATI fragment shader.

+ */

+struct atifs_machine

+{

+   GLfloat Registers[6][4];         /** six temporary registers */

+   GLfloat PrevPassRegisters[6][4];

+   GLfloat Inputs[2][4];   /** Primary, secondary input colors */

+};

+

+

+

+/**

+ * Fetch a texel.

+ */

+static void

+fetch_texel(struct gl_context * ctx, const GLfloat texcoord[4], GLfloat lambda,

+	    GLuint unit, GLfloat color[4])

+{

+   SWcontext *swrast = SWRAST_CONTEXT(ctx);

+

+   /* XXX use a float-valued TextureSample routine here!!! */

+   swrast->TextureSample[unit](ctx, ctx->Texture.Unit[unit]._Current,

+                               1, (const GLfloat(*)[4]) texcoord,

+                               &lambda, (GLfloat (*)[4]) color);

+}

+

+static void

+apply_swizzle(GLfloat values[4], GLuint swizzle)

+{

+   GLfloat s, t, r, q;

+

+   s = values[0];

+   t = values[1];

+   r = values[2];

+   q = values[3];

+

+   switch (swizzle) {

+   case GL_SWIZZLE_STR_ATI:

+      values[0] = s;

+      values[1] = t;

+      values[2] = r;

+      break;

+   case GL_SWIZZLE_STQ_ATI:

+      values[0] = s;

+      values[1] = t;

+      values[2] = q;

+      break;

+   case GL_SWIZZLE_STR_DR_ATI:

+      values[0] = s / r;

+      values[1] = t / r;

+      values[2] = 1 / r;

+      break;

+   case GL_SWIZZLE_STQ_DQ_ATI:

+/* make sure q is not 0 to avoid problems later with infinite values (texture lookup)? */

+      if (q == 0.0F)

+         q = 0.000000001F;

+      values[0] = s / q;

+      values[1] = t / q;

+      values[2] = 1.0F / q;

+      break;

+   }

+   values[3] = 0.0;

+}

+

+static void

+apply_src_rep(GLint optype, GLuint rep, GLfloat * val)

+{

+   GLint i;

+   GLint start, end;

+   if (!rep)

+      return;

+

+   start = optype ? 3 : 0;

+   end = 4;

+

+   for (i = start; i < end; i++) {

+      switch (rep) {

+      case GL_RED:

+	 val[i] = val[0];

+	 break;

+      case GL_GREEN:

+	 val[i] = val[1];

+	 break;

+      case GL_BLUE:

+	 val[i] = val[2];

+	 break;

+      case GL_ALPHA:

+	 val[i] = val[3];

+	 break;

+      }

+   }

+}

+

+static void

+apply_src_mod(GLint optype, GLuint mod, GLfloat * val)

+{

+   GLint i;

+   GLint start, end;

+

+   if (!mod)

+      return;

+

+   start = optype ? 3 : 0;

+   end = 4;

+

+   for (i = start; i < end; i++) {

+      if (mod & GL_COMP_BIT_ATI)

+	 val[i] = 1 - val[i];

+

+      if (mod & GL_BIAS_BIT_ATI)

+	 val[i] = val[i] - 0.5F;

+

+      if (mod & GL_2X_BIT_ATI)

+	 val[i] = 2 * val[i];

+

+      if (mod & GL_NEGATE_BIT_ATI)

+	 val[i] = -val[i];

+   }

+}

+

+static void

+apply_dst_mod(GLuint optype, GLuint mod, GLfloat * val)

+{

+   GLint i;

+   GLint has_sat = mod & GL_SATURATE_BIT_ATI;

+   GLint start, end;

+

+   mod &= ~GL_SATURATE_BIT_ATI;

+

+   start = optype ? 3 : 0;

+   end = optype ? 4 : 3;

+

+   for (i = start; i < end; i++) {

+      switch (mod) {

+      case GL_2X_BIT_ATI:

+	 val[i] = 2 * val[i];

+	 break;

+      case GL_4X_BIT_ATI:

+	 val[i] = 4 * val[i];

+	 break;

+      case GL_8X_BIT_ATI:

+	 val[i] = 8 * val[i];

+	 break;

+      case GL_HALF_BIT_ATI:

+	 val[i] = val[i] * 0.5F;

+	 break;

+      case GL_QUARTER_BIT_ATI:

+	 val[i] = val[i] * 0.25F;

+	 break;

+      case GL_EIGHTH_BIT_ATI:

+	 val[i] = val[i] * 0.125F;

+	 break;

+      }

+

+      if (has_sat) {

+	 if (val[i] < 0.0F)

+	    val[i] = 0.0F;

+	 else if (val[i] > 1.0F)

+	    val[i] = 1.0F;

+      }

+      else {

+	 if (val[i] < -8.0F)

+	    val[i] = -8.0F;

+	 else if (val[i] > 8.0F)

+	    val[i] = 8.0F;

+      }

+   }

+}

+

+

+static void

+write_dst_addr(GLuint optype, GLuint mod, GLuint mask, GLfloat * src,

+	       GLfloat * dst)

+{

+   GLint i;

+   apply_dst_mod(optype, mod, src);

+

+   if (optype == ATI_FRAGMENT_SHADER_COLOR_OP) {

+      if (mask) {

+	 if (mask & GL_RED_BIT_ATI)

+	    dst[0] = src[0];

+

+	 if (mask & GL_GREEN_BIT_ATI)

+	    dst[1] = src[1];

+

+	 if (mask & GL_BLUE_BIT_ATI)

+	    dst[2] = src[2];

+      }

+      else {

+	 for (i = 0; i < 3; i++)

+	    dst[i] = src[i];

+      }

+   }

+   else

+      dst[3] = src[3];

+}

+

+static void

+finish_pass(struct atifs_machine *machine)

+{

+   GLint i;

+

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

+      COPY_4V(machine->PrevPassRegisters[i], machine->Registers[i]);

+   }

+}

+

+struct ati_fs_opcode_st ati_fs_opcodes[] = {

+   {GL_ADD_ATI, 2},

+   {GL_SUB_ATI, 2},

+   {GL_MUL_ATI, 2},

+   {GL_MAD_ATI, 3},

+   {GL_LERP_ATI, 3},

+   {GL_MOV_ATI, 1},

+   {GL_CND_ATI, 3},

+   {GL_CND0_ATI, 3},

+   {GL_DOT2_ADD_ATI, 3},

+   {GL_DOT3_ATI, 2},

+   {GL_DOT4_ATI, 2}

+};

+

+

+

+static void

+handle_pass_op(struct atifs_machine *machine, struct atifs_setupinst *texinst,

+	       const SWspan *span, GLuint column, GLuint idx)

+{

+   GLuint swizzle = texinst->swizzle;

+   GLuint pass_tex = texinst->src;

+

+   if (pass_tex >= GL_TEXTURE0_ARB && pass_tex <= GL_TEXTURE7_ARB) {

+      pass_tex -= GL_TEXTURE0_ARB;

+      COPY_4V(machine->Registers[idx],

+	      span->array->attribs[FRAG_ATTRIB_TEX0 + pass_tex][column]);

+   }

+   else if (pass_tex >= GL_REG_0_ATI && pass_tex <= GL_REG_5_ATI) {

+      pass_tex -= GL_REG_0_ATI;

+      COPY_4V(machine->Registers[idx], machine->PrevPassRegisters[pass_tex]);

+   }

+   apply_swizzle(machine->Registers[idx], swizzle);

+

+}

+

+static void

+handle_sample_op(struct gl_context * ctx, struct atifs_machine *machine,

+		 struct atifs_setupinst *texinst, const SWspan *span,

+		 GLuint column, GLuint idx)

+{

+/* sample from unit idx using texinst->src as coords */

+   GLuint swizzle = texinst->swizzle;

+   GLuint coord_source = texinst->src;

+   GLfloat tex_coords[4] = { 0 };

+

+   if (coord_source >= GL_TEXTURE0_ARB && coord_source <= GL_TEXTURE7_ARB) {

+      coord_source -= GL_TEXTURE0_ARB;

+      COPY_4V(tex_coords,

+              span->array->attribs[FRAG_ATTRIB_TEX0 + coord_source][column]);

+   }

+   else if (coord_source >= GL_REG_0_ATI && coord_source <= GL_REG_5_ATI) {

+      coord_source -= GL_REG_0_ATI;

+      COPY_4V(tex_coords, machine->PrevPassRegisters[coord_source]);

+   }

+   apply_swizzle(tex_coords, swizzle);

+   fetch_texel(ctx, tex_coords, 0.0F, idx, machine->Registers[idx]);

+}

+

+#define SETUP_SRC_REG(optype, i, x)		\

+do {						\

+   COPY_4V(src[optype][i], x); 			\

+} while (0)

+

+

+

+/**

+ * Execute the given fragment shader.

+ * NOTE: we do everything in single-precision floating point

+ * \param ctx - rendering context

+ * \param shader - the shader to execute

+ * \param machine - virtual machine state

+ * \param span - the SWspan we're operating on

+ * \param column - which pixel [i] we're operating on in the span

+ */

+static void

+execute_shader(struct gl_context *ctx, const struct ati_fragment_shader *shader,

+	       struct atifs_machine *machine, const SWspan *span,

+               GLuint column)

+{

+   GLuint pc;

+   struct atifs_instruction *inst;

+   struct atifs_setupinst *texinst;

+   GLint optype;

+   GLuint i;

+   GLint j, pass;

+   GLint dstreg;

+   GLfloat src[2][3][4];

+   GLfloat zeros[4] = { 0.0, 0.0, 0.0, 0.0 };

+   GLfloat ones[4] = { 1.0, 1.0, 1.0, 1.0 };

+   GLfloat dst[2][4], *dstp;

+

+   for (pass = 0; pass < shader->NumPasses; pass++) {

+      if (pass > 0)

+	 finish_pass(machine);

+      for (j = 0; j < MAX_NUM_FRAGMENT_REGISTERS_ATI; j++) {

+	 texinst = &shader->SetupInst[pass][j];

+	 if (texinst->Opcode == ATI_FRAGMENT_SHADER_PASS_OP)

+	    handle_pass_op(machine, texinst, span, column, j);

+	 else if (texinst->Opcode == ATI_FRAGMENT_SHADER_SAMPLE_OP)

+	    handle_sample_op(ctx, machine, texinst, span, column, j);

+      }

+

+      for (pc = 0; pc < shader->numArithInstr[pass]; pc++) {

+	 inst = &shader->Instructions[pass][pc];

+

+	 /* setup the source registers for color and alpha ops */

+	 for (optype = 0; optype < 2; optype++) {

+ 	    for (i = 0; i < inst->ArgCount[optype]; i++) {

+	       GLint index = inst->SrcReg[optype][i].Index;

+

+	       if (index >= GL_REG_0_ATI && index <= GL_REG_5_ATI)

+		  SETUP_SRC_REG(optype, i,

+				machine->Registers[index - GL_REG_0_ATI]);

+	       else if (index >= GL_CON_0_ATI && index <= GL_CON_7_ATI) {

+		  if (shader->LocalConstDef & (1 << (index - GL_CON_0_ATI))) {

+		     SETUP_SRC_REG(optype, i,

+				shader->Constants[index - GL_CON_0_ATI]);

+		  } else {

+		     SETUP_SRC_REG(optype, i,

+				ctx->ATIFragmentShader.GlobalConstants[index - GL_CON_0_ATI]);

+		  }

+	       }

+	       else if (index == GL_ONE)

+		  SETUP_SRC_REG(optype, i, ones);

+	       else if (index == GL_ZERO)

+		  SETUP_SRC_REG(optype, i, zeros);

+	       else if (index == GL_PRIMARY_COLOR_EXT)

+		  SETUP_SRC_REG(optype, i,

+				machine->Inputs[ATI_FS_INPUT_PRIMARY]);

+	       else if (index == GL_SECONDARY_INTERPOLATOR_ATI)

+		  SETUP_SRC_REG(optype, i,

+				machine->Inputs[ATI_FS_INPUT_SECONDARY]);

+

+	       apply_src_rep(optype, inst->SrcReg[optype][i].argRep,

+			     src[optype][i]);

+	       apply_src_mod(optype, inst->SrcReg[optype][i].argMod,

+			     src[optype][i]);

+	    }

+	 }

+

+	 /* Execute the operations - color then alpha */

+	 for (optype = 0; optype < 2; optype++) {

+	    if (inst->Opcode[optype]) {

+	       switch (inst->Opcode[optype]) {

+	       case GL_ADD_ATI:

+		  if (!optype)

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

+			dst[optype][i] =

+			   src[optype][0][i] + src[optype][1][i];

+		     }

+		  else

+		     dst[optype][3] = src[optype][0][3] + src[optype][1][3];

+		  break;

+	       case GL_SUB_ATI:

+		  if (!optype)

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

+			dst[optype][i] =

+			   src[optype][0][i] - src[optype][1][i];

+		     }

+		  else

+		     dst[optype][3] = src[optype][0][3] - src[optype][1][3];

+		  break;

+	       case GL_MUL_ATI:

+		  if (!optype)

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

+			dst[optype][i] =

+			   src[optype][0][i] * src[optype][1][i];

+		     }

+		  else

+		     dst[optype][3] = src[optype][0][3] * src[optype][1][3];

+		  break;

+	       case GL_MAD_ATI:

+		  if (!optype)

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

+			dst[optype][i] =

+			   src[optype][0][i] * src[optype][1][i] +

+			   src[optype][2][i];

+		     }

+		  else

+		     dst[optype][3] =

+			src[optype][0][3] * src[optype][1][3] +

+			src[optype][2][3];

+		  break;

+	       case GL_LERP_ATI:

+		  if (!optype)

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

+			dst[optype][i] =

+			   src[optype][0][i] * src[optype][1][i] + (1 -

+								    src

+								    [optype]

+								    [0][i]) *

+			   src[optype][2][i];

+		     }

+		  else

+		     dst[optype][3] =

+			src[optype][0][3] * src[optype][1][3] + (1 -

+								 src[optype]

+								 [0][3]) *

+			src[optype][2][3];

+		  break;

+

+	       case GL_MOV_ATI:

+		  if (!optype)

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

+			dst[optype][i] = src[optype][0][i];

+		     }

+		  else

+		     dst[optype][3] = src[optype][0][3];

+		  break;

+	       case GL_CND_ATI:

+		  if (!optype) {

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

+			dst[optype][i] =

+			   (src[optype][2][i] >

+			    0.5) ? src[optype][0][i] : src[optype][1][i];

+		     }

+		  }

+		  else {

+		     dst[optype][3] =

+			(src[optype][2][3] >

+			 0.5) ? src[optype][0][3] : src[optype][1][3];

+		  }

+		  break;

+

+	       case GL_CND0_ATI:

+		  if (!optype)

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

+			dst[optype][i] =

+			   (src[optype][2][i] >=

+			    0) ? src[optype][0][i] : src[optype][1][i];

+		     }

+		  else {

+		     dst[optype][3] =

+			(src[optype][2][3] >=

+			 0) ? src[optype][0][3] : src[optype][1][3];

+		  }

+		  break;

+	       case GL_DOT2_ADD_ATI:

+		  {

+		     GLfloat result;

+

+		     /* DOT 2 always uses the source from the color op */

+		     /* could save recalculation of dot products for alpha inst */

+		     result = src[0][0][0] * src[0][1][0] +

+			src[0][0][1] * src[0][1][1] + src[0][2][2];

+		     if (!optype) {

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

+			   dst[optype][i] = result;

+			}

+		     }

+		     else

+			dst[optype][3] = result;

+		  }

+		  break;

+	       case GL_DOT3_ATI:

+		  {

+		     GLfloat result;

+

+		     /* DOT 3 always uses the source from the color op */

+		     result = src[0][0][0] * src[0][1][0] +

+			src[0][0][1] * src[0][1][1] +

+			src[0][0][2] * src[0][1][2];

+

+		     if (!optype) {

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

+			   dst[optype][i] = result;

+			}

+		     }

+		     else

+			dst[optype][3] = result;

+		  }

+		  break;

+	       case GL_DOT4_ATI:

+		  {

+		     GLfloat result;

+

+		     /* DOT 4 always uses the source from the color op */

+		     result = src[0][0][0] * src[0][1][0] +

+			src[0][0][1] * src[0][1][1] +

+			src[0][0][2] * src[0][1][2] +

+			src[0][0][3] * src[0][1][3];

+		     if (!optype) {

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

+			   dst[optype][i] = result;

+			}

+		     }

+		     else

+			dst[optype][3] = result;

+		  }

+		  break;

+

+	       }

+	    }

+	 }

+

+	 /* write out the destination registers */

+	 for (optype = 0; optype < 2; optype++) {

+	    if (inst->Opcode[optype]) {

+	       dstreg = inst->DstReg[optype].Index;

+	       dstp = machine->Registers[dstreg - GL_REG_0_ATI];

+

+	       if ((optype == 0) || ((inst->Opcode[1] != GL_DOT2_ADD_ATI) &&

+		  (inst->Opcode[1] != GL_DOT3_ATI) && (inst->Opcode[1] != GL_DOT4_ATI)))

+	          write_dst_addr(optype, inst->DstReg[optype].dstMod,

+			      inst->DstReg[optype].dstMask, dst[optype],

+			      dstp);

+	       else

+		  write_dst_addr(1, inst->DstReg[0].dstMod, 0, dst[1], dstp);

+	    }

+	 }

+      }

+   }

+}

+

+

+/**

+ * Init fragment shader virtual machine state.

+ */

+static void

+init_machine(struct gl_context * ctx, struct atifs_machine *machine,

+	     const struct ati_fragment_shader *shader,

+	     const SWspan *span, GLuint col)

+{

+   GLfloat (*inputs)[4] = machine->Inputs;

+   GLint i, j;

+

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

+      for (j = 0; j < 4; j++)

+	 machine->Registers[i][j] = 0.0;

+   }

+

+   COPY_4V(inputs[ATI_FS_INPUT_PRIMARY], span->array->attribs[FRAG_ATTRIB_COL0][col]);

+   COPY_4V(inputs[ATI_FS_INPUT_SECONDARY], span->array->attribs[FRAG_ATTRIB_COL1][col]);

+}

+

+

+

+/**

+ * Execute the current ATI shader program, operating on the given span.

+ */

+void

+_swrast_exec_fragment_shader(struct gl_context * ctx, SWspan *span)

+{

+   const struct ati_fragment_shader *shader = ctx->ATIFragmentShader.Current;

+   struct atifs_machine machine;

+   GLuint i;

+

+   /* incoming colors should be floats */

+   ASSERT(span->array->ChanType == GL_FLOAT);

+

+   for (i = 0; i < span->end; i++) {

+      if (span->array->mask[i]) {

+	 init_machine(ctx, &machine, shader, span, i);

+

+	 execute_shader(ctx, shader, &machine, span, i);

+

+         /* store result color */

+	 {

+	    const GLfloat *colOut = machine.Registers[0];

+            /*fprintf(stderr,"outputs %f %f %f %f\n",

+              colOut[0], colOut[1], colOut[2], colOut[3]); */

+            COPY_4V(span->array->attribs[FRAG_ATTRIB_COL0][i], colOut);

+	 }

+      }

+   }

+}

diff --git a/mesalib/src/mesa/swrast/s_atifragshader.h b/mesalib/src/mesa/swrast/s_atifragshader.h
index cce455a04..16ed86fd7 100644
--- a/mesalib/src/mesa/swrast/s_atifragshader.h
+++ b/mesalib/src/mesa/swrast/s_atifragshader.h
@@ -1,38 +1,38 @@
-/*
- * Mesa 3-D graphics library
- * Version:  6.1
- *
- * Copyright (C) 1999-2003  David Airlie   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
- * DAVID AIRLIE 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.
- */
-
-
-#ifndef S_ATIFRAGSHADER_H
-#define S_ATIFRAGSHADER_H
-
-
-#include "main/mtypes.h"
-#include "s_span.h"
-
-
-extern void
-_swrast_exec_fragment_shader( GLcontext *ctx, SWspan *span );
-
-
-#endif
+/*

+ * Mesa 3-D graphics library

+ * Version:  6.1

+ *

+ * Copyright (C) 1999-2003  David Airlie   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

+ * DAVID AIRLIE 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.

+ */

+

+

+#ifndef S_ATIFRAGSHADER_H

+#define S_ATIFRAGSHADER_H

+

+

+#include "s_span.h"

+

+struct gl_context;

+

+extern void

+_swrast_exec_fragment_shader( struct gl_context *ctx, SWspan *span );

+

+

+#endif

diff --git a/mesalib/src/mesa/swrast/s_bitmap.c b/mesalib/src/mesa/swrast/s_bitmap.c
index da730213a..9b52e9053 100644
--- a/mesalib/src/mesa/swrast/s_bitmap.c
+++ b/mesalib/src/mesa/swrast/s_bitmap.c
@@ -1,222 +1,222 @@
-/*
- * Mesa 3-D graphics library
- * Version:  7.1
- *
- * Copyright (C) 1999-2008  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.
- */
-
-/**
- * \file swrast/s_bitmap.c
- * \brief glBitmap rendering.
- * \author Brian Paul
- */
-
-#include "main/glheader.h"
-#include "main/bufferobj.h"
-#include "main/condrender.h"
-#include "main/image.h"
-#include "main/macros.h"
-
-#include "s_context.h"
-#include "s_span.h"
-
-
-
-/**
- * Render a bitmap.
- * Called via ctx->Driver.Bitmap()
- * All parameter error checking will have been done before this is called.
- */
-void
-_swrast_Bitmap( GLcontext *ctx, GLint px, GLint py,
-		GLsizei width, GLsizei height,
-		const struct gl_pixelstore_attrib *unpack,
-		const GLubyte *bitmap )
-{
-   GLint row, col;
-   GLuint count = 0;
-   SWspan span;
-
-   ASSERT(ctx->RenderMode == GL_RENDER);
-
-   if (!_mesa_check_conditional_render(ctx))
-      return; /* don't draw */
-
-   bitmap = (const GLubyte *) _mesa_map_pbo_source(ctx, unpack, bitmap);
-   if (!bitmap)
-      return;
-
-   swrast_render_start(ctx);
-
-   if (SWRAST_CONTEXT(ctx)->NewState)
-      _swrast_validate_derived( ctx );
-
-   INIT_SPAN(span, GL_BITMAP);
-   span.end = width;
-   span.arrayMask = SPAN_XY;
-   _swrast_span_default_attribs(ctx, &span);
-
-   for (row = 0; row < height; row++) {
-      const GLubyte *src = (const GLubyte *) _mesa_image_address2d(unpack,
-                 bitmap, width, height, GL_COLOR_INDEX, GL_BITMAP, row, 0);
-
-      if (unpack->LsbFirst) {
-         /* Lsb first */
-         GLubyte mask = 1U << (unpack->SkipPixels & 0x7);
-         for (col = 0; col < width; col++) {
-            if (*src & mask) {
-               span.array->x[count] = px + col;
-               span.array->y[count] = py + row;
-               count++;
-            }
-            if (mask == 128U) {
-               src++;
-               mask = 1U;
-            }
-            else {
-               mask = mask << 1;
-            }
-         }
-
-         /* get ready for next row */
-         if (mask != 1)
-            src++;
-      }
-      else {
-         /* Msb first */
-         GLubyte mask = 128U >> (unpack->SkipPixels & 0x7);
-         for (col = 0; col < width; col++) {
-            if (*src & mask) {
-               span.array->x[count] = px + col;
-               span.array->y[count] = py + row;
-               count++;
-            }
-            if (mask == 1U) {
-               src++;
-               mask = 128U;
-            }
-            else {
-               mask = mask >> 1;
-            }
-         }
-
-         /* get ready for next row */
-         if (mask != 128)
-            src++;
-      }
-
-      if (count + width >= MAX_WIDTH || row + 1 == height) {
-         /* flush the span */
-         span.end = count;
-         _swrast_write_rgba_span(ctx, &span);
-         span.end = 0;
-         count = 0;
-      }
-   }
-
-   swrast_render_finish(ctx);
-
-   _mesa_unmap_pbo_source(ctx, unpack);
-}
-
-
-#if 0
-/*
- * XXX this is another way to implement Bitmap.  Use horizontal runs of
- * fragments, initializing the mask array to indicate which fragments to
- * draw or skip.
- */
-void
-_swrast_Bitmap( GLcontext *ctx, GLint px, GLint py,
-		GLsizei width, GLsizei height,
-		const struct gl_pixelstore_attrib *unpack,
-		const GLubyte *bitmap )
-{
-   SWcontext *swrast = SWRAST_CONTEXT(ctx);
-   GLint row, col;
-   SWspan span;
-
-   ASSERT(ctx->RenderMode == GL_RENDER);
-   ASSERT(bitmap);
-
-   swrast_render_start(ctx);
-
-   if (SWRAST_CONTEXT(ctx)->NewState)
-      _swrast_validate_derived( ctx );
-
-   INIT_SPAN(span, GL_BITMAP);
-   span.end = width;
-   span.arrayMask = SPAN_MASK;
-   _swrast_span_default_attribs(ctx, &span);
-
-   /*span.arrayMask |= SPAN_MASK;*/  /* we'll init span.mask[] */
-   span.x = px;
-   span.y = py;
-   /*span.end = width;*/
-
-   for (row=0; row<height; row++, span.y++) {
-      const GLubyte *src = (const GLubyte *) _mesa_image_address2d(unpack,
-                 bitmap, width, height, GL_COLOR_INDEX, GL_BITMAP, row, 0);
-
-      if (unpack->LsbFirst) {
-         /* Lsb first */
-         GLubyte mask = 1U << (unpack->SkipPixels & 0x7);
-         for (col=0; col<width; col++) {
-            span.array->mask[col] = (*src & mask) ? GL_TRUE : GL_FALSE;
-            if (mask == 128U) {
-               src++;
-               mask = 1U;
-            }
-            else {
-               mask = mask << 1;
-            }
-         }
-
-         _swrast_write_rgba_span(ctx, &span);
-
-         /* get ready for next row */
-         if (mask != 1)
-            src++;
-      }
-      else {
-         /* Msb first */
-         GLubyte mask = 128U >> (unpack->SkipPixels & 0x7);
-         for (col=0; col<width; col++) {
-            span.array->mask[col] = (*src & mask) ? GL_TRUE : GL_FALSE;
-            if (mask == 1U) {
-               src++;
-               mask = 128U;
-            }
-            else {
-               mask = mask >> 1;
-            }
-         }
-
-         _swrast_write_rgba_span(ctx, &span);
-
-         /* get ready for next row */
-         if (mask != 128)
-            src++;
-      }
-   }
-
-   swrast_render_finish(ctx);
-}
-#endif
+/*

+ * Mesa 3-D graphics library

+ * Version:  7.1

+ *

+ * Copyright (C) 1999-2008  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.

+ */

+

+/**

+ * \file swrast/s_bitmap.c

+ * \brief glBitmap rendering.

+ * \author Brian Paul

+ */

+

+#include "main/glheader.h"

+#include "main/bufferobj.h"

+#include "main/condrender.h"

+#include "main/image.h"

+#include "main/macros.h"

+

+#include "s_context.h"

+#include "s_span.h"

+

+

+

+/**

+ * Render a bitmap.

+ * Called via ctx->Driver.Bitmap()

+ * All parameter error checking will have been done before this is called.

+ */

+void

+_swrast_Bitmap( struct gl_context *ctx, GLint px, GLint py,

+		GLsizei width, GLsizei height,

+		const struct gl_pixelstore_attrib *unpack,

+		const GLubyte *bitmap )

+{

+   GLint row, col;

+   GLuint count = 0;

+   SWspan span;

+

+   ASSERT(ctx->RenderMode == GL_RENDER);

+

+   if (!_mesa_check_conditional_render(ctx))

+      return; /* don't draw */

+

+   bitmap = (const GLubyte *) _mesa_map_pbo_source(ctx, unpack, bitmap);

+   if (!bitmap)

+      return;

+

+   swrast_render_start(ctx);

+

+   if (SWRAST_CONTEXT(ctx)->NewState)

+      _swrast_validate_derived( ctx );

+

+   INIT_SPAN(span, GL_BITMAP);

+   span.end = width;

+   span.arrayMask = SPAN_XY;

+   _swrast_span_default_attribs(ctx, &span);

+

+   for (row = 0; row < height; row++) {

+      const GLubyte *src = (const GLubyte *) _mesa_image_address2d(unpack,

+                 bitmap, width, height, GL_COLOR_INDEX, GL_BITMAP, row, 0);

+

+      if (unpack->LsbFirst) {

+         /* Lsb first */

+         GLubyte mask = 1U << (unpack->SkipPixels & 0x7);

+         for (col = 0; col < width; col++) {

+            if (*src & mask) {

+               span.array->x[count] = px + col;

+               span.array->y[count] = py + row;

+               count++;

+            }

+            if (mask == 128U) {

+               src++;

+               mask = 1U;

+            }

+            else {

+               mask = mask << 1;

+            }

+         }

+

+         /* get ready for next row */

+         if (mask != 1)

+            src++;

+      }

+      else {

+         /* Msb first */

+         GLubyte mask = 128U >> (unpack->SkipPixels & 0x7);

+         for (col = 0; col < width; col++) {

+            if (*src & mask) {

+               span.array->x[count] = px + col;

+               span.array->y[count] = py + row;

+               count++;

+            }

+            if (mask == 1U) {

+               src++;

+               mask = 128U;

+            }

+            else {

+               mask = mask >> 1;

+            }

+         }

+

+         /* get ready for next row */

+         if (mask != 128)

+            src++;

+      }

+

+      if (count + width >= MAX_WIDTH || row + 1 == height) {

+         /* flush the span */

+         span.end = count;

+         _swrast_write_rgba_span(ctx, &span);

+         span.end = 0;

+         count = 0;

+      }

+   }

+

+   swrast_render_finish(ctx);

+

+   _mesa_unmap_pbo_source(ctx, unpack);

+}

+

+

+#if 0

+/*

+ * XXX this is another way to implement Bitmap.  Use horizontal runs of

+ * fragments, initializing the mask array to indicate which fragments to

+ * draw or skip.

+ */

+void

+_swrast_Bitmap( struct gl_context *ctx, GLint px, GLint py,

+		GLsizei width, GLsizei height,

+		const struct gl_pixelstore_attrib *unpack,

+		const GLubyte *bitmap )

+{

+   SWcontext *swrast = SWRAST_CONTEXT(ctx);

+   GLint row, col;

+   SWspan span;

+

+   ASSERT(ctx->RenderMode == GL_RENDER);

+   ASSERT(bitmap);

+

+   swrast_render_start(ctx);

+

+   if (SWRAST_CONTEXT(ctx)->NewState)

+      _swrast_validate_derived( ctx );

+

+   INIT_SPAN(span, GL_BITMAP);

+   span.end = width;

+   span.arrayMask = SPAN_MASK;

+   _swrast_span_default_attribs(ctx, &span);

+

+   /*span.arrayMask |= SPAN_MASK;*/  /* we'll init span.mask[] */

+   span.x = px;

+   span.y = py;

+   /*span.end = width;*/

+

+   for (row=0; row<height; row++, span.y++) {

+      const GLubyte *src = (const GLubyte *) _mesa_image_address2d(unpack,

+                 bitmap, width, height, GL_COLOR_INDEX, GL_BITMAP, row, 0);

+

+      if (unpack->LsbFirst) {

+         /* Lsb first */

+         GLubyte mask = 1U << (unpack->SkipPixels & 0x7);

+         for (col=0; col<width; col++) {

+            span.array->mask[col] = (*src & mask) ? GL_TRUE : GL_FALSE;

+            if (mask == 128U) {

+               src++;

+               mask = 1U;

+            }

+            else {

+               mask = mask << 1;

+            }

+         }

+

+         _swrast_write_rgba_span(ctx, &span);

+

+         /* get ready for next row */

+         if (mask != 1)

+            src++;

+      }

+      else {

+         /* Msb first */

+         GLubyte mask = 128U >> (unpack->SkipPixels & 0x7);

+         for (col=0; col<width; col++) {

+            span.array->mask[col] = (*src & mask) ? GL_TRUE : GL_FALSE;

+            if (mask == 1U) {

+               src++;

+               mask = 128U;

+            }

+            else {

+               mask = mask >> 1;

+            }

+         }

+

+         _swrast_write_rgba_span(ctx, &span);

+

+         /* get ready for next row */

+         if (mask != 128)

+            src++;

+      }

+   }

+

+   swrast_render_finish(ctx);

+}

+#endif

diff --git a/mesalib/src/mesa/swrast/s_blend.c b/mesalib/src/mesa/swrast/s_blend.c
index 5b090c72c..d2684b79e 100644
--- a/mesalib/src/mesa/swrast/s_blend.c
+++ b/mesalib/src/mesa/swrast/s_blend.c
@@ -1,1002 +1,1014 @@
-/*
- * Mesa 3-D graphics library
- * Version:  7.1
- *
- * Copyright (C) 1999-2008  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.
- */
-
-
-/**
- * \file swrast/s_blend.c
- * \brief software blending.
- * \author Brian Paul
- *
- * Only a few blend modes have been optimized (min, max, transparency, add)
- * more optimized cases can easily be added if needed.
- * Celestia uses glBlendFunc(GL_SRC_ALPHA, GL_ONE), for example.
- */
-
-
-
-#include "main/glheader.h"
-#include "main/context.h"
-#include "main/colormac.h"
-#include "main/macros.h"
-
-#include "s_blend.h"
-#include "s_context.h"
-#include "s_span.h"
-
-
-#if defined(USE_MMX_ASM)
-#include "x86/mmx.h"
-#include "x86/common_x86_asm.h"
-#define _BLENDAPI _ASMAPI
-#else
-#define _BLENDAPI
-#endif
-
-
-/**
- * Integer divide by 255
- * Declare "int divtemp" before using.
- * This satisfies Glean and should be reasonably fast.
- * Contributed by Nathan Hand.
- */
-#define DIV255(X)  (divtemp = (X), ((divtemp << 8) + divtemp + 256) >> 16)
-
-
-
-/**
- * Special case for glBlendFunc(GL_ZERO, GL_ONE).
- * No-op means the framebuffer values remain unchanged.
- * Any chanType ok.
- */
-static void _BLENDAPI
-blend_noop(GLcontext *ctx, GLuint n, const GLubyte mask[],
-           GLvoid *src, const GLvoid *dst, GLenum chanType)
-{
-   GLint bytes;
-
-   ASSERT(ctx->Color.BlendEquationRGB == GL_FUNC_ADD);
-   ASSERT(ctx->Color.BlendEquationA == GL_FUNC_ADD);
-   ASSERT(ctx->Color.BlendSrcRGB == GL_ZERO);
-   ASSERT(ctx->Color.BlendDstRGB == GL_ONE);
-   (void) ctx;
-
-   /* just memcpy */
-   if (chanType == GL_UNSIGNED_BYTE)
-      bytes = 4 * n * sizeof(GLubyte);
-   else if (chanType == GL_UNSIGNED_SHORT)
-      bytes = 4 * n * sizeof(GLushort);
-   else
-      bytes = 4 * n * sizeof(GLfloat);
-
-   memcpy(src, dst, bytes);
-}
-
-
-/**
- * Special case for glBlendFunc(GL_ONE, GL_ZERO)
- * Any chanType ok.
- */
-static void _BLENDAPI
-blend_replace(GLcontext *ctx, GLuint n, const GLubyte mask[],
-              GLvoid *src, const GLvoid *dst, GLenum chanType)
-{
-   ASSERT(ctx->Color.BlendEquationRGB == GL_FUNC_ADD);
-   ASSERT(ctx->Color.BlendEquationA == GL_FUNC_ADD);
-   ASSERT(ctx->Color.BlendSrcRGB == GL_ONE);
-   ASSERT(ctx->Color.BlendDstRGB == GL_ZERO);
-   (void) ctx;
-   (void) n;
-   (void) mask;
-   (void) src;
-   (void) dst;
-}
-
-
-/**
- * Common transparency blending mode:
- * glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA).
- */
-static void _BLENDAPI
-blend_transparency_ubyte(GLcontext *ctx, GLuint n, const GLubyte mask[],
-                         GLvoid *src, const GLvoid *dst, GLenum chanType)
-{
-   GLubyte (*rgba)[4] = (GLubyte (*)[4]) src;
-   const GLubyte (*dest)[4] = (const GLubyte (*)[4]) dst;
-   GLuint i;
-
-   ASSERT(ctx->Color.BlendEquationRGB == GL_FUNC_ADD);
-   ASSERT(ctx->Color.BlendEquationA == GL_FUNC_ADD);
-   ASSERT(ctx->Color.BlendSrcRGB == GL_SRC_ALPHA);
-   ASSERT(ctx->Color.BlendSrcA == GL_SRC_ALPHA);
-   ASSERT(ctx->Color.BlendDstRGB == GL_ONE_MINUS_SRC_ALPHA);
-   ASSERT(ctx->Color.BlendDstA == GL_ONE_MINUS_SRC_ALPHA);
-   ASSERT(chanType == GL_UNSIGNED_BYTE);
-
-   (void) ctx;
-
-   for (i = 0; i < n; i++) {
-      if (mask[i]) {
-         const GLint t = rgba[i][ACOMP];  /* t is in [0, 255] */
-         if (t == 0) {
-            /* 0% alpha */
-            COPY_4UBV(rgba[i], dest[i]);
-         }
-         else if (t != 255) {
-	    GLint divtemp;
-            const GLint r = DIV255((rgba[i][RCOMP] - dest[i][RCOMP]) * t) + dest[i][RCOMP];
-            const GLint g = DIV255((rgba[i][GCOMP] - dest[i][GCOMP]) * t) + dest[i][GCOMP];
-            const GLint b = DIV255((rgba[i][BCOMP] - dest[i][BCOMP]) * t) + dest[i][BCOMP];
-            const GLint a = DIV255((rgba[i][ACOMP] - dest[i][ACOMP]) * t) + dest[i][ACOMP]; 
-            ASSERT(r <= 255);
-            ASSERT(g <= 255);
-            ASSERT(b <= 255);
-            ASSERT(a <= 255);
-            rgba[i][RCOMP] = (GLubyte) r;
-            rgba[i][GCOMP] = (GLubyte) g;
-            rgba[i][BCOMP] = (GLubyte) b;
-            rgba[i][ACOMP] = (GLubyte) a;
-         }
-      }
-   }
-}
-
-
-static void _BLENDAPI
-blend_transparency_ushort(GLcontext *ctx, GLuint n, const GLubyte mask[],
-                          GLvoid *src, const GLvoid *dst, GLenum chanType)
-{
-   GLushort (*rgba)[4] = (GLushort (*)[4]) src;
-   const GLushort (*dest)[4] = (const GLushort (*)[4]) dst;
-   GLuint i;
-
-   ASSERT(ctx->Color.BlendEquationRGB == GL_FUNC_ADD);
-   ASSERT(ctx->Color.BlendEquationA == GL_FUNC_ADD);
-   ASSERT(ctx->Color.BlendSrcRGB == GL_SRC_ALPHA);
-   ASSERT(ctx->Color.BlendSrcA == GL_SRC_ALPHA);
-   ASSERT(ctx->Color.BlendDstRGB == GL_ONE_MINUS_SRC_ALPHA);
-   ASSERT(ctx->Color.BlendDstA == GL_ONE_MINUS_SRC_ALPHA);
-   ASSERT(chanType == GL_UNSIGNED_SHORT);
-
-   (void) ctx;
-
-   for (i = 0; i < n; i++) {
-      if (mask[i]) {
-         const GLint t = rgba[i][ACOMP];
-         if (t == 0) {
-            /* 0% alpha */
-            COPY_4V(rgba[i], dest[i]);
-         }
-         else if (t != 65535) {
-            const GLfloat tt = (GLfloat) t / 65535.0F;
-            GLushort r = (GLushort) ((rgba[i][RCOMP] - dest[i][RCOMP]) * tt + dest[i][RCOMP]);
-            GLushort g = (GLushort) ((rgba[i][GCOMP] - dest[i][GCOMP]) * tt + dest[i][GCOMP]);
-            GLushort b = (GLushort) ((rgba[i][BCOMP] - dest[i][BCOMP]) * tt + dest[i][BCOMP]);
-            GLushort a = (GLushort) ((rgba[i][ACOMP] - dest[i][ACOMP]) * tt + dest[i][ACOMP]);
-            ASSIGN_4V(rgba[i], r, g, b, a);
-         }
-      }
-   }
-}
-
-
-static void _BLENDAPI
-blend_transparency_float(GLcontext *ctx, GLuint n, const GLubyte mask[],
-                         GLvoid *src, const GLvoid *dst, GLenum chanType)
-{
-   GLfloat (*rgba)[4] = (GLfloat (*)[4]) src;
-   const GLfloat (*dest)[4] = (const GLfloat (*)[4]) dst;
-   GLuint i;
-
-   ASSERT(ctx->Color.BlendEquationRGB == GL_FUNC_ADD);
-   ASSERT(ctx->Color.BlendEquationA == GL_FUNC_ADD);
-   ASSERT(ctx->Color.BlendSrcRGB == GL_SRC_ALPHA);
-   ASSERT(ctx->Color.BlendSrcA == GL_SRC_ALPHA);
-   ASSERT(ctx->Color.BlendDstRGB == GL_ONE_MINUS_SRC_ALPHA);
-   ASSERT(ctx->Color.BlendDstA == GL_ONE_MINUS_SRC_ALPHA);
-   ASSERT(chanType == GL_FLOAT);
-
-   (void) ctx;
-
-   for (i = 0; i < n; i++) {
-      if (mask[i]) {
-         const GLfloat t = rgba[i][ACOMP];  /* t in [0, 1] */
-         if (t == 0.0F) {
-            /* 0% alpha */
-            COPY_4V(rgba[i], dest[i]);
-         }
-         else if (t != 1.0F) {
-            GLfloat r = (rgba[i][RCOMP] - dest[i][RCOMP]) * t + dest[i][RCOMP];
-            GLfloat g = (rgba[i][GCOMP] - dest[i][GCOMP]) * t + dest[i][GCOMP];
-            GLfloat b = (rgba[i][BCOMP] - dest[i][BCOMP]) * t + dest[i][BCOMP];
-            GLfloat a = (rgba[i][ACOMP] - dest[i][ACOMP]) * t + dest[i][ACOMP];
-            ASSIGN_4V(rgba[i], r, g, b, a);
-         }
-      }
-   }
-}
-
-
-
-/**
- * Add src and dest: glBlendFunc(GL_ONE, GL_ONE).
- * Any chanType ok.
- */
-static void _BLENDAPI
-blend_add(GLcontext *ctx, GLuint n, const GLubyte mask[],
-          GLvoid *src, const GLvoid *dst, GLenum chanType)
-{
-   GLuint i;
-
-   ASSERT(ctx->Color.BlendEquationRGB == GL_FUNC_ADD);
-   ASSERT(ctx->Color.BlendEquationA == GL_FUNC_ADD);
-   ASSERT(ctx->Color.BlendSrcRGB == GL_ONE);
-   ASSERT(ctx->Color.BlendDstRGB == GL_ONE);
-   (void) ctx;
-
-   if (chanType == GL_UNSIGNED_BYTE) {
-      GLubyte (*rgba)[4] = (GLubyte (*)[4]) src;
-      const GLubyte (*dest)[4] = (const GLubyte (*)[4]) dst;
-      for (i=0;i<n;i++) {
-         if (mask[i]) {
-            GLint r = rgba[i][RCOMP] + dest[i][RCOMP];
-            GLint g = rgba[i][GCOMP] + dest[i][GCOMP];
-            GLint b = rgba[i][BCOMP] + dest[i][BCOMP];
-            GLint a = rgba[i][ACOMP] + dest[i][ACOMP];
-            rgba[i][RCOMP] = (GLubyte) MIN2( r, 255 );
-            rgba[i][GCOMP] = (GLubyte) MIN2( g, 255 );
-            rgba[i][BCOMP] = (GLubyte) MIN2( b, 255 );
-            rgba[i][ACOMP] = (GLubyte) MIN2( a, 255 );
-         }
-      }
-   }
-   else if (chanType == GL_UNSIGNED_SHORT) {
-      GLushort (*rgba)[4] = (GLushort (*)[4]) src;
-      const GLushort (*dest)[4] = (const GLushort (*)[4]) dst;
-      for (i=0;i<n;i++) {
-         if (mask[i]) {
-            GLint r = rgba[i][RCOMP] + dest[i][RCOMP];
-            GLint g = rgba[i][GCOMP] + dest[i][GCOMP];
-            GLint b = rgba[i][BCOMP] + dest[i][BCOMP];
-            GLint a = rgba[i][ACOMP] + dest[i][ACOMP];
-            rgba[i][RCOMP] = (GLshort) MIN2( r, 255 );
-            rgba[i][GCOMP] = (GLshort) MIN2( g, 255 );
-            rgba[i][BCOMP] = (GLshort) MIN2( b, 255 );
-            rgba[i][ACOMP] = (GLshort) MIN2( a, 255 );
-         }
-      }
-   }
-   else {
-      GLfloat (*rgba)[4] = (GLfloat (*)[4]) src;
-      const GLfloat (*dest)[4] = (const GLfloat (*)[4]) dst;
-      ASSERT(chanType == GL_FLOAT);
-      for (i=0;i<n;i++) {
-         if (mask[i]) {
-            /* don't RGB clamp to max */
-            rgba[i][RCOMP] += dest[i][RCOMP];
-            rgba[i][GCOMP] += dest[i][GCOMP];
-            rgba[i][BCOMP] += dest[i][BCOMP];
-            rgba[i][ACOMP] += dest[i][ACOMP];
-         }
-      }
-   }
-}
-
-
-
-/**
- * Blend min function.
- * Any chanType ok.
- */
-static void _BLENDAPI
-blend_min(GLcontext *ctx, GLuint n, const GLubyte mask[],
-          GLvoid *src, const GLvoid *dst, GLenum chanType)
-{
-   GLuint i;
-   ASSERT(ctx->Color.BlendEquationRGB == GL_MIN);
-   ASSERT(ctx->Color.BlendEquationA == GL_MIN);
-   (void) ctx;
-
-   if (chanType == GL_UNSIGNED_BYTE) {
-      GLubyte (*rgba)[4] = (GLubyte (*)[4]) src;
-      const GLubyte (*dest)[4] = (const GLubyte (*)[4]) dst;
-      for (i=0;i<n;i++) {
-         if (mask[i]) {
-            rgba[i][RCOMP] = MIN2( rgba[i][RCOMP], dest[i][RCOMP] );
-            rgba[i][GCOMP] = MIN2( rgba[i][GCOMP], dest[i][GCOMP] );
-            rgba[i][BCOMP] = MIN2( rgba[i][BCOMP], dest[i][BCOMP] );
-            rgba[i][ACOMP] = MIN2( rgba[i][ACOMP], dest[i][ACOMP] );
-         }
-      }
-   }
-   else if (chanType == GL_UNSIGNED_SHORT) {
-      GLushort (*rgba)[4] = (GLushort (*)[4]) src;
-      const GLushort (*dest)[4] = (const GLushort (*)[4]) dst;
-      for (i=0;i<n;i++) {
-         if (mask[i]) {
-            rgba[i][RCOMP] = MIN2( rgba[i][RCOMP], dest[i][RCOMP] );
-            rgba[i][GCOMP] = MIN2( rgba[i][GCOMP], dest[i][GCOMP] );
-            rgba[i][BCOMP] = MIN2( rgba[i][BCOMP], dest[i][BCOMP] );
-            rgba[i][ACOMP] = MIN2( rgba[i][ACOMP], dest[i][ACOMP] );
-         }
-      }
-   }
-   else {
-      GLfloat (*rgba)[4] = (GLfloat (*)[4]) src;
-      const GLfloat (*dest)[4] = (const GLfloat (*)[4]) dst;
-      ASSERT(chanType == GL_FLOAT);
-      for (i=0;i<n;i++) {
-         if (mask[i]) {
-            rgba[i][RCOMP] = MIN2( rgba[i][RCOMP], dest[i][RCOMP] );
-            rgba[i][GCOMP] = MIN2( rgba[i][GCOMP], dest[i][GCOMP] );
-            rgba[i][BCOMP] = MIN2( rgba[i][BCOMP], dest[i][BCOMP] );
-            rgba[i][ACOMP] = MIN2( rgba[i][ACOMP], dest[i][ACOMP] );
-         }
-      }
-   }
-}
-
-
-/**
- * Blend max function.
- * Any chanType ok.
- */
-static void _BLENDAPI
-blend_max(GLcontext *ctx, GLuint n, const GLubyte mask[],
-          GLvoid *src, const GLvoid *dst, GLenum chanType)
-{
-   GLuint i;
-   ASSERT(ctx->Color.BlendEquationRGB == GL_MAX);
-   ASSERT(ctx->Color.BlendEquationA == GL_MAX);
-   (void) ctx;
-
-   if (chanType == GL_UNSIGNED_BYTE) {
-      GLubyte (*rgba)[4] = (GLubyte (*)[4]) src;
-      const GLubyte (*dest)[4] = (const GLubyte (*)[4]) dst;
-      for (i=0;i<n;i++) {
-         if (mask[i]) {
-            rgba[i][RCOMP] = MAX2( rgba[i][RCOMP], dest[i][RCOMP] );
-            rgba[i][GCOMP] = MAX2( rgba[i][GCOMP], dest[i][GCOMP] );
-            rgba[i][BCOMP] = MAX2( rgba[i][BCOMP], dest[i][BCOMP] );
-            rgba[i][ACOMP] = MAX2( rgba[i][ACOMP], dest[i][ACOMP] );
-         }
-      }
-   }
-   else if (chanType == GL_UNSIGNED_SHORT) {
-      GLushort (*rgba)[4] = (GLushort (*)[4]) src;
-      const GLushort (*dest)[4] = (const GLushort (*)[4]) dst;
-      for (i=0;i<n;i++) {
-         if (mask[i]) {
-            rgba[i][RCOMP] = MAX2( rgba[i][RCOMP], dest[i][RCOMP] );
-            rgba[i][GCOMP] = MAX2( rgba[i][GCOMP], dest[i][GCOMP] );
-            rgba[i][BCOMP] = MAX2( rgba[i][BCOMP], dest[i][BCOMP] );
-            rgba[i][ACOMP] = MAX2( rgba[i][ACOMP], dest[i][ACOMP] );
-         }
-      }
-   }
-   else {
-      GLfloat (*rgba)[4] = (GLfloat (*)[4]) src;
-      const GLfloat (*dest)[4] = (const GLfloat (*)[4]) dst;
-      ASSERT(chanType == GL_FLOAT);
-      for (i=0;i<n;i++) {
-         if (mask[i]) {
-            rgba[i][RCOMP] = MAX2( rgba[i][RCOMP], dest[i][RCOMP] );
-            rgba[i][GCOMP] = MAX2( rgba[i][GCOMP], dest[i][GCOMP] );
-            rgba[i][BCOMP] = MAX2( rgba[i][BCOMP], dest[i][BCOMP] );
-            rgba[i][ACOMP] = MAX2( rgba[i][ACOMP], dest[i][ACOMP] );
-         }
-      }
-   }
-}
-
-
-
-/**
- * Modulate:  result = src * dest
- * Any chanType ok.
- */
-static void _BLENDAPI
-blend_modulate(GLcontext *ctx, GLuint n, const GLubyte mask[],
-               GLvoid *src, const GLvoid *dst, GLenum chanType)
-{
-   GLuint i;
-   (void) ctx;
-
-   if (chanType == GL_UNSIGNED_BYTE) {
-      GLubyte (*rgba)[4] = (GLubyte (*)[4]) src;
-      const GLubyte (*dest)[4] = (const GLubyte (*)[4]) dst;
-      for (i=0;i<n;i++) {
-         if (mask[i]) {
-	    GLint divtemp;
-            rgba[i][RCOMP] = DIV255(rgba[i][RCOMP] * dest[i][RCOMP]);
-            rgba[i][GCOMP] = DIV255(rgba[i][GCOMP] * dest[i][GCOMP]);
-            rgba[i][BCOMP] = DIV255(rgba[i][BCOMP] * dest[i][BCOMP]);
-            rgba[i][ACOMP] = DIV255(rgba[i][ACOMP] * dest[i][ACOMP]);
-         }
-      }
-   }
-   else if (chanType == GL_UNSIGNED_SHORT) {
-      GLushort (*rgba)[4] = (GLushort (*)[4]) src;
-      const GLushort (*dest)[4] = (const GLushort (*)[4]) dst;
-      for (i=0;i<n;i++) {
-         if (mask[i]) {
-            rgba[i][RCOMP] = (rgba[i][RCOMP] * dest[i][RCOMP] + 65535) >> 16;
-            rgba[i][GCOMP] = (rgba[i][GCOMP] * dest[i][GCOMP] + 65535) >> 16;
-            rgba[i][BCOMP] = (rgba[i][BCOMP] * dest[i][BCOMP] + 65535) >> 16;
-            rgba[i][ACOMP] = (rgba[i][ACOMP] * dest[i][ACOMP] + 65535) >> 16;
-         }
-      }
-   }
-   else {
-      GLfloat (*rgba)[4] = (GLfloat (*)[4]) src;
-      const GLfloat (*dest)[4] = (const GLfloat (*)[4]) dst;
-      ASSERT(chanType == GL_FLOAT);
-      for (i=0;i<n;i++) {
-         if (mask[i]) {
-            rgba[i][RCOMP] = rgba[i][RCOMP] * dest[i][RCOMP];
-            rgba[i][GCOMP] = rgba[i][GCOMP] * dest[i][GCOMP];
-            rgba[i][BCOMP] = rgba[i][BCOMP] * dest[i][BCOMP];
-            rgba[i][ACOMP] = rgba[i][ACOMP] * dest[i][ACOMP];
-         }
-      }
-   }
-}
-
-
-/**
- * Do any blending operation, using floating point.
- * \param n  number of pixels
- * \param mask  fragment writemask array
- * \param rgba  array of incoming (and modified) pixels
- * \param dest  array of pixels from the dest color buffer
- */
-static void
-blend_general_float(GLcontext *ctx, GLuint n, const GLubyte mask[],
-                    GLfloat rgba[][4], GLfloat dest[][4],
-                    GLenum chanType)
-{
-   GLuint i;
-
-   for (i = 0; i < n; i++) {
-      if (mask[i]) {
-         /* Incoming/source Color */
-         const GLfloat Rs = rgba[i][RCOMP];
-         const GLfloat Gs = rgba[i][GCOMP];
-         const GLfloat Bs = rgba[i][BCOMP];
-         const GLfloat As = rgba[i][ACOMP];
-
-         /* Frame buffer/dest color */
-         const GLfloat Rd = dest[i][RCOMP];
-         const GLfloat Gd = dest[i][GCOMP];
-         const GLfloat Bd = dest[i][BCOMP];
-         const GLfloat Ad = dest[i][ACOMP];
-
-         GLfloat sR, sG, sB, sA;  /* Source factor */
-         GLfloat dR, dG, dB, dA;  /* Dest factor */
-         GLfloat r, g, b, a;      /* result color */
-
-         /* XXX for the case of constant blend terms we could init
-          * the sX and dX variables just once before the loop.
-          */
-
-         /* Source RGB factor */
-         switch (ctx->Color.BlendSrcRGB) {
-            case GL_ZERO:
-               sR = sG = sB = 0.0F;
-               break;
-            case GL_ONE:
-               sR = sG = sB = 1.0F;
-               break;
-            case GL_DST_COLOR:
-               sR = Rd;
-               sG = Gd;
-               sB = Bd;
-               break;
-            case GL_ONE_MINUS_DST_COLOR:
-               sR = 1.0F - Rd;
-               sG = 1.0F - Gd;
-               sB = 1.0F - Bd;
-               break;
-            case GL_SRC_ALPHA:
-               sR = sG = sB = As;
-               break;
-            case GL_ONE_MINUS_SRC_ALPHA:
-               sR = sG = sB = 1.0F - As;
-               break;
-            case GL_DST_ALPHA:
-               sR = sG = sB = Ad;
-               break;
-            case GL_ONE_MINUS_DST_ALPHA:
-               sR = sG = sB = 1.0F - Ad;
-               break;
-            case GL_SRC_ALPHA_SATURATE:
-               if (As < 1.0F - Ad) {
-                  sR = sG = sB = As;
-               }
-               else {
-                  sR = sG = sB = 1.0F - Ad;
-               }
-               break;
-            case GL_CONSTANT_COLOR:
-               sR = ctx->Color.BlendColor[0];
-               sG = ctx->Color.BlendColor[1];
-               sB = ctx->Color.BlendColor[2];
-               break;
-            case GL_ONE_MINUS_CONSTANT_COLOR:
-               sR = 1.0F - ctx->Color.BlendColor[0];
-               sG = 1.0F - ctx->Color.BlendColor[1];
-               sB = 1.0F - ctx->Color.BlendColor[2];
-               break;
-            case GL_CONSTANT_ALPHA:
-               sR = sG = sB = ctx->Color.BlendColor[3];
-               break;
-            case GL_ONE_MINUS_CONSTANT_ALPHA:
-               sR = sG = sB = 1.0F - ctx->Color.BlendColor[3];
-               break;
-            case GL_SRC_COLOR:
-               sR = Rs;
-               sG = Gs;
-               sB = Bs;
-               break;
-            case GL_ONE_MINUS_SRC_COLOR:
-               sR = 1.0F - Rs;
-               sG = 1.0F - Gs;
-               sB = 1.0F - Bs;
-               break;
-            default:
-               /* this should never happen */
-               _mesa_problem(ctx, "Bad blend source RGB factor in blend_general_float");
-               return;
-         }
-
-         /* Source Alpha factor */
-         switch (ctx->Color.BlendSrcA) {
-            case GL_ZERO:
-               sA = 0.0F;
-               break;
-            case GL_ONE:
-               sA = 1.0F;
-               break;
-            case GL_DST_COLOR:
-               sA = Ad;
-               break;
-            case GL_ONE_MINUS_DST_COLOR:
-               sA = 1.0F - Ad;
-               break;
-            case GL_SRC_ALPHA:
-               sA = As;
-               break;
-            case GL_ONE_MINUS_SRC_ALPHA:
-               sA = 1.0F - As;
-               break;
-            case GL_DST_ALPHA:
-               sA = Ad;
-               break;
-            case GL_ONE_MINUS_DST_ALPHA:
-               sA = 1.0F - Ad;
-               break;
-            case GL_SRC_ALPHA_SATURATE:
-               sA = 1.0;
-               break;
-            case GL_CONSTANT_COLOR:
-               sA = ctx->Color.BlendColor[3];
-               break;
-            case GL_ONE_MINUS_CONSTANT_COLOR:
-               sA = 1.0F - ctx->Color.BlendColor[3];
-               break;
-            case GL_CONSTANT_ALPHA:
-               sA = ctx->Color.BlendColor[3];
-               break;
-            case GL_ONE_MINUS_CONSTANT_ALPHA:
-               sA = 1.0F - ctx->Color.BlendColor[3];
-               break;
-            case GL_SRC_COLOR:
-               sA = As;
-               break;
-            case GL_ONE_MINUS_SRC_COLOR:
-               sA = 1.0F - As;
-               break;
-            default:
-               /* this should never happen */
-               sA = 0.0F;
-               _mesa_problem(ctx, "Bad blend source A factor in blend_general_float");
-               return;
-         }
-
-         /* Dest RGB factor */
-         switch (ctx->Color.BlendDstRGB) {
-            case GL_ZERO:
-               dR = dG = dB = 0.0F;
-               break;
-            case GL_ONE:
-               dR = dG = dB = 1.0F;
-               break;
-            case GL_SRC_COLOR:
-               dR = Rs;
-               dG = Gs;
-               dB = Bs;
-               break;
-            case GL_ONE_MINUS_SRC_COLOR:
-               dR = 1.0F - Rs;
-               dG = 1.0F - Gs;
-               dB = 1.0F - Bs;
-               break;
-            case GL_SRC_ALPHA:
-               dR = dG = dB = As;
-               break;
-            case GL_ONE_MINUS_SRC_ALPHA:
-               dR = dG = dB = 1.0F - As;
-               break;
-            case GL_DST_ALPHA:
-               dR = dG = dB = Ad;
-               break;
-            case GL_ONE_MINUS_DST_ALPHA:
-               dR = dG = dB = 1.0F - Ad;
-               break;
-            case GL_CONSTANT_COLOR:
-               dR = ctx->Color.BlendColor[0];
-               dG = ctx->Color.BlendColor[1];
-               dB = ctx->Color.BlendColor[2];
-               break;
-            case GL_ONE_MINUS_CONSTANT_COLOR:
-               dR = 1.0F - ctx->Color.BlendColor[0];
-               dG = 1.0F - ctx->Color.BlendColor[1];
-               dB = 1.0F - ctx->Color.BlendColor[2];
-               break;
-            case GL_CONSTANT_ALPHA:
-               dR = dG = dB = ctx->Color.BlendColor[3];
-               break;
-            case GL_ONE_MINUS_CONSTANT_ALPHA:
-               dR = dG = dB = 1.0F - ctx->Color.BlendColor[3];
-               break;
-            case GL_DST_COLOR:
-               dR = Rd;
-               dG = Gd;
-               dB = Bd;
-               break;
-            case GL_ONE_MINUS_DST_COLOR:
-               dR = 1.0F - Rd;
-               dG = 1.0F - Gd;
-               dB = 1.0F - Bd;
-               break;
-            default:
-               /* this should never happen */
-               dR = dG = dB = 0.0F;
-               _mesa_problem(ctx, "Bad blend dest RGB factor in blend_general_float");
-               return;
-         }
-
-         /* Dest Alpha factor */
-         switch (ctx->Color.BlendDstA) {
-            case GL_ZERO:
-               dA = 0.0F;
-               break;
-            case GL_ONE:
-               dA = 1.0F;
-               break;
-            case GL_SRC_COLOR:
-               dA = As;
-               break;
-            case GL_ONE_MINUS_SRC_COLOR:
-               dA = 1.0F - As;
-               break;
-            case GL_SRC_ALPHA:
-               dA = As;
-               break;
-            case GL_ONE_MINUS_SRC_ALPHA:
-               dA = 1.0F - As;
-               break;
-            case GL_DST_ALPHA:
-               dA = Ad;
-               break;
-            case GL_ONE_MINUS_DST_ALPHA:
-               dA = 1.0F - Ad;
-               break;
-            case GL_CONSTANT_COLOR:
-               dA = ctx->Color.BlendColor[3];
-               break;
-            case GL_ONE_MINUS_CONSTANT_COLOR:
-               dA = 1.0F - ctx->Color.BlendColor[3];
-               break;
-            case GL_CONSTANT_ALPHA:
-               dA = ctx->Color.BlendColor[3];
-               break;
-            case GL_ONE_MINUS_CONSTANT_ALPHA:
-               dA = 1.0F - ctx->Color.BlendColor[3];
-               break;
-            case GL_DST_COLOR:
-               dA = Ad;
-               break;
-            case GL_ONE_MINUS_DST_COLOR:
-               dA = 1.0F - Ad;
-               break;
-            default:
-               /* this should never happen */
-               dA = 0.0F;
-               _mesa_problem(ctx, "Bad blend dest A factor in blend_general_float");
-               return;
-         }
-
-         /* compute the blended RGB */
-         switch (ctx->Color.BlendEquationRGB) {
-         case GL_FUNC_ADD:
-            r = Rs * sR + Rd * dR;
-            g = Gs * sG + Gd * dG;
-            b = Bs * sB + Bd * dB;
-            a = As * sA + Ad * dA;
-            break;
-         case GL_FUNC_SUBTRACT:
-            r = Rs * sR - Rd * dR;
-            g = Gs * sG - Gd * dG;
-            b = Bs * sB - Bd * dB;
-            a = As * sA - Ad * dA;
-            break;
-         case GL_FUNC_REVERSE_SUBTRACT:
-            r = Rd * dR - Rs * sR;
-            g = Gd * dG - Gs * sG;
-            b = Bd * dB - Bs * sB;
-            a = Ad * dA - As * sA;
-            break;
-         case GL_MIN:
-	    r = MIN2( Rd, Rs );
-	    g = MIN2( Gd, Gs );
-	    b = MIN2( Bd, Bs );
-            break;
-         case GL_MAX:
-	    r = MAX2( Rd, Rs );
-	    g = MAX2( Gd, Gs );
-	    b = MAX2( Bd, Bs );
-            break;
-	 default:
-            /* should never get here */
-            r = g = b = 0.0F;  /* silence uninitialized var warning */
-            _mesa_problem(ctx, "unexpected BlendEquation in blend_general()");
-            return;
-         }
-
-         /* compute the blended alpha */
-         switch (ctx->Color.BlendEquationA) {
-         case GL_FUNC_ADD:
-            a = As * sA + Ad * dA;
-            break;
-         case GL_FUNC_SUBTRACT:
-            a = As * sA - Ad * dA;
-            break;
-         case GL_FUNC_REVERSE_SUBTRACT:
-            a = Ad * dA - As * sA;
-            break;
-         case GL_MIN:
-	    a = MIN2( Ad, As );
-            break;
-         case GL_MAX:
-	    a = MAX2( Ad, As );
-            break;
-         default:
-            /* should never get here */
-            a = 0.0F;  /* silence uninitialized var warning */
-            _mesa_problem(ctx, "unexpected BlendEquation in blend_general()");
-            return;
-         }
-
-         /* final clamping */
-#if 0
-         rgba[i][RCOMP] = MAX2( r, 0.0F );
-         rgba[i][GCOMP] = MAX2( g, 0.0F );
-         rgba[i][BCOMP] = MAX2( b, 0.0F );
-         rgba[i][ACOMP] = CLAMP( a, 0.0F, 1.0F );
-#else
-         ASSIGN_4V(rgba[i], r, g, b, a);
-#endif
-      }
-   }
-}
-
-
-/**
- * Do any blending operation, any chanType.
- */
-static void
-blend_general(GLcontext *ctx, GLuint n, const GLubyte mask[],
-              void *src, const void *dst, GLenum chanType)
-{
-   GLfloat rgbaF[MAX_WIDTH][4], destF[MAX_WIDTH][4];
-
-   if (chanType == GL_UNSIGNED_BYTE) {
-      GLubyte (*rgba)[4] = (GLubyte (*)[4]) src;
-      const GLubyte (*dest)[4] = (const GLubyte (*)[4]) dst;
-      GLuint i;
-      /* convert ubytes to floats */
-      for (i = 0; i < n; i++) {
-         if (mask[i]) {
-            rgbaF[i][RCOMP] = UBYTE_TO_FLOAT(rgba[i][RCOMP]);
-            rgbaF[i][GCOMP] = UBYTE_TO_FLOAT(rgba[i][GCOMP]);
-            rgbaF[i][BCOMP] = UBYTE_TO_FLOAT(rgba[i][BCOMP]);
-            rgbaF[i][ACOMP] = UBYTE_TO_FLOAT(rgba[i][ACOMP]);
-            destF[i][RCOMP] = UBYTE_TO_FLOAT(dest[i][RCOMP]);
-            destF[i][GCOMP] = UBYTE_TO_FLOAT(dest[i][GCOMP]);
-            destF[i][BCOMP] = UBYTE_TO_FLOAT(dest[i][BCOMP]);
-            destF[i][ACOMP] = UBYTE_TO_FLOAT(dest[i][ACOMP]);
-         }
-      }
-      /* do blend */
-      blend_general_float(ctx, n, mask, rgbaF, destF, chanType);
-      /* convert back to ubytes */
-      for (i = 0; i < n; i++) {
-         if (mask[i]) {
-            UNCLAMPED_FLOAT_TO_UBYTE(rgba[i][RCOMP], rgbaF[i][RCOMP]);
-            UNCLAMPED_FLOAT_TO_UBYTE(rgba[i][GCOMP], rgbaF[i][GCOMP]);
-            UNCLAMPED_FLOAT_TO_UBYTE(rgba[i][BCOMP], rgbaF[i][BCOMP]);
-            UNCLAMPED_FLOAT_TO_UBYTE(rgba[i][ACOMP], rgbaF[i][ACOMP]);
-         }
-      }
-   }
-   else if (chanType == GL_UNSIGNED_SHORT) {
-      GLushort (*rgba)[4] = (GLushort (*)[4]) src;
-      const GLushort (*dest)[4] = (const GLushort (*)[4]) dst;
-      GLuint i;
-      /* convert ushorts to floats */
-      for (i = 0; i < n; i++) {
-         if (mask[i]) {
-            rgbaF[i][RCOMP] = USHORT_TO_FLOAT(rgba[i][RCOMP]);
-            rgbaF[i][GCOMP] = USHORT_TO_FLOAT(rgba[i][GCOMP]);
-            rgbaF[i][BCOMP] = USHORT_TO_FLOAT(rgba[i][BCOMP]);
-            rgbaF[i][ACOMP] = USHORT_TO_FLOAT(rgba[i][ACOMP]);
-            destF[i][RCOMP] = USHORT_TO_FLOAT(dest[i][RCOMP]);
-            destF[i][GCOMP] = USHORT_TO_FLOAT(dest[i][GCOMP]);
-            destF[i][BCOMP] = USHORT_TO_FLOAT(dest[i][BCOMP]);
-            destF[i][ACOMP] = USHORT_TO_FLOAT(dest[i][ACOMP]);
-         }
-      }
-      /* do blend */
-      blend_general_float(ctx, n, mask, rgbaF, destF, chanType);
-      /* convert back to ushorts */
-      for (i = 0; i < n; i++) {
-         if (mask[i]) {
-            UNCLAMPED_FLOAT_TO_USHORT(rgba[i][RCOMP], rgbaF[i][RCOMP]);
-            UNCLAMPED_FLOAT_TO_USHORT(rgba[i][GCOMP], rgbaF[i][GCOMP]);
-            UNCLAMPED_FLOAT_TO_USHORT(rgba[i][BCOMP], rgbaF[i][BCOMP]);
-            UNCLAMPED_FLOAT_TO_USHORT(rgba[i][ACOMP], rgbaF[i][ACOMP]);
-         }
-      }
-   }
-   else {
-      blend_general_float(ctx, n, mask, (GLfloat (*)[4]) src,
-                          (GLfloat (*)[4]) dst, chanType);
-   }
-}
-
-
-
-/**
- * Analyze current blending parameters to pick fastest blending function.
- * Result: the ctx->Color.BlendFunc pointer is updated.
- */
-void
-_swrast_choose_blend_func(GLcontext *ctx, GLenum chanType)
-{
-   SWcontext *swrast = SWRAST_CONTEXT(ctx);
-   const GLenum eq = ctx->Color.BlendEquationRGB;
-   const GLenum srcRGB = ctx->Color.BlendSrcRGB;
-   const GLenum dstRGB = ctx->Color.BlendDstRGB;
-   const GLenum srcA = ctx->Color.BlendSrcA;
-   const GLenum dstA = ctx->Color.BlendDstA;
-
-   if (ctx->Color.BlendEquationRGB != ctx->Color.BlendEquationA) {
-      swrast->BlendFunc = blend_general;
-   }
-   else if (eq == GL_MIN) {
-      /* Note: GL_MIN ignores the blending weight factors */
-#if defined(USE_MMX_ASM)
-      if (cpu_has_mmx && chanType == GL_UNSIGNED_BYTE) {
-         swrast->BlendFunc = _mesa_mmx_blend_min;
-      }
-      else
-#endif
-         swrast->BlendFunc = blend_min;
-   }
-   else if (eq == GL_MAX) {
-      /* Note: GL_MAX ignores the blending weight factors */
-#if defined(USE_MMX_ASM)
-      if (cpu_has_mmx && chanType == GL_UNSIGNED_BYTE) {
-         swrast->BlendFunc = _mesa_mmx_blend_max;
-      }
-      else
-#endif
-         swrast->BlendFunc = blend_max;
-   }
-   else if (srcRGB != srcA || dstRGB != dstA) {
-      swrast->BlendFunc = blend_general;
-   }
-   else if (eq == GL_FUNC_ADD && srcRGB == GL_SRC_ALPHA
-            && dstRGB == GL_ONE_MINUS_SRC_ALPHA) {
-#if defined(USE_MMX_ASM)
-      if (cpu_has_mmx && chanType == GL_UNSIGNED_BYTE) {
-         swrast->BlendFunc = _mesa_mmx_blend_transparency;
-      }
-      else
-#endif
-      {
-         if (chanType == GL_UNSIGNED_BYTE)
-            swrast->BlendFunc = blend_transparency_ubyte;
-         else if (chanType == GL_UNSIGNED_SHORT)
-            swrast->BlendFunc = blend_transparency_ushort;
-         else
-            swrast->BlendFunc = blend_transparency_float;
-      }
-   }
-   else if (eq == GL_FUNC_ADD && srcRGB == GL_ONE && dstRGB == GL_ONE) {
-#if defined(USE_MMX_ASM)
-      if (cpu_has_mmx && chanType == GL_UNSIGNED_BYTE) {
-         swrast->BlendFunc = _mesa_mmx_blend_add;
-      }
-      else
-#endif
-         swrast->BlendFunc = blend_add;
-   }
-   else if (((eq == GL_FUNC_ADD || eq == GL_FUNC_REVERSE_SUBTRACT)
-	     && (srcRGB == GL_ZERO && dstRGB == GL_SRC_COLOR))
-	    ||
-	    ((eq == GL_FUNC_ADD || eq == GL_FUNC_SUBTRACT)
-	     && (srcRGB == GL_DST_COLOR && dstRGB == GL_ZERO))) {
-#if defined(USE_MMX_ASM)
-      if (cpu_has_mmx && chanType == GL_UNSIGNED_BYTE) {
-         swrast->BlendFunc = _mesa_mmx_blend_modulate;
-      }
-      else
-#endif
-         swrast->BlendFunc = blend_modulate;
-   }
-   else if (eq == GL_FUNC_ADD && srcRGB == GL_ZERO && dstRGB == GL_ONE) {
-      swrast->BlendFunc = blend_noop;
-   }
-   else if (eq == GL_FUNC_ADD && srcRGB == GL_ONE && dstRGB == GL_ZERO) {
-      swrast->BlendFunc = blend_replace;
-   }
-   else {
-      swrast->BlendFunc = blend_general;
-   }
-}
-
-
-
-/**
- * Apply the blending operator to a span of pixels.
- * We can handle horizontal runs of pixels (spans) or arrays of x/y
- * pixel coordinates.
- */
-void
-_swrast_blend_span(GLcontext *ctx, struct gl_renderbuffer *rb, SWspan *span)
-{
-   SWcontext *swrast = SWRAST_CONTEXT(ctx);
-   void *rbPixels;
-
-   ASSERT(span->end <= MAX_WIDTH);
-   ASSERT(span->arrayMask & SPAN_RGBA);
-   ASSERT(rb->DataType == span->array->ChanType);
-   ASSERT(!ctx->Color._LogicOpEnabled);
-
-   rbPixels = _swrast_get_dest_rgba(ctx, rb, span);
-
-   swrast->BlendFunc(ctx, span->end, span->array->mask,
-                     span->array->rgba, rbPixels, span->array->ChanType);
-}
+/*

+ * Mesa 3-D graphics library

+ * Version:  7.1

+ *

+ * Copyright (C) 1999-2008  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.

+ */

+

+

+/**

+ * \file swrast/s_blend.c

+ * \brief software blending.

+ * \author Brian Paul

+ *

+ * Only a few blend modes have been optimized (min, max, transparency, add)

+ * more optimized cases can easily be added if needed.

+ * Celestia uses glBlendFunc(GL_SRC_ALPHA, GL_ONE), for example.

+ */

+

+

+

+#include "main/glheader.h"

+#include "main/context.h"

+#include "main/colormac.h"

+#include "main/macros.h"

+

+#include "s_blend.h"

+#include "s_context.h"

+#include "s_span.h"

+

+

+#if defined(USE_MMX_ASM)

+#include "x86/mmx.h"

+#include "x86/common_x86_asm.h"

+#define _BLENDAPI _ASMAPI

+#else

+#define _BLENDAPI

+#endif

+

+

+/**

+ * Integer divide by 255

+ * Declare "int divtemp" before using.

+ * This satisfies Glean and should be reasonably fast.

+ * Contributed by Nathan Hand.

+ */

+#define DIV255(X)  (divtemp = (X), ((divtemp << 8) + divtemp + 256) >> 16)

+

+

+

+/**

+ * Special case for glBlendFunc(GL_ZERO, GL_ONE).

+ * No-op means the framebuffer values remain unchanged.

+ * Any chanType ok.

+ */

+static void _BLENDAPI

+blend_noop(struct gl_context *ctx, GLuint n, const GLubyte mask[],

+           GLvoid *src, const GLvoid *dst, GLenum chanType)

+{

+   GLint bytes;

+

+   ASSERT(ctx->Color.BlendEquationRGB == GL_FUNC_ADD);

+   ASSERT(ctx->Color.BlendEquationA == GL_FUNC_ADD);

+   ASSERT(ctx->Color.BlendSrcRGB == GL_ZERO);

+   ASSERT(ctx->Color.BlendDstRGB == GL_ONE);

+   (void) ctx;

+

+   /* just memcpy */

+   if (chanType == GL_UNSIGNED_BYTE)

+      bytes = 4 * n * sizeof(GLubyte);

+   else if (chanType == GL_UNSIGNED_SHORT)

+      bytes = 4 * n * sizeof(GLushort);

+   else

+      bytes = 4 * n * sizeof(GLfloat);

+

+   memcpy(src, dst, bytes);

+}

+

+

+/**

+ * Special case for glBlendFunc(GL_ONE, GL_ZERO)

+ * Any chanType ok.

+ */

+static void _BLENDAPI

+blend_replace(struct gl_context *ctx, GLuint n, const GLubyte mask[],

+              GLvoid *src, const GLvoid *dst, GLenum chanType)

+{

+   ASSERT(ctx->Color.BlendEquationRGB == GL_FUNC_ADD);

+   ASSERT(ctx->Color.BlendEquationA == GL_FUNC_ADD);

+   ASSERT(ctx->Color.BlendSrcRGB == GL_ONE);

+   ASSERT(ctx->Color.BlendDstRGB == GL_ZERO);

+   (void) ctx;

+   (void) n;

+   (void) mask;

+   (void) src;

+   (void) dst;

+}

+

+

+/**

+ * Common transparency blending mode:

+ * glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA).

+ */

+static void _BLENDAPI

+blend_transparency_ubyte(struct gl_context *ctx, GLuint n, const GLubyte mask[],

+                         GLvoid *src, const GLvoid *dst, GLenum chanType)

+{

+   GLubyte (*rgba)[4] = (GLubyte (*)[4]) src;

+   const GLubyte (*dest)[4] = (const GLubyte (*)[4]) dst;

+   GLuint i;

+

+   ASSERT(ctx->Color.BlendEquationRGB == GL_FUNC_ADD);

+   ASSERT(ctx->Color.BlendEquationA == GL_FUNC_ADD);

+   ASSERT(ctx->Color.BlendSrcRGB == GL_SRC_ALPHA);

+   ASSERT(ctx->Color.BlendSrcA == GL_SRC_ALPHA);

+   ASSERT(ctx->Color.BlendDstRGB == GL_ONE_MINUS_SRC_ALPHA);

+   ASSERT(ctx->Color.BlendDstA == GL_ONE_MINUS_SRC_ALPHA);

+   ASSERT(chanType == GL_UNSIGNED_BYTE);

+

+   (void) ctx;

+

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

+      if (mask[i]) {

+         const GLint t = rgba[i][ACOMP];  /* t is in [0, 255] */

+         if (t == 0) {

+            /* 0% alpha */

+            COPY_4UBV(rgba[i], dest[i]);

+         }

+         else if (t != 255) {

+	    GLint divtemp;

+            const GLint r = DIV255((rgba[i][RCOMP] - dest[i][RCOMP]) * t) + dest[i][RCOMP];

+            const GLint g = DIV255((rgba[i][GCOMP] - dest[i][GCOMP]) * t) + dest[i][GCOMP];

+            const GLint b = DIV255((rgba[i][BCOMP] - dest[i][BCOMP]) * t) + dest[i][BCOMP];

+            const GLint a = DIV255((rgba[i][ACOMP] - dest[i][ACOMP]) * t) + dest[i][ACOMP]; 

+            ASSERT(r <= 255);

+            ASSERT(g <= 255);

+            ASSERT(b <= 255);

+            ASSERT(a <= 255);

+            rgba[i][RCOMP] = (GLubyte) r;

+            rgba[i][GCOMP] = (GLubyte) g;

+            rgba[i][BCOMP] = (GLubyte) b;

+            rgba[i][ACOMP] = (GLubyte) a;

+         }

+      }

+   }

+}

+

+

+static void _BLENDAPI

+blend_transparency_ushort(struct gl_context *ctx, GLuint n, const GLubyte mask[],

+                          GLvoid *src, const GLvoid *dst, GLenum chanType)

+{

+   GLushort (*rgba)[4] = (GLushort (*)[4]) src;

+   const GLushort (*dest)[4] = (const GLushort (*)[4]) dst;

+   GLuint i;

+

+   ASSERT(ctx->Color.BlendEquationRGB == GL_FUNC_ADD);

+   ASSERT(ctx->Color.BlendEquationA == GL_FUNC_ADD);

+   ASSERT(ctx->Color.BlendSrcRGB == GL_SRC_ALPHA);

+   ASSERT(ctx->Color.BlendSrcA == GL_SRC_ALPHA);

+   ASSERT(ctx->Color.BlendDstRGB == GL_ONE_MINUS_SRC_ALPHA);

+   ASSERT(ctx->Color.BlendDstA == GL_ONE_MINUS_SRC_ALPHA);

+   ASSERT(chanType == GL_UNSIGNED_SHORT);

+

+   (void) ctx;

+

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

+      if (mask[i]) {

+         const GLint t = rgba[i][ACOMP];

+         if (t == 0) {

+            /* 0% alpha */

+            COPY_4V(rgba[i], dest[i]);

+         }

+         else if (t != 65535) {

+            const GLfloat tt = (GLfloat) t / 65535.0F;

+            GLushort r = (GLushort) ((rgba[i][RCOMP] - dest[i][RCOMP]) * tt + dest[i][RCOMP]);

+            GLushort g = (GLushort) ((rgba[i][GCOMP] - dest[i][GCOMP]) * tt + dest[i][GCOMP]);

+            GLushort b = (GLushort) ((rgba[i][BCOMP] - dest[i][BCOMP]) * tt + dest[i][BCOMP]);

+            GLushort a = (GLushort) ((rgba[i][ACOMP] - dest[i][ACOMP]) * tt + dest[i][ACOMP]);

+            ASSIGN_4V(rgba[i], r, g, b, a);

+         }

+      }

+   }

+}

+

+

+static void _BLENDAPI

+blend_transparency_float(struct gl_context *ctx, GLuint n, const GLubyte mask[],

+                         GLvoid *src, const GLvoid *dst, GLenum chanType)

+{

+   GLfloat (*rgba)[4] = (GLfloat (*)[4]) src;

+   const GLfloat (*dest)[4] = (const GLfloat (*)[4]) dst;

+   GLuint i;

+

+   ASSERT(ctx->Color.BlendEquationRGB == GL_FUNC_ADD);

+   ASSERT(ctx->Color.BlendEquationA == GL_FUNC_ADD);

+   ASSERT(ctx->Color.BlendSrcRGB == GL_SRC_ALPHA);

+   ASSERT(ctx->Color.BlendSrcA == GL_SRC_ALPHA);

+   ASSERT(ctx->Color.BlendDstRGB == GL_ONE_MINUS_SRC_ALPHA);

+   ASSERT(ctx->Color.BlendDstA == GL_ONE_MINUS_SRC_ALPHA);

+   ASSERT(chanType == GL_FLOAT);

+

+   (void) ctx;

+

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

+      if (mask[i]) {

+         const GLfloat t = rgba[i][ACOMP];  /* t in [0, 1] */

+         if (t == 0.0F) {

+            /* 0% alpha */

+            COPY_4V(rgba[i], dest[i]);

+         }

+         else if (t != 1.0F) {

+            GLfloat r = (rgba[i][RCOMP] - dest[i][RCOMP]) * t + dest[i][RCOMP];

+            GLfloat g = (rgba[i][GCOMP] - dest[i][GCOMP]) * t + dest[i][GCOMP];

+            GLfloat b = (rgba[i][BCOMP] - dest[i][BCOMP]) * t + dest[i][BCOMP];

+            GLfloat a = (rgba[i][ACOMP] - dest[i][ACOMP]) * t + dest[i][ACOMP];

+            ASSIGN_4V(rgba[i], r, g, b, a);

+         }

+      }

+   }

+}

+

+

+

+/**

+ * Add src and dest: glBlendFunc(GL_ONE, GL_ONE).

+ * Any chanType ok.

+ */

+static void _BLENDAPI

+blend_add(struct gl_context *ctx, GLuint n, const GLubyte mask[],

+          GLvoid *src, const GLvoid *dst, GLenum chanType)

+{

+   GLuint i;

+

+   ASSERT(ctx->Color.BlendEquationRGB == GL_FUNC_ADD);

+   ASSERT(ctx->Color.BlendEquationA == GL_FUNC_ADD);

+   ASSERT(ctx->Color.BlendSrcRGB == GL_ONE);

+   ASSERT(ctx->Color.BlendDstRGB == GL_ONE);

+   (void) ctx;

+

+   if (chanType == GL_UNSIGNED_BYTE) {

+      GLubyte (*rgba)[4] = (GLubyte (*)[4]) src;

+      const GLubyte (*dest)[4] = (const GLubyte (*)[4]) dst;

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

+         if (mask[i]) {

+            GLint r = rgba[i][RCOMP] + dest[i][RCOMP];

+            GLint g = rgba[i][GCOMP] + dest[i][GCOMP];

+            GLint b = rgba[i][BCOMP] + dest[i][BCOMP];

+            GLint a = rgba[i][ACOMP] + dest[i][ACOMP];

+            rgba[i][RCOMP] = (GLubyte) MIN2( r, 255 );

+            rgba[i][GCOMP] = (GLubyte) MIN2( g, 255 );

+            rgba[i][BCOMP] = (GLubyte) MIN2( b, 255 );

+            rgba[i][ACOMP] = (GLubyte) MIN2( a, 255 );

+         }

+      }

+   }

+   else if (chanType == GL_UNSIGNED_SHORT) {

+      GLushort (*rgba)[4] = (GLushort (*)[4]) src;

+      const GLushort (*dest)[4] = (const GLushort (*)[4]) dst;

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

+         if (mask[i]) {

+            GLint r = rgba[i][RCOMP] + dest[i][RCOMP];

+            GLint g = rgba[i][GCOMP] + dest[i][GCOMP];

+            GLint b = rgba[i][BCOMP] + dest[i][BCOMP];

+            GLint a = rgba[i][ACOMP] + dest[i][ACOMP];

+            rgba[i][RCOMP] = (GLshort) MIN2( r, 255 );

+            rgba[i][GCOMP] = (GLshort) MIN2( g, 255 );

+            rgba[i][BCOMP] = (GLshort) MIN2( b, 255 );

+            rgba[i][ACOMP] = (GLshort) MIN2( a, 255 );

+         }

+      }

+   }

+   else {

+      GLfloat (*rgba)[4] = (GLfloat (*)[4]) src;

+      const GLfloat (*dest)[4] = (const GLfloat (*)[4]) dst;

+      ASSERT(chanType == GL_FLOAT);

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

+         if (mask[i]) {

+            /* don't RGB clamp to max */

+            rgba[i][RCOMP] += dest[i][RCOMP];

+            rgba[i][GCOMP] += dest[i][GCOMP];

+            rgba[i][BCOMP] += dest[i][BCOMP];

+            rgba[i][ACOMP] += dest[i][ACOMP];

+         }

+      }

+   }

+}

+

+

+

+/**

+ * Blend min function.

+ * Any chanType ok.

+ */

+static void _BLENDAPI

+blend_min(struct gl_context *ctx, GLuint n, const GLubyte mask[],

+          GLvoid *src, const GLvoid *dst, GLenum chanType)

+{

+   GLuint i;

+   ASSERT(ctx->Color.BlendEquationRGB == GL_MIN);

+   ASSERT(ctx->Color.BlendEquationA == GL_MIN);

+   (void) ctx;

+

+   if (chanType == GL_UNSIGNED_BYTE) {

+      GLubyte (*rgba)[4] = (GLubyte (*)[4]) src;

+      const GLubyte (*dest)[4] = (const GLubyte (*)[4]) dst;

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

+         if (mask[i]) {

+            rgba[i][RCOMP] = MIN2( rgba[i][RCOMP], dest[i][RCOMP] );

+            rgba[i][GCOMP] = MIN2( rgba[i][GCOMP], dest[i][GCOMP] );

+            rgba[i][BCOMP] = MIN2( rgba[i][BCOMP], dest[i][BCOMP] );

+            rgba[i][ACOMP] = MIN2( rgba[i][ACOMP], dest[i][ACOMP] );

+         }

+      }

+   }

+   else if (chanType == GL_UNSIGNED_SHORT) {

+      GLushort (*rgba)[4] = (GLushort (*)[4]) src;

+      const GLushort (*dest)[4] = (const GLushort (*)[4]) dst;

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

+         if (mask[i]) {

+            rgba[i][RCOMP] = MIN2( rgba[i][RCOMP], dest[i][RCOMP] );

+            rgba[i][GCOMP] = MIN2( rgba[i][GCOMP], dest[i][GCOMP] );

+            rgba[i][BCOMP] = MIN2( rgba[i][BCOMP], dest[i][BCOMP] );

+            rgba[i][ACOMP] = MIN2( rgba[i][ACOMP], dest[i][ACOMP] );

+         }

+      }

+   }

+   else {

+      GLfloat (*rgba)[4] = (GLfloat (*)[4]) src;

+      const GLfloat (*dest)[4] = (const GLfloat (*)[4]) dst;

+      ASSERT(chanType == GL_FLOAT);

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

+         if (mask[i]) {

+            rgba[i][RCOMP] = MIN2( rgba[i][RCOMP], dest[i][RCOMP] );

+            rgba[i][GCOMP] = MIN2( rgba[i][GCOMP], dest[i][GCOMP] );

+            rgba[i][BCOMP] = MIN2( rgba[i][BCOMP], dest[i][BCOMP] );

+            rgba[i][ACOMP] = MIN2( rgba[i][ACOMP], dest[i][ACOMP] );

+         }

+      }

+   }

+}

+

+

+/**

+ * Blend max function.

+ * Any chanType ok.

+ */

+static void _BLENDAPI

+blend_max(struct gl_context *ctx, GLuint n, const GLubyte mask[],

+          GLvoid *src, const GLvoid *dst, GLenum chanType)

+{

+   GLuint i;

+   ASSERT(ctx->Color.BlendEquationRGB == GL_MAX);

+   ASSERT(ctx->Color.BlendEquationA == GL_MAX);

+   (void) ctx;

+

+   if (chanType == GL_UNSIGNED_BYTE) {

+      GLubyte (*rgba)[4] = (GLubyte (*)[4]) src;

+      const GLubyte (*dest)[4] = (const GLubyte (*)[4]) dst;

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

+         if (mask[i]) {

+            rgba[i][RCOMP] = MAX2( rgba[i][RCOMP], dest[i][RCOMP] );

+            rgba[i][GCOMP] = MAX2( rgba[i][GCOMP], dest[i][GCOMP] );

+            rgba[i][BCOMP] = MAX2( rgba[i][BCOMP], dest[i][BCOMP] );

+            rgba[i][ACOMP] = MAX2( rgba[i][ACOMP], dest[i][ACOMP] );

+         }

+      }

+   }

+   else if (chanType == GL_UNSIGNED_SHORT) {

+      GLushort (*rgba)[4] = (GLushort (*)[4]) src;

+      const GLushort (*dest)[4] = (const GLushort (*)[4]) dst;

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

+         if (mask[i]) {

+            rgba[i][RCOMP] = MAX2( rgba[i][RCOMP], dest[i][RCOMP] );

+            rgba[i][GCOMP] = MAX2( rgba[i][GCOMP], dest[i][GCOMP] );

+            rgba[i][BCOMP] = MAX2( rgba[i][BCOMP], dest[i][BCOMP] );

+            rgba[i][ACOMP] = MAX2( rgba[i][ACOMP], dest[i][ACOMP] );

+         }

+      }

+   }

+   else {

+      GLfloat (*rgba)[4] = (GLfloat (*)[4]) src;

+      const GLfloat (*dest)[4] = (const GLfloat (*)[4]) dst;

+      ASSERT(chanType == GL_FLOAT);

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

+         if (mask[i]) {

+            rgba[i][RCOMP] = MAX2( rgba[i][RCOMP], dest[i][RCOMP] );

+            rgba[i][GCOMP] = MAX2( rgba[i][GCOMP], dest[i][GCOMP] );

+            rgba[i][BCOMP] = MAX2( rgba[i][BCOMP], dest[i][BCOMP] );

+            rgba[i][ACOMP] = MAX2( rgba[i][ACOMP], dest[i][ACOMP] );

+         }

+      }

+   }

+}

+

+

+

+/**

+ * Modulate:  result = src * dest

+ * Any chanType ok.

+ */

+static void _BLENDAPI

+blend_modulate(struct gl_context *ctx, GLuint n, const GLubyte mask[],

+               GLvoid *src, const GLvoid *dst, GLenum chanType)

+{

+   GLuint i;

+   (void) ctx;

+

+   if (chanType == GL_UNSIGNED_BYTE) {

+      GLubyte (*rgba)[4] = (GLubyte (*)[4]) src;

+      const GLubyte (*dest)[4] = (const GLubyte (*)[4]) dst;

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

+         if (mask[i]) {

+	    GLint divtemp;

+            rgba[i][RCOMP] = DIV255(rgba[i][RCOMP] * dest[i][RCOMP]);

+            rgba[i][GCOMP] = DIV255(rgba[i][GCOMP] * dest[i][GCOMP]);

+            rgba[i][BCOMP] = DIV255(rgba[i][BCOMP] * dest[i][BCOMP]);

+            rgba[i][ACOMP] = DIV255(rgba[i][ACOMP] * dest[i][ACOMP]);

+         }

+      }

+   }

+   else if (chanType == GL_UNSIGNED_SHORT) {

+      GLushort (*rgba)[4] = (GLushort (*)[4]) src;

+      const GLushort (*dest)[4] = (const GLushort (*)[4]) dst;

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

+         if (mask[i]) {

+            rgba[i][RCOMP] = (rgba[i][RCOMP] * dest[i][RCOMP] + 65535) >> 16;

+            rgba[i][GCOMP] = (rgba[i][GCOMP] * dest[i][GCOMP] + 65535) >> 16;

+            rgba[i][BCOMP] = (rgba[i][BCOMP] * dest[i][BCOMP] + 65535) >> 16;

+            rgba[i][ACOMP] = (rgba[i][ACOMP] * dest[i][ACOMP] + 65535) >> 16;

+         }

+      }

+   }

+   else {

+      GLfloat (*rgba)[4] = (GLfloat (*)[4]) src;

+      const GLfloat (*dest)[4] = (const GLfloat (*)[4]) dst;

+      ASSERT(chanType == GL_FLOAT);

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

+         if (mask[i]) {

+            rgba[i][RCOMP] = rgba[i][RCOMP] * dest[i][RCOMP];

+            rgba[i][GCOMP] = rgba[i][GCOMP] * dest[i][GCOMP];

+            rgba[i][BCOMP] = rgba[i][BCOMP] * dest[i][BCOMP];

+            rgba[i][ACOMP] = rgba[i][ACOMP] * dest[i][ACOMP];

+         }

+      }

+   }

+}

+

+

+/**

+ * Do any blending operation, using floating point.

+ * \param n  number of pixels

+ * \param mask  fragment writemask array

+ * \param rgba  array of incoming (and modified) pixels

+ * \param dest  array of pixels from the dest color buffer

+ */

+static void

+blend_general_float(struct gl_context *ctx, GLuint n, const GLubyte mask[],

+                    GLfloat rgba[][4], GLfloat dest[][4],

+                    GLenum chanType)

+{

+   GLuint i;

+

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

+      if (mask[i]) {

+         /* Incoming/source Color */

+         const GLfloat Rs = rgba[i][RCOMP];

+         const GLfloat Gs = rgba[i][GCOMP];

+         const GLfloat Bs = rgba[i][BCOMP];

+         const GLfloat As = rgba[i][ACOMP];

+

+         /* Frame buffer/dest color */

+         const GLfloat Rd = dest[i][RCOMP];

+         const GLfloat Gd = dest[i][GCOMP];

+         const GLfloat Bd = dest[i][BCOMP];

+         const GLfloat Ad = dest[i][ACOMP];

+

+         GLfloat sR, sG, sB, sA;  /* Source factor */

+         GLfloat dR, dG, dB, dA;  /* Dest factor */

+         GLfloat r, g, b, a;      /* result color */

+

+         /* XXX for the case of constant blend terms we could init

+          * the sX and dX variables just once before the loop.

+          */

+

+         /* Source RGB factor */

+         switch (ctx->Color.BlendSrcRGB) {

+            case GL_ZERO:

+               sR = sG = sB = 0.0F;

+               break;

+            case GL_ONE:

+               sR = sG = sB = 1.0F;

+               break;

+            case GL_DST_COLOR:

+               sR = Rd;

+               sG = Gd;

+               sB = Bd;

+               break;

+            case GL_ONE_MINUS_DST_COLOR:

+               sR = 1.0F - Rd;

+               sG = 1.0F - Gd;

+               sB = 1.0F - Bd;

+               break;

+            case GL_SRC_ALPHA:

+               sR = sG = sB = As;

+               break;

+            case GL_ONE_MINUS_SRC_ALPHA:

+               sR = sG = sB = 1.0F - As;

+               break;

+            case GL_DST_ALPHA:

+               sR = sG = sB = Ad;

+               break;

+            case GL_ONE_MINUS_DST_ALPHA:

+               sR = sG = sB = 1.0F - Ad;

+               break;

+            case GL_SRC_ALPHA_SATURATE:

+               if (As < 1.0F - Ad) {

+                  sR = sG = sB = As;

+               }

+               else {

+                  sR = sG = sB = 1.0F - Ad;

+               }

+               break;

+            case GL_CONSTANT_COLOR:

+               sR = ctx->Color.BlendColor[0];

+               sG = ctx->Color.BlendColor[1];

+               sB = ctx->Color.BlendColor[2];

+               break;

+            case GL_ONE_MINUS_CONSTANT_COLOR:

+               sR = 1.0F - ctx->Color.BlendColor[0];

+               sG = 1.0F - ctx->Color.BlendColor[1];

+               sB = 1.0F - ctx->Color.BlendColor[2];

+               break;

+            case GL_CONSTANT_ALPHA:

+               sR = sG = sB = ctx->Color.BlendColor[3];

+               break;

+            case GL_ONE_MINUS_CONSTANT_ALPHA:

+               sR = sG = sB = 1.0F - ctx->Color.BlendColor[3];

+               break;

+            case GL_SRC_COLOR:

+               sR = Rs;

+               sG = Gs;

+               sB = Bs;

+               break;

+            case GL_ONE_MINUS_SRC_COLOR:

+               sR = 1.0F - Rs;

+               sG = 1.0F - Gs;

+               sB = 1.0F - Bs;

+               break;

+            default:

+               /* this should never happen */

+               _mesa_problem(ctx, "Bad blend source RGB factor in blend_general_float");

+               return;

+         }

+

+         /* Source Alpha factor */

+         switch (ctx->Color.BlendSrcA) {

+            case GL_ZERO:

+               sA = 0.0F;

+               break;

+            case GL_ONE:

+               sA = 1.0F;

+               break;

+            case GL_DST_COLOR:

+               sA = Ad;

+               break;

+            case GL_ONE_MINUS_DST_COLOR:

+               sA = 1.0F - Ad;

+               break;

+            case GL_SRC_ALPHA:

+               sA = As;

+               break;

+            case GL_ONE_MINUS_SRC_ALPHA:

+               sA = 1.0F - As;

+               break;

+            case GL_DST_ALPHA:

+               sA = Ad;

+               break;

+            case GL_ONE_MINUS_DST_ALPHA:

+               sA = 1.0F - Ad;

+               break;

+            case GL_SRC_ALPHA_SATURATE:

+               sA = 1.0;

+               break;

+            case GL_CONSTANT_COLOR:

+               sA = ctx->Color.BlendColor[3];

+               break;

+            case GL_ONE_MINUS_CONSTANT_COLOR:

+               sA = 1.0F - ctx->Color.BlendColor[3];

+               break;

+            case GL_CONSTANT_ALPHA:

+               sA = ctx->Color.BlendColor[3];

+               break;

+            case GL_ONE_MINUS_CONSTANT_ALPHA:

+               sA = 1.0F - ctx->Color.BlendColor[3];

+               break;

+            case GL_SRC_COLOR:

+               sA = As;

+               break;

+            case GL_ONE_MINUS_SRC_COLOR:

+               sA = 1.0F - As;

+               break;

+            default:

+               /* this should never happen */

+               sA = 0.0F;

+               _mesa_problem(ctx, "Bad blend source A factor in blend_general_float");

+               return;

+         }

+

+         /* Dest RGB factor */

+         switch (ctx->Color.BlendDstRGB) {

+            case GL_ZERO:

+               dR = dG = dB = 0.0F;

+               break;

+            case GL_ONE:

+               dR = dG = dB = 1.0F;

+               break;

+            case GL_SRC_COLOR:

+               dR = Rs;

+               dG = Gs;

+               dB = Bs;

+               break;

+            case GL_ONE_MINUS_SRC_COLOR:

+               dR = 1.0F - Rs;

+               dG = 1.0F - Gs;

+               dB = 1.0F - Bs;

+               break;

+            case GL_SRC_ALPHA:

+               dR = dG = dB = As;

+               break;

+            case GL_ONE_MINUS_SRC_ALPHA:

+               dR = dG = dB = 1.0F - As;

+               break;

+            case GL_DST_ALPHA:

+               dR = dG = dB = Ad;

+               break;

+            case GL_ONE_MINUS_DST_ALPHA:

+               dR = dG = dB = 1.0F - Ad;

+               break;

+            case GL_CONSTANT_COLOR:

+               dR = ctx->Color.BlendColor[0];

+               dG = ctx->Color.BlendColor[1];

+               dB = ctx->Color.BlendColor[2];

+               break;

+            case GL_ONE_MINUS_CONSTANT_COLOR:

+               dR = 1.0F - ctx->Color.BlendColor[0];

+               dG = 1.0F - ctx->Color.BlendColor[1];

+               dB = 1.0F - ctx->Color.BlendColor[2];

+               break;

+            case GL_CONSTANT_ALPHA:

+               dR = dG = dB = ctx->Color.BlendColor[3];

+               break;

+            case GL_ONE_MINUS_CONSTANT_ALPHA:

+               dR = dG = dB = 1.0F - ctx->Color.BlendColor[3];

+               break;

+            case GL_DST_COLOR:

+               dR = Rd;

+               dG = Gd;

+               dB = Bd;

+               break;

+            case GL_ONE_MINUS_DST_COLOR:

+               dR = 1.0F - Rd;

+               dG = 1.0F - Gd;

+               dB = 1.0F - Bd;

+               break;

+            default:

+               /* this should never happen */

+               dR = dG = dB = 0.0F;

+               _mesa_problem(ctx, "Bad blend dest RGB factor in blend_general_float");

+               return;

+         }

+

+         /* Dest Alpha factor */

+         switch (ctx->Color.BlendDstA) {

+            case GL_ZERO:

+               dA = 0.0F;

+               break;

+            case GL_ONE:

+               dA = 1.0F;

+               break;

+            case GL_SRC_COLOR:

+               dA = As;

+               break;

+            case GL_ONE_MINUS_SRC_COLOR:

+               dA = 1.0F - As;

+               break;

+            case GL_SRC_ALPHA:

+               dA = As;

+               break;

+            case GL_ONE_MINUS_SRC_ALPHA:

+               dA = 1.0F - As;

+               break;

+            case GL_DST_ALPHA:

+               dA = Ad;

+               break;

+            case GL_ONE_MINUS_DST_ALPHA:

+               dA = 1.0F - Ad;

+               break;

+            case GL_CONSTANT_COLOR:

+               dA = ctx->Color.BlendColor[3];

+               break;

+            case GL_ONE_MINUS_CONSTANT_COLOR:

+               dA = 1.0F - ctx->Color.BlendColor[3];

+               break;

+            case GL_CONSTANT_ALPHA:

+               dA = ctx->Color.BlendColor[3];

+               break;

+            case GL_ONE_MINUS_CONSTANT_ALPHA:

+               dA = 1.0F - ctx->Color.BlendColor[3];

+               break;

+            case GL_DST_COLOR:

+               dA = Ad;

+               break;

+            case GL_ONE_MINUS_DST_COLOR:

+               dA = 1.0F - Ad;

+               break;

+            default:

+               /* this should never happen */

+               dA = 0.0F;

+               _mesa_problem(ctx, "Bad blend dest A factor in blend_general_float");

+               return;

+         }

+

+         /* compute the blended RGB */

+         switch (ctx->Color.BlendEquationRGB) {

+         case GL_FUNC_ADD:

+            r = Rs * sR + Rd * dR;

+            g = Gs * sG + Gd * dG;

+            b = Bs * sB + Bd * dB;

+            a = As * sA + Ad * dA;

+            break;

+         case GL_FUNC_SUBTRACT:

+            r = Rs * sR - Rd * dR;

+            g = Gs * sG - Gd * dG;

+            b = Bs * sB - Bd * dB;

+            a = As * sA - Ad * dA;

+            break;

+         case GL_FUNC_REVERSE_SUBTRACT:

+            r = Rd * dR - Rs * sR;

+            g = Gd * dG - Gs * sG;

+            b = Bd * dB - Bs * sB;

+            a = Ad * dA - As * sA;

+            break;

+         case GL_MIN:

+	    r = MIN2( Rd, Rs );

+	    g = MIN2( Gd, Gs );

+	    b = MIN2( Bd, Bs );

+            break;

+         case GL_MAX:

+	    r = MAX2( Rd, Rs );

+	    g = MAX2( Gd, Gs );

+	    b = MAX2( Bd, Bs );

+            break;

+	 default:

+            /* should never get here */

+            r = g = b = 0.0F;  /* silence uninitialized var warning */

+            _mesa_problem(ctx, "unexpected BlendEquation in blend_general()");

+            return;

+         }

+

+         /* compute the blended alpha */

+         switch (ctx->Color.BlendEquationA) {

+         case GL_FUNC_ADD:

+            a = As * sA + Ad * dA;

+            break;

+         case GL_FUNC_SUBTRACT:

+            a = As * sA - Ad * dA;

+            break;

+         case GL_FUNC_REVERSE_SUBTRACT:

+            a = Ad * dA - As * sA;

+            break;

+         case GL_MIN:

+	    a = MIN2( Ad, As );

+            break;

+         case GL_MAX:

+	    a = MAX2( Ad, As );

+            break;

+         default:

+            /* should never get here */

+            a = 0.0F;  /* silence uninitialized var warning */

+            _mesa_problem(ctx, "unexpected BlendEquation in blend_general()");

+            return;

+         }

+

+         /* final clamping */

+#if 0

+         rgba[i][RCOMP] = MAX2( r, 0.0F );

+         rgba[i][GCOMP] = MAX2( g, 0.0F );

+         rgba[i][BCOMP] = MAX2( b, 0.0F );

+         rgba[i][ACOMP] = CLAMP( a, 0.0F, 1.0F );

+#else

+         ASSIGN_4V(rgba[i], r, g, b, a);

+#endif

+      }

+   }

+}

+

+

+/**

+ * Do any blending operation, any chanType.

+ */

+static void

+blend_general(struct gl_context *ctx, GLuint n, const GLubyte mask[],

+              void *src, const void *dst, GLenum chanType)

+{

+   GLfloat (*rgbaF)[4], (*destF)[4];

+

+   rgbaF = (GLfloat (*)[4]) malloc(4 * n * sizeof(GLfloat));

+   destF = (GLfloat (*)[4]) malloc(4 * n * sizeof(GLfloat));

+   if (!rgbaF || !destF) {

+      free(rgbaF);

+      free(destF);

+      _mesa_error(ctx, GL_OUT_OF_MEMORY, "blending");

+      return;

+   }

+

+   if (chanType == GL_UNSIGNED_BYTE) {

+      GLubyte (*rgba)[4] = (GLubyte (*)[4]) src;

+      const GLubyte (*dest)[4] = (const GLubyte (*)[4]) dst;

+      GLuint i;

+      /* convert ubytes to floats */

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

+         if (mask[i]) {

+            rgbaF[i][RCOMP] = UBYTE_TO_FLOAT(rgba[i][RCOMP]);

+            rgbaF[i][GCOMP] = UBYTE_TO_FLOAT(rgba[i][GCOMP]);

+            rgbaF[i][BCOMP] = UBYTE_TO_FLOAT(rgba[i][BCOMP]);

+            rgbaF[i][ACOMP] = UBYTE_TO_FLOAT(rgba[i][ACOMP]);

+            destF[i][RCOMP] = UBYTE_TO_FLOAT(dest[i][RCOMP]);

+            destF[i][GCOMP] = UBYTE_TO_FLOAT(dest[i][GCOMP]);

+            destF[i][BCOMP] = UBYTE_TO_FLOAT(dest[i][BCOMP]);

+            destF[i][ACOMP] = UBYTE_TO_FLOAT(dest[i][ACOMP]);

+         }

+      }

+      /* do blend */

+      blend_general_float(ctx, n, mask, rgbaF, destF, chanType);

+      /* convert back to ubytes */

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

+         if (mask[i]) {

+            UNCLAMPED_FLOAT_TO_UBYTE(rgba[i][RCOMP], rgbaF[i][RCOMP]);

+            UNCLAMPED_FLOAT_TO_UBYTE(rgba[i][GCOMP], rgbaF[i][GCOMP]);

+            UNCLAMPED_FLOAT_TO_UBYTE(rgba[i][BCOMP], rgbaF[i][BCOMP]);

+            UNCLAMPED_FLOAT_TO_UBYTE(rgba[i][ACOMP], rgbaF[i][ACOMP]);

+         }

+      }

+   }

+   else if (chanType == GL_UNSIGNED_SHORT) {

+      GLushort (*rgba)[4] = (GLushort (*)[4]) src;

+      const GLushort (*dest)[4] = (const GLushort (*)[4]) dst;

+      GLuint i;

+      /* convert ushorts to floats */

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

+         if (mask[i]) {

+            rgbaF[i][RCOMP] = USHORT_TO_FLOAT(rgba[i][RCOMP]);

+            rgbaF[i][GCOMP] = USHORT_TO_FLOAT(rgba[i][GCOMP]);

+            rgbaF[i][BCOMP] = USHORT_TO_FLOAT(rgba[i][BCOMP]);

+            rgbaF[i][ACOMP] = USHORT_TO_FLOAT(rgba[i][ACOMP]);

+            destF[i][RCOMP] = USHORT_TO_FLOAT(dest[i][RCOMP]);

+            destF[i][GCOMP] = USHORT_TO_FLOAT(dest[i][GCOMP]);

+            destF[i][BCOMP] = USHORT_TO_FLOAT(dest[i][BCOMP]);

+            destF[i][ACOMP] = USHORT_TO_FLOAT(dest[i][ACOMP]);

+         }

+      }

+      /* do blend */

+      blend_general_float(ctx, n, mask, rgbaF, destF, chanType);

+      /* convert back to ushorts */

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

+         if (mask[i]) {

+            UNCLAMPED_FLOAT_TO_USHORT(rgba[i][RCOMP], rgbaF[i][RCOMP]);

+            UNCLAMPED_FLOAT_TO_USHORT(rgba[i][GCOMP], rgbaF[i][GCOMP]);

+            UNCLAMPED_FLOAT_TO_USHORT(rgba[i][BCOMP], rgbaF[i][BCOMP]);

+            UNCLAMPED_FLOAT_TO_USHORT(rgba[i][ACOMP], rgbaF[i][ACOMP]);

+         }

+      }

+   }

+   else {

+      blend_general_float(ctx, n, mask, (GLfloat (*)[4]) src,

+                          (GLfloat (*)[4]) dst, chanType);

+   }

+

+   free(rgbaF);

+   free(destF);

+}

+

+

+

+/**

+ * Analyze current blending parameters to pick fastest blending function.

+ * Result: the ctx->Color.BlendFunc pointer is updated.

+ */

+void

+_swrast_choose_blend_func(struct gl_context *ctx, GLenum chanType)

+{

+   SWcontext *swrast = SWRAST_CONTEXT(ctx);

+   const GLenum eq = ctx->Color.BlendEquationRGB;

+   const GLenum srcRGB = ctx->Color.BlendSrcRGB;

+   const GLenum dstRGB = ctx->Color.BlendDstRGB;

+   const GLenum srcA = ctx->Color.BlendSrcA;

+   const GLenum dstA = ctx->Color.BlendDstA;

+

+   if (ctx->Color.BlendEquationRGB != ctx->Color.BlendEquationA) {

+      swrast->BlendFunc = blend_general;

+   }

+   else if (eq == GL_MIN) {

+      /* Note: GL_MIN ignores the blending weight factors */

+#if defined(USE_MMX_ASM)

+      if (cpu_has_mmx && chanType == GL_UNSIGNED_BYTE) {

+         swrast->BlendFunc = _mesa_mmx_blend_min;

+      }

+      else

+#endif

+         swrast->BlendFunc = blend_min;

+   }

+   else if (eq == GL_MAX) {

+      /* Note: GL_MAX ignores the blending weight factors */

+#if defined(USE_MMX_ASM)

+      if (cpu_has_mmx && chanType == GL_UNSIGNED_BYTE) {

+         swrast->BlendFunc = _mesa_mmx_blend_max;

+      }

+      else

+#endif

+         swrast->BlendFunc = blend_max;

+   }

+   else if (srcRGB != srcA || dstRGB != dstA) {

+      swrast->BlendFunc = blend_general;

+   }

+   else if (eq == GL_FUNC_ADD && srcRGB == GL_SRC_ALPHA

+            && dstRGB == GL_ONE_MINUS_SRC_ALPHA) {

+#if defined(USE_MMX_ASM)

+      if (cpu_has_mmx && chanType == GL_UNSIGNED_BYTE) {

+         swrast->BlendFunc = _mesa_mmx_blend_transparency;

+      }

+      else

+#endif

+      {

+         if (chanType == GL_UNSIGNED_BYTE)

+            swrast->BlendFunc = blend_transparency_ubyte;

+         else if (chanType == GL_UNSIGNED_SHORT)

+            swrast->BlendFunc = blend_transparency_ushort;

+         else

+            swrast->BlendFunc = blend_transparency_float;

+      }

+   }

+   else if (eq == GL_FUNC_ADD && srcRGB == GL_ONE && dstRGB == GL_ONE) {

+#if defined(USE_MMX_ASM)

+      if (cpu_has_mmx && chanType == GL_UNSIGNED_BYTE) {

+         swrast->BlendFunc = _mesa_mmx_blend_add;

+      }

+      else

+#endif

+         swrast->BlendFunc = blend_add;

+   }

+   else if (((eq == GL_FUNC_ADD || eq == GL_FUNC_REVERSE_SUBTRACT)

+	     && (srcRGB == GL_ZERO && dstRGB == GL_SRC_COLOR))

+	    ||

+	    ((eq == GL_FUNC_ADD || eq == GL_FUNC_SUBTRACT)

+	     && (srcRGB == GL_DST_COLOR && dstRGB == GL_ZERO))) {

+#if defined(USE_MMX_ASM)

+      if (cpu_has_mmx && chanType == GL_UNSIGNED_BYTE) {

+         swrast->BlendFunc = _mesa_mmx_blend_modulate;

+      }

+      else

+#endif

+         swrast->BlendFunc = blend_modulate;

+   }

+   else if (eq == GL_FUNC_ADD && srcRGB == GL_ZERO && dstRGB == GL_ONE) {

+      swrast->BlendFunc = blend_noop;

+   }

+   else if (eq == GL_FUNC_ADD && srcRGB == GL_ONE && dstRGB == GL_ZERO) {

+      swrast->BlendFunc = blend_replace;

+   }

+   else {

+      swrast->BlendFunc = blend_general;

+   }

+}

+

+

+

+/**

+ * Apply the blending operator to a span of pixels.

+ * We can handle horizontal runs of pixels (spans) or arrays of x/y

+ * pixel coordinates.

+ */

+void

+_swrast_blend_span(struct gl_context *ctx, struct gl_renderbuffer *rb, SWspan *span)

+{

+   SWcontext *swrast = SWRAST_CONTEXT(ctx);

+   void *rbPixels;

+

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

+   ASSERT(span->arrayMask & SPAN_RGBA);

+   ASSERT(rb->DataType == span->array->ChanType);

+   ASSERT(!ctx->Color._LogicOpEnabled);

+

+   rbPixels = _swrast_get_dest_rgba(ctx, rb, span);

+

+   swrast->BlendFunc(ctx, span->end, span->array->mask,

+                     span->array->rgba, rbPixels, span->array->ChanType);

+}

diff --git a/mesalib/src/mesa/swrast/s_blend.h b/mesalib/src/mesa/swrast/s_blend.h
index 9cedde3bf..8ecff52cf 100644
--- a/mesalib/src/mesa/swrast/s_blend.h
+++ b/mesalib/src/mesa/swrast/s_blend.h
@@ -1,42 +1,45 @@
-/*
- * Mesa 3-D graphics library
- * Version:  6.5.2
- *
- * Copyright (C) 1999-2006  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.
- */
-
-
-#ifndef S_BLEND_H
-#define S_BLEND_H
-
-
-#include "main/mtypes.h"
-#include "s_span.h"
-
-
-extern void
-_swrast_blend_span(GLcontext *ctx, struct gl_renderbuffer *rb, SWspan *span);
-
-
-extern void
-_swrast_choose_blend_func(GLcontext *ctx, GLenum chanType);
-
-
-#endif
+/*

+ * Mesa 3-D graphics library

+ * Version:  6.5.2

+ *

+ * Copyright (C) 1999-2006  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.

+ */

+

+

+#ifndef S_BLEND_H

+#define S_BLEND_H

+

+

+#include "main/glheader.h"

+#include "s_span.h"

+

+struct gl_context;

+struct gl_renderbuffer;

+

+

+extern void

+_swrast_blend_span(struct gl_context *ctx, struct gl_renderbuffer *rb, SWspan *span);

+

+

+extern void

+_swrast_choose_blend_func(struct gl_context *ctx, GLenum chanType);

+

+

+#endif

diff --git a/mesalib/src/mesa/swrast/s_blit.c b/mesalib/src/mesa/swrast/s_blit.c
index 753f3136f..2dd11399f 100644
--- a/mesalib/src/mesa/swrast/s_blit.c
+++ b/mesalib/src/mesa/swrast/s_blit.c
@@ -1,619 +1,619 @@
-/*
- * Mesa 3-D graphics library
- * Version:  6.5
- *
- * Copyright (C) 1999-2006  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/condrender.h"
-#include "main/image.h"
-#include "main/macros.h"
-#include "s_context.h"
-
-
-#define ABS(X)   ((X) < 0 ? -(X) : (X))
-
-
-/**
- * Generate a row resampler function for GL_NEAREST mode.
- */
-#define RESAMPLE(NAME, PIXELTYPE, SIZE)			\
-static void						\
-NAME(GLint srcWidth, GLint dstWidth,			\
-     const GLvoid *srcBuffer, GLvoid *dstBuffer,	\
-     GLboolean flip)					\
-{							\
-   const PIXELTYPE *src = (const PIXELTYPE *) srcBuffer;\
-   PIXELTYPE *dst = (PIXELTYPE *) dstBuffer;		\
-   GLint dstCol;					\
-							\
-   if (flip) {						\
-      for (dstCol = 0; dstCol < dstWidth; dstCol++) {	\
-         GLint srcCol = (dstCol * srcWidth) / dstWidth;	\
-         ASSERT(srcCol >= 0);				\
-         ASSERT(srcCol < srcWidth);			\
-         srcCol = srcWidth - 1 - srcCol; /* flip */	\
-         if (SIZE == 1) {				\
-            dst[dstCol] = src[srcCol];			\
-         }						\
-         else if (SIZE == 2) {				\
-            dst[dstCol*2+0] = src[srcCol*2+0];		\
-            dst[dstCol*2+1] = src[srcCol*2+1];		\
-         }						\
-         else if (SIZE == 4) {				\
-            dst[dstCol*4+0] = src[srcCol*4+0];		\
-            dst[dstCol*4+1] = src[srcCol*4+1];		\
-            dst[dstCol*4+2] = src[srcCol*4+2];		\
-            dst[dstCol*4+3] = src[srcCol*4+3];		\
-         }						\
-      }							\
-   }							\
-   else {						\
-      for (dstCol = 0; dstCol < dstWidth; dstCol++) {	\
-         GLint srcCol = (dstCol * srcWidth) / dstWidth;	\
-         ASSERT(srcCol >= 0);				\
-         ASSERT(srcCol < srcWidth);			\
-         if (SIZE == 1) {				\
-            dst[dstCol] = src[srcCol];			\
-         }						\
-         else if (SIZE == 2) {				\
-            dst[dstCol*2+0] = src[srcCol*2+0];		\
-            dst[dstCol*2+1] = src[srcCol*2+1];		\
-         }						\
-         else if (SIZE == 4) {				\
-            dst[dstCol*4+0] = src[srcCol*4+0];		\
-            dst[dstCol*4+1] = src[srcCol*4+1];		\
-            dst[dstCol*4+2] = src[srcCol*4+2];		\
-            dst[dstCol*4+3] = src[srcCol*4+3];		\
-         }						\
-      }							\
-   }							\
-}
-
-/**
- * Resamplers for 1, 2, 4, 8 and 16-byte pixels.
- */
-RESAMPLE(resample_row_1, GLubyte, 1)
-RESAMPLE(resample_row_2, GLushort, 1)
-RESAMPLE(resample_row_4, GLuint, 1)
-RESAMPLE(resample_row_8, GLuint, 2)
-RESAMPLE(resample_row_16, GLuint, 4)
-
-
-/**
- * Blit color, depth or stencil with GL_NEAREST filtering.
- */
-static void
-blit_nearest(GLcontext *ctx,
-             GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1,
-             GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1,
-             GLbitfield buffer)
-{
-   struct gl_renderbuffer *readRb, *drawRb;
-
-   const GLint srcWidth = ABS(srcX1 - srcX0);
-   const GLint dstWidth = ABS(dstX1 - dstX0);
-   const GLint srcHeight = ABS(srcY1 - srcY0);
-   const GLint dstHeight = ABS(dstY1 - dstY0);
-
-   const GLint srcXpos = MIN2(srcX0, srcX1);
-   const GLint srcYpos = MIN2(srcY0, srcY1);
-   const GLint dstXpos = MIN2(dstX0, dstX1);
-   const GLint dstYpos = MIN2(dstY0, dstY1);
-
-   const GLboolean invertX = (srcX1 < srcX0) ^ (dstX1 < dstX0);
-   const GLboolean invertY = (srcY1 < srcY0) ^ (dstY1 < dstY0);
-
-   GLint dstRow;
-
-   GLint comps, pixelSize;
-   GLvoid *srcBuffer, *dstBuffer;
-   GLint prevY = -1;
-
-   typedef void (*resample_func)(GLint srcWidth, GLint dstWidth,
-                                 const GLvoid *srcBuffer, GLvoid *dstBuffer,
-                                 GLboolean flip);
-   resample_func resampleRow;
-
-   switch (buffer) {
-   case GL_COLOR_BUFFER_BIT:
-      readRb = ctx->ReadBuffer->_ColorReadBuffer;
-      drawRb = ctx->DrawBuffer->_ColorDrawBuffers[0];
-      comps = 4;
-      break;
-   case GL_DEPTH_BUFFER_BIT:
-      readRb = ctx->ReadBuffer->_DepthBuffer;
-      drawRb = ctx->DrawBuffer->_DepthBuffer;
-      comps = 1;
-      break;
-   case GL_STENCIL_BUFFER_BIT:
-      readRb = ctx->ReadBuffer->_StencilBuffer;
-      drawRb = ctx->DrawBuffer->_StencilBuffer;
-      comps = 1;
-      break;
-   default:
-      _mesa_problem(ctx, "unexpected buffer in blit_nearest()");
-      return;
-   }
-
-   switch (readRb->DataType) {
-   case GL_UNSIGNED_BYTE:
-      pixelSize = comps * sizeof(GLubyte);
-      break;
-   case GL_UNSIGNED_SHORT:
-      pixelSize = comps * sizeof(GLushort);
-      break;
-   case GL_UNSIGNED_INT:
-      pixelSize = comps * sizeof(GLuint);
-      break;
-   case GL_FLOAT:
-      pixelSize = comps * sizeof(GLfloat);
-      break;
-   default:
-      _mesa_problem(ctx, "unexpected buffer type (0x%x) in blit_nearest",
-                    readRb->DataType);
-      return;
-   }
-
-   /* choose row resampler */
-   switch (pixelSize) {
-   case 1:
-      resampleRow = resample_row_1;
-      break;
-   case 2:
-      resampleRow = resample_row_2;
-      break;
-   case 4:
-      resampleRow = resample_row_4;
-      break;
-   case 8:
-      resampleRow = resample_row_8;
-      break;
-   case 16:
-      resampleRow = resample_row_16;
-      break;
-   default:
-      _mesa_problem(ctx, "unexpected pixel size (%d) in blit_nearest",
-                    pixelSize);
-      return;
-   }
-
-   /* allocate the src/dst row buffers */
-   srcBuffer = malloc(pixelSize * srcWidth);
-   if (!srcBuffer) {
-      _mesa_error(ctx, GL_OUT_OF_MEMORY, "glBlitFrameBufferEXT");
-      return;
-   }
-   dstBuffer = malloc(pixelSize * dstWidth);
-   if (!dstBuffer) {
-      free(srcBuffer);
-      _mesa_error(ctx, GL_OUT_OF_MEMORY, "glBlitFrameBufferEXT");
-      return;
-   }
-
-   for (dstRow = 0; dstRow < dstHeight; dstRow++) {
-      const GLint dstY = dstYpos + dstRow;
-      GLint srcRow = (dstRow * srcHeight) / dstHeight;
-      GLint srcY;
-
-      ASSERT(srcRow >= 0);
-      ASSERT(srcRow < srcHeight);
-
-      if (invertY) {
-         srcRow = srcHeight - 1 - srcRow;
-      }
-
-      srcY = srcYpos + srcRow;
-
-      /* get pixel row from source and resample to match dest width */
-      if (prevY != srcY) {
-         readRb->GetRow(ctx, readRb, srcWidth, srcXpos, srcY, srcBuffer);
-         (*resampleRow)(srcWidth, dstWidth, srcBuffer, dstBuffer, invertX);
-         prevY = srcY;
-      }
-
-      /* store pixel row in destination */
-      drawRb->PutRow(ctx, drawRb, dstWidth, dstXpos, dstY, dstBuffer, NULL);
-   }
-
-   free(srcBuffer);
-   free(dstBuffer);
-}
-
-
-
-#define LERP(T, A, B)  ( (A) + (T) * ((B) - (A)) )
-
-static INLINE GLfloat
-lerp_2d(GLfloat a, GLfloat b,
-        GLfloat v00, GLfloat v10, GLfloat v01, GLfloat v11)
-{
-   const GLfloat temp0 = LERP(a, v00, v10);
-   const GLfloat temp1 = LERP(a, v01, v11);
-   return LERP(b, temp0, temp1);
-}
-
-
-/**
- * Bilinear interpolation of two source rows.
- * GLubyte pixels.
- */
-static void
-resample_linear_row_ub(GLint srcWidth, GLint dstWidth,
-                       const GLvoid *srcBuffer0, const GLvoid *srcBuffer1,
-                       GLvoid *dstBuffer, GLboolean flip, GLfloat rowWeight)
-{
-   const GLubyte (*srcColor0)[4] = (const GLubyte (*)[4]) srcBuffer0;
-   const GLubyte (*srcColor1)[4] = (const GLubyte (*)[4]) srcBuffer1;
-   GLubyte (*dstColor)[4] = (GLubyte (*)[4]) dstBuffer;
-   const GLfloat dstWidthF = (GLfloat) dstWidth;
-   GLint dstCol;
-
-   for (dstCol = 0; dstCol < dstWidth; dstCol++) {
-      const GLfloat srcCol = (dstCol * srcWidth) / dstWidthF;
-      GLint srcCol0 = IFLOOR(srcCol);
-      GLint srcCol1 = srcCol0 + 1;
-      GLfloat colWeight = srcCol - srcCol0; /* fractional part of srcCol */
-      GLfloat red, green, blue, alpha;
-
-      ASSERT(srcCol0 >= 0);
-      ASSERT(srcCol0 < srcWidth);
-      ASSERT(srcCol1 <= srcWidth);
-
-      if (srcCol1 == srcWidth) {
-         /* last column fudge */
-         srcCol1--;
-         colWeight = 0.0;
-      }
-
-      if (flip) {
-         srcCol0 = srcWidth - 1 - srcCol0;
-         srcCol1 = srcWidth - 1 - srcCol1;
-      }
-
-      red = lerp_2d(colWeight, rowWeight,
-                    srcColor0[srcCol0][RCOMP], srcColor0[srcCol1][RCOMP],
-                    srcColor1[srcCol0][RCOMP], srcColor1[srcCol1][RCOMP]);
-      green = lerp_2d(colWeight, rowWeight,
-                    srcColor0[srcCol0][GCOMP], srcColor0[srcCol1][GCOMP],
-                    srcColor1[srcCol0][GCOMP], srcColor1[srcCol1][GCOMP]);
-      blue = lerp_2d(colWeight, rowWeight,
-                    srcColor0[srcCol0][BCOMP], srcColor0[srcCol1][BCOMP],
-                    srcColor1[srcCol0][BCOMP], srcColor1[srcCol1][BCOMP]);
-      alpha = lerp_2d(colWeight, rowWeight,
-                    srcColor0[srcCol0][ACOMP], srcColor0[srcCol1][ACOMP],
-                    srcColor1[srcCol0][ACOMP], srcColor1[srcCol1][ACOMP]);
-      
-      dstColor[dstCol][RCOMP] = IFLOOR(red);
-      dstColor[dstCol][GCOMP] = IFLOOR(green);
-      dstColor[dstCol][BCOMP] = IFLOOR(blue);
-      dstColor[dstCol][ACOMP] = IFLOOR(alpha);
-   }
-}
-
-
-
-/**
- * Bilinear filtered blit (color only).
- */
-static void
-blit_linear(GLcontext *ctx,
-            GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1,
-            GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1)
-{
-   struct gl_renderbuffer *readRb = ctx->ReadBuffer->_ColorReadBuffer;
-   struct gl_renderbuffer *drawRb = ctx->DrawBuffer->_ColorDrawBuffers[0];
-
-   const GLint srcWidth = ABS(srcX1 - srcX0);
-   const GLint dstWidth = ABS(dstX1 - dstX0);
-   const GLint srcHeight = ABS(srcY1 - srcY0);
-   const GLint dstHeight = ABS(dstY1 - dstY0);
-   const GLfloat dstHeightF = (GLfloat) dstHeight;
-
-   const GLint srcXpos = MIN2(srcX0, srcX1);
-   const GLint srcYpos = MIN2(srcY0, srcY1);
-   const GLint dstXpos = MIN2(dstX0, dstX1);
-   const GLint dstYpos = MIN2(dstY0, dstY1);
-
-   const GLboolean invertX = (srcX1 < srcX0) ^ (dstX1 < dstX0);
-   const GLboolean invertY = (srcY1 < srcY0) ^ (dstY1 < dstY0);
-
-   GLint dstRow;
-
-   GLint pixelSize;
-   GLvoid *srcBuffer0, *srcBuffer1;
-   GLint srcBufferY0 = -1, srcBufferY1 = -1;
-   GLvoid *dstBuffer;
-
-   switch (readRb->DataType) {
-   case GL_UNSIGNED_BYTE:
-      pixelSize = 4 * sizeof(GLubyte);
-      break;
-   case GL_UNSIGNED_SHORT:
-      pixelSize = 4 * sizeof(GLushort);
-      break;
-   case GL_UNSIGNED_INT:
-      pixelSize = 4 * sizeof(GLuint);
-      break;
-   case GL_FLOAT:
-      pixelSize = 4 * sizeof(GLfloat);
-      break;
-   default:
-      _mesa_problem(ctx, "unexpected buffer type (0x%x) in blit_nearest",
-                    readRb->DataType);
-      return;
-   }
-
-   /* Allocate the src/dst row buffers.
-    * Keep two adjacent src rows around for bilinear sampling.
-    */
-   srcBuffer0 = malloc(pixelSize * srcWidth);
-   if (!srcBuffer0) {
-      _mesa_error(ctx, GL_OUT_OF_MEMORY, "glBlitFrameBufferEXT");
-      return;
-   }
-   srcBuffer1 = malloc(pixelSize * srcWidth);
-   if (!srcBuffer1) {
-      free(srcBuffer0);
-      _mesa_error(ctx, GL_OUT_OF_MEMORY, "glBlitFrameBufferEXT");
-      return;
-   }
-   dstBuffer = malloc(pixelSize * dstWidth);
-   if (!dstBuffer) {
-      free(srcBuffer0);
-      free(srcBuffer1);
-      _mesa_error(ctx, GL_OUT_OF_MEMORY, "glBlitFrameBufferEXT");
-      return;
-   }
-
-   for (dstRow = 0; dstRow < dstHeight; dstRow++) {
-      const GLint dstY = dstYpos + dstRow;
-      const GLfloat srcRow = (dstRow * srcHeight) / dstHeightF;
-      GLint srcRow0 = IFLOOR(srcRow);
-      GLint srcRow1 = srcRow0 + 1;
-      GLfloat rowWeight = srcRow - srcRow0; /* fractional part of srcRow */
-
-      ASSERT(srcRow >= 0);
-      ASSERT(srcRow < srcHeight);
-
-      if (srcRow1 == srcHeight) {
-         /* last row fudge */
-         srcRow1 = srcRow0;
-         rowWeight = 0.0;
-      }
-
-      if (invertY) {
-         srcRow0 = srcHeight - 1 - srcRow0;
-         srcRow1 = srcHeight - 1 - srcRow1;
-      }
-
-      srcY0 = srcYpos + srcRow0;
-      srcY1 = srcYpos + srcRow1;
-
-      /* get the two source rows */
-      if (srcY0 == srcBufferY0 && srcY1 == srcBufferY1) {
-         /* use same source row buffers again */
-      }
-      else if (srcY0 == srcBufferY1) {
-         /* move buffer1 into buffer0 by swapping pointers */
-         GLvoid *tmp = srcBuffer0;
-         srcBuffer0 = srcBuffer1;
-         srcBuffer1 = tmp;
-         /* get y1 row */
-         readRb->GetRow(ctx, readRb, srcWidth, srcXpos, srcY1, srcBuffer1);
-         srcBufferY0 = srcY0;
-         srcBufferY1 = srcY1;
-      }
-      else {
-         /* get both new rows */
-         readRb->GetRow(ctx, readRb, srcWidth, srcXpos, srcY0, srcBuffer0);
-         readRb->GetRow(ctx, readRb, srcWidth, srcXpos, srcY1, srcBuffer1);
-         srcBufferY0 = srcY0;
-         srcBufferY1 = srcY1;
-      }
-
-      if (readRb->DataType == GL_UNSIGNED_BYTE) {
-         resample_linear_row_ub(srcWidth, dstWidth, srcBuffer0, srcBuffer1,
-                                dstBuffer, invertX, rowWeight);
-      }
-      else {
-         _mesa_problem(ctx, "Unsupported color channel type in sw blit");
-         break;
-      }
-
-      /* store pixel row in destination */
-      drawRb->PutRow(ctx, drawRb, dstWidth, dstXpos, dstY, dstBuffer, NULL);
-   }
-
-   free(srcBuffer0);
-   free(srcBuffer1);
-   free(dstBuffer);
-}
-
-
-/**
- * Simple case:  Blit color, depth or stencil with no scaling or flipping.
- * XXX we could easily support vertical flipping here.
- */
-static void
-simple_blit(GLcontext *ctx,
-            GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1,
-            GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1,
-            GLbitfield buffer)
-{
-   struct gl_renderbuffer *readRb, *drawRb;
-   const GLint width = srcX1 - srcX0;
-   const GLint height = srcY1 - srcY0;
-   GLint row, srcY, dstY, yStep;
-   GLint comps, bytesPerRow;
-   void *rowBuffer;
-
-   /* only one buffer */
-   ASSERT(_mesa_bitcount(buffer) == 1);
-   /* no flipping checks */
-   ASSERT(srcX0 < srcX1);
-   ASSERT(srcY0 < srcY1);
-   ASSERT(dstX0 < dstX1);
-   ASSERT(dstY0 < dstY1);
-   /* size checks */
-   ASSERT(srcX1 - srcX0 == dstX1 - dstX0);
-   ASSERT(srcY1 - srcY0 == dstY1 - dstY0);
-
-   /* determine if copy should be bottom-to-top or top-to-bottom */
-   if (srcY0 > dstY0) {
-      /* src above dst: copy bottom-to-top */
-      yStep = 1;
-      srcY = srcY0;
-      dstY = dstY0;
-   }
-   else {
-      /* src below dst: copy top-to-bottom */
-      yStep = -1;
-      srcY = srcY1 - 1;
-      dstY = dstY1 - 1;
-   }
-
-   switch (buffer) {
-   case GL_COLOR_BUFFER_BIT:
-      readRb = ctx->ReadBuffer->_ColorReadBuffer;
-      drawRb = ctx->DrawBuffer->_ColorDrawBuffers[0];
-      comps = 4;
-      break;
-   case GL_DEPTH_BUFFER_BIT:
-      readRb = ctx->ReadBuffer->_DepthBuffer;
-      drawRb = ctx->DrawBuffer->_DepthBuffer;
-      comps = 1;
-      break;
-   case GL_STENCIL_BUFFER_BIT:
-      readRb = ctx->ReadBuffer->_StencilBuffer;
-      drawRb = ctx->DrawBuffer->_StencilBuffer;
-      comps = 1;
-      break;
-   default:
-      _mesa_problem(ctx, "unexpected buffer in simple_blit()");
-      return;
-   }
-
-   ASSERT(readRb->DataType == drawRb->DataType);
-
-   /* compute bytes per row */
-   switch (readRb->DataType) {
-   case GL_UNSIGNED_BYTE:
-      bytesPerRow = comps * width * sizeof(GLubyte);
-      break;
-   case GL_UNSIGNED_SHORT:
-      bytesPerRow = comps * width * sizeof(GLushort);
-      break;
-   case GL_UNSIGNED_INT:
-      bytesPerRow = comps * width * sizeof(GLuint);
-      break;
-   case GL_FLOAT:
-      bytesPerRow = comps * width * sizeof(GLfloat);
-      break;
-   default:
-      _mesa_problem(ctx, "unexpected buffer type in simple_blit");
-      return;
-   }
-
-   /* allocate the row buffer */
-   rowBuffer = malloc(bytesPerRow);
-   if (!rowBuffer) {
-      _mesa_error(ctx, GL_OUT_OF_MEMORY, "glBlitFrameBufferEXT");
-      return;
-   }
-
-   for (row = 0; row < height; row++) {
-      readRb->GetRow(ctx, readRb, width, srcX0, srcY, rowBuffer);
-      drawRb->PutRow(ctx, drawRb, width, dstX0, dstY, rowBuffer, NULL);
-      srcY += yStep;
-      dstY += yStep;
-   }
-
-   free(rowBuffer);
-}
-
-
-/**
- * Software fallback for glBlitFramebufferEXT().
- */
-void
-_swrast_BlitFramebuffer(GLcontext *ctx,
-                        GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1,
-                        GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1,
-                        GLbitfield mask, GLenum filter)
-{
-   static const GLbitfield buffers[3] = {
-      GL_COLOR_BUFFER_BIT,
-      GL_DEPTH_BUFFER_BIT,
-      GL_STENCIL_BUFFER_BIT
-   };
-   GLint i;
-
-   if (!_mesa_check_conditional_render(ctx))
-      return; /* don't clear */
-
-   if (!ctx->DrawBuffer->_NumColorDrawBuffers)
-      return;
-
-   if (!_mesa_clip_blit(ctx, &srcX0, &srcY0, &srcX1, &srcY1,
-                        &dstX0, &dstY0, &dstX1, &dstY1)) {
-      return;
-   }
-
-   swrast_render_start(ctx);
-
-   if (srcX1 - srcX0 == dstX1 - dstX0 &&
-       srcY1 - srcY0 == dstY1 - dstY0 &&
-       srcX0 < srcX1 &&
-       srcY0 < srcY1 &&
-       dstX0 < dstX1 &&
-       dstY0 < dstY1) {
-      /* no stretching or flipping.
-       * filter doesn't matter.
-       */
-      for (i = 0; i < 3; i++) {
-         if (mask & buffers[i]) {
-            simple_blit(ctx, srcX0, srcY0, srcX1, srcY1,
-                        dstX0, dstY0, dstX1, dstY1, buffers[i]);
-         }
-      }
-   }
-   else {
-      if (filter == GL_NEAREST) {
-         for (i = 0; i < 3; i++) {
-            if (mask & buffers[i]) {
-               blit_nearest(ctx,  srcX0, srcY0, srcX1, srcY1,
-                            dstX0, dstY0, dstX1, dstY1, buffers[i]);
-            }
-         }
-      }
-      else {
-         ASSERT(filter == GL_LINEAR);
-         if (mask & GL_COLOR_BUFFER_BIT) {  /* depth/stencil not allowed */
-            blit_linear(ctx,  srcX0, srcY0, srcX1, srcY1,
-                        dstX0, dstY0, dstX1, dstY1);
-         }
-      }
-   }
-
-   swrast_render_finish(ctx);
-}
+/*

+ * Mesa 3-D graphics library

+ * Version:  6.5

+ *

+ * Copyright (C) 1999-2006  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/condrender.h"

+#include "main/image.h"

+#include "main/macros.h"

+#include "s_context.h"

+

+

+#define ABS(X)   ((X) < 0 ? -(X) : (X))

+

+

+/**

+ * Generate a row resampler function for GL_NEAREST mode.

+ */

+#define RESAMPLE(NAME, PIXELTYPE, SIZE)			\

+static void						\

+NAME(GLint srcWidth, GLint dstWidth,			\

+     const GLvoid *srcBuffer, GLvoid *dstBuffer,	\

+     GLboolean flip)					\

+{							\

+   const PIXELTYPE *src = (const PIXELTYPE *) srcBuffer;\

+   PIXELTYPE *dst = (PIXELTYPE *) dstBuffer;		\

+   GLint dstCol;					\

+							\

+   if (flip) {						\

+      for (dstCol = 0; dstCol < dstWidth; dstCol++) {	\

+         GLint srcCol = (dstCol * srcWidth) / dstWidth;	\

+         ASSERT(srcCol >= 0);				\

+         ASSERT(srcCol < srcWidth);			\

+         srcCol = srcWidth - 1 - srcCol; /* flip */	\

+         if (SIZE == 1) {				\

+            dst[dstCol] = src[srcCol];			\

+         }						\

+         else if (SIZE == 2) {				\

+            dst[dstCol*2+0] = src[srcCol*2+0];		\

+            dst[dstCol*2+1] = src[srcCol*2+1];		\

+         }						\

+         else if (SIZE == 4) {				\

+            dst[dstCol*4+0] = src[srcCol*4+0];		\

+            dst[dstCol*4+1] = src[srcCol*4+1];		\

+            dst[dstCol*4+2] = src[srcCol*4+2];		\

+            dst[dstCol*4+3] = src[srcCol*4+3];		\

+         }						\

+      }							\

+   }							\

+   else {						\

+      for (dstCol = 0; dstCol < dstWidth; dstCol++) {	\

+         GLint srcCol = (dstCol * srcWidth) / dstWidth;	\

+         ASSERT(srcCol >= 0);				\

+         ASSERT(srcCol < srcWidth);			\

+         if (SIZE == 1) {				\

+            dst[dstCol] = src[srcCol];			\

+         }						\

+         else if (SIZE == 2) {				\

+            dst[dstCol*2+0] = src[srcCol*2+0];		\

+            dst[dstCol*2+1] = src[srcCol*2+1];		\

+         }						\

+         else if (SIZE == 4) {				\

+            dst[dstCol*4+0] = src[srcCol*4+0];		\

+            dst[dstCol*4+1] = src[srcCol*4+1];		\

+            dst[dstCol*4+2] = src[srcCol*4+2];		\

+            dst[dstCol*4+3] = src[srcCol*4+3];		\

+         }						\

+      }							\

+   }							\

+}

+

+/**

+ * Resamplers for 1, 2, 4, 8 and 16-byte pixels.

+ */

+RESAMPLE(resample_row_1, GLubyte, 1)

+RESAMPLE(resample_row_2, GLushort, 1)

+RESAMPLE(resample_row_4, GLuint, 1)

+RESAMPLE(resample_row_8, GLuint, 2)

+RESAMPLE(resample_row_16, GLuint, 4)

+

+

+/**

+ * Blit color, depth or stencil with GL_NEAREST filtering.

+ */

+static void

+blit_nearest(struct gl_context *ctx,

+             GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1,

+             GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1,

+             GLbitfield buffer)

+{

+   struct gl_renderbuffer *readRb, *drawRb;

+

+   const GLint srcWidth = ABS(srcX1 - srcX0);

+   const GLint dstWidth = ABS(dstX1 - dstX0);

+   const GLint srcHeight = ABS(srcY1 - srcY0);

+   const GLint dstHeight = ABS(dstY1 - dstY0);

+

+   const GLint srcXpos = MIN2(srcX0, srcX1);

+   const GLint srcYpos = MIN2(srcY0, srcY1);

+   const GLint dstXpos = MIN2(dstX0, dstX1);

+   const GLint dstYpos = MIN2(dstY0, dstY1);

+

+   const GLboolean invertX = (srcX1 < srcX0) ^ (dstX1 < dstX0);

+   const GLboolean invertY = (srcY1 < srcY0) ^ (dstY1 < dstY0);

+

+   GLint dstRow;

+

+   GLint comps, pixelSize;

+   GLvoid *srcBuffer, *dstBuffer;

+   GLint prevY = -1;

+

+   typedef void (*resample_func)(GLint srcWidth, GLint dstWidth,

+                                 const GLvoid *srcBuffer, GLvoid *dstBuffer,

+                                 GLboolean flip);

+   resample_func resampleRow;

+

+   switch (buffer) {

+   case GL_COLOR_BUFFER_BIT:

+      readRb = ctx->ReadBuffer->_ColorReadBuffer;

+      drawRb = ctx->DrawBuffer->_ColorDrawBuffers[0];

+      comps = 4;

+      break;

+   case GL_DEPTH_BUFFER_BIT:

+      readRb = ctx->ReadBuffer->_DepthBuffer;

+      drawRb = ctx->DrawBuffer->_DepthBuffer;

+      comps = 1;

+      break;

+   case GL_STENCIL_BUFFER_BIT:

+      readRb = ctx->ReadBuffer->_StencilBuffer;

+      drawRb = ctx->DrawBuffer->_StencilBuffer;

+      comps = 1;

+      break;

+   default:

+      _mesa_problem(ctx, "unexpected buffer in blit_nearest()");

+      return;

+   }

+

+   switch (readRb->DataType) {

+   case GL_UNSIGNED_BYTE:

+      pixelSize = comps * sizeof(GLubyte);

+      break;

+   case GL_UNSIGNED_SHORT:

+      pixelSize = comps * sizeof(GLushort);

+      break;

+   case GL_UNSIGNED_INT:

+      pixelSize = comps * sizeof(GLuint);

+      break;

+   case GL_FLOAT:

+      pixelSize = comps * sizeof(GLfloat);

+      break;

+   default:

+      _mesa_problem(ctx, "unexpected buffer type (0x%x) in blit_nearest",

+                    readRb->DataType);

+      return;

+   }

+

+   /* choose row resampler */

+   switch (pixelSize) {

+   case 1:

+      resampleRow = resample_row_1;

+      break;

+   case 2:

+      resampleRow = resample_row_2;

+      break;

+   case 4:

+      resampleRow = resample_row_4;

+      break;

+   case 8:

+      resampleRow = resample_row_8;

+      break;

+   case 16:

+      resampleRow = resample_row_16;

+      break;

+   default:

+      _mesa_problem(ctx, "unexpected pixel size (%d) in blit_nearest",

+                    pixelSize);

+      return;

+   }

+

+   /* allocate the src/dst row buffers */

+   srcBuffer = malloc(pixelSize * srcWidth);

+   if (!srcBuffer) {

+      _mesa_error(ctx, GL_OUT_OF_MEMORY, "glBlitFrameBufferEXT");

+      return;

+   }

+   dstBuffer = malloc(pixelSize * dstWidth);

+   if (!dstBuffer) {

+      free(srcBuffer);

+      _mesa_error(ctx, GL_OUT_OF_MEMORY, "glBlitFrameBufferEXT");

+      return;

+   }

+

+   for (dstRow = 0; dstRow < dstHeight; dstRow++) {

+      const GLint dstY = dstYpos + dstRow;

+      GLint srcRow = (dstRow * srcHeight) / dstHeight;

+      GLint srcY;

+

+      ASSERT(srcRow >= 0);

+      ASSERT(srcRow < srcHeight);

+

+      if (invertY) {

+         srcRow = srcHeight - 1 - srcRow;

+      }

+

+      srcY = srcYpos + srcRow;

+

+      /* get pixel row from source and resample to match dest width */

+      if (prevY != srcY) {

+         readRb->GetRow(ctx, readRb, srcWidth, srcXpos, srcY, srcBuffer);

+         (*resampleRow)(srcWidth, dstWidth, srcBuffer, dstBuffer, invertX);

+         prevY = srcY;

+      }

+

+      /* store pixel row in destination */

+      drawRb->PutRow(ctx, drawRb, dstWidth, dstXpos, dstY, dstBuffer, NULL);

+   }

+

+   free(srcBuffer);

+   free(dstBuffer);

+}

+

+

+

+#define LERP(T, A, B)  ( (A) + (T) * ((B) - (A)) )

+

+static INLINE GLfloat

+lerp_2d(GLfloat a, GLfloat b,

+        GLfloat v00, GLfloat v10, GLfloat v01, GLfloat v11)

+{

+   const GLfloat temp0 = LERP(a, v00, v10);

+   const GLfloat temp1 = LERP(a, v01, v11);

+   return LERP(b, temp0, temp1);

+}

+

+

+/**

+ * Bilinear interpolation of two source rows.

+ * GLubyte pixels.

+ */

+static void

+resample_linear_row_ub(GLint srcWidth, GLint dstWidth,

+                       const GLvoid *srcBuffer0, const GLvoid *srcBuffer1,

+                       GLvoid *dstBuffer, GLboolean flip, GLfloat rowWeight)

+{

+   const GLubyte (*srcColor0)[4] = (const GLubyte (*)[4]) srcBuffer0;

+   const GLubyte (*srcColor1)[4] = (const GLubyte (*)[4]) srcBuffer1;

+   GLubyte (*dstColor)[4] = (GLubyte (*)[4]) dstBuffer;

+   const GLfloat dstWidthF = (GLfloat) dstWidth;

+   GLint dstCol;

+

+   for (dstCol = 0; dstCol < dstWidth; dstCol++) {

+      const GLfloat srcCol = (dstCol * srcWidth) / dstWidthF;

+      GLint srcCol0 = IFLOOR(srcCol);

+      GLint srcCol1 = srcCol0 + 1;

+      GLfloat colWeight = srcCol - srcCol0; /* fractional part of srcCol */

+      GLfloat red, green, blue, alpha;

+

+      ASSERT(srcCol0 >= 0);

+      ASSERT(srcCol0 < srcWidth);

+      ASSERT(srcCol1 <= srcWidth);

+

+      if (srcCol1 == srcWidth) {

+         /* last column fudge */

+         srcCol1--;

+         colWeight = 0.0;

+      }

+

+      if (flip) {

+         srcCol0 = srcWidth - 1 - srcCol0;

+         srcCol1 = srcWidth - 1 - srcCol1;

+      }

+

+      red = lerp_2d(colWeight, rowWeight,

+                    srcColor0[srcCol0][RCOMP], srcColor0[srcCol1][RCOMP],

+                    srcColor1[srcCol0][RCOMP], srcColor1[srcCol1][RCOMP]);

+      green = lerp_2d(colWeight, rowWeight,

+                    srcColor0[srcCol0][GCOMP], srcColor0[srcCol1][GCOMP],

+                    srcColor1[srcCol0][GCOMP], srcColor1[srcCol1][GCOMP]);

+      blue = lerp_2d(colWeight, rowWeight,

+                    srcColor0[srcCol0][BCOMP], srcColor0[srcCol1][BCOMP],

+                    srcColor1[srcCol0][BCOMP], srcColor1[srcCol1][BCOMP]);

+      alpha = lerp_2d(colWeight, rowWeight,

+                    srcColor0[srcCol0][ACOMP], srcColor0[srcCol1][ACOMP],

+                    srcColor1[srcCol0][ACOMP], srcColor1[srcCol1][ACOMP]);

+      

+      dstColor[dstCol][RCOMP] = IFLOOR(red);

+      dstColor[dstCol][GCOMP] = IFLOOR(green);

+      dstColor[dstCol][BCOMP] = IFLOOR(blue);

+      dstColor[dstCol][ACOMP] = IFLOOR(alpha);

+   }

+}

+

+

+

+/**

+ * Bilinear filtered blit (color only).

+ */

+static void

+blit_linear(struct gl_context *ctx,

+            GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1,

+            GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1)

+{

+   struct gl_renderbuffer *readRb = ctx->ReadBuffer->_ColorReadBuffer;

+   struct gl_renderbuffer *drawRb = ctx->DrawBuffer->_ColorDrawBuffers[0];

+

+   const GLint srcWidth = ABS(srcX1 - srcX0);

+   const GLint dstWidth = ABS(dstX1 - dstX0);

+   const GLint srcHeight = ABS(srcY1 - srcY0);

+   const GLint dstHeight = ABS(dstY1 - dstY0);

+   const GLfloat dstHeightF = (GLfloat) dstHeight;

+

+   const GLint srcXpos = MIN2(srcX0, srcX1);

+   const GLint srcYpos = MIN2(srcY0, srcY1);

+   const GLint dstXpos = MIN2(dstX0, dstX1);

+   const GLint dstYpos = MIN2(dstY0, dstY1);

+

+   const GLboolean invertX = (srcX1 < srcX0) ^ (dstX1 < dstX0);

+   const GLboolean invertY = (srcY1 < srcY0) ^ (dstY1 < dstY0);

+

+   GLint dstRow;

+

+   GLint pixelSize;

+   GLvoid *srcBuffer0, *srcBuffer1;

+   GLint srcBufferY0 = -1, srcBufferY1 = -1;

+   GLvoid *dstBuffer;

+

+   switch (readRb->DataType) {

+   case GL_UNSIGNED_BYTE:

+      pixelSize = 4 * sizeof(GLubyte);

+      break;

+   case GL_UNSIGNED_SHORT:

+      pixelSize = 4 * sizeof(GLushort);

+      break;

+   case GL_UNSIGNED_INT:

+      pixelSize = 4 * sizeof(GLuint);

+      break;

+   case GL_FLOAT:

+      pixelSize = 4 * sizeof(GLfloat);

+      break;

+   default:

+      _mesa_problem(ctx, "unexpected buffer type (0x%x) in blit_nearest",

+                    readRb->DataType);

+      return;

+   }

+

+   /* Allocate the src/dst row buffers.

+    * Keep two adjacent src rows around for bilinear sampling.

+    */

+   srcBuffer0 = malloc(pixelSize * srcWidth);

+   if (!srcBuffer0) {

+      _mesa_error(ctx, GL_OUT_OF_MEMORY, "glBlitFrameBufferEXT");

+      return;

+   }

+   srcBuffer1 = malloc(pixelSize * srcWidth);

+   if (!srcBuffer1) {

+      free(srcBuffer0);

+      _mesa_error(ctx, GL_OUT_OF_MEMORY, "glBlitFrameBufferEXT");

+      return;

+   }

+   dstBuffer = malloc(pixelSize * dstWidth);

+   if (!dstBuffer) {

+      free(srcBuffer0);

+      free(srcBuffer1);

+      _mesa_error(ctx, GL_OUT_OF_MEMORY, "glBlitFrameBufferEXT");

+      return;

+   }

+

+   for (dstRow = 0; dstRow < dstHeight; dstRow++) {

+      const GLint dstY = dstYpos + dstRow;

+      const GLfloat srcRow = (dstRow * srcHeight) / dstHeightF;

+      GLint srcRow0 = IFLOOR(srcRow);

+      GLint srcRow1 = srcRow0 + 1;

+      GLfloat rowWeight = srcRow - srcRow0; /* fractional part of srcRow */

+

+      ASSERT(srcRow >= 0);

+      ASSERT(srcRow < srcHeight);

+

+      if (srcRow1 == srcHeight) {

+         /* last row fudge */

+         srcRow1 = srcRow0;

+         rowWeight = 0.0;

+      }

+

+      if (invertY) {

+         srcRow0 = srcHeight - 1 - srcRow0;

+         srcRow1 = srcHeight - 1 - srcRow1;

+      }

+

+      srcY0 = srcYpos + srcRow0;

+      srcY1 = srcYpos + srcRow1;

+

+      /* get the two source rows */

+      if (srcY0 == srcBufferY0 && srcY1 == srcBufferY1) {

+         /* use same source row buffers again */

+      }

+      else if (srcY0 == srcBufferY1) {

+         /* move buffer1 into buffer0 by swapping pointers */

+         GLvoid *tmp = srcBuffer0;

+         srcBuffer0 = srcBuffer1;

+         srcBuffer1 = tmp;

+         /* get y1 row */

+         readRb->GetRow(ctx, readRb, srcWidth, srcXpos, srcY1, srcBuffer1);

+         srcBufferY0 = srcY0;

+         srcBufferY1 = srcY1;

+      }

+      else {

+         /* get both new rows */

+         readRb->GetRow(ctx, readRb, srcWidth, srcXpos, srcY0, srcBuffer0);

+         readRb->GetRow(ctx, readRb, srcWidth, srcXpos, srcY1, srcBuffer1);

+         srcBufferY0 = srcY0;

+         srcBufferY1 = srcY1;

+      }

+

+      if (readRb->DataType == GL_UNSIGNED_BYTE) {

+         resample_linear_row_ub(srcWidth, dstWidth, srcBuffer0, srcBuffer1,

+                                dstBuffer, invertX, rowWeight);

+      }

+      else {

+         _mesa_problem(ctx, "Unsupported color channel type in sw blit");

+         break;

+      }

+

+      /* store pixel row in destination */

+      drawRb->PutRow(ctx, drawRb, dstWidth, dstXpos, dstY, dstBuffer, NULL);

+   }

+

+   free(srcBuffer0);

+   free(srcBuffer1);

+   free(dstBuffer);

+}

+

+

+/**

+ * Simple case:  Blit color, depth or stencil with no scaling or flipping.

+ * XXX we could easily support vertical flipping here.

+ */

+static void

+simple_blit(struct gl_context *ctx,

+            GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1,

+            GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1,

+            GLbitfield buffer)

+{

+   struct gl_renderbuffer *readRb, *drawRb;

+   const GLint width = srcX1 - srcX0;

+   const GLint height = srcY1 - srcY0;

+   GLint row, srcY, dstY, yStep;

+   GLint comps, bytesPerRow;

+   void *rowBuffer;

+

+   /* only one buffer */

+   ASSERT(_mesa_bitcount(buffer) == 1);

+   /* no flipping checks */

+   ASSERT(srcX0 < srcX1);

+   ASSERT(srcY0 < srcY1);

+   ASSERT(dstX0 < dstX1);

+   ASSERT(dstY0 < dstY1);

+   /* size checks */

+   ASSERT(srcX1 - srcX0 == dstX1 - dstX0);

+   ASSERT(srcY1 - srcY0 == dstY1 - dstY0);

+

+   /* determine if copy should be bottom-to-top or top-to-bottom */

+   if (srcY0 > dstY0) {

+      /* src above dst: copy bottom-to-top */

+      yStep = 1;

+      srcY = srcY0;

+      dstY = dstY0;

+   }

+   else {

+      /* src below dst: copy top-to-bottom */

+      yStep = -1;

+      srcY = srcY1 - 1;

+      dstY = dstY1 - 1;

+   }

+

+   switch (buffer) {

+   case GL_COLOR_BUFFER_BIT:

+      readRb = ctx->ReadBuffer->_ColorReadBuffer;

+      drawRb = ctx->DrawBuffer->_ColorDrawBuffers[0];

+      comps = 4;

+      break;

+   case GL_DEPTH_BUFFER_BIT:

+      readRb = ctx->ReadBuffer->_DepthBuffer;

+      drawRb = ctx->DrawBuffer->_DepthBuffer;

+      comps = 1;

+      break;

+   case GL_STENCIL_BUFFER_BIT:

+      readRb = ctx->ReadBuffer->_StencilBuffer;

+      drawRb = ctx->DrawBuffer->_StencilBuffer;

+      comps = 1;

+      break;

+   default:

+      _mesa_problem(ctx, "unexpected buffer in simple_blit()");

+      return;

+   }

+

+   ASSERT(readRb->DataType == drawRb->DataType);

+

+   /* compute bytes per row */

+   switch (readRb->DataType) {

+   case GL_UNSIGNED_BYTE:

+      bytesPerRow = comps * width * sizeof(GLubyte);

+      break;

+   case GL_UNSIGNED_SHORT:

+      bytesPerRow = comps * width * sizeof(GLushort);

+      break;

+   case GL_UNSIGNED_INT:

+      bytesPerRow = comps * width * sizeof(GLuint);

+      break;

+   case GL_FLOAT:

+      bytesPerRow = comps * width * sizeof(GLfloat);

+      break;

+   default:

+      _mesa_problem(ctx, "unexpected buffer type in simple_blit");

+      return;

+   }

+

+   /* allocate the row buffer */

+   rowBuffer = malloc(bytesPerRow);

+   if (!rowBuffer) {

+      _mesa_error(ctx, GL_OUT_OF_MEMORY, "glBlitFrameBufferEXT");

+      return;

+   }

+

+   for (row = 0; row < height; row++) {

+      readRb->GetRow(ctx, readRb, width, srcX0, srcY, rowBuffer);

+      drawRb->PutRow(ctx, drawRb, width, dstX0, dstY, rowBuffer, NULL);

+      srcY += yStep;

+      dstY += yStep;

+   }

+

+   free(rowBuffer);

+}

+

+

+/**

+ * Software fallback for glBlitFramebufferEXT().

+ */

+void

+_swrast_BlitFramebuffer(struct gl_context *ctx,

+                        GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1,

+                        GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1,

+                        GLbitfield mask, GLenum filter)

+{

+   static const GLbitfield buffers[3] = {

+      GL_COLOR_BUFFER_BIT,

+      GL_DEPTH_BUFFER_BIT,

+      GL_STENCIL_BUFFER_BIT

+   };

+   GLint i;

+

+   if (!_mesa_check_conditional_render(ctx))

+      return; /* don't clear */

+

+   if (!ctx->DrawBuffer->_NumColorDrawBuffers)

+      return;

+

+   if (!_mesa_clip_blit(ctx, &srcX0, &srcY0, &srcX1, &srcY1,

+                        &dstX0, &dstY0, &dstX1, &dstY1)) {

+      return;

+   }

+

+   swrast_render_start(ctx);

+

+   if (srcX1 - srcX0 == dstX1 - dstX0 &&

+       srcY1 - srcY0 == dstY1 - dstY0 &&

+       srcX0 < srcX1 &&

+       srcY0 < srcY1 &&

+       dstX0 < dstX1 &&

+       dstY0 < dstY1) {

+      /* no stretching or flipping.

+       * filter doesn't matter.

+       */

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

+         if (mask & buffers[i]) {

+            simple_blit(ctx, srcX0, srcY0, srcX1, srcY1,

+                        dstX0, dstY0, dstX1, dstY1, buffers[i]);

+         }

+      }

+   }

+   else {

+      if (filter == GL_NEAREST) {

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

+            if (mask & buffers[i]) {

+               blit_nearest(ctx,  srcX0, srcY0, srcX1, srcY1,

+                            dstX0, dstY0, dstX1, dstY1, buffers[i]);

+            }

+         }

+      }

+      else {

+         ASSERT(filter == GL_LINEAR);

+         if (mask & GL_COLOR_BUFFER_BIT) {  /* depth/stencil not allowed */

+            blit_linear(ctx,  srcX0, srcY0, srcX1, srcY1,

+                        dstX0, dstY0, dstX1, dstY1);

+         }

+      }

+   }

+

+   swrast_render_finish(ctx);

+}

diff --git a/mesalib/src/mesa/swrast/s_clear.c b/mesalib/src/mesa/swrast/s_clear.c
index efe500ae2..fac092f1e 100644
--- a/mesalib/src/mesa/swrast/s_clear.c
+++ b/mesalib/src/mesa/swrast/s_clear.c
@@ -1,230 +1,230 @@
-/*
- * Mesa 3-D graphics library
- * Version:  7.1
- *
- * Copyright (C) 1999-2008  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/condrender.h"
-#include "main/macros.h"
-#include "main/imports.h"
-#include "main/mtypes.h"
-
-#include "s_accum.h"
-#include "s_context.h"
-#include "s_depth.h"
-#include "s_masking.h"
-#include "s_stencil.h"
-
-
-/**
- * Clear the color buffer when glColorMask is in effect.
- */
-static void
-clear_rgba_buffer_with_masking(GLcontext *ctx, struct gl_renderbuffer *rb,
-                               GLuint buf)
-{
-   const GLint x = ctx->DrawBuffer->_Xmin;
-   const GLint y = ctx->DrawBuffer->_Ymin;
-   const GLint height = ctx->DrawBuffer->_Ymax - ctx->DrawBuffer->_Ymin;
-   const GLint width  = ctx->DrawBuffer->_Xmax - ctx->DrawBuffer->_Xmin;
-   SWspan span;
-   GLint i;
-
-   ASSERT(rb->PutRow);
-
-   /* Initialize color span with clear color */
-   /* XXX optimize for clearcolor == black/zero (bzero) */
-   INIT_SPAN(span, GL_BITMAP);
-   span.end = width;
-   span.arrayMask = SPAN_RGBA;
-   span.array->ChanType = rb->DataType;
-   if (span.array->ChanType == GL_UNSIGNED_BYTE) {
-      GLubyte clearColor[4];
-      UNCLAMPED_FLOAT_TO_UBYTE(clearColor[RCOMP], ctx->Color.ClearColor[0]);
-      UNCLAMPED_FLOAT_TO_UBYTE(clearColor[GCOMP], ctx->Color.ClearColor[1]);
-      UNCLAMPED_FLOAT_TO_UBYTE(clearColor[BCOMP], ctx->Color.ClearColor[2]);
-      UNCLAMPED_FLOAT_TO_UBYTE(clearColor[ACOMP], ctx->Color.ClearColor[3]);
-      for (i = 0; i < width; i++) {
-         COPY_4UBV(span.array->rgba[i], clearColor);
-      }
-   }
-   else if (span.array->ChanType == GL_UNSIGNED_SHORT) {
-      GLushort clearColor[4];
-      UNCLAMPED_FLOAT_TO_USHORT(clearColor[RCOMP], ctx->Color.ClearColor[0]);
-      UNCLAMPED_FLOAT_TO_USHORT(clearColor[GCOMP], ctx->Color.ClearColor[1]);
-      UNCLAMPED_FLOAT_TO_USHORT(clearColor[BCOMP], ctx->Color.ClearColor[2]);
-      UNCLAMPED_FLOAT_TO_USHORT(clearColor[ACOMP], ctx->Color.ClearColor[3]);
-      for (i = 0; i < width; i++) {
-         COPY_4V_CAST(span.array->rgba[i], clearColor, GLchan);
-      }
-   }
-   else {
-      ASSERT(span.array->ChanType == GL_FLOAT);
-      for (i = 0; i < width; i++) {
-         CLAMPED_FLOAT_TO_CHAN(span.array->rgba[i][0], ctx->Color.ClearColor[0]);
-         CLAMPED_FLOAT_TO_CHAN(span.array->rgba[i][1], ctx->Color.ClearColor[1]);
-         CLAMPED_FLOAT_TO_CHAN(span.array->rgba[i][2], ctx->Color.ClearColor[2]);
-         CLAMPED_FLOAT_TO_CHAN(span.array->rgba[i][3], ctx->Color.ClearColor[3]);
-      }
-   }
-
-   /* Note that masking will change the color values, but only the
-    * channels for which the write mask is GL_FALSE.  The channels
-    * which which are write-enabled won't get modified.
-    */
-   for (i = 0; i < height; i++) {
-      span.x = x;
-      span.y = y + i;
-      _swrast_mask_rgba_span(ctx, rb, &span, buf);
-      /* write masked row */
-      rb->PutRow(ctx, rb, width, x, y + i, span.array->rgba, NULL);
-   }
-}
-
-
-/**
- * Clear an rgba color buffer without channel masking.
- */
-static void
-clear_rgba_buffer(GLcontext *ctx, struct gl_renderbuffer *rb, GLuint buf)
-{
-   const GLint x = ctx->DrawBuffer->_Xmin;
-   const GLint y = ctx->DrawBuffer->_Ymin;
-   const GLint height = ctx->DrawBuffer->_Ymax - ctx->DrawBuffer->_Ymin;
-   const GLint width  = ctx->DrawBuffer->_Xmax - ctx->DrawBuffer->_Xmin;
-   GLubyte clear8[4];
-   GLushort clear16[4];
-   GLvoid *clearVal;
-   GLint i;
-
-   ASSERT(ctx->Color.ColorMask[buf][0] &&
-          ctx->Color.ColorMask[buf][1] &&
-          ctx->Color.ColorMask[buf][2] &&
-          ctx->Color.ColorMask[buf][3]);             
-
-   ASSERT(rb->PutMonoRow);
-
-   switch (rb->DataType) {
-      case GL_UNSIGNED_BYTE:
-         UNCLAMPED_FLOAT_TO_UBYTE(clear8[0], ctx->Color.ClearColor[0]);
-         UNCLAMPED_FLOAT_TO_UBYTE(clear8[1], ctx->Color.ClearColor[1]);
-         UNCLAMPED_FLOAT_TO_UBYTE(clear8[2], ctx->Color.ClearColor[2]);
-         UNCLAMPED_FLOAT_TO_UBYTE(clear8[3], ctx->Color.ClearColor[3]);
-         clearVal = clear8;
-         break;
-      case GL_UNSIGNED_SHORT:
-         UNCLAMPED_FLOAT_TO_USHORT(clear16[0], ctx->Color.ClearColor[0]);
-         UNCLAMPED_FLOAT_TO_USHORT(clear16[1], ctx->Color.ClearColor[1]);
-         UNCLAMPED_FLOAT_TO_USHORT(clear16[2], ctx->Color.ClearColor[2]);
-         UNCLAMPED_FLOAT_TO_USHORT(clear16[3], ctx->Color.ClearColor[3]);
-         clearVal = clear16;
-         break;
-      case GL_FLOAT:
-         clearVal = ctx->Color.ClearColor;
-         break;
-      default:
-         _mesa_problem(ctx, "Bad rb DataType in clear_color_buffer");
-         return;
-   }
-
-   for (i = 0; i < height; i++) {
-      rb->PutMonoRow(ctx, rb, width, x, y + i, clearVal, NULL);
-   }
-}
-
-
-/**
- * Clear the front/back/left/right/aux color buffers.
- * This function is usually only called if the device driver can't
- * clear its own color buffers for some reason (such as with masking).
- */
-static void
-clear_color_buffers(GLcontext *ctx)
-{
-   GLuint buf;
-
-   for (buf = 0; buf < ctx->DrawBuffer->_NumColorDrawBuffers; buf++) {
-      struct gl_renderbuffer *rb = ctx->DrawBuffer->_ColorDrawBuffers[buf];
-      if (ctx->Color.ColorMask[buf][0] == 0 ||
-          ctx->Color.ColorMask[buf][1] == 0 ||
-          ctx->Color.ColorMask[buf][2] == 0 ||
-          ctx->Color.ColorMask[buf][3] == 0) {
-         clear_rgba_buffer_with_masking(ctx, rb, buf);
-      }
-      else {
-         clear_rgba_buffer(ctx, rb, buf);
-      }
-   }
-}
-
-
-/**
- * Called via the device driver's ctx->Driver.Clear() function if the
- * device driver can't clear one or more of the buffers itself.
- * \param buffers  bitfield of BUFFER_BIT_* values indicating which
- *                 renderbuffers are to be cleared.
- * \param all  if GL_TRUE, clear whole buffer, else clear specified region.
- */
-void
-_swrast_Clear(GLcontext *ctx, GLbitfield buffers)
-{
-#ifdef DEBUG_FOO
-   {
-      const GLbitfield legalBits =
-         BUFFER_BIT_FRONT_LEFT |
-	 BUFFER_BIT_FRONT_RIGHT |
-	 BUFFER_BIT_BACK_LEFT |
-	 BUFFER_BIT_BACK_RIGHT |
-	 BUFFER_BIT_DEPTH |
-	 BUFFER_BIT_STENCIL |
-	 BUFFER_BIT_ACCUM |
-         BUFFER_BIT_AUX0;
-      assert((buffers & (~legalBits)) == 0);
-   }
-#endif
-
-   if (!_mesa_check_conditional_render(ctx))
-      return; /* don't clear */
-
-   swrast_render_start(ctx);
-
-   /* do software clearing here */
-   if (buffers) {
-      if ((buffers & BUFFER_BITS_COLOR)
-          && (ctx->DrawBuffer->_NumColorDrawBuffers > 0)) {
-         clear_color_buffers(ctx);
-      }
-      if (buffers & BUFFER_BIT_DEPTH) {
-         _swrast_clear_depth_buffer(ctx, ctx->DrawBuffer->_DepthBuffer);
-      }
-      if (buffers & BUFFER_BIT_ACCUM) {
-         _swrast_clear_accum_buffer(ctx,
-                       ctx->DrawBuffer->Attachment[BUFFER_ACCUM].Renderbuffer);
-      }
-      if (buffers & BUFFER_BIT_STENCIL) {
-         _swrast_clear_stencil_buffer(ctx, ctx->DrawBuffer->_StencilBuffer);
-      }
-   }
-
-   swrast_render_finish(ctx);
-}
+/*

+ * Mesa 3-D graphics library

+ * Version:  7.1

+ *

+ * Copyright (C) 1999-2008  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/condrender.h"

+#include "main/macros.h"

+#include "main/imports.h"

+#include "main/mtypes.h"

+

+#include "s_accum.h"

+#include "s_context.h"

+#include "s_depth.h"

+#include "s_masking.h"

+#include "s_stencil.h"

+

+

+/**

+ * Clear the color buffer when glColorMask is in effect.

+ */

+static void

+clear_rgba_buffer_with_masking(struct gl_context *ctx, struct gl_renderbuffer *rb,

+                               GLuint buf)

+{

+   const GLint x = ctx->DrawBuffer->_Xmin;

+   const GLint y = ctx->DrawBuffer->_Ymin;

+   const GLint height = ctx->DrawBuffer->_Ymax - ctx->DrawBuffer->_Ymin;

+   const GLint width  = ctx->DrawBuffer->_Xmax - ctx->DrawBuffer->_Xmin;

+   SWspan span;

+   GLint i;

+

+   ASSERT(rb->PutRow);

+

+   /* Initialize color span with clear color */

+   /* XXX optimize for clearcolor == black/zero (bzero) */

+   INIT_SPAN(span, GL_BITMAP);

+   span.end = width;

+   span.arrayMask = SPAN_RGBA;

+   span.array->ChanType = rb->DataType;

+   if (span.array->ChanType == GL_UNSIGNED_BYTE) {

+      GLubyte clearColor[4];

+      UNCLAMPED_FLOAT_TO_UBYTE(clearColor[RCOMP], ctx->Color.ClearColor[0]);

+      UNCLAMPED_FLOAT_TO_UBYTE(clearColor[GCOMP], ctx->Color.ClearColor[1]);

+      UNCLAMPED_FLOAT_TO_UBYTE(clearColor[BCOMP], ctx->Color.ClearColor[2]);

+      UNCLAMPED_FLOAT_TO_UBYTE(clearColor[ACOMP], ctx->Color.ClearColor[3]);

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

+         COPY_4UBV(span.array->rgba[i], clearColor);

+      }

+   }

+   else if (span.array->ChanType == GL_UNSIGNED_SHORT) {

+      GLushort clearColor[4];

+      UNCLAMPED_FLOAT_TO_USHORT(clearColor[RCOMP], ctx->Color.ClearColor[0]);

+      UNCLAMPED_FLOAT_TO_USHORT(clearColor[GCOMP], ctx->Color.ClearColor[1]);

+      UNCLAMPED_FLOAT_TO_USHORT(clearColor[BCOMP], ctx->Color.ClearColor[2]);

+      UNCLAMPED_FLOAT_TO_USHORT(clearColor[ACOMP], ctx->Color.ClearColor[3]);

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

+         COPY_4V_CAST(span.array->rgba[i], clearColor, GLchan);

+      }

+   }

+   else {

+      ASSERT(span.array->ChanType == GL_FLOAT);

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

+         CLAMPED_FLOAT_TO_CHAN(span.array->rgba[i][0], ctx->Color.ClearColor[0]);

+         CLAMPED_FLOAT_TO_CHAN(span.array->rgba[i][1], ctx->Color.ClearColor[1]);

+         CLAMPED_FLOAT_TO_CHAN(span.array->rgba[i][2], ctx->Color.ClearColor[2]);

+         CLAMPED_FLOAT_TO_CHAN(span.array->rgba[i][3], ctx->Color.ClearColor[3]);

+      }

+   }

+

+   /* Note that masking will change the color values, but only the

+    * channels for which the write mask is GL_FALSE.  The channels

+    * which which are write-enabled won't get modified.

+    */

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

+      span.x = x;

+      span.y = y + i;

+      _swrast_mask_rgba_span(ctx, rb, &span, buf);

+      /* write masked row */

+      rb->PutRow(ctx, rb, width, x, y + i, span.array->rgba, NULL);

+   }

+}

+

+

+/**

+ * Clear an rgba color buffer without channel masking.

+ */

+static void

+clear_rgba_buffer(struct gl_context *ctx, struct gl_renderbuffer *rb, GLuint buf)

+{

+   const GLint x = ctx->DrawBuffer->_Xmin;

+   const GLint y = ctx->DrawBuffer->_Ymin;

+   const GLint height = ctx->DrawBuffer->_Ymax - ctx->DrawBuffer->_Ymin;

+   const GLint width  = ctx->DrawBuffer->_Xmax - ctx->DrawBuffer->_Xmin;

+   GLubyte clear8[4];

+   GLushort clear16[4];

+   GLvoid *clearVal;

+   GLint i;

+

+   ASSERT(ctx->Color.ColorMask[buf][0] &&

+          ctx->Color.ColorMask[buf][1] &&

+          ctx->Color.ColorMask[buf][2] &&

+          ctx->Color.ColorMask[buf][3]);             

+

+   ASSERT(rb->PutMonoRow);

+

+   switch (rb->DataType) {

+      case GL_UNSIGNED_BYTE:

+         UNCLAMPED_FLOAT_TO_UBYTE(clear8[0], ctx->Color.ClearColor[0]);

+         UNCLAMPED_FLOAT_TO_UBYTE(clear8[1], ctx->Color.ClearColor[1]);

+         UNCLAMPED_FLOAT_TO_UBYTE(clear8[2], ctx->Color.ClearColor[2]);

+         UNCLAMPED_FLOAT_TO_UBYTE(clear8[3], ctx->Color.ClearColor[3]);

+         clearVal = clear8;

+         break;

+      case GL_UNSIGNED_SHORT:

+         UNCLAMPED_FLOAT_TO_USHORT(clear16[0], ctx->Color.ClearColor[0]);

+         UNCLAMPED_FLOAT_TO_USHORT(clear16[1], ctx->Color.ClearColor[1]);

+         UNCLAMPED_FLOAT_TO_USHORT(clear16[2], ctx->Color.ClearColor[2]);

+         UNCLAMPED_FLOAT_TO_USHORT(clear16[3], ctx->Color.ClearColor[3]);

+         clearVal = clear16;

+         break;

+      case GL_FLOAT:

+         clearVal = ctx->Color.ClearColor;

+         break;

+      default:

+         _mesa_problem(ctx, "Bad rb DataType in clear_color_buffer");

+         return;

+   }

+

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

+      rb->PutMonoRow(ctx, rb, width, x, y + i, clearVal, NULL);

+   }

+}

+

+

+/**

+ * Clear the front/back/left/right/aux color buffers.

+ * This function is usually only called if the device driver can't

+ * clear its own color buffers for some reason (such as with masking).

+ */

+static void

+clear_color_buffers(struct gl_context *ctx)

+{

+   GLuint buf;

+

+   for (buf = 0; buf < ctx->DrawBuffer->_NumColorDrawBuffers; buf++) {

+      struct gl_renderbuffer *rb = ctx->DrawBuffer->_ColorDrawBuffers[buf];

+      if (ctx->Color.ColorMask[buf][0] == 0 ||

+          ctx->Color.ColorMask[buf][1] == 0 ||

+          ctx->Color.ColorMask[buf][2] == 0 ||

+          ctx->Color.ColorMask[buf][3] == 0) {

+         clear_rgba_buffer_with_masking(ctx, rb, buf);

+      }

+      else {

+         clear_rgba_buffer(ctx, rb, buf);

+      }

+   }

+}

+

+

+/**

+ * Called via the device driver's ctx->Driver.Clear() function if the

+ * device driver can't clear one or more of the buffers itself.

+ * \param buffers  bitfield of BUFFER_BIT_* values indicating which

+ *                 renderbuffers are to be cleared.

+ * \param all  if GL_TRUE, clear whole buffer, else clear specified region.

+ */

+void

+_swrast_Clear(struct gl_context *ctx, GLbitfield buffers)

+{

+#ifdef DEBUG_FOO

+   {

+      const GLbitfield legalBits =

+         BUFFER_BIT_FRONT_LEFT |

+	 BUFFER_BIT_FRONT_RIGHT |

+	 BUFFER_BIT_BACK_LEFT |

+	 BUFFER_BIT_BACK_RIGHT |

+	 BUFFER_BIT_DEPTH |

+	 BUFFER_BIT_STENCIL |

+	 BUFFER_BIT_ACCUM |

+         BUFFER_BIT_AUX0;

+      assert((buffers & (~legalBits)) == 0);

+   }

+#endif

+

+   if (!_mesa_check_conditional_render(ctx))

+      return; /* don't clear */

+

+   swrast_render_start(ctx);

+

+   /* do software clearing here */

+   if (buffers) {

+      if ((buffers & BUFFER_BITS_COLOR)

+          && (ctx->DrawBuffer->_NumColorDrawBuffers > 0)) {

+         clear_color_buffers(ctx);

+      }

+      if (buffers & BUFFER_BIT_DEPTH) {

+         _swrast_clear_depth_buffer(ctx, ctx->DrawBuffer->_DepthBuffer);

+      }

+      if (buffers & BUFFER_BIT_ACCUM) {

+         _swrast_clear_accum_buffer(ctx,

+                       ctx->DrawBuffer->Attachment[BUFFER_ACCUM].Renderbuffer);

+      }

+      if (buffers & BUFFER_BIT_STENCIL) {

+         _swrast_clear_stencil_buffer(ctx, ctx->DrawBuffer->_StencilBuffer);

+      }

+   }

+

+   swrast_render_finish(ctx);

+}

diff --git a/mesalib/src/mesa/swrast/s_context.c b/mesalib/src/mesa/swrast/s_context.c
index f76a2b68e..b0c9880b1 100644
--- a/mesalib/src/mesa/swrast/s_context.c
+++ b/mesalib/src/mesa/swrast/s_context.c
@@ -1,957 +1,957 @@
-/*
- * Mesa 3-D graphics library
- * Version:  7.1
- *
- * Copyright (C) 1999-2008  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.
- *
- * Authors:
- *    Keith Whitwell <keith@tungstengraphics.com>
- *    Brian Paul
- */
-
-#include "main/imports.h"
-#include "main/bufferobj.h"
-#include "main/colormac.h"
-#include "main/mtypes.h"
-#include "main/teximage.h"
-#include "program/prog_parameter.h"
-#include "program/prog_statevars.h"
-#include "swrast.h"
-#include "s_blend.h"
-#include "s_context.h"
-#include "s_lines.h"
-#include "s_points.h"
-#include "s_span.h"
-#include "s_triangle.h"
-#include "s_texfilter.h"
-
-
-/**
- * Recompute the value of swrast->_RasterMask, etc. according to
- * the current context.  The _RasterMask field can be easily tested by
- * drivers to determine certain basic GL state (does the primitive need
- * stenciling, logic-op, fog, etc?).
- */
-static void
-_swrast_update_rasterflags( GLcontext *ctx )
-{
-   SWcontext *swrast = SWRAST_CONTEXT(ctx);
-   GLbitfield rasterMask = 0;
-   GLuint i;
-
-   if (ctx->Color.AlphaEnabled)           rasterMask |= ALPHATEST_BIT;
-   if (ctx->Color.BlendEnabled)           rasterMask |= BLEND_BIT;
-   if (ctx->Depth.Test)                   rasterMask |= DEPTH_BIT;
-   if (swrast->_FogEnabled)               rasterMask |= FOG_BIT;
-   if (ctx->Scissor.Enabled)              rasterMask |= CLIP_BIT;
-   if (ctx->Stencil._Enabled)             rasterMask |= STENCIL_BIT;
-   for (i = 0; i < ctx->Const.MaxDrawBuffers; i++) {
-      if (!ctx->Color.ColorMask[i][0] ||
-          !ctx->Color.ColorMask[i][1] ||
-          !ctx->Color.ColorMask[i][2] ||
-          !ctx->Color.ColorMask[i][3]) {
-         rasterMask |= MASKING_BIT;
-         break;
-      }
-   }
-   if (ctx->Color._LogicOpEnabled)     rasterMask |= LOGIC_OP_BIT;
-   if (ctx->Texture._EnabledUnits)     rasterMask |= TEXTURE_BIT;
-   if (   ctx->Viewport.X < 0
-       || ctx->Viewport.X + ctx->Viewport.Width > (GLint) ctx->DrawBuffer->Width
-       || ctx->Viewport.Y < 0
-       || ctx->Viewport.Y + ctx->Viewport.Height > (GLint) ctx->DrawBuffer->Height) {
-      rasterMask |= CLIP_BIT;
-   }
-
-   if (ctx->Query.CurrentOcclusionObject)
-      rasterMask |= OCCLUSION_BIT;
-
-
-   /* If we're not drawing to exactly one color buffer set the
-    * MULTI_DRAW_BIT flag.  Also set it if we're drawing to no
-    * buffers or the RGBA or CI mask disables all writes.
-    */
-   if (ctx->DrawBuffer->_NumColorDrawBuffers != 1) {
-      /* more than one color buffer designated for writing (or zero buffers) */
-      rasterMask |= MULTI_DRAW_BIT;
-   }
-
-   for (i = 0; i < ctx->Const.MaxDrawBuffers; i++) {
-      if (ctx->Color.ColorMask[i][0] +
-          ctx->Color.ColorMask[i][1] +
-          ctx->Color.ColorMask[i][2] +
-          ctx->Color.ColorMask[i][3] == 0) {
-         rasterMask |= MULTI_DRAW_BIT; /* all RGBA channels disabled */
-         break;
-      }
-   }
-
-
-   if (ctx->FragmentProgram._Current) {
-      rasterMask |= FRAGPROG_BIT;
-   }
-
-   if (ctx->ATIFragmentShader._Enabled) {
-      rasterMask |= ATIFRAGSHADER_BIT;
-   }
-
-#if CHAN_TYPE == GL_FLOAT
-   if (ctx->Color.ClampFragmentColor == GL_TRUE) {
-      rasterMask |= CLAMPING_BIT;
-   }
-#endif
-
-   SWRAST_CONTEXT(ctx)->_RasterMask = rasterMask;
-}
-
-
-/**
- * Examine polygon cull state to compute the _BackfaceCullSign field.
- * _BackfaceCullSign will be 0 if no culling, -1 if culling back-faces,
- * and 1 if culling front-faces.  The Polygon FrontFace state also
- * factors in.
- */
-static void
-_swrast_update_polygon( GLcontext *ctx )
-{
-   GLfloat backface_sign;
-
-   if (ctx->Polygon.CullFlag) {
-      switch (ctx->Polygon.CullFaceMode) {
-      case GL_BACK:
-         backface_sign = -1.0F;
-	 break;
-      case GL_FRONT:
-         backface_sign = 1.0F;
-	 break;
-      case GL_FRONT_AND_BACK:
-         /* fallthrough */
-      default:
-	 backface_sign = 0.0F;
-      }
-   }
-   else {
-      backface_sign = 0.0F;
-   }
-
-   SWRAST_CONTEXT(ctx)->_BackfaceCullSign = backface_sign;
-
-   /* This is for front/back-face determination, but not for culling */
-   SWRAST_CONTEXT(ctx)->_BackfaceSign
-      = (ctx->Polygon.FrontFace == GL_CW) ? -1.0F : 1.0F;
-}
-
-
-
-/**
- * Update the _PreferPixelFog field to indicate if we need to compute
- * fog blend factors (from the fog coords) per-fragment.
- */
-static void
-_swrast_update_fog_hint( GLcontext *ctx )
-{
-   SWcontext *swrast = SWRAST_CONTEXT(ctx);
-   swrast->_PreferPixelFog = (!swrast->AllowVertexFog ||
-                              ctx->FragmentProgram._Current ||
-			      (ctx->Hint.Fog == GL_NICEST &&
-			       swrast->AllowPixelFog));
-}
-
-
-
-/**
- * Update the swrast->_TextureCombinePrimary flag.
- */
-static void
-_swrast_update_texture_env( GLcontext *ctx )
-{
-   SWcontext *swrast = SWRAST_CONTEXT(ctx);
-   GLuint i;
-
-   swrast->_TextureCombinePrimary = GL_FALSE;
-
-   for (i = 0; i < ctx->Const.MaxTextureUnits; i++) {
-      const struct gl_tex_env_combine_state *combine =
-         ctx->Texture.Unit[i]._CurrentCombine;
-      GLuint term;
-      for (term = 0; term < combine->_NumArgsRGB; term++) {
-         if (combine->SourceRGB[term] == GL_PRIMARY_COLOR) {
-            swrast->_TextureCombinePrimary = GL_TRUE;
-            return;
-         }
-         if (combine->SourceA[term] == GL_PRIMARY_COLOR) {
-            swrast->_TextureCombinePrimary = GL_TRUE;
-            return;
-         }
-      }
-   }
-}
-
-
-/**
- * Determine if we can defer texturing/shading until after Z/stencil
- * testing.  This potentially allows us to skip texturing/shading for
- * lots of fragments.
- */
-static void
-_swrast_update_deferred_texture(GLcontext *ctx)
-{
-   SWcontext *swrast = SWRAST_CONTEXT(ctx);
-   if (ctx->Color.AlphaEnabled) {
-      /* alpha test depends on post-texture/shader colors */
-      swrast->_DeferredTexture = GL_FALSE;
-   }
-   else {
-      const struct gl_fragment_program *fprog
-         = ctx->FragmentProgram._Current;
-      if (fprog && (fprog->Base.OutputsWritten & (1 << FRAG_RESULT_DEPTH))) {
-         /* Z comes from fragment program/shader */
-         swrast->_DeferredTexture = GL_FALSE;
-      }
-      else if (fprog && fprog->UsesKill) {
-         swrast->_DeferredTexture = GL_FALSE;
-      }
-      else if (ctx->Query.CurrentOcclusionObject) {
-         /* occlusion query depends on shader discard/kill results */
-         swrast->_DeferredTexture = GL_FALSE;
-      }
-      else {
-         swrast->_DeferredTexture = GL_TRUE;
-      }
-   }
-}
-
-
-/**
- * Update swrast->_FogColor and swrast->_FogEnable values.
- */
-static void
-_swrast_update_fog_state( GLcontext *ctx )
-{
-   SWcontext *swrast = SWRAST_CONTEXT(ctx);
-   const struct gl_fragment_program *fp = ctx->FragmentProgram._Current;
-
-   /* determine if fog is needed, and if so, which fog mode */
-   swrast->_FogEnabled = GL_FALSE;
-   if (fp && fp->Base.Target == GL_FRAGMENT_PROGRAM_ARB) {
-      if (fp->FogOption != GL_NONE) {
-         swrast->_FogEnabled = GL_TRUE;
-         swrast->_FogMode = fp->FogOption;
-      }
-   }
-   else if (ctx->Fog.Enabled) {
-      swrast->_FogEnabled = GL_TRUE;
-      swrast->_FogMode = ctx->Fog.Mode;
-   }
-}
-
-
-/**
- * Update state for running fragment programs.  Basically, load the
- * program parameters with current state values.
- */
-static void
-_swrast_update_fragment_program(GLcontext *ctx, GLbitfield newState)
-{
-   const struct gl_fragment_program *fp = ctx->FragmentProgram._Current;
-   if (fp) {
-      _mesa_load_state_parameters(ctx, fp->Base.Parameters);
-   }
-}
-
-
-/**
- * See if we can do early diffuse+specular (primary+secondary) color
- * add per vertex instead of per-fragment.
- */
-static void
-_swrast_update_specular_vertex_add(GLcontext *ctx)
-{
-   SWcontext *swrast = SWRAST_CONTEXT(ctx);
-   GLboolean separateSpecular = ctx->Fog.ColorSumEnabled ||
-      (ctx->Light.Enabled &&
-       ctx->Light.Model.ColorControl == GL_SEPARATE_SPECULAR_COLOR);
-
-   swrast->SpecularVertexAdd = (separateSpecular
-                                && ctx->Texture._EnabledUnits == 0x0
-                                && !ctx->FragmentProgram._Current
-                                && !ctx->ATIFragmentShader._Enabled);
-}
-
-
-#define _SWRAST_NEW_DERIVED (_SWRAST_NEW_RASTERMASK |	\
-                             _NEW_PROGRAM_CONSTANTS |   \
-			     _NEW_TEXTURE |		\
-			     _NEW_HINT |		\
-			     _NEW_POLYGON )
-
-/* State referenced by _swrast_choose_triangle, _swrast_choose_line.
- */
-#define _SWRAST_NEW_TRIANGLE (_SWRAST_NEW_DERIVED |		\
-			      _NEW_RENDERMODE|			\
-                              _NEW_POLYGON|			\
-                              _NEW_DEPTH|			\
-                              _NEW_STENCIL|			\
-                              _NEW_COLOR|			\
-                              _NEW_TEXTURE|			\
-                              _SWRAST_NEW_RASTERMASK|		\
-                              _NEW_LIGHT|			\
-                              _NEW_FOG |			\
-			      _DD_NEW_SEPARATE_SPECULAR)
-
-#define _SWRAST_NEW_LINE (_SWRAST_NEW_DERIVED |		\
-			  _NEW_RENDERMODE|		\
-                          _NEW_LINE|			\
-                          _NEW_TEXTURE|			\
-                          _NEW_LIGHT|			\
-                          _NEW_FOG|			\
-                          _NEW_DEPTH |			\
-                          _DD_NEW_SEPARATE_SPECULAR)
-
-#define _SWRAST_NEW_POINT (_SWRAST_NEW_DERIVED |	\
-			   _NEW_RENDERMODE |		\
-			   _NEW_POINT |			\
-			   _NEW_TEXTURE |		\
-			   _NEW_LIGHT |			\
-			   _NEW_FOG |			\
-                           _DD_NEW_SEPARATE_SPECULAR)
-
-#define _SWRAST_NEW_TEXTURE_SAMPLE_FUNC _NEW_TEXTURE
-
-#define _SWRAST_NEW_TEXTURE_ENV_MODE _NEW_TEXTURE
-
-#define _SWRAST_NEW_BLEND_FUNC _NEW_COLOR
-
-
-
-/**
- * Stub for swrast->Triangle to select a true triangle function
- * after a state change.
- */
-static void
-_swrast_validate_triangle( GLcontext *ctx,
-			   const SWvertex *v0,
-                           const SWvertex *v1,
-                           const SWvertex *v2 )
-{
-   SWcontext *swrast = SWRAST_CONTEXT(ctx);
-
-   _swrast_validate_derived( ctx );
-   swrast->choose_triangle( ctx );
-   ASSERT(swrast->Triangle);
-
-   if (swrast->SpecularVertexAdd) {
-      /* separate specular color, but no texture */
-      swrast->SpecTriangle = swrast->Triangle;
-      swrast->Triangle = _swrast_add_spec_terms_triangle;
-   }
-
-   swrast->Triangle( ctx, v0, v1, v2 );
-}
-
-/**
- * Called via swrast->Line.  Examine current GL state and choose a software
- * line routine.  Then call it.
- */
-static void
-_swrast_validate_line( GLcontext *ctx, const SWvertex *v0, const SWvertex *v1 )
-{
-   SWcontext *swrast = SWRAST_CONTEXT(ctx);
-
-   _swrast_validate_derived( ctx );
-   swrast->choose_line( ctx );
-   ASSERT(swrast->Line);
-
-   if (swrast->SpecularVertexAdd) {
-      swrast->SpecLine = swrast->Line;
-      swrast->Line = _swrast_add_spec_terms_line;
-   }
-
-   swrast->Line( ctx, v0, v1 );
-}
-
-/**
- * Called via swrast->Point.  Examine current GL state and choose a software
- * point routine.  Then call it.
- */
-static void
-_swrast_validate_point( GLcontext *ctx, const SWvertex *v0 )
-{
-   SWcontext *swrast = SWRAST_CONTEXT(ctx);
-
-   _swrast_validate_derived( ctx );
-   swrast->choose_point( ctx );
-
-   if (swrast->SpecularVertexAdd) {
-      swrast->SpecPoint = swrast->Point;
-      swrast->Point = _swrast_add_spec_terms_point;
-   }
-
-   swrast->Point( ctx, v0 );
-}
-
-
-/**
- * Called via swrast->BlendFunc.  Examine GL state to choose a blending
- * function, then call it.
- */
-static void _ASMAPI
-_swrast_validate_blend_func(GLcontext *ctx, GLuint n, const GLubyte mask[],
-                            GLvoid *src, const GLvoid *dst,
-                            GLenum chanType )
-{
-   SWcontext *swrast = SWRAST_CONTEXT(ctx);
-
-   _swrast_validate_derived( ctx ); /* why is this needed? */
-   _swrast_choose_blend_func( ctx, chanType );
-
-   swrast->BlendFunc( ctx, n, mask, src, dst, chanType );
-}
-
-
-/**
- * Make sure we have texture image data for all the textures we may need
- * for subsequent rendering.
- */
-static void
-_swrast_validate_texture_images(GLcontext *ctx)
-{
-   SWcontext *swrast = SWRAST_CONTEXT(ctx);
-   GLuint u;
-
-   if (!swrast->ValidateTextureImage || !ctx->Texture._EnabledUnits) {
-      /* no textures enabled, or no way to validate images! */
-      return;
-   }
-
-   for (u = 0; u < ctx->Const.MaxTextureImageUnits; u++) {
-      if (ctx->Texture.Unit[u]._ReallyEnabled) {
-         struct gl_texture_object *texObj = ctx->Texture.Unit[u]._Current;
-         ASSERT(texObj);
-         if (texObj) {
-            GLuint numFaces = (texObj->Target == GL_TEXTURE_CUBE_MAP) ? 6 : 1;
-            GLuint face;
-            for (face = 0; face < numFaces; face++) {
-               GLint lvl;
-               for (lvl = texObj->BaseLevel; lvl <= texObj->_MaxLevel; lvl++) {
-                  struct gl_texture_image *texImg = texObj->Image[face][lvl];
-                  if (texImg && !texImg->Data) {
-                     swrast->ValidateTextureImage(ctx, texObj, face, lvl);
-                     ASSERT(texObj->Image[face][lvl]->Data);
-                  }
-               }
-            }
-         }
-      }
-   }
-}
-
-
-/**
- * Free the texture image data attached to all currently enabled
- * textures.  Meant to be called by device drivers when transitioning
- * from software to hardware rendering.
- */
-void
-_swrast_eject_texture_images(GLcontext *ctx)
-{
-   GLuint u;
-
-   if (!ctx->Texture._EnabledUnits) {
-      /* no textures enabled */
-      return;
-   }
-
-   for (u = 0; u < ctx->Const.MaxTextureImageUnits; u++) {
-      if (ctx->Texture.Unit[u]._ReallyEnabled) {
-         struct gl_texture_object *texObj = ctx->Texture.Unit[u]._Current;
-         ASSERT(texObj);
-         if (texObj) {
-            GLuint numFaces = (texObj->Target == GL_TEXTURE_CUBE_MAP) ? 6 : 1;
-            GLuint face;
-            for (face = 0; face < numFaces; face++) {
-               GLint lvl;
-               for (lvl = texObj->BaseLevel; lvl <= texObj->_MaxLevel; lvl++) {
-                  struct gl_texture_image *texImg = texObj->Image[face][lvl];
-                  if (texImg && texImg->Data) {
-                     _mesa_free_texmemory(texImg->Data);
-                     texImg->Data = NULL;
-                  }
-               }
-            }
-         }
-      }
-   }
-}
-
-
-
-static void
-_swrast_sleep( GLcontext *ctx, GLbitfield new_state )
-{
-   (void) ctx; (void) new_state;
-}
-
-
-static void
-_swrast_invalidate_state( GLcontext *ctx, GLbitfield new_state )
-{
-   SWcontext *swrast = SWRAST_CONTEXT(ctx);
-   GLuint i;
-
-   swrast->NewState |= new_state;
-
-   /* After 10 statechanges without any swrast functions being called,
-    * put the module to sleep.
-    */
-   if (++swrast->StateChanges > 10) {
-      swrast->InvalidateState = _swrast_sleep;
-      swrast->NewState = ~0;
-      new_state = ~0;
-   }
-
-   if (new_state & swrast->InvalidateTriangleMask)
-      swrast->Triangle = _swrast_validate_triangle;
-
-   if (new_state & swrast->InvalidateLineMask)
-      swrast->Line = _swrast_validate_line;
-
-   if (new_state & swrast->InvalidatePointMask)
-      swrast->Point = _swrast_validate_point;
-
-   if (new_state & _SWRAST_NEW_BLEND_FUNC)
-      swrast->BlendFunc = _swrast_validate_blend_func;
-
-   if (new_state & _SWRAST_NEW_TEXTURE_SAMPLE_FUNC)
-      for (i = 0 ; i < ctx->Const.MaxTextureImageUnits ; i++)
-	 swrast->TextureSample[i] = NULL;
-}
-
-
-void
-_swrast_update_texture_samplers(GLcontext *ctx)
-{
-   SWcontext *swrast = SWRAST_CONTEXT(ctx);
-   GLuint u;
-
-   if (!swrast)
-      return; /* pipe hack */
-
-   for (u = 0; u < ctx->Const.MaxTextureImageUnits; u++) {
-      const struct gl_texture_object *tObj = ctx->Texture.Unit[u]._Current;
-      /* Note: If tObj is NULL, the sample function will be a simple
-       * function that just returns opaque black (0,0,0,1).
-       */
-      swrast->TextureSample[u] = _swrast_choose_texture_sample_func(ctx, tObj);
-   }
-}
-
-
-/**
- * Update swrast->_ActiveAttribs, swrast->_NumActiveAttribs,
- * swrast->_ActiveAtttribMask.
- */
-static void
-_swrast_update_active_attribs(GLcontext *ctx)
-{
-   SWcontext *swrast = SWRAST_CONTEXT(ctx);
-   GLuint attribsMask;
-
-   /*
-    * Compute _ActiveAttribsMask = which fragment attributes are needed.
-    */
-   if (ctx->FragmentProgram._Current) {
-      /* fragment program/shader */
-      attribsMask = ctx->FragmentProgram._Current->Base.InputsRead;
-      attribsMask &= ~FRAG_BIT_WPOS; /* WPOS is always handled specially */
-   }
-   else if (ctx->ATIFragmentShader._Enabled) {
-      attribsMask = ~0;  /* XXX fix me */
-   }
-   else {
-      /* fixed function */
-      attribsMask = 0x0;
-
-#if CHAN_TYPE == GL_FLOAT
-      attribsMask |= FRAG_BIT_COL0;
-#endif
-
-      if (ctx->Fog.ColorSumEnabled ||
-          (ctx->Light.Enabled &&
-           ctx->Light.Model.ColorControl == GL_SEPARATE_SPECULAR_COLOR)) {
-         attribsMask |= FRAG_BIT_COL1;
-      }
-
-      if (swrast->_FogEnabled)
-         attribsMask |= FRAG_BIT_FOGC;
-
-      attribsMask |= (ctx->Texture._EnabledUnits << FRAG_ATTRIB_TEX0);
-   }
-
-   swrast->_ActiveAttribMask = attribsMask;
-
-   /* Update _ActiveAttribs[] list */
-   {
-      GLuint i, num = 0;
-      for (i = 0; i < FRAG_ATTRIB_MAX; i++) {
-         if (attribsMask & (1 << i)) {
-            swrast->_ActiveAttribs[num++] = i;
-            /* how should this attribute be interpolated? */
-            if (i == FRAG_ATTRIB_COL0 || i == FRAG_ATTRIB_COL1)
-               swrast->_InterpMode[i] = ctx->Light.ShadeModel;
-            else
-               swrast->_InterpMode[i] = GL_SMOOTH;
-         }
-      }
-      swrast->_NumActiveAttribs = num;
-   }
-}
-
-
-void
-_swrast_validate_derived( GLcontext *ctx )
-{
-   SWcontext *swrast = SWRAST_CONTEXT(ctx);
-
-   if (swrast->NewState) {
-      if (swrast->NewState & _NEW_POLYGON)
-	 _swrast_update_polygon( ctx );
-
-      if (swrast->NewState & (_NEW_HINT | _NEW_PROGRAM))
-	 _swrast_update_fog_hint( ctx );
-
-      if (swrast->NewState & _SWRAST_NEW_TEXTURE_ENV_MODE)
-	 _swrast_update_texture_env( ctx );
-
-      if (swrast->NewState & (_NEW_FOG | _NEW_PROGRAM))
-         _swrast_update_fog_state( ctx );
-
-      if (swrast->NewState & (_NEW_PROGRAM_CONSTANTS | _NEW_PROGRAM))
-	 _swrast_update_fragment_program( ctx, swrast->NewState );
-
-      if (swrast->NewState & (_NEW_TEXTURE | _NEW_PROGRAM)) {
-         _swrast_update_texture_samplers( ctx );
-         _swrast_validate_texture_images(ctx);
-      }
-
-      if (swrast->NewState & (_NEW_COLOR | _NEW_PROGRAM))
-         _swrast_update_deferred_texture(ctx);
-
-      if (swrast->NewState & _SWRAST_NEW_RASTERMASK)
- 	 _swrast_update_rasterflags( ctx );
-
-      if (swrast->NewState & (_NEW_DEPTH |
-                              _NEW_FOG |
-                              _NEW_LIGHT |
-                              _NEW_PROGRAM |
-                              _NEW_TEXTURE))
-         _swrast_update_active_attribs(ctx);
-
-      if (swrast->NewState & (_NEW_FOG | 
-                              _NEW_PROGRAM |
-                              _NEW_LIGHT |
-                              _NEW_TEXTURE))
-         _swrast_update_specular_vertex_add(ctx);
-
-      swrast->NewState = 0;
-      swrast->StateChanges = 0;
-      swrast->InvalidateState = _swrast_invalidate_state;
-   }
-}
-
-#define SWRAST_DEBUG 0
-
-/* Public entrypoints:  See also s_accum.c, s_bitmap.c, etc.
- */
-void
-_swrast_Quad( GLcontext *ctx,
-	      const SWvertex *v0, const SWvertex *v1,
-              const SWvertex *v2, const SWvertex *v3 )
-{
-   if (SWRAST_DEBUG) {
-      _mesa_debug(ctx, "_swrast_Quad\n");
-      _swrast_print_vertex( ctx, v0 );
-      _swrast_print_vertex( ctx, v1 );
-      _swrast_print_vertex( ctx, v2 );
-      _swrast_print_vertex( ctx, v3 );
-   }
-   SWRAST_CONTEXT(ctx)->Triangle( ctx, v0, v1, v3 );
-   SWRAST_CONTEXT(ctx)->Triangle( ctx, v1, v2, v3 );
-}
-
-void
-_swrast_Triangle( GLcontext *ctx, const SWvertex *v0,
-                  const SWvertex *v1, const SWvertex *v2 )
-{
-   if (SWRAST_DEBUG) {
-      _mesa_debug(ctx, "_swrast_Triangle\n");
-      _swrast_print_vertex( ctx, v0 );
-      _swrast_print_vertex( ctx, v1 );
-      _swrast_print_vertex( ctx, v2 );
-   }
-   SWRAST_CONTEXT(ctx)->Triangle( ctx, v0, v1, v2 );
-}
-
-void
-_swrast_Line( GLcontext *ctx, const SWvertex *v0, const SWvertex *v1 )
-{
-   if (SWRAST_DEBUG) {
-      _mesa_debug(ctx, "_swrast_Line\n");
-      _swrast_print_vertex( ctx, v0 );
-      _swrast_print_vertex( ctx, v1 );
-   }
-   SWRAST_CONTEXT(ctx)->Line( ctx, v0, v1 );
-}
-
-void
-_swrast_Point( GLcontext *ctx, const SWvertex *v0 )
-{
-   if (SWRAST_DEBUG) {
-      _mesa_debug(ctx, "_swrast_Point\n");
-      _swrast_print_vertex( ctx, v0 );
-   }
-   SWRAST_CONTEXT(ctx)->Point( ctx, v0 );
-}
-
-void
-_swrast_InvalidateState( GLcontext *ctx, GLbitfield new_state )
-{
-   if (SWRAST_DEBUG) {
-      _mesa_debug(ctx, "_swrast_InvalidateState\n");
-   }
-   SWRAST_CONTEXT(ctx)->InvalidateState( ctx, new_state );
-}
-
-void
-_swrast_ResetLineStipple( GLcontext *ctx )
-{
-   if (SWRAST_DEBUG) {
-      _mesa_debug(ctx, "_swrast_ResetLineStipple\n");
-   }
-   SWRAST_CONTEXT(ctx)->StippleCounter = 0;
-}
-
-void
-_swrast_SetFacing(GLcontext *ctx, GLuint facing)
-{
-   SWRAST_CONTEXT(ctx)->PointLineFacing = facing;
-}
-
-void
-_swrast_allow_vertex_fog( GLcontext *ctx, GLboolean value )
-{
-   if (SWRAST_DEBUG) {
-      _mesa_debug(ctx, "_swrast_allow_vertex_fog %d\n", value);
-   }
-   SWRAST_CONTEXT(ctx)->InvalidateState( ctx, _NEW_HINT );
-   SWRAST_CONTEXT(ctx)->AllowVertexFog = value;
-}
-
-void
-_swrast_allow_pixel_fog( GLcontext *ctx, GLboolean value )
-{
-   if (SWRAST_DEBUG) {
-      _mesa_debug(ctx, "_swrast_allow_pixel_fog %d\n", value);
-   }
-   SWRAST_CONTEXT(ctx)->InvalidateState( ctx, _NEW_HINT );
-   SWRAST_CONTEXT(ctx)->AllowPixelFog = value;
-}
-
-
-GLboolean
-_swrast_CreateContext( GLcontext *ctx )
-{
-   GLuint i;
-   SWcontext *swrast = (SWcontext *)CALLOC(sizeof(SWcontext));
-
-   if (SWRAST_DEBUG) {
-      _mesa_debug(ctx, "_swrast_CreateContext\n");
-   }
-
-   if (!swrast)
-      return GL_FALSE;
-
-   swrast->NewState = ~0;
-
-   swrast->choose_point = _swrast_choose_point;
-   swrast->choose_line = _swrast_choose_line;
-   swrast->choose_triangle = _swrast_choose_triangle;
-
-   swrast->InvalidatePointMask = _SWRAST_NEW_POINT;
-   swrast->InvalidateLineMask = _SWRAST_NEW_LINE;
-   swrast->InvalidateTriangleMask = _SWRAST_NEW_TRIANGLE;
-
-   swrast->Point = _swrast_validate_point;
-   swrast->Line = _swrast_validate_line;
-   swrast->Triangle = _swrast_validate_triangle;
-   swrast->InvalidateState = _swrast_sleep;
-   swrast->BlendFunc = _swrast_validate_blend_func;
-
-   swrast->AllowVertexFog = GL_TRUE;
-   swrast->AllowPixelFog = GL_TRUE;
-
-   /* Optimized Accum buffer */
-   swrast->_IntegerAccumMode = GL_FALSE;
-   swrast->_IntegerAccumScaler = 0.0;
-
-   for (i = 0; i < MAX_TEXTURE_IMAGE_UNITS; i++)
-      swrast->TextureSample[i] = NULL;
-
-   swrast->SpanArrays = MALLOC_STRUCT(sw_span_arrays);
-   if (!swrast->SpanArrays) {
-      FREE(swrast);
-      return GL_FALSE;
-   }
-   swrast->SpanArrays->ChanType = CHAN_TYPE;
-#if CHAN_TYPE == GL_UNSIGNED_BYTE
-   swrast->SpanArrays->rgba = swrast->SpanArrays->rgba8;
-#elif CHAN_TYPE == GL_UNSIGNED_SHORT
-   swrast->SpanArrays->rgba = swrast->SpanArrays->rgba16;
-#else
-   swrast->SpanArrays->rgba = swrast->SpanArrays->attribs[FRAG_ATTRIB_COL0];
-#endif
-
-   /* init point span buffer */
-   swrast->PointSpan.primitive = GL_POINT;
-   swrast->PointSpan.end = 0;
-   swrast->PointSpan.facing = 0;
-   swrast->PointSpan.array = swrast->SpanArrays;
-
-   swrast->TexelBuffer = (GLfloat *) MALLOC(ctx->Const.MaxTextureImageUnits *
-                                           MAX_WIDTH * 4 * sizeof(GLfloat));
-   if (!swrast->TexelBuffer) {
-      FREE(swrast->SpanArrays);
-      FREE(swrast);
-      return GL_FALSE;
-   }
-
-   ctx->swrast_context = swrast;
-
-   return GL_TRUE;
-}
-
-void
-_swrast_DestroyContext( GLcontext *ctx )
-{
-   SWcontext *swrast = SWRAST_CONTEXT(ctx);
-
-   if (SWRAST_DEBUG) {
-      _mesa_debug(ctx, "_swrast_DestroyContext\n");
-   }
-
-   FREE( swrast->SpanArrays );
-   if (swrast->ZoomedArrays)
-      FREE( swrast->ZoomedArrays );
-   FREE( swrast->TexelBuffer );
-   FREE( swrast );
-
-   ctx->swrast_context = 0;
-}
-
-
-struct swrast_device_driver *
-_swrast_GetDeviceDriverReference( GLcontext *ctx )
-{
-   SWcontext *swrast = SWRAST_CONTEXT(ctx);
-   return &swrast->Driver;
-}
-
-void
-_swrast_flush( GLcontext *ctx )
-{
-   SWcontext *swrast = SWRAST_CONTEXT(ctx);
-   /* flush any pending fragments from rendering points */
-   if (swrast->PointSpan.end > 0) {
-      _swrast_write_rgba_span(ctx, &(swrast->PointSpan));
-      swrast->PointSpan.end = 0;
-   }
-}
-
-void
-_swrast_render_primitive( GLcontext *ctx, GLenum prim )
-{
-   SWcontext *swrast = SWRAST_CONTEXT(ctx);
-   if (swrast->Primitive == GL_POINTS && prim != GL_POINTS) {
-      _swrast_flush(ctx);
-   }
-   swrast->Primitive = prim;
-}
-
-
-void
-_swrast_render_start( GLcontext *ctx )
-{
-   SWcontext *swrast = SWRAST_CONTEXT(ctx);
-   if (swrast->Driver.SpanRenderStart)
-      swrast->Driver.SpanRenderStart( ctx );
-   swrast->PointSpan.end = 0;
-}
- 
-void
-_swrast_render_finish( GLcontext *ctx )
-{
-   SWcontext *swrast = SWRAST_CONTEXT(ctx);
-   if (swrast->Driver.SpanRenderFinish)
-      swrast->Driver.SpanRenderFinish( ctx );
-
-   _swrast_flush(ctx);
-}
-
-
-#define SWRAST_DEBUG_VERTICES 0
-
-void
-_swrast_print_vertex( GLcontext *ctx, const SWvertex *v )
-{
-   GLuint i;
-
-   if (SWRAST_DEBUG_VERTICES) {
-      _mesa_debug(ctx, "win %f %f %f %f\n",
-                  v->attrib[FRAG_ATTRIB_WPOS][0],
-                  v->attrib[FRAG_ATTRIB_WPOS][1],
-                  v->attrib[FRAG_ATTRIB_WPOS][2],
-                  v->attrib[FRAG_ATTRIB_WPOS][3]);
-
-      for (i = 0 ; i < ctx->Const.MaxTextureCoordUnits ; i++)
-	 if (ctx->Texture.Unit[i]._ReallyEnabled)
-	    _mesa_debug(ctx, "texcoord[%d] %f %f %f %f\n", i,
-                        v->attrib[FRAG_ATTRIB_TEX0 + i][0],
-                        v->attrib[FRAG_ATTRIB_TEX0 + i][1],
-                        v->attrib[FRAG_ATTRIB_TEX0 + i][2],
-                        v->attrib[FRAG_ATTRIB_TEX0 + i][3]);
-
-#if CHAN_TYPE == GL_FLOAT
-      _mesa_debug(ctx, "color %f %f %f %f\n",
-                  v->color[0], v->color[1], v->color[2], v->color[3]);
-#else
-      _mesa_debug(ctx, "color %d %d %d %d\n",
-                  v->color[0], v->color[1], v->color[2], v->color[3]);
-#endif
-      _mesa_debug(ctx, "spec %g %g %g %g\n",
-                  v->attrib[FRAG_ATTRIB_COL1][0],
-                  v->attrib[FRAG_ATTRIB_COL1][1],
-                  v->attrib[FRAG_ATTRIB_COL1][2],
-                  v->attrib[FRAG_ATTRIB_COL1][3]);
-      _mesa_debug(ctx, "fog %f\n", v->attrib[FRAG_ATTRIB_FOGC][0]);
-      _mesa_debug(ctx, "index %f\n", v->attrib[FRAG_ATTRIB_CI][0]);
-      _mesa_debug(ctx, "pointsize %f\n", v->pointSize);
-      _mesa_debug(ctx, "\n");
-   }
-}
+/*

+ * Mesa 3-D graphics library

+ * Version:  7.1

+ *

+ * Copyright (C) 1999-2008  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.

+ *

+ * Authors:

+ *    Keith Whitwell <keith@tungstengraphics.com>

+ *    Brian Paul

+ */

+

+#include "main/imports.h"

+#include "main/bufferobj.h"

+#include "main/colormac.h"

+#include "main/mtypes.h"

+#include "main/teximage.h"

+#include "program/prog_parameter.h"

+#include "program/prog_statevars.h"

+#include "swrast.h"

+#include "s_blend.h"

+#include "s_context.h"

+#include "s_lines.h"

+#include "s_points.h"

+#include "s_span.h"

+#include "s_triangle.h"

+#include "s_texfilter.h"

+

+

+/**

+ * Recompute the value of swrast->_RasterMask, etc. according to

+ * the current context.  The _RasterMask field can be easily tested by

+ * drivers to determine certain basic GL state (does the primitive need

+ * stenciling, logic-op, fog, etc?).

+ */

+static void

+_swrast_update_rasterflags( struct gl_context *ctx )

+{

+   SWcontext *swrast = SWRAST_CONTEXT(ctx);

+   GLbitfield rasterMask = 0;

+   GLuint i;

+

+   if (ctx->Color.AlphaEnabled)           rasterMask |= ALPHATEST_BIT;

+   if (ctx->Color.BlendEnabled)           rasterMask |= BLEND_BIT;

+   if (ctx->Depth.Test)                   rasterMask |= DEPTH_BIT;

+   if (swrast->_FogEnabled)               rasterMask |= FOG_BIT;

+   if (ctx->Scissor.Enabled)              rasterMask |= CLIP_BIT;

+   if (ctx->Stencil._Enabled)             rasterMask |= STENCIL_BIT;

+   for (i = 0; i < ctx->Const.MaxDrawBuffers; i++) {

+      if (!ctx->Color.ColorMask[i][0] ||

+          !ctx->Color.ColorMask[i][1] ||

+          !ctx->Color.ColorMask[i][2] ||

+          !ctx->Color.ColorMask[i][3]) {

+         rasterMask |= MASKING_BIT;

+         break;

+      }

+   }

+   if (ctx->Color._LogicOpEnabled)     rasterMask |= LOGIC_OP_BIT;

+   if (ctx->Texture._EnabledUnits)     rasterMask |= TEXTURE_BIT;

+   if (   ctx->Viewport.X < 0

+       || ctx->Viewport.X + ctx->Viewport.Width > (GLint) ctx->DrawBuffer->Width

+       || ctx->Viewport.Y < 0

+       || ctx->Viewport.Y + ctx->Viewport.Height > (GLint) ctx->DrawBuffer->Height) {

+      rasterMask |= CLIP_BIT;

+   }

+

+   if (ctx->Query.CurrentOcclusionObject)

+      rasterMask |= OCCLUSION_BIT;

+

+

+   /* If we're not drawing to exactly one color buffer set the

+    * MULTI_DRAW_BIT flag.  Also set it if we're drawing to no

+    * buffers or the RGBA or CI mask disables all writes.

+    */

+   if (ctx->DrawBuffer->_NumColorDrawBuffers != 1) {

+      /* more than one color buffer designated for writing (or zero buffers) */

+      rasterMask |= MULTI_DRAW_BIT;

+   }

+

+   for (i = 0; i < ctx->Const.MaxDrawBuffers; i++) {

+      if (ctx->Color.ColorMask[i][0] +

+          ctx->Color.ColorMask[i][1] +

+          ctx->Color.ColorMask[i][2] +

+          ctx->Color.ColorMask[i][3] == 0) {

+         rasterMask |= MULTI_DRAW_BIT; /* all RGBA channels disabled */

+         break;

+      }

+   }

+

+

+   if (ctx->FragmentProgram._Current) {

+      rasterMask |= FRAGPROG_BIT;

+   }

+

+   if (ctx->ATIFragmentShader._Enabled) {

+      rasterMask |= ATIFRAGSHADER_BIT;

+   }

+

+#if CHAN_TYPE == GL_FLOAT

+   if (ctx->Color.ClampFragmentColor == GL_TRUE) {

+      rasterMask |= CLAMPING_BIT;

+   }

+#endif

+

+   SWRAST_CONTEXT(ctx)->_RasterMask = rasterMask;

+}

+

+

+/**

+ * Examine polygon cull state to compute the _BackfaceCullSign field.

+ * _BackfaceCullSign will be 0 if no culling, -1 if culling back-faces,

+ * and 1 if culling front-faces.  The Polygon FrontFace state also

+ * factors in.

+ */

+static void

+_swrast_update_polygon( struct gl_context *ctx )

+{

+   GLfloat backface_sign;

+

+   if (ctx->Polygon.CullFlag) {

+      switch (ctx->Polygon.CullFaceMode) {

+      case GL_BACK:

+         backface_sign = -1.0F;

+	 break;

+      case GL_FRONT:

+         backface_sign = 1.0F;

+	 break;

+      case GL_FRONT_AND_BACK:

+         /* fallthrough */

+      default:

+	 backface_sign = 0.0F;

+      }

+   }

+   else {

+      backface_sign = 0.0F;

+   }

+

+   SWRAST_CONTEXT(ctx)->_BackfaceCullSign = backface_sign;

+

+   /* This is for front/back-face determination, but not for culling */

+   SWRAST_CONTEXT(ctx)->_BackfaceSign

+      = (ctx->Polygon.FrontFace == GL_CW) ? -1.0F : 1.0F;

+}

+

+

+

+/**

+ * Update the _PreferPixelFog field to indicate if we need to compute

+ * fog blend factors (from the fog coords) per-fragment.

+ */

+static void

+_swrast_update_fog_hint( struct gl_context *ctx )

+{

+   SWcontext *swrast = SWRAST_CONTEXT(ctx);

+   swrast->_PreferPixelFog = (!swrast->AllowVertexFog ||

+                              ctx->FragmentProgram._Current ||

+			      (ctx->Hint.Fog == GL_NICEST &&

+			       swrast->AllowPixelFog));

+}

+

+

+

+/**

+ * Update the swrast->_TextureCombinePrimary flag.

+ */

+static void

+_swrast_update_texture_env( struct gl_context *ctx )

+{

+   SWcontext *swrast = SWRAST_CONTEXT(ctx);

+   GLuint i;

+

+   swrast->_TextureCombinePrimary = GL_FALSE;

+

+   for (i = 0; i < ctx->Const.MaxTextureUnits; i++) {

+      const struct gl_tex_env_combine_state *combine =

+         ctx->Texture.Unit[i]._CurrentCombine;

+      GLuint term;

+      for (term = 0; term < combine->_NumArgsRGB; term++) {

+         if (combine->SourceRGB[term] == GL_PRIMARY_COLOR) {

+            swrast->_TextureCombinePrimary = GL_TRUE;

+            return;

+         }

+         if (combine->SourceA[term] == GL_PRIMARY_COLOR) {

+            swrast->_TextureCombinePrimary = GL_TRUE;

+            return;

+         }

+      }

+   }

+}

+

+

+/**

+ * Determine if we can defer texturing/shading until after Z/stencil

+ * testing.  This potentially allows us to skip texturing/shading for

+ * lots of fragments.

+ */

+static void

+_swrast_update_deferred_texture(struct gl_context *ctx)

+{

+   SWcontext *swrast = SWRAST_CONTEXT(ctx);

+   if (ctx->Color.AlphaEnabled) {

+      /* alpha test depends on post-texture/shader colors */

+      swrast->_DeferredTexture = GL_FALSE;

+   }

+   else {

+      const struct gl_fragment_program *fprog

+         = ctx->FragmentProgram._Current;

+      if (fprog && (fprog->Base.OutputsWritten & (1 << FRAG_RESULT_DEPTH))) {

+         /* Z comes from fragment program/shader */

+         swrast->_DeferredTexture = GL_FALSE;

+      }

+      else if (fprog && fprog->UsesKill) {

+         swrast->_DeferredTexture = GL_FALSE;

+      }

+      else if (ctx->Query.CurrentOcclusionObject) {

+         /* occlusion query depends on shader discard/kill results */

+         swrast->_DeferredTexture = GL_FALSE;

+      }

+      else {

+         swrast->_DeferredTexture = GL_TRUE;

+      }

+   }

+}

+

+

+/**

+ * Update swrast->_FogColor and swrast->_FogEnable values.

+ */

+static void

+_swrast_update_fog_state( struct gl_context *ctx )

+{

+   SWcontext *swrast = SWRAST_CONTEXT(ctx);

+   const struct gl_fragment_program *fp = ctx->FragmentProgram._Current;

+

+   /* determine if fog is needed, and if so, which fog mode */

+   swrast->_FogEnabled = GL_FALSE;

+   if (fp && fp->Base.Target == GL_FRAGMENT_PROGRAM_ARB) {

+      if (fp->FogOption != GL_NONE) {

+         swrast->_FogEnabled = GL_TRUE;

+         swrast->_FogMode = fp->FogOption;

+      }

+   }

+   else if (ctx->Fog.Enabled) {

+      swrast->_FogEnabled = GL_TRUE;

+      swrast->_FogMode = ctx->Fog.Mode;

+   }

+}

+

+

+/**

+ * Update state for running fragment programs.  Basically, load the

+ * program parameters with current state values.

+ */

+static void

+_swrast_update_fragment_program(struct gl_context *ctx, GLbitfield newState)

+{

+   const struct gl_fragment_program *fp = ctx->FragmentProgram._Current;

+   if (fp) {

+      _mesa_load_state_parameters(ctx, fp->Base.Parameters);

+   }

+}

+

+

+/**

+ * See if we can do early diffuse+specular (primary+secondary) color

+ * add per vertex instead of per-fragment.

+ */

+static void

+_swrast_update_specular_vertex_add(struct gl_context *ctx)

+{

+   SWcontext *swrast = SWRAST_CONTEXT(ctx);

+   GLboolean separateSpecular = ctx->Fog.ColorSumEnabled ||

+      (ctx->Light.Enabled &&

+       ctx->Light.Model.ColorControl == GL_SEPARATE_SPECULAR_COLOR);

+

+   swrast->SpecularVertexAdd = (separateSpecular

+                                && ctx->Texture._EnabledUnits == 0x0

+                                && !ctx->FragmentProgram._Current

+                                && !ctx->ATIFragmentShader._Enabled);

+}

+

+

+#define _SWRAST_NEW_DERIVED (_SWRAST_NEW_RASTERMASK |	\

+                             _NEW_PROGRAM_CONSTANTS |   \

+			     _NEW_TEXTURE |		\

+			     _NEW_HINT |		\

+			     _NEW_POLYGON )

+

+/* State referenced by _swrast_choose_triangle, _swrast_choose_line.

+ */

+#define _SWRAST_NEW_TRIANGLE (_SWRAST_NEW_DERIVED |		\

+			      _NEW_RENDERMODE|			\

+                              _NEW_POLYGON|			\

+                              _NEW_DEPTH|			\

+                              _NEW_STENCIL|			\

+                              _NEW_COLOR|			\

+                              _NEW_TEXTURE|			\

+                              _SWRAST_NEW_RASTERMASK|		\

+                              _NEW_LIGHT|			\

+                              _NEW_FOG |			\

+			      _DD_NEW_SEPARATE_SPECULAR)

+

+#define _SWRAST_NEW_LINE (_SWRAST_NEW_DERIVED |		\

+			  _NEW_RENDERMODE|		\

+                          _NEW_LINE|			\

+                          _NEW_TEXTURE|			\

+                          _NEW_LIGHT|			\

+                          _NEW_FOG|			\

+                          _NEW_DEPTH |			\

+                          _DD_NEW_SEPARATE_SPECULAR)

+

+#define _SWRAST_NEW_POINT (_SWRAST_NEW_DERIVED |	\

+			   _NEW_RENDERMODE |		\

+			   _NEW_POINT |			\

+			   _NEW_TEXTURE |		\

+			   _NEW_LIGHT |			\

+			   _NEW_FOG |			\

+                           _DD_NEW_SEPARATE_SPECULAR)

+

+#define _SWRAST_NEW_TEXTURE_SAMPLE_FUNC _NEW_TEXTURE

+

+#define _SWRAST_NEW_TEXTURE_ENV_MODE _NEW_TEXTURE

+

+#define _SWRAST_NEW_BLEND_FUNC _NEW_COLOR

+

+

+

+/**

+ * Stub for swrast->Triangle to select a true triangle function

+ * after a state change.

+ */

+static void

+_swrast_validate_triangle( struct gl_context *ctx,

+			   const SWvertex *v0,

+                           const SWvertex *v1,

+                           const SWvertex *v2 )

+{

+   SWcontext *swrast = SWRAST_CONTEXT(ctx);

+

+   _swrast_validate_derived( ctx );

+   swrast->choose_triangle( ctx );

+   ASSERT(swrast->Triangle);

+

+   if (swrast->SpecularVertexAdd) {

+      /* separate specular color, but no texture */

+      swrast->SpecTriangle = swrast->Triangle;

+      swrast->Triangle = _swrast_add_spec_terms_triangle;

+   }

+

+   swrast->Triangle( ctx, v0, v1, v2 );

+}

+

+/**

+ * Called via swrast->Line.  Examine current GL state and choose a software

+ * line routine.  Then call it.

+ */

+static void

+_swrast_validate_line( struct gl_context *ctx, const SWvertex *v0, const SWvertex *v1 )

+{

+   SWcontext *swrast = SWRAST_CONTEXT(ctx);

+

+   _swrast_validate_derived( ctx );

+   swrast->choose_line( ctx );

+   ASSERT(swrast->Line);

+

+   if (swrast->SpecularVertexAdd) {

+      swrast->SpecLine = swrast->Line;

+      swrast->Line = _swrast_add_spec_terms_line;

+   }

+

+   swrast->Line( ctx, v0, v1 );

+}

+

+/**

+ * Called via swrast->Point.  Examine current GL state and choose a software

+ * point routine.  Then call it.

+ */

+static void

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

+{

+   SWcontext *swrast = SWRAST_CONTEXT(ctx);

+

+   _swrast_validate_derived( ctx );

+   swrast->choose_point( ctx );

+

+   if (swrast->SpecularVertexAdd) {

+      swrast->SpecPoint = swrast->Point;

+      swrast->Point = _swrast_add_spec_terms_point;

+   }

+

+   swrast->Point( ctx, v0 );

+}

+

+

+/**

+ * Called via swrast->BlendFunc.  Examine GL state to choose a blending

+ * function, then call it.

+ */

+static void _ASMAPI

+_swrast_validate_blend_func(struct gl_context *ctx, GLuint n, const GLubyte mask[],

+                            GLvoid *src, const GLvoid *dst,

+                            GLenum chanType )

+{

+   SWcontext *swrast = SWRAST_CONTEXT(ctx);

+

+   _swrast_validate_derived( ctx ); /* why is this needed? */

+   _swrast_choose_blend_func( ctx, chanType );

+

+   swrast->BlendFunc( ctx, n, mask, src, dst, chanType );

+}

+

+

+/**

+ * Make sure we have texture image data for all the textures we may need

+ * for subsequent rendering.

+ */

+static void

+_swrast_validate_texture_images(struct gl_context *ctx)

+{

+   SWcontext *swrast = SWRAST_CONTEXT(ctx);

+   GLuint u;

+

+   if (!swrast->ValidateTextureImage || !ctx->Texture._EnabledUnits) {

+      /* no textures enabled, or no way to validate images! */

+      return;

+   }

+

+   for (u = 0; u < ctx->Const.MaxTextureImageUnits; u++) {

+      if (ctx->Texture.Unit[u]._ReallyEnabled) {

+         struct gl_texture_object *texObj = ctx->Texture.Unit[u]._Current;

+         ASSERT(texObj);

+         if (texObj) {

+            GLuint numFaces = (texObj->Target == GL_TEXTURE_CUBE_MAP) ? 6 : 1;

+            GLuint face;

+            for (face = 0; face < numFaces; face++) {

+               GLint lvl;

+               for (lvl = texObj->BaseLevel; lvl <= texObj->_MaxLevel; lvl++) {

+                  struct gl_texture_image *texImg = texObj->Image[face][lvl];

+                  if (texImg && !texImg->Data) {

+                     swrast->ValidateTextureImage(ctx, texObj, face, lvl);

+                     ASSERT(texObj->Image[face][lvl]->Data);

+                  }

+               }

+            }

+         }

+      }

+   }

+}

+

+

+/**

+ * Free the texture image data attached to all currently enabled

+ * textures.  Meant to be called by device drivers when transitioning

+ * from software to hardware rendering.

+ */

+void

+_swrast_eject_texture_images(struct gl_context *ctx)

+{

+   GLuint u;

+

+   if (!ctx->Texture._EnabledUnits) {

+      /* no textures enabled */

+      return;

+   }

+

+   for (u = 0; u < ctx->Const.MaxTextureImageUnits; u++) {

+      if (ctx->Texture.Unit[u]._ReallyEnabled) {

+         struct gl_texture_object *texObj = ctx->Texture.Unit[u]._Current;

+         ASSERT(texObj);

+         if (texObj) {

+            GLuint numFaces = (texObj->Target == GL_TEXTURE_CUBE_MAP) ? 6 : 1;

+            GLuint face;

+            for (face = 0; face < numFaces; face++) {

+               GLint lvl;

+               for (lvl = texObj->BaseLevel; lvl <= texObj->_MaxLevel; lvl++) {

+                  struct gl_texture_image *texImg = texObj->Image[face][lvl];

+                  if (texImg && texImg->Data) {

+                     _mesa_free_texmemory(texImg->Data);

+                     texImg->Data = NULL;

+                  }

+               }

+            }

+         }

+      }

+   }

+}

+

+

+

+static void

+_swrast_sleep( struct gl_context *ctx, GLbitfield new_state )

+{

+   (void) ctx; (void) new_state;

+}

+

+

+static void

+_swrast_invalidate_state( struct gl_context *ctx, GLbitfield new_state )

+{

+   SWcontext *swrast = SWRAST_CONTEXT(ctx);

+   GLuint i;

+

+   swrast->NewState |= new_state;

+

+   /* After 10 statechanges without any swrast functions being called,

+    * put the module to sleep.

+    */

+   if (++swrast->StateChanges > 10) {

+      swrast->InvalidateState = _swrast_sleep;

+      swrast->NewState = ~0;

+      new_state = ~0;

+   }

+

+   if (new_state & swrast->InvalidateTriangleMask)

+      swrast->Triangle = _swrast_validate_triangle;

+

+   if (new_state & swrast->InvalidateLineMask)

+      swrast->Line = _swrast_validate_line;

+

+   if (new_state & swrast->InvalidatePointMask)

+      swrast->Point = _swrast_validate_point;

+

+   if (new_state & _SWRAST_NEW_BLEND_FUNC)

+      swrast->BlendFunc = _swrast_validate_blend_func;

+

+   if (new_state & _SWRAST_NEW_TEXTURE_SAMPLE_FUNC)

+      for (i = 0 ; i < ctx->Const.MaxTextureImageUnits ; i++)

+	 swrast->TextureSample[i] = NULL;

+}

+

+

+void

+_swrast_update_texture_samplers(struct gl_context *ctx)

+{

+   SWcontext *swrast = SWRAST_CONTEXT(ctx);

+   GLuint u;

+

+   if (!swrast)

+      return; /* pipe hack */

+

+   for (u = 0; u < ctx->Const.MaxTextureImageUnits; u++) {

+      const struct gl_texture_object *tObj = ctx->Texture.Unit[u]._Current;

+      /* Note: If tObj is NULL, the sample function will be a simple

+       * function that just returns opaque black (0,0,0,1).

+       */

+      swrast->TextureSample[u] = _swrast_choose_texture_sample_func(ctx, tObj);

+   }

+}

+

+

+/**

+ * Update swrast->_ActiveAttribs, swrast->_NumActiveAttribs,

+ * swrast->_ActiveAtttribMask.

+ */

+static void

+_swrast_update_active_attribs(struct gl_context *ctx)

+{

+   SWcontext *swrast = SWRAST_CONTEXT(ctx);

+   GLuint attribsMask;

+

+   /*

+    * Compute _ActiveAttribsMask = which fragment attributes are needed.

+    */

+   if (ctx->FragmentProgram._Current) {

+      /* fragment program/shader */

+      attribsMask = ctx->FragmentProgram._Current->Base.InputsRead;

+      attribsMask &= ~FRAG_BIT_WPOS; /* WPOS is always handled specially */

+   }

+   else if (ctx->ATIFragmentShader._Enabled) {

+      attribsMask = ~0;  /* XXX fix me */

+   }

+   else {

+      /* fixed function */

+      attribsMask = 0x0;

+

+#if CHAN_TYPE == GL_FLOAT

+      attribsMask |= FRAG_BIT_COL0;

+#endif

+

+      if (ctx->Fog.ColorSumEnabled ||

+          (ctx->Light.Enabled &&

+           ctx->Light.Model.ColorControl == GL_SEPARATE_SPECULAR_COLOR)) {

+         attribsMask |= FRAG_BIT_COL1;

+      }

+

+      if (swrast->_FogEnabled)

+         attribsMask |= FRAG_BIT_FOGC;

+

+      attribsMask |= (ctx->Texture._EnabledUnits << FRAG_ATTRIB_TEX0);

+   }

+

+   swrast->_ActiveAttribMask = attribsMask;

+

+   /* Update _ActiveAttribs[] list */

+   {

+      GLuint i, num = 0;

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

+         if (attribsMask & (1 << i)) {

+            swrast->_ActiveAttribs[num++] = i;

+            /* how should this attribute be interpolated? */

+            if (i == FRAG_ATTRIB_COL0 || i == FRAG_ATTRIB_COL1)

+               swrast->_InterpMode[i] = ctx->Light.ShadeModel;

+            else

+               swrast->_InterpMode[i] = GL_SMOOTH;

+         }

+      }

+      swrast->_NumActiveAttribs = num;

+   }

+}

+

+

+void

+_swrast_validate_derived( struct gl_context *ctx )

+{

+   SWcontext *swrast = SWRAST_CONTEXT(ctx);

+

+   if (swrast->NewState) {

+      if (swrast->NewState & _NEW_POLYGON)

+	 _swrast_update_polygon( ctx );

+

+      if (swrast->NewState & (_NEW_HINT | _NEW_PROGRAM))

+	 _swrast_update_fog_hint( ctx );

+

+      if (swrast->NewState & _SWRAST_NEW_TEXTURE_ENV_MODE)

+	 _swrast_update_texture_env( ctx );

+

+      if (swrast->NewState & (_NEW_FOG | _NEW_PROGRAM))

+         _swrast_update_fog_state( ctx );

+

+      if (swrast->NewState & (_NEW_PROGRAM_CONSTANTS | _NEW_PROGRAM))

+	 _swrast_update_fragment_program( ctx, swrast->NewState );

+

+      if (swrast->NewState & (_NEW_TEXTURE | _NEW_PROGRAM)) {

+         _swrast_update_texture_samplers( ctx );

+         _swrast_validate_texture_images(ctx);

+      }

+

+      if (swrast->NewState & (_NEW_COLOR | _NEW_PROGRAM))

+         _swrast_update_deferred_texture(ctx);

+

+      if (swrast->NewState & _SWRAST_NEW_RASTERMASK)

+ 	 _swrast_update_rasterflags( ctx );

+

+      if (swrast->NewState & (_NEW_DEPTH |

+                              _NEW_FOG |

+                              _NEW_LIGHT |

+                              _NEW_PROGRAM |

+                              _NEW_TEXTURE))

+         _swrast_update_active_attribs(ctx);

+

+      if (swrast->NewState & (_NEW_FOG | 

+                              _NEW_PROGRAM |

+                              _NEW_LIGHT |

+                              _NEW_TEXTURE))

+         _swrast_update_specular_vertex_add(ctx);

+

+      swrast->NewState = 0;

+      swrast->StateChanges = 0;

+      swrast->InvalidateState = _swrast_invalidate_state;

+   }

+}

+

+#define SWRAST_DEBUG 0

+

+/* Public entrypoints:  See also s_accum.c, s_bitmap.c, etc.

+ */

+void

+_swrast_Quad( struct gl_context *ctx,

+	      const SWvertex *v0, const SWvertex *v1,

+              const SWvertex *v2, const SWvertex *v3 )

+{

+   if (SWRAST_DEBUG) {

+      _mesa_debug(ctx, "_swrast_Quad\n");

+      _swrast_print_vertex( ctx, v0 );

+      _swrast_print_vertex( ctx, v1 );

+      _swrast_print_vertex( ctx, v2 );

+      _swrast_print_vertex( ctx, v3 );

+   }

+   SWRAST_CONTEXT(ctx)->Triangle( ctx, v0, v1, v3 );

+   SWRAST_CONTEXT(ctx)->Triangle( ctx, v1, v2, v3 );

+}

+

+void

+_swrast_Triangle( struct gl_context *ctx, const SWvertex *v0,

+                  const SWvertex *v1, const SWvertex *v2 )

+{

+   if (SWRAST_DEBUG) {

+      _mesa_debug(ctx, "_swrast_Triangle\n");

+      _swrast_print_vertex( ctx, v0 );

+      _swrast_print_vertex( ctx, v1 );

+      _swrast_print_vertex( ctx, v2 );

+   }

+   SWRAST_CONTEXT(ctx)->Triangle( ctx, v0, v1, v2 );

+}

+

+void

+_swrast_Line( struct gl_context *ctx, const SWvertex *v0, const SWvertex *v1 )

+{

+   if (SWRAST_DEBUG) {

+      _mesa_debug(ctx, "_swrast_Line\n");

+      _swrast_print_vertex( ctx, v0 );

+      _swrast_print_vertex( ctx, v1 );

+   }

+   SWRAST_CONTEXT(ctx)->Line( ctx, v0, v1 );

+}

+

+void

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

+{

+   if (SWRAST_DEBUG) {

+      _mesa_debug(ctx, "_swrast_Point\n");

+      _swrast_print_vertex( ctx, v0 );

+   }

+   SWRAST_CONTEXT(ctx)->Point( ctx, v0 );

+}

+

+void

+_swrast_InvalidateState( struct gl_context *ctx, GLbitfield new_state )

+{

+   if (SWRAST_DEBUG) {

+      _mesa_debug(ctx, "_swrast_InvalidateState\n");

+   }

+   SWRAST_CONTEXT(ctx)->InvalidateState( ctx, new_state );

+}

+

+void

+_swrast_ResetLineStipple( struct gl_context *ctx )

+{

+   if (SWRAST_DEBUG) {

+      _mesa_debug(ctx, "_swrast_ResetLineStipple\n");

+   }

+   SWRAST_CONTEXT(ctx)->StippleCounter = 0;

+}

+

+void

+_swrast_SetFacing(struct gl_context *ctx, GLuint facing)

+{

+   SWRAST_CONTEXT(ctx)->PointLineFacing = facing;

+}

+

+void

+_swrast_allow_vertex_fog( struct gl_context *ctx, GLboolean value )

+{

+   if (SWRAST_DEBUG) {

+      _mesa_debug(ctx, "_swrast_allow_vertex_fog %d\n", value);

+   }

+   SWRAST_CONTEXT(ctx)->InvalidateState( ctx, _NEW_HINT );

+   SWRAST_CONTEXT(ctx)->AllowVertexFog = value;

+}

+

+void

+_swrast_allow_pixel_fog( struct gl_context *ctx, GLboolean value )

+{

+   if (SWRAST_DEBUG) {

+      _mesa_debug(ctx, "_swrast_allow_pixel_fog %d\n", value);

+   }

+   SWRAST_CONTEXT(ctx)->InvalidateState( ctx, _NEW_HINT );

+   SWRAST_CONTEXT(ctx)->AllowPixelFog = value;

+}

+

+

+GLboolean

+_swrast_CreateContext( struct gl_context *ctx )

+{

+   GLuint i;

+   SWcontext *swrast = (SWcontext *)CALLOC(sizeof(SWcontext));

+

+   if (SWRAST_DEBUG) {

+      _mesa_debug(ctx, "_swrast_CreateContext\n");

+   }

+

+   if (!swrast)

+      return GL_FALSE;

+

+   swrast->NewState = ~0;

+

+   swrast->choose_point = _swrast_choose_point;

+   swrast->choose_line = _swrast_choose_line;

+   swrast->choose_triangle = _swrast_choose_triangle;

+

+   swrast->InvalidatePointMask = _SWRAST_NEW_POINT;

+   swrast->InvalidateLineMask = _SWRAST_NEW_LINE;

+   swrast->InvalidateTriangleMask = _SWRAST_NEW_TRIANGLE;

+

+   swrast->Point = _swrast_validate_point;

+   swrast->Line = _swrast_validate_line;

+   swrast->Triangle = _swrast_validate_triangle;

+   swrast->InvalidateState = _swrast_sleep;

+   swrast->BlendFunc = _swrast_validate_blend_func;

+

+   swrast->AllowVertexFog = GL_TRUE;

+   swrast->AllowPixelFog = GL_TRUE;

+

+   /* Optimized Accum buffer */

+   swrast->_IntegerAccumMode = GL_FALSE;

+   swrast->_IntegerAccumScaler = 0.0;

+

+   for (i = 0; i < MAX_TEXTURE_IMAGE_UNITS; i++)

+      swrast->TextureSample[i] = NULL;

+

+   swrast->SpanArrays = MALLOC_STRUCT(sw_span_arrays);

+   if (!swrast->SpanArrays) {

+      FREE(swrast);

+      return GL_FALSE;

+   }

+   swrast->SpanArrays->ChanType = CHAN_TYPE;

+#if CHAN_TYPE == GL_UNSIGNED_BYTE

+   swrast->SpanArrays->rgba = swrast->SpanArrays->rgba8;

+#elif CHAN_TYPE == GL_UNSIGNED_SHORT

+   swrast->SpanArrays->rgba = swrast->SpanArrays->rgba16;

+#else

+   swrast->SpanArrays->rgba = swrast->SpanArrays->attribs[FRAG_ATTRIB_COL0];

+#endif

+

+   /* init point span buffer */

+   swrast->PointSpan.primitive = GL_POINT;

+   swrast->PointSpan.end = 0;

+   swrast->PointSpan.facing = 0;

+   swrast->PointSpan.array = swrast->SpanArrays;

+

+   swrast->TexelBuffer = (GLfloat *) MALLOC(ctx->Const.MaxTextureImageUnits *

+                                           MAX_WIDTH * 4 * sizeof(GLfloat));

+   if (!swrast->TexelBuffer) {

+      FREE(swrast->SpanArrays);

+      FREE(swrast);

+      return GL_FALSE;

+   }

+

+   ctx->swrast_context = swrast;

+

+   return GL_TRUE;

+}

+

+void

+_swrast_DestroyContext( struct gl_context *ctx )

+{

+   SWcontext *swrast = SWRAST_CONTEXT(ctx);

+

+   if (SWRAST_DEBUG) {

+      _mesa_debug(ctx, "_swrast_DestroyContext\n");

+   }

+

+   FREE( swrast->SpanArrays );

+   if (swrast->ZoomedArrays)

+      FREE( swrast->ZoomedArrays );

+   FREE( swrast->TexelBuffer );

+   FREE( swrast );

+

+   ctx->swrast_context = 0;

+}

+

+

+struct swrast_device_driver *

+_swrast_GetDeviceDriverReference( struct gl_context *ctx )

+{

+   SWcontext *swrast = SWRAST_CONTEXT(ctx);

+   return &swrast->Driver;

+}

+

+void

+_swrast_flush( struct gl_context *ctx )

+{

+   SWcontext *swrast = SWRAST_CONTEXT(ctx);

+   /* flush any pending fragments from rendering points */

+   if (swrast->PointSpan.end > 0) {

+      _swrast_write_rgba_span(ctx, &(swrast->PointSpan));

+      swrast->PointSpan.end = 0;

+   }

+}

+

+void

+_swrast_render_primitive( struct gl_context *ctx, GLenum prim )

+{

+   SWcontext *swrast = SWRAST_CONTEXT(ctx);

+   if (swrast->Primitive == GL_POINTS && prim != GL_POINTS) {

+      _swrast_flush(ctx);

+   }

+   swrast->Primitive = prim;

+}

+

+

+void

+_swrast_render_start( struct gl_context *ctx )

+{

+   SWcontext *swrast = SWRAST_CONTEXT(ctx);

+   if (swrast->Driver.SpanRenderStart)

+      swrast->Driver.SpanRenderStart( ctx );

+   swrast->PointSpan.end = 0;

+}

+ 

+void

+_swrast_render_finish( struct gl_context *ctx )

+{

+   SWcontext *swrast = SWRAST_CONTEXT(ctx);

+   if (swrast->Driver.SpanRenderFinish)

+      swrast->Driver.SpanRenderFinish( ctx );

+

+   _swrast_flush(ctx);

+}

+

+

+#define SWRAST_DEBUG_VERTICES 0

+

+void

+_swrast_print_vertex( struct gl_context *ctx, const SWvertex *v )

+{

+   GLuint i;

+

+   if (SWRAST_DEBUG_VERTICES) {

+      _mesa_debug(ctx, "win %f %f %f %f\n",

+                  v->attrib[FRAG_ATTRIB_WPOS][0],

+                  v->attrib[FRAG_ATTRIB_WPOS][1],

+                  v->attrib[FRAG_ATTRIB_WPOS][2],

+                  v->attrib[FRAG_ATTRIB_WPOS][3]);

+

+      for (i = 0 ; i < ctx->Const.MaxTextureCoordUnits ; i++)

+	 if (ctx->Texture.Unit[i]._ReallyEnabled)

+	    _mesa_debug(ctx, "texcoord[%d] %f %f %f %f\n", i,

+                        v->attrib[FRAG_ATTRIB_TEX0 + i][0],

+                        v->attrib[FRAG_ATTRIB_TEX0 + i][1],

+                        v->attrib[FRAG_ATTRIB_TEX0 + i][2],

+                        v->attrib[FRAG_ATTRIB_TEX0 + i][3]);

+

+#if CHAN_TYPE == GL_FLOAT

+      _mesa_debug(ctx, "color %f %f %f %f\n",

+                  v->color[0], v->color[1], v->color[2], v->color[3]);

+#else

+      _mesa_debug(ctx, "color %d %d %d %d\n",

+                  v->color[0], v->color[1], v->color[2], v->color[3]);

+#endif

+      _mesa_debug(ctx, "spec %g %g %g %g\n",

+                  v->attrib[FRAG_ATTRIB_COL1][0],

+                  v->attrib[FRAG_ATTRIB_COL1][1],

+                  v->attrib[FRAG_ATTRIB_COL1][2],

+                  v->attrib[FRAG_ATTRIB_COL1][3]);

+      _mesa_debug(ctx, "fog %f\n", v->attrib[FRAG_ATTRIB_FOGC][0]);

+      _mesa_debug(ctx, "index %f\n", v->attrib[FRAG_ATTRIB_CI][0]);

+      _mesa_debug(ctx, "pointsize %f\n", v->pointSize);

+      _mesa_debug(ctx, "\n");

+   }

+}

diff --git a/mesalib/src/mesa/swrast/s_context.h b/mesalib/src/mesa/swrast/s_context.h
index 6d81f7476..7535832ab 100644
--- a/mesalib/src/mesa/swrast/s_context.h
+++ b/mesalib/src/mesa/swrast/s_context.h
@@ -1,349 +1,349 @@
-/*
- * Mesa 3-D graphics library
- * Version:  6.5.3
- *
- * 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.
- */
-
-
-/**
- * \file swrast/s_context.h
- * \brief Software rasterization context and private types.
- * \author Keith Whitwell <keith@tungstengraphics.com>
- */
-
-/**
- * \mainpage swrast module
- *
- * This module, software rasterization, contains the software fallback
- * routines for drawing points, lines, triangles, bitmaps and images.
- * All rendering boils down to writing spans (arrays) of pixels with
- * particular colors.  The span-writing routines must be implemented
- * by the device driver.
- */
-
-
-#ifndef S_CONTEXT_H
-#define S_CONTEXT_H
-
-#include "main/compiler.h"
-#include "main/mtypes.h"
-#include "program/prog_execute.h"
-#include "swrast.h"
-#include "s_span.h"
-
-
-typedef void (*texture_sample_func)(GLcontext *ctx,
-                                    const struct gl_texture_object *tObj,
-                                    GLuint n, const GLfloat texcoords[][4],
-                                    const GLfloat lambda[], GLfloat rgba[][4]);
-
-typedef void (_ASMAPIP blend_func)( GLcontext *ctx, GLuint n,
-                                    const GLubyte mask[],
-                                    GLvoid *src, const GLvoid *dst,
-                                    GLenum chanType);
-
-typedef void (*swrast_point_func)( GLcontext *ctx, const SWvertex *);
-
-typedef void (*swrast_line_func)( GLcontext *ctx,
-                                  const SWvertex *, const SWvertex *);
-
-typedef void (*swrast_tri_func)( GLcontext *ctx, const SWvertex *,
-                                 const SWvertex *, const SWvertex *);
-
-
-typedef void (*validate_texture_image_func)(GLcontext *ctx,
-                                            struct gl_texture_object *texObj,
-                                            GLuint face, GLuint level);
-
-
-/**
- * \defgroup Bitmasks
- * Bitmasks to indicate which rasterization options are enabled
- * (RasterMask)
- */
-/*@{*/
-#define ALPHATEST_BIT		0x001	/**< Alpha-test pixels */
-#define BLEND_BIT		0x002	/**< Blend pixels */
-#define DEPTH_BIT		0x004	/**< Depth-test pixels */
-#define FOG_BIT			0x008	/**< Fog pixels */
-#define LOGIC_OP_BIT		0x010	/**< Apply logic op in software */
-#define CLIP_BIT		0x020	/**< Scissor or window clip pixels */
-#define STENCIL_BIT		0x040	/**< Stencil pixels */
-#define MASKING_BIT		0x080	/**< Do glColorMask or glIndexMask */
-#define MULTI_DRAW_BIT		0x400	/**< Write to more than one color- */
-                                        /**< buffer or no buffers. */
-#define OCCLUSION_BIT           0x800   /**< GL_HP_occlusion_test enabled */
-#define TEXTURE_BIT		0x1000	/**< Texturing really enabled */
-#define FRAGPROG_BIT            0x2000  /**< Fragment program enabled */
-#define ATIFRAGSHADER_BIT       0x4000  /**< ATI Fragment shader enabled */
-#define CLAMPING_BIT            0x8000  /**< Clamp colors to [0,1] */
-/*@}*/
-
-#define _SWRAST_NEW_RASTERMASK (_NEW_BUFFERS|	\
-			        _NEW_SCISSOR|	\
-			        _NEW_COLOR|	\
-			        _NEW_DEPTH|	\
-			        _NEW_FOG|	\
-                                _NEW_PROGRAM|   \
-			        _NEW_STENCIL|	\
-			        _NEW_TEXTURE|	\
-			        _NEW_VIEWPORT|	\
-			        _NEW_DEPTH)
-
-
-/**
- * \struct SWcontext
- * \brief  Per-context state that's private to the software rasterizer module.
- */
-typedef struct
-{
-   /** Driver interface:
-    */
-   struct swrast_device_driver Driver;
-
-   /** Configuration mechanisms to make software rasterizer match
-    * characteristics of the hardware rasterizer (if present):
-    */
-   GLboolean AllowVertexFog;
-   GLboolean AllowPixelFog;
-
-   /** Derived values, invalidated on statechanges, updated from
-    * _swrast_validate_derived():
-    */
-   GLbitfield _RasterMask;
-   GLfloat _BackfaceSign;      /** +1 or -1 */
-   GLfloat _BackfaceCullSign;  /** +1, 0, or -1 */
-   GLboolean _PreferPixelFog;    /* Compute fog blend factor per fragment? */
-   GLboolean _TextureCombinePrimary;
-   GLboolean _FogEnabled;
-   GLboolean _DeferredTexture;
-   GLenum _FogMode;  /* either GL_FOG_MODE or fragment program's fog mode */
-
-   /** List/array of the fragment attributes to interpolate */
-   GLuint _ActiveAttribs[FRAG_ATTRIB_MAX];
-   /** Same info, but as a bitmask */
-   GLbitfield _ActiveAttribMask;
-   /** Number of fragment attributes to interpolate */
-   GLuint _NumActiveAttribs;
-   /** Indicates how each attrib is to be interpolated (lines/tris) */
-   GLenum _InterpMode[FRAG_ATTRIB_MAX]; /* GL_FLAT or GL_SMOOTH (for now) */
-
-   /* Accum buffer temporaries.
-    */
-   GLboolean _IntegerAccumMode;	/**< Storing unscaled integers? */
-   GLfloat _IntegerAccumScaler;	/**< Implicit scale factor */
-
-   /* Working values:
-    */
-   GLuint StippleCounter;    /**< Line stipple counter */
-   GLuint PointLineFacing;
-   GLbitfield NewState;
-   GLuint StateChanges;
-   GLenum Primitive;    /* current primitive being drawn (ala glBegin) */
-   GLboolean SpecularVertexAdd; /**< Add specular/secondary color per vertex */
-
-   void (*InvalidateState)( GLcontext *ctx, GLbitfield new_state );
-
-   /**
-    * When the NewState mask intersects these masks, we invalidate the
-    * Point/Line/Triangle function pointers below.
-    */
-   /*@{*/
-   GLbitfield InvalidatePointMask;
-   GLbitfield InvalidateLineMask;
-   GLbitfield InvalidateTriangleMask;
-   /*@}*/
-
-   /**
-    * Device drivers plug in functions for these callbacks.
-    * Will be called when the GL state change mask intersects the above masks.
-    */
-   /*@{*/
-   void (*choose_point)( GLcontext * );
-   void (*choose_line)( GLcontext * );
-   void (*choose_triangle)( GLcontext * );
-   /*@}*/
-
-   /**
-    * Current point, line and triangle drawing functions.
-    */
-   /*@{*/
-   swrast_point_func Point;
-   swrast_line_func Line;
-   swrast_tri_func Triangle;
-   /*@}*/
-
-   /**
-    * Placeholders for when separate specular (or secondary color) is
-    * enabled but texturing is not.
-    */
-   /*@{*/
-   swrast_point_func SpecPoint;
-   swrast_line_func SpecLine;
-   swrast_tri_func SpecTriangle;
-   /*@}*/
-
-   /**
-    * Typically, we'll allocate a sw_span structure as a local variable
-    * and set its 'array' pointer to point to this object.  The reason is
-    * this object is big and causes problems when allocated on the stack
-    * on some systems.
-    */
-   SWspanarrays *SpanArrays;
-   SWspanarrays *ZoomedArrays;  /**< For pixel zooming */
-
-   /**
-    * Used to buffer N GL_POINTS, instead of rendering one by one.
-    */
-   SWspan PointSpan;
-
-   /** Internal hooks, kept up to date by the same mechanism as above.
-    */
-   blend_func BlendFunc;
-   texture_sample_func TextureSample[MAX_TEXTURE_IMAGE_UNITS];
-
-   /** Buffer for saving the sampled texture colors.
-    * Needed for GL_ARB_texture_env_crossbar implementation.
-    */
-   GLfloat *TexelBuffer;
-
-   validate_texture_image_func ValidateTextureImage;
-
-   /** State used during execution of fragment programs */
-   struct gl_program_machine FragProgMachine;
-
-} SWcontext;
-
-
-extern void
-_swrast_validate_derived( GLcontext *ctx );
-
-extern void
-_swrast_update_texture_samplers(GLcontext *ctx);
-
-
-/** Return SWcontext for the given GLcontext */
-static INLINE SWcontext *
-SWRAST_CONTEXT(GLcontext *ctx)
-{
-   return (SWcontext *) ctx->swrast_context;
-}
-
-/** const version of above */
-static INLINE const SWcontext *
-CONST_SWRAST_CONTEXT(const GLcontext *ctx)
-{
-   return (const SWcontext *) ctx->swrast_context;
-}
-
-
-/**
- * Called prior to framebuffer reading/writing.
- * For drivers that rely on swrast for fallback rendering, this is the
- * driver's opportunity to map renderbuffers and textures.
- */
-static INLINE void
-swrast_render_start(GLcontext *ctx)
-{
-   SWcontext *swrast = SWRAST_CONTEXT(ctx);
-   if (swrast->Driver.SpanRenderStart)
-      swrast->Driver.SpanRenderStart(ctx);
-}
-
-
-/** Called after framebuffer reading/writing */
-static INLINE void
-swrast_render_finish(GLcontext *ctx)
-{
-   SWcontext *swrast = SWRAST_CONTEXT(ctx);
-   if (swrast->Driver.SpanRenderFinish)
-      swrast->Driver.SpanRenderFinish(ctx);
-}
-
-
-
-/**
- * Size of an RGBA pixel, in bytes, for given datatype.
- */
-#define RGBA_PIXEL_SIZE(TYPE)                                     \
-         ((TYPE == GL_UNSIGNED_BYTE) ? 4 * sizeof(GLubyte) :      \
-          ((TYPE == GL_UNSIGNED_SHORT) ? 4 * sizeof(GLushort)     \
-           : 4 * sizeof(GLfloat)))
-
-
-
-/*
- * Fixed point arithmetic macros
- */
-#ifndef FIXED_FRAC_BITS
-#define FIXED_FRAC_BITS 11
-#endif
-
-#define FIXED_SHIFT     FIXED_FRAC_BITS
-#define FIXED_ONE       (1 << FIXED_SHIFT)
-#define FIXED_HALF      (1 << (FIXED_SHIFT-1))
-#define FIXED_FRAC_MASK (FIXED_ONE - 1)
-#define FIXED_INT_MASK  (~FIXED_FRAC_MASK)
-#define FIXED_EPSILON   1
-#define FIXED_SCALE     ((float) FIXED_ONE)
-#define FIXED_DBL_SCALE ((double) FIXED_ONE)
-#define FloatToFixed(X) (IROUND((X) * FIXED_SCALE))
-#define FixedToDouble(X) ((X) * (1.0 / FIXED_DBL_SCALE))
-#define IntToFixed(I)   ((I) << FIXED_SHIFT)
-#define FixedToInt(X)   ((X) >> FIXED_SHIFT)
-#define FixedToUns(X)   (((unsigned int)(X)) >> FIXED_SHIFT)
-#define FixedCeil(X)    (((X) + FIXED_ONE - FIXED_EPSILON) & FIXED_INT_MASK)
-#define FixedFloor(X)   ((X) & FIXED_INT_MASK)
-#define FixedToFloat(X) ((X) * (1.0F / FIXED_SCALE))
-#define PosFloatToFixed(X)      FloatToFixed(X)
-#define SignedFloatToFixed(X)   FloatToFixed(X)
-
-
-
-/*
- * XXX these macros are just bandages for now in order to make
- * CHAN_BITS==32 compile cleanly.
- * These should probably go elsewhere at some point.
- */
-#if CHAN_TYPE == GL_FLOAT
-#define ChanToFixed(X)  (X)
-#define FixedToChan(X)  (X)
-#else
-#define ChanToFixed(X)  IntToFixed(X)
-#define FixedToChan(X)  FixedToInt(X)
-#endif
-
-
-/**
- * For looping over fragment attributes in the pointe, line
- * triangle rasterizers.
- */
-#define ATTRIB_LOOP_BEGIN                                \
-   {                                                     \
-      GLuint a;                                          \
-      for (a = 0; a < swrast->_NumActiveAttribs; a++) {  \
-         const GLuint attr = swrast->_ActiveAttribs[a];
-
-#define ATTRIB_LOOP_END } }
-
-
-
-#endif
+/*

+ * Mesa 3-D graphics library

+ * Version:  6.5.3

+ *

+ * 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.

+ */

+

+

+/**

+ * \file swrast/s_context.h

+ * \brief Software rasterization context and private types.

+ * \author Keith Whitwell <keith@tungstengraphics.com>

+ */

+

+/**

+ * \mainpage swrast module

+ *

+ * This module, software rasterization, contains the software fallback

+ * routines for drawing points, lines, triangles, bitmaps and images.

+ * All rendering boils down to writing spans (arrays) of pixels with

+ * particular colors.  The span-writing routines must be implemented

+ * by the device driver.

+ */

+

+

+#ifndef S_CONTEXT_H

+#define S_CONTEXT_H

+

+#include "main/compiler.h"

+#include "main/mtypes.h"

+#include "program/prog_execute.h"

+#include "swrast.h"

+#include "s_span.h"

+

+

+typedef void (*texture_sample_func)(struct gl_context *ctx,

+                                    const struct gl_texture_object *tObj,

+                                    GLuint n, const GLfloat texcoords[][4],

+                                    const GLfloat lambda[], GLfloat rgba[][4]);

+

+typedef void (_ASMAPIP blend_func)( struct gl_context *ctx, GLuint n,

+                                    const GLubyte mask[],

+                                    GLvoid *src, const GLvoid *dst,

+                                    GLenum chanType);

+

+typedef void (*swrast_point_func)( struct gl_context *ctx, const SWvertex *);

+

+typedef void (*swrast_line_func)( struct gl_context *ctx,

+                                  const SWvertex *, const SWvertex *);

+

+typedef void (*swrast_tri_func)( struct gl_context *ctx, const SWvertex *,

+                                 const SWvertex *, const SWvertex *);

+

+

+typedef void (*validate_texture_image_func)(struct gl_context *ctx,

+                                            struct gl_texture_object *texObj,

+                                            GLuint face, GLuint level);

+

+

+/**

+ * \defgroup Bitmasks

+ * Bitmasks to indicate which rasterization options are enabled

+ * (RasterMask)

+ */

+/*@{*/

+#define ALPHATEST_BIT		0x001	/**< Alpha-test pixels */

+#define BLEND_BIT		0x002	/**< Blend pixels */

+#define DEPTH_BIT		0x004	/**< Depth-test pixels */

+#define FOG_BIT			0x008	/**< Fog pixels */

+#define LOGIC_OP_BIT		0x010	/**< Apply logic op in software */

+#define CLIP_BIT		0x020	/**< Scissor or window clip pixels */

+#define STENCIL_BIT		0x040	/**< Stencil pixels */

+#define MASKING_BIT		0x080	/**< Do glColorMask or glIndexMask */

+#define MULTI_DRAW_BIT		0x400	/**< Write to more than one color- */

+                                        /**< buffer or no buffers. */

+#define OCCLUSION_BIT           0x800   /**< GL_HP_occlusion_test enabled */

+#define TEXTURE_BIT		0x1000	/**< Texturing really enabled */

+#define FRAGPROG_BIT            0x2000  /**< Fragment program enabled */

+#define ATIFRAGSHADER_BIT       0x4000  /**< ATI Fragment shader enabled */

+#define CLAMPING_BIT            0x8000  /**< Clamp colors to [0,1] */

+/*@}*/

+

+#define _SWRAST_NEW_RASTERMASK (_NEW_BUFFERS|	\

+			        _NEW_SCISSOR|	\

+			        _NEW_COLOR|	\

+			        _NEW_DEPTH|	\

+			        _NEW_FOG|	\

+                                _NEW_PROGRAM|   \

+			        _NEW_STENCIL|	\

+			        _NEW_TEXTURE|	\

+			        _NEW_VIEWPORT|	\

+			        _NEW_DEPTH)

+

+

+/**

+ * \struct SWcontext

+ * \brief  Per-context state that's private to the software rasterizer module.

+ */

+typedef struct

+{

+   /** Driver interface:

+    */

+   struct swrast_device_driver Driver;

+

+   /** Configuration mechanisms to make software rasterizer match

+    * characteristics of the hardware rasterizer (if present):

+    */

+   GLboolean AllowVertexFog;

+   GLboolean AllowPixelFog;

+

+   /** Derived values, invalidated on statechanges, updated from

+    * _swrast_validate_derived():

+    */

+   GLbitfield _RasterMask;

+   GLfloat _BackfaceSign;      /** +1 or -1 */

+   GLfloat _BackfaceCullSign;  /** +1, 0, or -1 */

+   GLboolean _PreferPixelFog;    /* Compute fog blend factor per fragment? */

+   GLboolean _TextureCombinePrimary;

+   GLboolean _FogEnabled;

+   GLboolean _DeferredTexture;

+   GLenum _FogMode;  /* either GL_FOG_MODE or fragment program's fog mode */

+

+   /** List/array of the fragment attributes to interpolate */

+   GLuint _ActiveAttribs[FRAG_ATTRIB_MAX];

+   /** Same info, but as a bitmask */

+   GLbitfield _ActiveAttribMask;

+   /** Number of fragment attributes to interpolate */

+   GLuint _NumActiveAttribs;

+   /** Indicates how each attrib is to be interpolated (lines/tris) */

+   GLenum _InterpMode[FRAG_ATTRIB_MAX]; /* GL_FLAT or GL_SMOOTH (for now) */

+

+   /* Accum buffer temporaries.

+    */

+   GLboolean _IntegerAccumMode;	/**< Storing unscaled integers? */

+   GLfloat _IntegerAccumScaler;	/**< Implicit scale factor */

+

+   /* Working values:

+    */

+   GLuint StippleCounter;    /**< Line stipple counter */

+   GLuint PointLineFacing;

+   GLbitfield NewState;

+   GLuint StateChanges;

+   GLenum Primitive;    /* current primitive being drawn (ala glBegin) */

+   GLboolean SpecularVertexAdd; /**< Add specular/secondary color per vertex */

+

+   void (*InvalidateState)( struct gl_context *ctx, GLbitfield new_state );

+

+   /**

+    * When the NewState mask intersects these masks, we invalidate the

+    * Point/Line/Triangle function pointers below.

+    */

+   /*@{*/

+   GLbitfield InvalidatePointMask;

+   GLbitfield InvalidateLineMask;

+   GLbitfield InvalidateTriangleMask;

+   /*@}*/

+

+   /**

+    * Device drivers plug in functions for these callbacks.

+    * Will be called when the GL state change mask intersects the above masks.

+    */

+   /*@{*/

+   void (*choose_point)( struct gl_context * );

+   void (*choose_line)( struct gl_context * );

+   void (*choose_triangle)( struct gl_context * );

+   /*@}*/

+

+   /**

+    * Current point, line and triangle drawing functions.

+    */

+   /*@{*/

+   swrast_point_func Point;

+   swrast_line_func Line;

+   swrast_tri_func Triangle;

+   /*@}*/

+

+   /**

+    * Placeholders for when separate specular (or secondary color) is

+    * enabled but texturing is not.

+    */

+   /*@{*/

+   swrast_point_func SpecPoint;

+   swrast_line_func SpecLine;

+   swrast_tri_func SpecTriangle;

+   /*@}*/

+

+   /**

+    * Typically, we'll allocate a sw_span structure as a local variable

+    * and set its 'array' pointer to point to this object.  The reason is

+    * this object is big and causes problems when allocated on the stack

+    * on some systems.

+    */

+   SWspanarrays *SpanArrays;

+   SWspanarrays *ZoomedArrays;  /**< For pixel zooming */

+

+   /**

+    * Used to buffer N GL_POINTS, instead of rendering one by one.

+    */

+   SWspan PointSpan;

+

+   /** Internal hooks, kept up to date by the same mechanism as above.

+    */

+   blend_func BlendFunc;

+   texture_sample_func TextureSample[MAX_TEXTURE_IMAGE_UNITS];

+

+   /** Buffer for saving the sampled texture colors.

+    * Needed for GL_ARB_texture_env_crossbar implementation.

+    */

+   GLfloat *TexelBuffer;

+

+   validate_texture_image_func ValidateTextureImage;

+

+   /** State used during execution of fragment programs */

+   struct gl_program_machine FragProgMachine;

+

+} SWcontext;

+

+

+extern void

+_swrast_validate_derived( struct gl_context *ctx );

+

+extern void

+_swrast_update_texture_samplers(struct gl_context *ctx);

+

+

+/** Return SWcontext for the given struct gl_context */

+static INLINE SWcontext *

+SWRAST_CONTEXT(struct gl_context *ctx)

+{

+   return (SWcontext *) ctx->swrast_context;

+}

+

+/** const version of above */

+static INLINE const SWcontext *

+CONST_SWRAST_CONTEXT(const struct gl_context *ctx)

+{

+   return (const SWcontext *) ctx->swrast_context;

+}

+

+

+/**

+ * Called prior to framebuffer reading/writing.

+ * For drivers that rely on swrast for fallback rendering, this is the

+ * driver's opportunity to map renderbuffers and textures.

+ */

+static INLINE void

+swrast_render_start(struct gl_context *ctx)

+{

+   SWcontext *swrast = SWRAST_CONTEXT(ctx);

+   if (swrast->Driver.SpanRenderStart)

+      swrast->Driver.SpanRenderStart(ctx);

+}

+

+

+/** Called after framebuffer reading/writing */

+static INLINE void

+swrast_render_finish(struct gl_context *ctx)

+{

+   SWcontext *swrast = SWRAST_CONTEXT(ctx);

+   if (swrast->Driver.SpanRenderFinish)

+      swrast->Driver.SpanRenderFinish(ctx);

+}

+

+

+

+/**

+ * Size of an RGBA pixel, in bytes, for given datatype.

+ */

+#define RGBA_PIXEL_SIZE(TYPE)                                     \

+         ((TYPE == GL_UNSIGNED_BYTE) ? 4 * sizeof(GLubyte) :      \

+          ((TYPE == GL_UNSIGNED_SHORT) ? 4 * sizeof(GLushort)     \

+           : 4 * sizeof(GLfloat)))

+

+

+

+/*

+ * Fixed point arithmetic macros

+ */

+#ifndef FIXED_FRAC_BITS

+#define FIXED_FRAC_BITS 11

+#endif

+

+#define FIXED_SHIFT     FIXED_FRAC_BITS

+#define FIXED_ONE       (1 << FIXED_SHIFT)

+#define FIXED_HALF      (1 << (FIXED_SHIFT-1))

+#define FIXED_FRAC_MASK (FIXED_ONE - 1)

+#define FIXED_INT_MASK  (~FIXED_FRAC_MASK)

+#define FIXED_EPSILON   1

+#define FIXED_SCALE     ((float) FIXED_ONE)

+#define FIXED_DBL_SCALE ((double) FIXED_ONE)

+#define FloatToFixed(X) (IROUND((X) * FIXED_SCALE))

+#define FixedToDouble(X) ((X) * (1.0 / FIXED_DBL_SCALE))

+#define IntToFixed(I)   ((I) << FIXED_SHIFT)

+#define FixedToInt(X)   ((X) >> FIXED_SHIFT)

+#define FixedToUns(X)   (((unsigned int)(X)) >> FIXED_SHIFT)

+#define FixedCeil(X)    (((X) + FIXED_ONE - FIXED_EPSILON) & FIXED_INT_MASK)

+#define FixedFloor(X)   ((X) & FIXED_INT_MASK)

+#define FixedToFloat(X) ((X) * (1.0F / FIXED_SCALE))

+#define PosFloatToFixed(X)      FloatToFixed(X)

+#define SignedFloatToFixed(X)   FloatToFixed(X)

+

+

+

+/*

+ * XXX these macros are just bandages for now in order to make

+ * CHAN_BITS==32 compile cleanly.

+ * These should probably go elsewhere at some point.

+ */

+#if CHAN_TYPE == GL_FLOAT

+#define ChanToFixed(X)  (X)

+#define FixedToChan(X)  (X)

+#else

+#define ChanToFixed(X)  IntToFixed(X)

+#define FixedToChan(X)  FixedToInt(X)

+#endif

+

+

+/**

+ * For looping over fragment attributes in the pointe, line

+ * triangle rasterizers.

+ */

+#define ATTRIB_LOOP_BEGIN                                \

+   {                                                     \

+      GLuint a;                                          \

+      for (a = 0; a < swrast->_NumActiveAttribs; a++) {  \

+         const GLuint attr = swrast->_ActiveAttribs[a];

+

+#define ATTRIB_LOOP_END } }

+

+

+

+#endif

diff --git a/mesalib/src/mesa/swrast/s_copypix.c b/mesalib/src/mesa/swrast/s_copypix.c
index f4f0c8a33..e249e4ad5 100644
--- a/mesalib/src/mesa/swrast/s_copypix.c
+++ b/mesalib/src/mesa/swrast/s_copypix.c
@@ -1,827 +1,720 @@
-/*
- * 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/context.h"
-#include "main/colormac.h"
-#include "main/condrender.h"
-#include "main/convolve.h"
-#include "main/image.h"
-#include "main/macros.h"
-#include "main/imports.h"
-
-#include "s_context.h"
-#include "s_depth.h"
-#include "s_span.h"
-#include "s_stencil.h"
-#include "s_zoom.h"
-
-
-
-/**
- * Determine if there's overlap in an image copy.
- * This test also compensates for the fact that copies are done from
- * bottom to top and overlaps can sometimes be handled correctly
- * without making a temporary image copy.
- * \return GL_TRUE if the regions overlap, GL_FALSE otherwise.
- */
-static GLboolean
-regions_overlap(GLint srcx, GLint srcy,
-                GLint dstx, GLint dsty,
-                GLint width, GLint height,
-                GLfloat zoomX, GLfloat zoomY)
-{
-   if (zoomX == 1.0 && zoomY == 1.0) {
-      /* no zoom */
-      if (srcx >= dstx + width || (srcx + width <= dstx)) {
-         return GL_FALSE;
-      }
-      else if (srcy < dsty) { /* this is OK */
-         return GL_FALSE;
-      }
-      else if (srcy > dsty + height) {
-         return GL_FALSE;
-      }
-      else {
-         return GL_TRUE;
-      }
-   }
-   else {
-      /* add one pixel of slop when zooming, just to be safe */
-      if (srcx > (dstx + ((zoomX > 0.0F) ? (width * zoomX + 1.0F) : 0.0F))) {
-         /* src is completely right of dest */
-         return GL_FALSE;
-      }
-      else if (srcx + width + 1.0F < dstx + ((zoomX > 0.0F) ? 0.0F : (width * zoomX))) {
-         /* src is completely left of dest */
-         return GL_FALSE;
-      }
-      else if ((srcy < dsty) && (srcy + height < dsty + (height * zoomY))) {
-         /* src is completely below dest */
-         return GL_FALSE;
-      }
-      else if ((srcy > dsty) && (srcy + height > dsty + (height * zoomY))) {
-         /* src is completely above dest */
-         return GL_FALSE;
-      }
-      else {
-         return GL_TRUE;
-      }
-   }
-}
-
-
-/**
- * RGBA copypixels with convolution.
- */
-static void
-copy_conv_rgba_pixels(GLcontext *ctx, GLint srcx, GLint srcy,
-                      GLint width, GLint height, GLint destx, GLint desty)
-{
-   GLint row;
-   const GLboolean zoom = ctx->Pixel.ZoomX != 1.0F || ctx->Pixel.ZoomY != 1.0F;
-   const GLbitfield transferOps = ctx->_ImageTransferState;
-   const GLboolean sink = (ctx->Pixel.MinMaxEnabled && ctx->MinMax.Sink)
-      || (ctx->Pixel.HistogramEnabled && ctx->Histogram.Sink);
-   GLfloat *dest, *tmpImage, *convImage;
-   SWspan span;
-
-   INIT_SPAN(span, GL_BITMAP);
-   _swrast_span_default_attribs(ctx, &span);
-   span.arrayMask = SPAN_RGBA;
-   span.arrayAttribs = FRAG_BIT_COL0;
-
-   /* allocate space for GLfloat image */
-   tmpImage = (GLfloat *) malloc(width * height * 4 * sizeof(GLfloat));
-   if (!tmpImage) {
-      _mesa_error(ctx, GL_OUT_OF_MEMORY, "glCopyPixels");
-      return;
-   }
-   convImage = (GLfloat *) malloc(width * height * 4 * sizeof(GLfloat));
-   if (!convImage) {
-      free(tmpImage);
-      _mesa_error(ctx, GL_OUT_OF_MEMORY, "glCopyPixels");
-      return;
-   }
-
-   /* read source image as float/RGBA */
-   dest = tmpImage;
-   for (row = 0; row < height; row++) {
-      _swrast_read_rgba_span(ctx, ctx->ReadBuffer->_ColorReadBuffer,
-                             width, srcx, srcy + row, GL_FLOAT, dest);
-      dest += 4 * width;
-   }
-
-   /* do the image transfer ops which preceed convolution */
-   for (row = 0; row < height; row++) {
-      GLfloat (*rgba)[4] = (GLfloat (*)[4]) (tmpImage + row * width * 4);
-      _mesa_apply_rgba_transfer_ops(ctx,
-                                    transferOps & IMAGE_PRE_CONVOLUTION_BITS,
-                                    width, rgba);
-   }
-
-   /* do convolution */
-   if (ctx->Pixel.Convolution2DEnabled) {
-      _mesa_convolve_2d_image(ctx, &width, &height, tmpImage, convImage);
-   }
-   else {
-      ASSERT(ctx->Pixel.Separable2DEnabled);
-      _mesa_convolve_sep_image(ctx, &width, &height, tmpImage, convImage);
-   }
-   free(tmpImage);
-
-   /* do remaining post-convolution image transfer ops */
-   for (row = 0; row < height; row++) {
-      GLfloat (*rgba)[4] = (GLfloat (*)[4]) (convImage + row * width * 4);
-      _mesa_apply_rgba_transfer_ops(ctx,
-                                    transferOps & IMAGE_POST_CONVOLUTION_BITS,
-                                    width, rgba);
-   }
-
-   if (!sink) {
-      /* write the new image */
-      for (row = 0; row < height; row++) {
-         const GLfloat *src = convImage + row * width * 4;
-         GLfloat *rgba = (GLfloat *) span.array->attribs[FRAG_ATTRIB_COL0];
-
-         /* copy convolved colors into span array */
-         memcpy(rgba, src, width * 4 * sizeof(GLfloat));
-
-         /* write span */
-         span.x = destx;
-         span.y = desty + row;
-         span.end = width;
-         span.array->ChanType = GL_FLOAT;
-         if (zoom) {
-            _swrast_write_zoomed_rgba_span(ctx, destx, desty, &span, rgba);
-         }
-         else {
-            _swrast_write_rgba_span(ctx, &span);
-         }
-      }
-      /* restore this */
-      span.array->ChanType = CHAN_TYPE;
-   }
-
-   free(convImage);
-}
-
-
-/**
- * RGBA copypixels
- */
-static void
-copy_rgba_pixels(GLcontext *ctx, GLint srcx, GLint srcy,
-                 GLint width, GLint height, GLint destx, GLint desty)
-{
-   GLfloat *tmpImage, *p;
-   GLint sy, dy, stepy, row;
-   const GLboolean zoom = ctx->Pixel.ZoomX != 1.0F || ctx->Pixel.ZoomY != 1.0F;
-   GLint overlapping;
-   GLuint transferOps = ctx->_ImageTransferState;
-   SWspan span;
-
-   if (!ctx->ReadBuffer->_ColorReadBuffer) {
-      /* no readbuffer - OK */
-      return;
-   }
-
-   if (ctx->Pixel.Convolution2DEnabled || ctx->Pixel.Separable2DEnabled) {
-      copy_conv_rgba_pixels(ctx, srcx, srcy, width, height, destx, desty);
-      return;
-   }
-   else if (ctx->Pixel.Convolution1DEnabled) {
-      /* make sure we don't apply 1D convolution */
-      transferOps &= ~(IMAGE_CONVOLUTION_BIT |
-                       IMAGE_POST_CONVOLUTION_SCALE_BIAS);
-   }
-
-   if (ctx->DrawBuffer == ctx->ReadBuffer) {
-      overlapping = regions_overlap(srcx, srcy, destx, desty, width, height,
-                                    ctx->Pixel.ZoomX, ctx->Pixel.ZoomY);
-   }
-   else {
-      overlapping = GL_FALSE;
-   }
-
-   /* Determine if copy should be done bottom-to-top or top-to-bottom */
-   if (!overlapping && srcy < desty) {
-      /* top-down  max-to-min */
-      sy = srcy + height - 1;
-      dy = desty + height - 1;
-      stepy = -1;
-   }
-   else {
-      /* bottom-up  min-to-max */
-      sy = srcy;
-      dy = desty;
-      stepy = 1;
-   }
-
-   INIT_SPAN(span, GL_BITMAP);
-   _swrast_span_default_attribs(ctx, &span);
-   span.arrayMask = SPAN_RGBA;
-   span.arrayAttribs = FRAG_BIT_COL0; /* we'll fill in COL0 attrib values */
-
-   if (overlapping) {
-      tmpImage = (GLfloat *) malloc(width * height * sizeof(GLfloat) * 4);
-      if (!tmpImage) {
-         _mesa_error( ctx, GL_OUT_OF_MEMORY, "glCopyPixels" );
-         return;
-      }
-      /* read the source image as RGBA/float */
-      p = tmpImage;
-      for (row = 0; row < height; row++) {
-         _swrast_read_rgba_span( ctx, ctx->ReadBuffer->_ColorReadBuffer,
-                                 width, srcx, sy + row, GL_FLOAT, p );
-         p += width * 4;
-      }
-      p = tmpImage;
-   }
-   else {
-      tmpImage = NULL;  /* silence compiler warnings */
-      p = NULL;
-   }
-
-   ASSERT(width < MAX_WIDTH);
-
-   for (row = 0; row < height; row++, sy += stepy, dy += stepy) {
-      GLvoid *rgba = span.array->attribs[FRAG_ATTRIB_COL0];
-
-      /* Get row/span of source pixels */
-      if (overlapping) {
-         /* get from buffered image */
-         memcpy(rgba, p, width * sizeof(GLfloat) * 4);
-         p += width * 4;
-      }
-      else {
-         /* get from framebuffer */
-         _swrast_read_rgba_span( ctx, ctx->ReadBuffer->_ColorReadBuffer,
-                                 width, srcx, sy, GL_FLOAT, rgba );
-      }
-
-      if (transferOps) {
-         _mesa_apply_rgba_transfer_ops(ctx, transferOps, width,
-                                       (GLfloat (*)[4]) rgba);
-      }
-
-      /* Write color span */
-      span.x = destx;
-      span.y = dy;
-      span.end = width;
-      span.array->ChanType = GL_FLOAT;
-      if (zoom) {
-         _swrast_write_zoomed_rgba_span(ctx, destx, desty, &span, rgba);
-      }
-      else {
-         _swrast_write_rgba_span(ctx, &span);
-      }
-   }
-
-   span.array->ChanType = CHAN_TYPE; /* restore */
-
-   if (overlapping)
-      free(tmpImage);
-}
-
-
-/**
- * Convert floating point Z values to integer Z values with pixel transfer's
- * Z scale and bias.
- */
-static void
-scale_and_bias_z(GLcontext *ctx, GLuint width,
-                 const GLfloat depth[], GLuint z[])
-{
-   const GLuint depthMax = ctx->DrawBuffer->_DepthMax;
-   GLuint i;
-
-   if (depthMax <= 0xffffff &&
-       ctx->Pixel.DepthScale == 1.0 &&
-       ctx->Pixel.DepthBias == 0.0) {
-      /* no scale or bias and no clamping and no worry of overflow */
-      const GLfloat depthMaxF = ctx->DrawBuffer->_DepthMaxF;
-      for (i = 0; i < width; i++) {
-         z[i] = (GLuint) (depth[i] * depthMaxF);
-      }
-   }
-   else {
-      /* need to be careful with overflow */
-      const GLdouble depthMaxF = ctx->DrawBuffer->_DepthMaxF;
-      for (i = 0; i < width; i++) {
-         GLdouble d = depth[i] * ctx->Pixel.DepthScale + ctx->Pixel.DepthBias;
-         d = CLAMP(d, 0.0, 1.0) * depthMaxF;
-         if (d >= depthMaxF)
-            z[i] = depthMax;
-         else
-            z[i] = (GLuint) d;
-      }
-   }
-}
-
-
-
-/*
- * TODO: Optimize!!!!
- */
-static void
-copy_depth_pixels( GLcontext *ctx, GLint srcx, GLint srcy,
-                   GLint width, GLint height,
-                   GLint destx, GLint desty )
-{
-   struct gl_framebuffer *fb = ctx->ReadBuffer;
-   struct gl_renderbuffer *readRb = fb->_DepthBuffer;
-   GLfloat *p, *tmpImage;
-   GLint sy, dy, stepy;
-   GLint j;
-   const GLboolean zoom = ctx->Pixel.ZoomX != 1.0F || ctx->Pixel.ZoomY != 1.0F;
-   GLint overlapping;
-   SWspan span;
-
-   if (!readRb) {
-      /* no readbuffer - OK */
-      return;
-   }
-
-   INIT_SPAN(span, GL_BITMAP);
-   _swrast_span_default_attribs(ctx, &span);
-   span.arrayMask = SPAN_Z;
-
-   if (ctx->DrawBuffer == ctx->ReadBuffer) {
-      overlapping = regions_overlap(srcx, srcy, destx, desty, width, height,
-                                    ctx->Pixel.ZoomX, ctx->Pixel.ZoomY);
-   }
-   else {
-      overlapping = GL_FALSE;
-   }
-
-   /* Determine if copy should be bottom-to-top or top-to-bottom */
-   if (!overlapping && srcy < desty) {
-      /* top-down  max-to-min */
-      sy = srcy + height - 1;
-      dy = desty + height - 1;
-      stepy = -1;
-   }
-   else {
-      /* bottom-up  min-to-max */
-      sy = srcy;
-      dy = desty;
-      stepy = 1;
-   }
-
-   if (overlapping) {
-      GLint ssy = sy;
-      tmpImage = (GLfloat *) malloc(width * height * sizeof(GLfloat));
-      if (!tmpImage) {
-         _mesa_error( ctx, GL_OUT_OF_MEMORY, "glCopyPixels" );
-         return;
-      }
-      p = tmpImage;
-      for (j = 0; j < height; j++, ssy += stepy) {
-         _swrast_read_depth_span_float(ctx, readRb, width, srcx, ssy, p);
-         p += width;
-      }
-      p = tmpImage;
-   }
-   else {
-      tmpImage = NULL;  /* silence compiler warning */
-      p = NULL;
-   }
-
-   for (j = 0; j < height; j++, sy += stepy, dy += stepy) {
-      GLfloat depth[MAX_WIDTH];
-      /* get depth values */
-      if (overlapping) {
-         memcpy(depth, p, width * sizeof(GLfloat));
-         p += width;
-      }
-      else {
-         _swrast_read_depth_span_float(ctx, readRb, width, srcx, sy, depth);
-      }
-
-      /* apply scale and bias */
-      scale_and_bias_z(ctx, width, depth, span.array->z);
-
-      /* write depth values */
-      span.x = destx;
-      span.y = dy;
-      span.end = width;
-      if (zoom)
-         _swrast_write_zoomed_depth_span(ctx, destx, desty, &span);
-      else
-         _swrast_write_rgba_span(ctx, &span);
-   }
-
-   if (overlapping)
-      free(tmpImage);
-}
-
-
-
-static void
-copy_stencil_pixels( GLcontext *ctx, GLint srcx, GLint srcy,
-                     GLint width, GLint height,
-                     GLint destx, GLint desty )
-{
-   struct gl_framebuffer *fb = ctx->ReadBuffer;
-   struct gl_renderbuffer *rb = fb->_StencilBuffer;
-   GLint sy, dy, stepy;
-   GLint j;
-   GLstencil *p, *tmpImage;
-   const GLboolean zoom = ctx->Pixel.ZoomX != 1.0F || ctx->Pixel.ZoomY != 1.0F;
-   GLint overlapping;
-
-   if (!rb) {
-      /* no readbuffer - OK */
-      return;
-   }
-
-   if (ctx->DrawBuffer == ctx->ReadBuffer) {
-      overlapping = regions_overlap(srcx, srcy, destx, desty, width, height,
-                                    ctx->Pixel.ZoomX, ctx->Pixel.ZoomY);
-   }
-   else {
-      overlapping = GL_FALSE;
-   }
-
-   /* Determine if copy should be bottom-to-top or top-to-bottom */
-   if (!overlapping && srcy < desty) {
-      /* top-down  max-to-min */
-      sy = srcy + height - 1;
-      dy = desty + height - 1;
-      stepy = -1;
-   }
-   else {
-      /* bottom-up  min-to-max */
-      sy = srcy;
-      dy = desty;
-      stepy = 1;
-   }
-
-   if (overlapping) {
-      GLint ssy = sy;
-      tmpImage = (GLstencil *) malloc(width * height * sizeof(GLstencil));
-      if (!tmpImage) {
-         _mesa_error( ctx, GL_OUT_OF_MEMORY, "glCopyPixels" );
-         return;
-      }
-      p = tmpImage;
-      for (j = 0; j < height; j++, ssy += stepy) {
-         _swrast_read_stencil_span( ctx, rb, width, srcx, ssy, p );
-         p += width;
-      }
-      p = tmpImage;
-   }
-   else {
-      tmpImage = NULL;  /* silence compiler warning */
-      p = NULL;
-   }
-
-   for (j = 0; j < height; j++, sy += stepy, dy += stepy) {
-      GLstencil stencil[MAX_WIDTH];
-
-      /* Get stencil values */
-      if (overlapping) {
-         memcpy(stencil, p, width * sizeof(GLstencil));
-         p += width;
-      }
-      else {
-         _swrast_read_stencil_span( ctx, rb, width, srcx, sy, stencil );
-      }
-
-      _mesa_apply_stencil_transfer_ops(ctx, width, stencil);
-
-      /* Write stencil values */
-      if (zoom) {
-         _swrast_write_zoomed_stencil_span(ctx, destx, desty, width,
-                                           destx, dy, stencil);
-      }
-      else {
-         _swrast_write_stencil_span( ctx, width, destx, dy, stencil );
-      }
-   }
-
-   if (overlapping)
-      free(tmpImage);
-}
-
-
-/**
- * This isn't terribly efficient.  If a driver really has combined
- * depth/stencil buffers the driver should implement an optimized
- * CopyPixels function.
- */
-static void
-copy_depth_stencil_pixels(GLcontext *ctx,
-                          const GLint srcX, const GLint srcY,
-                          const GLint width, const GLint height,
-                          const GLint destX, const GLint destY)
-{
-   struct gl_renderbuffer *stencilReadRb, *depthReadRb, *depthDrawRb;
-   GLint sy, dy, stepy;
-   GLint j;
-   GLstencil *tempStencilImage = NULL, *stencilPtr = NULL;
-   GLfloat *tempDepthImage = NULL, *depthPtr = NULL;
-   const GLfloat depthScale = ctx->DrawBuffer->_DepthMaxF;
-   const GLuint stencilMask = ctx->Stencil.WriteMask[0];
-   const GLboolean zoom = ctx->Pixel.ZoomX != 1.0F || ctx->Pixel.ZoomY != 1.0F;
-   const GLboolean scaleOrBias
-      = ctx->Pixel.DepthScale != 1.0 || ctx->Pixel.DepthBias != 0.0;
-   GLint overlapping;
-
-   depthDrawRb = ctx->DrawBuffer->_DepthBuffer;
-   depthReadRb = ctx->ReadBuffer->_DepthBuffer;
-   stencilReadRb = ctx->ReadBuffer->_StencilBuffer;
-
-   ASSERT(depthDrawRb);
-   ASSERT(depthReadRb);
-   ASSERT(stencilReadRb);
-
-   if (ctx->DrawBuffer == ctx->ReadBuffer) {
-      overlapping = regions_overlap(srcX, srcY, destX, destY, width, height,
-                                    ctx->Pixel.ZoomX, ctx->Pixel.ZoomY);
-   }
-   else {
-      overlapping = GL_FALSE;
-   }
-
-   /* Determine if copy should be bottom-to-top or top-to-bottom */
-   if (!overlapping && srcY < destY) {
-      /* top-down  max-to-min */
-      sy = srcY + height - 1;
-      dy = destY + height - 1;
-      stepy = -1;
-   }
-   else {
-      /* bottom-up  min-to-max */
-      sy = srcY;
-      dy = destY;
-      stepy = 1;
-   }
-
-   if (overlapping) {
-      GLint ssy = sy;
-
-      if (stencilMask != 0x0) {
-         tempStencilImage
-            = (GLstencil *) malloc(width * height * sizeof(GLstencil));
-         if (!tempStencilImage) {
-            _mesa_error(ctx, GL_OUT_OF_MEMORY, "glCopyPixels");
-            return;
-         }
-
-         /* get copy of stencil pixels */
-         stencilPtr = tempStencilImage;
-         for (j = 0; j < height; j++, ssy += stepy) {
-            _swrast_read_stencil_span(ctx, stencilReadRb,
-                                      width, srcX, ssy, stencilPtr);
-            stencilPtr += width;
-         }
-         stencilPtr = tempStencilImage;
-      }
-
-      if (ctx->Depth.Mask) {
-         tempDepthImage
-            = (GLfloat *) malloc(width * height * sizeof(GLfloat));
-         if (!tempDepthImage) {
-            _mesa_error(ctx, GL_OUT_OF_MEMORY, "glCopyPixels");
-            free(tempStencilImage);
-            return;
-         }
-
-         /* get copy of depth pixels */
-         depthPtr = tempDepthImage;
-         for (j = 0; j < height; j++, ssy += stepy) {
-            _swrast_read_depth_span_float(ctx, depthReadRb,
-                                          width, srcX, ssy, depthPtr);
-            depthPtr += width;
-         }
-         depthPtr = tempDepthImage;
-      }
-   }
-
-   for (j = 0; j < height; j++, sy += stepy, dy += stepy) {
-      if (stencilMask != 0x0) {
-         GLstencil stencil[MAX_WIDTH];
-
-         /* Get stencil values */
-         if (overlapping) {
-            memcpy(stencil, stencilPtr, width * sizeof(GLstencil));
-            stencilPtr += width;
-         }
-         else {
-            _swrast_read_stencil_span(ctx, stencilReadRb,
-                                      width, srcX, sy, stencil);
-         }
-
-         _mesa_apply_stencil_transfer_ops(ctx, width, stencil);
-
-         /* Write values */
-         if (zoom) {
-            _swrast_write_zoomed_stencil_span(ctx, destX, destY, width,
-                                              destX, dy, stencil);
-         }
-         else {
-            _swrast_write_stencil_span( ctx, width, destX, dy, stencil );
-         }
-      }
-
-      if (ctx->Depth.Mask) {
-         GLfloat depth[MAX_WIDTH];
-         GLuint zVals32[MAX_WIDTH];
-         GLushort zVals16[MAX_WIDTH];
-         GLvoid *zVals;
-         GLuint zBytes;
-
-         /* get depth values */
-         if (overlapping) {
-            memcpy(depth, depthPtr, width * sizeof(GLfloat));
-            depthPtr += width;
-         }
-         else {
-            _swrast_read_depth_span_float(ctx, depthReadRb,
-                                          width, srcX, sy, depth);
-         }
-
-         /* scale & bias */
-         if (scaleOrBias) {
-            _mesa_scale_and_bias_depth(ctx, width, depth);
-         }
-         /* convert to integer Z values */
-         if (depthDrawRb->DataType == GL_UNSIGNED_SHORT) {
-            GLint k;
-            for (k = 0; k < width; k++)
-               zVals16[k] = (GLushort) (depth[k] * depthScale);
-            zVals = zVals16;
-            zBytes = 2;
-         }
-         else {
-            GLint k;
-            for (k = 0; k < width; k++)
-               zVals32[k] = (GLuint) (depth[k] * depthScale);
-            zVals = zVals32;
-            zBytes = 4;
-         }
-
-         /* Write values */
-         if (zoom) {
-            _swrast_write_zoomed_z_span(ctx, destX, destY, width,
-                                        destX, dy, zVals);
-         }
-         else {
-            _swrast_put_row(ctx, depthDrawRb, width, destX, dy, zVals, zBytes);
-         }
-      }
-   }
-
-   if (tempStencilImage)
-      free(tempStencilImage);
-
-   if (tempDepthImage)
-      free(tempDepthImage);
-}
-
-
-
-/**
- * Try to do a fast copy pixels.
- */
-static GLboolean
-fast_copy_pixels(GLcontext *ctx,
-                 GLint srcX, GLint srcY, GLsizei width, GLsizei height,
-                 GLint dstX, GLint dstY, GLenum type)
-{
-   struct gl_framebuffer *srcFb = ctx->ReadBuffer;
-   struct gl_framebuffer *dstFb = ctx->DrawBuffer;
-   struct gl_renderbuffer *srcRb, *dstRb;
-   GLint row, yStep;
-
-   if (SWRAST_CONTEXT(ctx)->_RasterMask != 0x0 ||
-       ctx->Pixel.ZoomX != 1.0F ||
-       ctx->Pixel.ZoomY != 1.0F ||
-       ctx->_ImageTransferState) {
-      /* can't handle these */
-      return GL_FALSE;
-   }
-
-   if (type == GL_COLOR) {
-      if (dstFb->_NumColorDrawBuffers != 1)
-         return GL_FALSE;
-      srcRb = srcFb->_ColorReadBuffer;
-      dstRb = dstFb->_ColorDrawBuffers[0];
-   }
-   else if (type == GL_STENCIL) {
-      srcRb = srcFb->_StencilBuffer;
-      dstRb = dstFb->_StencilBuffer;
-   }
-   else if (type == GL_DEPTH) {
-      srcRb = srcFb->_DepthBuffer;
-      dstRb = dstFb->_DepthBuffer;
-   }
-   else {
-      ASSERT(type == GL_DEPTH_STENCIL_EXT);
-      /* XXX correct? */
-      srcRb = srcFb->Attachment[BUFFER_DEPTH].Renderbuffer;
-      dstRb = dstFb->Attachment[BUFFER_DEPTH].Renderbuffer;
-   }
-
-   /* src and dst renderbuffers must be same format and type */
-   if (!srcRb || !dstRb ||
-       srcRb->DataType != dstRb->DataType ||
-       srcRb->_BaseFormat != dstRb->_BaseFormat) {
-      return GL_FALSE;
-   }
-
-   /* clipping not supported */
-   if (srcX < 0 || srcX + width > (GLint) srcFb->Width ||
-       srcY < 0 || srcY + height > (GLint) srcFb->Height ||
-       dstX < dstFb->_Xmin || dstX + width > dstFb->_Xmax ||
-       dstY < dstFb->_Ymin || dstY + height > dstFb->_Ymax) {
-      return GL_FALSE;
-   }
-
-   /* overlapping src/dst doesn't matter, just determine Y direction */
-   if (srcY < dstY) {
-      /* top-down  max-to-min */
-      srcY = srcY + height - 1;
-      dstY = dstY + height - 1;
-      yStep = -1;
-   }
-   else {
-      /* bottom-up  min-to-max */
-      yStep = 1;
-   }
-
-   for (row = 0; row < height; row++) {
-      GLuint temp[MAX_WIDTH][4];
-      srcRb->GetRow(ctx, srcRb, width, srcX, srcY, temp);
-      dstRb->PutRow(ctx, dstRb, width, dstX, dstY, temp, NULL);
-      srcY += yStep;
-      dstY += yStep;
-   }
-
-   return GL_TRUE;
-}
-
-
-/**
- * Do software-based glCopyPixels.
- * By time we get here, all parameters will have been error-checked.
- */
-void
-_swrast_CopyPixels( GLcontext *ctx,
-		    GLint srcx, GLint srcy, GLsizei width, GLsizei height,
-		    GLint destx, GLint desty, GLenum type )
-{
-   SWcontext *swrast = SWRAST_CONTEXT(ctx);
-   swrast_render_start(ctx);
-      
-   if (!_mesa_check_conditional_render(ctx))
-      return; /* don't copy */
-
-   if (swrast->NewState)
-      _swrast_validate_derived( ctx );
-
-   if (!fast_copy_pixels(ctx, srcx, srcy, width, height, destx, desty, type)) {
-      switch (type) {
-      case GL_COLOR:
-         copy_rgba_pixels( ctx, srcx, srcy, width, height, destx, desty );
-         break;
-      case GL_DEPTH:
-         copy_depth_pixels( ctx, srcx, srcy, width, height, destx, desty );
-         break;
-      case GL_STENCIL:
-         copy_stencil_pixels( ctx, srcx, srcy, width, height, destx, desty );
-         break;
-      case GL_DEPTH_STENCIL_EXT:
-         copy_depth_stencil_pixels(ctx, srcx, srcy, width, height, destx, desty);
-         break;
-      default:
-         _mesa_problem(ctx, "unexpected type in _swrast_CopyPixels");
-      }
-   }
-
-   swrast_render_finish(ctx);
-}
+/*

+ * 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/context.h"

+#include "main/colormac.h"

+#include "main/condrender.h"

+#include "main/macros.h"

+#include "main/pixeltransfer.h"

+#include "main/imports.h"

+

+#include "s_context.h"

+#include "s_depth.h"

+#include "s_span.h"

+#include "s_stencil.h"

+#include "s_zoom.h"

+

+

+

+/**

+ * Determine if there's overlap in an image copy.

+ * This test also compensates for the fact that copies are done from

+ * bottom to top and overlaps can sometimes be handled correctly

+ * without making a temporary image copy.

+ * \return GL_TRUE if the regions overlap, GL_FALSE otherwise.

+ */

+static GLboolean

+regions_overlap(GLint srcx, GLint srcy,

+                GLint dstx, GLint dsty,

+                GLint width, GLint height,

+                GLfloat zoomX, GLfloat zoomY)

+{

+   if (zoomX == 1.0 && zoomY == 1.0) {

+      /* no zoom */

+      if (srcx >= dstx + width || (srcx + width <= dstx)) {

+         return GL_FALSE;

+      }

+      else if (srcy < dsty) { /* this is OK */

+         return GL_FALSE;

+      }

+      else if (srcy > dsty + height) {

+         return GL_FALSE;

+      }

+      else {

+         return GL_TRUE;

+      }

+   }

+   else {

+      /* add one pixel of slop when zooming, just to be safe */

+      if (srcx > (dstx + ((zoomX > 0.0F) ? (width * zoomX + 1.0F) : 0.0F))) {

+         /* src is completely right of dest */

+         return GL_FALSE;

+      }

+      else if (srcx + width + 1.0F < dstx + ((zoomX > 0.0F) ? 0.0F : (width * zoomX))) {

+         /* src is completely left of dest */

+         return GL_FALSE;

+      }

+      else if ((srcy < dsty) && (srcy + height < dsty + (height * zoomY))) {

+         /* src is completely below dest */

+         return GL_FALSE;

+      }

+      else if ((srcy > dsty) && (srcy + height > dsty + (height * zoomY))) {

+         /* src is completely above dest */

+         return GL_FALSE;

+      }

+      else {

+         return GL_TRUE;

+      }

+   }

+}

+

+

+/**

+ * RGBA copypixels

+ */

+static void

+copy_rgba_pixels(struct gl_context *ctx, GLint srcx, GLint srcy,

+                 GLint width, GLint height, GLint destx, GLint desty)

+{

+   GLfloat *tmpImage, *p;

+   GLint sy, dy, stepy, row;

+   const GLboolean zoom = ctx->Pixel.ZoomX != 1.0F || ctx->Pixel.ZoomY != 1.0F;

+   GLint overlapping;

+   GLuint transferOps = ctx->_ImageTransferState;

+   SWspan span;

+

+   if (!ctx->ReadBuffer->_ColorReadBuffer) {

+      /* no readbuffer - OK */

+      return;

+   }

+

+   if (ctx->DrawBuffer == ctx->ReadBuffer) {

+      overlapping = regions_overlap(srcx, srcy, destx, desty, width, height,

+                                    ctx->Pixel.ZoomX, ctx->Pixel.ZoomY);

+   }

+   else {

+      overlapping = GL_FALSE;

+   }

+

+   /* Determine if copy should be done bottom-to-top or top-to-bottom */

+   if (!overlapping && srcy < desty) {

+      /* top-down  max-to-min */

+      sy = srcy + height - 1;

+      dy = desty + height - 1;

+      stepy = -1;

+   }

+   else {

+      /* bottom-up  min-to-max */

+      sy = srcy;

+      dy = desty;

+      stepy = 1;

+   }

+

+   INIT_SPAN(span, GL_BITMAP);

+   _swrast_span_default_attribs(ctx, &span);

+   span.arrayMask = SPAN_RGBA;

+   span.arrayAttribs = FRAG_BIT_COL0; /* we'll fill in COL0 attrib values */

+

+   if (overlapping) {

+      tmpImage = (GLfloat *) malloc(width * height * sizeof(GLfloat) * 4);

+      if (!tmpImage) {

+         _mesa_error( ctx, GL_OUT_OF_MEMORY, "glCopyPixels" );

+         return;

+      }

+      /* read the source image as RGBA/float */

+      p = tmpImage;

+      for (row = 0; row < height; row++) {

+         _swrast_read_rgba_span( ctx, ctx->ReadBuffer->_ColorReadBuffer,

+                                 width, srcx, sy + row, GL_FLOAT, p );

+         p += width * 4;

+      }

+      p = tmpImage;

+   }

+   else {

+      tmpImage = NULL;  /* silence compiler warnings */

+      p = NULL;

+   }

+

+   ASSERT(width < MAX_WIDTH);

+

+   for (row = 0; row < height; row++, sy += stepy, dy += stepy) {

+      GLvoid *rgba = span.array->attribs[FRAG_ATTRIB_COL0];

+

+      /* Get row/span of source pixels */

+      if (overlapping) {

+         /* get from buffered image */

+         memcpy(rgba, p, width * sizeof(GLfloat) * 4);

+         p += width * 4;

+      }

+      else {

+         /* get from framebuffer */

+         _swrast_read_rgba_span( ctx, ctx->ReadBuffer->_ColorReadBuffer,

+                                 width, srcx, sy, GL_FLOAT, rgba );

+      }

+

+      if (transferOps) {

+         _mesa_apply_rgba_transfer_ops(ctx, transferOps, width,

+                                       (GLfloat (*)[4]) rgba);

+      }

+

+      /* Write color span */

+      span.x = destx;

+      span.y = dy;

+      span.end = width;

+      span.array->ChanType = GL_FLOAT;

+      if (zoom) {

+         _swrast_write_zoomed_rgba_span(ctx, destx, desty, &span, rgba);

+      }

+      else {

+         _swrast_write_rgba_span(ctx, &span);

+      }

+   }

+

+   span.array->ChanType = CHAN_TYPE; /* restore */

+

+   if (overlapping)

+      free(tmpImage);

+}

+

+

+/**

+ * Convert floating point Z values to integer Z values with pixel transfer's

+ * Z scale and bias.

+ */

+static void

+scale_and_bias_z(struct gl_context *ctx, GLuint width,

+                 const GLfloat depth[], GLuint z[])

+{

+   const GLuint depthMax = ctx->DrawBuffer->_DepthMax;

+   GLuint i;

+

+   if (depthMax <= 0xffffff &&

+       ctx->Pixel.DepthScale == 1.0 &&

+       ctx->Pixel.DepthBias == 0.0) {

+      /* no scale or bias and no clamping and no worry of overflow */

+      const GLfloat depthMaxF = ctx->DrawBuffer->_DepthMaxF;

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

+         z[i] = (GLuint) (depth[i] * depthMaxF);

+      }

+   }

+   else {

+      /* need to be careful with overflow */

+      const GLdouble depthMaxF = ctx->DrawBuffer->_DepthMaxF;

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

+         GLdouble d = depth[i] * ctx->Pixel.DepthScale + ctx->Pixel.DepthBias;

+         d = CLAMP(d, 0.0, 1.0) * depthMaxF;

+         if (d >= depthMaxF)

+            z[i] = depthMax;

+         else

+            z[i] = (GLuint) d;

+      }

+   }

+}

+

+

+

+/*

+ * TODO: Optimize!!!!

+ */

+static void

+copy_depth_pixels( struct gl_context *ctx, GLint srcx, GLint srcy,

+                   GLint width, GLint height,

+                   GLint destx, GLint desty )

+{

+   struct gl_framebuffer *fb = ctx->ReadBuffer;

+   struct gl_renderbuffer *readRb = fb->_DepthBuffer;

+   GLfloat *p, *tmpImage;

+   GLint sy, dy, stepy;

+   GLint j;

+   const GLboolean zoom = ctx->Pixel.ZoomX != 1.0F || ctx->Pixel.ZoomY != 1.0F;

+   GLint overlapping;

+   SWspan span;

+

+   if (!readRb) {

+      /* no readbuffer - OK */

+      return;

+   }

+

+   INIT_SPAN(span, GL_BITMAP);

+   _swrast_span_default_attribs(ctx, &span);

+   span.arrayMask = SPAN_Z;

+

+   if (ctx->DrawBuffer == ctx->ReadBuffer) {

+      overlapping = regions_overlap(srcx, srcy, destx, desty, width, height,

+                                    ctx->Pixel.ZoomX, ctx->Pixel.ZoomY);

+   }

+   else {

+      overlapping = GL_FALSE;

+   }

+

+   /* Determine if copy should be bottom-to-top or top-to-bottom */

+   if (!overlapping && srcy < desty) {

+      /* top-down  max-to-min */

+      sy = srcy + height - 1;

+      dy = desty + height - 1;

+      stepy = -1;

+   }

+   else {

+      /* bottom-up  min-to-max */

+      sy = srcy;

+      dy = desty;

+      stepy = 1;

+   }

+

+   if (overlapping) {

+      GLint ssy = sy;

+      tmpImage = (GLfloat *) malloc(width * height * sizeof(GLfloat));

+      if (!tmpImage) {

+         _mesa_error( ctx, GL_OUT_OF_MEMORY, "glCopyPixels" );

+         return;

+      }

+      p = tmpImage;

+      for (j = 0; j < height; j++, ssy += stepy) {

+         _swrast_read_depth_span_float(ctx, readRb, width, srcx, ssy, p);

+         p += width;

+      }

+      p = tmpImage;

+   }

+   else {

+      tmpImage = NULL;  /* silence compiler warning */

+      p = NULL;

+   }

+

+   for (j = 0; j < height; j++, sy += stepy, dy += stepy) {

+      GLfloat depth[MAX_WIDTH];

+      /* get depth values */

+      if (overlapping) {

+         memcpy(depth, p, width * sizeof(GLfloat));

+         p += width;

+      }

+      else {

+         _swrast_read_depth_span_float(ctx, readRb, width, srcx, sy, depth);

+      }

+

+      /* apply scale and bias */

+      scale_and_bias_z(ctx, width, depth, span.array->z);

+

+      /* write depth values */

+      span.x = destx;

+      span.y = dy;

+      span.end = width;

+      if (zoom)

+         _swrast_write_zoomed_depth_span(ctx, destx, desty, &span);

+      else

+         _swrast_write_rgba_span(ctx, &span);

+   }

+

+   if (overlapping)

+      free(tmpImage);

+}

+

+

+

+static void

+copy_stencil_pixels( struct gl_context *ctx, GLint srcx, GLint srcy,

+                     GLint width, GLint height,

+                     GLint destx, GLint desty )

+{

+   struct gl_framebuffer *fb = ctx->ReadBuffer;

+   struct gl_renderbuffer *rb = fb->_StencilBuffer;

+   GLint sy, dy, stepy;

+   GLint j;

+   GLstencil *p, *tmpImage;

+   const GLboolean zoom = ctx->Pixel.ZoomX != 1.0F || ctx->Pixel.ZoomY != 1.0F;

+   GLint overlapping;

+

+   if (!rb) {

+      /* no readbuffer - OK */

+      return;

+   }

+

+   if (ctx->DrawBuffer == ctx->ReadBuffer) {

+      overlapping = regions_overlap(srcx, srcy, destx, desty, width, height,

+                                    ctx->Pixel.ZoomX, ctx->Pixel.ZoomY);

+   }

+   else {

+      overlapping = GL_FALSE;

+   }

+

+   /* Determine if copy should be bottom-to-top or top-to-bottom */

+   if (!overlapping && srcy < desty) {

+      /* top-down  max-to-min */

+      sy = srcy + height - 1;

+      dy = desty + height - 1;

+      stepy = -1;

+   }

+   else {

+      /* bottom-up  min-to-max */

+      sy = srcy;

+      dy = desty;

+      stepy = 1;

+   }

+

+   if (overlapping) {

+      GLint ssy = sy;

+      tmpImage = (GLstencil *) malloc(width * height * sizeof(GLstencil));

+      if (!tmpImage) {

+         _mesa_error( ctx, GL_OUT_OF_MEMORY, "glCopyPixels" );

+         return;

+      }

+      p = tmpImage;

+      for (j = 0; j < height; j++, ssy += stepy) {

+         _swrast_read_stencil_span( ctx, rb, width, srcx, ssy, p );

+         p += width;

+      }

+      p = tmpImage;

+   }

+   else {

+      tmpImage = NULL;  /* silence compiler warning */

+      p = NULL;

+   }

+

+   for (j = 0; j < height; j++, sy += stepy, dy += stepy) {

+      GLstencil stencil[MAX_WIDTH];

+

+      /* Get stencil values */

+      if (overlapping) {

+         memcpy(stencil, p, width * sizeof(GLstencil));

+         p += width;

+      }

+      else {

+         _swrast_read_stencil_span( ctx, rb, width, srcx, sy, stencil );

+      }

+

+      _mesa_apply_stencil_transfer_ops(ctx, width, stencil);

+

+      /* Write stencil values */

+      if (zoom) {

+         _swrast_write_zoomed_stencil_span(ctx, destx, desty, width,

+                                           destx, dy, stencil);

+      }

+      else {

+         _swrast_write_stencil_span( ctx, width, destx, dy, stencil );

+      }

+   }

+

+   if (overlapping)

+      free(tmpImage);

+}

+

+

+/**

+ * This isn't terribly efficient.  If a driver really has combined

+ * depth/stencil buffers the driver should implement an optimized

+ * CopyPixels function.

+ */

+static void

+copy_depth_stencil_pixels(struct gl_context *ctx,

+                          const GLint srcX, const GLint srcY,

+                          const GLint width, const GLint height,

+                          const GLint destX, const GLint destY)

+{

+   struct gl_renderbuffer *stencilReadRb, *depthReadRb, *depthDrawRb;

+   GLint sy, dy, stepy;

+   GLint j;

+   GLstencil *tempStencilImage = NULL, *stencilPtr = NULL;

+   GLfloat *tempDepthImage = NULL, *depthPtr = NULL;

+   const GLfloat depthScale = ctx->DrawBuffer->_DepthMaxF;

+   const GLuint stencilMask = ctx->Stencil.WriteMask[0];

+   const GLboolean zoom = ctx->Pixel.ZoomX != 1.0F || ctx->Pixel.ZoomY != 1.0F;

+   const GLboolean scaleOrBias

+      = ctx->Pixel.DepthScale != 1.0 || ctx->Pixel.DepthBias != 0.0;

+   GLint overlapping;

+

+   depthDrawRb = ctx->DrawBuffer->_DepthBuffer;

+   depthReadRb = ctx->ReadBuffer->_DepthBuffer;

+   stencilReadRb = ctx->ReadBuffer->_StencilBuffer;

+

+   ASSERT(depthDrawRb);

+   ASSERT(depthReadRb);

+   ASSERT(stencilReadRb);

+

+   if (ctx->DrawBuffer == ctx->ReadBuffer) {

+      overlapping = regions_overlap(srcX, srcY, destX, destY, width, height,

+                                    ctx->Pixel.ZoomX, ctx->Pixel.ZoomY);

+   }

+   else {

+      overlapping = GL_FALSE;

+   }

+

+   /* Determine if copy should be bottom-to-top or top-to-bottom */

+   if (!overlapping && srcY < destY) {

+      /* top-down  max-to-min */

+      sy = srcY + height - 1;

+      dy = destY + height - 1;

+      stepy = -1;

+   }

+   else {

+      /* bottom-up  min-to-max */

+      sy = srcY;

+      dy = destY;

+      stepy = 1;

+   }

+

+   if (overlapping) {

+      GLint ssy = sy;

+

+      if (stencilMask != 0x0) {

+         tempStencilImage

+            = (GLstencil *) malloc(width * height * sizeof(GLstencil));

+         if (!tempStencilImage) {

+            _mesa_error(ctx, GL_OUT_OF_MEMORY, "glCopyPixels");

+            return;

+         }

+

+         /* get copy of stencil pixels */

+         stencilPtr = tempStencilImage;

+         for (j = 0; j < height; j++, ssy += stepy) {

+            _swrast_read_stencil_span(ctx, stencilReadRb,

+                                      width, srcX, ssy, stencilPtr);

+            stencilPtr += width;

+         }

+         stencilPtr = tempStencilImage;

+      }

+

+      if (ctx->Depth.Mask) {

+         tempDepthImage

+            = (GLfloat *) malloc(width * height * sizeof(GLfloat));

+         if (!tempDepthImage) {

+            _mesa_error(ctx, GL_OUT_OF_MEMORY, "glCopyPixels");

+            free(tempStencilImage);

+            return;

+         }

+

+         /* get copy of depth pixels */

+         depthPtr = tempDepthImage;

+         for (j = 0; j < height; j++, ssy += stepy) {

+            _swrast_read_depth_span_float(ctx, depthReadRb,

+                                          width, srcX, ssy, depthPtr);

+            depthPtr += width;

+         }

+         depthPtr = tempDepthImage;

+      }

+   }

+

+   for (j = 0; j < height; j++, sy += stepy, dy += stepy) {

+      if (stencilMask != 0x0) {

+         GLstencil stencil[MAX_WIDTH];

+

+         /* Get stencil values */

+         if (overlapping) {

+            memcpy(stencil, stencilPtr, width * sizeof(GLstencil));

+            stencilPtr += width;

+         }

+         else {

+            _swrast_read_stencil_span(ctx, stencilReadRb,

+                                      width, srcX, sy, stencil);

+         }

+

+         _mesa_apply_stencil_transfer_ops(ctx, width, stencil);

+

+         /* Write values */

+         if (zoom) {

+            _swrast_write_zoomed_stencil_span(ctx, destX, destY, width,

+                                              destX, dy, stencil);

+         }

+         else {

+            _swrast_write_stencil_span( ctx, width, destX, dy, stencil );

+         }

+      }

+

+      if (ctx->Depth.Mask) {

+         GLfloat depth[MAX_WIDTH];

+         GLuint zVals32[MAX_WIDTH];

+         GLushort zVals16[MAX_WIDTH];

+         GLvoid *zVals;

+         GLuint zBytes;

+

+         /* get depth values */

+         if (overlapping) {

+            memcpy(depth, depthPtr, width * sizeof(GLfloat));

+            depthPtr += width;

+         }

+         else {

+            _swrast_read_depth_span_float(ctx, depthReadRb,

+                                          width, srcX, sy, depth);

+         }

+

+         /* scale & bias */

+         if (scaleOrBias) {

+            _mesa_scale_and_bias_depth(ctx, width, depth);

+         }

+         /* convert to integer Z values */

+         if (depthDrawRb->DataType == GL_UNSIGNED_SHORT) {

+            GLint k;

+            for (k = 0; k < width; k++)

+               zVals16[k] = (GLushort) (depth[k] * depthScale);

+            zVals = zVals16;

+            zBytes = 2;

+         }

+         else {

+            GLint k;

+            for (k = 0; k < width; k++)

+               zVals32[k] = (GLuint) (depth[k] * depthScale);

+            zVals = zVals32;

+            zBytes = 4;

+         }

+

+         /* Write values */

+         if (zoom) {

+            _swrast_write_zoomed_z_span(ctx, destX, destY, width,

+                                        destX, dy, zVals);

+         }

+         else {

+            _swrast_put_row(ctx, depthDrawRb, width, destX, dy, zVals, zBytes);

+         }

+      }

+   }

+

+   if (tempStencilImage)

+      free(tempStencilImage);

+

+   if (tempDepthImage)

+      free(tempDepthImage);

+}

+

+

+

+/**

+ * Try to do a fast copy pixels.

+ */

+static GLboolean

+fast_copy_pixels(struct gl_context *ctx,

+                 GLint srcX, GLint srcY, GLsizei width, GLsizei height,

+                 GLint dstX, GLint dstY, GLenum type)

+{

+   struct gl_framebuffer *srcFb = ctx->ReadBuffer;

+   struct gl_framebuffer *dstFb = ctx->DrawBuffer;

+   struct gl_renderbuffer *srcRb, *dstRb;

+   GLint row, yStep;

+

+   if (SWRAST_CONTEXT(ctx)->_RasterMask != 0x0 ||

+       ctx->Pixel.ZoomX != 1.0F ||

+       ctx->Pixel.ZoomY != 1.0F ||

+       ctx->_ImageTransferState) {

+      /* can't handle these */

+      return GL_FALSE;

+   }

+

+   if (type == GL_COLOR) {

+      if (dstFb->_NumColorDrawBuffers != 1)

+         return GL_FALSE;

+      srcRb = srcFb->_ColorReadBuffer;

+      dstRb = dstFb->_ColorDrawBuffers[0];

+   }

+   else if (type == GL_STENCIL) {

+      srcRb = srcFb->_StencilBuffer;

+      dstRb = dstFb->_StencilBuffer;

+   }

+   else if (type == GL_DEPTH) {

+      srcRb = srcFb->_DepthBuffer;

+      dstRb = dstFb->_DepthBuffer;

+   }

+   else {

+      ASSERT(type == GL_DEPTH_STENCIL_EXT);

+      /* XXX correct? */

+      srcRb = srcFb->Attachment[BUFFER_DEPTH].Renderbuffer;

+      dstRb = dstFb->Attachment[BUFFER_DEPTH].Renderbuffer;

+   }

+

+   /* src and dst renderbuffers must be same format and type */

+   if (!srcRb || !dstRb ||

+       srcRb->DataType != dstRb->DataType ||

+       srcRb->_BaseFormat != dstRb->_BaseFormat) {

+      return GL_FALSE;

+   }

+

+   /* clipping not supported */

+   if (srcX < 0 || srcX + width > (GLint) srcFb->Width ||

+       srcY < 0 || srcY + height > (GLint) srcFb->Height ||

+       dstX < dstFb->_Xmin || dstX + width > dstFb->_Xmax ||

+       dstY < dstFb->_Ymin || dstY + height > dstFb->_Ymax) {

+      return GL_FALSE;

+   }

+

+   /* overlapping src/dst doesn't matter, just determine Y direction */

+   if (srcY < dstY) {

+      /* top-down  max-to-min */

+      srcY = srcY + height - 1;

+      dstY = dstY + height - 1;

+      yStep = -1;

+   }

+   else {

+      /* bottom-up  min-to-max */

+      yStep = 1;

+   }

+

+   for (row = 0; row < height; row++) {

+      GLuint temp[MAX_WIDTH][4];

+      srcRb->GetRow(ctx, srcRb, width, srcX, srcY, temp);

+      dstRb->PutRow(ctx, dstRb, width, dstX, dstY, temp, NULL);

+      srcY += yStep;

+      dstY += yStep;

+   }

+

+   return GL_TRUE;

+}

+

+

+/**

+ * Do software-based glCopyPixels.

+ * By time we get here, all parameters will have been error-checked.

+ */

+void

+_swrast_CopyPixels( struct gl_context *ctx,

+		    GLint srcx, GLint srcy, GLsizei width, GLsizei height,

+		    GLint destx, GLint desty, GLenum type )

+{

+   SWcontext *swrast = SWRAST_CONTEXT(ctx);

+   swrast_render_start(ctx);

+      

+   if (!_mesa_check_conditional_render(ctx))

+      return; /* don't copy */

+

+   if (swrast->NewState)

+      _swrast_validate_derived( ctx );

+

+   if (!fast_copy_pixels(ctx, srcx, srcy, width, height, destx, desty, type)) {

+      switch (type) {

+      case GL_COLOR:

+         copy_rgba_pixels( ctx, srcx, srcy, width, height, destx, desty );

+         break;

+      case GL_DEPTH:

+         copy_depth_pixels( ctx, srcx, srcy, width, height, destx, desty );

+         break;

+      case GL_STENCIL:

+         copy_stencil_pixels( ctx, srcx, srcy, width, height, destx, desty );

+         break;

+      case GL_DEPTH_STENCIL_EXT:

+         copy_depth_stencil_pixels(ctx, srcx, srcy, width, height, destx, desty);

+         break;

+      default:

+         _mesa_problem(ctx, "unexpected type in _swrast_CopyPixels");

+      }

+   }

+

+   swrast_render_finish(ctx);

+}

diff --git a/mesalib/src/mesa/swrast/s_depth.c b/mesalib/src/mesa/swrast/s_depth.c
index f952fd6ba..90b9ee572 100644
--- a/mesalib/src/mesa/swrast/s_depth.c
+++ b/mesalib/src/mesa/swrast/s_depth.c
@@ -1,1484 +1,1484 @@
-/*
- * Mesa 3-D graphics library
- * Version:  7.2.1
- *
- * Copyright (C) 1999-2008  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/context.h"
-#include "main/formats.h"
-#include "main/macros.h"
-#include "main/imports.h"
-
-#include "s_depth.h"
-#include "s_span.h"
-
-
-/**
- * Do depth test for a horizontal span of fragments.
- * Input:  zbuffer - array of z values in the zbuffer
- *         z - array of fragment z values
- * Return:  number of fragments which pass the test.
- */
-static GLuint
-depth_test_span16( GLcontext *ctx, GLuint n,
-                   GLushort zbuffer[], const GLuint z[], GLubyte mask[] )
-{
-   GLuint passed = 0;
-
-   /* switch cases ordered from most frequent to less frequent */
-   switch (ctx->Depth.Func) {
-      case GL_LESS:
-         if (ctx->Depth.Mask) {
-	    /* Update Z buffer */
-            GLuint i;
-	    for (i=0; i<n; i++) {
-	       if (mask[i]) {
-		  if (z[i] < zbuffer[i]) {
-		     /* pass */
-		     zbuffer[i] = z[i];
-		     passed++;
-		  }
-		  else {
-		     /* fail */
-		     mask[i] = 0;
-		  }
-	       }
-	    }
-	 }
-	 else {
-	    /* Don't update Z buffer */
-            GLuint i;
-	    for (i=0; i<n; i++) {
-	       if (mask[i]) {
-		  if (z[i] < zbuffer[i]) {
-		     /* pass */
-		     passed++;
-		  }
-		  else {
-		     mask[i] = 0;
-		  }
-	       }
-	    }
-	 }
-	 break;
-      case GL_LEQUAL:
-	 if (ctx->Depth.Mask) {
-	    /* Update Z buffer */
-            GLuint i;
-	    for (i=0;i<n;i++) {
-	       if (mask[i]) {
-		  if (z[i] <= zbuffer[i]) {
-		     zbuffer[i] = z[i];
-		     passed++;
-		  }
-		  else {
-		     mask[i] = 0;
-		  }
-	       }
-	    }
-	 }
-	 else {
-	    /* Don't update Z buffer */
-            GLuint i;
-	    for (i=0;i<n;i++) {
-	       if (mask[i]) {
-		  if (z[i] <= zbuffer[i]) {
-		     /* pass */
-		     passed++;
-		  }
-		  else {
-		     mask[i] = 0;
-		  }
-	       }
-	    }
-	 }
-	 break;
-      case GL_GEQUAL:
-	 if (ctx->Depth.Mask) {
-	    /* Update Z buffer */
-            GLuint i;
-	    for (i=0;i<n;i++) {
-	       if (mask[i]) {
-		  if (z[i] >= zbuffer[i]) {
-		     zbuffer[i] = z[i];
-		     passed++;
-		  }
-		  else {
-		     mask[i] = 0;
-		  }
-	       }
-	    }
-	 }
-	 else {
-	    /* Don't update Z buffer */
-            GLuint i;
-	    for (i=0;i<n;i++) {
-	       if (mask[i]) {
-		  if (z[i] >= zbuffer[i]) {
-		     /* pass */
-		     passed++;
-		  }
-		  else {
-		     mask[i] = 0;
-		  }
-	       }
-	    }
-	 }
-	 break;
-      case GL_GREATER:
-	 if (ctx->Depth.Mask) {
-	    /* Update Z buffer */
-            GLuint i;
-	    for (i=0;i<n;i++) {
-	       if (mask[i]) {
-		  if (z[i] > zbuffer[i]) {
-		     zbuffer[i] = z[i];
-		     passed++;
-		  }
-		  else {
-		     mask[i] = 0;
-		  }
-	       }
-	    }
-	 }
-	 else {
-	    /* Don't update Z buffer */
-            GLuint i;
-	    for (i=0;i<n;i++) {
-	       if (mask[i]) {
-		  if (z[i] > zbuffer[i]) {
-		     /* pass */
-		     passed++;
-		  }
-		  else {
-		     mask[i] = 0;
-		  }
-	       }
-	    }
-	 }
-	 break;
-      case GL_NOTEQUAL:
-	 if (ctx->Depth.Mask) {
-	    /* Update Z buffer */
-            GLuint i;
-	    for (i=0;i<n;i++) {
-	       if (mask[i]) {
-		  if (z[i] != zbuffer[i]) {
-		     zbuffer[i] = z[i];
-		     passed++;
-		  }
-		  else {
-		     mask[i] = 0;
-		  }
-	       }
-	    }
-	 }
-	 else {
-	    /* Don't update Z buffer */
-            GLuint i;
-	    for (i=0;i<n;i++) {
-	       if (mask[i]) {
-		  if (z[i] != zbuffer[i]) {
-		     /* pass */
-		     passed++;
-		  }
-		  else {
-		     mask[i] = 0;
-		  }
-	       }
-	    }
-	 }
-	 break;
-      case GL_EQUAL:
-	 if (ctx->Depth.Mask) {
-	    /* Update Z buffer */
-            GLuint i;
-	    for (i=0;i<n;i++) {
-	       if (mask[i]) {
-		  if (z[i] == zbuffer[i]) {
-		     zbuffer[i] = z[i];
-		     passed++;
-		  }
-		  else {
-		     mask[i] = 0;
-		  }
-	       }
-	    }
-	 }
-	 else {
-	    /* Don't update Z buffer */
-            GLuint i;
-	    for (i=0;i<n;i++) {
-	       if (mask[i]) {
-		  if (z[i] == zbuffer[i]) {
-		     /* pass */
-		     passed++;
-		  }
-		  else {
-		     mask[i] = 0;
-		  }
-	       }
-	    }
-	 }
-	 break;
-      case GL_ALWAYS:
-	 if (ctx->Depth.Mask) {
-	    /* Update Z buffer */
-            GLuint i;
-	    for (i=0;i<n;i++) {
-	       if (mask[i]) {
-		  zbuffer[i] = z[i];
-		  passed++;
-	       }
-	    }
-	 }
-	 else {
-	    /* Don't update Z buffer or mask */
-	    passed = n;
-	 }
-	 break;
-      case GL_NEVER:
-         memset(mask, 0, n * sizeof(GLubyte));
-	 break;
-      default:
-         _mesa_problem(ctx, "Bad depth func in depth_test_span16");
-   }
-
-   return passed;
-}
-
-
-static GLuint
-depth_test_span32( GLcontext *ctx, GLuint n,
-                   GLuint zbuffer[], const GLuint z[], GLubyte mask[] )
-{
-   GLuint passed = 0;
-
-   /* switch cases ordered from most frequent to less frequent */
-   switch (ctx->Depth.Func) {
-      case GL_LESS:
-         if (ctx->Depth.Mask) {
-	    /* Update Z buffer */
-            GLuint i;
-	    for (i=0; i<n; i++) {
-	       if (mask[i]) {
-		  if (z[i] < zbuffer[i]) {
-		     /* pass */
-		     zbuffer[i] = z[i];
-		     passed++;
-		  }
-		  else {
-		     /* fail */
-		     mask[i] = 0;
-		  }
-	       }
-	    }
-	 }
-	 else {
-	    /* Don't update Z buffer */
-            GLuint i;
-	    for (i=0; i<n; i++) {
-	       if (mask[i]) {
-		  if (z[i] < zbuffer[i]) {
-		     /* pass */
-		     passed++;
-		  }
-		  else {
-		     mask[i] = 0;
-		  }
-	       }
-	    }
-	 }
-	 break;
-      case GL_LEQUAL:
-	 if (ctx->Depth.Mask) {
-	    /* Update Z buffer */
-            GLuint i;
-	    for (i=0;i<n;i++) {
-	       if (mask[i]) {
-		  if (z[i] <= zbuffer[i]) {
-		     zbuffer[i] = z[i];
-		     passed++;
-		  }
-		  else {
-		     mask[i] = 0;
-		  }
-	       }
-	    }
-	 }
-	 else {
-	    /* Don't update Z buffer */
-            GLuint i;
-	    for (i=0;i<n;i++) {
-	       if (mask[i]) {
-		  if (z[i] <= zbuffer[i]) {
-		     /* pass */
-		     passed++;
-		  }
-		  else {
-		     mask[i] = 0;
-		  }
-	       }
-	    }
-	 }
-	 break;
-      case GL_GEQUAL:
-	 if (ctx->Depth.Mask) {
-	    /* Update Z buffer */
-            GLuint i;
-	    for (i=0;i<n;i++) {
-	       if (mask[i]) {
-		  if (z[i] >= zbuffer[i]) {
-		     zbuffer[i] = z[i];
-		     passed++;
-		  }
-		  else {
-		     mask[i] = 0;
-		  }
-	       }
-	    }
-	 }
-	 else {
-	    /* Don't update Z buffer */
-            GLuint i;
-	    for (i=0;i<n;i++) {
-	       if (mask[i]) {
-		  if (z[i] >= zbuffer[i]) {
-		     /* pass */
-		     passed++;
-		  }
-		  else {
-		     mask[i] = 0;
-		  }
-	       }
-	    }
-	 }
-	 break;
-      case GL_GREATER:
-	 if (ctx->Depth.Mask) {
-	    /* Update Z buffer */
-            GLuint i;
-	    for (i=0;i<n;i++) {
-	       if (mask[i]) {
-		  if (z[i] > zbuffer[i]) {
-		     zbuffer[i] = z[i];
-		     passed++;
-		  }
-		  else {
-		     mask[i] = 0;
-		  }
-	       }
-	    }
-	 }
-	 else {
-	    /* Don't update Z buffer */
-            GLuint i;
-	    for (i=0;i<n;i++) {
-	       if (mask[i]) {
-		  if (z[i] > zbuffer[i]) {
-		     /* pass */
-		     passed++;
-		  }
-		  else {
-		     mask[i] = 0;
-		  }
-	       }
-	    }
-	 }
-	 break;
-      case GL_NOTEQUAL:
-	 if (ctx->Depth.Mask) {
-	    /* Update Z buffer */
-            GLuint i;
-	    for (i=0;i<n;i++) {
-	       if (mask[i]) {
-		  if (z[i] != zbuffer[i]) {
-		     zbuffer[i] = z[i];
-		     passed++;
-		  }
-		  else {
-		     mask[i] = 0;
-		  }
-	       }
-	    }
-	 }
-	 else {
-	    /* Don't update Z buffer */
-            GLuint i;
-	    for (i=0;i<n;i++) {
-	       if (mask[i]) {
-		  if (z[i] != zbuffer[i]) {
-		     /* pass */
-		     passed++;
-		  }
-		  else {
-		     mask[i] = 0;
-		  }
-	       }
-	    }
-	 }
-	 break;
-      case GL_EQUAL:
-	 if (ctx->Depth.Mask) {
-	    /* Update Z buffer */
-            GLuint i;
-	    for (i=0;i<n;i++) {
-	       if (mask[i]) {
-		  if (z[i] == zbuffer[i]) {
-		     zbuffer[i] = z[i];
-		     passed++;
-		  }
-		  else {
-		     mask[i] = 0;
-		  }
-	       }
-	    }
-	 }
-	 else {
-	    /* Don't update Z buffer */
-            GLuint i;
-	    for (i=0;i<n;i++) {
-	       if (mask[i]) {
-		  if (z[i] == zbuffer[i]) {
-		     /* pass */
-		     passed++;
-		  }
-		  else {
-		     mask[i] = 0;
-		  }
-	       }
-	    }
-	 }
-	 break;
-      case GL_ALWAYS:
-	 if (ctx->Depth.Mask) {
-	    /* Update Z buffer */
-            GLuint i;
-	    for (i=0;i<n;i++) {
-	       if (mask[i]) {
-		  zbuffer[i] = z[i];
-		  passed++;
-	       }
-	    }
-	 }
-	 else {
-	    /* Don't update Z buffer or mask */
-	    passed = n;
-	 }
-	 break;
-      case GL_NEVER:
-         memset(mask, 0, n * sizeof(GLubyte));
-	 break;
-      default:
-         _mesa_problem(ctx, "Bad depth func in depth_test_span32");
-   }
-
-   return passed;
-}
-
-
-
-/**
- * Clamp fragment Z values to the depth near/far range (glDepthRange()).
- * This is used when GL_ARB_depth_clamp/GL_DEPTH_CLAMP is turned on.
- * In that case, vertexes are not clipped against the near/far planes
- * so rasterization will produce fragment Z values outside the usual
- * [0,1] range.
- */
-void
-_swrast_depth_clamp_span( GLcontext *ctx, SWspan *span )
-{
-   struct gl_framebuffer *fb = ctx->DrawBuffer;
-   const GLuint count = span->end;
-   GLint *zValues = (GLint *) span->array->z; /* sign change */
-   GLint min, max;
-   GLfloat min_f, max_f;
-   GLuint i;
-
-   if (ctx->Viewport.Near < ctx->Viewport.Far) {
-      min_f = ctx->Viewport.Near;
-      max_f = ctx->Viewport.Far;
-   } else {
-      min_f = ctx->Viewport.Far;
-      max_f = ctx->Viewport.Near;
-   }
-
-   /* Convert floating point values in [0,1] to device Z coordinates in
-    * [0, DepthMax].
-    * ex: If the Z buffer has 24 bits, DepthMax = 0xffffff.
-    * 
-    * XXX this all falls apart if we have 31 or more bits of Z because
-    * the triangle rasterization code produces unsigned Z values.  Negative
-    * vertex Z values come out as large fragment Z uints.
-    */
-   min = (GLint) (min_f * fb->_DepthMaxF);
-   max = (GLint) (max_f * fb->_DepthMaxF);
-   if (max < 0)
-      max = 0x7fffffff; /* catch over flow for 30-bit z */
-
-   /* Note that we do the comparisons here using signed integers.
-    */
-   for (i = 0; i < count; i++) {
-      if (zValues[i] < min)
-	 zValues[i] = min;
-      if (zValues[i] > max)
-	 zValues[i] = max;
-   }
-}
-
-
-
-/*
- * Apply depth test to span of fragments.
- */
-static GLuint
-depth_test_span( GLcontext *ctx, SWspan *span)
-{
-   struct gl_framebuffer *fb = ctx->DrawBuffer;
-   struct gl_renderbuffer *rb = fb->_DepthBuffer;
-   const GLint x = span->x;
-   const GLint y = span->y;
-   const GLuint count = span->end;
-   const GLuint *zValues = span->array->z;
-   GLubyte *mask = span->array->mask;
-   GLuint passed;
-
-   ASSERT((span->arrayMask & SPAN_XY) == 0);
-   ASSERT(span->arrayMask & SPAN_Z);
-   
-   if (rb->GetPointer(ctx, rb, 0, 0)) {
-      /* Directly access buffer */
-      if (rb->DataType == GL_UNSIGNED_SHORT) {
-         GLushort *zbuffer = (GLushort *) rb->GetPointer(ctx, rb, x, y);
-         passed = depth_test_span16(ctx, count, zbuffer, zValues, mask);
-      }
-      else {
-         GLuint *zbuffer = (GLuint *) rb->GetPointer(ctx, rb, x, y);
-         ASSERT(rb->DataType == GL_UNSIGNED_INT);
-         passed = depth_test_span32(ctx, count, zbuffer, zValues, mask);
-      }
-   }
-   else {
-      /* read depth values from buffer, test, write back */
-      if (rb->DataType == GL_UNSIGNED_SHORT) {
-         GLushort zbuffer[MAX_WIDTH];
-         rb->GetRow(ctx, rb, count, x, y, zbuffer);
-         passed = depth_test_span16(ctx, count, zbuffer, zValues, mask);
-         rb->PutRow(ctx, rb, count, x, y, zbuffer, mask);
-      }
-      else {
-         GLuint zbuffer[MAX_WIDTH];
-         ASSERT(rb->DataType == GL_UNSIGNED_INT);
-         rb->GetRow(ctx, rb, count, x, y, zbuffer);
-         passed = depth_test_span32(ctx, count, zbuffer, zValues, mask);
-         rb->PutRow(ctx, rb, count, x, y, zbuffer, mask);
-      }
-   }
-
-   if (passed < count) {
-      span->writeAll = GL_FALSE;
-   }
-   return passed;
-}
-
-
-
-#define Z_ADDRESS(X, Y)   (zStart + (Y) * stride + (X))
-
-
-/*
- * Do depth testing for an array of fragments at assorted locations.
- */
-static void
-direct_depth_test_pixels16(GLcontext *ctx, GLushort *zStart, GLuint stride,
-                           GLuint n, const GLint x[], const GLint y[],
-                           const GLuint z[], GLubyte mask[] )
-{
-   /* switch cases ordered from most frequent to less frequent */
-   switch (ctx->Depth.Func) {
-      case GL_LESS:
-         if (ctx->Depth.Mask) {
-	    /* Update Z buffer */
-            GLuint i;
-	    for (i=0; i<n; i++) {
-	       if (mask[i]) {
-		  GLushort *zptr = Z_ADDRESS(x[i], y[i]);
-		  if (z[i] < *zptr) {
-		     /* pass */
-		     *zptr = z[i];
-		  }
-		  else {
-		     /* fail */
-		     mask[i] = 0;
-		  }
-	       }
-	    }
-	 }
-	 else {
-	    /* Don't update Z buffer */
-            GLuint i;
-	    for (i=0; i<n; i++) {
-	       if (mask[i]) {
-		  GLushort *zptr = Z_ADDRESS(x[i], y[i]);
-		  if (z[i] < *zptr) {
-		     /* pass */
-		  }
-		  else {
-		     /* fail */
-		     mask[i] = 0;
-		  }
-	       }
-	    }
-	 }
-	 break;
-      case GL_LEQUAL:
-         if (ctx->Depth.Mask) {
-	    /* Update Z buffer */
-            GLuint i;
-	    for (i=0; i<n; i++) {
-	       if (mask[i]) {
-		  GLushort *zptr = Z_ADDRESS(x[i], y[i]);
-		  if (z[i] <= *zptr) {
-		     /* pass */
-		     *zptr = z[i];
-		  }
-		  else {
-		     /* fail */
-		     mask[i] = 0;
-		  }
-	       }
-	    }
-	 }
-	 else {
-	    /* Don't update Z buffer */
-            GLuint i;
-	    for (i=0; i<n; i++) {
-	       if (mask[i]) {
-		  GLushort *zptr = Z_ADDRESS(x[i], y[i]);
-		  if (z[i] <= *zptr) {
-		     /* pass */
-		  }
-		  else {
-		     /* fail */
-		     mask[i] = 0;
-		  }
-	       }
-	    }
-	 }
-	 break;
-      case GL_GEQUAL:
-         if (ctx->Depth.Mask) {
-	    /* Update Z buffer */
-            GLuint i;
-	    for (i=0; i<n; i++) {
-	       if (mask[i]) {
-		  GLushort *zptr = Z_ADDRESS(x[i], y[i]);
-		  if (z[i] >= *zptr) {
-		     /* pass */
-		     *zptr = z[i];
-		  }
-		  else {
-		     /* fail */
-		     mask[i] = 0;
-		  }
-	       }
-	    }
-	 }
-	 else {
-	    /* Don't update Z buffer */
-            GLuint i;
-	    for (i=0; i<n; i++) {
-	       if (mask[i]) {
-		  GLushort *zptr = Z_ADDRESS(x[i], y[i]);
-		  if (z[i] >= *zptr) {
-		     /* pass */
-		  }
-		  else {
-		     /* fail */
-		     mask[i] = 0;
-		  }
-	       }
-	    }
-	 }
-	 break;
-      case GL_GREATER:
-         if (ctx->Depth.Mask) {
-	    /* Update Z buffer */
-            GLuint i;
-	    for (i=0; i<n; i++) {
-	       if (mask[i]) {
-		  GLushort *zptr = Z_ADDRESS(x[i], y[i]);
-		  if (z[i] > *zptr) {
-		     /* pass */
-		     *zptr = z[i];
-		  }
-		  else {
-		     /* fail */
-		     mask[i] = 0;
-		  }
-	       }
-	    }
-	 }
-	 else {
-	    /* Don't update Z buffer */
-            GLuint i;
-	    for (i=0; i<n; i++) {
-	       if (mask[i]) {
-		  GLushort *zptr = Z_ADDRESS(x[i], y[i]);
-		  if (z[i] > *zptr) {
-		     /* pass */
-		  }
-		  else {
-		     /* fail */
-		     mask[i] = 0;
-		  }
-	       }
-	    }
-	 }
-	 break;
-      case GL_NOTEQUAL:
-         if (ctx->Depth.Mask) {
-	    /* Update Z buffer */
-            GLuint i;
-	    for (i=0; i<n; i++) {
-	       if (mask[i]) {
-		  GLushort *zptr = Z_ADDRESS(x[i], y[i]);
-		  if (z[i] != *zptr) {
-		     /* pass */
-		     *zptr = z[i];
-		  }
-		  else {
-		     /* fail */
-		     mask[i] = 0;
-		  }
-	       }
-	    }
-	 }
-	 else {
-	    /* Don't update Z buffer */
-            GLuint i;
-	    for (i=0; i<n; i++) {
-	       if (mask[i]) {
-		  GLushort *zptr = Z_ADDRESS(x[i], y[i]);
-		  if (z[i] != *zptr) {
-		     /* pass */
-		  }
-		  else {
-		     /* fail */
-		     mask[i] = 0;
-		  }
-	       }
-	    }
-	 }
-	 break;
-      case GL_EQUAL:
-         if (ctx->Depth.Mask) {
-	    /* Update Z buffer */
-            GLuint i;
-	    for (i=0; i<n; i++) {
-	       if (mask[i]) {
-		  GLushort *zptr = Z_ADDRESS(x[i], y[i]);
-		  if (z[i] == *zptr) {
-		     /* pass */
-		     *zptr = z[i];
-		  }
-		  else {
-		     /* fail */
-		     mask[i] = 0;
-		  }
-	       }
-	    }
-	 }
-	 else {
-	    /* Don't update Z buffer */
-            GLuint i;
-	    for (i=0; i<n; i++) {
-	       if (mask[i]) {
-		  GLushort *zptr = Z_ADDRESS(x[i], y[i]);
-		  if (z[i] == *zptr) {
-		     /* pass */
-		  }
-		  else {
-		     /* fail */
-		     mask[i] = 0;
-		  }
-	       }
-	    }
-	 }
-	 break;
-      case GL_ALWAYS:
-	 if (ctx->Depth.Mask) {
-	    /* Update Z buffer */
-            GLuint i;
-	    for (i=0; i<n; i++) {
-	       if (mask[i]) {
-		  GLushort *zptr = Z_ADDRESS(x[i], y[i]);
-		  *zptr = z[i];
-	       }
-	    }
-	 }
-	 else {
-	    /* Don't update Z buffer or mask */
-	 }
-	 break;
-      case GL_NEVER:
-	 /* depth test never passes */
-         memset(mask, 0, n * sizeof(GLubyte));
-	 break;
-      default:
-         _mesa_problem(ctx, "Bad depth func in direct_depth_test_pixels");
-   }
-}
-
-
-
-/*
- * Do depth testing for an array of fragments with direct access to zbuffer.
- */
-static void
-direct_depth_test_pixels32(GLcontext *ctx, GLuint *zStart, GLuint stride,
-                           GLuint n, const GLint x[], const GLint y[],
-                           const GLuint z[], GLubyte mask[] )
-{
-   /* switch cases ordered from most frequent to less frequent */
-   switch (ctx->Depth.Func) {
-      case GL_LESS:
-         if (ctx->Depth.Mask) {
-	    /* Update Z buffer */
-            GLuint i;
-	    for (i=0; i<n; i++) {
-	       if (mask[i]) {
-		  GLuint *zptr = Z_ADDRESS(x[i], y[i]);
-		  if (z[i] < *zptr) {
-		     /* pass */
-		     *zptr = z[i];
-		  }
-		  else {
-		     /* fail */
-		     mask[i] = 0;
-		  }
-	       }
-	    }
-	 }
-	 else {
-	    /* Don't update Z buffer */
-            GLuint i;
-	    for (i=0; i<n; i++) {
-	       if (mask[i]) {
-		  GLuint *zptr = Z_ADDRESS(x[i], y[i]);
-		  if (z[i] < *zptr) {
-		     /* pass */
-		  }
-		  else {
-		     /* fail */
-		     mask[i] = 0;
-		  }
-	       }
-	    }
-	 }
-	 break;
-      case GL_LEQUAL:
-         if (ctx->Depth.Mask) {
-	    /* Update Z buffer */
-            GLuint i;
-	    for (i=0; i<n; i++) {
-	       if (mask[i]) {
-		  GLuint *zptr = Z_ADDRESS(x[i], y[i]);
-		  if (z[i] <= *zptr) {
-		     /* pass */
-		     *zptr = z[i];
-		  }
-		  else {
-		     /* fail */
-		     mask[i] = 0;
-		  }
-	       }
-	    }
-	 }
-	 else {
-	    /* Don't update Z buffer */
-            GLuint i;
-	    for (i=0; i<n; i++) {
-	       if (mask[i]) {
-		  GLuint *zptr = Z_ADDRESS(x[i], y[i]);
-		  if (z[i] <= *zptr) {
-		     /* pass */
-		  }
-		  else {
-		     /* fail */
-		     mask[i] = 0;
-		  }
-	       }
-	    }
-	 }
-	 break;
-      case GL_GEQUAL:
-         if (ctx->Depth.Mask) {
-	    /* Update Z buffer */
-            GLuint i;
-	    for (i=0; i<n; i++) {
-	       if (mask[i]) {
-		  GLuint *zptr = Z_ADDRESS(x[i], y[i]);
-		  if (z[i] >= *zptr) {
-		     /* pass */
-		     *zptr = z[i];
-		  }
-		  else {
-		     /* fail */
-		     mask[i] = 0;
-		  }
-	       }
-	    }
-	 }
-	 else {
-	    /* Don't update Z buffer */
-            GLuint i;
-	    for (i=0; i<n; i++) {
-	       if (mask[i]) {
-		  GLuint *zptr = Z_ADDRESS(x[i], y[i]);
-		  if (z[i] >= *zptr) {
-		     /* pass */
-		  }
-		  else {
-		     /* fail */
-		     mask[i] = 0;
-		  }
-	       }
-	    }
-	 }
-	 break;
-      case GL_GREATER:
-         if (ctx->Depth.Mask) {
-	    /* Update Z buffer */
-            GLuint i;
-	    for (i=0; i<n; i++) {
-	       if (mask[i]) {
-		  GLuint *zptr = Z_ADDRESS(x[i], y[i]);
-		  if (z[i] > *zptr) {
-		     /* pass */
-		     *zptr = z[i];
-		  }
-		  else {
-		     /* fail */
-		     mask[i] = 0;
-		  }
-	       }
-	    }
-	 }
-	 else {
-	    /* Don't update Z buffer */
-            GLuint i;
-	    for (i=0; i<n; i++) {
-	       if (mask[i]) {
-		  GLuint *zptr = Z_ADDRESS(x[i], y[i]);
-		  if (z[i] > *zptr) {
-		     /* pass */
-		  }
-		  else {
-		     /* fail */
-		     mask[i] = 0;
-		  }
-	       }
-	    }
-	 }
-	 break;
-      case GL_NOTEQUAL:
-         if (ctx->Depth.Mask) {
-	    /* Update Z buffer */
-            GLuint i;
-	    for (i=0; i<n; i++) {
-	       if (mask[i]) {
-		  GLuint *zptr = Z_ADDRESS(x[i], y[i]);
-		  if (z[i] != *zptr) {
-		     /* pass */
-		     *zptr = z[i];
-		  }
-		  else {
-		     /* fail */
-		     mask[i] = 0;
-		  }
-	       }
-	    }
-	 }
-	 else {
-	    /* Don't update Z buffer */
-            GLuint i;
-	    for (i=0; i<n; i++) {
-	       if (mask[i]) {
-		  GLuint *zptr = Z_ADDRESS(x[i], y[i]);
-		  if (z[i] != *zptr) {
-		     /* pass */
-		  }
-		  else {
-		     /* fail */
-		     mask[i] = 0;
-		  }
-	       }
-	    }
-	 }
-	 break;
-      case GL_EQUAL:
-         if (ctx->Depth.Mask) {
-	    /* Update Z buffer */
-            GLuint i;
-	    for (i=0; i<n; i++) {
-	       if (mask[i]) {
-		  GLuint *zptr = Z_ADDRESS(x[i], y[i]);
-		  if (z[i] == *zptr) {
-		     /* pass */
-		     *zptr = z[i];
-		  }
-		  else {
-		     /* fail */
-		     mask[i] = 0;
-		  }
-	       }
-	    }
-	 }
-	 else {
-	    /* Don't update Z buffer */
-            GLuint i;
-	    for (i=0; i<n; i++) {
-	       if (mask[i]) {
-		  GLuint *zptr = Z_ADDRESS(x[i], y[i]);
-		  if (z[i] == *zptr) {
-		     /* pass */
-		  }
-		  else {
-		     /* fail */
-		     mask[i] = 0;
-		  }
-	       }
-	    }
-	 }
-	 break;
-      case GL_ALWAYS:
-	 if (ctx->Depth.Mask) {
-	    /* Update Z buffer */
-            GLuint i;
-	    for (i=0; i<n; i++) {
-	       if (mask[i]) {
-		  GLuint *zptr = Z_ADDRESS(x[i], y[i]);
-		  *zptr = z[i];
-	       }
-	    }
-	 }
-	 else {
-	    /* Don't update Z buffer or mask */
-	 }
-	 break;
-      case GL_NEVER:
-	 /* depth test never passes */
-         memset(mask, 0, n * sizeof(GLubyte));
-	 break;
-      default:
-         _mesa_problem(ctx, "Bad depth func in direct_depth_test_pixels");
-   }
-}
-
-
-
-
-static GLuint
-depth_test_pixels( GLcontext *ctx, SWspan *span )
-{
-   struct gl_framebuffer *fb = ctx->DrawBuffer;
-   struct gl_renderbuffer *rb = fb->_DepthBuffer;
-   const GLuint count = span->end;
-   const GLint *x = span->array->x;
-   const GLint *y = span->array->y;
-   const GLuint *z = span->array->z;
-   GLubyte *mask = span->array->mask;
-
-   if (rb->GetPointer(ctx, rb, 0, 0)) {
-      /* Directly access values */
-      if (rb->DataType == GL_UNSIGNED_SHORT) {
-         GLushort *zStart = (GLushort *) rb->Data;
-         GLuint stride = rb->Width;
-         direct_depth_test_pixels16(ctx, zStart, stride, count, x, y, z, mask);
-      }
-      else {
-         GLuint *zStart = (GLuint *) rb->Data;
-         GLuint stride = rb->Width;
-         ASSERT(rb->DataType == GL_UNSIGNED_INT);
-         direct_depth_test_pixels32(ctx, zStart, stride, count, x, y, z, mask);
-      }
-   }
-   else {
-      /* read depth values from buffer, test, write back */
-      if (rb->DataType == GL_UNSIGNED_SHORT) {
-         GLushort zbuffer[MAX_WIDTH];
-         _swrast_get_values(ctx, rb, count, x, y, zbuffer, sizeof(GLushort));
-         depth_test_span16(ctx, count, zbuffer, z, mask);
-         rb->PutValues(ctx, rb, count, x, y, zbuffer, mask);
-      }
-      else {
-         GLuint zbuffer[MAX_WIDTH];
-         ASSERT(rb->DataType == GL_UNSIGNED_INT);
-         _swrast_get_values(ctx, rb, count, x, y, zbuffer, sizeof(GLuint));
-         depth_test_span32(ctx, count, zbuffer, z, mask);
-         rb->PutValues(ctx, rb, count, x, y, zbuffer, mask);
-      }
-   }
-
-   return count; /* not really correct, but OK */
-}
-
-
-/**
- * Apply depth (Z) buffer testing to the span.
- * \return approx number of pixels that passed (only zero is reliable)
- */
-GLuint
-_swrast_depth_test_span( GLcontext *ctx, SWspan *span)
-{
-   if (span->arrayMask & SPAN_XY)
-      return depth_test_pixels(ctx, span);
-   else
-      return depth_test_span(ctx, span);
-}
-
-
-/**
- * GL_EXT_depth_bounds_test extension.
- * Discard fragments depending on whether the corresponding Z-buffer
- * values are outside the depth bounds test range.
- * Note: we test the Z buffer values, not the fragment Z values!
- * \return GL_TRUE if any fragments pass, GL_FALSE if no fragments pass
- */
-GLboolean
-_swrast_depth_bounds_test( GLcontext *ctx, SWspan *span )
-{
-   struct gl_framebuffer *fb = ctx->DrawBuffer;
-   struct gl_renderbuffer *rb = fb->_DepthBuffer;
-   GLuint zMin = (GLuint) (ctx->Depth.BoundsMin * fb->_DepthMaxF + 0.5F);
-   GLuint zMax = (GLuint) (ctx->Depth.BoundsMax * fb->_DepthMaxF + 0.5F);
-   GLubyte *mask = span->array->mask;
-   const GLuint count = span->end;
-   GLuint i;
-   GLboolean anyPass = GL_FALSE;
-
-   if (rb->DataType == GL_UNSIGNED_SHORT) {
-      /* get 16-bit values */
-      GLushort zbuffer16[MAX_WIDTH], *zbuffer;
-      if (span->arrayMask & SPAN_XY) {
-         _swrast_get_values(ctx, rb, count, span->array->x, span->array->y,
-                            zbuffer16, sizeof(GLushort));
-         zbuffer = zbuffer16;
-      }
-      else {
-         zbuffer = (GLushort*) rb->GetPointer(ctx, rb, span->x, span->y);
-         if (!zbuffer) {
-            rb->GetRow(ctx, rb, count, span->x, span->y, zbuffer16);
-            zbuffer = zbuffer16;
-         }
-      }
-      assert(zbuffer);
-
-      /* Now do the tests */
-      for (i = 0; i < count; i++) {
-         if (mask[i]) {
-            if (zbuffer[i] < zMin || zbuffer[i] > zMax)
-               mask[i] = GL_FALSE;
-            else
-               anyPass = GL_TRUE;
-         }
-      }
-   }
-   else {
-      /* get 32-bit values */
-      GLuint zbuffer32[MAX_WIDTH], *zbuffer;
-      ASSERT(rb->DataType == GL_UNSIGNED_INT);
-      if (span->arrayMask & SPAN_XY) {
-         _swrast_get_values(ctx, rb, count, span->array->x, span->array->y,
-                            zbuffer32, sizeof(GLuint));
-         zbuffer = zbuffer32;
-      }
-      else {
-         zbuffer = (GLuint*) rb->GetPointer(ctx, rb, span->x, span->y);
-         if (!zbuffer) {
-            rb->GetRow(ctx, rb, count, span->x, span->y, zbuffer32);
-            zbuffer = zbuffer32;
-         }
-      }
-      assert(zbuffer);
-
-      /* Now do the tests */
-      for (i = 0; i < count; i++) {
-         if (mask[i]) {
-            if (zbuffer[i] < zMin || zbuffer[i] > zMax)
-               mask[i] = GL_FALSE;
-            else
-               anyPass = GL_TRUE;
-         }
-      }
-   }
-
-   return anyPass;
-}
-
-
-
-/**********************************************************************/
-/*****                      Read Depth Buffer                     *****/
-/**********************************************************************/
-
-
-/**
- * Read a span of depth values from the given depth renderbuffer, returning
- * the values as GLfloats.
- * This function does clipping to prevent reading outside the depth buffer's
- * bounds.  Though the clipping is redundant when we're called from
- * _swrast_ReadPixels.
- */
-void
-_swrast_read_depth_span_float( GLcontext *ctx, struct gl_renderbuffer *rb,
-                               GLint n, GLint x, GLint y, GLfloat depth[] )
-{
-   const GLfloat scale = 1.0F / ctx->DrawBuffer->_DepthMaxF;
-
-   if (!rb) {
-      /* really only doing this to prevent FP exceptions later */
-      memset(depth, 0, n * sizeof(GLfloat));
-      return;
-   }
-
-   ASSERT(rb->_BaseFormat == GL_DEPTH_COMPONENT);
-
-   if (y < 0 || y >= (GLint) rb->Height ||
-       x + n <= 0 || x >= (GLint) rb->Width) {
-      /* span is completely outside framebuffer */
-      memset(depth, 0, n * sizeof(GLfloat));
-      return;
-   }
-
-   if (x < 0) {
-      GLint dx = -x;
-      GLint i;
-      for (i = 0; i < dx; i++)
-         depth[i] = 0.0;
-      x = 0;
-      n -= dx;
-      depth += dx;
-   }
-   if (x + n > (GLint) rb->Width) {
-      GLint dx = x + n - (GLint) rb->Width;
-      GLint i;
-      for (i = 0; i < dx; i++)
-         depth[n - i - 1] = 0.0;
-      n -= dx;
-   }
-   if (n <= 0) {
-      return;
-   }
-
-   if (rb->DataType == GL_UNSIGNED_INT) {
-      GLuint temp[MAX_WIDTH];
-      GLint i;
-      rb->GetRow(ctx, rb, n, x, y, temp);
-      for (i = 0; i < n; i++) {
-         depth[i] = temp[i] * scale;
-      }
-   }
-   else if (rb->DataType == GL_UNSIGNED_SHORT) {
-      GLushort temp[MAX_WIDTH];
-      GLint i;
-      rb->GetRow(ctx, rb, n, x, y, temp);
-      for (i = 0; i < n; i++) {
-         depth[i] = temp[i] * scale;
-      }
-   }
-   else {
-      _mesa_problem(ctx, "Invalid depth renderbuffer data type");
-   }
-}
-
-
-/**
- * As above, but return 32-bit GLuint values.
- */
-void
-_swrast_read_depth_span_uint( GLcontext *ctx, struct gl_renderbuffer *rb,
-                              GLint n, GLint x, GLint y, GLuint depth[] )
-{
-   GLuint depthBits;
-
-   if (!rb) {
-      /* really only doing this to prevent FP exceptions later */
-      memset(depth, 0, n * sizeof(GLuint));
-      return;
-   }
-
-   depthBits = _mesa_get_format_bits(rb->Format, GL_DEPTH_BITS);
-
-   ASSERT(rb->_BaseFormat == GL_DEPTH_COMPONENT);
-
-   if (y < 0 || y >= (GLint) rb->Height ||
-       x + n <= 0 || x >= (GLint) rb->Width) {
-      /* span is completely outside framebuffer */
-      memset(depth, 0, n * sizeof(GLfloat));
-      return;
-   }
-
-   if (x < 0) {
-      GLint dx = -x;
-      GLint i;
-      for (i = 0; i < dx; i++)
-         depth[i] = 0;
-      x = 0;
-      n -= dx;
-      depth += dx;
-   }
-   if (x + n > (GLint) rb->Width) {
-      GLint dx = x + n - (GLint) rb->Width;
-      GLint i;
-      for (i = 0; i < dx; i++)
-         depth[n - i - 1] = 0;
-      n -= dx;
-   }
-   if (n <= 0) {
-      return;
-   }
-
-   if (rb->DataType == GL_UNSIGNED_INT) {
-      rb->GetRow(ctx, rb, n, x, y, depth);
-      if (depthBits < 32) {
-         GLuint shift = 32 - depthBits;
-         GLint i;
-         for (i = 0; i < n; i++) {
-            GLuint z = depth[i];
-            depth[i] = z << shift; /* XXX lsb bits? */
-         }
-      }
-   }
-   else if (rb->DataType == GL_UNSIGNED_SHORT) {
-      GLushort temp[MAX_WIDTH];
-      GLint i;
-      rb->GetRow(ctx, rb, n, x, y, temp);
-      if (depthBits == 16) {
-         for (i = 0; i < n; i++) {
-            GLuint z = temp[i];
-            depth[i] = (z << 16) | z;
-         }
-      }
-      else {
-         GLuint shift = 16 - depthBits;
-         for (i = 0; i < n; i++) {
-            GLuint z = temp[i];
-            depth[i] = (z << (shift + 16)) | (z << shift); /* XXX lsb bits? */
-         }
-      }
-   }
-   else {
-      _mesa_problem(ctx, "Invalid depth renderbuffer data type");
-   }
-}
-
-
-
-/**
- * Clear the given z/depth renderbuffer.
- */
-void
-_swrast_clear_depth_buffer( GLcontext *ctx, struct gl_renderbuffer *rb )
-{
-   GLuint clearValue;
-   GLint x, y, width, height;
-
-   if (!rb || !ctx->Depth.Mask) {
-      /* no depth buffer, or writing to it is disabled */
-      return;
-   }
-
-   /* compute integer clearing value */
-   if (ctx->Depth.Clear == 1.0) {
-      clearValue = ctx->DrawBuffer->_DepthMax;
-   }
-   else {
-      clearValue = (GLuint) (ctx->Depth.Clear * ctx->DrawBuffer->_DepthMaxF);
-   }
-
-   assert(rb->_BaseFormat == GL_DEPTH_COMPONENT);
-
-   /* compute region to clear */
-   x = ctx->DrawBuffer->_Xmin;
-   y = ctx->DrawBuffer->_Ymin;
-   width  = ctx->DrawBuffer->_Xmax - ctx->DrawBuffer->_Xmin;
-   height = ctx->DrawBuffer->_Ymax - ctx->DrawBuffer->_Ymin;
-
-   if (rb->GetPointer(ctx, rb, 0, 0)) {
-      /* Direct buffer access is possible.  Either this is just malloc'd
-       * memory, or perhaps the driver mmap'd the zbuffer memory.
-       */
-      if (rb->DataType == GL_UNSIGNED_SHORT) {
-         if ((clearValue & 0xff) == ((clearValue >> 8) & 0xff) &&
-             ((GLushort *) rb->GetPointer(ctx, rb, 0, 0) + width ==
-              (GLushort *) rb->GetPointer(ctx, rb, 0, 1))) {
-            /* optimized case */
-            GLushort *dst = (GLushort *) rb->GetPointer(ctx, rb, x, y);
-            GLuint len = width * height * sizeof(GLushort);
-            memset(dst, (clearValue & 0xff), len);
-         }
-         else {
-            /* general case */
-            GLint i, j;
-            for (i = 0; i < height; i++) {
-               GLushort *dst = (GLushort *) rb->GetPointer(ctx, rb, x, y + i);
-               for (j = 0; j < width; j++) {
-                  dst[j] = clearValue;
-               }
-            }
-         }
-      }
-      else {
-         GLint i, j;
-         ASSERT(rb->DataType == GL_UNSIGNED_INT);
-         for (i = 0; i < height; i++) {
-            GLuint *dst = (GLuint *) rb->GetPointer(ctx, rb, x, y + i);
-            for (j = 0; j < width; j++) {
-               dst[j] = clearValue;
-            }
-         }
-      }
-   }
-   else {
-      /* Direct access not possible.  Use PutRow to write new values. */
-      if (rb->DataType == GL_UNSIGNED_SHORT) {
-         GLushort clearVal16 = (GLushort) (clearValue & 0xffff);
-         GLint i;
-         for (i = 0; i < height; i++) {
-            rb->PutMonoRow(ctx, rb, width, x, y + i, &clearVal16, NULL);
-         }
-      }
-      else if (rb->DataType == GL_UNSIGNED_INT) {
-         GLint i;
-         ASSERT(sizeof(clearValue) == sizeof(GLuint));
-         for (i = 0; i < height; i++) {
-            rb->PutMonoRow(ctx, rb, width, x, y + i, &clearValue, NULL);
-         }
-      }
-      else {
-         _mesa_problem(ctx, "bad depth renderbuffer DataType");
-      }
-   }
-}
+/*

+ * Mesa 3-D graphics library

+ * Version:  7.2.1

+ *

+ * Copyright (C) 1999-2008  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/context.h"

+#include "main/formats.h"

+#include "main/macros.h"

+#include "main/imports.h"

+

+#include "s_depth.h"

+#include "s_span.h"

+

+

+/**

+ * Do depth test for a horizontal span of fragments.

+ * Input:  zbuffer - array of z values in the zbuffer

+ *         z - array of fragment z values

+ * Return:  number of fragments which pass the test.

+ */

+static GLuint

+depth_test_span16( struct gl_context *ctx, GLuint n,

+                   GLushort zbuffer[], const GLuint z[], GLubyte mask[] )

+{

+   GLuint passed = 0;

+

+   /* switch cases ordered from most frequent to less frequent */

+   switch (ctx->Depth.Func) {

+      case GL_LESS:

+         if (ctx->Depth.Mask) {

+	    /* Update Z buffer */

+            GLuint i;

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

+	       if (mask[i]) {

+		  if (z[i] < zbuffer[i]) {

+		     /* pass */

+		     zbuffer[i] = z[i];

+		     passed++;

+		  }

+		  else {

+		     /* fail */

+		     mask[i] = 0;

+		  }

+	       }

+	    }

+	 }

+	 else {

+	    /* Don't update Z buffer */

+            GLuint i;

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

+	       if (mask[i]) {

+		  if (z[i] < zbuffer[i]) {

+		     /* pass */

+		     passed++;

+		  }

+		  else {

+		     mask[i] = 0;

+		  }

+	       }

+	    }

+	 }

+	 break;

+      case GL_LEQUAL:

+	 if (ctx->Depth.Mask) {

+	    /* Update Z buffer */

+            GLuint i;

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

+	       if (mask[i]) {

+		  if (z[i] <= zbuffer[i]) {

+		     zbuffer[i] = z[i];

+		     passed++;

+		  }

+		  else {

+		     mask[i] = 0;

+		  }

+	       }

+	    }

+	 }

+	 else {

+	    /* Don't update Z buffer */

+            GLuint i;

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

+	       if (mask[i]) {

+		  if (z[i] <= zbuffer[i]) {

+		     /* pass */

+		     passed++;

+		  }

+		  else {

+		     mask[i] = 0;

+		  }

+	       }

+	    }

+	 }

+	 break;

+      case GL_GEQUAL:

+	 if (ctx->Depth.Mask) {

+	    /* Update Z buffer */

+            GLuint i;

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

+	       if (mask[i]) {

+		  if (z[i] >= zbuffer[i]) {

+		     zbuffer[i] = z[i];

+		     passed++;

+		  }

+		  else {

+		     mask[i] = 0;

+		  }

+	       }

+	    }

+	 }

+	 else {

+	    /* Don't update Z buffer */

+            GLuint i;

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

+	       if (mask[i]) {

+		  if (z[i] >= zbuffer[i]) {

+		     /* pass */

+		     passed++;

+		  }

+		  else {

+		     mask[i] = 0;

+		  }

+	       }

+	    }

+	 }

+	 break;

+      case GL_GREATER:

+	 if (ctx->Depth.Mask) {

+	    /* Update Z buffer */

+            GLuint i;

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

+	       if (mask[i]) {

+		  if (z[i] > zbuffer[i]) {

+		     zbuffer[i] = z[i];

+		     passed++;

+		  }

+		  else {

+		     mask[i] = 0;

+		  }

+	       }

+	    }

+	 }

+	 else {

+	    /* Don't update Z buffer */

+            GLuint i;

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

+	       if (mask[i]) {

+		  if (z[i] > zbuffer[i]) {

+		     /* pass */

+		     passed++;

+		  }

+		  else {

+		     mask[i] = 0;

+		  }

+	       }

+	    }

+	 }

+	 break;

+      case GL_NOTEQUAL:

+	 if (ctx->Depth.Mask) {

+	    /* Update Z buffer */

+            GLuint i;

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

+	       if (mask[i]) {

+		  if (z[i] != zbuffer[i]) {

+		     zbuffer[i] = z[i];

+		     passed++;

+		  }

+		  else {

+		     mask[i] = 0;

+		  }

+	       }

+	    }

+	 }

+	 else {

+	    /* Don't update Z buffer */

+            GLuint i;

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

+	       if (mask[i]) {

+		  if (z[i] != zbuffer[i]) {

+		     /* pass */

+		     passed++;

+		  }

+		  else {

+		     mask[i] = 0;

+		  }

+	       }

+	    }

+	 }

+	 break;

+      case GL_EQUAL:

+	 if (ctx->Depth.Mask) {

+	    /* Update Z buffer */

+            GLuint i;

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

+	       if (mask[i]) {

+		  if (z[i] == zbuffer[i]) {

+		     zbuffer[i] = z[i];

+		     passed++;

+		  }

+		  else {

+		     mask[i] = 0;

+		  }

+	       }

+	    }

+	 }

+	 else {

+	    /* Don't update Z buffer */

+            GLuint i;

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

+	       if (mask[i]) {

+		  if (z[i] == zbuffer[i]) {

+		     /* pass */

+		     passed++;

+		  }

+		  else {

+		     mask[i] = 0;

+		  }

+	       }

+	    }

+	 }

+	 break;

+      case GL_ALWAYS:

+	 if (ctx->Depth.Mask) {

+	    /* Update Z buffer */

+            GLuint i;

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

+	       if (mask[i]) {

+		  zbuffer[i] = z[i];

+		  passed++;

+	       }

+	    }

+	 }

+	 else {

+	    /* Don't update Z buffer or mask */

+	    passed = n;

+	 }

+	 break;

+      case GL_NEVER:

+         memset(mask, 0, n * sizeof(GLubyte));

+	 break;

+      default:

+         _mesa_problem(ctx, "Bad depth func in depth_test_span16");

+   }

+

+   return passed;

+}

+

+

+static GLuint

+depth_test_span32( struct gl_context *ctx, GLuint n,

+                   GLuint zbuffer[], const GLuint z[], GLubyte mask[] )

+{

+   GLuint passed = 0;

+

+   /* switch cases ordered from most frequent to less frequent */

+   switch (ctx->Depth.Func) {

+      case GL_LESS:

+         if (ctx->Depth.Mask) {

+	    /* Update Z buffer */

+            GLuint i;

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

+	       if (mask[i]) {

+		  if (z[i] < zbuffer[i]) {

+		     /* pass */

+		     zbuffer[i] = z[i];

+		     passed++;

+		  }

+		  else {

+		     /* fail */

+		     mask[i] = 0;

+		  }

+	       }

+	    }

+	 }

+	 else {

+	    /* Don't update Z buffer */

+            GLuint i;

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

+	       if (mask[i]) {

+		  if (z[i] < zbuffer[i]) {

+		     /* pass */

+		     passed++;

+		  }

+		  else {

+		     mask[i] = 0;

+		  }

+	       }

+	    }

+	 }

+	 break;

+      case GL_LEQUAL:

+	 if (ctx->Depth.Mask) {

+	    /* Update Z buffer */

+            GLuint i;

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

+	       if (mask[i]) {

+		  if (z[i] <= zbuffer[i]) {

+		     zbuffer[i] = z[i];

+		     passed++;

+		  }

+		  else {

+		     mask[i] = 0;

+		  }

+	       }

+	    }

+	 }

+	 else {

+	    /* Don't update Z buffer */

+            GLuint i;

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

+	       if (mask[i]) {

+		  if (z[i] <= zbuffer[i]) {

+		     /* pass */

+		     passed++;

+		  }

+		  else {

+		     mask[i] = 0;

+		  }

+	       }

+	    }

+	 }

+	 break;

+      case GL_GEQUAL:

+	 if (ctx->Depth.Mask) {

+	    /* Update Z buffer */

+            GLuint i;

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

+	       if (mask[i]) {

+		  if (z[i] >= zbuffer[i]) {

+		     zbuffer[i] = z[i];

+		     passed++;

+		  }

+		  else {

+		     mask[i] = 0;

+		  }

+	       }

+	    }

+	 }

+	 else {

+	    /* Don't update Z buffer */

+            GLuint i;

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

+	       if (mask[i]) {

+		  if (z[i] >= zbuffer[i]) {

+		     /* pass */

+		     passed++;

+		  }

+		  else {

+		     mask[i] = 0;

+		  }

+	       }

+	    }

+	 }

+	 break;

+      case GL_GREATER:

+	 if (ctx->Depth.Mask) {

+	    /* Update Z buffer */

+            GLuint i;

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

+	       if (mask[i]) {

+		  if (z[i] > zbuffer[i]) {

+		     zbuffer[i] = z[i];

+		     passed++;

+		  }

+		  else {

+		     mask[i] = 0;

+		  }

+	       }

+	    }

+	 }

+	 else {

+	    /* Don't update Z buffer */

+            GLuint i;

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

+	       if (mask[i]) {

+		  if (z[i] > zbuffer[i]) {

+		     /* pass */

+		     passed++;

+		  }

+		  else {

+		     mask[i] = 0;

+		  }

+	       }

+	    }

+	 }

+	 break;

+      case GL_NOTEQUAL:

+	 if (ctx->Depth.Mask) {

+	    /* Update Z buffer */

+            GLuint i;

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

+	       if (mask[i]) {

+		  if (z[i] != zbuffer[i]) {

+		     zbuffer[i] = z[i];

+		     passed++;

+		  }

+		  else {

+		     mask[i] = 0;

+		  }

+	       }

+	    }

+	 }

+	 else {

+	    /* Don't update Z buffer */

+            GLuint i;

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

+	       if (mask[i]) {

+		  if (z[i] != zbuffer[i]) {

+		     /* pass */

+		     passed++;

+		  }

+		  else {

+		     mask[i] = 0;

+		  }

+	       }

+	    }

+	 }

+	 break;

+      case GL_EQUAL:

+	 if (ctx->Depth.Mask) {

+	    /* Update Z buffer */

+            GLuint i;

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

+	       if (mask[i]) {

+		  if (z[i] == zbuffer[i]) {

+		     zbuffer[i] = z[i];

+		     passed++;

+		  }

+		  else {

+		     mask[i] = 0;

+		  }

+	       }

+	    }

+	 }

+	 else {

+	    /* Don't update Z buffer */

+            GLuint i;

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

+	       if (mask[i]) {

+		  if (z[i] == zbuffer[i]) {

+		     /* pass */

+		     passed++;

+		  }

+		  else {

+		     mask[i] = 0;

+		  }

+	       }

+	    }

+	 }

+	 break;

+      case GL_ALWAYS:

+	 if (ctx->Depth.Mask) {

+	    /* Update Z buffer */

+            GLuint i;

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

+	       if (mask[i]) {

+		  zbuffer[i] = z[i];

+		  passed++;

+	       }

+	    }

+	 }

+	 else {

+	    /* Don't update Z buffer or mask */

+	    passed = n;

+	 }

+	 break;

+      case GL_NEVER:

+         memset(mask, 0, n * sizeof(GLubyte));

+	 break;

+      default:

+         _mesa_problem(ctx, "Bad depth func in depth_test_span32");

+   }

+

+   return passed;

+}

+

+

+

+/**

+ * Clamp fragment Z values to the depth near/far range (glDepthRange()).

+ * This is used when GL_ARB_depth_clamp/GL_DEPTH_CLAMP is turned on.

+ * In that case, vertexes are not clipped against the near/far planes

+ * so rasterization will produce fragment Z values outside the usual

+ * [0,1] range.

+ */

+void

+_swrast_depth_clamp_span( struct gl_context *ctx, SWspan *span )

+{

+   struct gl_framebuffer *fb = ctx->DrawBuffer;

+   const GLuint count = span->end;

+   GLint *zValues = (GLint *) span->array->z; /* sign change */

+   GLint min, max;

+   GLfloat min_f, max_f;

+   GLuint i;

+

+   if (ctx->Viewport.Near < ctx->Viewport.Far) {

+      min_f = ctx->Viewport.Near;

+      max_f = ctx->Viewport.Far;

+   } else {

+      min_f = ctx->Viewport.Far;

+      max_f = ctx->Viewport.Near;

+   }

+

+   /* Convert floating point values in [0,1] to device Z coordinates in

+    * [0, DepthMax].

+    * ex: If the Z buffer has 24 bits, DepthMax = 0xffffff.

+    * 

+    * XXX this all falls apart if we have 31 or more bits of Z because

+    * the triangle rasterization code produces unsigned Z values.  Negative

+    * vertex Z values come out as large fragment Z uints.

+    */

+   min = (GLint) (min_f * fb->_DepthMaxF);

+   max = (GLint) (max_f * fb->_DepthMaxF);

+   if (max < 0)

+      max = 0x7fffffff; /* catch over flow for 30-bit z */

+

+   /* Note that we do the comparisons here using signed integers.

+    */

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

+      if (zValues[i] < min)

+	 zValues[i] = min;

+      if (zValues[i] > max)

+	 zValues[i] = max;

+   }

+}

+

+

+

+/*

+ * Apply depth test to span of fragments.

+ */

+static GLuint

+depth_test_span( struct gl_context *ctx, SWspan *span)

+{

+   struct gl_framebuffer *fb = ctx->DrawBuffer;

+   struct gl_renderbuffer *rb = fb->_DepthBuffer;

+   const GLint x = span->x;

+   const GLint y = span->y;

+   const GLuint count = span->end;

+   const GLuint *zValues = span->array->z;

+   GLubyte *mask = span->array->mask;

+   GLuint passed;

+

+   ASSERT((span->arrayMask & SPAN_XY) == 0);

+   ASSERT(span->arrayMask & SPAN_Z);

+   

+   if (rb->GetPointer(ctx, rb, 0, 0)) {

+      /* Directly access buffer */

+      if (rb->DataType == GL_UNSIGNED_SHORT) {

+         GLushort *zbuffer = (GLushort *) rb->GetPointer(ctx, rb, x, y);

+         passed = depth_test_span16(ctx, count, zbuffer, zValues, mask);

+      }

+      else {

+         GLuint *zbuffer = (GLuint *) rb->GetPointer(ctx, rb, x, y);

+         ASSERT(rb->DataType == GL_UNSIGNED_INT);

+         passed = depth_test_span32(ctx, count, zbuffer, zValues, mask);

+      }

+   }

+   else {

+      /* read depth values from buffer, test, write back */

+      if (rb->DataType == GL_UNSIGNED_SHORT) {

+         GLushort zbuffer[MAX_WIDTH];

+         rb->GetRow(ctx, rb, count, x, y, zbuffer);

+         passed = depth_test_span16(ctx, count, zbuffer, zValues, mask);

+         rb->PutRow(ctx, rb, count, x, y, zbuffer, mask);

+      }

+      else {

+         GLuint zbuffer[MAX_WIDTH];

+         ASSERT(rb->DataType == GL_UNSIGNED_INT);

+         rb->GetRow(ctx, rb, count, x, y, zbuffer);

+         passed = depth_test_span32(ctx, count, zbuffer, zValues, mask);

+         rb->PutRow(ctx, rb, count, x, y, zbuffer, mask);

+      }

+   }

+

+   if (passed < count) {

+      span->writeAll = GL_FALSE;

+   }

+   return passed;

+}

+

+

+

+#define Z_ADDRESS(X, Y)   (zStart + (Y) * stride + (X))

+

+

+/*

+ * Do depth testing for an array of fragments at assorted locations.

+ */

+static void

+direct_depth_test_pixels16(struct gl_context *ctx, GLushort *zStart, GLuint stride,

+                           GLuint n, const GLint x[], const GLint y[],

+                           const GLuint z[], GLubyte mask[] )

+{

+   /* switch cases ordered from most frequent to less frequent */

+   switch (ctx->Depth.Func) {

+      case GL_LESS:

+         if (ctx->Depth.Mask) {

+	    /* Update Z buffer */

+            GLuint i;

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

+	       if (mask[i]) {

+		  GLushort *zptr = Z_ADDRESS(x[i], y[i]);

+		  if (z[i] < *zptr) {

+		     /* pass */

+		     *zptr = z[i];

+		  }

+		  else {

+		     /* fail */

+		     mask[i] = 0;

+		  }

+	       }

+	    }

+	 }

+	 else {

+	    /* Don't update Z buffer */

+            GLuint i;

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

+	       if (mask[i]) {

+		  GLushort *zptr = Z_ADDRESS(x[i], y[i]);

+		  if (z[i] < *zptr) {

+		     /* pass */

+		  }

+		  else {

+		     /* fail */

+		     mask[i] = 0;

+		  }

+	       }

+	    }

+	 }

+	 break;

+      case GL_LEQUAL:

+         if (ctx->Depth.Mask) {

+	    /* Update Z buffer */

+            GLuint i;

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

+	       if (mask[i]) {

+		  GLushort *zptr = Z_ADDRESS(x[i], y[i]);

+		  if (z[i] <= *zptr) {

+		     /* pass */

+		     *zptr = z[i];

+		  }

+		  else {

+		     /* fail */

+		     mask[i] = 0;

+		  }

+	       }

+	    }

+	 }

+	 else {

+	    /* Don't update Z buffer */

+            GLuint i;

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

+	       if (mask[i]) {

+		  GLushort *zptr = Z_ADDRESS(x[i], y[i]);

+		  if (z[i] <= *zptr) {

+		     /* pass */

+		  }

+		  else {

+		     /* fail */

+		     mask[i] = 0;

+		  }

+	       }

+	    }

+	 }

+	 break;

+      case GL_GEQUAL:

+         if (ctx->Depth.Mask) {

+	    /* Update Z buffer */

+            GLuint i;

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

+	       if (mask[i]) {

+		  GLushort *zptr = Z_ADDRESS(x[i], y[i]);

+		  if (z[i] >= *zptr) {

+		     /* pass */

+		     *zptr = z[i];

+		  }

+		  else {

+		     /* fail */

+		     mask[i] = 0;

+		  }

+	       }

+	    }

+	 }

+	 else {

+	    /* Don't update Z buffer */

+            GLuint i;

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

+	       if (mask[i]) {

+		  GLushort *zptr = Z_ADDRESS(x[i], y[i]);

+		  if (z[i] >= *zptr) {

+		     /* pass */

+		  }

+		  else {

+		     /* fail */

+		     mask[i] = 0;

+		  }

+	       }

+	    }

+	 }

+	 break;

+      case GL_GREATER:

+         if (ctx->Depth.Mask) {

+	    /* Update Z buffer */

+            GLuint i;

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

+	       if (mask[i]) {

+		  GLushort *zptr = Z_ADDRESS(x[i], y[i]);

+		  if (z[i] > *zptr) {

+		     /* pass */

+		     *zptr = z[i];

+		  }

+		  else {

+		     /* fail */

+		     mask[i] = 0;

+		  }

+	       }

+	    }

+	 }

+	 else {

+	    /* Don't update Z buffer */

+            GLuint i;

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

+	       if (mask[i]) {

+		  GLushort *zptr = Z_ADDRESS(x[i], y[i]);

+		  if (z[i] > *zptr) {

+		     /* pass */

+		  }

+		  else {

+		     /* fail */

+		     mask[i] = 0;

+		  }

+	       }

+	    }

+	 }

+	 break;

+      case GL_NOTEQUAL:

+         if (ctx->Depth.Mask) {

+	    /* Update Z buffer */

+            GLuint i;

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

+	       if (mask[i]) {

+		  GLushort *zptr = Z_ADDRESS(x[i], y[i]);

+		  if (z[i] != *zptr) {

+		     /* pass */

+		     *zptr = z[i];

+		  }

+		  else {

+		     /* fail */

+		     mask[i] = 0;

+		  }

+	       }

+	    }

+	 }

+	 else {

+	    /* Don't update Z buffer */

+            GLuint i;

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

+	       if (mask[i]) {

+		  GLushort *zptr = Z_ADDRESS(x[i], y[i]);

+		  if (z[i] != *zptr) {

+		     /* pass */

+		  }

+		  else {

+		     /* fail */

+		     mask[i] = 0;

+		  }

+	       }

+	    }

+	 }

+	 break;

+      case GL_EQUAL:

+         if (ctx->Depth.Mask) {

+	    /* Update Z buffer */

+            GLuint i;

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

+	       if (mask[i]) {

+		  GLushort *zptr = Z_ADDRESS(x[i], y[i]);

+		  if (z[i] == *zptr) {

+		     /* pass */

+		     *zptr = z[i];

+		  }

+		  else {

+		     /* fail */

+		     mask[i] = 0;

+		  }

+	       }

+	    }

+	 }

+	 else {

+	    /* Don't update Z buffer */

+            GLuint i;

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

+	       if (mask[i]) {

+		  GLushort *zptr = Z_ADDRESS(x[i], y[i]);

+		  if (z[i] == *zptr) {

+		     /* pass */

+		  }

+		  else {

+		     /* fail */

+		     mask[i] = 0;

+		  }

+	       }

+	    }

+	 }

+	 break;

+      case GL_ALWAYS:

+	 if (ctx->Depth.Mask) {

+	    /* Update Z buffer */

+            GLuint i;

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

+	       if (mask[i]) {

+		  GLushort *zptr = Z_ADDRESS(x[i], y[i]);

+		  *zptr = z[i];

+	       }

+	    }

+	 }

+	 else {

+	    /* Don't update Z buffer or mask */

+	 }

+	 break;

+      case GL_NEVER:

+	 /* depth test never passes */

+         memset(mask, 0, n * sizeof(GLubyte));

+	 break;

+      default:

+         _mesa_problem(ctx, "Bad depth func in direct_depth_test_pixels");

+   }

+}

+

+

+

+/*

+ * Do depth testing for an array of fragments with direct access to zbuffer.

+ */

+static void

+direct_depth_test_pixels32(struct gl_context *ctx, GLuint *zStart, GLuint stride,

+                           GLuint n, const GLint x[], const GLint y[],

+                           const GLuint z[], GLubyte mask[] )

+{

+   /* switch cases ordered from most frequent to less frequent */

+   switch (ctx->Depth.Func) {

+      case GL_LESS:

+         if (ctx->Depth.Mask) {

+	    /* Update Z buffer */

+            GLuint i;

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

+	       if (mask[i]) {

+		  GLuint *zptr = Z_ADDRESS(x[i], y[i]);

+		  if (z[i] < *zptr) {

+		     /* pass */

+		     *zptr = z[i];

+		  }

+		  else {

+		     /* fail */

+		     mask[i] = 0;

+		  }

+	       }

+	    }

+	 }

+	 else {

+	    /* Don't update Z buffer */

+            GLuint i;

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

+	       if (mask[i]) {

+		  GLuint *zptr = Z_ADDRESS(x[i], y[i]);

+		  if (z[i] < *zptr) {

+		     /* pass */

+		  }

+		  else {

+		     /* fail */

+		     mask[i] = 0;

+		  }

+	       }

+	    }

+	 }

+	 break;

+      case GL_LEQUAL:

+         if (ctx->Depth.Mask) {

+	    /* Update Z buffer */

+            GLuint i;

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

+	       if (mask[i]) {

+		  GLuint *zptr = Z_ADDRESS(x[i], y[i]);

+		  if (z[i] <= *zptr) {

+		     /* pass */

+		     *zptr = z[i];

+		  }

+		  else {

+		     /* fail */

+		     mask[i] = 0;

+		  }

+	       }

+	    }

+	 }

+	 else {

+	    /* Don't update Z buffer */

+            GLuint i;

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

+	       if (mask[i]) {

+		  GLuint *zptr = Z_ADDRESS(x[i], y[i]);

+		  if (z[i] <= *zptr) {

+		     /* pass */

+		  }

+		  else {

+		     /* fail */

+		     mask[i] = 0;

+		  }

+	       }

+	    }

+	 }

+	 break;

+      case GL_GEQUAL:

+         if (ctx->Depth.Mask) {

+	    /* Update Z buffer */

+            GLuint i;

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

+	       if (mask[i]) {

+		  GLuint *zptr = Z_ADDRESS(x[i], y[i]);

+		  if (z[i] >= *zptr) {

+		     /* pass */

+		     *zptr = z[i];

+		  }

+		  else {

+		     /* fail */

+		     mask[i] = 0;

+		  }

+	       }

+	    }

+	 }

+	 else {

+	    /* Don't update Z buffer */

+            GLuint i;

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

+	       if (mask[i]) {

+		  GLuint *zptr = Z_ADDRESS(x[i], y[i]);

+		  if (z[i] >= *zptr) {

+		     /* pass */

+		  }

+		  else {

+		     /* fail */

+		     mask[i] = 0;

+		  }

+	       }

+	    }

+	 }

+	 break;

+      case GL_GREATER:

+         if (ctx->Depth.Mask) {

+	    /* Update Z buffer */

+            GLuint i;

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

+	       if (mask[i]) {

+		  GLuint *zptr = Z_ADDRESS(x[i], y[i]);

+		  if (z[i] > *zptr) {

+		     /* pass */

+		     *zptr = z[i];

+		  }

+		  else {

+		     /* fail */

+		     mask[i] = 0;

+		  }

+	       }

+	    }

+	 }

+	 else {

+	    /* Don't update Z buffer */

+            GLuint i;

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

+	       if (mask[i]) {

+		  GLuint *zptr = Z_ADDRESS(x[i], y[i]);

+		  if (z[i] > *zptr) {

+		     /* pass */

+		  }

+		  else {

+		     /* fail */

+		     mask[i] = 0;

+		  }

+	       }

+	    }

+	 }

+	 break;

+      case GL_NOTEQUAL:

+         if (ctx->Depth.Mask) {

+	    /* Update Z buffer */

+            GLuint i;

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

+	       if (mask[i]) {

+		  GLuint *zptr = Z_ADDRESS(x[i], y[i]);

+		  if (z[i] != *zptr) {

+		     /* pass */

+		     *zptr = z[i];

+		  }

+		  else {

+		     /* fail */

+		     mask[i] = 0;

+		  }

+	       }

+	    }

+	 }

+	 else {

+	    /* Don't update Z buffer */

+            GLuint i;

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

+	       if (mask[i]) {

+		  GLuint *zptr = Z_ADDRESS(x[i], y[i]);

+		  if (z[i] != *zptr) {

+		     /* pass */

+		  }

+		  else {

+		     /* fail */

+		     mask[i] = 0;

+		  }

+	       }

+	    }

+	 }

+	 break;

+      case GL_EQUAL:

+         if (ctx->Depth.Mask) {

+	    /* Update Z buffer */

+            GLuint i;

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

+	       if (mask[i]) {

+		  GLuint *zptr = Z_ADDRESS(x[i], y[i]);

+		  if (z[i] == *zptr) {

+		     /* pass */

+		     *zptr = z[i];

+		  }

+		  else {

+		     /* fail */

+		     mask[i] = 0;

+		  }

+	       }

+	    }

+	 }

+	 else {

+	    /* Don't update Z buffer */

+            GLuint i;

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

+	       if (mask[i]) {

+		  GLuint *zptr = Z_ADDRESS(x[i], y[i]);

+		  if (z[i] == *zptr) {

+		     /* pass */

+		  }

+		  else {

+		     /* fail */

+		     mask[i] = 0;

+		  }

+	       }

+	    }

+	 }

+	 break;

+      case GL_ALWAYS:

+	 if (ctx->Depth.Mask) {

+	    /* Update Z buffer */

+            GLuint i;

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

+	       if (mask[i]) {

+		  GLuint *zptr = Z_ADDRESS(x[i], y[i]);

+		  *zptr = z[i];

+	       }

+	    }

+	 }

+	 else {

+	    /* Don't update Z buffer or mask */

+	 }

+	 break;

+      case GL_NEVER:

+	 /* depth test never passes */

+         memset(mask, 0, n * sizeof(GLubyte));

+	 break;

+      default:

+         _mesa_problem(ctx, "Bad depth func in direct_depth_test_pixels");

+   }

+}

+

+

+

+

+static GLuint

+depth_test_pixels( struct gl_context *ctx, SWspan *span )

+{

+   struct gl_framebuffer *fb = ctx->DrawBuffer;

+   struct gl_renderbuffer *rb = fb->_DepthBuffer;

+   const GLuint count = span->end;

+   const GLint *x = span->array->x;

+   const GLint *y = span->array->y;

+   const GLuint *z = span->array->z;

+   GLubyte *mask = span->array->mask;

+

+   if (rb->GetPointer(ctx, rb, 0, 0)) {

+      /* Directly access values */

+      if (rb->DataType == GL_UNSIGNED_SHORT) {

+         GLushort *zStart = (GLushort *) rb->Data;

+         GLuint stride = rb->Width;

+         direct_depth_test_pixels16(ctx, zStart, stride, count, x, y, z, mask);

+      }

+      else {

+         GLuint *zStart = (GLuint *) rb->Data;

+         GLuint stride = rb->Width;

+         ASSERT(rb->DataType == GL_UNSIGNED_INT);

+         direct_depth_test_pixels32(ctx, zStart, stride, count, x, y, z, mask);

+      }

+   }

+   else {

+      /* read depth values from buffer, test, write back */

+      if (rb->DataType == GL_UNSIGNED_SHORT) {

+         GLushort zbuffer[MAX_WIDTH];

+         _swrast_get_values(ctx, rb, count, x, y, zbuffer, sizeof(GLushort));

+         depth_test_span16(ctx, count, zbuffer, z, mask);

+         rb->PutValues(ctx, rb, count, x, y, zbuffer, mask);

+      }

+      else {

+         GLuint zbuffer[MAX_WIDTH];

+         ASSERT(rb->DataType == GL_UNSIGNED_INT);

+         _swrast_get_values(ctx, rb, count, x, y, zbuffer, sizeof(GLuint));

+         depth_test_span32(ctx, count, zbuffer, z, mask);

+         rb->PutValues(ctx, rb, count, x, y, zbuffer, mask);

+      }

+   }

+

+   return count; /* not really correct, but OK */

+}

+

+

+/**

+ * Apply depth (Z) buffer testing to the span.

+ * \return approx number of pixels that passed (only zero is reliable)

+ */

+GLuint

+_swrast_depth_test_span( struct gl_context *ctx, SWspan *span)

+{

+   if (span->arrayMask & SPAN_XY)

+      return depth_test_pixels(ctx, span);

+   else

+      return depth_test_span(ctx, span);

+}

+

+

+/**

+ * GL_EXT_depth_bounds_test extension.

+ * Discard fragments depending on whether the corresponding Z-buffer

+ * values are outside the depth bounds test range.

+ * Note: we test the Z buffer values, not the fragment Z values!

+ * \return GL_TRUE if any fragments pass, GL_FALSE if no fragments pass

+ */

+GLboolean

+_swrast_depth_bounds_test( struct gl_context *ctx, SWspan *span )

+{

+   struct gl_framebuffer *fb = ctx->DrawBuffer;

+   struct gl_renderbuffer *rb = fb->_DepthBuffer;

+   GLuint zMin = (GLuint) (ctx->Depth.BoundsMin * fb->_DepthMaxF + 0.5F);

+   GLuint zMax = (GLuint) (ctx->Depth.BoundsMax * fb->_DepthMaxF + 0.5F);

+   GLubyte *mask = span->array->mask;

+   const GLuint count = span->end;

+   GLuint i;

+   GLboolean anyPass = GL_FALSE;

+

+   if (rb->DataType == GL_UNSIGNED_SHORT) {

+      /* get 16-bit values */

+      GLushort zbuffer16[MAX_WIDTH], *zbuffer;

+      if (span->arrayMask & SPAN_XY) {

+         _swrast_get_values(ctx, rb, count, span->array->x, span->array->y,

+                            zbuffer16, sizeof(GLushort));

+         zbuffer = zbuffer16;

+      }

+      else {

+         zbuffer = (GLushort*) rb->GetPointer(ctx, rb, span->x, span->y);

+         if (!zbuffer) {

+            rb->GetRow(ctx, rb, count, span->x, span->y, zbuffer16);

+            zbuffer = zbuffer16;

+         }

+      }

+      assert(zbuffer);

+

+      /* Now do the tests */

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

+         if (mask[i]) {

+            if (zbuffer[i] < zMin || zbuffer[i] > zMax)

+               mask[i] = GL_FALSE;

+            else

+               anyPass = GL_TRUE;

+         }

+      }

+   }

+   else {

+      /* get 32-bit values */

+      GLuint zbuffer32[MAX_WIDTH], *zbuffer;

+      ASSERT(rb->DataType == GL_UNSIGNED_INT);

+      if (span->arrayMask & SPAN_XY) {

+         _swrast_get_values(ctx, rb, count, span->array->x, span->array->y,

+                            zbuffer32, sizeof(GLuint));

+         zbuffer = zbuffer32;

+      }

+      else {

+         zbuffer = (GLuint*) rb->GetPointer(ctx, rb, span->x, span->y);

+         if (!zbuffer) {

+            rb->GetRow(ctx, rb, count, span->x, span->y, zbuffer32);

+            zbuffer = zbuffer32;

+         }

+      }

+      assert(zbuffer);

+

+      /* Now do the tests */

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

+         if (mask[i]) {

+            if (zbuffer[i] < zMin || zbuffer[i] > zMax)

+               mask[i] = GL_FALSE;

+            else

+               anyPass = GL_TRUE;

+         }

+      }

+   }

+

+   return anyPass;

+}

+

+

+

+/**********************************************************************/

+/*****                      Read Depth Buffer                     *****/

+/**********************************************************************/

+

+

+/**

+ * Read a span of depth values from the given depth renderbuffer, returning

+ * the values as GLfloats.

+ * This function does clipping to prevent reading outside the depth buffer's

+ * bounds.  Though the clipping is redundant when we're called from

+ * _swrast_ReadPixels.

+ */

+void

+_swrast_read_depth_span_float( struct gl_context *ctx, struct gl_renderbuffer *rb,

+                               GLint n, GLint x, GLint y, GLfloat depth[] )

+{

+   const GLfloat scale = 1.0F / ctx->DrawBuffer->_DepthMaxF;

+

+   if (!rb) {

+      /* really only doing this to prevent FP exceptions later */

+      memset(depth, 0, n * sizeof(GLfloat));

+      return;

+   }

+

+   ASSERT(rb->_BaseFormat == GL_DEPTH_COMPONENT);

+

+   if (y < 0 || y >= (GLint) rb->Height ||

+       x + n <= 0 || x >= (GLint) rb->Width) {

+      /* span is completely outside framebuffer */

+      memset(depth, 0, n * sizeof(GLfloat));

+      return;

+   }

+

+   if (x < 0) {

+      GLint dx = -x;

+      GLint i;

+      for (i = 0; i < dx; i++)

+         depth[i] = 0.0;

+      x = 0;

+      n -= dx;

+      depth += dx;

+   }

+   if (x + n > (GLint) rb->Width) {

+      GLint dx = x + n - (GLint) rb->Width;

+      GLint i;

+      for (i = 0; i < dx; i++)

+         depth[n - i - 1] = 0.0;

+      n -= dx;

+   }

+   if (n <= 0) {

+      return;

+   }

+

+   if (rb->DataType == GL_UNSIGNED_INT) {

+      GLuint temp[MAX_WIDTH];

+      GLint i;

+      rb->GetRow(ctx, rb, n, x, y, temp);

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

+         depth[i] = temp[i] * scale;

+      }

+   }

+   else if (rb->DataType == GL_UNSIGNED_SHORT) {

+      GLushort temp[MAX_WIDTH];

+      GLint i;

+      rb->GetRow(ctx, rb, n, x, y, temp);

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

+         depth[i] = temp[i] * scale;

+      }

+   }

+   else {

+      _mesa_problem(ctx, "Invalid depth renderbuffer data type");

+   }

+}

+

+

+/**

+ * As above, but return 32-bit GLuint values.

+ */

+void

+_swrast_read_depth_span_uint( struct gl_context *ctx, struct gl_renderbuffer *rb,

+                              GLint n, GLint x, GLint y, GLuint depth[] )

+{

+   GLuint depthBits;

+

+   if (!rb) {

+      /* really only doing this to prevent FP exceptions later */

+      memset(depth, 0, n * sizeof(GLuint));

+      return;

+   }

+

+   depthBits = _mesa_get_format_bits(rb->Format, GL_DEPTH_BITS);

+

+   ASSERT(rb->_BaseFormat == GL_DEPTH_COMPONENT);

+

+   if (y < 0 || y >= (GLint) rb->Height ||

+       x + n <= 0 || x >= (GLint) rb->Width) {

+      /* span is completely outside framebuffer */

+      memset(depth, 0, n * sizeof(GLfloat));

+      return;

+   }

+

+   if (x < 0) {

+      GLint dx = -x;

+      GLint i;

+      for (i = 0; i < dx; i++)

+         depth[i] = 0;

+      x = 0;

+      n -= dx;

+      depth += dx;

+   }

+   if (x + n > (GLint) rb->Width) {

+      GLint dx = x + n - (GLint) rb->Width;

+      GLint i;

+      for (i = 0; i < dx; i++)

+         depth[n - i - 1] = 0;

+      n -= dx;

+   }

+   if (n <= 0) {

+      return;

+   }

+

+   if (rb->DataType == GL_UNSIGNED_INT) {

+      rb->GetRow(ctx, rb, n, x, y, depth);

+      if (depthBits < 32) {

+         GLuint shift = 32 - depthBits;

+         GLint i;

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

+            GLuint z = depth[i];

+            depth[i] = z << shift; /* XXX lsb bits? */

+         }

+      }

+   }

+   else if (rb->DataType == GL_UNSIGNED_SHORT) {

+      GLushort temp[MAX_WIDTH];

+      GLint i;

+      rb->GetRow(ctx, rb, n, x, y, temp);

+      if (depthBits == 16) {

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

+            GLuint z = temp[i];

+            depth[i] = (z << 16) | z;

+         }

+      }

+      else {

+         GLuint shift = 16 - depthBits;

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

+            GLuint z = temp[i];

+            depth[i] = (z << (shift + 16)) | (z << shift); /* XXX lsb bits? */

+         }

+      }

+   }

+   else {

+      _mesa_problem(ctx, "Invalid depth renderbuffer data type");

+   }

+}

+

+

+

+/**

+ * Clear the given z/depth renderbuffer.

+ */

+void

+_swrast_clear_depth_buffer( struct gl_context *ctx, struct gl_renderbuffer *rb )

+{

+   GLuint clearValue;

+   GLint x, y, width, height;

+

+   if (!rb || !ctx->Depth.Mask) {

+      /* no depth buffer, or writing to it is disabled */

+      return;

+   }

+

+   /* compute integer clearing value */

+   if (ctx->Depth.Clear == 1.0) {

+      clearValue = ctx->DrawBuffer->_DepthMax;

+   }

+   else {

+      clearValue = (GLuint) (ctx->Depth.Clear * ctx->DrawBuffer->_DepthMaxF);

+   }

+

+   assert(rb->_BaseFormat == GL_DEPTH_COMPONENT);

+

+   /* compute region to clear */

+   x = ctx->DrawBuffer->_Xmin;

+   y = ctx->DrawBuffer->_Ymin;

+   width  = ctx->DrawBuffer->_Xmax - ctx->DrawBuffer->_Xmin;

+   height = ctx->DrawBuffer->_Ymax - ctx->DrawBuffer->_Ymin;

+

+   if (rb->GetPointer(ctx, rb, 0, 0)) {

+      /* Direct buffer access is possible.  Either this is just malloc'd

+       * memory, or perhaps the driver mmap'd the zbuffer memory.

+       */

+      if (rb->DataType == GL_UNSIGNED_SHORT) {

+         if ((clearValue & 0xff) == ((clearValue >> 8) & 0xff) &&

+             ((GLushort *) rb->GetPointer(ctx, rb, 0, 0) + width ==

+              (GLushort *) rb->GetPointer(ctx, rb, 0, 1))) {

+            /* optimized case */

+            GLushort *dst = (GLushort *) rb->GetPointer(ctx, rb, x, y);

+            GLuint len = width * height * sizeof(GLushort);

+            memset(dst, (clearValue & 0xff), len);

+         }

+         else {

+            /* general case */

+            GLint i, j;

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

+               GLushort *dst = (GLushort *) rb->GetPointer(ctx, rb, x, y + i);

+               for (j = 0; j < width; j++) {

+                  dst[j] = clearValue;

+               }

+            }

+         }

+      }

+      else {

+         GLint i, j;

+         ASSERT(rb->DataType == GL_UNSIGNED_INT);

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

+            GLuint *dst = (GLuint *) rb->GetPointer(ctx, rb, x, y + i);

+            for (j = 0; j < width; j++) {

+               dst[j] = clearValue;

+            }

+         }

+      }

+   }

+   else {

+      /* Direct access not possible.  Use PutRow to write new values. */

+      if (rb->DataType == GL_UNSIGNED_SHORT) {

+         GLushort clearVal16 = (GLushort) (clearValue & 0xffff);

+         GLint i;

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

+            rb->PutMonoRow(ctx, rb, width, x, y + i, &clearVal16, NULL);

+         }

+      }

+      else if (rb->DataType == GL_UNSIGNED_INT) {

+         GLint i;

+         ASSERT(sizeof(clearValue) == sizeof(GLuint));

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

+            rb->PutMonoRow(ctx, rb, width, x, y + i, &clearValue, NULL);

+         }

+      }

+      else {

+         _mesa_problem(ctx, "bad depth renderbuffer DataType");

+      }

+   }

+}

diff --git a/mesalib/src/mesa/swrast/s_depth.h b/mesalib/src/mesa/swrast/s_depth.h
index 878d242f5..a35ed66bc 100644
--- a/mesalib/src/mesa/swrast/s_depth.h
+++ b/mesalib/src/mesa/swrast/s_depth.h
@@ -1,58 +1,61 @@
-/*
- * Mesa 3-D graphics library
- * Version:  6.5.1
- *
- * Copyright (C) 1999-2006  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.
- */
-
-
-#ifndef S_DEPTH_H
-#define S_DEPTH_H
-
-
-#include "main/mtypes.h"
-#include "s_span.h"
-
-
-extern GLuint
-_swrast_depth_test_span( GLcontext *ctx, SWspan *span);
-
-extern void
-_swrast_depth_clamp_span( GLcontext *ctx, SWspan *span );
-
-extern GLboolean
-_swrast_depth_bounds_test( GLcontext *ctx, SWspan *span );
-
-
-extern void
-_swrast_read_depth_span_float( GLcontext *ctx, struct gl_renderbuffer *rb,
-                               GLint n, GLint x, GLint y, GLfloat depth[] );
-
-
-extern void
-_swrast_read_depth_span_uint( GLcontext *ctx, struct gl_renderbuffer *rb,
-                              GLint n, GLint x, GLint y, GLuint depth[] );
-
-
-extern void
-_swrast_clear_depth_buffer( GLcontext *ctx, struct gl_renderbuffer *rb );
-
-
-#endif
+/*

+ * Mesa 3-D graphics library

+ * Version:  6.5.1

+ *

+ * Copyright (C) 1999-2006  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.

+ */

+

+

+#ifndef S_DEPTH_H

+#define S_DEPTH_H

+

+

+#include "main/glheader.h"

+#include "s_span.h"

+

+struct gl_context;

+struct gl_renderbuffer;

+

+

+extern GLuint

+_swrast_depth_test_span( struct gl_context *ctx, SWspan *span);

+

+extern void

+_swrast_depth_clamp_span( struct gl_context *ctx, SWspan *span );

+

+extern GLboolean

+_swrast_depth_bounds_test( struct gl_context *ctx, SWspan *span );

+

+

+extern void

+_swrast_read_depth_span_float( struct gl_context *ctx, struct gl_renderbuffer *rb,

+                               GLint n, GLint x, GLint y, GLfloat depth[] );

+

+

+extern void

+_swrast_read_depth_span_uint( struct gl_context *ctx, struct gl_renderbuffer *rb,

+                              GLint n, GLint x, GLint y, GLuint depth[] );

+

+

+extern void

+_swrast_clear_depth_buffer( struct gl_context *ctx, struct gl_renderbuffer *rb );

+

+

+#endif

diff --git a/mesalib/src/mesa/swrast/s_drawpix.c b/mesalib/src/mesa/swrast/s_drawpix.c
index 3cec3a7a2..cca75784a 100644
--- a/mesalib/src/mesa/swrast/s_drawpix.c
+++ b/mesalib/src/mesa/swrast/s_drawpix.c
@@ -1,824 +1,752 @@
-/*
- * 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/bufferobj.h"
-#include "main/condrender.h"
-#include "main/context.h"
-#include "main/convolve.h"
-#include "main/image.h"
-#include "main/macros.h"
-#include "main/imports.h"
-#include "main/state.h"
-
-#include "s_context.h"
-#include "s_span.h"
-#include "s_stencil.h"
-#include "s_zoom.h"
-
-
-
-/**
- * Try to do a fast and simple RGB(a) glDrawPixels.
- * Return:  GL_TRUE if success, GL_FALSE if slow path must be used instead
- */
-static GLboolean
-fast_draw_rgba_pixels(GLcontext *ctx, GLint x, GLint y,
-                      GLsizei width, GLsizei height,
-                      GLenum format, GLenum type,
-                      const struct gl_pixelstore_attrib *userUnpack,
-                      const GLvoid *pixels)
-{
-   const GLint imgX = x, imgY = y;
-   struct gl_renderbuffer *rb = ctx->DrawBuffer->_ColorDrawBuffers[0];
-   GLenum rbType;
-   SWcontext *swrast = SWRAST_CONTEXT(ctx);
-   SWspan span;
-   GLboolean simpleZoom;
-   GLint yStep;  /* +1 or -1 */
-   struct gl_pixelstore_attrib unpack;
-   GLint destX, destY, drawWidth, drawHeight; /* post clipping */
-
-   if (!rb)
-      return GL_TRUE; /* no-op */
-
-   rbType = rb->DataType;
-
-   if ((swrast->_RasterMask & ~CLIP_BIT) ||
-       ctx->Texture._EnabledCoordUnits ||
-       userUnpack->SwapBytes ||
-       ctx->_ImageTransferState) {
-      /* can't handle any of those conditions */
-      return GL_FALSE;
-   }
-
-   INIT_SPAN(span, GL_BITMAP);
-   span.arrayMask = SPAN_RGBA;
-   span.arrayAttribs = FRAG_BIT_COL0;
-   _swrast_span_default_attribs(ctx, &span);
-
-   /* copy input params since clipping may change them */
-   unpack = *userUnpack;
-   destX = x;
-   destY = y;
-   drawWidth = width;
-   drawHeight = height;
-
-   /* check for simple zooming and clipping */
-   if (ctx->Pixel.ZoomX == 1.0F &&
-       (ctx->Pixel.ZoomY == 1.0F || ctx->Pixel.ZoomY == -1.0F)) {
-      if (!_mesa_clip_drawpixels(ctx, &destX, &destY,
-                                 &drawWidth, &drawHeight, &unpack)) {
-         /* image was completely clipped: no-op, all done */
-         return GL_TRUE;
-      }
-      simpleZoom = GL_TRUE;
-      yStep = (GLint) ctx->Pixel.ZoomY;
-      ASSERT(yStep == 1 || yStep == -1);
-   }
-   else {
-      /* non-simple zooming */
-      simpleZoom = GL_FALSE;
-      yStep = 1;
-      if (unpack.RowLength == 0)
-         unpack.RowLength = width;
-   }
-
-   /*
-    * Ready to draw!
-    */
-
-   if (format == GL_RGBA && type == rbType) {
-      const GLubyte *src
-         = (const GLubyte *) _mesa_image_address2d(&unpack, pixels, width,
-                                                   height, format, type, 0, 0);
-      const GLint srcStride = _mesa_image_row_stride(&unpack, width,
-                                                     format, type);
-      if (simpleZoom) {
-         GLint row;
-         for (row = 0; row < drawHeight; row++) {
-            rb->PutRow(ctx, rb, drawWidth, destX, destY, src, NULL);
-            src += srcStride;
-            destY += yStep;
-         }
-      }
-      else {
-         /* with zooming */
-         GLint row;
-         for (row = 0; row < drawHeight; row++) {
-            span.x = destX;
-            span.y = destY + row;
-            span.end = drawWidth;
-            span.array->ChanType = rbType;
-            _swrast_write_zoomed_rgba_span(ctx, imgX, imgY, &span, src);
-            src += srcStride;
-         }
-         span.array->ChanType = CHAN_TYPE;
-      }
-      return GL_TRUE;
-   }
-
-   if (format == GL_RGB && type == rbType) {
-      const GLubyte *src
-         = (const GLubyte *) _mesa_image_address2d(&unpack, pixels, width,
-                                                   height, format, type, 0, 0);
-      const GLint srcStride = _mesa_image_row_stride(&unpack, width,
-                                                     format, type);
-      if (simpleZoom) {
-         GLint row;
-         for (row = 0; row < drawHeight; row++) {
-            rb->PutRowRGB(ctx, rb, drawWidth, destX, destY, src, NULL);
-            src += srcStride;
-            destY += yStep;
-         }
-      }
-      else {
-         /* with zooming */
-         GLint row;
-         for (row = 0; row < drawHeight; row++) {
-            span.x = destX;
-            span.y = destY;
-            span.end = drawWidth;
-            span.array->ChanType = rbType;
-            _swrast_write_zoomed_rgb_span(ctx, imgX, imgY, &span, src);
-            src += srcStride;
-            destY++;
-         }
-         span.array->ChanType = CHAN_TYPE;
-      }
-      return GL_TRUE;
-   }
-
-   /* Remaining cases haven't been tested with alignment != 1 */
-   if (userUnpack->Alignment != 1)
-      return GL_FALSE;
-
-   if (format == GL_LUMINANCE && type == CHAN_TYPE && rbType == CHAN_TYPE) {
-      const GLchan *src = (const GLchan *) pixels
-         + (unpack.SkipRows * unpack.RowLength + unpack.SkipPixels);
-      if (simpleZoom) {
-         /* no zooming */
-         GLint row;
-         ASSERT(drawWidth <= MAX_WIDTH);
-         for (row = 0; row < drawHeight; row++) {
-            GLchan rgb[MAX_WIDTH][3];
-            GLint i;
-            for (i = 0;i<drawWidth;i++) {
-               rgb[i][0] = src[i];
-               rgb[i][1] = src[i];
-               rgb[i][2] = src[i];
-            }
-            rb->PutRowRGB(ctx, rb, drawWidth, destX, destY, rgb, NULL);
-            src += unpack.RowLength;
-            destY += yStep;
-         }
-      }
-      else {
-         /* with zooming */
-         GLint row;
-         ASSERT(drawWidth <= MAX_WIDTH);
-         for (row = 0; row < drawHeight; row++) {
-            GLchan rgb[MAX_WIDTH][3];
-            GLint i;
-            for (i = 0;i<drawWidth;i++) {
-               rgb[i][0] = src[i];
-               rgb[i][1] = src[i];
-               rgb[i][2] = src[i];
-            }
-            span.x = destX;
-            span.y = destY;
-            span.end = drawWidth;
-            _swrast_write_zoomed_rgb_span(ctx, imgX, imgY, &span, rgb);
-            src += unpack.RowLength;
-            destY++;
-         }
-      }
-      return GL_TRUE;
-   }
-
-   if (format == GL_LUMINANCE_ALPHA && type == CHAN_TYPE && rbType == CHAN_TYPE) {
-      const GLchan *src = (const GLchan *) pixels
-         + (unpack.SkipRows * unpack.RowLength + unpack.SkipPixels)*2;
-      if (simpleZoom) {
-         GLint row;
-         ASSERT(drawWidth <= MAX_WIDTH);
-         for (row = 0; row < drawHeight; row++) {
-            GLint i;
-            const GLchan *ptr = src;
-            for (i = 0;i<drawWidth;i++) {
-               span.array->rgba[i][0] = *ptr;
-               span.array->rgba[i][1] = *ptr;
-               span.array->rgba[i][2] = *ptr++;
-               span.array->rgba[i][3] = *ptr++;
-            }
-            rb->PutRow(ctx, rb, drawWidth, destX, destY,
-                       span.array->rgba, NULL);
-            src += unpack.RowLength*2;
-            destY += yStep;
-         }
-      }
-      else {
-         /* with zooming */
-         GLint row;
-         ASSERT(drawWidth <= MAX_WIDTH);
-         for (row = 0; row < drawHeight; row++) {
-            const GLchan *ptr = src;
-            GLint i;
-            for (i = 0;i<drawWidth;i++) {
-               span.array->rgba[i][0] = *ptr;
-               span.array->rgba[i][1] = *ptr;
-               span.array->rgba[i][2] = *ptr++;
-               span.array->rgba[i][3] = *ptr++;
-            }
-            span.x = destX;
-            span.y = destY;
-            span.end = drawWidth;
-            _swrast_write_zoomed_rgba_span(ctx, imgX, imgY, &span,
-                                           span.array->rgba);
-            src += unpack.RowLength*2;
-            destY++;
-         }
-      }
-      return GL_TRUE;
-   }
-
-   if (format == GL_COLOR_INDEX && type == GL_UNSIGNED_BYTE) {
-      const GLubyte *src = (const GLubyte *) pixels
-         + unpack.SkipRows * unpack.RowLength + unpack.SkipPixels;
-      if (rbType == GL_UNSIGNED_BYTE) {
-         /* convert ubyte/CI data to ubyte/RGBA */
-         if (simpleZoom) {
-            GLint row;
-            for (row = 0; row < drawHeight; row++) {
-               ASSERT(drawWidth <= MAX_WIDTH);
-               _mesa_map_ci8_to_rgba8(ctx, drawWidth, src,
-                                      span.array->rgba8);
-               rb->PutRow(ctx, rb, drawWidth, destX, destY,
-                          span.array->rgba8, NULL);
-               src += unpack.RowLength;
-               destY += yStep;
-            }
-         }
-         else {
-            /* ubyte/CI to ubyte/RGBA with zooming */
-            GLint row;
-            for (row = 0; row < drawHeight; row++) {
-               ASSERT(drawWidth <= MAX_WIDTH);
-               _mesa_map_ci8_to_rgba8(ctx, drawWidth, src,
-                                      span.array->rgba8);
-               span.x = destX;
-               span.y = destY;
-               span.end = drawWidth;
-               _swrast_write_zoomed_rgba_span(ctx, imgX, imgY, &span,
-                                              span.array->rgba8);
-               src += unpack.RowLength;
-               destY++;
-            }
-         }
-         return GL_TRUE;
-      }
-   }
-
-   /* can't handle this pixel format and/or data type */
-   return GL_FALSE;
-}
-
-
-
-/*
- * Draw stencil image.
- */
-static void
-draw_stencil_pixels( GLcontext *ctx, GLint x, GLint y,
-                     GLsizei width, GLsizei height,
-                     GLenum type,
-                     const struct gl_pixelstore_attrib *unpack,
-                     const GLvoid *pixels )
-{
-   const GLboolean zoom = ctx->Pixel.ZoomX != 1.0 || ctx->Pixel.ZoomY != 1.0;
-   GLint skipPixels;
-
-   /* if width > MAX_WIDTH, have to process image in chunks */
-   skipPixels = 0;
-   while (skipPixels < width) {
-      const GLint spanX = x + skipPixels;
-      const GLint spanWidth = MIN2(width - skipPixels, MAX_WIDTH);
-      GLint row;
-      for (row = 0; row < height; row++) {
-         const GLint spanY = y + row;
-         GLstencil values[MAX_WIDTH];
-         GLenum destType = (sizeof(GLstencil) == sizeof(GLubyte))
-                         ? GL_UNSIGNED_BYTE : GL_UNSIGNED_SHORT;
-         const GLvoid *source = _mesa_image_address2d(unpack, pixels,
-                                                      width, height,
-                                                      GL_COLOR_INDEX, type,
-                                                      row, skipPixels);
-         _mesa_unpack_stencil_span(ctx, spanWidth, destType, values,
-                                   type, source, unpack,
-                                   ctx->_ImageTransferState);
-         if (zoom) {
-            _swrast_write_zoomed_stencil_span(ctx, x, y, spanWidth,
-                                              spanX, spanY, values);
-         }
-         else {
-            _swrast_write_stencil_span(ctx, spanWidth, spanX, spanY, values);
-         }
-      }
-      skipPixels += spanWidth;
-   }
-}
-
-
-/*
- * Draw depth image.
- */
-static void
-draw_depth_pixels( GLcontext *ctx, GLint x, GLint y,
-                   GLsizei width, GLsizei height,
-                   GLenum type,
-                   const struct gl_pixelstore_attrib *unpack,
-                   const GLvoid *pixels )
-{
-   const GLboolean scaleOrBias
-      = ctx->Pixel.DepthScale != 1.0 || ctx->Pixel.DepthBias != 0.0;
-   const GLboolean zoom = ctx->Pixel.ZoomX != 1.0 || ctx->Pixel.ZoomY != 1.0;
-   SWspan span;
-
-   INIT_SPAN(span, GL_BITMAP);
-   span.arrayMask = SPAN_Z;
-   _swrast_span_default_attribs(ctx, &span);
-
-   if (type == GL_UNSIGNED_SHORT
-       && ctx->DrawBuffer->Visual.depthBits == 16
-       && !scaleOrBias
-       && !zoom
-       && width <= MAX_WIDTH
-       && !unpack->SwapBytes) {
-      /* Special case: directly write 16-bit depth values */
-      GLint row;
-      for (row = 0; row < height; row++) {
-         const GLushort *zSrc = (const GLushort *)
-            _mesa_image_address2d(unpack, pixels, width, height,
-                                  GL_DEPTH_COMPONENT, type, row, 0);
-         GLint i;
-         for (i = 0; i < width; i++)
-            span.array->z[i] = zSrc[i];
-         span.x = x;
-         span.y = y + row;
-         span.end = width;
-         _swrast_write_rgba_span(ctx, &span);
-      }
-   }
-   else if (type == GL_UNSIGNED_INT
-            && !scaleOrBias
-            && !zoom
-            && width <= MAX_WIDTH
-            && !unpack->SwapBytes) {
-      /* Special case: shift 32-bit values down to Visual.depthBits */
-      const GLint shift = 32 - ctx->DrawBuffer->Visual.depthBits;
-      GLint row;
-      for (row = 0; row < height; row++) {
-         const GLuint *zSrc = (const GLuint *)
-            _mesa_image_address2d(unpack, pixels, width, height,
-                                  GL_DEPTH_COMPONENT, type, row, 0);
-         if (shift == 0) {
-            memcpy(span.array->z, zSrc, width * sizeof(GLuint));
-         }
-         else {
-            GLint col;
-            for (col = 0; col < width; col++)
-               span.array->z[col] = zSrc[col] >> shift;
-         }
-         span.x = x;
-         span.y = y + row;
-         span.end = width;
-         _swrast_write_rgba_span(ctx, &span);
-      }
-   }
-   else {
-      /* General case */
-      const GLuint depthMax = ctx->DrawBuffer->_DepthMax;
-      GLint skipPixels = 0;
-
-      /* in case width > MAX_WIDTH do the copy in chunks */
-      while (skipPixels < width) {
-         const GLint spanWidth = MIN2(width - skipPixels, MAX_WIDTH);
-         GLint row;
-         ASSERT(span.end <= MAX_WIDTH);
-         for (row = 0; row < height; row++) {
-            const GLvoid *zSrc = _mesa_image_address2d(unpack,
-                                                      pixels, width, height,
-                                                      GL_DEPTH_COMPONENT, type,
-                                                      row, skipPixels);
-
-            /* Set these for each row since the _swrast_write_* function may
-             * change them while clipping.
-             */
-            span.x = x + skipPixels;
-            span.y = y + row;
-            span.end = spanWidth;
-
-            _mesa_unpack_depth_span(ctx, spanWidth,
-                                    GL_UNSIGNED_INT, span.array->z, depthMax,
-                                    type, zSrc, unpack);
-            if (zoom) {
-               _swrast_write_zoomed_depth_span(ctx, x, y, &span);
-            }
-            else {
-               _swrast_write_rgba_span(ctx, &span);
-            }
-         }
-         skipPixels += spanWidth;
-      }
-   }
-}
-
-
-
-/**
- * Draw RGBA image.
- */
-static void
-draw_rgba_pixels( GLcontext *ctx, GLint x, GLint y,
-                  GLsizei width, GLsizei height,
-                  GLenum format, GLenum type,
-                  const struct gl_pixelstore_attrib *unpack,
-                  const GLvoid *pixels )
-{
-   const GLint imgX = x, imgY = y;
-   const GLboolean zoom = ctx->Pixel.ZoomX!=1.0 || ctx->Pixel.ZoomY!=1.0;
-   GLfloat *convImage = NULL;
-   GLbitfield transferOps = ctx->_ImageTransferState;
-   SWspan span;
-
-   /* Try an optimized glDrawPixels first */
-   if (fast_draw_rgba_pixels(ctx, x, y, width, height, format, type,
-                             unpack, pixels)) {
-      return;
-   }
-
-   INIT_SPAN(span, GL_BITMAP);
-   _swrast_span_default_attribs(ctx, &span);
-   span.arrayMask = SPAN_RGBA;
-   span.arrayAttribs = FRAG_BIT_COL0; /* we're fill in COL0 attrib values */
-
-   if (ctx->Pixel.Convolution2DEnabled || ctx->Pixel.Separable2DEnabled) {
-      /* Convolution has to be handled specially.  We'll create an
-       * intermediate image, applying all pixel transfer operations
-       * up to convolution.  Then we'll convolve the image.  Then
-       * we'll proceed with the rest of the transfer operations and
-       * rasterize the image.
-       */
-      GLint row;
-      GLfloat *dest, *tmpImage;
-
-      tmpImage = (GLfloat *) malloc(width * height * 4 * sizeof(GLfloat));
-      if (!tmpImage) {
-         _mesa_error(ctx, GL_OUT_OF_MEMORY, "glDrawPixels");
-         return;
-      }
-      convImage = (GLfloat *) malloc(width * height * 4 * sizeof(GLfloat));
-      if (!convImage) {
-         free(tmpImage);
-         _mesa_error(ctx, GL_OUT_OF_MEMORY, "glDrawPixels");
-         return;
-      }
-
-      /* Unpack the image and apply transfer ops up to convolution */
-      dest = tmpImage;
-      for (row = 0; row < height; row++) {
-         const GLvoid *source = _mesa_image_address2d(unpack,
-                                  pixels, width, height, format, type, row, 0);
-         _mesa_unpack_color_span_float(ctx, width, GL_RGBA, (GLfloat *) dest,
-                                     format, type, source, unpack,
-                                     transferOps & IMAGE_PRE_CONVOLUTION_BITS);
-         dest += width * 4;
-      }
-
-      /* do convolution */
-      if (ctx->Pixel.Convolution2DEnabled) {
-         _mesa_convolve_2d_image(ctx, &width, &height, tmpImage, convImage);
-      }
-      else {
-         ASSERT(ctx->Pixel.Separable2DEnabled);
-         _mesa_convolve_sep_image(ctx, &width, &height, tmpImage, convImage);
-      }
-      free(tmpImage);
-
-      /* continue transfer ops and draw the convolved image */
-      unpack = &ctx->DefaultPacking;
-      pixels = convImage;
-      format = GL_RGBA;
-      type = GL_FLOAT;
-      transferOps &= IMAGE_POST_CONVOLUTION_BITS;
-   }
-   else if (ctx->Pixel.Convolution1DEnabled) {
-      /* we only want to apply 1D convolution to glTexImage1D */
-      transferOps &= ~(IMAGE_CONVOLUTION_BIT |
-                       IMAGE_POST_CONVOLUTION_SCALE_BIAS);
-   }
-
-   if (ctx->DrawBuffer->_NumColorDrawBuffers > 0 &&
-       ctx->DrawBuffer->_ColorDrawBuffers[0]->DataType != GL_FLOAT &&
-       ctx->Color.ClampFragmentColor != GL_FALSE) {
-      /* need to clamp colors before applying fragment ops */
-      transferOps |= IMAGE_CLAMP_BIT;
-   }
-
-   /*
-    * General solution
-    */
-   {
-      const GLboolean sink = (ctx->Pixel.MinMaxEnabled && ctx->MinMax.Sink)
-         || (ctx->Pixel.HistogramEnabled && ctx->Histogram.Sink);
-      const GLbitfield interpMask = span.interpMask;
-      const GLbitfield arrayMask = span.arrayMask;
-      const GLint srcStride
-         = _mesa_image_row_stride(unpack, width, format, type);
-      GLint skipPixels = 0;
-      /* use span array for temp color storage */
-      GLfloat *rgba = (GLfloat *) span.array->attribs[FRAG_ATTRIB_COL0];
-
-      /* if the span is wider than MAX_WIDTH we have to do it in chunks */
-      while (skipPixels < width) {
-         const GLint spanWidth = MIN2(width - skipPixels, MAX_WIDTH);
-         const GLubyte *source
-            = (const GLubyte *) _mesa_image_address2d(unpack, pixels,
-                                                      width, height, format,
-                                                      type, 0, skipPixels);
-         GLint row;
-
-         for (row = 0; row < height; row++) {
-            /* get image row as float/RGBA */
-            _mesa_unpack_color_span_float(ctx, spanWidth, GL_RGBA, rgba,
-                                     format, type, source, unpack,
-                                     transferOps);
-            /* draw the span */
-            if (!sink) {
-               /* Set these for each row since the _swrast_write_* functions
-                * may change them while clipping/rendering.
-                */
-               span.array->ChanType = GL_FLOAT;
-               span.x = x + skipPixels;
-               span.y = y + row;
-               span.end = spanWidth;
-               span.arrayMask = arrayMask;
-               span.interpMask = interpMask;
-               if (zoom) {
-                  _swrast_write_zoomed_rgba_span(ctx, imgX, imgY, &span, rgba);
-               }
-               else {
-                  _swrast_write_rgba_span(ctx, &span);
-               }
-            }
-
-            source += srcStride;
-         } /* for row */
-
-         skipPixels += spanWidth;
-      } /* while skipPixels < width */
-
-      /* XXX this is ugly/temporary, to undo above change */
-      span.array->ChanType = CHAN_TYPE;
-   }
-
-   if (convImage) {
-      free(convImage);
-   }
-}
-
-
-/**
- * This is a bit different from drawing GL_DEPTH_COMPONENT pixels.
- * The only per-pixel operations that apply are depth scale/bias,
- * stencil offset/shift, GL_DEPTH_WRITEMASK and GL_STENCIL_WRITEMASK,
- * and pixel zoom.
- * Also, only the depth buffer and stencil buffers are touched, not the
- * color buffer(s).
- */
-static void
-draw_depth_stencil_pixels(GLcontext *ctx, GLint x, GLint y,
-                          GLsizei width, GLsizei height, GLenum type,
-                          const struct gl_pixelstore_attrib *unpack,
-                          const GLvoid *pixels)
-{
-   const GLint imgX = x, imgY = y;
-   const GLboolean scaleOrBias
-      = ctx->Pixel.DepthScale != 1.0 || ctx->Pixel.DepthBias != 0.0;
-   const GLuint depthMax = ctx->DrawBuffer->_DepthMax;
-   const GLuint stencilMask = ctx->Stencil.WriteMask[0];
-   const GLuint stencilType = (STENCIL_BITS == 8) ? 
-      GL_UNSIGNED_BYTE : GL_UNSIGNED_SHORT;
-   const GLboolean zoom = ctx->Pixel.ZoomX != 1.0 || ctx->Pixel.ZoomY != 1.0;
-   struct gl_renderbuffer *depthRb, *stencilRb;
-   struct gl_pixelstore_attrib clippedUnpack = *unpack;
-
-   if (!zoom) {
-      if (!_mesa_clip_drawpixels(ctx, &x, &y, &width, &height,
-                                 &clippedUnpack)) {
-         /* totally clipped */
-         return;
-      }
-   }
-   
-   depthRb = ctx->ReadBuffer->Attachment[BUFFER_DEPTH].Renderbuffer;
-   stencilRb = ctx->ReadBuffer->Attachment[BUFFER_STENCIL].Renderbuffer;
-   ASSERT(depthRb);
-   ASSERT(stencilRb);
-
-   if (depthRb->_BaseFormat == GL_DEPTH_STENCIL_EXT &&
-       stencilRb->_BaseFormat == GL_DEPTH_STENCIL_EXT &&
-       depthRb == stencilRb &&
-       !scaleOrBias &&
-       !zoom &&
-       ctx->Depth.Mask &&
-       (stencilMask & 0xff) == 0xff) {
-      /* This is the ideal case.
-       * Drawing GL_DEPTH_STENCIL pixels into a combined depth/stencil buffer.
-       * Plus, no pixel transfer ops, zooming, or masking needed.
-       */
-      GLint i;
-      for (i = 0; i < height; i++) {
-         const GLuint *src = (const GLuint *) 
-            _mesa_image_address2d(&clippedUnpack, pixels, width, height,
-                                  GL_DEPTH_STENCIL_EXT, type, i, 0);
-         depthRb->PutRow(ctx, depthRb, width, x, y + i, src, NULL);
-      }
-   }
-   else {
-      /* sub-optimal cases:
-       * Separate depth/stencil buffers, or pixel transfer ops required.
-       */
-      /* XXX need to handle very wide images (skippixels) */
-      GLint i;
-
-      depthRb = ctx->DrawBuffer->_DepthBuffer;
-      stencilRb = ctx->DrawBuffer->_StencilBuffer;
-
-      for (i = 0; i < height; i++) {
-         const GLuint *depthStencilSrc = (const GLuint *)
-            _mesa_image_address2d(&clippedUnpack, pixels, width, height,
-                                  GL_DEPTH_STENCIL_EXT, type, i, 0);
-
-         if (ctx->Depth.Mask) {
-            if (!scaleOrBias && ctx->DrawBuffer->Visual.depthBits == 24) {
-               /* fast path 24-bit zbuffer */
-               GLuint zValues[MAX_WIDTH];
-               GLint j;
-               ASSERT(depthRb->DataType == GL_UNSIGNED_INT);
-               for (j = 0; j < width; j++) {
-                  zValues[j] = depthStencilSrc[j] >> 8;
-               }
-               if (zoom)
-                  _swrast_write_zoomed_z_span(ctx, imgX, imgY, width,
-                                              x, y + i, zValues);
-               else
-                  depthRb->PutRow(ctx, depthRb, width, x, y + i, zValues,NULL);
-            }
-            else if (!scaleOrBias && ctx->DrawBuffer->Visual.depthBits == 16) {
-               /* fast path 16-bit zbuffer */
-               GLushort zValues[MAX_WIDTH];
-               GLint j;
-               ASSERT(depthRb->DataType == GL_UNSIGNED_SHORT);
-               for (j = 0; j < width; j++) {
-                  zValues[j] = depthStencilSrc[j] >> 16;
-               }
-               if (zoom)
-                  _swrast_write_zoomed_z_span(ctx, imgX, imgY, width,
-                                              x, y + i, zValues);
-               else
-                  depthRb->PutRow(ctx, depthRb, width, x, y + i, zValues,NULL);
-            }
-            else {
-               /* general case */
-               GLuint zValues[MAX_WIDTH];  /* 16 or 32-bit Z value storage */
-               _mesa_unpack_depth_span(ctx, width,
-                                       depthRb->DataType, zValues, depthMax,
-                                       type, depthStencilSrc, &clippedUnpack);
-               if (zoom) {
-                  _swrast_write_zoomed_z_span(ctx, imgX, imgY, width, x,
-                                              y + i, zValues);
-               }
-               else {
-                  depthRb->PutRow(ctx, depthRb, width, x, y + i, zValues,NULL);
-               }
-            }
-         }
-
-         if (stencilMask != 0x0) {
-            GLstencil stencilValues[MAX_WIDTH];
-            /* get stencil values, with shift/offset/mapping */
-            _mesa_unpack_stencil_span(ctx, width, stencilType, stencilValues,
-                                      type, depthStencilSrc, &clippedUnpack,
-                                      ctx->_ImageTransferState);
-            if (zoom)
-               _swrast_write_zoomed_stencil_span(ctx, imgX, imgY, width,
-                                                  x, y + i, stencilValues);
-            else
-               _swrast_write_stencil_span(ctx, width, x, y + i, stencilValues);
-         }
-      }
-   }
-}
-
-
-/**
- * Execute software-based glDrawPixels.
- * By time we get here, all error checking will have been done.
- */
-void
-_swrast_DrawPixels( GLcontext *ctx,
-		    GLint x, GLint y,
-		    GLsizei width, GLsizei height,
-		    GLenum format, GLenum type,
-		    const struct gl_pixelstore_attrib *unpack,
-		    const GLvoid *pixels )
-{
-   SWcontext *swrast = SWRAST_CONTEXT(ctx);
-   GLboolean save_vp_override = ctx->VertexProgram._Overriden;
-
-   if (!_mesa_check_conditional_render(ctx))
-      return; /* don't draw */
-
-   /* We are creating fragments directly, without going through vertex
-    * programs.
-    *
-    * This override flag tells the fragment processing code that its input
-    * comes from a non-standard source, and it may therefore not rely on
-    * optimizations that assume e.g. constant color if there is no color
-    * vertex array.
-    */
-   _mesa_set_vp_override(ctx, GL_TRUE);
-
-   swrast_render_start(ctx);
-
-   if (ctx->NewState)
-      _mesa_update_state(ctx);
-
-   if (swrast->NewState)
-      _swrast_validate_derived( ctx );
-
-    pixels = _mesa_map_pbo_source(ctx, unpack, pixels);
-    if (!pixels) {
-       swrast_render_finish(ctx);
-       _mesa_set_vp_override(ctx, save_vp_override);
-       return;
-    }
-
-   switch (format) {
-   case GL_STENCIL_INDEX:
-      draw_stencil_pixels( ctx, x, y, width, height, type, unpack, pixels );
-      break;
-   case GL_DEPTH_COMPONENT:
-      draw_depth_pixels( ctx, x, y, width, height, type, unpack, pixels );
-      break;
-   case GL_COLOR_INDEX:
-   case GL_RED:
-   case GL_GREEN:
-   case GL_BLUE:
-   case GL_ALPHA:
-   case GL_LUMINANCE:
-   case GL_LUMINANCE_ALPHA:
-   case GL_RGB:
-   case GL_BGR:
-   case GL_RGBA:
-   case GL_BGRA:
-   case GL_ABGR_EXT:
-      draw_rgba_pixels(ctx, x, y, width, height, format, type, unpack, pixels);
-      break;
-   case GL_DEPTH_STENCIL_EXT:
-      draw_depth_stencil_pixels(ctx, x, y, width, height,
-                                type, unpack, pixels);
-      break;
-   default:
-      _mesa_problem(ctx, "unexpected format in _swrast_DrawPixels");
-      /* don't return yet, clean-up */
-   }
-
-   swrast_render_finish(ctx);
-   _mesa_set_vp_override(ctx, save_vp_override);
-
-   _mesa_unmap_pbo_source(ctx, unpack);
-}
+/*

+ * 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/bufferobj.h"

+#include "main/condrender.h"

+#include "main/context.h"

+#include "main/image.h"

+#include "main/imports.h"

+#include "main/macros.h"

+#include "main/pack.h"

+#include "main/pixeltransfer.h"

+#include "main/state.h"

+

+#include "s_context.h"

+#include "s_span.h"

+#include "s_stencil.h"

+#include "s_zoom.h"

+

+

+

+/**

+ * Try to do a fast and simple RGB(a) glDrawPixels.

+ * Return:  GL_TRUE if success, GL_FALSE if slow path must be used instead

+ */

+static GLboolean

+fast_draw_rgba_pixels(struct gl_context *ctx, GLint x, GLint y,

+                      GLsizei width, GLsizei height,

+                      GLenum format, GLenum type,

+                      const struct gl_pixelstore_attrib *userUnpack,

+                      const GLvoid *pixels)

+{

+   const GLint imgX = x, imgY = y;

+   struct gl_renderbuffer *rb = ctx->DrawBuffer->_ColorDrawBuffers[0];

+   GLenum rbType;

+   SWcontext *swrast = SWRAST_CONTEXT(ctx);

+   SWspan span;

+   GLboolean simpleZoom;

+   GLint yStep;  /* +1 or -1 */

+   struct gl_pixelstore_attrib unpack;

+   GLint destX, destY, drawWidth, drawHeight; /* post clipping */

+

+   if (!rb)

+      return GL_TRUE; /* no-op */

+

+   rbType = rb->DataType;

+

+   if ((swrast->_RasterMask & ~CLIP_BIT) ||

+       ctx->Texture._EnabledCoordUnits ||

+       userUnpack->SwapBytes ||

+       ctx->_ImageTransferState) {

+      /* can't handle any of those conditions */

+      return GL_FALSE;

+   }

+

+   INIT_SPAN(span, GL_BITMAP);

+   span.arrayMask = SPAN_RGBA;

+   span.arrayAttribs = FRAG_BIT_COL0;

+   _swrast_span_default_attribs(ctx, &span);

+

+   /* copy input params since clipping may change them */

+   unpack = *userUnpack;

+   destX = x;

+   destY = y;

+   drawWidth = width;

+   drawHeight = height;

+

+   /* check for simple zooming and clipping */

+   if (ctx->Pixel.ZoomX == 1.0F &&

+       (ctx->Pixel.ZoomY == 1.0F || ctx->Pixel.ZoomY == -1.0F)) {

+      if (!_mesa_clip_drawpixels(ctx, &destX, &destY,

+                                 &drawWidth, &drawHeight, &unpack)) {

+         /* image was completely clipped: no-op, all done */

+         return GL_TRUE;

+      }

+      simpleZoom = GL_TRUE;

+      yStep = (GLint) ctx->Pixel.ZoomY;

+      ASSERT(yStep == 1 || yStep == -1);

+   }

+   else {

+      /* non-simple zooming */

+      simpleZoom = GL_FALSE;

+      yStep = 1;

+      if (unpack.RowLength == 0)

+         unpack.RowLength = width;

+   }

+

+   /*

+    * Ready to draw!

+    */

+

+   if (format == GL_RGBA && type == rbType) {

+      const GLubyte *src

+         = (const GLubyte *) _mesa_image_address2d(&unpack, pixels, width,

+                                                   height, format, type, 0, 0);

+      const GLint srcStride = _mesa_image_row_stride(&unpack, width,

+                                                     format, type);

+      if (simpleZoom) {

+         GLint row;

+         for (row = 0; row < drawHeight; row++) {

+            rb->PutRow(ctx, rb, drawWidth, destX, destY, src, NULL);

+            src += srcStride;

+            destY += yStep;

+         }

+      }

+      else {

+         /* with zooming */

+         GLint row;

+         for (row = 0; row < drawHeight; row++) {

+            span.x = destX;

+            span.y = destY + row;

+            span.end = drawWidth;

+            span.array->ChanType = rbType;

+            _swrast_write_zoomed_rgba_span(ctx, imgX, imgY, &span, src);

+            src += srcStride;

+         }

+         span.array->ChanType = CHAN_TYPE;

+      }

+      return GL_TRUE;

+   }

+

+   if (format == GL_RGB && type == rbType) {

+      const GLubyte *src

+         = (const GLubyte *) _mesa_image_address2d(&unpack, pixels, width,

+                                                   height, format, type, 0, 0);

+      const GLint srcStride = _mesa_image_row_stride(&unpack, width,

+                                                     format, type);

+      if (simpleZoom) {

+         GLint row;

+         for (row = 0; row < drawHeight; row++) {

+            rb->PutRowRGB(ctx, rb, drawWidth, destX, destY, src, NULL);

+            src += srcStride;

+            destY += yStep;

+         }

+      }

+      else {

+         /* with zooming */

+         GLint row;

+         for (row = 0; row < drawHeight; row++) {

+            span.x = destX;

+            span.y = destY;

+            span.end = drawWidth;

+            span.array->ChanType = rbType;

+            _swrast_write_zoomed_rgb_span(ctx, imgX, imgY, &span, src);

+            src += srcStride;

+            destY++;

+         }

+         span.array->ChanType = CHAN_TYPE;

+      }

+      return GL_TRUE;

+   }

+

+   /* Remaining cases haven't been tested with alignment != 1 */

+   if (userUnpack->Alignment != 1)

+      return GL_FALSE;

+

+   if (format == GL_LUMINANCE && type == CHAN_TYPE && rbType == CHAN_TYPE) {

+      const GLchan *src = (const GLchan *) pixels

+         + (unpack.SkipRows * unpack.RowLength + unpack.SkipPixels);

+      if (simpleZoom) {

+         /* no zooming */

+         GLint row;

+         ASSERT(drawWidth <= MAX_WIDTH);

+         for (row = 0; row < drawHeight; row++) {

+            GLchan rgb[MAX_WIDTH][3];

+            GLint i;

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

+               rgb[i][0] = src[i];

+               rgb[i][1] = src[i];

+               rgb[i][2] = src[i];

+            }

+            rb->PutRowRGB(ctx, rb, drawWidth, destX, destY, rgb, NULL);

+            src += unpack.RowLength;

+            destY += yStep;

+         }

+      }

+      else {

+         /* with zooming */

+         GLint row;

+         ASSERT(drawWidth <= MAX_WIDTH);

+         for (row = 0; row < drawHeight; row++) {

+            GLchan rgb[MAX_WIDTH][3];

+            GLint i;

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

+               rgb[i][0] = src[i];

+               rgb[i][1] = src[i];

+               rgb[i][2] = src[i];

+            }

+            span.x = destX;

+            span.y = destY;

+            span.end = drawWidth;

+            _swrast_write_zoomed_rgb_span(ctx, imgX, imgY, &span, rgb);

+            src += unpack.RowLength;

+            destY++;

+         }

+      }

+      return GL_TRUE;

+   }

+

+   if (format == GL_LUMINANCE_ALPHA && type == CHAN_TYPE && rbType == CHAN_TYPE) {

+      const GLchan *src = (const GLchan *) pixels

+         + (unpack.SkipRows * unpack.RowLength + unpack.SkipPixels)*2;

+      if (simpleZoom) {

+         GLint row;

+         ASSERT(drawWidth <= MAX_WIDTH);

+         for (row = 0; row < drawHeight; row++) {

+            GLint i;

+            const GLchan *ptr = src;

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

+               span.array->rgba[i][0] = *ptr;

+               span.array->rgba[i][1] = *ptr;

+               span.array->rgba[i][2] = *ptr++;

+               span.array->rgba[i][3] = *ptr++;

+            }

+            rb->PutRow(ctx, rb, drawWidth, destX, destY,

+                       span.array->rgba, NULL);

+            src += unpack.RowLength*2;

+            destY += yStep;

+         }

+      }

+      else {

+         /* with zooming */

+         GLint row;

+         ASSERT(drawWidth <= MAX_WIDTH);

+         for (row = 0; row < drawHeight; row++) {

+            const GLchan *ptr = src;

+            GLint i;

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

+               span.array->rgba[i][0] = *ptr;

+               span.array->rgba[i][1] = *ptr;

+               span.array->rgba[i][2] = *ptr++;

+               span.array->rgba[i][3] = *ptr++;

+            }

+            span.x = destX;

+            span.y = destY;

+            span.end = drawWidth;

+            _swrast_write_zoomed_rgba_span(ctx, imgX, imgY, &span,

+                                           span.array->rgba);

+            src += unpack.RowLength*2;

+            destY++;

+         }

+      }

+      return GL_TRUE;

+   }

+

+   if (format == GL_COLOR_INDEX && type == GL_UNSIGNED_BYTE) {

+      const GLubyte *src = (const GLubyte *) pixels

+         + unpack.SkipRows * unpack.RowLength + unpack.SkipPixels;

+      if (rbType == GL_UNSIGNED_BYTE) {

+         /* convert ubyte/CI data to ubyte/RGBA */

+         if (simpleZoom) {

+            GLint row;

+            for (row = 0; row < drawHeight; row++) {

+               ASSERT(drawWidth <= MAX_WIDTH);

+               _mesa_map_ci8_to_rgba8(ctx, drawWidth, src,

+                                      span.array->rgba8);

+               rb->PutRow(ctx, rb, drawWidth, destX, destY,

+                          span.array->rgba8, NULL);

+               src += unpack.RowLength;

+               destY += yStep;

+            }

+         }

+         else {

+            /* ubyte/CI to ubyte/RGBA with zooming */

+            GLint row;

+            for (row = 0; row < drawHeight; row++) {

+               ASSERT(drawWidth <= MAX_WIDTH);

+               _mesa_map_ci8_to_rgba8(ctx, drawWidth, src,

+                                      span.array->rgba8);

+               span.x = destX;

+               span.y = destY;

+               span.end = drawWidth;

+               _swrast_write_zoomed_rgba_span(ctx, imgX, imgY, &span,

+                                              span.array->rgba8);

+               src += unpack.RowLength;

+               destY++;

+            }

+         }

+         return GL_TRUE;

+      }

+   }

+

+   /* can't handle this pixel format and/or data type */

+   return GL_FALSE;

+}

+

+

+

+/*

+ * Draw stencil image.

+ */

+static void

+draw_stencil_pixels( struct gl_context *ctx, GLint x, GLint y,

+                     GLsizei width, GLsizei height,

+                     GLenum type,

+                     const struct gl_pixelstore_attrib *unpack,

+                     const GLvoid *pixels )

+{

+   const GLboolean zoom = ctx->Pixel.ZoomX != 1.0 || ctx->Pixel.ZoomY != 1.0;

+   GLint skipPixels;

+

+   /* if width > MAX_WIDTH, have to process image in chunks */

+   skipPixels = 0;

+   while (skipPixels < width) {

+      const GLint spanX = x + skipPixels;

+      const GLint spanWidth = MIN2(width - skipPixels, MAX_WIDTH);

+      GLint row;

+      for (row = 0; row < height; row++) {

+         const GLint spanY = y + row;

+         GLstencil values[MAX_WIDTH];

+         GLenum destType = (sizeof(GLstencil) == sizeof(GLubyte))

+                         ? GL_UNSIGNED_BYTE : GL_UNSIGNED_SHORT;

+         const GLvoid *source = _mesa_image_address2d(unpack, pixels,

+                                                      width, height,

+                                                      GL_COLOR_INDEX, type,

+                                                      row, skipPixels);

+         _mesa_unpack_stencil_span(ctx, spanWidth, destType, values,

+                                   type, source, unpack,

+                                   ctx->_ImageTransferState);

+         if (zoom) {

+            _swrast_write_zoomed_stencil_span(ctx, x, y, spanWidth,

+                                              spanX, spanY, values);

+         }

+         else {

+            _swrast_write_stencil_span(ctx, spanWidth, spanX, spanY, values);

+         }

+      }

+      skipPixels += spanWidth;

+   }

+}

+

+

+/*

+ * Draw depth image.

+ */

+static void

+draw_depth_pixels( struct gl_context *ctx, GLint x, GLint y,

+                   GLsizei width, GLsizei height,

+                   GLenum type,

+                   const struct gl_pixelstore_attrib *unpack,

+                   const GLvoid *pixels )

+{

+   const GLboolean scaleOrBias

+      = ctx->Pixel.DepthScale != 1.0 || ctx->Pixel.DepthBias != 0.0;

+   const GLboolean zoom = ctx->Pixel.ZoomX != 1.0 || ctx->Pixel.ZoomY != 1.0;

+   SWspan span;

+

+   INIT_SPAN(span, GL_BITMAP);

+   span.arrayMask = SPAN_Z;

+   _swrast_span_default_attribs(ctx, &span);

+

+   if (type == GL_UNSIGNED_SHORT

+       && ctx->DrawBuffer->Visual.depthBits == 16

+       && !scaleOrBias

+       && !zoom

+       && width <= MAX_WIDTH

+       && !unpack->SwapBytes) {

+      /* Special case: directly write 16-bit depth values */

+      GLint row;

+      for (row = 0; row < height; row++) {

+         const GLushort *zSrc = (const GLushort *)

+            _mesa_image_address2d(unpack, pixels, width, height,

+                                  GL_DEPTH_COMPONENT, type, row, 0);

+         GLint i;

+         for (i = 0; i < width; i++)

+            span.array->z[i] = zSrc[i];

+         span.x = x;

+         span.y = y + row;

+         span.end = width;

+         _swrast_write_rgba_span(ctx, &span);

+      }

+   }

+   else if (type == GL_UNSIGNED_INT

+            && !scaleOrBias

+            && !zoom

+            && width <= MAX_WIDTH

+            && !unpack->SwapBytes) {

+      /* Special case: shift 32-bit values down to Visual.depthBits */

+      const GLint shift = 32 - ctx->DrawBuffer->Visual.depthBits;

+      GLint row;

+      for (row = 0; row < height; row++) {

+         const GLuint *zSrc = (const GLuint *)

+            _mesa_image_address2d(unpack, pixels, width, height,

+                                  GL_DEPTH_COMPONENT, type, row, 0);

+         if (shift == 0) {

+            memcpy(span.array->z, zSrc, width * sizeof(GLuint));

+         }

+         else {

+            GLint col;

+            for (col = 0; col < width; col++)

+               span.array->z[col] = zSrc[col] >> shift;

+         }

+         span.x = x;

+         span.y = y + row;

+         span.end = width;

+         _swrast_write_rgba_span(ctx, &span);

+      }

+   }

+   else {

+      /* General case */

+      const GLuint depthMax = ctx->DrawBuffer->_DepthMax;

+      GLint skipPixels = 0;

+

+      /* in case width > MAX_WIDTH do the copy in chunks */

+      while (skipPixels < width) {

+         const GLint spanWidth = MIN2(width - skipPixels, MAX_WIDTH);

+         GLint row;

+         ASSERT(span.end <= MAX_WIDTH);

+         for (row = 0; row < height; row++) {

+            const GLvoid *zSrc = _mesa_image_address2d(unpack,

+                                                      pixels, width, height,

+                                                      GL_DEPTH_COMPONENT, type,

+                                                      row, skipPixels);

+

+            /* Set these for each row since the _swrast_write_* function may

+             * change them while clipping.

+             */

+            span.x = x + skipPixels;

+            span.y = y + row;

+            span.end = spanWidth;

+

+            _mesa_unpack_depth_span(ctx, spanWidth,

+                                    GL_UNSIGNED_INT, span.array->z, depthMax,

+                                    type, zSrc, unpack);

+            if (zoom) {

+               _swrast_write_zoomed_depth_span(ctx, x, y, &span);

+            }

+            else {

+               _swrast_write_rgba_span(ctx, &span);

+            }

+         }

+         skipPixels += spanWidth;

+      }

+   }

+}

+

+

+

+/**

+ * Draw RGBA image.

+ */

+static void

+draw_rgba_pixels( struct gl_context *ctx, GLint x, GLint y,

+                  GLsizei width, GLsizei height,

+                  GLenum format, GLenum type,

+                  const struct gl_pixelstore_attrib *unpack,

+                  const GLvoid *pixels )

+{

+   const GLint imgX = x, imgY = y;

+   const GLboolean zoom = ctx->Pixel.ZoomX!=1.0 || ctx->Pixel.ZoomY!=1.0;

+   GLfloat *convImage = NULL;

+   GLbitfield transferOps = ctx->_ImageTransferState;

+   SWspan span;

+

+   /* Try an optimized glDrawPixels first */

+   if (fast_draw_rgba_pixels(ctx, x, y, width, height, format, type,

+                             unpack, pixels)) {

+      return;

+   }

+

+   INIT_SPAN(span, GL_BITMAP);

+   _swrast_span_default_attribs(ctx, &span);

+   span.arrayMask = SPAN_RGBA;

+   span.arrayAttribs = FRAG_BIT_COL0; /* we're fill in COL0 attrib values */

+

+   if (ctx->DrawBuffer->_NumColorDrawBuffers > 0 &&

+       ctx->DrawBuffer->_ColorDrawBuffers[0]->DataType != GL_FLOAT &&

+       ctx->Color.ClampFragmentColor != GL_FALSE) {

+      /* need to clamp colors before applying fragment ops */

+      transferOps |= IMAGE_CLAMP_BIT;

+   }

+

+   /*

+    * General solution

+    */

+   {

+      const GLbitfield interpMask = span.interpMask;

+      const GLbitfield arrayMask = span.arrayMask;

+      const GLint srcStride

+         = _mesa_image_row_stride(unpack, width, format, type);

+      GLint skipPixels = 0;

+      /* use span array for temp color storage */

+      GLfloat *rgba = (GLfloat *) span.array->attribs[FRAG_ATTRIB_COL0];

+

+      /* if the span is wider than MAX_WIDTH we have to do it in chunks */

+      while (skipPixels < width) {

+         const GLint spanWidth = MIN2(width - skipPixels, MAX_WIDTH);

+         const GLubyte *source

+            = (const GLubyte *) _mesa_image_address2d(unpack, pixels,

+                                                      width, height, format,

+                                                      type, 0, skipPixels);

+         GLint row;

+

+         for (row = 0; row < height; row++) {

+            /* get image row as float/RGBA */

+            _mesa_unpack_color_span_float(ctx, spanWidth, GL_RGBA, rgba,

+                                     format, type, source, unpack,

+                                     transferOps);

+	    /* Set these for each row since the _swrast_write_* functions

+	     * may change them while clipping/rendering.

+	     */

+	    span.array->ChanType = GL_FLOAT;

+	    span.x = x + skipPixels;

+	    span.y = y + row;

+	    span.end = spanWidth;

+	    span.arrayMask = arrayMask;

+	    span.interpMask = interpMask;

+	    if (zoom) {

+	       _swrast_write_zoomed_rgba_span(ctx, imgX, imgY, &span, rgba);

+	    }

+	    else {

+	       _swrast_write_rgba_span(ctx, &span);

+	    }

+

+            source += srcStride;

+         } /* for row */

+

+         skipPixels += spanWidth;

+      } /* while skipPixels < width */

+

+      /* XXX this is ugly/temporary, to undo above change */

+      span.array->ChanType = CHAN_TYPE;

+   }

+

+   if (convImage) {

+      free(convImage);

+   }

+}

+

+

+/**

+ * This is a bit different from drawing GL_DEPTH_COMPONENT pixels.

+ * The only per-pixel operations that apply are depth scale/bias,

+ * stencil offset/shift, GL_DEPTH_WRITEMASK and GL_STENCIL_WRITEMASK,

+ * and pixel zoom.

+ * Also, only the depth buffer and stencil buffers are touched, not the

+ * color buffer(s).

+ */

+static void

+draw_depth_stencil_pixels(struct gl_context *ctx, GLint x, GLint y,

+                          GLsizei width, GLsizei height, GLenum type,

+                          const struct gl_pixelstore_attrib *unpack,

+                          const GLvoid *pixels)

+{

+   const GLint imgX = x, imgY = y;

+   const GLboolean scaleOrBias

+      = ctx->Pixel.DepthScale != 1.0 || ctx->Pixel.DepthBias != 0.0;

+   const GLuint depthMax = ctx->DrawBuffer->_DepthMax;

+   const GLuint stencilMask = ctx->Stencil.WriteMask[0];

+   const GLuint stencilType = (STENCIL_BITS == 8) ? 

+      GL_UNSIGNED_BYTE : GL_UNSIGNED_SHORT;

+   const GLboolean zoom = ctx->Pixel.ZoomX != 1.0 || ctx->Pixel.ZoomY != 1.0;

+   struct gl_renderbuffer *depthRb, *stencilRb;

+   struct gl_pixelstore_attrib clippedUnpack = *unpack;

+

+   if (!zoom) {

+      if (!_mesa_clip_drawpixels(ctx, &x, &y, &width, &height,

+                                 &clippedUnpack)) {

+         /* totally clipped */

+         return;

+      }

+   }

+   

+   depthRb = ctx->ReadBuffer->Attachment[BUFFER_DEPTH].Renderbuffer;

+   stencilRb = ctx->ReadBuffer->Attachment[BUFFER_STENCIL].Renderbuffer;

+   ASSERT(depthRb);

+   ASSERT(stencilRb);

+

+   if (depthRb->_BaseFormat == GL_DEPTH_STENCIL_EXT &&

+       stencilRb->_BaseFormat == GL_DEPTH_STENCIL_EXT &&

+       depthRb == stencilRb &&

+       !scaleOrBias &&

+       !zoom &&

+       ctx->Depth.Mask &&

+       (stencilMask & 0xff) == 0xff) {

+      /* This is the ideal case.

+       * Drawing GL_DEPTH_STENCIL pixels into a combined depth/stencil buffer.

+       * Plus, no pixel transfer ops, zooming, or masking needed.

+       */

+      GLint i;

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

+         const GLuint *src = (const GLuint *) 

+            _mesa_image_address2d(&clippedUnpack, pixels, width, height,

+                                  GL_DEPTH_STENCIL_EXT, type, i, 0);

+         depthRb->PutRow(ctx, depthRb, width, x, y + i, src, NULL);

+      }

+   }

+   else {

+      /* sub-optimal cases:

+       * Separate depth/stencil buffers, or pixel transfer ops required.

+       */

+      /* XXX need to handle very wide images (skippixels) */

+      GLint i;

+

+      depthRb = ctx->DrawBuffer->_DepthBuffer;

+      stencilRb = ctx->DrawBuffer->_StencilBuffer;

+

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

+         const GLuint *depthStencilSrc = (const GLuint *)

+            _mesa_image_address2d(&clippedUnpack, pixels, width, height,

+                                  GL_DEPTH_STENCIL_EXT, type, i, 0);

+

+         if (ctx->Depth.Mask) {

+            if (!scaleOrBias && ctx->DrawBuffer->Visual.depthBits == 24) {

+               /* fast path 24-bit zbuffer */

+               GLuint zValues[MAX_WIDTH];

+               GLint j;

+               ASSERT(depthRb->DataType == GL_UNSIGNED_INT);

+               for (j = 0; j < width; j++) {

+                  zValues[j] = depthStencilSrc[j] >> 8;

+               }

+               if (zoom)

+                  _swrast_write_zoomed_z_span(ctx, imgX, imgY, width,

+                                              x, y + i, zValues);

+               else

+                  depthRb->PutRow(ctx, depthRb, width, x, y + i, zValues,NULL);

+            }

+            else if (!scaleOrBias && ctx->DrawBuffer->Visual.depthBits == 16) {

+               /* fast path 16-bit zbuffer */

+               GLushort zValues[MAX_WIDTH];

+               GLint j;

+               ASSERT(depthRb->DataType == GL_UNSIGNED_SHORT);

+               for (j = 0; j < width; j++) {

+                  zValues[j] = depthStencilSrc[j] >> 16;

+               }

+               if (zoom)

+                  _swrast_write_zoomed_z_span(ctx, imgX, imgY, width,

+                                              x, y + i, zValues);

+               else

+                  depthRb->PutRow(ctx, depthRb, width, x, y + i, zValues,NULL);

+            }

+            else {

+               /* general case */

+               GLuint zValues[MAX_WIDTH];  /* 16 or 32-bit Z value storage */

+               _mesa_unpack_depth_span(ctx, width,

+                                       depthRb->DataType, zValues, depthMax,

+                                       type, depthStencilSrc, &clippedUnpack);

+               if (zoom) {

+                  _swrast_write_zoomed_z_span(ctx, imgX, imgY, width, x,

+                                              y + i, zValues);

+               }

+               else {

+                  depthRb->PutRow(ctx, depthRb, width, x, y + i, zValues,NULL);

+               }

+            }

+         }

+

+         if (stencilMask != 0x0) {

+            GLstencil stencilValues[MAX_WIDTH];

+            /* get stencil values, with shift/offset/mapping */

+            _mesa_unpack_stencil_span(ctx, width, stencilType, stencilValues,

+                                      type, depthStencilSrc, &clippedUnpack,

+                                      ctx->_ImageTransferState);

+            if (zoom)

+               _swrast_write_zoomed_stencil_span(ctx, imgX, imgY, width,

+                                                  x, y + i, stencilValues);

+            else

+               _swrast_write_stencil_span(ctx, width, x, y + i, stencilValues);

+         }

+      }

+   }

+}

+

+

+/**

+ * Execute software-based glDrawPixels.

+ * By time we get here, all error checking will have been done.

+ */

+void

+_swrast_DrawPixels( struct gl_context *ctx,

+		    GLint x, GLint y,

+		    GLsizei width, GLsizei height,

+		    GLenum format, GLenum type,

+		    const struct gl_pixelstore_attrib *unpack,

+		    const GLvoid *pixels )

+{

+   SWcontext *swrast = SWRAST_CONTEXT(ctx);

+   GLboolean save_vp_override = ctx->VertexProgram._Overriden;

+

+   if (!_mesa_check_conditional_render(ctx))

+      return; /* don't draw */

+

+   /* We are creating fragments directly, without going through vertex

+    * programs.

+    *

+    * This override flag tells the fragment processing code that its input

+    * comes from a non-standard source, and it may therefore not rely on

+    * optimizations that assume e.g. constant color if there is no color

+    * vertex array.

+    */

+   _mesa_set_vp_override(ctx, GL_TRUE);

+

+   swrast_render_start(ctx);

+

+   if (ctx->NewState)

+      _mesa_update_state(ctx);

+

+   if (swrast->NewState)

+      _swrast_validate_derived( ctx );

+

+   pixels = _mesa_map_pbo_source(ctx, unpack, pixels);

+   if (!pixels) {

+      swrast_render_finish(ctx);

+      _mesa_set_vp_override(ctx, save_vp_override);

+      return;

+   }

+

+   /*

+    * By time we get here, all error checking should have been done.

+    */

+   switch (format) {

+   case GL_STENCIL_INDEX:

+      draw_stencil_pixels( ctx, x, y, width, height, type, unpack, pixels );

+      break;

+   case GL_DEPTH_COMPONENT:

+      draw_depth_pixels( ctx, x, y, width, height, type, unpack, pixels );

+      break;

+   case GL_DEPTH_STENCIL_EXT:

+      draw_depth_stencil_pixels(ctx, x, y, width, height, type, unpack, pixels);

+      break;

+   default:

+      /* all other formats should be color formats */

+      draw_rgba_pixels(ctx, x, y, width, height, format, type, unpack, pixels);

+   }

+

+   swrast_render_finish(ctx);

+   _mesa_set_vp_override(ctx, save_vp_override);

+

+   _mesa_unmap_pbo_source(ctx, unpack);

+}

diff --git a/mesalib/src/mesa/swrast/s_feedback.c b/mesalib/src/mesa/swrast/s_feedback.c
index 6ac8ac73b..e548bf9c3 100644
--- a/mesalib/src/mesa/swrast/s_feedback.c
+++ b/mesalib/src/mesa/swrast/s_feedback.c
@@ -1,138 +1,138 @@
-/*
- * Mesa 3-D graphics library
- * Version:  7.0
- *
- * 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/feedback.h"
-#include "main/macros.h"
-
-#include "s_context.h"
-#include "s_feedback.h"
-#include "s_triangle.h"
-
-
-
-static void
-feedback_vertex(GLcontext * ctx, const SWvertex * v, const SWvertex * pv)
-{
-   GLfloat win[4];
-   const GLfloat *vtc = v->attrib[FRAG_ATTRIB_TEX0];
-   const GLfloat *color = v->attrib[FRAG_ATTRIB_COL0];
-
-   win[0] = v->attrib[FRAG_ATTRIB_WPOS][0];
-   win[1] = v->attrib[FRAG_ATTRIB_WPOS][1];
-   win[2] = v->attrib[FRAG_ATTRIB_WPOS][2] / ctx->DrawBuffer->_DepthMaxF;
-   win[3] = 1.0F / v->attrib[FRAG_ATTRIB_WPOS][3];
-
-   _mesa_feedback_vertex(ctx, win, color, vtc);
-}
-
-
-/*
- * Put triangle in feedback buffer.
- */
-void
-_swrast_feedback_triangle(GLcontext *ctx, const SWvertex *v0,
-                          const SWvertex *v1, const SWvertex *v2)
-{
-   if (!_swrast_culltriangle(ctx, v0, v1, v2)) {
-      _mesa_feedback_token(ctx, (GLfloat) (GLint) GL_POLYGON_TOKEN);
-      _mesa_feedback_token(ctx, (GLfloat) 3); /* three vertices */
-
-      if (ctx->Light.ShadeModel == GL_SMOOTH) {
-         feedback_vertex(ctx, v0, v0);
-         feedback_vertex(ctx, v1, v1);
-         feedback_vertex(ctx, v2, v2);
-      }
-      else {
-         feedback_vertex(ctx, v0, v2);
-         feedback_vertex(ctx, v1, v2);
-         feedback_vertex(ctx, v2, v2);
-      }
-   }
-}
-
-
-void
-_swrast_feedback_line(GLcontext *ctx, const SWvertex *v0,
-                      const SWvertex *v1)
-{
-   GLenum token = GL_LINE_TOKEN;
-   SWcontext *swrast = SWRAST_CONTEXT(ctx);
-
-   if (swrast->StippleCounter == 0)
-      token = GL_LINE_RESET_TOKEN;
-
-   _mesa_feedback_token(ctx, (GLfloat) (GLint) token);
-
-   if (ctx->Light.ShadeModel == GL_SMOOTH) {
-      feedback_vertex(ctx, v0, v0);
-      feedback_vertex(ctx, v1, v1);
-   }
-   else {
-      feedback_vertex(ctx, v0, v1);
-      feedback_vertex(ctx, v1, v1);
-   }
-
-   swrast->StippleCounter++;
-}
-
-
-void
-_swrast_feedback_point(GLcontext *ctx, const SWvertex *v)
-{
-   _mesa_feedback_token(ctx, (GLfloat) (GLint) GL_POINT_TOKEN);
-   feedback_vertex(ctx, v, v);
-}
-
-
-void
-_swrast_select_triangle(GLcontext *ctx, const SWvertex *v0,
-                        const SWvertex *v1, const SWvertex *v2)
-{
-   if (!_swrast_culltriangle(ctx, v0, v1, v2)) {
-      const GLfloat zs = 1.0F / ctx->DrawBuffer->_DepthMaxF;
-
-      _mesa_update_hitflag( ctx, v0->attrib[FRAG_ATTRIB_WPOS][2] * zs );
-      _mesa_update_hitflag( ctx, v1->attrib[FRAG_ATTRIB_WPOS][2] * zs );
-      _mesa_update_hitflag( ctx, v2->attrib[FRAG_ATTRIB_WPOS][2] * zs );
-   }
-}
-
-
-void
-_swrast_select_line(GLcontext *ctx, const SWvertex *v0, const SWvertex *v1)
-{
-   const GLfloat zs = 1.0F / ctx->DrawBuffer->_DepthMaxF;
-   _mesa_update_hitflag( ctx, v0->attrib[FRAG_ATTRIB_WPOS][2] * zs );
-   _mesa_update_hitflag( ctx, v1->attrib[FRAG_ATTRIB_WPOS][2] * zs );
-}
-
-
-void
-_swrast_select_point(GLcontext *ctx, const SWvertex *v)
-{
-   const GLfloat zs = 1.0F / ctx->DrawBuffer->_DepthMaxF;
-   _mesa_update_hitflag( ctx, v->attrib[FRAG_ATTRIB_WPOS][2] * zs );
-}
+/*

+ * Mesa 3-D graphics library

+ * Version:  7.0

+ *

+ * 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/feedback.h"

+#include "main/macros.h"

+

+#include "s_context.h"

+#include "s_feedback.h"

+#include "s_triangle.h"

+

+

+

+static void

+feedback_vertex(struct gl_context * ctx, const SWvertex * v, const SWvertex * pv)

+{

+   GLfloat win[4];

+   const GLfloat *vtc = v->attrib[FRAG_ATTRIB_TEX0];

+   const GLfloat *color = v->attrib[FRAG_ATTRIB_COL0];

+

+   win[0] = v->attrib[FRAG_ATTRIB_WPOS][0];

+   win[1] = v->attrib[FRAG_ATTRIB_WPOS][1];

+   win[2] = v->attrib[FRAG_ATTRIB_WPOS][2] / ctx->DrawBuffer->_DepthMaxF;

+   win[3] = 1.0F / v->attrib[FRAG_ATTRIB_WPOS][3];

+

+   _mesa_feedback_vertex(ctx, win, color, vtc);

+}

+

+

+/*

+ * Put triangle in feedback buffer.

+ */

+void

+_swrast_feedback_triangle(struct gl_context *ctx, const SWvertex *v0,

+                          const SWvertex *v1, const SWvertex *v2)

+{

+   if (!_swrast_culltriangle(ctx, v0, v1, v2)) {

+      _mesa_feedback_token(ctx, (GLfloat) (GLint) GL_POLYGON_TOKEN);

+      _mesa_feedback_token(ctx, (GLfloat) 3); /* three vertices */

+

+      if (ctx->Light.ShadeModel == GL_SMOOTH) {

+         feedback_vertex(ctx, v0, v0);

+         feedback_vertex(ctx, v1, v1);

+         feedback_vertex(ctx, v2, v2);

+      }

+      else {

+         feedback_vertex(ctx, v0, v2);

+         feedback_vertex(ctx, v1, v2);

+         feedback_vertex(ctx, v2, v2);

+      }

+   }

+}

+

+

+void

+_swrast_feedback_line(struct gl_context *ctx, const SWvertex *v0,

+                      const SWvertex *v1)

+{

+   GLenum token = GL_LINE_TOKEN;

+   SWcontext *swrast = SWRAST_CONTEXT(ctx);

+

+   if (swrast->StippleCounter == 0)

+      token = GL_LINE_RESET_TOKEN;

+

+   _mesa_feedback_token(ctx, (GLfloat) (GLint) token);

+

+   if (ctx->Light.ShadeModel == GL_SMOOTH) {

+      feedback_vertex(ctx, v0, v0);

+      feedback_vertex(ctx, v1, v1);

+   }

+   else {

+      feedback_vertex(ctx, v0, v1);

+      feedback_vertex(ctx, v1, v1);

+   }

+

+   swrast->StippleCounter++;

+}

+

+

+void

+_swrast_feedback_point(struct gl_context *ctx, const SWvertex *v)

+{

+   _mesa_feedback_token(ctx, (GLfloat) (GLint) GL_POINT_TOKEN);

+   feedback_vertex(ctx, v, v);

+}

+

+

+void

+_swrast_select_triangle(struct gl_context *ctx, const SWvertex *v0,

+                        const SWvertex *v1, const SWvertex *v2)

+{

+   if (!_swrast_culltriangle(ctx, v0, v1, v2)) {

+      const GLfloat zs = 1.0F / ctx->DrawBuffer->_DepthMaxF;

+

+      _mesa_update_hitflag( ctx, v0->attrib[FRAG_ATTRIB_WPOS][2] * zs );

+      _mesa_update_hitflag( ctx, v1->attrib[FRAG_ATTRIB_WPOS][2] * zs );

+      _mesa_update_hitflag( ctx, v2->attrib[FRAG_ATTRIB_WPOS][2] * zs );

+   }

+}

+

+

+void

+_swrast_select_line(struct gl_context *ctx, const SWvertex *v0, const SWvertex *v1)

+{

+   const GLfloat zs = 1.0F / ctx->DrawBuffer->_DepthMaxF;

+   _mesa_update_hitflag( ctx, v0->attrib[FRAG_ATTRIB_WPOS][2] * zs );

+   _mesa_update_hitflag( ctx, v1->attrib[FRAG_ATTRIB_WPOS][2] * zs );

+}

+

+

+void

+_swrast_select_point(struct gl_context *ctx, const SWvertex *v)

+{

+   const GLfloat zs = 1.0F / ctx->DrawBuffer->_DepthMaxF;

+   _mesa_update_hitflag( ctx, v->attrib[FRAG_ATTRIB_WPOS][2] * zs );

+}

diff --git a/mesalib/src/mesa/swrast/s_feedback.h b/mesalib/src/mesa/swrast/s_feedback.h
index 9feab75db..f0ca2c0e6 100644
--- a/mesalib/src/mesa/swrast/s_feedback.h
+++ b/mesalib/src/mesa/swrast/s_feedback.h
@@ -1,50 +1,50 @@
-
-/*
- * Mesa 3-D graphics library
- * Version:  3.5
- *
- * Copyright (C) 1999-2001  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.
- */
-
-
-#ifndef S_FEEDBACK_H
-#define S_FEEDBACK_H
-
-
-#include "swrast.h"
-
-
-extern void _swrast_feedback_point( GLcontext *ctx, const SWvertex *v );
-
-extern void _swrast_feedback_line( GLcontext *ctx,
-                              const SWvertex *v1, const SWvertex *v2 );
-
-extern void _swrast_feedback_triangle( GLcontext *ctx, const SWvertex *v0,
-                                  const SWvertex *v1, const SWvertex *v2 );
-
-extern void _swrast_select_point( GLcontext *ctx, const SWvertex *v );
-
-extern void _swrast_select_line( GLcontext *ctx,
-                            const SWvertex *v1, const SWvertex *v2 );
-
-extern void _swrast_select_triangle( GLcontext *ctx, const SWvertex *v0,
-                                const SWvertex *v1, const SWvertex *v2 );
-
-#endif
+

+/*

+ * Mesa 3-D graphics library

+ * Version:  3.5

+ *

+ * Copyright (C) 1999-2001  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.

+ */

+

+

+#ifndef S_FEEDBACK_H

+#define S_FEEDBACK_H

+

+

+#include "swrast.h"

+

+

+extern void _swrast_feedback_point( struct gl_context *ctx, const SWvertex *v );

+

+extern void _swrast_feedback_line( struct gl_context *ctx,

+                              const SWvertex *v1, const SWvertex *v2 );

+

+extern void _swrast_feedback_triangle( struct gl_context *ctx, const SWvertex *v0,

+                                  const SWvertex *v1, const SWvertex *v2 );

+

+extern void _swrast_select_point( struct gl_context *ctx, const SWvertex *v );

+

+extern void _swrast_select_line( struct gl_context *ctx,

+                            const SWvertex *v1, const SWvertex *v2 );

+

+extern void _swrast_select_triangle( struct gl_context *ctx, const SWvertex *v0,

+                                const SWvertex *v1, const SWvertex *v2 );

+

+#endif

diff --git a/mesalib/src/mesa/swrast/s_fog.c b/mesalib/src/mesa/swrast/s_fog.c
index 689500a61..5acb5f4d1 100644
--- a/mesalib/src/mesa/swrast/s_fog.c
+++ b/mesalib/src/mesa/swrast/s_fog.c
@@ -1,244 +1,244 @@
-/*
- * Mesa 3-D graphics library
- * Version:  6.5.2
- *
- * Copyright (C) 1999-2006  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_fog.h"
-
-
-/**
- * Used to convert current raster distance to a fog factor in [0,1].
- */
-GLfloat
-_swrast_z_to_fogfactor(GLcontext *ctx, GLfloat z)
-{
-   GLfloat d, f;
-
-   switch (ctx->Fog.Mode) {
-   case GL_LINEAR:
-      if (ctx->Fog.Start == ctx->Fog.End)
-         d = 1.0F;
-      else
-         d = 1.0F / (ctx->Fog.End - ctx->Fog.Start);
-      f = (ctx->Fog.End - z) * d;
-      return CLAMP(f, 0.0F, 1.0F);
-   case GL_EXP:
-      d = ctx->Fog.Density;
-      f = EXPF(-d * z);
-      f = CLAMP(f, 0.0F, 1.0F);
-      return f;
-   case GL_EXP2:
-      d = ctx->Fog.Density;
-      f = EXPF(-(d * d * z * z));
-      f = CLAMP(f, 0.0F, 1.0F);
-      return f;
-   default:
-      _mesa_problem(ctx, "Bad fog mode in _swrast_z_to_fogfactor");
-      return 0.0; 
-   }
-}
-
-
-#define LINEAR_FOG(f, coord)  f = (fogEnd - coord) * fogScale
-
-#define EXP_FOG(f, coord)  f = EXPF(density * coord)
-
-#define EXP2_FOG(f, coord)				\
-do {							\
-   GLfloat tmp = negDensitySquared * coord * coord;	\
-   if (tmp < FLT_MIN_10_EXP)				\
-      tmp = FLT_MIN_10_EXP;				\
-   f = EXPF(tmp);					\
- } while(0)
-
-
-#define BLEND_FOG(f, coord)  f = coord
-
-
-
-/**
- * Template code for computing fog blend factor and applying it to colors.
- * \param TYPE  either GLubyte, GLushort or GLfloat.
- * \param COMPUTE_F  code to compute the fog blend factor, f.
- */
-#define FOG_LOOP(TYPE, FOG_FUNC)						\
-if (span->arrayAttribs & FRAG_BIT_FOGC) {					\
-   GLuint i;									\
-   for (i = 0; i < span->end; i++) {						\
-      const GLfloat fogCoord = span->array->attribs[FRAG_ATTRIB_FOGC][i][0];	\
-      const GLfloat c = FABSF(fogCoord);					\
-      GLfloat f, oneMinusF;							\
-      FOG_FUNC(f, c);								\
-      f = CLAMP(f, 0.0F, 1.0F);							\
-      oneMinusF = 1.0F - f;							\
-      rgba[i][RCOMP] = (TYPE) (f * rgba[i][RCOMP] + oneMinusF * rFog);		\
-      rgba[i][GCOMP] = (TYPE) (f * rgba[i][GCOMP] + oneMinusF * gFog);		\
-      rgba[i][BCOMP] = (TYPE) (f * rgba[i][BCOMP] + oneMinusF * bFog);		\
-   }										\
-}										\
-else {										\
-   const GLfloat fogStep = span->attrStepX[FRAG_ATTRIB_FOGC][0];		\
-   GLfloat fogCoord = span->attrStart[FRAG_ATTRIB_FOGC][0];			\
-   const GLfloat wStep = span->attrStepX[FRAG_ATTRIB_WPOS][3];			\
-   GLfloat w = span->attrStart[FRAG_ATTRIB_WPOS][3];				\
-   GLuint i;									\
-   for (i = 0; i < span->end; i++) {						\
-      const GLfloat c = FABSF(fogCoord) / w;					\
-      GLfloat f, oneMinusF;							\
-      FOG_FUNC(f, c);								\
-      f = CLAMP(f, 0.0F, 1.0F);							\
-      oneMinusF = 1.0F - f;							\
-      rgba[i][RCOMP] = (TYPE) (f * rgba[i][RCOMP] + oneMinusF * rFog);		\
-      rgba[i][GCOMP] = (TYPE) (f * rgba[i][GCOMP] + oneMinusF * gFog);		\
-      rgba[i][BCOMP] = (TYPE) (f * rgba[i][BCOMP] + oneMinusF * bFog);		\
-      fogCoord += fogStep;							\
-      w += wStep;								\
-   }										\
-}
-
-/**
- * Apply fog to a span of RGBA pixels.
- * The fog value are either in the span->array->fog array or interpolated from
- * the fog/fogStep values.
- * They fog values are either fog coordinates (Z) or fog blend factors.
- * _PreferPixelFog should be in sync with that state!
- */
-void
-_swrast_fog_rgba_span( const GLcontext *ctx, SWspan *span )
-{
-   const SWcontext *swrast = CONST_SWRAST_CONTEXT(ctx);
-   GLfloat rFog, gFog, bFog;
-
-   ASSERT(swrast->_FogEnabled);
-   ASSERT(span->arrayMask & SPAN_RGBA);
-
-   /* compute (scaled) fog color */
-   if (span->array->ChanType == GL_UNSIGNED_BYTE) {
-      rFog = ctx->Fog.Color[RCOMP] * 255.0F;
-      gFog = ctx->Fog.Color[GCOMP] * 255.0F;
-      bFog = ctx->Fog.Color[BCOMP] * 255.0F;
-   }
-   else if (span->array->ChanType == GL_UNSIGNED_SHORT) {
-      rFog = ctx->Fog.Color[RCOMP] * 65535.0F;
-      gFog = ctx->Fog.Color[GCOMP] * 65535.0F;
-      bFog = ctx->Fog.Color[BCOMP] * 65535.0F;
-   }
-   else {
-      rFog = ctx->Fog.Color[RCOMP];
-      gFog = ctx->Fog.Color[GCOMP];
-      bFog = ctx->Fog.Color[BCOMP];
-   }
-
-   if (swrast->_PreferPixelFog) {
-      /* The span's fog values are fog coordinates, now compute blend factors
-       * and blend the fragment colors with the fog color.
-       */
-      switch (swrast->_FogMode) {
-      case GL_LINEAR:
-         {
-            const GLfloat fogEnd = ctx->Fog.End;
-            const GLfloat fogScale = (ctx->Fog.Start == ctx->Fog.End)
-               ? 1.0F : 1.0F / (ctx->Fog.End - ctx->Fog.Start);
-            if (span->array->ChanType == GL_UNSIGNED_BYTE) {
-               GLubyte (*rgba)[4] = span->array->rgba8;
-               FOG_LOOP(GLubyte, LINEAR_FOG);
-            }
-            else if (span->array->ChanType == GL_UNSIGNED_SHORT) {
-               GLushort (*rgba)[4] = span->array->rgba16;
-               FOG_LOOP(GLushort, LINEAR_FOG);
-            }
-            else {
-               GLfloat (*rgba)[4] = span->array->attribs[FRAG_ATTRIB_COL0];
-               ASSERT(span->array->ChanType == GL_FLOAT);
-               FOG_LOOP(GLfloat, LINEAR_FOG);
-            }
-         }
-         break;
-
-      case GL_EXP:
-         {
-            const GLfloat density = -ctx->Fog.Density;
-            if (span->array->ChanType == GL_UNSIGNED_BYTE) {
-               GLubyte (*rgba)[4] = span->array->rgba8;
-               FOG_LOOP(GLubyte, EXP_FOG);
-            }
-            else if (span->array->ChanType == GL_UNSIGNED_SHORT) {
-               GLushort (*rgba)[4] = span->array->rgba16;
-               FOG_LOOP(GLushort, EXP_FOG);
-            }
-            else {
-               GLfloat (*rgba)[4] = span->array->attribs[FRAG_ATTRIB_COL0];
-               ASSERT(span->array->ChanType == GL_FLOAT);
-               FOG_LOOP(GLfloat, EXP_FOG);
-            }
-         }
-         break;
-
-      case GL_EXP2:
-         {
-            const GLfloat negDensitySquared = -ctx->Fog.Density * ctx->Fog.Density;
-            if (span->array->ChanType == GL_UNSIGNED_BYTE) {
-               GLubyte (*rgba)[4] = span->array->rgba8;
-               FOG_LOOP(GLubyte, EXP2_FOG);
-            }
-            else if (span->array->ChanType == GL_UNSIGNED_SHORT) {
-               GLushort (*rgba)[4] = span->array->rgba16;
-               FOG_LOOP(GLushort, EXP2_FOG);
-            }
-            else {
-               GLfloat (*rgba)[4] = span->array->attribs[FRAG_ATTRIB_COL0];
-               ASSERT(span->array->ChanType == GL_FLOAT);
-               FOG_LOOP(GLfloat, EXP2_FOG);
-            }
-         }
-         break;
-
-      default:
-         _mesa_problem(ctx, "Bad fog mode in _swrast_fog_rgba_span");
-         return;
-      }
-   }
-   else {
-      /* The span's fog start/step/array values are blend factors in [0,1].
-       * They were previously computed per-vertex.
-       */
-      if (span->array->ChanType == GL_UNSIGNED_BYTE) {
-         GLubyte (*rgba)[4] = span->array->rgba8;
-         FOG_LOOP(GLubyte, BLEND_FOG);
-      }
-      else if (span->array->ChanType == GL_UNSIGNED_SHORT) {
-         GLushort (*rgba)[4] = span->array->rgba16;
-         FOG_LOOP(GLushort, BLEND_FOG);
-      }
-      else {
-         GLfloat (*rgba)[4] = span->array->attribs[FRAG_ATTRIB_COL0];
-         ASSERT(span->array->ChanType == GL_FLOAT);
-         FOG_LOOP(GLfloat, BLEND_FOG);
-      }
-   }
-}
+/*

+ * Mesa 3-D graphics library

+ * Version:  6.5.2

+ *

+ * Copyright (C) 1999-2006  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_fog.h"

+

+

+/**

+ * Used to convert current raster distance to a fog factor in [0,1].

+ */

+GLfloat

+_swrast_z_to_fogfactor(struct gl_context *ctx, GLfloat z)

+{

+   GLfloat d, f;

+

+   switch (ctx->Fog.Mode) {

+   case GL_LINEAR:

+      if (ctx->Fog.Start == ctx->Fog.End)

+         d = 1.0F;

+      else

+         d = 1.0F / (ctx->Fog.End - ctx->Fog.Start);

+      f = (ctx->Fog.End - z) * d;

+      return CLAMP(f, 0.0F, 1.0F);

+   case GL_EXP:

+      d = ctx->Fog.Density;

+      f = EXPF(-d * z);

+      f = CLAMP(f, 0.0F, 1.0F);

+      return f;

+   case GL_EXP2:

+      d = ctx->Fog.Density;

+      f = EXPF(-(d * d * z * z));

+      f = CLAMP(f, 0.0F, 1.0F);

+      return f;

+   default:

+      _mesa_problem(ctx, "Bad fog mode in _swrast_z_to_fogfactor");

+      return 0.0; 

+   }

+}

+

+

+#define LINEAR_FOG(f, coord)  f = (fogEnd - coord) * fogScale

+

+#define EXP_FOG(f, coord)  f = EXPF(density * coord)

+

+#define EXP2_FOG(f, coord)				\

+do {							\

+   GLfloat tmp = negDensitySquared * coord * coord;	\

+   if (tmp < FLT_MIN_10_EXP)				\

+      tmp = FLT_MIN_10_EXP;				\

+   f = EXPF(tmp);					\

+ } while(0)

+

+

+#define BLEND_FOG(f, coord)  f = coord

+

+

+

+/**

+ * Template code for computing fog blend factor and applying it to colors.

+ * \param TYPE  either GLubyte, GLushort or GLfloat.

+ * \param COMPUTE_F  code to compute the fog blend factor, f.

+ */

+#define FOG_LOOP(TYPE, FOG_FUNC)						\

+if (span->arrayAttribs & FRAG_BIT_FOGC) {					\

+   GLuint i;									\

+   for (i = 0; i < span->end; i++) {						\

+      const GLfloat fogCoord = span->array->attribs[FRAG_ATTRIB_FOGC][i][0];	\

+      const GLfloat c = FABSF(fogCoord);					\

+      GLfloat f, oneMinusF;							\

+      FOG_FUNC(f, c);								\

+      f = CLAMP(f, 0.0F, 1.0F);							\

+      oneMinusF = 1.0F - f;							\

+      rgba[i][RCOMP] = (TYPE) (f * rgba[i][RCOMP] + oneMinusF * rFog);		\

+      rgba[i][GCOMP] = (TYPE) (f * rgba[i][GCOMP] + oneMinusF * gFog);		\

+      rgba[i][BCOMP] = (TYPE) (f * rgba[i][BCOMP] + oneMinusF * bFog);		\

+   }										\

+}										\

+else {										\

+   const GLfloat fogStep = span->attrStepX[FRAG_ATTRIB_FOGC][0];		\

+   GLfloat fogCoord = span->attrStart[FRAG_ATTRIB_FOGC][0];			\

+   const GLfloat wStep = span->attrStepX[FRAG_ATTRIB_WPOS][3];			\

+   GLfloat w = span->attrStart[FRAG_ATTRIB_WPOS][3];				\

+   GLuint i;									\

+   for (i = 0; i < span->end; i++) {						\

+      const GLfloat c = FABSF(fogCoord) / w;					\

+      GLfloat f, oneMinusF;							\

+      FOG_FUNC(f, c);								\

+      f = CLAMP(f, 0.0F, 1.0F);							\

+      oneMinusF = 1.0F - f;							\

+      rgba[i][RCOMP] = (TYPE) (f * rgba[i][RCOMP] + oneMinusF * rFog);		\

+      rgba[i][GCOMP] = (TYPE) (f * rgba[i][GCOMP] + oneMinusF * gFog);		\

+      rgba[i][BCOMP] = (TYPE) (f * rgba[i][BCOMP] + oneMinusF * bFog);		\

+      fogCoord += fogStep;							\

+      w += wStep;								\

+   }										\

+}

+

+/**

+ * Apply fog to a span of RGBA pixels.

+ * The fog value are either in the span->array->fog array or interpolated from

+ * the fog/fogStep values.

+ * They fog values are either fog coordinates (Z) or fog blend factors.

+ * _PreferPixelFog should be in sync with that state!

+ */

+void

+_swrast_fog_rgba_span( const struct gl_context *ctx, SWspan *span )

+{

+   const SWcontext *swrast = CONST_SWRAST_CONTEXT(ctx);

+   GLfloat rFog, gFog, bFog;

+

+   ASSERT(swrast->_FogEnabled);

+   ASSERT(span->arrayMask & SPAN_RGBA);

+

+   /* compute (scaled) fog color */

+   if (span->array->ChanType == GL_UNSIGNED_BYTE) {

+      rFog = ctx->Fog.Color[RCOMP] * 255.0F;

+      gFog = ctx->Fog.Color[GCOMP] * 255.0F;

+      bFog = ctx->Fog.Color[BCOMP] * 255.0F;

+   }

+   else if (span->array->ChanType == GL_UNSIGNED_SHORT) {

+      rFog = ctx->Fog.Color[RCOMP] * 65535.0F;

+      gFog = ctx->Fog.Color[GCOMP] * 65535.0F;

+      bFog = ctx->Fog.Color[BCOMP] * 65535.0F;

+   }

+   else {

+      rFog = ctx->Fog.Color[RCOMP];

+      gFog = ctx->Fog.Color[GCOMP];

+      bFog = ctx->Fog.Color[BCOMP];

+   }

+

+   if (swrast->_PreferPixelFog) {

+      /* The span's fog values are fog coordinates, now compute blend factors

+       * and blend the fragment colors with the fog color.

+       */

+      switch (swrast->_FogMode) {

+      case GL_LINEAR:

+         {

+            const GLfloat fogEnd = ctx->Fog.End;

+            const GLfloat fogScale = (ctx->Fog.Start == ctx->Fog.End)

+               ? 1.0F : 1.0F / (ctx->Fog.End - ctx->Fog.Start);

+            if (span->array->ChanType == GL_UNSIGNED_BYTE) {

+               GLubyte (*rgba)[4] = span->array->rgba8;

+               FOG_LOOP(GLubyte, LINEAR_FOG);

+            }

+            else if (span->array->ChanType == GL_UNSIGNED_SHORT) {

+               GLushort (*rgba)[4] = span->array->rgba16;

+               FOG_LOOP(GLushort, LINEAR_FOG);

+            }

+            else {

+               GLfloat (*rgba)[4] = span->array->attribs[FRAG_ATTRIB_COL0];

+               ASSERT(span->array->ChanType == GL_FLOAT);

+               FOG_LOOP(GLfloat, LINEAR_FOG);

+            }

+         }

+         break;

+

+      case GL_EXP:

+         {

+            const GLfloat density = -ctx->Fog.Density;

+            if (span->array->ChanType == GL_UNSIGNED_BYTE) {

+               GLubyte (*rgba)[4] = span->array->rgba8;

+               FOG_LOOP(GLubyte, EXP_FOG);

+            }

+            else if (span->array->ChanType == GL_UNSIGNED_SHORT) {

+               GLushort (*rgba)[4] = span->array->rgba16;

+               FOG_LOOP(GLushort, EXP_FOG);

+            }

+            else {

+               GLfloat (*rgba)[4] = span->array->attribs[FRAG_ATTRIB_COL0];

+               ASSERT(span->array->ChanType == GL_FLOAT);

+               FOG_LOOP(GLfloat, EXP_FOG);

+            }

+         }

+         break;

+

+      case GL_EXP2:

+         {

+            const GLfloat negDensitySquared = -ctx->Fog.Density * ctx->Fog.Density;

+            if (span->array->ChanType == GL_UNSIGNED_BYTE) {

+               GLubyte (*rgba)[4] = span->array->rgba8;

+               FOG_LOOP(GLubyte, EXP2_FOG);

+            }

+            else if (span->array->ChanType == GL_UNSIGNED_SHORT) {

+               GLushort (*rgba)[4] = span->array->rgba16;

+               FOG_LOOP(GLushort, EXP2_FOG);

+            }

+            else {

+               GLfloat (*rgba)[4] = span->array->attribs[FRAG_ATTRIB_COL0];

+               ASSERT(span->array->ChanType == GL_FLOAT);

+               FOG_LOOP(GLfloat, EXP2_FOG);

+            }

+         }

+         break;

+

+      default:

+         _mesa_problem(ctx, "Bad fog mode in _swrast_fog_rgba_span");

+         return;

+      }

+   }

+   else {

+      /* The span's fog start/step/array values are blend factors in [0,1].

+       * They were previously computed per-vertex.

+       */

+      if (span->array->ChanType == GL_UNSIGNED_BYTE) {

+         GLubyte (*rgba)[4] = span->array->rgba8;

+         FOG_LOOP(GLubyte, BLEND_FOG);

+      }

+      else if (span->array->ChanType == GL_UNSIGNED_SHORT) {

+         GLushort (*rgba)[4] = span->array->rgba16;

+         FOG_LOOP(GLushort, BLEND_FOG);

+      }

+      else {

+         GLfloat (*rgba)[4] = span->array->attribs[FRAG_ATTRIB_COL0];

+         ASSERT(span->array->ChanType == GL_FLOAT);

+         FOG_LOOP(GLfloat, BLEND_FOG);

+      }

+   }

+}

diff --git a/mesalib/src/mesa/swrast/s_fog.h b/mesalib/src/mesa/swrast/s_fog.h
index a496746d1..eed9b8bdd 100644
--- a/mesalib/src/mesa/swrast/s_fog.h
+++ b/mesalib/src/mesa/swrast/s_fog.h
@@ -1,41 +1,42 @@
-
-/*
- * Mesa 3-D graphics library
- * Version:  4.1
- *
- * Copyright (C) 1999-2002  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.
- */
-
-
-#ifndef S_FOG_H
-#define S_FOG_H
-
-
-#include "main/mtypes.h"
-#include "s_span.h"
-
-
-extern GLfloat
-_swrast_z_to_fogfactor(GLcontext *ctx, GLfloat z);
-
-extern void
-_swrast_fog_rgba_span( const GLcontext *ctx, SWspan *span );
-
-#endif
+

+/*

+ * Mesa 3-D graphics library

+ * Version:  4.1

+ *

+ * Copyright (C) 1999-2002  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.

+ */

+

+

+#ifndef S_FOG_H

+#define S_FOG_H

+

+

+#include "main/glheader.h"

+#include "s_span.h"

+

+struct gl_context;

+

+extern GLfloat

+_swrast_z_to_fogfactor(struct gl_context *ctx, GLfloat z);

+

+extern void

+_swrast_fog_rgba_span( const struct gl_context *ctx, SWspan *span );

+

+#endif

diff --git a/mesalib/src/mesa/swrast/s_fragprog.c b/mesalib/src/mesa/swrast/s_fragprog.c
index 9facb44d9..2608d5373 100644
--- a/mesalib/src/mesa/swrast/s_fragprog.c
+++ b/mesalib/src/mesa/swrast/s_fragprog.c
@@ -1,277 +1,277 @@
-/*
- * Mesa 3-D graphics library
- * Version:  7.0.3
- *
- * 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 "program/prog_instruction.h"
-
-#include "s_context.h"
-#include "s_fragprog.h"
-#include "s_span.h"
-
-
-/**
- * Apply texture object's swizzle (X/Y/Z/W/0/1) to incoming 'texel'
- * and return results in 'colorOut'.
- */
-static INLINE void
-swizzle_texel(const GLfloat texel[4], GLfloat colorOut[4], GLuint swizzle)
-{
-   if (swizzle == SWIZZLE_NOOP) {
-      COPY_4V(colorOut, texel);
-   }
-   else {
-      GLfloat vector[6];
-      vector[SWIZZLE_X] = texel[0];
-      vector[SWIZZLE_Y] = texel[1];
-      vector[SWIZZLE_Z] = texel[2];
-      vector[SWIZZLE_W] = texel[3];
-      vector[SWIZZLE_ZERO] = 0.0F;
-      vector[SWIZZLE_ONE] = 1.0F;
-      colorOut[0] = vector[GET_SWZ(swizzle, 0)];
-      colorOut[1] = vector[GET_SWZ(swizzle, 1)];
-      colorOut[2] = vector[GET_SWZ(swizzle, 2)];
-      colorOut[3] = vector[GET_SWZ(swizzle, 3)];
-   }
-}
-
-
-/**
- * Fetch a texel with given lod.
- * Called via machine->FetchTexelLod()
- */
-static void
-fetch_texel_lod( GLcontext *ctx, const GLfloat texcoord[4], GLfloat lambda,
-                 GLuint unit, GLfloat color[4] )
-{
-   const struct gl_texture_object *texObj = ctx->Texture.Unit[unit]._Current;
-
-   if (texObj) {
-      SWcontext *swrast = SWRAST_CONTEXT(ctx);
-      GLfloat rgba[4];
-
-      lambda = CLAMP(lambda, texObj->MinLod, texObj->MaxLod);
-
-      swrast->TextureSample[unit](ctx, texObj, 1,
-                                  (const GLfloat (*)[4]) texcoord,
-                                  &lambda, &rgba);
-      swizzle_texel(rgba, color, texObj->_Swizzle);
-   }
-   else {
-      ASSIGN_4V(color, 0.0F, 0.0F, 0.0F, 1.0F);
-   }
-}
-
-
-/**
- * Fetch a texel with the given partial derivatives to compute a level
- * of detail in the mipmap.
- * Called via machine->FetchTexelDeriv()
- * \param lodBias  the lod bias which may be specified by a TXB instruction,
- *                 otherwise zero.
- */
-static void
-fetch_texel_deriv( GLcontext *ctx, const GLfloat texcoord[4],
-                   const GLfloat texdx[4], const GLfloat texdy[4],
-                   GLfloat lodBias, GLuint unit, GLfloat color[4] )
-{
-   SWcontext *swrast = SWRAST_CONTEXT(ctx);
-   const struct gl_texture_unit *texUnit = &ctx->Texture.Unit[unit];
-   const struct gl_texture_object *texObj = texUnit->_Current;
-
-   if (texObj) {
-      const struct gl_texture_image *texImg =
-         texObj->Image[0][texObj->BaseLevel];
-      const GLfloat texW = (GLfloat) texImg->WidthScale;
-      const GLfloat texH = (GLfloat) texImg->HeightScale;
-      GLfloat lambda;
-      GLfloat rgba[4];
-
-      lambda = _swrast_compute_lambda(texdx[0], texdy[0], /* ds/dx, ds/dy */
-                                      texdx[1], texdy[1], /* dt/dx, dt/dy */
-                                      texdx[3], texdy[3], /* dq/dx, dq/dy */
-                                      texW, texH,
-                                      texcoord[0], texcoord[1], texcoord[3],
-                                      1.0F / texcoord[3]);
-
-      lambda += lodBias + texUnit->LodBias + texObj->LodBias;
-
-      lambda = CLAMP(lambda, texObj->MinLod, texObj->MaxLod);
-
-      swrast->TextureSample[unit](ctx, texObj, 1,
-                                  (const GLfloat (*)[4]) texcoord,
-                                  &lambda, &rgba);
-      swizzle_texel(rgba, color, texObj->_Swizzle);
-   }
-   else {
-      ASSIGN_4V(color, 0.0F, 0.0F, 0.0F, 1.0F);
-   }
-}
-
-
-/**
- * Initialize the virtual fragment program machine state prior to running
- * fragment program on a fragment.  This involves initializing the input
- * registers, condition codes, etc.
- * \param machine  the virtual machine state to init
- * \param program  the fragment program we're about to run
- * \param span  the span of pixels we'll operate on
- * \param col  which element (column) of the span we'll operate on
- */
-static void
-init_machine(GLcontext *ctx, struct gl_program_machine *machine,
-             const struct gl_fragment_program *program,
-             const SWspan *span, GLuint col)
-{
-   GLfloat *wpos = span->array->attribs[FRAG_ATTRIB_WPOS][col];
-
-   if (program->Base.Target == GL_FRAGMENT_PROGRAM_NV) {
-      /* Clear temporary registers (undefined for ARB_f_p) */
-      memset(machine->Temporaries, 0, MAX_PROGRAM_TEMPS * 4 * sizeof(GLfloat));
-   }
-
-   /* ARB_fragment_coord_conventions */
-   if (program->OriginUpperLeft)
-      wpos[1] = ctx->DrawBuffer->Height - 1 - wpos[1];
-   if (!program->PixelCenterInteger) {
-      wpos[0] += 0.5F;
-      wpos[1] += 0.5F;
-   }
-
-   /* Setup pointer to input attributes */
-   machine->Attribs = span->array->attribs;
-
-   machine->DerivX = (GLfloat (*)[4]) span->attrStepX;
-   machine->DerivY = (GLfloat (*)[4]) span->attrStepY;
-   machine->NumDeriv = FRAG_ATTRIB_MAX;
-
-   machine->Samplers = program->Base.SamplerUnits;
-
-   /* if running a GLSL program (not ARB_fragment_program) */
-   if (ctx->Shader.CurrentProgram) {
-      /* Store front/back facing value */
-      machine->Attribs[FRAG_ATTRIB_FACE][col][0] = 1.0F - span->facing;
-   }
-
-   machine->CurElement = col;
-
-   /* init condition codes */
-   machine->CondCodes[0] = COND_EQ;
-   machine->CondCodes[1] = COND_EQ;
-   machine->CondCodes[2] = COND_EQ;
-   machine->CondCodes[3] = COND_EQ;
-
-   /* init call stack */
-   machine->StackDepth = 0;
-
-   machine->FetchTexelLod = fetch_texel_lod;
-   machine->FetchTexelDeriv = fetch_texel_deriv;
-}
-
-
-/**
- * Run fragment program on the pixels in span from 'start' to 'end' - 1.
- */
-static void
-run_program(GLcontext *ctx, SWspan *span, GLuint start, GLuint end)
-{
-   SWcontext *swrast = SWRAST_CONTEXT(ctx);
-   const struct gl_fragment_program *program = ctx->FragmentProgram._Current;
-   const GLbitfield64 outputsWritten = program->Base.OutputsWritten;
-   struct gl_program_machine *machine = &swrast->FragProgMachine;
-   GLuint i;
-
-   for (i = start; i < end; i++) {
-      if (span->array->mask[i]) {
-         init_machine(ctx, machine, program, span, i);
-
-         if (_mesa_execute_program(ctx, &program->Base, machine)) {
-
-            /* Store result color */
-	    if (outputsWritten & BITFIELD64_BIT(FRAG_RESULT_COLOR)) {
-               COPY_4V(span->array->attribs[FRAG_ATTRIB_COL0][i],
-                       machine->Outputs[FRAG_RESULT_COLOR]);
-            }
-            else {
-               /* Multiple drawbuffers / render targets
-                * Note that colors beyond 0 and 1 will overwrite other
-                * attributes, such as FOGC, TEX0, TEX1, etc.  That's OK.
-                */
-               GLuint buf;
-               for (buf = 0; buf < ctx->DrawBuffer->_NumColorDrawBuffers; buf++) {
-                  if (outputsWritten & BITFIELD64_BIT(FRAG_RESULT_DATA0 + buf)) {
-                     COPY_4V(span->array->attribs[FRAG_ATTRIB_COL0 + buf][i],
-                             machine->Outputs[FRAG_RESULT_DATA0 + buf]);
-                  }
-               }
-            }
-
-            /* Store result depth/z */
-            if (outputsWritten & BITFIELD64_BIT(FRAG_RESULT_DEPTH)) {
-               const GLfloat depth = machine->Outputs[FRAG_RESULT_DEPTH][2];
-               if (depth <= 0.0)
-                  span->array->z[i] = 0;
-               else if (depth >= 1.0)
-                  span->array->z[i] = ctx->DrawBuffer->_DepthMax;
-               else
-                  span->array->z[i] = IROUND(depth * ctx->DrawBuffer->_DepthMaxF);
-            }
-         }
-         else {
-            /* killed fragment */
-            span->array->mask[i] = GL_FALSE;
-            span->writeAll = GL_FALSE;
-         }
-      }
-   }
-}
-
-
-/**
- * Execute the current fragment program for all the fragments
- * in the given span.
- */
-void
-_swrast_exec_fragment_program( GLcontext *ctx, SWspan *span )
-{
-   const struct gl_fragment_program *program = ctx->FragmentProgram._Current;
-
-   /* incoming colors should be floats */
-   if (program->Base.InputsRead & FRAG_BIT_COL0) {
-      ASSERT(span->array->ChanType == GL_FLOAT);
-   }
-
-   run_program(ctx, span, 0, span->end);
-
-   if (program->Base.OutputsWritten & BITFIELD64_BIT(FRAG_RESULT_COLOR)) {
-      span->interpMask &= ~SPAN_RGBA;
-      span->arrayMask |= SPAN_RGBA;
-   }
-
-   if (program->Base.OutputsWritten & BITFIELD64_BIT(FRAG_RESULT_DEPTH)) {
-      span->interpMask &= ~SPAN_Z;
-      span->arrayMask |= SPAN_Z;
-   }
-}
-
+/*

+ * Mesa 3-D graphics library

+ * Version:  7.0.3

+ *

+ * 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 "program/prog_instruction.h"

+

+#include "s_context.h"

+#include "s_fragprog.h"

+#include "s_span.h"

+

+

+/**

+ * Apply texture object's swizzle (X/Y/Z/W/0/1) to incoming 'texel'

+ * and return results in 'colorOut'.

+ */

+static INLINE void

+swizzle_texel(const GLfloat texel[4], GLfloat colorOut[4], GLuint swizzle)

+{

+   if (swizzle == SWIZZLE_NOOP) {

+      COPY_4V(colorOut, texel);

+   }

+   else {

+      GLfloat vector[6];

+      vector[SWIZZLE_X] = texel[0];

+      vector[SWIZZLE_Y] = texel[1];

+      vector[SWIZZLE_Z] = texel[2];

+      vector[SWIZZLE_W] = texel[3];

+      vector[SWIZZLE_ZERO] = 0.0F;

+      vector[SWIZZLE_ONE] = 1.0F;

+      colorOut[0] = vector[GET_SWZ(swizzle, 0)];

+      colorOut[1] = vector[GET_SWZ(swizzle, 1)];

+      colorOut[2] = vector[GET_SWZ(swizzle, 2)];

+      colorOut[3] = vector[GET_SWZ(swizzle, 3)];

+   }

+}

+

+

+/**

+ * Fetch a texel with given lod.

+ * Called via machine->FetchTexelLod()

+ */

+static void

+fetch_texel_lod( struct gl_context *ctx, const GLfloat texcoord[4], GLfloat lambda,

+                 GLuint unit, GLfloat color[4] )

+{

+   const struct gl_texture_object *texObj = ctx->Texture.Unit[unit]._Current;

+

+   if (texObj) {

+      SWcontext *swrast = SWRAST_CONTEXT(ctx);

+      GLfloat rgba[4];

+

+      lambda = CLAMP(lambda, texObj->MinLod, texObj->MaxLod);

+

+      swrast->TextureSample[unit](ctx, texObj, 1,

+                                  (const GLfloat (*)[4]) texcoord,

+                                  &lambda, &rgba);

+      swizzle_texel(rgba, color, texObj->_Swizzle);

+   }

+   else {

+      ASSIGN_4V(color, 0.0F, 0.0F, 0.0F, 1.0F);

+   }

+}

+

+

+/**

+ * Fetch a texel with the given partial derivatives to compute a level

+ * of detail in the mipmap.

+ * Called via machine->FetchTexelDeriv()

+ * \param lodBias  the lod bias which may be specified by a TXB instruction,

+ *                 otherwise zero.

+ */

+static void

+fetch_texel_deriv( struct gl_context *ctx, const GLfloat texcoord[4],

+                   const GLfloat texdx[4], const GLfloat texdy[4],

+                   GLfloat lodBias, GLuint unit, GLfloat color[4] )

+{

+   SWcontext *swrast = SWRAST_CONTEXT(ctx);

+   const struct gl_texture_unit *texUnit = &ctx->Texture.Unit[unit];

+   const struct gl_texture_object *texObj = texUnit->_Current;

+

+   if (texObj) {

+      const struct gl_texture_image *texImg =

+         texObj->Image[0][texObj->BaseLevel];

+      const GLfloat texW = (GLfloat) texImg->WidthScale;

+      const GLfloat texH = (GLfloat) texImg->HeightScale;

+      GLfloat lambda;

+      GLfloat rgba[4];

+

+      lambda = _swrast_compute_lambda(texdx[0], texdy[0], /* ds/dx, ds/dy */

+                                      texdx[1], texdy[1], /* dt/dx, dt/dy */

+                                      texdx[3], texdy[3], /* dq/dx, dq/dy */

+                                      texW, texH,

+                                      texcoord[0], texcoord[1], texcoord[3],

+                                      1.0F / texcoord[3]);

+

+      lambda += lodBias + texUnit->LodBias + texObj->LodBias;

+

+      lambda = CLAMP(lambda, texObj->MinLod, texObj->MaxLod);

+

+      swrast->TextureSample[unit](ctx, texObj, 1,

+                                  (const GLfloat (*)[4]) texcoord,

+                                  &lambda, &rgba);

+      swizzle_texel(rgba, color, texObj->_Swizzle);

+   }

+   else {

+      ASSIGN_4V(color, 0.0F, 0.0F, 0.0F, 1.0F);

+   }

+}

+

+

+/**

+ * Initialize the virtual fragment program machine state prior to running

+ * fragment program on a fragment.  This involves initializing the input

+ * registers, condition codes, etc.

+ * \param machine  the virtual machine state to init

+ * \param program  the fragment program we're about to run

+ * \param span  the span of pixels we'll operate on

+ * \param col  which element (column) of the span we'll operate on

+ */

+static void

+init_machine(struct gl_context *ctx, struct gl_program_machine *machine,

+             const struct gl_fragment_program *program,

+             const SWspan *span, GLuint col)

+{

+   GLfloat *wpos = span->array->attribs[FRAG_ATTRIB_WPOS][col];

+

+   if (program->Base.Target == GL_FRAGMENT_PROGRAM_NV) {

+      /* Clear temporary registers (undefined for ARB_f_p) */

+      memset(machine->Temporaries, 0, MAX_PROGRAM_TEMPS * 4 * sizeof(GLfloat));

+   }

+

+   /* ARB_fragment_coord_conventions */

+   if (program->OriginUpperLeft)

+      wpos[1] = ctx->DrawBuffer->Height - 1 - wpos[1];

+   if (!program->PixelCenterInteger) {

+      wpos[0] += 0.5F;

+      wpos[1] += 0.5F;

+   }

+

+   /* Setup pointer to input attributes */

+   machine->Attribs = span->array->attribs;

+

+   machine->DerivX = (GLfloat (*)[4]) span->attrStepX;

+   machine->DerivY = (GLfloat (*)[4]) span->attrStepY;

+   machine->NumDeriv = FRAG_ATTRIB_MAX;

+

+   machine->Samplers = program->Base.SamplerUnits;

+

+   /* if running a GLSL program (not ARB_fragment_program) */

+   if (ctx->Shader.CurrentFragmentProgram) {

+      /* Store front/back facing value */

+      machine->Attribs[FRAG_ATTRIB_FACE][col][0] = 1.0F - span->facing;

+   }

+

+   machine->CurElement = col;

+

+   /* init condition codes */

+   machine->CondCodes[0] = COND_EQ;

+   machine->CondCodes[1] = COND_EQ;

+   machine->CondCodes[2] = COND_EQ;

+   machine->CondCodes[3] = COND_EQ;

+

+   /* init call stack */

+   machine->StackDepth = 0;

+

+   machine->FetchTexelLod = fetch_texel_lod;

+   machine->FetchTexelDeriv = fetch_texel_deriv;

+}

+

+

+/**

+ * Run fragment program on the pixels in span from 'start' to 'end' - 1.

+ */

+static void

+run_program(struct gl_context *ctx, SWspan *span, GLuint start, GLuint end)

+{

+   SWcontext *swrast = SWRAST_CONTEXT(ctx);

+   const struct gl_fragment_program *program = ctx->FragmentProgram._Current;

+   const GLbitfield64 outputsWritten = program->Base.OutputsWritten;

+   struct gl_program_machine *machine = &swrast->FragProgMachine;

+   GLuint i;

+

+   for (i = start; i < end; i++) {

+      if (span->array->mask[i]) {

+         init_machine(ctx, machine, program, span, i);

+

+         if (_mesa_execute_program(ctx, &program->Base, machine)) {

+

+            /* Store result color */

+	    if (outputsWritten & BITFIELD64_BIT(FRAG_RESULT_COLOR)) {

+               COPY_4V(span->array->attribs[FRAG_ATTRIB_COL0][i],

+                       machine->Outputs[FRAG_RESULT_COLOR]);

+            }

+            else {

+               /* Multiple drawbuffers / render targets

+                * Note that colors beyond 0 and 1 will overwrite other

+                * attributes, such as FOGC, TEX0, TEX1, etc.  That's OK.

+                */

+               GLuint buf;

+               for (buf = 0; buf < ctx->DrawBuffer->_NumColorDrawBuffers; buf++) {

+                  if (outputsWritten & BITFIELD64_BIT(FRAG_RESULT_DATA0 + buf)) {

+                     COPY_4V(span->array->attribs[FRAG_ATTRIB_COL0 + buf][i],

+                             machine->Outputs[FRAG_RESULT_DATA0 + buf]);

+                  }

+               }

+            }

+

+            /* Store result depth/z */

+            if (outputsWritten & BITFIELD64_BIT(FRAG_RESULT_DEPTH)) {

+               const GLfloat depth = machine->Outputs[FRAG_RESULT_DEPTH][2];

+               if (depth <= 0.0)

+                  span->array->z[i] = 0;

+               else if (depth >= 1.0)

+                  span->array->z[i] = ctx->DrawBuffer->_DepthMax;

+               else

+                  span->array->z[i] = IROUND(depth * ctx->DrawBuffer->_DepthMaxF);

+            }

+         }

+         else {

+            /* killed fragment */

+            span->array->mask[i] = GL_FALSE;

+            span->writeAll = GL_FALSE;

+         }

+      }

+   }

+}

+

+

+/**

+ * Execute the current fragment program for all the fragments

+ * in the given span.

+ */

+void

+_swrast_exec_fragment_program( struct gl_context *ctx, SWspan *span )

+{

+   const struct gl_fragment_program *program = ctx->FragmentProgram._Current;

+

+   /* incoming colors should be floats */

+   if (program->Base.InputsRead & FRAG_BIT_COL0) {

+      ASSERT(span->array->ChanType == GL_FLOAT);

+   }

+

+   run_program(ctx, span, 0, span->end);

+

+   if (program->Base.OutputsWritten & BITFIELD64_BIT(FRAG_RESULT_COLOR)) {

+      span->interpMask &= ~SPAN_RGBA;

+      span->arrayMask |= SPAN_RGBA;

+   }

+

+   if (program->Base.OutputsWritten & BITFIELD64_BIT(FRAG_RESULT_DEPTH)) {

+      span->interpMask &= ~SPAN_Z;

+      span->arrayMask |= SPAN_Z;

+   }

+}

+

diff --git a/mesalib/src/mesa/swrast/s_fragprog.h b/mesalib/src/mesa/swrast/s_fragprog.h
index 92b9d01e1..bd5fe6877 100644
--- a/mesalib/src/mesa/swrast/s_fragprog.h
+++ b/mesalib/src/mesa/swrast/s_fragprog.h
@@ -1,39 +1,40 @@
-/*
- * Mesa 3-D graphics library
- * Version:  6.5.3
- *
- * Copyright (C) 1999-2006  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.
- */
-
-
-#ifndef S_FRAGPROG_H
-#define S_FRAGPROG_H
-
-
-#include "main/mtypes.h"
-#include "s_span.h"
-
-
-extern void
-_swrast_exec_fragment_program(GLcontext *ctx, SWspan *span);
-
-
-#endif /* S_FRAGPROG_H */
-
+/*

+ * Mesa 3-D graphics library

+ * Version:  6.5.3

+ *

+ * Copyright (C) 1999-2006  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.

+ */

+

+

+#ifndef S_FRAGPROG_H

+#define S_FRAGPROG_H

+

+

+#include "s_span.h"

+

+struct gl_context;

+

+

+extern void

+_swrast_exec_fragment_program(struct gl_context *ctx, SWspan *span);

+

+

+#endif /* S_FRAGPROG_H */

+

diff --git a/mesalib/src/mesa/swrast/s_lines.c b/mesalib/src/mesa/swrast/s_lines.c
index 7db5af4ae..aba403308 100644
--- a/mesalib/src/mesa/swrast/s_lines.c
+++ b/mesalib/src/mesa/swrast/s_lines.c
@@ -1,268 +1,268 @@
-/*
- * 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/context.h"
-#include "main/colormac.h"
-#include "main/macros.h"
-#include "s_aaline.h"
-#include "s_context.h"
-#include "s_feedback.h"
-#include "s_lines.h"
-#include "s_span.h"
-
-
-/*
- * Init the mask[] array to implement a line stipple.
- */
-static void
-compute_stipple_mask( GLcontext *ctx, GLuint len, GLubyte mask[] )
-{
-   SWcontext *swrast = SWRAST_CONTEXT(ctx);
-   GLuint i;
-
-   for (i = 0; i < len; i++) {
-      GLuint bit = (swrast->StippleCounter / ctx->Line.StippleFactor) & 0xf;
-      if ((1 << bit) & ctx->Line.StipplePattern) {
-         mask[i] = GL_TRUE;
-      }
-      else {
-         mask[i] = GL_FALSE;
-      }
-      swrast->StippleCounter++;
-   }
-}
-
-
-/*
- * To draw a wide line we can simply redraw the span N times, side by side.
- */
-static void
-draw_wide_line( GLcontext *ctx, SWspan *span, GLboolean xMajor )
-{
-   const GLint width = (GLint) CLAMP(ctx->Line.Width,
-                                     ctx->Const.MinLineWidth,
-                                     ctx->Const.MaxLineWidth);
-   GLint start;
-
-   ASSERT(span->end < MAX_WIDTH);
-
-   if (width & 1)
-      start = width / 2;
-   else
-      start = width / 2 - 1;
-
-   if (xMajor) {
-      GLint *y = span->array->y;
-      GLuint i;
-      GLint w;
-      for (w = 0; w < width; w++) {
-         if (w == 0) {
-            for (i = 0; i < span->end; i++)
-               y[i] -= start;
-         }
-         else {
-            for (i = 0; i < span->end; i++)
-               y[i]++;
-         }
-	 _swrast_write_rgba_span(ctx, span);
-      }
-   }
-   else {
-      GLint *x = span->array->x;
-      GLuint i;
-      GLint w;
-      for (w = 0; w < width; w++) {
-         if (w == 0) {
-            for (i = 0; i < span->end; i++)
-               x[i] -= start;
-         }
-         else {
-            for (i = 0; i < span->end; i++)
-               x[i]++;
-         }
-	 _swrast_write_rgba_span(ctx, span);
-      }
-   }
-}
-
-
-
-/**********************************************************************/
-/*****                    Rasterization                           *****/
-/**********************************************************************/
-
-/* Simple RGBA index line (no stipple, width=1, no Z, no fog, no tex)*/
-#define NAME simple_no_z_rgba_line
-#define INTERP_RGBA
-#define RENDER_SPAN(span) _swrast_write_rgba_span(ctx, &span);
-#include "s_linetemp.h"
-
-
-/* Z, fog, wide, stipple RGBA line */
-#define NAME rgba_line
-#define INTERP_RGBA
-#define INTERP_Z
-#define RENDER_SPAN(span)					\
-   if (ctx->Line.StippleFlag) {					\
-      span.arrayMask |= SPAN_MASK;				\
-      compute_stipple_mask(ctx, span.end, span.array->mask);	\
-   }								\
-   if (ctx->Line.Width > 1.0) {					\
-      draw_wide_line(ctx, &span, (GLboolean)(dx > dy));		\
-   }								\
-   else {							\
-      _swrast_write_rgba_span(ctx, &span);			\
-   }
-#include "s_linetemp.h"
-
-
-/* General-purpose line (any/all features). */
-#define NAME general_line
-#define INTERP_RGBA
-#define INTERP_Z
-#define INTERP_ATTRIBS
-#define RENDER_SPAN(span)					\
-   if (ctx->Line.StippleFlag) {					\
-      span.arrayMask |= SPAN_MASK;				\
-      compute_stipple_mask(ctx, span.end, span.array->mask);	\
-   }								\
-   if (ctx->Line.Width > 1.0) {					\
-      draw_wide_line(ctx, &span, (GLboolean)(dx > dy));		\
-   }								\
-   else {							\
-      _swrast_write_rgba_span(ctx, &span);			\
-   }
-#include "s_linetemp.h"
-
-
-
-void
-_swrast_add_spec_terms_line(GLcontext *ctx,
-                            const SWvertex *v0, const SWvertex *v1)
-{
-   SWvertex *ncv0 = (SWvertex *)v0;
-   SWvertex *ncv1 = (SWvertex *)v1;
-   GLfloat rSum, gSum, bSum;
-   GLchan cSave[2][4];
-
-   /* save original colors */
-   COPY_CHAN4(cSave[0], ncv0->color);
-   COPY_CHAN4(cSave[1], ncv1->color);
-   /* sum v0 */
-   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);
-   /* sum v1 */
-   rSum = CHAN_TO_FLOAT(ncv1->color[0]) + ncv1->attrib[FRAG_ATTRIB_COL1][0];
-   gSum = CHAN_TO_FLOAT(ncv1->color[1]) + ncv1->attrib[FRAG_ATTRIB_COL1][1];
-   bSum = CHAN_TO_FLOAT(ncv1->color[2]) + ncv1->attrib[FRAG_ATTRIB_COL1][2];
-   UNCLAMPED_FLOAT_TO_CHAN(ncv1->color[0], rSum);
-   UNCLAMPED_FLOAT_TO_CHAN(ncv1->color[1], gSum);
-   UNCLAMPED_FLOAT_TO_CHAN(ncv1->color[2], bSum);
-   /* draw */
-   SWRAST_CONTEXT(ctx)->SpecLine( ctx, ncv0, ncv1 );
-   /* restore original colors */
-   COPY_CHAN4( ncv0->attrib[FRAG_ATTRIB_COL0], cSave[0] );
-   COPY_CHAN4( ncv1->attrib[FRAG_ATTRIB_COL0], cSave[1] );
-}
-
-
-
-#ifdef DEBUG
-
-/* record the current line function name */
-static const char *lineFuncName = NULL;
-
-#define USE(lineFunc)                   \
-do {                                    \
-    lineFuncName = #lineFunc;           \
-    /*printf("%s\n", lineFuncName);*/   \
-    swrast->Line = lineFunc;            \
-} while (0)
-
-#else
-
-#define USE(lineFunc)  swrast->Line = lineFunc
-
-#endif
-
-
-
-/**
- * Determine which line drawing function to use given the current
- * rendering context.
- *
- * Please update the summary flag _SWRAST_NEW_LINE if you add or remove
- * tests to this code.
- */
-void
-_swrast_choose_line( GLcontext *ctx )
-{
-   SWcontext *swrast = SWRAST_CONTEXT(ctx);
-   GLboolean specular = (ctx->Fog.ColorSumEnabled ||
-                         (ctx->Light.Enabled &&
-                          ctx->Light.Model.ColorControl == GL_SEPARATE_SPECULAR_COLOR));
-
-   if (ctx->RenderMode == GL_RENDER) {
-      if (ctx->Line.SmoothFlag) {
-         /* antialiased lines */
-         _swrast_choose_aa_line_function(ctx);
-         ASSERT(swrast->Line);
-      }
-      else if (ctx->Texture._EnabledCoordUnits
-               || ctx->FragmentProgram._Current
-               || swrast->_FogEnabled
-               || specular) {
-         USE(general_line);
-      }
-      else if (ctx->Depth.Test
-               || ctx->Line.Width != 1.0
-               || ctx->Line.StippleFlag) {
-         /* no texture, but Z, fog, width>1, stipple, etc. */
-#if CHAN_BITS == 32
-         USE(general_line);
-#else
-         USE(rgba_line);
-#endif
-      }
-      else {
-         ASSERT(!ctx->Depth.Test);
-         ASSERT(ctx->Line.Width == 1.0);
-         /* simple lines */
-         USE(simple_no_z_rgba_line);
-      }
-   }
-   else if (ctx->RenderMode == GL_FEEDBACK) {
-      USE(_swrast_feedback_line);
-   }
-   else {
-      ASSERT(ctx->RenderMode == GL_SELECT);
-      USE(_swrast_select_line);
-   }
-}
+/*

+ * 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/context.h"

+#include "main/colormac.h"

+#include "main/macros.h"

+#include "s_aaline.h"

+#include "s_context.h"

+#include "s_feedback.h"

+#include "s_lines.h"

+#include "s_span.h"

+

+

+/*

+ * Init the mask[] array to implement a line stipple.

+ */

+static void

+compute_stipple_mask( struct gl_context *ctx, GLuint len, GLubyte mask[] )

+{

+   SWcontext *swrast = SWRAST_CONTEXT(ctx);

+   GLuint i;

+

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

+      GLuint bit = (swrast->StippleCounter / ctx->Line.StippleFactor) & 0xf;

+      if ((1 << bit) & ctx->Line.StipplePattern) {

+         mask[i] = GL_TRUE;

+      }

+      else {

+         mask[i] = GL_FALSE;

+      }

+      swrast->StippleCounter++;

+   }

+}

+

+

+/*

+ * To draw a wide line we can simply redraw the span N times, side by side.

+ */

+static void

+draw_wide_line( struct gl_context *ctx, SWspan *span, GLboolean xMajor )

+{

+   const GLint width = (GLint) CLAMP(ctx->Line.Width,

+                                     ctx->Const.MinLineWidth,

+                                     ctx->Const.MaxLineWidth);

+   GLint start;

+

+   ASSERT(span->end < MAX_WIDTH);

+

+   if (width & 1)

+      start = width / 2;

+   else

+      start = width / 2 - 1;

+

+   if (xMajor) {

+      GLint *y = span->array->y;

+      GLuint i;

+      GLint w;

+      for (w = 0; w < width; w++) {

+         if (w == 0) {

+            for (i = 0; i < span->end; i++)

+               y[i] -= start;

+         }

+         else {

+            for (i = 0; i < span->end; i++)

+               y[i]++;

+         }

+	 _swrast_write_rgba_span(ctx, span);

+      }

+   }

+   else {

+      GLint *x = span->array->x;

+      GLuint i;

+      GLint w;

+      for (w = 0; w < width; w++) {

+         if (w == 0) {

+            for (i = 0; i < span->end; i++)

+               x[i] -= start;

+         }

+         else {

+            for (i = 0; i < span->end; i++)

+               x[i]++;

+         }

+	 _swrast_write_rgba_span(ctx, span);

+      }

+   }

+}

+

+

+

+/**********************************************************************/

+/*****                    Rasterization                           *****/

+/**********************************************************************/

+

+/* Simple RGBA index line (no stipple, width=1, no Z, no fog, no tex)*/

+#define NAME simple_no_z_rgba_line

+#define INTERP_RGBA

+#define RENDER_SPAN(span) _swrast_write_rgba_span(ctx, &span);

+#include "s_linetemp.h"

+

+

+/* Z, fog, wide, stipple RGBA line */

+#define NAME rgba_line

+#define INTERP_RGBA

+#define INTERP_Z

+#define RENDER_SPAN(span)					\

+   if (ctx->Line.StippleFlag) {					\

+      span.arrayMask |= SPAN_MASK;				\

+      compute_stipple_mask(ctx, span.end, span.array->mask);	\

+   }								\

+   if (ctx->Line.Width > 1.0) {					\

+      draw_wide_line(ctx, &span, (GLboolean)(dx > dy));		\

+   }								\

+   else {							\

+      _swrast_write_rgba_span(ctx, &span);			\

+   }

+#include "s_linetemp.h"

+

+

+/* General-purpose line (any/all features). */

+#define NAME general_line

+#define INTERP_RGBA

+#define INTERP_Z

+#define INTERP_ATTRIBS

+#define RENDER_SPAN(span)					\

+   if (ctx->Line.StippleFlag) {					\

+      span.arrayMask |= SPAN_MASK;				\

+      compute_stipple_mask(ctx, span.end, span.array->mask);	\

+   }								\

+   if (ctx->Line.Width > 1.0) {					\

+      draw_wide_line(ctx, &span, (GLboolean)(dx > dy));		\

+   }								\

+   else {							\

+      _swrast_write_rgba_span(ctx, &span);			\

+   }

+#include "s_linetemp.h"

+

+

+

+void

+_swrast_add_spec_terms_line(struct gl_context *ctx,

+                            const SWvertex *v0, const SWvertex *v1)

+{

+   SWvertex *ncv0 = (SWvertex *)v0;

+   SWvertex *ncv1 = (SWvertex *)v1;

+   GLfloat rSum, gSum, bSum;

+   GLchan cSave[2][4];

+

+   /* save original colors */

+   COPY_CHAN4(cSave[0], ncv0->color);

+   COPY_CHAN4(cSave[1], ncv1->color);

+   /* sum v0 */

+   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);

+   /* sum v1 */

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

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

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

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

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

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

+   /* draw */

+   SWRAST_CONTEXT(ctx)->SpecLine( ctx, ncv0, ncv1 );

+   /* restore original colors */

+   COPY_CHAN4( ncv0->attrib[FRAG_ATTRIB_COL0], cSave[0] );

+   COPY_CHAN4( ncv1->attrib[FRAG_ATTRIB_COL0], cSave[1] );

+}

+

+

+

+#ifdef DEBUG

+

+/* record the current line function name */

+static const char *lineFuncName = NULL;

+

+#define USE(lineFunc)                   \

+do {                                    \

+    lineFuncName = #lineFunc;           \

+    /*printf("%s\n", lineFuncName);*/   \

+    swrast->Line = lineFunc;            \

+} while (0)

+

+#else

+

+#define USE(lineFunc)  swrast->Line = lineFunc

+

+#endif

+

+

+

+/**

+ * Determine which line drawing function to use given the current

+ * rendering context.

+ *

+ * Please update the summary flag _SWRAST_NEW_LINE if you add or remove

+ * tests to this code.

+ */

+void

+_swrast_choose_line( struct gl_context *ctx )

+{

+   SWcontext *swrast = SWRAST_CONTEXT(ctx);

+   GLboolean specular = (ctx->Fog.ColorSumEnabled ||

+                         (ctx->Light.Enabled &&

+                          ctx->Light.Model.ColorControl == GL_SEPARATE_SPECULAR_COLOR));

+

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

+      if (ctx->Line.SmoothFlag) {

+         /* antialiased lines */

+         _swrast_choose_aa_line_function(ctx);

+         ASSERT(swrast->Line);

+      }

+      else if (ctx->Texture._EnabledCoordUnits

+               || ctx->FragmentProgram._Current

+               || swrast->_FogEnabled

+               || specular) {

+         USE(general_line);

+      }

+      else if (ctx->Depth.Test

+               || ctx->Line.Width != 1.0

+               || ctx->Line.StippleFlag) {

+         /* no texture, but Z, fog, width>1, stipple, etc. */

+#if CHAN_BITS == 32

+         USE(general_line);

+#else

+         USE(rgba_line);

+#endif

+      }

+      else {

+         ASSERT(!ctx->Depth.Test);

+         ASSERT(ctx->Line.Width == 1.0);

+         /* simple lines */

+         USE(simple_no_z_rgba_line);

+      }

+   }

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

+      USE(_swrast_feedback_line);

+   }

+   else {

+      ASSERT(ctx->RenderMode == GL_SELECT);

+      USE(_swrast_select_line);

+   }

+}

diff --git a/mesalib/src/mesa/swrast/s_lines.h b/mesalib/src/mesa/swrast/s_lines.h
index 22979a02b..0f95eecab 100644
--- a/mesalib/src/mesa/swrast/s_lines.h
+++ b/mesalib/src/mesa/swrast/s_lines.h
@@ -1,41 +1,41 @@
-
-/*
- * Mesa 3-D graphics library
- * Version:  3.5
- *
- * Copyright (C) 1999-2001  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.
- */
-
-
-#ifndef S_LINES_H
-#define S_LINES_H
-
-#include "swrast.h"
-
-void
-_swrast_choose_line( GLcontext *ctx );
-
-void
-_swrast_add_spec_terms_line( GLcontext *ctx,
-			     const SWvertex *v0,
-			     const SWvertex *v1 );
-
-
-#endif
+

+/*

+ * Mesa 3-D graphics library

+ * Version:  3.5

+ *

+ * Copyright (C) 1999-2001  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.

+ */

+

+

+#ifndef S_LINES_H

+#define S_LINES_H

+

+#include "swrast.h"

+

+void

+_swrast_choose_line( struct gl_context *ctx );

+

+void

+_swrast_add_spec_terms_line( struct gl_context *ctx,

+			     const SWvertex *v0,

+			     const SWvertex *v1 );

+

+

+#endif

diff --git a/mesalib/src/mesa/swrast/s_linetemp.h b/mesalib/src/mesa/swrast/s_linetemp.h
index 033431df2..bd94ca40a 100644
--- a/mesalib/src/mesa/swrast/s_linetemp.h
+++ b/mesalib/src/mesa/swrast/s_linetemp.h
@@ -1,402 +1,402 @@
-/*
- * Mesa 3-D graphics library
- * Version:  7.0
- *
- * 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.
- */
-
-
-/*
- * Line Rasterizer Template
- *
- * This file is #include'd to generate custom line rasterizers.
- *
- * The following macros may be defined to indicate what auxillary information
- * must be interplated along the line:
- *    INTERP_Z        - if defined, interpolate Z values
- *    INTERP_ATTRIBS  - if defined, interpolate attribs (texcoords, varying, etc)
- *
- * When one can directly address pixels in the color buffer the following
- * macros can be defined and used to directly compute pixel addresses during
- * rasterization (see pixelPtr):
- *    PIXEL_TYPE          - the datatype of a pixel (GLubyte, GLushort, GLuint)
- *    BYTES_PER_ROW       - number of bytes per row in the color buffer
- *    PIXEL_ADDRESS(X,Y)  - returns the address of pixel at (X,Y) where
- *                          Y==0 at bottom of screen and increases upward.
- *
- * Similarly, for direct depth buffer access, this type is used for depth
- * buffer addressing:
- *    DEPTH_TYPE          - either GLushort or GLuint
- *
- * Optionally, one may provide one-time setup code
- *    SETUP_CODE    - code which is to be executed once per line
- *
- * To actually "plot" each pixel the PLOT macro must be defined...
- *    PLOT(X,Y) - code to plot a pixel.  Example:
- *                if (Z < *zPtr) {
- *                   *zPtr = Z;
- *                   color = pack_rgb( FixedToInt(r0), FixedToInt(g0),
- *                                     FixedToInt(b0) );
- *                   put_pixel( X, Y, color );
- *                }
- *
- * This code was designed for the origin to be in the lower-left corner.
- *
- */
-
-
-static void
-NAME( GLcontext *ctx, const SWvertex *vert0, const SWvertex *vert1 )
-{
-   const SWcontext *swrast = SWRAST_CONTEXT(ctx);
-   SWspan span;
-   GLuint interpFlags = 0;
-   GLint x0 = (GLint) vert0->attrib[FRAG_ATTRIB_WPOS][0];
-   GLint x1 = (GLint) vert1->attrib[FRAG_ATTRIB_WPOS][0];
-   GLint y0 = (GLint) vert0->attrib[FRAG_ATTRIB_WPOS][1];
-   GLint y1 = (GLint) vert1->attrib[FRAG_ATTRIB_WPOS][1];
-   GLint dx, dy;
-   GLint numPixels;
-   GLint xstep, ystep;
-#if defined(DEPTH_TYPE)
-   const GLint depthBits = ctx->DrawBuffer->Visual.depthBits;
-   const GLint fixedToDepthShift = depthBits <= 16 ? FIXED_SHIFT : 0;
-   struct gl_renderbuffer *zrb = ctx->DrawBuffer->Attachment[BUFFER_DEPTH].Renderbuffer;
-#define FixedToDepth(F)  ((F) >> fixedToDepthShift)
-   GLint zPtrXstep, zPtrYstep;
-   DEPTH_TYPE *zPtr;
-#elif defined(INTERP_Z)
-   const GLint depthBits = ctx->DrawBuffer->Visual.depthBits;
-#endif
-#ifdef PIXEL_ADDRESS
-   PIXEL_TYPE *pixelPtr;
-   GLint pixelXstep, pixelYstep;
-#endif
-
-#ifdef SETUP_CODE
-   SETUP_CODE
-#endif
-
-   (void) swrast;
-
-   /* Cull primitives with malformed coordinates.
-    */
-   {
-      GLfloat tmp = vert0->attrib[FRAG_ATTRIB_WPOS][0] + vert0->attrib[FRAG_ATTRIB_WPOS][1]
-                  + vert1->attrib[FRAG_ATTRIB_WPOS][0] + vert1->attrib[FRAG_ATTRIB_WPOS][1];
-      if (IS_INF_OR_NAN(tmp))
-	 return;
-   }
-
-   /*
-   printf("%s():\n", __FUNCTION__);
-   printf(" (%f, %f, %f) -> (%f, %f, %f)\n",
-          vert0->attrib[FRAG_ATTRIB_WPOS][0],
-          vert0->attrib[FRAG_ATTRIB_WPOS][1],
-          vert0->attrib[FRAG_ATTRIB_WPOS][2],
-          vert1->attrib[FRAG_ATTRIB_WPOS][0],
-          vert1->attrib[FRAG_ATTRIB_WPOS][1],
-          vert1->attrib[FRAG_ATTRIB_WPOS][2]);
-   printf(" (%d, %d, %d) -> (%d, %d, %d)\n",
-          vert0->color[0], vert0->color[1], vert0->color[2], 
-          vert1->color[0], vert1->color[1], vert1->color[2]);
-   printf(" (%d, %d, %d) -> (%d, %d, %d)\n",
-          vert0->specular[0], vert0->specular[1], vert0->specular[2], 
-          vert1->specular[0], vert1->specular[1], vert1->specular[2]);
-   */
-
-/*
- * Despite being clipped to the view volume, the line's window coordinates
- * may just lie outside the window bounds.  That is, if the legal window
- * coordinates are [0,W-1][0,H-1], it's possible for x==W and/or y==H.
- * This quick and dirty code nudges the endpoints inside the window if
- * necessary.
- */
-#ifdef CLIP_HACK
-   {
-      GLint w = ctx->DrawBuffer->Width;
-      GLint h = ctx->DrawBuffer->Height;
-      if ((x0==w) | (x1==w)) {
-         if ((x0==w) & (x1==w))
-           return;
-         x0 -= x0==w;
-         x1 -= x1==w;
-      }
-      if ((y0==h) | (y1==h)) {
-         if ((y0==h) & (y1==h))
-           return;
-         y0 -= y0==h;
-         y1 -= y1==h;
-      }
-   }
-#endif
-
-   dx = x1 - x0;
-   dy = y1 - y0;
-   if (dx == 0 && dy == 0)
-      return;
-
-   /*
-   printf("%s %d,%d  %g %g %g %g  %g %g %g %g\n", __FUNCTION__, dx, dy,
-          vert0->attrib[FRAG_ATTRIB_COL1][0],
-          vert0->attrib[FRAG_ATTRIB_COL1][1],
-          vert0->attrib[FRAG_ATTRIB_COL1][2],
-          vert0->attrib[FRAG_ATTRIB_COL1][3],
-          vert1->attrib[FRAG_ATTRIB_COL1][0],
-          vert1->attrib[FRAG_ATTRIB_COL1][1],
-          vert1->attrib[FRAG_ATTRIB_COL1][2],
-          vert1->attrib[FRAG_ATTRIB_COL1][3]);
-   */
-
-#ifdef DEPTH_TYPE
-   zPtr = (DEPTH_TYPE *) zrb->GetPointer(ctx, zrb, x0, y0);
-#endif
-#ifdef PIXEL_ADDRESS
-   pixelPtr = (PIXEL_TYPE *) PIXEL_ADDRESS(x0,y0);
-#endif
-
-   if (dx<0) {
-      dx = -dx;   /* make positive */
-      xstep = -1;
-#ifdef DEPTH_TYPE
-      zPtrXstep = -((GLint)sizeof(DEPTH_TYPE));
-#endif
-#ifdef PIXEL_ADDRESS
-      pixelXstep = -((GLint)sizeof(PIXEL_TYPE));
-#endif
-   }
-   else {
-      xstep = 1;
-#ifdef DEPTH_TYPE
-      zPtrXstep = ((GLint)sizeof(DEPTH_TYPE));
-#endif
-#ifdef PIXEL_ADDRESS
-      pixelXstep = ((GLint)sizeof(PIXEL_TYPE));
-#endif
-   }
-
-   if (dy<0) {
-      dy = -dy;   /* make positive */
-      ystep = -1;
-#ifdef DEPTH_TYPE
-      zPtrYstep = -((GLint) (ctx->DrawBuffer->Width * sizeof(DEPTH_TYPE)));
-#endif
-#ifdef PIXEL_ADDRESS
-      pixelYstep = BYTES_PER_ROW;
-#endif
-   }
-   else {
-      ystep = 1;
-#ifdef DEPTH_TYPE
-      zPtrYstep = (GLint) (ctx->DrawBuffer->Width * sizeof(DEPTH_TYPE));
-#endif
-#ifdef PIXEL_ADDRESS
-      pixelYstep = -(BYTES_PER_ROW);
-#endif
-   }
-
-   ASSERT(dx >= 0);
-   ASSERT(dy >= 0);
-
-   numPixels = MAX2(dx, dy);
-
-   /*
-    * Span setup: compute start and step values for all interpolated values.
-    */
-   interpFlags |= SPAN_RGBA;
-   if (ctx->Light.ShadeModel == GL_SMOOTH) {
-      span.red   = ChanToFixed(vert0->color[0]);
-      span.green = ChanToFixed(vert0->color[1]);
-      span.blue  = ChanToFixed(vert0->color[2]);
-      span.alpha = ChanToFixed(vert0->color[3]);
-      span.redStep   = (ChanToFixed(vert1->color[0]) - span.red  ) / numPixels;
-      span.greenStep = (ChanToFixed(vert1->color[1]) - span.green) / numPixels;
-      span.blueStep  = (ChanToFixed(vert1->color[2]) - span.blue ) / numPixels;
-      span.alphaStep = (ChanToFixed(vert1->color[3]) - span.alpha) / numPixels;
-   }
-   else {
-      span.red   = ChanToFixed(vert1->color[0]);
-      span.green = ChanToFixed(vert1->color[1]);
-      span.blue  = ChanToFixed(vert1->color[2]);
-      span.alpha = ChanToFixed(vert1->color[3]);
-      span.redStep   = 0;
-      span.greenStep = 0;
-      span.blueStep  = 0;
-      span.alphaStep = 0;
-   }
-#if defined(INTERP_Z) || defined(DEPTH_TYPE)
-   interpFlags |= SPAN_Z;
-   {
-      if (depthBits <= 16) {
-         span.z = FloatToFixed(vert0->attrib[FRAG_ATTRIB_WPOS][2]) + FIXED_HALF;
-         span.zStep = FloatToFixed(  vert1->attrib[FRAG_ATTRIB_WPOS][2]
-                                   - vert0->attrib[FRAG_ATTRIB_WPOS][2]) / numPixels;
-      }
-      else {
-         /* don't use fixed point */
-         span.z = (GLuint) vert0->attrib[FRAG_ATTRIB_WPOS][2];
-         span.zStep = (GLint) ((  vert1->attrib[FRAG_ATTRIB_WPOS][2]
-                                - vert0->attrib[FRAG_ATTRIB_WPOS][2]) / numPixels);
-      }
-   }
-#endif
-#if defined(INTERP_ATTRIBS)
-   {
-      const GLfloat invLen = 1.0F / numPixels;
-      const GLfloat invw0 = vert0->attrib[FRAG_ATTRIB_WPOS][3];
-      const GLfloat invw1 = vert1->attrib[FRAG_ATTRIB_WPOS][3];
-
-      span.attrStart[FRAG_ATTRIB_WPOS][3] = invw0;
-      span.attrStepX[FRAG_ATTRIB_WPOS][3] = (invw1 - invw0) * invLen;
-      span.attrStepY[FRAG_ATTRIB_WPOS][3] = 0.0;
-
-      ATTRIB_LOOP_BEGIN
-         if (swrast->_InterpMode[attr] == GL_FLAT) {
-            COPY_4V(span.attrStart[attr], vert1->attrib[attr]);
-            ASSIGN_4V(span.attrStepX[attr], 0.0, 0.0, 0.0, 0.0);
-         }
-         else {
-            GLuint c;
-            for (c = 0; c < 4; c++) {
-               float da;
-               span.attrStart[attr][c] = invw0 * vert0->attrib[attr][c];
-               da = (invw1 * vert1->attrib[attr][c]) - span.attrStart[attr][c];
-               span.attrStepX[attr][c] = da * invLen;
-            }
-         }
-         ASSIGN_4V(span.attrStepY[attr], 0.0, 0.0, 0.0, 0.0);
-      ATTRIB_LOOP_END
-   }
-#endif
-
-   INIT_SPAN(span, GL_LINE);
-   span.end = numPixels;
-   span.interpMask = interpFlags;
-   span.arrayMask = SPAN_XY;
-
-   span.facing = swrast->PointLineFacing;
-
-
-   /*
-    * Draw
-    */
-
-   if (dx > dy) {
-      /*** X-major line ***/
-      GLint i;
-      GLint errorInc = dy+dy;
-      GLint error = errorInc-dx;
-      GLint errorDec = error-dx;
-
-      for (i = 0; i < dx; i++) {
-#ifdef DEPTH_TYPE
-         GLuint Z = FixedToDepth(span.z);
-#endif
-#ifdef PLOT
-         PLOT( x0, y0 );
-#else
-         span.array->x[i] = x0;
-         span.array->y[i] = y0;
-#endif
-         x0 += xstep;
-#ifdef DEPTH_TYPE
-         zPtr = (DEPTH_TYPE *) ((GLubyte*) zPtr + zPtrXstep);
-         span.z += span.zStep;
-#endif
-#ifdef PIXEL_ADDRESS
-         pixelPtr = (PIXEL_TYPE*) ((GLubyte*) pixelPtr + pixelXstep);
-#endif
-         if (error < 0) {
-            error += errorInc;
-         }
-         else {
-            error += errorDec;
-            y0 += ystep;
-#ifdef DEPTH_TYPE
-            zPtr = (DEPTH_TYPE *) ((GLubyte*) zPtr + zPtrYstep);
-#endif
-#ifdef PIXEL_ADDRESS
-            pixelPtr = (PIXEL_TYPE*) ((GLubyte*) pixelPtr + pixelYstep);
-#endif
-         }
-      }
-   }
-   else {
-      /*** Y-major line ***/
-      GLint i;
-      GLint errorInc = dx+dx;
-      GLint error = errorInc-dy;
-      GLint errorDec = error-dy;
-
-      for (i=0;i<dy;i++) {
-#ifdef DEPTH_TYPE
-         GLuint Z = FixedToDepth(span.z);
-#endif
-#ifdef PLOT
-         PLOT( x0, y0 );
-#else
-         span.array->x[i] = x0;
-         span.array->y[i] = y0;
-#endif
-         y0 += ystep;
-#ifdef DEPTH_TYPE
-         zPtr = (DEPTH_TYPE *) ((GLubyte*) zPtr + zPtrYstep);
-         span.z += span.zStep;
-#endif
-#ifdef PIXEL_ADDRESS
-         pixelPtr = (PIXEL_TYPE*) ((GLubyte*) pixelPtr + pixelYstep);
-#endif
-         if (error<0) {
-            error += errorInc;
-         }
-         else {
-            error += errorDec;
-            x0 += xstep;
-#ifdef DEPTH_TYPE
-            zPtr = (DEPTH_TYPE *) ((GLubyte*) zPtr + zPtrXstep);
-#endif
-#ifdef PIXEL_ADDRESS
-            pixelPtr = (PIXEL_TYPE*) ((GLubyte*) pixelPtr + pixelXstep);
-#endif
-         }
-      }
-   }
-
-#ifdef RENDER_SPAN
-   RENDER_SPAN( span );
-#endif
-
-   (void)span;
-
-}
-
-
-#undef NAME
-#undef INTERP_Z
-#undef INTERP_ATTRIBS
-#undef PIXEL_ADDRESS
-#undef PIXEL_TYPE
-#undef DEPTH_TYPE
-#undef BYTES_PER_ROW
-#undef SETUP_CODE
-#undef PLOT
-#undef CLIP_HACK
-#undef FixedToDepth
-#undef RENDER_SPAN
+/*

+ * Mesa 3-D graphics library

+ * Version:  7.0

+ *

+ * 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.

+ */

+

+

+/*

+ * Line Rasterizer Template

+ *

+ * This file is #include'd to generate custom line rasterizers.

+ *

+ * The following macros may be defined to indicate what auxillary information

+ * must be interplated along the line:

+ *    INTERP_Z        - if defined, interpolate Z values

+ *    INTERP_ATTRIBS  - if defined, interpolate attribs (texcoords, varying, etc)

+ *

+ * When one can directly address pixels in the color buffer the following

+ * macros can be defined and used to directly compute pixel addresses during

+ * rasterization (see pixelPtr):

+ *    PIXEL_TYPE          - the datatype of a pixel (GLubyte, GLushort, GLuint)

+ *    BYTES_PER_ROW       - number of bytes per row in the color buffer

+ *    PIXEL_ADDRESS(X,Y)  - returns the address of pixel at (X,Y) where

+ *                          Y==0 at bottom of screen and increases upward.

+ *

+ * Similarly, for direct depth buffer access, this type is used for depth

+ * buffer addressing:

+ *    DEPTH_TYPE          - either GLushort or GLuint

+ *

+ * Optionally, one may provide one-time setup code

+ *    SETUP_CODE    - code which is to be executed once per line

+ *

+ * To actually "plot" each pixel the PLOT macro must be defined...

+ *    PLOT(X,Y) - code to plot a pixel.  Example:

+ *                if (Z < *zPtr) {

+ *                   *zPtr = Z;

+ *                   color = pack_rgb( FixedToInt(r0), FixedToInt(g0),

+ *                                     FixedToInt(b0) );

+ *                   put_pixel( X, Y, color );

+ *                }

+ *

+ * This code was designed for the origin to be in the lower-left corner.

+ *

+ */

+

+

+static void

+NAME( struct gl_context *ctx, const SWvertex *vert0, const SWvertex *vert1 )

+{

+   const SWcontext *swrast = SWRAST_CONTEXT(ctx);

+   SWspan span;

+   GLuint interpFlags = 0;

+   GLint x0 = (GLint) vert0->attrib[FRAG_ATTRIB_WPOS][0];

+   GLint x1 = (GLint) vert1->attrib[FRAG_ATTRIB_WPOS][0];

+   GLint y0 = (GLint) vert0->attrib[FRAG_ATTRIB_WPOS][1];

+   GLint y1 = (GLint) vert1->attrib[FRAG_ATTRIB_WPOS][1];

+   GLint dx, dy;

+   GLint numPixels;

+   GLint xstep, ystep;

+#if defined(DEPTH_TYPE)

+   const GLint depthBits = ctx->DrawBuffer->Visual.depthBits;

+   const GLint fixedToDepthShift = depthBits <= 16 ? FIXED_SHIFT : 0;

+   struct gl_renderbuffer *zrb = ctx->DrawBuffer->Attachment[BUFFER_DEPTH].Renderbuffer;

+#define FixedToDepth(F)  ((F) >> fixedToDepthShift)

+   GLint zPtrXstep, zPtrYstep;

+   DEPTH_TYPE *zPtr;

+#elif defined(INTERP_Z)

+   const GLint depthBits = ctx->DrawBuffer->Visual.depthBits;

+#endif

+#ifdef PIXEL_ADDRESS

+   PIXEL_TYPE *pixelPtr;

+   GLint pixelXstep, pixelYstep;

+#endif

+

+#ifdef SETUP_CODE

+   SETUP_CODE

+#endif

+

+   (void) swrast;

+

+   /* Cull primitives with malformed coordinates.

+    */

+   {

+      GLfloat tmp = vert0->attrib[FRAG_ATTRIB_WPOS][0] + vert0->attrib[FRAG_ATTRIB_WPOS][1]

+                  + vert1->attrib[FRAG_ATTRIB_WPOS][0] + vert1->attrib[FRAG_ATTRIB_WPOS][1];

+      if (IS_INF_OR_NAN(tmp))

+	 return;

+   }

+

+   /*

+   printf("%s():\n", __FUNCTION__);

+   printf(" (%f, %f, %f) -> (%f, %f, %f)\n",

+          vert0->attrib[FRAG_ATTRIB_WPOS][0],

+          vert0->attrib[FRAG_ATTRIB_WPOS][1],

+          vert0->attrib[FRAG_ATTRIB_WPOS][2],

+          vert1->attrib[FRAG_ATTRIB_WPOS][0],

+          vert1->attrib[FRAG_ATTRIB_WPOS][1],

+          vert1->attrib[FRAG_ATTRIB_WPOS][2]);

+   printf(" (%d, %d, %d) -> (%d, %d, %d)\n",

+          vert0->color[0], vert0->color[1], vert0->color[2], 

+          vert1->color[0], vert1->color[1], vert1->color[2]);

+   printf(" (%d, %d, %d) -> (%d, %d, %d)\n",

+          vert0->specular[0], vert0->specular[1], vert0->specular[2], 

+          vert1->specular[0], vert1->specular[1], vert1->specular[2]);

+   */

+

+/*

+ * Despite being clipped to the view volume, the line's window coordinates

+ * may just lie outside the window bounds.  That is, if the legal window

+ * coordinates are [0,W-1][0,H-1], it's possible for x==W and/or y==H.

+ * This quick and dirty code nudges the endpoints inside the window if

+ * necessary.

+ */

+#ifdef CLIP_HACK

+   {

+      GLint w = ctx->DrawBuffer->Width;

+      GLint h = ctx->DrawBuffer->Height;

+      if ((x0==w) | (x1==w)) {

+         if ((x0==w) & (x1==w))

+           return;

+         x0 -= x0==w;

+         x1 -= x1==w;

+      }

+      if ((y0==h) | (y1==h)) {

+         if ((y0==h) & (y1==h))

+           return;

+         y0 -= y0==h;

+         y1 -= y1==h;

+      }

+   }

+#endif

+

+   dx = x1 - x0;

+   dy = y1 - y0;

+   if (dx == 0 && dy == 0)

+      return;

+

+   /*

+   printf("%s %d,%d  %g %g %g %g  %g %g %g %g\n", __FUNCTION__, dx, dy,

+          vert0->attrib[FRAG_ATTRIB_COL1][0],

+          vert0->attrib[FRAG_ATTRIB_COL1][1],

+          vert0->attrib[FRAG_ATTRIB_COL1][2],

+          vert0->attrib[FRAG_ATTRIB_COL1][3],

+          vert1->attrib[FRAG_ATTRIB_COL1][0],

+          vert1->attrib[FRAG_ATTRIB_COL1][1],

+          vert1->attrib[FRAG_ATTRIB_COL1][2],

+          vert1->attrib[FRAG_ATTRIB_COL1][3]);

+   */

+

+#ifdef DEPTH_TYPE

+   zPtr = (DEPTH_TYPE *) zrb->GetPointer(ctx, zrb, x0, y0);

+#endif

+#ifdef PIXEL_ADDRESS

+   pixelPtr = (PIXEL_TYPE *) PIXEL_ADDRESS(x0,y0);

+#endif

+

+   if (dx<0) {

+      dx = -dx;   /* make positive */

+      xstep = -1;

+#ifdef DEPTH_TYPE

+      zPtrXstep = -((GLint)sizeof(DEPTH_TYPE));

+#endif

+#ifdef PIXEL_ADDRESS

+      pixelXstep = -((GLint)sizeof(PIXEL_TYPE));

+#endif

+   }

+   else {

+      xstep = 1;

+#ifdef DEPTH_TYPE

+      zPtrXstep = ((GLint)sizeof(DEPTH_TYPE));

+#endif

+#ifdef PIXEL_ADDRESS

+      pixelXstep = ((GLint)sizeof(PIXEL_TYPE));

+#endif

+   }

+

+   if (dy<0) {

+      dy = -dy;   /* make positive */

+      ystep = -1;

+#ifdef DEPTH_TYPE

+      zPtrYstep = -((GLint) (ctx->DrawBuffer->Width * sizeof(DEPTH_TYPE)));

+#endif

+#ifdef PIXEL_ADDRESS

+      pixelYstep = BYTES_PER_ROW;

+#endif

+   }

+   else {

+      ystep = 1;

+#ifdef DEPTH_TYPE

+      zPtrYstep = (GLint) (ctx->DrawBuffer->Width * sizeof(DEPTH_TYPE));

+#endif

+#ifdef PIXEL_ADDRESS

+      pixelYstep = -(BYTES_PER_ROW);

+#endif

+   }

+

+   ASSERT(dx >= 0);

+   ASSERT(dy >= 0);

+

+   numPixels = MAX2(dx, dy);

+

+   /*

+    * Span setup: compute start and step values for all interpolated values.

+    */

+   interpFlags |= SPAN_RGBA;

+   if (ctx->Light.ShadeModel == GL_SMOOTH) {

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

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

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

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

+      span.redStep   = (ChanToFixed(vert1->color[0]) - span.red  ) / numPixels;

+      span.greenStep = (ChanToFixed(vert1->color[1]) - span.green) / numPixels;

+      span.blueStep  = (ChanToFixed(vert1->color[2]) - span.blue ) / numPixels;

+      span.alphaStep = (ChanToFixed(vert1->color[3]) - span.alpha) / numPixels;

+   }

+   else {

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

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

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

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

+      span.redStep   = 0;

+      span.greenStep = 0;

+      span.blueStep  = 0;

+      span.alphaStep = 0;

+   }

+#if defined(INTERP_Z) || defined(DEPTH_TYPE)

+   interpFlags |= SPAN_Z;

+   {

+      if (depthBits <= 16) {

+         span.z = FloatToFixed(vert0->attrib[FRAG_ATTRIB_WPOS][2]) + FIXED_HALF;

+         span.zStep = FloatToFixed(  vert1->attrib[FRAG_ATTRIB_WPOS][2]

+                                   - vert0->attrib[FRAG_ATTRIB_WPOS][2]) / numPixels;

+      }

+      else {

+         /* don't use fixed point */

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

+         span.zStep = (GLint) ((  vert1->attrib[FRAG_ATTRIB_WPOS][2]

+                                - vert0->attrib[FRAG_ATTRIB_WPOS][2]) / numPixels);

+      }

+   }

+#endif

+#if defined(INTERP_ATTRIBS)

+   {

+      const GLfloat invLen = 1.0F / numPixels;

+      const GLfloat invw0 = vert0->attrib[FRAG_ATTRIB_WPOS][3];

+      const GLfloat invw1 = vert1->attrib[FRAG_ATTRIB_WPOS][3];

+

+      span.attrStart[FRAG_ATTRIB_WPOS][3] = invw0;

+      span.attrStepX[FRAG_ATTRIB_WPOS][3] = (invw1 - invw0) * invLen;

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

+

+      ATTRIB_LOOP_BEGIN

+         if (swrast->_InterpMode[attr] == GL_FLAT) {

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

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

+         }

+         else {

+            GLuint c;

+            for (c = 0; c < 4; c++) {

+               float da;

+               span.attrStart[attr][c] = invw0 * vert0->attrib[attr][c];

+               da = (invw1 * vert1->attrib[attr][c]) - span.attrStart[attr][c];

+               span.attrStepX[attr][c] = da * invLen;

+            }

+         }

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

+      ATTRIB_LOOP_END

+   }

+#endif

+

+   INIT_SPAN(span, GL_LINE);

+   span.end = numPixels;

+   span.interpMask = interpFlags;

+   span.arrayMask = SPAN_XY;

+

+   span.facing = swrast->PointLineFacing;

+

+

+   /*

+    * Draw

+    */

+

+   if (dx > dy) {

+      /*** X-major line ***/

+      GLint i;

+      GLint errorInc = dy+dy;

+      GLint error = errorInc-dx;

+      GLint errorDec = error-dx;

+

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

+#ifdef DEPTH_TYPE

+         GLuint Z = FixedToDepth(span.z);

+#endif

+#ifdef PLOT

+         PLOT( x0, y0 );

+#else

+         span.array->x[i] = x0;

+         span.array->y[i] = y0;

+#endif

+         x0 += xstep;

+#ifdef DEPTH_TYPE

+         zPtr = (DEPTH_TYPE *) ((GLubyte*) zPtr + zPtrXstep);

+         span.z += span.zStep;

+#endif

+#ifdef PIXEL_ADDRESS

+         pixelPtr = (PIXEL_TYPE*) ((GLubyte*) pixelPtr + pixelXstep);

+#endif

+         if (error < 0) {

+            error += errorInc;

+         }

+         else {

+            error += errorDec;

+            y0 += ystep;

+#ifdef DEPTH_TYPE

+            zPtr = (DEPTH_TYPE *) ((GLubyte*) zPtr + zPtrYstep);

+#endif

+#ifdef PIXEL_ADDRESS

+            pixelPtr = (PIXEL_TYPE*) ((GLubyte*) pixelPtr + pixelYstep);

+#endif

+         }

+      }

+   }

+   else {

+      /*** Y-major line ***/

+      GLint i;

+      GLint errorInc = dx+dx;

+      GLint error = errorInc-dy;

+      GLint errorDec = error-dy;

+

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

+#ifdef DEPTH_TYPE

+         GLuint Z = FixedToDepth(span.z);

+#endif

+#ifdef PLOT

+         PLOT( x0, y0 );

+#else

+         span.array->x[i] = x0;

+         span.array->y[i] = y0;

+#endif

+         y0 += ystep;

+#ifdef DEPTH_TYPE

+         zPtr = (DEPTH_TYPE *) ((GLubyte*) zPtr + zPtrYstep);

+         span.z += span.zStep;

+#endif

+#ifdef PIXEL_ADDRESS

+         pixelPtr = (PIXEL_TYPE*) ((GLubyte*) pixelPtr + pixelYstep);

+#endif

+         if (error<0) {

+            error += errorInc;

+         }

+         else {

+            error += errorDec;

+            x0 += xstep;

+#ifdef DEPTH_TYPE

+            zPtr = (DEPTH_TYPE *) ((GLubyte*) zPtr + zPtrXstep);

+#endif

+#ifdef PIXEL_ADDRESS

+            pixelPtr = (PIXEL_TYPE*) ((GLubyte*) pixelPtr + pixelXstep);

+#endif

+         }

+      }

+   }

+

+#ifdef RENDER_SPAN

+   RENDER_SPAN( span );

+#endif

+

+   (void)span;

+

+}

+

+

+#undef NAME

+#undef INTERP_Z

+#undef INTERP_ATTRIBS

+#undef PIXEL_ADDRESS

+#undef PIXEL_TYPE

+#undef DEPTH_TYPE

+#undef BYTES_PER_ROW

+#undef SETUP_CODE

+#undef PLOT

+#undef CLIP_HACK

+#undef FixedToDepth

+#undef RENDER_SPAN

diff --git a/mesalib/src/mesa/swrast/s_logic.c b/mesalib/src/mesa/swrast/s_logic.c
index c36a16e66..2f0c0ea7c 100644
--- a/mesalib/src/mesa/swrast/s_logic.c
+++ b/mesalib/src/mesa/swrast/s_logic.c
@@ -1,219 +1,219 @@
-/*
- * Mesa 3-D graphics library
- * Version:  6.5.2
- *
- * Copyright (C) 1999-2006  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/context.h"
-#include "main/imports.h"
-#include "main/macros.h"
-
-#include "s_context.h"
-#include "s_logic.h"
-#include "s_span.h"
-
-
-/**
- * We do all logic ops on 4-byte GLuints.
- * Depending on bytes per pixel, the mask array elements correspond to
- * 1, 2 or 4 GLuints.
- */
-#define LOGIC_OP_LOOP(MODE, MASKSTRIDE)		\
-do {						\
-   GLuint i;					\
-   switch (MODE) {				\
-      case GL_CLEAR:				\
-         for (i = 0; i < n; i++) {		\
-	    if (mask[i / MASKSTRIDE]) {		\
-	       src[i] = 0;			\
-	    }					\
-	 }					\
-	 break;					\
-      case GL_SET:				\
-         for (i = 0; i < n; i++) {		\
-	    if (mask[i / MASKSTRIDE]) {		\
-	       src[i] = ~0;			\
-	    }					\
-	 }					\
-	 break;					\
-      case GL_COPY:				\
-	 /* do nothing */			\
-	 break;					\
-      case GL_COPY_INVERTED:			\
-         for (i = 0; i < n; i++) {		\
-	    if (mask[i / MASKSTRIDE]) {		\
-	       src[i] = ~src[i];		\
-	    }					\
-	 }					\
-	 break;					\
-      case GL_NOOP:				\
-         for (i = 0; i < n; i++) {		\
-	    if (mask[i / MASKSTRIDE]) {		\
-	       src[i] = dest[i];		\
-	    }					\
-	 }					\
-	 break;					\
-      case GL_INVERT:				\
-         for (i = 0; i < n; i++) {		\
-	    if (mask[i / MASKSTRIDE]) {		\
-	       src[i] = ~dest[i];		\
-	    }					\
-	 }					\
-	 break;					\
-      case GL_AND:				\
-         for (i = 0; i < n; i++) {		\
-	    if (mask[i / MASKSTRIDE]) {		\
-	       src[i] &= dest[i];		\
-	    }					\
-	 }					\
-	 break;					\
-      case GL_NAND:				\
-         for (i = 0; i < n; i++) {		\
-	    if (mask[i / MASKSTRIDE]) {		\
-	       src[i] = ~(src[i] & dest[i]);	\
-	    }					\
-	 }					\
-	 break;					\
-      case GL_OR:				\
-         for (i = 0; i < n; i++) {		\
-	    if (mask[i / MASKSTRIDE]) {		\
-	       src[i] |= dest[i];		\
-	    }					\
-	 }					\
-	 break;					\
-      case GL_NOR:				\
-         for (i = 0; i < n; i++) {		\
-	    if (mask[i / MASKSTRIDE]) {		\
-	       src[i] = ~(src[i] | dest[i]);	\
-	    }					\
-	 }					\
-	 break;					\
-      case GL_XOR:				\
-         for (i = 0; i < n; i++) {		\
-	    if (mask[i / MASKSTRIDE]) {		\
-	       src[i] ^= dest[i];		\
-	    }					\
-	 }					\
-	 break;					\
-      case GL_EQUIV:				\
-         for (i = 0; i < n; i++) {		\
-	    if (mask[i / MASKSTRIDE]) {		\
-	       src[i] = ~(src[i] ^ dest[i]);	\
-	    }					\
-	 }					\
-	 break;					\
-      case GL_AND_REVERSE:			\
-         for (i = 0; i < n; i++) {		\
-	    if (mask[i / MASKSTRIDE]) {		\
-	       src[i] = src[i] & ~dest[i];	\
-	    }					\
-	 }					\
-	 break;					\
-      case GL_AND_INVERTED:			\
-         for (i = 0; i < n; i++) {		\
-	    if (mask[i / MASKSTRIDE]) {		\
-	       src[i] = ~src[i] & dest[i];	\
-	    }					\
-	 }					\
-	 break;					\
-      case GL_OR_REVERSE:			\
-         for (i = 0; i < n; i++) {		\
-	    if (mask[i / MASKSTRIDE]) {		\
-	       src[i] = src[i] | ~dest[i];	\
-	    }					\
-	 }					\
-	 break;					\
-      case GL_OR_INVERTED:			\
-         for (i = 0; i < n; i++) {		\
-	    if (mask[i / MASKSTRIDE]) {		\
-	       src[i] = ~src[i] | dest[i];	\
-	    }					\
-	 }					\
-	 break;					\
-      default:					\
-	 _mesa_problem(ctx, "bad logicop mode");\
-   }						\
-} while (0)
-
-
-
-static INLINE void
-logicop_uint1(GLcontext *ctx, GLuint n, GLuint src[], const GLuint dest[],
-              const GLubyte mask[])
-{
-   LOGIC_OP_LOOP(ctx->Color.LogicOp, 1);
-}
-
-
-static INLINE void
-logicop_uint2(GLcontext *ctx, GLuint n, GLuint src[], const GLuint dest[],
-              const GLubyte mask[])
-{
-   LOGIC_OP_LOOP(ctx->Color.LogicOp, 2);
-}
-
-
-static INLINE void
-logicop_uint4(GLcontext *ctx, GLuint n, GLuint src[], const GLuint dest[],
-              const GLubyte mask[])
-{
-   LOGIC_OP_LOOP(ctx->Color.LogicOp, 4);
-}
-
-
-
-/**
- * Apply the current logic operator to a span of RGBA pixels.
- * We can handle horizontal runs of pixels (spans) or arrays of x/y
- * pixel coordinates.
- */
-void
-_swrast_logicop_rgba_span(GLcontext *ctx, struct gl_renderbuffer *rb,
-                          SWspan *span)
-{
-   void *rbPixels;
-
-   ASSERT(span->end < MAX_WIDTH);
-   ASSERT(span->arrayMask & SPAN_RGBA);
-   ASSERT(rb->DataType == span->array->ChanType);
-
-   rbPixels = _swrast_get_dest_rgba(ctx, rb, span);
-
-   if (span->array->ChanType == GL_UNSIGNED_BYTE) {
-      /* treat 4*GLubyte as GLuint */
-      logicop_uint1(ctx, span->end,
-                    (GLuint *) span->array->rgba8,
-                    (const GLuint *) rbPixels, span->array->mask);
-   }
-   else if (span->array->ChanType == GL_UNSIGNED_SHORT) {
-      /* treat 2*GLushort as GLuint */
-      logicop_uint2(ctx, 2 * span->end,
-                    (GLuint *) span->array->rgba16,
-                    (const GLuint *) rbPixels, span->array->mask);
-   }
-   else {
-      logicop_uint4(ctx, 4 * span->end,
-                    (GLuint *) span->array->attribs[FRAG_ATTRIB_COL0],
-                    (const GLuint *) rbPixels, span->array->mask);
-   }
-}
+/*

+ * Mesa 3-D graphics library

+ * Version:  6.5.2

+ *

+ * Copyright (C) 1999-2006  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/context.h"

+#include "main/imports.h"

+#include "main/macros.h"

+

+#include "s_context.h"

+#include "s_logic.h"

+#include "s_span.h"

+

+

+/**

+ * We do all logic ops on 4-byte GLuints.

+ * Depending on bytes per pixel, the mask array elements correspond to

+ * 1, 2 or 4 GLuints.

+ */

+#define LOGIC_OP_LOOP(MODE, MASKSTRIDE)		\

+do {						\

+   GLuint i;					\

+   switch (MODE) {				\

+      case GL_CLEAR:				\

+         for (i = 0; i < n; i++) {		\

+	    if (mask[i / MASKSTRIDE]) {		\

+	       src[i] = 0;			\

+	    }					\

+	 }					\

+	 break;					\

+      case GL_SET:				\

+         for (i = 0; i < n; i++) {		\

+	    if (mask[i / MASKSTRIDE]) {		\

+	       src[i] = ~0;			\

+	    }					\

+	 }					\

+	 break;					\

+      case GL_COPY:				\

+	 /* do nothing */			\

+	 break;					\

+      case GL_COPY_INVERTED:			\

+         for (i = 0; i < n; i++) {		\

+	    if (mask[i / MASKSTRIDE]) {		\

+	       src[i] = ~src[i];		\

+	    }					\

+	 }					\

+	 break;					\

+      case GL_NOOP:				\

+         for (i = 0; i < n; i++) {		\

+	    if (mask[i / MASKSTRIDE]) {		\

+	       src[i] = dest[i];		\

+	    }					\

+	 }					\

+	 break;					\

+      case GL_INVERT:				\

+         for (i = 0; i < n; i++) {		\

+	    if (mask[i / MASKSTRIDE]) {		\

+	       src[i] = ~dest[i];		\

+	    }					\

+	 }					\

+	 break;					\

+      case GL_AND:				\

+         for (i = 0; i < n; i++) {		\

+	    if (mask[i / MASKSTRIDE]) {		\

+	       src[i] &= dest[i];		\

+	    }					\

+	 }					\

+	 break;					\

+      case GL_NAND:				\

+         for (i = 0; i < n; i++) {		\

+	    if (mask[i / MASKSTRIDE]) {		\

+	       src[i] = ~(src[i] & dest[i]);	\

+	    }					\

+	 }					\

+	 break;					\

+      case GL_OR:				\

+         for (i = 0; i < n; i++) {		\

+	    if (mask[i / MASKSTRIDE]) {		\

+	       src[i] |= dest[i];		\

+	    }					\

+	 }					\

+	 break;					\

+      case GL_NOR:				\

+         for (i = 0; i < n; i++) {		\

+	    if (mask[i / MASKSTRIDE]) {		\

+	       src[i] = ~(src[i] | dest[i]);	\

+	    }					\

+	 }					\

+	 break;					\

+      case GL_XOR:				\

+         for (i = 0; i < n; i++) {		\

+	    if (mask[i / MASKSTRIDE]) {		\

+	       src[i] ^= dest[i];		\

+	    }					\

+	 }					\

+	 break;					\

+      case GL_EQUIV:				\

+         for (i = 0; i < n; i++) {		\

+	    if (mask[i / MASKSTRIDE]) {		\

+	       src[i] = ~(src[i] ^ dest[i]);	\

+	    }					\

+	 }					\

+	 break;					\

+      case GL_AND_REVERSE:			\

+         for (i = 0; i < n; i++) {		\

+	    if (mask[i / MASKSTRIDE]) {		\

+	       src[i] = src[i] & ~dest[i];	\

+	    }					\

+	 }					\

+	 break;					\

+      case GL_AND_INVERTED:			\

+         for (i = 0; i < n; i++) {		\

+	    if (mask[i / MASKSTRIDE]) {		\

+	       src[i] = ~src[i] & dest[i];	\

+	    }					\

+	 }					\

+	 break;					\

+      case GL_OR_REVERSE:			\

+         for (i = 0; i < n; i++) {		\

+	    if (mask[i / MASKSTRIDE]) {		\

+	       src[i] = src[i] | ~dest[i];	\

+	    }					\

+	 }					\

+	 break;					\

+      case GL_OR_INVERTED:			\

+         for (i = 0; i < n; i++) {		\

+	    if (mask[i / MASKSTRIDE]) {		\

+	       src[i] = ~src[i] | dest[i];	\

+	    }					\

+	 }					\

+	 break;					\

+      default:					\

+	 _mesa_problem(ctx, "bad logicop mode");\

+   }						\

+} while (0)

+

+

+

+static INLINE void

+logicop_uint1(struct gl_context *ctx, GLuint n, GLuint src[], const GLuint dest[],

+              const GLubyte mask[])

+{

+   LOGIC_OP_LOOP(ctx->Color.LogicOp, 1);

+}

+

+

+static INLINE void

+logicop_uint2(struct gl_context *ctx, GLuint n, GLuint src[], const GLuint dest[],

+              const GLubyte mask[])

+{

+   LOGIC_OP_LOOP(ctx->Color.LogicOp, 2);

+}

+

+

+static INLINE void

+logicop_uint4(struct gl_context *ctx, GLuint n, GLuint src[], const GLuint dest[],

+              const GLubyte mask[])

+{

+   LOGIC_OP_LOOP(ctx->Color.LogicOp, 4);

+}

+

+

+

+/**

+ * Apply the current logic operator to a span of RGBA pixels.

+ * We can handle horizontal runs of pixels (spans) or arrays of x/y

+ * pixel coordinates.

+ */

+void

+_swrast_logicop_rgba_span(struct gl_context *ctx, struct gl_renderbuffer *rb,

+                          SWspan *span)

+{

+   void *rbPixels;

+

+   ASSERT(span->end < MAX_WIDTH);

+   ASSERT(span->arrayMask & SPAN_RGBA);

+   ASSERT(rb->DataType == span->array->ChanType);

+

+   rbPixels = _swrast_get_dest_rgba(ctx, rb, span);

+

+   if (span->array->ChanType == GL_UNSIGNED_BYTE) {

+      /* treat 4*GLubyte as GLuint */

+      logicop_uint1(ctx, span->end,

+                    (GLuint *) span->array->rgba8,

+                    (const GLuint *) rbPixels, span->array->mask);

+   }

+   else if (span->array->ChanType == GL_UNSIGNED_SHORT) {

+      /* treat 2*GLushort as GLuint */

+      logicop_uint2(ctx, 2 * span->end,

+                    (GLuint *) span->array->rgba16,

+                    (const GLuint *) rbPixels, span->array->mask);

+   }

+   else {

+      logicop_uint4(ctx, 4 * span->end,

+                    (GLuint *) span->array->attribs[FRAG_ATTRIB_COL0],

+                    (const GLuint *) rbPixels, span->array->mask);

+   }

+}

diff --git a/mesalib/src/mesa/swrast/s_logic.h b/mesalib/src/mesa/swrast/s_logic.h
index d60951334..39713b990 100644
--- a/mesalib/src/mesa/swrast/s_logic.h
+++ b/mesalib/src/mesa/swrast/s_logic.h
@@ -1,38 +1,40 @@
-/*
- * Mesa 3-D graphics library
- * Version:  6.5.2
- *
- * Copyright (C) 1999-2006  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.
- */
-
-
-#ifndef S_LOGIC_H
-#define S_LOGIC_H
-
-
-#include "main/mtypes.h"
-#include "s_span.h"
-
-extern void
-_swrast_logicop_rgba_span(GLcontext *ctx, struct gl_renderbuffer *rb,
-                          SWspan *span);
-
-
-#endif
+/*

+ * Mesa 3-D graphics library

+ * Version:  6.5.2

+ *

+ * Copyright (C) 1999-2006  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.

+ */

+

+

+#ifndef S_LOGIC_H

+#define S_LOGIC_H

+

+

+#include "s_span.h"

+

+struct gl_context;

+struct gl_renderbuffer;

+

+extern void

+_swrast_logicop_rgba_span(struct gl_context *ctx, struct gl_renderbuffer *rb,

+                          SWspan *span);

+

+

+#endif

diff --git a/mesalib/src/mesa/swrast/s_masking.c b/mesalib/src/mesa/swrast/s_masking.c
index e38d90f19..6ee29d4b3 100644
--- a/mesalib/src/mesa/swrast/s_masking.c
+++ b/mesalib/src/mesa/swrast/s_masking.c
@@ -1,103 +1,103 @@
-/*
- * Mesa 3-D graphics library
- * Version:  6.5.2
- *
- * Copyright (C) 1999-2006  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.
- */
-
-
-/*
- * Implement the effect of glColorMask and glIndexMask in software.
- */
-
-
-#include "main/glheader.h"
-#include "main/macros.h"
-
-#include "s_context.h"
-#include "s_masking.h"
-#include "s_span.h"
-
-
-/**
- * Apply the color mask to a span of rgba values.
- */
-void
-_swrast_mask_rgba_span(GLcontext *ctx, struct gl_renderbuffer *rb,
-                       SWspan *span, GLuint buf)
-{
-   const GLuint n = span->end;
-   void *rbPixels;
-
-   ASSERT(n < MAX_WIDTH);
-   ASSERT(span->arrayMask & SPAN_RGBA);
-   ASSERT(rb->DataType == span->array->ChanType);
-
-   rbPixels = _swrast_get_dest_rgba(ctx, rb, span);
-
-   /*
-    * Do component masking.
-    * Note that we're not using span->array->mask[] here.  We could...
-    */
-   if (span->array->ChanType == GL_UNSIGNED_BYTE) {
-      /* treat 4xGLubyte as 1xGLuint */
-      const GLuint srcMask = *((GLuint *) ctx->Color.ColorMask[buf]);
-      const GLuint dstMask = ~srcMask;
-      const GLuint *dst = (const GLuint *) rbPixels;
-      GLuint *src = (GLuint *) span->array->rgba8;
-      GLuint i;
-      for (i = 0; i < n; i++) {
-         src[i] = (src[i] & srcMask) | (dst[i] & dstMask);
-      }
-   }
-   else if (span->array->ChanType == GL_UNSIGNED_SHORT) {
-      /* 2-byte components */
-      /* XXX try to use 64-bit arithmetic someday */
-      const GLushort rMask = ctx->Color.ColorMask[buf][RCOMP] ? 0xffff : 0x0;
-      const GLushort gMask = ctx->Color.ColorMask[buf][GCOMP] ? 0xffff : 0x0;
-      const GLushort bMask = ctx->Color.ColorMask[buf][BCOMP] ? 0xffff : 0x0;
-      const GLushort aMask = ctx->Color.ColorMask[buf][ACOMP] ? 0xffff : 0x0;
-      const GLushort (*dst)[4] = (const GLushort (*)[4]) rbPixels;
-      GLushort (*src)[4] = span->array->rgba16;
-      GLuint i;
-      for (i = 0; i < n; i++) {
-         src[i][RCOMP] = (src[i][RCOMP] & rMask) | (dst[i][RCOMP] & ~rMask);
-         src[i][GCOMP] = (src[i][GCOMP] & gMask) | (dst[i][GCOMP] & ~gMask);
-         src[i][BCOMP] = (src[i][BCOMP] & bMask) | (dst[i][BCOMP] & ~bMask);
-         src[i][ACOMP] = (src[i][ACOMP] & aMask) | (dst[i][ACOMP] & ~aMask);
-      }
-   }
-   else {
-      /* 4-byte components */
-      const GLuint rMask = ctx->Color.ColorMask[buf][RCOMP] ? ~0x0 : 0x0;
-      const GLuint gMask = ctx->Color.ColorMask[buf][GCOMP] ? ~0x0 : 0x0;
-      const GLuint bMask = ctx->Color.ColorMask[buf][BCOMP] ? ~0x0 : 0x0;
-      const GLuint aMask = ctx->Color.ColorMask[buf][ACOMP] ? ~0x0 : 0x0;
-      const GLuint (*dst)[4] = (const GLuint (*)[4]) rbPixels;
-      GLuint (*src)[4] = (GLuint (*)[4]) span->array->attribs[FRAG_ATTRIB_COL0];
-      GLuint i;
-      for (i = 0; i < n; i++) {
-         src[i][RCOMP] = (src[i][RCOMP] & rMask) | (dst[i][RCOMP] & ~rMask);
-         src[i][GCOMP] = (src[i][GCOMP] & gMask) | (dst[i][GCOMP] & ~gMask);
-         src[i][BCOMP] = (src[i][BCOMP] & bMask) | (dst[i][BCOMP] & ~bMask);
-         src[i][ACOMP] = (src[i][ACOMP] & aMask) | (dst[i][ACOMP] & ~aMask);
-      }
-   }
-}
+/*

+ * Mesa 3-D graphics library

+ * Version:  6.5.2

+ *

+ * Copyright (C) 1999-2006  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.

+ */

+

+

+/*

+ * Implement the effect of glColorMask and glIndexMask in software.

+ */

+

+

+#include "main/glheader.h"

+#include "main/macros.h"

+

+#include "s_context.h"

+#include "s_masking.h"

+#include "s_span.h"

+

+

+/**

+ * Apply the color mask to a span of rgba values.

+ */

+void

+_swrast_mask_rgba_span(struct gl_context *ctx, struct gl_renderbuffer *rb,

+                       SWspan *span, GLuint buf)

+{

+   const GLuint n = span->end;

+   void *rbPixels;

+

+   ASSERT(n < MAX_WIDTH);

+   ASSERT(span->arrayMask & SPAN_RGBA);

+   ASSERT(rb->DataType == span->array->ChanType);

+

+   rbPixels = _swrast_get_dest_rgba(ctx, rb, span);

+

+   /*

+    * Do component masking.

+    * Note that we're not using span->array->mask[] here.  We could...

+    */

+   if (span->array->ChanType == GL_UNSIGNED_BYTE) {

+      /* treat 4xGLubyte as 1xGLuint */

+      const GLuint srcMask = *((GLuint *) ctx->Color.ColorMask[buf]);

+      const GLuint dstMask = ~srcMask;

+      const GLuint *dst = (const GLuint *) rbPixels;

+      GLuint *src = (GLuint *) span->array->rgba8;

+      GLuint i;

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

+         src[i] = (src[i] & srcMask) | (dst[i] & dstMask);

+      }

+   }

+   else if (span->array->ChanType == GL_UNSIGNED_SHORT) {

+      /* 2-byte components */

+      /* XXX try to use 64-bit arithmetic someday */

+      const GLushort rMask = ctx->Color.ColorMask[buf][RCOMP] ? 0xffff : 0x0;

+      const GLushort gMask = ctx->Color.ColorMask[buf][GCOMP] ? 0xffff : 0x0;

+      const GLushort bMask = ctx->Color.ColorMask[buf][BCOMP] ? 0xffff : 0x0;

+      const GLushort aMask = ctx->Color.ColorMask[buf][ACOMP] ? 0xffff : 0x0;

+      const GLushort (*dst)[4] = (const GLushort (*)[4]) rbPixels;

+      GLushort (*src)[4] = span->array->rgba16;

+      GLuint i;

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

+         src[i][RCOMP] = (src[i][RCOMP] & rMask) | (dst[i][RCOMP] & ~rMask);

+         src[i][GCOMP] = (src[i][GCOMP] & gMask) | (dst[i][GCOMP] & ~gMask);

+         src[i][BCOMP] = (src[i][BCOMP] & bMask) | (dst[i][BCOMP] & ~bMask);

+         src[i][ACOMP] = (src[i][ACOMP] & aMask) | (dst[i][ACOMP] & ~aMask);

+      }

+   }

+   else {

+      /* 4-byte components */

+      const GLuint rMask = ctx->Color.ColorMask[buf][RCOMP] ? ~0x0 : 0x0;

+      const GLuint gMask = ctx->Color.ColorMask[buf][GCOMP] ? ~0x0 : 0x0;

+      const GLuint bMask = ctx->Color.ColorMask[buf][BCOMP] ? ~0x0 : 0x0;

+      const GLuint aMask = ctx->Color.ColorMask[buf][ACOMP] ? ~0x0 : 0x0;

+      const GLuint (*dst)[4] = (const GLuint (*)[4]) rbPixels;

+      GLuint (*src)[4] = (GLuint (*)[4]) span->array->attribs[FRAG_ATTRIB_COL0];

+      GLuint i;

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

+         src[i][RCOMP] = (src[i][RCOMP] & rMask) | (dst[i][RCOMP] & ~rMask);

+         src[i][GCOMP] = (src[i][GCOMP] & gMask) | (dst[i][GCOMP] & ~gMask);

+         src[i][BCOMP] = (src[i][BCOMP] & bMask) | (dst[i][BCOMP] & ~bMask);

+         src[i][ACOMP] = (src[i][ACOMP] & aMask) | (dst[i][ACOMP] & ~aMask);

+      }

+   }

+}

diff --git a/mesalib/src/mesa/swrast/s_masking.h b/mesalib/src/mesa/swrast/s_masking.h
index cb000da0f..7ab02cc7a 100644
--- a/mesalib/src/mesa/swrast/s_masking.h
+++ b/mesalib/src/mesa/swrast/s_masking.h
@@ -1,38 +1,41 @@
-/*
- * Mesa 3-D graphics library
- * Version:  6.5.2
- *
- * Copyright (C) 1999-2006  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.
- */
-
-
-#ifndef S_MASKING_H
-#define S_MASKING_H
-
-
-#include "main/mtypes.h"
-#include "s_span.h"
-
-
-extern void
-_swrast_mask_rgba_span(GLcontext *ctx, struct gl_renderbuffer *rb,
-                       SWspan *span, GLuint buf);
-
-#endif
+/*

+ * Mesa 3-D graphics library

+ * Version:  6.5.2

+ *

+ * Copyright (C) 1999-2006  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.

+ */

+

+

+#ifndef S_MASKING_H

+#define S_MASKING_H

+

+

+#include "main/glheader.h"

+#include "s_span.h"

+

+struct gl_context;

+struct gl_renderbuffer;

+

+

+extern void

+_swrast_mask_rgba_span(struct gl_context *ctx, struct gl_renderbuffer *rb,

+                       SWspan *span, GLuint buf);

+

+#endif

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;

+   }

+}

diff --git a/mesalib/src/mesa/swrast/s_points.h b/mesalib/src/mesa/swrast/s_points.h
index 9e39c601e..d99470bfe 100644
--- a/mesalib/src/mesa/swrast/s_points.h
+++ b/mesalib/src/mesa/swrast/s_points.h
@@ -1,39 +1,39 @@
-
-/*
- * Mesa 3-D graphics library
- * Version:  3.5
- *
- * Copyright (C) 1999-2001  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.
- */
-
-
-#ifndef S_POINTS_H
-#define S_POINTS_H
-
-#include "swrast.h"
-
-extern void
-_swrast_choose_point( GLcontext *ctx );
-
-extern void
-_swrast_add_spec_terms_point( GLcontext *ctx,
-			      const SWvertex *v0 );
-
-#endif
+

+/*

+ * Mesa 3-D graphics library

+ * Version:  3.5

+ *

+ * Copyright (C) 1999-2001  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.

+ */

+

+

+#ifndef S_POINTS_H

+#define S_POINTS_H

+

+#include "swrast.h"

+

+extern void

+_swrast_choose_point( struct gl_context *ctx );

+

+extern void

+_swrast_add_spec_terms_point( struct gl_context *ctx,

+			      const SWvertex *v0 );

+

+#endif

diff --git a/mesalib/src/mesa/swrast/s_readpix.c b/mesalib/src/mesa/swrast/s_readpix.c
index 1de481248..61399010b 100644
--- a/mesalib/src/mesa/swrast/s_readpix.c
+++ b/mesalib/src/mesa/swrast/s_readpix.c
@@ -1,578 +1,508 @@
-/*
- * Mesa 3-D graphics library
- * Version:  7.0.3
- *
- * 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/bufferobj.h"
-#include "main/colormac.h"
-#include "main/convolve.h"
-#include "main/feedback.h"
-#include "main/formats.h"
-#include "main/image.h"
-#include "main/macros.h"
-#include "main/imports.h"
-#include "main/state.h"
-
-#include "s_context.h"
-#include "s_depth.h"
-#include "s_span.h"
-#include "s_stencil.h"
-
-
-/**
- * Read pixels for format=GL_DEPTH_COMPONENT.
- */
-static void
-read_depth_pixels( GLcontext *ctx,
-                   GLint x, GLint y,
-                   GLsizei width, GLsizei height,
-                   GLenum type, GLvoid *pixels,
-                   const struct gl_pixelstore_attrib *packing )
-{
-   struct gl_framebuffer *fb = ctx->ReadBuffer;
-   struct gl_renderbuffer *rb = fb->_DepthBuffer;
-   const GLboolean biasOrScale
-      = ctx->Pixel.DepthScale != 1.0 || ctx->Pixel.DepthBias != 0.0;
-
-   if (!rb)
-      return;
-
-   /* clipping should have been done already */
-   ASSERT(x >= 0);
-   ASSERT(y >= 0);
-   ASSERT(x + width <= (GLint) rb->Width);
-   ASSERT(y + height <= (GLint) rb->Height);
-   /* width should never be > MAX_WIDTH since we did clipping earlier */
-   ASSERT(width <= MAX_WIDTH);
-
-   if (type == GL_UNSIGNED_SHORT && fb->Visual.depthBits == 16
-       && !biasOrScale && !packing->SwapBytes) {
-      /* Special case: directly read 16-bit unsigned depth values. */
-      GLint j;
-      ASSERT(rb->Format == MESA_FORMAT_Z16);
-      ASSERT(rb->DataType == GL_UNSIGNED_SHORT);
-      for (j = 0; j < height; j++, y++) {
-         void *dest =_mesa_image_address2d(packing, pixels, width, height,
-                                           GL_DEPTH_COMPONENT, type, j, 0);
-         rb->GetRow(ctx, rb, width, x, y, dest);
-      }
-   }
-   else if (type == GL_UNSIGNED_INT && fb->Visual.depthBits == 24
-            && !biasOrScale && !packing->SwapBytes) {
-      /* Special case: directly read 24-bit unsigned depth values. */
-      GLint j;
-      ASSERT(rb->Format == MESA_FORMAT_X8_Z24 ||
-             rb->Format == MESA_FORMAT_S8_Z24 ||
-             rb->Format == MESA_FORMAT_Z24_X8 ||
-             rb->Format == MESA_FORMAT_Z24_S8);
-      ASSERT(rb->DataType == GL_UNSIGNED_INT ||
-             rb->DataType == GL_UNSIGNED_INT_24_8);
-      for (j = 0; j < height; j++, y++) {
-         GLuint *dest = (GLuint *)
-            _mesa_image_address2d(packing, pixels, width, height,
-                                  GL_DEPTH_COMPONENT, type, j, 0);
-         GLint k;
-         rb->GetRow(ctx, rb, width, x, y, dest);
-         /* convert range from 24-bit to 32-bit */
-         if (rb->Format == MESA_FORMAT_X8_Z24 ||
-             rb->Format == MESA_FORMAT_S8_Z24) {
-            for (k = 0; k < width; k++) {
-               /* Note: put MSByte of 24-bit value into LSByte */
-               dest[k] = (dest[k] << 8) | ((dest[k] >> 16) & 0xff);
-            }
-         }
-         else {
-            for (k = 0; k < width; k++) {
-               /* Note: fill in LSByte by replication */
-               dest[k] = dest[k] | ((dest[k] >> 8) & 0xff);
-            }
-         }
-      }
-   }
-   else if (type == GL_UNSIGNED_INT && fb->Visual.depthBits == 32
-            && !biasOrScale && !packing->SwapBytes) {
-      /* Special case: directly read 32-bit unsigned depth values. */
-      GLint j;
-      ASSERT(rb->Format == MESA_FORMAT_Z32);
-      ASSERT(rb->DataType == GL_UNSIGNED_INT);
-      for (j = 0; j < height; j++, y++) {
-         void *dest = _mesa_image_address2d(packing, pixels, width, height,
-                                            GL_DEPTH_COMPONENT, type, j, 0);
-         rb->GetRow(ctx, rb, width, x, y, dest);
-      }
-   }
-   else {
-      /* General case (slower) */
-      GLint j;
-      for (j = 0; j < height; j++, y++) {
-         GLfloat depthValues[MAX_WIDTH];
-         GLvoid *dest = _mesa_image_address2d(packing, pixels, width, height,
-                                              GL_DEPTH_COMPONENT, type, j, 0);
-         _swrast_read_depth_span_float(ctx, rb, width, x, y, depthValues);
-         _mesa_pack_depth_span(ctx, width, dest, type, depthValues, packing);
-      }
-   }
-}
-
-
-/**
- * Read pixels for format=GL_STENCIL_INDEX.
- */
-static void
-read_stencil_pixels( GLcontext *ctx,
-                     GLint x, GLint y,
-                     GLsizei width, GLsizei height,
-                     GLenum type, GLvoid *pixels,
-                     const struct gl_pixelstore_attrib *packing )
-{
-   struct gl_framebuffer *fb = ctx->ReadBuffer;
-   struct gl_renderbuffer *rb = fb->_StencilBuffer;
-   GLint j;
-
-   if (!rb)
-      return;
-
-   /* width should never be > MAX_WIDTH since we did clipping earlier */
-   ASSERT(width <= MAX_WIDTH);
-
-   /* process image row by row */
-   for (j=0;j<height;j++,y++) {
-      GLvoid *dest;
-      GLstencil stencil[MAX_WIDTH];
-
-      _swrast_read_stencil_span(ctx, rb, width, x, y, stencil);
-
-      dest = _mesa_image_address2d(packing, pixels, width, height,
-                                   GL_STENCIL_INDEX, type, j, 0);
-
-      _mesa_pack_stencil_span(ctx, width, type, dest, stencil, packing);
-   }
-}
-
-
-
-/**
- * Optimized glReadPixels for particular pixel formats when pixel
- * scaling, biasing, mapping, etc. are disabled.
- * \return GL_TRUE if success, GL_FALSE if unable to do the readpixels
- */
-static GLboolean
-fast_read_rgba_pixels( GLcontext *ctx,
-                       GLint x, GLint y,
-                       GLsizei width, GLsizei height,
-                       GLenum format, GLenum type,
-                       GLvoid *pixels,
-                       const struct gl_pixelstore_attrib *packing,
-                       GLbitfield transferOps)
-{
-   struct gl_renderbuffer *rb = ctx->ReadBuffer->_ColorReadBuffer;
-
-   if (!rb)
-      return GL_FALSE;
-
-   ASSERT(rb->_BaseFormat == GL_RGBA || rb->_BaseFormat == GL_RGB ||
-	  rb->_BaseFormat == GL_ALPHA);
-
-   /* clipping should have already been done */
-   ASSERT(x + width <= (GLint) rb->Width);
-   ASSERT(y + height <= (GLint) rb->Height);
-
-   /* check for things we can't handle here */
-   if (transferOps ||
-       packing->SwapBytes ||
-       packing->LsbFirst) {
-      return GL_FALSE;
-   }
-
-   if (format == GL_RGBA && rb->DataType == type) {
-      const GLint dstStride = _mesa_image_row_stride(packing, width,
-                                                     format, type);
-      GLubyte *dest
-         = (GLubyte *) _mesa_image_address2d(packing, pixels, width, height,
-                                             format, type, 0, 0);
-      GLint row;
-      ASSERT(rb->GetRow);
-      for (row = 0; row < height; row++) {
-         rb->GetRow(ctx, rb, width, x, y + row, dest);
-         dest += dstStride;
-      }
-      return GL_TRUE;
-   }
-
-   if (format == GL_RGB &&
-       rb->DataType == GL_UNSIGNED_BYTE &&
-       type == GL_UNSIGNED_BYTE) {
-      const GLint dstStride = _mesa_image_row_stride(packing, width,
-                                                     format, type);
-      GLubyte *dest
-         = (GLubyte *) _mesa_image_address2d(packing, pixels, width, height,
-                                             format, type, 0, 0);
-      GLint row;
-      ASSERT(rb->GetRow);
-      for (row = 0; row < height; row++) {
-         GLubyte tempRow[MAX_WIDTH][4];
-         GLint col;
-         rb->GetRow(ctx, rb, width, x, y + row, tempRow);
-         /* convert RGBA to RGB */
-         for (col = 0; col < width; col++) {
-            dest[col * 3 + 0] = tempRow[col][0];
-            dest[col * 3 + 1] = tempRow[col][1];
-            dest[col * 3 + 2] = tempRow[col][2];
-         }
-         dest += dstStride;
-      }
-      return GL_TRUE;
-   }
-
-   /* not handled */
-   return GL_FALSE;
-}
-
-
-/**
- * When we're using a low-precision color buffer (like 16-bit 5/6/5)
- * we have to adjust our color values a bit to pass conformance.
- * The problem is when a 5 or 6-bit color value is converted to an 8-bit
- * value and then a floating point value, the floating point values don't
- * increment uniformly as the 5 or 6-bit value is incremented.
- *
- * This function adjusts floating point values to compensate.
- */
-static void
-adjust_colors(const struct gl_framebuffer *fb, GLuint n, GLfloat rgba[][4])
-{
-   const GLuint rShift = 8 - fb->Visual.redBits;
-   const GLuint gShift = 8 - fb->Visual.greenBits;
-   const GLuint bShift = 8 - fb->Visual.blueBits;
-   GLfloat rScale = 1.0F / (GLfloat) ((1 << fb->Visual.redBits  ) - 1);
-   GLfloat gScale = 1.0F / (GLfloat) ((1 << fb->Visual.greenBits) - 1);
-   GLfloat bScale = 1.0F / (GLfloat) ((1 << fb->Visual.blueBits ) - 1);
-   GLuint i;
-
-   if (fb->Visual.redBits == 0)
-      rScale = 0;
-   if (fb->Visual.greenBits == 0)
-      gScale = 0;
-   if (fb->Visual.blueBits == 0)
-      bScale = 0;
-
-   for (i = 0; i < n; i++) {
-      GLint r, g, b;
-      /* convert float back to ubyte */
-      CLAMPED_FLOAT_TO_UBYTE(r, rgba[i][RCOMP]);
-      CLAMPED_FLOAT_TO_UBYTE(g, rgba[i][GCOMP]);
-      CLAMPED_FLOAT_TO_UBYTE(b, rgba[i][BCOMP]);
-      /* using only the N most significant bits of the ubyte value, convert to
-       * float in [0,1].
-       */
-      rgba[i][RCOMP] = (GLfloat) (r >> rShift) * rScale;
-      rgba[i][GCOMP] = (GLfloat) (g >> gShift) * gScale;
-      rgba[i][BCOMP] = (GLfloat) (b >> bShift) * bScale;
-   }
-}
-
-
-
-/*
- * Read R, G, B, A, RGB, L, or LA pixels.
- */
-static void
-read_rgba_pixels( GLcontext *ctx,
-                  GLint x, GLint y,
-                  GLsizei width, GLsizei height,
-                  GLenum format, GLenum type, GLvoid *pixels,
-                  const struct gl_pixelstore_attrib *packing )
-{
-   SWcontext *swrast = SWRAST_CONTEXT(ctx);
-   GLbitfield transferOps = ctx->_ImageTransferState;
-   struct gl_framebuffer *fb = ctx->ReadBuffer;
-   struct gl_renderbuffer *rb = fb->_ColorReadBuffer;
-
-   if (!rb)
-      return;
-
-   if (type == GL_FLOAT && ((ctx->Color.ClampReadColor == GL_TRUE) ||
-                            (ctx->Color.ClampReadColor == GL_FIXED_ONLY_ARB &&
-                             rb->DataType != GL_FLOAT)))
-      transferOps |= IMAGE_CLAMP_BIT;
-
-   /* Try optimized path first */
-   if (fast_read_rgba_pixels(ctx, x, y, width, height,
-                             format, type, pixels, packing, transferOps)) {
-      return; /* done! */
-   }
-
-   /* width should never be > MAX_WIDTH since we did clipping earlier */
-   ASSERT(width <= MAX_WIDTH);
-
-   if (ctx->Pixel.Convolution2DEnabled || ctx->Pixel.Separable2DEnabled) {
-      GLfloat *dest, *src, *tmpImage, *convImage;
-      GLint row;
-
-      tmpImage = (GLfloat *) malloc(width * height * 4 * sizeof(GLfloat));
-      if (!tmpImage) {
-         _mesa_error(ctx, GL_OUT_OF_MEMORY, "glReadPixels");
-         return;
-      }
-      convImage = (GLfloat *) malloc(width * height * 4 * sizeof(GLfloat));
-      if (!convImage) {
-         free(tmpImage);
-         _mesa_error(ctx, GL_OUT_OF_MEMORY, "glReadPixels");
-         return;
-      }
-
-      /* read full RGBA, FLOAT image */
-      dest = tmpImage;
-      for (row = 0; row < height; row++, y++) {
-         _swrast_read_rgba_span(ctx, rb, width, x, y, GL_FLOAT, dest);
-         _mesa_apply_rgba_transfer_ops(ctx, 
-                                      transferOps & IMAGE_PRE_CONVOLUTION_BITS,
-                                      width, (GLfloat (*)[4]) dest);
-         dest += width * 4;
-      }
-
-      /* do convolution */
-      if (ctx->Pixel.Convolution2DEnabled) {
-         _mesa_convolve_2d_image(ctx, &width, &height, tmpImage, convImage);
-      }
-      else {
-         ASSERT(ctx->Pixel.Separable2DEnabled);
-         _mesa_convolve_sep_image(ctx, &width, &height, tmpImage, convImage);
-      }
-      free(tmpImage);
-
-      /* finish transfer ops and pack the resulting image */
-      src = convImage;
-      for (row = 0; row < height; row++) {
-         GLvoid *dest;
-         dest = _mesa_image_address2d(packing, pixels, width, height,
-                                      format, type, row, 0);
-         _mesa_pack_rgba_span_float(ctx, width, (GLfloat (*)[4]) src,
-                                    format, type, dest, packing,
-                                    transferOps & IMAGE_POST_CONVOLUTION_BITS);
-         src += width * 4;
-      }
-      free(convImage);
-   }
-   else {
-      /* no convolution */
-      const GLint dstStride
-         = _mesa_image_row_stride(packing, width, format, type);
-      GLfloat (*rgba)[4] = swrast->SpanArrays->attribs[FRAG_ATTRIB_COL0];
-      GLint row;
-      GLubyte *dst
-         = (GLubyte *) _mesa_image_address2d(packing, pixels, width, height,
-                                             format, type, 0, 0);
-
-      /* make sure we don't apply 1D convolution */
-      transferOps &= ~(IMAGE_CONVOLUTION_BIT |
-                       IMAGE_POST_CONVOLUTION_SCALE_BIAS);
-
-      for (row = 0; row < height; row++, y++) {
-
-         /* Get float rgba pixels */
-         _swrast_read_rgba_span(ctx, rb, width, x, y, GL_FLOAT, rgba);
-
-         /* apply fudge factor for shallow color buffers */
-         if (fb->Visual.redBits < 8 ||
-             fb->Visual.greenBits < 8 ||
-             fb->Visual.blueBits < 8) {
-            adjust_colors(fb, width, rgba);
-         }
-
-         /* pack the row of RGBA pixels into user's buffer */
-         _mesa_pack_rgba_span_float(ctx, width, rgba, format, type, dst,
-                                    packing, transferOps);
-
-         dst += dstStride;
-      }
-   }
-}
-
-
-/**
- * Read combined depth/stencil values.
- * We'll have already done error checking to be sure the expected
- * depth and stencil buffers really exist.
- */
-static void
-read_depth_stencil_pixels(GLcontext *ctx,
-                          GLint x, GLint y,
-                          GLsizei width, GLsizei height,
-                          GLenum type, GLvoid *pixels,
-                          const struct gl_pixelstore_attrib *packing )
-{
-   const GLboolean scaleOrBias
-      = ctx->Pixel.DepthScale != 1.0 || ctx->Pixel.DepthBias != 0.0;
-   const GLboolean stencilTransfer = ctx->Pixel.IndexShift
-      || ctx->Pixel.IndexOffset || ctx->Pixel.MapStencilFlag;
-   struct gl_renderbuffer *depthRb, *stencilRb;
-
-   depthRb = ctx->ReadBuffer->_DepthBuffer;
-   stencilRb = ctx->ReadBuffer->_StencilBuffer;
-
-   if (!depthRb || !stencilRb)
-      return;
-
-   depthRb = ctx->ReadBuffer->Attachment[BUFFER_DEPTH].Renderbuffer;
-   stencilRb = ctx->ReadBuffer->Attachment[BUFFER_STENCIL].Renderbuffer;
-
-   if (depthRb->_BaseFormat == GL_DEPTH_STENCIL_EXT &&
-       stencilRb->_BaseFormat == GL_DEPTH_STENCIL_EXT &&
-       depthRb == stencilRb &&
-       !scaleOrBias &&
-       !stencilTransfer) {
-      /* This is the ideal case.
-       * Reading GL_DEPTH_STENCIL pixels from combined depth/stencil buffer.
-       * Plus, no pixel transfer ops to worry about!
-       */
-      GLint i;
-      GLint dstStride = _mesa_image_row_stride(packing, width,
-                                               GL_DEPTH_STENCIL_EXT, type);
-      GLubyte *dst = (GLubyte *) _mesa_image_address2d(packing, pixels,
-                                                       width, height,
-                                                       GL_DEPTH_STENCIL_EXT,
-                                                       type, 0, 0);
-      for (i = 0; i < height; i++) {
-         depthRb->GetRow(ctx, depthRb, width, x, y + i, dst);
-         dst += dstStride;
-      }
-   }
-   else {
-      /* Reading GL_DEPTH_STENCIL pixels from separate depth/stencil buffers,
-       * or we need pixel transfer.
-       */
-      GLint i;
-      depthRb = ctx->ReadBuffer->_DepthBuffer;
-      stencilRb = ctx->ReadBuffer->_StencilBuffer;
-
-      for (i = 0; i < height; i++) {
-         GLstencil stencilVals[MAX_WIDTH];
-
-         GLuint *depthStencilDst = (GLuint *)
-            _mesa_image_address2d(packing, pixels, width, height,
-                                  GL_DEPTH_STENCIL_EXT, type, i, 0);
-
-         _swrast_read_stencil_span(ctx, stencilRb, width,
-                                   x, y + i, stencilVals);
-
-         if (!scaleOrBias && !stencilTransfer
-             && ctx->ReadBuffer->Visual.depthBits == 24) {
-            /* ideal case */
-            GLuint zVals[MAX_WIDTH]; /* 24-bit values! */
-            GLint j;
-            ASSERT(depthRb->DataType == GL_UNSIGNED_INT);
-            /* note, we've already been clipped */
-            depthRb->GetRow(ctx, depthRb, width, x, y + i, zVals);
-            for (j = 0; j < width; j++) {
-               depthStencilDst[j] = (zVals[j] << 8) | (stencilVals[j] & 0xff);
-            }
-         }
-         else {
-            /* general case */
-            GLfloat depthVals[MAX_WIDTH];
-            _swrast_read_depth_span_float(ctx, depthRb, width, x, y + i,
-                                          depthVals);
-            _mesa_pack_depth_stencil_span(ctx, width, depthStencilDst,
-                                          depthVals, stencilVals, packing);
-         }
-      }
-   }
-}
-
-
-
-/**
- * Software fallback routine for ctx->Driver.ReadPixels().
- * By time we get here, all error checking will have been done.
- */
-void
-_swrast_ReadPixels( GLcontext *ctx,
-		    GLint x, GLint y, GLsizei width, GLsizei height,
-		    GLenum format, GLenum type,
-		    const struct gl_pixelstore_attrib *packing,
-		    GLvoid *pixels )
-{
-   SWcontext *swrast = SWRAST_CONTEXT(ctx);
-   struct gl_pixelstore_attrib clippedPacking = *packing;
-
-   if (ctx->NewState)
-      _mesa_update_state(ctx);
-
-   /* Need to do swrast_render_start() before clipping or anything else
-    * since this is where a driver may grab the hw lock and get an updated
-    * window size.
-    */
-   swrast_render_start(ctx);
-
-   if (swrast->NewState)
-      _swrast_validate_derived( ctx );
-
-   /* Do all needed clipping here, so that we can forget about it later */
-   if (!_mesa_clip_readpixels(ctx, &x, &y, &width, &height, &clippedPacking)) {
-      /* The ReadPixels region is totally outside the window bounds */
-      swrast_render_finish(ctx);
-      return;
-   }
-
-   pixels = _mesa_map_pbo_dest(ctx, &clippedPacking, pixels);
-   if (!pixels)
-      return;
-  
-   switch (format) {
-      case GL_STENCIL_INDEX:
-	 read_stencil_pixels(ctx, x, y, width, height, type, pixels,
-                             &clippedPacking);
-         break;
-      case GL_DEPTH_COMPONENT:
-	 read_depth_pixels(ctx, x, y, width, height, type, pixels,
-                           &clippedPacking);
-	 break;
-      case GL_RED:
-      case GL_GREEN:
-      case GL_BLUE:
-      case GL_ALPHA:
-      case GL_RGB:
-      case GL_LUMINANCE:
-      case GL_LUMINANCE_ALPHA:
-      case GL_RGBA:
-      case GL_BGR:
-      case GL_BGRA:
-      case GL_ABGR_EXT:
-         read_rgba_pixels(ctx, x, y, width, height,
-                          format, type, pixels, &clippedPacking);
-	 break;
-      case GL_DEPTH_STENCIL_EXT:
-         read_depth_stencil_pixels(ctx, x, y, width, height,
-                                   type, pixels, &clippedPacking);
-         break;
-      default:
-	 _mesa_problem(ctx, "unexpected format in _swrast_ReadPixels");
-         /* don't return yet, clean-up */
-   }
-
-   swrast_render_finish(ctx);
-
-   _mesa_unmap_pbo_dest(ctx, &clippedPacking);
-}
+/*

+ * Mesa 3-D graphics library

+ * Version:  7.0.3

+ *

+ * 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/bufferobj.h"

+#include "main/colormac.h"

+#include "main/feedback.h"

+#include "main/formats.h"

+#include "main/image.h"

+#include "main/imports.h"

+#include "main/macros.h"

+#include "main/pack.h"

+#include "main/state.h"

+

+#include "s_context.h"

+#include "s_depth.h"

+#include "s_span.h"

+#include "s_stencil.h"

+

+

+/**

+ * Read pixels for format=GL_DEPTH_COMPONENT.

+ */

+static void

+read_depth_pixels( struct gl_context *ctx,

+                   GLint x, GLint y,

+                   GLsizei width, GLsizei height,

+                   GLenum type, GLvoid *pixels,

+                   const struct gl_pixelstore_attrib *packing )

+{

+   struct gl_framebuffer *fb = ctx->ReadBuffer;

+   struct gl_renderbuffer *rb = fb->_DepthBuffer;

+   const GLboolean biasOrScale

+      = ctx->Pixel.DepthScale != 1.0 || ctx->Pixel.DepthBias != 0.0;

+

+   if (!rb)

+      return;

+

+   /* clipping should have been done already */

+   ASSERT(x >= 0);

+   ASSERT(y >= 0);

+   ASSERT(x + width <= (GLint) rb->Width);

+   ASSERT(y + height <= (GLint) rb->Height);

+   /* width should never be > MAX_WIDTH since we did clipping earlier */

+   ASSERT(width <= MAX_WIDTH);

+

+   if (type == GL_UNSIGNED_SHORT && fb->Visual.depthBits == 16

+       && !biasOrScale && !packing->SwapBytes) {

+      /* Special case: directly read 16-bit unsigned depth values. */

+      GLint j;

+      ASSERT(rb->Format == MESA_FORMAT_Z16);

+      ASSERT(rb->DataType == GL_UNSIGNED_SHORT);

+      for (j = 0; j < height; j++, y++) {

+         void *dest =_mesa_image_address2d(packing, pixels, width, height,

+                                           GL_DEPTH_COMPONENT, type, j, 0);

+         rb->GetRow(ctx, rb, width, x, y, dest);

+      }

+   }

+   else if (type == GL_UNSIGNED_INT && fb->Visual.depthBits == 24

+            && !biasOrScale && !packing->SwapBytes) {

+      /* Special case: directly read 24-bit unsigned depth values. */

+      GLint j;

+      ASSERT(rb->Format == MESA_FORMAT_X8_Z24 ||

+             rb->Format == MESA_FORMAT_S8_Z24 ||

+             rb->Format == MESA_FORMAT_Z24_X8 ||

+             rb->Format == MESA_FORMAT_Z24_S8);

+      ASSERT(rb->DataType == GL_UNSIGNED_INT ||

+             rb->DataType == GL_UNSIGNED_INT_24_8);

+      for (j = 0; j < height; j++, y++) {

+         GLuint *dest = (GLuint *)

+            _mesa_image_address2d(packing, pixels, width, height,

+                                  GL_DEPTH_COMPONENT, type, j, 0);

+         GLint k;

+         rb->GetRow(ctx, rb, width, x, y, dest);

+         /* convert range from 24-bit to 32-bit */

+         if (rb->Format == MESA_FORMAT_X8_Z24 ||

+             rb->Format == MESA_FORMAT_S8_Z24) {

+            for (k = 0; k < width; k++) {

+               /* Note: put MSByte of 24-bit value into LSByte */

+               dest[k] = (dest[k] << 8) | ((dest[k] >> 16) & 0xff);

+            }

+         }

+         else {

+            for (k = 0; k < width; k++) {

+               /* Note: fill in LSByte by replication */

+               dest[k] = dest[k] | ((dest[k] >> 8) & 0xff);

+            }

+         }

+      }

+   }

+   else if (type == GL_UNSIGNED_INT && fb->Visual.depthBits == 32

+            && !biasOrScale && !packing->SwapBytes) {

+      /* Special case: directly read 32-bit unsigned depth values. */

+      GLint j;

+      ASSERT(rb->Format == MESA_FORMAT_Z32);

+      ASSERT(rb->DataType == GL_UNSIGNED_INT);

+      for (j = 0; j < height; j++, y++) {

+         void *dest = _mesa_image_address2d(packing, pixels, width, height,

+                                            GL_DEPTH_COMPONENT, type, j, 0);

+         rb->GetRow(ctx, rb, width, x, y, dest);

+      }

+   }

+   else {

+      /* General case (slower) */

+      GLint j;

+      for (j = 0; j < height; j++, y++) {

+         GLfloat depthValues[MAX_WIDTH];

+         GLvoid *dest = _mesa_image_address2d(packing, pixels, width, height,

+                                              GL_DEPTH_COMPONENT, type, j, 0);

+         _swrast_read_depth_span_float(ctx, rb, width, x, y, depthValues);

+         _mesa_pack_depth_span(ctx, width, dest, type, depthValues, packing);

+      }

+   }

+}

+

+

+/**

+ * Read pixels for format=GL_STENCIL_INDEX.

+ */

+static void

+read_stencil_pixels( struct gl_context *ctx,

+                     GLint x, GLint y,

+                     GLsizei width, GLsizei height,

+                     GLenum type, GLvoid *pixels,

+                     const struct gl_pixelstore_attrib *packing )

+{

+   struct gl_framebuffer *fb = ctx->ReadBuffer;

+   struct gl_renderbuffer *rb = fb->_StencilBuffer;

+   GLint j;

+

+   if (!rb)

+      return;

+

+   /* width should never be > MAX_WIDTH since we did clipping earlier */

+   ASSERT(width <= MAX_WIDTH);

+

+   /* process image row by row */

+   for (j=0;j<height;j++,y++) {

+      GLvoid *dest;

+      GLstencil stencil[MAX_WIDTH];

+

+      _swrast_read_stencil_span(ctx, rb, width, x, y, stencil);

+

+      dest = _mesa_image_address2d(packing, pixels, width, height,

+                                   GL_STENCIL_INDEX, type, j, 0);

+

+      _mesa_pack_stencil_span(ctx, width, type, dest, stencil, packing);

+   }

+}

+

+

+

+/**

+ * Optimized glReadPixels for particular pixel formats when pixel

+ * scaling, biasing, mapping, etc. are disabled.

+ * \return GL_TRUE if success, GL_FALSE if unable to do the readpixels

+ */

+static GLboolean

+fast_read_rgba_pixels( struct gl_context *ctx,

+                       GLint x, GLint y,

+                       GLsizei width, GLsizei height,

+                       GLenum format, GLenum type,

+                       GLvoid *pixels,

+                       const struct gl_pixelstore_attrib *packing,

+                       GLbitfield transferOps)

+{

+   struct gl_renderbuffer *rb = ctx->ReadBuffer->_ColorReadBuffer;

+

+   if (!rb)

+      return GL_FALSE;

+

+   ASSERT(rb->_BaseFormat == GL_RGBA || rb->_BaseFormat == GL_RGB ||

+	  rb->_BaseFormat == GL_ALPHA);

+

+   /* clipping should have already been done */

+   ASSERT(x + width <= (GLint) rb->Width);

+   ASSERT(y + height <= (GLint) rb->Height);

+

+   /* check for things we can't handle here */

+   if (transferOps ||

+       packing->SwapBytes ||

+       packing->LsbFirst) {

+      return GL_FALSE;

+   }

+

+   if (format == GL_RGBA && rb->DataType == type) {

+      const GLint dstStride = _mesa_image_row_stride(packing, width,

+                                                     format, type);

+      GLubyte *dest

+         = (GLubyte *) _mesa_image_address2d(packing, pixels, width, height,

+                                             format, type, 0, 0);

+      GLint row;

+      ASSERT(rb->GetRow);

+      for (row = 0; row < height; row++) {

+         rb->GetRow(ctx, rb, width, x, y + row, dest);

+         dest += dstStride;

+      }

+      return GL_TRUE;

+   }

+

+   if (format == GL_RGB &&

+       rb->DataType == GL_UNSIGNED_BYTE &&

+       type == GL_UNSIGNED_BYTE) {

+      const GLint dstStride = _mesa_image_row_stride(packing, width,

+                                                     format, type);

+      GLubyte *dest

+         = (GLubyte *) _mesa_image_address2d(packing, pixels, width, height,

+                                             format, type, 0, 0);

+      GLint row;

+      ASSERT(rb->GetRow);

+      for (row = 0; row < height; row++) {

+         GLubyte tempRow[MAX_WIDTH][4];

+         GLint col;

+         rb->GetRow(ctx, rb, width, x, y + row, tempRow);

+         /* convert RGBA to RGB */

+         for (col = 0; col < width; col++) {

+            dest[col * 3 + 0] = tempRow[col][0];

+            dest[col * 3 + 1] = tempRow[col][1];

+            dest[col * 3 + 2] = tempRow[col][2];

+         }

+         dest += dstStride;

+      }

+      return GL_TRUE;

+   }

+

+   /* not handled */

+   return GL_FALSE;

+}

+

+

+/**

+ * When we're using a low-precision color buffer (like 16-bit 5/6/5)

+ * we have to adjust our color values a bit to pass conformance.

+ * The problem is when a 5 or 6-bit color value is converted to an 8-bit

+ * value and then a floating point value, the floating point values don't

+ * increment uniformly as the 5 or 6-bit value is incremented.

+ *

+ * This function adjusts floating point values to compensate.

+ */

+static void

+adjust_colors(const struct gl_framebuffer *fb, GLuint n, GLfloat rgba[][4])

+{

+   const GLuint rShift = 8 - fb->Visual.redBits;

+   const GLuint gShift = 8 - fb->Visual.greenBits;

+   const GLuint bShift = 8 - fb->Visual.blueBits;

+   GLfloat rScale = 1.0F / (GLfloat) ((1 << fb->Visual.redBits  ) - 1);

+   GLfloat gScale = 1.0F / (GLfloat) ((1 << fb->Visual.greenBits) - 1);

+   GLfloat bScale = 1.0F / (GLfloat) ((1 << fb->Visual.blueBits ) - 1);

+   GLuint i;

+

+   if (fb->Visual.redBits == 0)

+      rScale = 0;

+   if (fb->Visual.greenBits == 0)

+      gScale = 0;

+   if (fb->Visual.blueBits == 0)

+      bScale = 0;

+

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

+      GLint r, g, b;

+      /* convert float back to ubyte */

+      CLAMPED_FLOAT_TO_UBYTE(r, rgba[i][RCOMP]);

+      CLAMPED_FLOAT_TO_UBYTE(g, rgba[i][GCOMP]);

+      CLAMPED_FLOAT_TO_UBYTE(b, rgba[i][BCOMP]);

+      /* using only the N most significant bits of the ubyte value, convert to

+       * float in [0,1].

+       */

+      rgba[i][RCOMP] = (GLfloat) (r >> rShift) * rScale;

+      rgba[i][GCOMP] = (GLfloat) (g >> gShift) * gScale;

+      rgba[i][BCOMP] = (GLfloat) (b >> bShift) * bScale;

+   }

+}

+

+

+

+/*

+ * Read R, G, B, A, RGB, L, or LA pixels.

+ */

+static void

+read_rgba_pixels( struct gl_context *ctx,

+                  GLint x, GLint y,

+                  GLsizei width, GLsizei height,

+                  GLenum format, GLenum type, GLvoid *pixels,

+                  const struct gl_pixelstore_attrib *packing )

+{

+   SWcontext *swrast = SWRAST_CONTEXT(ctx);

+   GLbitfield transferOps = ctx->_ImageTransferState;

+   struct gl_framebuffer *fb = ctx->ReadBuffer;

+   struct gl_renderbuffer *rb = fb->_ColorReadBuffer;

+

+   if (!rb)

+      return;

+

+   if (type == GL_FLOAT && ((ctx->Color.ClampReadColor == GL_TRUE) ||

+                            (ctx->Color.ClampReadColor == GL_FIXED_ONLY_ARB &&

+                             rb->DataType != GL_FLOAT)))

+      transferOps |= IMAGE_CLAMP_BIT;

+

+   /* Try optimized path first */

+   if (fast_read_rgba_pixels(ctx, x, y, width, height,

+                             format, type, pixels, packing, transferOps)) {

+      return; /* done! */

+   }

+

+   /* width should never be > MAX_WIDTH since we did clipping earlier */

+   ASSERT(width <= MAX_WIDTH);

+

+   do {

+      const GLint dstStride

+         = _mesa_image_row_stride(packing, width, format, type);

+      GLfloat (*rgba)[4] = swrast->SpanArrays->attribs[FRAG_ATTRIB_COL0];

+      GLint row;

+      GLubyte *dst

+         = (GLubyte *) _mesa_image_address2d(packing, pixels, width, height,

+                                             format, type, 0, 0);

+

+      for (row = 0; row < height; row++, y++) {

+

+         /* Get float rgba pixels */

+         _swrast_read_rgba_span(ctx, rb, width, x, y, GL_FLOAT, rgba);

+

+         /* apply fudge factor for shallow color buffers */

+         if (fb->Visual.redBits < 8 ||

+             fb->Visual.greenBits < 8 ||

+             fb->Visual.blueBits < 8) {

+            adjust_colors(fb, width, rgba);

+         }

+

+         /* pack the row of RGBA pixels into user's buffer */

+         _mesa_pack_rgba_span_float(ctx, width, rgba, format, type, dst,

+                                    packing, transferOps);

+

+         dst += dstStride;

+      }

+   } while (0);

+}

+

+

+/**

+ * Read combined depth/stencil values.

+ * We'll have already done error checking to be sure the expected

+ * depth and stencil buffers really exist.

+ */

+static void

+read_depth_stencil_pixels(struct gl_context *ctx,

+                          GLint x, GLint y,

+                          GLsizei width, GLsizei height,

+                          GLenum type, GLvoid *pixels,

+                          const struct gl_pixelstore_attrib *packing )

+{

+   const GLboolean scaleOrBias

+      = ctx->Pixel.DepthScale != 1.0 || ctx->Pixel.DepthBias != 0.0;

+   const GLboolean stencilTransfer = ctx->Pixel.IndexShift

+      || ctx->Pixel.IndexOffset || ctx->Pixel.MapStencilFlag;

+   struct gl_renderbuffer *depthRb, *stencilRb;

+

+   depthRb = ctx->ReadBuffer->_DepthBuffer;

+   stencilRb = ctx->ReadBuffer->_StencilBuffer;

+

+   if (!depthRb || !stencilRb)

+      return;

+

+   depthRb = ctx->ReadBuffer->Attachment[BUFFER_DEPTH].Renderbuffer;

+   stencilRb = ctx->ReadBuffer->Attachment[BUFFER_STENCIL].Renderbuffer;

+

+   if (depthRb->_BaseFormat == GL_DEPTH_STENCIL_EXT &&

+       stencilRb->_BaseFormat == GL_DEPTH_STENCIL_EXT &&

+       depthRb == stencilRb &&

+       !scaleOrBias &&

+       !stencilTransfer) {

+      /* This is the ideal case.

+       * Reading GL_DEPTH_STENCIL pixels from combined depth/stencil buffer.

+       * Plus, no pixel transfer ops to worry about!

+       */

+      GLint i;

+      GLint dstStride = _mesa_image_row_stride(packing, width,

+                                               GL_DEPTH_STENCIL_EXT, type);

+      GLubyte *dst = (GLubyte *) _mesa_image_address2d(packing, pixels,

+                                                       width, height,

+                                                       GL_DEPTH_STENCIL_EXT,

+                                                       type, 0, 0);

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

+         depthRb->GetRow(ctx, depthRb, width, x, y + i, dst);

+         dst += dstStride;

+      }

+   }

+   else {

+      /* Reading GL_DEPTH_STENCIL pixels from separate depth/stencil buffers,

+       * or we need pixel transfer.

+       */

+      GLint i;

+      depthRb = ctx->ReadBuffer->_DepthBuffer;

+      stencilRb = ctx->ReadBuffer->_StencilBuffer;

+

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

+         GLstencil stencilVals[MAX_WIDTH];

+

+         GLuint *depthStencilDst = (GLuint *)

+            _mesa_image_address2d(packing, pixels, width, height,

+                                  GL_DEPTH_STENCIL_EXT, type, i, 0);

+

+         _swrast_read_stencil_span(ctx, stencilRb, width,

+                                   x, y + i, stencilVals);

+

+         if (!scaleOrBias && !stencilTransfer

+             && ctx->ReadBuffer->Visual.depthBits == 24) {

+            /* ideal case */

+            GLuint zVals[MAX_WIDTH]; /* 24-bit values! */

+            GLint j;

+            ASSERT(depthRb->DataType == GL_UNSIGNED_INT);

+            /* note, we've already been clipped */

+            depthRb->GetRow(ctx, depthRb, width, x, y + i, zVals);

+            for (j = 0; j < width; j++) {

+               depthStencilDst[j] = (zVals[j] << 8) | (stencilVals[j] & 0xff);

+            }

+         }

+         else {

+            /* general case */

+            GLfloat depthVals[MAX_WIDTH];

+            _swrast_read_depth_span_float(ctx, depthRb, width, x, y + i,

+                                          depthVals);

+            _mesa_pack_depth_stencil_span(ctx, width, depthStencilDst,

+                                          depthVals, stencilVals, packing);

+         }

+      }

+   }

+}

+

+

+

+/**

+ * Software fallback routine for ctx->Driver.ReadPixels().

+ * By time we get here, all error checking will have been done.

+ */

+void

+_swrast_ReadPixels( struct gl_context *ctx,

+		    GLint x, GLint y, GLsizei width, GLsizei height,

+		    GLenum format, GLenum type,

+		    const struct gl_pixelstore_attrib *packing,

+		    GLvoid *pixels )

+{

+   SWcontext *swrast = SWRAST_CONTEXT(ctx);

+   struct gl_pixelstore_attrib clippedPacking = *packing;

+

+   if (ctx->NewState)

+      _mesa_update_state(ctx);

+

+   /* Need to do swrast_render_start() before clipping or anything else

+    * since this is where a driver may grab the hw lock and get an updated

+    * window size.

+    */

+   swrast_render_start(ctx);

+

+   if (swrast->NewState)

+      _swrast_validate_derived( ctx );

+

+   /* Do all needed clipping here, so that we can forget about it later */

+   if (_mesa_clip_readpixels(ctx, &x, &y, &width, &height, &clippedPacking)) {

+

+      pixels = _mesa_map_pbo_dest(ctx, &clippedPacking, pixels);

+

+      if (pixels) {

+         switch (format) {

+         case GL_STENCIL_INDEX:

+            read_stencil_pixels(ctx, x, y, width, height, type, pixels,

+                                &clippedPacking);

+            break;

+         case GL_DEPTH_COMPONENT:

+            read_depth_pixels(ctx, x, y, width, height, type, pixels,

+                              &clippedPacking);

+            break;

+         case GL_DEPTH_STENCIL_EXT:

+            read_depth_stencil_pixels(ctx, x, y, width, height, type, pixels,

+                                      &clippedPacking);

+            break;

+         default:

+            /* all other formats should be color formats */

+            read_rgba_pixels(ctx, x, y, width, height, format, type, pixels,

+                             &clippedPacking);

+         }

+

+         _mesa_unmap_pbo_dest(ctx, &clippedPacking);

+      }

+   }

+

+   swrast_render_finish(ctx);

+}

diff --git a/mesalib/src/mesa/swrast/s_span.c b/mesalib/src/mesa/swrast/s_span.c
index 28c82990e..029c88b29 100644
--- a/mesalib/src/mesa/swrast/s_span.c
+++ b/mesalib/src/mesa/swrast/s_span.c
@@ -1,1502 +1,1502 @@
-/*
- * Mesa 3-D graphics library
- * Version:  7.5
- *
- * Copyright (C) 1999-2008  Brian Paul   All Rights Reserved.
- * Copyright (C) 2009  VMware, Inc.  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.
- */
-
-
-/**
- * \file swrast/s_span.c
- * \brief Span processing functions used by all rasterization functions.
- * This is where all the per-fragment tests are performed
- * \author Brian Paul
- */
-
-#include "main/glheader.h"
-#include "main/colormac.h"
-#include "main/macros.h"
-#include "main/imports.h"
-#include "main/image.h"
-
-#include "s_atifragshader.h"
-#include "s_alpha.h"
-#include "s_blend.h"
-#include "s_context.h"
-#include "s_depth.h"
-#include "s_fog.h"
-#include "s_logic.h"
-#include "s_masking.h"
-#include "s_fragprog.h"
-#include "s_span.h"
-#include "s_stencil.h"
-#include "s_texcombine.h"
-
-
-/**
- * Set default fragment attributes for the span using the
- * current raster values.  Used prior to glDraw/CopyPixels
- * and glBitmap.
- */
-void
-_swrast_span_default_attribs(GLcontext *ctx, SWspan *span)
-{
-   GLchan r, g, b, a;
-   /* Z*/
-   {
-      const GLfloat depthMax = ctx->DrawBuffer->_DepthMaxF;
-      if (ctx->DrawBuffer->Visual.depthBits <= 16)
-         span->z = FloatToFixed(ctx->Current.RasterPos[2] * depthMax + 0.5F);
-      else {
-         GLfloat tmpf = ctx->Current.RasterPos[2] * depthMax; 
-         tmpf = MIN2(tmpf, depthMax);
-         span->z = (GLint)tmpf;
-      }
-      span->zStep = 0;
-      span->interpMask |= SPAN_Z;
-   }
-
-   /* W (for perspective correction) */
-   span->attrStart[FRAG_ATTRIB_WPOS][3] = 1.0;
-   span->attrStepX[FRAG_ATTRIB_WPOS][3] = 0.0;
-   span->attrStepY[FRAG_ATTRIB_WPOS][3] = 0.0;
-
-   /* primary color, or color index */
-   UNCLAMPED_FLOAT_TO_CHAN(r, ctx->Current.RasterColor[0]);
-   UNCLAMPED_FLOAT_TO_CHAN(g, ctx->Current.RasterColor[1]);
-   UNCLAMPED_FLOAT_TO_CHAN(b, ctx->Current.RasterColor[2]);
-   UNCLAMPED_FLOAT_TO_CHAN(a, ctx->Current.RasterColor[3]);
-#if CHAN_TYPE == GL_FLOAT
-   span->red = r;
-   span->green = g;
-   span->blue = b;
-   span->alpha = a;
-#else
-   span->red   = IntToFixed(r);
-   span->green = IntToFixed(g);
-   span->blue  = IntToFixed(b);
-   span->alpha = IntToFixed(a);
-#endif
-   span->redStep = 0;
-   span->greenStep = 0;
-   span->blueStep = 0;
-   span->alphaStep = 0;
-   span->interpMask |= SPAN_RGBA;
-
-   COPY_4V(span->attrStart[FRAG_ATTRIB_COL0], ctx->Current.RasterColor);
-   ASSIGN_4V(span->attrStepX[FRAG_ATTRIB_COL0], 0.0, 0.0, 0.0, 0.0);
-   ASSIGN_4V(span->attrStepY[FRAG_ATTRIB_COL0], 0.0, 0.0, 0.0, 0.0);
-
-   /* Secondary color */
-   if (ctx->Light.Enabled || ctx->Fog.ColorSumEnabled)
-   {
-      COPY_4V(span->attrStart[FRAG_ATTRIB_COL1], ctx->Current.RasterSecondaryColor);
-      ASSIGN_4V(span->attrStepX[FRAG_ATTRIB_COL1], 0.0, 0.0, 0.0, 0.0);
-      ASSIGN_4V(span->attrStepY[FRAG_ATTRIB_COL1], 0.0, 0.0, 0.0, 0.0);
-   }
-
-   /* fog */
-   {
-      const SWcontext *swrast = SWRAST_CONTEXT(ctx);
-      GLfloat fogVal; /* a coord or a blend factor */
-      if (swrast->_PreferPixelFog) {
-         /* fog blend factors will be computed from fog coordinates per pixel */
-         fogVal = ctx->Current.RasterDistance;
-      }
-      else {
-         /* fog blend factor should be computed from fogcoord now */
-         fogVal = _swrast_z_to_fogfactor(ctx, ctx->Current.RasterDistance);
-      }
-      span->attrStart[FRAG_ATTRIB_FOGC][0] = fogVal;
-      span->attrStepX[FRAG_ATTRIB_FOGC][0] = 0.0;
-      span->attrStepY[FRAG_ATTRIB_FOGC][0] = 0.0;
-   }
-
-   /* texcoords */
-   {
-      GLuint i;
-      for (i = 0; i < ctx->Const.MaxTextureCoordUnits; i++) {
-         const GLuint attr = FRAG_ATTRIB_TEX0 + i;
-         const GLfloat *tc = ctx->Current.RasterTexCoords[i];
-         if (ctx->FragmentProgram._Current || ctx->ATIFragmentShader._Enabled) {
-            COPY_4V(span->attrStart[attr], tc);
-         }
-         else if (tc[3] > 0.0F) {
-            /* use (s/q, t/q, r/q, 1) */
-            span->attrStart[attr][0] = tc[0] / tc[3];
-            span->attrStart[attr][1] = tc[1] / tc[3];
-            span->attrStart[attr][2] = tc[2] / tc[3];
-            span->attrStart[attr][3] = 1.0;
-         }
-         else {
-            ASSIGN_4V(span->attrStart[attr], 0.0F, 0.0F, 0.0F, 1.0F);
-         }
-         ASSIGN_4V(span->attrStepX[attr], 0.0F, 0.0F, 0.0F, 0.0F);
-         ASSIGN_4V(span->attrStepY[attr], 0.0F, 0.0F, 0.0F, 0.0F);
-      }
-   }
-}
-
-
-/**
- * Interpolate the active attributes (and'd with attrMask) to
- * fill in span->array->attribs[].
- * Perspective correction will be done.  The point/line/triangle function
- * should have computed attrStart/Step values for FRAG_ATTRIB_WPOS[3]!
- */
-static INLINE void
-interpolate_active_attribs(GLcontext *ctx, SWspan *span, GLbitfield attrMask)
-{
-   const SWcontext *swrast = SWRAST_CONTEXT(ctx);
-
-   /*
-    * Don't overwrite existing array values, such as colors that may have
-    * been produced by glDraw/CopyPixels.
-    */
-   attrMask &= ~span->arrayAttribs;
-
-   ATTRIB_LOOP_BEGIN
-      if (attrMask & (1 << attr)) {
-         const GLfloat dwdx = span->attrStepX[FRAG_ATTRIB_WPOS][3];
-         GLfloat w = span->attrStart[FRAG_ATTRIB_WPOS][3];
-         const GLfloat dv0dx = span->attrStepX[attr][0];
-         const GLfloat dv1dx = span->attrStepX[attr][1];
-         const GLfloat dv2dx = span->attrStepX[attr][2];
-         const GLfloat dv3dx = span->attrStepX[attr][3];
-         GLfloat v0 = span->attrStart[attr][0] + span->leftClip * dv0dx;
-         GLfloat v1 = span->attrStart[attr][1] + span->leftClip * dv1dx;
-         GLfloat v2 = span->attrStart[attr][2] + span->leftClip * dv2dx;
-         GLfloat v3 = span->attrStart[attr][3] + span->leftClip * dv3dx;
-         GLuint k;
-         for (k = 0; k < span->end; k++) {
-            const GLfloat invW = 1.0f / w;
-            span->array->attribs[attr][k][0] = v0 * invW;
-            span->array->attribs[attr][k][1] = v1 * invW;
-            span->array->attribs[attr][k][2] = v2 * invW;
-            span->array->attribs[attr][k][3] = v3 * invW;
-            v0 += dv0dx;
-            v1 += dv1dx;
-            v2 += dv2dx;
-            v3 += dv3dx;
-            w += dwdx;
-         }
-         ASSERT((span->arrayAttribs & (1 << attr)) == 0);
-         span->arrayAttribs |= (1 << attr);
-      }
-   ATTRIB_LOOP_END
-}
-
-
-/**
- * Interpolate primary colors to fill in the span->array->rgba8 (or rgb16)
- * color array.
- */
-static INLINE void
-interpolate_int_colors(GLcontext *ctx, SWspan *span)
-{
-   const GLuint n = span->end;
-   GLuint i;
-
-#if CHAN_BITS != 32
-   ASSERT(!(span->arrayMask & SPAN_RGBA));
-#endif
-
-   switch (span->array->ChanType) {
-#if CHAN_BITS != 32
-   case GL_UNSIGNED_BYTE:
-      {
-         GLubyte (*rgba)[4] = span->array->rgba8;
-         if (span->interpMask & SPAN_FLAT) {
-            GLubyte color[4];
-            color[RCOMP] = FixedToInt(span->red);
-            color[GCOMP] = FixedToInt(span->green);
-            color[BCOMP] = FixedToInt(span->blue);
-            color[ACOMP] = FixedToInt(span->alpha);
-            for (i = 0; i < n; i++) {
-               COPY_4UBV(rgba[i], color);
-            }
-         }
-         else {
-            GLfixed r = span->red;
-            GLfixed g = span->green;
-            GLfixed b = span->blue;
-            GLfixed a = span->alpha;
-            GLint dr = span->redStep;
-            GLint dg = span->greenStep;
-            GLint db = span->blueStep;
-            GLint da = span->alphaStep;
-            for (i = 0; i < n; i++) {
-               rgba[i][RCOMP] = FixedToChan(r);
-               rgba[i][GCOMP] = FixedToChan(g);
-               rgba[i][BCOMP] = FixedToChan(b);
-               rgba[i][ACOMP] = FixedToChan(a);
-               r += dr;
-               g += dg;
-               b += db;
-               a += da;
-            }
-         }
-      }
-      break;
-   case GL_UNSIGNED_SHORT:
-      {
-         GLushort (*rgba)[4] = span->array->rgba16;
-         if (span->interpMask & SPAN_FLAT) {
-            GLushort color[4];
-            color[RCOMP] = FixedToInt(span->red);
-            color[GCOMP] = FixedToInt(span->green);
-            color[BCOMP] = FixedToInt(span->blue);
-            color[ACOMP] = FixedToInt(span->alpha);
-            for (i = 0; i < n; i++) {
-               COPY_4V(rgba[i], color);
-            }
-         }
-         else {
-            GLushort (*rgba)[4] = span->array->rgba16;
-            GLfixed r, g, b, a;
-            GLint dr, dg, db, da;
-            r = span->red;
-            g = span->green;
-            b = span->blue;
-            a = span->alpha;
-            dr = span->redStep;
-            dg = span->greenStep;
-            db = span->blueStep;
-            da = span->alphaStep;
-            for (i = 0; i < n; i++) {
-               rgba[i][RCOMP] = FixedToChan(r);
-               rgba[i][GCOMP] = FixedToChan(g);
-               rgba[i][BCOMP] = FixedToChan(b);
-               rgba[i][ACOMP] = FixedToChan(a);
-               r += dr;
-               g += dg;
-               b += db;
-               a += da;
-            }
-         }
-      }
-      break;
-#endif
-   case GL_FLOAT:
-      interpolate_active_attribs(ctx, span, FRAG_BIT_COL0);
-      break;
-   default:
-      _mesa_problem(NULL, "bad datatype in interpolate_int_colors");
-   }
-   span->arrayMask |= SPAN_RGBA;
-}
-
-
-/**
- * Populate the FRAG_ATTRIB_COL0 array.
- */
-static INLINE void
-interpolate_float_colors(SWspan *span)
-{
-   GLfloat (*col0)[4] = span->array->attribs[FRAG_ATTRIB_COL0];
-   const GLuint n = span->end;
-   GLuint i;
-
-   assert(!(span->arrayAttribs & FRAG_BIT_COL0));
-
-   if (span->arrayMask & SPAN_RGBA) {
-      /* convert array of int colors */
-      for (i = 0; i < n; i++) {
-         col0[i][0] = UBYTE_TO_FLOAT(span->array->rgba8[i][0]);
-         col0[i][1] = UBYTE_TO_FLOAT(span->array->rgba8[i][1]);
-         col0[i][2] = UBYTE_TO_FLOAT(span->array->rgba8[i][2]);
-         col0[i][3] = UBYTE_TO_FLOAT(span->array->rgba8[i][3]);
-      }
-   }
-   else {
-      /* interpolate red/green/blue/alpha to get float colors */
-      ASSERT(span->interpMask & SPAN_RGBA);
-      if (span->interpMask & SPAN_FLAT) {
-         GLfloat r = FixedToFloat(span->red);
-         GLfloat g = FixedToFloat(span->green);
-         GLfloat b = FixedToFloat(span->blue);
-         GLfloat a = FixedToFloat(span->alpha);
-         for (i = 0; i < n; i++) {
-            ASSIGN_4V(col0[i], r, g, b, a);
-         }
-      }
-      else {
-         GLfloat r = FixedToFloat(span->red);
-         GLfloat g = FixedToFloat(span->green);
-         GLfloat b = FixedToFloat(span->blue);
-         GLfloat a = FixedToFloat(span->alpha);
-         GLfloat dr = FixedToFloat(span->redStep);
-         GLfloat dg = FixedToFloat(span->greenStep);
-         GLfloat db = FixedToFloat(span->blueStep);
-         GLfloat da = FixedToFloat(span->alphaStep);
-         for (i = 0; i < n; i++) {
-            col0[i][0] = r;
-            col0[i][1] = g;
-            col0[i][2] = b;
-            col0[i][3] = a;
-            r += dr;
-            g += dg;
-            b += db;
-            a += da;
-         }
-      }
-   }
-
-   span->arrayAttribs |= FRAG_BIT_COL0;
-   span->array->ChanType = GL_FLOAT;
-}
-
-
-
-/**
- * Fill in the span.zArray array from the span->z, zStep values.
- */
-void
-_swrast_span_interpolate_z( const GLcontext *ctx, SWspan *span )
-{
-   const GLuint n = span->end;
-   GLuint i;
-
-   ASSERT(!(span->arrayMask & SPAN_Z));
-
-   if (ctx->DrawBuffer->Visual.depthBits <= 16) {
-      GLfixed zval = span->z;
-      GLuint *z = span->array->z; 
-      for (i = 0; i < n; i++) {
-         z[i] = FixedToInt(zval);
-         zval += span->zStep;
-      }
-   }
-   else {
-      /* Deep Z buffer, no fixed->int shift */
-      GLuint zval = span->z;
-      GLuint *z = span->array->z;
-      for (i = 0; i < n; i++) {
-         z[i] = zval;
-         zval += span->zStep;
-      }
-   }
-   span->interpMask &= ~SPAN_Z;
-   span->arrayMask |= SPAN_Z;
-}
-
-
-/**
- * Compute mipmap LOD from partial derivatives.
- * This the ideal solution, as given in the OpenGL spec.
- */
-GLfloat
-_swrast_compute_lambda(GLfloat dsdx, GLfloat dsdy, GLfloat dtdx, GLfloat dtdy,
-                       GLfloat dqdx, GLfloat dqdy, GLfloat texW, GLfloat texH,
-                       GLfloat s, GLfloat t, GLfloat q, GLfloat invQ)
-{
-   GLfloat dudx = texW * ((s + dsdx) / (q + dqdx) - s * invQ);
-   GLfloat dvdx = texH * ((t + dtdx) / (q + dqdx) - t * invQ);
-   GLfloat dudy = texW * ((s + dsdy) / (q + dqdy) - s * invQ);
-   GLfloat dvdy = texH * ((t + dtdy) / (q + dqdy) - t * invQ);
-   GLfloat x = SQRTF(dudx * dudx + dvdx * dvdx);
-   GLfloat y = SQRTF(dudy * dudy + dvdy * dvdy);
-   GLfloat rho = MAX2(x, y);
-   GLfloat lambda = LOG2(rho);
-   return lambda;
-}
-
-
-/**
- * Compute mipmap LOD from partial derivatives.
- * This is a faster approximation than above function.
- */
-#if 0
-GLfloat
-_swrast_compute_lambda(GLfloat dsdx, GLfloat dsdy, GLfloat dtdx, GLfloat dtdy,
-                     GLfloat dqdx, GLfloat dqdy, GLfloat texW, GLfloat texH,
-                     GLfloat s, GLfloat t, GLfloat q, GLfloat invQ)
-{
-   GLfloat dsdx2 = (s + dsdx) / (q + dqdx) - s * invQ;
-   GLfloat dtdx2 = (t + dtdx) / (q + dqdx) - t * invQ;
-   GLfloat dsdy2 = (s + dsdy) / (q + dqdy) - s * invQ;
-   GLfloat dtdy2 = (t + dtdy) / (q + dqdy) - t * invQ;
-   GLfloat maxU, maxV, rho, lambda;
-   dsdx2 = FABSF(dsdx2);
-   dsdy2 = FABSF(dsdy2);
-   dtdx2 = FABSF(dtdx2);
-   dtdy2 = FABSF(dtdy2);
-   maxU = MAX2(dsdx2, dsdy2) * texW;
-   maxV = MAX2(dtdx2, dtdy2) * texH;
-   rho = MAX2(maxU, maxV);
-   lambda = LOG2(rho);
-   return lambda;
-}
-#endif
-
-
-/**
- * Fill in the span.array->attrib[FRAG_ATTRIB_TEXn] arrays from the
- * using the attrStart/Step values.
- *
- * This function only used during fixed-function fragment processing.
- *
- * Note: in the places where we divide by Q (or mult by invQ) we're
- * really doing two things: perspective correction and texcoord
- * projection.  Remember, for texcoord (s,t,r,q) we need to index
- * texels with (s/q, t/q, r/q).
- */
-static void
-interpolate_texcoords(GLcontext *ctx, SWspan *span)
-{
-   const GLuint maxUnit
-      = (ctx->Texture._EnabledCoordUnits > 1) ? ctx->Const.MaxTextureUnits : 1;
-   GLuint u;
-
-   /* XXX CoordUnits vs. ImageUnits */
-   for (u = 0; u < maxUnit; u++) {
-      if (ctx->Texture._EnabledCoordUnits & (1 << u)) {
-         const GLuint attr = FRAG_ATTRIB_TEX0 + u;
-         const struct gl_texture_object *obj = ctx->Texture.Unit[u]._Current;
-         GLfloat texW, texH;
-         GLboolean needLambda;
-         GLfloat (*texcoord)[4] = span->array->attribs[attr];
-         GLfloat *lambda = span->array->lambda[u];
-         const GLfloat dsdx = span->attrStepX[attr][0];
-         const GLfloat dsdy = span->attrStepY[attr][0];
-         const GLfloat dtdx = span->attrStepX[attr][1];
-         const GLfloat dtdy = span->attrStepY[attr][1];
-         const GLfloat drdx = span->attrStepX[attr][2];
-         const GLfloat dqdx = span->attrStepX[attr][3];
-         const GLfloat dqdy = span->attrStepY[attr][3];
-         GLfloat s = span->attrStart[attr][0] + span->leftClip * dsdx;
-         GLfloat t = span->attrStart[attr][1] + span->leftClip * dtdx;
-         GLfloat r = span->attrStart[attr][2] + span->leftClip * drdx;
-         GLfloat q = span->attrStart[attr][3] + span->leftClip * dqdx;
-
-         if (obj) {
-            const struct gl_texture_image *img = obj->Image[0][obj->BaseLevel];
-            needLambda = (obj->MinFilter != obj->MagFilter)
-               || ctx->FragmentProgram._Current;
-            texW = img->WidthScale;
-            texH = img->HeightScale;
-         }
-         else {
-            /* using a fragment program */
-            texW = 1.0;
-            texH = 1.0;
-            needLambda = GL_FALSE;
-         }
-
-         if (needLambda) {
-            GLuint i;
-            if (ctx->FragmentProgram._Current
-                || ctx->ATIFragmentShader._Enabled) {
-               /* do perspective correction but don't divide s, t, r by q */
-               const GLfloat dwdx = span->attrStepX[FRAG_ATTRIB_WPOS][3];
-               GLfloat w = span->attrStart[FRAG_ATTRIB_WPOS][3] + span->leftClip * dwdx;
-               for (i = 0; i < span->end; i++) {
-                  const GLfloat invW = 1.0F / w;
-                  texcoord[i][0] = s * invW;
-                  texcoord[i][1] = t * invW;
-                  texcoord[i][2] = r * invW;
-                  texcoord[i][3] = q * invW;
-                  lambda[i] = _swrast_compute_lambda(dsdx, dsdy, dtdx, dtdy,
-                                                     dqdx, dqdy, texW, texH,
-                                                     s, t, q, invW);
-                  s += dsdx;
-                  t += dtdx;
-                  r += drdx;
-                  q += dqdx;
-                  w += dwdx;
-               }
-            }
-            else {
-               for (i = 0; i < span->end; i++) {
-                  const GLfloat invQ = (q == 0.0F) ? 1.0F : (1.0F / q);
-                  texcoord[i][0] = s * invQ;
-                  texcoord[i][1] = t * invQ;
-                  texcoord[i][2] = r * invQ;
-                  texcoord[i][3] = q;
-                  lambda[i] = _swrast_compute_lambda(dsdx, dsdy, dtdx, dtdy,
-                                                     dqdx, dqdy, texW, texH,
-                                                     s, t, q, invQ);
-                  s += dsdx;
-                  t += dtdx;
-                  r += drdx;
-                  q += dqdx;
-               }
-            }
-            span->arrayMask |= SPAN_LAMBDA;
-         }
-         else {
-            GLuint i;
-            if (ctx->FragmentProgram._Current ||
-                ctx->ATIFragmentShader._Enabled) {
-               /* do perspective correction but don't divide s, t, r by q */
-               const GLfloat dwdx = span->attrStepX[FRAG_ATTRIB_WPOS][3];
-               GLfloat w = span->attrStart[FRAG_ATTRIB_WPOS][3] + span->leftClip * dwdx;
-               for (i = 0; i < span->end; i++) {
-                  const GLfloat invW = 1.0F / w;
-                  texcoord[i][0] = s * invW;
-                  texcoord[i][1] = t * invW;
-                  texcoord[i][2] = r * invW;
-                  texcoord[i][3] = q * invW;
-                  lambda[i] = 0.0;
-                  s += dsdx;
-                  t += dtdx;
-                  r += drdx;
-                  q += dqdx;
-                  w += dwdx;
-               }
-            }
-            else if (dqdx == 0.0F) {
-               /* Ortho projection or polygon's parallel to window X axis */
-               const GLfloat invQ = (q == 0.0F) ? 1.0F : (1.0F / q);
-               for (i = 0; i < span->end; i++) {
-                  texcoord[i][0] = s * invQ;
-                  texcoord[i][1] = t * invQ;
-                  texcoord[i][2] = r * invQ;
-                  texcoord[i][3] = q;
-                  lambda[i] = 0.0;
-                  s += dsdx;
-                  t += dtdx;
-                  r += drdx;
-               }
-            }
-            else {
-               for (i = 0; i < span->end; i++) {
-                  const GLfloat invQ = (q == 0.0F) ? 1.0F : (1.0F / q);
-                  texcoord[i][0] = s * invQ;
-                  texcoord[i][1] = t * invQ;
-                  texcoord[i][2] = r * invQ;
-                  texcoord[i][3] = q;
-                  lambda[i] = 0.0;
-                  s += dsdx;
-                  t += dtdx;
-                  r += drdx;
-                  q += dqdx;
-               }
-            }
-         } /* lambda */
-      } /* if */
-   } /* for */
-}
-
-
-/**
- * Fill in the arrays->attribs[FRAG_ATTRIB_WPOS] array.
- */
-static INLINE void
-interpolate_wpos(GLcontext *ctx, SWspan *span)
-{
-   GLfloat (*wpos)[4] = span->array->attribs[FRAG_ATTRIB_WPOS];
-   GLuint i;
-   const GLfloat zScale = 1.0F / ctx->DrawBuffer->_DepthMaxF;
-   GLfloat w, dw;
-
-   if (span->arrayMask & SPAN_XY) {
-      for (i = 0; i < span->end; i++) {
-         wpos[i][0] = (GLfloat) span->array->x[i];
-         wpos[i][1] = (GLfloat) span->array->y[i];
-      }
-   }
-   else {
-      for (i = 0; i < span->end; i++) {
-         wpos[i][0] = (GLfloat) span->x + i;
-         wpos[i][1] = (GLfloat) span->y;
-      }
-   }
-
-   dw = span->attrStepX[FRAG_ATTRIB_WPOS][3];
-   w = span->attrStart[FRAG_ATTRIB_WPOS][3] + span->leftClip * dw;
-   for (i = 0; i < span->end; i++) {
-      wpos[i][2] = (GLfloat) span->array->z[i] * zScale;
-      wpos[i][3] = w;
-      w += dw;
-   }
-}
-
-
-/**
- * Apply the current polygon stipple pattern to a span of pixels.
- */
-static INLINE void
-stipple_polygon_span(GLcontext *ctx, SWspan *span)
-{
-   GLubyte *mask = span->array->mask;
-
-   ASSERT(ctx->Polygon.StippleFlag);
-
-   if (span->arrayMask & SPAN_XY) {
-      /* arrays of x/y pixel coords */
-      GLuint i;
-      for (i = 0; i < span->end; i++) {
-         const GLint col = span->array->x[i] % 32;
-         const GLint row = span->array->y[i] % 32;
-         const GLuint stipple = ctx->PolygonStipple[row];
-         if (((1 << col) & stipple) == 0) {
-            mask[i] = 0;
-         }
-      }
-   }
-   else {
-      /* horizontal span of pixels */
-      const GLuint highBit = 1 << 31;
-      const GLuint stipple = ctx->PolygonStipple[span->y % 32];
-      GLuint i, m = highBit >> (GLuint) (span->x % 32);
-      for (i = 0; i < span->end; i++) {
-         if ((m & stipple) == 0) {
-            mask[i] = 0;
-         }
-         m = m >> 1;
-         if (m == 0) {
-            m = highBit;
-         }
-      }
-   }
-   span->writeAll = GL_FALSE;
-}
-
-
-/**
- * Clip a pixel span to the current buffer/window boundaries:
- * DrawBuffer->_Xmin, _Xmax, _Ymin, _Ymax.  This will accomplish
- * window clipping and scissoring.
- * Return:   GL_TRUE   some pixels still visible
- *           GL_FALSE  nothing visible
- */
-static INLINE GLuint
-clip_span( GLcontext *ctx, SWspan *span )
-{
-   const GLint xmin = ctx->DrawBuffer->_Xmin;
-   const GLint xmax = ctx->DrawBuffer->_Xmax;
-   const GLint ymin = ctx->DrawBuffer->_Ymin;
-   const GLint ymax = ctx->DrawBuffer->_Ymax;
-
-   span->leftClip = 0;
-
-   if (span->arrayMask & SPAN_XY) {
-      /* arrays of x/y pixel coords */
-      const GLint *x = span->array->x;
-      const GLint *y = span->array->y;
-      const GLint n = span->end;
-      GLubyte *mask = span->array->mask;
-      GLint i;
-      if (span->arrayMask & SPAN_MASK) {
-         /* note: using & intead of && to reduce branches */
-         for (i = 0; i < n; i++) {
-            mask[i] &= (x[i] >= xmin) & (x[i] < xmax)
-                     & (y[i] >= ymin) & (y[i] < ymax);
-         }
-      }
-      else {
-         /* note: using & intead of && to reduce branches */
-         for (i = 0; i < n; i++) {
-            mask[i] = (x[i] >= xmin) & (x[i] < xmax)
-                    & (y[i] >= ymin) & (y[i] < ymax);
-         }
-      }
-      return GL_TRUE;  /* some pixels visible */
-   }
-   else {
-      /* horizontal span of pixels */
-      const GLint x = span->x;
-      const GLint y = span->y;
-      GLint n = span->end;
-
-      /* Trivial rejection tests */
-      if (y < ymin || y >= ymax || x + n <= xmin || x >= xmax) {
-         span->end = 0;
-         return GL_FALSE;  /* all pixels clipped */
-      }
-
-      /* Clip to right */
-      if (x + n > xmax) {
-         ASSERT(x < xmax);
-         n = span->end = xmax - x;
-      }
-
-      /* Clip to the left */
-      if (x < xmin) {
-         const GLint leftClip = xmin - x;
-         GLuint i;
-
-         ASSERT(leftClip > 0);
-         ASSERT(x + n > xmin);
-
-         /* Clip 'leftClip' pixels from the left side.
-          * The span->leftClip field will be applied when we interpolate
-          * fragment attributes.
-          * For arrays of values, shift them left.
-          */
-         for (i = 0; i < FRAG_ATTRIB_MAX; i++) {
-            if (span->interpMask & (1 << i)) {
-               GLuint j;
-               for (j = 0; j < 4; j++) {
-                  span->attrStart[i][j] += leftClip * span->attrStepX[i][j];
-               }
-            }
-         }
-
-         span->red += leftClip * span->redStep;
-         span->green += leftClip * span->greenStep;
-         span->blue += leftClip * span->blueStep;
-         span->alpha += leftClip * span->alphaStep;
-         span->index += leftClip * span->indexStep;
-         span->z += leftClip * span->zStep;
-         span->intTex[0] += leftClip * span->intTexStep[0];
-         span->intTex[1] += leftClip * span->intTexStep[1];
-
-#define SHIFT_ARRAY(ARRAY, SHIFT, LEN) \
-         memcpy(ARRAY, ARRAY + (SHIFT), (LEN) * sizeof(ARRAY[0]))
-
-         for (i = 0; i < FRAG_ATTRIB_MAX; i++) {
-            if (span->arrayAttribs & (1 << i)) {
-               /* shift array elements left by 'leftClip' */
-               SHIFT_ARRAY(span->array->attribs[i], leftClip, n - leftClip);
-            }
-         }
-
-         SHIFT_ARRAY(span->array->mask, leftClip, n - leftClip);
-         SHIFT_ARRAY(span->array->rgba8, leftClip, n - leftClip);
-         SHIFT_ARRAY(span->array->rgba16, leftClip, n - leftClip);
-         SHIFT_ARRAY(span->array->x, leftClip, n - leftClip);
-         SHIFT_ARRAY(span->array->y, leftClip, n - leftClip);
-         SHIFT_ARRAY(span->array->z, leftClip, n - leftClip);
-         SHIFT_ARRAY(span->array->index, leftClip, n - leftClip);
-         for (i = 0; i < MAX_TEXTURE_COORD_UNITS; i++) {
-            SHIFT_ARRAY(span->array->lambda[i], leftClip, n - leftClip);
-         }
-         SHIFT_ARRAY(span->array->coverage, leftClip, n - leftClip);
-
-#undef SHIFT_ARRAY
-
-         span->leftClip = leftClip;
-         span->x = xmin;
-         span->end -= leftClip;
-         span->writeAll = GL_FALSE;
-      }
-
-      ASSERT(span->x >= xmin);
-      ASSERT(span->x + span->end <= xmax);
-      ASSERT(span->y >= ymin);
-      ASSERT(span->y < ymax);
-
-      return GL_TRUE;  /* some pixels visible */
-   }
-}
-
-
-/**
- * Add specular colors to primary colors.
- * Only called during fixed-function operation.
- * Result is float color array (FRAG_ATTRIB_COL0).
- */
-static INLINE void
-add_specular(GLcontext *ctx, SWspan *span)
-{
-   const SWcontext *swrast = SWRAST_CONTEXT(ctx);
-   const GLubyte *mask = span->array->mask;
-   GLfloat (*col0)[4] = span->array->attribs[FRAG_ATTRIB_COL0];
-   GLfloat (*col1)[4] = span->array->attribs[FRAG_ATTRIB_COL1];
-   GLuint i;
-
-   ASSERT(!ctx->FragmentProgram._Current);
-   ASSERT(span->arrayMask & SPAN_RGBA);
-   ASSERT(swrast->_ActiveAttribMask & FRAG_BIT_COL1);
-   (void) swrast; /* silence warning */
-
-   if (span->array->ChanType == GL_FLOAT) {
-      if ((span->arrayAttribs & FRAG_BIT_COL0) == 0) {
-         interpolate_active_attribs(ctx, span, FRAG_BIT_COL0);
-      }
-   }
-   else {
-      /* need float colors */
-      if ((span->arrayAttribs & FRAG_BIT_COL0) == 0) {
-         interpolate_float_colors(span);
-      }
-   }
-
-   if ((span->arrayAttribs & FRAG_BIT_COL1) == 0) {
-      /* XXX could avoid this and interpolate COL1 in the loop below */
-      interpolate_active_attribs(ctx, span, FRAG_BIT_COL1);
-   }
-
-   ASSERT(span->arrayAttribs & FRAG_BIT_COL0);
-   ASSERT(span->arrayAttribs & FRAG_BIT_COL1);
-
-   for (i = 0; i < span->end; i++) {
-      if (mask[i]) {
-         col0[i][0] += col1[i][0];
-         col0[i][1] += col1[i][1];
-         col0[i][2] += col1[i][2];
-      }
-   }
-
-   span->array->ChanType = GL_FLOAT;
-}
-
-
-/**
- * Apply antialiasing coverage value to alpha values.
- */
-static INLINE void
-apply_aa_coverage(SWspan *span)
-{
-   const GLfloat *coverage = span->array->coverage;
-   GLuint i;
-   if (span->array->ChanType == GL_UNSIGNED_BYTE) {
-      GLubyte (*rgba)[4] = span->array->rgba8;
-      for (i = 0; i < span->end; i++) {
-         const GLfloat a = rgba[i][ACOMP] * coverage[i];
-         rgba[i][ACOMP] = (GLubyte) CLAMP(a, 0.0, 255.0);
-         ASSERT(coverage[i] >= 0.0);
-         ASSERT(coverage[i] <= 1.0);
-      }
-   }
-   else if (span->array->ChanType == GL_UNSIGNED_SHORT) {
-      GLushort (*rgba)[4] = span->array->rgba16;
-      for (i = 0; i < span->end; i++) {
-         const GLfloat a = rgba[i][ACOMP] * coverage[i];
-         rgba[i][ACOMP] = (GLushort) CLAMP(a, 0.0, 65535.0);
-      }
-   }
-   else {
-      GLfloat (*rgba)[4] = span->array->attribs[FRAG_ATTRIB_COL0];
-      for (i = 0; i < span->end; i++) {
-         rgba[i][ACOMP] = rgba[i][ACOMP] * coverage[i];
-         /* clamp later */
-      }
-   }
-}
-
-
-/**
- * Clamp span's float colors to [0,1]
- */
-static INLINE void
-clamp_colors(SWspan *span)
-{
-   GLfloat (*rgba)[4] = span->array->attribs[FRAG_ATTRIB_COL0];
-   GLuint i;
-   ASSERT(span->array->ChanType == GL_FLOAT);
-   for (i = 0; i < span->end; i++) {
-      rgba[i][RCOMP] = CLAMP(rgba[i][RCOMP], 0.0F, 1.0F);
-      rgba[i][GCOMP] = CLAMP(rgba[i][GCOMP], 0.0F, 1.0F);
-      rgba[i][BCOMP] = CLAMP(rgba[i][BCOMP], 0.0F, 1.0F);
-      rgba[i][ACOMP] = CLAMP(rgba[i][ACOMP], 0.0F, 1.0F);
-   }
-}
-
-
-/**
- * Convert the span's color arrays to the given type.
- * The only way 'output' can be greater than zero is when we have a fragment
- * program that writes to gl_FragData[1] or higher.
- * \param output  which fragment program color output is being processed
- */
-static INLINE void
-convert_color_type(SWspan *span, GLenum newType, GLuint output)
-{
-   GLvoid *src, *dst;
-
-   if (output > 0 || span->array->ChanType == GL_FLOAT) {
-      src = span->array->attribs[FRAG_ATTRIB_COL0 + output];
-      span->array->ChanType = GL_FLOAT;
-   }
-   else if (span->array->ChanType == GL_UNSIGNED_BYTE) {
-      src = span->array->rgba8;
-   }
-   else {
-      ASSERT(span->array->ChanType == GL_UNSIGNED_SHORT);
-      src = span->array->rgba16;
-   }
-
-   if (newType == GL_UNSIGNED_BYTE) {
-      dst = span->array->rgba8;
-   }
-   else if (newType == GL_UNSIGNED_SHORT) {
-      dst = span->array->rgba16;
-   }
-   else {
-      dst = span->array->attribs[FRAG_ATTRIB_COL0];
-   }
-
-   _mesa_convert_colors(span->array->ChanType, src,
-                        newType, dst,
-                        span->end, span->array->mask);
-
-   span->array->ChanType = newType;
-   span->array->rgba = dst;
-}
-
-
-
-/**
- * Apply fragment shader, fragment program or normal texturing to span.
- */
-static INLINE void
-shade_texture_span(GLcontext *ctx, SWspan *span)
-{
-   GLbitfield inputsRead;
-
-   /* Determine which fragment attributes are actually needed */
-   if (ctx->FragmentProgram._Current) {
-      inputsRead = ctx->FragmentProgram._Current->Base.InputsRead;
-   }
-   else {
-      /* XXX we could be a bit smarter about this */
-      inputsRead = ~0;
-   }
-
-   if (ctx->FragmentProgram._Current ||
-       ctx->ATIFragmentShader._Enabled) {
-      /* programmable shading */
-      if (span->primitive == GL_BITMAP && span->array->ChanType != GL_FLOAT) {
-         convert_color_type(span, GL_FLOAT, 0);
-      }
-      else {
-         span->array->rgba = (void *) span->array->attribs[FRAG_ATTRIB_COL0];
-      }
-
-      if (span->primitive != GL_POINT ||
-	  (span->interpMask & SPAN_RGBA) ||
-	  ctx->Point.PointSprite) {
-         /* for single-pixel points, we populated the arrays already */
-         interpolate_active_attribs(ctx, span, ~0);
-      }
-      span->array->ChanType = GL_FLOAT;
-
-      if (!(span->arrayMask & SPAN_Z))
-         _swrast_span_interpolate_z (ctx, span);
-
-#if 0
-      if (inputsRead & FRAG_BIT_WPOS)
-#else
-      /* XXX always interpolate wpos so that DDX/DDY work */
-#endif
-         interpolate_wpos(ctx, span);
-
-      /* Run fragment program/shader now */
-      if (ctx->FragmentProgram._Current) {
-         _swrast_exec_fragment_program(ctx, span);
-      }
-      else {
-         ASSERT(ctx->ATIFragmentShader._Enabled);
-         _swrast_exec_fragment_shader(ctx, span);
-      }
-   }
-   else if (ctx->Texture._EnabledCoordUnits) {
-      /* conventional texturing */
-
-#if CHAN_BITS == 32
-      if ((span->arrayAttribs & FRAG_BIT_COL0) == 0) {
-         interpolate_int_colors(ctx, span);
-      }
-#else
-      if (!(span->arrayMask & SPAN_RGBA))
-         interpolate_int_colors(ctx, span);
-#endif
-      if ((span->arrayAttribs & FRAG_BITS_TEX_ANY) == 0x0)
-         interpolate_texcoords(ctx, span);
-
-      _swrast_texture_span(ctx, span);
-   }
-}
-
-
-
-/**
- * Apply all the per-fragment operations to a span.
- * This now includes texturing (_swrast_write_texture_span() is history).
- * This function may modify any of the array values in the span.
- * span->interpMask and span->arrayMask may be changed but will be restored
- * to their original values before returning.
- */
-void
-_swrast_write_rgba_span( GLcontext *ctx, SWspan *span)
-{
-   const SWcontext *swrast = SWRAST_CONTEXT(ctx);
-   const GLuint *colorMask = (GLuint *) ctx->Color.ColorMask;
-   const GLbitfield origInterpMask = span->interpMask;
-   const GLbitfield origArrayMask = span->arrayMask;
-   const GLbitfield origArrayAttribs = span->arrayAttribs;
-   const GLenum origChanType = span->array->ChanType;
-   void * const origRgba = span->array->rgba;
-   const GLboolean shader = (ctx->FragmentProgram._Current
-                             || ctx->ATIFragmentShader._Enabled);
-   const GLboolean shaderOrTexture = shader || ctx->Texture._EnabledCoordUnits;
-   struct gl_framebuffer *fb = ctx->DrawBuffer;
-
-   /*
-   printf("%s()  interp 0x%x  array 0x%x\n", __FUNCTION__,
-          span->interpMask, span->arrayMask);
-   */
-
-   ASSERT(span->primitive == GL_POINT ||
-          span->primitive == GL_LINE ||
-	  span->primitive == GL_POLYGON ||
-          span->primitive == GL_BITMAP);
-
-   /* Fragment write masks */
-   if (span->arrayMask & SPAN_MASK) {
-      /* mask was initialized by caller, probably glBitmap */
-      span->writeAll = GL_FALSE;
-   }
-   else {
-      memset(span->array->mask, 1, span->end);
-      span->writeAll = GL_TRUE;
-   }
-
-   /* Clip to window/scissor box */
-   if (!clip_span(ctx, span)) {
-      return;
-   }
-
-   ASSERT(span->end <= MAX_WIDTH);
-
-   /* Depth bounds test */
-   if (ctx->Depth.BoundsTest && fb->Visual.depthBits > 0) {
-      if (!_swrast_depth_bounds_test(ctx, span)) {
-         return;
-      }
-   }
-
-#ifdef DEBUG
-   /* Make sure all fragments are within window bounds */
-   if (span->arrayMask & SPAN_XY) {
-      /* array of pixel locations */
-      GLuint i;
-      for (i = 0; i < span->end; i++) {
-         if (span->array->mask[i]) {
-            assert(span->array->x[i] >= fb->_Xmin);
-            assert(span->array->x[i] < fb->_Xmax);
-            assert(span->array->y[i] >= fb->_Ymin);
-            assert(span->array->y[i] < fb->_Ymax);
-         }
-      }
-   }
-#endif
-
-   /* Polygon Stippling */
-   if (ctx->Polygon.StippleFlag && span->primitive == GL_POLYGON) {
-      stipple_polygon_span(ctx, span);
-   }
-
-   /* This is the normal place to compute the fragment color/Z
-    * from texturing or shading.
-    */
-   if (shaderOrTexture && !swrast->_DeferredTexture) {
-      shade_texture_span(ctx, span);
-   }
-
-   /* Do the alpha test */
-   if (ctx->Color.AlphaEnabled) {
-      if (!_swrast_alpha_test(ctx, span)) {
-         /* all fragments failed test */
-         goto end;
-      }
-   }
-
-   /* Stencil and Z testing */
-   if (ctx->Stencil._Enabled || ctx->Depth.Test) {
-      if (!(span->arrayMask & SPAN_Z))
-         _swrast_span_interpolate_z(ctx, span);
-
-      if (ctx->Transform.DepthClamp)
-	 _swrast_depth_clamp_span(ctx, span);
-
-      if (ctx->Stencil._Enabled) {
-         /* Combined Z/stencil tests */
-         if (!_swrast_stencil_and_ztest_span(ctx, span)) {
-            /* all fragments failed test */
-            goto end;
-         }
-      }
-      else if (fb->Visual.depthBits > 0) {
-         /* Just regular depth testing */
-         ASSERT(ctx->Depth.Test);
-         ASSERT(span->arrayMask & SPAN_Z);
-         if (!_swrast_depth_test_span(ctx, span)) {
-            /* all fragments failed test */
-            goto end;
-         }
-      }
-   }
-
-   if (ctx->Query.CurrentOcclusionObject) {
-      /* update count of 'passed' fragments */
-      struct gl_query_object *q = ctx->Query.CurrentOcclusionObject;
-      GLuint i;
-      for (i = 0; i < span->end; i++)
-         q->Result += span->array->mask[i];
-   }
-
-   /* We had to wait until now to check for glColorMask(0,0,0,0) because of
-    * the occlusion test.
-    */
-   if (fb->_NumColorDrawBuffers == 1 && colorMask[0] == 0x0) {
-      /* no colors to write */
-      goto end;
-   }
-
-   /* If we were able to defer fragment color computation to now, there's
-    * a good chance that many fragments will have already been killed by
-    * Z/stencil testing.
-    */
-   if (shaderOrTexture && swrast->_DeferredTexture) {
-      shade_texture_span(ctx, span);
-   }
-
-#if CHAN_BITS == 32
-   if ((span->arrayAttribs & FRAG_BIT_COL0) == 0) {
-      interpolate_active_attribs(ctx, span, FRAG_BIT_COL0);
-   }
-#else
-   if ((span->arrayMask & SPAN_RGBA) == 0) {
-      interpolate_int_colors(ctx, span);
-   }
-#endif
-
-   ASSERT(span->arrayMask & SPAN_RGBA);
-
-   if (span->primitive == GL_BITMAP || !swrast->SpecularVertexAdd) {
-      /* Add primary and specular (diffuse + specular) colors */
-      if (!shader) {
-         if (ctx->Fog.ColorSumEnabled ||
-             (ctx->Light.Enabled &&
-              ctx->Light.Model.ColorControl == GL_SEPARATE_SPECULAR_COLOR)) {
-            add_specular(ctx, span);
-         }
-      }
-   }
-
-   /* Fog */
-   if (swrast->_FogEnabled) {
-      _swrast_fog_rgba_span(ctx, span);
-   }
-
-   /* Antialias coverage application */
-   if (span->arrayMask & SPAN_COVERAGE) {
-      apply_aa_coverage(span);
-   }
-
-   /* Clamp color/alpha values over the range [0.0, 1.0] before storage */
-   if (ctx->Color.ClampFragmentColor == GL_TRUE &&
-       span->array->ChanType == GL_FLOAT) {
-      clamp_colors(span);
-   }
-
-   /*
-    * Write to renderbuffers.
-    * Depending on glDrawBuffer() state and the which color outputs are
-    * written by the fragment shader, we may either replicate one color to
-    * all renderbuffers or write a different color to each renderbuffer.
-    * multiFragOutputs=TRUE for the later case.
-    */
-   {
-      const GLuint numBuffers = fb->_NumColorDrawBuffers;
-      const struct gl_fragment_program *fp = ctx->FragmentProgram._Current;
-      const GLboolean multiFragOutputs = 
-         (fp && fp->Base.OutputsWritten >= (1 << FRAG_RESULT_DATA0));
-      GLuint buf;
-
-      for (buf = 0; buf < numBuffers; buf++) {
-         struct gl_renderbuffer *rb = fb->_ColorDrawBuffers[buf];
-
-         /* color[fragOutput] will be written to buffer[buf] */
-
-         if (rb) {
-            GLchan rgbaSave[MAX_WIDTH][4];
-            const GLuint fragOutput = multiFragOutputs ? buf : 0;
-
-            /* set span->array->rgba to colors for render buffer's datatype */
-            if (rb->DataType != span->array->ChanType || fragOutput > 0) {
-               convert_color_type(span, rb->DataType, fragOutput);
-            }
-            else {
-               if (rb->DataType == GL_UNSIGNED_BYTE) {
-                  span->array->rgba = span->array->rgba8;
-               }
-               else if (rb->DataType == GL_UNSIGNED_SHORT) {
-                  span->array->rgba = (void *) span->array->rgba16;
-               }
-               else {
-                  span->array->rgba = (void *)
-                     span->array->attribs[FRAG_ATTRIB_COL0];
-               }
-            }
-
-            if (!multiFragOutputs && numBuffers > 1) {
-               /* save colors for second, third renderbuffer writes */
-               memcpy(rgbaSave, span->array->rgba,
-                      4 * span->end * sizeof(GLchan));
-            }
-
-            ASSERT(rb->_BaseFormat == GL_RGBA || rb->_BaseFormat == GL_RGB ||
-		   rb->_BaseFormat == GL_ALPHA);
-
-            if (ctx->Color._LogicOpEnabled) {
-               _swrast_logicop_rgba_span(ctx, rb, span);
-            }
-            else if ((ctx->Color.BlendEnabled >> buf) & 1) {
-               _swrast_blend_span(ctx, rb, span);
-            }
-
-            if (colorMask[buf] != 0xffffffff) {
-               _swrast_mask_rgba_span(ctx, rb, span, buf);
-            }
-
-            if (span->arrayMask & SPAN_XY) {
-               /* array of pixel coords */
-               ASSERT(rb->PutValues);
-               rb->PutValues(ctx, rb, span->end,
-                             span->array->x, span->array->y,
-                             span->array->rgba, span->array->mask);
-            }
-            else {
-               /* horizontal run of pixels */
-               ASSERT(rb->PutRow);
-               rb->PutRow(ctx, rb, span->end, span->x, span->y,
-                          span->array->rgba,
-                          span->writeAll ? NULL: span->array->mask);
-            }
-
-            if (!multiFragOutputs && numBuffers > 1) {
-               /* restore original span values */
-               memcpy(span->array->rgba, rgbaSave,
-                      4 * span->end * sizeof(GLchan));
-            }
-
-         } /* if rb */
-      } /* for buf */
-   }
-
-end:
-   /* restore these values before returning */
-   span->interpMask = origInterpMask;
-   span->arrayMask = origArrayMask;
-   span->arrayAttribs = origArrayAttribs;
-   span->array->ChanType = origChanType;
-   span->array->rgba = origRgba;
-}
-
-
-/**
- * Read RGBA pixels from a renderbuffer.  Clipping will be done to prevent
- * reading ouside the buffer's boundaries.
- * \param dstType  datatype for returned colors
- * \param rgba  the returned colors
- */
-void
-_swrast_read_rgba_span( GLcontext *ctx, struct gl_renderbuffer *rb,
-                        GLuint n, GLint x, GLint y, GLenum dstType,
-                        GLvoid *rgba)
-{
-   const GLint bufWidth = (GLint) rb->Width;
-   const GLint bufHeight = (GLint) rb->Height;
-
-   if (y < 0 || y >= bufHeight || x + (GLint) n < 0 || x >= bufWidth) {
-      /* completely above, below, or right */
-      /* XXX maybe leave rgba values undefined? */
-      memset(rgba, 0, 4 * n * sizeof(GLchan));
-   }
-   else {
-      GLint skip, length;
-      if (x < 0) {
-         /* left edge clipping */
-         skip = -x;
-         length = (GLint) n - skip;
-         if (length < 0) {
-            /* completely left of window */
-            return;
-         }
-         if (length > bufWidth) {
-            length = bufWidth;
-         }
-      }
-      else if ((GLint) (x + n) > bufWidth) {
-         /* right edge clipping */
-         skip = 0;
-         length = bufWidth - x;
-         if (length < 0) {
-            /* completely to right of window */
-            return;
-         }
-      }
-      else {
-         /* no clipping */
-         skip = 0;
-         length = (GLint) n;
-      }
-
-      ASSERT(rb);
-      ASSERT(rb->GetRow);
-      ASSERT(rb->_BaseFormat == GL_RGB || rb->_BaseFormat == GL_RGBA ||
-	     rb->_BaseFormat == GL_ALPHA);
-
-      if (rb->DataType == dstType) {
-         rb->GetRow(ctx, rb, length, x + skip, y,
-                    (GLubyte *) rgba + skip * RGBA_PIXEL_SIZE(rb->DataType));
-      }
-      else {
-         GLuint temp[MAX_WIDTH * 4];
-         rb->GetRow(ctx, rb, length, x + skip, y, temp);
-         _mesa_convert_colors(rb->DataType, temp,
-                   dstType, (GLubyte *) rgba + skip * RGBA_PIXEL_SIZE(dstType),
-                   length, NULL);
-      }
-   }
-}
-
-
-/**
- * Wrapper for gl_renderbuffer::GetValues() which does clipping to avoid
- * reading values outside the buffer bounds.
- * We can use this for reading any format/type of renderbuffer.
- * \param valueSize is the size in bytes of each value (pixel) put into the
- *                  values array.
- */
-void
-_swrast_get_values(GLcontext *ctx, struct gl_renderbuffer *rb,
-                   GLuint count, const GLint x[], const GLint y[],
-                   void *values, GLuint valueSize)
-{
-   GLuint i, inCount = 0, inStart = 0;
-
-   for (i = 0; i < count; i++) {
-      if (x[i] >= 0 && y[i] >= 0 &&
-	  x[i] < (GLint) rb->Width && y[i] < (GLint) rb->Height) {
-         /* inside */
-         if (inCount == 0)
-            inStart = i;
-         inCount++;
-      }
-      else {
-         if (inCount > 0) {
-            /* read [inStart, inStart + inCount) */
-            rb->GetValues(ctx, rb, inCount, x + inStart, y + inStart,
-                          (GLubyte *) values + inStart * valueSize);
-            inCount = 0;
-         }
-      }
-   }
-   if (inCount > 0) {
-      /* read last values */
-      rb->GetValues(ctx, rb, inCount, x + inStart, y + inStart,
-                    (GLubyte *) values + inStart * valueSize);
-   }
-}
-
-
-/**
- * Wrapper for gl_renderbuffer::PutRow() which does clipping.
- * \param valueSize  size of each value (pixel) in bytes
- */
-void
-_swrast_put_row(GLcontext *ctx, struct gl_renderbuffer *rb,
-                GLuint count, GLint x, GLint y,
-                const GLvoid *values, GLuint valueSize)
-{
-   GLint skip = 0;
-
-   if (y < 0 || y >= (GLint) rb->Height)
-      return; /* above or below */
-
-   if (x + (GLint) count <= 0 || x >= (GLint) rb->Width)
-      return; /* entirely left or right */
-
-   if ((GLint) (x + count) > (GLint) rb->Width) {
-      /* right clip */
-      GLint clip = x + count - rb->Width;
-      count -= clip;
-   }
-
-   if (x < 0) {
-      /* left clip */
-      skip = -x;
-      x = 0;
-      count -= skip;
-   }
-
-   rb->PutRow(ctx, rb, count, x, y,
-              (const GLubyte *) values + skip * valueSize, NULL);
-}
-
-
-/**
- * Wrapper for gl_renderbuffer::GetRow() which does clipping.
- * \param valueSize  size of each value (pixel) in bytes
- */
-void
-_swrast_get_row(GLcontext *ctx, struct gl_renderbuffer *rb,
-                GLuint count, GLint x, GLint y,
-                GLvoid *values, GLuint valueSize)
-{
-   GLint skip = 0;
-
-   if (y < 0 || y >= (GLint) rb->Height)
-      return; /* above or below */
-
-   if (x + (GLint) count <= 0 || x >= (GLint) rb->Width)
-      return; /* entirely left or right */
-
-   if (x + count > rb->Width) {
-      /* right clip */
-      GLint clip = x + count - rb->Width;
-      count -= clip;
-   }
-
-   if (x < 0) {
-      /* left clip */
-      skip = -x;
-      x = 0;
-      count -= skip;
-   }
-
-   rb->GetRow(ctx, rb, count, x, y, (GLubyte *) values + skip * valueSize);
-}
-
-
-/**
- * Get RGBA pixels from the given renderbuffer.
- * Used by blending, logicop and masking functions.
- * \return pointer to the colors we read.
- */
-void *
-_swrast_get_dest_rgba(GLcontext *ctx, struct gl_renderbuffer *rb,
-                      SWspan *span)
-{
-   const GLuint pixelSize = RGBA_PIXEL_SIZE(span->array->ChanType);
-   void *rbPixels;
-
-   /* Point rbPixels to a temporary space */
-   rbPixels = span->array->attribs[FRAG_ATTRIB_MAX - 1];
-
-   /* Get destination values from renderbuffer */
-   if (span->arrayMask & SPAN_XY) {
-      _swrast_get_values(ctx, rb, span->end, span->array->x, span->array->y,
-                         rbPixels, pixelSize);
-   }
-   else {
-      _swrast_get_row(ctx, rb, span->end, span->x, span->y,
-                      rbPixels, pixelSize);
-   }
-
-   return rbPixels;
-}
+/*

+ * Mesa 3-D graphics library

+ * Version:  7.5

+ *

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

+ * Copyright (C) 2009  VMware, Inc.  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.

+ */

+

+

+/**

+ * \file swrast/s_span.c

+ * \brief Span processing functions used by all rasterization functions.

+ * This is where all the per-fragment tests are performed

+ * \author Brian Paul

+ */

+

+#include "main/glheader.h"

+#include "main/colormac.h"

+#include "main/macros.h"

+#include "main/imports.h"

+#include "main/image.h"

+

+#include "s_atifragshader.h"

+#include "s_alpha.h"

+#include "s_blend.h"

+#include "s_context.h"

+#include "s_depth.h"

+#include "s_fog.h"

+#include "s_logic.h"

+#include "s_masking.h"

+#include "s_fragprog.h"

+#include "s_span.h"

+#include "s_stencil.h"

+#include "s_texcombine.h"

+

+

+/**

+ * Set default fragment attributes for the span using the

+ * current raster values.  Used prior to glDraw/CopyPixels

+ * and glBitmap.

+ */

+void

+_swrast_span_default_attribs(struct gl_context *ctx, SWspan *span)

+{

+   GLchan r, g, b, a;

+   /* Z*/

+   {

+      const GLfloat depthMax = ctx->DrawBuffer->_DepthMaxF;

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

+         span->z = FloatToFixed(ctx->Current.RasterPos[2] * depthMax + 0.5F);

+      else {

+         GLfloat tmpf = ctx->Current.RasterPos[2] * depthMax; 

+         tmpf = MIN2(tmpf, depthMax);

+         span->z = (GLint)tmpf;

+      }

+      span->zStep = 0;

+      span->interpMask |= SPAN_Z;

+   }

+

+   /* W (for perspective correction) */

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

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

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

+

+   /* primary color, or color index */

+   UNCLAMPED_FLOAT_TO_CHAN(r, ctx->Current.RasterColor[0]);

+   UNCLAMPED_FLOAT_TO_CHAN(g, ctx->Current.RasterColor[1]);

+   UNCLAMPED_FLOAT_TO_CHAN(b, ctx->Current.RasterColor[2]);

+   UNCLAMPED_FLOAT_TO_CHAN(a, ctx->Current.RasterColor[3]);

+#if CHAN_TYPE == GL_FLOAT

+   span->red = r;

+   span->green = g;

+   span->blue = b;

+   span->alpha = a;

+#else

+   span->red   = IntToFixed(r);

+   span->green = IntToFixed(g);

+   span->blue  = IntToFixed(b);

+   span->alpha = IntToFixed(a);

+#endif

+   span->redStep = 0;

+   span->greenStep = 0;

+   span->blueStep = 0;

+   span->alphaStep = 0;

+   span->interpMask |= SPAN_RGBA;

+

+   COPY_4V(span->attrStart[FRAG_ATTRIB_COL0], ctx->Current.RasterColor);

+   ASSIGN_4V(span->attrStepX[FRAG_ATTRIB_COL0], 0.0, 0.0, 0.0, 0.0);

+   ASSIGN_4V(span->attrStepY[FRAG_ATTRIB_COL0], 0.0, 0.0, 0.0, 0.0);

+

+   /* Secondary color */

+   if (ctx->Light.Enabled || ctx->Fog.ColorSumEnabled)

+   {

+      COPY_4V(span->attrStart[FRAG_ATTRIB_COL1], ctx->Current.RasterSecondaryColor);

+      ASSIGN_4V(span->attrStepX[FRAG_ATTRIB_COL1], 0.0, 0.0, 0.0, 0.0);

+      ASSIGN_4V(span->attrStepY[FRAG_ATTRIB_COL1], 0.0, 0.0, 0.0, 0.0);

+   }

+

+   /* fog */

+   {

+      const SWcontext *swrast = SWRAST_CONTEXT(ctx);

+      GLfloat fogVal; /* a coord or a blend factor */

+      if (swrast->_PreferPixelFog) {

+         /* fog blend factors will be computed from fog coordinates per pixel */

+         fogVal = ctx->Current.RasterDistance;

+      }

+      else {

+         /* fog blend factor should be computed from fogcoord now */

+         fogVal = _swrast_z_to_fogfactor(ctx, ctx->Current.RasterDistance);

+      }

+      span->attrStart[FRAG_ATTRIB_FOGC][0] = fogVal;

+      span->attrStepX[FRAG_ATTRIB_FOGC][0] = 0.0;

+      span->attrStepY[FRAG_ATTRIB_FOGC][0] = 0.0;

+   }

+

+   /* texcoords */

+   {

+      GLuint i;

+      for (i = 0; i < ctx->Const.MaxTextureCoordUnits; i++) {

+         const GLuint attr = FRAG_ATTRIB_TEX0 + i;

+         const GLfloat *tc = ctx->Current.RasterTexCoords[i];

+         if (ctx->FragmentProgram._Current || ctx->ATIFragmentShader._Enabled) {

+            COPY_4V(span->attrStart[attr], tc);

+         }

+         else if (tc[3] > 0.0F) {

+            /* use (s/q, t/q, r/q, 1) */

+            span->attrStart[attr][0] = tc[0] / tc[3];

+            span->attrStart[attr][1] = tc[1] / tc[3];

+            span->attrStart[attr][2] = tc[2] / tc[3];

+            span->attrStart[attr][3] = 1.0;

+         }

+         else {

+            ASSIGN_4V(span->attrStart[attr], 0.0F, 0.0F, 0.0F, 1.0F);

+         }

+         ASSIGN_4V(span->attrStepX[attr], 0.0F, 0.0F, 0.0F, 0.0F);

+         ASSIGN_4V(span->attrStepY[attr], 0.0F, 0.0F, 0.0F, 0.0F);

+      }

+   }

+}

+

+

+/**

+ * Interpolate the active attributes (and'd with attrMask) to

+ * fill in span->array->attribs[].

+ * Perspective correction will be done.  The point/line/triangle function

+ * should have computed attrStart/Step values for FRAG_ATTRIB_WPOS[3]!

+ */

+static INLINE void

+interpolate_active_attribs(struct gl_context *ctx, SWspan *span, GLbitfield attrMask)

+{

+   const SWcontext *swrast = SWRAST_CONTEXT(ctx);

+

+   /*

+    * Don't overwrite existing array values, such as colors that may have

+    * been produced by glDraw/CopyPixels.

+    */

+   attrMask &= ~span->arrayAttribs;

+

+   ATTRIB_LOOP_BEGIN

+      if (attrMask & (1 << attr)) {

+         const GLfloat dwdx = span->attrStepX[FRAG_ATTRIB_WPOS][3];

+         GLfloat w = span->attrStart[FRAG_ATTRIB_WPOS][3];

+         const GLfloat dv0dx = span->attrStepX[attr][0];

+         const GLfloat dv1dx = span->attrStepX[attr][1];

+         const GLfloat dv2dx = span->attrStepX[attr][2];

+         const GLfloat dv3dx = span->attrStepX[attr][3];

+         GLfloat v0 = span->attrStart[attr][0] + span->leftClip * dv0dx;

+         GLfloat v1 = span->attrStart[attr][1] + span->leftClip * dv1dx;

+         GLfloat v2 = span->attrStart[attr][2] + span->leftClip * dv2dx;

+         GLfloat v3 = span->attrStart[attr][3] + span->leftClip * dv3dx;

+         GLuint k;

+         for (k = 0; k < span->end; k++) {

+            const GLfloat invW = 1.0f / w;

+            span->array->attribs[attr][k][0] = v0 * invW;

+            span->array->attribs[attr][k][1] = v1 * invW;

+            span->array->attribs[attr][k][2] = v2 * invW;

+            span->array->attribs[attr][k][3] = v3 * invW;

+            v0 += dv0dx;

+            v1 += dv1dx;

+            v2 += dv2dx;

+            v3 += dv3dx;

+            w += dwdx;

+         }

+         ASSERT((span->arrayAttribs & (1 << attr)) == 0);

+         span->arrayAttribs |= (1 << attr);

+      }

+   ATTRIB_LOOP_END

+}

+

+

+/**

+ * Interpolate primary colors to fill in the span->array->rgba8 (or rgb16)

+ * color array.

+ */

+static INLINE void

+interpolate_int_colors(struct gl_context *ctx, SWspan *span)

+{

+   const GLuint n = span->end;

+   GLuint i;

+

+#if CHAN_BITS != 32

+   ASSERT(!(span->arrayMask & SPAN_RGBA));

+#endif

+

+   switch (span->array->ChanType) {

+#if CHAN_BITS != 32

+   case GL_UNSIGNED_BYTE:

+      {

+         GLubyte (*rgba)[4] = span->array->rgba8;

+         if (span->interpMask & SPAN_FLAT) {

+            GLubyte color[4];

+            color[RCOMP] = FixedToInt(span->red);

+            color[GCOMP] = FixedToInt(span->green);

+            color[BCOMP] = FixedToInt(span->blue);

+            color[ACOMP] = FixedToInt(span->alpha);

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

+               COPY_4UBV(rgba[i], color);

+            }

+         }

+         else {

+            GLfixed r = span->red;

+            GLfixed g = span->green;

+            GLfixed b = span->blue;

+            GLfixed a = span->alpha;

+            GLint dr = span->redStep;

+            GLint dg = span->greenStep;

+            GLint db = span->blueStep;

+            GLint da = span->alphaStep;

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

+               rgba[i][RCOMP] = FixedToChan(r);

+               rgba[i][GCOMP] = FixedToChan(g);

+               rgba[i][BCOMP] = FixedToChan(b);

+               rgba[i][ACOMP] = FixedToChan(a);

+               r += dr;

+               g += dg;

+               b += db;

+               a += da;

+            }

+         }

+      }

+      break;

+   case GL_UNSIGNED_SHORT:

+      {

+         GLushort (*rgba)[4] = span->array->rgba16;

+         if (span->interpMask & SPAN_FLAT) {

+            GLushort color[4];

+            color[RCOMP] = FixedToInt(span->red);

+            color[GCOMP] = FixedToInt(span->green);

+            color[BCOMP] = FixedToInt(span->blue);

+            color[ACOMP] = FixedToInt(span->alpha);

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

+               COPY_4V(rgba[i], color);

+            }

+         }

+         else {

+            GLushort (*rgba)[4] = span->array->rgba16;

+            GLfixed r, g, b, a;

+            GLint dr, dg, db, da;

+            r = span->red;

+            g = span->green;

+            b = span->blue;

+            a = span->alpha;

+            dr = span->redStep;

+            dg = span->greenStep;

+            db = span->blueStep;

+            da = span->alphaStep;

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

+               rgba[i][RCOMP] = FixedToChan(r);

+               rgba[i][GCOMP] = FixedToChan(g);

+               rgba[i][BCOMP] = FixedToChan(b);

+               rgba[i][ACOMP] = FixedToChan(a);

+               r += dr;

+               g += dg;

+               b += db;

+               a += da;

+            }

+         }

+      }

+      break;

+#endif

+   case GL_FLOAT:

+      interpolate_active_attribs(ctx, span, FRAG_BIT_COL0);

+      break;

+   default:

+      _mesa_problem(NULL, "bad datatype in interpolate_int_colors");

+   }

+   span->arrayMask |= SPAN_RGBA;

+}

+

+

+/**

+ * Populate the FRAG_ATTRIB_COL0 array.

+ */

+static INLINE void

+interpolate_float_colors(SWspan *span)

+{

+   GLfloat (*col0)[4] = span->array->attribs[FRAG_ATTRIB_COL0];

+   const GLuint n = span->end;

+   GLuint i;

+

+   assert(!(span->arrayAttribs & FRAG_BIT_COL0));

+

+   if (span->arrayMask & SPAN_RGBA) {

+      /* convert array of int colors */

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

+         col0[i][0] = UBYTE_TO_FLOAT(span->array->rgba8[i][0]);

+         col0[i][1] = UBYTE_TO_FLOAT(span->array->rgba8[i][1]);

+         col0[i][2] = UBYTE_TO_FLOAT(span->array->rgba8[i][2]);

+         col0[i][3] = UBYTE_TO_FLOAT(span->array->rgba8[i][3]);

+      }

+   }

+   else {

+      /* interpolate red/green/blue/alpha to get float colors */

+      ASSERT(span->interpMask & SPAN_RGBA);

+      if (span->interpMask & SPAN_FLAT) {

+         GLfloat r = FixedToFloat(span->red);

+         GLfloat g = FixedToFloat(span->green);

+         GLfloat b = FixedToFloat(span->blue);

+         GLfloat a = FixedToFloat(span->alpha);

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

+            ASSIGN_4V(col0[i], r, g, b, a);

+         }

+      }

+      else {

+         GLfloat r = FixedToFloat(span->red);

+         GLfloat g = FixedToFloat(span->green);

+         GLfloat b = FixedToFloat(span->blue);

+         GLfloat a = FixedToFloat(span->alpha);

+         GLfloat dr = FixedToFloat(span->redStep);

+         GLfloat dg = FixedToFloat(span->greenStep);

+         GLfloat db = FixedToFloat(span->blueStep);

+         GLfloat da = FixedToFloat(span->alphaStep);

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

+            col0[i][0] = r;

+            col0[i][1] = g;

+            col0[i][2] = b;

+            col0[i][3] = a;

+            r += dr;

+            g += dg;

+            b += db;

+            a += da;

+         }

+      }

+   }

+

+   span->arrayAttribs |= FRAG_BIT_COL0;

+   span->array->ChanType = GL_FLOAT;

+}

+

+

+

+/**

+ * Fill in the span.zArray array from the span->z, zStep values.

+ */

+void

+_swrast_span_interpolate_z( const struct gl_context *ctx, SWspan *span )

+{

+   const GLuint n = span->end;

+   GLuint i;

+

+   ASSERT(!(span->arrayMask & SPAN_Z));

+

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

+      GLfixed zval = span->z;

+      GLuint *z = span->array->z; 

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

+         z[i] = FixedToInt(zval);

+         zval += span->zStep;

+      }

+   }

+   else {

+      /* Deep Z buffer, no fixed->int shift */

+      GLuint zval = span->z;

+      GLuint *z = span->array->z;

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

+         z[i] = zval;

+         zval += span->zStep;

+      }

+   }

+   span->interpMask &= ~SPAN_Z;

+   span->arrayMask |= SPAN_Z;

+}

+

+

+/**

+ * Compute mipmap LOD from partial derivatives.

+ * This the ideal solution, as given in the OpenGL spec.

+ */

+GLfloat

+_swrast_compute_lambda(GLfloat dsdx, GLfloat dsdy, GLfloat dtdx, GLfloat dtdy,

+                       GLfloat dqdx, GLfloat dqdy, GLfloat texW, GLfloat texH,

+                       GLfloat s, GLfloat t, GLfloat q, GLfloat invQ)

+{

+   GLfloat dudx = texW * ((s + dsdx) / (q + dqdx) - s * invQ);

+   GLfloat dvdx = texH * ((t + dtdx) / (q + dqdx) - t * invQ);

+   GLfloat dudy = texW * ((s + dsdy) / (q + dqdy) - s * invQ);

+   GLfloat dvdy = texH * ((t + dtdy) / (q + dqdy) - t * invQ);

+   GLfloat x = SQRTF(dudx * dudx + dvdx * dvdx);

+   GLfloat y = SQRTF(dudy * dudy + dvdy * dvdy);

+   GLfloat rho = MAX2(x, y);

+   GLfloat lambda = LOG2(rho);

+   return lambda;

+}

+

+

+/**

+ * Compute mipmap LOD from partial derivatives.

+ * This is a faster approximation than above function.

+ */

+#if 0

+GLfloat

+_swrast_compute_lambda(GLfloat dsdx, GLfloat dsdy, GLfloat dtdx, GLfloat dtdy,

+                     GLfloat dqdx, GLfloat dqdy, GLfloat texW, GLfloat texH,

+                     GLfloat s, GLfloat t, GLfloat q, GLfloat invQ)

+{

+   GLfloat dsdx2 = (s + dsdx) / (q + dqdx) - s * invQ;

+   GLfloat dtdx2 = (t + dtdx) / (q + dqdx) - t * invQ;

+   GLfloat dsdy2 = (s + dsdy) / (q + dqdy) - s * invQ;

+   GLfloat dtdy2 = (t + dtdy) / (q + dqdy) - t * invQ;

+   GLfloat maxU, maxV, rho, lambda;

+   dsdx2 = FABSF(dsdx2);

+   dsdy2 = FABSF(dsdy2);

+   dtdx2 = FABSF(dtdx2);

+   dtdy2 = FABSF(dtdy2);

+   maxU = MAX2(dsdx2, dsdy2) * texW;

+   maxV = MAX2(dtdx2, dtdy2) * texH;

+   rho = MAX2(maxU, maxV);

+   lambda = LOG2(rho);

+   return lambda;

+}

+#endif

+

+

+/**

+ * Fill in the span.array->attrib[FRAG_ATTRIB_TEXn] arrays from the

+ * using the attrStart/Step values.

+ *

+ * This function only used during fixed-function fragment processing.

+ *

+ * Note: in the places where we divide by Q (or mult by invQ) we're

+ * really doing two things: perspective correction and texcoord

+ * projection.  Remember, for texcoord (s,t,r,q) we need to index

+ * texels with (s/q, t/q, r/q).

+ */

+static void

+interpolate_texcoords(struct gl_context *ctx, SWspan *span)

+{

+   const GLuint maxUnit

+      = (ctx->Texture._EnabledCoordUnits > 1) ? ctx->Const.MaxTextureUnits : 1;

+   GLuint u;

+

+   /* XXX CoordUnits vs. ImageUnits */

+   for (u = 0; u < maxUnit; u++) {

+      if (ctx->Texture._EnabledCoordUnits & (1 << u)) {

+         const GLuint attr = FRAG_ATTRIB_TEX0 + u;

+         const struct gl_texture_object *obj = ctx->Texture.Unit[u]._Current;

+         GLfloat texW, texH;

+         GLboolean needLambda;

+         GLfloat (*texcoord)[4] = span->array->attribs[attr];

+         GLfloat *lambda = span->array->lambda[u];

+         const GLfloat dsdx = span->attrStepX[attr][0];

+         const GLfloat dsdy = span->attrStepY[attr][0];

+         const GLfloat dtdx = span->attrStepX[attr][1];

+         const GLfloat dtdy = span->attrStepY[attr][1];

+         const GLfloat drdx = span->attrStepX[attr][2];

+         const GLfloat dqdx = span->attrStepX[attr][3];

+         const GLfloat dqdy = span->attrStepY[attr][3];

+         GLfloat s = span->attrStart[attr][0] + span->leftClip * dsdx;

+         GLfloat t = span->attrStart[attr][1] + span->leftClip * dtdx;

+         GLfloat r = span->attrStart[attr][2] + span->leftClip * drdx;

+         GLfloat q = span->attrStart[attr][3] + span->leftClip * dqdx;

+

+         if (obj) {

+            const struct gl_texture_image *img = obj->Image[0][obj->BaseLevel];

+            needLambda = (obj->MinFilter != obj->MagFilter)

+               || ctx->FragmentProgram._Current;

+            texW = img->WidthScale;

+            texH = img->HeightScale;

+         }

+         else {

+            /* using a fragment program */

+            texW = 1.0;

+            texH = 1.0;

+            needLambda = GL_FALSE;

+         }

+

+         if (needLambda) {

+            GLuint i;

+            if (ctx->FragmentProgram._Current

+                || ctx->ATIFragmentShader._Enabled) {

+               /* do perspective correction but don't divide s, t, r by q */

+               const GLfloat dwdx = span->attrStepX[FRAG_ATTRIB_WPOS][3];

+               GLfloat w = span->attrStart[FRAG_ATTRIB_WPOS][3] + span->leftClip * dwdx;

+               for (i = 0; i < span->end; i++) {

+                  const GLfloat invW = 1.0F / w;

+                  texcoord[i][0] = s * invW;

+                  texcoord[i][1] = t * invW;

+                  texcoord[i][2] = r * invW;

+                  texcoord[i][3] = q * invW;

+                  lambda[i] = _swrast_compute_lambda(dsdx, dsdy, dtdx, dtdy,

+                                                     dqdx, dqdy, texW, texH,

+                                                     s, t, q, invW);

+                  s += dsdx;

+                  t += dtdx;

+                  r += drdx;

+                  q += dqdx;

+                  w += dwdx;

+               }

+            }

+            else {

+               for (i = 0; i < span->end; i++) {

+                  const GLfloat invQ = (q == 0.0F) ? 1.0F : (1.0F / q);

+                  texcoord[i][0] = s * invQ;

+                  texcoord[i][1] = t * invQ;

+                  texcoord[i][2] = r * invQ;

+                  texcoord[i][3] = q;

+                  lambda[i] = _swrast_compute_lambda(dsdx, dsdy, dtdx, dtdy,

+                                                     dqdx, dqdy, texW, texH,

+                                                     s, t, q, invQ);

+                  s += dsdx;

+                  t += dtdx;

+                  r += drdx;

+                  q += dqdx;

+               }

+            }

+            span->arrayMask |= SPAN_LAMBDA;

+         }

+         else {

+            GLuint i;

+            if (ctx->FragmentProgram._Current ||

+                ctx->ATIFragmentShader._Enabled) {

+               /* do perspective correction but don't divide s, t, r by q */

+               const GLfloat dwdx = span->attrStepX[FRAG_ATTRIB_WPOS][3];

+               GLfloat w = span->attrStart[FRAG_ATTRIB_WPOS][3] + span->leftClip * dwdx;

+               for (i = 0; i < span->end; i++) {

+                  const GLfloat invW = 1.0F / w;

+                  texcoord[i][0] = s * invW;

+                  texcoord[i][1] = t * invW;

+                  texcoord[i][2] = r * invW;

+                  texcoord[i][3] = q * invW;

+                  lambda[i] = 0.0;

+                  s += dsdx;

+                  t += dtdx;

+                  r += drdx;

+                  q += dqdx;

+                  w += dwdx;

+               }

+            }

+            else if (dqdx == 0.0F) {

+               /* Ortho projection or polygon's parallel to window X axis */

+               const GLfloat invQ = (q == 0.0F) ? 1.0F : (1.0F / q);

+               for (i = 0; i < span->end; i++) {

+                  texcoord[i][0] = s * invQ;

+                  texcoord[i][1] = t * invQ;

+                  texcoord[i][2] = r * invQ;

+                  texcoord[i][3] = q;

+                  lambda[i] = 0.0;

+                  s += dsdx;

+                  t += dtdx;

+                  r += drdx;

+               }

+            }

+            else {

+               for (i = 0; i < span->end; i++) {

+                  const GLfloat invQ = (q == 0.0F) ? 1.0F : (1.0F / q);

+                  texcoord[i][0] = s * invQ;

+                  texcoord[i][1] = t * invQ;

+                  texcoord[i][2] = r * invQ;

+                  texcoord[i][3] = q;

+                  lambda[i] = 0.0;

+                  s += dsdx;

+                  t += dtdx;

+                  r += drdx;

+                  q += dqdx;

+               }

+            }

+         } /* lambda */

+      } /* if */

+   } /* for */

+}

+

+

+/**

+ * Fill in the arrays->attribs[FRAG_ATTRIB_WPOS] array.

+ */

+static INLINE void

+interpolate_wpos(struct gl_context *ctx, SWspan *span)

+{

+   GLfloat (*wpos)[4] = span->array->attribs[FRAG_ATTRIB_WPOS];

+   GLuint i;

+   const GLfloat zScale = 1.0F / ctx->DrawBuffer->_DepthMaxF;

+   GLfloat w, dw;

+

+   if (span->arrayMask & SPAN_XY) {

+      for (i = 0; i < span->end; i++) {

+         wpos[i][0] = (GLfloat) span->array->x[i];

+         wpos[i][1] = (GLfloat) span->array->y[i];

+      }

+   }

+   else {

+      for (i = 0; i < span->end; i++) {

+         wpos[i][0] = (GLfloat) span->x + i;

+         wpos[i][1] = (GLfloat) span->y;

+      }

+   }

+

+   dw = span->attrStepX[FRAG_ATTRIB_WPOS][3];

+   w = span->attrStart[FRAG_ATTRIB_WPOS][3] + span->leftClip * dw;

+   for (i = 0; i < span->end; i++) {

+      wpos[i][2] = (GLfloat) span->array->z[i] * zScale;

+      wpos[i][3] = w;

+      w += dw;

+   }

+}

+

+

+/**

+ * Apply the current polygon stipple pattern to a span of pixels.

+ */

+static INLINE void

+stipple_polygon_span(struct gl_context *ctx, SWspan *span)

+{

+   GLubyte *mask = span->array->mask;

+

+   ASSERT(ctx->Polygon.StippleFlag);

+

+   if (span->arrayMask & SPAN_XY) {

+      /* arrays of x/y pixel coords */

+      GLuint i;

+      for (i = 0; i < span->end; i++) {

+         const GLint col = span->array->x[i] % 32;

+         const GLint row = span->array->y[i] % 32;

+         const GLuint stipple = ctx->PolygonStipple[row];

+         if (((1 << col) & stipple) == 0) {

+            mask[i] = 0;

+         }

+      }

+   }

+   else {

+      /* horizontal span of pixels */

+      const GLuint highBit = 1 << 31;

+      const GLuint stipple = ctx->PolygonStipple[span->y % 32];

+      GLuint i, m = highBit >> (GLuint) (span->x % 32);

+      for (i = 0; i < span->end; i++) {

+         if ((m & stipple) == 0) {

+            mask[i] = 0;

+         }

+         m = m >> 1;

+         if (m == 0) {

+            m = highBit;

+         }

+      }

+   }

+   span->writeAll = GL_FALSE;

+}

+

+

+/**

+ * Clip a pixel span to the current buffer/window boundaries:

+ * DrawBuffer->_Xmin, _Xmax, _Ymin, _Ymax.  This will accomplish

+ * window clipping and scissoring.

+ * Return:   GL_TRUE   some pixels still visible

+ *           GL_FALSE  nothing visible

+ */

+static INLINE GLuint

+clip_span( struct gl_context *ctx, SWspan *span )

+{

+   const GLint xmin = ctx->DrawBuffer->_Xmin;

+   const GLint xmax = ctx->DrawBuffer->_Xmax;

+   const GLint ymin = ctx->DrawBuffer->_Ymin;

+   const GLint ymax = ctx->DrawBuffer->_Ymax;

+

+   span->leftClip = 0;

+

+   if (span->arrayMask & SPAN_XY) {

+      /* arrays of x/y pixel coords */

+      const GLint *x = span->array->x;

+      const GLint *y = span->array->y;

+      const GLint n = span->end;

+      GLubyte *mask = span->array->mask;

+      GLint i;

+      if (span->arrayMask & SPAN_MASK) {

+         /* note: using & intead of && to reduce branches */

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

+            mask[i] &= (x[i] >= xmin) & (x[i] < xmax)

+                     & (y[i] >= ymin) & (y[i] < ymax);

+         }

+      }

+      else {

+         /* note: using & intead of && to reduce branches */

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

+            mask[i] = (x[i] >= xmin) & (x[i] < xmax)

+                    & (y[i] >= ymin) & (y[i] < ymax);

+         }

+      }

+      return GL_TRUE;  /* some pixels visible */

+   }

+   else {

+      /* horizontal span of pixels */

+      const GLint x = span->x;

+      const GLint y = span->y;

+      GLint n = span->end;

+

+      /* Trivial rejection tests */

+      if (y < ymin || y >= ymax || x + n <= xmin || x >= xmax) {

+         span->end = 0;

+         return GL_FALSE;  /* all pixels clipped */

+      }

+

+      /* Clip to right */

+      if (x + n > xmax) {

+         ASSERT(x < xmax);

+         n = span->end = xmax - x;

+      }

+

+      /* Clip to the left */

+      if (x < xmin) {

+         const GLint leftClip = xmin - x;

+         GLuint i;

+

+         ASSERT(leftClip > 0);

+         ASSERT(x + n > xmin);

+

+         /* Clip 'leftClip' pixels from the left side.

+          * The span->leftClip field will be applied when we interpolate

+          * fragment attributes.

+          * For arrays of values, shift them left.

+          */

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

+            if (span->interpMask & (1 << i)) {

+               GLuint j;

+               for (j = 0; j < 4; j++) {

+                  span->attrStart[i][j] += leftClip * span->attrStepX[i][j];

+               }

+            }

+         }

+

+         span->red += leftClip * span->redStep;

+         span->green += leftClip * span->greenStep;

+         span->blue += leftClip * span->blueStep;

+         span->alpha += leftClip * span->alphaStep;

+         span->index += leftClip * span->indexStep;

+         span->z += leftClip * span->zStep;

+         span->intTex[0] += leftClip * span->intTexStep[0];

+         span->intTex[1] += leftClip * span->intTexStep[1];

+

+#define SHIFT_ARRAY(ARRAY, SHIFT, LEN) \

+         memcpy(ARRAY, ARRAY + (SHIFT), (LEN) * sizeof(ARRAY[0]))

+

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

+            if (span->arrayAttribs & (1 << i)) {

+               /* shift array elements left by 'leftClip' */

+               SHIFT_ARRAY(span->array->attribs[i], leftClip, n - leftClip);

+            }

+         }

+

+         SHIFT_ARRAY(span->array->mask, leftClip, n - leftClip);

+         SHIFT_ARRAY(span->array->rgba8, leftClip, n - leftClip);

+         SHIFT_ARRAY(span->array->rgba16, leftClip, n - leftClip);

+         SHIFT_ARRAY(span->array->x, leftClip, n - leftClip);

+         SHIFT_ARRAY(span->array->y, leftClip, n - leftClip);

+         SHIFT_ARRAY(span->array->z, leftClip, n - leftClip);

+         SHIFT_ARRAY(span->array->index, leftClip, n - leftClip);

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

+            SHIFT_ARRAY(span->array->lambda[i], leftClip, n - leftClip);

+         }

+         SHIFT_ARRAY(span->array->coverage, leftClip, n - leftClip);

+

+#undef SHIFT_ARRAY

+

+         span->leftClip = leftClip;

+         span->x = xmin;

+         span->end -= leftClip;

+         span->writeAll = GL_FALSE;

+      }

+

+      ASSERT(span->x >= xmin);

+      ASSERT(span->x + span->end <= xmax);

+      ASSERT(span->y >= ymin);

+      ASSERT(span->y < ymax);

+

+      return GL_TRUE;  /* some pixels visible */

+   }

+}

+

+

+/**

+ * Add specular colors to primary colors.

+ * Only called during fixed-function operation.

+ * Result is float color array (FRAG_ATTRIB_COL0).

+ */

+static INLINE void

+add_specular(struct gl_context *ctx, SWspan *span)

+{

+   const SWcontext *swrast = SWRAST_CONTEXT(ctx);

+   const GLubyte *mask = span->array->mask;

+   GLfloat (*col0)[4] = span->array->attribs[FRAG_ATTRIB_COL0];

+   GLfloat (*col1)[4] = span->array->attribs[FRAG_ATTRIB_COL1];

+   GLuint i;

+

+   ASSERT(!ctx->FragmentProgram._Current);

+   ASSERT(span->arrayMask & SPAN_RGBA);

+   ASSERT(swrast->_ActiveAttribMask & FRAG_BIT_COL1);

+   (void) swrast; /* silence warning */

+

+   if (span->array->ChanType == GL_FLOAT) {

+      if ((span->arrayAttribs & FRAG_BIT_COL0) == 0) {

+         interpolate_active_attribs(ctx, span, FRAG_BIT_COL0);

+      }

+   }

+   else {

+      /* need float colors */

+      if ((span->arrayAttribs & FRAG_BIT_COL0) == 0) {

+         interpolate_float_colors(span);

+      }

+   }

+

+   if ((span->arrayAttribs & FRAG_BIT_COL1) == 0) {

+      /* XXX could avoid this and interpolate COL1 in the loop below */

+      interpolate_active_attribs(ctx, span, FRAG_BIT_COL1);

+   }

+

+   ASSERT(span->arrayAttribs & FRAG_BIT_COL0);

+   ASSERT(span->arrayAttribs & FRAG_BIT_COL1);

+

+   for (i = 0; i < span->end; i++) {

+      if (mask[i]) {

+         col0[i][0] += col1[i][0];

+         col0[i][1] += col1[i][1];

+         col0[i][2] += col1[i][2];

+      }

+   }

+

+   span->array->ChanType = GL_FLOAT;

+}

+

+

+/**

+ * Apply antialiasing coverage value to alpha values.

+ */

+static INLINE void

+apply_aa_coverage(SWspan *span)

+{

+   const GLfloat *coverage = span->array->coverage;

+   GLuint i;

+   if (span->array->ChanType == GL_UNSIGNED_BYTE) {

+      GLubyte (*rgba)[4] = span->array->rgba8;

+      for (i = 0; i < span->end; i++) {

+         const GLfloat a = rgba[i][ACOMP] * coverage[i];

+         rgba[i][ACOMP] = (GLubyte) CLAMP(a, 0.0, 255.0);

+         ASSERT(coverage[i] >= 0.0);

+         ASSERT(coverage[i] <= 1.0);

+      }

+   }

+   else if (span->array->ChanType == GL_UNSIGNED_SHORT) {

+      GLushort (*rgba)[4] = span->array->rgba16;

+      for (i = 0; i < span->end; i++) {

+         const GLfloat a = rgba[i][ACOMP] * coverage[i];

+         rgba[i][ACOMP] = (GLushort) CLAMP(a, 0.0, 65535.0);

+      }

+   }

+   else {

+      GLfloat (*rgba)[4] = span->array->attribs[FRAG_ATTRIB_COL0];

+      for (i = 0; i < span->end; i++) {

+         rgba[i][ACOMP] = rgba[i][ACOMP] * coverage[i];

+         /* clamp later */

+      }

+   }

+}

+

+

+/**

+ * Clamp span's float colors to [0,1]

+ */

+static INLINE void

+clamp_colors(SWspan *span)

+{

+   GLfloat (*rgba)[4] = span->array->attribs[FRAG_ATTRIB_COL0];

+   GLuint i;

+   ASSERT(span->array->ChanType == GL_FLOAT);

+   for (i = 0; i < span->end; i++) {

+      rgba[i][RCOMP] = CLAMP(rgba[i][RCOMP], 0.0F, 1.0F);

+      rgba[i][GCOMP] = CLAMP(rgba[i][GCOMP], 0.0F, 1.0F);

+      rgba[i][BCOMP] = CLAMP(rgba[i][BCOMP], 0.0F, 1.0F);

+      rgba[i][ACOMP] = CLAMP(rgba[i][ACOMP], 0.0F, 1.0F);

+   }

+}

+

+

+/**

+ * Convert the span's color arrays to the given type.

+ * The only way 'output' can be greater than zero is when we have a fragment

+ * program that writes to gl_FragData[1] or higher.

+ * \param output  which fragment program color output is being processed

+ */

+static INLINE void

+convert_color_type(SWspan *span, GLenum newType, GLuint output)

+{

+   GLvoid *src, *dst;

+

+   if (output > 0 || span->array->ChanType == GL_FLOAT) {

+      src = span->array->attribs[FRAG_ATTRIB_COL0 + output];

+      span->array->ChanType = GL_FLOAT;

+   }

+   else if (span->array->ChanType == GL_UNSIGNED_BYTE) {

+      src = span->array->rgba8;

+   }

+   else {

+      ASSERT(span->array->ChanType == GL_UNSIGNED_SHORT);

+      src = span->array->rgba16;

+   }

+

+   if (newType == GL_UNSIGNED_BYTE) {

+      dst = span->array->rgba8;

+   }

+   else if (newType == GL_UNSIGNED_SHORT) {

+      dst = span->array->rgba16;

+   }

+   else {

+      dst = span->array->attribs[FRAG_ATTRIB_COL0];

+   }

+

+   _mesa_convert_colors(span->array->ChanType, src,

+                        newType, dst,

+                        span->end, span->array->mask);

+

+   span->array->ChanType = newType;

+   span->array->rgba = dst;

+}

+

+

+

+/**

+ * Apply fragment shader, fragment program or normal texturing to span.

+ */

+static INLINE void

+shade_texture_span(struct gl_context *ctx, SWspan *span)

+{

+   GLbitfield inputsRead;

+

+   /* Determine which fragment attributes are actually needed */

+   if (ctx->FragmentProgram._Current) {

+      inputsRead = ctx->FragmentProgram._Current->Base.InputsRead;

+   }

+   else {

+      /* XXX we could be a bit smarter about this */

+      inputsRead = ~0;

+   }

+

+   if (ctx->FragmentProgram._Current ||

+       ctx->ATIFragmentShader._Enabled) {

+      /* programmable shading */

+      if (span->primitive == GL_BITMAP && span->array->ChanType != GL_FLOAT) {

+         convert_color_type(span, GL_FLOAT, 0);

+      }

+      else {

+         span->array->rgba = (void *) span->array->attribs[FRAG_ATTRIB_COL0];

+      }

+

+      if (span->primitive != GL_POINT ||

+	  (span->interpMask & SPAN_RGBA) ||

+	  ctx->Point.PointSprite) {

+         /* for single-pixel points, we populated the arrays already */

+         interpolate_active_attribs(ctx, span, ~0);

+      }

+      span->array->ChanType = GL_FLOAT;

+

+      if (!(span->arrayMask & SPAN_Z))

+         _swrast_span_interpolate_z (ctx, span);

+

+#if 0

+      if (inputsRead & FRAG_BIT_WPOS)

+#else

+      /* XXX always interpolate wpos so that DDX/DDY work */

+#endif

+         interpolate_wpos(ctx, span);

+

+      /* Run fragment program/shader now */

+      if (ctx->FragmentProgram._Current) {

+         _swrast_exec_fragment_program(ctx, span);

+      }

+      else {

+         ASSERT(ctx->ATIFragmentShader._Enabled);

+         _swrast_exec_fragment_shader(ctx, span);

+      }

+   }

+   else if (ctx->Texture._EnabledCoordUnits) {

+      /* conventional texturing */

+

+#if CHAN_BITS == 32

+      if ((span->arrayAttribs & FRAG_BIT_COL0) == 0) {

+         interpolate_int_colors(ctx, span);

+      }

+#else

+      if (!(span->arrayMask & SPAN_RGBA))

+         interpolate_int_colors(ctx, span);

+#endif

+      if ((span->arrayAttribs & FRAG_BITS_TEX_ANY) == 0x0)

+         interpolate_texcoords(ctx, span);

+

+      _swrast_texture_span(ctx, span);

+   }

+}

+

+

+

+/**

+ * Apply all the per-fragment operations to a span.

+ * This now includes texturing (_swrast_write_texture_span() is history).

+ * This function may modify any of the array values in the span.

+ * span->interpMask and span->arrayMask may be changed but will be restored

+ * to their original values before returning.

+ */

+void

+_swrast_write_rgba_span( struct gl_context *ctx, SWspan *span)

+{

+   const SWcontext *swrast = SWRAST_CONTEXT(ctx);

+   const GLuint *colorMask = (GLuint *) ctx->Color.ColorMask;

+   const GLbitfield origInterpMask = span->interpMask;

+   const GLbitfield origArrayMask = span->arrayMask;

+   const GLbitfield origArrayAttribs = span->arrayAttribs;

+   const GLenum origChanType = span->array->ChanType;

+   void * const origRgba = span->array->rgba;

+   const GLboolean shader = (ctx->FragmentProgram._Current

+                             || ctx->ATIFragmentShader._Enabled);

+   const GLboolean shaderOrTexture = shader || ctx->Texture._EnabledCoordUnits;

+   struct gl_framebuffer *fb = ctx->DrawBuffer;

+

+   /*

+   printf("%s()  interp 0x%x  array 0x%x\n", __FUNCTION__,

+          span->interpMask, span->arrayMask);

+   */

+

+   ASSERT(span->primitive == GL_POINT ||

+          span->primitive == GL_LINE ||

+	  span->primitive == GL_POLYGON ||

+          span->primitive == GL_BITMAP);

+

+   /* Fragment write masks */

+   if (span->arrayMask & SPAN_MASK) {

+      /* mask was initialized by caller, probably glBitmap */

+      span->writeAll = GL_FALSE;

+   }

+   else {

+      memset(span->array->mask, 1, span->end);

+      span->writeAll = GL_TRUE;

+   }

+

+   /* Clip to window/scissor box */

+   if (!clip_span(ctx, span)) {

+      return;

+   }

+

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

+

+   /* Depth bounds test */

+   if (ctx->Depth.BoundsTest && fb->Visual.depthBits > 0) {

+      if (!_swrast_depth_bounds_test(ctx, span)) {

+         return;

+      }

+   }

+

+#ifdef DEBUG

+   /* Make sure all fragments are within window bounds */

+   if (span->arrayMask & SPAN_XY) {

+      /* array of pixel locations */

+      GLuint i;

+      for (i = 0; i < span->end; i++) {

+         if (span->array->mask[i]) {

+            assert(span->array->x[i] >= fb->_Xmin);

+            assert(span->array->x[i] < fb->_Xmax);

+            assert(span->array->y[i] >= fb->_Ymin);

+            assert(span->array->y[i] < fb->_Ymax);

+         }

+      }

+   }

+#endif

+

+   /* Polygon Stippling */

+   if (ctx->Polygon.StippleFlag && span->primitive == GL_POLYGON) {

+      stipple_polygon_span(ctx, span);

+   }

+

+   /* This is the normal place to compute the fragment color/Z

+    * from texturing or shading.

+    */

+   if (shaderOrTexture && !swrast->_DeferredTexture) {

+      shade_texture_span(ctx, span);

+   }

+

+   /* Do the alpha test */

+   if (ctx->Color.AlphaEnabled) {

+      if (!_swrast_alpha_test(ctx, span)) {

+         /* all fragments failed test */

+         goto end;

+      }

+   }

+

+   /* Stencil and Z testing */

+   if (ctx->Stencil._Enabled || ctx->Depth.Test) {

+      if (!(span->arrayMask & SPAN_Z))

+         _swrast_span_interpolate_z(ctx, span);

+

+      if (ctx->Transform.DepthClamp)

+	 _swrast_depth_clamp_span(ctx, span);

+

+      if (ctx->Stencil._Enabled) {

+         /* Combined Z/stencil tests */

+         if (!_swrast_stencil_and_ztest_span(ctx, span)) {

+            /* all fragments failed test */

+            goto end;

+         }

+      }

+      else if (fb->Visual.depthBits > 0) {

+         /* Just regular depth testing */

+         ASSERT(ctx->Depth.Test);

+         ASSERT(span->arrayMask & SPAN_Z);

+         if (!_swrast_depth_test_span(ctx, span)) {

+            /* all fragments failed test */

+            goto end;

+         }

+      }

+   }

+

+   if (ctx->Query.CurrentOcclusionObject) {

+      /* update count of 'passed' fragments */

+      struct gl_query_object *q = ctx->Query.CurrentOcclusionObject;

+      GLuint i;

+      for (i = 0; i < span->end; i++)

+         q->Result += span->array->mask[i];

+   }

+

+   /* We had to wait until now to check for glColorMask(0,0,0,0) because of

+    * the occlusion test.

+    */

+   if (fb->_NumColorDrawBuffers == 1 && colorMask[0] == 0x0) {

+      /* no colors to write */

+      goto end;

+   }

+

+   /* If we were able to defer fragment color computation to now, there's

+    * a good chance that many fragments will have already been killed by

+    * Z/stencil testing.

+    */

+   if (shaderOrTexture && swrast->_DeferredTexture) {

+      shade_texture_span(ctx, span);

+   }

+

+#if CHAN_BITS == 32

+   if ((span->arrayAttribs & FRAG_BIT_COL0) == 0) {

+      interpolate_active_attribs(ctx, span, FRAG_BIT_COL0);

+   }

+#else

+   if ((span->arrayMask & SPAN_RGBA) == 0) {

+      interpolate_int_colors(ctx, span);

+   }

+#endif

+

+   ASSERT(span->arrayMask & SPAN_RGBA);

+

+   if (span->primitive == GL_BITMAP || !swrast->SpecularVertexAdd) {

+      /* Add primary and specular (diffuse + specular) colors */

+      if (!shader) {

+         if (ctx->Fog.ColorSumEnabled ||

+             (ctx->Light.Enabled &&

+              ctx->Light.Model.ColorControl == GL_SEPARATE_SPECULAR_COLOR)) {

+            add_specular(ctx, span);

+         }

+      }

+   }

+

+   /* Fog */

+   if (swrast->_FogEnabled) {

+      _swrast_fog_rgba_span(ctx, span);

+   }

+

+   /* Antialias coverage application */

+   if (span->arrayMask & SPAN_COVERAGE) {

+      apply_aa_coverage(span);

+   }

+

+   /* Clamp color/alpha values over the range [0.0, 1.0] before storage */

+   if (ctx->Color.ClampFragmentColor == GL_TRUE &&

+       span->array->ChanType == GL_FLOAT) {

+      clamp_colors(span);

+   }

+

+   /*

+    * Write to renderbuffers.

+    * Depending on glDrawBuffer() state and the which color outputs are

+    * written by the fragment shader, we may either replicate one color to

+    * all renderbuffers or write a different color to each renderbuffer.

+    * multiFragOutputs=TRUE for the later case.

+    */

+   {

+      const GLuint numBuffers = fb->_NumColorDrawBuffers;

+      const struct gl_fragment_program *fp = ctx->FragmentProgram._Current;

+      const GLboolean multiFragOutputs = 

+         (fp && fp->Base.OutputsWritten >= (1 << FRAG_RESULT_DATA0));

+      GLuint buf;

+

+      for (buf = 0; buf < numBuffers; buf++) {

+         struct gl_renderbuffer *rb = fb->_ColorDrawBuffers[buf];

+

+         /* color[fragOutput] will be written to buffer[buf] */

+

+         if (rb) {

+            GLchan rgbaSave[MAX_WIDTH][4];

+            const GLuint fragOutput = multiFragOutputs ? buf : 0;

+

+            /* set span->array->rgba to colors for render buffer's datatype */

+            if (rb->DataType != span->array->ChanType || fragOutput > 0) {

+               convert_color_type(span, rb->DataType, fragOutput);

+            }

+            else {

+               if (rb->DataType == GL_UNSIGNED_BYTE) {

+                  span->array->rgba = span->array->rgba8;

+               }

+               else if (rb->DataType == GL_UNSIGNED_SHORT) {

+                  span->array->rgba = (void *) span->array->rgba16;

+               }

+               else {

+                  span->array->rgba = (void *)

+                     span->array->attribs[FRAG_ATTRIB_COL0];

+               }

+            }

+

+            if (!multiFragOutputs && numBuffers > 1) {

+               /* save colors for second, third renderbuffer writes */

+               memcpy(rgbaSave, span->array->rgba,

+                      4 * span->end * sizeof(GLchan));

+            }

+

+            ASSERT(rb->_BaseFormat == GL_RGBA || rb->_BaseFormat == GL_RGB ||

+		   rb->_BaseFormat == GL_ALPHA);

+

+            if (ctx->Color._LogicOpEnabled) {

+               _swrast_logicop_rgba_span(ctx, rb, span);

+            }

+            else if ((ctx->Color.BlendEnabled >> buf) & 1) {

+               _swrast_blend_span(ctx, rb, span);

+            }

+

+            if (colorMask[buf] != 0xffffffff) {

+               _swrast_mask_rgba_span(ctx, rb, span, buf);

+            }

+

+            if (span->arrayMask & SPAN_XY) {

+               /* array of pixel coords */

+               ASSERT(rb->PutValues);

+               rb->PutValues(ctx, rb, span->end,

+                             span->array->x, span->array->y,

+                             span->array->rgba, span->array->mask);

+            }

+            else {

+               /* horizontal run of pixels */

+               ASSERT(rb->PutRow);

+               rb->PutRow(ctx, rb, span->end, span->x, span->y,

+                          span->array->rgba,

+                          span->writeAll ? NULL: span->array->mask);

+            }

+

+            if (!multiFragOutputs && numBuffers > 1) {

+               /* restore original span values */

+               memcpy(span->array->rgba, rgbaSave,

+                      4 * span->end * sizeof(GLchan));

+            }

+

+         } /* if rb */

+      } /* for buf */

+   }

+

+end:

+   /* restore these values before returning */

+   span->interpMask = origInterpMask;

+   span->arrayMask = origArrayMask;

+   span->arrayAttribs = origArrayAttribs;

+   span->array->ChanType = origChanType;

+   span->array->rgba = origRgba;

+}

+

+

+/**

+ * Read RGBA pixels from a renderbuffer.  Clipping will be done to prevent

+ * reading ouside the buffer's boundaries.

+ * \param dstType  datatype for returned colors

+ * \param rgba  the returned colors

+ */

+void

+_swrast_read_rgba_span( struct gl_context *ctx, struct gl_renderbuffer *rb,

+                        GLuint n, GLint x, GLint y, GLenum dstType,

+                        GLvoid *rgba)

+{

+   const GLint bufWidth = (GLint) rb->Width;

+   const GLint bufHeight = (GLint) rb->Height;

+

+   if (y < 0 || y >= bufHeight || x + (GLint) n < 0 || x >= bufWidth) {

+      /* completely above, below, or right */

+      /* XXX maybe leave rgba values undefined? */

+      memset(rgba, 0, 4 * n * sizeof(GLchan));

+   }

+   else {

+      GLint skip, length;

+      if (x < 0) {

+         /* left edge clipping */

+         skip = -x;

+         length = (GLint) n - skip;

+         if (length < 0) {

+            /* completely left of window */

+            return;

+         }

+         if (length > bufWidth) {

+            length = bufWidth;

+         }

+      }

+      else if ((GLint) (x + n) > bufWidth) {

+         /* right edge clipping */

+         skip = 0;

+         length = bufWidth - x;

+         if (length < 0) {

+            /* completely to right of window */

+            return;

+         }

+      }

+      else {

+         /* no clipping */

+         skip = 0;

+         length = (GLint) n;

+      }

+

+      ASSERT(rb);

+      ASSERT(rb->GetRow);

+      ASSERT(rb->_BaseFormat == GL_RGB || rb->_BaseFormat == GL_RGBA ||

+	     rb->_BaseFormat == GL_ALPHA);

+

+      if (rb->DataType == dstType) {

+         rb->GetRow(ctx, rb, length, x + skip, y,

+                    (GLubyte *) rgba + skip * RGBA_PIXEL_SIZE(rb->DataType));

+      }

+      else {

+         GLuint temp[MAX_WIDTH * 4];

+         rb->GetRow(ctx, rb, length, x + skip, y, temp);

+         _mesa_convert_colors(rb->DataType, temp,

+                   dstType, (GLubyte *) rgba + skip * RGBA_PIXEL_SIZE(dstType),

+                   length, NULL);

+      }

+   }

+}

+

+

+/**

+ * Wrapper for gl_renderbuffer::GetValues() which does clipping to avoid

+ * reading values outside the buffer bounds.

+ * We can use this for reading any format/type of renderbuffer.

+ * \param valueSize is the size in bytes of each value (pixel) put into the

+ *                  values array.

+ */

+void

+_swrast_get_values(struct gl_context *ctx, struct gl_renderbuffer *rb,

+                   GLuint count, const GLint x[], const GLint y[],

+                   void *values, GLuint valueSize)

+{

+   GLuint i, inCount = 0, inStart = 0;

+

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

+      if (x[i] >= 0 && y[i] >= 0 &&

+	  x[i] < (GLint) rb->Width && y[i] < (GLint) rb->Height) {

+         /* inside */

+         if (inCount == 0)

+            inStart = i;

+         inCount++;

+      }

+      else {

+         if (inCount > 0) {

+            /* read [inStart, inStart + inCount) */

+            rb->GetValues(ctx, rb, inCount, x + inStart, y + inStart,

+                          (GLubyte *) values + inStart * valueSize);

+            inCount = 0;

+         }

+      }

+   }

+   if (inCount > 0) {

+      /* read last values */

+      rb->GetValues(ctx, rb, inCount, x + inStart, y + inStart,

+                    (GLubyte *) values + inStart * valueSize);

+   }

+}

+

+

+/**

+ * Wrapper for gl_renderbuffer::PutRow() which does clipping.

+ * \param valueSize  size of each value (pixel) in bytes

+ */

+void

+_swrast_put_row(struct gl_context *ctx, struct gl_renderbuffer *rb,

+                GLuint count, GLint x, GLint y,

+                const GLvoid *values, GLuint valueSize)

+{

+   GLint skip = 0;

+

+   if (y < 0 || y >= (GLint) rb->Height)

+      return; /* above or below */

+

+   if (x + (GLint) count <= 0 || x >= (GLint) rb->Width)

+      return; /* entirely left or right */

+

+   if ((GLint) (x + count) > (GLint) rb->Width) {

+      /* right clip */

+      GLint clip = x + count - rb->Width;

+      count -= clip;

+   }

+

+   if (x < 0) {

+      /* left clip */

+      skip = -x;

+      x = 0;

+      count -= skip;

+   }

+

+   rb->PutRow(ctx, rb, count, x, y,

+              (const GLubyte *) values + skip * valueSize, NULL);

+}

+

+

+/**

+ * Wrapper for gl_renderbuffer::GetRow() which does clipping.

+ * \param valueSize  size of each value (pixel) in bytes

+ */

+void

+_swrast_get_row(struct gl_context *ctx, struct gl_renderbuffer *rb,

+                GLuint count, GLint x, GLint y,

+                GLvoid *values, GLuint valueSize)

+{

+   GLint skip = 0;

+

+   if (y < 0 || y >= (GLint) rb->Height)

+      return; /* above or below */

+

+   if (x + (GLint) count <= 0 || x >= (GLint) rb->Width)

+      return; /* entirely left or right */

+

+   if (x + count > rb->Width) {

+      /* right clip */

+      GLint clip = x + count - rb->Width;

+      count -= clip;

+   }

+

+   if (x < 0) {

+      /* left clip */

+      skip = -x;

+      x = 0;

+      count -= skip;

+   }

+

+   rb->GetRow(ctx, rb, count, x, y, (GLubyte *) values + skip * valueSize);

+}

+

+

+/**

+ * Get RGBA pixels from the given renderbuffer.

+ * Used by blending, logicop and masking functions.

+ * \return pointer to the colors we read.

+ */

+void *

+_swrast_get_dest_rgba(struct gl_context *ctx, struct gl_renderbuffer *rb,

+                      SWspan *span)

+{

+   const GLuint pixelSize = RGBA_PIXEL_SIZE(span->array->ChanType);

+   void *rbPixels;

+

+   /* Point rbPixels to a temporary space */

+   rbPixels = span->array->attribs[FRAG_ATTRIB_MAX - 1];

+

+   /* Get destination values from renderbuffer */

+   if (span->arrayMask & SPAN_XY) {

+      _swrast_get_values(ctx, rb, span->end, span->array->x, span->array->y,

+                         rbPixels, pixelSize);

+   }

+   else {

+      _swrast_get_row(ctx, rb, span->end, span->x, span->y,

+                      rbPixels, pixelSize);

+   }

+

+   return rbPixels;

+}

diff --git a/mesalib/src/mesa/swrast/s_span.h b/mesalib/src/mesa/swrast/s_span.h
index aaf1fec2a..d3cce304f 100644
--- a/mesalib/src/mesa/swrast/s_span.h
+++ b/mesalib/src/mesa/swrast/s_span.h
@@ -1,218 +1,223 @@
-/*
- * Mesa 3-D graphics library
- * Version:  7.5
- *
- * Copyright (C) 1999-2008  Brian Paul   All Rights Reserved.
- * Copyright (C) 2009  VMware, Inc.  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.
- */
-
-
-#ifndef S_SPAN_H
-#define S_SPAN_H
-
-
-#include "swrast.h"
-
-
-/**
- * \defgroup SpanFlags
- * Special bitflags to describe span data.
- *
- * In general, the point/line/triangle functions interpolate/emit the
- * attributes specified by swrast->_ActiveAttribs (i.e. FRAT_BIT_* values).
- * Some things don't fit into that, though, so we have these flags.
- */
-/*@{*/
-#define SPAN_RGBA       0x01  /**< interpMask and arrayMask */
-#define SPAN_Z          0x02  /**< interpMask and arrayMask */
-#define SPAN_FLAT       0x04  /**< interpMask: flat shading? */
-#define SPAN_XY         0x08  /**< array.x[], y[] valid? */
-#define SPAN_MASK       0x10  /**< was array.mask[] filled in by caller? */
-#define SPAN_LAMBDA     0x20  /**< array.lambda[] valid? */
-#define SPAN_COVERAGE   0x40  /**< array.coverage[] valid? */
-/*@}*/
-
-
-/**
- * \sw_span_arrays 
- * \brief Arrays of fragment values.
- *
- * These will either be computed from the span x/xStep values or
- * filled in by glDraw/CopyPixels, etc.
- * These arrays are separated out of sw_span to conserve memory.
- */
-typedef struct sw_span_arrays
-{
-   /** Per-fragment attributes (indexed by FRAG_ATTRIB_* tokens) */
-   /* XXX someday look at transposing first two indexes for better memory
-    * access pattern.
-    */
-   GLfloat attribs[FRAG_ATTRIB_MAX][MAX_WIDTH][4];
-
-   /** This mask indicates which fragments are alive or culled */
-   GLubyte mask[MAX_WIDTH];
-
-   GLenum ChanType; /**< Color channel type, GL_UNSIGNED_BYTE, GL_FLOAT */
-
-   /** Attribute arrays that don't fit into attribs[] array above */
-   /*@{*/
-   GLubyte rgba8[MAX_WIDTH][4];
-   GLushort rgba16[MAX_WIDTH][4];
-   GLchan (*rgba)[4];  /** either == rgba8 or rgba16 */
-   GLint   x[MAX_WIDTH];  /**< fragment X coords */
-   GLint   y[MAX_WIDTH];  /**< fragment Y coords */
-   GLuint  z[MAX_WIDTH];  /**< fragment Z coords */
-   GLuint  index[MAX_WIDTH];  /**< Color indexes */
-   GLfloat lambda[MAX_TEXTURE_COORD_UNITS][MAX_WIDTH]; /**< Texture LOD */
-   GLfloat coverage[MAX_WIDTH];  /**< Fragment coverage for AA/smoothing */
-   /*@}*/
-} SWspanarrays;
-
-
-/**
- * The SWspan structure describes the colors, Z, fogcoord, texcoords,
- * etc for either a horizontal run or an array of independent pixels.
- * We can either specify a base/step to indicate interpolated values, or
- * fill in explicit arrays of values.  The interpMask and arrayMask bitfields
- * indicate which attributes are active interpolants or arrays, respectively.
- *
- * It would be interesting to experiment with multiprocessor rasterization
- * with this structure.  The triangle rasterizer could simply emit a
- * stream of these structures which would be consumed by one or more
- * span-processing threads which could run in parallel.
- */
-typedef struct sw_span
-{
-   /** Coord of first fragment in horizontal span/run */
-   GLint x, y;
-
-   /** Number of fragments in the span */
-   GLuint end;
-
-   /** for clipping left edge of spans */
-   GLuint leftClip;
-
-   /** This flag indicates that mask[] array is effectively filled with ones */
-   GLboolean writeAll;
-
-   /** either GL_POLYGON, GL_LINE, GL_POLYGON, GL_BITMAP */
-   GLenum primitive;
-
-   /** 0 = front-facing span, 1 = back-facing span (for two-sided stencil) */
-   GLuint facing;
-
-   /**
-    * This bitmask (of  \link SpanFlags SPAN_* flags\endlink) indicates
-    * which of the attrStart/StepX/StepY variables are relevant.
-    */
-   GLbitfield interpMask;
-
-   /** Fragment attribute interpolants */
-   GLfloat attrStart[FRAG_ATTRIB_MAX][4];   /**< initial value */
-   GLfloat attrStepX[FRAG_ATTRIB_MAX][4];   /**< dvalue/dx */
-   GLfloat attrStepY[FRAG_ATTRIB_MAX][4];   /**< dvalue/dy */
-
-   /* XXX the rest of these will go away eventually... */
-
-   /* For horizontal spans, step is the partial derivative wrt X.
-    * For lines, step is the delta from one fragment to the next.
-    */
-   GLfixed red, redStep;
-   GLfixed green, greenStep;
-   GLfixed blue, blueStep;
-   GLfixed alpha, alphaStep;
-   GLfixed index, indexStep;
-   GLfixed z, zStep;    /**< XXX z should probably be GLuint */
-   GLfixed intTex[2], intTexStep[2];  /**< (s,t) for unit[0] only */
-
-   /**
-    * This bitmask (of \link SpanFlags SPAN_* flags\endlink) indicates
-    * which of the fragment arrays in the span_arrays struct are relevant.
-    */
-   GLbitfield arrayMask;
-
-   GLbitfield arrayAttribs;
-
-   /**
-    * We store the arrays of fragment values in a separate struct so
-    * that we can allocate sw_span structs on the stack without using
-    * a lot of memory.  The span_arrays struct is about 1.4MB while the
-    * sw_span struct is only about 512 bytes.
-    */
-   SWspanarrays *array;
-} SWspan;
-
-
-
-#define INIT_SPAN(S, PRIMITIVE)			\
-do {						\
-   (S).primitive = (PRIMITIVE);			\
-   (S).interpMask = 0x0;			\
-   (S).arrayMask = 0x0;				\
-   (S).arrayAttribs = 0x0;			\
-   (S).end = 0;					\
-   (S).leftClip = 0;				\
-   (S).facing = 0;				\
-   (S).array = SWRAST_CONTEXT(ctx)->SpanArrays;	\
-} while (0)
-
-
-
-extern void
-_swrast_span_default_attribs(GLcontext *ctx, SWspan *span);
-
-extern void
-_swrast_span_interpolate_z( const GLcontext *ctx, SWspan *span );
-
-extern GLfloat
-_swrast_compute_lambda(GLfloat dsdx, GLfloat dsdy, GLfloat dtdx, GLfloat dtdy,
-                       GLfloat dqdx, GLfloat dqdy, GLfloat texW, GLfloat texH,
-                       GLfloat s, GLfloat t, GLfloat q, GLfloat invQ);
-
-
-extern void
-_swrast_write_rgba_span( GLcontext *ctx, SWspan *span);
-
-
-extern void
-_swrast_read_rgba_span(GLcontext *ctx, struct gl_renderbuffer *rb,
-                       GLuint n, GLint x, GLint y, GLenum type, GLvoid *rgba);
-
-extern void
-_swrast_get_values(GLcontext *ctx, struct gl_renderbuffer *rb,
-                   GLuint count, const GLint x[], const GLint y[],
-                   void *values, GLuint valueSize);
-
-extern void
-_swrast_put_row(GLcontext *ctx, struct gl_renderbuffer *rb,
-                GLuint count, GLint x, GLint y,
-                const GLvoid *values, GLuint valueSize);
-
-extern void
-_swrast_get_row(GLcontext *ctx, struct gl_renderbuffer *rb,
-                GLuint count, GLint x, GLint y,
-                GLvoid *values, GLuint valueSize);
-
-
-extern void *
-_swrast_get_dest_rgba(GLcontext *ctx, struct gl_renderbuffer *rb,
-                      SWspan *span);
-
-#endif
+/*

+ * Mesa 3-D graphics library

+ * Version:  7.5

+ *

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

+ * Copyright (C) 2009  VMware, Inc.  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.

+ */

+

+

+#ifndef S_SPAN_H

+#define S_SPAN_H

+

+

+#include "main/config.h"

+#include "main/glheader.h"

+#include "main/mtypes.h"

+

+struct gl_context;

+struct gl_renderbuffer;

+

+

+/**

+ * \defgroup SpanFlags

+ * Special bitflags to describe span data.

+ *

+ * In general, the point/line/triangle functions interpolate/emit the

+ * attributes specified by swrast->_ActiveAttribs (i.e. FRAT_BIT_* values).

+ * Some things don't fit into that, though, so we have these flags.

+ */

+/*@{*/

+#define SPAN_RGBA       0x01  /**< interpMask and arrayMask */

+#define SPAN_Z          0x02  /**< interpMask and arrayMask */

+#define SPAN_FLAT       0x04  /**< interpMask: flat shading? */

+#define SPAN_XY         0x08  /**< array.x[], y[] valid? */

+#define SPAN_MASK       0x10  /**< was array.mask[] filled in by caller? */

+#define SPAN_LAMBDA     0x20  /**< array.lambda[] valid? */

+#define SPAN_COVERAGE   0x40  /**< array.coverage[] valid? */

+/*@}*/

+

+

+/**

+ * \sw_span_arrays 

+ * \brief Arrays of fragment values.

+ *

+ * These will either be computed from the span x/xStep values or

+ * filled in by glDraw/CopyPixels, etc.

+ * These arrays are separated out of sw_span to conserve memory.

+ */

+typedef struct sw_span_arrays

+{

+   /** Per-fragment attributes (indexed by FRAG_ATTRIB_* tokens) */

+   /* XXX someday look at transposing first two indexes for better memory

+    * access pattern.

+    */

+   GLfloat attribs[FRAG_ATTRIB_MAX][MAX_WIDTH][4];

+

+   /** This mask indicates which fragments are alive or culled */

+   GLubyte mask[MAX_WIDTH];

+

+   GLenum ChanType; /**< Color channel type, GL_UNSIGNED_BYTE, GL_FLOAT */

+

+   /** Attribute arrays that don't fit into attribs[] array above */

+   /*@{*/

+   GLubyte rgba8[MAX_WIDTH][4];

+   GLushort rgba16[MAX_WIDTH][4];

+   GLchan (*rgba)[4];  /** either == rgba8 or rgba16 */

+   GLint   x[MAX_WIDTH];  /**< fragment X coords */

+   GLint   y[MAX_WIDTH];  /**< fragment Y coords */

+   GLuint  z[MAX_WIDTH];  /**< fragment Z coords */

+   GLuint  index[MAX_WIDTH];  /**< Color indexes */

+   GLfloat lambda[MAX_TEXTURE_COORD_UNITS][MAX_WIDTH]; /**< Texture LOD */

+   GLfloat coverage[MAX_WIDTH];  /**< Fragment coverage for AA/smoothing */

+   /*@}*/

+} SWspanarrays;

+

+

+/**

+ * The SWspan structure describes the colors, Z, fogcoord, texcoords,

+ * etc for either a horizontal run or an array of independent pixels.

+ * We can either specify a base/step to indicate interpolated values, or

+ * fill in explicit arrays of values.  The interpMask and arrayMask bitfields

+ * indicate which attributes are active interpolants or arrays, respectively.

+ *

+ * It would be interesting to experiment with multiprocessor rasterization

+ * with this structure.  The triangle rasterizer could simply emit a

+ * stream of these structures which would be consumed by one or more

+ * span-processing threads which could run in parallel.

+ */

+typedef struct sw_span

+{

+   /** Coord of first fragment in horizontal span/run */

+   GLint x, y;

+

+   /** Number of fragments in the span */

+   GLuint end;

+

+   /** for clipping left edge of spans */

+   GLuint leftClip;

+

+   /** This flag indicates that mask[] array is effectively filled with ones */

+   GLboolean writeAll;

+

+   /** either GL_POLYGON, GL_LINE, GL_POLYGON, GL_BITMAP */

+   GLenum primitive;

+

+   /** 0 = front-facing span, 1 = back-facing span (for two-sided stencil) */

+   GLuint facing;

+

+   /**

+    * This bitmask (of  \link SpanFlags SPAN_* flags\endlink) indicates

+    * which of the attrStart/StepX/StepY variables are relevant.

+    */

+   GLbitfield interpMask;

+

+   /** Fragment attribute interpolants */

+   GLfloat attrStart[FRAG_ATTRIB_MAX][4];   /**< initial value */

+   GLfloat attrStepX[FRAG_ATTRIB_MAX][4];   /**< dvalue/dx */

+   GLfloat attrStepY[FRAG_ATTRIB_MAX][4];   /**< dvalue/dy */

+

+   /* XXX the rest of these will go away eventually... */

+

+   /* For horizontal spans, step is the partial derivative wrt X.

+    * For lines, step is the delta from one fragment to the next.

+    */

+   GLfixed red, redStep;

+   GLfixed green, greenStep;

+   GLfixed blue, blueStep;

+   GLfixed alpha, alphaStep;

+   GLfixed index, indexStep;

+   GLfixed z, zStep;    /**< XXX z should probably be GLuint */

+   GLfixed intTex[2], intTexStep[2];  /**< (s,t) for unit[0] only */

+

+   /**

+    * This bitmask (of \link SpanFlags SPAN_* flags\endlink) indicates

+    * which of the fragment arrays in the span_arrays struct are relevant.

+    */

+   GLbitfield arrayMask;

+

+   GLbitfield arrayAttribs;

+

+   /**

+    * We store the arrays of fragment values in a separate struct so

+    * that we can allocate sw_span structs on the stack without using

+    * a lot of memory.  The span_arrays struct is about 1.4MB while the

+    * sw_span struct is only about 512 bytes.

+    */

+   SWspanarrays *array;

+} SWspan;

+

+

+

+#define INIT_SPAN(S, PRIMITIVE)			\

+do {						\

+   (S).primitive = (PRIMITIVE);			\

+   (S).interpMask = 0x0;			\

+   (S).arrayMask = 0x0;				\

+   (S).arrayAttribs = 0x0;			\

+   (S).end = 0;					\

+   (S).leftClip = 0;				\

+   (S).facing = 0;				\

+   (S).array = SWRAST_CONTEXT(ctx)->SpanArrays;	\

+} while (0)

+

+

+

+extern void

+_swrast_span_default_attribs(struct gl_context *ctx, SWspan *span);

+

+extern void

+_swrast_span_interpolate_z( const struct gl_context *ctx, SWspan *span );

+

+extern GLfloat

+_swrast_compute_lambda(GLfloat dsdx, GLfloat dsdy, GLfloat dtdx, GLfloat dtdy,

+                       GLfloat dqdx, GLfloat dqdy, GLfloat texW, GLfloat texH,

+                       GLfloat s, GLfloat t, GLfloat q, GLfloat invQ);

+

+

+extern void

+_swrast_write_rgba_span( struct gl_context *ctx, SWspan *span);

+

+

+extern void

+_swrast_read_rgba_span(struct gl_context *ctx, struct gl_renderbuffer *rb,

+                       GLuint n, GLint x, GLint y, GLenum type, GLvoid *rgba);

+

+extern void

+_swrast_get_values(struct gl_context *ctx, struct gl_renderbuffer *rb,

+                   GLuint count, const GLint x[], const GLint y[],

+                   void *values, GLuint valueSize);

+

+extern void

+_swrast_put_row(struct gl_context *ctx, struct gl_renderbuffer *rb,

+                GLuint count, GLint x, GLint y,

+                const GLvoid *values, GLuint valueSize);

+

+extern void

+_swrast_get_row(struct gl_context *ctx, struct gl_renderbuffer *rb,

+                GLuint count, GLint x, GLint y,

+                GLvoid *values, GLuint valueSize);

+

+

+extern void *

+_swrast_get_dest_rgba(struct gl_context *ctx, struct gl_renderbuffer *rb,

+                      SWspan *span);

+

+#endif

diff --git a/mesalib/src/mesa/swrast/s_spantemp.h b/mesalib/src/mesa/swrast/s_spantemp.h
index 2948a90f6..125d19638 100644
--- a/mesalib/src/mesa/swrast/s_spantemp.h
+++ b/mesalib/src/mesa/swrast/s_spantemp.h
@@ -1,221 +1,221 @@
-/*
- * Mesa 3-D graphics library
- * Version:  6.5.1
- *
- * Copyright (C) 1999-2006  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.
- */
-
-
-/*
- * Templates for the span/pixel-array write/read functions called via
- * the gl_renderbuffer's GetRow, GetValues, PutRow, PutMonoRow, PutValues
- * and PutMonoValues functions.
- *
- * Define the following macros before including this file:
- *   NAME(BASE)  to generate the function name (i.e. add prefix or suffix)
- *   RB_TYPE  the renderbuffer DataType
- *   SPAN_VARS  to declare any local variables
- *   INIT_PIXEL_PTR(P, X, Y)  to initialize a pointer to a pixel
- *   INC_PIXEL_PTR(P)  to increment a pixel pointer by one pixel
- *   STORE_PIXEL(DST, X, Y, VALUE)  to store pixel values in buffer
- *   FETCH_PIXEL(DST, SRC)  to fetch pixel values from buffer
- *
- * Note that in the STORE_PIXEL macros, we also pass in the (X,Y) coordinates
- * for the pixels to be stored.  This is useful when dithering and probably
- * ignored otherwise.
- */
-
-#include "main/macros.h"
-
-
-#if !defined(RB_COMPONENTS)
-#define RB_COMPONENTS 4
-#endif
-
-
-static void
-NAME(get_row)( GLcontext *ctx, struct gl_renderbuffer *rb,
-               GLuint count, GLint x, GLint y, void *values )
-{
-#ifdef SPAN_VARS
-   SPAN_VARS
-#endif
-   RB_TYPE (*dest)[RB_COMPONENTS] = (RB_TYPE (*)[RB_COMPONENTS]) values;
-   GLuint i;
-   INIT_PIXEL_PTR(pixel, x, y);
-   for (i = 0; i < count; i++) {
-      FETCH_PIXEL(dest[i], pixel);
-      INC_PIXEL_PTR(pixel);
-   }
-   (void) rb;
-}
-
-
-static void
-NAME(get_values)( GLcontext *ctx, struct gl_renderbuffer *rb,
-                  GLuint count, const GLint x[], const GLint y[], void *values )
-{
-#ifdef SPAN_VARS
-   SPAN_VARS
-#endif
-   RB_TYPE (*dest)[RB_COMPONENTS] = (RB_TYPE (*)[RB_COMPONENTS]) values;
-   GLuint i;
-   for (i = 0; i < count; i++) {
-      INIT_PIXEL_PTR(pixel, x[i], y[i]);
-      FETCH_PIXEL(dest[i], pixel);
-   }
-   (void) rb;
-}
-
-
-static void
-NAME(put_row)( GLcontext *ctx, struct gl_renderbuffer *rb,
-               GLuint count, GLint x, GLint y,
-               const void *values, const GLubyte mask[] )
-{
-#ifdef SPAN_VARS
-   SPAN_VARS
-#endif
-   const RB_TYPE (*src)[RB_COMPONENTS] = (const RB_TYPE (*)[RB_COMPONENTS]) values;
-   GLuint i;
-   INIT_PIXEL_PTR(pixel, x, y);
-   if (mask) {
-      for (i = 0; i < count; i++) {
-         if (mask[i]) {
-            STORE_PIXEL(pixel, x + i, y, src[i]);
-         }
-         INC_PIXEL_PTR(pixel);
-      }
-   }
-   else {
-      for (i = 0; i < count; i++) {
-         STORE_PIXEL(pixel, x + i, y, src[i]);
-         INC_PIXEL_PTR(pixel);
-      }
-   }
-   (void) rb;
-}
-
-
-static void
-NAME(put_row_rgb)( GLcontext *ctx, struct gl_renderbuffer *rb,
-                   GLuint count, GLint x, GLint y,
-                   const void *values, const GLubyte mask[] )
-{
-#ifdef SPAN_VARS
-   SPAN_VARS
-#endif
-   const RB_TYPE (*src)[3] = (const RB_TYPE (*)[3]) values;
-   GLuint i;
-   INIT_PIXEL_PTR(pixel, x, y);
-   for (i = 0; i < count; i++) {
-      if (!mask || mask[i]) {
-#ifdef STORE_PIXEL_RGB
-         STORE_PIXEL_RGB(pixel, x + i, y, src[i]);
-#else
-         STORE_PIXEL(pixel, x + i, y, src[i]);
-#endif
-      }
-      INC_PIXEL_PTR(pixel);
-   }
-   (void) rb;
-}
-
-
-static void
-NAME(put_mono_row)( GLcontext *ctx, struct gl_renderbuffer *rb,
-                    GLuint count, GLint x, GLint y,
-                    const void *value, const GLubyte mask[] )
-{
-#ifdef SPAN_VARS
-   SPAN_VARS
-#endif
-   const RB_TYPE *src = (const RB_TYPE *) value;
-   GLuint i;
-   INIT_PIXEL_PTR(pixel, x, y);
-   if (mask) {
-      for (i = 0; i < count; i++) {
-         if (mask[i]) {
-            STORE_PIXEL(pixel, x + i, y, src);
-         }
-         INC_PIXEL_PTR(pixel);
-      }
-   }
-   else {
-      for (i = 0; i < count; i++) {
-         STORE_PIXEL(pixel, x + i, y, src);
-         INC_PIXEL_PTR(pixel);
-      }
-   }
-   (void) rb;
-}
-
-
-static void
-NAME(put_values)( GLcontext *ctx, struct gl_renderbuffer *rb,
-                  GLuint count, const GLint x[], const GLint y[],
-                  const void *values, const GLubyte mask[] )
-{
-#ifdef SPAN_VARS
-   SPAN_VARS
-#endif
-   const RB_TYPE (*src)[RB_COMPONENTS] = (const RB_TYPE (*)[RB_COMPONENTS]) values;
-   GLuint i;
-   ASSERT(mask);
-   for (i = 0; i < count; i++) {
-      if (mask[i]) {
-         INIT_PIXEL_PTR(pixel, x[i], y[i]);
-         STORE_PIXEL(pixel, x[i], y[i], src[i]);
-      }
-   }
-   (void) rb;
-}
-
-
-static void
-NAME(put_mono_values)( GLcontext *ctx, struct gl_renderbuffer *rb,
-                       GLuint count, const GLint x[], const GLint y[],
-                       const void *value, const GLubyte mask[] )
-{
-#ifdef SPAN_VARS
-   SPAN_VARS
-#endif
-   const RB_TYPE *src = (const RB_TYPE *) value;
-   GLuint i;
-   ASSERT(mask);
-   for (i = 0; i < count; i++) {
-      if (mask[i]) {
-         INIT_PIXEL_PTR(pixel, x[i], y[i]);
-         STORE_PIXEL(pixel, x[i], y[i], src);
-      }
-   }
-   (void) rb;
-}
-
-
-#undef NAME
-#undef RB_TYPE
-#undef RB_COMPONENTS
-#undef SPAN_VARS
-#undef INIT_PIXEL_PTR
-#undef INC_PIXEL_PTR
-#undef STORE_PIXEL
-#undef STORE_PIXEL_RGB
-#undef FETCH_PIXEL
+/*

+ * Mesa 3-D graphics library

+ * Version:  6.5.1

+ *

+ * Copyright (C) 1999-2006  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.

+ */

+

+

+/*

+ * Templates for the span/pixel-array write/read functions called via

+ * the gl_renderbuffer's GetRow, GetValues, PutRow, PutMonoRow, PutValues

+ * and PutMonoValues functions.

+ *

+ * Define the following macros before including this file:

+ *   NAME(BASE)  to generate the function name (i.e. add prefix or suffix)

+ *   RB_TYPE  the renderbuffer DataType

+ *   SPAN_VARS  to declare any local variables

+ *   INIT_PIXEL_PTR(P, X, Y)  to initialize a pointer to a pixel

+ *   INC_PIXEL_PTR(P)  to increment a pixel pointer by one pixel

+ *   STORE_PIXEL(DST, X, Y, VALUE)  to store pixel values in buffer

+ *   FETCH_PIXEL(DST, SRC)  to fetch pixel values from buffer

+ *

+ * Note that in the STORE_PIXEL macros, we also pass in the (X,Y) coordinates

+ * for the pixels to be stored.  This is useful when dithering and probably

+ * ignored otherwise.

+ */

+

+#include "main/macros.h"

+

+

+#if !defined(RB_COMPONENTS)

+#define RB_COMPONENTS 4

+#endif

+

+

+static void

+NAME(get_row)( struct gl_context *ctx, struct gl_renderbuffer *rb,

+               GLuint count, GLint x, GLint y, void *values )

+{

+#ifdef SPAN_VARS

+   SPAN_VARS

+#endif

+   RB_TYPE (*dest)[RB_COMPONENTS] = (RB_TYPE (*)[RB_COMPONENTS]) values;

+   GLuint i;

+   INIT_PIXEL_PTR(pixel, x, y);

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

+      FETCH_PIXEL(dest[i], pixel);

+      INC_PIXEL_PTR(pixel);

+   }

+   (void) rb;

+}

+

+

+static void

+NAME(get_values)( struct gl_context *ctx, struct gl_renderbuffer *rb,

+                  GLuint count, const GLint x[], const GLint y[], void *values )

+{

+#ifdef SPAN_VARS

+   SPAN_VARS

+#endif

+   RB_TYPE (*dest)[RB_COMPONENTS] = (RB_TYPE (*)[RB_COMPONENTS]) values;

+   GLuint i;

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

+      INIT_PIXEL_PTR(pixel, x[i], y[i]);

+      FETCH_PIXEL(dest[i], pixel);

+   }

+   (void) rb;

+}

+

+

+static void

+NAME(put_row)( struct gl_context *ctx, struct gl_renderbuffer *rb,

+               GLuint count, GLint x, GLint y,

+               const void *values, const GLubyte mask[] )

+{

+#ifdef SPAN_VARS

+   SPAN_VARS

+#endif

+   const RB_TYPE (*src)[RB_COMPONENTS] = (const RB_TYPE (*)[RB_COMPONENTS]) values;

+   GLuint i;

+   INIT_PIXEL_PTR(pixel, x, y);

+   if (mask) {

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

+         if (mask[i]) {

+            STORE_PIXEL(pixel, x + i, y, src[i]);

+         }

+         INC_PIXEL_PTR(pixel);

+      }

+   }

+   else {

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

+         STORE_PIXEL(pixel, x + i, y, src[i]);

+         INC_PIXEL_PTR(pixel);

+      }

+   }

+   (void) rb;

+}

+

+

+static void

+NAME(put_row_rgb)( struct gl_context *ctx, struct gl_renderbuffer *rb,

+                   GLuint count, GLint x, GLint y,

+                   const void *values, const GLubyte mask[] )

+{

+#ifdef SPAN_VARS

+   SPAN_VARS

+#endif

+   const RB_TYPE (*src)[3] = (const RB_TYPE (*)[3]) values;

+   GLuint i;

+   INIT_PIXEL_PTR(pixel, x, y);

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

+      if (!mask || mask[i]) {

+#ifdef STORE_PIXEL_RGB

+         STORE_PIXEL_RGB(pixel, x + i, y, src[i]);

+#else

+         STORE_PIXEL(pixel, x + i, y, src[i]);

+#endif

+      }

+      INC_PIXEL_PTR(pixel);

+   }

+   (void) rb;

+}

+

+

+static void

+NAME(put_mono_row)( struct gl_context *ctx, struct gl_renderbuffer *rb,

+                    GLuint count, GLint x, GLint y,

+                    const void *value, const GLubyte mask[] )

+{

+#ifdef SPAN_VARS

+   SPAN_VARS

+#endif

+   const RB_TYPE *src = (const RB_TYPE *) value;

+   GLuint i;

+   INIT_PIXEL_PTR(pixel, x, y);

+   if (mask) {

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

+         if (mask[i]) {

+            STORE_PIXEL(pixel, x + i, y, src);

+         }

+         INC_PIXEL_PTR(pixel);

+      }

+   }

+   else {

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

+         STORE_PIXEL(pixel, x + i, y, src);

+         INC_PIXEL_PTR(pixel);

+      }

+   }

+   (void) rb;

+}

+

+

+static void

+NAME(put_values)( struct gl_context *ctx, struct gl_renderbuffer *rb,

+                  GLuint count, const GLint x[], const GLint y[],

+                  const void *values, const GLubyte mask[] )

+{

+#ifdef SPAN_VARS

+   SPAN_VARS

+#endif

+   const RB_TYPE (*src)[RB_COMPONENTS] = (const RB_TYPE (*)[RB_COMPONENTS]) values;

+   GLuint i;

+   ASSERT(mask);

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

+      if (mask[i]) {

+         INIT_PIXEL_PTR(pixel, x[i], y[i]);

+         STORE_PIXEL(pixel, x[i], y[i], src[i]);

+      }

+   }

+   (void) rb;

+}

+

+

+static void

+NAME(put_mono_values)( struct gl_context *ctx, struct gl_renderbuffer *rb,

+                       GLuint count, const GLint x[], const GLint y[],

+                       const void *value, const GLubyte mask[] )

+{

+#ifdef SPAN_VARS

+   SPAN_VARS

+#endif

+   const RB_TYPE *src = (const RB_TYPE *) value;

+   GLuint i;

+   ASSERT(mask);

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

+      if (mask[i]) {

+         INIT_PIXEL_PTR(pixel, x[i], y[i]);

+         STORE_PIXEL(pixel, x[i], y[i], src);

+      }

+   }

+   (void) rb;

+}

+

+

+#undef NAME

+#undef RB_TYPE

+#undef RB_COMPONENTS

+#undef SPAN_VARS

+#undef INIT_PIXEL_PTR

+#undef INC_PIXEL_PTR

+#undef STORE_PIXEL

+#undef STORE_PIXEL_RGB

+#undef FETCH_PIXEL

diff --git a/mesalib/src/mesa/swrast/s_stencil.c b/mesalib/src/mesa/swrast/s_stencil.c
index aa74b21ee..999fe3c3f 100644
--- a/mesalib/src/mesa/swrast/s_stencil.c
+++ b/mesalib/src/mesa/swrast/s_stencil.c
@@ -1,1245 +1,1245 @@
-/*
- * 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/context.h"
-#include "main/imports.h"
-
-#include "s_context.h"
-#include "s_depth.h"
-#include "s_stencil.h"
-#include "s_span.h"
-
-
-
-/* Stencil Logic:
-
-IF stencil test fails THEN
-   Apply fail-op to stencil value
-   Don't write the pixel (RGBA,Z)
-ELSE
-   IF doing depth test && depth test fails THEN
-      Apply zfail-op to stencil value
-      Write RGBA and Z to appropriate buffers
-   ELSE
-      Apply zpass-op to stencil value
-ENDIF
-
-*/
-
-
-/**
- * Apply the given stencil operator to the array of stencil values.
- * Don't touch stencil[i] if mask[i] is zero.
- * Input:  n - size of stencil array
- *         oper - the stencil buffer operator
- *         face - 0 or 1 for front or back face operation
- *         stencil - array of stencil values
- *         mask - array [n] of flag:  1=apply operator, 0=don't apply operator
- * Output:  stencil - modified values
- */
-static void
-apply_stencil_op( const GLcontext *ctx, GLenum oper, GLuint face,
-                  GLuint n, GLstencil stencil[], const GLubyte mask[] )
-{
-   const GLstencil ref = ctx->Stencil.Ref[face];
-   const GLstencil wrtmask = ctx->Stencil.WriteMask[face];
-   const GLstencil invmask = (GLstencil) (~wrtmask);
-   const GLstencil stencilMax = (1 << ctx->DrawBuffer->Visual.stencilBits) - 1;
-   GLuint i;
-
-   switch (oper) {
-      case GL_KEEP:
-         /* do nothing */
-         break;
-      case GL_ZERO:
-	 if (invmask==0) {
-	    for (i=0;i<n;i++) {
-	       if (mask[i]) {
-		  stencil[i] = 0;
-	       }
-	    }
-	 }
-	 else {
-	    for (i=0;i<n;i++) {
-	       if (mask[i]) {
-		  stencil[i] = (GLstencil) (stencil[i] & invmask);
-	       }
-	    }
-	 }
-	 break;
-      case GL_REPLACE:
-	 if (invmask==0) {
-	    for (i=0;i<n;i++) {
-	       if (mask[i]) {
-                  stencil[i] = ref;
-	       }
-	    }
-	 }
-	 else {
-	    for (i=0;i<n;i++) {
-	       if (mask[i]) {
-		  GLstencil s = stencil[i];
-		  stencil[i] = (GLstencil) ((invmask & s ) | (wrtmask & ref));
-	       }
-	    }
-	 }
-	 break;
-      case GL_INCR:
-	 if (invmask==0) {
-	    for (i=0;i<n;i++) {
-	       if (mask[i]) {
-		  GLstencil s = stencil[i];
-		  if (s < stencilMax) {
-		     stencil[i] = (GLstencil) (s+1);
-		  }
-	       }
-	    }
-	 }
-	 else {
-	    for (i=0;i<n;i++) {
-	       if (mask[i]) {
-		  /* VERIFY logic of adding 1 to a write-masked value */
-		  GLstencil s = stencil[i];
-		  if (s < stencilMax) {
-		     stencil[i] = (GLstencil) ((invmask & s) | (wrtmask & (s+1)));
-		  }
-	       }
-	    }
-	 }
-	 break;
-      case GL_DECR:
-	 if (invmask==0) {
-	    for (i=0;i<n;i++) {
-	       if (mask[i]) {
-		  GLstencil s = stencil[i];
-		  if (s>0) {
-		     stencil[i] = (GLstencil) (s-1);
-		  }
-	       }
-	    }
-	 }
-	 else {
-	    for (i=0;i<n;i++) {
-	       if (mask[i]) {
-		  /* VERIFY logic of subtracting 1 to a write-masked value */
-		  GLstencil s = stencil[i];
-		  if (s>0) {
-		     stencil[i] = (GLstencil) ((invmask & s) | (wrtmask & (s-1)));
-		  }
-	       }
-	    }
-	 }
-	 break;
-      case GL_INCR_WRAP_EXT:
-	 if (invmask==0) {
-	    for (i=0;i<n;i++) {
-	       if (mask[i]) {
-                  stencil[i]++;
-	       }
-	    }
-	 }
-	 else {
-	    for (i=0;i<n;i++) {
-	       if (mask[i]) {
-                  GLstencil s = stencil[i];
-                  stencil[i] = (GLstencil) ((invmask & s) | (wrtmask & (s+1)));
-	       }
-	    }
-	 }
-	 break;
-      case GL_DECR_WRAP_EXT:
-	 if (invmask==0) {
-	    for (i=0;i<n;i++) {
-	       if (mask[i]) {
-		  stencil[i]--;
-	       }
-	    }
-	 }
-	 else {
-	    for (i=0;i<n;i++) {
-	       if (mask[i]) {
-                  GLstencil s = stencil[i];
-                  stencil[i] = (GLstencil) ((invmask & s) | (wrtmask & (s-1)));
-	       }
-	    }
-	 }
-	 break;
-      case GL_INVERT:
-	 if (invmask==0) {
-	    for (i=0;i<n;i++) {
-	       if (mask[i]) {
-		  GLstencil s = stencil[i];
-		  stencil[i] = (GLstencil) ~s;
-	       }
-	    }
-	 }
-	 else {
-	    for (i=0;i<n;i++) {
-	       if (mask[i]) {
-		  GLstencil s = stencil[i];
-		  stencil[i] = (GLstencil) ((invmask & s) | (wrtmask & ~s));
-	       }
-	    }
-	 }
-	 break;
-      default:
-         _mesa_problem(ctx, "Bad stencil op in apply_stencil_op");
-   }
-}
-
-
-
-
-/**
- * Apply stencil test to an array of stencil values (before depth buffering).
- * Input:  face - 0 or 1 for front or back-face polygons
- *         n - number of pixels in the array
- *         stencil - array of [n] stencil values
- *         mask - array [n] of flag:  0=skip the pixel, 1=stencil the pixel
- * Output:  mask - pixels which fail the stencil test will have their
- *                 mask flag set to 0.
- *          stencil - updated stencil values (where the test passed)
- * Return:  GL_FALSE = all pixels failed, GL_TRUE = zero or more pixels passed.
- */
-static GLboolean
-do_stencil_test( GLcontext *ctx, GLuint face, GLuint n, GLstencil stencil[],
-                 GLubyte mask[] )
-{
-   GLubyte fail[MAX_WIDTH];
-   GLboolean allfail = GL_FALSE;
-   GLuint i;
-   const GLuint valueMask = ctx->Stencil.ValueMask[face];
-   const GLstencil r = (GLstencil) (ctx->Stencil.Ref[face] & valueMask);
-   GLstencil s;
-
-   ASSERT(n <= MAX_WIDTH);
-
-   /*
-    * Perform stencil test.  The results of this operation are stored
-    * in the fail[] array:
-    *   IF fail[i] is non-zero THEN
-    *       the stencil fail operator is to be applied
-    *   ELSE
-    *       the stencil fail operator is not to be applied
-    *   ENDIF
-    */
-   switch (ctx->Stencil.Function[face]) {
-      case GL_NEVER:
-         /* never pass; always fail */
-         for (i=0;i<n;i++) {
-	    if (mask[i]) {
-	       mask[i] = 0;
-	       fail[i] = 1;
-	    }
-	    else {
-	       fail[i] = 0;
-	    }
-	 }
-	 allfail = GL_TRUE;
-	 break;
-      case GL_LESS:
-	 for (i=0;i<n;i++) {
-	    if (mask[i]) {
-	       s = (GLstencil) (stencil[i] & valueMask);
-	       if (r < s) {
-		  /* passed */
-		  fail[i] = 0;
-	       }
-	       else {
-		  fail[i] = 1;
-		  mask[i] = 0;
-	       }
-	    }
-	    else {
-	       fail[i] = 0;
-	    }
-	 }
-	 break;
-      case GL_LEQUAL:
-	 for (i=0;i<n;i++) {
-	    if (mask[i]) {
-	       s = (GLstencil) (stencil[i] & valueMask);
-	       if (r <= s) {
-		  /* pass */
-		  fail[i] = 0;
-	       }
-	       else {
-		  fail[i] = 1;
-		  mask[i] = 0;
-	       }
-	    }
-	    else {
-	       fail[i] = 0;
-	    }
-	 }
-	 break;
-      case GL_GREATER:
-	 for (i=0;i<n;i++) {
-	    if (mask[i]) {
-	       s = (GLstencil) (stencil[i] & valueMask);
-	       if (r > s) {
-		  /* passed */
-		  fail[i] = 0;
-	       }
-	       else {
-		  fail[i] = 1;
-		  mask[i] = 0;
-	       }
-	    }
-	    else {
-	       fail[i] = 0;
-	    }
-	 }
-	 break;
-      case GL_GEQUAL:
-	 for (i=0;i<n;i++) {
-	    if (mask[i]) {
-	       s = (GLstencil) (stencil[i] & valueMask);
-	       if (r >= s) {
-		  /* passed */
-		  fail[i] = 0;
-	       }
-	       else {
-		  fail[i] = 1;
-		  mask[i] = 0;
-	       }
-	    }
-	    else {
-	       fail[i] = 0;
-	    }
-	 }
-	 break;
-      case GL_EQUAL:
-	 for (i=0;i<n;i++) {
-	    if (mask[i]) {
-	       s = (GLstencil) (stencil[i] & valueMask);
-	       if (r == s) {
-		  /* passed */
-		  fail[i] = 0;
-	       }
-	       else {
-		  fail[i] = 1;
-		  mask[i] = 0;
-	       }
-	    }
-	    else {
-	       fail[i] = 0;
-	    }
-	 }
-	 break;
-      case GL_NOTEQUAL:
-	 for (i=0;i<n;i++) {
-	    if (mask[i]) {
-	       s = (GLstencil) (stencil[i] & valueMask);
-	       if (r != s) {
-		  /* passed */
-		  fail[i] = 0;
-	       }
-	       else {
-		  fail[i] = 1;
-		  mask[i] = 0;
-	       }
-	    }
-	    else {
-	       fail[i] = 0;
-	    }
-	 }
-	 break;
-      case GL_ALWAYS:
-	 /* always pass */
-	 for (i=0;i<n;i++) {
-	    fail[i] = 0;
-	 }
-	 break;
-      default:
-         _mesa_problem(ctx, "Bad stencil func in gl_stencil_span");
-         return 0;
-   }
-
-   if (ctx->Stencil.FailFunc[face] != GL_KEEP) {
-      apply_stencil_op( ctx, ctx->Stencil.FailFunc[face], face, n, stencil, fail );
-   }
-
-   return !allfail;
-}
-
-
-/**
- * Compute the zpass/zfail masks by comparing the pre- and post-depth test
- * masks.
- */
-static INLINE void
-compute_pass_fail_masks(GLuint n, const GLubyte origMask[],
-                        const GLubyte newMask[],
-                        GLubyte passMask[], GLubyte failMask[])
-{
-   GLuint i;
-   for (i = 0; i < n; i++) {
-      ASSERT(newMask[i] == 0 || newMask[i] == 1);
-      passMask[i] = origMask[i] & newMask[i];
-      failMask[i] = origMask[i] & (newMask[i] ^ 1);
-   }
-}
-
-
-/**
- * Apply stencil and depth testing to the span of pixels.
- * Both software and hardware stencil buffers are acceptable.
- * Input:  n - number of pixels in the span
- *         x, y - location of leftmost pixel in span
- *         z - array [n] of z values
- *         mask - array [n] of flags  (1=test this pixel, 0=skip the pixel)
- * Output:  mask - array [n] of flags (1=stencil and depth test passed)
- * Return: GL_FALSE - all fragments failed the testing
- *         GL_TRUE - one or more fragments passed the testing
- *
- */
-static GLboolean
-stencil_and_ztest_span(GLcontext *ctx, SWspan *span, GLuint face)
-{
-   struct gl_framebuffer *fb = ctx->DrawBuffer;
-   struct gl_renderbuffer *rb = fb->_StencilBuffer;
-   GLstencil stencilRow[MAX_WIDTH];
-   GLstencil *stencil;
-   const GLuint n = span->end;
-   const GLint x = span->x;
-   const GLint y = span->y;
-   GLubyte *mask = span->array->mask;
-
-   ASSERT((span->arrayMask & SPAN_XY) == 0);
-   ASSERT(ctx->Stencil.Enabled);
-   ASSERT(n <= MAX_WIDTH);
-#ifdef DEBUG
-   if (ctx->Depth.Test) {
-      ASSERT(span->arrayMask & SPAN_Z);
-   }
-#endif
-
-   stencil = (GLstencil *) rb->GetPointer(ctx, rb, x, y);
-   if (!stencil) {
-      rb->GetRow(ctx, rb, n, x, y, stencilRow);
-      stencil = stencilRow;
-   }
-
-   /*
-    * Apply the stencil test to the fragments.
-    * failMask[i] is 1 if the stencil test failed.
-    */
-   if (do_stencil_test( ctx, face, n, stencil, mask ) == GL_FALSE) {
-      /* all fragments failed the stencil test, we're done. */
-      span->writeAll = GL_FALSE;
-      if (!rb->GetPointer(ctx, rb, 0, 0)) {
-         /* put updated stencil values into buffer */
-         rb->PutRow(ctx, rb, n, x, y, stencil, NULL);
-      }
-      return GL_FALSE;
-   }
-
-   /*
-    * Some fragments passed the stencil test, apply depth test to them
-    * and apply Zpass and Zfail stencil ops.
-    */
-   if (ctx->Depth.Test == GL_FALSE) {
-      /*
-       * No depth buffer, just apply zpass stencil function to active pixels.
-       */
-      apply_stencil_op( ctx, ctx->Stencil.ZPassFunc[face], face, n, stencil, mask );
-   }
-   else {
-      /*
-       * Perform depth buffering, then apply zpass or zfail stencil function.
-       */
-      GLubyte passMask[MAX_WIDTH], failMask[MAX_WIDTH], origMask[MAX_WIDTH];
-
-      /* save the current mask bits */
-      memcpy(origMask, mask, n * sizeof(GLubyte));
-
-      /* apply the depth test */
-      _swrast_depth_test_span(ctx, span);
-
-      compute_pass_fail_masks(n, origMask, mask, passMask, failMask);
-
-      /* apply the pass and fail operations */
-      if (ctx->Stencil.ZFailFunc[face] != GL_KEEP) {
-         apply_stencil_op( ctx, ctx->Stencil.ZFailFunc[face], face,
-                           n, stencil, failMask );
-      }
-      if (ctx->Stencil.ZPassFunc[face] != GL_KEEP) {
-         apply_stencil_op( ctx, ctx->Stencil.ZPassFunc[face], face,
-                           n, stencil, passMask );
-      }
-   }
-
-   /*
-    * Write updated stencil values back into hardware stencil buffer.
-    */
-   if (!rb->GetPointer(ctx, rb, 0, 0)) {
-      rb->PutRow(ctx, rb, n, x, y, stencil, NULL);
-   }
-   
-   span->writeAll = GL_FALSE;
-   
-   return GL_TRUE;  /* one or more fragments passed both tests */
-}
-
-
-
-/*
- * Return the address of a stencil buffer value given the window coords:
- */
-#define STENCIL_ADDRESS(X, Y)  (stencilStart + (Y) * stride + (X))
-
-
-
-/**
- * Apply the given stencil operator for each pixel in the array whose
- * mask flag is set.
- * \note  This is for software stencil buffers only.
- * Input:  n - number of pixels in the span
- *         x, y - array of [n] pixels
- *         operator - the stencil buffer operator
- *         mask - array [n] of flag:  1=apply operator, 0=don't apply operator
- */
-static void
-apply_stencil_op_to_pixels( GLcontext *ctx,
-                            GLuint n, const GLint x[], const GLint y[],
-                            GLenum oper, GLuint face, const GLubyte mask[] )
-{
-   struct gl_framebuffer *fb = ctx->DrawBuffer;
-   struct gl_renderbuffer *rb = fb->_StencilBuffer;
-   const GLstencil stencilMax = (1 << fb->Visual.stencilBits) - 1;
-   const GLstencil ref = ctx->Stencil.Ref[face];
-   const GLstencil wrtmask = ctx->Stencil.WriteMask[face];
-   const GLstencil invmask = (GLstencil) (~wrtmask);
-   GLuint i;
-   GLstencil *stencilStart = (GLubyte *) rb->Data;
-   const GLuint stride = rb->Width;
-
-   ASSERT(rb->GetPointer(ctx, rb, 0, 0));
-   ASSERT(sizeof(GLstencil) == 1);
-
-   switch (oper) {
-      case GL_KEEP:
-         /* do nothing */
-         break;
-      case GL_ZERO:
-	 if (invmask==0) {
-	    for (i=0;i<n;i++) {
-	       if (mask[i]) {
-                  GLstencil *sptr = STENCIL_ADDRESS( x[i], y[i] );
-                  *sptr = 0;
-	       }
-	    }
-	 }
-	 else {
-	    for (i=0;i<n;i++) {
-	       if (mask[i]) {
-                  GLstencil *sptr = STENCIL_ADDRESS( x[i], y[i] );
-		  *sptr = (GLstencil) (invmask & *sptr);
-	       }
-	    }
-	 }
-	 break;
-      case GL_REPLACE:
-	 if (invmask==0) {
-	    for (i=0;i<n;i++) {
-	       if (mask[i]) {
-                  GLstencil *sptr = STENCIL_ADDRESS( x[i], y[i] );
-                  *sptr = ref;
-	       }
-	    }
-	 }
-	 else {
-	    for (i=0;i<n;i++) {
-	       if (mask[i]) {
-                  GLstencil *sptr = STENCIL_ADDRESS( x[i], y[i] );
-		  *sptr = (GLstencil) ((invmask & *sptr ) | (wrtmask & ref));
-	       }
-	    }
-	 }
-	 break;
-      case GL_INCR:
-	 if (invmask==0) {
-	    for (i=0;i<n;i++) {
-	       if (mask[i]) {
-                  GLstencil *sptr = STENCIL_ADDRESS( x[i], y[i] );
-		  if (*sptr < stencilMax) {
-		     *sptr = (GLstencil) (*sptr + 1);
-		  }
-	       }
-	    }
-	 }
-	 else {
-	    for (i=0;i<n;i++) {
-	       if (mask[i]) {
-                  GLstencil *sptr = STENCIL_ADDRESS( x[i], y[i] );
-		  if (*sptr < stencilMax) {
-		     *sptr = (GLstencil) ((invmask & *sptr) | (wrtmask & (*sptr+1)));
-		  }
-	       }
-	    }
-	 }
-	 break;
-      case GL_DECR:
-	 if (invmask==0) {
-	    for (i=0;i<n;i++) {
-	       if (mask[i]) {
-                  GLstencil *sptr = STENCIL_ADDRESS( x[i], y[i] );
-		  if (*sptr>0) {
-		     *sptr = (GLstencil) (*sptr - 1);
-		  }
-	       }
-	    }
-	 }
-	 else {
-	    for (i=0;i<n;i++) {
-	       if (mask[i]) {
-                  GLstencil *sptr = STENCIL_ADDRESS( x[i], y[i] );
-		  if (*sptr>0) {
-		     *sptr = (GLstencil) ((invmask & *sptr) | (wrtmask & (*sptr-1)));
-		  }
-	       }
-	    }
-	 }
-	 break;
-      case GL_INCR_WRAP_EXT:
-	 if (invmask==0) {
-	    for (i=0;i<n;i++) {
-	       if (mask[i]) {
-                  GLstencil *sptr = STENCIL_ADDRESS( x[i], y[i] );
-                  *sptr = (GLstencil) (*sptr + 1);
-	       }
-	    }
-	 }
-	 else {
-	    for (i=0;i<n;i++) {
-	       if (mask[i]) {
-                  GLstencil *sptr = STENCIL_ADDRESS( x[i], y[i] );
-                  *sptr = (GLstencil) ((invmask & *sptr) | (wrtmask & (*sptr+1)));
-	       }
-	    }
-	 }
-	 break;
-      case GL_DECR_WRAP_EXT:
-	 if (invmask==0) {
-	    for (i=0;i<n;i++) {
-	       if (mask[i]) {
-                  GLstencil *sptr = STENCIL_ADDRESS( x[i], y[i] );
-                  *sptr = (GLstencil) (*sptr - 1);
-	       }
-	    }
-	 }
-	 else {
-	    for (i=0;i<n;i++) {
-	       if (mask[i]) {
-                  GLstencil *sptr = STENCIL_ADDRESS( x[i], y[i] );
-                  *sptr = (GLstencil) ((invmask & *sptr) | (wrtmask & (*sptr-1)));
-	       }
-	    }
-	 }
-	 break;
-      case GL_INVERT:
-	 if (invmask==0) {
-	    for (i=0;i<n;i++) {
-	       if (mask[i]) {
-                  GLstencil *sptr = STENCIL_ADDRESS( x[i], y[i] );
-                  *sptr = (GLstencil) (~*sptr);
-	       }
-	    }
-	 }
-	 else {
-	    for (i=0;i<n;i++) {
-	       if (mask[i]) {
-                  GLstencil *sptr = STENCIL_ADDRESS( x[i], y[i] );
-                  *sptr = (GLstencil) ((invmask & *sptr) | (wrtmask & ~*sptr));
-	       }
-	    }
-	 }
-	 break;
-      default:
-         _mesa_problem(ctx, "Bad stencilop in apply_stencil_op_to_pixels");
-   }
-}
-
-
-
-/**
- * Apply stencil test to an array of pixels before depth buffering.
- *
- * \note Used for software stencil buffer only.
- * Input:  n - number of pixels in the span
- *         x, y - array of [n] pixels to stencil
- *         mask - array [n] of flag:  0=skip the pixel, 1=stencil the pixel
- * Output:  mask - pixels which fail the stencil test will have their
- *                 mask flag set to 0.
- * \return  GL_FALSE = all pixels failed, GL_TRUE = zero or more pixels passed.
- */
-static GLboolean
-stencil_test_pixels( GLcontext *ctx, GLuint face, GLuint n,
-                     const GLint x[], const GLint y[], GLubyte mask[] )
-{
-   const struct gl_framebuffer *fb = ctx->DrawBuffer;
-   struct gl_renderbuffer *rb = fb->_StencilBuffer;
-   GLubyte fail[MAX_WIDTH];
-   GLstencil r, s;
-   GLuint i;
-   GLboolean allfail = GL_FALSE;
-   const GLuint valueMask = ctx->Stencil.ValueMask[face];
-   const GLstencil *stencilStart = (GLstencil *) rb->Data;
-   const GLuint stride = rb->Width;
-
-   ASSERT(rb->GetPointer(ctx, rb, 0, 0));
-   ASSERT(sizeof(GLstencil) == 1);
-
-   /*
-    * Perform stencil test.  The results of this operation are stored
-    * in the fail[] array:
-    *   IF fail[i] is non-zero THEN
-    *       the stencil fail operator is to be applied
-    *   ELSE
-    *       the stencil fail operator is not to be applied
-    *   ENDIF
-    */
-
-   switch (ctx->Stencil.Function[face]) {
-      case GL_NEVER:
-         /* always fail */
-         for (i=0;i<n;i++) {
-	    if (mask[i]) {
-	       mask[i] = 0;
-	       fail[i] = 1;
-	    }
-	    else {
-	       fail[i] = 0;
-	    }
-	 }
-	 allfail = GL_TRUE;
-	 break;
-      case GL_LESS:
-	 r = (GLstencil) (ctx->Stencil.Ref[face] & valueMask);
-	 for (i=0;i<n;i++) {
-	    if (mask[i]) {
-               const GLstencil *sptr = STENCIL_ADDRESS(x[i],y[i]);
-	       s = (GLstencil) (*sptr & valueMask);
-	       if (r < s) {
-		  /* passed */
-		  fail[i] = 0;
-	       }
-	       else {
-		  fail[i] = 1;
-		  mask[i] = 0;
-	       }
-	    }
-	    else {
-	       fail[i] = 0;
-	    }
-	 }
-	 break;
-      case GL_LEQUAL:
-	 r = (GLstencil) (ctx->Stencil.Ref[face] & valueMask);
-	 for (i=0;i<n;i++) {
-	    if (mask[i]) {
-               const GLstencil *sptr = STENCIL_ADDRESS(x[i],y[i]);
-	       s = (GLstencil) (*sptr & valueMask);
-	       if (r <= s) {
-		  /* pass */
-		  fail[i] = 0;
-	       }
-	       else {
-		  fail[i] = 1;
-		  mask[i] = 0;
-	       }
-	    }
-	    else {
-	       fail[i] = 0;
-	    }
-	 }
-	 break;
-      case GL_GREATER:
-	 r = (GLstencil) (ctx->Stencil.Ref[face] & valueMask);
-	 for (i=0;i<n;i++) {
-	    if (mask[i]) {
-               const GLstencil *sptr = STENCIL_ADDRESS(x[i],y[i]);
-	       s = (GLstencil) (*sptr & valueMask);
-	       if (r > s) {
-		  /* passed */
-		  fail[i] = 0;
-	       }
-	       else {
-		  fail[i] = 1;
-		  mask[i] = 0;
-	       }
-	    }
-	    else {
-	       fail[i] = 0;
-	    }
-	 }
-	 break;
-      case GL_GEQUAL:
-	 r = (GLstencil) (ctx->Stencil.Ref[face] & valueMask);
-	 for (i=0;i<n;i++) {
-	    if (mask[i]) {
-               const GLstencil *sptr = STENCIL_ADDRESS(x[i],y[i]);
-	       s = (GLstencil) (*sptr & valueMask);
-	       if (r >= s) {
-		  /* passed */
-		  fail[i] = 0;
-	       }
-	       else {
-		  fail[i] = 1;
-		  mask[i] = 0;
-	       }
-	    }
-	    else {
-	       fail[i] = 0;
-	    }
-	 }
-	 break;
-      case GL_EQUAL:
-	 r = (GLstencil) (ctx->Stencil.Ref[face] & valueMask);
-	 for (i=0;i<n;i++) {
-	    if (mask[i]) {
-               const GLstencil *sptr = STENCIL_ADDRESS(x[i],y[i]);
-	       s = (GLstencil) (*sptr & valueMask);
-	       if (r == s) {
-		  /* passed */
-		  fail[i] = 0;
-	       }
-	       else {
-		  fail[i] = 1;
-		  mask[i] = 0;
-	       }
-	    }
-	    else {
-	       fail[i] = 0;
-	    }
-	 }
-	 break;
-      case GL_NOTEQUAL:
-	 r = (GLstencil) (ctx->Stencil.Ref[face] & valueMask);
-	 for (i=0;i<n;i++) {
-	    if (mask[i]) {
-               const GLstencil *sptr = STENCIL_ADDRESS(x[i],y[i]);
-	       s = (GLstencil) (*sptr & valueMask);
-	       if (r != s) {
-		  /* passed */
-		  fail[i] = 0;
-	       }
-	       else {
-		  fail[i] = 1;
-		  mask[i] = 0;
-	       }
-	    }
-	    else {
-	       fail[i] = 0;
-	    }
-	 }
-	 break;
-      case GL_ALWAYS:
-	 /* always pass */
-	 for (i=0;i<n;i++) {
-	    fail[i] = 0;
-	 }
-	 break;
-      default:
-         _mesa_problem(ctx, "Bad stencil func in gl_stencil_pixels");
-         return 0;
-   }
-
-   if (ctx->Stencil.FailFunc[face] != GL_KEEP) {
-      apply_stencil_op_to_pixels( ctx, n, x, y, ctx->Stencil.FailFunc[face],
-                                  face, fail );
-   }
-
-   return !allfail;
-}
-
-
-
-
-/**
- * Apply stencil and depth testing to an array of pixels.
- * This is used both for software and hardware stencil buffers.
- *
- * The comments in this function are a bit sparse but the code is
- * almost identical to stencil_and_ztest_span(), which is well
- * commented.
- *
- * Input:  n - number of pixels in the array
- *         x, y - array of [n] pixel positions
- *         z - array [n] of z values
- *         mask - array [n] of flags  (1=test this pixel, 0=skip the pixel)
- * Output: mask - array [n] of flags (1=stencil and depth test passed)
- * Return: GL_FALSE - all fragments failed the testing
- *         GL_TRUE - one or more fragments passed the testing
- */
-static GLboolean
-stencil_and_ztest_pixels( GLcontext *ctx, SWspan *span, GLuint face )
-{
-   GLubyte passMask[MAX_WIDTH], failMask[MAX_WIDTH], origMask[MAX_WIDTH];
-   struct gl_framebuffer *fb = ctx->DrawBuffer;
-   struct gl_renderbuffer *rb = fb->_StencilBuffer;
-   const GLuint n = span->end;
-   const GLint *x = span->array->x;
-   const GLint *y = span->array->y;
-   GLubyte *mask = span->array->mask;
-
-   ASSERT(span->arrayMask & SPAN_XY);
-   ASSERT(ctx->Stencil.Enabled);
-   ASSERT(n <= MAX_WIDTH);
-
-   if (!rb->GetPointer(ctx, rb, 0, 0)) {
-      /* No direct access */
-      GLstencil stencil[MAX_WIDTH];
-
-      ASSERT(rb->DataType == GL_UNSIGNED_BYTE);
-      _swrast_get_values(ctx, rb, n, x, y, stencil, sizeof(GLubyte));
-
-      memcpy(origMask, mask, n * sizeof(GLubyte));          
-
-      (void) do_stencil_test(ctx, face, n, stencil, mask);
-
-      if (ctx->Depth.Test == GL_FALSE) {
-         apply_stencil_op(ctx, ctx->Stencil.ZPassFunc[face], face,
-                          n, stencil, mask);
-      }
-      else {
-         GLubyte tmpMask[MAX_WIDTH]; 
-         memcpy(tmpMask, mask, n * sizeof(GLubyte));
-
-         _swrast_depth_test_span(ctx, span);
-
-         compute_pass_fail_masks(n, tmpMask, mask, passMask, failMask);
-
-         if (ctx->Stencil.ZFailFunc[face] != GL_KEEP) {
-            apply_stencil_op(ctx, ctx->Stencil.ZFailFunc[face], face,
-                             n, stencil, failMask);
-         }
-         if (ctx->Stencil.ZPassFunc[face] != GL_KEEP) {
-            apply_stencil_op(ctx, ctx->Stencil.ZPassFunc[face], face,
-                             n, stencil, passMask);
-         }
-      }
-
-      /* Write updated stencil values into hardware stencil buffer */
-      rb->PutValues(ctx, rb, n, x, y, stencil, origMask);
-
-      return GL_TRUE;
-   }
-   else {
-      /* Direct access to stencil buffer */
-
-      if (stencil_test_pixels(ctx, face, n, x, y, mask) == GL_FALSE) {
-         /* all fragments failed the stencil test, we're done. */
-         return GL_FALSE;
-      }
-
-      if (ctx->Depth.Test==GL_FALSE) {
-         apply_stencil_op_to_pixels(ctx, n, x, y,
-                                    ctx->Stencil.ZPassFunc[face], face, mask);
-      }
-      else {
-         memcpy(origMask, mask, n * sizeof(GLubyte));
-
-         _swrast_depth_test_span(ctx, span);
-
-         compute_pass_fail_masks(n, origMask, mask, passMask, failMask);
-
-         if (ctx->Stencil.ZFailFunc[face] != GL_KEEP) {
-            apply_stencil_op_to_pixels(ctx, n, x, y,
-                                       ctx->Stencil.ZFailFunc[face],
-                                       face, failMask);
-         }
-         if (ctx->Stencil.ZPassFunc[face] != GL_KEEP) {
-            apply_stencil_op_to_pixels(ctx, n, x, y,
-                                       ctx->Stencil.ZPassFunc[face],
-                                       face, passMask);
-         }
-      }
-
-      return GL_TRUE;  /* one or more fragments passed both tests */
-   }
-}
-
-
-/**
- * /return GL_TRUE = one or more fragments passed,
- * GL_FALSE = all fragments failed.
- */
-GLboolean
-_swrast_stencil_and_ztest_span(GLcontext *ctx, SWspan *span)
-{
-   const GLuint face = (span->facing == 0) ? 0 : ctx->Stencil._BackFace;
-
-   if (span->arrayMask & SPAN_XY)
-      return stencil_and_ztest_pixels(ctx, span, face);
-   else
-      return stencil_and_ztest_span(ctx, span, face);
-}
-
-
-#if 0
-GLuint
-clip_span(GLuint bufferWidth, GLuint bufferHeight,
-          GLint x, GLint y, GLuint *count)
-{
-   GLuint n = *count;
-   GLuint skipPixels = 0;
-
-   if (y < 0 || y >= bufferHeight || x + n <= 0 || x >= bufferWidth) {
-      /* totally out of bounds */
-      n = 0;
-   }
-   else {
-      /* left clip */
-      if (x < 0) {
-         skipPixels = -x;
-         x = 0;
-         n -= skipPixels;
-      }
-      /* right clip */
-      if (x + n > bufferWidth) {
-         GLint dx = x + n - bufferWidth;
-         n -= dx;
-      }
-   }
-
-   *count = n;
-
-   return skipPixels;
-}
-#endif
-
-
-/**
- * Return a span of stencil values from the stencil buffer.
- * Used for glRead/CopyPixels
- * Input:  n - how many pixels
- *         x,y - location of first pixel
- * Output:  stencil - the array of stencil values
- */
-void
-_swrast_read_stencil_span(GLcontext *ctx, struct gl_renderbuffer *rb,
-                          GLint n, GLint x, GLint y, GLstencil stencil[])
-{
-   if (y < 0 || y >= (GLint) rb->Height ||
-       x + n <= 0 || x >= (GLint) rb->Width) {
-      /* span is completely outside framebuffer */
-      return; /* undefined values OK */
-   }
-
-   if (x < 0) {
-      GLint dx = -x;
-      x = 0;
-      n -= dx;
-      stencil += dx;
-   }
-   if (x + n > (GLint) rb->Width) {
-      GLint dx = x + n - rb->Width;
-      n -= dx;
-   }
-   if (n <= 0) {
-      return;
-   }
-
-   rb->GetRow(ctx, rb, n, x, y, stencil);
-}
-
-
-
-/**
- * Write a span of stencil values to the stencil buffer.  This function
- * applies the stencil write mask when needed.
- * Used for glDraw/CopyPixels
- * Input:  n - how many pixels
- *         x, y - location of first pixel
- *         stencil - the array of stencil values
- */
-void
-_swrast_write_stencil_span(GLcontext *ctx, GLint n, GLint x, GLint y,
-                           const GLstencil stencil[] )
-{
-   struct gl_framebuffer *fb = ctx->DrawBuffer;
-   struct gl_renderbuffer *rb = fb->_StencilBuffer;
-   const GLuint stencilMax = (1 << fb->Visual.stencilBits) - 1;
-   const GLuint stencilMask = ctx->Stencil.WriteMask[0];
-
-   if (y < 0 || y >= (GLint) rb->Height ||
-       x + n <= 0 || x >= (GLint) rb->Width) {
-      /* span is completely outside framebuffer */
-      return; /* undefined values OK */
-   }
-   if (x < 0) {
-      GLint dx = -x;
-      x = 0;
-      n -= dx;
-      stencil += dx;
-   }
-   if (x + n > (GLint) rb->Width) {
-      GLint dx = x + n - rb->Width;
-      n -= dx;
-   }
-   if (n <= 0) {
-      return;
-   }
-
-   if ((stencilMask & stencilMax) != stencilMax) {
-      /* need to apply writemask */
-      GLstencil destVals[MAX_WIDTH], newVals[MAX_WIDTH];
-      GLint i;
-      rb->GetRow(ctx, rb, n, x, y, destVals);
-      for (i = 0; i < n; i++) {
-         newVals[i]
-            = (stencil[i] & stencilMask) | (destVals[i] & ~stencilMask);
-      }
-      rb->PutRow(ctx, rb, n, x, y, newVals, NULL);
-   }
-   else {
-      rb->PutRow(ctx, rb, n, x, y, stencil, NULL);
-   }
-}
-
-
-
-/**
- * Clear the stencil buffer.
- */
-void
-_swrast_clear_stencil_buffer( GLcontext *ctx, struct gl_renderbuffer *rb )
-{
-   const GLubyte stencilBits = ctx->DrawBuffer->Visual.stencilBits;
-   const GLuint mask = ctx->Stencil.WriteMask[0];
-   const GLuint invMask = ~mask;
-   const GLuint clearVal = (ctx->Stencil.Clear & mask);
-   const GLuint stencilMax = (1 << stencilBits) - 1;
-   GLint x, y, width, height;
-
-   if (!rb || mask == 0)
-      return;
-
-   ASSERT(rb->DataType == GL_UNSIGNED_BYTE ||
-          rb->DataType == GL_UNSIGNED_SHORT);
-
-   ASSERT(rb->_BaseFormat == GL_STENCIL_INDEX);
-
-   /* compute region to clear */
-   x = ctx->DrawBuffer->_Xmin;
-   y = ctx->DrawBuffer->_Ymin;
-   width  = ctx->DrawBuffer->_Xmax - ctx->DrawBuffer->_Xmin;
-   height = ctx->DrawBuffer->_Ymax - ctx->DrawBuffer->_Ymin;
-
-   if (rb->GetPointer(ctx, rb, 0, 0)) {
-      /* Direct buffer access */
-      if ((mask & stencilMax) != stencilMax) {
-         /* need to mask the clear */
-         if (rb->DataType == GL_UNSIGNED_BYTE) {
-            GLint i, j;
-            for (i = 0; i < height; i++) {
-               GLubyte *stencil = (GLubyte*) rb->GetPointer(ctx, rb, x, y + i);
-               for (j = 0; j < width; j++) {
-                  stencil[j] = (stencil[j] & invMask) | clearVal;
-               }
-            }
-         }
-         else {
-            GLint i, j;
-            for (i = 0; i < height; i++) {
-               GLushort *stencil = (GLushort*) rb->GetPointer(ctx, rb, x, y + i);
-               for (j = 0; j < width; j++) {
-                  stencil[j] = (stencil[j] & invMask) | clearVal;
-               }
-            }
-         }
-      }
-      else {
-         /* no bit masking */
-         if (width == (GLint) rb->Width && rb->DataType == GL_UNSIGNED_BYTE) {
-            /* optimized case */
-            /* Note: bottom-to-top raster assumed! */
-            GLubyte *stencil = (GLubyte *) rb->GetPointer(ctx, rb, x, y);
-            GLuint len = width * height * sizeof(GLubyte);
-            memset(stencil, clearVal, len);
-         }
-         else {
-            /* general case */
-            GLint i;
-            for (i = 0; i < height; i++) {
-               GLvoid *stencil = rb->GetPointer(ctx, rb, x, y + i);
-               if (rb->DataType == GL_UNSIGNED_BYTE) {
-                  memset(stencil, clearVal, width);
-               }
-               else {
-                  _mesa_memset16((short unsigned int*) stencil, clearVal, width);
-               }
-            }
-         }
-      }
-   }
-   else {
-      /* no direct access */
-      if ((mask & stencilMax) != stencilMax) {
-         /* need to mask the clear */
-         if (rb->DataType == GL_UNSIGNED_BYTE) {
-            GLint i, j;
-            for (i = 0; i < height; i++) {
-               GLubyte stencil[MAX_WIDTH];
-               rb->GetRow(ctx, rb, width, x, y + i, stencil);
-               for (j = 0; j < width; j++) {
-                  stencil[j] = (stencil[j] & invMask) | clearVal;
-               }
-               rb->PutRow(ctx, rb, width, x, y + i, stencil, NULL);
-            }
-         }
-         else {
-            GLint i, j;
-            for (i = 0; i < height; i++) {
-               GLushort stencil[MAX_WIDTH];
-               rb->GetRow(ctx, rb, width, x, y + i, stencil);
-               for (j = 0; j < width; j++) {
-                  stencil[j] = (stencil[j] & invMask) | clearVal;
-               }
-               rb->PutRow(ctx, rb, width, x, y + i, stencil, NULL);
-            }
-         }
-      }
-      else {
-         /* no bit masking */
-         const GLubyte clear8 = (GLubyte) clearVal;
-         const GLushort clear16 = (GLushort) clearVal;
-         const void *clear;
-         GLint i;
-         if (rb->DataType == GL_UNSIGNED_BYTE) {
-            clear = &clear8;
-         }
-         else {
-            clear = &clear16;
-         }
-         for (i = 0; i < height; i++) {
-            rb->PutMonoRow(ctx, rb, width, x, y + i, clear, NULL);
-         }
-      }
-   }
-}
+/*

+ * 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/context.h"

+#include "main/imports.h"

+

+#include "s_context.h"

+#include "s_depth.h"

+#include "s_stencil.h"

+#include "s_span.h"

+

+

+

+/* Stencil Logic:

+

+IF stencil test fails THEN

+   Apply fail-op to stencil value

+   Don't write the pixel (RGBA,Z)

+ELSE

+   IF doing depth test && depth test fails THEN

+      Apply zfail-op to stencil value

+      Write RGBA and Z to appropriate buffers

+   ELSE

+      Apply zpass-op to stencil value

+ENDIF

+

+*/

+

+

+/**

+ * Apply the given stencil operator to the array of stencil values.

+ * Don't touch stencil[i] if mask[i] is zero.

+ * Input:  n - size of stencil array

+ *         oper - the stencil buffer operator

+ *         face - 0 or 1 for front or back face operation

+ *         stencil - array of stencil values

+ *         mask - array [n] of flag:  1=apply operator, 0=don't apply operator

+ * Output:  stencil - modified values

+ */

+static void

+apply_stencil_op( const struct gl_context *ctx, GLenum oper, GLuint face,

+                  GLuint n, GLstencil stencil[], const GLubyte mask[] )

+{

+   const GLstencil ref = ctx->Stencil.Ref[face];

+   const GLstencil wrtmask = ctx->Stencil.WriteMask[face];

+   const GLstencil invmask = (GLstencil) (~wrtmask);

+   const GLstencil stencilMax = (1 << ctx->DrawBuffer->Visual.stencilBits) - 1;

+   GLuint i;

+

+   switch (oper) {

+      case GL_KEEP:

+         /* do nothing */

+         break;

+      case GL_ZERO:

+	 if (invmask==0) {

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

+	       if (mask[i]) {

+		  stencil[i] = 0;

+	       }

+	    }

+	 }

+	 else {

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

+	       if (mask[i]) {

+		  stencil[i] = (GLstencil) (stencil[i] & invmask);

+	       }

+	    }

+	 }

+	 break;

+      case GL_REPLACE:

+	 if (invmask==0) {

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

+	       if (mask[i]) {

+                  stencil[i] = ref;

+	       }

+	    }

+	 }

+	 else {

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

+	       if (mask[i]) {

+		  GLstencil s = stencil[i];

+		  stencil[i] = (GLstencil) ((invmask & s ) | (wrtmask & ref));

+	       }

+	    }

+	 }

+	 break;

+      case GL_INCR:

+	 if (invmask==0) {

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

+	       if (mask[i]) {

+		  GLstencil s = stencil[i];

+		  if (s < stencilMax) {

+		     stencil[i] = (GLstencil) (s+1);

+		  }

+	       }

+	    }

+	 }

+	 else {

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

+	       if (mask[i]) {

+		  /* VERIFY logic of adding 1 to a write-masked value */

+		  GLstencil s = stencil[i];

+		  if (s < stencilMax) {

+		     stencil[i] = (GLstencil) ((invmask & s) | (wrtmask & (s+1)));

+		  }

+	       }

+	    }

+	 }

+	 break;

+      case GL_DECR:

+	 if (invmask==0) {

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

+	       if (mask[i]) {

+		  GLstencil s = stencil[i];

+		  if (s>0) {

+		     stencil[i] = (GLstencil) (s-1);

+		  }

+	       }

+	    }

+	 }

+	 else {

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

+	       if (mask[i]) {

+		  /* VERIFY logic of subtracting 1 to a write-masked value */

+		  GLstencil s = stencil[i];

+		  if (s>0) {

+		     stencil[i] = (GLstencil) ((invmask & s) | (wrtmask & (s-1)));

+		  }

+	       }

+	    }

+	 }

+	 break;

+      case GL_INCR_WRAP_EXT:

+	 if (invmask==0) {

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

+	       if (mask[i]) {

+                  stencil[i]++;

+	       }

+	    }

+	 }

+	 else {

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

+	       if (mask[i]) {

+                  GLstencil s = stencil[i];

+                  stencil[i] = (GLstencil) ((invmask & s) | (wrtmask & (s+1)));

+	       }

+	    }

+	 }

+	 break;

+      case GL_DECR_WRAP_EXT:

+	 if (invmask==0) {

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

+	       if (mask[i]) {

+		  stencil[i]--;

+	       }

+	    }

+	 }

+	 else {

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

+	       if (mask[i]) {

+                  GLstencil s = stencil[i];

+                  stencil[i] = (GLstencil) ((invmask & s) | (wrtmask & (s-1)));

+	       }

+	    }

+	 }

+	 break;

+      case GL_INVERT:

+	 if (invmask==0) {

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

+	       if (mask[i]) {

+		  GLstencil s = stencil[i];

+		  stencil[i] = (GLstencil) ~s;

+	       }

+	    }

+	 }

+	 else {

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

+	       if (mask[i]) {

+		  GLstencil s = stencil[i];

+		  stencil[i] = (GLstencil) ((invmask & s) | (wrtmask & ~s));

+	       }

+	    }

+	 }

+	 break;

+      default:

+         _mesa_problem(ctx, "Bad stencil op in apply_stencil_op");

+   }

+}

+

+

+

+

+/**

+ * Apply stencil test to an array of stencil values (before depth buffering).

+ * Input:  face - 0 or 1 for front or back-face polygons

+ *         n - number of pixels in the array

+ *         stencil - array of [n] stencil values

+ *         mask - array [n] of flag:  0=skip the pixel, 1=stencil the pixel

+ * Output:  mask - pixels which fail the stencil test will have their

+ *                 mask flag set to 0.

+ *          stencil - updated stencil values (where the test passed)

+ * Return:  GL_FALSE = all pixels failed, GL_TRUE = zero or more pixels passed.

+ */

+static GLboolean

+do_stencil_test( struct gl_context *ctx, GLuint face, GLuint n, GLstencil stencil[],

+                 GLubyte mask[] )

+{

+   GLubyte fail[MAX_WIDTH];

+   GLboolean allfail = GL_FALSE;

+   GLuint i;

+   const GLuint valueMask = ctx->Stencil.ValueMask[face];

+   const GLstencil r = (GLstencil) (ctx->Stencil.Ref[face] & valueMask);

+   GLstencil s;

+

+   ASSERT(n <= MAX_WIDTH);

+

+   /*

+    * Perform stencil test.  The results of this operation are stored

+    * in the fail[] array:

+    *   IF fail[i] is non-zero THEN

+    *       the stencil fail operator is to be applied

+    *   ELSE

+    *       the stencil fail operator is not to be applied

+    *   ENDIF

+    */

+   switch (ctx->Stencil.Function[face]) {

+      case GL_NEVER:

+         /* never pass; always fail */

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

+	    if (mask[i]) {

+	       mask[i] = 0;

+	       fail[i] = 1;

+	    }

+	    else {

+	       fail[i] = 0;

+	    }

+	 }

+	 allfail = GL_TRUE;

+	 break;

+      case GL_LESS:

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

+	    if (mask[i]) {

+	       s = (GLstencil) (stencil[i] & valueMask);

+	       if (r < s) {

+		  /* passed */

+		  fail[i] = 0;

+	       }

+	       else {

+		  fail[i] = 1;

+		  mask[i] = 0;

+	       }

+	    }

+	    else {

+	       fail[i] = 0;

+	    }

+	 }

+	 break;

+      case GL_LEQUAL:

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

+	    if (mask[i]) {

+	       s = (GLstencil) (stencil[i] & valueMask);

+	       if (r <= s) {

+		  /* pass */

+		  fail[i] = 0;

+	       }

+	       else {

+		  fail[i] = 1;

+		  mask[i] = 0;

+	       }

+	    }

+	    else {

+	       fail[i] = 0;

+	    }

+	 }

+	 break;

+      case GL_GREATER:

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

+	    if (mask[i]) {

+	       s = (GLstencil) (stencil[i] & valueMask);

+	       if (r > s) {

+		  /* passed */

+		  fail[i] = 0;

+	       }

+	       else {

+		  fail[i] = 1;

+		  mask[i] = 0;

+	       }

+	    }

+	    else {

+	       fail[i] = 0;

+	    }

+	 }

+	 break;

+      case GL_GEQUAL:

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

+	    if (mask[i]) {

+	       s = (GLstencil) (stencil[i] & valueMask);

+	       if (r >= s) {

+		  /* passed */

+		  fail[i] = 0;

+	       }

+	       else {

+		  fail[i] = 1;

+		  mask[i] = 0;

+	       }

+	    }

+	    else {

+	       fail[i] = 0;

+	    }

+	 }

+	 break;

+      case GL_EQUAL:

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

+	    if (mask[i]) {

+	       s = (GLstencil) (stencil[i] & valueMask);

+	       if (r == s) {

+		  /* passed */

+		  fail[i] = 0;

+	       }

+	       else {

+		  fail[i] = 1;

+		  mask[i] = 0;

+	       }

+	    }

+	    else {

+	       fail[i] = 0;

+	    }

+	 }

+	 break;

+      case GL_NOTEQUAL:

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

+	    if (mask[i]) {

+	       s = (GLstencil) (stencil[i] & valueMask);

+	       if (r != s) {

+		  /* passed */

+		  fail[i] = 0;

+	       }

+	       else {

+		  fail[i] = 1;

+		  mask[i] = 0;

+	       }

+	    }

+	    else {

+	       fail[i] = 0;

+	    }

+	 }

+	 break;

+      case GL_ALWAYS:

+	 /* always pass */

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

+	    fail[i] = 0;

+	 }

+	 break;

+      default:

+         _mesa_problem(ctx, "Bad stencil func in gl_stencil_span");

+         return 0;

+   }

+

+   if (ctx->Stencil.FailFunc[face] != GL_KEEP) {

+      apply_stencil_op( ctx, ctx->Stencil.FailFunc[face], face, n, stencil, fail );

+   }

+

+   return !allfail;

+}

+

+

+/**

+ * Compute the zpass/zfail masks by comparing the pre- and post-depth test

+ * masks.

+ */

+static INLINE void

+compute_pass_fail_masks(GLuint n, const GLubyte origMask[],

+                        const GLubyte newMask[],

+                        GLubyte passMask[], GLubyte failMask[])

+{

+   GLuint i;

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

+      ASSERT(newMask[i] == 0 || newMask[i] == 1);

+      passMask[i] = origMask[i] & newMask[i];

+      failMask[i] = origMask[i] & (newMask[i] ^ 1);

+   }

+}

+

+

+/**

+ * Apply stencil and depth testing to the span of pixels.

+ * Both software and hardware stencil buffers are acceptable.

+ * Input:  n - number of pixels in the span

+ *         x, y - location of leftmost pixel in span

+ *         z - array [n] of z values

+ *         mask - array [n] of flags  (1=test this pixel, 0=skip the pixel)

+ * Output:  mask - array [n] of flags (1=stencil and depth test passed)

+ * Return: GL_FALSE - all fragments failed the testing

+ *         GL_TRUE - one or more fragments passed the testing

+ *

+ */

+static GLboolean

+stencil_and_ztest_span(struct gl_context *ctx, SWspan *span, GLuint face)

+{

+   struct gl_framebuffer *fb = ctx->DrawBuffer;

+   struct gl_renderbuffer *rb = fb->_StencilBuffer;

+   GLstencil stencilRow[MAX_WIDTH];

+   GLstencil *stencil;

+   const GLuint n = span->end;

+   const GLint x = span->x;

+   const GLint y = span->y;

+   GLubyte *mask = span->array->mask;

+

+   ASSERT((span->arrayMask & SPAN_XY) == 0);

+   ASSERT(ctx->Stencil.Enabled);

+   ASSERT(n <= MAX_WIDTH);

+#ifdef DEBUG

+   if (ctx->Depth.Test) {

+      ASSERT(span->arrayMask & SPAN_Z);

+   }

+#endif

+

+   stencil = (GLstencil *) rb->GetPointer(ctx, rb, x, y);

+   if (!stencil) {

+      rb->GetRow(ctx, rb, n, x, y, stencilRow);

+      stencil = stencilRow;

+   }

+

+   /*

+    * Apply the stencil test to the fragments.

+    * failMask[i] is 1 if the stencil test failed.

+    */

+   if (do_stencil_test( ctx, face, n, stencil, mask ) == GL_FALSE) {

+      /* all fragments failed the stencil test, we're done. */

+      span->writeAll = GL_FALSE;

+      if (!rb->GetPointer(ctx, rb, 0, 0)) {

+         /* put updated stencil values into buffer */

+         rb->PutRow(ctx, rb, n, x, y, stencil, NULL);

+      }

+      return GL_FALSE;

+   }

+

+   /*

+    * Some fragments passed the stencil test, apply depth test to them

+    * and apply Zpass and Zfail stencil ops.

+    */

+   if (ctx->Depth.Test == GL_FALSE) {

+      /*

+       * No depth buffer, just apply zpass stencil function to active pixels.

+       */

+      apply_stencil_op( ctx, ctx->Stencil.ZPassFunc[face], face, n, stencil, mask );

+   }

+   else {

+      /*

+       * Perform depth buffering, then apply zpass or zfail stencil function.

+       */

+      GLubyte passMask[MAX_WIDTH], failMask[MAX_WIDTH], origMask[MAX_WIDTH];

+

+      /* save the current mask bits */

+      memcpy(origMask, mask, n * sizeof(GLubyte));

+

+      /* apply the depth test */

+      _swrast_depth_test_span(ctx, span);

+

+      compute_pass_fail_masks(n, origMask, mask, passMask, failMask);

+

+      /* apply the pass and fail operations */

+      if (ctx->Stencil.ZFailFunc[face] != GL_KEEP) {

+         apply_stencil_op( ctx, ctx->Stencil.ZFailFunc[face], face,

+                           n, stencil, failMask );

+      }

+      if (ctx->Stencil.ZPassFunc[face] != GL_KEEP) {

+         apply_stencil_op( ctx, ctx->Stencil.ZPassFunc[face], face,

+                           n, stencil, passMask );

+      }

+   }

+

+   /*

+    * Write updated stencil values back into hardware stencil buffer.

+    */

+   if (!rb->GetPointer(ctx, rb, 0, 0)) {

+      rb->PutRow(ctx, rb, n, x, y, stencil, NULL);

+   }

+   

+   span->writeAll = GL_FALSE;

+   

+   return GL_TRUE;  /* one or more fragments passed both tests */

+}

+

+

+

+/*

+ * Return the address of a stencil buffer value given the window coords:

+ */

+#define STENCIL_ADDRESS(X, Y)  (stencilStart + (Y) * stride + (X))

+

+

+

+/**

+ * Apply the given stencil operator for each pixel in the array whose

+ * mask flag is set.

+ * \note  This is for software stencil buffers only.

+ * Input:  n - number of pixels in the span

+ *         x, y - array of [n] pixels

+ *         operator - the stencil buffer operator

+ *         mask - array [n] of flag:  1=apply operator, 0=don't apply operator

+ */

+static void

+apply_stencil_op_to_pixels( struct gl_context *ctx,

+                            GLuint n, const GLint x[], const GLint y[],

+                            GLenum oper, GLuint face, const GLubyte mask[] )

+{

+   struct gl_framebuffer *fb = ctx->DrawBuffer;

+   struct gl_renderbuffer *rb = fb->_StencilBuffer;

+   const GLstencil stencilMax = (1 << fb->Visual.stencilBits) - 1;

+   const GLstencil ref = ctx->Stencil.Ref[face];

+   const GLstencil wrtmask = ctx->Stencil.WriteMask[face];

+   const GLstencil invmask = (GLstencil) (~wrtmask);

+   GLuint i;

+   GLstencil *stencilStart = (GLubyte *) rb->Data;

+   const GLuint stride = rb->Width;

+

+   ASSERT(rb->GetPointer(ctx, rb, 0, 0));

+   ASSERT(sizeof(GLstencil) == 1);

+

+   switch (oper) {

+      case GL_KEEP:

+         /* do nothing */

+         break;

+      case GL_ZERO:

+	 if (invmask==0) {

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

+	       if (mask[i]) {

+                  GLstencil *sptr = STENCIL_ADDRESS( x[i], y[i] );

+                  *sptr = 0;

+	       }

+	    }

+	 }

+	 else {

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

+	       if (mask[i]) {

+                  GLstencil *sptr = STENCIL_ADDRESS( x[i], y[i] );

+		  *sptr = (GLstencil) (invmask & *sptr);

+	       }

+	    }

+	 }

+	 break;

+      case GL_REPLACE:

+	 if (invmask==0) {

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

+	       if (mask[i]) {

+                  GLstencil *sptr = STENCIL_ADDRESS( x[i], y[i] );

+                  *sptr = ref;

+	       }

+	    }

+	 }

+	 else {

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

+	       if (mask[i]) {

+                  GLstencil *sptr = STENCIL_ADDRESS( x[i], y[i] );

+		  *sptr = (GLstencil) ((invmask & *sptr ) | (wrtmask & ref));

+	       }

+	    }

+	 }

+	 break;

+      case GL_INCR:

+	 if (invmask==0) {

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

+	       if (mask[i]) {

+                  GLstencil *sptr = STENCIL_ADDRESS( x[i], y[i] );

+		  if (*sptr < stencilMax) {

+		     *sptr = (GLstencil) (*sptr + 1);

+		  }

+	       }

+	    }

+	 }

+	 else {

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

+	       if (mask[i]) {

+                  GLstencil *sptr = STENCIL_ADDRESS( x[i], y[i] );

+		  if (*sptr < stencilMax) {

+		     *sptr = (GLstencil) ((invmask & *sptr) | (wrtmask & (*sptr+1)));

+		  }

+	       }

+	    }

+	 }

+	 break;

+      case GL_DECR:

+	 if (invmask==0) {

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

+	       if (mask[i]) {

+                  GLstencil *sptr = STENCIL_ADDRESS( x[i], y[i] );

+		  if (*sptr>0) {

+		     *sptr = (GLstencil) (*sptr - 1);

+		  }

+	       }

+	    }

+	 }

+	 else {

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

+	       if (mask[i]) {

+                  GLstencil *sptr = STENCIL_ADDRESS( x[i], y[i] );

+		  if (*sptr>0) {

+		     *sptr = (GLstencil) ((invmask & *sptr) | (wrtmask & (*sptr-1)));

+		  }

+	       }

+	    }

+	 }

+	 break;

+      case GL_INCR_WRAP_EXT:

+	 if (invmask==0) {

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

+	       if (mask[i]) {

+                  GLstencil *sptr = STENCIL_ADDRESS( x[i], y[i] );

+                  *sptr = (GLstencil) (*sptr + 1);

+	       }

+	    }

+	 }

+	 else {

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

+	       if (mask[i]) {

+                  GLstencil *sptr = STENCIL_ADDRESS( x[i], y[i] );

+                  *sptr = (GLstencil) ((invmask & *sptr) | (wrtmask & (*sptr+1)));

+	       }

+	    }

+	 }

+	 break;

+      case GL_DECR_WRAP_EXT:

+	 if (invmask==0) {

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

+	       if (mask[i]) {

+                  GLstencil *sptr = STENCIL_ADDRESS( x[i], y[i] );

+                  *sptr = (GLstencil) (*sptr - 1);

+	       }

+	    }

+	 }

+	 else {

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

+	       if (mask[i]) {

+                  GLstencil *sptr = STENCIL_ADDRESS( x[i], y[i] );

+                  *sptr = (GLstencil) ((invmask & *sptr) | (wrtmask & (*sptr-1)));

+	       }

+	    }

+	 }

+	 break;

+      case GL_INVERT:

+	 if (invmask==0) {

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

+	       if (mask[i]) {

+                  GLstencil *sptr = STENCIL_ADDRESS( x[i], y[i] );

+                  *sptr = (GLstencil) (~*sptr);

+	       }

+	    }

+	 }

+	 else {

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

+	       if (mask[i]) {

+                  GLstencil *sptr = STENCIL_ADDRESS( x[i], y[i] );

+                  *sptr = (GLstencil) ((invmask & *sptr) | (wrtmask & ~*sptr));

+	       }

+	    }

+	 }

+	 break;

+      default:

+         _mesa_problem(ctx, "Bad stencilop in apply_stencil_op_to_pixels");

+   }

+}

+

+

+

+/**

+ * Apply stencil test to an array of pixels before depth buffering.

+ *

+ * \note Used for software stencil buffer only.

+ * Input:  n - number of pixels in the span

+ *         x, y - array of [n] pixels to stencil

+ *         mask - array [n] of flag:  0=skip the pixel, 1=stencil the pixel

+ * Output:  mask - pixels which fail the stencil test will have their

+ *                 mask flag set to 0.

+ * \return  GL_FALSE = all pixels failed, GL_TRUE = zero or more pixels passed.

+ */

+static GLboolean

+stencil_test_pixels( struct gl_context *ctx, GLuint face, GLuint n,

+                     const GLint x[], const GLint y[], GLubyte mask[] )

+{

+   const struct gl_framebuffer *fb = ctx->DrawBuffer;

+   struct gl_renderbuffer *rb = fb->_StencilBuffer;

+   GLubyte fail[MAX_WIDTH];

+   GLstencil r, s;

+   GLuint i;

+   GLboolean allfail = GL_FALSE;

+   const GLuint valueMask = ctx->Stencil.ValueMask[face];

+   const GLstencil *stencilStart = (GLstencil *) rb->Data;

+   const GLuint stride = rb->Width;

+

+   ASSERT(rb->GetPointer(ctx, rb, 0, 0));

+   ASSERT(sizeof(GLstencil) == 1);

+

+   /*

+    * Perform stencil test.  The results of this operation are stored

+    * in the fail[] array:

+    *   IF fail[i] is non-zero THEN

+    *       the stencil fail operator is to be applied

+    *   ELSE

+    *       the stencil fail operator is not to be applied

+    *   ENDIF

+    */

+

+   switch (ctx->Stencil.Function[face]) {

+      case GL_NEVER:

+         /* always fail */

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

+	    if (mask[i]) {

+	       mask[i] = 0;

+	       fail[i] = 1;

+	    }

+	    else {

+	       fail[i] = 0;

+	    }

+	 }

+	 allfail = GL_TRUE;

+	 break;

+      case GL_LESS:

+	 r = (GLstencil) (ctx->Stencil.Ref[face] & valueMask);

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

+	    if (mask[i]) {

+               const GLstencil *sptr = STENCIL_ADDRESS(x[i],y[i]);

+	       s = (GLstencil) (*sptr & valueMask);

+	       if (r < s) {

+		  /* passed */

+		  fail[i] = 0;

+	       }

+	       else {

+		  fail[i] = 1;

+		  mask[i] = 0;

+	       }

+	    }

+	    else {

+	       fail[i] = 0;

+	    }

+	 }

+	 break;

+      case GL_LEQUAL:

+	 r = (GLstencil) (ctx->Stencil.Ref[face] & valueMask);

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

+	    if (mask[i]) {

+               const GLstencil *sptr = STENCIL_ADDRESS(x[i],y[i]);

+	       s = (GLstencil) (*sptr & valueMask);

+	       if (r <= s) {

+		  /* pass */

+		  fail[i] = 0;

+	       }

+	       else {

+		  fail[i] = 1;

+		  mask[i] = 0;

+	       }

+	    }

+	    else {

+	       fail[i] = 0;

+	    }

+	 }

+	 break;

+      case GL_GREATER:

+	 r = (GLstencil) (ctx->Stencil.Ref[face] & valueMask);

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

+	    if (mask[i]) {

+               const GLstencil *sptr = STENCIL_ADDRESS(x[i],y[i]);

+	       s = (GLstencil) (*sptr & valueMask);

+	       if (r > s) {

+		  /* passed */

+		  fail[i] = 0;

+	       }

+	       else {

+		  fail[i] = 1;

+		  mask[i] = 0;

+	       }

+	    }

+	    else {

+	       fail[i] = 0;

+	    }

+	 }

+	 break;

+      case GL_GEQUAL:

+	 r = (GLstencil) (ctx->Stencil.Ref[face] & valueMask);

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

+	    if (mask[i]) {

+               const GLstencil *sptr = STENCIL_ADDRESS(x[i],y[i]);

+	       s = (GLstencil) (*sptr & valueMask);

+	       if (r >= s) {

+		  /* passed */

+		  fail[i] = 0;

+	       }

+	       else {

+		  fail[i] = 1;

+		  mask[i] = 0;

+	       }

+	    }

+	    else {

+	       fail[i] = 0;

+	    }

+	 }

+	 break;

+      case GL_EQUAL:

+	 r = (GLstencil) (ctx->Stencil.Ref[face] & valueMask);

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

+	    if (mask[i]) {

+               const GLstencil *sptr = STENCIL_ADDRESS(x[i],y[i]);

+	       s = (GLstencil) (*sptr & valueMask);

+	       if (r == s) {

+		  /* passed */

+		  fail[i] = 0;

+	       }

+	       else {

+		  fail[i] = 1;

+		  mask[i] = 0;

+	       }

+	    }

+	    else {

+	       fail[i] = 0;

+	    }

+	 }

+	 break;

+      case GL_NOTEQUAL:

+	 r = (GLstencil) (ctx->Stencil.Ref[face] & valueMask);

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

+	    if (mask[i]) {

+               const GLstencil *sptr = STENCIL_ADDRESS(x[i],y[i]);

+	       s = (GLstencil) (*sptr & valueMask);

+	       if (r != s) {

+		  /* passed */

+		  fail[i] = 0;

+	       }

+	       else {

+		  fail[i] = 1;

+		  mask[i] = 0;

+	       }

+	    }

+	    else {

+	       fail[i] = 0;

+	    }

+	 }

+	 break;

+      case GL_ALWAYS:

+	 /* always pass */

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

+	    fail[i] = 0;

+	 }

+	 break;

+      default:

+         _mesa_problem(ctx, "Bad stencil func in gl_stencil_pixels");

+         return 0;

+   }

+

+   if (ctx->Stencil.FailFunc[face] != GL_KEEP) {

+      apply_stencil_op_to_pixels( ctx, n, x, y, ctx->Stencil.FailFunc[face],

+                                  face, fail );

+   }

+

+   return !allfail;

+}

+

+

+

+

+/**

+ * Apply stencil and depth testing to an array of pixels.

+ * This is used both for software and hardware stencil buffers.

+ *

+ * The comments in this function are a bit sparse but the code is

+ * almost identical to stencil_and_ztest_span(), which is well

+ * commented.

+ *

+ * Input:  n - number of pixels in the array

+ *         x, y - array of [n] pixel positions

+ *         z - array [n] of z values

+ *         mask - array [n] of flags  (1=test this pixel, 0=skip the pixel)

+ * Output: mask - array [n] of flags (1=stencil and depth test passed)

+ * Return: GL_FALSE - all fragments failed the testing

+ *         GL_TRUE - one or more fragments passed the testing

+ */

+static GLboolean

+stencil_and_ztest_pixels( struct gl_context *ctx, SWspan *span, GLuint face )

+{

+   GLubyte passMask[MAX_WIDTH], failMask[MAX_WIDTH], origMask[MAX_WIDTH];

+   struct gl_framebuffer *fb = ctx->DrawBuffer;

+   struct gl_renderbuffer *rb = fb->_StencilBuffer;

+   const GLuint n = span->end;

+   const GLint *x = span->array->x;

+   const GLint *y = span->array->y;

+   GLubyte *mask = span->array->mask;

+

+   ASSERT(span->arrayMask & SPAN_XY);

+   ASSERT(ctx->Stencil.Enabled);

+   ASSERT(n <= MAX_WIDTH);

+

+   if (!rb->GetPointer(ctx, rb, 0, 0)) {

+      /* No direct access */

+      GLstencil stencil[MAX_WIDTH];

+

+      ASSERT(rb->DataType == GL_UNSIGNED_BYTE);

+      _swrast_get_values(ctx, rb, n, x, y, stencil, sizeof(GLubyte));

+

+      memcpy(origMask, mask, n * sizeof(GLubyte));          

+

+      (void) do_stencil_test(ctx, face, n, stencil, mask);

+

+      if (ctx->Depth.Test == GL_FALSE) {

+         apply_stencil_op(ctx, ctx->Stencil.ZPassFunc[face], face,

+                          n, stencil, mask);

+      }

+      else {

+         GLubyte tmpMask[MAX_WIDTH]; 

+         memcpy(tmpMask, mask, n * sizeof(GLubyte));

+

+         _swrast_depth_test_span(ctx, span);

+

+         compute_pass_fail_masks(n, tmpMask, mask, passMask, failMask);

+

+         if (ctx->Stencil.ZFailFunc[face] != GL_KEEP) {

+            apply_stencil_op(ctx, ctx->Stencil.ZFailFunc[face], face,

+                             n, stencil, failMask);

+         }

+         if (ctx->Stencil.ZPassFunc[face] != GL_KEEP) {

+            apply_stencil_op(ctx, ctx->Stencil.ZPassFunc[face], face,

+                             n, stencil, passMask);

+         }

+      }

+

+      /* Write updated stencil values into hardware stencil buffer */

+      rb->PutValues(ctx, rb, n, x, y, stencil, origMask);

+

+      return GL_TRUE;

+   }

+   else {

+      /* Direct access to stencil buffer */

+

+      if (stencil_test_pixels(ctx, face, n, x, y, mask) == GL_FALSE) {

+         /* all fragments failed the stencil test, we're done. */

+         return GL_FALSE;

+      }

+

+      if (ctx->Depth.Test==GL_FALSE) {

+         apply_stencil_op_to_pixels(ctx, n, x, y,

+                                    ctx->Stencil.ZPassFunc[face], face, mask);

+      }

+      else {

+         memcpy(origMask, mask, n * sizeof(GLubyte));

+

+         _swrast_depth_test_span(ctx, span);

+

+         compute_pass_fail_masks(n, origMask, mask, passMask, failMask);

+

+         if (ctx->Stencil.ZFailFunc[face] != GL_KEEP) {

+            apply_stencil_op_to_pixels(ctx, n, x, y,

+                                       ctx->Stencil.ZFailFunc[face],

+                                       face, failMask);

+         }

+         if (ctx->Stencil.ZPassFunc[face] != GL_KEEP) {

+            apply_stencil_op_to_pixels(ctx, n, x, y,

+                                       ctx->Stencil.ZPassFunc[face],

+                                       face, passMask);

+         }

+      }

+

+      return GL_TRUE;  /* one or more fragments passed both tests */

+   }

+}

+

+

+/**

+ * /return GL_TRUE = one or more fragments passed,

+ * GL_FALSE = all fragments failed.

+ */

+GLboolean

+_swrast_stencil_and_ztest_span(struct gl_context *ctx, SWspan *span)

+{

+   const GLuint face = (span->facing == 0) ? 0 : ctx->Stencil._BackFace;

+

+   if (span->arrayMask & SPAN_XY)

+      return stencil_and_ztest_pixels(ctx, span, face);

+   else

+      return stencil_and_ztest_span(ctx, span, face);

+}

+

+

+#if 0

+GLuint

+clip_span(GLuint bufferWidth, GLuint bufferHeight,

+          GLint x, GLint y, GLuint *count)

+{

+   GLuint n = *count;

+   GLuint skipPixels = 0;

+

+   if (y < 0 || y >= bufferHeight || x + n <= 0 || x >= bufferWidth) {

+      /* totally out of bounds */

+      n = 0;

+   }

+   else {

+      /* left clip */

+      if (x < 0) {

+         skipPixels = -x;

+         x = 0;

+         n -= skipPixels;

+      }

+      /* right clip */

+      if (x + n > bufferWidth) {

+         GLint dx = x + n - bufferWidth;

+         n -= dx;

+      }

+   }

+

+   *count = n;

+

+   return skipPixels;

+}

+#endif

+

+

+/**

+ * Return a span of stencil values from the stencil buffer.

+ * Used for glRead/CopyPixels

+ * Input:  n - how many pixels

+ *         x,y - location of first pixel

+ * Output:  stencil - the array of stencil values

+ */

+void

+_swrast_read_stencil_span(struct gl_context *ctx, struct gl_renderbuffer *rb,

+                          GLint n, GLint x, GLint y, GLstencil stencil[])

+{

+   if (y < 0 || y >= (GLint) rb->Height ||

+       x + n <= 0 || x >= (GLint) rb->Width) {

+      /* span is completely outside framebuffer */

+      return; /* undefined values OK */

+   }

+

+   if (x < 0) {

+      GLint dx = -x;

+      x = 0;

+      n -= dx;

+      stencil += dx;

+   }

+   if (x + n > (GLint) rb->Width) {

+      GLint dx = x + n - rb->Width;

+      n -= dx;

+   }

+   if (n <= 0) {

+      return;

+   }

+

+   rb->GetRow(ctx, rb, n, x, y, stencil);

+}

+

+

+

+/**

+ * Write a span of stencil values to the stencil buffer.  This function

+ * applies the stencil write mask when needed.

+ * Used for glDraw/CopyPixels

+ * Input:  n - how many pixels

+ *         x, y - location of first pixel

+ *         stencil - the array of stencil values

+ */

+void

+_swrast_write_stencil_span(struct gl_context *ctx, GLint n, GLint x, GLint y,

+                           const GLstencil stencil[] )

+{

+   struct gl_framebuffer *fb = ctx->DrawBuffer;

+   struct gl_renderbuffer *rb = fb->_StencilBuffer;

+   const GLuint stencilMax = (1 << fb->Visual.stencilBits) - 1;

+   const GLuint stencilMask = ctx->Stencil.WriteMask[0];

+

+   if (y < 0 || y >= (GLint) rb->Height ||

+       x + n <= 0 || x >= (GLint) rb->Width) {

+      /* span is completely outside framebuffer */

+      return; /* undefined values OK */

+   }

+   if (x < 0) {

+      GLint dx = -x;

+      x = 0;

+      n -= dx;

+      stencil += dx;

+   }

+   if (x + n > (GLint) rb->Width) {

+      GLint dx = x + n - rb->Width;

+      n -= dx;

+   }

+   if (n <= 0) {

+      return;

+   }

+

+   if ((stencilMask & stencilMax) != stencilMax) {

+      /* need to apply writemask */

+      GLstencil destVals[MAX_WIDTH], newVals[MAX_WIDTH];

+      GLint i;

+      rb->GetRow(ctx, rb, n, x, y, destVals);

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

+         newVals[i]

+            = (stencil[i] & stencilMask) | (destVals[i] & ~stencilMask);

+      }

+      rb->PutRow(ctx, rb, n, x, y, newVals, NULL);

+   }

+   else {

+      rb->PutRow(ctx, rb, n, x, y, stencil, NULL);

+   }

+}

+

+

+

+/**

+ * Clear the stencil buffer.

+ */

+void

+_swrast_clear_stencil_buffer( struct gl_context *ctx, struct gl_renderbuffer *rb )

+{

+   const GLubyte stencilBits = ctx->DrawBuffer->Visual.stencilBits;

+   const GLuint mask = ctx->Stencil.WriteMask[0];

+   const GLuint invMask = ~mask;

+   const GLuint clearVal = (ctx->Stencil.Clear & mask);

+   const GLuint stencilMax = (1 << stencilBits) - 1;

+   GLint x, y, width, height;

+

+   if (!rb || mask == 0)

+      return;

+

+   ASSERT(rb->DataType == GL_UNSIGNED_BYTE ||

+          rb->DataType == GL_UNSIGNED_SHORT);

+

+   ASSERT(rb->_BaseFormat == GL_STENCIL_INDEX);

+

+   /* compute region to clear */

+   x = ctx->DrawBuffer->_Xmin;

+   y = ctx->DrawBuffer->_Ymin;

+   width  = ctx->DrawBuffer->_Xmax - ctx->DrawBuffer->_Xmin;

+   height = ctx->DrawBuffer->_Ymax - ctx->DrawBuffer->_Ymin;

+

+   if (rb->GetPointer(ctx, rb, 0, 0)) {

+      /* Direct buffer access */

+      if ((mask & stencilMax) != stencilMax) {

+         /* need to mask the clear */

+         if (rb->DataType == GL_UNSIGNED_BYTE) {

+            GLint i, j;

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

+               GLubyte *stencil = (GLubyte*) rb->GetPointer(ctx, rb, x, y + i);

+               for (j = 0; j < width; j++) {

+                  stencil[j] = (stencil[j] & invMask) | clearVal;

+               }

+            }

+         }

+         else {

+            GLint i, j;

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

+               GLushort *stencil = (GLushort*) rb->GetPointer(ctx, rb, x, y + i);

+               for (j = 0; j < width; j++) {

+                  stencil[j] = (stencil[j] & invMask) | clearVal;

+               }

+            }

+         }

+      }

+      else {

+         /* no bit masking */

+         if (width == (GLint) rb->Width && rb->DataType == GL_UNSIGNED_BYTE) {

+            /* optimized case */

+            /* Note: bottom-to-top raster assumed! */

+            GLubyte *stencil = (GLubyte *) rb->GetPointer(ctx, rb, x, y);

+            GLuint len = width * height * sizeof(GLubyte);

+            memset(stencil, clearVal, len);

+         }

+         else {

+            /* general case */

+            GLint i;

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

+               GLvoid *stencil = rb->GetPointer(ctx, rb, x, y + i);

+               if (rb->DataType == GL_UNSIGNED_BYTE) {

+                  memset(stencil, clearVal, width);

+               }

+               else {

+                  _mesa_memset16((short unsigned int*) stencil, clearVal, width);

+               }

+            }

+         }

+      }

+   }

+   else {

+      /* no direct access */

+      if ((mask & stencilMax) != stencilMax) {

+         /* need to mask the clear */

+         if (rb->DataType == GL_UNSIGNED_BYTE) {

+            GLint i, j;

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

+               GLubyte stencil[MAX_WIDTH];

+               rb->GetRow(ctx, rb, width, x, y + i, stencil);

+               for (j = 0; j < width; j++) {

+                  stencil[j] = (stencil[j] & invMask) | clearVal;

+               }

+               rb->PutRow(ctx, rb, width, x, y + i, stencil, NULL);

+            }

+         }

+         else {

+            GLint i, j;

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

+               GLushort stencil[MAX_WIDTH];

+               rb->GetRow(ctx, rb, width, x, y + i, stencil);

+               for (j = 0; j < width; j++) {

+                  stencil[j] = (stencil[j] & invMask) | clearVal;

+               }

+               rb->PutRow(ctx, rb, width, x, y + i, stencil, NULL);

+            }

+         }

+      }

+      else {

+         /* no bit masking */

+         const GLubyte clear8 = (GLubyte) clearVal;

+         const GLushort clear16 = (GLushort) clearVal;

+         const void *clear;

+         GLint i;

+         if (rb->DataType == GL_UNSIGNED_BYTE) {

+            clear = &clear8;

+         }

+         else {

+            clear = &clear16;

+         }

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

+            rb->PutMonoRow(ctx, rb, width, x, y + i, clear, NULL);

+         }

+      }

+   }

+}

diff --git a/mesalib/src/mesa/swrast/s_stencil.h b/mesalib/src/mesa/swrast/s_stencil.h
index c076ebbe2..0bcfb799f 100644
--- a/mesalib/src/mesa/swrast/s_stencil.h
+++ b/mesalib/src/mesa/swrast/s_stencil.h
@@ -1,53 +1,53 @@
-/*
- * Mesa 3-D graphics library
- * Version:  6.3
- *
- * Copyright (C) 1999-2005  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.
- */
-
-
-#ifndef S_STENCIL_H
-#define S_STENCIL_H
-
-
-#include "main/mtypes.h"
-#include "s_span.h"
-
-
-
-extern GLboolean
-_swrast_stencil_and_ztest_span(GLcontext *ctx, SWspan *span);
-
-
-extern void
-_swrast_read_stencil_span(GLcontext *ctx, struct gl_renderbuffer *rb,
-                          GLint n, GLint x, GLint y, GLstencil stencil[]);
-
-
-extern void
-_swrast_write_stencil_span( GLcontext *ctx, GLint n, GLint x, GLint y,
-                          const GLstencil stencil[] );
-
-
-extern void
-_swrast_clear_stencil_buffer( GLcontext *ctx, struct gl_renderbuffer *rb );
-
-
-#endif
+/*

+ * Mesa 3-D graphics library

+ * Version:  6.3

+ *

+ * Copyright (C) 1999-2005  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.

+ */

+

+

+#ifndef S_STENCIL_H

+#define S_STENCIL_H

+

+

+#include "main/mtypes.h"

+#include "s_span.h"

+

+

+

+extern GLboolean

+_swrast_stencil_and_ztest_span(struct gl_context *ctx, SWspan *span);

+

+

+extern void

+_swrast_read_stencil_span(struct gl_context *ctx, struct gl_renderbuffer *rb,

+                          GLint n, GLint x, GLint y, GLstencil stencil[]);

+

+

+extern void

+_swrast_write_stencil_span( struct gl_context *ctx, GLint n, GLint x, GLint y,

+                          const GLstencil stencil[] );

+

+

+extern void

+_swrast_clear_stencil_buffer( struct gl_context *ctx, struct gl_renderbuffer *rb );

+

+

+#endif

diff --git a/mesalib/src/mesa/swrast/s_texcombine.c b/mesalib/src/mesa/swrast/s_texcombine.c
index 2ac0aaa24..672cd77bf 100644
--- a/mesalib/src/mesa/swrast/s_texcombine.c
+++ b/mesalib/src/mesa/swrast/s_texcombine.c
@@ -1,709 +1,742 @@
-/*
- * Mesa 3-D graphics library
- * Version:  7.5
- *
- * Copyright (C) 1999-2008  Brian Paul   All Rights Reserved.
- * Copyright (C) 2009  VMware, Inc.   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/context.h"
-#include "main/colormac.h"
-#include "main/image.h"
-#include "main/imports.h"
-#include "program/prog_instruction.h"
-
-#include "s_context.h"
-#include "s_texcombine.h"
-
-
-/**
- * Pointer to array of float[4]
- * This type makes the code below more concise and avoids a lot of casting.
- */
-typedef float (*float4_array)[4];
-
-
-/**
- * Return array of texels for given unit.
- */
-static INLINE float4_array
-get_texel_array(SWcontext *swrast, GLuint unit)
-{
-   return (float4_array) (swrast->TexelBuffer + unit * MAX_WIDTH * 4);
-}
-
-
-
-/**
- * Do texture application for:
- *  GL_EXT_texture_env_combine
- *  GL_ARB_texture_env_combine
- *  GL_EXT_texture_env_dot3
- *  GL_ARB_texture_env_dot3
- *  GL_ATI_texture_env_combine3
- *  GL_NV_texture_env_combine4
- *  conventional GL texture env modes
- *
- * \param ctx          rendering context
- * \param unit         the texture combiner unit
- * \param n            number of fragments to process (span width)
- * \param primary_rgba incoming fragment color array
- * \param texelBuffer  pointer to texel colors for all texture units
- * 
- * \param rgba         incoming/result fragment colors
- */
-static void
-texture_combine( GLcontext *ctx, GLuint unit, GLuint n,
-                 const float4_array primary_rgba,
-                 const GLfloat *texelBuffer,
-                 GLchan (*rgbaChan)[4] )
-{
-   SWcontext *swrast = SWRAST_CONTEXT(ctx);
-   const struct gl_texture_unit *textureUnit = &(ctx->Texture.Unit[unit]);
-   const struct gl_tex_env_combine_state *combine = textureUnit->_CurrentCombine;
-   float4_array argRGB[MAX_COMBINER_TERMS];
-   float4_array argA[MAX_COMBINER_TERMS];
-   const GLfloat scaleRGB = (GLfloat) (1 << combine->ScaleShiftRGB);
-   const GLfloat scaleA = (GLfloat) (1 << combine->ScaleShiftA);
-   const GLuint numArgsRGB = combine->_NumArgsRGB;
-   const GLuint numArgsA = combine->_NumArgsA;
-   GLfloat ccolor[MAX_COMBINER_TERMS][MAX_WIDTH][4]; /* temp color buffers */
-   GLfloat rgba[MAX_WIDTH][4];
-   GLuint i, term;
-
-   for (i = 0; i < n; i++) {
-      rgba[i][RCOMP] = CHAN_TO_FLOAT(rgbaChan[i][RCOMP]);
-      rgba[i][GCOMP] = CHAN_TO_FLOAT(rgbaChan[i][GCOMP]);
-      rgba[i][BCOMP] = CHAN_TO_FLOAT(rgbaChan[i][BCOMP]);
-      rgba[i][ACOMP] = CHAN_TO_FLOAT(rgbaChan[i][ACOMP]);
-   }
-
-   /*
-   printf("modeRGB 0x%x  modeA 0x%x  srcRGB1 0x%x  srcA1 0x%x  srcRGB2 0x%x  srcA2 0x%x\n",
-          combine->ModeRGB,
-          combine->ModeA,
-          combine->SourceRGB[0],
-          combine->SourceA[0],
-          combine->SourceRGB[1],
-          combine->SourceA[1]);
-   */
-
-   /*
-    * Do operand setup for up to 4 operands.  Loop over the terms.
-    */
-   for (term = 0; term < numArgsRGB; term++) {
-      const GLenum srcRGB = combine->SourceRGB[term];
-      const GLenum operandRGB = combine->OperandRGB[term];
-
-      switch (srcRGB) {
-         case GL_TEXTURE:
-            argRGB[term] = get_texel_array(swrast, unit);
-            break;
-         case GL_PRIMARY_COLOR:
-            argRGB[term] = primary_rgba;
-            break;
-         case GL_PREVIOUS:
-            argRGB[term] = rgba;
-            break;
-         case GL_CONSTANT:
-            {
-               float4_array c = ccolor[term];
-               GLfloat red   = textureUnit->EnvColor[0];
-               GLfloat green = textureUnit->EnvColor[1];
-               GLfloat blue  = textureUnit->EnvColor[2];
-               GLfloat alpha = textureUnit->EnvColor[3];
-               for (i = 0; i < n; i++) {
-                  ASSIGN_4V(c[i], red, green, blue, alpha);
-               }
-               argRGB[term] = ccolor[term];
-            }
-            break;
-	 /* GL_ATI_texture_env_combine3 allows GL_ZERO & GL_ONE as sources.
-	  */
-	 case GL_ZERO:
-            {
-               float4_array c = ccolor[term];
-               for (i = 0; i < n; i++) {
-                  ASSIGN_4V(c[i], 0.0F, 0.0F, 0.0F, 0.0F);
-               }
-               argRGB[term] = ccolor[term];
-            }
-            break;
-	 case GL_ONE:
-            {
-               float4_array c = ccolor[term];
-               for (i = 0; i < n; i++) {
-                  ASSIGN_4V(c[i], 1.0F, 1.0F, 1.0F, 1.0F);
-               }
-               argRGB[term] = ccolor[term];
-            }
-            break;
-         default:
-            /* ARB_texture_env_crossbar source */
-            {
-               const GLuint srcUnit = srcRGB - GL_TEXTURE0;
-               ASSERT(srcUnit < ctx->Const.MaxTextureUnits);
-               if (!ctx->Texture.Unit[srcUnit]._ReallyEnabled)
-                  return;
-               argRGB[term] = get_texel_array(swrast, srcUnit);
-            }
-      }
-
-      if (operandRGB != GL_SRC_COLOR) {
-         float4_array src = argRGB[term];
-         float4_array dst = ccolor[term];
-
-         /* point to new arg[term] storage */
-         argRGB[term] = ccolor[term];
-
-         switch (operandRGB) {
-         case GL_ONE_MINUS_SRC_COLOR:
-            for (i = 0; i < n; i++) {
-               dst[i][RCOMP] = 1.0F - src[i][RCOMP];
-               dst[i][GCOMP] = 1.0F - src[i][GCOMP];
-               dst[i][BCOMP] = 1.0F - src[i][BCOMP];
-            }
-            break;
-         case GL_SRC_ALPHA:
-            for (i = 0; i < n; i++) {
-               dst[i][RCOMP] =
-               dst[i][GCOMP] =
-               dst[i][BCOMP] = src[i][ACOMP];
-            }
-            break;
-         case GL_ONE_MINUS_SRC_ALPHA:
-            for (i = 0; i < n; i++) {
-               dst[i][RCOMP] =
-               dst[i][GCOMP] =
-               dst[i][BCOMP] = 1.0F - src[i][ACOMP];
-            }
-            break;
-         default:
-            _mesa_problem(ctx, "Bad operandRGB");
-         }
-      }
-   }
-
-   /*
-    * Set up the argA[term] pointers
-    */
-   for (term = 0; term < numArgsA; term++) {
-      const GLenum srcA = combine->SourceA[term];
-      const GLenum operandA = combine->OperandA[term];
-
-      switch (srcA) {
-         case GL_TEXTURE:
-            argA[term] = get_texel_array(swrast, unit);
-            break;
-         case GL_PRIMARY_COLOR:
-            argA[term] = primary_rgba;
-            break;
-         case GL_PREVIOUS:
-            argA[term] = rgba;
-            break;
-         case GL_CONSTANT:
-            {
-               float4_array c = ccolor[term];
-               GLfloat alpha = textureUnit->EnvColor[3];
-               for (i = 0; i < n; i++)
-                  c[i][ACOMP] = alpha;
-               argA[term] = ccolor[term];
-            }
-            break;
-	 /* GL_ATI_texture_env_combine3 allows GL_ZERO & GL_ONE as sources.
-	  */
-	 case GL_ZERO:
-            {
-               float4_array c = ccolor[term];
-               for (i = 0; i < n; i++)
-                  c[i][ACOMP] = 0.0F;
-               argA[term] = ccolor[term];
-            }
-            break;
-	 case GL_ONE:
-            {
-               float4_array c = ccolor[term];
-               for (i = 0; i < n; i++)
-                  c[i][ACOMP] = 1.0F;
-               argA[term] = ccolor[term];
-            }
-            break;
-         default:
-            /* ARB_texture_env_crossbar source */
-            {
-               const GLuint srcUnit = srcA - GL_TEXTURE0;
-               ASSERT(srcUnit < ctx->Const.MaxTextureUnits);
-               if (!ctx->Texture.Unit[srcUnit]._ReallyEnabled)
-                  return;
-               argA[term] = get_texel_array(swrast, srcUnit);
-            }
-      }
-
-      if (operandA == GL_ONE_MINUS_SRC_ALPHA) {
-         float4_array src = argA[term];
-         float4_array dst = ccolor[term];
-         argA[term] = ccolor[term];
-         for (i = 0; i < n; i++) {
-            dst[i][ACOMP] = 1.0F - src[i][ACOMP];
-         }
-      }
-   }
-
-   /* RGB channel combine */
-   {
-      float4_array arg0 = argRGB[0];
-      float4_array arg1 = argRGB[1];
-      float4_array arg2 = argRGB[2];
-      float4_array arg3 = argRGB[3];
-
-      switch (combine->ModeRGB) {
-      case GL_REPLACE:
-         for (i = 0; i < n; i++) {
-            rgba[i][RCOMP] = arg0[i][RCOMP] * scaleRGB;
-            rgba[i][GCOMP] = arg0[i][GCOMP] * scaleRGB;
-            rgba[i][BCOMP] = arg0[i][BCOMP] * scaleRGB;
-         }
-         break;
-      case GL_MODULATE:
-         for (i = 0; i < n; i++) {
-            rgba[i][RCOMP] = arg0[i][RCOMP] * arg1[i][RCOMP] * scaleRGB;
-            rgba[i][GCOMP] = arg0[i][GCOMP] * arg1[i][GCOMP] * scaleRGB;
-            rgba[i][BCOMP] = arg0[i][BCOMP] * arg1[i][BCOMP] * scaleRGB;
-         }
-         break;
-      case GL_ADD:
-         if (textureUnit->EnvMode == GL_COMBINE4_NV) {
-            /* (a * b) + (c * d) */
-            for (i = 0; i < n; i++) {
-               rgba[i][RCOMP] = (arg0[i][RCOMP] * arg1[i][RCOMP] +
-                                 arg2[i][RCOMP] * arg3[i][RCOMP]) * scaleRGB;
-               rgba[i][GCOMP] = (arg0[i][GCOMP] * arg1[i][GCOMP] +
-                                 arg2[i][GCOMP] * arg3[i][GCOMP]) * scaleRGB;
-               rgba[i][BCOMP] = (arg0[i][BCOMP] * arg1[i][BCOMP] +
-                                 arg2[i][BCOMP] * arg3[i][BCOMP]) * scaleRGB;
-            }
-         }
-         else {
-            /* 2-term addition */
-            for (i = 0; i < n; i++) {
-               rgba[i][RCOMP] = (arg0[i][RCOMP] + arg1[i][RCOMP]) * scaleRGB;
-               rgba[i][GCOMP] = (arg0[i][GCOMP] + arg1[i][GCOMP]) * scaleRGB;
-               rgba[i][BCOMP] = (arg0[i][BCOMP] + arg1[i][BCOMP]) * scaleRGB;
-            }
-         }
-         break;
-      case GL_ADD_SIGNED:
-         if (textureUnit->EnvMode == GL_COMBINE4_NV) {
-            /* (a * b) + (c * d) - 0.5 */
-            for (i = 0; i < n; i++) {
-               rgba[i][RCOMP] = (arg0[i][RCOMP] * arg1[i][RCOMP] +
-                                 arg2[i][RCOMP] * arg3[i][RCOMP] - 0.5F) * scaleRGB;
-               rgba[i][GCOMP] = (arg0[i][GCOMP] * arg1[i][GCOMP] +
-                                 arg2[i][GCOMP] * arg3[i][GCOMP] - 0.5F) * scaleRGB;
-               rgba[i][BCOMP] = (arg0[i][BCOMP] * arg1[i][BCOMP] +
-                                 arg2[i][BCOMP] * arg3[i][BCOMP] - 0.5F) * scaleRGB;
-            }
-         }
-         else {
-            for (i = 0; i < n; i++) {
-               rgba[i][RCOMP] = (arg0[i][RCOMP] + arg1[i][RCOMP] - 0.5F) * scaleRGB;
-               rgba[i][GCOMP] = (arg0[i][GCOMP] + arg1[i][GCOMP] - 0.5F) * scaleRGB;
-               rgba[i][BCOMP] = (arg0[i][BCOMP] + arg1[i][BCOMP] - 0.5F) * scaleRGB;
-            }
-         }
-         break;
-      case GL_INTERPOLATE:
-         for (i = 0; i < n; i++) {
-            rgba[i][RCOMP] = (arg0[i][RCOMP] * arg2[i][RCOMP] +
-                          arg1[i][RCOMP] * (1.0F - arg2[i][RCOMP])) * scaleRGB;
-            rgba[i][GCOMP] = (arg0[i][GCOMP] * arg2[i][GCOMP] +
-                          arg1[i][GCOMP] * (1.0F - arg2[i][GCOMP])) * scaleRGB;
-            rgba[i][BCOMP] = (arg0[i][BCOMP] * arg2[i][BCOMP] +
-                          arg1[i][BCOMP] * (1.0F - arg2[i][BCOMP])) * scaleRGB;
-         }
-         break;
-      case GL_SUBTRACT:
-         for (i = 0; i < n; i++) {
-            rgba[i][RCOMP] = (arg0[i][RCOMP] - arg1[i][RCOMP]) * scaleRGB;
-            rgba[i][GCOMP] = (arg0[i][GCOMP] - arg1[i][GCOMP]) * scaleRGB;
-            rgba[i][BCOMP] = (arg0[i][BCOMP] - arg1[i][BCOMP]) * scaleRGB;
-         }
-         break;
-      case GL_DOT3_RGB_EXT:
-      case GL_DOT3_RGBA_EXT:
-         /* Do not scale the result by 1 2 or 4 */
-         for (i = 0; i < n; i++) {
-            GLfloat dot = ((arg0[i][RCOMP] - 0.5F) * (arg1[i][RCOMP] - 0.5F) +
-                           (arg0[i][GCOMP] - 0.5F) * (arg1[i][GCOMP] - 0.5F) +
-                           (arg0[i][BCOMP] - 0.5F) * (arg1[i][BCOMP] - 0.5F))
-               * 4.0F;
-            dot = CLAMP(dot, 0.0F, 1.0F);
-            rgba[i][RCOMP] = rgba[i][GCOMP] = rgba[i][BCOMP] = dot;
-         }
-         break;
-      case GL_DOT3_RGB:
-      case GL_DOT3_RGBA:
-         /* DO scale the result by 1 2 or 4 */
-         for (i = 0; i < n; i++) {
-            GLfloat dot = ((arg0[i][RCOMP] - 0.5F) * (arg1[i][RCOMP] - 0.5F) +
-                           (arg0[i][GCOMP] - 0.5F) * (arg1[i][GCOMP] - 0.5F) +
-                           (arg0[i][BCOMP] - 0.5F) * (arg1[i][BCOMP] - 0.5F))
-               * 4.0F * scaleRGB;
-            dot = CLAMP(dot, 0.0F, 1.0F);
-            rgba[i][RCOMP] = rgba[i][GCOMP] = rgba[i][BCOMP] = dot;
-         }
-         break;
-      case GL_MODULATE_ADD_ATI:
-         for (i = 0; i < n; i++) {
-            rgba[i][RCOMP] = ((arg0[i][RCOMP] * arg2[i][RCOMP]) +
-                              arg1[i][RCOMP]) * scaleRGB;
-            rgba[i][GCOMP] = ((arg0[i][GCOMP] * arg2[i][GCOMP]) +
-                              arg1[i][GCOMP]) * scaleRGB;
-            rgba[i][BCOMP] = ((arg0[i][BCOMP] * arg2[i][BCOMP]) +
-                              arg1[i][BCOMP]) * scaleRGB;
-	 }
-         break;
-      case GL_MODULATE_SIGNED_ADD_ATI:
-         for (i = 0; i < n; i++) {
-            rgba[i][RCOMP] = ((arg0[i][RCOMP] * arg2[i][RCOMP]) +
-                              arg1[i][RCOMP] - 0.5F) * scaleRGB;
-            rgba[i][GCOMP] = ((arg0[i][GCOMP] * arg2[i][GCOMP]) +
-                              arg1[i][GCOMP] - 0.5F) * scaleRGB;
-            rgba[i][BCOMP] = ((arg0[i][BCOMP] * arg2[i][BCOMP]) +
-                              arg1[i][BCOMP] - 0.5F) * scaleRGB;
-	 }
-         break;
-      case GL_MODULATE_SUBTRACT_ATI:
-         for (i = 0; i < n; i++) {
-            rgba[i][RCOMP] = ((arg0[i][RCOMP] * arg2[i][RCOMP]) -
-                              arg1[i][RCOMP]) * scaleRGB;
-            rgba[i][GCOMP] = ((arg0[i][GCOMP] * arg2[i][GCOMP]) -
-                              arg1[i][GCOMP]) * scaleRGB;
-            rgba[i][BCOMP] = ((arg0[i][BCOMP] * arg2[i][BCOMP]) -
-                              arg1[i][BCOMP]) * scaleRGB;
-	 }
-         break;
-      case GL_BUMP_ENVMAP_ATI:
-         /* this produces a fixed rgba color, and the coord calc is done elsewhere */
-         for (i = 0; i < n; i++) {
-            /* rgba result is 0,0,0,1 */
-            rgba[i][RCOMP] = 0.0;
-            rgba[i][GCOMP] = 0.0;
-            rgba[i][BCOMP] = 0.0;
-            rgba[i][ACOMP] = 1.0;
-	 }
-         return; /* no alpha processing */
-      default:
-         _mesa_problem(ctx, "invalid combine mode");
-      }
-   }
-
-   /* Alpha channel combine */
-   {
-      float4_array arg0 = argA[0];
-      float4_array arg1 = argA[1];
-      float4_array arg2 = argA[2];
-      float4_array arg3 = argA[3];
-
-      switch (combine->ModeA) {
-      case GL_REPLACE:
-         for (i = 0; i < n; i++) {
-            rgba[i][ACOMP] = arg0[i][ACOMP] * scaleA;
-         }
-         break;
-      case GL_MODULATE:
-         for (i = 0; i < n; i++) {
-            rgba[i][ACOMP] = arg0[i][ACOMP] * arg1[i][ACOMP] * scaleA;
-         }
-         break;
-      case GL_ADD:
-         if (textureUnit->EnvMode == GL_COMBINE4_NV) {
-            /* (a * b) + (c * d) */
-            for (i = 0; i < n; i++) {
-               rgba[i][ACOMP] = (arg0[i][ACOMP] * arg1[i][ACOMP] +
-                                 arg2[i][ACOMP] * arg3[i][ACOMP]) * scaleA;
-            }
-         }
-         else {
-            /* two-term add */
-            for (i = 0; i < n; i++) {
-               rgba[i][ACOMP] = (arg0[i][ACOMP] + arg1[i][ACOMP]) * scaleA;
-            }
-         }
-         break;
-      case GL_ADD_SIGNED:
-         if (textureUnit->EnvMode == GL_COMBINE4_NV) {
-            /* (a * b) + (c * d) - 0.5 */
-            for (i = 0; i < n; i++) {
-               rgba[i][ACOMP] = (arg0[i][ACOMP] * arg1[i][ACOMP] +
-                                 arg2[i][ACOMP] * arg3[i][ACOMP] -
-                                 0.5F) * scaleA;
-            }
-         }
-         else {
-            /* a + b - 0.5 */
-            for (i = 0; i < n; i++) {
-               rgba[i][ACOMP] = (arg0[i][ACOMP] + arg1[i][ACOMP] - 0.5F) * scaleA;
-            }
-         }
-         break;
-      case GL_INTERPOLATE:
-         for (i = 0; i < n; i++) {
-            rgba[i][ACOMP] = (arg0[i][ACOMP] * arg2[i][ACOMP] +
-                              arg1[i][ACOMP] * (1.0F - arg2[i][ACOMP]))
-               * scaleA;
-         }
-         break;
-      case GL_SUBTRACT:
-         for (i = 0; i < n; i++) {
-            rgba[i][ACOMP] = (arg0[i][ACOMP] - arg1[i][ACOMP]) * scaleA;
-         }
-         break;
-      case GL_MODULATE_ADD_ATI:
-         for (i = 0; i < n; i++) {
-            rgba[i][ACOMP] = ((arg0[i][ACOMP] * arg2[i][ACOMP])
-                              + arg1[i][ACOMP]) * scaleA;
-         }
-         break;
-      case GL_MODULATE_SIGNED_ADD_ATI:
-         for (i = 0; i < n; i++) {
-            rgba[i][ACOMP] = ((arg0[i][ACOMP] * arg2[i][ACOMP]) +
-                              arg1[i][ACOMP] - 0.5F) * scaleA;
-         }
-         break;
-      case GL_MODULATE_SUBTRACT_ATI:
-         for (i = 0; i < n; i++) {
-            rgba[i][ACOMP] = ((arg0[i][ACOMP] * arg2[i][ACOMP])
-                              - arg1[i][ACOMP]) * scaleA;
-         }
-         break;
-      default:
-         _mesa_problem(ctx, "invalid combine mode");
-      }
-   }
-
-   /* Fix the alpha component for GL_DOT3_RGBA_EXT/ARB combining.
-    * This is kind of a kludge.  It would have been better if the spec
-    * were written such that the GL_COMBINE_ALPHA value could be set to
-    * GL_DOT3.
-    */
-   if (combine->ModeRGB == GL_DOT3_RGBA_EXT ||
-       combine->ModeRGB == GL_DOT3_RGBA) {
-      for (i = 0; i < n; i++) {
-	 rgba[i][ACOMP] = rgba[i][RCOMP];
-      }
-   }
-
-   for (i = 0; i < n; i++) {
-      UNCLAMPED_FLOAT_TO_CHAN(rgbaChan[i][RCOMP], rgba[i][RCOMP]);
-      UNCLAMPED_FLOAT_TO_CHAN(rgbaChan[i][GCOMP], rgba[i][GCOMP]);
-      UNCLAMPED_FLOAT_TO_CHAN(rgbaChan[i][BCOMP], rgba[i][BCOMP]);
-      UNCLAMPED_FLOAT_TO_CHAN(rgbaChan[i][ACOMP], rgba[i][ACOMP]);
-   }
-}
-
-
-/**
- * Apply X/Y/Z/W/0/1 swizzle to an array of colors/texels.
- * See GL_EXT_texture_swizzle.
- */
-static void
-swizzle_texels(GLuint swizzle, GLuint count, float4_array texels)
-{
-   const GLuint swzR = GET_SWZ(swizzle, 0);
-   const GLuint swzG = GET_SWZ(swizzle, 1);
-   const GLuint swzB = GET_SWZ(swizzle, 2);
-   const GLuint swzA = GET_SWZ(swizzle, 3);
-   GLfloat vector[6];
-   GLuint i;
-
-   vector[SWIZZLE_ZERO] = 0;
-   vector[SWIZZLE_ONE] = 1.0F;
-
-   for (i = 0; i < count; i++) {
-      vector[SWIZZLE_X] = texels[i][0];
-      vector[SWIZZLE_Y] = texels[i][1];
-      vector[SWIZZLE_Z] = texels[i][2];
-      vector[SWIZZLE_W] = texels[i][3];
-      texels[i][RCOMP] = vector[swzR];
-      texels[i][GCOMP] = vector[swzG];
-      texels[i][BCOMP] = vector[swzB];
-      texels[i][ACOMP] = vector[swzA];
-   }
-}
-
-
-/**
- * Apply texture mapping to a span of fragments.
- */
-void
-_swrast_texture_span( GLcontext *ctx, SWspan *span )
-{
-   SWcontext *swrast = SWRAST_CONTEXT(ctx);
-   GLfloat primary_rgba[MAX_WIDTH][4];
-   GLuint unit;
-
-   ASSERT(span->end <= MAX_WIDTH);
-
-   /*
-    * Save copy of the incoming fragment colors (the GL_PRIMARY_COLOR)
-    */
-   if (swrast->_TextureCombinePrimary) {
-      GLuint i;
-      for (i = 0; i < span->end; i++) {
-         primary_rgba[i][RCOMP] = CHAN_TO_FLOAT(span->array->rgba[i][RCOMP]);
-         primary_rgba[i][GCOMP] = CHAN_TO_FLOAT(span->array->rgba[i][GCOMP]);
-         primary_rgba[i][BCOMP] = CHAN_TO_FLOAT(span->array->rgba[i][BCOMP]);
-         primary_rgba[i][ACOMP] = CHAN_TO_FLOAT(span->array->rgba[i][ACOMP]);
-      }
-   }
-
-   /* First must sample all bump maps */
-   for (unit = 0; unit < ctx->Const.MaxTextureUnits; unit++) {
-      const struct gl_texture_unit *texUnit = &ctx->Texture.Unit[unit];
-
-      if (texUnit->_ReallyEnabled &&
-         texUnit->_CurrentCombine->ModeRGB == GL_BUMP_ENVMAP_ATI) {
-         const GLfloat (*texcoords)[4] = (const GLfloat (*)[4])
-            span->array->attribs[FRAG_ATTRIB_TEX0 + unit];
-         float4_array targetcoords =
-            span->array->attribs[FRAG_ATTRIB_TEX0 +
-               ctx->Texture.Unit[unit].BumpTarget - GL_TEXTURE0];
-
-         const struct gl_texture_object *curObj = texUnit->_Current;
-         GLfloat *lambda = span->array->lambda[unit];
-         float4_array texels = get_texel_array(swrast, unit);
-         GLuint i;
-         GLfloat rotMatrix00 = ctx->Texture.Unit[unit].RotMatrix[0];
-         GLfloat rotMatrix01 = ctx->Texture.Unit[unit].RotMatrix[1];
-         GLfloat rotMatrix10 = ctx->Texture.Unit[unit].RotMatrix[2];
-         GLfloat rotMatrix11 = ctx->Texture.Unit[unit].RotMatrix[3];
-
-         /* adjust texture lod (lambda) */
-         if (span->arrayMask & SPAN_LAMBDA) {
-            if (texUnit->LodBias + curObj->LodBias != 0.0F) {
-               /* apply LOD bias, but don't clamp yet */
-               const GLfloat bias = CLAMP(texUnit->LodBias + curObj->LodBias,
-                                          -ctx->Const.MaxTextureLodBias,
-                                          ctx->Const.MaxTextureLodBias);
-               GLuint i;
-               for (i = 0; i < span->end; i++) {
-                  lambda[i] += bias;
-               }
-            }
-
-            if (curObj->MinLod != -1000.0 || curObj->MaxLod != 1000.0) {
-               /* apply LOD clamping to lambda */
-               const GLfloat min = curObj->MinLod;
-               const GLfloat max = curObj->MaxLod;
-               GLuint i;
-               for (i = 0; i < span->end; i++) {
-                  GLfloat l = lambda[i];
-                  lambda[i] = CLAMP(l, min, max);
-               }
-            }
-         }
-
-         /* Sample the texture (span->end = number of fragments) */
-         swrast->TextureSample[unit]( ctx, texUnit->_Current, span->end,
-                                      texcoords, lambda, texels );
-
-         /* manipulate the span values of the bump target
-            not sure this can work correctly even ignoring
-            the problem that channel is unsigned */
-         for (i = 0; i < span->end; i++) {
-            targetcoords[i][0] += (texels[i][0] * rotMatrix00 + texels[i][1] *
-                                  rotMatrix01) / targetcoords[i][3];
-            targetcoords[i][1] += (texels[i][0] * rotMatrix10 + texels[i][1] *
-                                  rotMatrix11) / targetcoords[i][3];
-         }
-      }
-   }
-
-   /*
-    * Must do all texture sampling before combining in order to
-    * accomodate GL_ARB_texture_env_crossbar.
-    */
-   for (unit = 0; unit < ctx->Const.MaxTextureUnits; unit++) {
-      const struct gl_texture_unit *texUnit = &ctx->Texture.Unit[unit];
-      if (texUnit->_ReallyEnabled &&
-          texUnit->_CurrentCombine->ModeRGB != GL_BUMP_ENVMAP_ATI) {
-         const GLfloat (*texcoords)[4] = (const GLfloat (*)[4])
-            span->array->attribs[FRAG_ATTRIB_TEX0 + unit];
-         const struct gl_texture_object *curObj = texUnit->_Current;
-         GLfloat *lambda = span->array->lambda[unit];
-         float4_array texels = get_texel_array(swrast, unit);
-
-         /* adjust texture lod (lambda) */
-         if (span->arrayMask & SPAN_LAMBDA) {
-            if (texUnit->LodBias + curObj->LodBias != 0.0F) {
-               /* apply LOD bias, but don't clamp yet */
-               const GLfloat bias = CLAMP(texUnit->LodBias + curObj->LodBias,
-                                          -ctx->Const.MaxTextureLodBias,
-                                          ctx->Const.MaxTextureLodBias);
-               GLuint i;
-               for (i = 0; i < span->end; i++) {
-                  lambda[i] += bias;
-               }
-            }
-
-            if (curObj->MinLod != -1000.0 || curObj->MaxLod != 1000.0) {
-               /* apply LOD clamping to lambda */
-               const GLfloat min = curObj->MinLod;
-               const GLfloat max = curObj->MaxLod;
-               GLuint i;
-               for (i = 0; i < span->end; i++) {
-                  GLfloat l = lambda[i];
-                  lambda[i] = CLAMP(l, min, max);
-               }
-            }
-         }
-
-         /* Sample the texture (span->end = number of fragments) */
-         swrast->TextureSample[unit]( ctx, texUnit->_Current, span->end,
-                                      texcoords, lambda, texels );
-
-         /* GL_SGI_texture_color_table */
-         if (texUnit->ColorTableEnabled) {
-            _mesa_lookup_rgba_float(&texUnit->ColorTable, span->end, texels);
-         }
-
-         /* GL_EXT_texture_swizzle */
-         if (curObj->_Swizzle != SWIZZLE_NOOP) {
-            swizzle_texels(curObj->_Swizzle, span->end, texels);
-         }
-      }
-   }
-
-   /*
-    * OK, now apply the texture (aka texture combine/blend).
-    * We modify the span->color.rgba values.
-    */
-   for (unit = 0; unit < ctx->Const.MaxTextureUnits; unit++) {
-      if (ctx->Texture.Unit[unit]._ReallyEnabled) {
-         texture_combine( ctx, unit, span->end,
-                          primary_rgba,
-                          swrast->TexelBuffer,
-                          span->array->rgba );
-      }
-   }
-}
+/*

+ * Mesa 3-D graphics library

+ * Version:  7.5

+ *

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

+ * Copyright (C) 2009  VMware, Inc.   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/context.h"

+#include "main/colormac.h"

+#include "main/imports.h"

+#include "main/pixeltransfer.h"

+#include "program/prog_instruction.h"

+

+#include "s_context.h"

+#include "s_texcombine.h"

+

+

+/**

+ * Pointer to array of float[4]

+ * This type makes the code below more concise and avoids a lot of casting.

+ */

+typedef float (*float4_array)[4];

+

+

+/**

+ * Return array of texels for given unit.

+ */

+static INLINE float4_array

+get_texel_array(SWcontext *swrast, GLuint unit)

+{

+   return (float4_array) (swrast->TexelBuffer + unit * MAX_WIDTH * 4);

+}

+

+

+

+/**

+ * Do texture application for:

+ *  GL_EXT_texture_env_combine

+ *  GL_ARB_texture_env_combine

+ *  GL_EXT_texture_env_dot3

+ *  GL_ARB_texture_env_dot3

+ *  GL_ATI_texture_env_combine3

+ *  GL_NV_texture_env_combine4

+ *  conventional GL texture env modes

+ *

+ * \param ctx          rendering context

+ * \param unit         the texture combiner unit

+ * \param n            number of fragments to process (span width)

+ * \param primary_rgba incoming fragment color array

+ * \param texelBuffer  pointer to texel colors for all texture units

+ * 

+ * \param rgba         incoming/result fragment colors

+ */

+static void

+texture_combine( struct gl_context *ctx, GLuint unit, GLuint n,

+                 const float4_array primary_rgba,

+                 const GLfloat *texelBuffer,

+                 GLchan (*rgbaChan)[4] )

+{

+   SWcontext *swrast = SWRAST_CONTEXT(ctx);

+   const struct gl_texture_unit *textureUnit = &(ctx->Texture.Unit[unit]);

+   const struct gl_tex_env_combine_state *combine = textureUnit->_CurrentCombine;

+   float4_array argRGB[MAX_COMBINER_TERMS];

+   float4_array argA[MAX_COMBINER_TERMS];

+   const GLfloat scaleRGB = (GLfloat) (1 << combine->ScaleShiftRGB);

+   const GLfloat scaleA = (GLfloat) (1 << combine->ScaleShiftA);

+   const GLuint numArgsRGB = combine->_NumArgsRGB;

+   const GLuint numArgsA = combine->_NumArgsA;

+   float4_array ccolor[4], rgba;

+   GLuint i, term;

+

+   /* alloc temp pixel buffers */

+   rgba = (float4_array) malloc(4 * n * sizeof(GLfloat));

+   if (!rgba) {

+      _mesa_error(ctx, GL_OUT_OF_MEMORY, "texture_combine");

+      return;

+   }

+

+   for (i = 0; i < numArgsRGB || i < numArgsA; i++) {

+      ccolor[i] = (float4_array) malloc(4 * n * sizeof(GLfloat));

+      if (!ccolor[i]) {

+         while (i) {

+            free(ccolor[i]);

+            i--;

+         }

+         _mesa_error(ctx, GL_OUT_OF_MEMORY, "texture_combine");

+         return;

+      }

+   }

+

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

+      rgba[i][RCOMP] = CHAN_TO_FLOAT(rgbaChan[i][RCOMP]);

+      rgba[i][GCOMP] = CHAN_TO_FLOAT(rgbaChan[i][GCOMP]);

+      rgba[i][BCOMP] = CHAN_TO_FLOAT(rgbaChan[i][BCOMP]);

+      rgba[i][ACOMP] = CHAN_TO_FLOAT(rgbaChan[i][ACOMP]);

+   }

+

+   /*

+   printf("modeRGB 0x%x  modeA 0x%x  srcRGB1 0x%x  srcA1 0x%x  srcRGB2 0x%x  srcA2 0x%x\n",

+          combine->ModeRGB,

+          combine->ModeA,

+          combine->SourceRGB[0],

+          combine->SourceA[0],

+          combine->SourceRGB[1],

+          combine->SourceA[1]);

+   */

+

+   /*

+    * Do operand setup for up to 4 operands.  Loop over the terms.

+    */

+   for (term = 0; term < numArgsRGB; term++) {

+      const GLenum srcRGB = combine->SourceRGB[term];

+      const GLenum operandRGB = combine->OperandRGB[term];

+

+      switch (srcRGB) {

+         case GL_TEXTURE:

+            argRGB[term] = get_texel_array(swrast, unit);

+            break;

+         case GL_PRIMARY_COLOR:

+            argRGB[term] = primary_rgba;

+            break;

+         case GL_PREVIOUS:

+            argRGB[term] = rgba;

+            break;

+         case GL_CONSTANT:

+            {

+               float4_array c = ccolor[term];

+               GLfloat red   = textureUnit->EnvColor[0];

+               GLfloat green = textureUnit->EnvColor[1];

+               GLfloat blue  = textureUnit->EnvColor[2];

+               GLfloat alpha = textureUnit->EnvColor[3];

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

+                  ASSIGN_4V(c[i], red, green, blue, alpha);

+               }

+               argRGB[term] = ccolor[term];

+            }

+            break;

+	 /* GL_ATI_texture_env_combine3 allows GL_ZERO & GL_ONE as sources.

+	  */

+	 case GL_ZERO:

+            {

+               float4_array c = ccolor[term];

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

+                  ASSIGN_4V(c[i], 0.0F, 0.0F, 0.0F, 0.0F);

+               }

+               argRGB[term] = ccolor[term];

+            }

+            break;

+	 case GL_ONE:

+            {

+               float4_array c = ccolor[term];

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

+                  ASSIGN_4V(c[i], 1.0F, 1.0F, 1.0F, 1.0F);

+               }

+               argRGB[term] = ccolor[term];

+            }

+            break;

+         default:

+            /* ARB_texture_env_crossbar source */

+            {

+               const GLuint srcUnit = srcRGB - GL_TEXTURE0;

+               ASSERT(srcUnit < ctx->Const.MaxTextureUnits);

+               if (!ctx->Texture.Unit[srcUnit]._ReallyEnabled)

+                  goto end;

+               argRGB[term] = get_texel_array(swrast, srcUnit);

+            }

+      }

+

+      if (operandRGB != GL_SRC_COLOR) {

+         float4_array src = argRGB[term];

+         float4_array dst = ccolor[term];

+

+         /* point to new arg[term] storage */

+         argRGB[term] = ccolor[term];

+

+         switch (operandRGB) {

+         case GL_ONE_MINUS_SRC_COLOR:

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

+               dst[i][RCOMP] = 1.0F - src[i][RCOMP];

+               dst[i][GCOMP] = 1.0F - src[i][GCOMP];

+               dst[i][BCOMP] = 1.0F - src[i][BCOMP];

+            }

+            break;

+         case GL_SRC_ALPHA:

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

+               dst[i][RCOMP] =

+               dst[i][GCOMP] =

+               dst[i][BCOMP] = src[i][ACOMP];

+            }

+            break;

+         case GL_ONE_MINUS_SRC_ALPHA:

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

+               dst[i][RCOMP] =

+               dst[i][GCOMP] =

+               dst[i][BCOMP] = 1.0F - src[i][ACOMP];

+            }

+            break;

+         default:

+            _mesa_problem(ctx, "Bad operandRGB");

+         }

+      }

+   }

+

+   /*

+    * Set up the argA[term] pointers

+    */

+   for (term = 0; term < numArgsA; term++) {

+      const GLenum srcA = combine->SourceA[term];

+      const GLenum operandA = combine->OperandA[term];

+

+      switch (srcA) {

+         case GL_TEXTURE:

+            argA[term] = get_texel_array(swrast, unit);

+            break;

+         case GL_PRIMARY_COLOR:

+            argA[term] = primary_rgba;

+            break;

+         case GL_PREVIOUS:

+            argA[term] = rgba;

+            break;

+         case GL_CONSTANT:

+            {

+               float4_array c = ccolor[term];

+               GLfloat alpha = textureUnit->EnvColor[3];

+               for (i = 0; i < n; i++)

+                  c[i][ACOMP] = alpha;

+               argA[term] = ccolor[term];

+            }

+            break;

+	 /* GL_ATI_texture_env_combine3 allows GL_ZERO & GL_ONE as sources.

+	  */

+	 case GL_ZERO:

+            {

+               float4_array c = ccolor[term];

+               for (i = 0; i < n; i++)

+                  c[i][ACOMP] = 0.0F;

+               argA[term] = ccolor[term];

+            }

+            break;

+	 case GL_ONE:

+            {

+               float4_array c = ccolor[term];

+               for (i = 0; i < n; i++)

+                  c[i][ACOMP] = 1.0F;

+               argA[term] = ccolor[term];

+            }

+            break;

+         default:

+            /* ARB_texture_env_crossbar source */

+            {

+               const GLuint srcUnit = srcA - GL_TEXTURE0;

+               ASSERT(srcUnit < ctx->Const.MaxTextureUnits);

+               if (!ctx->Texture.Unit[srcUnit]._ReallyEnabled)

+                  goto end;

+               argA[term] = get_texel_array(swrast, srcUnit);

+            }

+      }

+

+      if (operandA == GL_ONE_MINUS_SRC_ALPHA) {

+         float4_array src = argA[term];

+         float4_array dst = ccolor[term];

+         argA[term] = ccolor[term];

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

+            dst[i][ACOMP] = 1.0F - src[i][ACOMP];

+         }

+      }

+   }

+

+   /* RGB channel combine */

+   {

+      float4_array arg0 = argRGB[0];

+      float4_array arg1 = argRGB[1];

+      float4_array arg2 = argRGB[2];

+      float4_array arg3 = argRGB[3];

+

+      switch (combine->ModeRGB) {

+      case GL_REPLACE:

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

+            rgba[i][RCOMP] = arg0[i][RCOMP] * scaleRGB;

+            rgba[i][GCOMP] = arg0[i][GCOMP] * scaleRGB;

+            rgba[i][BCOMP] = arg0[i][BCOMP] * scaleRGB;

+         }

+         break;

+      case GL_MODULATE:

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

+            rgba[i][RCOMP] = arg0[i][RCOMP] * arg1[i][RCOMP] * scaleRGB;

+            rgba[i][GCOMP] = arg0[i][GCOMP] * arg1[i][GCOMP] * scaleRGB;

+            rgba[i][BCOMP] = arg0[i][BCOMP] * arg1[i][BCOMP] * scaleRGB;

+         }

+         break;

+      case GL_ADD:

+         if (textureUnit->EnvMode == GL_COMBINE4_NV) {

+            /* (a * b) + (c * d) */

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

+               rgba[i][RCOMP] = (arg0[i][RCOMP] * arg1[i][RCOMP] +

+                                 arg2[i][RCOMP] * arg3[i][RCOMP]) * scaleRGB;

+               rgba[i][GCOMP] = (arg0[i][GCOMP] * arg1[i][GCOMP] +

+                                 arg2[i][GCOMP] * arg3[i][GCOMP]) * scaleRGB;

+               rgba[i][BCOMP] = (arg0[i][BCOMP] * arg1[i][BCOMP] +

+                                 arg2[i][BCOMP] * arg3[i][BCOMP]) * scaleRGB;

+            }

+         }

+         else {

+            /* 2-term addition */

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

+               rgba[i][RCOMP] = (arg0[i][RCOMP] + arg1[i][RCOMP]) * scaleRGB;

+               rgba[i][GCOMP] = (arg0[i][GCOMP] + arg1[i][GCOMP]) * scaleRGB;

+               rgba[i][BCOMP] = (arg0[i][BCOMP] + arg1[i][BCOMP]) * scaleRGB;

+            }

+         }

+         break;

+      case GL_ADD_SIGNED:

+         if (textureUnit->EnvMode == GL_COMBINE4_NV) {

+            /* (a * b) + (c * d) - 0.5 */

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

+               rgba[i][RCOMP] = (arg0[i][RCOMP] * arg1[i][RCOMP] +

+                                 arg2[i][RCOMP] * arg3[i][RCOMP] - 0.5F) * scaleRGB;

+               rgba[i][GCOMP] = (arg0[i][GCOMP] * arg1[i][GCOMP] +

+                                 arg2[i][GCOMP] * arg3[i][GCOMP] - 0.5F) * scaleRGB;

+               rgba[i][BCOMP] = (arg0[i][BCOMP] * arg1[i][BCOMP] +

+                                 arg2[i][BCOMP] * arg3[i][BCOMP] - 0.5F) * scaleRGB;

+            }

+         }

+         else {

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

+               rgba[i][RCOMP] = (arg0[i][RCOMP] + arg1[i][RCOMP] - 0.5F) * scaleRGB;

+               rgba[i][GCOMP] = (arg0[i][GCOMP] + arg1[i][GCOMP] - 0.5F) * scaleRGB;

+               rgba[i][BCOMP] = (arg0[i][BCOMP] + arg1[i][BCOMP] - 0.5F) * scaleRGB;

+            }

+         }

+         break;

+      case GL_INTERPOLATE:

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

+            rgba[i][RCOMP] = (arg0[i][RCOMP] * arg2[i][RCOMP] +

+                          arg1[i][RCOMP] * (1.0F - arg2[i][RCOMP])) * scaleRGB;

+            rgba[i][GCOMP] = (arg0[i][GCOMP] * arg2[i][GCOMP] +

+                          arg1[i][GCOMP] * (1.0F - arg2[i][GCOMP])) * scaleRGB;

+            rgba[i][BCOMP] = (arg0[i][BCOMP] * arg2[i][BCOMP] +

+                          arg1[i][BCOMP] * (1.0F - arg2[i][BCOMP])) * scaleRGB;

+         }

+         break;

+      case GL_SUBTRACT:

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

+            rgba[i][RCOMP] = (arg0[i][RCOMP] - arg1[i][RCOMP]) * scaleRGB;

+            rgba[i][GCOMP] = (arg0[i][GCOMP] - arg1[i][GCOMP]) * scaleRGB;

+            rgba[i][BCOMP] = (arg0[i][BCOMP] - arg1[i][BCOMP]) * scaleRGB;

+         }

+         break;

+      case GL_DOT3_RGB_EXT:

+      case GL_DOT3_RGBA_EXT:

+         /* Do not scale the result by 1 2 or 4 */

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

+            GLfloat dot = ((arg0[i][RCOMP] - 0.5F) * (arg1[i][RCOMP] - 0.5F) +

+                           (arg0[i][GCOMP] - 0.5F) * (arg1[i][GCOMP] - 0.5F) +

+                           (arg0[i][BCOMP] - 0.5F) * (arg1[i][BCOMP] - 0.5F))

+               * 4.0F;

+            dot = CLAMP(dot, 0.0F, 1.0F);

+            rgba[i][RCOMP] = rgba[i][GCOMP] = rgba[i][BCOMP] = dot;

+         }

+         break;

+      case GL_DOT3_RGB:

+      case GL_DOT3_RGBA:

+         /* DO scale the result by 1 2 or 4 */

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

+            GLfloat dot = ((arg0[i][RCOMP] - 0.5F) * (arg1[i][RCOMP] - 0.5F) +

+                           (arg0[i][GCOMP] - 0.5F) * (arg1[i][GCOMP] - 0.5F) +

+                           (arg0[i][BCOMP] - 0.5F) * (arg1[i][BCOMP] - 0.5F))

+               * 4.0F * scaleRGB;

+            dot = CLAMP(dot, 0.0F, 1.0F);

+            rgba[i][RCOMP] = rgba[i][GCOMP] = rgba[i][BCOMP] = dot;

+         }

+         break;

+      case GL_MODULATE_ADD_ATI:

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

+            rgba[i][RCOMP] = ((arg0[i][RCOMP] * arg2[i][RCOMP]) +

+                              arg1[i][RCOMP]) * scaleRGB;

+            rgba[i][GCOMP] = ((arg0[i][GCOMP] * arg2[i][GCOMP]) +

+                              arg1[i][GCOMP]) * scaleRGB;

+            rgba[i][BCOMP] = ((arg0[i][BCOMP] * arg2[i][BCOMP]) +

+                              arg1[i][BCOMP]) * scaleRGB;

+	 }

+         break;

+      case GL_MODULATE_SIGNED_ADD_ATI:

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

+            rgba[i][RCOMP] = ((arg0[i][RCOMP] * arg2[i][RCOMP]) +

+                              arg1[i][RCOMP] - 0.5F) * scaleRGB;

+            rgba[i][GCOMP] = ((arg0[i][GCOMP] * arg2[i][GCOMP]) +

+                              arg1[i][GCOMP] - 0.5F) * scaleRGB;

+            rgba[i][BCOMP] = ((arg0[i][BCOMP] * arg2[i][BCOMP]) +

+                              arg1[i][BCOMP] - 0.5F) * scaleRGB;

+	 }

+         break;

+      case GL_MODULATE_SUBTRACT_ATI:

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

+            rgba[i][RCOMP] = ((arg0[i][RCOMP] * arg2[i][RCOMP]) -

+                              arg1[i][RCOMP]) * scaleRGB;

+            rgba[i][GCOMP] = ((arg0[i][GCOMP] * arg2[i][GCOMP]) -

+                              arg1[i][GCOMP]) * scaleRGB;

+            rgba[i][BCOMP] = ((arg0[i][BCOMP] * arg2[i][BCOMP]) -

+                              arg1[i][BCOMP]) * scaleRGB;

+	 }

+         break;

+      case GL_BUMP_ENVMAP_ATI:

+         /* this produces a fixed rgba color, and the coord calc is done elsewhere */

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

+            /* rgba result is 0,0,0,1 */

+            rgba[i][RCOMP] = 0.0;

+            rgba[i][GCOMP] = 0.0;

+            rgba[i][BCOMP] = 0.0;

+            rgba[i][ACOMP] = 1.0;

+	 }

+         goto end; /* no alpha processing */

+      default:

+         _mesa_problem(ctx, "invalid combine mode");

+      }

+   }

+

+   /* Alpha channel combine */

+   {

+      float4_array arg0 = argA[0];

+      float4_array arg1 = argA[1];

+      float4_array arg2 = argA[2];

+      float4_array arg3 = argA[3];

+

+      switch (combine->ModeA) {

+      case GL_REPLACE:

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

+            rgba[i][ACOMP] = arg0[i][ACOMP] * scaleA;

+         }

+         break;

+      case GL_MODULATE:

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

+            rgba[i][ACOMP] = arg0[i][ACOMP] * arg1[i][ACOMP] * scaleA;

+         }

+         break;

+      case GL_ADD:

+         if (textureUnit->EnvMode == GL_COMBINE4_NV) {

+            /* (a * b) + (c * d) */

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

+               rgba[i][ACOMP] = (arg0[i][ACOMP] * arg1[i][ACOMP] +

+                                 arg2[i][ACOMP] * arg3[i][ACOMP]) * scaleA;

+            }

+         }

+         else {

+            /* two-term add */

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

+               rgba[i][ACOMP] = (arg0[i][ACOMP] + arg1[i][ACOMP]) * scaleA;

+            }

+         }

+         break;

+      case GL_ADD_SIGNED:

+         if (textureUnit->EnvMode == GL_COMBINE4_NV) {

+            /* (a * b) + (c * d) - 0.5 */

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

+               rgba[i][ACOMP] = (arg0[i][ACOMP] * arg1[i][ACOMP] +

+                                 arg2[i][ACOMP] * arg3[i][ACOMP] -

+                                 0.5F) * scaleA;

+            }

+         }

+         else {

+            /* a + b - 0.5 */

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

+               rgba[i][ACOMP] = (arg0[i][ACOMP] + arg1[i][ACOMP] - 0.5F) * scaleA;

+            }

+         }

+         break;

+      case GL_INTERPOLATE:

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

+            rgba[i][ACOMP] = (arg0[i][ACOMP] * arg2[i][ACOMP] +

+                              arg1[i][ACOMP] * (1.0F - arg2[i][ACOMP]))

+               * scaleA;

+         }

+         break;

+      case GL_SUBTRACT:

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

+            rgba[i][ACOMP] = (arg0[i][ACOMP] - arg1[i][ACOMP]) * scaleA;

+         }

+         break;

+      case GL_MODULATE_ADD_ATI:

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

+            rgba[i][ACOMP] = ((arg0[i][ACOMP] * arg2[i][ACOMP])

+                              + arg1[i][ACOMP]) * scaleA;

+         }

+         break;

+      case GL_MODULATE_SIGNED_ADD_ATI:

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

+            rgba[i][ACOMP] = ((arg0[i][ACOMP] * arg2[i][ACOMP]) +

+                              arg1[i][ACOMP] - 0.5F) * scaleA;

+         }

+         break;

+      case GL_MODULATE_SUBTRACT_ATI:

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

+            rgba[i][ACOMP] = ((arg0[i][ACOMP] * arg2[i][ACOMP])

+                              - arg1[i][ACOMP]) * scaleA;

+         }

+         break;

+      default:

+         _mesa_problem(ctx, "invalid combine mode");

+      }

+   }

+

+   /* Fix the alpha component for GL_DOT3_RGBA_EXT/ARB combining.

+    * This is kind of a kludge.  It would have been better if the spec

+    * were written such that the GL_COMBINE_ALPHA value could be set to

+    * GL_DOT3.

+    */

+   if (combine->ModeRGB == GL_DOT3_RGBA_EXT ||

+       combine->ModeRGB == GL_DOT3_RGBA) {

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

+	 rgba[i][ACOMP] = rgba[i][RCOMP];

+      }

+   }

+

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

+      UNCLAMPED_FLOAT_TO_CHAN(rgbaChan[i][RCOMP], rgba[i][RCOMP]);

+      UNCLAMPED_FLOAT_TO_CHAN(rgbaChan[i][GCOMP], rgba[i][GCOMP]);

+      UNCLAMPED_FLOAT_TO_CHAN(rgbaChan[i][BCOMP], rgba[i][BCOMP]);

+      UNCLAMPED_FLOAT_TO_CHAN(rgbaChan[i][ACOMP], rgba[i][ACOMP]);

+   }

+

+end:

+   for (i = 0; i < numArgsRGB || i < numArgsA; i++) {

+      free(ccolor[i]);

+   }

+   free(rgba);

+}

+

+

+/**

+ * Apply X/Y/Z/W/0/1 swizzle to an array of colors/texels.

+ * See GL_EXT_texture_swizzle.

+ */

+static void

+swizzle_texels(GLuint swizzle, GLuint count, float4_array texels)

+{

+   const GLuint swzR = GET_SWZ(swizzle, 0);

+   const GLuint swzG = GET_SWZ(swizzle, 1);

+   const GLuint swzB = GET_SWZ(swizzle, 2);

+   const GLuint swzA = GET_SWZ(swizzle, 3);

+   GLfloat vector[6];

+   GLuint i;

+

+   vector[SWIZZLE_ZERO] = 0;

+   vector[SWIZZLE_ONE] = 1.0F;

+

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

+      vector[SWIZZLE_X] = texels[i][0];

+      vector[SWIZZLE_Y] = texels[i][1];

+      vector[SWIZZLE_Z] = texels[i][2];

+      vector[SWIZZLE_W] = texels[i][3];

+      texels[i][RCOMP] = vector[swzR];

+      texels[i][GCOMP] = vector[swzG];

+      texels[i][BCOMP] = vector[swzB];

+      texels[i][ACOMP] = vector[swzA];

+   }

+}

+

+

+/**

+ * Apply texture mapping to a span of fragments.

+ */

+void

+_swrast_texture_span( struct gl_context *ctx, SWspan *span )

+{

+   SWcontext *swrast = SWRAST_CONTEXT(ctx);

+   float4_array primary_rgba;

+   GLuint unit;

+

+   primary_rgba = (float4_array) malloc(span->end * 4 * sizeof(GLfloat));

+

+   if (!primary_rgba) {

+      _mesa_error(ctx, GL_OUT_OF_MEMORY, "texture_span");

+      return;

+   }

+

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

+

+   /*

+    * Save copy of the incoming fragment colors (the GL_PRIMARY_COLOR)

+    */

+   if (swrast->_TextureCombinePrimary) {

+      GLuint i;

+      for (i = 0; i < span->end; i++) {

+         primary_rgba[i][RCOMP] = CHAN_TO_FLOAT(span->array->rgba[i][RCOMP]);

+         primary_rgba[i][GCOMP] = CHAN_TO_FLOAT(span->array->rgba[i][GCOMP]);

+         primary_rgba[i][BCOMP] = CHAN_TO_FLOAT(span->array->rgba[i][BCOMP]);

+         primary_rgba[i][ACOMP] = CHAN_TO_FLOAT(span->array->rgba[i][ACOMP]);

+      }

+   }

+

+   /* First must sample all bump maps */

+   for (unit = 0; unit < ctx->Const.MaxTextureUnits; unit++) {

+      const struct gl_texture_unit *texUnit = &ctx->Texture.Unit[unit];

+

+      if (texUnit->_ReallyEnabled &&

+         texUnit->_CurrentCombine->ModeRGB == GL_BUMP_ENVMAP_ATI) {

+         const GLfloat (*texcoords)[4] = (const GLfloat (*)[4])

+            span->array->attribs[FRAG_ATTRIB_TEX0 + unit];

+         float4_array targetcoords =

+            span->array->attribs[FRAG_ATTRIB_TEX0 +

+               ctx->Texture.Unit[unit].BumpTarget - GL_TEXTURE0];

+

+         const struct gl_texture_object *curObj = texUnit->_Current;

+         GLfloat *lambda = span->array->lambda[unit];

+         float4_array texels = get_texel_array(swrast, unit);

+         GLuint i;

+         GLfloat rotMatrix00 = ctx->Texture.Unit[unit].RotMatrix[0];

+         GLfloat rotMatrix01 = ctx->Texture.Unit[unit].RotMatrix[1];

+         GLfloat rotMatrix10 = ctx->Texture.Unit[unit].RotMatrix[2];

+         GLfloat rotMatrix11 = ctx->Texture.Unit[unit].RotMatrix[3];

+

+         /* adjust texture lod (lambda) */

+         if (span->arrayMask & SPAN_LAMBDA) {

+            if (texUnit->LodBias + curObj->LodBias != 0.0F) {

+               /* apply LOD bias, but don't clamp yet */

+               const GLfloat bias = CLAMP(texUnit->LodBias + curObj->LodBias,

+                                          -ctx->Const.MaxTextureLodBias,

+                                          ctx->Const.MaxTextureLodBias);

+               GLuint i;

+               for (i = 0; i < span->end; i++) {

+                  lambda[i] += bias;

+               }

+            }

+

+            if (curObj->MinLod != -1000.0 || curObj->MaxLod != 1000.0) {

+               /* apply LOD clamping to lambda */

+               const GLfloat min = curObj->MinLod;

+               const GLfloat max = curObj->MaxLod;

+               GLuint i;

+               for (i = 0; i < span->end; i++) {

+                  GLfloat l = lambda[i];

+                  lambda[i] = CLAMP(l, min, max);

+               }

+            }

+         }

+

+         /* Sample the texture (span->end = number of fragments) */

+         swrast->TextureSample[unit]( ctx, texUnit->_Current, span->end,

+                                      texcoords, lambda, texels );

+

+         /* manipulate the span values of the bump target

+            not sure this can work correctly even ignoring

+            the problem that channel is unsigned */

+         for (i = 0; i < span->end; i++) {

+            targetcoords[i][0] += (texels[i][0] * rotMatrix00 + texels[i][1] *

+                                  rotMatrix01) / targetcoords[i][3];

+            targetcoords[i][1] += (texels[i][0] * rotMatrix10 + texels[i][1] *

+                                  rotMatrix11) / targetcoords[i][3];

+         }

+      }

+   }

+

+   /*

+    * Must do all texture sampling before combining in order to

+    * accomodate GL_ARB_texture_env_crossbar.

+    */

+   for (unit = 0; unit < ctx->Const.MaxTextureUnits; unit++) {

+      const struct gl_texture_unit *texUnit = &ctx->Texture.Unit[unit];

+      if (texUnit->_ReallyEnabled &&

+          texUnit->_CurrentCombine->ModeRGB != GL_BUMP_ENVMAP_ATI) {

+         const GLfloat (*texcoords)[4] = (const GLfloat (*)[4])

+            span->array->attribs[FRAG_ATTRIB_TEX0 + unit];

+         const struct gl_texture_object *curObj = texUnit->_Current;

+         GLfloat *lambda = span->array->lambda[unit];

+         float4_array texels = get_texel_array(swrast, unit);

+

+         /* adjust texture lod (lambda) */

+         if (span->arrayMask & SPAN_LAMBDA) {

+            if (texUnit->LodBias + curObj->LodBias != 0.0F) {

+               /* apply LOD bias, but don't clamp yet */

+               const GLfloat bias = CLAMP(texUnit->LodBias + curObj->LodBias,

+                                          -ctx->Const.MaxTextureLodBias,

+                                          ctx->Const.MaxTextureLodBias);

+               GLuint i;

+               for (i = 0; i < span->end; i++) {

+                  lambda[i] += bias;

+               }

+            }

+

+            if (curObj->MinLod != -1000.0 || curObj->MaxLod != 1000.0) {

+               /* apply LOD clamping to lambda */

+               const GLfloat min = curObj->MinLod;

+               const GLfloat max = curObj->MaxLod;

+               GLuint i;

+               for (i = 0; i < span->end; i++) {

+                  GLfloat l = lambda[i];

+                  lambda[i] = CLAMP(l, min, max);

+               }

+            }

+         }

+

+         /* Sample the texture (span->end = number of fragments) */

+         swrast->TextureSample[unit]( ctx, texUnit->_Current, span->end,

+                                      texcoords, lambda, texels );

+

+         /* GL_SGI_texture_color_table */

+         if (texUnit->ColorTableEnabled) {

+            _mesa_lookup_rgba_float(&texUnit->ColorTable, span->end, texels);

+         }

+

+         /* GL_EXT_texture_swizzle */

+         if (curObj->_Swizzle != SWIZZLE_NOOP) {

+            swizzle_texels(curObj->_Swizzle, span->end, texels);

+         }

+      }

+   }

+

+   /*

+    * OK, now apply the texture (aka texture combine/blend).

+    * We modify the span->color.rgba values.

+    */

+   for (unit = 0; unit < ctx->Const.MaxTextureUnits; unit++) {

+      if (ctx->Texture.Unit[unit]._ReallyEnabled) {

+         texture_combine( ctx, unit, span->end,

+                          primary_rgba,

+                          swrast->TexelBuffer,

+                          span->array->rgba );

+      }

+   }

+

+   free(primary_rgba);

+}

diff --git a/mesalib/src/mesa/swrast/s_texcombine.h b/mesalib/src/mesa/swrast/s_texcombine.h
index 4f5dfbe1a..3897acd69 100644
--- a/mesalib/src/mesa/swrast/s_texcombine.h
+++ b/mesalib/src/mesa/swrast/s_texcombine.h
@@ -1,36 +1,37 @@
-/*
- * Mesa 3-D graphics library
- * Version:  6.5
- *
- * Copyright (C) 1999-2005  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.
- */
-
-
-#ifndef S_TEXCOMBINE_H
-#define S_TEXCOMBINE_H
-
-
-#include "main/mtypes.h"
-#include "s_span.h"
-
-extern void
-_swrast_texture_span( GLcontext *ctx, SWspan *span );
-
-#endif
+/*

+ * Mesa 3-D graphics library

+ * Version:  6.5

+ *

+ * Copyright (C) 1999-2005  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.

+ */

+

+

+#ifndef S_TEXCOMBINE_H

+#define S_TEXCOMBINE_H

+

+

+#include "s_span.h"

+

+struct gl_context;

+

+extern void

+_swrast_texture_span( struct gl_context *ctx, SWspan *span );

+

+#endif

diff --git a/mesalib/src/mesa/swrast/s_texfilter.c b/mesalib/src/mesa/swrast/s_texfilter.c
index 3fc554c5a..f39bd8a38 100644
--- a/mesalib/src/mesa/swrast/s_texfilter.c
+++ b/mesalib/src/mesa/swrast/s_texfilter.c
@@ -1,3300 +1,3312 @@
-/*
- * Mesa 3-D graphics library
- * Version:  7.3
- *
- * Copyright (C) 1999-2008  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/context.h"
-#include "main/colormac.h"
-#include "main/imports.h"
-#include "main/texformat.h"
-
-#include "s_context.h"
-#include "s_texfilter.h"
-
-
-/*
- * Note, the FRAC macro has to work perfectly.  Otherwise you'll sometimes
- * see 1-pixel bands of improperly weighted linear-filtered textures.
- * The tests/texwrap.c demo is a good test.
- * Also note, FRAC(x) doesn't truly return the fractional part of x for x < 0.
- * Instead, if x < 0 then FRAC(x) = 1 - true_frac(x).
- */
-#define FRAC(f)  ((f) - IFLOOR(f))
-
-
-
-/**
- * Linear interpolation macro
- */
-#define LERP(T, A, B)  ( (A) + (T) * ((B) - (A)) )
-
-
-/**
- * Do 2D/biliner interpolation of float values.
- * v00, v10, v01 and v11 are typically four texture samples in a square/box.
- * a and b are the horizontal and vertical interpolants.
- * It's important that this function is inlined when compiled with
- * optimization!  If we find that's not true on some systems, convert
- * to a macro.
- */
-static INLINE GLfloat
-lerp_2d(GLfloat a, GLfloat b,
-        GLfloat v00, GLfloat v10, GLfloat v01, GLfloat v11)
-{
-   const GLfloat temp0 = LERP(a, v00, v10);
-   const GLfloat temp1 = LERP(a, v01, v11);
-   return LERP(b, temp0, temp1);
-}
-
-
-/**
- * Do 3D/trilinear interpolation of float values.
- * \sa lerp_2d
- */
-static INLINE GLfloat
-lerp_3d(GLfloat a, GLfloat b, GLfloat c,
-        GLfloat v000, GLfloat v100, GLfloat v010, GLfloat v110,
-        GLfloat v001, GLfloat v101, GLfloat v011, GLfloat v111)
-{
-   const GLfloat temp00 = LERP(a, v000, v100);
-   const GLfloat temp10 = LERP(a, v010, v110);
-   const GLfloat temp01 = LERP(a, v001, v101);
-   const GLfloat temp11 = LERP(a, v011, v111);
-   const GLfloat temp0 = LERP(b, temp00, temp10);
-   const GLfloat temp1 = LERP(b, temp01, temp11);
-   return LERP(c, temp0, temp1);
-}
-
-
-/**
- * Do linear interpolation of colors.
- */
-static INLINE void
-lerp_rgba(GLfloat result[4], GLfloat t, const GLfloat a[4], const GLfloat b[4])
-{
-   result[0] = LERP(t, a[0], b[0]);
-   result[1] = LERP(t, a[1], b[1]);
-   result[2] = LERP(t, a[2], b[2]);
-   result[3] = LERP(t, a[3], b[3]);
-}
-
-
-/**
- * Do bilinear interpolation of colors.
- */
-static INLINE void
-lerp_rgba_2d(GLfloat result[4], GLfloat a, GLfloat b,
-             const GLfloat t00[4], const GLfloat t10[4],
-             const GLfloat t01[4], const GLfloat t11[4])
-{
-   result[0] = lerp_2d(a, b, t00[0], t10[0], t01[0], t11[0]);
-   result[1] = lerp_2d(a, b, t00[1], t10[1], t01[1], t11[1]);
-   result[2] = lerp_2d(a, b, t00[2], t10[2], t01[2], t11[2]);
-   result[3] = lerp_2d(a, b, t00[3], t10[3], t01[3], t11[3]);
-}
-
-
-/**
- * Do trilinear interpolation of colors.
- */
-static INLINE void
-lerp_rgba_3d(GLfloat result[4], GLfloat a, GLfloat b, GLfloat c,
-             const GLfloat t000[4], const GLfloat t100[4],
-             const GLfloat t010[4], const GLfloat t110[4],
-             const GLfloat t001[4], const GLfloat t101[4],
-             const GLfloat t011[4], const GLfloat t111[4])
-{
-   GLuint k;
-   /* compiler should unroll these short loops */
-   for (k = 0; k < 4; k++) {
-      result[k] = lerp_3d(a, b, c, t000[k], t100[k], t010[k], t110[k],
-                                   t001[k], t101[k], t011[k], t111[k]);
-   }
-}
-
-
-/**
- * If A is a signed integer, A % B doesn't give the right value for A < 0
- * (in terms of texture repeat).  Just casting to unsigned fixes that.
- */
-#define REMAINDER(A, B) (((A) + (B) * 1024) % (B))
-
-
-/**
- * Used to compute texel locations for linear sampling.
- * Input:
- *    wrapMode = GL_REPEAT, GL_CLAMP, GL_CLAMP_TO_EDGE, GL_CLAMP_TO_BORDER
- *    s = texcoord in [0,1]
- *    size = width (or height or depth) of texture
- * Output:
- *    i0, i1 = returns two nearest texel indexes
- *    weight = returns blend factor between texels
- */
-static INLINE void
-linear_texel_locations(GLenum wrapMode,
-                       const struct gl_texture_image *img,
-                       GLint size, GLfloat s,
-                       GLint *i0, GLint *i1, GLfloat *weight)
-{
-   GLfloat u;
-   switch (wrapMode) {
-   case GL_REPEAT:
-      u = s * size - 0.5F;
-      if (img->_IsPowerOfTwo) {
-         *i0 = IFLOOR(u) & (size - 1);
-         *i1 = (*i0 + 1) & (size - 1);
-      }
-      else {
-         *i0 = REMAINDER(IFLOOR(u), size);
-         *i1 = REMAINDER(*i0 + 1, size);
-      }
-      break;
-   case GL_CLAMP_TO_EDGE:
-      if (s <= 0.0F)
-         u = 0.0F;
-      else if (s >= 1.0F)
-         u = (GLfloat) size;
-      else
-         u = s * size;
-      u -= 0.5F;
-      *i0 = IFLOOR(u);
-      *i1 = *i0 + 1;
-      if (*i0 < 0)
-         *i0 = 0;
-      if (*i1 >= (GLint) size)
-         *i1 = size - 1;
-      break;
-   case GL_CLAMP_TO_BORDER:
-      {
-         const GLfloat min = -1.0F / (2.0F * size);
-         const GLfloat max = 1.0F - min;
-         if (s <= min)
-            u = min * size;
-         else if (s >= max)
-            u = max * size;
-         else
-            u = s * size;
-         u -= 0.5F;
-         *i0 = IFLOOR(u);
-         *i1 = *i0 + 1;
-      }
-      break;
-   case GL_MIRRORED_REPEAT:
-      {
-         const GLint flr = IFLOOR(s);
-         if (flr & 1)
-            u = 1.0F - (s - (GLfloat) flr);
-         else
-            u = s - (GLfloat) flr;
-         u = (u * size) - 0.5F;
-         *i0 = IFLOOR(u);
-         *i1 = *i0 + 1;
-         if (*i0 < 0)
-            *i0 = 0;
-         if (*i1 >= (GLint) size)
-            *i1 = size - 1;
-      }
-      break;
-   case GL_MIRROR_CLAMP_EXT:
-      u = FABSF(s);
-      if (u >= 1.0F)
-         u = (GLfloat) size;
-      else
-         u *= size;
-      u -= 0.5F;
-      *i0 = IFLOOR(u);
-      *i1 = *i0 + 1;
-      break;
-   case GL_MIRROR_CLAMP_TO_EDGE_EXT:
-      u = FABSF(s);
-      if (u >= 1.0F)
-         u = (GLfloat) size;
-      else
-         u *= size;
-      u -= 0.5F;
-      *i0 = IFLOOR(u);
-      *i1 = *i0 + 1;
-      if (*i0 < 0)
-         *i0 = 0;
-      if (*i1 >= (GLint) size)
-         *i1 = size - 1;
-      break;
-   case GL_MIRROR_CLAMP_TO_BORDER_EXT:
-      {
-         const GLfloat min = -1.0F / (2.0F * size);
-         const GLfloat max = 1.0F - min;
-         u = FABSF(s);
-         if (u <= min)
-            u = min * size;
-         else if (u >= max)
-            u = max * size;
-         else
-            u *= size;
-         u -= 0.5F;
-         *i0 = IFLOOR(u);
-         *i1 = *i0 + 1;
-      }
-      break;
-   case GL_CLAMP:
-      if (s <= 0.0F)
-         u = 0.0F;
-      else if (s >= 1.0F)
-         u = (GLfloat) size;
-      else
-         u = s * size;
-      u -= 0.5F;
-      *i0 = IFLOOR(u);
-      *i1 = *i0 + 1;
-      break;
-   default:
-      _mesa_problem(NULL, "Bad wrap mode");
-      u = 0.0F;
-   }
-   *weight = FRAC(u);
-}
-
-
-/**
- * Used to compute texel location for nearest sampling.
- */
-static INLINE GLint
-nearest_texel_location(GLenum wrapMode,
-                       const struct gl_texture_image *img,
-                       GLint size, GLfloat s)
-{
-   GLint i;
-
-   switch (wrapMode) {
-   case GL_REPEAT:
-      /* s limited to [0,1) */
-      /* i limited to [0,size-1] */
-      i = IFLOOR(s * size);
-      if (img->_IsPowerOfTwo)
-         i &= (size - 1);
-      else
-         i = REMAINDER(i, size);
-      return i;
-   case GL_CLAMP_TO_EDGE:
-      {
-         /* s limited to [min,max] */
-         /* i limited to [0, size-1] */
-         const GLfloat min = 1.0F / (2.0F * size);
-         const GLfloat max = 1.0F - min;
-         if (s < min)
-            i = 0;
-         else if (s > max)
-            i = size - 1;
-         else
-            i = IFLOOR(s * size);
-      }
-      return i;
-   case GL_CLAMP_TO_BORDER:
-      {
-         /* s limited to [min,max] */
-         /* i limited to [-1, size] */
-         const GLfloat min = -1.0F / (2.0F * size);
-         const GLfloat max = 1.0F - min;
-         if (s <= min)
-            i = -1;
-         else if (s >= max)
-            i = size;
-         else
-            i = IFLOOR(s * size);
-      }
-      return i;
-   case GL_MIRRORED_REPEAT:
-      {
-         const GLfloat min = 1.0F / (2.0F * size);
-         const GLfloat max = 1.0F - min;
-         const GLint flr = IFLOOR(s);
-         GLfloat u;
-         if (flr & 1)
-            u = 1.0F - (s - (GLfloat) flr);
-         else
-            u = s - (GLfloat) flr;
-         if (u < min)
-            i = 0;
-         else if (u > max)
-            i = size - 1;
-         else
-            i = IFLOOR(u * size);
-      }
-      return i;
-   case GL_MIRROR_CLAMP_EXT:
-      {
-         /* s limited to [0,1] */
-         /* i limited to [0,size-1] */
-         const GLfloat u = FABSF(s);
-         if (u <= 0.0F)
-            i = 0;
-         else if (u >= 1.0F)
-            i = size - 1;
-         else
-            i = IFLOOR(u * size);
-      }
-      return i;
-   case GL_MIRROR_CLAMP_TO_EDGE_EXT:
-      {
-         /* s limited to [min,max] */
-         /* i limited to [0, size-1] */
-         const GLfloat min = 1.0F / (2.0F * size);
-         const GLfloat max = 1.0F - min;
-         const GLfloat u = FABSF(s);
-         if (u < min)
-            i = 0;
-         else if (u > max)
-            i = size - 1;
-         else
-            i = IFLOOR(u * size);
-      }
-      return i;
-   case GL_MIRROR_CLAMP_TO_BORDER_EXT:
-      {
-         /* s limited to [min,max] */
-         /* i limited to [0, size-1] */
-         const GLfloat min = -1.0F / (2.0F * size);
-         const GLfloat max = 1.0F - min;
-         const GLfloat u = FABSF(s);
-         if (u < min)
-            i = -1;
-         else if (u > max)
-            i = size;
-         else
-            i = IFLOOR(u * size);
-      }
-      return i;
-   case GL_CLAMP:
-      /* s limited to [0,1] */
-      /* i limited to [0,size-1] */
-      if (s <= 0.0F)
-         i = 0;
-      else if (s >= 1.0F)
-         i = size - 1;
-      else
-         i = IFLOOR(s * size);
-      return i;
-   default:
-      _mesa_problem(NULL, "Bad wrap mode");
-      return 0;
-   }
-}
-
-
-/* Power of two image sizes only */
-static INLINE void
-linear_repeat_texel_location(GLuint size, GLfloat s,
-                             GLint *i0, GLint *i1, GLfloat *weight)
-{
-   GLfloat u = s * size - 0.5F;
-   *i0 = IFLOOR(u) & (size - 1);
-   *i1 = (*i0 + 1) & (size - 1);
-   *weight = FRAC(u);
-}
-
-
-/**
- * Do clamp/wrap for a texture rectangle coord, GL_NEAREST filter mode.
- */
-static INLINE GLint
-clamp_rect_coord_nearest(GLenum wrapMode, GLfloat coord, GLint max)
-{
-   switch (wrapMode) {
-   case GL_CLAMP:
-      return IFLOOR( CLAMP(coord, 0.0F, max - 1) );
-   case GL_CLAMP_TO_EDGE:
-      return IFLOOR( CLAMP(coord, 0.5F, max - 0.5F) );
-   case GL_CLAMP_TO_BORDER:
-      return IFLOOR( CLAMP(coord, -0.5F, max + 0.5F) );
-   default:
-      _mesa_problem(NULL, "bad wrapMode in clamp_rect_coord_nearest");
-      return 0;
-   }
-}
-
-
-/**
- * As above, but GL_LINEAR filtering.
- */
-static INLINE void
-clamp_rect_coord_linear(GLenum wrapMode, GLfloat coord, GLint max,
-                        GLint *i0out, GLint *i1out, GLfloat *weight)
-{
-   GLfloat fcol;
-   GLint i0, i1;
-   switch (wrapMode) {
-   case GL_CLAMP:
-      /* Not exactly what the spec says, but it matches NVIDIA output */
-      fcol = CLAMP(coord - 0.5F, 0.0F, max - 1);
-      i0 = IFLOOR(fcol);
-      i1 = i0 + 1;
-      break;
-   case GL_CLAMP_TO_EDGE:
-      fcol = CLAMP(coord, 0.5F, max - 0.5F);
-      fcol -= 0.5F;
-      i0 = IFLOOR(fcol);
-      i1 = i0 + 1;
-      if (i1 > max - 1)
-         i1 = max - 1;
-      break;
-   case GL_CLAMP_TO_BORDER:
-      fcol = CLAMP(coord, -0.5F, max + 0.5F);
-      fcol -= 0.5F;
-      i0 = IFLOOR(fcol);
-      i1 = i0 + 1;
-      break;
-   default:
-      _mesa_problem(NULL, "bad wrapMode in clamp_rect_coord_linear");
-      i0 = i1 = 0;
-      fcol = 0.0F;
-   }
-   *i0out = i0;
-   *i1out = i1;
-   *weight = FRAC(fcol);
-}
-
-
-/**
- * Compute slice/image to use for 1D or 2D array texture.
- */
-static INLINE GLint
-tex_array_slice(GLfloat coord, GLsizei size)
-{
-   GLint slice = IFLOOR(coord + 0.5f);
-   slice = CLAMP(slice, 0, size - 1);
-   return slice;
-}
-
-
-/**
- * Compute nearest integer texcoords for given texobj and coordinate.
- * NOTE: only used for depth texture sampling.
- */
-static INLINE void
-nearest_texcoord(const struct gl_texture_object *texObj,
-                 GLuint level,
-                 const GLfloat texcoord[4],
-                 GLint *i, GLint *j, GLint *k)
-{
-   const struct gl_texture_image *img = texObj->Image[0][level];
-   const GLint width = img->Width;
-   const GLint height = img->Height;
-   const GLint depth = img->Depth;
-
-   switch (texObj->Target) {
-   case GL_TEXTURE_RECTANGLE_ARB:
-      *i = clamp_rect_coord_nearest(texObj->WrapS, texcoord[0], width);
-      *j = clamp_rect_coord_nearest(texObj->WrapT, texcoord[1], height);
-      *k = 0;
-      break;
-   case GL_TEXTURE_1D:
-      *i = nearest_texel_location(texObj->WrapS, img, width, texcoord[0]);
-      *j = 0;
-      *k = 0;
-      break;
-   case GL_TEXTURE_2D:
-      *i = nearest_texel_location(texObj->WrapS, img, width, texcoord[0]);
-      *j = nearest_texel_location(texObj->WrapT, img, height, texcoord[1]);
-      *k = 0;
-      break;
-   case GL_TEXTURE_1D_ARRAY_EXT:
-      *i = nearest_texel_location(texObj->WrapS, img, width, texcoord[0]);
-      *j = tex_array_slice(texcoord[1], height);
-      *k = 0;
-      break;
-   case GL_TEXTURE_2D_ARRAY_EXT:
-      *i = nearest_texel_location(texObj->WrapS, img, width, texcoord[0]);
-      *j = nearest_texel_location(texObj->WrapT, img, height, texcoord[1]);
-      *k = tex_array_slice(texcoord[2], depth);
-      break;
-   default:
-      *i = *j = *k = 0;
-   }
-}
-
-
-/**
- * Compute linear integer texcoords for given texobj and coordinate.
- * NOTE: only used for depth texture sampling.
- */
-static INLINE void
-linear_texcoord(const struct gl_texture_object *texObj,
-                GLuint level,
-                const GLfloat texcoord[4],
-                GLint *i0, GLint *i1, GLint *j0, GLint *j1, GLint *slice,
-                GLfloat *wi, GLfloat *wj)
-{
-   const struct gl_texture_image *img = texObj->Image[0][level];
-   const GLint width = img->Width;
-   const GLint height = img->Height;
-   const GLint depth = img->Depth;
-
-   switch (texObj->Target) {
-   case GL_TEXTURE_RECTANGLE_ARB:
-      clamp_rect_coord_linear(texObj->WrapS, texcoord[0],
-                              width, i0, i1, wi);
-      clamp_rect_coord_linear(texObj->WrapT, texcoord[1],
-                              height, j0, j1, wj);
-      *slice = 0;
-      break;
-
-   case GL_TEXTURE_1D:
-   case GL_TEXTURE_2D:
-      linear_texel_locations(texObj->WrapS, img, width,
-                             texcoord[0], i0, i1, wi);
-      linear_texel_locations(texObj->WrapT, img, height,
-                             texcoord[1], j0, j1, wj);
-      *slice = 0;
-      break;
-
-   case GL_TEXTURE_1D_ARRAY_EXT:
-      linear_texel_locations(texObj->WrapS, img, width,
-                             texcoord[0], i0, i1, wi);
-      *j0 = tex_array_slice(texcoord[1], height);
-      *j1 = *j0;
-      *slice = 0;
-      break;
-
-   case GL_TEXTURE_2D_ARRAY_EXT:
-      linear_texel_locations(texObj->WrapS, img, width,
-                             texcoord[0], i0, i1, wi);
-      linear_texel_locations(texObj->WrapT, img, height,
-                             texcoord[1], j0, j1, wj);
-      *slice = tex_array_slice(texcoord[2], depth);
-      break;
-
-   default:
-      *slice = 0;
-   }
-}
-
-
-
-/**
- * For linear interpolation between mipmap levels N and N+1, this function
- * computes N.
- */
-static INLINE GLint
-linear_mipmap_level(const struct gl_texture_object *tObj, GLfloat lambda)
-{
-   if (lambda < 0.0F)
-      return tObj->BaseLevel;
-   else if (lambda > tObj->_MaxLambda)
-      return (GLint) (tObj->BaseLevel + tObj->_MaxLambda);
-   else
-      return (GLint) (tObj->BaseLevel + lambda);
-}
-
-
-/**
- * Compute the nearest mipmap level to take texels from.
- */
-static INLINE GLint
-nearest_mipmap_level(const struct gl_texture_object *tObj, GLfloat lambda)
-{
-   GLfloat l;
-   GLint level;
-   if (lambda <= 0.5F)
-      l = 0.0F;
-   else if (lambda > tObj->_MaxLambda + 0.4999F)
-      l = tObj->_MaxLambda + 0.4999F;
-   else
-      l = lambda;
-   level = (GLint) (tObj->BaseLevel + l + 0.5F);
-   if (level > tObj->_MaxLevel)
-      level = tObj->_MaxLevel;
-   return level;
-}
-
-
-
-/*
- * Bitflags for texture border color sampling.
- */
-#define I0BIT   1
-#define I1BIT   2
-#define J0BIT   4
-#define J1BIT   8
-#define K0BIT  16
-#define K1BIT  32
-
-
-
-/**
- * The lambda[] array values are always monotonic.  Either the whole span
- * will be minified, magnified, or split between the two.  This function
- * determines the subranges in [0, n-1] that are to be minified or magnified.
- */
-static INLINE void
-compute_min_mag_ranges(const struct gl_texture_object *tObj,
-                       GLuint n, const GLfloat lambda[],
-                       GLuint *minStart, GLuint *minEnd,
-                       GLuint *magStart, GLuint *magEnd)
-{
-   GLfloat minMagThresh;
-
-   /* we shouldn't be here if minfilter == magfilter */
-   ASSERT(tObj->MinFilter != tObj->MagFilter);
-
-   /* This bit comes from the OpenGL spec: */
-   if (tObj->MagFilter == GL_LINEAR
-       && (tObj->MinFilter == GL_NEAREST_MIPMAP_NEAREST ||
-           tObj->MinFilter == GL_NEAREST_MIPMAP_LINEAR)) {
-      minMagThresh = 0.5F;
-   }
-   else {
-      minMagThresh = 0.0F;
-   }
-
-#if 0
-   /* DEBUG CODE: Verify that lambda[] is monotonic.
-    * We can't really use this because the inaccuracy in the LOG2 function
-    * causes this test to fail, yet the resulting texturing is correct.
-    */
-   if (n > 1) {
-      GLuint i;
-      printf("lambda delta = %g\n", lambda[0] - lambda[n-1]);
-      if (lambda[0] >= lambda[n-1]) { /* decreasing */
-         for (i = 0; i < n - 1; i++) {
-            ASSERT((GLint) (lambda[i] * 10) >= (GLint) (lambda[i+1] * 10));
-         }
-      }
-      else { /* increasing */
-         for (i = 0; i < n - 1; i++) {
-            ASSERT((GLint) (lambda[i] * 10) <= (GLint) (lambda[i+1] * 10));
-         }
-      }
-   }
-#endif /* DEBUG */
-
-   if (lambda[0] <= minMagThresh && (n <= 1 || lambda[n-1] <= minMagThresh)) {
-      /* magnification for whole span */
-      *magStart = 0;
-      *magEnd = n;
-      *minStart = *minEnd = 0;
-   }
-   else if (lambda[0] > minMagThresh && (n <=1 || lambda[n-1] > minMagThresh)) {
-      /* minification for whole span */
-      *minStart = 0;
-      *minEnd = n;
-      *magStart = *magEnd = 0;
-   }
-   else {
-      /* a mix of minification and magnification */
-      GLuint i;
-      if (lambda[0] > minMagThresh) {
-         /* start with minification */
-         for (i = 1; i < n; i++) {
-            if (lambda[i] <= minMagThresh)
-               break;
-         }
-         *minStart = 0;
-         *minEnd = i;
-         *magStart = i;
-         *magEnd = n;
-      }
-      else {
-         /* start with magnification */
-         for (i = 1; i < n; i++) {
-            if (lambda[i] > minMagThresh)
-               break;
-         }
-         *magStart = 0;
-         *magEnd = i;
-         *minStart = i;
-         *minEnd = n;
-      }
-   }
-
-#if 0
-   /* Verify the min/mag Start/End values
-    * We don't use this either (see above)
-    */
-   {
-      GLint i;
-      for (i = 0; i < n; i++) {
-         if (lambda[i] > minMagThresh) {
-            /* minification */
-            ASSERT(i >= *minStart);
-            ASSERT(i < *minEnd);
-         }
-         else {
-            /* magnification */
-            ASSERT(i >= *magStart);
-            ASSERT(i < *magEnd);
-         }
-      }
-   }
-#endif
-}
-
-
-/**
- * When we sample the border color, it must be interpreted according to
- * the base texture format.  Ex: if the texture base format it GL_ALPHA,
- * we return (0,0,0,BorderAlpha).
- */
-static INLINE void
-get_border_color(const struct gl_texture_object *tObj,
-                 const struct gl_texture_image *img,
-                 GLfloat rgba[4])
-{
-   switch (img->_BaseFormat) {
-   case GL_RGB:
-      rgba[0] = tObj->BorderColor.f[0];
-      rgba[1] = tObj->BorderColor.f[1];
-      rgba[2] = tObj->BorderColor.f[2];
-      rgba[3] = 1.0F;
-      break;
-   case GL_ALPHA:
-      rgba[0] = rgba[1] = rgba[2] = 0.0;
-      rgba[3] = tObj->BorderColor.f[3];
-      break;
-   case GL_LUMINANCE:
-      rgba[0] = rgba[1] = rgba[2] = tObj->BorderColor.f[0];
-      rgba[3] = 1.0;
-      break;
-   case GL_LUMINANCE_ALPHA:
-      rgba[0] = rgba[1] = rgba[2] = tObj->BorderColor.f[0];
-      rgba[3] = tObj->BorderColor.f[3];
-      break;
-   case GL_INTENSITY:
-      rgba[0] = rgba[1] = rgba[2] = rgba[3] = tObj->BorderColor.f[0];
-      break;
-   default:
-      COPY_4V(rgba, tObj->BorderColor.f);
-   }
-}
-
-
-/**********************************************************************/
-/*                    1-D Texture Sampling Functions                  */
-/**********************************************************************/
-
-/**
- * Return the texture sample for coordinate (s) using GL_NEAREST filter.
- */
-static INLINE void
-sample_1d_nearest(GLcontext *ctx,
-                  const struct gl_texture_object *tObj,
-                  const struct gl_texture_image *img,
-                  const GLfloat texcoord[4], GLfloat rgba[4])
-{
-   const GLint width = img->Width2;  /* without border, power of two */
-   GLint i;
-   i = nearest_texel_location(tObj->WrapS, img, width, texcoord[0]);
-   /* skip over the border, if any */
-   i += img->Border;
-   if (i < 0 || i >= (GLint) img->Width) {
-      /* Need this test for GL_CLAMP_TO_BORDER mode */
-      get_border_color(tObj, img, rgba);
-   }
-   else {
-      img->FetchTexelf(img, i, 0, 0, rgba);
-   }
-}
-
-
-/**
- * Return the texture sample for coordinate (s) using GL_LINEAR filter.
- */
-static INLINE void
-sample_1d_linear(GLcontext *ctx,
-                 const struct gl_texture_object *tObj,
-                 const struct gl_texture_image *img,
-                 const GLfloat texcoord[4], GLfloat rgba[4])
-{
-   const GLint width = img->Width2;
-   GLint i0, i1;
-   GLbitfield useBorderColor = 0x0;
-   GLfloat a;
-   GLfloat t0[4], t1[4];  /* texels */
-
-   linear_texel_locations(tObj->WrapS, img, width, texcoord[0], &i0, &i1, &a);
-
-   if (img->Border) {
-      i0 += img->Border;
-      i1 += img->Border;
-   }
-   else {
-      if (i0 < 0 || i0 >= width)   useBorderColor |= I0BIT;
-      if (i1 < 0 || i1 >= width)   useBorderColor |= I1BIT;
-   }
-
-   /* fetch texel colors */
-   if (useBorderColor & I0BIT) {
-      get_border_color(tObj, img, t0);
-   }
-   else {
-      img->FetchTexelf(img, i0, 0, 0, t0);
-   }
-   if (useBorderColor & I1BIT) {
-      get_border_color(tObj, img, t1);
-   }
-   else {
-      img->FetchTexelf(img, i1, 0, 0, t1);
-   }
-
-   lerp_rgba(rgba, a, t0, t1);
-}
-
-
-static void
-sample_1d_nearest_mipmap_nearest(GLcontext *ctx,
-                                 const struct gl_texture_object *tObj,
-                                 GLuint n, const GLfloat texcoord[][4],
-                                 const GLfloat lambda[], GLfloat rgba[][4])
-{
-   GLuint i;
-   ASSERT(lambda != NULL);
-   for (i = 0; i < n; i++) {
-      GLint level = nearest_mipmap_level(tObj, lambda[i]);
-      sample_1d_nearest(ctx, tObj, tObj->Image[0][level], texcoord[i], rgba[i]);
-   }
-}
-
-
-static void
-sample_1d_linear_mipmap_nearest(GLcontext *ctx,
-                                const struct gl_texture_object *tObj,
-                                GLuint n, const GLfloat texcoord[][4],
-                                const GLfloat lambda[], GLfloat rgba[][4])
-{
-   GLuint i;
-   ASSERT(lambda != NULL);
-   for (i = 0; i < n; i++) {
-      GLint level = nearest_mipmap_level(tObj, lambda[i]);
-      sample_1d_linear(ctx, tObj, tObj->Image[0][level], texcoord[i], rgba[i]);
-   }
-}
-
-
-static void
-sample_1d_nearest_mipmap_linear(GLcontext *ctx,
-                                const struct gl_texture_object *tObj,
-                                GLuint n, const GLfloat texcoord[][4],
-                                const GLfloat lambda[], GLfloat rgba[][4])
-{
-   GLuint i;
-   ASSERT(lambda != NULL);
-   for (i = 0; i < n; i++) {
-      GLint level = linear_mipmap_level(tObj, lambda[i]);
-      if (level >= tObj->_MaxLevel) {
-         sample_1d_nearest(ctx, tObj, tObj->Image[0][tObj->_MaxLevel],
-                           texcoord[i], rgba[i]);
-      }
-      else {
-         GLfloat t0[4], t1[4];
-         const GLfloat f = FRAC(lambda[i]);
-         sample_1d_nearest(ctx, tObj, tObj->Image[0][level  ], texcoord[i], t0);
-         sample_1d_nearest(ctx, tObj, tObj->Image[0][level+1], texcoord[i], t1);
-         lerp_rgba(rgba[i], f, t0, t1);
-      }
-   }
-}
-
-
-static void
-sample_1d_linear_mipmap_linear(GLcontext *ctx,
-                               const struct gl_texture_object *tObj,
-                               GLuint n, const GLfloat texcoord[][4],
-                               const GLfloat lambda[], GLfloat rgba[][4])
-{
-   GLuint i;
-   ASSERT(lambda != NULL);
-   for (i = 0; i < n; i++) {
-      GLint level = linear_mipmap_level(tObj, lambda[i]);
-      if (level >= tObj->_MaxLevel) {
-         sample_1d_linear(ctx, tObj, tObj->Image[0][tObj->_MaxLevel],
-                          texcoord[i], rgba[i]);
-      }
-      else {
-         GLfloat t0[4], t1[4];
-         const GLfloat f = FRAC(lambda[i]);
-         sample_1d_linear(ctx, tObj, tObj->Image[0][level  ], texcoord[i], t0);
-         sample_1d_linear(ctx, tObj, tObj->Image[0][level+1], texcoord[i], t1);
-         lerp_rgba(rgba[i], f, t0, t1);
-      }
-   }
-}
-
-
-/** Sample 1D texture, nearest filtering for both min/magnification */
-static void
-sample_nearest_1d( GLcontext *ctx,
-                   const struct gl_texture_object *tObj, GLuint n,
-                   const GLfloat texcoords[][4], const GLfloat lambda[],
-                   GLfloat rgba[][4] )
-{
-   GLuint i;
-   struct gl_texture_image *image = tObj->Image[0][tObj->BaseLevel];
-   (void) lambda;
-   for (i = 0; i < n; i++) {
-      sample_1d_nearest(ctx, tObj, image, texcoords[i], rgba[i]);
-   }
-}
-
-
-/** Sample 1D texture, linear filtering for both min/magnification */
-static void
-sample_linear_1d( GLcontext *ctx,
-                  const struct gl_texture_object *tObj, GLuint n,
-                  const GLfloat texcoords[][4], const GLfloat lambda[],
-                  GLfloat rgba[][4] )
-{
-   GLuint i;
-   struct gl_texture_image *image = tObj->Image[0][tObj->BaseLevel];
-   (void) lambda;
-   for (i = 0; i < n; i++) {
-      sample_1d_linear(ctx, tObj, image, texcoords[i], rgba[i]);
-   }
-}
-
-
-/** Sample 1D texture, using lambda to choose between min/magnification */
-static void
-sample_lambda_1d( GLcontext *ctx,
-                  const struct gl_texture_object *tObj, GLuint n,
-                  const GLfloat texcoords[][4],
-                  const GLfloat lambda[], GLfloat rgba[][4] )
-{
-   GLuint minStart, minEnd;  /* texels with minification */
-   GLuint magStart, magEnd;  /* texels with magnification */
-   GLuint i;
-
-   ASSERT(lambda != NULL);
-   compute_min_mag_ranges(tObj, n, lambda,
-                          &minStart, &minEnd, &magStart, &magEnd);
-
-   if (minStart < minEnd) {
-      /* do the minified texels */
-      const GLuint m = minEnd - minStart;
-      switch (tObj->MinFilter) {
-      case GL_NEAREST:
-         for (i = minStart; i < minEnd; i++)
-            sample_1d_nearest(ctx, tObj, tObj->Image[0][tObj->BaseLevel],
-                              texcoords[i], rgba[i]);
-         break;
-      case GL_LINEAR:
-         for (i = minStart; i < minEnd; i++)
-            sample_1d_linear(ctx, tObj, tObj->Image[0][tObj->BaseLevel],
-                             texcoords[i], rgba[i]);
-         break;
-      case GL_NEAREST_MIPMAP_NEAREST:
-         sample_1d_nearest_mipmap_nearest(ctx, tObj, m, texcoords + minStart,
-                                          lambda + minStart, rgba + minStart);
-         break;
-      case GL_LINEAR_MIPMAP_NEAREST:
-         sample_1d_linear_mipmap_nearest(ctx, tObj, m, texcoords + minStart,
-                                         lambda + minStart, rgba + minStart);
-         break;
-      case GL_NEAREST_MIPMAP_LINEAR:
-         sample_1d_nearest_mipmap_linear(ctx, tObj, m, texcoords + minStart,
-                                         lambda + minStart, rgba + minStart);
-         break;
-      case GL_LINEAR_MIPMAP_LINEAR:
-         sample_1d_linear_mipmap_linear(ctx, tObj, m, texcoords + minStart,
-                                        lambda + minStart, rgba + minStart);
-         break;
-      default:
-         _mesa_problem(ctx, "Bad min filter in sample_1d_texture");
-         return;
-      }
-   }
-
-   if (magStart < magEnd) {
-      /* do the magnified texels */
-      switch (tObj->MagFilter) {
-      case GL_NEAREST:
-         for (i = magStart; i < magEnd; i++)
-            sample_1d_nearest(ctx, tObj, tObj->Image[0][tObj->BaseLevel],
-                              texcoords[i], rgba[i]);
-         break;
-      case GL_LINEAR:
-         for (i = magStart; i < magEnd; i++)
-            sample_1d_linear(ctx, tObj, tObj->Image[0][tObj->BaseLevel],
-                             texcoords[i], rgba[i]);
-         break;
-      default:
-         _mesa_problem(ctx, "Bad mag filter in sample_1d_texture");
-         return;
-      }
-   }
-}
-
-
-/**********************************************************************/
-/*                    2-D Texture Sampling Functions                  */
-/**********************************************************************/
-
-
-/**
- * Return the texture sample for coordinate (s,t) using GL_NEAREST filter.
- */
-static INLINE void
-sample_2d_nearest(GLcontext *ctx,
-                  const struct gl_texture_object *tObj,
-                  const struct gl_texture_image *img,
-                  const GLfloat texcoord[4],
-                  GLfloat rgba[])
-{
-   const GLint width = img->Width2;    /* without border, power of two */
-   const GLint height = img->Height2;  /* without border, power of two */
-   GLint i, j;
-   (void) ctx;
-
-   i = nearest_texel_location(tObj->WrapS, img, width, texcoord[0]);
-   j = nearest_texel_location(tObj->WrapT, img, height, texcoord[1]);
-
-   /* skip over the border, if any */
-   i += img->Border;
-   j += img->Border;
-
-   if (i < 0 || i >= (GLint) img->Width || j < 0 || j >= (GLint) img->Height) {
-      /* Need this test for GL_CLAMP_TO_BORDER mode */
-      get_border_color(tObj, img, rgba);
-   }
-   else {
-      img->FetchTexelf(img, i, j, 0, rgba);
-   }
-}
-
-
-/**
- * Return the texture sample for coordinate (s,t) using GL_LINEAR filter.
- * New sampling code contributed by Lynn Quam <quam@ai.sri.com>.
- */
-static INLINE void
-sample_2d_linear(GLcontext *ctx,
-                 const struct gl_texture_object *tObj,
-                 const struct gl_texture_image *img,
-                 const GLfloat texcoord[4],
-                 GLfloat rgba[])
-{
-   const GLint width = img->Width2;
-   const GLint height = img->Height2;
-   GLint i0, j0, i1, j1;
-   GLbitfield useBorderColor = 0x0;
-   GLfloat a, b;
-   GLfloat t00[4], t10[4], t01[4], t11[4]; /* sampled texel colors */
-
-   linear_texel_locations(tObj->WrapS, img, width, texcoord[0],  &i0, &i1, &a);
-   linear_texel_locations(tObj->WrapT, img, height, texcoord[1], &j0, &j1, &b);
-
-   if (img->Border) {
-      i0 += img->Border;
-      i1 += img->Border;
-      j0 += img->Border;
-      j1 += img->Border;
-   }
-   else {
-      if (i0 < 0 || i0 >= width)   useBorderColor |= I0BIT;
-      if (i1 < 0 || i1 >= width)   useBorderColor |= I1BIT;
-      if (j0 < 0 || j0 >= height)  useBorderColor |= J0BIT;
-      if (j1 < 0 || j1 >= height)  useBorderColor |= J1BIT;
-   }
-
-   /* fetch four texel colors */
-   if (useBorderColor & (I0BIT | J0BIT)) {
-      get_border_color(tObj, img, t00);
-   }
-   else {
-      img->FetchTexelf(img, i0, j0, 0, t00);
-   }
-   if (useBorderColor & (I1BIT | J0BIT)) {
-      get_border_color(tObj, img, t10);
-   }
-   else {
-      img->FetchTexelf(img, i1, j0, 0, t10);
-   }
-   if (useBorderColor & (I0BIT | J1BIT)) {
-      get_border_color(tObj, img, t01);
-   }
-   else {
-      img->FetchTexelf(img, i0, j1, 0, t01);
-   }
-   if (useBorderColor & (I1BIT | J1BIT)) {
-      get_border_color(tObj, img, t11);
-   }
-   else {
-      img->FetchTexelf(img, i1, j1, 0, t11);
-   }
-
-   lerp_rgba_2d(rgba, a, b, t00, t10, t01, t11);
-}
-
-
-/**
- * As above, but we know WRAP_S == REPEAT and WRAP_T == REPEAT.
- * We don't have to worry about the texture border.
- */
-static INLINE void
-sample_2d_linear_repeat(GLcontext *ctx,
-                        const struct gl_texture_object *tObj,
-                        const struct gl_texture_image *img,
-                        const GLfloat texcoord[4],
-                        GLfloat rgba[])
-{
-   const GLint width = img->Width2;
-   const GLint height = img->Height2;
-   GLint i0, j0, i1, j1;
-   GLfloat wi, wj;
-   GLfloat t00[4], t10[4], t01[4], t11[4]; /* sampled texel colors */
-
-   (void) ctx;
-
-   ASSERT(tObj->WrapS == GL_REPEAT);
-   ASSERT(tObj->WrapT == GL_REPEAT);
-   ASSERT(img->Border == 0);
-   ASSERT(img->_BaseFormat != GL_COLOR_INDEX);
-   ASSERT(img->_IsPowerOfTwo);
-
-   linear_repeat_texel_location(width,  texcoord[0], &i0, &i1, &wi);
-   linear_repeat_texel_location(height, texcoord[1], &j0, &j1, &wj);
-
-   img->FetchTexelf(img, i0, j0, 0, t00);
-   img->FetchTexelf(img, i1, j0, 0, t10);
-   img->FetchTexelf(img, i0, j1, 0, t01);
-   img->FetchTexelf(img, i1, j1, 0, t11);
-
-   lerp_rgba_2d(rgba, wi, wj, t00, t10, t01, t11);
-}
-
-
-static void
-sample_2d_nearest_mipmap_nearest(GLcontext *ctx,
-                                 const struct gl_texture_object *tObj,
-                                 GLuint n, const GLfloat texcoord[][4],
-                                 const GLfloat lambda[], GLfloat rgba[][4])
-{
-   GLuint i;
-   for (i = 0; i < n; i++) {
-      GLint level = nearest_mipmap_level(tObj, lambda[i]);
-      sample_2d_nearest(ctx, tObj, tObj->Image[0][level], texcoord[i], rgba[i]);
-   }
-}
-
-
-static void
-sample_2d_linear_mipmap_nearest(GLcontext *ctx,
-                                const struct gl_texture_object *tObj,
-                                GLuint n, const GLfloat texcoord[][4],
-                                const GLfloat lambda[], GLfloat rgba[][4])
-{
-   GLuint i;
-   ASSERT(lambda != NULL);
-   for (i = 0; i < n; i++) {
-      GLint level = nearest_mipmap_level(tObj, lambda[i]);
-      sample_2d_linear(ctx, tObj, tObj->Image[0][level], texcoord[i], rgba[i]);
-   }
-}
-
-
-static void
-sample_2d_nearest_mipmap_linear(GLcontext *ctx,
-                                const struct gl_texture_object *tObj,
-                                GLuint n, const GLfloat texcoord[][4],
-                                const GLfloat lambda[], GLfloat rgba[][4])
-{
-   GLuint i;
-   ASSERT(lambda != NULL);
-   for (i = 0; i < n; i++) {
-      GLint level = linear_mipmap_level(tObj, lambda[i]);
-      if (level >= tObj->_MaxLevel) {
-         sample_2d_nearest(ctx, tObj, tObj->Image[0][tObj->_MaxLevel],
-                           texcoord[i], rgba[i]);
-      }
-      else {
-         GLfloat t0[4], t1[4];  /* texels */
-         const GLfloat f = FRAC(lambda[i]);
-         sample_2d_nearest(ctx, tObj, tObj->Image[0][level  ], texcoord[i], t0);
-         sample_2d_nearest(ctx, tObj, tObj->Image[0][level+1], texcoord[i], t1);
-         lerp_rgba(rgba[i], f, t0, t1);
-      }
-   }
-}
-
-
-static void
-sample_2d_linear_mipmap_linear( GLcontext *ctx,
-                                const struct gl_texture_object *tObj,
-                                GLuint n, const GLfloat texcoord[][4],
-                                const GLfloat lambda[], GLfloat rgba[][4] )
-{
-   GLuint i;
-   ASSERT(lambda != NULL);
-   for (i = 0; i < n; i++) {
-      GLint level = linear_mipmap_level(tObj, lambda[i]);
-      if (level >= tObj->_MaxLevel) {
-         sample_2d_linear(ctx, tObj, tObj->Image[0][tObj->_MaxLevel],
-                          texcoord[i], rgba[i]);
-      }
-      else {
-         GLfloat t0[4], t1[4];  /* texels */
-         const GLfloat f = FRAC(lambda[i]);
-         sample_2d_linear(ctx, tObj, tObj->Image[0][level  ], texcoord[i], t0);
-         sample_2d_linear(ctx, tObj, tObj->Image[0][level+1], texcoord[i], t1);
-         lerp_rgba(rgba[i], f, t0, t1);
-      }
-   }
-}
-
-
-static void
-sample_2d_linear_mipmap_linear_repeat(GLcontext *ctx,
-                                      const struct gl_texture_object *tObj,
-                                      GLuint n, const GLfloat texcoord[][4],
-                                      const GLfloat lambda[], GLfloat rgba[][4])
-{
-   GLuint i;
-   ASSERT(lambda != NULL);
-   ASSERT(tObj->WrapS == GL_REPEAT);
-   ASSERT(tObj->WrapT == GL_REPEAT);
-   for (i = 0; i < n; i++) {
-      GLint level = linear_mipmap_level(tObj, lambda[i]);
-      if (level >= tObj->_MaxLevel) {
-         sample_2d_linear_repeat(ctx, tObj, tObj->Image[0][tObj->_MaxLevel],
-                                 texcoord[i], rgba[i]);
-      }
-      else {
-         GLfloat t0[4], t1[4];  /* texels */
-         const GLfloat f = FRAC(lambda[i]);
-         sample_2d_linear_repeat(ctx, tObj, tObj->Image[0][level  ],
-                                 texcoord[i], t0);
-         sample_2d_linear_repeat(ctx, tObj, tObj->Image[0][level+1],
-                                 texcoord[i], t1);
-         lerp_rgba(rgba[i], f, t0, t1);
-      }
-   }
-}
-
-
-/** Sample 2D texture, nearest filtering for both min/magnification */
-static void
-sample_nearest_2d(GLcontext *ctx,
-                  const struct gl_texture_object *tObj, GLuint n,
-                  const GLfloat texcoords[][4],
-                  const GLfloat lambda[], GLfloat rgba[][4])
-{
-   GLuint i;
-   struct gl_texture_image *image = tObj->Image[0][tObj->BaseLevel];
-   (void) lambda;
-   for (i = 0; i < n; i++) {
-      sample_2d_nearest(ctx, tObj, image, texcoords[i], rgba[i]);
-   }
-}
-
-
-/** Sample 2D texture, linear filtering for both min/magnification */
-static void
-sample_linear_2d(GLcontext *ctx,
-                 const struct gl_texture_object *tObj, GLuint n,
-                 const GLfloat texcoords[][4],
-                 const GLfloat lambda[], GLfloat rgba[][4])
-{
-   GLuint i;
-   struct gl_texture_image *image = tObj->Image[0][tObj->BaseLevel];
-   (void) lambda;
-   if (tObj->WrapS == GL_REPEAT &&
-       tObj->WrapT == GL_REPEAT &&
-       image->_IsPowerOfTwo &&
-       image->Border == 0) {
-      for (i = 0; i < n; i++) {
-         sample_2d_linear_repeat(ctx, tObj, image, texcoords[i], rgba[i]);
-      }
-   }
-   else {
-      for (i = 0; i < n; i++) {
-         sample_2d_linear(ctx, tObj, image, texcoords[i], rgba[i]);
-      }
-   }
-}
-
-
-/**
- * Optimized 2-D texture sampling:
- *    S and T wrap mode == GL_REPEAT
- *    GL_NEAREST min/mag filter
- *    No border, 
- *    RowStride == Width,
- *    Format = GL_RGB
- */
-static void
-opt_sample_rgb_2d(GLcontext *ctx,
-                  const struct gl_texture_object *tObj,
-                  GLuint n, const GLfloat texcoords[][4],
-                  const GLfloat lambda[], GLfloat rgba[][4])
-{
-   const struct gl_texture_image *img = tObj->Image[0][tObj->BaseLevel];
-   const GLfloat width = (GLfloat) img->Width;
-   const GLfloat height = (GLfloat) img->Height;
-   const GLint colMask = img->Width - 1;
-   const GLint rowMask = img->Height - 1;
-   const GLint shift = img->WidthLog2;
-   GLuint k;
-   (void) ctx;
-   (void) lambda;
-   ASSERT(tObj->WrapS==GL_REPEAT);
-   ASSERT(tObj->WrapT==GL_REPEAT);
-   ASSERT(img->Border==0);
-   ASSERT(img->TexFormat == MESA_FORMAT_RGB888);
-   ASSERT(img->_IsPowerOfTwo);
-
-   for (k=0; k<n; k++) {
-      GLint i = IFLOOR(texcoords[k][0] * width) & colMask;
-      GLint j = IFLOOR(texcoords[k][1] * height) & rowMask;
-      GLint pos = (j << shift) | i;
-      GLubyte *texel = ((GLubyte *) img->Data) + 3*pos;
-      rgba[k][RCOMP] = UBYTE_TO_FLOAT(texel[2]);
-      rgba[k][GCOMP] = UBYTE_TO_FLOAT(texel[1]);
-      rgba[k][BCOMP] = UBYTE_TO_FLOAT(texel[0]);
-   }
-}
-
-
-/**
- * Optimized 2-D texture sampling:
- *    S and T wrap mode == GL_REPEAT
- *    GL_NEAREST min/mag filter
- *    No border
- *    RowStride == Width,
- *    Format = GL_RGBA
- */
-static void
-opt_sample_rgba_2d(GLcontext *ctx,
-                   const struct gl_texture_object *tObj,
-                   GLuint n, const GLfloat texcoords[][4],
-                   const GLfloat lambda[], GLfloat rgba[][4])
-{
-   const struct gl_texture_image *img = tObj->Image[0][tObj->BaseLevel];
-   const GLfloat width = (GLfloat) img->Width;
-   const GLfloat height = (GLfloat) img->Height;
-   const GLint colMask = img->Width - 1;
-   const GLint rowMask = img->Height - 1;
-   const GLint shift = img->WidthLog2;
-   GLuint i;
-   (void) ctx;
-   (void) lambda;
-   ASSERT(tObj->WrapS==GL_REPEAT);
-   ASSERT(tObj->WrapT==GL_REPEAT);
-   ASSERT(img->Border==0);
-   ASSERT(img->TexFormat == MESA_FORMAT_RGBA8888);
-   ASSERT(img->_IsPowerOfTwo);
-
-   for (i = 0; i < n; i++) {
-      const GLint col = IFLOOR(texcoords[i][0] * width) & colMask;
-      const GLint row = IFLOOR(texcoords[i][1] * height) & rowMask;
-      const GLint pos = (row << shift) | col;
-      const GLuint texel = *((GLuint *) img->Data + pos);
-      rgba[i][RCOMP] = UBYTE_TO_FLOAT( (texel >> 24)        );
-      rgba[i][GCOMP] = UBYTE_TO_FLOAT( (texel >> 16) & 0xff );
-      rgba[i][BCOMP] = UBYTE_TO_FLOAT( (texel >>  8) & 0xff );
-      rgba[i][ACOMP] = UBYTE_TO_FLOAT( (texel      ) & 0xff );
-   }
-}
-
-
-/** Sample 2D texture, using lambda to choose between min/magnification */
-static void
-sample_lambda_2d(GLcontext *ctx,
-                 const struct gl_texture_object *tObj,
-                 GLuint n, const GLfloat texcoords[][4],
-                 const GLfloat lambda[], GLfloat rgba[][4])
-{
-   const struct gl_texture_image *tImg = tObj->Image[0][tObj->BaseLevel];
-   GLuint minStart, minEnd;  /* texels with minification */
-   GLuint magStart, magEnd;  /* texels with magnification */
-
-   const GLboolean repeatNoBorderPOT = (tObj->WrapS == GL_REPEAT)
-      && (tObj->WrapT == GL_REPEAT)
-      && (tImg->Border == 0 && (tImg->Width == tImg->RowStride))
-      && (tImg->_BaseFormat != GL_COLOR_INDEX)
-      && tImg->_IsPowerOfTwo;
-
-   ASSERT(lambda != NULL);
-   compute_min_mag_ranges(tObj, n, lambda,
-                          &minStart, &minEnd, &magStart, &magEnd);
-
-   if (minStart < minEnd) {
-      /* do the minified texels */
-      const GLuint m = minEnd - minStart;
-      switch (tObj->MinFilter) {
-      case GL_NEAREST:
-         if (repeatNoBorderPOT) {
-            switch (tImg->TexFormat) {
-            case MESA_FORMAT_RGB888:
-               opt_sample_rgb_2d(ctx, tObj, m, texcoords + minStart,
-                                 NULL, rgba + minStart);
-               break;
-            case MESA_FORMAT_RGBA8888:
-	       opt_sample_rgba_2d(ctx, tObj, m, texcoords + minStart,
-                                  NULL, rgba + minStart);
-               break;
-            default:
-               sample_nearest_2d(ctx, tObj, m, texcoords + minStart,
-                                 NULL, rgba + minStart );
-            }
-         }
-         else {
-            sample_nearest_2d(ctx, tObj, m, texcoords + minStart,
-                              NULL, rgba + minStart);
-         }
-         break;
-      case GL_LINEAR:
-	 sample_linear_2d(ctx, tObj, m, texcoords + minStart,
-			  NULL, rgba + minStart);
-         break;
-      case GL_NEAREST_MIPMAP_NEAREST:
-         sample_2d_nearest_mipmap_nearest(ctx, tObj, m,
-                                          texcoords + minStart,
-                                          lambda + minStart, rgba + minStart);
-         break;
-      case GL_LINEAR_MIPMAP_NEAREST:
-         sample_2d_linear_mipmap_nearest(ctx, tObj, m, texcoords + minStart,
-                                         lambda + minStart, rgba + minStart);
-         break;
-      case GL_NEAREST_MIPMAP_LINEAR:
-         sample_2d_nearest_mipmap_linear(ctx, tObj, m, texcoords + minStart,
-                                         lambda + minStart, rgba + minStart);
-         break;
-      case GL_LINEAR_MIPMAP_LINEAR:
-         if (repeatNoBorderPOT)
-            sample_2d_linear_mipmap_linear_repeat(ctx, tObj, m,
-                  texcoords + minStart, lambda + minStart, rgba + minStart);
-         else
-            sample_2d_linear_mipmap_linear(ctx, tObj, m, texcoords + minStart,
-                                        lambda + minStart, rgba + minStart);
-         break;
-      default:
-         _mesa_problem(ctx, "Bad min filter in sample_2d_texture");
-         return;
-      }
-   }
-
-   if (magStart < magEnd) {
-      /* do the magnified texels */
-      const GLuint m = magEnd - magStart;
-
-      switch (tObj->MagFilter) {
-      case GL_NEAREST:
-         if (repeatNoBorderPOT) {
-            switch (tImg->TexFormat) {
-            case MESA_FORMAT_RGB888:
-               opt_sample_rgb_2d(ctx, tObj, m, texcoords + magStart,
-                                 NULL, rgba + magStart);
-               break;
-            case MESA_FORMAT_RGBA8888:
-	       opt_sample_rgba_2d(ctx, tObj, m, texcoords + magStart,
-                                  NULL, rgba + magStart);
-               break;
-            default:
-               sample_nearest_2d(ctx, tObj, m, texcoords + magStart,
-                                 NULL, rgba + magStart );
-            }
-         }
-         else {
-            sample_nearest_2d(ctx, tObj, m, texcoords + magStart,
-                              NULL, rgba + magStart);
-         }
-         break;
-      case GL_LINEAR:
-	 sample_linear_2d(ctx, tObj, m, texcoords + magStart,
-			  NULL, rgba + magStart);
-         break;
-      default:
-         _mesa_problem(ctx, "Bad mag filter in sample_lambda_2d");
-      }
-   }
-}
-
-
-
-/**********************************************************************/
-/*                    3-D Texture Sampling Functions                  */
-/**********************************************************************/
-
-/**
- * Return the texture sample for coordinate (s,t,r) using GL_NEAREST filter.
- */
-static INLINE void
-sample_3d_nearest(GLcontext *ctx,
-                  const struct gl_texture_object *tObj,
-                  const struct gl_texture_image *img,
-                  const GLfloat texcoord[4],
-                  GLfloat rgba[4])
-{
-   const GLint width = img->Width2;     /* without border, power of two */
-   const GLint height = img->Height2;   /* without border, power of two */
-   const GLint depth = img->Depth2;     /* without border, power of two */
-   GLint i, j, k;
-   (void) ctx;
-
-   i = nearest_texel_location(tObj->WrapS, img, width, texcoord[0]);
-   j = nearest_texel_location(tObj->WrapT, img, height, texcoord[1]);
-   k = nearest_texel_location(tObj->WrapR, img, depth, texcoord[2]);
-
-   if (i < 0 || i >= (GLint) img->Width ||
-       j < 0 || j >= (GLint) img->Height ||
-       k < 0 || k >= (GLint) img->Depth) {
-      /* Need this test for GL_CLAMP_TO_BORDER mode */
-      get_border_color(tObj, img, rgba);
-   }
-   else {
-      img->FetchTexelf(img, i, j, k, rgba);
-   }
-}
-
-
-/**
- * Return the texture sample for coordinate (s,t,r) using GL_LINEAR filter.
- */
-static void
-sample_3d_linear(GLcontext *ctx,
-                 const struct gl_texture_object *tObj,
-                 const struct gl_texture_image *img,
-                 const GLfloat texcoord[4],
-                 GLfloat rgba[4])
-{
-   const GLint width = img->Width2;
-   const GLint height = img->Height2;
-   const GLint depth = img->Depth2;
-   GLint i0, j0, k0, i1, j1, k1;
-   GLbitfield useBorderColor = 0x0;
-   GLfloat a, b, c;
-   GLfloat t000[4], t010[4], t001[4], t011[4];
-   GLfloat t100[4], t110[4], t101[4], t111[4];
-
-   linear_texel_locations(tObj->WrapS, img, width, texcoord[0],  &i0, &i1, &a);
-   linear_texel_locations(tObj->WrapT, img, height, texcoord[1], &j0, &j1, &b);
-   linear_texel_locations(tObj->WrapR, img, depth, texcoord[2],  &k0, &k1, &c);
-
-   if (img->Border) {
-      i0 += img->Border;
-      i1 += img->Border;
-      j0 += img->Border;
-      j1 += img->Border;
-      k0 += img->Border;
-      k1 += img->Border;
-   }
-   else {
-      /* check if sampling texture border color */
-      if (i0 < 0 || i0 >= width)   useBorderColor |= I0BIT;
-      if (i1 < 0 || i1 >= width)   useBorderColor |= I1BIT;
-      if (j0 < 0 || j0 >= height)  useBorderColor |= J0BIT;
-      if (j1 < 0 || j1 >= height)  useBorderColor |= J1BIT;
-      if (k0 < 0 || k0 >= depth)   useBorderColor |= K0BIT;
-      if (k1 < 0 || k1 >= depth)   useBorderColor |= K1BIT;
-   }
-
-   /* Fetch texels */
-   if (useBorderColor & (I0BIT | J0BIT | K0BIT)) {
-      get_border_color(tObj, img, t000);
-   }
-   else {
-      img->FetchTexelf(img, i0, j0, k0, t000);
-   }
-   if (useBorderColor & (I1BIT | J0BIT | K0BIT)) {
-      get_border_color(tObj, img, t100);
-   }
-   else {
-      img->FetchTexelf(img, i1, j0, k0, t100);
-   }
-   if (useBorderColor & (I0BIT | J1BIT | K0BIT)) {
-      get_border_color(tObj, img, t010);
-   }
-   else {
-      img->FetchTexelf(img, i0, j1, k0, t010);
-   }
-   if (useBorderColor & (I1BIT | J1BIT | K0BIT)) {
-      get_border_color(tObj, img, t110);
-   }
-   else {
-      img->FetchTexelf(img, i1, j1, k0, t110);
-   }
-
-   if (useBorderColor & (I0BIT | J0BIT | K1BIT)) {
-      get_border_color(tObj, img, t001);
-   }
-   else {
-      img->FetchTexelf(img, i0, j0, k1, t001);
-   }
-   if (useBorderColor & (I1BIT | J0BIT | K1BIT)) {
-      get_border_color(tObj, img, t101);
-   }
-   else {
-      img->FetchTexelf(img, i1, j0, k1, t101);
-   }
-   if (useBorderColor & (I0BIT | J1BIT | K1BIT)) {
-      get_border_color(tObj, img, t011);
-   }
-   else {
-      img->FetchTexelf(img, i0, j1, k1, t011);
-   }
-   if (useBorderColor & (I1BIT | J1BIT | K1BIT)) {
-      get_border_color(tObj, img, t111);
-   }
-   else {
-      img->FetchTexelf(img, i1, j1, k1, t111);
-   }
-
-   /* trilinear interpolation of samples */
-   lerp_rgba_3d(rgba, a, b, c, t000, t100, t010, t110, t001, t101, t011, t111);
-}
-
-
-static void
-sample_3d_nearest_mipmap_nearest(GLcontext *ctx,
-                                 const struct gl_texture_object *tObj,
-                                 GLuint n, const GLfloat texcoord[][4],
-                                 const GLfloat lambda[], GLfloat rgba[][4] )
-{
-   GLuint i;
-   for (i = 0; i < n; i++) {
-      GLint level = nearest_mipmap_level(tObj, lambda[i]);
-      sample_3d_nearest(ctx, tObj, tObj->Image[0][level], texcoord[i], rgba[i]);
-   }
-}
-
-
-static void
-sample_3d_linear_mipmap_nearest(GLcontext *ctx,
-                                const struct gl_texture_object *tObj,
-                                GLuint n, const GLfloat texcoord[][4],
-                                const GLfloat lambda[], GLfloat rgba[][4])
-{
-   GLuint i;
-   ASSERT(lambda != NULL);
-   for (i = 0; i < n; i++) {
-      GLint level = nearest_mipmap_level(tObj, lambda[i]);
-      sample_3d_linear(ctx, tObj, tObj->Image[0][level], texcoord[i], rgba[i]);
-   }
-}
-
-
-static void
-sample_3d_nearest_mipmap_linear(GLcontext *ctx,
-                                const struct gl_texture_object *tObj,
-                                GLuint n, const GLfloat texcoord[][4],
-                                const GLfloat lambda[], GLfloat rgba[][4])
-{
-   GLuint i;
-   ASSERT(lambda != NULL);
-   for (i = 0; i < n; i++) {
-      GLint level = linear_mipmap_level(tObj, lambda[i]);
-      if (level >= tObj->_MaxLevel) {
-         sample_3d_nearest(ctx, tObj, tObj->Image[0][tObj->_MaxLevel],
-                           texcoord[i], rgba[i]);
-      }
-      else {
-         GLfloat t0[4], t1[4];  /* texels */
-         const GLfloat f = FRAC(lambda[i]);
-         sample_3d_nearest(ctx, tObj, tObj->Image[0][level  ], texcoord[i], t0);
-         sample_3d_nearest(ctx, tObj, tObj->Image[0][level+1], texcoord[i], t1);
-         lerp_rgba(rgba[i], f, t0, t1);
-      }
-   }
-}
-
-
-static void
-sample_3d_linear_mipmap_linear(GLcontext *ctx,
-                               const struct gl_texture_object *tObj,
-                               GLuint n, const GLfloat texcoord[][4],
-                               const GLfloat lambda[], GLfloat rgba[][4])
-{
-   GLuint i;
-   ASSERT(lambda != NULL);
-   for (i = 0; i < n; i++) {
-      GLint level = linear_mipmap_level(tObj, lambda[i]);
-      if (level >= tObj->_MaxLevel) {
-         sample_3d_linear(ctx, tObj, tObj->Image[0][tObj->_MaxLevel],
-                          texcoord[i], rgba[i]);
-      }
-      else {
-         GLfloat t0[4], t1[4];  /* texels */
-         const GLfloat f = FRAC(lambda[i]);
-         sample_3d_linear(ctx, tObj, tObj->Image[0][level  ], texcoord[i], t0);
-         sample_3d_linear(ctx, tObj, tObj->Image[0][level+1], texcoord[i], t1);
-         lerp_rgba(rgba[i], f, t0, t1);
-      }
-   }
-}
-
-
-/** Sample 3D texture, nearest filtering for both min/magnification */
-static void
-sample_nearest_3d(GLcontext *ctx,
-                  const struct gl_texture_object *tObj, GLuint n,
-                  const GLfloat texcoords[][4], const GLfloat lambda[],
-                  GLfloat rgba[][4])
-{
-   GLuint i;
-   struct gl_texture_image *image = tObj->Image[0][tObj->BaseLevel];
-   (void) lambda;
-   for (i = 0; i < n; i++) {
-      sample_3d_nearest(ctx, tObj, image, texcoords[i], rgba[i]);
-   }
-}
-
-
-/** Sample 3D texture, linear filtering for both min/magnification */
-static void
-sample_linear_3d(GLcontext *ctx,
-                 const struct gl_texture_object *tObj, GLuint n,
-                 const GLfloat texcoords[][4],
-		 const GLfloat lambda[], GLfloat rgba[][4])
-{
-   GLuint i;
-   struct gl_texture_image *image = tObj->Image[0][tObj->BaseLevel];
-   (void) lambda;
-   for (i = 0; i < n; i++) {
-      sample_3d_linear(ctx, tObj, image, texcoords[i], rgba[i]);
-   }
-}
-
-
-/** Sample 3D texture, using lambda to choose between min/magnification */
-static void
-sample_lambda_3d(GLcontext *ctx,
-                 const struct gl_texture_object *tObj, GLuint n,
-                 const GLfloat texcoords[][4], const GLfloat lambda[],
-                 GLfloat rgba[][4])
-{
-   GLuint minStart, minEnd;  /* texels with minification */
-   GLuint magStart, magEnd;  /* texels with magnification */
-   GLuint i;
-
-   ASSERT(lambda != NULL);
-   compute_min_mag_ranges(tObj, n, lambda,
-                          &minStart, &minEnd, &magStart, &magEnd);
-
-   if (minStart < minEnd) {
-      /* do the minified texels */
-      GLuint m = minEnd - minStart;
-      switch (tObj->MinFilter) {
-      case GL_NEAREST:
-         for (i = minStart; i < minEnd; i++)
-            sample_3d_nearest(ctx, tObj, tObj->Image[0][tObj->BaseLevel],
-                              texcoords[i], rgba[i]);
-         break;
-      case GL_LINEAR:
-         for (i = minStart; i < minEnd; i++)
-            sample_3d_linear(ctx, tObj, tObj->Image[0][tObj->BaseLevel],
-                             texcoords[i], rgba[i]);
-         break;
-      case GL_NEAREST_MIPMAP_NEAREST:
-         sample_3d_nearest_mipmap_nearest(ctx, tObj, m, texcoords + minStart,
-                                          lambda + minStart, rgba + minStart);
-         break;
-      case GL_LINEAR_MIPMAP_NEAREST:
-         sample_3d_linear_mipmap_nearest(ctx, tObj, m, texcoords + minStart,
-                                         lambda + minStart, rgba + minStart);
-         break;
-      case GL_NEAREST_MIPMAP_LINEAR:
-         sample_3d_nearest_mipmap_linear(ctx, tObj, m, texcoords + minStart,
-                                         lambda + minStart, rgba + minStart);
-         break;
-      case GL_LINEAR_MIPMAP_LINEAR:
-         sample_3d_linear_mipmap_linear(ctx, tObj, m, texcoords + minStart,
-                                        lambda + minStart, rgba + minStart);
-         break;
-      default:
-         _mesa_problem(ctx, "Bad min filter in sample_3d_texture");
-         return;
-      }
-   }
-
-   if (magStart < magEnd) {
-      /* do the magnified texels */
-      switch (tObj->MagFilter) {
-      case GL_NEAREST:
-         for (i = magStart; i < magEnd; i++)
-            sample_3d_nearest(ctx, tObj, tObj->Image[0][tObj->BaseLevel],
-                              texcoords[i], rgba[i]);
-         break;
-      case GL_LINEAR:
-         for (i = magStart; i < magEnd; i++)
-            sample_3d_linear(ctx, tObj, tObj->Image[0][tObj->BaseLevel],
-                             texcoords[i], rgba[i]);
-         break;
-      default:
-         _mesa_problem(ctx, "Bad mag filter in sample_3d_texture");
-         return;
-      }
-   }
-}
-
-
-/**********************************************************************/
-/*                Texture Cube Map Sampling Functions                 */
-/**********************************************************************/
-
-/**
- * Choose one of six sides of a texture cube map given the texture
- * coord (rx,ry,rz).  Return pointer to corresponding array of texture
- * images.
- */
-static const struct gl_texture_image **
-choose_cube_face(const struct gl_texture_object *texObj,
-                 const GLfloat texcoord[4], GLfloat newCoord[4])
-{
-   /*
-      major axis
-      direction     target                             sc     tc    ma
-      ----------    -------------------------------    ---    ---   ---
-       +rx          TEXTURE_CUBE_MAP_POSITIVE_X_EXT    -rz    -ry   rx
-       -rx          TEXTURE_CUBE_MAP_NEGATIVE_X_EXT    +rz    -ry   rx
-       +ry          TEXTURE_CUBE_MAP_POSITIVE_Y_EXT    +rx    +rz   ry
-       -ry          TEXTURE_CUBE_MAP_NEGATIVE_Y_EXT    +rx    -rz   ry
-       +rz          TEXTURE_CUBE_MAP_POSITIVE_Z_EXT    +rx    -ry   rz
-       -rz          TEXTURE_CUBE_MAP_NEGATIVE_Z_EXT    -rx    -ry   rz
-   */
-   const GLfloat rx = texcoord[0];
-   const GLfloat ry = texcoord[1];
-   const GLfloat rz = texcoord[2];
-   const GLfloat arx = FABSF(rx), ary = FABSF(ry), arz = FABSF(rz);
-   GLuint face;
-   GLfloat sc, tc, ma;
-
-   if (arx >= ary && arx >= arz) {
-      if (rx >= 0.0F) {
-         face = FACE_POS_X;
-         sc = -rz;
-         tc = -ry;
-         ma = arx;
-      }
-      else {
-         face = FACE_NEG_X;
-         sc = rz;
-         tc = -ry;
-         ma = arx;
-      }
-   }
-   else if (ary >= arx && ary >= arz) {
-      if (ry >= 0.0F) {
-         face = FACE_POS_Y;
-         sc = rx;
-         tc = rz;
-         ma = ary;
-      }
-      else {
-         face = FACE_NEG_Y;
-         sc = rx;
-         tc = -rz;
-         ma = ary;
-      }
-   }
-   else {
-      if (rz > 0.0F) {
-         face = FACE_POS_Z;
-         sc = rx;
-         tc = -ry;
-         ma = arz;
-      }
-      else {
-         face = FACE_NEG_Z;
-         sc = -rx;
-         tc = -ry;
-         ma = arz;
-      }
-   }
-
-   { 
-      const float ima = 1.0F / ma;
-      newCoord[0] = ( sc * ima + 1.0F ) * 0.5F;
-      newCoord[1] = ( tc * ima + 1.0F ) * 0.5F;
-   }
-
-   return (const struct gl_texture_image **) texObj->Image[face];
-}
-
-
-static void
-sample_nearest_cube(GLcontext *ctx,
-		    const struct gl_texture_object *tObj, GLuint n,
-                    const GLfloat texcoords[][4], const GLfloat lambda[],
-                    GLfloat rgba[][4])
-{
-   GLuint i;
-   (void) lambda;
-   for (i = 0; i < n; i++) {
-      const struct gl_texture_image **images;
-      GLfloat newCoord[4];
-      images = choose_cube_face(tObj, texcoords[i], newCoord);
-      sample_2d_nearest(ctx, tObj, images[tObj->BaseLevel],
-                        newCoord, rgba[i]);
-   }
-}
-
-
-static void
-sample_linear_cube(GLcontext *ctx,
-		   const struct gl_texture_object *tObj, GLuint n,
-                   const GLfloat texcoords[][4],
-		   const GLfloat lambda[], GLfloat rgba[][4])
-{
-   GLuint i;
-   (void) lambda;
-   for (i = 0; i < n; i++) {
-      const struct gl_texture_image **images;
-      GLfloat newCoord[4];
-      images = choose_cube_face(tObj, texcoords[i], newCoord);
-      sample_2d_linear(ctx, tObj, images[tObj->BaseLevel],
-                       newCoord, rgba[i]);
-   }
-}
-
-
-static void
-sample_cube_nearest_mipmap_nearest(GLcontext *ctx,
-                                   const struct gl_texture_object *tObj,
-                                   GLuint n, const GLfloat texcoord[][4],
-                                   const GLfloat lambda[], GLfloat rgba[][4])
-{
-   GLuint i;
-   ASSERT(lambda != NULL);
-   for (i = 0; i < n; i++) {
-      const struct gl_texture_image **images;
-      GLfloat newCoord[4];
-      GLint level;
-      images = choose_cube_face(tObj, texcoord[i], newCoord);
-
-      /* XXX we actually need to recompute lambda here based on the newCoords.
-       * But we would need the texcoords of adjacent fragments to compute that
-       * properly, and we don't have those here.
-       * For now, do an approximation:  subtracting 1 from the chosen mipmap
-       * level seems to work in some test cases.
-       * The same adjustment is done in the next few functions.
-      */
-      level = nearest_mipmap_level(tObj, lambda[i]);
-      level = MAX2(level - 1, 0);
-
-      sample_2d_nearest(ctx, tObj, images[level], newCoord, rgba[i]);
-   }
-}
-
-
-static void
-sample_cube_linear_mipmap_nearest(GLcontext *ctx,
-                                  const struct gl_texture_object *tObj,
-                                  GLuint n, const GLfloat texcoord[][4],
-                                  const GLfloat lambda[], GLfloat rgba[][4])
-{
-   GLuint i;
-   ASSERT(lambda != NULL);
-   for (i = 0; i < n; i++) {
-      const struct gl_texture_image **images;
-      GLfloat newCoord[4];
-      GLint level = nearest_mipmap_level(tObj, lambda[i]);
-      level = MAX2(level - 1, 0); /* see comment above */
-      images = choose_cube_face(tObj, texcoord[i], newCoord);
-      sample_2d_linear(ctx, tObj, images[level], newCoord, rgba[i]);
-   }
-}
-
-
-static void
-sample_cube_nearest_mipmap_linear(GLcontext *ctx,
-                                  const struct gl_texture_object *tObj,
-                                  GLuint n, const GLfloat texcoord[][4],
-                                  const GLfloat lambda[], GLfloat rgba[][4])
-{
-   GLuint i;
-   ASSERT(lambda != NULL);
-   for (i = 0; i < n; i++) {
-      const struct gl_texture_image **images;
-      GLfloat newCoord[4];
-      GLint level = linear_mipmap_level(tObj, lambda[i]);
-      level = MAX2(level - 1, 0); /* see comment above */
-      images = choose_cube_face(tObj, texcoord[i], newCoord);
-      if (level >= tObj->_MaxLevel) {
-         sample_2d_nearest(ctx, tObj, images[tObj->_MaxLevel],
-                           newCoord, rgba[i]);
-      }
-      else {
-         GLfloat t0[4], t1[4];  /* texels */
-         const GLfloat f = FRAC(lambda[i]);
-         sample_2d_nearest(ctx, tObj, images[level  ], newCoord, t0);
-         sample_2d_nearest(ctx, tObj, images[level+1], newCoord, t1);
-         lerp_rgba(rgba[i], f, t0, t1);
-      }
-   }
-}
-
-
-static void
-sample_cube_linear_mipmap_linear(GLcontext *ctx,
-                                 const struct gl_texture_object *tObj,
-                                 GLuint n, const GLfloat texcoord[][4],
-                                 const GLfloat lambda[], GLfloat rgba[][4])
-{
-   GLuint i;
-   ASSERT(lambda != NULL);
-   for (i = 0; i < n; i++) {
-      const struct gl_texture_image **images;
-      GLfloat newCoord[4];
-      GLint level = linear_mipmap_level(tObj, lambda[i]);
-      level = MAX2(level - 1, 0); /* see comment above */
-      images = choose_cube_face(tObj, texcoord[i], newCoord);
-      if (level >= tObj->_MaxLevel) {
-         sample_2d_linear(ctx, tObj, images[tObj->_MaxLevel],
-                          newCoord, rgba[i]);
-      }
-      else {
-         GLfloat t0[4], t1[4];
-         const GLfloat f = FRAC(lambda[i]);
-         sample_2d_linear(ctx, tObj, images[level  ], newCoord, t0);
-         sample_2d_linear(ctx, tObj, images[level+1], newCoord, t1);
-         lerp_rgba(rgba[i], f, t0, t1);
-      }
-   }
-}
-
-
-/** Sample cube texture, using lambda to choose between min/magnification */
-static void
-sample_lambda_cube(GLcontext *ctx,
-		   const struct gl_texture_object *tObj, GLuint n,
-		   const GLfloat texcoords[][4], const GLfloat lambda[],
-		   GLfloat rgba[][4])
-{
-   GLuint minStart, minEnd;  /* texels with minification */
-   GLuint magStart, magEnd;  /* texels with magnification */
-
-   ASSERT(lambda != NULL);
-   compute_min_mag_ranges(tObj, n, lambda,
-                          &minStart, &minEnd, &magStart, &magEnd);
-
-   if (minStart < minEnd) {
-      /* do the minified texels */
-      const GLuint m = minEnd - minStart;
-      switch (tObj->MinFilter) {
-      case GL_NEAREST:
-         sample_nearest_cube(ctx, tObj, m, texcoords + minStart,
-                             lambda + minStart, rgba + minStart);
-         break;
-      case GL_LINEAR:
-         sample_linear_cube(ctx, tObj, m, texcoords + minStart,
-                            lambda + minStart, rgba + minStart);
-         break;
-      case GL_NEAREST_MIPMAP_NEAREST:
-         sample_cube_nearest_mipmap_nearest(ctx, tObj, m,
-                                            texcoords + minStart,
-                                           lambda + minStart, rgba + minStart);
-         break;
-      case GL_LINEAR_MIPMAP_NEAREST:
-         sample_cube_linear_mipmap_nearest(ctx, tObj, m,
-                                           texcoords + minStart,
-                                           lambda + minStart, rgba + minStart);
-         break;
-      case GL_NEAREST_MIPMAP_LINEAR:
-         sample_cube_nearest_mipmap_linear(ctx, tObj, m,
-                                           texcoords + minStart,
-                                           lambda + minStart, rgba + minStart);
-         break;
-      case GL_LINEAR_MIPMAP_LINEAR:
-         sample_cube_linear_mipmap_linear(ctx, tObj, m,
-                                          texcoords + minStart,
-                                          lambda + minStart, rgba + minStart);
-         break;
-      default:
-         _mesa_problem(ctx, "Bad min filter in sample_lambda_cube");
-      }
-   }
-
-   if (magStart < magEnd) {
-      /* do the magnified texels */
-      const GLuint m = magEnd - magStart;
-      switch (tObj->MagFilter) {
-      case GL_NEAREST:
-         sample_nearest_cube(ctx, tObj, m, texcoords + magStart,
-                             lambda + magStart, rgba + magStart);
-         break;
-      case GL_LINEAR:
-         sample_linear_cube(ctx, tObj, m, texcoords + magStart,
-                            lambda + magStart, rgba + magStart);
-         break;
-      default:
-         _mesa_problem(ctx, "Bad mag filter in sample_lambda_cube");
-      }
-   }
-}
-
-
-/**********************************************************************/
-/*               Texture Rectangle Sampling Functions                 */
-/**********************************************************************/
-
-
-static void
-sample_nearest_rect(GLcontext *ctx,
-		    const struct gl_texture_object *tObj, GLuint n,
-                    const GLfloat texcoords[][4], const GLfloat lambda[],
-                    GLfloat rgba[][4])
-{
-   const struct gl_texture_image *img = tObj->Image[0][0];
-   const GLint width = img->Width;
-   const GLint height = img->Height;
-   GLuint i;
-
-   (void) ctx;
-   (void) lambda;
-
-   ASSERT(tObj->WrapS == GL_CLAMP ||
-          tObj->WrapS == GL_CLAMP_TO_EDGE ||
-          tObj->WrapS == GL_CLAMP_TO_BORDER);
-   ASSERT(tObj->WrapT == GL_CLAMP ||
-          tObj->WrapT == GL_CLAMP_TO_EDGE ||
-          tObj->WrapT == GL_CLAMP_TO_BORDER);
-   ASSERT(img->_BaseFormat != GL_COLOR_INDEX);
-
-   for (i = 0; i < n; i++) {
-      GLint row, col;
-      col = clamp_rect_coord_nearest(tObj->WrapS, texcoords[i][0], width);
-      row = clamp_rect_coord_nearest(tObj->WrapT, texcoords[i][1], height);
-      if (col < 0 || col >= width || row < 0 || row >= height)
-         get_border_color(tObj, img, rgba[i]);
-      else
-         img->FetchTexelf(img, col, row, 0, rgba[i]);
-   }
-}
-
-
-static void
-sample_linear_rect(GLcontext *ctx,
-		   const struct gl_texture_object *tObj, GLuint n,
-                   const GLfloat texcoords[][4],
-		   const GLfloat lambda[], GLfloat rgba[][4])
-{
-   const struct gl_texture_image *img = tObj->Image[0][0];
-   const GLint width = img->Width;
-   const GLint height = img->Height;
-   GLuint i;
-
-   (void) ctx;
-   (void) lambda;
-
-   ASSERT(tObj->WrapS == GL_CLAMP ||
-          tObj->WrapS == GL_CLAMP_TO_EDGE ||
-          tObj->WrapS == GL_CLAMP_TO_BORDER);
-   ASSERT(tObj->WrapT == GL_CLAMP ||
-          tObj->WrapT == GL_CLAMP_TO_EDGE ||
-          tObj->WrapT == GL_CLAMP_TO_BORDER);
-   ASSERT(img->_BaseFormat != GL_COLOR_INDEX);
-
-   for (i = 0; i < n; i++) {
-      GLint i0, j0, i1, j1;
-      GLfloat t00[4], t01[4], t10[4], t11[4];
-      GLfloat a, b;
-      GLbitfield useBorderColor = 0x0;
-
-      clamp_rect_coord_linear(tObj->WrapS, texcoords[i][0], width,
-                              &i0, &i1, &a);
-      clamp_rect_coord_linear(tObj->WrapT, texcoords[i][1], height,
-                              &j0, &j1, &b);
-
-      /* compute integer rows/columns */
-      if (i0 < 0 || i0 >= width)   useBorderColor |= I0BIT;
-      if (i1 < 0 || i1 >= width)   useBorderColor |= I1BIT;
-      if (j0 < 0 || j0 >= height)  useBorderColor |= J0BIT;
-      if (j1 < 0 || j1 >= height)  useBorderColor |= J1BIT;
-
-      /* get four texel samples */
-      if (useBorderColor & (I0BIT | J0BIT))
-         get_border_color(tObj, img, t00);
-      else
-         img->FetchTexelf(img, i0, j0, 0, t00);
-
-      if (useBorderColor & (I1BIT | J0BIT))
-         get_border_color(tObj, img, t10);
-      else
-         img->FetchTexelf(img, i1, j0, 0, t10);
-
-      if (useBorderColor & (I0BIT | J1BIT))
-         get_border_color(tObj, img, t01);
-      else
-         img->FetchTexelf(img, i0, j1, 0, t01);
-
-      if (useBorderColor & (I1BIT | J1BIT))
-         get_border_color(tObj, img, t11);
-      else
-         img->FetchTexelf(img, i1, j1, 0, t11);
-
-      lerp_rgba_2d(rgba[i], a, b, t00, t10, t01, t11);
-   }
-}
-
-
-/** Sample Rect texture, using lambda to choose between min/magnification */
-static void
-sample_lambda_rect(GLcontext *ctx,
-		   const struct gl_texture_object *tObj, GLuint n,
-		   const GLfloat texcoords[][4], const GLfloat lambda[],
-		   GLfloat rgba[][4])
-{
-   GLuint minStart, minEnd, magStart, magEnd;
-
-   /* We only need lambda to decide between minification and magnification.
-    * There is no mipmapping with rectangular textures.
-    */
-   compute_min_mag_ranges(tObj, n, lambda,
-                          &minStart, &minEnd, &magStart, &magEnd);
-
-   if (minStart < minEnd) {
-      if (tObj->MinFilter == GL_NEAREST) {
-         sample_nearest_rect(ctx, tObj, minEnd - minStart,
-                             texcoords + minStart, NULL, rgba + minStart);
-      }
-      else {
-         sample_linear_rect(ctx, tObj, minEnd - minStart,
-                            texcoords + minStart, NULL, rgba + minStart);
-      }
-   }
-   if (magStart < magEnd) {
-      if (tObj->MagFilter == GL_NEAREST) {
-         sample_nearest_rect(ctx, tObj, magEnd - magStart,
-                             texcoords + magStart, NULL, rgba + magStart);
-      }
-      else {
-         sample_linear_rect(ctx, tObj, magEnd - magStart,
-                            texcoords + magStart, NULL, rgba + magStart);
-      }
-   }
-}
-
-
-/**********************************************************************/
-/*                2D Texture Array Sampling Functions                 */
-/**********************************************************************/
-
-/**
- * Return the texture sample for coordinate (s,t,r) using GL_NEAREST filter.
- */
-static void
-sample_2d_array_nearest(GLcontext *ctx,
-                        const struct gl_texture_object *tObj,
-                        const struct gl_texture_image *img,
-                        const GLfloat texcoord[4],
-                        GLfloat rgba[4])
-{
-   const GLint width = img->Width2;     /* without border, power of two */
-   const GLint height = img->Height2;   /* without border, power of two */
-   const GLint depth = img->Depth;
-   GLint i, j;
-   GLint array;
-   (void) ctx;
-
-   i = nearest_texel_location(tObj->WrapS, img, width, texcoord[0]);
-   j = nearest_texel_location(tObj->WrapT, img, height, texcoord[1]);
-   array = tex_array_slice(texcoord[2], depth);
-
-   if (i < 0 || i >= (GLint) img->Width ||
-       j < 0 || j >= (GLint) img->Height ||
-       array < 0 || array >= (GLint) img->Depth) {
-      /* Need this test for GL_CLAMP_TO_BORDER mode */
-      get_border_color(tObj, img, rgba);
-   }
-   else {
-      img->FetchTexelf(img, i, j, array, rgba);
-   }
-}
-
-
-/**
- * Return the texture sample for coordinate (s,t,r) using GL_LINEAR filter.
- */
-static void
-sample_2d_array_linear(GLcontext *ctx,
-                       const struct gl_texture_object *tObj,
-                       const struct gl_texture_image *img,
-                       const GLfloat texcoord[4],
-                       GLfloat rgba[4])
-{
-   const GLint width = img->Width2;
-   const GLint height = img->Height2;
-   const GLint depth = img->Depth;
-   GLint i0, j0, i1, j1;
-   GLint array;
-   GLbitfield useBorderColor = 0x0;
-   GLfloat a, b;
-   GLfloat t00[4], t01[4], t10[4], t11[4];
-
-   linear_texel_locations(tObj->WrapS, img, width,  texcoord[0], &i0, &i1, &a);
-   linear_texel_locations(tObj->WrapT, img, height, texcoord[1], &j0, &j1, &b);
-   array = tex_array_slice(texcoord[2], depth);
-
-   if (array < 0 || array >= depth) {
-      COPY_4V(rgba, tObj->BorderColor.f);
-   }
-   else {
-      if (img->Border) {
-	 i0 += img->Border;
-	 i1 += img->Border;
-	 j0 += img->Border;
-	 j1 += img->Border;
-      }
-      else {
-	 /* check if sampling texture border color */
-	 if (i0 < 0 || i0 >= width)   useBorderColor |= I0BIT;
-	 if (i1 < 0 || i1 >= width)   useBorderColor |= I1BIT;
-	 if (j0 < 0 || j0 >= height)  useBorderColor |= J0BIT;
-	 if (j1 < 0 || j1 >= height)  useBorderColor |= J1BIT;
-      }
-
-      /* Fetch texels */
-      if (useBorderColor & (I0BIT | J0BIT)) {
-         get_border_color(tObj, img, t00);
-      }
-      else {
-	 img->FetchTexelf(img, i0, j0, array, t00);
-      }
-      if (useBorderColor & (I1BIT | J0BIT)) {
-         get_border_color(tObj, img, t10);
-      }
-      else {
-	 img->FetchTexelf(img, i1, j0, array, t10);
-      }
-      if (useBorderColor & (I0BIT | J1BIT)) {
-         get_border_color(tObj, img, t01);
-      }
-      else {
-	 img->FetchTexelf(img, i0, j1, array, t01);
-      }
-      if (useBorderColor & (I1BIT | J1BIT)) {
-         get_border_color(tObj, img, t11);
-      }
-      else {
-	 img->FetchTexelf(img, i1, j1, array, t11);
-      }
-      
-      /* trilinear interpolation of samples */
-      lerp_rgba_2d(rgba, a, b, t00, t10, t01, t11);
-   }
-}
-
-
-static void
-sample_2d_array_nearest_mipmap_nearest(GLcontext *ctx,
-                                       const struct gl_texture_object *tObj,
-                                       GLuint n, const GLfloat texcoord[][4],
-                                       const GLfloat lambda[], GLfloat rgba[][4])
-{
-   GLuint i;
-   for (i = 0; i < n; i++) {
-      GLint level = nearest_mipmap_level(tObj, lambda[i]);
-      sample_2d_array_nearest(ctx, tObj, tObj->Image[0][level], texcoord[i],
-                              rgba[i]);
-   }
-}
-
-
-static void
-sample_2d_array_linear_mipmap_nearest(GLcontext *ctx,
-                                      const struct gl_texture_object *tObj,
-                                      GLuint n, const GLfloat texcoord[][4],
-                                      const GLfloat lambda[], GLfloat rgba[][4])
-{
-   GLuint i;
-   ASSERT(lambda != NULL);
-   for (i = 0; i < n; i++) {
-      GLint level = nearest_mipmap_level(tObj, lambda[i]);
-      sample_2d_array_linear(ctx, tObj, tObj->Image[0][level],
-                             texcoord[i], rgba[i]);
-   }
-}
-
-
-static void
-sample_2d_array_nearest_mipmap_linear(GLcontext *ctx,
-                                      const struct gl_texture_object *tObj,
-                                      GLuint n, const GLfloat texcoord[][4],
-                                      const GLfloat lambda[], GLfloat rgba[][4])
-{
-   GLuint i;
-   ASSERT(lambda != NULL);
-   for (i = 0; i < n; i++) {
-      GLint level = linear_mipmap_level(tObj, lambda[i]);
-      if (level >= tObj->_MaxLevel) {
-         sample_2d_array_nearest(ctx, tObj, tObj->Image[0][tObj->_MaxLevel],
-                                 texcoord[i], rgba[i]);
-      }
-      else {
-         GLfloat t0[4], t1[4];  /* texels */
-         const GLfloat f = FRAC(lambda[i]);
-         sample_2d_array_nearest(ctx, tObj, tObj->Image[0][level  ],
-                                 texcoord[i], t0);
-         sample_2d_array_nearest(ctx, tObj, tObj->Image[0][level+1],
-                                 texcoord[i], t1);
-         lerp_rgba(rgba[i], f, t0, t1);
-      }
-   }
-}
-
-
-static void
-sample_2d_array_linear_mipmap_linear(GLcontext *ctx,
-                                     const struct gl_texture_object *tObj,
-                                     GLuint n, const GLfloat texcoord[][4],
-                                     const GLfloat lambda[], GLfloat rgba[][4])
-{
-   GLuint i;
-   ASSERT(lambda != NULL);
-   for (i = 0; i < n; i++) {
-      GLint level = linear_mipmap_level(tObj, lambda[i]);
-      if (level >= tObj->_MaxLevel) {
-         sample_2d_array_linear(ctx, tObj, tObj->Image[0][tObj->_MaxLevel],
-                          texcoord[i], rgba[i]);
-      }
-      else {
-         GLfloat t0[4], t1[4];  /* texels */
-         const GLfloat f = FRAC(lambda[i]);
-         sample_2d_array_linear(ctx, tObj, tObj->Image[0][level  ],
-                                texcoord[i], t0);
-         sample_2d_array_linear(ctx, tObj, tObj->Image[0][level+1],
-                                texcoord[i], t1);
-         lerp_rgba(rgba[i], f, t0, t1);
-      }
-   }
-}
-
-
-/** Sample 2D Array texture, nearest filtering for both min/magnification */
-static void
-sample_nearest_2d_array(GLcontext *ctx,
-                        const struct gl_texture_object *tObj, GLuint n,
-                        const GLfloat texcoords[][4], const GLfloat lambda[],
-                        GLfloat rgba[][4])
-{
-   GLuint i;
-   struct gl_texture_image *image = tObj->Image[0][tObj->BaseLevel];
-   (void) lambda;
-   for (i = 0; i < n; i++) {
-      sample_2d_array_nearest(ctx, tObj, image, texcoords[i], rgba[i]);
-   }
-}
-
-
-
-/** Sample 2D Array texture, linear filtering for both min/magnification */
-static void
-sample_linear_2d_array(GLcontext *ctx,
-                       const struct gl_texture_object *tObj, GLuint n,
-                       const GLfloat texcoords[][4],
-                       const GLfloat lambda[], GLfloat rgba[][4])
-{
-   GLuint i;
-   struct gl_texture_image *image = tObj->Image[0][tObj->BaseLevel];
-   (void) lambda;
-   for (i = 0; i < n; i++) {
-      sample_2d_array_linear(ctx, tObj, image, texcoords[i], rgba[i]);
-   }
-}
-
-
-/** Sample 2D Array texture, using lambda to choose between min/magnification */
-static void
-sample_lambda_2d_array(GLcontext *ctx,
-                       const struct gl_texture_object *tObj, GLuint n,
-                       const GLfloat texcoords[][4], const GLfloat lambda[],
-                       GLfloat rgba[][4])
-{
-   GLuint minStart, minEnd;  /* texels with minification */
-   GLuint magStart, magEnd;  /* texels with magnification */
-   GLuint i;
-
-   ASSERT(lambda != NULL);
-   compute_min_mag_ranges(tObj, n, lambda,
-                          &minStart, &minEnd, &magStart, &magEnd);
-
-   if (minStart < minEnd) {
-      /* do the minified texels */
-      GLuint m = minEnd - minStart;
-      switch (tObj->MinFilter) {
-      case GL_NEAREST:
-         for (i = minStart; i < minEnd; i++)
-            sample_2d_array_nearest(ctx, tObj, tObj->Image[0][tObj->BaseLevel],
-                                    texcoords[i], rgba[i]);
-         break;
-      case GL_LINEAR:
-         for (i = minStart; i < minEnd; i++)
-            sample_2d_array_linear(ctx, tObj, tObj->Image[0][tObj->BaseLevel],
-                                   texcoords[i], rgba[i]);
-         break;
-      case GL_NEAREST_MIPMAP_NEAREST:
-         sample_2d_array_nearest_mipmap_nearest(ctx, tObj, m,
-                                                texcoords + minStart,
-                                                lambda + minStart,
-                                                rgba + minStart);
-         break;
-      case GL_LINEAR_MIPMAP_NEAREST:
-         sample_2d_array_linear_mipmap_nearest(ctx, tObj, m, 
-                                               texcoords + minStart,
-                                               lambda + minStart,
-                                               rgba + minStart);
-         break;
-      case GL_NEAREST_MIPMAP_LINEAR:
-         sample_2d_array_nearest_mipmap_linear(ctx, tObj, m,
-                                               texcoords + minStart,
-                                               lambda + minStart,
-                                               rgba + minStart);
-         break;
-      case GL_LINEAR_MIPMAP_LINEAR:
-         sample_2d_array_linear_mipmap_linear(ctx, tObj, m, 
-                                              texcoords + minStart,
-                                              lambda + minStart, 
-                                              rgba + minStart);
-         break;
-      default:
-         _mesa_problem(ctx, "Bad min filter in sample_2d_array_texture");
-         return;
-      }
-   }
-
-   if (magStart < magEnd) {
-      /* do the magnified texels */
-      switch (tObj->MagFilter) {
-      case GL_NEAREST:
-         for (i = magStart; i < magEnd; i++)
-            sample_2d_array_nearest(ctx, tObj, tObj->Image[0][tObj->BaseLevel],
-                              texcoords[i], rgba[i]);
-         break;
-      case GL_LINEAR:
-         for (i = magStart; i < magEnd; i++)
-            sample_2d_array_linear(ctx, tObj, tObj->Image[0][tObj->BaseLevel],
-                                   texcoords[i], rgba[i]);
-         break;
-      default:
-         _mesa_problem(ctx, "Bad mag filter in sample_2d_array_texture");
-         return;
-      }
-   }
-}
-
-
-
-
-/**********************************************************************/
-/*                1D Texture Array Sampling Functions                 */
-/**********************************************************************/
-
-/**
- * Return the texture sample for coordinate (s,t,r) using GL_NEAREST filter.
- */
-static void
-sample_1d_array_nearest(GLcontext *ctx,
-                        const struct gl_texture_object *tObj,
-                        const struct gl_texture_image *img,
-                        const GLfloat texcoord[4],
-                        GLfloat rgba[4])
-{
-   const GLint width = img->Width2;     /* without border, power of two */
-   const GLint height = img->Height;
-   GLint i;
-   GLint array;
-   (void) ctx;
-
-   i = nearest_texel_location(tObj->WrapS, img, width, texcoord[0]);
-   array = tex_array_slice(texcoord[1], height);
-
-   if (i < 0 || i >= (GLint) img->Width ||
-       array < 0 || array >= (GLint) img->Height) {
-      /* Need this test for GL_CLAMP_TO_BORDER mode */
-      get_border_color(tObj, img, rgba);
-   }
-   else {
-      img->FetchTexelf(img, i, array, 0, rgba);
-   }
-}
-
-
-/**
- * Return the texture sample for coordinate (s,t,r) using GL_LINEAR filter.
- */
-static void
-sample_1d_array_linear(GLcontext *ctx,
-                       const struct gl_texture_object *tObj,
-                       const struct gl_texture_image *img,
-                       const GLfloat texcoord[4],
-                       GLfloat rgba[4])
-{
-   const GLint width = img->Width2;
-   const GLint height = img->Height;
-   GLint i0, i1;
-   GLint array;
-   GLbitfield useBorderColor = 0x0;
-   GLfloat a;
-   GLfloat t0[4], t1[4];
-
-   linear_texel_locations(tObj->WrapS, img, width, texcoord[0], &i0, &i1, &a);
-   array = tex_array_slice(texcoord[1], height);
-
-   if (img->Border) {
-      i0 += img->Border;
-      i1 += img->Border;
-   }
-   else {
-      /* check if sampling texture border color */
-      if (i0 < 0 || i0 >= width)   useBorderColor |= I0BIT;
-      if (i1 < 0 || i1 >= width)   useBorderColor |= I1BIT;
-   }
-
-   if (array < 0 || array >= height)   useBorderColor |= K0BIT;
-
-   /* Fetch texels */
-   if (useBorderColor & (I0BIT | K0BIT)) {
-      get_border_color(tObj, img, t0);
-   }
-   else {
-      img->FetchTexelf(img, i0, array, 0, t0);
-   }
-   if (useBorderColor & (I1BIT | K0BIT)) {
-      get_border_color(tObj, img, t1);
-   }
-   else {
-      img->FetchTexelf(img, i1, array, 0, t1);
-   }
-
-   /* bilinear interpolation of samples */
-   lerp_rgba(rgba, a, t0, t1);
-}
-
-
-static void
-sample_1d_array_nearest_mipmap_nearest(GLcontext *ctx,
-                                       const struct gl_texture_object *tObj,
-                                       GLuint n, const GLfloat texcoord[][4],
-                                       const GLfloat lambda[], GLfloat rgba[][4])
-{
-   GLuint i;
-   for (i = 0; i < n; i++) {
-      GLint level = nearest_mipmap_level(tObj, lambda[i]);
-      sample_1d_array_nearest(ctx, tObj, tObj->Image[0][level], texcoord[i],
-                              rgba[i]);
-   }
-}
-
-
-static void
-sample_1d_array_linear_mipmap_nearest(GLcontext *ctx,
-                                      const struct gl_texture_object *tObj,
-                                      GLuint n, const GLfloat texcoord[][4],
-                                      const GLfloat lambda[], GLfloat rgba[][4])
-{
-   GLuint i;
-   ASSERT(lambda != NULL);
-   for (i = 0; i < n; i++) {
-      GLint level = nearest_mipmap_level(tObj, lambda[i]);
-      sample_1d_array_linear(ctx, tObj, tObj->Image[0][level],
-                             texcoord[i], rgba[i]);
-   }
-}
-
-
-static void
-sample_1d_array_nearest_mipmap_linear(GLcontext *ctx,
-                                      const struct gl_texture_object *tObj,
-                                      GLuint n, const GLfloat texcoord[][4],
-                                      const GLfloat lambda[], GLfloat rgba[][4])
-{
-   GLuint i;
-   ASSERT(lambda != NULL);
-   for (i = 0; i < n; i++) {
-      GLint level = linear_mipmap_level(tObj, lambda[i]);
-      if (level >= tObj->_MaxLevel) {
-         sample_1d_array_nearest(ctx, tObj, tObj->Image[0][tObj->_MaxLevel],
-                                 texcoord[i], rgba[i]);
-      }
-      else {
-         GLfloat t0[4], t1[4];  /* texels */
-         const GLfloat f = FRAC(lambda[i]);
-         sample_1d_array_nearest(ctx, tObj, tObj->Image[0][level  ], texcoord[i], t0);
-         sample_1d_array_nearest(ctx, tObj, tObj->Image[0][level+1], texcoord[i], t1);
-         lerp_rgba(rgba[i], f, t0, t1);
-      }
-   }
-}
-
-
-static void
-sample_1d_array_linear_mipmap_linear(GLcontext *ctx,
-                                     const struct gl_texture_object *tObj,
-                                     GLuint n, const GLfloat texcoord[][4],
-                                     const GLfloat lambda[], GLfloat rgba[][4])
-{
-   GLuint i;
-   ASSERT(lambda != NULL);
-   for (i = 0; i < n; i++) {
-      GLint level = linear_mipmap_level(tObj, lambda[i]);
-      if (level >= tObj->_MaxLevel) {
-         sample_1d_array_linear(ctx, tObj, tObj->Image[0][tObj->_MaxLevel],
-                          texcoord[i], rgba[i]);
-      }
-      else {
-         GLfloat t0[4], t1[4];  /* texels */
-         const GLfloat f = FRAC(lambda[i]);
-         sample_1d_array_linear(ctx, tObj, tObj->Image[0][level  ], texcoord[i], t0);
-         sample_1d_array_linear(ctx, tObj, tObj->Image[0][level+1], texcoord[i], t1);
-         lerp_rgba(rgba[i], f, t0, t1);
-      }
-   }
-}
-
-
-/** Sample 1D Array texture, nearest filtering for both min/magnification */
-static void
-sample_nearest_1d_array(GLcontext *ctx,
-                        const struct gl_texture_object *tObj, GLuint n,
-                        const GLfloat texcoords[][4], const GLfloat lambda[],
-                        GLfloat rgba[][4])
-{
-   GLuint i;
-   struct gl_texture_image *image = tObj->Image[0][tObj->BaseLevel];
-   (void) lambda;
-   for (i = 0; i < n; i++) {
-      sample_1d_array_nearest(ctx, tObj, image, texcoords[i], rgba[i]);
-   }
-}
-
-
-/** Sample 1D Array texture, linear filtering for both min/magnification */
-static void
-sample_linear_1d_array(GLcontext *ctx,
-                       const struct gl_texture_object *tObj, GLuint n,
-                       const GLfloat texcoords[][4],
-                       const GLfloat lambda[], GLfloat rgba[][4])
-{
-   GLuint i;
-   struct gl_texture_image *image = tObj->Image[0][tObj->BaseLevel];
-   (void) lambda;
-   for (i = 0; i < n; i++) {
-      sample_1d_array_linear(ctx, tObj, image, texcoords[i], rgba[i]);
-   }
-}
-
-
-/** Sample 1D Array texture, using lambda to choose between min/magnification */
-static void
-sample_lambda_1d_array(GLcontext *ctx,
-                       const struct gl_texture_object *tObj, GLuint n,
-                       const GLfloat texcoords[][4], const GLfloat lambda[],
-                       GLfloat rgba[][4])
-{
-   GLuint minStart, minEnd;  /* texels with minification */
-   GLuint magStart, magEnd;  /* texels with magnification */
-   GLuint i;
-
-   ASSERT(lambda != NULL);
-   compute_min_mag_ranges(tObj, n, lambda,
-                          &minStart, &minEnd, &magStart, &magEnd);
-
-   if (minStart < minEnd) {
-      /* do the minified texels */
-      GLuint m = minEnd - minStart;
-      switch (tObj->MinFilter) {
-      case GL_NEAREST:
-         for (i = minStart; i < minEnd; i++)
-            sample_1d_array_nearest(ctx, tObj, tObj->Image[0][tObj->BaseLevel],
-                                    texcoords[i], rgba[i]);
-         break;
-      case GL_LINEAR:
-         for (i = minStart; i < minEnd; i++)
-            sample_1d_array_linear(ctx, tObj, tObj->Image[0][tObj->BaseLevel],
-                                   texcoords[i], rgba[i]);
-         break;
-      case GL_NEAREST_MIPMAP_NEAREST:
-         sample_1d_array_nearest_mipmap_nearest(ctx, tObj, m, texcoords + minStart,
-                                                lambda + minStart, rgba + minStart);
-         break;
-      case GL_LINEAR_MIPMAP_NEAREST:
-         sample_1d_array_linear_mipmap_nearest(ctx, tObj, m, 
-                                               texcoords + minStart,
-                                               lambda + minStart,
-                                               rgba + minStart);
-         break;
-      case GL_NEAREST_MIPMAP_LINEAR:
-         sample_1d_array_nearest_mipmap_linear(ctx, tObj, m, texcoords + minStart,
-                                               lambda + minStart, rgba + minStart);
-         break;
-      case GL_LINEAR_MIPMAP_LINEAR:
-         sample_1d_array_linear_mipmap_linear(ctx, tObj, m, 
-                                              texcoords + minStart,
-                                              lambda + minStart, 
-                                              rgba + minStart);
-         break;
-      default:
-         _mesa_problem(ctx, "Bad min filter in sample_1d_array_texture");
-         return;
-      }
-   }
-
-   if (magStart < magEnd) {
-      /* do the magnified texels */
-      switch (tObj->MagFilter) {
-      case GL_NEAREST:
-         for (i = magStart; i < magEnd; i++)
-            sample_1d_array_nearest(ctx, tObj, tObj->Image[0][tObj->BaseLevel],
-                              texcoords[i], rgba[i]);
-         break;
-      case GL_LINEAR:
-         for (i = magStart; i < magEnd; i++)
-            sample_1d_array_linear(ctx, tObj, tObj->Image[0][tObj->BaseLevel],
-                                   texcoords[i], rgba[i]);
-         break;
-      default:
-         _mesa_problem(ctx, "Bad mag filter in sample_1d_array_texture");
-         return;
-      }
-   }
-}
-
-
-/**
- * Compare texcoord against depth sample.  Return 1.0 or the ambient value.
- */
-static INLINE GLfloat
-shadow_compare(GLenum function, GLfloat coord, GLfloat depthSample,
-               GLfloat ambient)
-{
-   switch (function) {
-   case GL_LEQUAL:
-      return (coord <= depthSample) ? 1.0F : ambient;
-   case GL_GEQUAL:
-      return (coord >= depthSample) ? 1.0F : ambient;
-   case GL_LESS:
-      return (coord < depthSample) ? 1.0F : ambient;
-   case GL_GREATER:
-      return (coord > depthSample) ? 1.0F : ambient;
-   case GL_EQUAL:
-      return (coord == depthSample) ? 1.0F : ambient;
-   case GL_NOTEQUAL:
-      return (coord != depthSample) ? 1.0F : ambient;
-   case GL_ALWAYS:
-      return 1.0F;
-   case GL_NEVER:
-      return ambient;
-   case GL_NONE:
-      return depthSample;
-   default:
-      _mesa_problem(NULL, "Bad compare func in shadow_compare");
-      return ambient;
-   }
-}
-
-
-/**
- * Compare texcoord against four depth samples.
- */
-static INLINE GLfloat
-shadow_compare4(GLenum function, GLfloat coord,
-                GLfloat depth00, GLfloat depth01,
-                GLfloat depth10, GLfloat depth11,
-                GLfloat ambient, GLfloat wi, GLfloat wj)
-{
-   const GLfloat d = (1.0F - (GLfloat) ambient) * 0.25F;
-   GLfloat luminance = 1.0F;
-
-   switch (function) {
-   case GL_LEQUAL:
-      if (depth00 <= coord)  luminance -= d;
-      if (depth01 <= coord)  luminance -= d;
-      if (depth10 <= coord)  luminance -= d;
-      if (depth11 <= coord)  luminance -= d;
-      return luminance;
-   case GL_GEQUAL:
-      if (depth00 >= coord)  luminance -= d;
-      if (depth01 >= coord)  luminance -= d;
-      if (depth10 >= coord)  luminance -= d;
-      if (depth11 >= coord)  luminance -= d;
-      return luminance;
-   case GL_LESS:
-      if (depth00 < coord)  luminance -= d;
-      if (depth01 < coord)  luminance -= d;
-      if (depth10 < coord)  luminance -= d;
-      if (depth11 < coord)  luminance -= d;
-      return luminance;
-   case GL_GREATER:
-      if (depth00 > coord)  luminance -= d;
-      if (depth01 > coord)  luminance -= d;
-      if (depth10 > coord)  luminance -= d;
-      if (depth11 > coord)  luminance -= d;
-      return luminance;
-   case GL_EQUAL:
-      if (depth00 == coord)  luminance -= d;
-      if (depth01 == coord)  luminance -= d;
-      if (depth10 == coord)  luminance -= d;
-      if (depth11 == coord)  luminance -= d;
-      return luminance;
-   case GL_NOTEQUAL:
-      if (depth00 != coord)  luminance -= d;
-      if (depth01 != coord)  luminance -= d;
-      if (depth10 != coord)  luminance -= d;
-      if (depth11 != coord)  luminance -= d;
-      return luminance;
-   case GL_ALWAYS:
-      return 0.0;
-   case GL_NEVER:
-      return ambient;
-   case GL_NONE:
-      /* ordinary bilinear filtering */
-      return lerp_2d(wi, wj, depth00, depth10, depth01, depth11);
-   default:
-      _mesa_problem(NULL, "Bad compare func in sample_depth_texture");
-      return 0.0F;
-   }
-}
-
-
-/**
- * Choose the mipmap level to use when sampling from a depth texture.
- */
-static int
-choose_depth_texture_level(const struct gl_texture_object *tObj, GLfloat lambda)
-{
-   GLint level;
-
-   lambda = CLAMP(lambda, tObj->MinLod, tObj->MaxLod);
-
-   level = (GLint) lambda;
-
-   level = CLAMP(level, tObj->BaseLevel, tObj->_MaxLevel);
-
-   return level;
-}
-
-
-/**
- * Sample a shadow/depth texture.  This function is incomplete.  It doesn't
- * check for minification vs. magnification, etc.
- */
-static void
-sample_depth_texture( GLcontext *ctx,
-                      const struct gl_texture_object *tObj, GLuint n,
-                      const GLfloat texcoords[][4], const GLfloat lambda[],
-                      GLfloat texel[][4] )
-{
-   const GLint level = choose_depth_texture_level(tObj, lambda[0]);
-   const struct gl_texture_image *img = tObj->Image[0][level];
-   const GLint width = img->Width;
-   const GLint height = img->Height;
-   const GLint depth = img->Depth;
-   const GLuint compare_coord = (tObj->Target == GL_TEXTURE_2D_ARRAY_EXT)
-       ? 3 : 2;
-   GLfloat ambient;
-   GLenum function;
-   GLfloat result;
-
-   ASSERT(img->_BaseFormat == GL_DEPTH_COMPONENT ||
-          img->_BaseFormat == GL_DEPTH_STENCIL_EXT);
-
-   ASSERT(tObj->Target == GL_TEXTURE_1D ||
-          tObj->Target == GL_TEXTURE_2D ||
-          tObj->Target == GL_TEXTURE_RECTANGLE_NV ||
-          tObj->Target == GL_TEXTURE_1D_ARRAY_EXT ||
-          tObj->Target == GL_TEXTURE_2D_ARRAY_EXT);
-
-   ambient = tObj->CompareFailValue;
-
-   /* XXXX if tObj->MinFilter != tObj->MagFilter, we're ignoring lambda */
-
-   function = (tObj->CompareMode == GL_COMPARE_R_TO_TEXTURE_ARB) ?
-      tObj->CompareFunc : GL_NONE;
-
-   if (tObj->MagFilter == GL_NEAREST) {
-      GLuint i;
-      for (i = 0; i < n; i++) {
-         GLfloat depthSample;
-         GLint col, row, slice;
-
-         nearest_texcoord(tObj, level, texcoords[i], &col, &row, &slice);
-
-         if (col >= 0 && row >= 0 && col < width && row < height && 
-             slice >= 0 && slice < depth) {
-            img->FetchTexelf(img, col, row, slice, &depthSample);
-         }
-         else {
-            depthSample = tObj->BorderColor.f[0];
-         }
-
-         result = shadow_compare(function, texcoords[i][compare_coord],
-                                 depthSample, ambient);
-
-         switch (tObj->DepthMode) {
-         case GL_LUMINANCE:
-            ASSIGN_4V(texel[i], result, result, result, 1.0F);
-            break;
-         case GL_INTENSITY:
-            ASSIGN_4V(texel[i], result, result, result, result);
-            break;
-         case GL_ALPHA:
-            ASSIGN_4V(texel[i], 0.0F, 0.0F, 0.0F, result);
-            break;
-         default:
-            _mesa_problem(ctx, "Bad depth texture mode");
-         }
-      }
-   }
-   else {
-      GLuint i;
-      ASSERT(tObj->MagFilter == GL_LINEAR);
-      for (i = 0; i < n; i++) {
-         GLfloat depth00, depth01, depth10, depth11;
-         GLint i0, i1, j0, j1;
-         GLint slice;
-         GLfloat wi, wj;
-         GLuint useBorderTexel;
-
-         linear_texcoord(tObj, level, texcoords[i], &i0, &i1, &j0, &j1, &slice,
-                         &wi, &wj);
-
-         useBorderTexel = 0;
-         if (img->Border) {
-            i0 += img->Border;
-            i1 += img->Border;
-            if (tObj->Target != GL_TEXTURE_1D_ARRAY_EXT) {
-               j0 += img->Border;
-               j1 += img->Border;
-            }
-         }
-         else {
-            if (i0 < 0 || i0 >= (GLint) width)   useBorderTexel |= I0BIT;
-            if (i1 < 0 || i1 >= (GLint) width)   useBorderTexel |= I1BIT;
-            if (j0 < 0 || j0 >= (GLint) height)  useBorderTexel |= J0BIT;
-            if (j1 < 0 || j1 >= (GLint) height)  useBorderTexel |= J1BIT;
-         }
-
-         if (slice < 0 || slice >= (GLint) depth) {
-            depth00 = tObj->BorderColor.f[0];
-            depth01 = tObj->BorderColor.f[0];
-            depth10 = tObj->BorderColor.f[0];
-            depth11 = tObj->BorderColor.f[0];
-         }
-         else {
-            /* get four depth samples from the texture */
-            if (useBorderTexel & (I0BIT | J0BIT)) {
-               depth00 = tObj->BorderColor.f[0];
-            }
-            else {
-               img->FetchTexelf(img, i0, j0, slice, &depth00);
-            }
-            if (useBorderTexel & (I1BIT | J0BIT)) {
-               depth10 = tObj->BorderColor.f[0];
-            }
-            else {
-               img->FetchTexelf(img, i1, j0, slice, &depth10);
-            }
-
-            if (tObj->Target != GL_TEXTURE_1D_ARRAY_EXT) {
-               if (useBorderTexel & (I0BIT | J1BIT)) {
-                  depth01 = tObj->BorderColor.f[0];
-               }
-               else {
-                  img->FetchTexelf(img, i0, j1, slice, &depth01);
-               }
-               if (useBorderTexel & (I1BIT | J1BIT)) {
-                  depth11 = tObj->BorderColor.f[0];
-               }
-               else {
-                  img->FetchTexelf(img, i1, j1, slice, &depth11);
-               }
-            }
-            else {
-               depth01 = depth00;
-               depth11 = depth10;
-            }
-         }
-
-         result = shadow_compare4(function, texcoords[i][compare_coord],
-                                  depth00, depth01, depth10, depth11,
-                                  ambient, wi, wj);
-
-         switch (tObj->DepthMode) {
-         case GL_LUMINANCE:
-            ASSIGN_4V(texel[i], result, result, result, 1.0F);
-            break;
-         case GL_INTENSITY:
-            ASSIGN_4V(texel[i], result, result, result, result);
-            break;
-         case GL_ALPHA:
-            ASSIGN_4V(texel[i], 0.0F, 0.0F, 0.0F, result);
-            break;
-         default:
-            _mesa_problem(ctx, "Bad depth texture mode");
-         }
-
-      }  /* for */
-   }  /* if filter */
-}
-
-
-/**
- * We use this function when a texture object is in an "incomplete" state.
- * When a fragment program attempts to sample an incomplete texture we
- * return black (see issue 23 in GL_ARB_fragment_program spec).
- * Note: fragment programs don't observe the texture enable/disable flags.
- */
-static void
-null_sample_func( GLcontext *ctx,
-		  const struct gl_texture_object *tObj, GLuint n,
-		  const GLfloat texcoords[][4], const GLfloat lambda[],
-		  GLfloat rgba[][4])
-{
-   GLuint i;
-   (void) ctx;
-   (void) tObj;
-   (void) texcoords;
-   (void) lambda;
-   for (i = 0; i < n; i++) {
-      rgba[i][RCOMP] = 0;
-      rgba[i][GCOMP] = 0;
-      rgba[i][BCOMP] = 0;
-      rgba[i][ACOMP] = 1.0;
-   }
-}
-
-
-/**
- * Choose the texture sampling function for the given texture object.
- */
-texture_sample_func
-_swrast_choose_texture_sample_func( GLcontext *ctx,
-				    const struct gl_texture_object *t )
-{
-   if (!t || !t->_Complete) {
-      return &null_sample_func;
-   }
-   else {
-      const GLboolean needLambda = (GLboolean) (t->MinFilter != t->MagFilter);
-      const GLenum format = t->Image[0][t->BaseLevel]->_BaseFormat;
-
-      switch (t->Target) {
-      case GL_TEXTURE_1D:
-         if (format == GL_DEPTH_COMPONENT || format == GL_DEPTH_STENCIL_EXT) {
-            return &sample_depth_texture;
-         }
-         else if (needLambda) {
-            return &sample_lambda_1d;
-         }
-         else if (t->MinFilter == GL_LINEAR) {
-            return &sample_linear_1d;
-         }
-         else {
-            ASSERT(t->MinFilter == GL_NEAREST);
-            return &sample_nearest_1d;
-         }
-      case GL_TEXTURE_2D:
-         if (format == GL_DEPTH_COMPONENT || format == GL_DEPTH_STENCIL_EXT) {
-            return &sample_depth_texture;
-         }
-         else if (needLambda) {
-            return &sample_lambda_2d;
-         }
-         else if (t->MinFilter == GL_LINEAR) {
-            return &sample_linear_2d;
-         }
-         else {
-            /* check for a few optimized cases */
-            const struct gl_texture_image *img = t->Image[0][t->BaseLevel];
-            ASSERT(t->MinFilter == GL_NEAREST);
-            if (t->WrapS == GL_REPEAT &&
-                t->WrapT == GL_REPEAT &&
-                img->_IsPowerOfTwo &&
-                img->Border == 0 &&
-                img->TexFormat == MESA_FORMAT_RGB888) {
-               return &opt_sample_rgb_2d;
-            }
-            else if (t->WrapS == GL_REPEAT &&
-                     t->WrapT == GL_REPEAT &&
-                     img->_IsPowerOfTwo &&
-                     img->Border == 0 &&
-                     img->TexFormat == MESA_FORMAT_RGBA8888) {
-               return &opt_sample_rgba_2d;
-            }
-            else {
-               return &sample_nearest_2d;
-            }
-         }
-      case GL_TEXTURE_3D:
-         if (needLambda) {
-            return &sample_lambda_3d;
-         }
-         else if (t->MinFilter == GL_LINEAR) {
-            return &sample_linear_3d;
-         }
-         else {
-            ASSERT(t->MinFilter == GL_NEAREST);
-            return &sample_nearest_3d;
-         }
-      case GL_TEXTURE_CUBE_MAP:
-         if (needLambda) {
-            return &sample_lambda_cube;
-         }
-         else if (t->MinFilter == GL_LINEAR) {
-            return &sample_linear_cube;
-         }
-         else {
-            ASSERT(t->MinFilter == GL_NEAREST);
-            return &sample_nearest_cube;
-         }
-      case GL_TEXTURE_RECTANGLE_NV:
-         if (format == GL_DEPTH_COMPONENT || format == GL_DEPTH_STENCIL_EXT) {
-            return &sample_depth_texture;
-         }
-         else if (needLambda) {
-            return &sample_lambda_rect;
-         }
-         else if (t->MinFilter == GL_LINEAR) {
-            return &sample_linear_rect;
-         }
-         else {
-            ASSERT(t->MinFilter == GL_NEAREST);
-            return &sample_nearest_rect;
-         }
-      case GL_TEXTURE_1D_ARRAY_EXT:
-         if (needLambda) {
-            return &sample_lambda_1d_array;
-         }
-         else if (t->MinFilter == GL_LINEAR) {
-            return &sample_linear_1d_array;
-         }
-         else {
-            ASSERT(t->MinFilter == GL_NEAREST);
-            return &sample_nearest_1d_array;
-         }
-      case GL_TEXTURE_2D_ARRAY_EXT:
-         if (needLambda) {
-            return &sample_lambda_2d_array;
-         }
-         else if (t->MinFilter == GL_LINEAR) {
-            return &sample_linear_2d_array;
-         }
-         else {
-            ASSERT(t->MinFilter == GL_NEAREST);
-            return &sample_nearest_2d_array;
-         }
-      default:
-         _mesa_problem(ctx,
-                       "invalid target in _swrast_choose_texture_sample_func");
-         return &null_sample_func;
-      }
-   }
-}
+/*

+ * Mesa 3-D graphics library

+ * Version:  7.3

+ *

+ * Copyright (C) 1999-2008  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/context.h"

+#include "main/colormac.h"

+#include "main/imports.h"

+#include "main/texformat.h"

+

+#include "s_context.h"

+#include "s_texfilter.h"

+

+

+/*

+ * Note, the FRAC macro has to work perfectly.  Otherwise you'll sometimes

+ * see 1-pixel bands of improperly weighted linear-filtered textures.

+ * The tests/texwrap.c demo is a good test.

+ * Also note, FRAC(x) doesn't truly return the fractional part of x for x < 0.

+ * Instead, if x < 0 then FRAC(x) = 1 - true_frac(x).

+ */

+#define FRAC(f)  ((f) - IFLOOR(f))

+

+

+

+/**

+ * Linear interpolation macro

+ */

+#define LERP(T, A, B)  ( (A) + (T) * ((B) - (A)) )

+

+

+/**

+ * Do 2D/biliner interpolation of float values.

+ * v00, v10, v01 and v11 are typically four texture samples in a square/box.

+ * a and b are the horizontal and vertical interpolants.

+ * It's important that this function is inlined when compiled with

+ * optimization!  If we find that's not true on some systems, convert

+ * to a macro.

+ */

+static INLINE GLfloat

+lerp_2d(GLfloat a, GLfloat b,

+        GLfloat v00, GLfloat v10, GLfloat v01, GLfloat v11)

+{

+   const GLfloat temp0 = LERP(a, v00, v10);

+   const GLfloat temp1 = LERP(a, v01, v11);

+   return LERP(b, temp0, temp1);

+}

+

+

+/**

+ * Do 3D/trilinear interpolation of float values.

+ * \sa lerp_2d

+ */

+static INLINE GLfloat

+lerp_3d(GLfloat a, GLfloat b, GLfloat c,

+        GLfloat v000, GLfloat v100, GLfloat v010, GLfloat v110,

+        GLfloat v001, GLfloat v101, GLfloat v011, GLfloat v111)

+{

+   const GLfloat temp00 = LERP(a, v000, v100);

+   const GLfloat temp10 = LERP(a, v010, v110);

+   const GLfloat temp01 = LERP(a, v001, v101);

+   const GLfloat temp11 = LERP(a, v011, v111);

+   const GLfloat temp0 = LERP(b, temp00, temp10);

+   const GLfloat temp1 = LERP(b, temp01, temp11);

+   return LERP(c, temp0, temp1);

+}

+

+

+/**

+ * Do linear interpolation of colors.

+ */

+static INLINE void

+lerp_rgba(GLfloat result[4], GLfloat t, const GLfloat a[4], const GLfloat b[4])

+{

+   result[0] = LERP(t, a[0], b[0]);

+   result[1] = LERP(t, a[1], b[1]);

+   result[2] = LERP(t, a[2], b[2]);

+   result[3] = LERP(t, a[3], b[3]);

+}

+

+

+/**

+ * Do bilinear interpolation of colors.

+ */

+static INLINE void

+lerp_rgba_2d(GLfloat result[4], GLfloat a, GLfloat b,

+             const GLfloat t00[4], const GLfloat t10[4],

+             const GLfloat t01[4], const GLfloat t11[4])

+{

+   result[0] = lerp_2d(a, b, t00[0], t10[0], t01[0], t11[0]);

+   result[1] = lerp_2d(a, b, t00[1], t10[1], t01[1], t11[1]);

+   result[2] = lerp_2d(a, b, t00[2], t10[2], t01[2], t11[2]);

+   result[3] = lerp_2d(a, b, t00[3], t10[3], t01[3], t11[3]);

+}

+

+

+/**

+ * Do trilinear interpolation of colors.

+ */

+static INLINE void

+lerp_rgba_3d(GLfloat result[4], GLfloat a, GLfloat b, GLfloat c,

+             const GLfloat t000[4], const GLfloat t100[4],

+             const GLfloat t010[4], const GLfloat t110[4],

+             const GLfloat t001[4], const GLfloat t101[4],

+             const GLfloat t011[4], const GLfloat t111[4])

+{

+   GLuint k;

+   /* compiler should unroll these short loops */

+   for (k = 0; k < 4; k++) {

+      result[k] = lerp_3d(a, b, c, t000[k], t100[k], t010[k], t110[k],

+                                   t001[k], t101[k], t011[k], t111[k]);

+   }

+}

+

+

+/**

+ * Used for GL_REPEAT wrap mode.  Using A % B doesn't produce the

+ * right results for A<0.  Casting to A to be unsigned only works if B

+ * is a power of two.  Adding a bias to A (which is a multiple of B)

+ * avoids the problems with A < 0 (for reasonable A) without using a

+ * conditional.

+ */

+#define REMAINDER(A, B) (((A) + (B) * 1024) % (B))

+

+

+/**

+ * Used to compute texel locations for linear sampling.

+ * Input:

+ *    wrapMode = GL_REPEAT, GL_CLAMP, GL_CLAMP_TO_EDGE, GL_CLAMP_TO_BORDER

+ *    s = texcoord in [0,1]

+ *    size = width (or height or depth) of texture

+ * Output:

+ *    i0, i1 = returns two nearest texel indexes

+ *    weight = returns blend factor between texels

+ */

+static INLINE void

+linear_texel_locations(GLenum wrapMode,

+                       const struct gl_texture_image *img,

+                       GLint size, GLfloat s,

+                       GLint *i0, GLint *i1, GLfloat *weight)

+{

+   GLfloat u;

+   switch (wrapMode) {

+   case GL_REPEAT:

+      u = s * size - 0.5F;

+      if (img->_IsPowerOfTwo) {

+         *i0 = IFLOOR(u) & (size - 1);

+         *i1 = (*i0 + 1) & (size - 1);

+      }

+      else {

+         *i0 = REMAINDER(IFLOOR(u), size);

+         *i1 = REMAINDER(*i0 + 1, size);

+      }

+      break;

+   case GL_CLAMP_TO_EDGE:

+      if (s <= 0.0F)

+         u = 0.0F;

+      else if (s >= 1.0F)

+         u = (GLfloat) size;

+      else

+         u = s * size;

+      u -= 0.5F;

+      *i0 = IFLOOR(u);

+      *i1 = *i0 + 1;

+      if (*i0 < 0)

+         *i0 = 0;

+      if (*i1 >= (GLint) size)

+         *i1 = size - 1;

+      break;

+   case GL_CLAMP_TO_BORDER:

+      {

+         const GLfloat min = -1.0F / (2.0F * size);

+         const GLfloat max = 1.0F - min;

+         if (s <= min)

+            u = min * size;

+         else if (s >= max)

+            u = max * size;

+         else

+            u = s * size;

+         u -= 0.5F;

+         *i0 = IFLOOR(u);

+         *i1 = *i0 + 1;

+      }

+      break;

+   case GL_MIRRORED_REPEAT:

+      {

+         const GLint flr = IFLOOR(s);

+         if (flr & 1)

+            u = 1.0F - (s - (GLfloat) flr);

+         else

+            u = s - (GLfloat) flr;

+         u = (u * size) - 0.5F;

+         *i0 = IFLOOR(u);

+         *i1 = *i0 + 1;

+         if (*i0 < 0)

+            *i0 = 0;

+         if (*i1 >= (GLint) size)

+            *i1 = size - 1;

+      }

+      break;

+   case GL_MIRROR_CLAMP_EXT:

+      u = FABSF(s);

+      if (u >= 1.0F)

+         u = (GLfloat) size;

+      else

+         u *= size;

+      u -= 0.5F;

+      *i0 = IFLOOR(u);

+      *i1 = *i0 + 1;

+      break;

+   case GL_MIRROR_CLAMP_TO_EDGE_EXT:

+      u = FABSF(s);

+      if (u >= 1.0F)

+         u = (GLfloat) size;

+      else

+         u *= size;

+      u -= 0.5F;

+      *i0 = IFLOOR(u);

+      *i1 = *i0 + 1;

+      if (*i0 < 0)

+         *i0 = 0;

+      if (*i1 >= (GLint) size)

+         *i1 = size - 1;

+      break;

+   case GL_MIRROR_CLAMP_TO_BORDER_EXT:

+      {

+         const GLfloat min = -1.0F / (2.0F * size);

+         const GLfloat max = 1.0F - min;

+         u = FABSF(s);

+         if (u <= min)

+            u = min * size;

+         else if (u >= max)

+            u = max * size;

+         else

+            u *= size;

+         u -= 0.5F;

+         *i0 = IFLOOR(u);

+         *i1 = *i0 + 1;

+      }

+      break;

+   case GL_CLAMP:

+      if (s <= 0.0F)

+         u = 0.0F;

+      else if (s >= 1.0F)

+         u = (GLfloat) size;

+      else

+         u = s * size;

+      u -= 0.5F;

+      *i0 = IFLOOR(u);

+      *i1 = *i0 + 1;

+      break;

+   default:

+      _mesa_problem(NULL, "Bad wrap mode");

+      u = 0.0F;

+   }

+   *weight = FRAC(u);

+}

+

+

+/**

+ * Used to compute texel location for nearest sampling.

+ */

+static INLINE GLint

+nearest_texel_location(GLenum wrapMode,

+                       const struct gl_texture_image *img,

+                       GLint size, GLfloat s)

+{

+   GLint i;

+

+   switch (wrapMode) {

+   case GL_REPEAT:

+      /* s limited to [0,1) */

+      /* i limited to [0,size-1] */

+      i = IFLOOR(s * size);

+      if (img->_IsPowerOfTwo)

+         i &= (size - 1);

+      else

+         i = REMAINDER(i, size);

+      return i;

+   case GL_CLAMP_TO_EDGE:

+      {

+         /* s limited to [min,max] */

+         /* i limited to [0, size-1] */

+         const GLfloat min = 1.0F / (2.0F * size);

+         const GLfloat max = 1.0F - min;

+         if (s < min)

+            i = 0;

+         else if (s > max)

+            i = size - 1;

+         else

+            i = IFLOOR(s * size);

+      }

+      return i;

+   case GL_CLAMP_TO_BORDER:

+      {

+         /* s limited to [min,max] */

+         /* i limited to [-1, size] */

+         const GLfloat min = -1.0F / (2.0F * size);

+         const GLfloat max = 1.0F - min;

+         if (s <= min)

+            i = -1;

+         else if (s >= max)

+            i = size;

+         else

+            i = IFLOOR(s * size);

+      }

+      return i;

+   case GL_MIRRORED_REPEAT:

+      {

+         const GLfloat min = 1.0F / (2.0F * size);

+         const GLfloat max = 1.0F - min;

+         const GLint flr = IFLOOR(s);

+         GLfloat u;

+         if (flr & 1)

+            u = 1.0F - (s - (GLfloat) flr);

+         else

+            u = s - (GLfloat) flr;

+         if (u < min)

+            i = 0;

+         else if (u > max)

+            i = size - 1;

+         else

+            i = IFLOOR(u * size);

+      }

+      return i;

+   case GL_MIRROR_CLAMP_EXT:

+      {

+         /* s limited to [0,1] */

+         /* i limited to [0,size-1] */

+         const GLfloat u = FABSF(s);

+         if (u <= 0.0F)

+            i = 0;

+         else if (u >= 1.0F)

+            i = size - 1;

+         else

+            i = IFLOOR(u * size);

+      }

+      return i;

+   case GL_MIRROR_CLAMP_TO_EDGE_EXT:

+      {

+         /* s limited to [min,max] */

+         /* i limited to [0, size-1] */

+         const GLfloat min = 1.0F / (2.0F * size);

+         const GLfloat max = 1.0F - min;

+         const GLfloat u = FABSF(s);

+         if (u < min)

+            i = 0;

+         else if (u > max)

+            i = size - 1;

+         else

+            i = IFLOOR(u * size);

+      }

+      return i;

+   case GL_MIRROR_CLAMP_TO_BORDER_EXT:

+      {

+         /* s limited to [min,max] */

+         /* i limited to [0, size-1] */

+         const GLfloat min = -1.0F / (2.0F * size);

+         const GLfloat max = 1.0F - min;

+         const GLfloat u = FABSF(s);

+         if (u < min)

+            i = -1;

+         else if (u > max)

+            i = size;

+         else

+            i = IFLOOR(u * size);

+      }

+      return i;

+   case GL_CLAMP:

+      /* s limited to [0,1] */

+      /* i limited to [0,size-1] */

+      if (s <= 0.0F)

+         i = 0;

+      else if (s >= 1.0F)

+         i = size - 1;

+      else

+         i = IFLOOR(s * size);

+      return i;

+   default:

+      _mesa_problem(NULL, "Bad wrap mode");

+      return 0;

+   }

+}

+

+

+/* Power of two image sizes only */

+static INLINE void

+linear_repeat_texel_location(GLuint size, GLfloat s,

+                             GLint *i0, GLint *i1, GLfloat *weight)

+{

+   GLfloat u = s * size - 0.5F;

+   *i0 = IFLOOR(u) & (size - 1);

+   *i1 = (*i0 + 1) & (size - 1);

+   *weight = FRAC(u);

+}

+

+

+/**

+ * Do clamp/wrap for a texture rectangle coord, GL_NEAREST filter mode.

+ */

+static INLINE GLint

+clamp_rect_coord_nearest(GLenum wrapMode, GLfloat coord, GLint max)

+{

+   switch (wrapMode) {

+   case GL_CLAMP:

+      return IFLOOR( CLAMP(coord, 0.0F, max - 1) );

+   case GL_CLAMP_TO_EDGE:

+      return IFLOOR( CLAMP(coord, 0.5F, max - 0.5F) );

+   case GL_CLAMP_TO_BORDER:

+      return IFLOOR( CLAMP(coord, -0.5F, max + 0.5F) );

+   default:

+      _mesa_problem(NULL, "bad wrapMode in clamp_rect_coord_nearest");

+      return 0;

+   }

+}

+

+

+/**

+ * As above, but GL_LINEAR filtering.

+ */

+static INLINE void

+clamp_rect_coord_linear(GLenum wrapMode, GLfloat coord, GLint max,

+                        GLint *i0out, GLint *i1out, GLfloat *weight)

+{

+   GLfloat fcol;

+   GLint i0, i1;

+   switch (wrapMode) {

+   case GL_CLAMP:

+      /* Not exactly what the spec says, but it matches NVIDIA output */

+      fcol = CLAMP(coord - 0.5F, 0.0F, max - 1);

+      i0 = IFLOOR(fcol);

+      i1 = i0 + 1;

+      break;

+   case GL_CLAMP_TO_EDGE:

+      fcol = CLAMP(coord, 0.5F, max - 0.5F);

+      fcol -= 0.5F;

+      i0 = IFLOOR(fcol);

+      i1 = i0 + 1;

+      if (i1 > max - 1)

+         i1 = max - 1;

+      break;

+   case GL_CLAMP_TO_BORDER:

+      fcol = CLAMP(coord, -0.5F, max + 0.5F);

+      fcol -= 0.5F;

+      i0 = IFLOOR(fcol);

+      i1 = i0 + 1;

+      break;

+   default:

+      _mesa_problem(NULL, "bad wrapMode in clamp_rect_coord_linear");

+      i0 = i1 = 0;

+      fcol = 0.0F;

+   }

+   *i0out = i0;

+   *i1out = i1;

+   *weight = FRAC(fcol);

+}

+

+

+/**

+ * Compute slice/image to use for 1D or 2D array texture.

+ */

+static INLINE GLint

+tex_array_slice(GLfloat coord, GLsizei size)

+{

+   GLint slice = IFLOOR(coord + 0.5f);

+   slice = CLAMP(slice, 0, size - 1);

+   return slice;

+}

+

+

+/**

+ * Compute nearest integer texcoords for given texobj and coordinate.

+ * NOTE: only used for depth texture sampling.

+ */

+static INLINE void

+nearest_texcoord(const struct gl_texture_object *texObj,

+                 GLuint level,

+                 const GLfloat texcoord[4],

+                 GLint *i, GLint *j, GLint *k)

+{

+   const struct gl_texture_image *img = texObj->Image[0][level];

+   const GLint width = img->Width;

+   const GLint height = img->Height;

+   const GLint depth = img->Depth;

+

+   switch (texObj->Target) {

+   case GL_TEXTURE_RECTANGLE_ARB:

+      *i = clamp_rect_coord_nearest(texObj->WrapS, texcoord[0], width);

+      *j = clamp_rect_coord_nearest(texObj->WrapT, texcoord[1], height);

+      *k = 0;

+      break;

+   case GL_TEXTURE_1D:

+      *i = nearest_texel_location(texObj->WrapS, img, width, texcoord[0]);

+      *j = 0;

+      *k = 0;

+      break;

+   case GL_TEXTURE_2D:

+      *i = nearest_texel_location(texObj->WrapS, img, width, texcoord[0]);

+      *j = nearest_texel_location(texObj->WrapT, img, height, texcoord[1]);

+      *k = 0;

+      break;

+   case GL_TEXTURE_1D_ARRAY_EXT:

+      *i = nearest_texel_location(texObj->WrapS, img, width, texcoord[0]);

+      *j = tex_array_slice(texcoord[1], height);

+      *k = 0;

+      break;

+   case GL_TEXTURE_2D_ARRAY_EXT:

+      *i = nearest_texel_location(texObj->WrapS, img, width, texcoord[0]);

+      *j = nearest_texel_location(texObj->WrapT, img, height, texcoord[1]);

+      *k = tex_array_slice(texcoord[2], depth);

+      break;

+   default:

+      *i = *j = *k = 0;

+   }

+}

+

+

+/**

+ * Compute linear integer texcoords for given texobj and coordinate.

+ * NOTE: only used for depth texture sampling.

+ */

+static INLINE void

+linear_texcoord(const struct gl_texture_object *texObj,

+                GLuint level,

+                const GLfloat texcoord[4],

+                GLint *i0, GLint *i1, GLint *j0, GLint *j1, GLint *slice,

+                GLfloat *wi, GLfloat *wj)

+{

+   const struct gl_texture_image *img = texObj->Image[0][level];

+   const GLint width = img->Width;

+   const GLint height = img->Height;

+   const GLint depth = img->Depth;

+

+   switch (texObj->Target) {

+   case GL_TEXTURE_RECTANGLE_ARB:

+      clamp_rect_coord_linear(texObj->WrapS, texcoord[0],

+                              width, i0, i1, wi);

+      clamp_rect_coord_linear(texObj->WrapT, texcoord[1],

+                              height, j0, j1, wj);

+      *slice = 0;

+      break;

+

+   case GL_TEXTURE_1D:

+   case GL_TEXTURE_2D:

+      linear_texel_locations(texObj->WrapS, img, width,

+                             texcoord[0], i0, i1, wi);

+      linear_texel_locations(texObj->WrapT, img, height,

+                             texcoord[1], j0, j1, wj);

+      *slice = 0;

+      break;

+

+   case GL_TEXTURE_1D_ARRAY_EXT:

+      linear_texel_locations(texObj->WrapS, img, width,

+                             texcoord[0], i0, i1, wi);

+      *j0 = tex_array_slice(texcoord[1], height);

+      *j1 = *j0;

+      *slice = 0;

+      break;

+

+   case GL_TEXTURE_2D_ARRAY_EXT:

+      linear_texel_locations(texObj->WrapS, img, width,

+                             texcoord[0], i0, i1, wi);

+      linear_texel_locations(texObj->WrapT, img, height,

+                             texcoord[1], j0, j1, wj);

+      *slice = tex_array_slice(texcoord[2], depth);

+      break;

+

+   default:

+      *slice = 0;

+   }

+}

+

+

+

+/**

+ * For linear interpolation between mipmap levels N and N+1, this function

+ * computes N.

+ */

+static INLINE GLint

+linear_mipmap_level(const struct gl_texture_object *tObj, GLfloat lambda)

+{

+   if (lambda < 0.0F)

+      return tObj->BaseLevel;

+   else if (lambda > tObj->_MaxLambda)

+      return (GLint) (tObj->BaseLevel + tObj->_MaxLambda);

+   else

+      return (GLint) (tObj->BaseLevel + lambda);

+}

+

+

+/**

+ * Compute the nearest mipmap level to take texels from.

+ */

+static INLINE GLint

+nearest_mipmap_level(const struct gl_texture_object *tObj, GLfloat lambda)

+{

+   GLfloat l;

+   GLint level;

+   if (lambda <= 0.5F)

+      l = 0.0F;

+   else if (lambda > tObj->_MaxLambda + 0.4999F)

+      l = tObj->_MaxLambda + 0.4999F;

+   else

+      l = lambda;

+   level = (GLint) (tObj->BaseLevel + l + 0.5F);

+   if (level > tObj->_MaxLevel)

+      level = tObj->_MaxLevel;

+   return level;

+}

+

+

+

+/*

+ * Bitflags for texture border color sampling.

+ */

+#define I0BIT   1

+#define I1BIT   2

+#define J0BIT   4

+#define J1BIT   8

+#define K0BIT  16

+#define K1BIT  32

+

+

+

+/**

+ * The lambda[] array values are always monotonic.  Either the whole span

+ * will be minified, magnified, or split between the two.  This function

+ * determines the subranges in [0, n-1] that are to be minified or magnified.

+ */

+static INLINE void

+compute_min_mag_ranges(const struct gl_texture_object *tObj,

+                       GLuint n, const GLfloat lambda[],

+                       GLuint *minStart, GLuint *minEnd,

+                       GLuint *magStart, GLuint *magEnd)

+{

+   GLfloat minMagThresh;

+

+   /* we shouldn't be here if minfilter == magfilter */

+   ASSERT(tObj->MinFilter != tObj->MagFilter);

+

+   /* This bit comes from the OpenGL spec: */

+   if (tObj->MagFilter == GL_LINEAR

+       && (tObj->MinFilter == GL_NEAREST_MIPMAP_NEAREST ||

+           tObj->MinFilter == GL_NEAREST_MIPMAP_LINEAR)) {

+      minMagThresh = 0.5F;

+   }

+   else {

+      minMagThresh = 0.0F;

+   }

+

+#if 0

+   /* DEBUG CODE: Verify that lambda[] is monotonic.

+    * We can't really use this because the inaccuracy in the LOG2 function

+    * causes this test to fail, yet the resulting texturing is correct.

+    */

+   if (n > 1) {

+      GLuint i;

+      printf("lambda delta = %g\n", lambda[0] - lambda[n-1]);

+      if (lambda[0] >= lambda[n-1]) { /* decreasing */

+         for (i = 0; i < n - 1; i++) {

+            ASSERT((GLint) (lambda[i] * 10) >= (GLint) (lambda[i+1] * 10));

+         }

+      }

+      else { /* increasing */

+         for (i = 0; i < n - 1; i++) {

+            ASSERT((GLint) (lambda[i] * 10) <= (GLint) (lambda[i+1] * 10));

+         }

+      }

+   }

+#endif /* DEBUG */

+

+   if (lambda[0] <= minMagThresh && (n <= 1 || lambda[n-1] <= minMagThresh)) {

+      /* magnification for whole span */

+      *magStart = 0;

+      *magEnd = n;

+      *minStart = *minEnd = 0;

+   }

+   else if (lambda[0] > minMagThresh && (n <=1 || lambda[n-1] > minMagThresh)) {

+      /* minification for whole span */

+      *minStart = 0;

+      *minEnd = n;

+      *magStart = *magEnd = 0;

+   }

+   else {

+      /* a mix of minification and magnification */

+      GLuint i;

+      if (lambda[0] > minMagThresh) {

+         /* start with minification */

+         for (i = 1; i < n; i++) {

+            if (lambda[i] <= minMagThresh)

+               break;

+         }

+         *minStart = 0;

+         *minEnd = i;

+         *magStart = i;

+         *magEnd = n;

+      }

+      else {

+         /* start with magnification */

+         for (i = 1; i < n; i++) {

+            if (lambda[i] > minMagThresh)

+               break;

+         }

+         *magStart = 0;

+         *magEnd = i;

+         *minStart = i;

+         *minEnd = n;

+      }

+   }

+

+#if 0

+   /* Verify the min/mag Start/End values

+    * We don't use this either (see above)

+    */

+   {

+      GLint i;

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

+         if (lambda[i] > minMagThresh) {

+            /* minification */

+            ASSERT(i >= *minStart);

+            ASSERT(i < *minEnd);

+         }

+         else {

+            /* magnification */

+            ASSERT(i >= *magStart);

+            ASSERT(i < *magEnd);

+         }

+      }

+   }

+#endif

+}

+

+

+/**

+ * When we sample the border color, it must be interpreted according to

+ * the base texture format.  Ex: if the texture base format it GL_ALPHA,

+ * we return (0,0,0,BorderAlpha).

+ */

+static INLINE void

+get_border_color(const struct gl_texture_object *tObj,

+                 const struct gl_texture_image *img,

+                 GLfloat rgba[4])

+{

+   switch (img->_BaseFormat) {

+   case GL_RGB:

+      rgba[0] = tObj->BorderColor.f[0];

+      rgba[1] = tObj->BorderColor.f[1];

+      rgba[2] = tObj->BorderColor.f[2];

+      rgba[3] = 1.0F;

+      break;

+   case GL_ALPHA:

+      rgba[0] = rgba[1] = rgba[2] = 0.0;

+      rgba[3] = tObj->BorderColor.f[3];

+      break;

+   case GL_LUMINANCE:

+      rgba[0] = rgba[1] = rgba[2] = tObj->BorderColor.f[0];

+      rgba[3] = 1.0;

+      break;

+   case GL_LUMINANCE_ALPHA:

+      rgba[0] = rgba[1] = rgba[2] = tObj->BorderColor.f[0];

+      rgba[3] = tObj->BorderColor.f[3];

+      break;

+   case GL_INTENSITY:

+      rgba[0] = rgba[1] = rgba[2] = rgba[3] = tObj->BorderColor.f[0];

+      break;

+   default:

+      COPY_4V(rgba, tObj->BorderColor.f);

+   }

+}

+

+

+/**********************************************************************/

+/*                    1-D Texture Sampling Functions                  */

+/**********************************************************************/

+

+/**

+ * Return the texture sample for coordinate (s) using GL_NEAREST filter.

+ */

+static INLINE void

+sample_1d_nearest(struct gl_context *ctx,

+                  const struct gl_texture_object *tObj,

+                  const struct gl_texture_image *img,

+                  const GLfloat texcoord[4], GLfloat rgba[4])

+{

+   const GLint width = img->Width2;  /* without border, power of two */

+   GLint i;

+   i = nearest_texel_location(tObj->WrapS, img, width, texcoord[0]);

+   /* skip over the border, if any */

+   i += img->Border;

+   if (i < 0 || i >= (GLint) img->Width) {

+      /* Need this test for GL_CLAMP_TO_BORDER mode */

+      get_border_color(tObj, img, rgba);

+   }

+   else {

+      img->FetchTexelf(img, i, 0, 0, rgba);

+   }

+}

+

+

+/**

+ * Return the texture sample for coordinate (s) using GL_LINEAR filter.

+ */

+static INLINE void

+sample_1d_linear(struct gl_context *ctx,

+                 const struct gl_texture_object *tObj,

+                 const struct gl_texture_image *img,

+                 const GLfloat texcoord[4], GLfloat rgba[4])

+{

+   const GLint width = img->Width2;

+   GLint i0, i1;

+   GLbitfield useBorderColor = 0x0;

+   GLfloat a;

+   GLfloat t0[4], t1[4];  /* texels */

+

+   linear_texel_locations(tObj->WrapS, img, width, texcoord[0], &i0, &i1, &a);

+

+   if (img->Border) {

+      i0 += img->Border;

+      i1 += img->Border;

+   }

+   else {

+      if (i0 < 0 || i0 >= width)   useBorderColor |= I0BIT;

+      if (i1 < 0 || i1 >= width)   useBorderColor |= I1BIT;

+   }

+

+   /* fetch texel colors */

+   if (useBorderColor & I0BIT) {

+      get_border_color(tObj, img, t0);

+   }

+   else {

+      img->FetchTexelf(img, i0, 0, 0, t0);

+   }

+   if (useBorderColor & I1BIT) {

+      get_border_color(tObj, img, t1);

+   }

+   else {

+      img->FetchTexelf(img, i1, 0, 0, t1);

+   }

+

+   lerp_rgba(rgba, a, t0, t1);

+}

+

+

+static void

+sample_1d_nearest_mipmap_nearest(struct gl_context *ctx,

+                                 const struct gl_texture_object *tObj,

+                                 GLuint n, const GLfloat texcoord[][4],

+                                 const GLfloat lambda[], GLfloat rgba[][4])

+{

+   GLuint i;

+   ASSERT(lambda != NULL);

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

+      GLint level = nearest_mipmap_level(tObj, lambda[i]);

+      sample_1d_nearest(ctx, tObj, tObj->Image[0][level], texcoord[i], rgba[i]);

+   }

+}

+

+

+static void

+sample_1d_linear_mipmap_nearest(struct gl_context *ctx,

+                                const struct gl_texture_object *tObj,

+                                GLuint n, const GLfloat texcoord[][4],

+                                const GLfloat lambda[], GLfloat rgba[][4])

+{

+   GLuint i;

+   ASSERT(lambda != NULL);

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

+      GLint level = nearest_mipmap_level(tObj, lambda[i]);

+      sample_1d_linear(ctx, tObj, tObj->Image[0][level], texcoord[i], rgba[i]);

+   }

+}

+

+

+static void

+sample_1d_nearest_mipmap_linear(struct gl_context *ctx,

+                                const struct gl_texture_object *tObj,

+                                GLuint n, const GLfloat texcoord[][4],

+                                const GLfloat lambda[], GLfloat rgba[][4])

+{

+   GLuint i;

+   ASSERT(lambda != NULL);

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

+      GLint level = linear_mipmap_level(tObj, lambda[i]);

+      if (level >= tObj->_MaxLevel) {

+         sample_1d_nearest(ctx, tObj, tObj->Image[0][tObj->_MaxLevel],

+                           texcoord[i], rgba[i]);

+      }

+      else {

+         GLfloat t0[4], t1[4];

+         const GLfloat f = FRAC(lambda[i]);

+         sample_1d_nearest(ctx, tObj, tObj->Image[0][level  ], texcoord[i], t0);

+         sample_1d_nearest(ctx, tObj, tObj->Image[0][level+1], texcoord[i], t1);

+         lerp_rgba(rgba[i], f, t0, t1);

+      }

+   }

+}

+

+

+static void

+sample_1d_linear_mipmap_linear(struct gl_context *ctx,

+                               const struct gl_texture_object *tObj,

+                               GLuint n, const GLfloat texcoord[][4],

+                               const GLfloat lambda[], GLfloat rgba[][4])

+{

+   GLuint i;

+   ASSERT(lambda != NULL);

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

+      GLint level = linear_mipmap_level(tObj, lambda[i]);

+      if (level >= tObj->_MaxLevel) {

+         sample_1d_linear(ctx, tObj, tObj->Image[0][tObj->_MaxLevel],

+                          texcoord[i], rgba[i]);

+      }

+      else {

+         GLfloat t0[4], t1[4];

+         const GLfloat f = FRAC(lambda[i]);

+         sample_1d_linear(ctx, tObj, tObj->Image[0][level  ], texcoord[i], t0);

+         sample_1d_linear(ctx, tObj, tObj->Image[0][level+1], texcoord[i], t1);

+         lerp_rgba(rgba[i], f, t0, t1);

+      }

+   }

+}

+

+

+/** Sample 1D texture, nearest filtering for both min/magnification */

+static void

+sample_nearest_1d( struct gl_context *ctx,

+                   const struct gl_texture_object *tObj, GLuint n,

+                   const GLfloat texcoords[][4], const GLfloat lambda[],

+                   GLfloat rgba[][4] )

+{

+   GLuint i;

+   struct gl_texture_image *image = tObj->Image[0][tObj->BaseLevel];

+   (void) lambda;

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

+      sample_1d_nearest(ctx, tObj, image, texcoords[i], rgba[i]);

+   }

+}

+

+

+/** Sample 1D texture, linear filtering for both min/magnification */

+static void

+sample_linear_1d( struct gl_context *ctx,

+                  const struct gl_texture_object *tObj, GLuint n,

+                  const GLfloat texcoords[][4], const GLfloat lambda[],

+                  GLfloat rgba[][4] )

+{

+   GLuint i;

+   struct gl_texture_image *image = tObj->Image[0][tObj->BaseLevel];

+   (void) lambda;

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

+      sample_1d_linear(ctx, tObj, image, texcoords[i], rgba[i]);

+   }

+}

+

+

+/** Sample 1D texture, using lambda to choose between min/magnification */

+static void

+sample_lambda_1d( struct gl_context *ctx,

+                  const struct gl_texture_object *tObj, GLuint n,

+                  const GLfloat texcoords[][4],

+                  const GLfloat lambda[], GLfloat rgba[][4] )

+{

+   GLuint minStart, minEnd;  /* texels with minification */

+   GLuint magStart, magEnd;  /* texels with magnification */

+   GLuint i;

+

+   ASSERT(lambda != NULL);

+   compute_min_mag_ranges(tObj, n, lambda,

+                          &minStart, &minEnd, &magStart, &magEnd);

+

+   if (minStart < minEnd) {

+      /* do the minified texels */

+      const GLuint m = minEnd - minStart;

+      switch (tObj->MinFilter) {

+      case GL_NEAREST:

+         for (i = minStart; i < minEnd; i++)

+            sample_1d_nearest(ctx, tObj, tObj->Image[0][tObj->BaseLevel],

+                              texcoords[i], rgba[i]);

+         break;

+      case GL_LINEAR:

+         for (i = minStart; i < minEnd; i++)

+            sample_1d_linear(ctx, tObj, tObj->Image[0][tObj->BaseLevel],

+                             texcoords[i], rgba[i]);

+         break;

+      case GL_NEAREST_MIPMAP_NEAREST:

+         sample_1d_nearest_mipmap_nearest(ctx, tObj, m, texcoords + minStart,

+                                          lambda + minStart, rgba + minStart);

+         break;

+      case GL_LINEAR_MIPMAP_NEAREST:

+         sample_1d_linear_mipmap_nearest(ctx, tObj, m, texcoords + minStart,

+                                         lambda + minStart, rgba + minStart);

+         break;

+      case GL_NEAREST_MIPMAP_LINEAR:

+         sample_1d_nearest_mipmap_linear(ctx, tObj, m, texcoords + minStart,

+                                         lambda + minStart, rgba + minStart);

+         break;

+      case GL_LINEAR_MIPMAP_LINEAR:

+         sample_1d_linear_mipmap_linear(ctx, tObj, m, texcoords + minStart,

+                                        lambda + minStart, rgba + minStart);

+         break;

+      default:

+         _mesa_problem(ctx, "Bad min filter in sample_1d_texture");

+         return;

+      }

+   }

+

+   if (magStart < magEnd) {

+      /* do the magnified texels */

+      switch (tObj->MagFilter) {

+      case GL_NEAREST:

+         for (i = magStart; i < magEnd; i++)

+            sample_1d_nearest(ctx, tObj, tObj->Image[0][tObj->BaseLevel],

+                              texcoords[i], rgba[i]);

+         break;

+      case GL_LINEAR:

+         for (i = magStart; i < magEnd; i++)

+            sample_1d_linear(ctx, tObj, tObj->Image[0][tObj->BaseLevel],

+                             texcoords[i], rgba[i]);

+         break;

+      default:

+         _mesa_problem(ctx, "Bad mag filter in sample_1d_texture");

+         return;

+      }

+   }

+}

+

+

+/**********************************************************************/

+/*                    2-D Texture Sampling Functions                  */

+/**********************************************************************/

+

+

+/**

+ * Return the texture sample for coordinate (s,t) using GL_NEAREST filter.

+ */

+static INLINE void

+sample_2d_nearest(struct gl_context *ctx,

+                  const struct gl_texture_object *tObj,

+                  const struct gl_texture_image *img,

+                  const GLfloat texcoord[4],

+                  GLfloat rgba[])

+{

+   const GLint width = img->Width2;    /* without border, power of two */

+   const GLint height = img->Height2;  /* without border, power of two */

+   GLint i, j;

+   (void) ctx;

+

+   i = nearest_texel_location(tObj->WrapS, img, width, texcoord[0]);

+   j = nearest_texel_location(tObj->WrapT, img, height, texcoord[1]);

+

+   /* skip over the border, if any */

+   i += img->Border;

+   j += img->Border;

+

+   if (i < 0 || i >= (GLint) img->Width || j < 0 || j >= (GLint) img->Height) {

+      /* Need this test for GL_CLAMP_TO_BORDER mode */

+      get_border_color(tObj, img, rgba);

+   }

+   else {

+      img->FetchTexelf(img, i, j, 0, rgba);

+   }

+}

+

+

+/**

+ * Return the texture sample for coordinate (s,t) using GL_LINEAR filter.

+ * New sampling code contributed by Lynn Quam <quam@ai.sri.com>.

+ */

+static INLINE void

+sample_2d_linear(struct gl_context *ctx,

+                 const struct gl_texture_object *tObj,

+                 const struct gl_texture_image *img,

+                 const GLfloat texcoord[4],

+                 GLfloat rgba[])

+{

+   const GLint width = img->Width2;

+   const GLint height = img->Height2;

+   GLint i0, j0, i1, j1;

+   GLbitfield useBorderColor = 0x0;

+   GLfloat a, b;

+   GLfloat t00[4], t10[4], t01[4], t11[4]; /* sampled texel colors */

+

+   linear_texel_locations(tObj->WrapS, img, width, texcoord[0],  &i0, &i1, &a);

+   linear_texel_locations(tObj->WrapT, img, height, texcoord[1], &j0, &j1, &b);

+

+   if (img->Border) {

+      i0 += img->Border;

+      i1 += img->Border;

+      j0 += img->Border;

+      j1 += img->Border;

+   }

+   else {

+      if (i0 < 0 || i0 >= width)   useBorderColor |= I0BIT;

+      if (i1 < 0 || i1 >= width)   useBorderColor |= I1BIT;

+      if (j0 < 0 || j0 >= height)  useBorderColor |= J0BIT;

+      if (j1 < 0 || j1 >= height)  useBorderColor |= J1BIT;

+   }

+

+   /* fetch four texel colors */

+   if (useBorderColor & (I0BIT | J0BIT)) {

+      get_border_color(tObj, img, t00);

+   }

+   else {

+      img->FetchTexelf(img, i0, j0, 0, t00);

+   }

+   if (useBorderColor & (I1BIT | J0BIT)) {

+      get_border_color(tObj, img, t10);

+   }

+   else {

+      img->FetchTexelf(img, i1, j0, 0, t10);

+   }

+   if (useBorderColor & (I0BIT | J1BIT)) {

+      get_border_color(tObj, img, t01);

+   }

+   else {

+      img->FetchTexelf(img, i0, j1, 0, t01);

+   }

+   if (useBorderColor & (I1BIT | J1BIT)) {

+      get_border_color(tObj, img, t11);

+   }

+   else {

+      img->FetchTexelf(img, i1, j1, 0, t11);

+   }

+

+   lerp_rgba_2d(rgba, a, b, t00, t10, t01, t11);

+}

+

+

+/**

+ * As above, but we know WRAP_S == REPEAT and WRAP_T == REPEAT.

+ * We don't have to worry about the texture border.

+ */

+static INLINE void

+sample_2d_linear_repeat(struct gl_context *ctx,

+                        const struct gl_texture_object *tObj,

+                        const struct gl_texture_image *img,

+                        const GLfloat texcoord[4],

+                        GLfloat rgba[])

+{

+   const GLint width = img->Width2;

+   const GLint height = img->Height2;

+   GLint i0, j0, i1, j1;

+   GLfloat wi, wj;

+   GLfloat t00[4], t10[4], t01[4], t11[4]; /* sampled texel colors */

+

+   (void) ctx;

+

+   ASSERT(tObj->WrapS == GL_REPEAT);

+   ASSERT(tObj->WrapT == GL_REPEAT);

+   ASSERT(img->Border == 0);

+   ASSERT(img->_BaseFormat != GL_COLOR_INDEX);

+   ASSERT(img->_IsPowerOfTwo);

+

+   linear_repeat_texel_location(width,  texcoord[0], &i0, &i1, &wi);

+   linear_repeat_texel_location(height, texcoord[1], &j0, &j1, &wj);

+

+   img->FetchTexelf(img, i0, j0, 0, t00);

+   img->FetchTexelf(img, i1, j0, 0, t10);

+   img->FetchTexelf(img, i0, j1, 0, t01);

+   img->FetchTexelf(img, i1, j1, 0, t11);

+

+   lerp_rgba_2d(rgba, wi, wj, t00, t10, t01, t11);

+}

+

+

+static void

+sample_2d_nearest_mipmap_nearest(struct gl_context *ctx,

+                                 const struct gl_texture_object *tObj,

+                                 GLuint n, const GLfloat texcoord[][4],

+                                 const GLfloat lambda[], GLfloat rgba[][4])

+{

+   GLuint i;

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

+      GLint level = nearest_mipmap_level(tObj, lambda[i]);

+      sample_2d_nearest(ctx, tObj, tObj->Image[0][level], texcoord[i], rgba[i]);

+   }

+}

+

+

+static void

+sample_2d_linear_mipmap_nearest(struct gl_context *ctx,

+                                const struct gl_texture_object *tObj,

+                                GLuint n, const GLfloat texcoord[][4],

+                                const GLfloat lambda[], GLfloat rgba[][4])

+{

+   GLuint i;

+   ASSERT(lambda != NULL);

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

+      GLint level = nearest_mipmap_level(tObj, lambda[i]);

+      sample_2d_linear(ctx, tObj, tObj->Image[0][level], texcoord[i], rgba[i]);

+   }

+}

+

+

+static void

+sample_2d_nearest_mipmap_linear(struct gl_context *ctx,

+                                const struct gl_texture_object *tObj,

+                                GLuint n, const GLfloat texcoord[][4],

+                                const GLfloat lambda[], GLfloat rgba[][4])

+{

+   GLuint i;

+   ASSERT(lambda != NULL);

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

+      GLint level = linear_mipmap_level(tObj, lambda[i]);

+      if (level >= tObj->_MaxLevel) {

+         sample_2d_nearest(ctx, tObj, tObj->Image[0][tObj->_MaxLevel],

+                           texcoord[i], rgba[i]);

+      }

+      else {

+         GLfloat t0[4], t1[4];  /* texels */

+         const GLfloat f = FRAC(lambda[i]);

+         sample_2d_nearest(ctx, tObj, tObj->Image[0][level  ], texcoord[i], t0);

+         sample_2d_nearest(ctx, tObj, tObj->Image[0][level+1], texcoord[i], t1);

+         lerp_rgba(rgba[i], f, t0, t1);

+      }

+   }

+}

+

+

+static void

+sample_2d_linear_mipmap_linear( struct gl_context *ctx,

+                                const struct gl_texture_object *tObj,

+                                GLuint n, const GLfloat texcoord[][4],

+                                const GLfloat lambda[], GLfloat rgba[][4] )

+{

+   GLuint i;

+   ASSERT(lambda != NULL);

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

+      GLint level = linear_mipmap_level(tObj, lambda[i]);

+      if (level >= tObj->_MaxLevel) {

+         sample_2d_linear(ctx, tObj, tObj->Image[0][tObj->_MaxLevel],

+                          texcoord[i], rgba[i]);

+      }

+      else {

+         GLfloat t0[4], t1[4];  /* texels */

+         const GLfloat f = FRAC(lambda[i]);

+         sample_2d_linear(ctx, tObj, tObj->Image[0][level  ], texcoord[i], t0);

+         sample_2d_linear(ctx, tObj, tObj->Image[0][level+1], texcoord[i], t1);

+         lerp_rgba(rgba[i], f, t0, t1);

+      }

+   }

+}

+

+

+static void

+sample_2d_linear_mipmap_linear_repeat(struct gl_context *ctx,

+                                      const struct gl_texture_object *tObj,

+                                      GLuint n, const GLfloat texcoord[][4],

+                                      const GLfloat lambda[], GLfloat rgba[][4])

+{

+   GLuint i;

+   ASSERT(lambda != NULL);

+   ASSERT(tObj->WrapS == GL_REPEAT);

+   ASSERT(tObj->WrapT == GL_REPEAT);

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

+      GLint level = linear_mipmap_level(tObj, lambda[i]);

+      if (level >= tObj->_MaxLevel) {

+         sample_2d_linear_repeat(ctx, tObj, tObj->Image[0][tObj->_MaxLevel],

+                                 texcoord[i], rgba[i]);

+      }

+      else {

+         GLfloat t0[4], t1[4];  /* texels */

+         const GLfloat f = FRAC(lambda[i]);

+         sample_2d_linear_repeat(ctx, tObj, tObj->Image[0][level  ],

+                                 texcoord[i], t0);

+         sample_2d_linear_repeat(ctx, tObj, tObj->Image[0][level+1],

+                                 texcoord[i], t1);

+         lerp_rgba(rgba[i], f, t0, t1);

+      }

+   }

+}

+

+

+/** Sample 2D texture, nearest filtering for both min/magnification */

+static void

+sample_nearest_2d(struct gl_context *ctx,

+                  const struct gl_texture_object *tObj, GLuint n,

+                  const GLfloat texcoords[][4],

+                  const GLfloat lambda[], GLfloat rgba[][4])

+{

+   GLuint i;

+   struct gl_texture_image *image = tObj->Image[0][tObj->BaseLevel];

+   (void) lambda;

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

+      sample_2d_nearest(ctx, tObj, image, texcoords[i], rgba[i]);

+   }

+}

+

+

+/** Sample 2D texture, linear filtering for both min/magnification */

+static void

+sample_linear_2d(struct gl_context *ctx,

+                 const struct gl_texture_object *tObj, GLuint n,

+                 const GLfloat texcoords[][4],

+                 const GLfloat lambda[], GLfloat rgba[][4])

+{

+   GLuint i;

+   struct gl_texture_image *image = tObj->Image[0][tObj->BaseLevel];

+   (void) lambda;

+   if (tObj->WrapS == GL_REPEAT &&

+       tObj->WrapT == GL_REPEAT &&

+       image->_IsPowerOfTwo &&

+       image->Border == 0) {

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

+         sample_2d_linear_repeat(ctx, tObj, image, texcoords[i], rgba[i]);

+      }

+   }

+   else {

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

+         sample_2d_linear(ctx, tObj, image, texcoords[i], rgba[i]);

+      }

+   }

+}

+

+

+/**

+ * Optimized 2-D texture sampling:

+ *    S and T wrap mode == GL_REPEAT

+ *    GL_NEAREST min/mag filter

+ *    No border, 

+ *    RowStride == Width,

+ *    Format = GL_RGB

+ */

+static void

+opt_sample_rgb_2d(struct gl_context *ctx,

+                  const struct gl_texture_object *tObj,

+                  GLuint n, const GLfloat texcoords[][4],

+                  const GLfloat lambda[], GLfloat rgba[][4])

+{

+   const struct gl_texture_image *img = tObj->Image[0][tObj->BaseLevel];

+   const GLfloat width = (GLfloat) img->Width;

+   const GLfloat height = (GLfloat) img->Height;

+   const GLint colMask = img->Width - 1;

+   const GLint rowMask = img->Height - 1;

+   const GLint shift = img->WidthLog2;

+   GLuint k;

+   (void) ctx;

+   (void) lambda;

+   ASSERT(tObj->WrapS==GL_REPEAT);

+   ASSERT(tObj->WrapT==GL_REPEAT);

+   ASSERT(img->Border==0);

+   ASSERT(img->TexFormat == MESA_FORMAT_RGB888);

+   ASSERT(img->_IsPowerOfTwo);

+

+   for (k=0; k<n; k++) {

+      GLint i = IFLOOR(texcoords[k][0] * width) & colMask;

+      GLint j = IFLOOR(texcoords[k][1] * height) & rowMask;

+      GLint pos = (j << shift) | i;

+      GLubyte *texel = ((GLubyte *) img->Data) + 3*pos;

+      rgba[k][RCOMP] = UBYTE_TO_FLOAT(texel[2]);

+      rgba[k][GCOMP] = UBYTE_TO_FLOAT(texel[1]);

+      rgba[k][BCOMP] = UBYTE_TO_FLOAT(texel[0]);

+      rgba[k][ACOMP] = 1.0F;

+   }

+}

+

+

+/**

+ * Optimized 2-D texture sampling:

+ *    S and T wrap mode == GL_REPEAT

+ *    GL_NEAREST min/mag filter

+ *    No border

+ *    RowStride == Width,

+ *    Format = GL_RGBA

+ */

+static void

+opt_sample_rgba_2d(struct gl_context *ctx,

+                   const struct gl_texture_object *tObj,

+                   GLuint n, const GLfloat texcoords[][4],

+                   const GLfloat lambda[], GLfloat rgba[][4])

+{

+   const struct gl_texture_image *img = tObj->Image[0][tObj->BaseLevel];

+   const GLfloat width = (GLfloat) img->Width;

+   const GLfloat height = (GLfloat) img->Height;

+   const GLint colMask = img->Width - 1;

+   const GLint rowMask = img->Height - 1;

+   const GLint shift = img->WidthLog2;

+   GLuint i;

+   (void) ctx;

+   (void) lambda;

+   ASSERT(tObj->WrapS==GL_REPEAT);

+   ASSERT(tObj->WrapT==GL_REPEAT);

+   ASSERT(img->Border==0);

+   ASSERT(img->TexFormat == MESA_FORMAT_RGBA8888);

+   ASSERT(img->_IsPowerOfTwo);

+

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

+      const GLint col = IFLOOR(texcoords[i][0] * width) & colMask;

+      const GLint row = IFLOOR(texcoords[i][1] * height) & rowMask;

+      const GLint pos = (row << shift) | col;

+      const GLuint texel = *((GLuint *) img->Data + pos);

+      rgba[i][RCOMP] = UBYTE_TO_FLOAT( (texel >> 24)        );

+      rgba[i][GCOMP] = UBYTE_TO_FLOAT( (texel >> 16) & 0xff );

+      rgba[i][BCOMP] = UBYTE_TO_FLOAT( (texel >>  8) & 0xff );

+      rgba[i][ACOMP] = UBYTE_TO_FLOAT( (texel      ) & 0xff );

+   }

+}

+

+

+/** Sample 2D texture, using lambda to choose between min/magnification */

+static void

+sample_lambda_2d(struct gl_context *ctx,

+                 const struct gl_texture_object *tObj,

+                 GLuint n, const GLfloat texcoords[][4],

+                 const GLfloat lambda[], GLfloat rgba[][4])

+{

+   const struct gl_texture_image *tImg = tObj->Image[0][tObj->BaseLevel];

+   GLuint minStart, minEnd;  /* texels with minification */

+   GLuint magStart, magEnd;  /* texels with magnification */

+

+   const GLboolean repeatNoBorderPOT = (tObj->WrapS == GL_REPEAT)

+      && (tObj->WrapT == GL_REPEAT)

+      && (tImg->Border == 0 && (tImg->Width == tImg->RowStride))

+      && (tImg->_BaseFormat != GL_COLOR_INDEX)

+      && tImg->_IsPowerOfTwo;

+

+   ASSERT(lambda != NULL);

+   compute_min_mag_ranges(tObj, n, lambda,

+                          &minStart, &minEnd, &magStart, &magEnd);

+

+   if (minStart < minEnd) {

+      /* do the minified texels */

+      const GLuint m = minEnd - minStart;

+      switch (tObj->MinFilter) {

+      case GL_NEAREST:

+         if (repeatNoBorderPOT) {

+            switch (tImg->TexFormat) {

+            case MESA_FORMAT_RGB888:

+               opt_sample_rgb_2d(ctx, tObj, m, texcoords + minStart,

+                                 NULL, rgba + minStart);

+               break;

+            case MESA_FORMAT_RGBA8888:

+	       opt_sample_rgba_2d(ctx, tObj, m, texcoords + minStart,

+                                  NULL, rgba + minStart);

+               break;

+            default:

+               sample_nearest_2d(ctx, tObj, m, texcoords + minStart,

+                                 NULL, rgba + minStart );

+            }

+         }

+         else {

+            sample_nearest_2d(ctx, tObj, m, texcoords + minStart,

+                              NULL, rgba + minStart);

+         }

+         break;

+      case GL_LINEAR:

+	 sample_linear_2d(ctx, tObj, m, texcoords + minStart,

+			  NULL, rgba + minStart);

+         break;

+      case GL_NEAREST_MIPMAP_NEAREST:

+         sample_2d_nearest_mipmap_nearest(ctx, tObj, m,

+                                          texcoords + minStart,

+                                          lambda + minStart, rgba + minStart);

+         break;

+      case GL_LINEAR_MIPMAP_NEAREST:

+         sample_2d_linear_mipmap_nearest(ctx, tObj, m, texcoords + minStart,

+                                         lambda + minStart, rgba + minStart);

+         break;

+      case GL_NEAREST_MIPMAP_LINEAR:

+         sample_2d_nearest_mipmap_linear(ctx, tObj, m, texcoords + minStart,

+                                         lambda + minStart, rgba + minStart);

+         break;

+      case GL_LINEAR_MIPMAP_LINEAR:

+         if (repeatNoBorderPOT)

+            sample_2d_linear_mipmap_linear_repeat(ctx, tObj, m,

+                  texcoords + minStart, lambda + minStart, rgba + minStart);

+         else

+            sample_2d_linear_mipmap_linear(ctx, tObj, m, texcoords + minStart,

+                                        lambda + minStart, rgba + minStart);

+         break;

+      default:

+         _mesa_problem(ctx, "Bad min filter in sample_2d_texture");

+         return;

+      }

+   }

+

+   if (magStart < magEnd) {

+      /* do the magnified texels */

+      const GLuint m = magEnd - magStart;

+

+      switch (tObj->MagFilter) {

+      case GL_NEAREST:

+         if (repeatNoBorderPOT) {

+            switch (tImg->TexFormat) {

+            case MESA_FORMAT_RGB888:

+               opt_sample_rgb_2d(ctx, tObj, m, texcoords + magStart,

+                                 NULL, rgba + magStart);

+               break;

+            case MESA_FORMAT_RGBA8888:

+	       opt_sample_rgba_2d(ctx, tObj, m, texcoords + magStart,

+                                  NULL, rgba + magStart);

+               break;

+            default:

+               sample_nearest_2d(ctx, tObj, m, texcoords + magStart,

+                                 NULL, rgba + magStart );

+            }

+         }

+         else {

+            sample_nearest_2d(ctx, tObj, m, texcoords + magStart,

+                              NULL, rgba + magStart);

+         }

+         break;

+      case GL_LINEAR:

+	 sample_linear_2d(ctx, tObj, m, texcoords + magStart,

+			  NULL, rgba + magStart);

+         break;

+      default:

+         _mesa_problem(ctx, "Bad mag filter in sample_lambda_2d");

+      }

+   }

+}

+

+

+

+/**********************************************************************/

+/*                    3-D Texture Sampling Functions                  */

+/**********************************************************************/

+

+/**

+ * Return the texture sample for coordinate (s,t,r) using GL_NEAREST filter.

+ */

+static INLINE void

+sample_3d_nearest(struct gl_context *ctx,

+                  const struct gl_texture_object *tObj,

+                  const struct gl_texture_image *img,

+                  const GLfloat texcoord[4],

+                  GLfloat rgba[4])

+{

+   const GLint width = img->Width2;     /* without border, power of two */

+   const GLint height = img->Height2;   /* without border, power of two */

+   const GLint depth = img->Depth2;     /* without border, power of two */

+   GLint i, j, k;

+   (void) ctx;

+

+   i = nearest_texel_location(tObj->WrapS, img, width, texcoord[0]);

+   j = nearest_texel_location(tObj->WrapT, img, height, texcoord[1]);

+   k = nearest_texel_location(tObj->WrapR, img, depth, texcoord[2]);

+

+   if (i < 0 || i >= (GLint) img->Width ||

+       j < 0 || j >= (GLint) img->Height ||

+       k < 0 || k >= (GLint) img->Depth) {

+      /* Need this test for GL_CLAMP_TO_BORDER mode */

+      get_border_color(tObj, img, rgba);

+   }

+   else {

+      img->FetchTexelf(img, i, j, k, rgba);

+   }

+}

+

+

+/**

+ * Return the texture sample for coordinate (s,t,r) using GL_LINEAR filter.

+ */

+static void

+sample_3d_linear(struct gl_context *ctx,

+                 const struct gl_texture_object *tObj,

+                 const struct gl_texture_image *img,

+                 const GLfloat texcoord[4],

+                 GLfloat rgba[4])

+{

+   const GLint width = img->Width2;

+   const GLint height = img->Height2;

+   const GLint depth = img->Depth2;

+   GLint i0, j0, k0, i1, j1, k1;

+   GLbitfield useBorderColor = 0x0;

+   GLfloat a, b, c;

+   GLfloat t000[4], t010[4], t001[4], t011[4];

+   GLfloat t100[4], t110[4], t101[4], t111[4];

+

+   linear_texel_locations(tObj->WrapS, img, width, texcoord[0],  &i0, &i1, &a);

+   linear_texel_locations(tObj->WrapT, img, height, texcoord[1], &j0, &j1, &b);

+   linear_texel_locations(tObj->WrapR, img, depth, texcoord[2],  &k0, &k1, &c);

+

+   if (img->Border) {

+      i0 += img->Border;

+      i1 += img->Border;

+      j0 += img->Border;

+      j1 += img->Border;

+      k0 += img->Border;

+      k1 += img->Border;

+   }

+   else {

+      /* check if sampling texture border color */

+      if (i0 < 0 || i0 >= width)   useBorderColor |= I0BIT;

+      if (i1 < 0 || i1 >= width)   useBorderColor |= I1BIT;

+      if (j0 < 0 || j0 >= height)  useBorderColor |= J0BIT;

+      if (j1 < 0 || j1 >= height)  useBorderColor |= J1BIT;

+      if (k0 < 0 || k0 >= depth)   useBorderColor |= K0BIT;

+      if (k1 < 0 || k1 >= depth)   useBorderColor |= K1BIT;

+   }

+

+   /* Fetch texels */

+   if (useBorderColor & (I0BIT | J0BIT | K0BIT)) {

+      get_border_color(tObj, img, t000);

+   }

+   else {

+      img->FetchTexelf(img, i0, j0, k0, t000);

+   }

+   if (useBorderColor & (I1BIT | J0BIT | K0BIT)) {

+      get_border_color(tObj, img, t100);

+   }

+   else {

+      img->FetchTexelf(img, i1, j0, k0, t100);

+   }

+   if (useBorderColor & (I0BIT | J1BIT | K0BIT)) {

+      get_border_color(tObj, img, t010);

+   }

+   else {

+      img->FetchTexelf(img, i0, j1, k0, t010);

+   }

+   if (useBorderColor & (I1BIT | J1BIT | K0BIT)) {

+      get_border_color(tObj, img, t110);

+   }

+   else {

+      img->FetchTexelf(img, i1, j1, k0, t110);

+   }

+

+   if (useBorderColor & (I0BIT | J0BIT | K1BIT)) {

+      get_border_color(tObj, img, t001);

+   }

+   else {

+      img->FetchTexelf(img, i0, j0, k1, t001);

+   }

+   if (useBorderColor & (I1BIT | J0BIT | K1BIT)) {

+      get_border_color(tObj, img, t101);

+   }

+   else {

+      img->FetchTexelf(img, i1, j0, k1, t101);

+   }

+   if (useBorderColor & (I0BIT | J1BIT | K1BIT)) {

+      get_border_color(tObj, img, t011);

+   }

+   else {

+      img->FetchTexelf(img, i0, j1, k1, t011);

+   }

+   if (useBorderColor & (I1BIT | J1BIT | K1BIT)) {

+      get_border_color(tObj, img, t111);

+   }

+   else {

+      img->FetchTexelf(img, i1, j1, k1, t111);

+   }

+

+   /* trilinear interpolation of samples */

+   lerp_rgba_3d(rgba, a, b, c, t000, t100, t010, t110, t001, t101, t011, t111);

+}

+

+

+static void

+sample_3d_nearest_mipmap_nearest(struct gl_context *ctx,

+                                 const struct gl_texture_object *tObj,

+                                 GLuint n, const GLfloat texcoord[][4],

+                                 const GLfloat lambda[], GLfloat rgba[][4] )

+{

+   GLuint i;

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

+      GLint level = nearest_mipmap_level(tObj, lambda[i]);

+      sample_3d_nearest(ctx, tObj, tObj->Image[0][level], texcoord[i], rgba[i]);

+   }

+}

+

+

+static void

+sample_3d_linear_mipmap_nearest(struct gl_context *ctx,

+                                const struct gl_texture_object *tObj,

+                                GLuint n, const GLfloat texcoord[][4],

+                                const GLfloat lambda[], GLfloat rgba[][4])

+{

+   GLuint i;

+   ASSERT(lambda != NULL);

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

+      GLint level = nearest_mipmap_level(tObj, lambda[i]);

+      sample_3d_linear(ctx, tObj, tObj->Image[0][level], texcoord[i], rgba[i]);

+   }

+}

+

+

+static void

+sample_3d_nearest_mipmap_linear(struct gl_context *ctx,

+                                const struct gl_texture_object *tObj,

+                                GLuint n, const GLfloat texcoord[][4],

+                                const GLfloat lambda[], GLfloat rgba[][4])

+{

+   GLuint i;

+   ASSERT(lambda != NULL);

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

+      GLint level = linear_mipmap_level(tObj, lambda[i]);

+      if (level >= tObj->_MaxLevel) {

+         sample_3d_nearest(ctx, tObj, tObj->Image[0][tObj->_MaxLevel],

+                           texcoord[i], rgba[i]);

+      }

+      else {

+         GLfloat t0[4], t1[4];  /* texels */

+         const GLfloat f = FRAC(lambda[i]);

+         sample_3d_nearest(ctx, tObj, tObj->Image[0][level  ], texcoord[i], t0);

+         sample_3d_nearest(ctx, tObj, tObj->Image[0][level+1], texcoord[i], t1);

+         lerp_rgba(rgba[i], f, t0, t1);

+      }

+   }

+}

+

+

+static void

+sample_3d_linear_mipmap_linear(struct gl_context *ctx,

+                               const struct gl_texture_object *tObj,

+                               GLuint n, const GLfloat texcoord[][4],

+                               const GLfloat lambda[], GLfloat rgba[][4])

+{

+   GLuint i;

+   ASSERT(lambda != NULL);

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

+      GLint level = linear_mipmap_level(tObj, lambda[i]);

+      if (level >= tObj->_MaxLevel) {

+         sample_3d_linear(ctx, tObj, tObj->Image[0][tObj->_MaxLevel],

+                          texcoord[i], rgba[i]);

+      }

+      else {

+         GLfloat t0[4], t1[4];  /* texels */

+         const GLfloat f = FRAC(lambda[i]);

+         sample_3d_linear(ctx, tObj, tObj->Image[0][level  ], texcoord[i], t0);

+         sample_3d_linear(ctx, tObj, tObj->Image[0][level+1], texcoord[i], t1);

+         lerp_rgba(rgba[i], f, t0, t1);

+      }

+   }

+}

+

+

+/** Sample 3D texture, nearest filtering for both min/magnification */

+static void

+sample_nearest_3d(struct gl_context *ctx,

+                  const struct gl_texture_object *tObj, GLuint n,

+                  const GLfloat texcoords[][4], const GLfloat lambda[],

+                  GLfloat rgba[][4])

+{

+   GLuint i;

+   struct gl_texture_image *image = tObj->Image[0][tObj->BaseLevel];

+   (void) lambda;

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

+      sample_3d_nearest(ctx, tObj, image, texcoords[i], rgba[i]);

+   }

+}

+

+

+/** Sample 3D texture, linear filtering for both min/magnification */

+static void

+sample_linear_3d(struct gl_context *ctx,

+                 const struct gl_texture_object *tObj, GLuint n,

+                 const GLfloat texcoords[][4],

+		 const GLfloat lambda[], GLfloat rgba[][4])

+{

+   GLuint i;

+   struct gl_texture_image *image = tObj->Image[0][tObj->BaseLevel];

+   (void) lambda;

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

+      sample_3d_linear(ctx, tObj, image, texcoords[i], rgba[i]);

+   }

+}

+

+

+/** Sample 3D texture, using lambda to choose between min/magnification */

+static void

+sample_lambda_3d(struct gl_context *ctx,

+                 const struct gl_texture_object *tObj, GLuint n,

+                 const GLfloat texcoords[][4], const GLfloat lambda[],

+                 GLfloat rgba[][4])

+{

+   GLuint minStart, minEnd;  /* texels with minification */

+   GLuint magStart, magEnd;  /* texels with magnification */

+   GLuint i;

+

+   ASSERT(lambda != NULL);

+   compute_min_mag_ranges(tObj, n, lambda,

+                          &minStart, &minEnd, &magStart, &magEnd);

+

+   if (minStart < minEnd) {

+      /* do the minified texels */

+      GLuint m = minEnd - minStart;

+      switch (tObj->MinFilter) {

+      case GL_NEAREST:

+         for (i = minStart; i < minEnd; i++)

+            sample_3d_nearest(ctx, tObj, tObj->Image[0][tObj->BaseLevel],

+                              texcoords[i], rgba[i]);

+         break;

+      case GL_LINEAR:

+         for (i = minStart; i < minEnd; i++)

+            sample_3d_linear(ctx, tObj, tObj->Image[0][tObj->BaseLevel],

+                             texcoords[i], rgba[i]);

+         break;

+      case GL_NEAREST_MIPMAP_NEAREST:

+         sample_3d_nearest_mipmap_nearest(ctx, tObj, m, texcoords + minStart,

+                                          lambda + minStart, rgba + minStart);

+         break;

+      case GL_LINEAR_MIPMAP_NEAREST:

+         sample_3d_linear_mipmap_nearest(ctx, tObj, m, texcoords + minStart,

+                                         lambda + minStart, rgba + minStart);

+         break;

+      case GL_NEAREST_MIPMAP_LINEAR:

+         sample_3d_nearest_mipmap_linear(ctx, tObj, m, texcoords + minStart,

+                                         lambda + minStart, rgba + minStart);

+         break;

+      case GL_LINEAR_MIPMAP_LINEAR:

+         sample_3d_linear_mipmap_linear(ctx, tObj, m, texcoords + minStart,

+                                        lambda + minStart, rgba + minStart);

+         break;

+      default:

+         _mesa_problem(ctx, "Bad min filter in sample_3d_texture");

+         return;

+      }

+   }

+

+   if (magStart < magEnd) {

+      /* do the magnified texels */

+      switch (tObj->MagFilter) {

+      case GL_NEAREST:

+         for (i = magStart; i < magEnd; i++)

+            sample_3d_nearest(ctx, tObj, tObj->Image[0][tObj->BaseLevel],

+                              texcoords[i], rgba[i]);

+         break;

+      case GL_LINEAR:

+         for (i = magStart; i < magEnd; i++)

+            sample_3d_linear(ctx, tObj, tObj->Image[0][tObj->BaseLevel],

+                             texcoords[i], rgba[i]);

+         break;

+      default:

+         _mesa_problem(ctx, "Bad mag filter in sample_3d_texture");

+         return;

+      }

+   }

+}

+

+

+/**********************************************************************/

+/*                Texture Cube Map Sampling Functions                 */

+/**********************************************************************/

+

+/**

+ * Choose one of six sides of a texture cube map given the texture

+ * coord (rx,ry,rz).  Return pointer to corresponding array of texture

+ * images.

+ */

+static const struct gl_texture_image **

+choose_cube_face(const struct gl_texture_object *texObj,

+                 const GLfloat texcoord[4], GLfloat newCoord[4])

+{

+   /*

+      major axis

+      direction     target                             sc     tc    ma

+      ----------    -------------------------------    ---    ---   ---

+       +rx          TEXTURE_CUBE_MAP_POSITIVE_X_EXT    -rz    -ry   rx

+       -rx          TEXTURE_CUBE_MAP_NEGATIVE_X_EXT    +rz    -ry   rx

+       +ry          TEXTURE_CUBE_MAP_POSITIVE_Y_EXT    +rx    +rz   ry

+       -ry          TEXTURE_CUBE_MAP_NEGATIVE_Y_EXT    +rx    -rz   ry

+       +rz          TEXTURE_CUBE_MAP_POSITIVE_Z_EXT    +rx    -ry   rz

+       -rz          TEXTURE_CUBE_MAP_NEGATIVE_Z_EXT    -rx    -ry   rz

+   */

+   const GLfloat rx = texcoord[0];

+   const GLfloat ry = texcoord[1];

+   const GLfloat rz = texcoord[2];

+   const GLfloat arx = FABSF(rx), ary = FABSF(ry), arz = FABSF(rz);

+   GLuint face;

+   GLfloat sc, tc, ma;

+

+   if (arx >= ary && arx >= arz) {

+      if (rx >= 0.0F) {

+         face = FACE_POS_X;

+         sc = -rz;

+         tc = -ry;

+         ma = arx;

+      }

+      else {

+         face = FACE_NEG_X;

+         sc = rz;

+         tc = -ry;

+         ma = arx;

+      }

+   }

+   else if (ary >= arx && ary >= arz) {

+      if (ry >= 0.0F) {

+         face = FACE_POS_Y;

+         sc = rx;

+         tc = rz;

+         ma = ary;

+      }

+      else {

+         face = FACE_NEG_Y;

+         sc = rx;

+         tc = -rz;

+         ma = ary;

+      }

+   }

+   else {

+      if (rz > 0.0F) {

+         face = FACE_POS_Z;

+         sc = rx;

+         tc = -ry;

+         ma = arz;

+      }

+      else {

+         face = FACE_NEG_Z;

+         sc = -rx;

+         tc = -ry;

+         ma = arz;

+      }

+   }

+

+   { 

+      const float ima = 1.0F / ma;

+      newCoord[0] = ( sc * ima + 1.0F ) * 0.5F;

+      newCoord[1] = ( tc * ima + 1.0F ) * 0.5F;

+   }

+

+   return (const struct gl_texture_image **) texObj->Image[face];

+}

+

+

+static void

+sample_nearest_cube(struct gl_context *ctx,

+		    const struct gl_texture_object *tObj, GLuint n,

+                    const GLfloat texcoords[][4], const GLfloat lambda[],

+                    GLfloat rgba[][4])

+{

+   GLuint i;

+   (void) lambda;

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

+      const struct gl_texture_image **images;

+      GLfloat newCoord[4];

+      images = choose_cube_face(tObj, texcoords[i], newCoord);

+      sample_2d_nearest(ctx, tObj, images[tObj->BaseLevel],

+                        newCoord, rgba[i]);

+   }

+}

+

+

+static void

+sample_linear_cube(struct gl_context *ctx,

+		   const struct gl_texture_object *tObj, GLuint n,

+                   const GLfloat texcoords[][4],

+		   const GLfloat lambda[], GLfloat rgba[][4])

+{

+   GLuint i;

+   (void) lambda;

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

+      const struct gl_texture_image **images;

+      GLfloat newCoord[4];

+      images = choose_cube_face(tObj, texcoords[i], newCoord);

+      sample_2d_linear(ctx, tObj, images[tObj->BaseLevel],

+                       newCoord, rgba[i]);

+   }

+}

+

+

+static void

+sample_cube_nearest_mipmap_nearest(struct gl_context *ctx,

+                                   const struct gl_texture_object *tObj,

+                                   GLuint n, const GLfloat texcoord[][4],

+                                   const GLfloat lambda[], GLfloat rgba[][4])

+{

+   GLuint i;

+   ASSERT(lambda != NULL);

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

+      const struct gl_texture_image **images;

+      GLfloat newCoord[4];

+      GLint level;

+      images = choose_cube_face(tObj, texcoord[i], newCoord);

+

+      /* XXX we actually need to recompute lambda here based on the newCoords.

+       * But we would need the texcoords of adjacent fragments to compute that

+       * properly, and we don't have those here.

+       * For now, do an approximation:  subtracting 1 from the chosen mipmap

+       * level seems to work in some test cases.

+       * The same adjustment is done in the next few functions.

+      */

+      level = nearest_mipmap_level(tObj, lambda[i]);

+      level = MAX2(level - 1, 0);

+

+      sample_2d_nearest(ctx, tObj, images[level], newCoord, rgba[i]);

+   }

+}

+

+

+static void

+sample_cube_linear_mipmap_nearest(struct gl_context *ctx,

+                                  const struct gl_texture_object *tObj,

+                                  GLuint n, const GLfloat texcoord[][4],

+                                  const GLfloat lambda[], GLfloat rgba[][4])

+{

+   GLuint i;

+   ASSERT(lambda != NULL);

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

+      const struct gl_texture_image **images;

+      GLfloat newCoord[4];

+      GLint level = nearest_mipmap_level(tObj, lambda[i]);

+      level = MAX2(level - 1, 0); /* see comment above */

+      images = choose_cube_face(tObj, texcoord[i], newCoord);

+      sample_2d_linear(ctx, tObj, images[level], newCoord, rgba[i]);

+   }

+}

+

+

+static void

+sample_cube_nearest_mipmap_linear(struct gl_context *ctx,

+                                  const struct gl_texture_object *tObj,

+                                  GLuint n, const GLfloat texcoord[][4],

+                                  const GLfloat lambda[], GLfloat rgba[][4])

+{

+   GLuint i;

+   ASSERT(lambda != NULL);

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

+      const struct gl_texture_image **images;

+      GLfloat newCoord[4];

+      GLint level = linear_mipmap_level(tObj, lambda[i]);

+      level = MAX2(level - 1, 0); /* see comment above */

+      images = choose_cube_face(tObj, texcoord[i], newCoord);

+      if (level >= tObj->_MaxLevel) {

+         sample_2d_nearest(ctx, tObj, images[tObj->_MaxLevel],

+                           newCoord, rgba[i]);

+      }

+      else {

+         GLfloat t0[4], t1[4];  /* texels */

+         const GLfloat f = FRAC(lambda[i]);

+         sample_2d_nearest(ctx, tObj, images[level  ], newCoord, t0);

+         sample_2d_nearest(ctx, tObj, images[level+1], newCoord, t1);

+         lerp_rgba(rgba[i], f, t0, t1);

+      }

+   }

+}

+

+

+static void

+sample_cube_linear_mipmap_linear(struct gl_context *ctx,

+                                 const struct gl_texture_object *tObj,

+                                 GLuint n, const GLfloat texcoord[][4],

+                                 const GLfloat lambda[], GLfloat rgba[][4])

+{

+   GLuint i;

+   ASSERT(lambda != NULL);

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

+      const struct gl_texture_image **images;

+      GLfloat newCoord[4];

+      GLint level = linear_mipmap_level(tObj, lambda[i]);

+      level = MAX2(level - 1, 0); /* see comment above */

+      images = choose_cube_face(tObj, texcoord[i], newCoord);

+      if (level >= tObj->_MaxLevel) {

+         sample_2d_linear(ctx, tObj, images[tObj->_MaxLevel],

+                          newCoord, rgba[i]);

+      }

+      else {

+         GLfloat t0[4], t1[4];

+         const GLfloat f = FRAC(lambda[i]);

+         sample_2d_linear(ctx, tObj, images[level  ], newCoord, t0);

+         sample_2d_linear(ctx, tObj, images[level+1], newCoord, t1);

+         lerp_rgba(rgba[i], f, t0, t1);

+      }

+   }

+}

+

+

+/** Sample cube texture, using lambda to choose between min/magnification */

+static void

+sample_lambda_cube(struct gl_context *ctx,

+		   const struct gl_texture_object *tObj, GLuint n,

+		   const GLfloat texcoords[][4], const GLfloat lambda[],

+		   GLfloat rgba[][4])

+{

+   GLuint minStart, minEnd;  /* texels with minification */

+   GLuint magStart, magEnd;  /* texels with magnification */

+

+   ASSERT(lambda != NULL);

+   compute_min_mag_ranges(tObj, n, lambda,

+                          &minStart, &minEnd, &magStart, &magEnd);

+

+   if (minStart < minEnd) {

+      /* do the minified texels */

+      const GLuint m = minEnd - minStart;

+      switch (tObj->MinFilter) {

+      case GL_NEAREST:

+         sample_nearest_cube(ctx, tObj, m, texcoords + minStart,

+                             lambda + minStart, rgba + minStart);

+         break;

+      case GL_LINEAR:

+         sample_linear_cube(ctx, tObj, m, texcoords + minStart,

+                            lambda + minStart, rgba + minStart);

+         break;

+      case GL_NEAREST_MIPMAP_NEAREST:

+         sample_cube_nearest_mipmap_nearest(ctx, tObj, m,

+                                            texcoords + minStart,

+                                           lambda + minStart, rgba + minStart);

+         break;

+      case GL_LINEAR_MIPMAP_NEAREST:

+         sample_cube_linear_mipmap_nearest(ctx, tObj, m,

+                                           texcoords + minStart,

+                                           lambda + minStart, rgba + minStart);

+         break;

+      case GL_NEAREST_MIPMAP_LINEAR:

+         sample_cube_nearest_mipmap_linear(ctx, tObj, m,

+                                           texcoords + minStart,

+                                           lambda + minStart, rgba + minStart);

+         break;

+      case GL_LINEAR_MIPMAP_LINEAR:

+         sample_cube_linear_mipmap_linear(ctx, tObj, m,

+                                          texcoords + minStart,

+                                          lambda + minStart, rgba + minStart);

+         break;

+      default:

+         _mesa_problem(ctx, "Bad min filter in sample_lambda_cube");

+      }

+   }

+

+   if (magStart < magEnd) {

+      /* do the magnified texels */

+      const GLuint m = magEnd - magStart;

+      switch (tObj->MagFilter) {

+      case GL_NEAREST:

+         sample_nearest_cube(ctx, tObj, m, texcoords + magStart,

+                             lambda + magStart, rgba + magStart);

+         break;

+      case GL_LINEAR:

+         sample_linear_cube(ctx, tObj, m, texcoords + magStart,

+                            lambda + magStart, rgba + magStart);

+         break;

+      default:

+         _mesa_problem(ctx, "Bad mag filter in sample_lambda_cube");

+      }

+   }

+}

+

+

+/**********************************************************************/

+/*               Texture Rectangle Sampling Functions                 */

+/**********************************************************************/

+

+

+static void

+sample_nearest_rect(struct gl_context *ctx,

+		    const struct gl_texture_object *tObj, GLuint n,

+                    const GLfloat texcoords[][4], const GLfloat lambda[],

+                    GLfloat rgba[][4])

+{

+   const struct gl_texture_image *img = tObj->Image[0][0];

+   const GLint width = img->Width;

+   const GLint height = img->Height;

+   GLuint i;

+

+   (void) ctx;

+   (void) lambda;

+

+   ASSERT(tObj->WrapS == GL_CLAMP ||

+          tObj->WrapS == GL_CLAMP_TO_EDGE ||

+          tObj->WrapS == GL_CLAMP_TO_BORDER);

+   ASSERT(tObj->WrapT == GL_CLAMP ||

+          tObj->WrapT == GL_CLAMP_TO_EDGE ||

+          tObj->WrapT == GL_CLAMP_TO_BORDER);

+   ASSERT(img->_BaseFormat != GL_COLOR_INDEX);

+

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

+      GLint row, col;

+      col = clamp_rect_coord_nearest(tObj->WrapS, texcoords[i][0], width);

+      row = clamp_rect_coord_nearest(tObj->WrapT, texcoords[i][1], height);

+      if (col < 0 || col >= width || row < 0 || row >= height)

+         get_border_color(tObj, img, rgba[i]);

+      else

+         img->FetchTexelf(img, col, row, 0, rgba[i]);

+   }

+}

+

+

+static void

+sample_linear_rect(struct gl_context *ctx,

+		   const struct gl_texture_object *tObj, GLuint n,

+                   const GLfloat texcoords[][4],

+		   const GLfloat lambda[], GLfloat rgba[][4])

+{

+   const struct gl_texture_image *img = tObj->Image[0][0];

+   const GLint width = img->Width;

+   const GLint height = img->Height;

+   GLuint i;

+

+   (void) ctx;

+   (void) lambda;

+

+   ASSERT(tObj->WrapS == GL_CLAMP ||

+          tObj->WrapS == GL_CLAMP_TO_EDGE ||

+          tObj->WrapS == GL_CLAMP_TO_BORDER);

+   ASSERT(tObj->WrapT == GL_CLAMP ||

+          tObj->WrapT == GL_CLAMP_TO_EDGE ||

+          tObj->WrapT == GL_CLAMP_TO_BORDER);

+   ASSERT(img->_BaseFormat != GL_COLOR_INDEX);

+

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

+      GLint i0, j0, i1, j1;

+      GLfloat t00[4], t01[4], t10[4], t11[4];

+      GLfloat a, b;

+      GLbitfield useBorderColor = 0x0;

+

+      clamp_rect_coord_linear(tObj->WrapS, texcoords[i][0], width,

+                              &i0, &i1, &a);

+      clamp_rect_coord_linear(tObj->WrapT, texcoords[i][1], height,

+                              &j0, &j1, &b);

+

+      /* compute integer rows/columns */

+      if (i0 < 0 || i0 >= width)   useBorderColor |= I0BIT;

+      if (i1 < 0 || i1 >= width)   useBorderColor |= I1BIT;

+      if (j0 < 0 || j0 >= height)  useBorderColor |= J0BIT;

+      if (j1 < 0 || j1 >= height)  useBorderColor |= J1BIT;

+

+      /* get four texel samples */

+      if (useBorderColor & (I0BIT | J0BIT))

+         get_border_color(tObj, img, t00);

+      else

+         img->FetchTexelf(img, i0, j0, 0, t00);

+

+      if (useBorderColor & (I1BIT | J0BIT))

+         get_border_color(tObj, img, t10);

+      else

+         img->FetchTexelf(img, i1, j0, 0, t10);

+

+      if (useBorderColor & (I0BIT | J1BIT))

+         get_border_color(tObj, img, t01);

+      else

+         img->FetchTexelf(img, i0, j1, 0, t01);

+

+      if (useBorderColor & (I1BIT | J1BIT))

+         get_border_color(tObj, img, t11);

+      else

+         img->FetchTexelf(img, i1, j1, 0, t11);

+

+      lerp_rgba_2d(rgba[i], a, b, t00, t10, t01, t11);

+   }

+}

+

+

+/** Sample Rect texture, using lambda to choose between min/magnification */

+static void

+sample_lambda_rect(struct gl_context *ctx,

+		   const struct gl_texture_object *tObj, GLuint n,

+		   const GLfloat texcoords[][4], const GLfloat lambda[],

+		   GLfloat rgba[][4])

+{

+   GLuint minStart, minEnd, magStart, magEnd;

+

+   /* We only need lambda to decide between minification and magnification.

+    * There is no mipmapping with rectangular textures.

+    */

+   compute_min_mag_ranges(tObj, n, lambda,

+                          &minStart, &minEnd, &magStart, &magEnd);

+

+   if (minStart < minEnd) {

+      if (tObj->MinFilter == GL_NEAREST) {

+         sample_nearest_rect(ctx, tObj, minEnd - minStart,

+                             texcoords + minStart, NULL, rgba + minStart);

+      }

+      else {

+         sample_linear_rect(ctx, tObj, minEnd - minStart,

+                            texcoords + minStart, NULL, rgba + minStart);

+      }

+   }

+   if (magStart < magEnd) {

+      if (tObj->MagFilter == GL_NEAREST) {

+         sample_nearest_rect(ctx, tObj, magEnd - magStart,

+                             texcoords + magStart, NULL, rgba + magStart);

+      }

+      else {

+         sample_linear_rect(ctx, tObj, magEnd - magStart,

+                            texcoords + magStart, NULL, rgba + magStart);

+      }

+   }

+}

+

+

+/**********************************************************************/

+/*                2D Texture Array Sampling Functions                 */

+/**********************************************************************/

+

+/**

+ * Return the texture sample for coordinate (s,t,r) using GL_NEAREST filter.

+ */

+static void

+sample_2d_array_nearest(struct gl_context *ctx,

+                        const struct gl_texture_object *tObj,

+                        const struct gl_texture_image *img,

+                        const GLfloat texcoord[4],

+                        GLfloat rgba[4])

+{

+   const GLint width = img->Width2;     /* without border, power of two */

+   const GLint height = img->Height2;   /* without border, power of two */

+   const GLint depth = img->Depth;

+   GLint i, j;

+   GLint array;

+   (void) ctx;

+

+   i = nearest_texel_location(tObj->WrapS, img, width, texcoord[0]);

+   j = nearest_texel_location(tObj->WrapT, img, height, texcoord[1]);

+   array = tex_array_slice(texcoord[2], depth);

+

+   if (i < 0 || i >= (GLint) img->Width ||

+       j < 0 || j >= (GLint) img->Height ||

+       array < 0 || array >= (GLint) img->Depth) {

+      /* Need this test for GL_CLAMP_TO_BORDER mode */

+      get_border_color(tObj, img, rgba);

+   }

+   else {

+      img->FetchTexelf(img, i, j, array, rgba);

+   }

+}

+

+

+/**

+ * Return the texture sample for coordinate (s,t,r) using GL_LINEAR filter.

+ */

+static void

+sample_2d_array_linear(struct gl_context *ctx,

+                       const struct gl_texture_object *tObj,

+                       const struct gl_texture_image *img,

+                       const GLfloat texcoord[4],

+                       GLfloat rgba[4])

+{

+   const GLint width = img->Width2;

+   const GLint height = img->Height2;

+   const GLint depth = img->Depth;

+   GLint i0, j0, i1, j1;

+   GLint array;

+   GLbitfield useBorderColor = 0x0;

+   GLfloat a, b;

+   GLfloat t00[4], t01[4], t10[4], t11[4];

+

+   linear_texel_locations(tObj->WrapS, img, width,  texcoord[0], &i0, &i1, &a);

+   linear_texel_locations(tObj->WrapT, img, height, texcoord[1], &j0, &j1, &b);

+   array = tex_array_slice(texcoord[2], depth);

+

+   if (array < 0 || array >= depth) {

+      COPY_4V(rgba, tObj->BorderColor.f);

+   }

+   else {

+      if (img->Border) {

+	 i0 += img->Border;

+	 i1 += img->Border;

+	 j0 += img->Border;

+	 j1 += img->Border;

+      }

+      else {

+	 /* check if sampling texture border color */

+	 if (i0 < 0 || i0 >= width)   useBorderColor |= I0BIT;

+	 if (i1 < 0 || i1 >= width)   useBorderColor |= I1BIT;

+	 if (j0 < 0 || j0 >= height)  useBorderColor |= J0BIT;

+	 if (j1 < 0 || j1 >= height)  useBorderColor |= J1BIT;

+      }

+

+      /* Fetch texels */

+      if (useBorderColor & (I0BIT | J0BIT)) {

+         get_border_color(tObj, img, t00);

+      }

+      else {

+	 img->FetchTexelf(img, i0, j0, array, t00);

+      }

+      if (useBorderColor & (I1BIT | J0BIT)) {

+         get_border_color(tObj, img, t10);

+      }

+      else {

+	 img->FetchTexelf(img, i1, j0, array, t10);

+      }

+      if (useBorderColor & (I0BIT | J1BIT)) {

+         get_border_color(tObj, img, t01);

+      }

+      else {

+	 img->FetchTexelf(img, i0, j1, array, t01);

+      }

+      if (useBorderColor & (I1BIT | J1BIT)) {

+         get_border_color(tObj, img, t11);

+      }

+      else {

+	 img->FetchTexelf(img, i1, j1, array, t11);

+      }

+      

+      /* trilinear interpolation of samples */

+      lerp_rgba_2d(rgba, a, b, t00, t10, t01, t11);

+   }

+}

+

+

+static void

+sample_2d_array_nearest_mipmap_nearest(struct gl_context *ctx,

+                                       const struct gl_texture_object *tObj,

+                                       GLuint n, const GLfloat texcoord[][4],

+                                       const GLfloat lambda[], GLfloat rgba[][4])

+{

+   GLuint i;

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

+      GLint level = nearest_mipmap_level(tObj, lambda[i]);

+      sample_2d_array_nearest(ctx, tObj, tObj->Image[0][level], texcoord[i],

+                              rgba[i]);

+   }

+}

+

+

+static void

+sample_2d_array_linear_mipmap_nearest(struct gl_context *ctx,

+                                      const struct gl_texture_object *tObj,

+                                      GLuint n, const GLfloat texcoord[][4],

+                                      const GLfloat lambda[], GLfloat rgba[][4])

+{

+   GLuint i;

+   ASSERT(lambda != NULL);

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

+      GLint level = nearest_mipmap_level(tObj, lambda[i]);

+      sample_2d_array_linear(ctx, tObj, tObj->Image[0][level],

+                             texcoord[i], rgba[i]);

+   }

+}

+

+

+static void

+sample_2d_array_nearest_mipmap_linear(struct gl_context *ctx,

+                                      const struct gl_texture_object *tObj,

+                                      GLuint n, const GLfloat texcoord[][4],

+                                      const GLfloat lambda[], GLfloat rgba[][4])

+{

+   GLuint i;

+   ASSERT(lambda != NULL);

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

+      GLint level = linear_mipmap_level(tObj, lambda[i]);

+      if (level >= tObj->_MaxLevel) {

+         sample_2d_array_nearest(ctx, tObj, tObj->Image[0][tObj->_MaxLevel],

+                                 texcoord[i], rgba[i]);

+      }

+      else {

+         GLfloat t0[4], t1[4];  /* texels */

+         const GLfloat f = FRAC(lambda[i]);

+         sample_2d_array_nearest(ctx, tObj, tObj->Image[0][level  ],

+                                 texcoord[i], t0);

+         sample_2d_array_nearest(ctx, tObj, tObj->Image[0][level+1],

+                                 texcoord[i], t1);

+         lerp_rgba(rgba[i], f, t0, t1);

+      }

+   }

+}

+

+

+static void

+sample_2d_array_linear_mipmap_linear(struct gl_context *ctx,

+                                     const struct gl_texture_object *tObj,

+                                     GLuint n, const GLfloat texcoord[][4],

+                                     const GLfloat lambda[], GLfloat rgba[][4])

+{

+   GLuint i;

+   ASSERT(lambda != NULL);

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

+      GLint level = linear_mipmap_level(tObj, lambda[i]);

+      if (level >= tObj->_MaxLevel) {

+         sample_2d_array_linear(ctx, tObj, tObj->Image[0][tObj->_MaxLevel],

+                          texcoord[i], rgba[i]);

+      }

+      else {

+         GLfloat t0[4], t1[4];  /* texels */

+         const GLfloat f = FRAC(lambda[i]);

+         sample_2d_array_linear(ctx, tObj, tObj->Image[0][level  ],

+                                texcoord[i], t0);

+         sample_2d_array_linear(ctx, tObj, tObj->Image[0][level+1],

+                                texcoord[i], t1);

+         lerp_rgba(rgba[i], f, t0, t1);

+      }

+   }

+}

+

+

+/** Sample 2D Array texture, nearest filtering for both min/magnification */

+static void

+sample_nearest_2d_array(struct gl_context *ctx,

+                        const struct gl_texture_object *tObj, GLuint n,

+                        const GLfloat texcoords[][4], const GLfloat lambda[],

+                        GLfloat rgba[][4])

+{

+   GLuint i;

+   struct gl_texture_image *image = tObj->Image[0][tObj->BaseLevel];

+   (void) lambda;

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

+      sample_2d_array_nearest(ctx, tObj, image, texcoords[i], rgba[i]);

+   }

+}

+

+

+

+/** Sample 2D Array texture, linear filtering for both min/magnification */

+static void

+sample_linear_2d_array(struct gl_context *ctx,

+                       const struct gl_texture_object *tObj, GLuint n,

+                       const GLfloat texcoords[][4],

+                       const GLfloat lambda[], GLfloat rgba[][4])

+{

+   GLuint i;

+   struct gl_texture_image *image = tObj->Image[0][tObj->BaseLevel];

+   (void) lambda;

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

+      sample_2d_array_linear(ctx, tObj, image, texcoords[i], rgba[i]);

+   }

+}

+

+

+/** Sample 2D Array texture, using lambda to choose between min/magnification */

+static void

+sample_lambda_2d_array(struct gl_context *ctx,

+                       const struct gl_texture_object *tObj, GLuint n,

+                       const GLfloat texcoords[][4], const GLfloat lambda[],

+                       GLfloat rgba[][4])

+{

+   GLuint minStart, minEnd;  /* texels with minification */

+   GLuint magStart, magEnd;  /* texels with magnification */

+   GLuint i;

+

+   ASSERT(lambda != NULL);

+   compute_min_mag_ranges(tObj, n, lambda,

+                          &minStart, &minEnd, &magStart, &magEnd);

+

+   if (minStart < minEnd) {

+      /* do the minified texels */

+      GLuint m = minEnd - minStart;

+      switch (tObj->MinFilter) {

+      case GL_NEAREST:

+         for (i = minStart; i < minEnd; i++)

+            sample_2d_array_nearest(ctx, tObj, tObj->Image[0][tObj->BaseLevel],

+                                    texcoords[i], rgba[i]);

+         break;

+      case GL_LINEAR:

+         for (i = minStart; i < minEnd; i++)

+            sample_2d_array_linear(ctx, tObj, tObj->Image[0][tObj->BaseLevel],

+                                   texcoords[i], rgba[i]);

+         break;

+      case GL_NEAREST_MIPMAP_NEAREST:

+         sample_2d_array_nearest_mipmap_nearest(ctx, tObj, m,

+                                                texcoords + minStart,

+                                                lambda + minStart,

+                                                rgba + minStart);

+         break;

+      case GL_LINEAR_MIPMAP_NEAREST:

+         sample_2d_array_linear_mipmap_nearest(ctx, tObj, m, 

+                                               texcoords + minStart,

+                                               lambda + minStart,

+                                               rgba + minStart);

+         break;

+      case GL_NEAREST_MIPMAP_LINEAR:

+         sample_2d_array_nearest_mipmap_linear(ctx, tObj, m,

+                                               texcoords + minStart,

+                                               lambda + minStart,

+                                               rgba + minStart);

+         break;

+      case GL_LINEAR_MIPMAP_LINEAR:

+         sample_2d_array_linear_mipmap_linear(ctx, tObj, m, 

+                                              texcoords + minStart,

+                                              lambda + minStart, 

+                                              rgba + minStart);

+         break;

+      default:

+         _mesa_problem(ctx, "Bad min filter in sample_2d_array_texture");

+         return;

+      }

+   }

+

+   if (magStart < magEnd) {

+      /* do the magnified texels */

+      switch (tObj->MagFilter) {

+      case GL_NEAREST:

+         for (i = magStart; i < magEnd; i++)

+            sample_2d_array_nearest(ctx, tObj, tObj->Image[0][tObj->BaseLevel],

+                              texcoords[i], rgba[i]);

+         break;

+      case GL_LINEAR:

+         for (i = magStart; i < magEnd; i++)

+            sample_2d_array_linear(ctx, tObj, tObj->Image[0][tObj->BaseLevel],

+                                   texcoords[i], rgba[i]);

+         break;

+      default:

+         _mesa_problem(ctx, "Bad mag filter in sample_2d_array_texture");

+         return;

+      }

+   }

+}

+

+

+

+

+/**********************************************************************/

+/*                1D Texture Array Sampling Functions                 */

+/**********************************************************************/

+

+/**

+ * Return the texture sample for coordinate (s,t,r) using GL_NEAREST filter.

+ */

+static void

+sample_1d_array_nearest(struct gl_context *ctx,

+                        const struct gl_texture_object *tObj,

+                        const struct gl_texture_image *img,

+                        const GLfloat texcoord[4],

+                        GLfloat rgba[4])

+{

+   const GLint width = img->Width2;     /* without border, power of two */

+   const GLint height = img->Height;

+   GLint i;

+   GLint array;

+   (void) ctx;

+

+   i = nearest_texel_location(tObj->WrapS, img, width, texcoord[0]);

+   array = tex_array_slice(texcoord[1], height);

+

+   if (i < 0 || i >= (GLint) img->Width ||

+       array < 0 || array >= (GLint) img->Height) {

+      /* Need this test for GL_CLAMP_TO_BORDER mode */

+      get_border_color(tObj, img, rgba);

+   }

+   else {

+      img->FetchTexelf(img, i, array, 0, rgba);

+   }

+}

+

+

+/**

+ * Return the texture sample for coordinate (s,t,r) using GL_LINEAR filter.

+ */

+static void

+sample_1d_array_linear(struct gl_context *ctx,

+                       const struct gl_texture_object *tObj,

+                       const struct gl_texture_image *img,

+                       const GLfloat texcoord[4],

+                       GLfloat rgba[4])

+{

+   const GLint width = img->Width2;

+   const GLint height = img->Height;

+   GLint i0, i1;

+   GLint array;

+   GLbitfield useBorderColor = 0x0;

+   GLfloat a;

+   GLfloat t0[4], t1[4];

+

+   linear_texel_locations(tObj->WrapS, img, width, texcoord[0], &i0, &i1, &a);

+   array = tex_array_slice(texcoord[1], height);

+

+   if (img->Border) {

+      i0 += img->Border;

+      i1 += img->Border;

+   }

+   else {

+      /* check if sampling texture border color */

+      if (i0 < 0 || i0 >= width)   useBorderColor |= I0BIT;

+      if (i1 < 0 || i1 >= width)   useBorderColor |= I1BIT;

+   }

+

+   if (array < 0 || array >= height)   useBorderColor |= K0BIT;

+

+   /* Fetch texels */

+   if (useBorderColor & (I0BIT | K0BIT)) {

+      get_border_color(tObj, img, t0);

+   }

+   else {

+      img->FetchTexelf(img, i0, array, 0, t0);

+   }

+   if (useBorderColor & (I1BIT | K0BIT)) {

+      get_border_color(tObj, img, t1);

+   }

+   else {

+      img->FetchTexelf(img, i1, array, 0, t1);

+   }

+

+   /* bilinear interpolation of samples */

+   lerp_rgba(rgba, a, t0, t1);

+}

+

+

+static void

+sample_1d_array_nearest_mipmap_nearest(struct gl_context *ctx,

+                                       const struct gl_texture_object *tObj,

+                                       GLuint n, const GLfloat texcoord[][4],

+                                       const GLfloat lambda[], GLfloat rgba[][4])

+{

+   GLuint i;

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

+      GLint level = nearest_mipmap_level(tObj, lambda[i]);

+      sample_1d_array_nearest(ctx, tObj, tObj->Image[0][level], texcoord[i],

+                              rgba[i]);

+   }

+}

+

+

+static void

+sample_1d_array_linear_mipmap_nearest(struct gl_context *ctx,

+                                      const struct gl_texture_object *tObj,

+                                      GLuint n, const GLfloat texcoord[][4],

+                                      const GLfloat lambda[], GLfloat rgba[][4])

+{

+   GLuint i;

+   ASSERT(lambda != NULL);

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

+      GLint level = nearest_mipmap_level(tObj, lambda[i]);

+      sample_1d_array_linear(ctx, tObj, tObj->Image[0][level],

+                             texcoord[i], rgba[i]);

+   }

+}

+

+

+static void

+sample_1d_array_nearest_mipmap_linear(struct gl_context *ctx,

+                                      const struct gl_texture_object *tObj,

+                                      GLuint n, const GLfloat texcoord[][4],

+                                      const GLfloat lambda[], GLfloat rgba[][4])

+{

+   GLuint i;

+   ASSERT(lambda != NULL);

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

+      GLint level = linear_mipmap_level(tObj, lambda[i]);

+      if (level >= tObj->_MaxLevel) {

+         sample_1d_array_nearest(ctx, tObj, tObj->Image[0][tObj->_MaxLevel],

+                                 texcoord[i], rgba[i]);

+      }

+      else {

+         GLfloat t0[4], t1[4];  /* texels */

+         const GLfloat f = FRAC(lambda[i]);

+         sample_1d_array_nearest(ctx, tObj, tObj->Image[0][level  ], texcoord[i], t0);

+         sample_1d_array_nearest(ctx, tObj, tObj->Image[0][level+1], texcoord[i], t1);

+         lerp_rgba(rgba[i], f, t0, t1);

+      }

+   }

+}

+

+

+static void

+sample_1d_array_linear_mipmap_linear(struct gl_context *ctx,

+                                     const struct gl_texture_object *tObj,

+                                     GLuint n, const GLfloat texcoord[][4],

+                                     const GLfloat lambda[], GLfloat rgba[][4])

+{

+   GLuint i;

+   ASSERT(lambda != NULL);

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

+      GLint level = linear_mipmap_level(tObj, lambda[i]);

+      if (level >= tObj->_MaxLevel) {

+         sample_1d_array_linear(ctx, tObj, tObj->Image[0][tObj->_MaxLevel],

+                          texcoord[i], rgba[i]);

+      }

+      else {

+         GLfloat t0[4], t1[4];  /* texels */

+         const GLfloat f = FRAC(lambda[i]);

+         sample_1d_array_linear(ctx, tObj, tObj->Image[0][level  ], texcoord[i], t0);

+         sample_1d_array_linear(ctx, tObj, tObj->Image[0][level+1], texcoord[i], t1);

+         lerp_rgba(rgba[i], f, t0, t1);

+      }

+   }

+}

+

+

+/** Sample 1D Array texture, nearest filtering for both min/magnification */

+static void

+sample_nearest_1d_array(struct gl_context *ctx,

+                        const struct gl_texture_object *tObj, GLuint n,

+                        const GLfloat texcoords[][4], const GLfloat lambda[],

+                        GLfloat rgba[][4])

+{

+   GLuint i;

+   struct gl_texture_image *image = tObj->Image[0][tObj->BaseLevel];

+   (void) lambda;

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

+      sample_1d_array_nearest(ctx, tObj, image, texcoords[i], rgba[i]);

+   }

+}

+

+

+/** Sample 1D Array texture, linear filtering for both min/magnification */

+static void

+sample_linear_1d_array(struct gl_context *ctx,

+                       const struct gl_texture_object *tObj, GLuint n,

+                       const GLfloat texcoords[][4],

+                       const GLfloat lambda[], GLfloat rgba[][4])

+{

+   GLuint i;

+   struct gl_texture_image *image = tObj->Image[0][tObj->BaseLevel];

+   (void) lambda;

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

+      sample_1d_array_linear(ctx, tObj, image, texcoords[i], rgba[i]);

+   }

+}

+

+

+/** Sample 1D Array texture, using lambda to choose between min/magnification */

+static void

+sample_lambda_1d_array(struct gl_context *ctx,

+                       const struct gl_texture_object *tObj, GLuint n,

+                       const GLfloat texcoords[][4], const GLfloat lambda[],

+                       GLfloat rgba[][4])

+{

+   GLuint minStart, minEnd;  /* texels with minification */

+   GLuint magStart, magEnd;  /* texels with magnification */

+   GLuint i;

+

+   ASSERT(lambda != NULL);

+   compute_min_mag_ranges(tObj, n, lambda,

+                          &minStart, &minEnd, &magStart, &magEnd);

+

+   if (minStart < minEnd) {

+      /* do the minified texels */

+      GLuint m = minEnd - minStart;

+      switch (tObj->MinFilter) {

+      case GL_NEAREST:

+         for (i = minStart; i < minEnd; i++)

+            sample_1d_array_nearest(ctx, tObj, tObj->Image[0][tObj->BaseLevel],

+                                    texcoords[i], rgba[i]);

+         break;

+      case GL_LINEAR:

+         for (i = minStart; i < minEnd; i++)

+            sample_1d_array_linear(ctx, tObj, tObj->Image[0][tObj->BaseLevel],

+                                   texcoords[i], rgba[i]);

+         break;

+      case GL_NEAREST_MIPMAP_NEAREST:

+         sample_1d_array_nearest_mipmap_nearest(ctx, tObj, m, texcoords + minStart,

+                                                lambda + minStart, rgba + minStart);

+         break;

+      case GL_LINEAR_MIPMAP_NEAREST:

+         sample_1d_array_linear_mipmap_nearest(ctx, tObj, m, 

+                                               texcoords + minStart,

+                                               lambda + minStart,

+                                               rgba + minStart);

+         break;

+      case GL_NEAREST_MIPMAP_LINEAR:

+         sample_1d_array_nearest_mipmap_linear(ctx, tObj, m, texcoords + minStart,

+                                               lambda + minStart, rgba + minStart);

+         break;

+      case GL_LINEAR_MIPMAP_LINEAR:

+         sample_1d_array_linear_mipmap_linear(ctx, tObj, m, 

+                                              texcoords + minStart,

+                                              lambda + minStart, 

+                                              rgba + minStart);

+         break;

+      default:

+         _mesa_problem(ctx, "Bad min filter in sample_1d_array_texture");

+         return;

+      }

+   }

+

+   if (magStart < magEnd) {

+      /* do the magnified texels */

+      switch (tObj->MagFilter) {

+      case GL_NEAREST:

+         for (i = magStart; i < magEnd; i++)

+            sample_1d_array_nearest(ctx, tObj, tObj->Image[0][tObj->BaseLevel],

+                              texcoords[i], rgba[i]);

+         break;

+      case GL_LINEAR:

+         for (i = magStart; i < magEnd; i++)

+            sample_1d_array_linear(ctx, tObj, tObj->Image[0][tObj->BaseLevel],

+                                   texcoords[i], rgba[i]);

+         break;

+      default:

+         _mesa_problem(ctx, "Bad mag filter in sample_1d_array_texture");

+         return;

+      }

+   }

+}

+

+

+/**

+ * Compare texcoord against depth sample.  Return 1.0 or the ambient value.

+ */

+static INLINE GLfloat

+shadow_compare(GLenum function, GLfloat coord, GLfloat depthSample,

+               GLfloat ambient)

+{

+   switch (function) {

+   case GL_LEQUAL:

+      return (coord <= depthSample) ? 1.0F : ambient;

+   case GL_GEQUAL:

+      return (coord >= depthSample) ? 1.0F : ambient;

+   case GL_LESS:

+      return (coord < depthSample) ? 1.0F : ambient;

+   case GL_GREATER:

+      return (coord > depthSample) ? 1.0F : ambient;

+   case GL_EQUAL:

+      return (coord == depthSample) ? 1.0F : ambient;

+   case GL_NOTEQUAL:

+      return (coord != depthSample) ? 1.0F : ambient;

+   case GL_ALWAYS:

+      return 1.0F;

+   case GL_NEVER:

+      return ambient;

+   case GL_NONE:

+      return depthSample;

+   default:

+      _mesa_problem(NULL, "Bad compare func in shadow_compare");

+      return ambient;

+   }

+}

+

+

+/**

+ * Compare texcoord against four depth samples.

+ */

+static INLINE GLfloat

+shadow_compare4(GLenum function, GLfloat coord,

+                GLfloat depth00, GLfloat depth01,

+                GLfloat depth10, GLfloat depth11,

+                GLfloat ambient, GLfloat wi, GLfloat wj)

+{

+   const GLfloat d = (1.0F - (GLfloat) ambient) * 0.25F;

+   GLfloat luminance = 1.0F;

+

+   switch (function) {

+   case GL_LEQUAL:

+      if (depth00 <= coord)  luminance -= d;

+      if (depth01 <= coord)  luminance -= d;

+      if (depth10 <= coord)  luminance -= d;

+      if (depth11 <= coord)  luminance -= d;

+      return luminance;

+   case GL_GEQUAL:

+      if (depth00 >= coord)  luminance -= d;

+      if (depth01 >= coord)  luminance -= d;

+      if (depth10 >= coord)  luminance -= d;

+      if (depth11 >= coord)  luminance -= d;

+      return luminance;

+   case GL_LESS:

+      if (depth00 < coord)  luminance -= d;

+      if (depth01 < coord)  luminance -= d;

+      if (depth10 < coord)  luminance -= d;

+      if (depth11 < coord)  luminance -= d;

+      return luminance;

+   case GL_GREATER:

+      if (depth00 > coord)  luminance -= d;

+      if (depth01 > coord)  luminance -= d;

+      if (depth10 > coord)  luminance -= d;

+      if (depth11 > coord)  luminance -= d;

+      return luminance;

+   case GL_EQUAL:

+      if (depth00 == coord)  luminance -= d;

+      if (depth01 == coord)  luminance -= d;

+      if (depth10 == coord)  luminance -= d;

+      if (depth11 == coord)  luminance -= d;

+      return luminance;

+   case GL_NOTEQUAL:

+      if (depth00 != coord)  luminance -= d;

+      if (depth01 != coord)  luminance -= d;

+      if (depth10 != coord)  luminance -= d;

+      if (depth11 != coord)  luminance -= d;

+      return luminance;

+   case GL_ALWAYS:

+      return 0.0;

+   case GL_NEVER:

+      return ambient;

+   case GL_NONE:

+      /* ordinary bilinear filtering */

+      return lerp_2d(wi, wj, depth00, depth10, depth01, depth11);

+   default:

+      _mesa_problem(NULL, "Bad compare func in sample_depth_texture");

+      return 0.0F;

+   }

+}

+

+

+/**

+ * Choose the mipmap level to use when sampling from a depth texture.

+ */

+static int

+choose_depth_texture_level(const struct gl_texture_object *tObj, GLfloat lambda)

+{

+   GLint level;

+

+   if (tObj->MinFilter == GL_NEAREST || tObj->MinFilter == GL_LINEAR) {

+      /* no mipmapping - use base level */

+      level = tObj->BaseLevel;

+   }

+   else {

+      /* choose mipmap level */

+      lambda = CLAMP(lambda, tObj->MinLod, tObj->MaxLod);

+      level = (GLint) lambda;

+      level = CLAMP(level, tObj->BaseLevel, tObj->_MaxLevel);

+   }

+

+   return level;

+}

+

+

+/**

+ * Sample a shadow/depth texture.  This function is incomplete.  It doesn't

+ * check for minification vs. magnification, etc.

+ */

+static void

+sample_depth_texture( struct gl_context *ctx,

+                      const struct gl_texture_object *tObj, GLuint n,

+                      const GLfloat texcoords[][4], const GLfloat lambda[],

+                      GLfloat texel[][4] )

+{

+   const GLint level = choose_depth_texture_level(tObj, lambda[0]);

+   const struct gl_texture_image *img = tObj->Image[0][level];

+   const GLint width = img->Width;

+   const GLint height = img->Height;

+   const GLint depth = img->Depth;

+   const GLuint compare_coord = (tObj->Target == GL_TEXTURE_2D_ARRAY_EXT)

+       ? 3 : 2;

+   GLfloat ambient;

+   GLenum function;

+   GLfloat result;

+

+   ASSERT(img->_BaseFormat == GL_DEPTH_COMPONENT ||

+          img->_BaseFormat == GL_DEPTH_STENCIL_EXT);

+

+   ASSERT(tObj->Target == GL_TEXTURE_1D ||

+          tObj->Target == GL_TEXTURE_2D ||

+          tObj->Target == GL_TEXTURE_RECTANGLE_NV ||

+          tObj->Target == GL_TEXTURE_1D_ARRAY_EXT ||

+          tObj->Target == GL_TEXTURE_2D_ARRAY_EXT);

+

+   ambient = tObj->CompareFailValue;

+

+   /* XXXX if tObj->MinFilter != tObj->MagFilter, we're ignoring lambda */

+

+   function = (tObj->CompareMode == GL_COMPARE_R_TO_TEXTURE_ARB) ?

+      tObj->CompareFunc : GL_NONE;

+

+   if (tObj->MagFilter == GL_NEAREST) {

+      GLuint i;

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

+         GLfloat depthSample;

+         GLint col, row, slice;

+

+         nearest_texcoord(tObj, level, texcoords[i], &col, &row, &slice);

+

+         if (col >= 0 && row >= 0 && col < width && row < height && 

+             slice >= 0 && slice < depth) {

+            img->FetchTexelf(img, col, row, slice, &depthSample);

+         }

+         else {

+            depthSample = tObj->BorderColor.f[0];

+         }

+

+         result = shadow_compare(function, texcoords[i][compare_coord],

+                                 depthSample, ambient);

+

+         switch (tObj->DepthMode) {

+         case GL_LUMINANCE:

+            ASSIGN_4V(texel[i], result, result, result, 1.0F);

+            break;

+         case GL_INTENSITY:

+            ASSIGN_4V(texel[i], result, result, result, result);

+            break;

+         case GL_ALPHA:

+            ASSIGN_4V(texel[i], 0.0F, 0.0F, 0.0F, result);

+            break;

+         case GL_RED:

+            ASSIGN_4V(texel[i], result, 0.0F, 0.0F, 1.0F);

+            break;

+         default:

+            _mesa_problem(ctx, "Bad depth texture mode");

+         }

+      }

+   }

+   else {

+      GLuint i;

+      ASSERT(tObj->MagFilter == GL_LINEAR);

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

+         GLfloat depth00, depth01, depth10, depth11;

+         GLint i0, i1, j0, j1;

+         GLint slice;

+         GLfloat wi, wj;

+         GLuint useBorderTexel;

+

+         linear_texcoord(tObj, level, texcoords[i], &i0, &i1, &j0, &j1, &slice,

+                         &wi, &wj);

+

+         useBorderTexel = 0;

+         if (img->Border) {

+            i0 += img->Border;

+            i1 += img->Border;

+            if (tObj->Target != GL_TEXTURE_1D_ARRAY_EXT) {

+               j0 += img->Border;

+               j1 += img->Border;

+            }

+         }

+         else {

+            if (i0 < 0 || i0 >= (GLint) width)   useBorderTexel |= I0BIT;

+            if (i1 < 0 || i1 >= (GLint) width)   useBorderTexel |= I1BIT;

+            if (j0 < 0 || j0 >= (GLint) height)  useBorderTexel |= J0BIT;

+            if (j1 < 0 || j1 >= (GLint) height)  useBorderTexel |= J1BIT;

+         }

+

+         if (slice < 0 || slice >= (GLint) depth) {

+            depth00 = tObj->BorderColor.f[0];

+            depth01 = tObj->BorderColor.f[0];

+            depth10 = tObj->BorderColor.f[0];

+            depth11 = tObj->BorderColor.f[0];

+         }

+         else {

+            /* get four depth samples from the texture */

+            if (useBorderTexel & (I0BIT | J0BIT)) {

+               depth00 = tObj->BorderColor.f[0];

+            }

+            else {

+               img->FetchTexelf(img, i0, j0, slice, &depth00);

+            }

+            if (useBorderTexel & (I1BIT | J0BIT)) {

+               depth10 = tObj->BorderColor.f[0];

+            }

+            else {

+               img->FetchTexelf(img, i1, j0, slice, &depth10);

+            }

+

+            if (tObj->Target != GL_TEXTURE_1D_ARRAY_EXT) {

+               if (useBorderTexel & (I0BIT | J1BIT)) {

+                  depth01 = tObj->BorderColor.f[0];

+               }

+               else {

+                  img->FetchTexelf(img, i0, j1, slice, &depth01);

+               }

+               if (useBorderTexel & (I1BIT | J1BIT)) {

+                  depth11 = tObj->BorderColor.f[0];

+               }

+               else {

+                  img->FetchTexelf(img, i1, j1, slice, &depth11);

+               }

+            }

+            else {

+               depth01 = depth00;

+               depth11 = depth10;

+            }

+         }

+

+         result = shadow_compare4(function, texcoords[i][compare_coord],

+                                  depth00, depth01, depth10, depth11,

+                                  ambient, wi, wj);

+

+         switch (tObj->DepthMode) {

+         case GL_LUMINANCE:

+            ASSIGN_4V(texel[i], result, result, result, 1.0F);

+            break;

+         case GL_INTENSITY:

+            ASSIGN_4V(texel[i], result, result, result, result);

+            break;

+         case GL_ALPHA:

+            ASSIGN_4V(texel[i], 0.0F, 0.0F, 0.0F, result);

+            break;

+         default:

+            _mesa_problem(ctx, "Bad depth texture mode");

+         }

+

+      }  /* for */

+   }  /* if filter */

+}

+

+

+/**

+ * We use this function when a texture object is in an "incomplete" state.

+ * When a fragment program attempts to sample an incomplete texture we

+ * return black (see issue 23 in GL_ARB_fragment_program spec).

+ * Note: fragment programs don't observe the texture enable/disable flags.

+ */

+static void

+null_sample_func( struct gl_context *ctx,

+		  const struct gl_texture_object *tObj, GLuint n,

+		  const GLfloat texcoords[][4], const GLfloat lambda[],

+		  GLfloat rgba[][4])

+{

+   GLuint i;

+   (void) ctx;

+   (void) tObj;

+   (void) texcoords;

+   (void) lambda;

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

+      rgba[i][RCOMP] = 0;

+      rgba[i][GCOMP] = 0;

+      rgba[i][BCOMP] = 0;

+      rgba[i][ACOMP] = 1.0;

+   }

+}

+

+

+/**

+ * Choose the texture sampling function for the given texture object.

+ */

+texture_sample_func

+_swrast_choose_texture_sample_func( struct gl_context *ctx,

+				    const struct gl_texture_object *t )

+{

+   if (!t || !t->_Complete) {

+      return &null_sample_func;

+   }

+   else {

+      const GLboolean needLambda = (GLboolean) (t->MinFilter != t->MagFilter);

+      const GLenum format = t->Image[0][t->BaseLevel]->_BaseFormat;

+

+      switch (t->Target) {

+      case GL_TEXTURE_1D:

+         if (format == GL_DEPTH_COMPONENT || format == GL_DEPTH_STENCIL_EXT) {

+            return &sample_depth_texture;

+         }

+         else if (needLambda) {

+            return &sample_lambda_1d;

+         }

+         else if (t->MinFilter == GL_LINEAR) {

+            return &sample_linear_1d;

+         }

+         else {

+            ASSERT(t->MinFilter == GL_NEAREST);

+            return &sample_nearest_1d;

+         }

+      case GL_TEXTURE_2D:

+         if (format == GL_DEPTH_COMPONENT || format == GL_DEPTH_STENCIL_EXT) {

+            return &sample_depth_texture;

+         }

+         else if (needLambda) {

+            return &sample_lambda_2d;

+         }

+         else if (t->MinFilter == GL_LINEAR) {

+            return &sample_linear_2d;

+         }

+         else {

+            /* check for a few optimized cases */

+            const struct gl_texture_image *img = t->Image[0][t->BaseLevel];

+            ASSERT(t->MinFilter == GL_NEAREST);

+            if (t->WrapS == GL_REPEAT &&

+                t->WrapT == GL_REPEAT &&

+                img->_IsPowerOfTwo &&

+                img->Border == 0 &&

+                img->TexFormat == MESA_FORMAT_RGB888) {

+               return &opt_sample_rgb_2d;

+            }

+            else if (t->WrapS == GL_REPEAT &&

+                     t->WrapT == GL_REPEAT &&

+                     img->_IsPowerOfTwo &&

+                     img->Border == 0 &&

+                     img->TexFormat == MESA_FORMAT_RGBA8888) {

+               return &opt_sample_rgba_2d;

+            }

+            else {

+               return &sample_nearest_2d;

+            }

+         }

+      case GL_TEXTURE_3D:

+         if (needLambda) {

+            return &sample_lambda_3d;

+         }

+         else if (t->MinFilter == GL_LINEAR) {

+            return &sample_linear_3d;

+         }

+         else {

+            ASSERT(t->MinFilter == GL_NEAREST);

+            return &sample_nearest_3d;

+         }

+      case GL_TEXTURE_CUBE_MAP:

+         if (needLambda) {

+            return &sample_lambda_cube;

+         }

+         else if (t->MinFilter == GL_LINEAR) {

+            return &sample_linear_cube;

+         }

+         else {

+            ASSERT(t->MinFilter == GL_NEAREST);

+            return &sample_nearest_cube;

+         }

+      case GL_TEXTURE_RECTANGLE_NV:

+         if (format == GL_DEPTH_COMPONENT || format == GL_DEPTH_STENCIL_EXT) {

+            return &sample_depth_texture;

+         }

+         else if (needLambda) {

+            return &sample_lambda_rect;

+         }

+         else if (t->MinFilter == GL_LINEAR) {

+            return &sample_linear_rect;

+         }

+         else {

+            ASSERT(t->MinFilter == GL_NEAREST);

+            return &sample_nearest_rect;

+         }

+      case GL_TEXTURE_1D_ARRAY_EXT:

+         if (needLambda) {

+            return &sample_lambda_1d_array;

+         }

+         else if (t->MinFilter == GL_LINEAR) {

+            return &sample_linear_1d_array;

+         }

+         else {

+            ASSERT(t->MinFilter == GL_NEAREST);

+            return &sample_nearest_1d_array;

+         }

+      case GL_TEXTURE_2D_ARRAY_EXT:

+         if (needLambda) {

+            return &sample_lambda_2d_array;

+         }

+         else if (t->MinFilter == GL_LINEAR) {

+            return &sample_linear_2d_array;

+         }

+         else {

+            ASSERT(t->MinFilter == GL_NEAREST);

+            return &sample_nearest_2d_array;

+         }

+      default:

+         _mesa_problem(ctx,

+                       "invalid target in _swrast_choose_texture_sample_func");

+         return &null_sample_func;

+      }

+   }

+}

diff --git a/mesalib/src/mesa/swrast/s_texfilter.h b/mesalib/src/mesa/swrast/s_texfilter.h
index eceab5965..fd7e5776f 100644
--- a/mesalib/src/mesa/swrast/s_texfilter.h
+++ b/mesalib/src/mesa/swrast/s_texfilter.h
@@ -1,39 +1,41 @@
-/*
- * Mesa 3-D graphics library
- * Version:  6.5
- *
- * Copyright (C) 1999-2005  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.
- */
-
-
-#ifndef S_TEXFILTER_H
-#define S_TEXFILTER_H
-
-
-#include "main/mtypes.h"
-#include "s_context.h"
-
-
-extern texture_sample_func
-_swrast_choose_texture_sample_func( GLcontext *ctx,
-				    const struct gl_texture_object *tObj );
-
-
-#endif
+/*

+ * Mesa 3-D graphics library

+ * Version:  6.5

+ *

+ * Copyright (C) 1999-2005  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.

+ */

+

+

+#ifndef S_TEXFILTER_H

+#define S_TEXFILTER_H

+

+

+#include "s_context.h"

+

+struct gl_context;

+struct gl_texture_object;

+

+

+extern texture_sample_func

+_swrast_choose_texture_sample_func( struct gl_context *ctx,

+				    const struct gl_texture_object *tObj );

+

+

+#endif

diff --git a/mesalib/src/mesa/swrast/s_triangle.c b/mesalib/src/mesa/swrast/s_triangle.c
index d1b369bcd..93826b7ce 100644
--- a/mesalib/src/mesa/swrast/s_triangle.c
+++ b/mesalib/src/mesa/swrast/s_triangle.c
@@ -1,1142 +1,1142 @@
-/*
- * Mesa 3-D graphics library
- * Version:  7.3
- *
- * 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.
- */
-
-
-/*
- * When the device driver doesn't implement triangle rasterization it
- * can hook in _swrast_Triangle, which eventually calls one of these
- * functions to draw triangles.
- */
-
-#include "main/glheader.h"
-#include "main/context.h"
-#include "main/colormac.h"
-#include "main/imports.h"
-#include "main/macros.h"
-#include "main/texformat.h"
-#include "program/prog_instruction.h"
-
-#include "s_aatriangle.h"
-#include "s_context.h"
-#include "s_feedback.h"
-#include "s_span.h"
-#include "s_triangle.h"
-
-
-/**
- * Test if a triangle should be culled.  Used for feedback and selection mode.
- * \return GL_TRUE if the triangle is to be culled, GL_FALSE otherwise.
- */
-GLboolean
-_swrast_culltriangle( GLcontext *ctx,
-                      const SWvertex *v0,
-                      const SWvertex *v1,
-                      const SWvertex *v2 )
-{
-   SWcontext *swrast = SWRAST_CONTEXT(ctx);
-   GLfloat ex = v1->attrib[FRAG_ATTRIB_WPOS][0] - v0->attrib[FRAG_ATTRIB_WPOS][0];
-   GLfloat ey = v1->attrib[FRAG_ATTRIB_WPOS][1] - v0->attrib[FRAG_ATTRIB_WPOS][1];
-   GLfloat fx = v2->attrib[FRAG_ATTRIB_WPOS][0] - v0->attrib[FRAG_ATTRIB_WPOS][0];
-   GLfloat fy = v2->attrib[FRAG_ATTRIB_WPOS][1] - v0->attrib[FRAG_ATTRIB_WPOS][1];
-   GLfloat c = ex*fy-ey*fx;
-
-   if (c * swrast->_BackfaceSign * swrast->_BackfaceCullSign <= 0.0F)
-      return GL_FALSE;
-
-   return GL_TRUE;
-}
-
-
-
-/*
- * Render a flat-shaded RGBA triangle.
- */
-#define NAME flat_rgba_triangle
-#define INTERP_Z 1
-#define SETUP_CODE				\
-   ASSERT(ctx->Texture._EnabledCoordUnits == 0);\
-   ASSERT(ctx->Light.ShadeModel==GL_FLAT);	\
-   span.interpMask |= SPAN_RGBA;		\
-   span.red = ChanToFixed(v2->color[0]);	\
-   span.green = ChanToFixed(v2->color[1]);	\
-   span.blue = ChanToFixed(v2->color[2]);	\
-   span.alpha = ChanToFixed(v2->color[3]);	\
-   span.redStep = 0;				\
-   span.greenStep = 0;				\
-   span.blueStep = 0;				\
-   span.alphaStep = 0;
-#define RENDER_SPAN( span )  _swrast_write_rgba_span(ctx, &span);
-#include "s_tritemp.h"
-
-
-
-/*
- * Render a smooth-shaded RGBA triangle.
- */
-#define NAME smooth_rgba_triangle
-#define INTERP_Z 1
-#define INTERP_RGB 1
-#define INTERP_ALPHA 1
-#define SETUP_CODE				\
-   {						\
-      /* texturing must be off */		\
-      ASSERT(ctx->Texture._EnabledCoordUnits == 0);	\
-      ASSERT(ctx->Light.ShadeModel==GL_SMOOTH);	\
-   }
-#define RENDER_SPAN( span )  _swrast_write_rgba_span(ctx, &span);
-#include "s_tritemp.h"
-
-
-
-/*
- * Render an RGB, GL_DECAL, textured triangle.
- * Interpolate S,T only w/out mipmapping or perspective correction.
- *
- * No fog.  No depth testing.
- */
-#define NAME simple_textured_triangle
-#define INTERP_INT_TEX 1
-#define S_SCALE twidth
-#define T_SCALE theight
-
-#define SETUP_CODE							\
-   struct gl_renderbuffer *rb = ctx->DrawBuffer->_ColorDrawBuffers[0];	\
-   const struct gl_texture_object *obj = 				\
-      ctx->Texture.Unit[0].CurrentTex[TEXTURE_2D_INDEX];		\
-   const struct gl_texture_image *texImg =				\
-      obj->Image[0][obj->BaseLevel];					\
-   const GLfloat twidth = (GLfloat) texImg->Width;			\
-   const GLfloat theight = (GLfloat) texImg->Height;			\
-   const GLint twidth_log2 = texImg->WidthLog2;				\
-   const GLubyte *texture = (const GLubyte *) texImg->Data;		\
-   const GLint smask = texImg->Width - 1;				\
-   const GLint tmask = texImg->Height - 1;				\
-   ASSERT(texImg->TexFormat == MESA_FORMAT_RGB888);			\
-   if (!rb || !texture) {						\
-      return;								\
-   }
-
-#define RENDER_SPAN( span )						\
-   GLuint i;								\
-   GLubyte rgb[MAX_WIDTH][3];						\
-   span.intTex[0] -= FIXED_HALF; /* off-by-one error? */		\
-   span.intTex[1] -= FIXED_HALF;					\
-   for (i = 0; i < span.end; i++) {					\
-      GLint s = FixedToInt(span.intTex[0]) & smask;			\
-      GLint t = FixedToInt(span.intTex[1]) & tmask;			\
-      GLint pos = (t << twidth_log2) + s;				\
-      pos = pos + pos + pos;  /* multiply by 3 */			\
-      rgb[i][RCOMP] = texture[pos+2];					\
-      rgb[i][GCOMP] = texture[pos+1];					\
-      rgb[i][BCOMP] = texture[pos+0];					\
-      span.intTex[0] += span.intTexStep[0];				\
-      span.intTex[1] += span.intTexStep[1];				\
-   }									\
-   rb->PutRowRGB(ctx, rb, span.end, span.x, span.y, rgb, NULL);
-
-#include "s_tritemp.h"
-
-
-
-/*
- * Render an RGB, GL_DECAL, textured triangle.
- * Interpolate S,T, GL_LESS depth test, w/out mipmapping or
- * perspective correction.
- * Depth buffer bits must be <= sizeof(DEFAULT_SOFTWARE_DEPTH_TYPE)
- *
- * No fog.
- */
-#define NAME simple_z_textured_triangle
-#define INTERP_Z 1
-#define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE
-#define INTERP_INT_TEX 1
-#define S_SCALE twidth
-#define T_SCALE theight
-
-#define SETUP_CODE							\
-   struct gl_renderbuffer *rb = ctx->DrawBuffer->_ColorDrawBuffers[0];	\
-   const struct gl_texture_object *obj = 				\
-      ctx->Texture.Unit[0].CurrentTex[TEXTURE_2D_INDEX];		\
-   const struct gl_texture_image *texImg = 				\
-       obj->Image[0][obj->BaseLevel]; 					\
-   const GLfloat twidth = (GLfloat) texImg->Width;			\
-   const GLfloat theight = (GLfloat) texImg->Height;			\
-   const GLint twidth_log2 = texImg->WidthLog2;				\
-   const GLubyte *texture = (const GLubyte *) texImg->Data;		\
-   const GLint smask = texImg->Width - 1;				\
-   const GLint tmask = texImg->Height - 1;				\
-   ASSERT(texImg->TexFormat == MESA_FORMAT_RGB888);			\
-   if (!rb || !texture) {						\
-      return;								\
-   }
-
-#define RENDER_SPAN( span )						\
-   GLuint i;				    				\
-   GLubyte rgb[MAX_WIDTH][3];						\
-   span.intTex[0] -= FIXED_HALF; /* off-by-one error? */		\
-   span.intTex[1] -= FIXED_HALF;					\
-   for (i = 0; i < span.end; i++) {					\
-      const GLuint z = FixedToDepth(span.z);				\
-      if (z < zRow[i]) {						\
-         GLint s = FixedToInt(span.intTex[0]) & smask;			\
-         GLint t = FixedToInt(span.intTex[1]) & tmask;			\
-         GLint pos = (t << twidth_log2) + s;				\
-         pos = pos + pos + pos;  /* multiply by 3 */			\
-         rgb[i][RCOMP] = texture[pos+2];				\
-         rgb[i][GCOMP] = texture[pos+1];				\
-         rgb[i][BCOMP] = texture[pos+0];				\
-         zRow[i] = z;							\
-         span.array->mask[i] = 1;					\
-      }									\
-      else {								\
-         span.array->mask[i] = 0;					\
-      }									\
-      span.intTex[0] += span.intTexStep[0];				\
-      span.intTex[1] += span.intTexStep[1];				\
-      span.z += span.zStep;						\
-   }									\
-   rb->PutRowRGB(ctx, rb, span.end, span.x, span.y, rgb, span.array->mask);
-
-#include "s_tritemp.h"
-
-
-#if CHAN_TYPE != GL_FLOAT
-
-struct affine_info
-{
-   GLenum filter;
-   GLenum format;
-   GLenum envmode;
-   GLint smask, tmask;
-   GLint twidth_log2;
-   const GLchan *texture;
-   GLfixed er, eg, eb, ea;
-   GLint tbytesline, tsize;
-};
-
-
-static INLINE GLint
-ilerp(GLint t, GLint a, GLint b)
-{
-   return a + ((t * (b - a)) >> FIXED_SHIFT);
-}
-
-static INLINE GLint
-ilerp_2d(GLint ia, GLint ib, GLint v00, GLint v10, GLint v01, GLint v11)
-{
-   const GLint temp0 = ilerp(ia, v00, v10);
-   const GLint temp1 = ilerp(ia, v01, v11);
-   return ilerp(ib, temp0, temp1);
-}
-
-
-/* This function can handle GL_NEAREST or GL_LINEAR sampling of 2D RGB or RGBA
- * textures with GL_REPLACE, GL_MODULATE, GL_BLEND, GL_DECAL or GL_ADD
- * texture env modes.
- */
-static INLINE void
-affine_span(GLcontext *ctx, SWspan *span,
-            struct affine_info *info)
-{
-   GLchan sample[4];  /* the filtered texture sample */
-   const GLuint texEnableSave = ctx->Texture._EnabledCoordUnits;
-
-   /* Instead of defining a function for each mode, a test is done
-    * between the outer and inner loops. This is to reduce code size
-    * and complexity. Observe that an optimizing compiler kills
-    * unused variables (for instance tf,sf,ti,si in case of GL_NEAREST).
-    */
-
-#define NEAREST_RGB		\
-   sample[RCOMP] = tex00[2];	\
-   sample[GCOMP] = tex00[1];	\
-   sample[BCOMP] = tex00[0];	\
-   sample[ACOMP] = CHAN_MAX;
-
-#define LINEAR_RGB							\
-   sample[RCOMP] = ilerp_2d(sf, tf, tex00[2], tex01[2], tex10[2], tex11[2]);\
-   sample[GCOMP] = ilerp_2d(sf, tf, tex00[1], tex01[1], tex10[1], tex11[1]);\
-   sample[BCOMP] = ilerp_2d(sf, tf, tex00[0], tex01[0], tex10[0], tex11[0]);\
-   sample[ACOMP] = CHAN_MAX;
-
-#define NEAREST_RGBA  \
-   sample[RCOMP] = tex00[3];	\
-   sample[GCOMP] = tex00[2];	\
-   sample[BCOMP] = tex00[1];	\
-   sample[ACOMP] = tex00[0];
-
-#define LINEAR_RGBA							\
-   sample[RCOMP] = ilerp_2d(sf, tf, tex00[3], tex01[3], tex10[3], tex11[3]);\
-   sample[GCOMP] = ilerp_2d(sf, tf, tex00[2], tex01[2], tex10[2], tex11[2]);\
-   sample[BCOMP] = ilerp_2d(sf, tf, tex00[1], tex01[1], tex10[1], tex11[1]);\
-   sample[ACOMP] = ilerp_2d(sf, tf, tex00[0], tex01[0], tex10[0], tex11[0])
-
-#define MODULATE							  \
-   dest[RCOMP] = span->red   * (sample[RCOMP] + 1u) >> (FIXED_SHIFT + 8); \
-   dest[GCOMP] = span->green * (sample[GCOMP] + 1u) >> (FIXED_SHIFT + 8); \
-   dest[BCOMP] = span->blue  * (sample[BCOMP] + 1u) >> (FIXED_SHIFT + 8); \
-   dest[ACOMP] = span->alpha * (sample[ACOMP] + 1u) >> (FIXED_SHIFT + 8)
-
-#define DECAL								\
-   dest[RCOMP] = ((CHAN_MAX - sample[ACOMP]) * span->red +		\
-               ((sample[ACOMP] + 1) * sample[RCOMP] << FIXED_SHIFT))	\
-               >> (FIXED_SHIFT + 8);					\
-   dest[GCOMP] = ((CHAN_MAX - sample[ACOMP]) * span->green +		\
-               ((sample[ACOMP] + 1) * sample[GCOMP] << FIXED_SHIFT))	\
-               >> (FIXED_SHIFT + 8);					\
-   dest[BCOMP] = ((CHAN_MAX - sample[ACOMP]) * span->blue +		\
-               ((sample[ACOMP] + 1) * sample[BCOMP] << FIXED_SHIFT))	\
-               >> (FIXED_SHIFT + 8);					\
-   dest[ACOMP] = FixedToInt(span->alpha)
-
-#define BLEND								\
-   dest[RCOMP] = ((CHAN_MAX - sample[RCOMP]) * span->red		\
-               + (sample[RCOMP] + 1) * info->er) >> (FIXED_SHIFT + 8);	\
-   dest[GCOMP] = ((CHAN_MAX - sample[GCOMP]) * span->green		\
-               + (sample[GCOMP] + 1) * info->eg) >> (FIXED_SHIFT + 8);	\
-   dest[BCOMP] = ((CHAN_MAX - sample[BCOMP]) * span->blue		\
-               + (sample[BCOMP] + 1) * info->eb) >> (FIXED_SHIFT + 8);	\
-   dest[ACOMP] = span->alpha * (sample[ACOMP] + 1) >> (FIXED_SHIFT + 8)
-
-#define REPLACE  COPY_CHAN4(dest, sample)
-
-#define ADD								\
-   {									\
-      GLint rSum = FixedToInt(span->red)   + (GLint) sample[RCOMP];	\
-      GLint gSum = FixedToInt(span->green) + (GLint) sample[GCOMP];	\
-      GLint bSum = FixedToInt(span->blue)  + (GLint) sample[BCOMP];	\
-      dest[RCOMP] = MIN2(rSum, CHAN_MAX);				\
-      dest[GCOMP] = MIN2(gSum, CHAN_MAX);				\
-      dest[BCOMP] = MIN2(bSum, CHAN_MAX);				\
-      dest[ACOMP] = span->alpha * (sample[ACOMP] + 1) >> (FIXED_SHIFT + 8); \
-  }
-
-/* shortcuts */
-
-#define NEAREST_RGB_REPLACE		\
-   NEAREST_RGB;				\
-   dest[0] = sample[0];			\
-   dest[1] = sample[1];			\
-   dest[2] = sample[2];			\
-   dest[3] = FixedToInt(span->alpha);
-
-#define NEAREST_RGBA_REPLACE  \
-   dest[RCOMP] = tex00[3]; \
-   dest[GCOMP] = tex00[2]; \
-   dest[BCOMP] = tex00[1]; \
-   dest[ACOMP] = tex00[0]
-
-#define SPAN_NEAREST(DO_TEX, COMPS)					\
-	for (i = 0; i < span->end; i++) {				\
-           /* Isn't it necessary to use FixedFloor below?? */		\
-           GLint s = FixedToInt(span->intTex[0]) & info->smask;		\
-           GLint t = FixedToInt(span->intTex[1]) & info->tmask;		\
-           GLint pos = (t << info->twidth_log2) + s;			\
-           const GLchan *tex00 = info->texture + COMPS * pos;		\
-           DO_TEX;							\
-           span->red += span->redStep;					\
-	   span->green += span->greenStep;				\
-           span->blue += span->blueStep;				\
-	   span->alpha += span->alphaStep;				\
-	   span->intTex[0] += span->intTexStep[0];			\
-	   span->intTex[1] += span->intTexStep[1];			\
-           dest += 4;							\
-	}
-
-#define SPAN_LINEAR(DO_TEX, COMPS)					\
-	for (i = 0; i < span->end; i++) {				\
-           /* Isn't it necessary to use FixedFloor below?? */		\
-           const GLint s = FixedToInt(span->intTex[0]) & info->smask;	\
-           const GLint t = FixedToInt(span->intTex[1]) & info->tmask;	\
-           const GLfixed sf = span->intTex[0] & FIXED_FRAC_MASK;	\
-           const GLfixed tf = span->intTex[1] & FIXED_FRAC_MASK;	\
-           const GLint pos = (t << info->twidth_log2) + s;		\
-           const GLchan *tex00 = info->texture + COMPS * pos;		\
-           const GLchan *tex10 = tex00 + info->tbytesline;		\
-           const GLchan *tex01 = tex00 + COMPS;				\
-           const GLchan *tex11 = tex10 + COMPS;				\
-           if (t == info->tmask) {					\
-              tex10 -= info->tsize;					\
-              tex11 -= info->tsize;					\
-           }								\
-           if (s == info->smask) {					\
-              tex01 -= info->tbytesline;				\
-              tex11 -= info->tbytesline;				\
-           }								\
-           DO_TEX;							\
-           span->red += span->redStep;					\
-	   span->green += span->greenStep;				\
-           span->blue += span->blueStep;				\
-	   span->alpha += span->alphaStep;				\
-	   span->intTex[0] += span->intTexStep[0];			\
-	   span->intTex[1] += span->intTexStep[1];			\
-           dest += 4;							\
-	}
-
-
-   GLuint i;
-   GLchan *dest = span->array->rgba[0];
-
-   /* Disable tex units so they're not re-applied in swrast_write_rgba_span */
-   ctx->Texture._EnabledCoordUnits = 0x0;
-
-   span->intTex[0] -= FIXED_HALF;
-   span->intTex[1] -= FIXED_HALF;
-   switch (info->filter) {
-   case GL_NEAREST:
-      switch (info->format) {
-      case MESA_FORMAT_RGB888:
-         switch (info->envmode) {
-         case GL_MODULATE:
-            SPAN_NEAREST(NEAREST_RGB;MODULATE,3);
-            break;
-         case GL_DECAL:
-         case GL_REPLACE:
-            SPAN_NEAREST(NEAREST_RGB_REPLACE,3);
-            break;
-         case GL_BLEND:
-            SPAN_NEAREST(NEAREST_RGB;BLEND,3);
-            break;
-         case GL_ADD:
-            SPAN_NEAREST(NEAREST_RGB;ADD,3);
-            break;
-         default:
-            _mesa_problem(ctx, "bad tex env mode in SPAN_LINEAR");
-            return;
-         }
-         break;
-      case MESA_FORMAT_RGBA8888:
-         switch(info->envmode) {
-         case GL_MODULATE:
-            SPAN_NEAREST(NEAREST_RGBA;MODULATE,4);
-            break;
-         case GL_DECAL:
-            SPAN_NEAREST(NEAREST_RGBA;DECAL,4);
-            break;
-         case GL_BLEND:
-            SPAN_NEAREST(NEAREST_RGBA;BLEND,4);
-            break;
-         case GL_ADD:
-            SPAN_NEAREST(NEAREST_RGBA;ADD,4);
-            break;
-         case GL_REPLACE:
-            SPAN_NEAREST(NEAREST_RGBA_REPLACE,4);
-            break;
-         default:
-            _mesa_problem(ctx, "bad tex env mode (2) in SPAN_LINEAR");
-            return;
-         }
-         break;
-      }
-      break;
-
-   case GL_LINEAR:
-      span->intTex[0] -= FIXED_HALF;
-      span->intTex[1] -= FIXED_HALF;
-      switch (info->format) {
-      case MESA_FORMAT_RGB888:
-         switch (info->envmode) {
-         case GL_MODULATE:
-            SPAN_LINEAR(LINEAR_RGB;MODULATE,3);
-            break;
-         case GL_DECAL:
-         case GL_REPLACE:
-            SPAN_LINEAR(LINEAR_RGB;REPLACE,3);
-            break;
-         case GL_BLEND:
-            SPAN_LINEAR(LINEAR_RGB;BLEND,3);
-            break;
-         case GL_ADD:
-            SPAN_LINEAR(LINEAR_RGB;ADD,3);
-            break;
-         default:
-            _mesa_problem(ctx, "bad tex env mode (3) in SPAN_LINEAR");
-            return;
-         }
-         break;
-      case MESA_FORMAT_RGBA8888:
-         switch (info->envmode) {
-         case GL_MODULATE:
-            SPAN_LINEAR(LINEAR_RGBA;MODULATE,4);
-            break;
-         case GL_DECAL:
-            SPAN_LINEAR(LINEAR_RGBA;DECAL,4);
-            break;
-         case GL_BLEND:
-            SPAN_LINEAR(LINEAR_RGBA;BLEND,4);
-            break;
-         case GL_ADD:
-            SPAN_LINEAR(LINEAR_RGBA;ADD,4);
-            break;
-         case GL_REPLACE:
-            SPAN_LINEAR(LINEAR_RGBA;REPLACE,4);
-            break;
-         default:
-            _mesa_problem(ctx, "bad tex env mode (4) in SPAN_LINEAR");
-            return;
-         }
-         break;
-      }
-      break;
-   }
-   span->interpMask &= ~SPAN_RGBA;
-   ASSERT(span->arrayMask & SPAN_RGBA);
-
-   _swrast_write_rgba_span(ctx, span);
-
-   /* re-enable texture units */
-   ctx->Texture._EnabledCoordUnits = texEnableSave;
-
-#undef SPAN_NEAREST
-#undef SPAN_LINEAR
-}
-
-
-
-/*
- * Render an RGB/RGBA textured triangle without perspective correction.
- */
-#define NAME affine_textured_triangle
-#define INTERP_Z 1
-#define INTERP_RGB 1
-#define INTERP_ALPHA 1
-#define INTERP_INT_TEX 1
-#define S_SCALE twidth
-#define T_SCALE theight
-
-#define SETUP_CODE							\
-   struct affine_info info;						\
-   struct gl_texture_unit *unit = ctx->Texture.Unit+0;			\
-   const struct gl_texture_object *obj = 				\
-      ctx->Texture.Unit[0].CurrentTex[TEXTURE_2D_INDEX];		\
-   const struct gl_texture_image *texImg = 				\
-      obj->Image[0][obj->BaseLevel]; 					\
-   const GLfloat twidth = (GLfloat) texImg->Width;			\
-   const GLfloat theight = (GLfloat) texImg->Height;			\
-   info.texture = (const GLchan *) texImg->Data;			\
-   info.twidth_log2 = texImg->WidthLog2;				\
-   info.smask = texImg->Width - 1;					\
-   info.tmask = texImg->Height - 1;					\
-   info.format = texImg->TexFormat;					\
-   info.filter = obj->MinFilter;					\
-   info.envmode = unit->EnvMode;					\
-   info.er = 0;					\
-   info.eg = 0;					\
-   info.eb = 0;					\
-   span.arrayMask |= SPAN_RGBA;						\
-									\
-   if (info.envmode == GL_BLEND) {					\
-      /* potential off-by-one error here? (1.0f -> 2048 -> 0) */	\
-      info.er = FloatToFixed(unit->EnvColor[RCOMP] * CHAN_MAXF);	\
-      info.eg = FloatToFixed(unit->EnvColor[GCOMP] * CHAN_MAXF);	\
-      info.eb = FloatToFixed(unit->EnvColor[BCOMP] * CHAN_MAXF);	\
-      info.ea = FloatToFixed(unit->EnvColor[ACOMP] * CHAN_MAXF);	\
-   }									\
-   if (!info.texture) {							\
-      /* this shouldn't happen */					\
-      return;								\
-   }									\
-									\
-   switch (info.format) {						\
-   case MESA_FORMAT_RGB888:						\
-      info.tbytesline = texImg->Width * 3;				\
-      break;								\
-   case MESA_FORMAT_RGBA8888:						\
-      info.tbytesline = texImg->Width * 4;				\
-      break;								\
-   default:								\
-      _mesa_problem(NULL, "Bad texture format in affine_texture_triangle");\
-      return;								\
-   }									\
-   info.tsize = texImg->Height * info.tbytesline;
-
-#define RENDER_SPAN( span )   affine_span(ctx, &span, &info);
-
-#include "s_tritemp.h"
-
-
-
-struct persp_info
-{
-   GLenum filter;
-   GLenum format;
-   GLenum envmode;
-   GLint smask, tmask;
-   GLint twidth_log2;
-   const GLchan *texture;
-   GLfixed er, eg, eb, ea;   /* texture env color */
-   GLint tbytesline, tsize;
-};
-
-
-static INLINE void
-fast_persp_span(GLcontext *ctx, SWspan *span,
-		struct persp_info *info)
-{
-   GLchan sample[4];  /* the filtered texture sample */
-
-  /* Instead of defining a function for each mode, a test is done
-   * between the outer and inner loops. This is to reduce code size
-   * and complexity. Observe that an optimizing compiler kills
-   * unused variables (for instance tf,sf,ti,si in case of GL_NEAREST).
-   */
-#define SPAN_NEAREST(DO_TEX,COMP)					\
-	for (i = 0; i < span->end; i++) {				\
-           GLdouble invQ = tex_coord[2] ?				\
-                                 (1.0 / tex_coord[2]) : 1.0;            \
-           GLfloat s_tmp = (GLfloat) (tex_coord[0] * invQ);		\
-           GLfloat t_tmp = (GLfloat) (tex_coord[1] * invQ);		\
-           GLint s = IFLOOR(s_tmp) & info->smask;	        	\
-           GLint t = IFLOOR(t_tmp) & info->tmask;	        	\
-           GLint pos = (t << info->twidth_log2) + s;			\
-           const GLchan *tex00 = info->texture + COMP * pos;		\
-           DO_TEX;							\
-           span->red += span->redStep;					\
-	   span->green += span->greenStep;				\
-           span->blue += span->blueStep;				\
-	   span->alpha += span->alphaStep;				\
-	   tex_coord[0] += tex_step[0];					\
-	   tex_coord[1] += tex_step[1];					\
-	   tex_coord[2] += tex_step[2];					\
-           dest += 4;							\
-	}
-
-#define SPAN_LINEAR(DO_TEX,COMP)					\
-	for (i = 0; i < span->end; i++) {				\
-           GLdouble invQ = tex_coord[2] ?				\
-                                 (1.0 / tex_coord[2]) : 1.0;            \
-           const GLfloat s_tmp = (GLfloat) (tex_coord[0] * invQ);	\
-           const GLfloat t_tmp = (GLfloat) (tex_coord[1] * invQ);	\
-           const GLfixed s_fix = FloatToFixed(s_tmp) - FIXED_HALF;	\
-           const GLfixed t_fix = FloatToFixed(t_tmp) - FIXED_HALF;      \
-           const GLint s = FixedToInt(FixedFloor(s_fix)) & info->smask;	\
-           const GLint t = FixedToInt(FixedFloor(t_fix)) & info->tmask;	\
-           const GLfixed sf = s_fix & FIXED_FRAC_MASK;			\
-           const GLfixed tf = t_fix & FIXED_FRAC_MASK;			\
-           const GLint pos = (t << info->twidth_log2) + s;		\
-           const GLchan *tex00 = info->texture + COMP * pos;		\
-           const GLchan *tex10 = tex00 + info->tbytesline;		\
-           const GLchan *tex01 = tex00 + COMP;				\
-           const GLchan *tex11 = tex10 + COMP;				\
-           if (t == info->tmask) {					\
-              tex10 -= info->tsize;					\
-              tex11 -= info->tsize;					\
-           }								\
-           if (s == info->smask) {					\
-              tex01 -= info->tbytesline;				\
-              tex11 -= info->tbytesline;				\
-           }								\
-           DO_TEX;							\
-           span->red   += span->redStep;				\
-	   span->green += span->greenStep;				\
-           span->blue  += span->blueStep;				\
-	   span->alpha += span->alphaStep;				\
-	   tex_coord[0] += tex_step[0];					\
-	   tex_coord[1] += tex_step[1];					\
-	   tex_coord[2] += tex_step[2];					\
-           dest += 4;							\
-	}
-
-   GLuint i;
-   GLfloat tex_coord[3], tex_step[3];
-   GLchan *dest = span->array->rgba[0];
-
-   const GLuint texEnableSave = ctx->Texture._EnabledCoordUnits;
-   ctx->Texture._EnabledCoordUnits = 0;
-
-   tex_coord[0] = span->attrStart[FRAG_ATTRIB_TEX0][0]  * (info->smask + 1);
-   tex_step[0] = span->attrStepX[FRAG_ATTRIB_TEX0][0] * (info->smask + 1);
-   tex_coord[1] = span->attrStart[FRAG_ATTRIB_TEX0][1] * (info->tmask + 1);
-   tex_step[1] = span->attrStepX[FRAG_ATTRIB_TEX0][1] * (info->tmask + 1);
-   /* span->attrStart[FRAG_ATTRIB_TEX0][2] only if 3D-texturing, here only 2D */
-   tex_coord[2] = span->attrStart[FRAG_ATTRIB_TEX0][3];
-   tex_step[2] = span->attrStepX[FRAG_ATTRIB_TEX0][3];
-
-   switch (info->filter) {
-   case GL_NEAREST:
-      switch (info->format) {
-      case MESA_FORMAT_RGB888:
-         switch (info->envmode) {
-         case GL_MODULATE:
-            SPAN_NEAREST(NEAREST_RGB;MODULATE,3);
-            break;
-         case GL_DECAL:
-         case GL_REPLACE:
-            SPAN_NEAREST(NEAREST_RGB_REPLACE,3);
-            break;
-         case GL_BLEND:
-            SPAN_NEAREST(NEAREST_RGB;BLEND,3);
-            break;
-         case GL_ADD:
-            SPAN_NEAREST(NEAREST_RGB;ADD,3);
-            break;
-         default:
-            _mesa_problem(ctx, "bad tex env mode (5) in SPAN_LINEAR");
-            return;
-         }
-         break;
-      case MESA_FORMAT_RGBA8888:
-         switch(info->envmode) {
-         case GL_MODULATE:
-            SPAN_NEAREST(NEAREST_RGBA;MODULATE,4);
-            break;
-         case GL_DECAL:
-            SPAN_NEAREST(NEAREST_RGBA;DECAL,4);
-            break;
-         case GL_BLEND:
-            SPAN_NEAREST(NEAREST_RGBA;BLEND,4);
-            break;
-         case GL_ADD:
-            SPAN_NEAREST(NEAREST_RGBA;ADD,4);
-            break;
-         case GL_REPLACE:
-            SPAN_NEAREST(NEAREST_RGBA_REPLACE,4);
-            break;
-         default:
-            _mesa_problem(ctx, "bad tex env mode (6) in SPAN_LINEAR");
-            return;
-         }
-         break;
-      }
-      break;
-
-   case GL_LINEAR:
-      switch (info->format) {
-      case MESA_FORMAT_RGB888:
-         switch (info->envmode) {
-         case GL_MODULATE:
-            SPAN_LINEAR(LINEAR_RGB;MODULATE,3);
-            break;
-         case GL_DECAL:
-         case GL_REPLACE:
-            SPAN_LINEAR(LINEAR_RGB;REPLACE,3);
-            break;
-         case GL_BLEND:
-            SPAN_LINEAR(LINEAR_RGB;BLEND,3);
-            break;
-         case GL_ADD:
-            SPAN_LINEAR(LINEAR_RGB;ADD,3);
-            break;
-         default:
-            _mesa_problem(ctx, "bad tex env mode (7) in SPAN_LINEAR");
-            return;
-         }
-         break;
-      case MESA_FORMAT_RGBA8888:
-         switch (info->envmode) {
-         case GL_MODULATE:
-            SPAN_LINEAR(LINEAR_RGBA;MODULATE,4);
-            break;
-         case GL_DECAL:
-            SPAN_LINEAR(LINEAR_RGBA;DECAL,4);
-            break;
-         case GL_BLEND:
-            SPAN_LINEAR(LINEAR_RGBA;BLEND,4);
-            break;
-         case GL_ADD:
-            SPAN_LINEAR(LINEAR_RGBA;ADD,4);
-            break;
-         case GL_REPLACE:
-            SPAN_LINEAR(LINEAR_RGBA;REPLACE,4);
-            break;
-         default:
-            _mesa_problem(ctx, "bad tex env mode (8) in SPAN_LINEAR");
-            return;
-         }
-         break;
-      }
-      break;
-   }
-   
-   ASSERT(span->arrayMask & SPAN_RGBA);
-   _swrast_write_rgba_span(ctx, span);
-
-#undef SPAN_NEAREST
-#undef SPAN_LINEAR
-
-   /* restore state */
-   ctx->Texture._EnabledCoordUnits = texEnableSave;
-}
-
-
-/*
- * Render an perspective corrected RGB/RGBA textured triangle.
- * The Q (aka V in Mesa) coordinate must be zero such that the divide
- * by interpolated Q/W comes out right.
- *
- */
-#define NAME persp_textured_triangle
-#define INTERP_Z 1
-#define INTERP_RGB 1
-#define INTERP_ALPHA 1
-#define INTERP_ATTRIBS 1
-
-#define SETUP_CODE							\
-   struct persp_info info;						\
-   const struct gl_texture_unit *unit = ctx->Texture.Unit+0;		\
-   const struct gl_texture_object *obj = 				\
-      ctx->Texture.Unit[0].CurrentTex[TEXTURE_2D_INDEX];		\
-   const struct gl_texture_image *texImg = 				\
-      obj->Image[0][obj->BaseLevel];			 		\
-   info.texture = (const GLchan *) texImg->Data;			\
-   info.twidth_log2 = texImg->WidthLog2;				\
-   info.smask = texImg->Width - 1;					\
-   info.tmask = texImg->Height - 1;					\
-   info.format = texImg->TexFormat;					\
-   info.filter = obj->MinFilter;					\
-   info.envmode = unit->EnvMode;					\
-   info.er = 0;					\
-   info.eg = 0;					\
-   info.eb = 0;					\
-									\
-   if (info.envmode == GL_BLEND) {					\
-      /* potential off-by-one error here? (1.0f -> 2048 -> 0) */	\
-      info.er = FloatToFixed(unit->EnvColor[RCOMP] * CHAN_MAXF);	\
-      info.eg = FloatToFixed(unit->EnvColor[GCOMP] * CHAN_MAXF);	\
-      info.eb = FloatToFixed(unit->EnvColor[BCOMP] * CHAN_MAXF);	\
-      info.ea = FloatToFixed(unit->EnvColor[ACOMP] * CHAN_MAXF);	\
-   }									\
-   if (!info.texture) {							\
-      /* this shouldn't happen */					\
-      return;								\
-   }									\
-									\
-   switch (info.format) {						\
-   case MESA_FORMAT_RGB888:						\
-      info.tbytesline = texImg->Width * 3;				\
-      break;								\
-   case MESA_FORMAT_RGBA8888:						\
-      info.tbytesline = texImg->Width * 4;				\
-      break;								\
-   default:								\
-      _mesa_problem(NULL, "Bad texture format in persp_textured_triangle");\
-      return;								\
-   }									\
-   info.tsize = texImg->Height * info.tbytesline;
-
-#define RENDER_SPAN( span )			\
-   span.interpMask &= ~SPAN_RGBA;		\
-   span.arrayMask |= SPAN_RGBA;			\
-   fast_persp_span(ctx, &span, &info);
-
-#include "s_tritemp.h"
-
-#endif /*CHAN_TYPE != GL_FLOAT*/
-
-
-
-/*
- * Render an RGBA triangle with arbitrary attributes.
- */
-#define NAME general_triangle
-#define INTERP_Z 1
-#define INTERP_RGB 1
-#define INTERP_ALPHA 1
-#define INTERP_ATTRIBS 1
-#define RENDER_SPAN( span )   _swrast_write_rgba_span(ctx, &span);
-#include "s_tritemp.h"
-
-
-
-
-/*
- * Special tri function for occlusion testing
- */
-#define NAME occlusion_zless_triangle
-#define INTERP_Z 1
-#define SETUP_CODE							\
-   struct gl_renderbuffer *rb = ctx->DrawBuffer->_DepthBuffer;		\
-   struct gl_query_object *q = ctx->Query.CurrentOcclusionObject;	\
-   ASSERT(ctx->Depth.Test);						\
-   ASSERT(!ctx->Depth.Mask);						\
-   ASSERT(ctx->Depth.Func == GL_LESS);					\
-   if (!q) {								\
-      return;								\
-   }
-#define RENDER_SPAN( span )						\
-   if (rb->Format == MESA_FORMAT_Z16) {					\
-      GLuint i;								\
-      const GLushort *zRow = (const GLushort *)				\
-         rb->GetPointer(ctx, rb, span.x, span.y);			\
-      for (i = 0; i < span.end; i++) {					\
-         GLuint z = FixedToDepth(span.z);				\
-         if (z < zRow[i]) {						\
-            q->Result++;						\
-         }								\
-         span.z += span.zStep;						\
-      }									\
-   }									\
-   else {								\
-      GLuint i;								\
-      const GLuint *zRow = (const GLuint *)				\
-         rb->GetPointer(ctx, rb, span.x, span.y);			\
-      for (i = 0; i < span.end; i++) {					\
-         if ((GLuint)span.z < zRow[i]) {				\
-            q->Result++;						\
-         }								\
-         span.z += span.zStep;						\
-      }									\
-   }
-#include "s_tritemp.h"
-
-
-
-static void
-nodraw_triangle( GLcontext *ctx,
-                 const SWvertex *v0,
-                 const SWvertex *v1,
-                 const SWvertex *v2 )
-{
-   (void) (ctx && v0 && v1 && v2);
-}
-
-
-/*
- * This is used when separate specular color is enabled, but not
- * texturing.  We add the specular color to the primary color,
- * draw the triangle, then restore the original primary color.
- * Inefficient, but seldom needed.
- */
-void
-_swrast_add_spec_terms_triangle(GLcontext *ctx, const SWvertex *v0,
-                                const SWvertex *v1, const SWvertex *v2)
-{
-   SWvertex *ncv0 = (SWvertex *)v0; /* drop const qualifier */
-   SWvertex *ncv1 = (SWvertex *)v1;
-   SWvertex *ncv2 = (SWvertex *)v2;
-   GLfloat rSum, gSum, bSum;
-   GLchan cSave[3][4];
-
-   /* save original colors */
-   COPY_CHAN4( cSave[0], ncv0->color );
-   COPY_CHAN4( cSave[1], ncv1->color );
-   COPY_CHAN4( cSave[2], ncv2->color );
-   /* sum v0 */
-   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);
-   /* sum v1 */
-   rSum = CHAN_TO_FLOAT(ncv1->color[0]) + ncv1->attrib[FRAG_ATTRIB_COL1][0];
-   gSum = CHAN_TO_FLOAT(ncv1->color[1]) + ncv1->attrib[FRAG_ATTRIB_COL1][1];
-   bSum = CHAN_TO_FLOAT(ncv1->color[2]) + ncv1->attrib[FRAG_ATTRIB_COL1][2];
-   UNCLAMPED_FLOAT_TO_CHAN(ncv1->color[0], rSum);
-   UNCLAMPED_FLOAT_TO_CHAN(ncv1->color[1], gSum);
-   UNCLAMPED_FLOAT_TO_CHAN(ncv1->color[2], bSum);
-   /* sum v2 */
-   rSum = CHAN_TO_FLOAT(ncv2->color[0]) + ncv2->attrib[FRAG_ATTRIB_COL1][0];
-   gSum = CHAN_TO_FLOAT(ncv2->color[1]) + ncv2->attrib[FRAG_ATTRIB_COL1][1];
-   bSum = CHAN_TO_FLOAT(ncv2->color[2]) + ncv2->attrib[FRAG_ATTRIB_COL1][2];
-   UNCLAMPED_FLOAT_TO_CHAN(ncv2->color[0], rSum);
-   UNCLAMPED_FLOAT_TO_CHAN(ncv2->color[1], gSum);
-   UNCLAMPED_FLOAT_TO_CHAN(ncv2->color[2], bSum);
-   /* draw */
-   SWRAST_CONTEXT(ctx)->SpecTriangle( ctx, ncv0, ncv1, ncv2 );
-   /* restore original colors */
-   COPY_CHAN4( ncv0->color, cSave[0] );
-   COPY_CHAN4( ncv1->color, cSave[1] );
-   COPY_CHAN4( ncv2->color, cSave[2] );
-}
-
-
-
-#ifdef DEBUG
-
-/* record the current triangle function name */
-const char *_mesa_triFuncName = NULL;
-
-#define USE(triFunc)				\
-do {						\
-    _mesa_triFuncName = #triFunc;		\
-    /*printf("%s\n", _mesa_triFuncName);*/	\
-    swrast->Triangle = triFunc;			\
-} while (0)
-
-#else
-
-#define USE(triFunc)  swrast->Triangle = triFunc;
-
-#endif
-
-
-
-
-/*
- * Determine which triangle rendering function to use given the current
- * rendering context.
- *
- * Please update the summary flag _SWRAST_NEW_TRIANGLE if you add or
- * remove tests to this code.
- */
-void
-_swrast_choose_triangle( GLcontext *ctx )
-{
-   SWcontext *swrast = SWRAST_CONTEXT(ctx);
-
-   if (ctx->Polygon.CullFlag &&
-       ctx->Polygon.CullFaceMode == GL_FRONT_AND_BACK) {
-      USE(nodraw_triangle);
-      return;
-   }
-
-   if (ctx->RenderMode==GL_RENDER) {
-
-      if (ctx->Polygon.SmoothFlag) {
-         _swrast_set_aa_triangle_function(ctx);
-         ASSERT(swrast->Triangle);
-         return;
-      }
-
-      /* special case for occlusion testing */
-      if (ctx->Query.CurrentOcclusionObject &&
-          ctx->Depth.Test &&
-          ctx->Depth.Mask == GL_FALSE &&
-          ctx->Depth.Func == GL_LESS &&
-          !ctx->Stencil._Enabled) {
-         if (ctx->Color.ColorMask[0][0] == 0 &&
-	     ctx->Color.ColorMask[0][1] == 0 &&
-	     ctx->Color.ColorMask[0][2] == 0 &&
-	     ctx->Color.ColorMask[0][3] == 0) {
-            USE(occlusion_zless_triangle);
-            return;
-         }
-      }
-
-      /*
-       * XXX should examine swrast->_ActiveAttribMask to determine what
-       * needs to be interpolated.
-       */
-      if (ctx->Texture._EnabledCoordUnits ||
-          ctx->FragmentProgram._Current ||
-          ctx->ATIFragmentShader._Enabled ||
-          NEED_SECONDARY_COLOR(ctx) ||
-          swrast->_FogEnabled) {
-         /* Ugh, we do a _lot_ of tests to pick the best textured tri func */
-         const struct gl_texture_object *texObj2D;
-         const struct gl_texture_image *texImg;
-         GLenum minFilter, magFilter, envMode;
-         gl_format format;
-         texObj2D = ctx->Texture.Unit[0].CurrentTex[TEXTURE_2D_INDEX];
-
-         texImg = texObj2D ? texObj2D->Image[0][texObj2D->BaseLevel] : NULL;
-         format = texImg ? texImg->TexFormat : MESA_FORMAT_NONE;
-         minFilter = texObj2D ? texObj2D->MinFilter : GL_NONE;
-         magFilter = texObj2D ? texObj2D->MagFilter : GL_NONE;
-         envMode = ctx->Texture.Unit[0].EnvMode;
-
-         /* First see if we can use an optimized 2-D texture function */
-         if (ctx->Texture._EnabledCoordUnits == 0x1
-             && !ctx->FragmentProgram._Current
-             && !ctx->ATIFragmentShader._Enabled
-             && ctx->Texture._EnabledUnits == 0x1
-             && ctx->Texture.Unit[0]._ReallyEnabled == TEXTURE_2D_BIT
-             && texObj2D->WrapS == GL_REPEAT
-             && texObj2D->WrapT == GL_REPEAT
-             && texObj2D->_Swizzle == SWIZZLE_NOOP
-             && texImg->_IsPowerOfTwo
-             && texImg->Border == 0
-             && texImg->Width == texImg->RowStride
-             && (format == MESA_FORMAT_RGB888 || format == MESA_FORMAT_RGBA8888)
-             && minFilter == magFilter
-             && ctx->Light.Model.ColorControl == GL_SINGLE_COLOR
-             && !swrast->_FogEnabled
-             && ctx->Texture.Unit[0].EnvMode != GL_COMBINE_EXT
-             && ctx->Texture.Unit[0].EnvMode != GL_COMBINE4_NV) {
-	    if (ctx->Hint.PerspectiveCorrection==GL_FASTEST) {
-	       if (minFilter == GL_NEAREST
-		   && format == MESA_FORMAT_RGB888
-		   && (envMode == GL_REPLACE || envMode == GL_DECAL)
-		   && ((swrast->_RasterMask == (DEPTH_BIT | TEXTURE_BIT)
-			&& ctx->Depth.Func == GL_LESS
-			&& ctx->Depth.Mask == GL_TRUE)
-		       || swrast->_RasterMask == TEXTURE_BIT)
-		   && ctx->Polygon.StippleFlag == GL_FALSE
-                   && ctx->DrawBuffer->Visual.depthBits <= 16) {
-		  if (swrast->_RasterMask == (DEPTH_BIT | TEXTURE_BIT)) {
-		     USE(simple_z_textured_triangle);
-		  }
-		  else {
-		     USE(simple_textured_triangle);
-		  }
-	       }
-	       else {
-#if CHAN_BITS != 8
-                  USE(general_triangle);
-#else
-                  if (format == MESA_FORMAT_RGBA8888 && !_mesa_little_endian()) {
-                     /* We only handle RGBA8888 correctly on little endian
-                      * in the optimized code above.
-                      */
-                     USE(general_triangle);
-                  }
-                  else {
-                     USE(affine_textured_triangle);
-                 }
-#endif
-	       }
-	    }
-	    else {
-#if CHAN_BITS != 8
-               USE(general_triangle);
-#else
-               USE(persp_textured_triangle);
-#endif
-	    }
-	 }
-         else {
-            /* general case textured triangles */
-            USE(general_triangle);
-         }
-      }
-      else {
-         ASSERT(!swrast->_FogEnabled);
-         ASSERT(!NEED_SECONDARY_COLOR(ctx));
-	 if (ctx->Light.ShadeModel==GL_SMOOTH) {
-	    /* smooth shaded, no texturing, stippled or some raster ops */
-#if CHAN_BITS != 8
-               USE(general_triangle);
-#else
-               USE(smooth_rgba_triangle);
-#endif
-	 }
-	 else {
-	    /* flat shaded, no texturing, stippled or some raster ops */
-#if CHAN_BITS != 8
-            USE(general_triangle);
-#else
-            USE(flat_rgba_triangle);
-#endif
-	 }
-      }
-   }
-   else if (ctx->RenderMode==GL_FEEDBACK) {
-      USE(_swrast_feedback_triangle);
-   }
-   else {
-      /* GL_SELECT mode */
-      USE(_swrast_select_triangle);
-   }
-}
+/*

+ * Mesa 3-D graphics library

+ * Version:  7.3

+ *

+ * 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.

+ */

+

+

+/*

+ * When the device driver doesn't implement triangle rasterization it

+ * can hook in _swrast_Triangle, which eventually calls one of these

+ * functions to draw triangles.

+ */

+

+#include "main/glheader.h"

+#include "main/context.h"

+#include "main/colormac.h"

+#include "main/imports.h"

+#include "main/macros.h"

+#include "main/texformat.h"

+#include "program/prog_instruction.h"

+

+#include "s_aatriangle.h"

+#include "s_context.h"

+#include "s_feedback.h"

+#include "s_span.h"

+#include "s_triangle.h"

+

+

+/**

+ * Test if a triangle should be culled.  Used for feedback and selection mode.

+ * \return GL_TRUE if the triangle is to be culled, GL_FALSE otherwise.

+ */

+GLboolean

+_swrast_culltriangle( struct gl_context *ctx,

+                      const SWvertex *v0,

+                      const SWvertex *v1,

+                      const SWvertex *v2 )

+{

+   SWcontext *swrast = SWRAST_CONTEXT(ctx);

+   GLfloat ex = v1->attrib[FRAG_ATTRIB_WPOS][0] - v0->attrib[FRAG_ATTRIB_WPOS][0];

+   GLfloat ey = v1->attrib[FRAG_ATTRIB_WPOS][1] - v0->attrib[FRAG_ATTRIB_WPOS][1];

+   GLfloat fx = v2->attrib[FRAG_ATTRIB_WPOS][0] - v0->attrib[FRAG_ATTRIB_WPOS][0];

+   GLfloat fy = v2->attrib[FRAG_ATTRIB_WPOS][1] - v0->attrib[FRAG_ATTRIB_WPOS][1];

+   GLfloat c = ex*fy-ey*fx;

+

+   if (c * swrast->_BackfaceSign * swrast->_BackfaceCullSign <= 0.0F)

+      return GL_FALSE;

+

+   return GL_TRUE;

+}

+

+

+

+/*

+ * Render a flat-shaded RGBA triangle.

+ */

+#define NAME flat_rgba_triangle

+#define INTERP_Z 1

+#define SETUP_CODE				\

+   ASSERT(ctx->Texture._EnabledCoordUnits == 0);\

+   ASSERT(ctx->Light.ShadeModel==GL_FLAT);	\

+   span.interpMask |= SPAN_RGBA;		\

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

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

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

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

+   span.redStep = 0;				\

+   span.greenStep = 0;				\

+   span.blueStep = 0;				\

+   span.alphaStep = 0;

+#define RENDER_SPAN( span )  _swrast_write_rgba_span(ctx, &span);

+#include "s_tritemp.h"

+

+

+

+/*

+ * Render a smooth-shaded RGBA triangle.

+ */

+#define NAME smooth_rgba_triangle

+#define INTERP_Z 1

+#define INTERP_RGB 1

+#define INTERP_ALPHA 1

+#define SETUP_CODE				\

+   {						\

+      /* texturing must be off */		\

+      ASSERT(ctx->Texture._EnabledCoordUnits == 0);	\

+      ASSERT(ctx->Light.ShadeModel==GL_SMOOTH);	\

+   }

+#define RENDER_SPAN( span )  _swrast_write_rgba_span(ctx, &span);

+#include "s_tritemp.h"

+

+

+

+/*

+ * Render an RGB, GL_DECAL, textured triangle.

+ * Interpolate S,T only w/out mipmapping or perspective correction.

+ *

+ * No fog.  No depth testing.

+ */

+#define NAME simple_textured_triangle

+#define INTERP_INT_TEX 1

+#define S_SCALE twidth

+#define T_SCALE theight

+

+#define SETUP_CODE							\

+   struct gl_renderbuffer *rb = ctx->DrawBuffer->_ColorDrawBuffers[0];	\

+   const struct gl_texture_object *obj = 				\

+      ctx->Texture.Unit[0].CurrentTex[TEXTURE_2D_INDEX];		\

+   const struct gl_texture_image *texImg =				\

+      obj->Image[0][obj->BaseLevel];					\

+   const GLfloat twidth = (GLfloat) texImg->Width;			\

+   const GLfloat theight = (GLfloat) texImg->Height;			\

+   const GLint twidth_log2 = texImg->WidthLog2;				\

+   const GLubyte *texture = (const GLubyte *) texImg->Data;		\

+   const GLint smask = texImg->Width - 1;				\

+   const GLint tmask = texImg->Height - 1;				\

+   ASSERT(texImg->TexFormat == MESA_FORMAT_RGB888);			\

+   if (!rb || !texture) {						\

+      return;								\

+   }

+

+#define RENDER_SPAN( span )						\

+   GLuint i;								\

+   GLubyte rgb[MAX_WIDTH][3];						\

+   span.intTex[0] -= FIXED_HALF; /* off-by-one error? */		\

+   span.intTex[1] -= FIXED_HALF;					\

+   for (i = 0; i < span.end; i++) {					\

+      GLint s = FixedToInt(span.intTex[0]) & smask;			\

+      GLint t = FixedToInt(span.intTex[1]) & tmask;			\

+      GLint pos = (t << twidth_log2) + s;				\

+      pos = pos + pos + pos;  /* multiply by 3 */			\

+      rgb[i][RCOMP] = texture[pos+2];					\

+      rgb[i][GCOMP] = texture[pos+1];					\

+      rgb[i][BCOMP] = texture[pos+0];					\

+      span.intTex[0] += span.intTexStep[0];				\

+      span.intTex[1] += span.intTexStep[1];				\

+   }									\

+   rb->PutRowRGB(ctx, rb, span.end, span.x, span.y, rgb, NULL);

+

+#include "s_tritemp.h"

+

+

+

+/*

+ * Render an RGB, GL_DECAL, textured triangle.

+ * Interpolate S,T, GL_LESS depth test, w/out mipmapping or

+ * perspective correction.

+ * Depth buffer bits must be <= sizeof(DEFAULT_SOFTWARE_DEPTH_TYPE)

+ *

+ * No fog.

+ */

+#define NAME simple_z_textured_triangle

+#define INTERP_Z 1

+#define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE

+#define INTERP_INT_TEX 1

+#define S_SCALE twidth

+#define T_SCALE theight

+

+#define SETUP_CODE							\

+   struct gl_renderbuffer *rb = ctx->DrawBuffer->_ColorDrawBuffers[0];	\

+   const struct gl_texture_object *obj = 				\

+      ctx->Texture.Unit[0].CurrentTex[TEXTURE_2D_INDEX];		\

+   const struct gl_texture_image *texImg = 				\

+       obj->Image[0][obj->BaseLevel]; 					\

+   const GLfloat twidth = (GLfloat) texImg->Width;			\

+   const GLfloat theight = (GLfloat) texImg->Height;			\

+   const GLint twidth_log2 = texImg->WidthLog2;				\

+   const GLubyte *texture = (const GLubyte *) texImg->Data;		\

+   const GLint smask = texImg->Width - 1;				\

+   const GLint tmask = texImg->Height - 1;				\

+   ASSERT(texImg->TexFormat == MESA_FORMAT_RGB888);			\

+   if (!rb || !texture) {						\

+      return;								\

+   }

+

+#define RENDER_SPAN( span )						\

+   GLuint i;				    				\

+   GLubyte rgb[MAX_WIDTH][3];						\

+   span.intTex[0] -= FIXED_HALF; /* off-by-one error? */		\

+   span.intTex[1] -= FIXED_HALF;					\

+   for (i = 0; i < span.end; i++) {					\

+      const GLuint z = FixedToDepth(span.z);				\

+      if (z < zRow[i]) {						\

+         GLint s = FixedToInt(span.intTex[0]) & smask;			\

+         GLint t = FixedToInt(span.intTex[1]) & tmask;			\

+         GLint pos = (t << twidth_log2) + s;				\

+         pos = pos + pos + pos;  /* multiply by 3 */			\

+         rgb[i][RCOMP] = texture[pos+2];				\

+         rgb[i][GCOMP] = texture[pos+1];				\

+         rgb[i][BCOMP] = texture[pos+0];				\

+         zRow[i] = z;							\

+         span.array->mask[i] = 1;					\

+      }									\

+      else {								\

+         span.array->mask[i] = 0;					\

+      }									\

+      span.intTex[0] += span.intTexStep[0];				\

+      span.intTex[1] += span.intTexStep[1];				\

+      span.z += span.zStep;						\

+   }									\

+   rb->PutRowRGB(ctx, rb, span.end, span.x, span.y, rgb, span.array->mask);

+

+#include "s_tritemp.h"

+

+

+#if CHAN_TYPE != GL_FLOAT

+

+struct affine_info

+{

+   GLenum filter;

+   GLenum format;

+   GLenum envmode;

+   GLint smask, tmask;

+   GLint twidth_log2;

+   const GLchan *texture;

+   GLfixed er, eg, eb, ea;

+   GLint tbytesline, tsize;

+};

+

+

+static INLINE GLint

+ilerp(GLint t, GLint a, GLint b)

+{

+   return a + ((t * (b - a)) >> FIXED_SHIFT);

+}

+

+static INLINE GLint

+ilerp_2d(GLint ia, GLint ib, GLint v00, GLint v10, GLint v01, GLint v11)

+{

+   const GLint temp0 = ilerp(ia, v00, v10);

+   const GLint temp1 = ilerp(ia, v01, v11);

+   return ilerp(ib, temp0, temp1);

+}

+

+

+/* This function can handle GL_NEAREST or GL_LINEAR sampling of 2D RGB or RGBA

+ * textures with GL_REPLACE, GL_MODULATE, GL_BLEND, GL_DECAL or GL_ADD

+ * texture env modes.

+ */

+static INLINE void

+affine_span(struct gl_context *ctx, SWspan *span,

+            struct affine_info *info)

+{

+   GLchan sample[4];  /* the filtered texture sample */

+   const GLuint texEnableSave = ctx->Texture._EnabledCoordUnits;

+

+   /* Instead of defining a function for each mode, a test is done

+    * between the outer and inner loops. This is to reduce code size

+    * and complexity. Observe that an optimizing compiler kills

+    * unused variables (for instance tf,sf,ti,si in case of GL_NEAREST).

+    */

+

+#define NEAREST_RGB		\

+   sample[RCOMP] = tex00[2];	\

+   sample[GCOMP] = tex00[1];	\

+   sample[BCOMP] = tex00[0];	\

+   sample[ACOMP] = CHAN_MAX;

+

+#define LINEAR_RGB							\

+   sample[RCOMP] = ilerp_2d(sf, tf, tex00[2], tex01[2], tex10[2], tex11[2]);\

+   sample[GCOMP] = ilerp_2d(sf, tf, tex00[1], tex01[1], tex10[1], tex11[1]);\

+   sample[BCOMP] = ilerp_2d(sf, tf, tex00[0], tex01[0], tex10[0], tex11[0]);\

+   sample[ACOMP] = CHAN_MAX;

+

+#define NEAREST_RGBA  \

+   sample[RCOMP] = tex00[3];	\

+   sample[GCOMP] = tex00[2];	\

+   sample[BCOMP] = tex00[1];	\

+   sample[ACOMP] = tex00[0];

+

+#define LINEAR_RGBA							\

+   sample[RCOMP] = ilerp_2d(sf, tf, tex00[3], tex01[3], tex10[3], tex11[3]);\

+   sample[GCOMP] = ilerp_2d(sf, tf, tex00[2], tex01[2], tex10[2], tex11[2]);\

+   sample[BCOMP] = ilerp_2d(sf, tf, tex00[1], tex01[1], tex10[1], tex11[1]);\

+   sample[ACOMP] = ilerp_2d(sf, tf, tex00[0], tex01[0], tex10[0], tex11[0])

+

+#define MODULATE							  \

+   dest[RCOMP] = span->red   * (sample[RCOMP] + 1u) >> (FIXED_SHIFT + 8); \

+   dest[GCOMP] = span->green * (sample[GCOMP] + 1u) >> (FIXED_SHIFT + 8); \

+   dest[BCOMP] = span->blue  * (sample[BCOMP] + 1u) >> (FIXED_SHIFT + 8); \

+   dest[ACOMP] = span->alpha * (sample[ACOMP] + 1u) >> (FIXED_SHIFT + 8)

+

+#define DECAL								\

+   dest[RCOMP] = ((CHAN_MAX - sample[ACOMP]) * span->red +		\

+               ((sample[ACOMP] + 1) * sample[RCOMP] << FIXED_SHIFT))	\

+               >> (FIXED_SHIFT + 8);					\

+   dest[GCOMP] = ((CHAN_MAX - sample[ACOMP]) * span->green +		\

+               ((sample[ACOMP] + 1) * sample[GCOMP] << FIXED_SHIFT))	\

+               >> (FIXED_SHIFT + 8);					\

+   dest[BCOMP] = ((CHAN_MAX - sample[ACOMP]) * span->blue +		\

+               ((sample[ACOMP] + 1) * sample[BCOMP] << FIXED_SHIFT))	\

+               >> (FIXED_SHIFT + 8);					\

+   dest[ACOMP] = FixedToInt(span->alpha)

+

+#define BLEND								\

+   dest[RCOMP] = ((CHAN_MAX - sample[RCOMP]) * span->red		\

+               + (sample[RCOMP] + 1) * info->er) >> (FIXED_SHIFT + 8);	\

+   dest[GCOMP] = ((CHAN_MAX - sample[GCOMP]) * span->green		\

+               + (sample[GCOMP] + 1) * info->eg) >> (FIXED_SHIFT + 8);	\

+   dest[BCOMP] = ((CHAN_MAX - sample[BCOMP]) * span->blue		\

+               + (sample[BCOMP] + 1) * info->eb) >> (FIXED_SHIFT + 8);	\

+   dest[ACOMP] = span->alpha * (sample[ACOMP] + 1) >> (FIXED_SHIFT + 8)

+

+#define REPLACE  COPY_CHAN4(dest, sample)

+

+#define ADD								\

+   {									\

+      GLint rSum = FixedToInt(span->red)   + (GLint) sample[RCOMP];	\

+      GLint gSum = FixedToInt(span->green) + (GLint) sample[GCOMP];	\

+      GLint bSum = FixedToInt(span->blue)  + (GLint) sample[BCOMP];	\

+      dest[RCOMP] = MIN2(rSum, CHAN_MAX);				\

+      dest[GCOMP] = MIN2(gSum, CHAN_MAX);				\

+      dest[BCOMP] = MIN2(bSum, CHAN_MAX);				\

+      dest[ACOMP] = span->alpha * (sample[ACOMP] + 1) >> (FIXED_SHIFT + 8); \

+  }

+

+/* shortcuts */

+

+#define NEAREST_RGB_REPLACE		\

+   NEAREST_RGB;				\

+   dest[0] = sample[0];			\

+   dest[1] = sample[1];			\

+   dest[2] = sample[2];			\

+   dest[3] = FixedToInt(span->alpha);

+

+#define NEAREST_RGBA_REPLACE  \

+   dest[RCOMP] = tex00[3]; \

+   dest[GCOMP] = tex00[2]; \

+   dest[BCOMP] = tex00[1]; \

+   dest[ACOMP] = tex00[0]

+

+#define SPAN_NEAREST(DO_TEX, COMPS)					\

+	for (i = 0; i < span->end; i++) {				\

+           /* Isn't it necessary to use FixedFloor below?? */		\

+           GLint s = FixedToInt(span->intTex[0]) & info->smask;		\

+           GLint t = FixedToInt(span->intTex[1]) & info->tmask;		\

+           GLint pos = (t << info->twidth_log2) + s;			\

+           const GLchan *tex00 = info->texture + COMPS * pos;		\

+           DO_TEX;							\

+           span->red += span->redStep;					\

+	   span->green += span->greenStep;				\

+           span->blue += span->blueStep;				\

+	   span->alpha += span->alphaStep;				\

+	   span->intTex[0] += span->intTexStep[0];			\

+	   span->intTex[1] += span->intTexStep[1];			\

+           dest += 4;							\

+	}

+

+#define SPAN_LINEAR(DO_TEX, COMPS)					\

+	for (i = 0; i < span->end; i++) {				\

+           /* Isn't it necessary to use FixedFloor below?? */		\

+           const GLint s = FixedToInt(span->intTex[0]) & info->smask;	\

+           const GLint t = FixedToInt(span->intTex[1]) & info->tmask;	\

+           const GLfixed sf = span->intTex[0] & FIXED_FRAC_MASK;	\

+           const GLfixed tf = span->intTex[1] & FIXED_FRAC_MASK;	\

+           const GLint pos = (t << info->twidth_log2) + s;		\

+           const GLchan *tex00 = info->texture + COMPS * pos;		\

+           const GLchan *tex10 = tex00 + info->tbytesline;		\

+           const GLchan *tex01 = tex00 + COMPS;				\

+           const GLchan *tex11 = tex10 + COMPS;				\

+           if (t == info->tmask) {					\

+              tex10 -= info->tsize;					\

+              tex11 -= info->tsize;					\

+           }								\

+           if (s == info->smask) {					\

+              tex01 -= info->tbytesline;				\

+              tex11 -= info->tbytesline;				\

+           }								\

+           DO_TEX;							\

+           span->red += span->redStep;					\

+	   span->green += span->greenStep;				\

+           span->blue += span->blueStep;				\

+	   span->alpha += span->alphaStep;				\

+	   span->intTex[0] += span->intTexStep[0];			\

+	   span->intTex[1] += span->intTexStep[1];			\

+           dest += 4;							\

+	}

+

+

+   GLuint i;

+   GLchan *dest = span->array->rgba[0];

+

+   /* Disable tex units so they're not re-applied in swrast_write_rgba_span */

+   ctx->Texture._EnabledCoordUnits = 0x0;

+

+   span->intTex[0] -= FIXED_HALF;

+   span->intTex[1] -= FIXED_HALF;

+   switch (info->filter) {

+   case GL_NEAREST:

+      switch (info->format) {

+      case MESA_FORMAT_RGB888:

+         switch (info->envmode) {

+         case GL_MODULATE:

+            SPAN_NEAREST(NEAREST_RGB;MODULATE,3);

+            break;

+         case GL_DECAL:

+         case GL_REPLACE:

+            SPAN_NEAREST(NEAREST_RGB_REPLACE,3);

+            break;

+         case GL_BLEND:

+            SPAN_NEAREST(NEAREST_RGB;BLEND,3);

+            break;

+         case GL_ADD:

+            SPAN_NEAREST(NEAREST_RGB;ADD,3);

+            break;

+         default:

+            _mesa_problem(ctx, "bad tex env mode in SPAN_LINEAR");

+            return;

+         }

+         break;

+      case MESA_FORMAT_RGBA8888:

+         switch(info->envmode) {

+         case GL_MODULATE:

+            SPAN_NEAREST(NEAREST_RGBA;MODULATE,4);

+            break;

+         case GL_DECAL:

+            SPAN_NEAREST(NEAREST_RGBA;DECAL,4);

+            break;

+         case GL_BLEND:

+            SPAN_NEAREST(NEAREST_RGBA;BLEND,4);

+            break;

+         case GL_ADD:

+            SPAN_NEAREST(NEAREST_RGBA;ADD,4);

+            break;

+         case GL_REPLACE:

+            SPAN_NEAREST(NEAREST_RGBA_REPLACE,4);

+            break;

+         default:

+            _mesa_problem(ctx, "bad tex env mode (2) in SPAN_LINEAR");

+            return;

+         }

+         break;

+      }

+      break;

+

+   case GL_LINEAR:

+      span->intTex[0] -= FIXED_HALF;

+      span->intTex[1] -= FIXED_HALF;

+      switch (info->format) {

+      case MESA_FORMAT_RGB888:

+         switch (info->envmode) {

+         case GL_MODULATE:

+            SPAN_LINEAR(LINEAR_RGB;MODULATE,3);

+            break;

+         case GL_DECAL:

+         case GL_REPLACE:

+            SPAN_LINEAR(LINEAR_RGB;REPLACE,3);

+            break;

+         case GL_BLEND:

+            SPAN_LINEAR(LINEAR_RGB;BLEND,3);

+            break;

+         case GL_ADD:

+            SPAN_LINEAR(LINEAR_RGB;ADD,3);

+            break;

+         default:

+            _mesa_problem(ctx, "bad tex env mode (3) in SPAN_LINEAR");

+            return;

+         }

+         break;

+      case MESA_FORMAT_RGBA8888:

+         switch (info->envmode) {

+         case GL_MODULATE:

+            SPAN_LINEAR(LINEAR_RGBA;MODULATE,4);

+            break;

+         case GL_DECAL:

+            SPAN_LINEAR(LINEAR_RGBA;DECAL,4);

+            break;

+         case GL_BLEND:

+            SPAN_LINEAR(LINEAR_RGBA;BLEND,4);

+            break;

+         case GL_ADD:

+            SPAN_LINEAR(LINEAR_RGBA;ADD,4);

+            break;

+         case GL_REPLACE:

+            SPAN_LINEAR(LINEAR_RGBA;REPLACE,4);

+            break;

+         default:

+            _mesa_problem(ctx, "bad tex env mode (4) in SPAN_LINEAR");

+            return;

+         }

+         break;

+      }

+      break;

+   }

+   span->interpMask &= ~SPAN_RGBA;

+   ASSERT(span->arrayMask & SPAN_RGBA);

+

+   _swrast_write_rgba_span(ctx, span);

+

+   /* re-enable texture units */

+   ctx->Texture._EnabledCoordUnits = texEnableSave;

+

+#undef SPAN_NEAREST

+#undef SPAN_LINEAR

+}

+

+

+

+/*

+ * Render an RGB/RGBA textured triangle without perspective correction.

+ */

+#define NAME affine_textured_triangle

+#define INTERP_Z 1

+#define INTERP_RGB 1

+#define INTERP_ALPHA 1

+#define INTERP_INT_TEX 1

+#define S_SCALE twidth

+#define T_SCALE theight

+

+#define SETUP_CODE							\

+   struct affine_info info;						\

+   struct gl_texture_unit *unit = ctx->Texture.Unit+0;			\

+   const struct gl_texture_object *obj = 				\

+      ctx->Texture.Unit[0].CurrentTex[TEXTURE_2D_INDEX];		\

+   const struct gl_texture_image *texImg = 				\

+      obj->Image[0][obj->BaseLevel]; 					\

+   const GLfloat twidth = (GLfloat) texImg->Width;			\

+   const GLfloat theight = (GLfloat) texImg->Height;			\

+   info.texture = (const GLchan *) texImg->Data;			\

+   info.twidth_log2 = texImg->WidthLog2;				\

+   info.smask = texImg->Width - 1;					\

+   info.tmask = texImg->Height - 1;					\

+   info.format = texImg->TexFormat;					\

+   info.filter = obj->MinFilter;					\

+   info.envmode = unit->EnvMode;					\

+   info.er = 0;					\

+   info.eg = 0;					\

+   info.eb = 0;					\

+   span.arrayMask |= SPAN_RGBA;						\

+									\

+   if (info.envmode == GL_BLEND) {					\

+      /* potential off-by-one error here? (1.0f -> 2048 -> 0) */	\

+      info.er = FloatToFixed(unit->EnvColor[RCOMP] * CHAN_MAXF);	\

+      info.eg = FloatToFixed(unit->EnvColor[GCOMP] * CHAN_MAXF);	\

+      info.eb = FloatToFixed(unit->EnvColor[BCOMP] * CHAN_MAXF);	\

+      info.ea = FloatToFixed(unit->EnvColor[ACOMP] * CHAN_MAXF);	\

+   }									\

+   if (!info.texture) {							\

+      /* this shouldn't happen */					\

+      return;								\

+   }									\

+									\

+   switch (info.format) {						\

+   case MESA_FORMAT_RGB888:						\

+      info.tbytesline = texImg->Width * 3;				\

+      break;								\

+   case MESA_FORMAT_RGBA8888:						\

+      info.tbytesline = texImg->Width * 4;				\

+      break;								\

+   default:								\

+      _mesa_problem(NULL, "Bad texture format in affine_texture_triangle");\

+      return;								\

+   }									\

+   info.tsize = texImg->Height * info.tbytesline;

+

+#define RENDER_SPAN( span )   affine_span(ctx, &span, &info);

+

+#include "s_tritemp.h"

+

+

+

+struct persp_info

+{

+   GLenum filter;

+   GLenum format;

+   GLenum envmode;

+   GLint smask, tmask;

+   GLint twidth_log2;

+   const GLchan *texture;

+   GLfixed er, eg, eb, ea;   /* texture env color */

+   GLint tbytesline, tsize;

+};

+

+

+static INLINE void

+fast_persp_span(struct gl_context *ctx, SWspan *span,

+		struct persp_info *info)

+{

+   GLchan sample[4];  /* the filtered texture sample */

+

+  /* Instead of defining a function for each mode, a test is done

+   * between the outer and inner loops. This is to reduce code size

+   * and complexity. Observe that an optimizing compiler kills

+   * unused variables (for instance tf,sf,ti,si in case of GL_NEAREST).

+   */

+#define SPAN_NEAREST(DO_TEX,COMP)					\

+	for (i = 0; i < span->end; i++) {				\

+           GLdouble invQ = tex_coord[2] ?				\

+                                 (1.0 / tex_coord[2]) : 1.0;            \

+           GLfloat s_tmp = (GLfloat) (tex_coord[0] * invQ);		\

+           GLfloat t_tmp = (GLfloat) (tex_coord[1] * invQ);		\

+           GLint s = IFLOOR(s_tmp) & info->smask;	        	\

+           GLint t = IFLOOR(t_tmp) & info->tmask;	        	\

+           GLint pos = (t << info->twidth_log2) + s;			\

+           const GLchan *tex00 = info->texture + COMP * pos;		\

+           DO_TEX;							\

+           span->red += span->redStep;					\

+	   span->green += span->greenStep;				\

+           span->blue += span->blueStep;				\

+	   span->alpha += span->alphaStep;				\

+	   tex_coord[0] += tex_step[0];					\

+	   tex_coord[1] += tex_step[1];					\

+	   tex_coord[2] += tex_step[2];					\

+           dest += 4;							\

+	}

+

+#define SPAN_LINEAR(DO_TEX,COMP)					\

+	for (i = 0; i < span->end; i++) {				\

+           GLdouble invQ = tex_coord[2] ?				\

+                                 (1.0 / tex_coord[2]) : 1.0;            \

+           const GLfloat s_tmp = (GLfloat) (tex_coord[0] * invQ);	\

+           const GLfloat t_tmp = (GLfloat) (tex_coord[1] * invQ);	\

+           const GLfixed s_fix = FloatToFixed(s_tmp) - FIXED_HALF;	\

+           const GLfixed t_fix = FloatToFixed(t_tmp) - FIXED_HALF;      \

+           const GLint s = FixedToInt(FixedFloor(s_fix)) & info->smask;	\

+           const GLint t = FixedToInt(FixedFloor(t_fix)) & info->tmask;	\

+           const GLfixed sf = s_fix & FIXED_FRAC_MASK;			\

+           const GLfixed tf = t_fix & FIXED_FRAC_MASK;			\

+           const GLint pos = (t << info->twidth_log2) + s;		\

+           const GLchan *tex00 = info->texture + COMP * pos;		\

+           const GLchan *tex10 = tex00 + info->tbytesline;		\

+           const GLchan *tex01 = tex00 + COMP;				\

+           const GLchan *tex11 = tex10 + COMP;				\

+           if (t == info->tmask) {					\

+              tex10 -= info->tsize;					\

+              tex11 -= info->tsize;					\

+           }								\

+           if (s == info->smask) {					\

+              tex01 -= info->tbytesline;				\

+              tex11 -= info->tbytesline;				\

+           }								\

+           DO_TEX;							\

+           span->red   += span->redStep;				\

+	   span->green += span->greenStep;				\

+           span->blue  += span->blueStep;				\

+	   span->alpha += span->alphaStep;				\

+	   tex_coord[0] += tex_step[0];					\

+	   tex_coord[1] += tex_step[1];					\

+	   tex_coord[2] += tex_step[2];					\

+           dest += 4;							\

+	}

+

+   GLuint i;

+   GLfloat tex_coord[3], tex_step[3];

+   GLchan *dest = span->array->rgba[0];

+

+   const GLuint texEnableSave = ctx->Texture._EnabledCoordUnits;

+   ctx->Texture._EnabledCoordUnits = 0;

+

+   tex_coord[0] = span->attrStart[FRAG_ATTRIB_TEX0][0]  * (info->smask + 1);

+   tex_step[0] = span->attrStepX[FRAG_ATTRIB_TEX0][0] * (info->smask + 1);

+   tex_coord[1] = span->attrStart[FRAG_ATTRIB_TEX0][1] * (info->tmask + 1);

+   tex_step[1] = span->attrStepX[FRAG_ATTRIB_TEX0][1] * (info->tmask + 1);

+   /* span->attrStart[FRAG_ATTRIB_TEX0][2] only if 3D-texturing, here only 2D */

+   tex_coord[2] = span->attrStart[FRAG_ATTRIB_TEX0][3];

+   tex_step[2] = span->attrStepX[FRAG_ATTRIB_TEX0][3];

+

+   switch (info->filter) {

+   case GL_NEAREST:

+      switch (info->format) {

+      case MESA_FORMAT_RGB888:

+         switch (info->envmode) {

+         case GL_MODULATE:

+            SPAN_NEAREST(NEAREST_RGB;MODULATE,3);

+            break;

+         case GL_DECAL:

+         case GL_REPLACE:

+            SPAN_NEAREST(NEAREST_RGB_REPLACE,3);

+            break;

+         case GL_BLEND:

+            SPAN_NEAREST(NEAREST_RGB;BLEND,3);

+            break;

+         case GL_ADD:

+            SPAN_NEAREST(NEAREST_RGB;ADD,3);

+            break;

+         default:

+            _mesa_problem(ctx, "bad tex env mode (5) in SPAN_LINEAR");

+            return;

+         }

+         break;

+      case MESA_FORMAT_RGBA8888:

+         switch(info->envmode) {

+         case GL_MODULATE:

+            SPAN_NEAREST(NEAREST_RGBA;MODULATE,4);

+            break;

+         case GL_DECAL:

+            SPAN_NEAREST(NEAREST_RGBA;DECAL,4);

+            break;

+         case GL_BLEND:

+            SPAN_NEAREST(NEAREST_RGBA;BLEND,4);

+            break;

+         case GL_ADD:

+            SPAN_NEAREST(NEAREST_RGBA;ADD,4);

+            break;

+         case GL_REPLACE:

+            SPAN_NEAREST(NEAREST_RGBA_REPLACE,4);

+            break;

+         default:

+            _mesa_problem(ctx, "bad tex env mode (6) in SPAN_LINEAR");

+            return;

+         }

+         break;

+      }

+      break;

+

+   case GL_LINEAR:

+      switch (info->format) {

+      case MESA_FORMAT_RGB888:

+         switch (info->envmode) {

+         case GL_MODULATE:

+            SPAN_LINEAR(LINEAR_RGB;MODULATE,3);

+            break;

+         case GL_DECAL:

+         case GL_REPLACE:

+            SPAN_LINEAR(LINEAR_RGB;REPLACE,3);

+            break;

+         case GL_BLEND:

+            SPAN_LINEAR(LINEAR_RGB;BLEND,3);

+            break;

+         case GL_ADD:

+            SPAN_LINEAR(LINEAR_RGB;ADD,3);

+            break;

+         default:

+            _mesa_problem(ctx, "bad tex env mode (7) in SPAN_LINEAR");

+            return;

+         }

+         break;

+      case MESA_FORMAT_RGBA8888:

+         switch (info->envmode) {

+         case GL_MODULATE:

+            SPAN_LINEAR(LINEAR_RGBA;MODULATE,4);

+            break;

+         case GL_DECAL:

+            SPAN_LINEAR(LINEAR_RGBA;DECAL,4);

+            break;

+         case GL_BLEND:

+            SPAN_LINEAR(LINEAR_RGBA;BLEND,4);

+            break;

+         case GL_ADD:

+            SPAN_LINEAR(LINEAR_RGBA;ADD,4);

+            break;

+         case GL_REPLACE:

+            SPAN_LINEAR(LINEAR_RGBA;REPLACE,4);

+            break;

+         default:

+            _mesa_problem(ctx, "bad tex env mode (8) in SPAN_LINEAR");

+            return;

+         }

+         break;

+      }

+      break;

+   }

+   

+   ASSERT(span->arrayMask & SPAN_RGBA);

+   _swrast_write_rgba_span(ctx, span);

+

+#undef SPAN_NEAREST

+#undef SPAN_LINEAR

+

+   /* restore state */

+   ctx->Texture._EnabledCoordUnits = texEnableSave;

+}

+

+

+/*

+ * Render an perspective corrected RGB/RGBA textured triangle.

+ * The Q (aka V in Mesa) coordinate must be zero such that the divide

+ * by interpolated Q/W comes out right.

+ *

+ */

+#define NAME persp_textured_triangle

+#define INTERP_Z 1

+#define INTERP_RGB 1

+#define INTERP_ALPHA 1

+#define INTERP_ATTRIBS 1

+

+#define SETUP_CODE							\

+   struct persp_info info;						\

+   const struct gl_texture_unit *unit = ctx->Texture.Unit+0;		\

+   const struct gl_texture_object *obj = 				\

+      ctx->Texture.Unit[0].CurrentTex[TEXTURE_2D_INDEX];		\

+   const struct gl_texture_image *texImg = 				\

+      obj->Image[0][obj->BaseLevel];			 		\

+   info.texture = (const GLchan *) texImg->Data;			\

+   info.twidth_log2 = texImg->WidthLog2;				\

+   info.smask = texImg->Width - 1;					\

+   info.tmask = texImg->Height - 1;					\

+   info.format = texImg->TexFormat;					\

+   info.filter = obj->MinFilter;					\

+   info.envmode = unit->EnvMode;					\

+   info.er = 0;					\

+   info.eg = 0;					\

+   info.eb = 0;					\

+									\

+   if (info.envmode == GL_BLEND) {					\

+      /* potential off-by-one error here? (1.0f -> 2048 -> 0) */	\

+      info.er = FloatToFixed(unit->EnvColor[RCOMP] * CHAN_MAXF);	\

+      info.eg = FloatToFixed(unit->EnvColor[GCOMP] * CHAN_MAXF);	\

+      info.eb = FloatToFixed(unit->EnvColor[BCOMP] * CHAN_MAXF);	\

+      info.ea = FloatToFixed(unit->EnvColor[ACOMP] * CHAN_MAXF);	\

+   }									\

+   if (!info.texture) {							\

+      /* this shouldn't happen */					\

+      return;								\

+   }									\

+									\

+   switch (info.format) {						\

+   case MESA_FORMAT_RGB888:						\

+      info.tbytesline = texImg->Width * 3;				\

+      break;								\

+   case MESA_FORMAT_RGBA8888:						\

+      info.tbytesline = texImg->Width * 4;				\

+      break;								\

+   default:								\

+      _mesa_problem(NULL, "Bad texture format in persp_textured_triangle");\

+      return;								\

+   }									\

+   info.tsize = texImg->Height * info.tbytesline;

+

+#define RENDER_SPAN( span )			\

+   span.interpMask &= ~SPAN_RGBA;		\

+   span.arrayMask |= SPAN_RGBA;			\

+   fast_persp_span(ctx, &span, &info);

+

+#include "s_tritemp.h"

+

+#endif /*CHAN_TYPE != GL_FLOAT*/

+

+

+

+/*

+ * Render an RGBA triangle with arbitrary attributes.

+ */

+#define NAME general_triangle

+#define INTERP_Z 1

+#define INTERP_RGB 1

+#define INTERP_ALPHA 1

+#define INTERP_ATTRIBS 1

+#define RENDER_SPAN( span )   _swrast_write_rgba_span(ctx, &span);

+#include "s_tritemp.h"

+

+

+

+

+/*

+ * Special tri function for occlusion testing

+ */

+#define NAME occlusion_zless_triangle

+#define INTERP_Z 1

+#define SETUP_CODE							\

+   struct gl_renderbuffer *rb = ctx->DrawBuffer->_DepthBuffer;		\

+   struct gl_query_object *q = ctx->Query.CurrentOcclusionObject;	\

+   ASSERT(ctx->Depth.Test);						\

+   ASSERT(!ctx->Depth.Mask);						\

+   ASSERT(ctx->Depth.Func == GL_LESS);					\

+   if (!q) {								\

+      return;								\

+   }

+#define RENDER_SPAN( span )						\

+   if (rb->Format == MESA_FORMAT_Z16) {					\

+      GLuint i;								\

+      const GLushort *zRow = (const GLushort *)				\

+         rb->GetPointer(ctx, rb, span.x, span.y);			\

+      for (i = 0; i < span.end; i++) {					\

+         GLuint z = FixedToDepth(span.z);				\

+         if (z < zRow[i]) {						\

+            q->Result++;						\

+         }								\

+         span.z += span.zStep;						\

+      }									\

+   }									\

+   else {								\

+      GLuint i;								\

+      const GLuint *zRow = (const GLuint *)				\

+         rb->GetPointer(ctx, rb, span.x, span.y);			\

+      for (i = 0; i < span.end; i++) {					\

+         if ((GLuint)span.z < zRow[i]) {				\

+            q->Result++;						\

+         }								\

+         span.z += span.zStep;						\

+      }									\

+   }

+#include "s_tritemp.h"

+

+

+

+static void

+nodraw_triangle( struct gl_context *ctx,

+                 const SWvertex *v0,

+                 const SWvertex *v1,

+                 const SWvertex *v2 )

+{

+   (void) (ctx && v0 && v1 && v2);

+}

+

+

+/*

+ * This is used when separate specular color is enabled, but not

+ * texturing.  We add the specular color to the primary color,

+ * draw the triangle, then restore the original primary color.

+ * Inefficient, but seldom needed.

+ */

+void

+_swrast_add_spec_terms_triangle(struct gl_context *ctx, const SWvertex *v0,

+                                const SWvertex *v1, const SWvertex *v2)

+{

+   SWvertex *ncv0 = (SWvertex *)v0; /* drop const qualifier */

+   SWvertex *ncv1 = (SWvertex *)v1;

+   SWvertex *ncv2 = (SWvertex *)v2;

+   GLfloat rSum, gSum, bSum;

+   GLchan cSave[3][4];

+

+   /* save original colors */

+   COPY_CHAN4( cSave[0], ncv0->color );

+   COPY_CHAN4( cSave[1], ncv1->color );

+   COPY_CHAN4( cSave[2], ncv2->color );

+   /* sum v0 */

+   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);

+   /* sum v1 */

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

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

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

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

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

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

+   /* sum v2 */

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

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

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

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

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

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

+   /* draw */

+   SWRAST_CONTEXT(ctx)->SpecTriangle( ctx, ncv0, ncv1, ncv2 );

+   /* restore original colors */

+   COPY_CHAN4( ncv0->color, cSave[0] );

+   COPY_CHAN4( ncv1->color, cSave[1] );

+   COPY_CHAN4( ncv2->color, cSave[2] );

+}

+

+

+

+#ifdef DEBUG

+

+/* record the current triangle function name */

+const char *_mesa_triFuncName = NULL;

+

+#define USE(triFunc)				\

+do {						\

+    _mesa_triFuncName = #triFunc;		\

+    /*printf("%s\n", _mesa_triFuncName);*/	\

+    swrast->Triangle = triFunc;			\

+} while (0)

+

+#else

+

+#define USE(triFunc)  swrast->Triangle = triFunc;

+

+#endif

+

+

+

+

+/*

+ * Determine which triangle rendering function to use given the current

+ * rendering context.

+ *

+ * Please update the summary flag _SWRAST_NEW_TRIANGLE if you add or

+ * remove tests to this code.

+ */

+void

+_swrast_choose_triangle( struct gl_context *ctx )

+{

+   SWcontext *swrast = SWRAST_CONTEXT(ctx);

+

+   if (ctx->Polygon.CullFlag &&

+       ctx->Polygon.CullFaceMode == GL_FRONT_AND_BACK) {

+      USE(nodraw_triangle);

+      return;

+   }

+

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

+

+      if (ctx->Polygon.SmoothFlag) {

+         _swrast_set_aa_triangle_function(ctx);

+         ASSERT(swrast->Triangle);

+         return;

+      }

+

+      /* special case for occlusion testing */

+      if (ctx->Query.CurrentOcclusionObject &&

+          ctx->Depth.Test &&

+          ctx->Depth.Mask == GL_FALSE &&

+          ctx->Depth.Func == GL_LESS &&

+          !ctx->Stencil._Enabled) {

+         if (ctx->Color.ColorMask[0][0] == 0 &&

+	     ctx->Color.ColorMask[0][1] == 0 &&

+	     ctx->Color.ColorMask[0][2] == 0 &&

+	     ctx->Color.ColorMask[0][3] == 0) {

+            USE(occlusion_zless_triangle);

+            return;

+         }

+      }

+

+      /*

+       * XXX should examine swrast->_ActiveAttribMask to determine what

+       * needs to be interpolated.

+       */

+      if (ctx->Texture._EnabledCoordUnits ||

+          ctx->FragmentProgram._Current ||

+          ctx->ATIFragmentShader._Enabled ||

+          NEED_SECONDARY_COLOR(ctx) ||

+          swrast->_FogEnabled) {

+         /* Ugh, we do a _lot_ of tests to pick the best textured tri func */

+         const struct gl_texture_object *texObj2D;

+         const struct gl_texture_image *texImg;

+         GLenum minFilter, magFilter, envMode;

+         gl_format format;

+         texObj2D = ctx->Texture.Unit[0].CurrentTex[TEXTURE_2D_INDEX];

+

+         texImg = texObj2D ? texObj2D->Image[0][texObj2D->BaseLevel] : NULL;

+         format = texImg ? texImg->TexFormat : MESA_FORMAT_NONE;

+         minFilter = texObj2D ? texObj2D->MinFilter : GL_NONE;

+         magFilter = texObj2D ? texObj2D->MagFilter : GL_NONE;

+         envMode = ctx->Texture.Unit[0].EnvMode;

+

+         /* First see if we can use an optimized 2-D texture function */

+         if (ctx->Texture._EnabledCoordUnits == 0x1

+             && !ctx->FragmentProgram._Current

+             && !ctx->ATIFragmentShader._Enabled

+             && ctx->Texture._EnabledUnits == 0x1

+             && ctx->Texture.Unit[0]._ReallyEnabled == TEXTURE_2D_BIT

+             && texObj2D->WrapS == GL_REPEAT

+             && texObj2D->WrapT == GL_REPEAT

+             && texObj2D->_Swizzle == SWIZZLE_NOOP

+             && texImg->_IsPowerOfTwo

+             && texImg->Border == 0

+             && texImg->Width == texImg->RowStride

+             && (format == MESA_FORMAT_RGB888 || format == MESA_FORMAT_RGBA8888)

+             && minFilter == magFilter

+             && ctx->Light.Model.ColorControl == GL_SINGLE_COLOR

+             && !swrast->_FogEnabled

+             && ctx->Texture.Unit[0].EnvMode != GL_COMBINE_EXT

+             && ctx->Texture.Unit[0].EnvMode != GL_COMBINE4_NV) {

+	    if (ctx->Hint.PerspectiveCorrection==GL_FASTEST) {

+	       if (minFilter == GL_NEAREST

+		   && format == MESA_FORMAT_RGB888

+		   && (envMode == GL_REPLACE || envMode == GL_DECAL)

+		   && ((swrast->_RasterMask == (DEPTH_BIT | TEXTURE_BIT)

+			&& ctx->Depth.Func == GL_LESS

+			&& ctx->Depth.Mask == GL_TRUE)

+		       || swrast->_RasterMask == TEXTURE_BIT)

+		   && ctx->Polygon.StippleFlag == GL_FALSE

+                   && ctx->DrawBuffer->Visual.depthBits <= 16) {

+		  if (swrast->_RasterMask == (DEPTH_BIT | TEXTURE_BIT)) {

+		     USE(simple_z_textured_triangle);

+		  }

+		  else {

+		     USE(simple_textured_triangle);

+		  }

+	       }

+	       else {

+#if CHAN_BITS != 8

+                  USE(general_triangle);

+#else

+                  if (format == MESA_FORMAT_RGBA8888 && !_mesa_little_endian()) {

+                     /* We only handle RGBA8888 correctly on little endian

+                      * in the optimized code above.

+                      */

+                     USE(general_triangle);

+                  }

+                  else {

+                     USE(affine_textured_triangle);

+                 }

+#endif

+	       }

+	    }

+	    else {

+#if CHAN_BITS != 8

+               USE(general_triangle);

+#else

+               USE(persp_textured_triangle);

+#endif

+	    }

+	 }

+         else {

+            /* general case textured triangles */

+            USE(general_triangle);

+         }

+      }

+      else {

+         ASSERT(!swrast->_FogEnabled);

+         ASSERT(!NEED_SECONDARY_COLOR(ctx));

+	 if (ctx->Light.ShadeModel==GL_SMOOTH) {

+	    /* smooth shaded, no texturing, stippled or some raster ops */

+#if CHAN_BITS != 8

+               USE(general_triangle);

+#else

+               USE(smooth_rgba_triangle);

+#endif

+	 }

+	 else {

+	    /* flat shaded, no texturing, stippled or some raster ops */

+#if CHAN_BITS != 8

+            USE(general_triangle);

+#else

+            USE(flat_rgba_triangle);

+#endif

+	 }

+      }

+   }

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

+      USE(_swrast_feedback_triangle);

+   }

+   else {

+      /* GL_SELECT mode */

+      USE(_swrast_select_triangle);

+   }

+}

diff --git a/mesalib/src/mesa/swrast/s_triangle.h b/mesalib/src/mesa/swrast/s_triangle.h
index b81932c73..bde5dd58b 100644
--- a/mesalib/src/mesa/swrast/s_triangle.h
+++ b/mesalib/src/mesa/swrast/s_triangle.h
@@ -1,50 +1,50 @@
-
-/*
- * Mesa 3-D graphics library
- * Version:  5.1
- *
- * Copyright (C) 1999-2003  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.
- */
-
-
-#ifndef S_TRIANGLES_H
-#define S_TRIANGLES_H
-
-
-#include "swrast.h"
-
-
-extern GLboolean
-_swrast_culltriangle( GLcontext *ctx,
-                     const SWvertex *v0,
-                     const SWvertex *v1,
-                     const SWvertex *v2);
-
-extern void
-_swrast_choose_triangle( GLcontext *ctx );
-
-extern void
-_swrast_add_spec_terms_triangle( GLcontext *ctx,
-				 const SWvertex *v0,
-				 const SWvertex *v1,
-				 const SWvertex *v2 );
-
-
-#endif
+

+/*

+ * Mesa 3-D graphics library

+ * Version:  5.1

+ *

+ * Copyright (C) 1999-2003  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.

+ */

+

+

+#ifndef S_TRIANGLES_H

+#define S_TRIANGLES_H

+

+

+#include "swrast.h"

+

+

+extern GLboolean

+_swrast_culltriangle( struct gl_context *ctx,

+                     const SWvertex *v0,

+                     const SWvertex *v1,

+                     const SWvertex *v2);

+

+extern void

+_swrast_choose_triangle( struct gl_context *ctx );

+

+extern void

+_swrast_add_spec_terms_triangle( struct gl_context *ctx,

+				 const SWvertex *v0,

+				 const SWvertex *v1,

+				 const SWvertex *v2 );

+

+

+#endif

diff --git a/mesalib/src/mesa/swrast/s_tritemp.h b/mesalib/src/mesa/swrast/s_tritemp.h
index 0aa8739f4..340c410ca 100644
--- a/mesalib/src/mesa/swrast/s_tritemp.h
+++ b/mesalib/src/mesa/swrast/s_tritemp.h
@@ -1,929 +1,929 @@
-/*
- * Mesa 3-D graphics library
- * Version:  7.0
- *
- * 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.
- */
-
-/*
- * Triangle Rasterizer Template
- *
- * This file is #include'd to generate custom triangle rasterizers.
- *
- * The following macros may be defined to indicate what auxillary information
- * must be interpolated across the triangle:
- *    INTERP_Z        - if defined, interpolate integer Z values
- *    INTERP_RGB      - if defined, interpolate integer RGB values
- *    INTERP_ALPHA    - if defined, interpolate integer Alpha values
- *    INTERP_INT_TEX  - if defined, interpolate integer ST texcoords
- *                         (fast, simple 2-D texture mapping, without
- *                         perspective correction)
- *    INTERP_ATTRIBS  - if defined, interpolate arbitrary attribs (texcoords,
- *                         varying vars, etc)  This also causes W to be
- *                         computed for perspective correction).
- *
- * When one can directly address pixels in the color buffer the following
- * macros can be defined and used to compute pixel addresses during
- * rasterization (see pRow):
- *    PIXEL_TYPE          - the datatype of a pixel (GLubyte, GLushort, GLuint)
- *    BYTES_PER_ROW       - number of bytes per row in the color buffer
- *    PIXEL_ADDRESS(X,Y)  - returns the address of pixel at (X,Y) where
- *                          Y==0 at bottom of screen and increases upward.
- *
- * Similarly, for direct depth buffer access, this type is used for depth
- * buffer addressing (see zRow):
- *    DEPTH_TYPE          - either GLushort or GLuint
- *
- * Optionally, one may provide one-time setup code per triangle:
- *    SETUP_CODE    - code which is to be executed once per triangle
- *
- * The following macro MUST be defined:
- *    RENDER_SPAN(span) - code to write a span of pixels.
- *
- * This code was designed for the origin to be in the lower-left corner.
- *
- * Inspired by triangle rasterizer code written by Allen Akin.  Thanks Allen!
- *
- *
- * Some notes on rasterization accuracy:
- *
- * This code uses fixed point arithmetic (the GLfixed type) to iterate
- * over the triangle edges and interpolate ancillary data (such as Z,
- * color, secondary color, etc).  The number of fractional bits in
- * GLfixed and the value of SUB_PIXEL_BITS has a direct bearing on the
- * accuracy of rasterization.
- *
- * If SUB_PIXEL_BITS=4 then we'll snap the vertices to the nearest
- * 1/16 of a pixel.  If we're walking up a long, nearly vertical edge
- * (dx=1/16, dy=1024) we'll need 4 + 10 = 14 fractional bits in
- * GLfixed to walk the edge without error.  If the maximum viewport
- * height is 4K pixels, then we'll need 4 + 12 = 16 fractional bits.
- *
- * Historically, Mesa has used 11 fractional bits in GLfixed, snaps
- * vertices to 1/16 pixel and allowed a maximum viewport height of 2K
- * pixels.  11 fractional bits is actually insufficient for accurately
- * rasterizing some triangles.  More recently, the maximum viewport
- * height was increased to 4K pixels.  Thus, Mesa should be using 16
- * fractional bits in GLfixed.  Unfortunately, there may be some issues
- * with setting FIXED_FRAC_BITS=16, such as multiplication overflow.
- * This will have to be examined in some detail...
- *
- * For now, if you find rasterization errors, particularly with tall,
- * sliver triangles, try increasing FIXED_FRAC_BITS and/or decreasing
- * SUB_PIXEL_BITS.
- */
-
-
-/*
- * Some code we unfortunately need to prevent negative interpolated colors.
- */
-#ifndef CLAMP_INTERPOLANT
-#define CLAMP_INTERPOLANT(CHANNEL, CHANNELSTEP, LEN)		\
-do {								\
-   GLfixed endVal = span.CHANNEL + (LEN) * span.CHANNELSTEP;	\
-   if (endVal < 0) {						\
-      span.CHANNEL -= endVal;					\
-   }								\
-   if (span.CHANNEL < 0) {					\
-      span.CHANNEL = 0;						\
-   }								\
-} while (0)
-#endif
-
-
-static void NAME(GLcontext *ctx, const SWvertex *v0,
-                                 const SWvertex *v1,
-                                 const SWvertex *v2 )
-{
-   typedef struct {
-      const SWvertex *v0, *v1;   /* Y(v0) < Y(v1) */
-      GLfloat dx;	/* X(v1) - X(v0) */
-      GLfloat dy;	/* Y(v1) - Y(v0) */
-      GLfloat dxdy;	/* dx/dy */
-      GLfixed fdxdy;	/* dx/dy in fixed-point */
-      GLfloat adjy;	/* adjust from v[0]->fy to fsy, scaled */
-      GLfixed fsx;	/* first sample point x coord */
-      GLfixed fsy;
-      GLfixed fx0;	/* fixed pt X of lower endpoint */
-      GLint lines;	/* number of lines to be sampled on this edge */
-   } EdgeT;
-
-   const SWcontext *swrast = SWRAST_CONTEXT(ctx);
-#ifdef INTERP_Z
-   const GLint depthBits = ctx->DrawBuffer->Visual.depthBits;
-   const GLint fixedToDepthShift = depthBits <= 16 ? FIXED_SHIFT : 0;
-   const GLfloat maxDepth = ctx->DrawBuffer->_DepthMaxF;
-#define FixedToDepth(F)  ((F) >> fixedToDepthShift)
-#endif
-   EdgeT eMaj, eTop, eBot;
-   GLfloat oneOverArea;
-   const SWvertex *vMin, *vMid, *vMax;  /* Y(vMin)<=Y(vMid)<=Y(vMax) */
-   GLfloat bf = SWRAST_CONTEXT(ctx)->_BackfaceSign;
-   const GLint snapMask = ~((FIXED_ONE / (1 << SUB_PIXEL_BITS)) - 1); /* for x/y coord snapping */
-   GLfixed vMin_fx, vMin_fy, vMid_fx, vMid_fy, vMax_fx, vMax_fy;
-
-   SWspan span;
-
-   (void) swrast;
-
-   INIT_SPAN(span, GL_POLYGON);
-   span.y = 0; /* silence warnings */
-
-#ifdef INTERP_Z
-   (void) fixedToDepthShift;
-#endif
-
-   /*
-   printf("%s()\n", __FUNCTION__);
-   printf("  %g, %g, %g\n",
-          v0->attrib[FRAG_ATTRIB_WPOS][0],
-          v0->attrib[FRAG_ATTRIB_WPOS][1],
-          v0->attrib[FRAG_ATTRIB_WPOS][2]);
-   printf("  %g, %g, %g\n",
-          v1->attrib[FRAG_ATTRIB_WPOS][0],
-          v1->attrib[FRAG_ATTRIB_WPOS][1],
-          v1->attrib[FRAG_ATTRIB_WPOS][2]);
-   printf("  %g, %g, %g\n",
-          v2->attrib[FRAG_ATTRIB_WPOS][0],
-          v2->attrib[FRAG_ATTRIB_WPOS][1],
-          v2->attrib[FRAG_ATTRIB_WPOS][2]);
-   */
-
-   /* Compute fixed point x,y coords w/ half-pixel offsets and snapping.
-    * And find the order of the 3 vertices along the Y axis.
-    */
-   {
-      const GLfixed fy0 = FloatToFixed(v0->attrib[FRAG_ATTRIB_WPOS][1] - 0.5F) & snapMask;
-      const GLfixed fy1 = FloatToFixed(v1->attrib[FRAG_ATTRIB_WPOS][1] - 0.5F) & snapMask;
-      const GLfixed fy2 = FloatToFixed(v2->attrib[FRAG_ATTRIB_WPOS][1] - 0.5F) & snapMask;
-      if (fy0 <= fy1) {
-         if (fy1 <= fy2) {
-            /* y0 <= y1 <= y2 */
-            vMin = v0;   vMid = v1;   vMax = v2;
-            vMin_fy = fy0;  vMid_fy = fy1;  vMax_fy = fy2;
-         }
-         else if (fy2 <= fy0) {
-            /* y2 <= y0 <= y1 */
-            vMin = v2;   vMid = v0;   vMax = v1;
-            vMin_fy = fy2;  vMid_fy = fy0;  vMax_fy = fy1;
-         }
-         else {
-            /* y0 <= y2 <= y1 */
-            vMin = v0;   vMid = v2;   vMax = v1;
-            vMin_fy = fy0;  vMid_fy = fy2;  vMax_fy = fy1;
-            bf = -bf;
-         }
-      }
-      else {
-         if (fy0 <= fy2) {
-            /* y1 <= y0 <= y2 */
-            vMin = v1;   vMid = v0;   vMax = v2;
-            vMin_fy = fy1;  vMid_fy = fy0;  vMax_fy = fy2;
-            bf = -bf;
-         }
-         else if (fy2 <= fy1) {
-            /* y2 <= y1 <= y0 */
-            vMin = v2;   vMid = v1;   vMax = v0;
-            vMin_fy = fy2;  vMid_fy = fy1;  vMax_fy = fy0;
-            bf = -bf;
-         }
-         else {
-            /* y1 <= y2 <= y0 */
-            vMin = v1;   vMid = v2;   vMax = v0;
-            vMin_fy = fy1;  vMid_fy = fy2;  vMax_fy = fy0;
-         }
-      }
-
-      /* fixed point X coords */
-      vMin_fx = FloatToFixed(vMin->attrib[FRAG_ATTRIB_WPOS][0] + 0.5F) & snapMask;
-      vMid_fx = FloatToFixed(vMid->attrib[FRAG_ATTRIB_WPOS][0] + 0.5F) & snapMask;
-      vMax_fx = FloatToFixed(vMax->attrib[FRAG_ATTRIB_WPOS][0] + 0.5F) & snapMask;
-   }
-
-   /* vertex/edge relationship */
-   eMaj.v0 = vMin;   eMaj.v1 = vMax;   /*TODO: .v1's not needed */
-   eTop.v0 = vMid;   eTop.v1 = vMax;
-   eBot.v0 = vMin;   eBot.v1 = vMid;
-
-   /* compute deltas for each edge:  vertex[upper] - vertex[lower] */
-   eMaj.dx = FixedToFloat(vMax_fx - vMin_fx);
-   eMaj.dy = FixedToFloat(vMax_fy - vMin_fy);
-   eTop.dx = FixedToFloat(vMax_fx - vMid_fx);
-   eTop.dy = FixedToFloat(vMax_fy - vMid_fy);
-   eBot.dx = FixedToFloat(vMid_fx - vMin_fx);
-   eBot.dy = FixedToFloat(vMid_fy - vMin_fy);
-
-   /* compute area, oneOverArea and perform backface culling */
-   {
-      const GLfloat area = eMaj.dx * eBot.dy - eBot.dx * eMaj.dy;
-
-      if (IS_INF_OR_NAN(area) || area == 0.0F)
-         return;
-
-      if (area * bf * swrast->_BackfaceCullSign < 0.0)
-         return;
-
-      oneOverArea = 1.0F / area;
-
-      /* 0 = front, 1 = back */
-      span.facing = oneOverArea * bf > 0.0F;
-   }
-
-   /* Edge setup.  For a triangle strip these could be reused... */
-   {
-      eMaj.fsy = FixedCeil(vMin_fy);
-      eMaj.lines = FixedToInt(FixedCeil(vMax_fy - eMaj.fsy));
-      if (eMaj.lines > 0) {
-         eMaj.dxdy = eMaj.dx / eMaj.dy;
-         eMaj.fdxdy = SignedFloatToFixed(eMaj.dxdy);
-         eMaj.adjy = (GLfloat) (eMaj.fsy - vMin_fy);  /* SCALED! */
-         eMaj.fx0 = vMin_fx;
-         eMaj.fsx = eMaj.fx0 + (GLfixed) (eMaj.adjy * eMaj.dxdy);
-      }
-      else {
-         return;  /*CULLED*/
-      }
-
-      eTop.fsy = FixedCeil(vMid_fy);
-      eTop.lines = FixedToInt(FixedCeil(vMax_fy - eTop.fsy));
-      if (eTop.lines > 0) {
-         eTop.dxdy = eTop.dx / eTop.dy;
-         eTop.fdxdy = SignedFloatToFixed(eTop.dxdy);
-         eTop.adjy = (GLfloat) (eTop.fsy - vMid_fy); /* SCALED! */
-         eTop.fx0 = vMid_fx;
-         eTop.fsx = eTop.fx0 + (GLfixed) (eTop.adjy * eTop.dxdy);
-      }
-
-      eBot.fsy = FixedCeil(vMin_fy);
-      eBot.lines = FixedToInt(FixedCeil(vMid_fy - eBot.fsy));
-      if (eBot.lines > 0) {
-         eBot.dxdy = eBot.dx / eBot.dy;
-         eBot.fdxdy = SignedFloatToFixed(eBot.dxdy);
-         eBot.adjy = (GLfloat) (eBot.fsy - vMin_fy);  /* SCALED! */
-         eBot.fx0 = vMin_fx;
-         eBot.fsx = eBot.fx0 + (GLfixed) (eBot.adjy * eBot.dxdy);
-      }
-   }
-
-   /*
-    * Conceptually, we view a triangle as two subtriangles
-    * separated by a perfectly horizontal line.  The edge that is
-    * intersected by this line is one with maximal absolute dy; we
-    * call it a ``major'' edge.  The other two edges are the
-    * ``top'' edge (for the upper subtriangle) and the ``bottom''
-    * edge (for the lower subtriangle).  If either of these two
-    * edges is horizontal or very close to horizontal, the
-    * corresponding subtriangle might cover zero sample points;
-    * we take care to handle such cases, for performance as well
-    * as correctness.
-    *
-    * By stepping rasterization parameters along the major edge,
-    * we can avoid recomputing them at the discontinuity where
-    * the top and bottom edges meet.  However, this forces us to
-    * be able to scan both left-to-right and right-to-left.
-    * Also, we must determine whether the major edge is at the
-    * left or right side of the triangle.  We do this by
-    * computing the magnitude of the cross-product of the major
-    * and top edges.  Since this magnitude depends on the sine of
-    * the angle between the two edges, its sign tells us whether
-    * we turn to the left or to the right when travelling along
-    * the major edge to the top edge, and from this we infer
-    * whether the major edge is on the left or the right.
-    *
-    * Serendipitously, this cross-product magnitude is also a
-    * value we need to compute the iteration parameter
-    * derivatives for the triangle, and it can be used to perform
-    * backface culling because its sign tells us whether the
-    * triangle is clockwise or counterclockwise.  In this code we
-    * refer to it as ``area'' because it's also proportional to
-    * the pixel area of the triangle.
-    */
-
-   {
-      GLint scan_from_left_to_right;  /* true if scanning left-to-right */
-
-      /*
-       * Execute user-supplied setup code
-       */
-#ifdef SETUP_CODE
-      SETUP_CODE
-#endif
-
-      scan_from_left_to_right = (oneOverArea < 0.0F);
-
-
-      /* compute d?/dx and d?/dy derivatives */
-#ifdef INTERP_Z
-      span.interpMask |= SPAN_Z;
-      {
-         GLfloat eMaj_dz = vMax->attrib[FRAG_ATTRIB_WPOS][2] - vMin->attrib[FRAG_ATTRIB_WPOS][2];
-         GLfloat eBot_dz = vMid->attrib[FRAG_ATTRIB_WPOS][2] - vMin->attrib[FRAG_ATTRIB_WPOS][2];
-         span.attrStepX[FRAG_ATTRIB_WPOS][2] = oneOverArea * (eMaj_dz * eBot.dy - eMaj.dy * eBot_dz);
-         if (span.attrStepX[FRAG_ATTRIB_WPOS][2] > maxDepth ||
-             span.attrStepX[FRAG_ATTRIB_WPOS][2] < -maxDepth) {
-            /* probably a sliver triangle */
-            span.attrStepX[FRAG_ATTRIB_WPOS][2] = 0.0;
-            span.attrStepY[FRAG_ATTRIB_WPOS][2] = 0.0;
-         }
-         else {
-            span.attrStepY[FRAG_ATTRIB_WPOS][2] = oneOverArea * (eMaj.dx * eBot_dz - eMaj_dz * eBot.dx);
-         }
-         if (depthBits <= 16)
-            span.zStep = SignedFloatToFixed(span.attrStepX[FRAG_ATTRIB_WPOS][2]);
-         else
-            span.zStep = (GLint) span.attrStepX[FRAG_ATTRIB_WPOS][2];
-      }
-#endif
-#ifdef INTERP_RGB
-      span.interpMask |= SPAN_RGBA;
-      if (ctx->Light.ShadeModel == GL_SMOOTH) {
-         GLfloat eMaj_dr = (GLfloat) (vMax->color[RCOMP] - vMin->color[RCOMP]);
-         GLfloat eBot_dr = (GLfloat) (vMid->color[RCOMP] - vMin->color[RCOMP]);
-         GLfloat eMaj_dg = (GLfloat) (vMax->color[GCOMP] - vMin->color[GCOMP]);
-         GLfloat eBot_dg = (GLfloat) (vMid->color[GCOMP] - vMin->color[GCOMP]);
-         GLfloat eMaj_db = (GLfloat) (vMax->color[BCOMP] - vMin->color[BCOMP]);
-         GLfloat eBot_db = (GLfloat) (vMid->color[BCOMP] - vMin->color[BCOMP]);
-#  ifdef INTERP_ALPHA
-         GLfloat eMaj_da = (GLfloat) (vMax->color[ACOMP] - vMin->color[ACOMP]);
-         GLfloat eBot_da = (GLfloat) (vMid->color[ACOMP] - vMin->color[ACOMP]);
-#  endif
-         span.attrStepX[FRAG_ATTRIB_COL0][0] = oneOverArea * (eMaj_dr * eBot.dy - eMaj.dy * eBot_dr);
-         span.attrStepY[FRAG_ATTRIB_COL0][0] = oneOverArea * (eMaj.dx * eBot_dr - eMaj_dr * eBot.dx);
-         span.attrStepX[FRAG_ATTRIB_COL0][1] = oneOverArea * (eMaj_dg * eBot.dy - eMaj.dy * eBot_dg);
-         span.attrStepY[FRAG_ATTRIB_COL0][1] = oneOverArea * (eMaj.dx * eBot_dg - eMaj_dg * eBot.dx);
-         span.attrStepX[FRAG_ATTRIB_COL0][2] = oneOverArea * (eMaj_db * eBot.dy - eMaj.dy * eBot_db);
-         span.attrStepY[FRAG_ATTRIB_COL0][2] = oneOverArea * (eMaj.dx * eBot_db - eMaj_db * eBot.dx);
-         span.redStep   = SignedFloatToFixed(span.attrStepX[FRAG_ATTRIB_COL0][0]);
-         span.greenStep = SignedFloatToFixed(span.attrStepX[FRAG_ATTRIB_COL0][1]);
-         span.blueStep  = SignedFloatToFixed(span.attrStepX[FRAG_ATTRIB_COL0][2]);
-#  ifdef INTERP_ALPHA
-         span.attrStepX[FRAG_ATTRIB_COL0][3] = oneOverArea * (eMaj_da * eBot.dy - eMaj.dy * eBot_da);
-         span.attrStepY[FRAG_ATTRIB_COL0][3] = oneOverArea * (eMaj.dx * eBot_da - eMaj_da * eBot.dx);
-         span.alphaStep = SignedFloatToFixed(span.attrStepX[FRAG_ATTRIB_COL0][3]);
-#  endif /* INTERP_ALPHA */
-      }
-      else {
-         ASSERT(ctx->Light.ShadeModel == GL_FLAT);
-         span.interpMask |= SPAN_FLAT;
-         span.attrStepX[FRAG_ATTRIB_COL0][0] = span.attrStepY[FRAG_ATTRIB_COL0][0] = 0.0F;
-         span.attrStepX[FRAG_ATTRIB_COL0][1] = span.attrStepY[FRAG_ATTRIB_COL0][1] = 0.0F;
-         span.attrStepX[FRAG_ATTRIB_COL0][2] = span.attrStepY[FRAG_ATTRIB_COL0][2] = 0.0F;
-	 span.redStep   = 0;
-	 span.greenStep = 0;
-	 span.blueStep  = 0;
-#  ifdef INTERP_ALPHA
-         span.attrStepX[FRAG_ATTRIB_COL0][3] = span.attrStepY[FRAG_ATTRIB_COL0][3] = 0.0F;
-	 span.alphaStep = 0;
-#  endif
-      }
-#endif /* INTERP_RGB */
-#ifdef INTERP_INT_TEX
-      {
-         GLfloat eMaj_ds = (vMax->attrib[FRAG_ATTRIB_TEX0][0] - vMin->attrib[FRAG_ATTRIB_TEX0][0]) * S_SCALE;
-         GLfloat eBot_ds = (vMid->attrib[FRAG_ATTRIB_TEX0][0] - vMin->attrib[FRAG_ATTRIB_TEX0][0]) * S_SCALE;
-         GLfloat eMaj_dt = (vMax->attrib[FRAG_ATTRIB_TEX0][1] - vMin->attrib[FRAG_ATTRIB_TEX0][1]) * T_SCALE;
-         GLfloat eBot_dt = (vMid->attrib[FRAG_ATTRIB_TEX0][1] - vMin->attrib[FRAG_ATTRIB_TEX0][1]) * T_SCALE;
-         span.attrStepX[FRAG_ATTRIB_TEX0][0] = oneOverArea * (eMaj_ds * eBot.dy - eMaj.dy * eBot_ds);
-         span.attrStepY[FRAG_ATTRIB_TEX0][0] = oneOverArea * (eMaj.dx * eBot_ds - eMaj_ds * eBot.dx);
-         span.attrStepX[FRAG_ATTRIB_TEX0][1] = oneOverArea * (eMaj_dt * eBot.dy - eMaj.dy * eBot_dt);
-         span.attrStepY[FRAG_ATTRIB_TEX0][1] = oneOverArea * (eMaj.dx * eBot_dt - eMaj_dt * eBot.dx);
-         span.intTexStep[0] = SignedFloatToFixed(span.attrStepX[FRAG_ATTRIB_TEX0][0]);
-         span.intTexStep[1] = SignedFloatToFixed(span.attrStepX[FRAG_ATTRIB_TEX0][1]);
-      }
-#endif
-#ifdef INTERP_ATTRIBS
-      {
-         /* attrib[FRAG_ATTRIB_WPOS][3] is 1/W */
-         const GLfloat wMax = vMax->attrib[FRAG_ATTRIB_WPOS][3];
-         const GLfloat wMin = vMin->attrib[FRAG_ATTRIB_WPOS][3];
-         const GLfloat wMid = vMid->attrib[FRAG_ATTRIB_WPOS][3];
-         {
-            const GLfloat eMaj_dw = wMax - wMin;
-            const GLfloat eBot_dw = wMid - wMin;
-            span.attrStepX[FRAG_ATTRIB_WPOS][3] = oneOverArea * (eMaj_dw * eBot.dy - eMaj.dy * eBot_dw);
-            span.attrStepY[FRAG_ATTRIB_WPOS][3] = oneOverArea * (eMaj.dx * eBot_dw - eMaj_dw * eBot.dx);
-         }
-         ATTRIB_LOOP_BEGIN
-            if (swrast->_InterpMode[attr] == GL_FLAT) {
-               ASSIGN_4V(span.attrStepX[attr], 0.0, 0.0, 0.0, 0.0);
-               ASSIGN_4V(span.attrStepY[attr], 0.0, 0.0, 0.0, 0.0);
-            }
-            else {
-               GLuint c;
-               for (c = 0; c < 4; c++) {
-                  GLfloat eMaj_da = vMax->attrib[attr][c] * wMax - vMin->attrib[attr][c] * wMin;
-                  GLfloat eBot_da = vMid->attrib[attr][c] * wMid - vMin->attrib[attr][c] * wMin;
-                  span.attrStepX[attr][c] = oneOverArea * (eMaj_da * eBot.dy - eMaj.dy * eBot_da);
-                  span.attrStepY[attr][c] = oneOverArea * (eMaj.dx * eBot_da - eMaj_da * eBot.dx);
-               }
-            }
-         ATTRIB_LOOP_END
-      }
-#endif
-
-      /*
-       * We always sample at pixel centers.  However, we avoid
-       * explicit half-pixel offsets in this code by incorporating
-       * the proper offset in each of x and y during the
-       * transformation to window coordinates.
-       *
-       * We also apply the usual rasterization rules to prevent
-       * cracks and overlaps.  A pixel is considered inside a
-       * subtriangle if it meets all of four conditions: it is on or
-       * to the right of the left edge, strictly to the left of the
-       * right edge, on or below the top edge, and strictly above
-       * the bottom edge.  (Some edges may be degenerate.)
-       *
-       * The following discussion assumes left-to-right scanning
-       * (that is, the major edge is on the left); the right-to-left
-       * case is a straightforward variation.
-       *
-       * We start by finding the half-integral y coordinate that is
-       * at or below the top of the triangle.  This gives us the
-       * first scan line that could possibly contain pixels that are
-       * inside the triangle.
-       *
-       * Next we creep down the major edge until we reach that y,
-       * and compute the corresponding x coordinate on the edge.
-       * Then we find the half-integral x that lies on or just
-       * inside the edge.  This is the first pixel that might lie in
-       * the interior of the triangle.  (We won't know for sure
-       * until we check the other edges.)
-       *
-       * As we rasterize the triangle, we'll step down the major
-       * edge.  For each step in y, we'll move an integer number
-       * of steps in x.  There are two possible x step sizes, which
-       * we'll call the ``inner'' step (guaranteed to land on the
-       * edge or inside it) and the ``outer'' step (guaranteed to
-       * land on the edge or outside it).  The inner and outer steps
-       * differ by one.  During rasterization we maintain an error
-       * term that indicates our distance from the true edge, and
-       * select either the inner step or the outer step, whichever
-       * gets us to the first pixel that falls inside the triangle.
-       *
-       * All parameters (z, red, etc.) as well as the buffer
-       * addresses for color and z have inner and outer step values,
-       * so that we can increment them appropriately.  This method
-       * eliminates the need to adjust parameters by creeping a
-       * sub-pixel amount into the triangle at each scanline.
-       */
-
-      {
-         GLint subTriangle;
-         GLfixed fxLeftEdge = 0, fxRightEdge = 0;
-         GLfixed fdxLeftEdge = 0, fdxRightEdge = 0;
-         GLfixed fError = 0, fdError = 0;
-#ifdef PIXEL_ADDRESS
-         PIXEL_TYPE *pRow = NULL;
-         GLint dPRowOuter = 0, dPRowInner;  /* offset in bytes */
-#endif
-#ifdef INTERP_Z
-#  ifdef DEPTH_TYPE
-         struct gl_renderbuffer *zrb
-            = ctx->DrawBuffer->Attachment[BUFFER_DEPTH].Renderbuffer;
-         DEPTH_TYPE *zRow = NULL;
-         GLint dZRowOuter = 0, dZRowInner;  /* offset in bytes */
-#  endif
-         GLuint zLeft = 0;
-         GLfixed fdzOuter = 0, fdzInner;
-#endif
-#ifdef INTERP_RGB
-         GLint rLeft = 0, fdrOuter = 0, fdrInner;
-         GLint gLeft = 0, fdgOuter = 0, fdgInner;
-         GLint bLeft = 0, fdbOuter = 0, fdbInner;
-#endif
-#ifdef INTERP_ALPHA
-         GLint aLeft = 0, fdaOuter = 0, fdaInner;
-#endif
-#ifdef INTERP_INT_TEX
-         GLfixed sLeft=0, dsOuter=0, dsInner;
-         GLfixed tLeft=0, dtOuter=0, dtInner;
-#endif
-#ifdef INTERP_ATTRIBS
-         GLfloat wLeft = 0, dwOuter = 0, dwInner;
-         GLfloat attrLeft[FRAG_ATTRIB_MAX][4];
-         GLfloat daOuter[FRAG_ATTRIB_MAX][4], daInner[FRAG_ATTRIB_MAX][4];
-#endif
-
-         for (subTriangle=0; subTriangle<=1; subTriangle++) {
-            EdgeT *eLeft, *eRight;
-            int setupLeft, setupRight;
-            int lines;
-
-            if (subTriangle==0) {
-               /* bottom half */
-               if (scan_from_left_to_right) {
-                  eLeft = &eMaj;
-                  eRight = &eBot;
-                  lines = eRight->lines;
-                  setupLeft = 1;
-                  setupRight = 1;
-               }
-               else {
-                  eLeft = &eBot;
-                  eRight = &eMaj;
-                  lines = eLeft->lines;
-                  setupLeft = 1;
-                  setupRight = 1;
-               }
-            }
-            else {
-               /* top half */
-               if (scan_from_left_to_right) {
-                  eLeft = &eMaj;
-                  eRight = &eTop;
-                  lines = eRight->lines;
-                  setupLeft = 0;
-                  setupRight = 1;
-               }
-               else {
-                  eLeft = &eTop;
-                  eRight = &eMaj;
-                  lines = eLeft->lines;
-                  setupLeft = 1;
-                  setupRight = 0;
-               }
-               if (lines == 0)
-                  return;
-            }
-
-            if (setupLeft && eLeft->lines > 0) {
-               const SWvertex *vLower = eLeft->v0;
-               const GLfixed fsy = eLeft->fsy;
-               const GLfixed fsx = eLeft->fsx;  /* no fractional part */
-               const GLfixed fx = FixedCeil(fsx);  /* no fractional part */
-               const GLfixed adjx = (GLfixed) (fx - eLeft->fx0); /* SCALED! */
-               const GLfixed adjy = (GLfixed) eLeft->adjy;      /* SCALED! */
-               GLint idxOuter;
-               GLfloat dxOuter;
-               GLfixed fdxOuter;
-
-               fError = fx - fsx - FIXED_ONE;
-               fxLeftEdge = fsx - FIXED_EPSILON;
-               fdxLeftEdge = eLeft->fdxdy;
-               fdxOuter = FixedFloor(fdxLeftEdge - FIXED_EPSILON);
-               fdError = fdxOuter - fdxLeftEdge + FIXED_ONE;
-               idxOuter = FixedToInt(fdxOuter);
-               dxOuter = (GLfloat) idxOuter;
-               span.y = FixedToInt(fsy);
-
-               /* silence warnings on some compilers */
-               (void) dxOuter;
-               (void) adjx;
-               (void) adjy;
-               (void) vLower;
-
-#ifdef PIXEL_ADDRESS
-               {
-                  pRow = (PIXEL_TYPE *) PIXEL_ADDRESS(FixedToInt(fxLeftEdge), span.y);
-                  dPRowOuter = -((int)BYTES_PER_ROW) + idxOuter * sizeof(PIXEL_TYPE);
-                  /* negative because Y=0 at bottom and increases upward */
-               }
-#endif
-               /*
-                * Now we need the set of parameter (z, color, etc.) values at
-                * the point (fx, fsy).  This gives us properly-sampled parameter
-                * values that we can step from pixel to pixel.  Furthermore,
-                * although we might have intermediate results that overflow
-                * the normal parameter range when we step temporarily outside
-                * the triangle, we shouldn't overflow or underflow for any
-                * pixel that's actually inside the triangle.
-                */
-
-#ifdef INTERP_Z
-               {
-                  GLfloat z0 = vLower->attrib[FRAG_ATTRIB_WPOS][2];
-                  if (depthBits <= 16) {
-                     /* interpolate fixed-pt values */
-                     GLfloat tmp = (z0 * FIXED_SCALE
-                                    + span.attrStepX[FRAG_ATTRIB_WPOS][2] * adjx
-                                    + span.attrStepY[FRAG_ATTRIB_WPOS][2] * adjy) + FIXED_HALF;
-                     if (tmp < MAX_GLUINT / 2)
-                        zLeft = (GLfixed) tmp;
-                     else
-                        zLeft = MAX_GLUINT / 2;
-                     fdzOuter = SignedFloatToFixed(span.attrStepY[FRAG_ATTRIB_WPOS][2] +
-                                                   dxOuter * span.attrStepX[FRAG_ATTRIB_WPOS][2]);
-                  }
-                  else {
-                     /* interpolate depth values w/out scaling */
-                     zLeft = (GLuint) (z0 + span.attrStepX[FRAG_ATTRIB_WPOS][2] * FixedToFloat(adjx)
-                                          + span.attrStepY[FRAG_ATTRIB_WPOS][2] * FixedToFloat(adjy));
-                     fdzOuter = (GLint) (span.attrStepY[FRAG_ATTRIB_WPOS][2] +
-                                         dxOuter * span.attrStepX[FRAG_ATTRIB_WPOS][2]);
-                  }
-#  ifdef DEPTH_TYPE
-                  zRow = (DEPTH_TYPE *)
-                    zrb->GetPointer(ctx, zrb, FixedToInt(fxLeftEdge), span.y);
-                  dZRowOuter = (ctx->DrawBuffer->Width + idxOuter) * sizeof(DEPTH_TYPE);
-#  endif
-               }
-#endif
-#ifdef INTERP_RGB
-               if (ctx->Light.ShadeModel == GL_SMOOTH) {
-                  rLeft = (GLint)(ChanToFixed(vLower->color[RCOMP])
-                                  + span.attrStepX[FRAG_ATTRIB_COL0][0] * adjx
-                                  + span.attrStepY[FRAG_ATTRIB_COL0][0] * adjy) + FIXED_HALF;
-                  gLeft = (GLint)(ChanToFixed(vLower->color[GCOMP])
-                                  + span.attrStepX[FRAG_ATTRIB_COL0][1] * adjx
-                                  + span.attrStepY[FRAG_ATTRIB_COL0][1] * adjy) + FIXED_HALF;
-                  bLeft = (GLint)(ChanToFixed(vLower->color[BCOMP])
-                                  + span.attrStepX[FRAG_ATTRIB_COL0][2] * adjx
-                                  + span.attrStepY[FRAG_ATTRIB_COL0][2] * adjy) + FIXED_HALF;
-                  fdrOuter = SignedFloatToFixed(span.attrStepY[FRAG_ATTRIB_COL0][0]
-                                                + dxOuter * span.attrStepX[FRAG_ATTRIB_COL0][0]);
-                  fdgOuter = SignedFloatToFixed(span.attrStepY[FRAG_ATTRIB_COL0][1]
-                                                + dxOuter * span.attrStepX[FRAG_ATTRIB_COL0][1]);
-                  fdbOuter = SignedFloatToFixed(span.attrStepY[FRAG_ATTRIB_COL0][2]
-                                                + dxOuter * span.attrStepX[FRAG_ATTRIB_COL0][2]);
-#  ifdef INTERP_ALPHA
-                  aLeft = (GLint)(ChanToFixed(vLower->color[ACOMP])
-                                  + span.attrStepX[FRAG_ATTRIB_COL0][3] * adjx
-                                  + span.attrStepY[FRAG_ATTRIB_COL0][3] * adjy) + FIXED_HALF;
-                  fdaOuter = SignedFloatToFixed(span.attrStepY[FRAG_ATTRIB_COL0][3]
-                                                + dxOuter * span.attrStepX[FRAG_ATTRIB_COL0][3]);
-#  endif
-               }
-               else {
-                  ASSERT(ctx->Light.ShadeModel == GL_FLAT);
-                  rLeft = ChanToFixed(v2->color[RCOMP]);
-                  gLeft = ChanToFixed(v2->color[GCOMP]);
-                  bLeft = ChanToFixed(v2->color[BCOMP]);
-                  fdrOuter = fdgOuter = fdbOuter = 0;
-#  ifdef INTERP_ALPHA
-                  aLeft = ChanToFixed(v2->color[ACOMP]);
-                  fdaOuter = 0;
-#  endif
-               }
-#endif /* INTERP_RGB */
-
-
-#ifdef INTERP_INT_TEX
-               {
-                  GLfloat s0, t0;
-                  s0 = vLower->attrib[FRAG_ATTRIB_TEX0][0] * S_SCALE;
-                  sLeft = (GLfixed)(s0 * FIXED_SCALE + span.attrStepX[FRAG_ATTRIB_TEX0][0] * adjx
-                                 + span.attrStepY[FRAG_ATTRIB_TEX0][0] * adjy) + FIXED_HALF;
-                  dsOuter = SignedFloatToFixed(span.attrStepY[FRAG_ATTRIB_TEX0][0]
-                                               + dxOuter * span.attrStepX[FRAG_ATTRIB_TEX0][0]);
-
-                  t0 = vLower->attrib[FRAG_ATTRIB_TEX0][1] * T_SCALE;
-                  tLeft = (GLfixed)(t0 * FIXED_SCALE + span.attrStepX[FRAG_ATTRIB_TEX0][1] * adjx
-                                 + span.attrStepY[FRAG_ATTRIB_TEX0][1] * adjy) + FIXED_HALF;
-                  dtOuter = SignedFloatToFixed(span.attrStepY[FRAG_ATTRIB_TEX0][1]
-                                               + dxOuter * span.attrStepX[FRAG_ATTRIB_TEX0][1]);
-               }
-#endif
-#ifdef INTERP_ATTRIBS
-               {
-                  const GLuint attr = FRAG_ATTRIB_WPOS;
-                  wLeft = vLower->attrib[FRAG_ATTRIB_WPOS][3]
-                        + (span.attrStepX[attr][3] * adjx
-                           + span.attrStepY[attr][3] * adjy) * (1.0F/FIXED_SCALE);
-                  dwOuter = span.attrStepY[attr][3] + dxOuter * span.attrStepX[attr][3];
-               }
-               ATTRIB_LOOP_BEGIN
-                  const GLfloat invW = vLower->attrib[FRAG_ATTRIB_WPOS][3];
-                  if (swrast->_InterpMode[attr] == GL_FLAT) {
-                     GLuint c;
-                     for (c = 0; c < 4; c++) {
-                        attrLeft[attr][c] = v2->attrib[attr][c] * invW;
-                        daOuter[attr][c] = 0.0;
-                     }
-                  }
-                  else {
-                     GLuint c;
-                     for (c = 0; c < 4; c++) {
-                        const GLfloat a = vLower->attrib[attr][c] * invW;
-                        attrLeft[attr][c] = a + (  span.attrStepX[attr][c] * adjx
-                                                 + span.attrStepY[attr][c] * adjy) * (1.0F/FIXED_SCALE);
-                        daOuter[attr][c] = span.attrStepY[attr][c] + dxOuter * span.attrStepX[attr][c];
-                     }
-                  }
-               ATTRIB_LOOP_END
-#endif
-            } /*if setupLeft*/
-
-
-            if (setupRight && eRight->lines>0) {
-               fxRightEdge = eRight->fsx - FIXED_EPSILON;
-               fdxRightEdge = eRight->fdxdy;
-            }
-
-            if (lines==0) {
-               continue;
-            }
-
-
-            /* Rasterize setup */
-#ifdef PIXEL_ADDRESS
-            dPRowInner = dPRowOuter + sizeof(PIXEL_TYPE);
-#endif
-#ifdef INTERP_Z
-#  ifdef DEPTH_TYPE
-            dZRowInner = dZRowOuter + sizeof(DEPTH_TYPE);
-#  endif
-            fdzInner = fdzOuter + span.zStep;
-#endif
-#ifdef INTERP_RGB
-            fdrInner = fdrOuter + span.redStep;
-            fdgInner = fdgOuter + span.greenStep;
-            fdbInner = fdbOuter + span.blueStep;
-#endif
-#ifdef INTERP_ALPHA
-            fdaInner = fdaOuter + span.alphaStep;
-#endif
-#ifdef INTERP_INT_TEX
-            dsInner = dsOuter + span.intTexStep[0];
-            dtInner = dtOuter + span.intTexStep[1];
-#endif
-#ifdef INTERP_ATTRIBS
-            dwInner = dwOuter + span.attrStepX[FRAG_ATTRIB_WPOS][3];
-            ATTRIB_LOOP_BEGIN
-               GLuint c;
-               for (c = 0; c < 4; c++) {
-                  daInner[attr][c] = daOuter[attr][c] + span.attrStepX[attr][c];
-               }
-            ATTRIB_LOOP_END
-#endif
-
-            while (lines > 0) {
-               /* initialize the span interpolants to the leftmost value */
-               /* ff = fixed-pt fragment */
-               const GLint right = FixedToInt(fxRightEdge);
-               span.x = FixedToInt(fxLeftEdge);
-               if (right <= span.x)
-                  span.end = 0;
-               else
-                  span.end = right - span.x;
-
-#ifdef INTERP_Z
-               span.z = zLeft;
-#endif
-#ifdef INTERP_RGB
-               span.red = rLeft;
-               span.green = gLeft;
-               span.blue = bLeft;
-#endif
-#ifdef INTERP_ALPHA
-               span.alpha = aLeft;
-#endif
-#ifdef INTERP_INT_TEX
-               span.intTex[0] = sLeft;
-               span.intTex[1] = tLeft;
-#endif
-
-#ifdef INTERP_ATTRIBS
-               span.attrStart[FRAG_ATTRIB_WPOS][3] = wLeft;
-               ATTRIB_LOOP_BEGIN
-                  GLuint c;
-                  for (c = 0; c < 4; c++) {
-                     span.attrStart[attr][c] = attrLeft[attr][c];
-                  }
-               ATTRIB_LOOP_END
-#endif
-
-               /* This is where we actually generate fragments */
-               /* XXX the test for span.y > 0 _shouldn't_ be needed but
-                * it fixes a problem on 64-bit Opterons (bug 4842).
-                */
-               if (span.end > 0 && span.y >= 0) {
-                  const GLint len = span.end - 1;
-                  (void) len;
-#ifdef INTERP_RGB
-                  CLAMP_INTERPOLANT(red, redStep, len);
-                  CLAMP_INTERPOLANT(green, greenStep, len);
-                  CLAMP_INTERPOLANT(blue, blueStep, len);
-#endif
-#ifdef INTERP_ALPHA
-                  CLAMP_INTERPOLANT(alpha, alphaStep, len);
-#endif
-                  {
-                     RENDER_SPAN( span );
-                  }
-               }
-
-               /*
-                * Advance to the next scan line.  Compute the
-                * new edge coordinates, and adjust the
-                * pixel-center x coordinate so that it stays
-                * on or inside the major edge.
-                */
-               span.y++;
-               lines--;
-
-               fxLeftEdge += fdxLeftEdge;
-               fxRightEdge += fdxRightEdge;
-
-               fError += fdError;
-               if (fError >= 0) {
-                  fError -= FIXED_ONE;
-
-#ifdef PIXEL_ADDRESS
-                  pRow = (PIXEL_TYPE *) ((GLubyte *) pRow + dPRowOuter);
-#endif
-#ifdef INTERP_Z
-#  ifdef DEPTH_TYPE
-                  zRow = (DEPTH_TYPE *) ((GLubyte *) zRow + dZRowOuter);
-#  endif
-                  zLeft += fdzOuter;
-#endif
-#ifdef INTERP_RGB
-                  rLeft += fdrOuter;
-                  gLeft += fdgOuter;
-                  bLeft += fdbOuter;
-#endif
-#ifdef INTERP_ALPHA
-                  aLeft += fdaOuter;
-#endif
-#ifdef INTERP_INT_TEX
-                  sLeft += dsOuter;
-                  tLeft += dtOuter;
-#endif
-#ifdef INTERP_ATTRIBS
-                  wLeft += dwOuter;
-                  ATTRIB_LOOP_BEGIN
-                     GLuint c;
-                     for (c = 0; c < 4; c++) {
-                        attrLeft[attr][c] += daOuter[attr][c];
-                     }
-                  ATTRIB_LOOP_END
-#endif
-               }
-               else {
-#ifdef PIXEL_ADDRESS
-                  pRow = (PIXEL_TYPE *) ((GLubyte *) pRow + dPRowInner);
-#endif
-#ifdef INTERP_Z
-#  ifdef DEPTH_TYPE
-                  zRow = (DEPTH_TYPE *) ((GLubyte *) zRow + dZRowInner);
-#  endif
-                  zLeft += fdzInner;
-#endif
-#ifdef INTERP_RGB
-                  rLeft += fdrInner;
-                  gLeft += fdgInner;
-                  bLeft += fdbInner;
-#endif
-#ifdef INTERP_ALPHA
-                  aLeft += fdaInner;
-#endif
-#ifdef INTERP_INT_TEX
-                  sLeft += dsInner;
-                  tLeft += dtInner;
-#endif
-#ifdef INTERP_ATTRIBS
-                  wLeft += dwInner;
-                  ATTRIB_LOOP_BEGIN
-                     GLuint c;
-                     for (c = 0; c < 4; c++) {
-                        attrLeft[attr][c] += daInner[attr][c];
-                     }
-                  ATTRIB_LOOP_END
-#endif
-               }
-            } /*while lines>0*/
-
-         } /* for subTriangle */
-
-      }
-   }
-}
-
-#undef SETUP_CODE
-#undef RENDER_SPAN
-
-#undef PIXEL_TYPE
-#undef BYTES_PER_ROW
-#undef PIXEL_ADDRESS
-#undef DEPTH_TYPE
-
-#undef INTERP_Z
-#undef INTERP_RGB
-#undef INTERP_ALPHA
-#undef INTERP_INT_TEX
-#undef INTERP_ATTRIBS
-
-#undef S_SCALE
-#undef T_SCALE
-
-#undef FixedToDepth
-
-#undef NAME
+/*

+ * Mesa 3-D graphics library

+ * Version:  7.0

+ *

+ * 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.

+ */

+

+/*

+ * Triangle Rasterizer Template

+ *

+ * This file is #include'd to generate custom triangle rasterizers.

+ *

+ * The following macros may be defined to indicate what auxillary information

+ * must be interpolated across the triangle:

+ *    INTERP_Z        - if defined, interpolate integer Z values

+ *    INTERP_RGB      - if defined, interpolate integer RGB values

+ *    INTERP_ALPHA    - if defined, interpolate integer Alpha values

+ *    INTERP_INT_TEX  - if defined, interpolate integer ST texcoords

+ *                         (fast, simple 2-D texture mapping, without

+ *                         perspective correction)

+ *    INTERP_ATTRIBS  - if defined, interpolate arbitrary attribs (texcoords,

+ *                         varying vars, etc)  This also causes W to be

+ *                         computed for perspective correction).

+ *

+ * When one can directly address pixels in the color buffer the following

+ * macros can be defined and used to compute pixel addresses during

+ * rasterization (see pRow):

+ *    PIXEL_TYPE          - the datatype of a pixel (GLubyte, GLushort, GLuint)

+ *    BYTES_PER_ROW       - number of bytes per row in the color buffer

+ *    PIXEL_ADDRESS(X,Y)  - returns the address of pixel at (X,Y) where

+ *                          Y==0 at bottom of screen and increases upward.

+ *

+ * Similarly, for direct depth buffer access, this type is used for depth

+ * buffer addressing (see zRow):

+ *    DEPTH_TYPE          - either GLushort or GLuint

+ *

+ * Optionally, one may provide one-time setup code per triangle:

+ *    SETUP_CODE    - code which is to be executed once per triangle

+ *

+ * The following macro MUST be defined:

+ *    RENDER_SPAN(span) - code to write a span of pixels.

+ *

+ * This code was designed for the origin to be in the lower-left corner.

+ *

+ * Inspired by triangle rasterizer code written by Allen Akin.  Thanks Allen!

+ *

+ *

+ * Some notes on rasterization accuracy:

+ *

+ * This code uses fixed point arithmetic (the GLfixed type) to iterate

+ * over the triangle edges and interpolate ancillary data (such as Z,

+ * color, secondary color, etc).  The number of fractional bits in

+ * GLfixed and the value of SUB_PIXEL_BITS has a direct bearing on the

+ * accuracy of rasterization.

+ *

+ * If SUB_PIXEL_BITS=4 then we'll snap the vertices to the nearest

+ * 1/16 of a pixel.  If we're walking up a long, nearly vertical edge

+ * (dx=1/16, dy=1024) we'll need 4 + 10 = 14 fractional bits in

+ * GLfixed to walk the edge without error.  If the maximum viewport

+ * height is 4K pixels, then we'll need 4 + 12 = 16 fractional bits.

+ *

+ * Historically, Mesa has used 11 fractional bits in GLfixed, snaps

+ * vertices to 1/16 pixel and allowed a maximum viewport height of 2K

+ * pixels.  11 fractional bits is actually insufficient for accurately

+ * rasterizing some triangles.  More recently, the maximum viewport

+ * height was increased to 4K pixels.  Thus, Mesa should be using 16

+ * fractional bits in GLfixed.  Unfortunately, there may be some issues

+ * with setting FIXED_FRAC_BITS=16, such as multiplication overflow.

+ * This will have to be examined in some detail...

+ *

+ * For now, if you find rasterization errors, particularly with tall,

+ * sliver triangles, try increasing FIXED_FRAC_BITS and/or decreasing

+ * SUB_PIXEL_BITS.

+ */

+

+

+/*

+ * Some code we unfortunately need to prevent negative interpolated colors.

+ */

+#ifndef CLAMP_INTERPOLANT

+#define CLAMP_INTERPOLANT(CHANNEL, CHANNELSTEP, LEN)		\

+do {								\

+   GLfixed endVal = span.CHANNEL + (LEN) * span.CHANNELSTEP;	\

+   if (endVal < 0) {						\

+      span.CHANNEL -= endVal;					\

+   }								\

+   if (span.CHANNEL < 0) {					\

+      span.CHANNEL = 0;						\

+   }								\

+} while (0)

+#endif

+

+

+static void NAME(struct gl_context *ctx, const SWvertex *v0,

+                                 const SWvertex *v1,

+                                 const SWvertex *v2 )

+{

+   typedef struct {

+      const SWvertex *v0, *v1;   /* Y(v0) < Y(v1) */

+      GLfloat dx;	/* X(v1) - X(v0) */

+      GLfloat dy;	/* Y(v1) - Y(v0) */

+      GLfloat dxdy;	/* dx/dy */

+      GLfixed fdxdy;	/* dx/dy in fixed-point */

+      GLfloat adjy;	/* adjust from v[0]->fy to fsy, scaled */

+      GLfixed fsx;	/* first sample point x coord */

+      GLfixed fsy;

+      GLfixed fx0;	/* fixed pt X of lower endpoint */

+      GLint lines;	/* number of lines to be sampled on this edge */

+   } EdgeT;

+

+   const SWcontext *swrast = SWRAST_CONTEXT(ctx);

+#ifdef INTERP_Z

+   const GLint depthBits = ctx->DrawBuffer->Visual.depthBits;

+   const GLint fixedToDepthShift = depthBits <= 16 ? FIXED_SHIFT : 0;

+   const GLfloat maxDepth = ctx->DrawBuffer->_DepthMaxF;

+#define FixedToDepth(F)  ((F) >> fixedToDepthShift)

+#endif

+   EdgeT eMaj, eTop, eBot;

+   GLfloat oneOverArea;

+   const SWvertex *vMin, *vMid, *vMax;  /* Y(vMin)<=Y(vMid)<=Y(vMax) */

+   GLfloat bf = SWRAST_CONTEXT(ctx)->_BackfaceSign;

+   const GLint snapMask = ~((FIXED_ONE / (1 << SUB_PIXEL_BITS)) - 1); /* for x/y coord snapping */

+   GLfixed vMin_fx, vMin_fy, vMid_fx, vMid_fy, vMax_fx, vMax_fy;

+

+   SWspan span;

+

+   (void) swrast;

+

+   INIT_SPAN(span, GL_POLYGON);

+   span.y = 0; /* silence warnings */

+

+#ifdef INTERP_Z

+   (void) fixedToDepthShift;

+#endif

+

+   /*

+   printf("%s()\n", __FUNCTION__);

+   printf("  %g, %g, %g\n",

+          v0->attrib[FRAG_ATTRIB_WPOS][0],

+          v0->attrib[FRAG_ATTRIB_WPOS][1],

+          v0->attrib[FRAG_ATTRIB_WPOS][2]);

+   printf("  %g, %g, %g\n",

+          v1->attrib[FRAG_ATTRIB_WPOS][0],

+          v1->attrib[FRAG_ATTRIB_WPOS][1],

+          v1->attrib[FRAG_ATTRIB_WPOS][2]);

+   printf("  %g, %g, %g\n",

+          v2->attrib[FRAG_ATTRIB_WPOS][0],

+          v2->attrib[FRAG_ATTRIB_WPOS][1],

+          v2->attrib[FRAG_ATTRIB_WPOS][2]);

+   */

+

+   /* Compute fixed point x,y coords w/ half-pixel offsets and snapping.

+    * And find the order of the 3 vertices along the Y axis.

+    */

+   {

+      const GLfixed fy0 = FloatToFixed(v0->attrib[FRAG_ATTRIB_WPOS][1] - 0.5F) & snapMask;

+      const GLfixed fy1 = FloatToFixed(v1->attrib[FRAG_ATTRIB_WPOS][1] - 0.5F) & snapMask;

+      const GLfixed fy2 = FloatToFixed(v2->attrib[FRAG_ATTRIB_WPOS][1] - 0.5F) & snapMask;

+      if (fy0 <= fy1) {

+         if (fy1 <= fy2) {

+            /* y0 <= y1 <= y2 */

+            vMin = v0;   vMid = v1;   vMax = v2;

+            vMin_fy = fy0;  vMid_fy = fy1;  vMax_fy = fy2;

+         }

+         else if (fy2 <= fy0) {

+            /* y2 <= y0 <= y1 */

+            vMin = v2;   vMid = v0;   vMax = v1;

+            vMin_fy = fy2;  vMid_fy = fy0;  vMax_fy = fy1;

+         }

+         else {

+            /* y0 <= y2 <= y1 */

+            vMin = v0;   vMid = v2;   vMax = v1;

+            vMin_fy = fy0;  vMid_fy = fy2;  vMax_fy = fy1;

+            bf = -bf;

+         }

+      }

+      else {

+         if (fy0 <= fy2) {

+            /* y1 <= y0 <= y2 */

+            vMin = v1;   vMid = v0;   vMax = v2;

+            vMin_fy = fy1;  vMid_fy = fy0;  vMax_fy = fy2;

+            bf = -bf;

+         }

+         else if (fy2 <= fy1) {

+            /* y2 <= y1 <= y0 */

+            vMin = v2;   vMid = v1;   vMax = v0;

+            vMin_fy = fy2;  vMid_fy = fy1;  vMax_fy = fy0;

+            bf = -bf;

+         }

+         else {

+            /* y1 <= y2 <= y0 */

+            vMin = v1;   vMid = v2;   vMax = v0;

+            vMin_fy = fy1;  vMid_fy = fy2;  vMax_fy = fy0;

+         }

+      }

+

+      /* fixed point X coords */

+      vMin_fx = FloatToFixed(vMin->attrib[FRAG_ATTRIB_WPOS][0] + 0.5F) & snapMask;

+      vMid_fx = FloatToFixed(vMid->attrib[FRAG_ATTRIB_WPOS][0] + 0.5F) & snapMask;

+      vMax_fx = FloatToFixed(vMax->attrib[FRAG_ATTRIB_WPOS][0] + 0.5F) & snapMask;

+   }

+

+   /* vertex/edge relationship */

+   eMaj.v0 = vMin;   eMaj.v1 = vMax;   /*TODO: .v1's not needed */

+   eTop.v0 = vMid;   eTop.v1 = vMax;

+   eBot.v0 = vMin;   eBot.v1 = vMid;

+

+   /* compute deltas for each edge:  vertex[upper] - vertex[lower] */

+   eMaj.dx = FixedToFloat(vMax_fx - vMin_fx);

+   eMaj.dy = FixedToFloat(vMax_fy - vMin_fy);

+   eTop.dx = FixedToFloat(vMax_fx - vMid_fx);

+   eTop.dy = FixedToFloat(vMax_fy - vMid_fy);

+   eBot.dx = FixedToFloat(vMid_fx - vMin_fx);

+   eBot.dy = FixedToFloat(vMid_fy - vMin_fy);

+

+   /* compute area, oneOverArea and perform backface culling */

+   {

+      const GLfloat area = eMaj.dx * eBot.dy - eBot.dx * eMaj.dy;

+

+      if (IS_INF_OR_NAN(area) || area == 0.0F)

+         return;

+

+      if (area * bf * swrast->_BackfaceCullSign < 0.0)

+         return;

+

+      oneOverArea = 1.0F / area;

+

+      /* 0 = front, 1 = back */

+      span.facing = oneOverArea * bf > 0.0F;

+   }

+

+   /* Edge setup.  For a triangle strip these could be reused... */

+   {

+      eMaj.fsy = FixedCeil(vMin_fy);

+      eMaj.lines = FixedToInt(FixedCeil(vMax_fy - eMaj.fsy));

+      if (eMaj.lines > 0) {

+         eMaj.dxdy = eMaj.dx / eMaj.dy;

+         eMaj.fdxdy = SignedFloatToFixed(eMaj.dxdy);

+         eMaj.adjy = (GLfloat) (eMaj.fsy - vMin_fy);  /* SCALED! */

+         eMaj.fx0 = vMin_fx;

+         eMaj.fsx = eMaj.fx0 + (GLfixed) (eMaj.adjy * eMaj.dxdy);

+      }

+      else {

+         return;  /*CULLED*/

+      }

+

+      eTop.fsy = FixedCeil(vMid_fy);

+      eTop.lines = FixedToInt(FixedCeil(vMax_fy - eTop.fsy));

+      if (eTop.lines > 0) {

+         eTop.dxdy = eTop.dx / eTop.dy;

+         eTop.fdxdy = SignedFloatToFixed(eTop.dxdy);

+         eTop.adjy = (GLfloat) (eTop.fsy - vMid_fy); /* SCALED! */

+         eTop.fx0 = vMid_fx;

+         eTop.fsx = eTop.fx0 + (GLfixed) (eTop.adjy * eTop.dxdy);

+      }

+

+      eBot.fsy = FixedCeil(vMin_fy);

+      eBot.lines = FixedToInt(FixedCeil(vMid_fy - eBot.fsy));

+      if (eBot.lines > 0) {

+         eBot.dxdy = eBot.dx / eBot.dy;

+         eBot.fdxdy = SignedFloatToFixed(eBot.dxdy);

+         eBot.adjy = (GLfloat) (eBot.fsy - vMin_fy);  /* SCALED! */

+         eBot.fx0 = vMin_fx;

+         eBot.fsx = eBot.fx0 + (GLfixed) (eBot.adjy * eBot.dxdy);

+      }

+   }

+

+   /*

+    * Conceptually, we view a triangle as two subtriangles

+    * separated by a perfectly horizontal line.  The edge that is

+    * intersected by this line is one with maximal absolute dy; we

+    * call it a ``major'' edge.  The other two edges are the

+    * ``top'' edge (for the upper subtriangle) and the ``bottom''

+    * edge (for the lower subtriangle).  If either of these two

+    * edges is horizontal or very close to horizontal, the

+    * corresponding subtriangle might cover zero sample points;

+    * we take care to handle such cases, for performance as well

+    * as correctness.

+    *

+    * By stepping rasterization parameters along the major edge,

+    * we can avoid recomputing them at the discontinuity where

+    * the top and bottom edges meet.  However, this forces us to

+    * be able to scan both left-to-right and right-to-left.

+    * Also, we must determine whether the major edge is at the

+    * left or right side of the triangle.  We do this by

+    * computing the magnitude of the cross-product of the major

+    * and top edges.  Since this magnitude depends on the sine of

+    * the angle between the two edges, its sign tells us whether

+    * we turn to the left or to the right when travelling along

+    * the major edge to the top edge, and from this we infer

+    * whether the major edge is on the left or the right.

+    *

+    * Serendipitously, this cross-product magnitude is also a

+    * value we need to compute the iteration parameter

+    * derivatives for the triangle, and it can be used to perform

+    * backface culling because its sign tells us whether the

+    * triangle is clockwise or counterclockwise.  In this code we

+    * refer to it as ``area'' because it's also proportional to

+    * the pixel area of the triangle.

+    */

+

+   {

+      GLint scan_from_left_to_right;  /* true if scanning left-to-right */

+

+      /*

+       * Execute user-supplied setup code

+       */

+#ifdef SETUP_CODE

+      SETUP_CODE

+#endif

+

+      scan_from_left_to_right = (oneOverArea < 0.0F);

+

+

+      /* compute d?/dx and d?/dy derivatives */

+#ifdef INTERP_Z

+      span.interpMask |= SPAN_Z;

+      {

+         GLfloat eMaj_dz = vMax->attrib[FRAG_ATTRIB_WPOS][2] - vMin->attrib[FRAG_ATTRIB_WPOS][2];

+         GLfloat eBot_dz = vMid->attrib[FRAG_ATTRIB_WPOS][2] - vMin->attrib[FRAG_ATTRIB_WPOS][2];

+         span.attrStepX[FRAG_ATTRIB_WPOS][2] = oneOverArea * (eMaj_dz * eBot.dy - eMaj.dy * eBot_dz);

+         if (span.attrStepX[FRAG_ATTRIB_WPOS][2] > maxDepth ||

+             span.attrStepX[FRAG_ATTRIB_WPOS][2] < -maxDepth) {

+            /* probably a sliver triangle */

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

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

+         }

+         else {

+            span.attrStepY[FRAG_ATTRIB_WPOS][2] = oneOverArea * (eMaj.dx * eBot_dz - eMaj_dz * eBot.dx);

+         }

+         if (depthBits <= 16)

+            span.zStep = SignedFloatToFixed(span.attrStepX[FRAG_ATTRIB_WPOS][2]);

+         else

+            span.zStep = (GLint) span.attrStepX[FRAG_ATTRIB_WPOS][2];

+      }

+#endif

+#ifdef INTERP_RGB

+      span.interpMask |= SPAN_RGBA;

+      if (ctx->Light.ShadeModel == GL_SMOOTH) {

+         GLfloat eMaj_dr = (GLfloat) (vMax->color[RCOMP] - vMin->color[RCOMP]);

+         GLfloat eBot_dr = (GLfloat) (vMid->color[RCOMP] - vMin->color[RCOMP]);

+         GLfloat eMaj_dg = (GLfloat) (vMax->color[GCOMP] - vMin->color[GCOMP]);

+         GLfloat eBot_dg = (GLfloat) (vMid->color[GCOMP] - vMin->color[GCOMP]);

+         GLfloat eMaj_db = (GLfloat) (vMax->color[BCOMP] - vMin->color[BCOMP]);

+         GLfloat eBot_db = (GLfloat) (vMid->color[BCOMP] - vMin->color[BCOMP]);

+#  ifdef INTERP_ALPHA

+         GLfloat eMaj_da = (GLfloat) (vMax->color[ACOMP] - vMin->color[ACOMP]);

+         GLfloat eBot_da = (GLfloat) (vMid->color[ACOMP] - vMin->color[ACOMP]);

+#  endif

+         span.attrStepX[FRAG_ATTRIB_COL0][0] = oneOverArea * (eMaj_dr * eBot.dy - eMaj.dy * eBot_dr);

+         span.attrStepY[FRAG_ATTRIB_COL0][0] = oneOverArea * (eMaj.dx * eBot_dr - eMaj_dr * eBot.dx);

+         span.attrStepX[FRAG_ATTRIB_COL0][1] = oneOverArea * (eMaj_dg * eBot.dy - eMaj.dy * eBot_dg);

+         span.attrStepY[FRAG_ATTRIB_COL0][1] = oneOverArea * (eMaj.dx * eBot_dg - eMaj_dg * eBot.dx);

+         span.attrStepX[FRAG_ATTRIB_COL0][2] = oneOverArea * (eMaj_db * eBot.dy - eMaj.dy * eBot_db);

+         span.attrStepY[FRAG_ATTRIB_COL0][2] = oneOverArea * (eMaj.dx * eBot_db - eMaj_db * eBot.dx);

+         span.redStep   = SignedFloatToFixed(span.attrStepX[FRAG_ATTRIB_COL0][0]);

+         span.greenStep = SignedFloatToFixed(span.attrStepX[FRAG_ATTRIB_COL0][1]);

+         span.blueStep  = SignedFloatToFixed(span.attrStepX[FRAG_ATTRIB_COL0][2]);

+#  ifdef INTERP_ALPHA

+         span.attrStepX[FRAG_ATTRIB_COL0][3] = oneOverArea * (eMaj_da * eBot.dy - eMaj.dy * eBot_da);

+         span.attrStepY[FRAG_ATTRIB_COL0][3] = oneOverArea * (eMaj.dx * eBot_da - eMaj_da * eBot.dx);

+         span.alphaStep = SignedFloatToFixed(span.attrStepX[FRAG_ATTRIB_COL0][3]);

+#  endif /* INTERP_ALPHA */

+      }

+      else {

+         ASSERT(ctx->Light.ShadeModel == GL_FLAT);

+         span.interpMask |= SPAN_FLAT;

+         span.attrStepX[FRAG_ATTRIB_COL0][0] = span.attrStepY[FRAG_ATTRIB_COL0][0] = 0.0F;

+         span.attrStepX[FRAG_ATTRIB_COL0][1] = span.attrStepY[FRAG_ATTRIB_COL0][1] = 0.0F;

+         span.attrStepX[FRAG_ATTRIB_COL0][2] = span.attrStepY[FRAG_ATTRIB_COL0][2] = 0.0F;

+	 span.redStep   = 0;

+	 span.greenStep = 0;

+	 span.blueStep  = 0;

+#  ifdef INTERP_ALPHA

+         span.attrStepX[FRAG_ATTRIB_COL0][3] = span.attrStepY[FRAG_ATTRIB_COL0][3] = 0.0F;

+	 span.alphaStep = 0;

+#  endif

+      }

+#endif /* INTERP_RGB */

+#ifdef INTERP_INT_TEX

+      {

+         GLfloat eMaj_ds = (vMax->attrib[FRAG_ATTRIB_TEX0][0] - vMin->attrib[FRAG_ATTRIB_TEX0][0]) * S_SCALE;

+         GLfloat eBot_ds = (vMid->attrib[FRAG_ATTRIB_TEX0][0] - vMin->attrib[FRAG_ATTRIB_TEX0][0]) * S_SCALE;

+         GLfloat eMaj_dt = (vMax->attrib[FRAG_ATTRIB_TEX0][1] - vMin->attrib[FRAG_ATTRIB_TEX0][1]) * T_SCALE;

+         GLfloat eBot_dt = (vMid->attrib[FRAG_ATTRIB_TEX0][1] - vMin->attrib[FRAG_ATTRIB_TEX0][1]) * T_SCALE;

+         span.attrStepX[FRAG_ATTRIB_TEX0][0] = oneOverArea * (eMaj_ds * eBot.dy - eMaj.dy * eBot_ds);

+         span.attrStepY[FRAG_ATTRIB_TEX0][0] = oneOverArea * (eMaj.dx * eBot_ds - eMaj_ds * eBot.dx);

+         span.attrStepX[FRAG_ATTRIB_TEX0][1] = oneOverArea * (eMaj_dt * eBot.dy - eMaj.dy * eBot_dt);

+         span.attrStepY[FRAG_ATTRIB_TEX0][1] = oneOverArea * (eMaj.dx * eBot_dt - eMaj_dt * eBot.dx);

+         span.intTexStep[0] = SignedFloatToFixed(span.attrStepX[FRAG_ATTRIB_TEX0][0]);

+         span.intTexStep[1] = SignedFloatToFixed(span.attrStepX[FRAG_ATTRIB_TEX0][1]);

+      }

+#endif

+#ifdef INTERP_ATTRIBS

+      {

+         /* attrib[FRAG_ATTRIB_WPOS][3] is 1/W */

+         const GLfloat wMax = vMax->attrib[FRAG_ATTRIB_WPOS][3];

+         const GLfloat wMin = vMin->attrib[FRAG_ATTRIB_WPOS][3];

+         const GLfloat wMid = vMid->attrib[FRAG_ATTRIB_WPOS][3];

+         {

+            const GLfloat eMaj_dw = wMax - wMin;

+            const GLfloat eBot_dw = wMid - wMin;

+            span.attrStepX[FRAG_ATTRIB_WPOS][3] = oneOverArea * (eMaj_dw * eBot.dy - eMaj.dy * eBot_dw);

+            span.attrStepY[FRAG_ATTRIB_WPOS][3] = oneOverArea * (eMaj.dx * eBot_dw - eMaj_dw * eBot.dx);

+         }

+         ATTRIB_LOOP_BEGIN

+            if (swrast->_InterpMode[attr] == GL_FLAT) {

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

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

+            }

+            else {

+               GLuint c;

+               for (c = 0; c < 4; c++) {

+                  GLfloat eMaj_da = vMax->attrib[attr][c] * wMax - vMin->attrib[attr][c] * wMin;

+                  GLfloat eBot_da = vMid->attrib[attr][c] * wMid - vMin->attrib[attr][c] * wMin;

+                  span.attrStepX[attr][c] = oneOverArea * (eMaj_da * eBot.dy - eMaj.dy * eBot_da);

+                  span.attrStepY[attr][c] = oneOverArea * (eMaj.dx * eBot_da - eMaj_da * eBot.dx);

+               }

+            }

+         ATTRIB_LOOP_END

+      }

+#endif

+

+      /*

+       * We always sample at pixel centers.  However, we avoid

+       * explicit half-pixel offsets in this code by incorporating

+       * the proper offset in each of x and y during the

+       * transformation to window coordinates.

+       *

+       * We also apply the usual rasterization rules to prevent

+       * cracks and overlaps.  A pixel is considered inside a

+       * subtriangle if it meets all of four conditions: it is on or

+       * to the right of the left edge, strictly to the left of the

+       * right edge, on or below the top edge, and strictly above

+       * the bottom edge.  (Some edges may be degenerate.)

+       *

+       * The following discussion assumes left-to-right scanning

+       * (that is, the major edge is on the left); the right-to-left

+       * case is a straightforward variation.

+       *

+       * We start by finding the half-integral y coordinate that is

+       * at or below the top of the triangle.  This gives us the

+       * first scan line that could possibly contain pixels that are

+       * inside the triangle.

+       *

+       * Next we creep down the major edge until we reach that y,

+       * and compute the corresponding x coordinate on the edge.

+       * Then we find the half-integral x that lies on or just

+       * inside the edge.  This is the first pixel that might lie in

+       * the interior of the triangle.  (We won't know for sure

+       * until we check the other edges.)

+       *

+       * As we rasterize the triangle, we'll step down the major

+       * edge.  For each step in y, we'll move an integer number

+       * of steps in x.  There are two possible x step sizes, which

+       * we'll call the ``inner'' step (guaranteed to land on the

+       * edge or inside it) and the ``outer'' step (guaranteed to

+       * land on the edge or outside it).  The inner and outer steps

+       * differ by one.  During rasterization we maintain an error

+       * term that indicates our distance from the true edge, and

+       * select either the inner step or the outer step, whichever

+       * gets us to the first pixel that falls inside the triangle.

+       *

+       * All parameters (z, red, etc.) as well as the buffer

+       * addresses for color and z have inner and outer step values,

+       * so that we can increment them appropriately.  This method

+       * eliminates the need to adjust parameters by creeping a

+       * sub-pixel amount into the triangle at each scanline.

+       */

+

+      {

+         GLint subTriangle;

+         GLfixed fxLeftEdge = 0, fxRightEdge = 0;

+         GLfixed fdxLeftEdge = 0, fdxRightEdge = 0;

+         GLfixed fError = 0, fdError = 0;

+#ifdef PIXEL_ADDRESS

+         PIXEL_TYPE *pRow = NULL;

+         GLint dPRowOuter = 0, dPRowInner;  /* offset in bytes */

+#endif

+#ifdef INTERP_Z

+#  ifdef DEPTH_TYPE

+         struct gl_renderbuffer *zrb

+            = ctx->DrawBuffer->Attachment[BUFFER_DEPTH].Renderbuffer;

+         DEPTH_TYPE *zRow = NULL;

+         GLint dZRowOuter = 0, dZRowInner;  /* offset in bytes */

+#  endif

+         GLuint zLeft = 0;

+         GLfixed fdzOuter = 0, fdzInner;

+#endif

+#ifdef INTERP_RGB

+         GLint rLeft = 0, fdrOuter = 0, fdrInner;

+         GLint gLeft = 0, fdgOuter = 0, fdgInner;

+         GLint bLeft = 0, fdbOuter = 0, fdbInner;

+#endif

+#ifdef INTERP_ALPHA

+         GLint aLeft = 0, fdaOuter = 0, fdaInner;

+#endif

+#ifdef INTERP_INT_TEX

+         GLfixed sLeft=0, dsOuter=0, dsInner;

+         GLfixed tLeft=0, dtOuter=0, dtInner;

+#endif

+#ifdef INTERP_ATTRIBS

+         GLfloat wLeft = 0, dwOuter = 0, dwInner;

+         GLfloat attrLeft[FRAG_ATTRIB_MAX][4];

+         GLfloat daOuter[FRAG_ATTRIB_MAX][4], daInner[FRAG_ATTRIB_MAX][4];

+#endif

+

+         for (subTriangle=0; subTriangle<=1; subTriangle++) {

+            EdgeT *eLeft, *eRight;

+            int setupLeft, setupRight;

+            int lines;

+

+            if (subTriangle==0) {

+               /* bottom half */

+               if (scan_from_left_to_right) {

+                  eLeft = &eMaj;

+                  eRight = &eBot;

+                  lines = eRight->lines;

+                  setupLeft = 1;

+                  setupRight = 1;

+               }

+               else {

+                  eLeft = &eBot;

+                  eRight = &eMaj;

+                  lines = eLeft->lines;

+                  setupLeft = 1;

+                  setupRight = 1;

+               }

+            }

+            else {

+               /* top half */

+               if (scan_from_left_to_right) {

+                  eLeft = &eMaj;

+                  eRight = &eTop;

+                  lines = eRight->lines;

+                  setupLeft = 0;

+                  setupRight = 1;

+               }

+               else {

+                  eLeft = &eTop;

+                  eRight = &eMaj;

+                  lines = eLeft->lines;

+                  setupLeft = 1;

+                  setupRight = 0;

+               }

+               if (lines == 0)

+                  return;

+            }

+

+            if (setupLeft && eLeft->lines > 0) {

+               const SWvertex *vLower = eLeft->v0;

+               const GLfixed fsy = eLeft->fsy;

+               const GLfixed fsx = eLeft->fsx;  /* no fractional part */

+               const GLfixed fx = FixedCeil(fsx);  /* no fractional part */

+               const GLfixed adjx = (GLfixed) (fx - eLeft->fx0); /* SCALED! */

+               const GLfixed adjy = (GLfixed) eLeft->adjy;      /* SCALED! */

+               GLint idxOuter;

+               GLfloat dxOuter;

+               GLfixed fdxOuter;

+

+               fError = fx - fsx - FIXED_ONE;

+               fxLeftEdge = fsx - FIXED_EPSILON;

+               fdxLeftEdge = eLeft->fdxdy;

+               fdxOuter = FixedFloor(fdxLeftEdge - FIXED_EPSILON);

+               fdError = fdxOuter - fdxLeftEdge + FIXED_ONE;

+               idxOuter = FixedToInt(fdxOuter);

+               dxOuter = (GLfloat) idxOuter;

+               span.y = FixedToInt(fsy);

+

+               /* silence warnings on some compilers */

+               (void) dxOuter;

+               (void) adjx;

+               (void) adjy;

+               (void) vLower;

+

+#ifdef PIXEL_ADDRESS

+               {

+                  pRow = (PIXEL_TYPE *) PIXEL_ADDRESS(FixedToInt(fxLeftEdge), span.y);

+                  dPRowOuter = -((int)BYTES_PER_ROW) + idxOuter * sizeof(PIXEL_TYPE);

+                  /* negative because Y=0 at bottom and increases upward */

+               }

+#endif

+               /*

+                * Now we need the set of parameter (z, color, etc.) values at

+                * the point (fx, fsy).  This gives us properly-sampled parameter

+                * values that we can step from pixel to pixel.  Furthermore,

+                * although we might have intermediate results that overflow

+                * the normal parameter range when we step temporarily outside

+                * the triangle, we shouldn't overflow or underflow for any

+                * pixel that's actually inside the triangle.

+                */

+

+#ifdef INTERP_Z

+               {

+                  GLfloat z0 = vLower->attrib[FRAG_ATTRIB_WPOS][2];

+                  if (depthBits <= 16) {

+                     /* interpolate fixed-pt values */

+                     GLfloat tmp = (z0 * FIXED_SCALE

+                                    + span.attrStepX[FRAG_ATTRIB_WPOS][2] * adjx

+                                    + span.attrStepY[FRAG_ATTRIB_WPOS][2] * adjy) + FIXED_HALF;

+                     if (tmp < MAX_GLUINT / 2)

+                        zLeft = (GLfixed) tmp;

+                     else

+                        zLeft = MAX_GLUINT / 2;

+                     fdzOuter = SignedFloatToFixed(span.attrStepY[FRAG_ATTRIB_WPOS][2] +

+                                                   dxOuter * span.attrStepX[FRAG_ATTRIB_WPOS][2]);

+                  }

+                  else {

+                     /* interpolate depth values w/out scaling */

+                     zLeft = (GLuint) (z0 + span.attrStepX[FRAG_ATTRIB_WPOS][2] * FixedToFloat(adjx)

+                                          + span.attrStepY[FRAG_ATTRIB_WPOS][2] * FixedToFloat(adjy));

+                     fdzOuter = (GLint) (span.attrStepY[FRAG_ATTRIB_WPOS][2] +

+                                         dxOuter * span.attrStepX[FRAG_ATTRIB_WPOS][2]);

+                  }

+#  ifdef DEPTH_TYPE

+                  zRow = (DEPTH_TYPE *)

+                    zrb->GetPointer(ctx, zrb, FixedToInt(fxLeftEdge), span.y);

+                  dZRowOuter = (ctx->DrawBuffer->Width + idxOuter) * sizeof(DEPTH_TYPE);

+#  endif

+               }

+#endif

+#ifdef INTERP_RGB

+               if (ctx->Light.ShadeModel == GL_SMOOTH) {

+                  rLeft = (GLint)(ChanToFixed(vLower->color[RCOMP])

+                                  + span.attrStepX[FRAG_ATTRIB_COL0][0] * adjx

+                                  + span.attrStepY[FRAG_ATTRIB_COL0][0] * adjy) + FIXED_HALF;

+                  gLeft = (GLint)(ChanToFixed(vLower->color[GCOMP])

+                                  + span.attrStepX[FRAG_ATTRIB_COL0][1] * adjx

+                                  + span.attrStepY[FRAG_ATTRIB_COL0][1] * adjy) + FIXED_HALF;

+                  bLeft = (GLint)(ChanToFixed(vLower->color[BCOMP])

+                                  + span.attrStepX[FRAG_ATTRIB_COL0][2] * adjx

+                                  + span.attrStepY[FRAG_ATTRIB_COL0][2] * adjy) + FIXED_HALF;

+                  fdrOuter = SignedFloatToFixed(span.attrStepY[FRAG_ATTRIB_COL0][0]

+                                                + dxOuter * span.attrStepX[FRAG_ATTRIB_COL0][0]);

+                  fdgOuter = SignedFloatToFixed(span.attrStepY[FRAG_ATTRIB_COL0][1]

+                                                + dxOuter * span.attrStepX[FRAG_ATTRIB_COL0][1]);

+                  fdbOuter = SignedFloatToFixed(span.attrStepY[FRAG_ATTRIB_COL0][2]

+                                                + dxOuter * span.attrStepX[FRAG_ATTRIB_COL0][2]);

+#  ifdef INTERP_ALPHA

+                  aLeft = (GLint)(ChanToFixed(vLower->color[ACOMP])

+                                  + span.attrStepX[FRAG_ATTRIB_COL0][3] * adjx

+                                  + span.attrStepY[FRAG_ATTRIB_COL0][3] * adjy) + FIXED_HALF;

+                  fdaOuter = SignedFloatToFixed(span.attrStepY[FRAG_ATTRIB_COL0][3]

+                                                + dxOuter * span.attrStepX[FRAG_ATTRIB_COL0][3]);

+#  endif

+               }

+               else {

+                  ASSERT(ctx->Light.ShadeModel == GL_FLAT);

+                  rLeft = ChanToFixed(v2->color[RCOMP]);

+                  gLeft = ChanToFixed(v2->color[GCOMP]);

+                  bLeft = ChanToFixed(v2->color[BCOMP]);

+                  fdrOuter = fdgOuter = fdbOuter = 0;

+#  ifdef INTERP_ALPHA

+                  aLeft = ChanToFixed(v2->color[ACOMP]);

+                  fdaOuter = 0;

+#  endif

+               }

+#endif /* INTERP_RGB */

+

+

+#ifdef INTERP_INT_TEX

+               {

+                  GLfloat s0, t0;

+                  s0 = vLower->attrib[FRAG_ATTRIB_TEX0][0] * S_SCALE;

+                  sLeft = (GLfixed)(s0 * FIXED_SCALE + span.attrStepX[FRAG_ATTRIB_TEX0][0] * adjx

+                                 + span.attrStepY[FRAG_ATTRIB_TEX0][0] * adjy) + FIXED_HALF;

+                  dsOuter = SignedFloatToFixed(span.attrStepY[FRAG_ATTRIB_TEX0][0]

+                                               + dxOuter * span.attrStepX[FRAG_ATTRIB_TEX0][0]);

+

+                  t0 = vLower->attrib[FRAG_ATTRIB_TEX0][1] * T_SCALE;

+                  tLeft = (GLfixed)(t0 * FIXED_SCALE + span.attrStepX[FRAG_ATTRIB_TEX0][1] * adjx

+                                 + span.attrStepY[FRAG_ATTRIB_TEX0][1] * adjy) + FIXED_HALF;

+                  dtOuter = SignedFloatToFixed(span.attrStepY[FRAG_ATTRIB_TEX0][1]

+                                               + dxOuter * span.attrStepX[FRAG_ATTRIB_TEX0][1]);

+               }

+#endif

+#ifdef INTERP_ATTRIBS

+               {

+                  const GLuint attr = FRAG_ATTRIB_WPOS;

+                  wLeft = vLower->attrib[FRAG_ATTRIB_WPOS][3]

+                        + (span.attrStepX[attr][3] * adjx

+                           + span.attrStepY[attr][3] * adjy) * (1.0F/FIXED_SCALE);

+                  dwOuter = span.attrStepY[attr][3] + dxOuter * span.attrStepX[attr][3];

+               }

+               ATTRIB_LOOP_BEGIN

+                  const GLfloat invW = vLower->attrib[FRAG_ATTRIB_WPOS][3];

+                  if (swrast->_InterpMode[attr] == GL_FLAT) {

+                     GLuint c;

+                     for (c = 0; c < 4; c++) {

+                        attrLeft[attr][c] = v2->attrib[attr][c] * invW;

+                        daOuter[attr][c] = 0.0;

+                     }

+                  }

+                  else {

+                     GLuint c;

+                     for (c = 0; c < 4; c++) {

+                        const GLfloat a = vLower->attrib[attr][c] * invW;

+                        attrLeft[attr][c] = a + (  span.attrStepX[attr][c] * adjx

+                                                 + span.attrStepY[attr][c] * adjy) * (1.0F/FIXED_SCALE);

+                        daOuter[attr][c] = span.attrStepY[attr][c] + dxOuter * span.attrStepX[attr][c];

+                     }

+                  }

+               ATTRIB_LOOP_END

+#endif

+            } /*if setupLeft*/

+

+

+            if (setupRight && eRight->lines>0) {

+               fxRightEdge = eRight->fsx - FIXED_EPSILON;

+               fdxRightEdge = eRight->fdxdy;

+            }

+

+            if (lines==0) {

+               continue;

+            }

+

+

+            /* Rasterize setup */

+#ifdef PIXEL_ADDRESS

+            dPRowInner = dPRowOuter + sizeof(PIXEL_TYPE);

+#endif

+#ifdef INTERP_Z

+#  ifdef DEPTH_TYPE

+            dZRowInner = dZRowOuter + sizeof(DEPTH_TYPE);

+#  endif

+            fdzInner = fdzOuter + span.zStep;

+#endif

+#ifdef INTERP_RGB

+            fdrInner = fdrOuter + span.redStep;

+            fdgInner = fdgOuter + span.greenStep;

+            fdbInner = fdbOuter + span.blueStep;

+#endif

+#ifdef INTERP_ALPHA

+            fdaInner = fdaOuter + span.alphaStep;

+#endif

+#ifdef INTERP_INT_TEX

+            dsInner = dsOuter + span.intTexStep[0];

+            dtInner = dtOuter + span.intTexStep[1];

+#endif

+#ifdef INTERP_ATTRIBS

+            dwInner = dwOuter + span.attrStepX[FRAG_ATTRIB_WPOS][3];

+            ATTRIB_LOOP_BEGIN

+               GLuint c;

+               for (c = 0; c < 4; c++) {

+                  daInner[attr][c] = daOuter[attr][c] + span.attrStepX[attr][c];

+               }

+            ATTRIB_LOOP_END

+#endif

+

+            while (lines > 0) {

+               /* initialize the span interpolants to the leftmost value */

+               /* ff = fixed-pt fragment */

+               const GLint right = FixedToInt(fxRightEdge);

+               span.x = FixedToInt(fxLeftEdge);

+               if (right <= span.x)

+                  span.end = 0;

+               else

+                  span.end = right - span.x;

+

+#ifdef INTERP_Z

+               span.z = zLeft;

+#endif

+#ifdef INTERP_RGB

+               span.red = rLeft;

+               span.green = gLeft;

+               span.blue = bLeft;

+#endif

+#ifdef INTERP_ALPHA

+               span.alpha = aLeft;

+#endif

+#ifdef INTERP_INT_TEX

+               span.intTex[0] = sLeft;

+               span.intTex[1] = tLeft;

+#endif

+

+#ifdef INTERP_ATTRIBS

+               span.attrStart[FRAG_ATTRIB_WPOS][3] = wLeft;

+               ATTRIB_LOOP_BEGIN

+                  GLuint c;

+                  for (c = 0; c < 4; c++) {

+                     span.attrStart[attr][c] = attrLeft[attr][c];

+                  }

+               ATTRIB_LOOP_END

+#endif

+

+               /* This is where we actually generate fragments */

+               /* XXX the test for span.y > 0 _shouldn't_ be needed but

+                * it fixes a problem on 64-bit Opterons (bug 4842).

+                */

+               if (span.end > 0 && span.y >= 0) {

+                  const GLint len = span.end - 1;

+                  (void) len;

+#ifdef INTERP_RGB

+                  CLAMP_INTERPOLANT(red, redStep, len);

+                  CLAMP_INTERPOLANT(green, greenStep, len);

+                  CLAMP_INTERPOLANT(blue, blueStep, len);

+#endif

+#ifdef INTERP_ALPHA

+                  CLAMP_INTERPOLANT(alpha, alphaStep, len);

+#endif

+                  {

+                     RENDER_SPAN( span );

+                  }

+               }

+

+               /*

+                * Advance to the next scan line.  Compute the

+                * new edge coordinates, and adjust the

+                * pixel-center x coordinate so that it stays

+                * on or inside the major edge.

+                */

+               span.y++;

+               lines--;

+

+               fxLeftEdge += fdxLeftEdge;

+               fxRightEdge += fdxRightEdge;

+

+               fError += fdError;

+               if (fError >= 0) {

+                  fError -= FIXED_ONE;

+

+#ifdef PIXEL_ADDRESS

+                  pRow = (PIXEL_TYPE *) ((GLubyte *) pRow + dPRowOuter);

+#endif

+#ifdef INTERP_Z

+#  ifdef DEPTH_TYPE

+                  zRow = (DEPTH_TYPE *) ((GLubyte *) zRow + dZRowOuter);

+#  endif

+                  zLeft += fdzOuter;

+#endif

+#ifdef INTERP_RGB

+                  rLeft += fdrOuter;

+                  gLeft += fdgOuter;

+                  bLeft += fdbOuter;

+#endif

+#ifdef INTERP_ALPHA

+                  aLeft += fdaOuter;

+#endif

+#ifdef INTERP_INT_TEX

+                  sLeft += dsOuter;

+                  tLeft += dtOuter;

+#endif

+#ifdef INTERP_ATTRIBS

+                  wLeft += dwOuter;

+                  ATTRIB_LOOP_BEGIN

+                     GLuint c;

+                     for (c = 0; c < 4; c++) {

+                        attrLeft[attr][c] += daOuter[attr][c];

+                     }

+                  ATTRIB_LOOP_END

+#endif

+               }

+               else {

+#ifdef PIXEL_ADDRESS

+                  pRow = (PIXEL_TYPE *) ((GLubyte *) pRow + dPRowInner);

+#endif

+#ifdef INTERP_Z

+#  ifdef DEPTH_TYPE

+                  zRow = (DEPTH_TYPE *) ((GLubyte *) zRow + dZRowInner);

+#  endif

+                  zLeft += fdzInner;

+#endif

+#ifdef INTERP_RGB

+                  rLeft += fdrInner;

+                  gLeft += fdgInner;

+                  bLeft += fdbInner;

+#endif

+#ifdef INTERP_ALPHA

+                  aLeft += fdaInner;

+#endif

+#ifdef INTERP_INT_TEX

+                  sLeft += dsInner;

+                  tLeft += dtInner;

+#endif

+#ifdef INTERP_ATTRIBS

+                  wLeft += dwInner;

+                  ATTRIB_LOOP_BEGIN

+                     GLuint c;

+                     for (c = 0; c < 4; c++) {

+                        attrLeft[attr][c] += daInner[attr][c];

+                     }

+                  ATTRIB_LOOP_END

+#endif

+               }

+            } /*while lines>0*/

+

+         } /* for subTriangle */

+

+      }

+   }

+}

+

+#undef SETUP_CODE

+#undef RENDER_SPAN

+

+#undef PIXEL_TYPE

+#undef BYTES_PER_ROW

+#undef PIXEL_ADDRESS

+#undef DEPTH_TYPE

+

+#undef INTERP_Z

+#undef INTERP_RGB

+#undef INTERP_ALPHA

+#undef INTERP_INT_TEX

+#undef INTERP_ATTRIBS

+

+#undef S_SCALE

+#undef T_SCALE

+

+#undef FixedToDepth

+

+#undef NAME

diff --git a/mesalib/src/mesa/swrast/s_zoom.c b/mesalib/src/mesa/swrast/s_zoom.c
index f224627d5..3b99bf754 100644
--- a/mesalib/src/mesa/swrast/s_zoom.c
+++ b/mesalib/src/mesa/swrast/s_zoom.c
@@ -1,433 +1,433 @@
-/*
- * Mesa 3-D graphics library
- * Version:  7.1
- *
- * Copyright (C) 1999-2008  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/macros.h"
-#include "main/imports.h"
-#include "main/colormac.h"
-
-#include "s_context.h"
-#include "s_span.h"
-#include "s_stencil.h"
-#include "s_zoom.h"
-
-
-/**
- * Compute the bounds of the region resulting from zooming a pixel span.
- * The resulting region will be entirely inside the window/scissor bounds
- * so no additional clipping is needed.
- * \param imageX, imageY  position of the mage being drawn (gl WindowPos)
- * \param spanX, spanY  position of span being drawing
- * \param width  number of pixels in span
- * \param x0, x1  returned X bounds of zoomed region [x0, x1)
- * \param y0, y1  returned Y bounds of zoomed region [y0, y1)
- * \return GL_TRUE if any zoomed pixels visible, GL_FALSE if totally clipped
- */
-static GLboolean
-compute_zoomed_bounds(GLcontext *ctx, GLint imageX, GLint imageY,
-                      GLint spanX, GLint spanY, GLint width,
-                      GLint *x0, GLint *x1, GLint *y0, GLint *y1)
-{
-   const struct gl_framebuffer *fb = ctx->DrawBuffer;
-   GLint c0, c1, r0, r1;
-
-   ASSERT(spanX >= imageX);
-   ASSERT(spanY >= imageY);
-
-   /*
-    * Compute destination columns: [c0, c1)
-    */
-   c0 = imageX + (GLint) ((spanX - imageX) * ctx->Pixel.ZoomX);
-   c1 = imageX + (GLint) ((spanX + width - imageX) * ctx->Pixel.ZoomX);
-   if (c1 < c0) {
-      /* swap */
-      GLint tmp = c1;
-      c1 = c0;
-      c0 = tmp;
-   }
-   c0 = CLAMP(c0, fb->_Xmin, fb->_Xmax);
-   c1 = CLAMP(c1, fb->_Xmin, fb->_Xmax);
-   if (c0 == c1) {
-      return GL_FALSE; /* no width */
-   }
-
-   /*
-    * Compute destination rows: [r0, r1)
-    */
-   r0 = imageY + (GLint) ((spanY - imageY) * ctx->Pixel.ZoomY);
-   r1 = imageY + (GLint) ((spanY + 1 - imageY) * ctx->Pixel.ZoomY);
-   if (r1 < r0) {
-      /* swap */
-      GLint tmp = r1;
-      r1 = r0;
-      r0 = tmp;
-   }
-   r0 = CLAMP(r0, fb->_Ymin, fb->_Ymax);
-   r1 = CLAMP(r1, fb->_Ymin, fb->_Ymax);
-   if (r0 == r1) {
-      return GL_FALSE; /* no height */
-   }
-
-   *x0 = c0;
-   *x1 = c1;
-   *y0 = r0;
-   *y1 = r1;
-
-   return GL_TRUE;
-}
-
-
-/**
- * Convert a zoomed x image coordinate back to an unzoomed x coord.
- * 'zx' is screen position of a pixel in the zoomed image, who's left edge
- * is at 'imageX'.
- * return corresponding x coord in the original, unzoomed image.
- * This can use this for unzooming X or Y values.
- */
-static INLINE GLint
-unzoom_x(GLfloat zoomX, GLint imageX, GLint zx)
-{
-   /*
-   zx = imageX + (x - imageX) * zoomX;
-   zx - imageX = (x - imageX) * zoomX;
-   (zx - imageX) / zoomX = x - imageX;
-   */
-   GLint x;
-   if (zoomX < 0.0)
-      zx++;
-   x = imageX + (GLint) ((zx - imageX) / zoomX);
-   return x;
-}
-
-
-
-/**
- * Helper function called from _swrast_write_zoomed_rgba/rgb/
- * index/depth_span().
- */
-static void
-zoom_span( GLcontext *ctx, GLint imgX, GLint imgY, const SWspan *span,
-           const GLvoid *src, GLenum format )
-{
-   SWcontext *swrast = SWRAST_CONTEXT(ctx);
-   SWspan zoomed;
-   GLint x0, x1, y0, y1;
-   GLint zoomedWidth;
-
-   if (!compute_zoomed_bounds(ctx, imgX, imgY, span->x, span->y, span->end,
-                              &x0, &x1, &y0, &y1)) {
-      return;  /* totally clipped */
-   }
-
-   if (!swrast->ZoomedArrays) {
-      /* allocate on demand */
-      swrast->ZoomedArrays = (SWspanarrays *) CALLOC(sizeof(SWspanarrays));
-      if (!swrast->ZoomedArrays)
-         return;
-   }
-
-   zoomedWidth = x1 - x0;
-   ASSERT(zoomedWidth > 0);
-   ASSERT(zoomedWidth <= MAX_WIDTH);
-
-   /* no pixel arrays! must be horizontal spans. */
-   ASSERT((span->arrayMask & SPAN_XY) == 0);
-   ASSERT(span->primitive == GL_BITMAP);
-
-   INIT_SPAN(zoomed, GL_BITMAP);
-   zoomed.x = x0;
-   zoomed.end = zoomedWidth;
-   zoomed.array = swrast->ZoomedArrays;
-   zoomed.array->ChanType = span->array->ChanType;
-   if (zoomed.array->ChanType == GL_UNSIGNED_BYTE)
-      zoomed.array->rgba = (GLchan (*)[4]) zoomed.array->rgba8;
-   else if (zoomed.array->ChanType == GL_UNSIGNED_SHORT)
-      zoomed.array->rgba = (GLchan (*)[4]) zoomed.array->rgba16;
-   else
-      zoomed.array->rgba = (GLchan (*)[4]) zoomed.array->attribs[FRAG_ATTRIB_COL0];
-
-   COPY_4V(zoomed.attrStart[FRAG_ATTRIB_WPOS], span->attrStart[FRAG_ATTRIB_WPOS]);
-   COPY_4V(zoomed.attrStepX[FRAG_ATTRIB_WPOS], span->attrStepX[FRAG_ATTRIB_WPOS]);
-   COPY_4V(zoomed.attrStepY[FRAG_ATTRIB_WPOS], span->attrStepY[FRAG_ATTRIB_WPOS]);
-
-   zoomed.attrStart[FRAG_ATTRIB_FOGC][0] = span->attrStart[FRAG_ATTRIB_FOGC][0];
-   zoomed.attrStepX[FRAG_ATTRIB_FOGC][0] = span->attrStepX[FRAG_ATTRIB_FOGC][0];
-   zoomed.attrStepY[FRAG_ATTRIB_FOGC][0] = span->attrStepY[FRAG_ATTRIB_FOGC][0];
-
-   if (format == GL_RGBA || format == GL_RGB) {
-      /* copy Z info */
-      zoomed.z = span->z;
-      zoomed.zStep = span->zStep;
-      /* we'll generate an array of colorss */
-      zoomed.interpMask = span->interpMask & ~SPAN_RGBA;
-      zoomed.arrayMask |= SPAN_RGBA;
-      zoomed.arrayAttribs |= FRAG_BIT_COL0;  /* we'll produce these values */
-      ASSERT(span->arrayMask & SPAN_RGBA);
-   }
-   else if (format == GL_DEPTH_COMPONENT) {
-      /* Copy color info */
-      zoomed.red = span->red;
-      zoomed.green = span->green;
-      zoomed.blue = span->blue;
-      zoomed.alpha = span->alpha;
-      zoomed.redStep = span->redStep;
-      zoomed.greenStep = span->greenStep;
-      zoomed.blueStep = span->blueStep;
-      zoomed.alphaStep = span->alphaStep;
-      /* we'll generate an array of depth values */
-      zoomed.interpMask = span->interpMask & ~SPAN_Z;
-      zoomed.arrayMask |= SPAN_Z;
-      ASSERT(span->arrayMask & SPAN_Z);
-   }
-   else {
-      _mesa_problem(ctx, "Bad format in zoom_span");
-      return;
-   }
-
-   /* zoom the span horizontally */
-   if (format == GL_RGBA) {
-      if (zoomed.array->ChanType == GL_UNSIGNED_BYTE) {
-         const GLubyte (*rgba)[4] = (const GLubyte (*)[4]) src;
-         GLint i;
-         for (i = 0; i < zoomedWidth; i++) {
-            GLint j = unzoom_x(ctx->Pixel.ZoomX, imgX, x0 + i) - span->x;
-            ASSERT(j >= 0);
-            ASSERT(j < (GLint) span->end);
-            COPY_4UBV(zoomed.array->rgba8[i], rgba[j]);
-         }
-      }
-      else if (zoomed.array->ChanType == GL_UNSIGNED_SHORT) {
-         const GLushort (*rgba)[4] = (const GLushort (*)[4]) src;
-         GLint i;
-         for (i = 0; i < zoomedWidth; i++) {
-            GLint j = unzoom_x(ctx->Pixel.ZoomX, imgX, x0 + i) - span->x;
-            ASSERT(j >= 0);
-            ASSERT(j < (GLint) span->end);
-            COPY_4V(zoomed.array->rgba16[i], rgba[j]);
-         }
-      }
-      else {
-         const GLfloat (*rgba)[4] = (const GLfloat (*)[4]) src;
-         GLint i;
-         for (i = 0; i < zoomedWidth; i++) {
-            GLint j = unzoom_x(ctx->Pixel.ZoomX, imgX, x0 + i) - span->x;
-            ASSERT(j >= 0);
-            ASSERT(j < span->end);
-            COPY_4V(zoomed.array->attribs[FRAG_ATTRIB_COL0][i], rgba[j]);
-         }
-      }
-   }
-   else if (format == GL_RGB) {
-      if (zoomed.array->ChanType == GL_UNSIGNED_BYTE) {
-         const GLubyte (*rgb)[3] = (const GLubyte (*)[3]) src;
-         GLint i;
-         for (i = 0; i < zoomedWidth; i++) {
-            GLint j = unzoom_x(ctx->Pixel.ZoomX, imgX, x0 + i) - span->x;
-            ASSERT(j >= 0);
-            ASSERT(j < (GLint) span->end);
-            zoomed.array->rgba8[i][0] = rgb[j][0];
-            zoomed.array->rgba8[i][1] = rgb[j][1];
-            zoomed.array->rgba8[i][2] = rgb[j][2];
-            zoomed.array->rgba8[i][3] = 0xff;
-         }
-      }
-      else if (zoomed.array->ChanType == GL_UNSIGNED_SHORT) {
-         const GLushort (*rgb)[3] = (const GLushort (*)[3]) src;
-         GLint i;
-         for (i = 0; i < zoomedWidth; i++) {
-            GLint j = unzoom_x(ctx->Pixel.ZoomX, imgX, x0 + i) - span->x;
-            ASSERT(j >= 0);
-            ASSERT(j < (GLint) span->end);
-            zoomed.array->rgba16[i][0] = rgb[j][0];
-            zoomed.array->rgba16[i][1] = rgb[j][1];
-            zoomed.array->rgba16[i][2] = rgb[j][2];
-            zoomed.array->rgba16[i][3] = 0xffff;
-         }
-      }
-      else {
-         const GLfloat (*rgb)[3] = (const GLfloat (*)[3]) src;
-         GLint i;
-         for (i = 0; i < zoomedWidth; i++) {
-            GLint j = unzoom_x(ctx->Pixel.ZoomX, imgX, x0 + i) - span->x;
-            ASSERT(j >= 0);
-            ASSERT(j < span->end);
-            zoomed.array->attribs[FRAG_ATTRIB_COL0][i][0] = rgb[j][0];
-            zoomed.array->attribs[FRAG_ATTRIB_COL0][i][1] = rgb[j][1];
-            zoomed.array->attribs[FRAG_ATTRIB_COL0][i][2] = rgb[j][2];
-            zoomed.array->attribs[FRAG_ATTRIB_COL0][i][3] = 1.0F;
-         }
-      }
-   }
-   else if (format == GL_DEPTH_COMPONENT) {
-      const GLuint *zValues = (const GLuint *) src;
-      GLint i;
-      for (i = 0; i < zoomedWidth; i++) {
-         GLint j = unzoom_x(ctx->Pixel.ZoomX, imgX, x0 + i) - span->x;
-         ASSERT(j >= 0);
-         ASSERT(j < (GLint) span->end);
-         zoomed.array->z[i] = zValues[j];
-      }
-      /* Now, fall into the RGB path below */
-      format = GL_RGBA;
-   }
-
-   /* write the span in rows [r0, r1) */
-   if (format == GL_RGBA || format == GL_RGB) {
-      /* Writing the span may modify the colors, so make a backup now if we're
-       * going to call _swrast_write_zoomed_span() more than once.
-       * Also, clipping may change the span end value, so store it as well.
-       */
-      const GLint end = zoomed.end; /* save */
-      GLuint rgbaSave[MAX_WIDTH][4];
-      const GLint pixelSize =
-         (zoomed.array->ChanType == GL_UNSIGNED_BYTE) ? 4 * sizeof(GLubyte) :
-         ((zoomed.array->ChanType == GL_UNSIGNED_SHORT) ? 4 * sizeof(GLushort)
-          : 4 * sizeof(GLfloat));
-      if (y1 - y0 > 1) {
-         memcpy(rgbaSave, zoomed.array->rgba, zoomed.end * pixelSize);
-      }
-      for (zoomed.y = y0; zoomed.y < y1; zoomed.y++) {
-         _swrast_write_rgba_span(ctx, &zoomed);
-         zoomed.end = end;  /* restore */
-         if (y1 - y0 > 1) {
-            /* restore the colors */
-            memcpy(zoomed.array->rgba, rgbaSave, zoomed.end * pixelSize);
-         }
-      }
-   }
-}
-
-
-void
-_swrast_write_zoomed_rgba_span(GLcontext *ctx, GLint imgX, GLint imgY,
-                               const SWspan *span, const GLvoid *rgba)
-{
-   zoom_span(ctx, imgX, imgY, span, rgba, GL_RGBA);
-}
-
-
-void
-_swrast_write_zoomed_rgb_span(GLcontext *ctx, GLint imgX, GLint imgY,
-                              const SWspan *span, const GLvoid *rgb)
-{
-   zoom_span(ctx, imgX, imgY, span, rgb, GL_RGB);
-}
-
-
-void
-_swrast_write_zoomed_depth_span(GLcontext *ctx, GLint imgX, GLint imgY,
-                                const SWspan *span)
-{
-   zoom_span(ctx, imgX, imgY, span,
-             (const GLvoid *) span->array->z, GL_DEPTH_COMPONENT);
-}
-
-
-/**
- * Zoom/write stencil values.
- * No per-fragment operations are applied.
- */
-void
-_swrast_write_zoomed_stencil_span(GLcontext *ctx, GLint imgX, GLint imgY,
-                                  GLint width, GLint spanX, GLint spanY,
-                                  const GLstencil stencil[])
-{
-   GLstencil zoomedVals[MAX_WIDTH];
-   GLint x0, x1, y0, y1, y;
-   GLint i, zoomedWidth;
-
-   if (!compute_zoomed_bounds(ctx, imgX, imgY, spanX, spanY, width,
-                              &x0, &x1, &y0, &y1)) {
-      return;  /* totally clipped */
-   }
-
-   zoomedWidth = x1 - x0;
-   ASSERT(zoomedWidth > 0);
-   ASSERT(zoomedWidth <= MAX_WIDTH);
-
-   /* zoom the span horizontally */
-   for (i = 0; i < zoomedWidth; i++) {
-      GLint j = unzoom_x(ctx->Pixel.ZoomX, imgX, x0 + i) - spanX;
-      ASSERT(j >= 0);
-      ASSERT(j < width);
-      zoomedVals[i] = stencil[j];
-   }
-
-   /* write the zoomed spans */
-   for (y = y0; y < y1; y++) {
-      _swrast_write_stencil_span(ctx, zoomedWidth, x0, y, zoomedVals);
-   }
-}
-
-
-/**
- * Zoom/write z values (16 or 32-bit).
- * No per-fragment operations are applied.
- */
-void
-_swrast_write_zoomed_z_span(GLcontext *ctx, GLint imgX, GLint imgY,
-                            GLint width, GLint spanX, GLint spanY,
-                            const GLvoid *z)
-{
-   struct gl_renderbuffer *rb = ctx->DrawBuffer->_DepthBuffer;
-   GLushort zoomedVals16[MAX_WIDTH];
-   GLuint zoomedVals32[MAX_WIDTH];
-   GLint x0, x1, y0, y1, y;
-   GLint i, zoomedWidth;
-
-   if (!compute_zoomed_bounds(ctx, imgX, imgY, spanX, spanY, width,
-                              &x0, &x1, &y0, &y1)) {
-      return;  /* totally clipped */
-   }
-
-   zoomedWidth = x1 - x0;
-   ASSERT(zoomedWidth > 0);
-   ASSERT(zoomedWidth <= MAX_WIDTH);
-
-   /* zoom the span horizontally */
-   if (rb->DataType == GL_UNSIGNED_SHORT) {
-      for (i = 0; i < zoomedWidth; i++) {
-         GLint j = unzoom_x(ctx->Pixel.ZoomX, imgX, x0 + i) - spanX;
-         ASSERT(j >= 0);
-         ASSERT(j < width);
-         zoomedVals16[i] = ((GLushort *) z)[j];
-      }
-      z = zoomedVals16;
-   }
-   else {
-      ASSERT(rb->DataType == GL_UNSIGNED_INT);
-      for (i = 0; i < zoomedWidth; i++) {
-         GLint j = unzoom_x(ctx->Pixel.ZoomX, imgX, x0 + i) - spanX;
-         ASSERT(j >= 0);
-         ASSERT(j < width);
-         zoomedVals32[i] = ((GLuint *) z)[j];
-      }
-      z = zoomedVals32;
-   }
-
-   /* write the zoomed spans */
-   for (y = y0; y < y1; y++) {
-      rb->PutRow(ctx, rb, zoomedWidth, x0, y, z, NULL);
-   }
-}
+/*

+ * Mesa 3-D graphics library

+ * Version:  7.1

+ *

+ * Copyright (C) 1999-2008  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/macros.h"

+#include "main/imports.h"

+#include "main/colormac.h"

+

+#include "s_context.h"

+#include "s_span.h"

+#include "s_stencil.h"

+#include "s_zoom.h"

+

+

+/**

+ * Compute the bounds of the region resulting from zooming a pixel span.

+ * The resulting region will be entirely inside the window/scissor bounds

+ * so no additional clipping is needed.

+ * \param imageX, imageY  position of the mage being drawn (gl WindowPos)

+ * \param spanX, spanY  position of span being drawing

+ * \param width  number of pixels in span

+ * \param x0, x1  returned X bounds of zoomed region [x0, x1)

+ * \param y0, y1  returned Y bounds of zoomed region [y0, y1)

+ * \return GL_TRUE if any zoomed pixels visible, GL_FALSE if totally clipped

+ */

+static GLboolean

+compute_zoomed_bounds(struct gl_context *ctx, GLint imageX, GLint imageY,

+                      GLint spanX, GLint spanY, GLint width,

+                      GLint *x0, GLint *x1, GLint *y0, GLint *y1)

+{

+   const struct gl_framebuffer *fb = ctx->DrawBuffer;

+   GLint c0, c1, r0, r1;

+

+   ASSERT(spanX >= imageX);

+   ASSERT(spanY >= imageY);

+

+   /*

+    * Compute destination columns: [c0, c1)

+    */

+   c0 = imageX + (GLint) ((spanX - imageX) * ctx->Pixel.ZoomX);

+   c1 = imageX + (GLint) ((spanX + width - imageX) * ctx->Pixel.ZoomX);

+   if (c1 < c0) {

+      /* swap */

+      GLint tmp = c1;

+      c1 = c0;

+      c0 = tmp;

+   }

+   c0 = CLAMP(c0, fb->_Xmin, fb->_Xmax);

+   c1 = CLAMP(c1, fb->_Xmin, fb->_Xmax);

+   if (c0 == c1) {

+      return GL_FALSE; /* no width */

+   }

+

+   /*

+    * Compute destination rows: [r0, r1)

+    */

+   r0 = imageY + (GLint) ((spanY - imageY) * ctx->Pixel.ZoomY);

+   r1 = imageY + (GLint) ((spanY + 1 - imageY) * ctx->Pixel.ZoomY);

+   if (r1 < r0) {

+      /* swap */

+      GLint tmp = r1;

+      r1 = r0;

+      r0 = tmp;

+   }

+   r0 = CLAMP(r0, fb->_Ymin, fb->_Ymax);

+   r1 = CLAMP(r1, fb->_Ymin, fb->_Ymax);

+   if (r0 == r1) {

+      return GL_FALSE; /* no height */

+   }

+

+   *x0 = c0;

+   *x1 = c1;

+   *y0 = r0;

+   *y1 = r1;

+

+   return GL_TRUE;

+}

+

+

+/**

+ * Convert a zoomed x image coordinate back to an unzoomed x coord.

+ * 'zx' is screen position of a pixel in the zoomed image, who's left edge

+ * is at 'imageX'.

+ * return corresponding x coord in the original, unzoomed image.

+ * This can use this for unzooming X or Y values.

+ */

+static INLINE GLint

+unzoom_x(GLfloat zoomX, GLint imageX, GLint zx)

+{

+   /*

+   zx = imageX + (x - imageX) * zoomX;

+   zx - imageX = (x - imageX) * zoomX;

+   (zx - imageX) / zoomX = x - imageX;

+   */

+   GLint x;

+   if (zoomX < 0.0)

+      zx++;

+   x = imageX + (GLint) ((zx - imageX) / zoomX);

+   return x;

+}

+

+

+

+/**

+ * Helper function called from _swrast_write_zoomed_rgba/rgb/

+ * index/depth_span().

+ */

+static void

+zoom_span( struct gl_context *ctx, GLint imgX, GLint imgY, const SWspan *span,

+           const GLvoid *src, GLenum format )

+{

+   SWcontext *swrast = SWRAST_CONTEXT(ctx);

+   SWspan zoomed;

+   GLint x0, x1, y0, y1;

+   GLint zoomedWidth;

+

+   if (!compute_zoomed_bounds(ctx, imgX, imgY, span->x, span->y, span->end,

+                              &x0, &x1, &y0, &y1)) {

+      return;  /* totally clipped */

+   }

+

+   if (!swrast->ZoomedArrays) {

+      /* allocate on demand */

+      swrast->ZoomedArrays = (SWspanarrays *) CALLOC(sizeof(SWspanarrays));

+      if (!swrast->ZoomedArrays)

+         return;

+   }

+

+   zoomedWidth = x1 - x0;

+   ASSERT(zoomedWidth > 0);

+   ASSERT(zoomedWidth <= MAX_WIDTH);

+

+   /* no pixel arrays! must be horizontal spans. */

+   ASSERT((span->arrayMask & SPAN_XY) == 0);

+   ASSERT(span->primitive == GL_BITMAP);

+

+   INIT_SPAN(zoomed, GL_BITMAP);

+   zoomed.x = x0;

+   zoomed.end = zoomedWidth;

+   zoomed.array = swrast->ZoomedArrays;

+   zoomed.array->ChanType = span->array->ChanType;

+   if (zoomed.array->ChanType == GL_UNSIGNED_BYTE)

+      zoomed.array->rgba = (GLchan (*)[4]) zoomed.array->rgba8;

+   else if (zoomed.array->ChanType == GL_UNSIGNED_SHORT)

+      zoomed.array->rgba = (GLchan (*)[4]) zoomed.array->rgba16;

+   else

+      zoomed.array->rgba = (GLchan (*)[4]) zoomed.array->attribs[FRAG_ATTRIB_COL0];

+

+   COPY_4V(zoomed.attrStart[FRAG_ATTRIB_WPOS], span->attrStart[FRAG_ATTRIB_WPOS]);

+   COPY_4V(zoomed.attrStepX[FRAG_ATTRIB_WPOS], span->attrStepX[FRAG_ATTRIB_WPOS]);

+   COPY_4V(zoomed.attrStepY[FRAG_ATTRIB_WPOS], span->attrStepY[FRAG_ATTRIB_WPOS]);

+

+   zoomed.attrStart[FRAG_ATTRIB_FOGC][0] = span->attrStart[FRAG_ATTRIB_FOGC][0];

+   zoomed.attrStepX[FRAG_ATTRIB_FOGC][0] = span->attrStepX[FRAG_ATTRIB_FOGC][0];

+   zoomed.attrStepY[FRAG_ATTRIB_FOGC][0] = span->attrStepY[FRAG_ATTRIB_FOGC][0];

+

+   if (format == GL_RGBA || format == GL_RGB) {

+      /* copy Z info */

+      zoomed.z = span->z;

+      zoomed.zStep = span->zStep;

+      /* we'll generate an array of colorss */

+      zoomed.interpMask = span->interpMask & ~SPAN_RGBA;

+      zoomed.arrayMask |= SPAN_RGBA;

+      zoomed.arrayAttribs |= FRAG_BIT_COL0;  /* we'll produce these values */

+      ASSERT(span->arrayMask & SPAN_RGBA);

+   }

+   else if (format == GL_DEPTH_COMPONENT) {

+      /* Copy color info */

+      zoomed.red = span->red;

+      zoomed.green = span->green;

+      zoomed.blue = span->blue;

+      zoomed.alpha = span->alpha;

+      zoomed.redStep = span->redStep;

+      zoomed.greenStep = span->greenStep;

+      zoomed.blueStep = span->blueStep;

+      zoomed.alphaStep = span->alphaStep;

+      /* we'll generate an array of depth values */

+      zoomed.interpMask = span->interpMask & ~SPAN_Z;

+      zoomed.arrayMask |= SPAN_Z;

+      ASSERT(span->arrayMask & SPAN_Z);

+   }

+   else {

+      _mesa_problem(ctx, "Bad format in zoom_span");

+      return;

+   }

+

+   /* zoom the span horizontally */

+   if (format == GL_RGBA) {

+      if (zoomed.array->ChanType == GL_UNSIGNED_BYTE) {

+         const GLubyte (*rgba)[4] = (const GLubyte (*)[4]) src;

+         GLint i;

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

+            GLint j = unzoom_x(ctx->Pixel.ZoomX, imgX, x0 + i) - span->x;

+            ASSERT(j >= 0);

+            ASSERT(j < (GLint) span->end);

+            COPY_4UBV(zoomed.array->rgba8[i], rgba[j]);

+         }

+      }

+      else if (zoomed.array->ChanType == GL_UNSIGNED_SHORT) {

+         const GLushort (*rgba)[4] = (const GLushort (*)[4]) src;

+         GLint i;

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

+            GLint j = unzoom_x(ctx->Pixel.ZoomX, imgX, x0 + i) - span->x;

+            ASSERT(j >= 0);

+            ASSERT(j < (GLint) span->end);

+            COPY_4V(zoomed.array->rgba16[i], rgba[j]);

+         }

+      }

+      else {

+         const GLfloat (*rgba)[4] = (const GLfloat (*)[4]) src;

+         GLint i;

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

+            GLint j = unzoom_x(ctx->Pixel.ZoomX, imgX, x0 + i) - span->x;

+            ASSERT(j >= 0);

+            ASSERT(j < span->end);

+            COPY_4V(zoomed.array->attribs[FRAG_ATTRIB_COL0][i], rgba[j]);

+         }

+      }

+   }

+   else if (format == GL_RGB) {

+      if (zoomed.array->ChanType == GL_UNSIGNED_BYTE) {

+         const GLubyte (*rgb)[3] = (const GLubyte (*)[3]) src;

+         GLint i;

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

+            GLint j = unzoom_x(ctx->Pixel.ZoomX, imgX, x0 + i) - span->x;

+            ASSERT(j >= 0);

+            ASSERT(j < (GLint) span->end);

+            zoomed.array->rgba8[i][0] = rgb[j][0];

+            zoomed.array->rgba8[i][1] = rgb[j][1];

+            zoomed.array->rgba8[i][2] = rgb[j][2];

+            zoomed.array->rgba8[i][3] = 0xff;

+         }

+      }

+      else if (zoomed.array->ChanType == GL_UNSIGNED_SHORT) {

+         const GLushort (*rgb)[3] = (const GLushort (*)[3]) src;

+         GLint i;

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

+            GLint j = unzoom_x(ctx->Pixel.ZoomX, imgX, x0 + i) - span->x;

+            ASSERT(j >= 0);

+            ASSERT(j < (GLint) span->end);

+            zoomed.array->rgba16[i][0] = rgb[j][0];

+            zoomed.array->rgba16[i][1] = rgb[j][1];

+            zoomed.array->rgba16[i][2] = rgb[j][2];

+            zoomed.array->rgba16[i][3] = 0xffff;

+         }

+      }

+      else {

+         const GLfloat (*rgb)[3] = (const GLfloat (*)[3]) src;

+         GLint i;

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

+            GLint j = unzoom_x(ctx->Pixel.ZoomX, imgX, x0 + i) - span->x;

+            ASSERT(j >= 0);

+            ASSERT(j < span->end);

+            zoomed.array->attribs[FRAG_ATTRIB_COL0][i][0] = rgb[j][0];

+            zoomed.array->attribs[FRAG_ATTRIB_COL0][i][1] = rgb[j][1];

+            zoomed.array->attribs[FRAG_ATTRIB_COL0][i][2] = rgb[j][2];

+            zoomed.array->attribs[FRAG_ATTRIB_COL0][i][3] = 1.0F;

+         }

+      }

+   }

+   else if (format == GL_DEPTH_COMPONENT) {

+      const GLuint *zValues = (const GLuint *) src;

+      GLint i;

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

+         GLint j = unzoom_x(ctx->Pixel.ZoomX, imgX, x0 + i) - span->x;

+         ASSERT(j >= 0);

+         ASSERT(j < (GLint) span->end);

+         zoomed.array->z[i] = zValues[j];

+      }

+      /* Now, fall into the RGB path below */

+      format = GL_RGBA;

+   }

+

+   /* write the span in rows [r0, r1) */

+   if (format == GL_RGBA || format == GL_RGB) {

+      /* Writing the span may modify the colors, so make a backup now if we're

+       * going to call _swrast_write_zoomed_span() more than once.

+       * Also, clipping may change the span end value, so store it as well.

+       */

+      const GLint end = zoomed.end; /* save */

+      GLuint rgbaSave[MAX_WIDTH][4];

+      const GLint pixelSize =

+         (zoomed.array->ChanType == GL_UNSIGNED_BYTE) ? 4 * sizeof(GLubyte) :

+         ((zoomed.array->ChanType == GL_UNSIGNED_SHORT) ? 4 * sizeof(GLushort)

+          : 4 * sizeof(GLfloat));

+      if (y1 - y0 > 1) {

+         memcpy(rgbaSave, zoomed.array->rgba, zoomed.end * pixelSize);

+      }

+      for (zoomed.y = y0; zoomed.y < y1; zoomed.y++) {

+         _swrast_write_rgba_span(ctx, &zoomed);

+         zoomed.end = end;  /* restore */

+         if (y1 - y0 > 1) {

+            /* restore the colors */

+            memcpy(zoomed.array->rgba, rgbaSave, zoomed.end * pixelSize);

+         }

+      }

+   }

+}

+

+

+void

+_swrast_write_zoomed_rgba_span(struct gl_context *ctx, GLint imgX, GLint imgY,

+                               const SWspan *span, const GLvoid *rgba)

+{

+   zoom_span(ctx, imgX, imgY, span, rgba, GL_RGBA);

+}

+

+

+void

+_swrast_write_zoomed_rgb_span(struct gl_context *ctx, GLint imgX, GLint imgY,

+                              const SWspan *span, const GLvoid *rgb)

+{

+   zoom_span(ctx, imgX, imgY, span, rgb, GL_RGB);

+}

+

+

+void

+_swrast_write_zoomed_depth_span(struct gl_context *ctx, GLint imgX, GLint imgY,

+                                const SWspan *span)

+{

+   zoom_span(ctx, imgX, imgY, span,

+             (const GLvoid *) span->array->z, GL_DEPTH_COMPONENT);

+}

+

+

+/**

+ * Zoom/write stencil values.

+ * No per-fragment operations are applied.

+ */

+void

+_swrast_write_zoomed_stencil_span(struct gl_context *ctx, GLint imgX, GLint imgY,

+                                  GLint width, GLint spanX, GLint spanY,

+                                  const GLstencil stencil[])

+{

+   GLstencil zoomedVals[MAX_WIDTH];

+   GLint x0, x1, y0, y1, y;

+   GLint i, zoomedWidth;

+

+   if (!compute_zoomed_bounds(ctx, imgX, imgY, spanX, spanY, width,

+                              &x0, &x1, &y0, &y1)) {

+      return;  /* totally clipped */

+   }

+

+   zoomedWidth = x1 - x0;

+   ASSERT(zoomedWidth > 0);

+   ASSERT(zoomedWidth <= MAX_WIDTH);

+

+   /* zoom the span horizontally */

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

+      GLint j = unzoom_x(ctx->Pixel.ZoomX, imgX, x0 + i) - spanX;

+      ASSERT(j >= 0);

+      ASSERT(j < width);

+      zoomedVals[i] = stencil[j];

+   }

+

+   /* write the zoomed spans */

+   for (y = y0; y < y1; y++) {

+      _swrast_write_stencil_span(ctx, zoomedWidth, x0, y, zoomedVals);

+   }

+}

+

+

+/**

+ * Zoom/write z values (16 or 32-bit).

+ * No per-fragment operations are applied.

+ */

+void

+_swrast_write_zoomed_z_span(struct gl_context *ctx, GLint imgX, GLint imgY,

+                            GLint width, GLint spanX, GLint spanY,

+                            const GLvoid *z)

+{

+   struct gl_renderbuffer *rb = ctx->DrawBuffer->_DepthBuffer;

+   GLushort zoomedVals16[MAX_WIDTH];

+   GLuint zoomedVals32[MAX_WIDTH];

+   GLint x0, x1, y0, y1, y;

+   GLint i, zoomedWidth;

+

+   if (!compute_zoomed_bounds(ctx, imgX, imgY, spanX, spanY, width,

+                              &x0, &x1, &y0, &y1)) {

+      return;  /* totally clipped */

+   }

+

+   zoomedWidth = x1 - x0;

+   ASSERT(zoomedWidth > 0);

+   ASSERT(zoomedWidth <= MAX_WIDTH);

+

+   /* zoom the span horizontally */

+   if (rb->DataType == GL_UNSIGNED_SHORT) {

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

+         GLint j = unzoom_x(ctx->Pixel.ZoomX, imgX, x0 + i) - spanX;

+         ASSERT(j >= 0);

+         ASSERT(j < width);

+         zoomedVals16[i] = ((GLushort *) z)[j];

+      }

+      z = zoomedVals16;

+   }

+   else {

+      ASSERT(rb->DataType == GL_UNSIGNED_INT);

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

+         GLint j = unzoom_x(ctx->Pixel.ZoomX, imgX, x0 + i) - spanX;

+         ASSERT(j >= 0);

+         ASSERT(j < width);

+         zoomedVals32[i] = ((GLuint *) z)[j];

+      }

+      z = zoomedVals32;

+   }

+

+   /* write the zoomed spans */

+   for (y = y0; y < y1; y++) {

+      rb->PutRow(ctx, rb, zoomedWidth, x0, y, z, NULL);

+   }

+}

diff --git a/mesalib/src/mesa/swrast/s_zoom.h b/mesalib/src/mesa/swrast/s_zoom.h
index 09f624efa..b8d17b5a4 100644
--- a/mesalib/src/mesa/swrast/s_zoom.h
+++ b/mesalib/src/mesa/swrast/s_zoom.h
@@ -1,56 +1,56 @@
-/*
- * Mesa 3-D graphics library
- * Version:  6.5
- *
- * Copyright (C) 1999-2005  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.
- */
-
-#ifndef S_ZOOM_H
-#define S_ZOOM_H
-
-#include "main/mtypes.h"
-#include "s_span.h"
-
-
-extern void
-_swrast_write_zoomed_rgba_span(GLcontext *ctx, GLint imgX, GLint imgY,
-                               const SWspan *span, const GLvoid *rgba);
-
-extern void
-_swrast_write_zoomed_rgb_span(GLcontext *ctx, GLint imgX, GLint imgY,
-                              const SWspan *span, const GLvoid *rgb);
-
-extern void
-_swrast_write_zoomed_depth_span(GLcontext *ctx, GLint imgX, GLint imgY,
-                                const SWspan *span);
-
-
-extern void
-_swrast_write_zoomed_stencil_span(GLcontext *ctx, GLint imgX, GLint imgY,
-                                  GLint width, GLint spanX, GLint spanY,
-                                  const GLstencil stencil[]);
-
-extern void
-_swrast_write_zoomed_z_span(GLcontext *ctx, GLint imgX, GLint imgY,
-                            GLint width, GLint spanX, GLint spanY,
-                            const GLvoid *z);
-
-
-#endif
+/*

+ * Mesa 3-D graphics library

+ * Version:  6.5

+ *

+ * Copyright (C) 1999-2005  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.

+ */

+

+#ifndef S_ZOOM_H

+#define S_ZOOM_H

+

+#include "main/mtypes.h"

+#include "s_span.h"

+

+

+extern void

+_swrast_write_zoomed_rgba_span(struct gl_context *ctx, GLint imgX, GLint imgY,

+                               const SWspan *span, const GLvoid *rgba);

+

+extern void

+_swrast_write_zoomed_rgb_span(struct gl_context *ctx, GLint imgX, GLint imgY,

+                              const SWspan *span, const GLvoid *rgb);

+

+extern void

+_swrast_write_zoomed_depth_span(struct gl_context *ctx, GLint imgX, GLint imgY,

+                                const SWspan *span);

+

+

+extern void

+_swrast_write_zoomed_stencil_span(struct gl_context *ctx, GLint imgX, GLint imgY,

+                                  GLint width, GLint spanX, GLint spanY,

+                                  const GLstencil stencil[]);

+

+extern void

+_swrast_write_zoomed_z_span(struct gl_context *ctx, GLint imgX, GLint imgY,

+                            GLint width, GLint spanX, GLint spanY,

+                            const GLvoid *z);

+

+

+#endif

diff --git a/mesalib/src/mesa/swrast/swrast.h b/mesalib/src/mesa/swrast/swrast.h
index c01cf7d1f..2db536c7b 100644
--- a/mesalib/src/mesa/swrast/swrast.h
+++ b/mesalib/src/mesa/swrast/swrast.h
@@ -1,232 +1,232 @@
-/*
- * Mesa 3-D graphics library
- * Version:  6.5
- *
- * Copyright (C) 1999-2006  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.
- *
- */
-
-/**
- * \file swrast/swrast.h
- * \brief Public interface to the software rasterization functions.
- * \author Keith Whitwell <keith@tungstengraphics.com>
- */
-
-#ifndef SWRAST_H
-#define SWRAST_H
-
-#include "main/mtypes.h"
-
-/**
- * \struct SWvertex
- * \brief Data-structure to handle vertices in the software rasterizer.
- * 
- * The software rasterizer now uses this format for vertices.  Thus a
- * 'RasterSetup' stage or other translation is required between the
- * tnl module and the swrast rasterization functions.  This serves to
- * isolate the swrast module from the internals of the tnl module, and
- * improve its usefulness as a fallback mechanism for hardware
- * drivers.
- *
- * wpos = attr[FRAG_ATTRIB_WPOS] and MUST BE THE FIRST values in the
- * vertex because of the tnl clipping code.
-
- * wpos[0] and [1] are the screen-coords of SWvertex.
- * wpos[2] is the z-buffer coord (if 16-bit Z buffer, in range [0,65535]).
- * wpos[3] is 1/w where w is the clip-space W coord.  This is the value
- * that clip{XYZ} were multiplied by to get ndc{XYZ}.
- *
- * Full software drivers:
- *   - Register the rastersetup and triangle functions from
- *     utils/software_helper.
- *   - On statechange, update the rasterization pointers in that module.
- *
- * Rasterization hardware drivers:
- *   - Keep native rastersetup.
- *   - Implement native twoside,offset and unfilled triangle setup.
- *   - Implement a translator from native vertices to swrast vertices.
- *   - On partial fallback (mix of accelerated and unaccelerated
- *   prims), call a pass-through function which translates native
- *   vertices to SWvertices and calls the appropriate swrast function.
- *   - On total fallback (vertex format insufficient for state or all
- *     primitives unaccelerated), hook in swrast_setup instead.
- */
-typedef struct {
-   GLfloat attrib[FRAG_ATTRIB_MAX][4];
-   GLchan color[4];   /** integer color */
-   GLfloat pointSize;
-} SWvertex;
-
-
-#define FRAG_ATTRIB_CI FRAG_ATTRIB_COL0
-
-
-struct swrast_device_driver;
-
-
-/* These are the public-access functions exported from swrast.
- */
-
-extern GLboolean
-_swrast_CreateContext( GLcontext *ctx );
-
-extern void
-_swrast_DestroyContext( GLcontext *ctx );
-
-/* Get a (non-const) reference to the device driver struct for swrast.
- */
-extern struct swrast_device_driver *
-_swrast_GetDeviceDriverReference( GLcontext *ctx );
-
-extern void
-_swrast_Bitmap( GLcontext *ctx,
-		GLint px, GLint py,
-		GLsizei width, GLsizei height,
-		const struct gl_pixelstore_attrib *unpack,
-		const GLubyte *bitmap );
-
-extern void
-_swrast_CopyPixels( GLcontext *ctx,
-		    GLint srcx, GLint srcy,
-		    GLint destx, GLint desty,
-		    GLsizei width, GLsizei height,
-		    GLenum type );
-
-extern void
-_swrast_DrawPixels( GLcontext *ctx,
-		    GLint x, GLint y,
-		    GLsizei width, GLsizei height,
-		    GLenum format, GLenum type,
-		    const struct gl_pixelstore_attrib *unpack,
-		    const GLvoid *pixels );
-
-extern void
-_swrast_ReadPixels( GLcontext *ctx,
-		    GLint x, GLint y, GLsizei width, GLsizei height,
-		    GLenum format, GLenum type,
-		    const struct gl_pixelstore_attrib *unpack,
-		    GLvoid *pixels );
-
-extern void
-_swrast_BlitFramebuffer(GLcontext *ctx,
-                        GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1,
-                        GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1,
-                        GLbitfield mask, GLenum filter);
-
-extern void
-_swrast_Clear(GLcontext *ctx, GLbitfield buffers);
-
-extern void
-_swrast_Accum(GLcontext *ctx, GLenum op, GLfloat value);
-
-
-
-/* Reset the stipple counter
- */
-extern void
-_swrast_ResetLineStipple( GLcontext *ctx );
-
-/**
- * Indicates front/back facing for subsequent points/lines when drawing
- * unfilled polygons.  Needed for two-side stencil.
- */
-extern void
-_swrast_SetFacing(GLcontext *ctx, GLuint facing);
-
-/* These will always render the correct point/line/triangle for the
- * current state.
- *
- * For flatshaded primitives, the provoking vertex is the final one.
- */
-extern void
-_swrast_Point( GLcontext *ctx, const SWvertex *v );
-
-extern void
-_swrast_Line( GLcontext *ctx, const SWvertex *v0, const SWvertex *v1 );
-
-extern void
-_swrast_Triangle( GLcontext *ctx, const SWvertex *v0,
-                  const SWvertex *v1, const SWvertex *v2 );
-
-extern void
-_swrast_Quad( GLcontext *ctx,
-              const SWvertex *v0, const SWvertex *v1,
-	      const SWvertex *v2,  const SWvertex *v3);
-
-extern void
-_swrast_flush( GLcontext *ctx );
-
-extern void
-_swrast_render_primitive( GLcontext *ctx, GLenum mode );
-
-extern void
-_swrast_render_start( GLcontext *ctx );
-
-extern void
-_swrast_render_finish( GLcontext *ctx );
-
-/* Tell the software rasterizer about core state changes.
- */
-extern void
-_swrast_InvalidateState( GLcontext *ctx, GLbitfield new_state );
-
-/* Configure software rasterizer to match hardware rasterizer characteristics:
- */
-extern void
-_swrast_allow_vertex_fog( GLcontext *ctx, GLboolean value );
-
-extern void
-_swrast_allow_pixel_fog( GLcontext *ctx, GLboolean value );
-
-/* Debug:
- */
-extern void
-_swrast_print_vertex( GLcontext *ctx, const SWvertex *v );
-
-
-
-extern void
-_swrast_eject_texture_images(GLcontext *ctx);
-
-
-
-/**
- * The driver interface for the software rasterizer.
- * XXX this may go away.
- * We may move these functions to ctx->Driver.RenderStart, RenderEnd.
- */
-struct swrast_device_driver {
-   /*
-    * These are called before and after accessing renderbuffers during
-    * software rasterization.
-    *
-    * These are a suitable place for grabbing/releasing hardware locks.
-    *
-    * NOTE: The swrast triangle/line/point routines *DO NOT* call
-    * these functions.  Locking in that case must be organized by the
-    * driver by other mechanisms.
-    */
-   void (*SpanRenderStart)(GLcontext *ctx);
-   void (*SpanRenderFinish)(GLcontext *ctx);
-};
-
-
-
-#endif
+/*

+ * Mesa 3-D graphics library

+ * Version:  6.5

+ *

+ * Copyright (C) 1999-2006  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.

+ *

+ */

+

+/**

+ * \file swrast/swrast.h

+ * \brief Public interface to the software rasterization functions.

+ * \author Keith Whitwell <keith@tungstengraphics.com>

+ */

+

+#ifndef SWRAST_H

+#define SWRAST_H

+

+#include "main/mtypes.h"

+

+/**

+ * \struct SWvertex

+ * \brief Data-structure to handle vertices in the software rasterizer.

+ * 

+ * The software rasterizer now uses this format for vertices.  Thus a

+ * 'RasterSetup' stage or other translation is required between the

+ * tnl module and the swrast rasterization functions.  This serves to

+ * isolate the swrast module from the internals of the tnl module, and

+ * improve its usefulness as a fallback mechanism for hardware

+ * drivers.

+ *

+ * wpos = attr[FRAG_ATTRIB_WPOS] and MUST BE THE FIRST values in the

+ * vertex because of the tnl clipping code.

+

+ * wpos[0] and [1] are the screen-coords of SWvertex.

+ * wpos[2] is the z-buffer coord (if 16-bit Z buffer, in range [0,65535]).

+ * wpos[3] is 1/w where w is the clip-space W coord.  This is the value

+ * that clip{XYZ} were multiplied by to get ndc{XYZ}.

+ *

+ * Full software drivers:

+ *   - Register the rastersetup and triangle functions from

+ *     utils/software_helper.

+ *   - On statechange, update the rasterization pointers in that module.

+ *

+ * Rasterization hardware drivers:

+ *   - Keep native rastersetup.

+ *   - Implement native twoside,offset and unfilled triangle setup.

+ *   - Implement a translator from native vertices to swrast vertices.

+ *   - On partial fallback (mix of accelerated and unaccelerated

+ *   prims), call a pass-through function which translates native

+ *   vertices to SWvertices and calls the appropriate swrast function.

+ *   - On total fallback (vertex format insufficient for state or all

+ *     primitives unaccelerated), hook in swrast_setup instead.

+ */

+typedef struct {

+   GLfloat attrib[FRAG_ATTRIB_MAX][4];

+   GLchan color[4];   /** integer color */

+   GLfloat pointSize;

+} SWvertex;

+

+

+#define FRAG_ATTRIB_CI FRAG_ATTRIB_COL0

+

+

+struct swrast_device_driver;

+

+

+/* These are the public-access functions exported from swrast.

+ */

+

+extern GLboolean

+_swrast_CreateContext( struct gl_context *ctx );

+

+extern void

+_swrast_DestroyContext( struct gl_context *ctx );

+

+/* Get a (non-const) reference to the device driver struct for swrast.

+ */

+extern struct swrast_device_driver *

+_swrast_GetDeviceDriverReference( struct gl_context *ctx );

+

+extern void

+_swrast_Bitmap( struct gl_context *ctx,

+		GLint px, GLint py,

+		GLsizei width, GLsizei height,

+		const struct gl_pixelstore_attrib *unpack,

+		const GLubyte *bitmap );

+

+extern void

+_swrast_CopyPixels( struct gl_context *ctx,

+		    GLint srcx, GLint srcy,

+		    GLint destx, GLint desty,

+		    GLsizei width, GLsizei height,

+		    GLenum type );

+

+extern void

+_swrast_DrawPixels( struct gl_context *ctx,

+		    GLint x, GLint y,

+		    GLsizei width, GLsizei height,

+		    GLenum format, GLenum type,

+		    const struct gl_pixelstore_attrib *unpack,

+		    const GLvoid *pixels );

+

+extern void

+_swrast_ReadPixels( struct gl_context *ctx,

+		    GLint x, GLint y, GLsizei width, GLsizei height,

+		    GLenum format, GLenum type,

+		    const struct gl_pixelstore_attrib *unpack,

+		    GLvoid *pixels );

+

+extern void

+_swrast_BlitFramebuffer(struct gl_context *ctx,

+                        GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1,

+                        GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1,

+                        GLbitfield mask, GLenum filter);

+

+extern void

+_swrast_Clear(struct gl_context *ctx, GLbitfield buffers);

+

+extern void

+_swrast_Accum(struct gl_context *ctx, GLenum op, GLfloat value);

+

+

+

+/* Reset the stipple counter

+ */

+extern void

+_swrast_ResetLineStipple( struct gl_context *ctx );

+

+/**

+ * Indicates front/back facing for subsequent points/lines when drawing

+ * unfilled polygons.  Needed for two-side stencil.

+ */

+extern void

+_swrast_SetFacing(struct gl_context *ctx, GLuint facing);

+

+/* These will always render the correct point/line/triangle for the

+ * current state.

+ *

+ * For flatshaded primitives, the provoking vertex is the final one.

+ */

+extern void

+_swrast_Point( struct gl_context *ctx, const SWvertex *v );

+

+extern void

+_swrast_Line( struct gl_context *ctx, const SWvertex *v0, const SWvertex *v1 );

+

+extern void

+_swrast_Triangle( struct gl_context *ctx, const SWvertex *v0,

+                  const SWvertex *v1, const SWvertex *v2 );

+

+extern void

+_swrast_Quad( struct gl_context *ctx,

+              const SWvertex *v0, const SWvertex *v1,

+	      const SWvertex *v2,  const SWvertex *v3);

+

+extern void

+_swrast_flush( struct gl_context *ctx );

+

+extern void

+_swrast_render_primitive( struct gl_context *ctx, GLenum mode );

+

+extern void

+_swrast_render_start( struct gl_context *ctx );

+

+extern void

+_swrast_render_finish( struct gl_context *ctx );

+

+/* Tell the software rasterizer about core state changes.

+ */

+extern void

+_swrast_InvalidateState( struct gl_context *ctx, GLbitfield new_state );

+

+/* Configure software rasterizer to match hardware rasterizer characteristics:

+ */

+extern void

+_swrast_allow_vertex_fog( struct gl_context *ctx, GLboolean value );

+

+extern void

+_swrast_allow_pixel_fog( struct gl_context *ctx, GLboolean value );

+

+/* Debug:

+ */

+extern void

+_swrast_print_vertex( struct gl_context *ctx, const SWvertex *v );

+

+

+

+extern void

+_swrast_eject_texture_images(struct gl_context *ctx);

+

+

+

+/**

+ * The driver interface for the software rasterizer.

+ * XXX this may go away.

+ * We may move these functions to ctx->Driver.RenderStart, RenderEnd.

+ */

+struct swrast_device_driver {

+   /*

+    * These are called before and after accessing renderbuffers during

+    * software rasterization.

+    *

+    * These are a suitable place for grabbing/releasing hardware locks.

+    *

+    * NOTE: The swrast triangle/line/point routines *DO NOT* call

+    * these functions.  Locking in that case must be organized by the

+    * driver by other mechanisms.

+    */

+   void (*SpanRenderStart)(struct gl_context *ctx);

+   void (*SpanRenderFinish)(struct gl_context *ctx);

+};

+

+

+

+#endif