Synchronised line endinge with release branch

10 files changed, 5660 insertions, 5660 deletions

diff --git a/mesalib/src/mesa/swrast/s_accum.c b/mesalib/src/mesa/swrast/s_accum.c
index 2889d908b..0ec907d79 100644
--- a/mesalib/src/mesa/swrast/s_accum.c
+++ b/mesalib/src/mesa/swrast/s_accum.c
@@ -1,598 +1,598 @@
-/*

- * 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/condrender.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;

-   }

-

-   if (!_mesa_check_conditional_render(ctx))

-      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/condrender.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;
+   }
+
+   if (!_mesa_check_conditional_render(ctx))
+      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_bitmap.c b/mesalib/src/mesa/swrast/s_bitmap.c
index af65874fd..18f1c1866 100644
--- a/mesalib/src/mesa/swrast/s_bitmap.c
+++ b/mesalib/src/mesa/swrast/s_bitmap.c
@@ -1,223 +1,223 @@
-/*

- * 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 "main/pbo.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

+/*
+ * 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 "main/pbo.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_context.c b/mesalib/src/mesa/swrast/s_context.c
index e65f6aa9d..df213357f 100644
--- a/mesalib/src/mesa/swrast/s_context.c
+++ b/mesalib/src/mesa/swrast/s_context.c
@@ -1,906 +1,906 @@
-/*

- * 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;

-

-   assert((fp == NULL) || (fp->Base.Target == GL_FRAGMENT_PROGRAM_ARB));

-

-   /* determine if fog is needed, and if so, which fog mode */

-   swrast->_FogEnabled = (fp == NULL && ctx->Fog.Enabled);

-}

-

-

-/**

- * 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 );

-}

-

-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 );

-      }

-

-      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;

-}

-

-

-/**

- * Initialize native program limits by copying the logical limits.

- * See comments in init_program_limits() in context.c

- */

-static void

-init_program_native_limits(struct gl_program_constants *prog)

-{

-   prog->MaxNativeInstructions = prog->MaxInstructions;

-   prog->MaxNativeAluInstructions = prog->MaxAluInstructions;

-   prog->MaxNativeTexInstructions = prog->MaxTexInstructions;

-   prog->MaxNativeTexIndirections = prog->MaxTexIndirections;

-   prog->MaxNativeAttribs = prog->MaxAttribs;

-   prog->MaxNativeTemps = prog->MaxTemps;

-   prog->MaxNativeAddressRegs = prog->MaxAddressRegs;

-   prog->MaxNativeParameters = prog->MaxParameters;

-}

-

-

-GLboolean

-_swrast_CreateContext( struct gl_context *ctx )

-{

-   GLuint i;

-   SWcontext *swrast = (SWcontext *)CALLOC(sizeof(SWcontext));

-#ifdef _OPENMP

-   const GLint maxThreads = omp_get_max_threads();

-#else

-   const GLint maxThreads = 1;

-#endif

-

-   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;

-

-   /* SpanArrays is global and shared by all SWspan instances. However, when

-    * using multiple threads, it is necessary to have one SpanArrays instance

-    * per thread.

-    */

-   swrast->SpanArrays = (SWspanarrays *) MALLOC(maxThreads * sizeof(SWspanarrays));

-   if (!swrast->SpanArrays) {

-      FREE(swrast);

-      return GL_FALSE;

-   }

-   for(i = 0; i < maxThreads; i++) {

-      swrast->SpanArrays[i].ChanType = CHAN_TYPE;

-#if CHAN_TYPE == GL_UNSIGNED_BYTE

-      swrast->SpanArrays[i].rgba = swrast->SpanArrays[i].rgba8;

-#elif CHAN_TYPE == GL_UNSIGNED_SHORT

-      swrast->SpanArrays[i].rgba = swrast->SpanArrays[i].rgba16;

-#else

-      swrast->SpanArrays[i].rgba = swrast->SpanArrays[i].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;

-

-   /* TexelBuffer is also global and normally shared by all SWspan instances;

-    * when running with multiple threads, create one per thread.

-    */

-   swrast->TexelBuffer = (GLfloat *) MALLOC(ctx->Const.MaxTextureImageUnits * maxThreads *

-                                           MAX_WIDTH * 4 * sizeof(GLfloat));

-   if (!swrast->TexelBuffer) {

-      FREE(swrast->SpanArrays);

-      FREE(swrast);

-      return GL_FALSE;

-   }

-

-   init_program_native_limits(&ctx->Const.VertexProgram);

-   init_program_native_limits(&ctx->Const.GeometryProgram);

-   init_program_native_limits(&ctx->Const.FragmentProgram);

-

-   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");

-   }

-}

+/*
+ * 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;
+
+   assert((fp == NULL) || (fp->Base.Target == GL_FRAGMENT_PROGRAM_ARB));
+
+   /* determine if fog is needed, and if so, which fog mode */
+   swrast->_FogEnabled = (fp == NULL && ctx->Fog.Enabled);
+}
+
+
+/**
+ * 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 );
+}
+
+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 );
+      }
+
+      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;
+}
+
+
+/**
+ * Initialize native program limits by copying the logical limits.
+ * See comments in init_program_limits() in context.c
+ */
+static void
+init_program_native_limits(struct gl_program_constants *prog)
+{
+   prog->MaxNativeInstructions = prog->MaxInstructions;
+   prog->MaxNativeAluInstructions = prog->MaxAluInstructions;
+   prog->MaxNativeTexInstructions = prog->MaxTexInstructions;
+   prog->MaxNativeTexIndirections = prog->MaxTexIndirections;
+   prog->MaxNativeAttribs = prog->MaxAttribs;
+   prog->MaxNativeTemps = prog->MaxTemps;
+   prog->MaxNativeAddressRegs = prog->MaxAddressRegs;
+   prog->MaxNativeParameters = prog->MaxParameters;
+}
+
+
+GLboolean
+_swrast_CreateContext( struct gl_context *ctx )
+{
+   GLuint i;
+   SWcontext *swrast = (SWcontext *)CALLOC(sizeof(SWcontext));
+#ifdef _OPENMP
+   const GLint maxThreads = omp_get_max_threads();
+#else
+   const GLint maxThreads = 1;
+#endif
+
+   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;
+
+   /* SpanArrays is global and shared by all SWspan instances. However, when
+    * using multiple threads, it is necessary to have one SpanArrays instance
+    * per thread.
+    */
+   swrast->SpanArrays = (SWspanarrays *) MALLOC(maxThreads * sizeof(SWspanarrays));
+   if (!swrast->SpanArrays) {
+      FREE(swrast);
+      return GL_FALSE;
+   }
+   for(i = 0; i < maxThreads; i++) {
+      swrast->SpanArrays[i].ChanType = CHAN_TYPE;
+#if CHAN_TYPE == GL_UNSIGNED_BYTE
+      swrast->SpanArrays[i].rgba = swrast->SpanArrays[i].rgba8;
+#elif CHAN_TYPE == GL_UNSIGNED_SHORT
+      swrast->SpanArrays[i].rgba = swrast->SpanArrays[i].rgba16;
+#else
+      swrast->SpanArrays[i].rgba = swrast->SpanArrays[i].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;
+
+   /* TexelBuffer is also global and normally shared by all SWspan instances;
+    * when running with multiple threads, create one per thread.
+    */
+   swrast->TexelBuffer = (GLfloat *) MALLOC(ctx->Const.MaxTextureImageUnits * maxThreads *
+                                           MAX_WIDTH * 4 * sizeof(GLfloat));
+   if (!swrast->TexelBuffer) {
+      FREE(swrast->SpanArrays);
+      FREE(swrast);
+      return GL_FALSE;
+   }
+
+   init_program_native_limits(&ctx->Const.VertexProgram);
+   init_program_native_limits(&ctx->Const.GeometryProgram);
+   init_program_native_limits(&ctx->Const.FragmentProgram);
+
+   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 1673cece1..8d7458c2d 100644
--- a/mesalib/src/mesa/swrast/s_context.h
+++ b/mesalib/src/mesa/swrast/s_context.h
@@ -1,348 +1,348 @@
-/*

- * 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;

-

-   /** 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

+/*
+ * 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;
+
+   /** 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_drawpix.c b/mesalib/src/mesa/swrast/s_drawpix.c
index 5109eb0d3..63bfa79b5 100644
--- a/mesalib/src/mesa/swrast/s_drawpix.c
+++ b/mesalib/src/mesa/swrast/s_drawpix.c
@@ -1,753 +1,753 @@
-/*

- * 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/pbo.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_STENCIL_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);

-}

+/*
+ * 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/pbo.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_STENCIL_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_fog.c b/mesalib/src/mesa/swrast/s_fog.c
index 5df071481..ea59de160 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(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 (ctx->Fog.Mode) {

-      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 (ctx->Fog.Mode) {
+      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_fragprog.c b/mesalib/src/mesa/swrast/s_fragprog.c
index ab411a2f0..b6bfeaed4 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( 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->Sampler.MinLod, texObj->Sampler.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->Sampler.LodBias;

-

-      lambda = CLAMP(lambda, texObj->Sampler.MinLod, texObj->Sampler.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;

-   }

-}

-

+/*
+ * 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->Sampler.MinLod, texObj->Sampler.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->Sampler.LodBias;
+
+      lambda = CLAMP(lambda, texObj->Sampler.MinLod, texObj->Sampler.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_readpix.c b/mesalib/src/mesa/swrast/s_readpix.c
index 49da247e9..6eec2fc78 100644
--- a/mesalib/src/mesa/swrast/s_readpix.c
+++ b/mesalib/src/mesa/swrast/s_readpix.c
@@ -1,514 +1,514 @@
-/*

- * 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 "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/pbo.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_RG ||

-	  rb->_BaseFormat == GL_RED ||

-	  rb->_BaseFormat == GL_LUMINANCE ||

-	  rb->_BaseFormat == GL_INTENSITY ||

-	  rb->_BaseFormat == GL_LUMINANCE_ALPHA ||

-	  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 ((ctx->Color._ClampReadColor == GL_TRUE || type != GL_FLOAT) &&

-       !_mesa_is_integer_format(format)) {

-      transferOps |= IMAGE_CLAMP_BIT;

-   }

-

-   /* Try the 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);

-

-   {

-      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.redBits != 0) ||

-             (fb->Visual.greenBits < 8 && fb->Visual.greenBits != 0) ||

-	     (fb->Visual.blueBits < 8 && fb->Visual.blueBits != 0)) {

-            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(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, type, 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);

-}

+/*
+ * 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 "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/pbo.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_RG ||
+	  rb->_BaseFormat == GL_RED ||
+	  rb->_BaseFormat == GL_LUMINANCE ||
+	  rb->_BaseFormat == GL_INTENSITY ||
+	  rb->_BaseFormat == GL_LUMINANCE_ALPHA ||
+	  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 ((ctx->Color._ClampReadColor == GL_TRUE || type != GL_FLOAT) &&
+       !_mesa_is_integer_format(format)) {
+      transferOps |= IMAGE_CLAMP_BIT;
+   }
+
+   /* Try the 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);
+
+   {
+      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.redBits != 0) ||
+             (fb->Visual.greenBits < 8 && fb->Visual.greenBits != 0) ||
+	     (fb->Visual.blueBits < 8 && fb->Visual.blueBits != 0)) {
+            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(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, type, 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_texrender.c b/mesalib/src/mesa/swrast/s_texrender.c
index b7239a71d..52d03c92a 100644
--- a/mesalib/src/mesa/swrast/s_texrender.c
+++ b/mesalib/src/mesa/swrast/s_texrender.c
@@ -1,654 +1,654 @@
-

-#include "main/context.h"

-#include "main/colormac.h"

-#include "main/fbobject.h"

-#include "main/macros.h"

-#include "main/texfetch.h"

-#include "main/teximage.h"

-#include "main/renderbuffer.h"

-#include "swrast/swrast.h"

-

-

-/*

- * Render-to-texture code for GL_EXT_framebuffer_object

- */

-

-

-/**

- * Derived from gl_renderbuffer class

- */

-struct texture_renderbuffer

-{

-   struct gl_renderbuffer Base;   /**< Base class object */

-   struct gl_texture_image *TexImage;

-   StoreTexelFunc Store;

-   FetchTexelFuncF Fetchf;

-   GLint Yoffset;                 /**< Layer for 1D array textures. */

-   GLint Zoffset;                 /**< Layer for 2D array textures, or slice

-				   * for 3D textures

-				   */

-};

-

-

-/**

- * Get row of values from the renderbuffer that wraps a texture image.

- */

-static void

-texture_get_row(struct gl_context *ctx, struct gl_renderbuffer *rb, GLuint count,

-                GLint x, GLint y, void *values)

-{

-   const struct texture_renderbuffer *trb

-      = (const struct texture_renderbuffer *) rb;

-   const GLint z = trb->Zoffset;

-   GLuint i;

-

-   ASSERT(trb->TexImage->Width == rb->Width);

-   ASSERT(trb->TexImage->Height == rb->Height);

-

-   y += trb->Yoffset;

-

-   if (rb->DataType == CHAN_TYPE) {

-      GLchan *rgbaOut = (GLchan *) values;

-      for (i = 0; i < count; i++) {

-         GLfloat rgba[4];

-         trb->Fetchf(trb->TexImage, x + i, y, z, rgba);

-         UNCLAMPED_FLOAT_TO_RGBA_CHAN(rgbaOut + 4 * i, rgba);

-      }

-   }

-   else if (rb->DataType == GL_UNSIGNED_SHORT) {

-      GLushort *zValues = (GLushort *) values;

-      for (i = 0; i < count; i++) {

-         GLfloat flt;

-         trb->Fetchf(trb->TexImage, x + i, y, z, &flt);

-         zValues[i] = (GLushort) (flt * 0xffff);

-      }

-   }

-   else if (rb->DataType == GL_UNSIGNED_INT) {

-      GLuint *zValues = (GLuint *) values;

-      /*

-      const GLdouble scale = (GLdouble) 0xffffffff;

-      */

-      for (i = 0; i < count; i++) {

-         GLfloat flt;

-         trb->Fetchf(trb->TexImage, x + i, y, z, &flt);

-#if 0

-         /* this should work, but doesn't (overflow due to low precision) */

-         zValues[i] = (GLuint) (flt * scale);

-#else

-         /* temporary hack */

-         zValues[i] = ((GLuint) (flt * 0xffffff)) << 8;

-#endif

-      }

-   }

-   else if (rb->DataType == GL_UNSIGNED_INT_24_8_EXT) {

-      GLuint *zValues = (GLuint *) values;

-      for (i = 0; i < count; i++) {

-         GLfloat flt;

-         trb->Fetchf(trb->TexImage, x + i, y, z, &flt);

-         zValues[i] = ((GLuint) (flt * 0xffffff)) << 8;

-      }

-   }

-   else if (rb->DataType == GL_UNSIGNED_INT_8_24_REV_MESA) {

-      GLuint *zValues = (GLuint *) values;

-      for (i = 0; i < count; i++) {

-         GLfloat flt;

-         trb->Fetchf(trb->TexImage, x + i, y, z, &flt);

-         zValues[i] = (GLuint) (flt * 0xffffff);

-      }

-   }

-   else {

-      _mesa_problem(ctx, "invalid rb->DataType in texture_get_row");

-   }

-}

-

-

-static void

-texture_get_values(struct gl_context *ctx, struct gl_renderbuffer *rb, GLuint count,

-                   const GLint x[], const GLint y[], void *values)

-{

-   const struct texture_renderbuffer *trb

-      = (const struct texture_renderbuffer *) rb;

-   const GLint z = trb->Zoffset;

-   GLuint i;

-

-   if (rb->DataType == CHAN_TYPE) {

-      GLchan *rgbaOut = (GLchan *) values;

-      for (i = 0; i < count; i++) {

-         GLfloat rgba[4];

-         trb->Fetchf(trb->TexImage, x[i], y[i] + trb->Yoffset,

-				    z, rgba);

-         UNCLAMPED_FLOAT_TO_RGBA_CHAN(rgbaOut + 4 * i, rgba);

-      }

-   }

-   else if (rb->DataType == GL_UNSIGNED_SHORT) {

-      GLushort *zValues = (GLushort *) values;

-      for (i = 0; i < count; i++) {

-         GLfloat flt;

-         trb->Fetchf(trb->TexImage, x[i], y[i] + trb->Yoffset,

-				    z, &flt);

-         zValues[i] = (GLushort) (flt * 0xffff);

-      }

-   }

-   else if (rb->DataType == GL_UNSIGNED_INT) {

-      GLuint *zValues = (GLuint *) values;

-      for (i = 0; i < count; i++) {

-         GLfloat flt;

-         trb->Fetchf(trb->TexImage, x[i], y[i] + trb->Yoffset,

-				    z, &flt);

-#if 0

-         zValues[i] = (GLuint) (flt * 0xffffffff);

-#else

-         zValues[i] = ((GLuint) (flt * 0xffffff)) << 8;

-#endif

-      }

-   }

-   else if (rb->DataType == GL_UNSIGNED_INT_24_8_EXT) {

-      GLuint *zValues = (GLuint *) values;

-      for (i = 0; i < count; i++) {

-         GLfloat flt;

-         trb->Fetchf(trb->TexImage, x[i], y[i] + trb->Yoffset,

-				    z, &flt);

-         zValues[i] = ((GLuint) (flt * 0xffffff)) << 8;

-      }

-   }

-   else if (rb->DataType == GL_UNSIGNED_INT_8_24_REV_MESA) {

-      GLuint *zValues = (GLuint *) values;

-      for (i = 0; i < count; i++) {

-         GLfloat flt;

-         trb->Fetchf(trb->TexImage, x[i], y[i] + trb->Yoffset,

-				    z, &flt);

-         zValues[i] = (GLuint) (flt * 0xffffff);

-      }

-   }

-   else {

-      _mesa_problem(ctx, "invalid rb->DataType in texture_get_values");

-   }

-}

-

-

-/**

- * Put row of values into a renderbuffer that wraps a texture image.

- */

-static void

-texture_put_row(struct gl_context *ctx, struct gl_renderbuffer *rb, GLuint count,

-                GLint x, GLint y, const void *values, const GLubyte *mask)

-{

-   const struct texture_renderbuffer *trb

-      = (const struct texture_renderbuffer *) rb;

-   const GLint z = trb->Zoffset;

-   GLuint i;

-

-   y += trb->Yoffset;

-

-   if (rb->DataType == CHAN_TYPE) {

-      const GLchan *rgba = (const GLchan *) values;

-      for (i = 0; i < count; i++) {

-         if (!mask || mask[i]) {

-            trb->Store(trb->TexImage, x + i, y, z, rgba);

-         }

-         rgba += 4;

-      }

-   }

-   else if (rb->DataType == GL_UNSIGNED_SHORT) {

-      const GLushort *zValues = (const GLushort *) values;

-      for (i = 0; i < count; i++) {

-         if (!mask || mask[i]) {

-            trb->Store(trb->TexImage, x + i, y, z, zValues + i);

-         }

-      }

-   }

-   else if (rb->DataType == GL_UNSIGNED_INT) {

-      const GLuint *zValues = (const GLuint *) values;

-      for (i = 0; i < count; i++) {

-         if (!mask || mask[i]) {

-            trb->Store(trb->TexImage, x + i, y, z, zValues + i);

-         }

-      }

-   }

-   else if (rb->DataType == GL_UNSIGNED_INT_24_8_EXT) {

-      const GLuint *zValues = (const GLuint *) values;

-      for (i = 0; i < count; i++) {

-         if (!mask || mask[i]) {

-            GLfloat flt = (GLfloat) ((zValues[i] >> 8) * (1.0 / 0xffffff));

-            trb->Store(trb->TexImage, x + i, y, z, &flt);

-         }

-      }

-   }

-   else if (rb->DataType == GL_UNSIGNED_INT_8_24_REV_MESA) {

-      const GLuint *zValues = (const GLuint *) values;

-      for (i = 0; i < count; i++) {

-         if (!mask || mask[i]) {

-            GLfloat flt = (GLfloat) ((zValues[i] & 0xffffff) * (1.0 / 0xffffff));

-            trb->Store(trb->TexImage, x + i, y, z, &flt);

-         }

-      }

-   }

-   else {

-      _mesa_problem(ctx, "invalid rb->DataType in texture_put_row");

-   }

-}

-

-/**

- * Put row of RGB values into a renderbuffer that wraps a texture image.

- */

-static void

-texture_put_row_rgb(struct gl_context *ctx, struct gl_renderbuffer *rb, GLuint count,

-                GLint x, GLint y, const void *values, const GLubyte *mask)

-{

-   const struct texture_renderbuffer *trb

-      = (const struct texture_renderbuffer *) rb;

-   const GLint z = trb->Zoffset;

-   GLuint i;

-

-   y += trb->Yoffset;

-

-   if (rb->DataType == CHAN_TYPE) {

-      const GLchan *rgb = (const GLchan *) values;

-      for (i = 0; i < count; i++) {

-         if (!mask || mask[i]) {

-            trb->Store(trb->TexImage, x + i, y, z, rgb);

-         }

-         rgb += 3;

-      }

-   }

-   else if (rb->DataType == GL_UNSIGNED_SHORT) {

-      const GLushort *zValues = (const GLushort *) values;

-      for (i = 0; i < count; i++) {

-         if (!mask || mask[i]) {

-            trb->Store(trb->TexImage, x + i, y, z, zValues + i);

-         }

-      }

-   }

-   else if (rb->DataType == GL_UNSIGNED_INT) {

-      const GLuint *zValues = (const GLuint *) values;

-      for (i = 0; i < count; i++) {

-         if (!mask || mask[i]) {

-            trb->Store(trb->TexImage, x + i, y, z, zValues + i);

-         }

-      }

-   }

-   else if (rb->DataType == GL_UNSIGNED_INT_24_8_EXT) {

-      const GLuint *zValues = (const GLuint *) values;

-      for (i = 0; i < count; i++) {

-         if (!mask || mask[i]) {

-            GLfloat flt = (GLfloat) ((zValues[i] >> 8) * (1.0 / 0xffffff));

-            trb->Store(trb->TexImage, x + i, y, z, &flt);

-         }

-      }

-   }

-   else if (rb->DataType == GL_UNSIGNED_INT_8_24_REV_MESA) {

-      const GLuint *zValues = (const GLuint *) values;

-      for (i = 0; i < count; i++) {

-         if (!mask || mask[i]) {

-            GLfloat flt = (GLfloat) ((zValues[i] & 0xffffff) * (1.0 / 0xffffff));

-            trb->Store(trb->TexImage, x + i, y, z, &flt);

-         }

-      }

-   }

-   else {

-      _mesa_problem(ctx, "invalid rb->DataType in texture_put_row");

-   }

-}

-

-

-static void

-texture_put_mono_row(struct gl_context *ctx, struct gl_renderbuffer *rb, GLuint count,

-                     GLint x, GLint y, const void *value, const GLubyte *mask)

-{

-   const struct texture_renderbuffer *trb

-      = (const struct texture_renderbuffer *) rb;

-   const GLint z = trb->Zoffset;

-   GLuint i;

-

-   y += trb->Yoffset;

-

-   if (rb->DataType == CHAN_TYPE) {

-      const GLchan *rgba = (const GLchan *) value;

-      for (i = 0; i < count; i++) {

-         if (!mask || mask[i]) {

-            trb->Store(trb->TexImage, x + i, y, z, rgba);

-         }

-      }

-   }

-   else if (rb->DataType == GL_UNSIGNED_SHORT) {

-      const GLushort zValue = *((const GLushort *) value);

-      for (i = 0; i < count; i++) {

-         if (!mask || mask[i]) {

-            trb->Store(trb->TexImage, x + i, y, z, &zValue);

-         }

-      }

-   }

-   else if (rb->DataType == GL_UNSIGNED_INT) {

-      const GLuint zValue = *((const GLuint *) value);

-      for (i = 0; i < count; i++) {

-         if (!mask || mask[i]) {

-            trb->Store(trb->TexImage, x + i, y, z, &zValue);

-         }

-      }

-   }

-   else if (rb->DataType == GL_UNSIGNED_INT_24_8_EXT) {

-      const GLuint zValue = *((const GLuint *) value);

-      const GLfloat flt = (GLfloat) ((zValue >> 8) * (1.0 / 0xffffff));

-      for (i = 0; i < count; i++) {

-         if (!mask || mask[i]) {

-            trb->Store(trb->TexImage, x + i, y, z, &flt);

-         }

-      }

-   }

-   else if (rb->DataType == GL_UNSIGNED_INT_8_24_REV_MESA) {

-      const GLuint zValue = *((const GLuint *) value);

-      const GLfloat flt = (GLfloat) ((zValue & 0xffffff) * (1.0 / 0xffffff));

-      for (i = 0; i < count; i++) {

-         if (!mask || mask[i]) {

-            trb->Store(trb->TexImage, x + i, y, z, &flt);

-         }

-      }

-   }

-   else {

-      _mesa_problem(ctx, "invalid rb->DataType in texture_put_mono_row");

-   }

-}

-

-

-static void

-texture_put_values(struct gl_context *ctx, struct gl_renderbuffer *rb, GLuint count,

-                   const GLint x[], const GLint y[], const void *values,

-                   const GLubyte *mask)

-{

-   const struct texture_renderbuffer *trb

-      = (const struct texture_renderbuffer *) rb;

-   const GLint z = trb->Zoffset;

-   GLuint i;

-

-   if (rb->DataType == CHAN_TYPE) {

-      const GLchan *rgba = (const GLchan *) values;

-      for (i = 0; i < count; i++) {

-         if (!mask || mask[i]) {

-            trb->Store(trb->TexImage, x[i], y[i] + trb->Yoffset, z, rgba);

-         }

-         rgba += 4;

-      }

-   }

-   else if (rb->DataType == GL_UNSIGNED_SHORT) {

-      const GLushort *zValues = (const GLushort *) values;

-      for (i = 0; i < count; i++) {

-         if (!mask || mask[i]) {

-            trb->Store(trb->TexImage, x[i], y[i] + trb->Yoffset, z, zValues + i);

-         }

-      }

-   }

-   else if (rb->DataType == GL_UNSIGNED_INT) {

-      const GLuint *zValues = (const GLuint *) values;

-      for (i = 0; i < count; i++) {

-         if (!mask || mask[i]) {

-            trb->Store(trb->TexImage, x[i], y[i] + trb->Yoffset, z, zValues + i);

-         }

-      }

-   }

-   else if (rb->DataType == GL_UNSIGNED_INT_24_8_EXT) {

-      const GLuint *zValues = (const GLuint *) values;

-      for (i = 0; i < count; i++) {

-         if (!mask || mask[i]) {

-            GLfloat flt = (GLfloat) ((zValues[i] >> 8) * (1.0 / 0xffffff));

-            trb->Store(trb->TexImage, x[i], y[i] + trb->Yoffset, z, &flt);

-         }

-      }

-   }

-   else if (rb->DataType == GL_UNSIGNED_INT_8_24_REV_MESA) {

-      const GLuint *zValues = (const GLuint *) values;

-      for (i = 0; i < count; i++) {

-         if (!mask || mask[i]) {

-            GLfloat flt = (GLfloat) ((zValues[i] & 0xffffff) * (1.0 / 0xffffff));

-            trb->Store(trb->TexImage, x[i], y[i] + trb->Yoffset, z, &flt);

-         }

-      }

-   }

-   else {

-      _mesa_problem(ctx, "invalid rb->DataType in texture_put_values");

-   }

-}

-

-

-static void

-texture_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)

-{

-   const struct texture_renderbuffer *trb

-      = (const struct texture_renderbuffer *) rb;

-   const GLint z = trb->Zoffset;

-   GLuint i;

-

-   if (rb->DataType == CHAN_TYPE) {

-      const GLchan *rgba = (const GLchan *) value;

-      for (i = 0; i < count; i++) {

-         if (!mask || mask[i]) {

-            trb->Store(trb->TexImage, x[i], y[i] + trb->Yoffset, z, rgba);

-         }

-      }

-   }

-   else if (rb->DataType == GL_UNSIGNED_INT) {

-      const GLuint zValue = *((const GLuint *) value);

-      for (i = 0; i < count; i++) {

-         if (!mask || mask[i]) {

-            trb->Store(trb->TexImage, x[i], y[i] + trb->Yoffset, z, &zValue);

-         }

-      }

-   }

-   else if (rb->DataType == GL_UNSIGNED_SHORT) {

-      const GLushort zValue = *((const GLushort *) value);

-      for (i = 0; i < count; i++) {

-         if (!mask || mask[i]) {

-            trb->Store(trb->TexImage, x[i], y[i] + trb->Yoffset, z, &zValue);

-         }

-      }

-   }

-   else if (rb->DataType == GL_UNSIGNED_INT_24_8_EXT) {

-      const GLuint zValue = *((const GLuint *) value);

-      const GLfloat flt = (GLfloat) ((zValue >> 8) * (1.0 / 0xffffff));

-      for (i = 0; i < count; i++) {

-         if (!mask || mask[i]) {

-            trb->Store(trb->TexImage, x[i], y[i] + trb->Yoffset, z, &flt);

-         }

-      }

-   }

-   else if (rb->DataType == GL_UNSIGNED_INT_8_24_REV_MESA) {

-      const GLuint zValue = *((const GLuint *) value);

-      const GLfloat flt = (GLfloat) ((zValue & 0xffffff) * (1.0 / 0xffffff));

-      for (i = 0; i < count; i++) {

-         if (!mask || mask[i]) {

-            trb->Store(trb->TexImage, x[i], y[i] + trb->Yoffset, z, &flt);

-         }

-      }

-   }

-   else {

-      _mesa_problem(ctx, "invalid rb->DataType in texture_put_mono_values");

-   }

-}

-

-

-static void

-store_nop(struct gl_texture_image *texImage,

-          GLint col, GLint row, GLint img,

-          const void *texel)

-{

-}

-

-

-static void

-delete_texture_wrapper(struct gl_renderbuffer *rb)

-{

-   ASSERT(rb->RefCount == 0);

-   free(rb);

-}

-

-

-/**

- * This function creates a renderbuffer object which wraps a texture image.

- * The new renderbuffer is plugged into the given attachment point.

- * This allows rendering into the texture as if it were a renderbuffer.

- */

-static void

-wrap_texture(struct gl_context *ctx, struct gl_renderbuffer_attachment *att)

-{

-   struct texture_renderbuffer *trb;

-   const GLuint name = 0;

-

-   ASSERT(att->Type == GL_TEXTURE);

-   ASSERT(att->Renderbuffer == NULL);

-

-   trb = CALLOC_STRUCT(texture_renderbuffer);

-   if (!trb) {

-      _mesa_error(ctx, GL_OUT_OF_MEMORY, "wrap_texture");

-      return;

-   }

-

-   /* init base gl_renderbuffer fields */

-   _mesa_init_renderbuffer(&trb->Base, name);

-   /* plug in our texture_renderbuffer-specific functions */

-   trb->Base.Delete = delete_texture_wrapper;

-   trb->Base.AllocStorage = NULL; /* illegal! */

-   trb->Base.GetRow = texture_get_row;

-   trb->Base.GetValues = texture_get_values;

-   trb->Base.PutRow = texture_put_row;

-   trb->Base.PutRowRGB = texture_put_row_rgb;

-   trb->Base.PutMonoRow = texture_put_mono_row;

-   trb->Base.PutValues = texture_put_values;

-   trb->Base.PutMonoValues = texture_put_mono_values;

-

-   /* update attachment point */

-   _mesa_reference_renderbuffer(&att->Renderbuffer, &(trb->Base));

-}

-

-/**

- * Update the renderbuffer wrapper for rendering to a texture.

- * For example, update the width, height of the RB based on the texture size,

- * update the internal format info, etc.

- */

-static void

-update_wrapper(struct gl_context *ctx, struct gl_renderbuffer_attachment *att)

-{

-   struct texture_renderbuffer *trb

-      = (struct texture_renderbuffer *) att->Renderbuffer;

-

-   (void) ctx;

-   ASSERT(trb);

-

-   trb->TexImage = _mesa_get_attachment_teximage(att);

-   ASSERT(trb->TexImage);

-

-   trb->Store = _mesa_get_texel_store_func(trb->TexImage->TexFormat);

-   if (!trb->Store) {

-      /* we'll never draw into some textures (compressed formats) */

-      trb->Store = store_nop;

-   }

-

-   trb->Fetchf = trb->TexImage->FetchTexelf;

-

-   if (att->Texture->Target == GL_TEXTURE_1D_ARRAY_EXT) {

-      trb->Yoffset = att->Zoffset;

-      trb->Zoffset = 0;

-   }

-   else {

-      trb->Yoffset = 0;

-      trb->Zoffset = att->Zoffset;

-   }

-

-   trb->Base.Width = trb->TexImage->Width;

-   trb->Base.Height = trb->TexImage->Height;

-   trb->Base.InternalFormat = trb->TexImage->InternalFormat;

-   trb->Base.Format = trb->TexImage->TexFormat;

-

-   /* XXX may need more special cases here */

-   switch (trb->TexImage->TexFormat) {

-   case MESA_FORMAT_Z24_S8:

-      trb->Base.DataType = GL_UNSIGNED_INT_24_8_EXT;

-      trb->Base._BaseFormat = GL_DEPTH_STENCIL;

-      break;

-   case MESA_FORMAT_S8_Z24:

-      trb->Base.DataType = GL_UNSIGNED_INT_8_24_REV_MESA;

-      trb->Base._BaseFormat = GL_DEPTH_STENCIL;

-      break;

-   case MESA_FORMAT_Z24_X8:

-      trb->Base.DataType = GL_UNSIGNED_INT_24_8_EXT;

-      trb->Base._BaseFormat = GL_DEPTH_COMPONENT;

-      break;

-   case MESA_FORMAT_X8_Z24:

-      trb->Base.DataType = GL_UNSIGNED_INT_8_24_REV_MESA;

-      trb->Base._BaseFormat = GL_DEPTH_COMPONENT;

-      break;

-   case MESA_FORMAT_Z16:

-      trb->Base.DataType = GL_UNSIGNED_SHORT;

-      trb->Base._BaseFormat = GL_DEPTH_COMPONENT;

-      break;

-   case MESA_FORMAT_Z32:

-      trb->Base.DataType = GL_UNSIGNED_INT;

-      trb->Base._BaseFormat = GL_DEPTH_COMPONENT;

-      break;

-   /* SRGB formats pre EXT_framebuffer_sRGB don't do sRGB translations on FBO readback */

-   case MESA_FORMAT_SRGB8:

-      trb->Fetchf = _mesa_get_texel_fetch_func(MESA_FORMAT_RGB888, _mesa_get_texture_dimensions(att->Texture->Target));

-      trb->Base.DataType = CHAN_TYPE;

-      trb->Base._BaseFormat = GL_RGBA;

-      break;

-   case MESA_FORMAT_SRGBA8:

-      trb->Fetchf = _mesa_get_texel_fetch_func(MESA_FORMAT_RGBA8888, _mesa_get_texture_dimensions(att->Texture->Target));

-      trb->Base.DataType = CHAN_TYPE;

-      trb->Base._BaseFormat = GL_RGBA;

-      break;

-   case MESA_FORMAT_SARGB8:

-      trb->Fetchf = _mesa_get_texel_fetch_func(MESA_FORMAT_ARGB8888, _mesa_get_texture_dimensions(att->Texture->Target));

-      trb->Base.DataType = CHAN_TYPE;

-      trb->Base._BaseFormat = GL_RGBA;

-      break;

-   default:

-      trb->Base.DataType = CHAN_TYPE;

-      trb->Base._BaseFormat = GL_RGBA;

-   }

-   trb->Base.Data = trb->TexImage->Data;

-}

-

-

-

-/**

- * Called when rendering to a texture image begins, or when changing

- * the dest mipmap level, cube face, etc.

- * This is a fallback routine for software render-to-texture.

- *

- * Called via the glRenderbufferTexture1D/2D/3D() functions

- * and elsewhere (such as glTexImage2D).

- *

- * The image we're rendering into is

- * att->Texture->Image[att->CubeMapFace][att->TextureLevel];

- * It'll never be NULL.

- *

- * \param fb  the framebuffer object the texture is being bound to

- * \param att  the fb attachment point of the texture

- *

- * \sa _mesa_framebuffer_renderbuffer

- */

-void

-_swrast_render_texture(struct gl_context *ctx,

-                       struct gl_framebuffer *fb,

-                       struct gl_renderbuffer_attachment *att)

-{

-   (void) fb;

-

-   if (!att->Renderbuffer) {

-      wrap_texture(ctx, att);

-   }

-   update_wrapper(ctx, att);

-}

-

-

-void

-_swrast_finish_render_texture(struct gl_context *ctx,

-                              struct gl_renderbuffer_attachment *att)

-{

-   /* do nothing */

-   /* The renderbuffer texture wrapper will get deleted by the

-    * normal mechanism for deleting renderbuffers.

-    */

-   (void) ctx;

-   (void) att;

-}

+
+#include "main/context.h"
+#include "main/colormac.h"
+#include "main/fbobject.h"
+#include "main/macros.h"
+#include "main/texfetch.h"
+#include "main/teximage.h"
+#include "main/renderbuffer.h"
+#include "swrast/swrast.h"
+
+
+/*
+ * Render-to-texture code for GL_EXT_framebuffer_object
+ */
+
+
+/**
+ * Derived from gl_renderbuffer class
+ */
+struct texture_renderbuffer
+{
+   struct gl_renderbuffer Base;   /**< Base class object */
+   struct gl_texture_image *TexImage;
+   StoreTexelFunc Store;
+   FetchTexelFuncF Fetchf;
+   GLint Yoffset;                 /**< Layer for 1D array textures. */
+   GLint Zoffset;                 /**< Layer for 2D array textures, or slice
+				   * for 3D textures
+				   */
+};
+
+
+/**
+ * Get row of values from the renderbuffer that wraps a texture image.
+ */
+static void
+texture_get_row(struct gl_context *ctx, struct gl_renderbuffer *rb, GLuint count,
+                GLint x, GLint y, void *values)
+{
+   const struct texture_renderbuffer *trb
+      = (const struct texture_renderbuffer *) rb;
+   const GLint z = trb->Zoffset;
+   GLuint i;
+
+   ASSERT(trb->TexImage->Width == rb->Width);
+   ASSERT(trb->TexImage->Height == rb->Height);
+
+   y += trb->Yoffset;
+
+   if (rb->DataType == CHAN_TYPE) {
+      GLchan *rgbaOut = (GLchan *) values;
+      for (i = 0; i < count; i++) {
+         GLfloat rgba[4];
+         trb->Fetchf(trb->TexImage, x + i, y, z, rgba);
+         UNCLAMPED_FLOAT_TO_RGBA_CHAN(rgbaOut + 4 * i, rgba);
+      }
+   }
+   else if (rb->DataType == GL_UNSIGNED_SHORT) {
+      GLushort *zValues = (GLushort *) values;
+      for (i = 0; i < count; i++) {
+         GLfloat flt;
+         trb->Fetchf(trb->TexImage, x + i, y, z, &flt);
+         zValues[i] = (GLushort) (flt * 0xffff);
+      }
+   }
+   else if (rb->DataType == GL_UNSIGNED_INT) {
+      GLuint *zValues = (GLuint *) values;
+      /*
+      const GLdouble scale = (GLdouble) 0xffffffff;
+      */
+      for (i = 0; i < count; i++) {
+         GLfloat flt;
+         trb->Fetchf(trb->TexImage, x + i, y, z, &flt);
+#if 0
+         /* this should work, but doesn't (overflow due to low precision) */
+         zValues[i] = (GLuint) (flt * scale);
+#else
+         /* temporary hack */
+         zValues[i] = ((GLuint) (flt * 0xffffff)) << 8;
+#endif
+      }
+   }
+   else if (rb->DataType == GL_UNSIGNED_INT_24_8_EXT) {
+      GLuint *zValues = (GLuint *) values;
+      for (i = 0; i < count; i++) {
+         GLfloat flt;
+         trb->Fetchf(trb->TexImage, x + i, y, z, &flt);
+         zValues[i] = ((GLuint) (flt * 0xffffff)) << 8;
+      }
+   }
+   else if (rb->DataType == GL_UNSIGNED_INT_8_24_REV_MESA) {
+      GLuint *zValues = (GLuint *) values;
+      for (i = 0; i < count; i++) {
+         GLfloat flt;
+         trb->Fetchf(trb->TexImage, x + i, y, z, &flt);
+         zValues[i] = (GLuint) (flt * 0xffffff);
+      }
+   }
+   else {
+      _mesa_problem(ctx, "invalid rb->DataType in texture_get_row");
+   }
+}
+
+
+static void
+texture_get_values(struct gl_context *ctx, struct gl_renderbuffer *rb, GLuint count,
+                   const GLint x[], const GLint y[], void *values)
+{
+   const struct texture_renderbuffer *trb
+      = (const struct texture_renderbuffer *) rb;
+   const GLint z = trb->Zoffset;
+   GLuint i;
+
+   if (rb->DataType == CHAN_TYPE) {
+      GLchan *rgbaOut = (GLchan *) values;
+      for (i = 0; i < count; i++) {
+         GLfloat rgba[4];
+         trb->Fetchf(trb->TexImage, x[i], y[i] + trb->Yoffset,
+				    z, rgba);
+         UNCLAMPED_FLOAT_TO_RGBA_CHAN(rgbaOut + 4 * i, rgba);
+      }
+   }
+   else if (rb->DataType == GL_UNSIGNED_SHORT) {
+      GLushort *zValues = (GLushort *) values;
+      for (i = 0; i < count; i++) {
+         GLfloat flt;
+         trb->Fetchf(trb->TexImage, x[i], y[i] + trb->Yoffset,
+				    z, &flt);
+         zValues[i] = (GLushort) (flt * 0xffff);
+      }
+   }
+   else if (rb->DataType == GL_UNSIGNED_INT) {
+      GLuint *zValues = (GLuint *) values;
+      for (i = 0; i < count; i++) {
+         GLfloat flt;
+         trb->Fetchf(trb->TexImage, x[i], y[i] + trb->Yoffset,
+				    z, &flt);
+#if 0
+         zValues[i] = (GLuint) (flt * 0xffffffff);
+#else
+         zValues[i] = ((GLuint) (flt * 0xffffff)) << 8;
+#endif
+      }
+   }
+   else if (rb->DataType == GL_UNSIGNED_INT_24_8_EXT) {
+      GLuint *zValues = (GLuint *) values;
+      for (i = 0; i < count; i++) {
+         GLfloat flt;
+         trb->Fetchf(trb->TexImage, x[i], y[i] + trb->Yoffset,
+				    z, &flt);
+         zValues[i] = ((GLuint) (flt * 0xffffff)) << 8;
+      }
+   }
+   else if (rb->DataType == GL_UNSIGNED_INT_8_24_REV_MESA) {
+      GLuint *zValues = (GLuint *) values;
+      for (i = 0; i < count; i++) {
+         GLfloat flt;
+         trb->Fetchf(trb->TexImage, x[i], y[i] + trb->Yoffset,
+				    z, &flt);
+         zValues[i] = (GLuint) (flt * 0xffffff);
+      }
+   }
+   else {
+      _mesa_problem(ctx, "invalid rb->DataType in texture_get_values");
+   }
+}
+
+
+/**
+ * Put row of values into a renderbuffer that wraps a texture image.
+ */
+static void
+texture_put_row(struct gl_context *ctx, struct gl_renderbuffer *rb, GLuint count,
+                GLint x, GLint y, const void *values, const GLubyte *mask)
+{
+   const struct texture_renderbuffer *trb
+      = (const struct texture_renderbuffer *) rb;
+   const GLint z = trb->Zoffset;
+   GLuint i;
+
+   y += trb->Yoffset;
+
+   if (rb->DataType == CHAN_TYPE) {
+      const GLchan *rgba = (const GLchan *) values;
+      for (i = 0; i < count; i++) {
+         if (!mask || mask[i]) {
+            trb->Store(trb->TexImage, x + i, y, z, rgba);
+         }
+         rgba += 4;
+      }
+   }
+   else if (rb->DataType == GL_UNSIGNED_SHORT) {
+      const GLushort *zValues = (const GLushort *) values;
+      for (i = 0; i < count; i++) {
+         if (!mask || mask[i]) {
+            trb->Store(trb->TexImage, x + i, y, z, zValues + i);
+         }
+      }
+   }
+   else if (rb->DataType == GL_UNSIGNED_INT) {
+      const GLuint *zValues = (const GLuint *) values;
+      for (i = 0; i < count; i++) {
+         if (!mask || mask[i]) {
+            trb->Store(trb->TexImage, x + i, y, z, zValues + i);
+         }
+      }
+   }
+   else if (rb->DataType == GL_UNSIGNED_INT_24_8_EXT) {
+      const GLuint *zValues = (const GLuint *) values;
+      for (i = 0; i < count; i++) {
+         if (!mask || mask[i]) {
+            GLfloat flt = (GLfloat) ((zValues[i] >> 8) * (1.0 / 0xffffff));
+            trb->Store(trb->TexImage, x + i, y, z, &flt);
+         }
+      }
+   }
+   else if (rb->DataType == GL_UNSIGNED_INT_8_24_REV_MESA) {
+      const GLuint *zValues = (const GLuint *) values;
+      for (i = 0; i < count; i++) {
+         if (!mask || mask[i]) {
+            GLfloat flt = (GLfloat) ((zValues[i] & 0xffffff) * (1.0 / 0xffffff));
+            trb->Store(trb->TexImage, x + i, y, z, &flt);
+         }
+      }
+   }
+   else {
+      _mesa_problem(ctx, "invalid rb->DataType in texture_put_row");
+   }
+}
+
+/**
+ * Put row of RGB values into a renderbuffer that wraps a texture image.
+ */
+static void
+texture_put_row_rgb(struct gl_context *ctx, struct gl_renderbuffer *rb, GLuint count,
+                GLint x, GLint y, const void *values, const GLubyte *mask)
+{
+   const struct texture_renderbuffer *trb
+      = (const struct texture_renderbuffer *) rb;
+   const GLint z = trb->Zoffset;
+   GLuint i;
+
+   y += trb->Yoffset;
+
+   if (rb->DataType == CHAN_TYPE) {
+      const GLchan *rgb = (const GLchan *) values;
+      for (i = 0; i < count; i++) {
+         if (!mask || mask[i]) {
+            trb->Store(trb->TexImage, x + i, y, z, rgb);
+         }
+         rgb += 3;
+      }
+   }
+   else if (rb->DataType == GL_UNSIGNED_SHORT) {
+      const GLushort *zValues = (const GLushort *) values;
+      for (i = 0; i < count; i++) {
+         if (!mask || mask[i]) {
+            trb->Store(trb->TexImage, x + i, y, z, zValues + i);
+         }
+      }
+   }
+   else if (rb->DataType == GL_UNSIGNED_INT) {
+      const GLuint *zValues = (const GLuint *) values;
+      for (i = 0; i < count; i++) {
+         if (!mask || mask[i]) {
+            trb->Store(trb->TexImage, x + i, y, z, zValues + i);
+         }
+      }
+   }
+   else if (rb->DataType == GL_UNSIGNED_INT_24_8_EXT) {
+      const GLuint *zValues = (const GLuint *) values;
+      for (i = 0; i < count; i++) {
+         if (!mask || mask[i]) {
+            GLfloat flt = (GLfloat) ((zValues[i] >> 8) * (1.0 / 0xffffff));
+            trb->Store(trb->TexImage, x + i, y, z, &flt);
+         }
+      }
+   }
+   else if (rb->DataType == GL_UNSIGNED_INT_8_24_REV_MESA) {
+      const GLuint *zValues = (const GLuint *) values;
+      for (i = 0; i < count; i++) {
+         if (!mask || mask[i]) {
+            GLfloat flt = (GLfloat) ((zValues[i] & 0xffffff) * (1.0 / 0xffffff));
+            trb->Store(trb->TexImage, x + i, y, z, &flt);
+         }
+      }
+   }
+   else {
+      _mesa_problem(ctx, "invalid rb->DataType in texture_put_row");
+   }
+}
+
+
+static void
+texture_put_mono_row(struct gl_context *ctx, struct gl_renderbuffer *rb, GLuint count,
+                     GLint x, GLint y, const void *value, const GLubyte *mask)
+{
+   const struct texture_renderbuffer *trb
+      = (const struct texture_renderbuffer *) rb;
+   const GLint z = trb->Zoffset;
+   GLuint i;
+
+   y += trb->Yoffset;
+
+   if (rb->DataType == CHAN_TYPE) {
+      const GLchan *rgba = (const GLchan *) value;
+      for (i = 0; i < count; i++) {
+         if (!mask || mask[i]) {
+            trb->Store(trb->TexImage, x + i, y, z, rgba);
+         }
+      }
+   }
+   else if (rb->DataType == GL_UNSIGNED_SHORT) {
+      const GLushort zValue = *((const GLushort *) value);
+      for (i = 0; i < count; i++) {
+         if (!mask || mask[i]) {
+            trb->Store(trb->TexImage, x + i, y, z, &zValue);
+         }
+      }
+   }
+   else if (rb->DataType == GL_UNSIGNED_INT) {
+      const GLuint zValue = *((const GLuint *) value);
+      for (i = 0; i < count; i++) {
+         if (!mask || mask[i]) {
+            trb->Store(trb->TexImage, x + i, y, z, &zValue);
+         }
+      }
+   }
+   else if (rb->DataType == GL_UNSIGNED_INT_24_8_EXT) {
+      const GLuint zValue = *((const GLuint *) value);
+      const GLfloat flt = (GLfloat) ((zValue >> 8) * (1.0 / 0xffffff));
+      for (i = 0; i < count; i++) {
+         if (!mask || mask[i]) {
+            trb->Store(trb->TexImage, x + i, y, z, &flt);
+         }
+      }
+   }
+   else if (rb->DataType == GL_UNSIGNED_INT_8_24_REV_MESA) {
+      const GLuint zValue = *((const GLuint *) value);
+      const GLfloat flt = (GLfloat) ((zValue & 0xffffff) * (1.0 / 0xffffff));
+      for (i = 0; i < count; i++) {
+         if (!mask || mask[i]) {
+            trb->Store(trb->TexImage, x + i, y, z, &flt);
+         }
+      }
+   }
+   else {
+      _mesa_problem(ctx, "invalid rb->DataType in texture_put_mono_row");
+   }
+}
+
+
+static void
+texture_put_values(struct gl_context *ctx, struct gl_renderbuffer *rb, GLuint count,
+                   const GLint x[], const GLint y[], const void *values,
+                   const GLubyte *mask)
+{
+   const struct texture_renderbuffer *trb
+      = (const struct texture_renderbuffer *) rb;
+   const GLint z = trb->Zoffset;
+   GLuint i;
+
+   if (rb->DataType == CHAN_TYPE) {
+      const GLchan *rgba = (const GLchan *) values;
+      for (i = 0; i < count; i++) {
+         if (!mask || mask[i]) {
+            trb->Store(trb->TexImage, x[i], y[i] + trb->Yoffset, z, rgba);
+         }
+         rgba += 4;
+      }
+   }
+   else if (rb->DataType == GL_UNSIGNED_SHORT) {
+      const GLushort *zValues = (const GLushort *) values;
+      for (i = 0; i < count; i++) {
+         if (!mask || mask[i]) {
+            trb->Store(trb->TexImage, x[i], y[i] + trb->Yoffset, z, zValues + i);
+         }
+      }
+   }
+   else if (rb->DataType == GL_UNSIGNED_INT) {
+      const GLuint *zValues = (const GLuint *) values;
+      for (i = 0; i < count; i++) {
+         if (!mask || mask[i]) {
+            trb->Store(trb->TexImage, x[i], y[i] + trb->Yoffset, z, zValues + i);
+         }
+      }
+   }
+   else if (rb->DataType == GL_UNSIGNED_INT_24_8_EXT) {
+      const GLuint *zValues = (const GLuint *) values;
+      for (i = 0; i < count; i++) {
+         if (!mask || mask[i]) {
+            GLfloat flt = (GLfloat) ((zValues[i] >> 8) * (1.0 / 0xffffff));
+            trb->Store(trb->TexImage, x[i], y[i] + trb->Yoffset, z, &flt);
+         }
+      }
+   }
+   else if (rb->DataType == GL_UNSIGNED_INT_8_24_REV_MESA) {
+      const GLuint *zValues = (const GLuint *) values;
+      for (i = 0; i < count; i++) {
+         if (!mask || mask[i]) {
+            GLfloat flt = (GLfloat) ((zValues[i] & 0xffffff) * (1.0 / 0xffffff));
+            trb->Store(trb->TexImage, x[i], y[i] + trb->Yoffset, z, &flt);
+         }
+      }
+   }
+   else {
+      _mesa_problem(ctx, "invalid rb->DataType in texture_put_values");
+   }
+}
+
+
+static void
+texture_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)
+{
+   const struct texture_renderbuffer *trb
+      = (const struct texture_renderbuffer *) rb;
+   const GLint z = trb->Zoffset;
+   GLuint i;
+
+   if (rb->DataType == CHAN_TYPE) {
+      const GLchan *rgba = (const GLchan *) value;
+      for (i = 0; i < count; i++) {
+         if (!mask || mask[i]) {
+            trb->Store(trb->TexImage, x[i], y[i] + trb->Yoffset, z, rgba);
+         }
+      }
+   }
+   else if (rb->DataType == GL_UNSIGNED_INT) {
+      const GLuint zValue = *((const GLuint *) value);
+      for (i = 0; i < count; i++) {
+         if (!mask || mask[i]) {
+            trb->Store(trb->TexImage, x[i], y[i] + trb->Yoffset, z, &zValue);
+         }
+      }
+   }
+   else if (rb->DataType == GL_UNSIGNED_SHORT) {
+      const GLushort zValue = *((const GLushort *) value);
+      for (i = 0; i < count; i++) {
+         if (!mask || mask[i]) {
+            trb->Store(trb->TexImage, x[i], y[i] + trb->Yoffset, z, &zValue);
+         }
+      }
+   }
+   else if (rb->DataType == GL_UNSIGNED_INT_24_8_EXT) {
+      const GLuint zValue = *((const GLuint *) value);
+      const GLfloat flt = (GLfloat) ((zValue >> 8) * (1.0 / 0xffffff));
+      for (i = 0; i < count; i++) {
+         if (!mask || mask[i]) {
+            trb->Store(trb->TexImage, x[i], y[i] + trb->Yoffset, z, &flt);
+         }
+      }
+   }
+   else if (rb->DataType == GL_UNSIGNED_INT_8_24_REV_MESA) {
+      const GLuint zValue = *((const GLuint *) value);
+      const GLfloat flt = (GLfloat) ((zValue & 0xffffff) * (1.0 / 0xffffff));
+      for (i = 0; i < count; i++) {
+         if (!mask || mask[i]) {
+            trb->Store(trb->TexImage, x[i], y[i] + trb->Yoffset, z, &flt);
+         }
+      }
+   }
+   else {
+      _mesa_problem(ctx, "invalid rb->DataType in texture_put_mono_values");
+   }
+}
+
+
+static void
+store_nop(struct gl_texture_image *texImage,
+          GLint col, GLint row, GLint img,
+          const void *texel)
+{
+}
+
+
+static void
+delete_texture_wrapper(struct gl_renderbuffer *rb)
+{
+   ASSERT(rb->RefCount == 0);
+   free(rb);
+}
+
+
+/**
+ * This function creates a renderbuffer object which wraps a texture image.
+ * The new renderbuffer is plugged into the given attachment point.
+ * This allows rendering into the texture as if it were a renderbuffer.
+ */
+static void
+wrap_texture(struct gl_context *ctx, struct gl_renderbuffer_attachment *att)
+{
+   struct texture_renderbuffer *trb;
+   const GLuint name = 0;
+
+   ASSERT(att->Type == GL_TEXTURE);
+   ASSERT(att->Renderbuffer == NULL);
+
+   trb = CALLOC_STRUCT(texture_renderbuffer);
+   if (!trb) {
+      _mesa_error(ctx, GL_OUT_OF_MEMORY, "wrap_texture");
+      return;
+   }
+
+   /* init base gl_renderbuffer fields */
+   _mesa_init_renderbuffer(&trb->Base, name);
+   /* plug in our texture_renderbuffer-specific functions */
+   trb->Base.Delete = delete_texture_wrapper;
+   trb->Base.AllocStorage = NULL; /* illegal! */
+   trb->Base.GetRow = texture_get_row;
+   trb->Base.GetValues = texture_get_values;
+   trb->Base.PutRow = texture_put_row;
+   trb->Base.PutRowRGB = texture_put_row_rgb;
+   trb->Base.PutMonoRow = texture_put_mono_row;
+   trb->Base.PutValues = texture_put_values;
+   trb->Base.PutMonoValues = texture_put_mono_values;
+
+   /* update attachment point */
+   _mesa_reference_renderbuffer(&att->Renderbuffer, &(trb->Base));
+}
+
+/**
+ * Update the renderbuffer wrapper for rendering to a texture.
+ * For example, update the width, height of the RB based on the texture size,
+ * update the internal format info, etc.
+ */
+static void
+update_wrapper(struct gl_context *ctx, struct gl_renderbuffer_attachment *att)
+{
+   struct texture_renderbuffer *trb
+      = (struct texture_renderbuffer *) att->Renderbuffer;
+
+   (void) ctx;
+   ASSERT(trb);
+
+   trb->TexImage = _mesa_get_attachment_teximage(att);
+   ASSERT(trb->TexImage);
+
+   trb->Store = _mesa_get_texel_store_func(trb->TexImage->TexFormat);
+   if (!trb->Store) {
+      /* we'll never draw into some textures (compressed formats) */
+      trb->Store = store_nop;
+   }
+
+   trb->Fetchf = trb->TexImage->FetchTexelf;
+
+   if (att->Texture->Target == GL_TEXTURE_1D_ARRAY_EXT) {
+      trb->Yoffset = att->Zoffset;
+      trb->Zoffset = 0;
+   }
+   else {
+      trb->Yoffset = 0;
+      trb->Zoffset = att->Zoffset;
+   }
+
+   trb->Base.Width = trb->TexImage->Width;
+   trb->Base.Height = trb->TexImage->Height;
+   trb->Base.InternalFormat = trb->TexImage->InternalFormat;
+   trb->Base.Format = trb->TexImage->TexFormat;
+
+   /* XXX may need more special cases here */
+   switch (trb->TexImage->TexFormat) {
+   case MESA_FORMAT_Z24_S8:
+      trb->Base.DataType = GL_UNSIGNED_INT_24_8_EXT;
+      trb->Base._BaseFormat = GL_DEPTH_STENCIL;
+      break;
+   case MESA_FORMAT_S8_Z24:
+      trb->Base.DataType = GL_UNSIGNED_INT_8_24_REV_MESA;
+      trb->Base._BaseFormat = GL_DEPTH_STENCIL;
+      break;
+   case MESA_FORMAT_Z24_X8:
+      trb->Base.DataType = GL_UNSIGNED_INT_24_8_EXT;
+      trb->Base._BaseFormat = GL_DEPTH_COMPONENT;
+      break;
+   case MESA_FORMAT_X8_Z24:
+      trb->Base.DataType = GL_UNSIGNED_INT_8_24_REV_MESA;
+      trb->Base._BaseFormat = GL_DEPTH_COMPONENT;
+      break;
+   case MESA_FORMAT_Z16:
+      trb->Base.DataType = GL_UNSIGNED_SHORT;
+      trb->Base._BaseFormat = GL_DEPTH_COMPONENT;
+      break;
+   case MESA_FORMAT_Z32:
+      trb->Base.DataType = GL_UNSIGNED_INT;
+      trb->Base._BaseFormat = GL_DEPTH_COMPONENT;
+      break;
+   /* SRGB formats pre EXT_framebuffer_sRGB don't do sRGB translations on FBO readback */
+   case MESA_FORMAT_SRGB8:
+      trb->Fetchf = _mesa_get_texel_fetch_func(MESA_FORMAT_RGB888, _mesa_get_texture_dimensions(att->Texture->Target));
+      trb->Base.DataType = CHAN_TYPE;
+      trb->Base._BaseFormat = GL_RGBA;
+      break;
+   case MESA_FORMAT_SRGBA8:
+      trb->Fetchf = _mesa_get_texel_fetch_func(MESA_FORMAT_RGBA8888, _mesa_get_texture_dimensions(att->Texture->Target));
+      trb->Base.DataType = CHAN_TYPE;
+      trb->Base._BaseFormat = GL_RGBA;
+      break;
+   case MESA_FORMAT_SARGB8:
+      trb->Fetchf = _mesa_get_texel_fetch_func(MESA_FORMAT_ARGB8888, _mesa_get_texture_dimensions(att->Texture->Target));
+      trb->Base.DataType = CHAN_TYPE;
+      trb->Base._BaseFormat = GL_RGBA;
+      break;
+   default:
+      trb->Base.DataType = CHAN_TYPE;
+      trb->Base._BaseFormat = GL_RGBA;
+   }
+   trb->Base.Data = trb->TexImage->Data;
+}
+
+
+
+/**
+ * Called when rendering to a texture image begins, or when changing
+ * the dest mipmap level, cube face, etc.
+ * This is a fallback routine for software render-to-texture.
+ *
+ * Called via the glRenderbufferTexture1D/2D/3D() functions
+ * and elsewhere (such as glTexImage2D).
+ *
+ * The image we're rendering into is
+ * att->Texture->Image[att->CubeMapFace][att->TextureLevel];
+ * It'll never be NULL.
+ *
+ * \param fb  the framebuffer object the texture is being bound to
+ * \param att  the fb attachment point of the texture
+ *
+ * \sa _mesa_framebuffer_renderbuffer
+ */
+void
+_swrast_render_texture(struct gl_context *ctx,
+                       struct gl_framebuffer *fb,
+                       struct gl_renderbuffer_attachment *att)
+{
+   (void) fb;
+
+   if (!att->Renderbuffer) {
+      wrap_texture(ctx, att);
+   }
+   update_wrapper(ctx, att);
+}
+
+
+void
+_swrast_finish_render_texture(struct gl_context *ctx,
+                              struct gl_renderbuffer_attachment *att)
+{
+   /* do nothing */
+   /* The renderbuffer texture wrapper will get deleted by the
+    * normal mechanism for deleting renderbuffers.
+    */
+   (void) ctx;
+   (void) att;
+}
diff --git a/mesalib/src/mesa/swrast/s_triangle.c b/mesalib/src/mesa/swrast/s_triangle.c
index 0f21a33f9..8a9671aa0 100644
--- a/mesalib/src/mesa/swrast/s_triangle.c
+++ b/mesalib/src/mesa/swrast/s_triangle.c
@@ -1,1143 +1,1143 @@
-/*

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

-#include "main/state.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->Sampler.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->Sampler.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 ||

-          _mesa_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->Sampler.MinFilter : GL_NONE;

-         magFilter = texObj2D ? texObj2D->Sampler.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->Sampler.WrapS == GL_REPEAT

-             && texObj2D->Sampler.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(!_mesa_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/mtypes.h"
+#include "main/state.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->Sampler.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->Sampler.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 ||
+          _mesa_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->Sampler.MinFilter : GL_NONE;
+         magFilter = texObj2D ? texObj2D->Sampler.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->Sampler.WrapS == GL_REPEAT
+             && texObj2D->Sampler.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(!_mesa_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);
+   }
+}