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 0ec907d79..2889d908b 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 18f1c1866..af65874fd 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 df213357f..e65f6aa9d 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 8d7458c2d..1673cece1 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 63bfa79b5..5109eb0d3 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 ea59de160..5df071481 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 b6bfeaed4..ab411a2f0 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 6eec2fc78..49da247e9 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 52d03c92a..b7239a71d 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 8a9671aa0..0f21a33f9 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);

+   }

+}